Skip to content

Free Motion Capture for Everyone 💀✨

TypeScript

start bringing in skellycam-ui update

jonmatthisc205f52390e2
diff --git a/MULTI_SOCKET_REFACTOR.md b/MULTI_SOCKET_REFACTOR.md
new file mode 100644
index 00000000..f8d19bb7
--- /dev/null
+++ b/MULTI_SOCKET_REFACTOR.md
@@ -0,0 +1,137 @@
+# Multi-Socket WebSocket Refactor
+
+## Overview
+
+Splitting the single WebSocket connection into three specialized sockets for better separation of concerns, independent backpressure handling, and cleaner architecture.
+
+---
+
+## ✅ Completed
+
+### Backend (`freemocap/api/websocket/`)
+
+| File | Description | Status |
+|------|-------------|--------|
+| `message_types.py` | `StrEnum` for FrameMessageType, LogsMessageType, StateMessageType | ✅ Complete |
+| `base_handler.py` | Pydantic `BaseModel` abstract class with connection lifecycle, message routing, heartbeat | ✅ Complete |
+| `frame_handler.py` | Frame streaming with backpressure, overlay JSON, tracked points | ✅ Complete |
+| `logs_handler.py` | Log record streaming from queue | ✅ Complete |
+| `state_handler.py` | Settings sync, framerate updates, patch handling | ✅ Complete |
+| `routes.py` | FastAPI router with `/ws/frame`, `/ws/logs`, `/ws/state` endpoints | ✅ Complete |
+| `__init__.py` | Module exports | ✅ Complete |
+| `app.py` | Router registration updated | ✅ Complete |
+
+### Frontend (`freemocap-ui/src/services/server/`)
+
+| File | Description | Status |
+|------|-------------|--------|
+| `message-types.ts` | TypeScript enums for message types, ConnectionStatus | ✅ Complete |
+| `BaseWebSocketConnection.ts` | Reusable WebSocket class with reconnection, heartbeat, message routing | ✅ Complete |
+| `ServerContextProvider.tsx` | Consolidated provider managing 3 sockets internally | ✅ Complete |
+| `index.ts` | Module exports | ✅ Complete |
+
+### Integration Updates
+
+| File | Description | Status |
+|------|-------------|--------|
+| `freemocap-ui/src/hooks/server-urls.ts` | Added new WebSocket URL methods with backward compat | ✅ Complete |
+| `freemococap/tests/conftest.py` | Updated test fixtures for `/ws/state` | ✅ Complete |
+| `freemocap/tests/test_e2e_websocket_settings_sync.py` | Updated all E2E tests for `/ws/state` | ✅ Complete |
+| `freemocap/api/http/app/debug.py` | Updated debug page to use `/ws/state` | ✅ Complete |
+
+---
+
+## 🔜 Remaining
+
+### Backend
+
+1. **Test the handlers** - Run pytest to verify the new handlers work correctly
+ ```bash
+ cd freemocap && pytest freemocap/tests/test_e2e_websocket_settings_sync.py -v
+ ```
+
+2. **Decision: Keep or deprecate old `websocket_server.py`**
+ - OLD: `/websocket/connect` (single socket, 300+ lines)
+ - NEW: `/ws/frame`, `/ws/logs`, `/ws/state` (3 sockets, ~100 lines each)
+ - Recommendation: Keep old as fallback during transition, remove in future release
+
+### Frontend
+
+3. **Test the new UI components** - Verify ServerContextProvider works with real backend
+4. **Run type checking** - `cd freemocap-ui && npm run typecheck`
+5. **Test backpressure** - Verify frame acknowledgment under load
+
+### Integration
+
+6. **Full E2E smoke test** - Start server, connect UI, verify all 3 sockets
+7. **Performance test** - High frame rate, many cameras, verify no blocking
+
+---
+
+## Architecture
+
+```
+Backend Frontend
+┌─────────────────┐ ┌─────────────────┐
+│ /ws/frame │──────────────│ Frame Socket │
+│ - binary frames │ │ - CanvasManager │
+│ - overlays │ │ - OverlayMgr │
+│ - tracked pts │ │ - Subscribers │
+└─────────────────┘ └─────────────────┘
+
+┌─────────────────┐ ┌─────────────────┐
+│ /ws/logs │──────────────│ Logs Socket │
+│ - log records │ │ - Redux dispatch│
+└─────────────────┘ └─────────────────┘
+
+┌─────────────────┐ ┌─────────────────┐
+│ /ws/state │──────────────│ State Socket │
+│ - settings │ │ - Redux dispatch│
+│ - framerate │ │ - Patch sending │
+└─────────────────┘ └─────────────────┘
+ ┌─────────────────┐
+ │ ServerContext │
+ │ - Unified API │
+ │ - Health status │
+ └─────────────────┘
+```
+
+---
+
+## Key Benefits
+
+- **Independent backpressure** - Frame throttling doesn't block logs/state
+- **Separate connection states** - Granular status display
+- **Smaller modules** - ~100-200 lines each vs 361-line god object
+- **Type-safe routing** - Enums prevent string typos
+- **Easier testing** - Test each socket independently
+
+---
+
+## Migration Notes
+
+### Endpoint Changes
+
+| Old | New |
+|-----|-----|
+| `/websocket/connect` | `/ws/frame`, `/ws/logs`, `/ws/state` |
+
+### Frontend URL Methods
+
+| Old (deprecated) | New |
+|------------------|-----|
+| `getWebSocketUrl()` | `getFrameSocketUrl()` |
+| | `getLogsSocketUrl()` |
+| | `getStateSocketUrl()` |
+| `endpoints.websocket` | `endpoints.websocketFrame` |
+| | `endpoints.websocketLogs` |
+| | `endpoints.websocketState` |
+
+### Message Types (unchanged)
+
+- `frameAcknowledgment` → Frame socket
+- `charuco_overlay`, `mediapipe_overlay` → Frame socket
+- `tracked_points3d`, `rigid_body_poses` → Frame socket
+- `log_record` → Logs socket
+- `settings/state`, `settings/patch`, `settings/request` → State socket
+- `framerate_update` → State socket
diff --git a/freemocap-ui-old/.gitignore b/freemocap-ui-old/.gitignore
new file mode 100644
index 00000000..44980415
--- /dev/null
+++ b/freemocap-ui-old/.gitignore
@@ -0,0 +1,37 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+dist-electron
+release
+*.local
+
+# Editor directories and files
+.vscode/.debug.env
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?
+
+#lockfile
+package-lock.json
+pnpm-lock.yaml
+yarn.lock
+/test-results/
+/playwright-report/
+/playwright/.cache/
+
+*.exe
+pyapp-*
+*.zip
\ No newline at end of file
diff --git a/freemocap-ui-old/.npmrc b/freemocap-ui-old/.npmrc
new file mode 100644
index 00000000..45c8cd74
--- /dev/null
+++ b/freemocap-ui-old/.npmrc
@@ -0,0 +1,6 @@
+# For electron-builder
+# https://github.com/electron-userland/electron-builder/issues/6289#issuecomment-1042620422
+shamefully-hoist=true
+
+# For China 🇨🇳 developers
+# electron_mirror=https://npmmirror.com/mirrors/electron/
diff --git a/freemocap-ui-old/README.md b/freemocap-ui-old/README.md
new file mode 100644
index 00000000..8386c138
--- /dev/null
+++ b/freemocap-ui-old/README.md
@@ -0,0 +1,93 @@
+# electron-vite-react
+
+[![awesome-vite](https://awesome.re/mentioned-badge.svg)](https://github.com/vitejs/awesome-vite)
+![GitHub stars](https://img.shields.io/github/stars/caoxiemeihao/vite-react-electron?color=fa6470)
+![GitHub issues](https://img.shields.io/github/issues/caoxiemeihao/vite-react-electron?color=d8b22d)
+![GitHub license](https://img.shields.io/github/license/caoxiemeihao/vite-react-electron)
+[![Required Node.JS >= 14.18.0 || >=16.0.0](https://img.shields.io/static/v1?label=node&message=14.18.0%20||%20%3E=16.0.0&logo=node.js&color=3f893e)](https://nodejs.org/about/releases)
+
+English | [简体中文](README.zh-CN.md)
+
+## 👀 Overview
+
+📦 Ready out of the box
+🎯 Based on the
+official [template-react-ts](https://github.com/vitejs/vite/tree/main/packages/create-vite/template-react-ts), project
+structure will be familiar to you
+🌱 Easily extendable and customizable
+💪 Supports Node.js API in the renderer process
+🔩 Supports C/C++ native addons
+🐞 Debugger configuration included
+🖥 Easy to implement multiple windows
+
+## 🛫 Quick Setup
+
+```sh
+# clone the project
+git clone https://github.com/electron-vite/electron-vite-react.git
+
+# enter the project directory
+cd electron-vite-react
+
+# install dependency
+npm install
+
+# develop
+npm run dev
+```
+
+## 🐞 Debug
+
+![electron-vite-react-debug.gif](/electron-vite-react-debug.gif)
+
+## 📂 Directory structure
+
+Familiar React application structure, just with `electron` folder on the top :wink:
+*Files in this folder will be separated from your React application and built into `dist-electron`*
+
+```tree
+├── electron Electron-related code
+│ ├── main Main-process source code
+│ └── preload Preload-scripts source code
+│
+├── release Generated after production build, contains executables
+│ └── {version}
+│ ├── {os}-{os_arch} Contains unpacked application executable
+│ └── {app_name}_{version}.{ext} Installer for the application
+│
+├── public Static assets
+└── src Renderer source code, your React application
+```
+
+<!--
+## 🚨 Be aware
+
+This template integrates Node.js API to the renderer process by default. If you want to follow **Electron Security Concerns** you might want to disable this feature. You will have to expose needed API by yourself.
+
+To get started, remove the option as shown below. This will [modify the Vite configuration and disable this feature](https://github.com/electron-vite/vite-plugin-electron-renderer#config-presets-opinionated).
+
+```diff
+# vite.config.ts
+
+export default {
+ plugins: [
+ ...
+- // Use Node.js API in the Renderer-process
+- renderer({
+- nodeIntegration: true,
+- }),
+ ...
+ ],
+}
+```
+-->
+
+## 🔧 Additional features
+
+1. electron-updater 👉 [see docs](src/components/update/README.md)
+1. playwright
+
+## ❔ FAQ
+
+- [C/C++ addons, Node.js modules - Pre-Bundling](https://github.com/electron-vite/vite-plugin-electron-renderer#dependency-pre-bundling)
+- [dependencies vs devDependencies](https://github.com/electron-vite/vite-plugin-electron-renderer#dependencies-vs-devdependencies)
diff --git a/freemocap-ui-old/e2e/example.spec.ts b/freemocap-ui-old/e2e/example.spec.ts
new file mode 100644
index 00000000..6945042d
--- /dev/null
+++ b/freemocap-ui-old/e2e/example.spec.ts
@@ -0,0 +1,8 @@
+import {_electron as electron, expect, test} from "@playwright/test";
+
+test("homepage has title and links to intro page", async () => {
+ const app = await electron.launch({args: [".", "--no-sandbox"]});
+ const page = await app.firstWindow();
+ expect(await page.title()).toBe("Electron + Vite + React");
+ await page.screenshot({path: "e2e/screenshots/example.png"});
+});
diff --git a/freemocap-ui-old/e2e/screenshots/example.png b/freemocap-ui-old/e2e/screenshots/example.png
new file mode 100644
index 00000000..dad308ed
Binary files /dev/null and b/freemocap-ui-old/e2e/screenshots/example.png differ
diff --git a/freemocap-ui-old/electron-builder.json b/freemocap-ui-old/electron-builder.json
new file mode 100644
index 00000000..af64df5d
--- /dev/null
+++ b/freemocap-ui-old/electron-builder.json
@@ -0,0 +1,48 @@
+{
+ "appId": "freemocap.app",
+ "directories": {
+ "output": "release/${version}"
+ },
+ "files": [
+ "dist-electron",
+ "dist",
+ "freemocap_server.exe",
+ "../shared/freemocap-logo/freemocap-favicon.ico",
+ "../shared/freemocap-logo/freemocap-logo.png"
+ ],
+ "icon": "../shared/freemocap-logo/freemocap-favicon.ico",
+ "asar": true,
+ "asarUnpack": [
+ "**/freemocap_server.exe",
+ "**/freemocap-logo.png"
+ ],
+ "mac": {
+ "artifactName": "${productName}_${version}_installer.${ext}",
+ "target": [
+ "dmg",
+ "zip"
+ ]
+ },
+ "win": {
+ "target": [
+ {
+ "target": "nsis",
+ "arch": [
+ "x64"
+ ]
+ }
+ ],
+ "artifactName": "${productName}_${version}_installer.${ext}"
+ },
+ "nsis": {
+ "oneClick": false,
+ "perMachine": false,
+ "allowToChangeInstallationDirectory": true,
+ "deleteAppDataOnUninstall": false
+ },
+ "publish": {
+ "provider": "generic",
+ "channel": "latest",
+ "url": "https://github.com/freemocap/freemocap"
+ }
+}
diff --git a/freemocap-ui-old/electron/main/api.ts b/freemocap-ui-old/electron/main/api.ts
new file mode 100644
index 00000000..dfcd9030
--- /dev/null
+++ b/freemocap-ui-old/electron/main/api.ts
@@ -0,0 +1,234 @@
+
+import { initTRPC } from '@trpc/server';
+import { z } from 'zod';
+import superjson from 'superjson';
+
+// Services
+import { PythonServer } from './services/python-server';
+import { dialog, shell, app } from 'electron';
+import pkg from 'electron-updater';
+const { autoUpdater } = pkg;
+import path from 'node:path';
+import fs from 'node:fs';
+import os from 'node:os';
+import { APP_PATHS } from './app-paths';
+
+// Configure auto-updater (user triggers download manually)
+autoUpdater.autoDownload = false;
+autoUpdater.allowDowngrade = false;
+
+// Initialize tRPC
+const t = initTRPC.create({
+ transformer: superjson, // Handles Date/undefined/etc serialization
+});
+
+// Telemetry config lives in ~/freemocap_data/telemetry_config.json
+const TELEMETRY_CONFIG_PATH = path.join(os.homedir(), 'freemocap_data', 'telemetry_config.json');
+
+interface TelemetryConfig {
+ telemetry_enabled: boolean;
+}
+
+function readTelemetryConfig(): TelemetryConfig {
+ try {
+ if (fs.existsSync(TELEMETRY_CONFIG_PATH)) {
+ const raw = fs.readFileSync(TELEMETRY_CONFIG_PATH, 'utf-8');
+ const parsed = JSON.parse(raw);
+ return { telemetry_enabled: Boolean(parsed.telemetry_enabled) };
+ }
+ } catch (err) {
+ console.error('Failed to read telemetry config:', err);
+ }
+ // Default: enabled
+ return { telemetry_enabled: true };
+}
+
+function writeTelemetryConfig(config: TelemetryConfig): void {
+ const dir = path.dirname(TELEMETRY_CONFIG_PATH);
+ if (!fs.existsSync(dir)) {
+ fs.mkdirSync(dir, { recursive: true });
+ }
+ fs.writeFileSync(TELEMETRY_CONFIG_PATH, JSON.stringify(config, null, 2) + '\n');
+}
+
+// Create the main API router
+export const api = t.router({
+ // Python Server Management
+ pythonServer: t.router({
+ start: t.procedure
+ .input(z.object({ exePath: z.string().nullable() }))
+ .mutation(({ input }) => PythonServer.start(input.exePath)),
+
+ stop: t.procedure
+ .mutation(() => PythonServer.shutdown()),
+
+ getExecutablePath: t.procedure
+ .query(() => PythonServer.getCurrentExecutablePath()),
+
+ getExecutableCandidates: t.procedure
+ .query(() => PythonServer.validateAllCandidates()),
+
+ refreshCandidates: t.procedure
+ .mutation(() => PythonServer.refreshCandidates()),
+
+ isRunning: t.procedure
+ .query(() => PythonServer.isRunning()),
+
+ getProcessInfo: t.procedure
+ .query(() => PythonServer.getProcessInfo()),
+ }),
+
+ // File System Operations
+ fileSystem: t.router({
+ selectDirectory: t.procedure
+ .mutation(async () => {
+ const result = await dialog.showOpenDialog({
+ properties: ['openDirectory'],
+ });
+ return result.canceled ? null : result.filePaths[0];
+ }),
+
+ openFolder: t.procedure
+ .input(z.object({ path: z.string() }))
+ .mutation(async ({ input }) => {
+ await shell.openPath(input.path);
+ return true;
+ }),
+
+ getHomeDirectory: t.procedure
+ .query(() => app.getPath('home')),
+
+ getFolderContents: t.procedure
+ .input(z.object({ path: z.string() }))
+ .query(({ input }) => {
+ if (!fs.existsSync(input.path)) {
+ throw new Error('Folder does not exist');
+ }
+
+ const entries = fs.readdirSync(input.path);
+ return entries.map(entry => {
+ const fullPath = path.join(input.path, entry);
+ const stats = fs.statSync(fullPath);
+ return {
+ name: entry,
+ path: fullPath,
+ isDirectory: stats.isDirectory(),
+ isFile: stats.isFile(),
+ size: stats.size,
+ modified: stats.mtime,
+ };
+ });
+ }),
+
+ selectExecutableFile: t.procedure
+ .mutation(async () => {
+ const result = await dialog.showOpenDialog({
+ properties: ['openFile'],
+ filters: [
+ { name: 'Executable Files', extensions: ['exe'] },
+ { name: 'All Files', extensions: ['*'] },
+ ],
+ });
+ return result.canceled ? null : result.filePaths[0];
+ }),
+ }),
+
+ // Telemetry Settings
+ telemetry: t.router({
+ getEnabled: t.procedure
+ .query((): boolean => {
+ return readTelemetryConfig().telemetry_enabled;
+ }),
+
+ setEnabled: t.procedure
+ .input(z.object({ enabled: z.boolean() }))
+ .mutation(({ input }): boolean => {
+ writeTelemetryConfig({ telemetry_enabled: input.enabled });
+ return input.enabled;
+ }),
+ }),
+
+ // App Info & Updates
+ app: t.router({
+ getVersion: t.procedure
+ .query((): string => {
+ return app.getVersion();
+ }),
+
+ checkForUpdate: t.procedure
+ .mutation(async () => {
+ if (!app.isPackaged) {
+ return { available: false, reason: 'dev-mode' };
+ }
+ try {
+ const result = await autoUpdater.checkForUpdates();
+ if (result && result.updateInfo) {
+ return {
+ available: result.updateInfo.version !== app.getVersion(),
+ version: result.updateInfo.version,
+ currentVersion: app.getVersion(),
+ };
+ }
+ return { available: false };
+ } catch (error) {
+ console.error('[AutoUpdater] Check failed:', error);
+ return { available: false, error: String(error) };
+ }
+ }),
+
+ downloadUpdate: t.procedure
+ .mutation(async () => {
+ await autoUpdater.downloadUpdate();
+ return true;
+ }),
+
+ installUpdate: t.procedure
+ .mutation(() => {
+ autoUpdater.quitAndInstall(false, true);
+ }),
+ }),
+
+ // Asset Management
+ assets: t.router({
+ getLogoBase64: t.procedure
+ .query((): string | null => {
+ try {
+ let logoPath: string | null = null;
+
+ // Check for logo in order of preference
+ if (fs.existsSync(APP_PATHS.SKELLYCAM_LOGO_PNG_SHARED_PATH)) {
+ logoPath = APP_PATHS.SKELLYCAM_LOGO_PNG_SHARED_PATH;
+ } else if (fs.existsSync(APP_PATHS.SKELLYCAM_LOGO_PNG_RESOURCES_PATH)) {
+ logoPath = APP_PATHS.SKELLYCAM_LOGO_PNG_RESOURCES_PATH;
+ }
+
+ if (!logoPath) {
+ console.error('Logo file not found in any expected location');
+ return null;
+ }
+
+ // Read the file and convert to base64
+ const imageBuffer = fs.readFileSync(logoPath);
+ const base64String = imageBuffer.toString('base64');
+ const mimeType = 'image/png'; // Since we know it's a PNG
+
+ // Return as a data URL that can be used directly in img src
+ return `data:${mimeType};base64,${base64String}`;
+ } catch (error) {
+ console.error('Failed to load logo as base64:', error);
+ return null;
+ }
+ }),
+
+ getLogoPngPath: t.procedure
+ .query(() => {
+ if (fs.existsSync(APP_PATHS.SKELLYCAM_LOGO_PNG_SHARED_PATH)) {
+ return APP_PATHS.SKELLYCAM_LOGO_PNG_SHARED_PATH;
+ }
+ return APP_PATHS.SKELLYCAM_LOGO_PNG_RESOURCES_PATH;
+ }),
+ }),
+});
+
+// Export the type for use in renderer
+export type AppAPI = typeof api;
diff --git a/freemocap-ui-old/electron/main/app-paths.ts b/freemocap-ui-old/electron/main/app-paths.ts
new file mode 100644
index 00000000..c06a7b04
--- /dev/null
+++ b/freemocap-ui-old/electron/main/app-paths.ts
@@ -0,0 +1,87 @@
+import path from "node:path";
+import os from "node:os";
+import {fileURLToPath} from "node:url";
+import {app} from "electron";
+
+export const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+const APP_NAME = 'freemocap';
+const SERVER_EXE_NAME = process.platform === 'win32' ? 'freemocap_server.exe' : 'freemocap_server';
+
+// Function to get the correct resources path based on environment
+const getResourcesPath = () => {
+ if (app.isPackaged) {
+ const resourcesPath = path.join(process.resourcesPath, "app.asar.unpacked");
+ console.log(`App is packaged. resourcesPath: ${resourcesPath}`);
+ return resourcesPath;
+ } else {
+ const resourcesPath = path.join(__dirname, "../../");
+ console.log(`App is in development. resourcesPath: ${resourcesPath}`);
+ return resourcesPath;
+ }
+};
+
+// Platform-specific default install path where electron-builder puts the app
+const getDefaultInstallUnpackedPath = (): string => {
+ const home = os.homedir();
+ switch (process.platform) {
+ case 'win32':
+ // NSIS per-user install: %LOCALAPPDATA%\Programs\{name}\resources\app.asar.unpacked
+ return path.join(home, 'AppData', 'Local', 'Programs', APP_NAME, 'resources', 'app.asar.unpacked');
+ case 'darwin':
+ // macOS .app bundle: /Applications/{name}.app/Contents/Resources/app.asar.unpacked
+ return path.join('/Applications', `${APP_NAME}.app`, 'Contents', 'Resources', 'app.asar.unpacked');
+ case 'linux':
+ // Linux default: /opt/{name}/resources/app.asar.unpacked
+ return path.join('/opt', APP_NAME, 'resources', 'app.asar.unpacked');
+ default:
+ return path.join(home, APP_NAME, 'resources', 'app.asar.unpacked');
+ }
+};
+
+// Python server executable candidates in order of preference
+export const PYTHON_EXECUTABLE_CANDIDATES = [
+ {
+ name: 'bundled',
+ path: path.join(getResourcesPath(), SERVER_EXE_NAME),
+ description: 'Executable bundled with the running app (asar-unpacked)'
+ },
+ {
+ name: 'default-install',
+ path: path.join(getDefaultInstallUnpackedPath(), SERVER_EXE_NAME),
+ description: 'Executable in the platform default install location'
+ },
+ {
+ name: 'development',
+ path: path.join(getResourcesPath(), '..', 'dist', SERVER_EXE_NAME),
+ description: 'Development build executable (../dist/)'
+ },
+ {
+ name: 'portable',
+ path: path.join(process.cwd(), SERVER_EXE_NAME),
+ description: 'Portable executable in the current working directory'
+ },
+ {
+ name: 'system-path',
+ path: SERVER_EXE_NAME, // Resolved via PATH
+ description: 'Executable available in system PATH'
+ }
+];
+
+export const APP_PATHS = {
+ PRELOAD: path.join(__dirname, "../preload/index.mjs"),
+ RENDERER_HTML: path.join(__dirname, "../../dist/index.html"),
+ FREEMOCAP_ICON_PATH: path.resolve(
+ __dirname,
+ "../../../shared/freemocap-logo/freemocap-favicon.ico"
+ ),
+ SKELLYCAM_LOGO_PNG_RESOURCES_PATH: path.join(getResourcesPath(), 'dist/freemocap-logo.png'),
+ SKELLYCAM_LOGO_PNG_SHARED_PATH:path.resolve(
+ __dirname,
+ "../../../shared/freemocap-logo/freemocap-logo.png"
+ ),
+
+};
+
+
+console.log(`APP_PATHS: ${JSON.stringify(APP_PATHS, null, 2)}`);
diff --git a/freemocap-ui-old/electron/main/index.ts b/freemocap-ui-old/electron/main/index.ts
new file mode 100644
index 00000000..280f090d
--- /dev/null
+++ b/freemocap-ui-old/electron/main/index.ts
@@ -0,0 +1,78 @@
+// electron/main/index.ts
+import { app, BrowserWindow } from 'electron';
+import { setupIPC } from './ipc';
+import { WindowManager } from './services/window-manager';
+import { PythonServer } from './services/python-server';
+import { UpdateHandler } from './services/update-handler';
+import { LifecycleLogger } from './services/logger';
+import { buildApplicationMenu } from './services/menu-builder';
+// import os from 'node:os'; // Uncomment if needed for platform-specific checks
+
+// Export environment configuration
+export const APP_ENVIRONMENT = {
+ IS_DEV: process.env.NODE_ENV === 'development',
+ VITE_DEV_SERVER_URL: process.env.VITE_DEV_SERVER_URL,
+};
+
+
+// Platform config
+// if (os.release().startsWith('6.1')) app.disableHardwareAcceleration();
+if (process.platform === 'win32') app.setAppUserModelId(app.getName());
+
+// Prevent multiple instances
+const gotTheLock = app.requestSingleInstanceLock();
+
+if (!gotTheLock) {
+ app.quit();
+} else {
+ app.on('second-instance', () => {
+ // Someone tried to run a second instance, focus our window instead
+ const windows = BrowserWindow.getAllWindows();
+ if (windows.length > 0) {
+ const window = windows[0];
+ if (window.isMinimized()) window.restore();
+ window.focus();
+ }
+ });
+
+ // App lifecycle
+ app.whenReady().then(async () => {
+ LifecycleLogger.logProcessInfo();
+ console.log('App is ready');
+
+ // Setup IPC
+ setupIPC();
+
+ // Build the native application menu with shortcuts
+ buildApplicationMenu();
+
+ // Create window
+ const mainWindow = WindowManager.createMainWindow();
+
+ // Initialize auto-updater (only in production)
+ if (!APP_ENVIRONMENT.IS_DEV) {
+ UpdateHandler.initialize(mainWindow);
+ }
+
+ });
+
+ app.on('window-all-closed', async () => {
+ console.log('All windows closed, shutting down...');
+ await PythonServer.shutdown();
+ app.quit();
+ });
+
+ app.on('activate', () => {
+ if (BrowserWindow.getAllWindows().length === 0) {
+ WindowManager.createMainWindow();
+ }
+ });
+
+ app.on('before-quit', async (event) => {
+ event.preventDefault();
+ console.log('App is quitting, cleaning up...');
+ UpdateHandler.shutdown();
+ await PythonServer.shutdown();
+ app.exit(0);
+ });
+}
diff --git a/freemocap-ui-old/electron/main/ipc.ts b/freemocap-ui-old/electron/main/ipc.ts
new file mode 100644
index 00000000..3e20aa90
--- /dev/null
+++ b/freemocap-ui-old/electron/main/ipc.ts
@@ -0,0 +1,42 @@
+// electron/main/ipc.ts
+import { ipcMain } from 'electron';
+import { api } from './api';
+import superjson from 'superjson';
+import { buildApplicationMenu } from './services/menu-builder';
+import type { MenuBuildParams } from './services/menu-builder';
+
+export function setupIPC(): void {
+ ipcMain.handle('trpc', async (_event, { path, input }) => {
+ try {
+ const caller = api.createCaller({});
+
+ const pathParts = path.split('.');
+ let current: any = caller;
+
+ for (let i = 0; i < pathParts.length - 1; i++) {
+ current = current[pathParts[i]];
+ if (!current) {
+ throw new Error(`Router not found: ${pathParts.slice(0, i + 1).join('.')}`);
+ }
+ }
+
+ const procedureName = pathParts[pathParts.length - 1];
+ const fn = current[procedureName];
+
+ if (typeof fn !== 'function') {
+ throw new Error(`Procedure not found: ${path}`);
+ }
+
+ const result = await fn(input);
+ return superjson.serialize(result);
+ } catch (error) {
+ console.error(`IPC Error for ${path}:`, error);
+ throw error;
+ }
+ });
+
+ // Rebuild the native menu when the renderer sends translated labels
+ ipcMain.on('update-menu-labels', (_event, params: MenuBuildParams) => {
+ buildApplicationMenu(params);
+ });
+}
diff --git a/freemocap-ui-old/electron/main/services/logger.ts b/freemocap-ui-old/electron/main/services/logger.ts
new file mode 100644
index 00000000..deb6a09f
--- /dev/null
+++ b/freemocap-ui-old/electron/main/services/logger.ts
@@ -0,0 +1,23 @@
+import { app, BrowserWindow } from 'electron';
+import { exec } from 'child_process';
+
+export class LifecycleLogger {
+ static logProcessInfo() {
+ console.log(`
+ ============================================
+ Starting FreeMoCap v${app.getVersion()}
+ Platform: ${process.platform}-${process.arch}
+ Node: ${process.versions.node}
+ Chrome: ${process.versions.chrome}
+ Electron: ${process.versions.electron}
+ ============================================`);
+ }
+
+ static logWindowCreation(win: BrowserWindow) {
+ console.log(`[Window Manager] Created window ID: ${win.id}`);
+ }
+
+ static logPythonProcess(pythonProcess: ReturnType<typeof exec>) {
+ console.log(`[Python Server] Started process PID: ${pythonProcess.pid}`);
+ }
+}
diff --git a/freemocap-ui-old/electron/main/services/menu-builder.ts b/freemocap-ui-old/electron/main/services/menu-builder.ts
new file mode 100644
index 00000000..97745687
--- /dev/null
+++ b/freemocap-ui-old/electron/main/services/menu-builder.ts
@@ -0,0 +1,349 @@
+// electron/main/services/menu-builder.ts
+import { app, BrowserWindow, Menu, MenuItemConstructorOptions, shell } from 'electron';
+
+// Channel name for menu-triggered actions sent to the renderer
+const MENU_CHANNEL = 'menu-action';
+
+export type MenuAction =
+ | 'navigate-home'
+ | 'navigate-cameras'
+ | 'navigate-playback'
+ | 'navigate-settings'
+ | 'toggle-theme'
+ | 'toggle-sidebar'
+ | 'detect-cameras'
+ | 'connect-cameras'
+ | 'close-cameras'
+ | 'pause-unpause-cameras'
+ | 'start-recording'
+ | 'stop-recording'
+ | 'open-recording-folder'
+ | 'toggle-fullscreen'
+ | 'toggle-locale'
+ | 'check-for-updates'
+ | `change-locale:${string}`;
+
+export interface LocaleEntry {
+ code: string;
+ label: string;
+}
+
+// All translatable menu label keys. Renderer sends these as a Record<MenuLabelKey, string>.
+export interface MenuLabels {
+ menuFile: string;
+ menuView: string;
+ menuCamera: string;
+ menuRecording: string;
+ menuHelp: string;
+ menuDetectCameras: string;
+ menuConnectCameras: string;
+ menuCloseAllCameras: string;
+ menuOpenRecordingFolder: string;
+ menuToggleSidebar: string;
+ menuToggleTheme: string;
+ menuToggleFullScreen: string;
+ menuPauseUnpause: string;
+ menuConnectApplySettings: string;
+ menuCloseAll: string;
+ menuDocumentation: string;
+ menuGitHubRepository: string;
+ menuReportIssue: string;
+ menuAbout: string;
+ menuCheckForUpdates: string;
+ menuPlayback: string;
+ // Keys reused from the existing i18n
+ home: string;
+ cameras: string;
+ settings: string;
+ startRecording: string;
+ stopRecording: string;
+ language: string;
+}
+
+// English fallback labels used until the renderer sends translated ones
+const DEFAULT_LABELS: MenuLabels = {
+ menuFile: 'File',
+ menuView: 'View',
+ menuCamera: 'Camera',
+ menuRecording: 'Recording',
+ menuHelp: 'Help',
+ menuDetectCameras: 'Detect Cameras',
+ menuConnectCameras: 'Connect Cameras',
+ menuCloseAllCameras: 'Close All Cameras',
+ menuOpenRecordingFolder: 'Open Recording Folder…',
+ menuToggleSidebar: 'Toggle Sidebar',
+ menuToggleTheme: 'Toggle Theme',
+ menuToggleFullScreen: 'Toggle Full Screen',
+ menuPauseUnpause: 'Pause / Unpause',
+ menuConnectApplySettings: 'Connect / Apply Settings',
+ menuCloseAll: 'Close All',
+ menuDocumentation: 'Documentation',
+ menuGitHubRepository: 'GitHub Repository',
+ menuReportIssue: 'Report an Issue…',
+ menuAbout: 'About SkellyCam',
+ menuCheckForUpdates: 'Check for Updates…',
+ menuPlayback: 'Playback',
+ home: 'Home',
+ cameras: 'Cameras',
+ settings: 'Settings',
+ startRecording: 'Start Recording',
+ stopRecording: 'Stop Recording',
+ language: 'Language',
+};
+
+function sendMenuAction(action: MenuAction): void {
+ const window = BrowserWindow.getFocusedWindow();
+ if (!window) return;
+ window.webContents.send(MENU_CHANNEL, action);
+}
+
+const isMac = process.platform === 'darwin';
+
+function buildLanguageSubmenu(t: MenuLabels, locales: LocaleEntry[], currentLocale: string): MenuItemConstructorOptions {
+ return {
+ label: t.language,
+ submenu: [
+ {
+ label: 'Toggle Language',
+ accelerator: 'CmdOrCtrl+Shift+L',
+ click: () => sendMenuAction('toggle-locale'),
+ },
+ { type: 'separator' },
+ ...locales.map((locale): MenuItemConstructorOptions => ({
+ label: locale.label,
+ type: 'radio',
+ checked: locale.code === currentLocale,
+ click: () => sendMenuAction(`change-locale:${locale.code}`),
+ })),
+ ],
+ };
+}
+
+function buildFileMenu(t: MenuLabels, locales: LocaleEntry[], currentLocale: string): MenuItemConstructorOptions {
+ return {
+ label: t.menuFile,
+ submenu: [
+ {
+ label: t.menuOpenRecordingFolder,
+ accelerator: 'CmdOrCtrl+O',
+ click: () => sendMenuAction('open-recording-folder'),
+ },
+ { type: 'separator' },
+ buildLanguageSubmenu(t, locales, currentLocale),
+ {
+ label: `${t.settings}…`,
+ accelerator: 'CmdOrCtrl+,',
+ click: () => sendMenuAction('navigate-settings'),
+ },
+ { type: 'separator' },
+ isMac
+ ? { role: 'close' }
+ : { role: 'quit' },
+ ],
+ };
+}
+
+function buildViewMenu(t: MenuLabels): MenuItemConstructorOptions {
+ return {
+ label: t.menuView,
+ submenu: [
+ {
+ label: t.home,
+ accelerator: 'CmdOrCtrl+1',
+ click: () => sendMenuAction('navigate-home'),
+ },
+ {
+ label: t.cameras,
+ accelerator: 'CmdOrCtrl+2',
+ click: () => sendMenuAction('navigate-cameras'),
+ },
+ {
+ label: t.menuPlayback,
+ accelerator: 'CmdOrCtrl+3',
+ click: () => sendMenuAction('navigate-playback'),
+ },
+ { type: 'separator' },
+ {
+ label: t.menuToggleSidebar,
+ accelerator: 'CmdOrCtrl+B',
+ click: () => sendMenuAction('toggle-sidebar'),
+ },
+ {
+ label: t.menuToggleTheme,
+ accelerator: 'CmdOrCtrl+Shift+T',
+ click: () => sendMenuAction('toggle-theme'),
+ },
+ { type: 'separator' },
+ {
+ label: t.menuToggleFullScreen,
+ accelerator: isMac ? 'Ctrl+Cmd+F' : 'F11',
+ click: () => sendMenuAction('toggle-fullscreen'),
+ },
+ { type: 'separator' },
+ { role: 'reload' },
+ { role: 'forceReload' },
+ { role: 'toggleDevTools' },
+ { type: 'separator' },
+ { role: 'resetZoom' },
+ { role: 'zoomIn' },
+ { role: 'zoomOut' },
+ ],
+ };
+}
+
+function buildCameraMenu(t: MenuLabels): MenuItemConstructorOptions {
+ return {
+ label: t.menuCamera,
+ submenu: [
+ {
+ label: t.menuDetectCameras,
+ accelerator: 'CmdOrCtrl+D',
+ click: () => sendMenuAction('detect-cameras'),
+ },
+ {
+ label: t.menuConnectApplySettings,
+ accelerator: 'CmdOrCtrl+Shift+C',
+ click: () => sendMenuAction('connect-cameras'),
+ },
+ {
+ label: t.menuCloseAll,
+ accelerator: 'CmdOrCtrl+Shift+W',
+ click: () => sendMenuAction('close-cameras'),
+ },
+ { type: 'separator' },
+ {
+ label: t.menuPauseUnpause,
+ accelerator: 'Shift+Space',
+ click: () => sendMenuAction('pause-unpause-cameras'),
+ },
+ ],
+ };
+}
+
+function buildRecordingMenu(t: MenuLabels): MenuItemConstructorOptions {
+ return {
+ label: t.menuRecording,
+ submenu: [
+ {
+ label: t.startRecording,
+ accelerator: 'CmdOrCtrl+Shift+S',
+ click: () => sendMenuAction('start-recording'),
+ },
+ {
+ label: t.stopRecording,
+ accelerator: 'CmdOrCtrl+Shift+X',
+ click: () => sendMenuAction('stop-recording'),
+ },
+ { type: 'separator' },
+ {
+ label: t.menuOpenRecordingFolder,
+ click: () => sendMenuAction('open-recording-folder'),
+ },
+ ],
+ };
+}
+
+function buildHelpMenu(t: MenuLabels): MenuItemConstructorOptions {
+ return {
+ label: t.menuHelp,
+ submenu: [
+ {
+ label: t.menuDocumentation,
+ click: () => {
+ // Keep in sync with freemocap-ui/src/constants/external-urls.ts
+ shell.openExternal('https://docs.freemocap.org/freemocap');
+ },
+ },
+ {
+ label: t.menuGitHubRepository,
+ click: () => {
+ shell.openExternal('https://github.com/freemocap/freemocap');
+ },
+ },
+ {
+ label: t.menuReportIssue,
+ click: () => {
+ shell.openExternal('https://github.com/freemocap/freemocap/issues/new');
+ },
+ },
+ { type: 'separator' },
+ {
+ label: 'FreeMoCap Foundation',
+ click: () => {
+ shell.openExternal('https://freemocap.org');
+ },
+ },
+ { type: 'separator' },
+ {
+ label: t.menuCheckForUpdates,
+ click: () => sendMenuAction('check-for-updates'),
+ },
+ { type: 'separator' },
+ {
+ label: t.menuAbout,
+ click: () => sendMenuAction('navigate-settings'),
+ },
+ ],
+ };
+}
+
+export interface MenuBuildParams {
+ labels?: Partial<MenuLabels>;
+ locales?: LocaleEntry[];
+ currentLocale?: string;
+}
+
+export function buildApplicationMenu(params: MenuBuildParams = {}): void {
+ const { labels, locales = [], currentLocale = 'en' } = params;
+ const t: MenuLabels = { ...DEFAULT_LABELS, ...labels };
+ const template: MenuItemConstructorOptions[] = [];
+
+ // macOS app menu
+ if (isMac) {
+ template.push({
+ label: app.getName(),
+ submenu: [
+ { role: 'about' },
+ { type: 'separator' },
+ {
+ label: `${t.settings}…`,
+ accelerator: 'Cmd+,',
+ click: () => sendMenuAction('navigate-settings'),
+ },
+ { type: 'separator' },
+ { role: 'services' },
+ { type: 'separator' },
+ { role: 'hide' },
+ { role: 'hideOthers' },
+ { role: 'unhide' },
+ { type: 'separator' },
+ { role: 'quit' },
+ ],
+ });
+ }
+
+ template.push(buildFileMenu(t, locales, currentLocale));
+ template.push(buildViewMenu(t));
+ template.push(buildCameraMenu(t));
+ template.push(buildRecordingMenu(t));
+
+ // macOS window menu
+ if (isMac) {
+ template.push({
+ label: 'Window',
+ submenu: [
+ { role: 'minimize' },
+ { role: 'zoom' },
+ { type: 'separator' },
+ { role: 'front' },
+ ],
+ });
+ }
+
+ template.push(buildHelpMenu(t));
+
+ const menu = Menu.buildFromTemplate(template);
+ Menu.setApplicationMenu(menu);
+}
+
+export { MENU_CHANNEL };
diff --git a/freemocap-ui-old/electron/main/services/python-server.ts b/freemocap-ui-old/electron/main/services/python-server.ts
new file mode 100644
index 00000000..c6b16365
--- /dev/null
+++ b/freemocap-ui-old/electron/main/services/python-server.ts
@@ -0,0 +1,240 @@
+import {exec} from 'child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import {LifecycleLogger} from "./logger";
+import {promisify} from 'util';
+import treeKill from "tree-kill";
+import {PYTHON_EXECUTABLE_CANDIDATES} from "../app-paths";
+
+const treeKillAsync = promisify(treeKill);
+let pythonProcess: ReturnType<typeof exec> | null = null;
+
+export interface ExecutableCandidate {
+ name: string;
+ path: string;
+ description: string;
+ isValid?: boolean;
+ error?: string;
+ resolvedPath?: string; // Add resolved path for deduplication
+}
+
+export class PythonServer {
+ private static currentExecutablePath: string | null = null;
+ private static validatedCandidates: ExecutableCandidate[] = [];
+
+ static async start(exePath: string | null = null) {
+ console.log('Starting python server subprocess...');
+
+ try {
+ await this.shutdown();
+
+ let executablePath: string;
+
+ if (exePath) {
+ // If specific path provided, validate it
+ this.validateExecutable(exePath);
+ executablePath = exePath;
+ console.log(`Using provided executable path: ${executablePath}`);
+ } else {
+ // Find first valid executable from candidates
+ executablePath = await this.findValidExecutablePath();
+ console.log(`Using auto-detected executable path: ${executablePath}`);
+ }
+
+ this.currentExecutablePath = executablePath;
+ console.log(`Launching Python server from: ${executablePath}`);
+ pythonProcess = exec(`"${executablePath}"`, {
+ env: {
+ ...process.env,
+ },
+ maxBuffer: 1024 * 1024 * 100 // 100MB buffer
+ });
+
+ pythonProcess.on('exit', (code) => {
+ console.log(`Python server exited (code: ${code})`);
+ this.currentExecutablePath = null;
+ });
+
+ pythonProcess.on('error', (error) => {
+ console.error('Python server process error:', error);
+ this.currentExecutablePath = null;
+ });
+
+ if (!pythonProcess.pid) {
+ throw new Error('Python server failed to start - no process ID');
+ }
+
+ LifecycleLogger.logPythonProcess(pythonProcess);
+ console.log(`✔ Python server started successfully (PID: ${pythonProcess.pid})`);
+
+ } catch (error) {
+ console.error('Failed to start Python server:', error);
+ this.currentExecutablePath = null;
+ throw error;
+ }
+ }
+
+ static async shutdown() {
+ if (!pythonProcess || !pythonProcess.pid) {
+ console.log('No Python server process to shutdown');
+ return;
+ }
+
+ console.log(`Shutting down Python server (PID: ${pythonProcess.pid})`);
+
+ try {
+ // Kill entire process tree
+ await treeKillAsync(pythonProcess.pid);
+ console.log('✔ Python server process tree terminated');
+ } catch (error) {
+ console.error('Error killing process tree:', error);
+ // Fallback to direct kill
+ try {
+ pythonProcess?.kill('SIGKILL');
+ console.log('✔ Python server force-killed as fallback');
+ } catch (killError) {
+ console.error('Failed to force-kill Python server:', killError);
+ }
+ }
+
+ // Wait a moment for cleanup
+ await new Promise(resolve => setTimeout(resolve, 1000));
+
+ if (pythonProcess && !pythonProcess.killed) {
+ console.warn('Python server may not have exited cleanly');
+ }
+
+ pythonProcess = null;
+ this.currentExecutablePath = null;
+ console.log('✔ Python server shutdown complete');
+ }
+
+ static getCurrentExecutablePath(): string | null {
+ return this.currentExecutablePath;
+ }
+
+ static async findValidExecutablePath(): Promise<string> {
+ console.log('Searching for valid Python server executable...');
+
+ // Validate all candidates if not done yet
+ if (this.validatedCandidates.length === 0) {
+ await this.validateAllCandidates();
+ }
+
+ // Find first valid candidate
+ const validCandidate = this.validatedCandidates.find(candidate => candidate.isValid);
+
+ if (!validCandidate) {
+ const errorMessage = 'No valid Python server executable found in any candidate location:\n' +
+ this.validatedCandidates.map(c => ` - ${c.name}: ${c.error || 'Unknown error'}`).join('\n');
+ throw new Error(errorMessage);
+ }
+
+ console.log(`✔ Selected executable: ${validCandidate.name} (${validCandidate.path})`);
+ return validCandidate.path;
+ }
+
+ static async validateAllCandidates(): Promise<ExecutableCandidate[]> {
+ console.log('Validating all executable candidates...');
+
+ // First, validate all candidates
+ const allValidatedCandidates = await Promise.all(
+ PYTHON_EXECUTABLE_CANDIDATES.map(async (candidate) => {
+ const validatedCandidate: ExecutableCandidate = {
+ ...candidate,
+ isValid: false
+ };
+
+ try {
+ this.validateExecutable(candidate.path);
+ validatedCandidate.isValid = true;
+ // Store resolved path for deduplication
+ validatedCandidate.resolvedPath = fs.existsSync(candidate.path)
+ ? path.resolve(candidate.path)
+ : candidate.path;
+ console.log(` ✔ ${candidate.name}: Valid`);
+ } catch (error) {
+ validatedCandidate.error = error instanceof Error ? error.message : 'Unknown validation error';
+ console.log(` ✗ ${candidate.name}: ${validatedCandidate.error}`);
+ }
+
+ return validatedCandidate;
+ })
+ );
+
+ // Deduplicate by resolved path
+ const seenPaths = new Set<string>();
+ this.validatedCandidates = allValidatedCandidates.filter(candidate => {
+ const pathKey = candidate.resolvedPath || candidate.path;
+
+ // If we've seen this path before, skip it
+ if (seenPaths.has(pathKey)) {
+ console.log(` ⚠ Skipping duplicate: ${candidate.name} (same as another candidate)`);
+ return false;
+ }
+
+ // Add to seen paths
+ seenPaths.add(pathKey);
+ return true;
+ });
+
+ const validCount = this.validatedCandidates.filter(c => c.isValid).length;
+ console.log(`Validation complete: ${validCount}/${this.validatedCandidates.length} unique candidates are valid`);
+
+ return this.validatedCandidates;
+ }
+
+ static getPythonServerExecutableCandidates(): ExecutableCandidate[] {
+ return [...this.validatedCandidates]; // Return copy to prevent mutation
+ }
+
+ static async refreshCandidates(): Promise<ExecutableCandidate[]> {
+ console.log('Refreshing executable candidates validation...');
+ this.validatedCandidates = [];
+ return await this.validateAllCandidates();
+ }
+
+ static isRunning(): boolean {
+ return pythonProcess !== null && pythonProcess.pid !== undefined && !pythonProcess.killed;
+ }
+
+ static getProcessInfo(): { pid: number | undefined; killed: boolean } | null {
+ if (!pythonProcess) return null;
+
+ return {
+ pid: pythonProcess.pid,
+ killed: pythonProcess.killed || false
+ };
+ }
+
+ private static validateExecutable(exePath: string): void {
+ // Check if file exists
+ if (!fs.existsSync(exePath)) {
+ throw new Error(`Executable not found at: ${exePath}`);
+ }
+
+ // Check if it's actually a file (not a directory)
+ const stats = fs.statSync(exePath);
+ if (!stats.isFile()) {
+ throw new Error(`Path is not a file: ${exePath}`);
+ }
+
+ // Check if file is executable
+ try {
+ fs.accessSync(exePath, fs.constants.F_OK | fs.constants.R_OK);
+
+ // On Windows, we mainly check if file exists and is readable
+ // On Unix systems, we can check execute permissions
+ if (process.platform !== 'win32') {
+ fs.accessSync(exePath, fs.constants.X_OK);
+ }
+ } catch (error) {
+ throw new Error(`File is not accessible or executable: ${exePath}`);
+ }
+
+ // Additional validation: check file extension on Windows
+ if (process.platform === 'win32' && !exePath.toLowerCase().endsWith('.exe')) {
+ console.warn(`Warning: Executable doesn't have .exe extension: ${exePath}`);
+ }
+ }
+}
\ No newline at end of file
diff --git a/freemocap-ui-old/electron/main/services/update-handler.ts b/freemocap-ui-old/electron/main/services/update-handler.ts
new file mode 100644
index 00000000..9ca06240
--- /dev/null
+++ b/freemocap-ui-old/electron/main/services/update-handler.ts
@@ -0,0 +1,87 @@
+
+import { app, BrowserWindow } from 'electron';
+import pkg from 'electron-updater';
+const { autoUpdater } = pkg;
+
+const CHECK_INTERVAL_MS = 4 * 60 * 60 * 1000; // 4 hours
+const INITIAL_CHECK_DELAY_MS = 10 * 1000; // 10 seconds after startup
+
+export class UpdateHandler {
+ private static instance: UpdateHandler | null = null;
+ private checkInterval: ReturnType<typeof setInterval> | null = null;
+ private initialTimeout: ReturnType<typeof setTimeout> | null = null;
+
+ private constructor(private mainWindow: BrowserWindow) {
+ this.setupEventForwarding();
+ this.scheduleChecks();
+ }
+
+ private setupEventForwarding() {
+ autoUpdater.on('checking-for-update', () => {
+ console.log('[AutoUpdater] Checking for updates...');
+ });
+
+ autoUpdater.on('update-available', (info) => {
+ console.log('[AutoUpdater] Update available:', info.version);
+ this.mainWindow.webContents.send('update-available', {
+ version: info.version,
+ currentVersion: app.getVersion(),
+ });
+ });
+
+ autoUpdater.on('update-not-available', () => {
+ console.log('[AutoUpdater] Already up to date');
+ });
+
+ autoUpdater.on('download-progress', (progress) => {
+ this.mainWindow.webContents.send('download-progress', progress);
+ });
+
+ autoUpdater.on('update-downloaded', (info) => {
+ console.log('[AutoUpdater] Update downloaded:', info.version);
+ this.mainWindow.webContents.send('update-downloaded', {
+ version: info.version,
+ });
+ });
+
+ autoUpdater.on('error', (error) => {
+ console.error('[AutoUpdater] Error:', error.message);
+ this.mainWindow.webContents.send('update-error', {
+ message: error.message,
+ });
+ });
+ }
+
+ private scheduleChecks() {
+ // Initial check after a short delay to let the app finish loading
+ this.initialTimeout = setTimeout(() => {
+ autoUpdater.checkForUpdates().catch((err) => {
+ console.error('[AutoUpdater] Initial check failed:', err.message);
+ });
+ }, INITIAL_CHECK_DELAY_MS);
+
+ // Periodic checks
+ this.checkInterval = setInterval(() => {
+ autoUpdater.checkForUpdates().catch((err) => {
+ console.error('[AutoUpdater] Periodic check failed:', err.message);
+ });
+ }, CHECK_INTERVAL_MS);
+ }
+
+ dispose() {
+ if (this.initialTimeout) clearTimeout(this.initialTimeout);
+ if (this.checkInterval) clearInterval(this.checkInterval);
+ this.initialTimeout = null;
+ this.checkInterval = null;
+ }
+
+ static initialize(window: BrowserWindow) {
+ UpdateHandler.instance = new UpdateHandler(window);
+ return UpdateHandler.instance;
+ }
+
+ static shutdown() {
+ UpdateHandler.instance?.dispose();
+ UpdateHandler.instance = null;
+ }
+}
diff --git a/freemocap-ui-old/electron/main/services/window-manager.ts b/freemocap-ui-old/electron/main/services/window-manager.ts
new file mode 100644
index 00000000..9e982505
--- /dev/null
+++ b/freemocap-ui-old/electron/main/services/window-manager.ts
@@ -0,0 +1,113 @@
+// electron/main/services/window-manager.ts
+import { BrowserWindow, shell } from 'electron';
+import { LifecycleLogger } from './logger';
+import { APP_ENVIRONMENT } from '../index';
+import {APP_PATHS} from "../app-paths";
+
+export class WindowManager {
+ private static mainWindow: BrowserWindow | null = null;
+
+ static createMainWindow(): BrowserWindow {
+ // Return existing window if already created
+ if (this.mainWindow && !this.mainWindow.isDestroyed()) {
+ return this.mainWindow;
+ }
+
+ const window = new BrowserWindow({
+ title: 'FreeMoCap 💀✨',
+ icon: APP_PATHS.FREEMOCAP_ICON_PATH,
+ width: 1280,
+ height: 720,
+ minWidth: 800,
+ minHeight: 600,
+ webPreferences: {
+ preload: APP_PATHS.PRELOAD,
+ contextIsolation: true,
+ nodeIntegration: false,
+ sandbox: true,
+ },
+ show: false, // Don't show until ready
+ });
+
+ this.mainWindow = window;
+ this.configureWindowHandlers(window);
+ this.loadContent(window);
+
+ // Show window when ready
+ window.once('ready-to-show', () => {
+ window.show();
+ LifecycleLogger.logWindowCreation(window);
+ });
+
+ return window;
+ }
+
+ private static configureWindowHandlers(window: BrowserWindow): void {
+ console.log('Configuring window handlers');
+
+ window.on('closed', () => {
+ console.log('Window closed');
+ this.mainWindow = null;
+ });
+
+ window.webContents.on('did-finish-load', () => {
+ console.log('Window finished loading');
+ window.webContents.send('app-ready', Date.now());
+ });
+
+ // Handle external links
+ window.webContents.setWindowOpenHandler(({ url }) => {
+ if (url.startsWith('http:') || url.startsWith('https:')) {
+ shell.openExternal(url).catch(err =>
+ console.error('Failed to open external link:', err)
+ );
+ }
+ return { action: 'deny' };
+ });
+
+ // Intercept navigation to external links
+ window.webContents.on('will-navigate', (event, url) => {
+ const currentURL = window.webContents.getURL();
+
+ // Allow navigation within the app
+ if (APP_ENVIRONMENT.IS_DEV && url.startsWith(APP_ENVIRONMENT.VITE_DEV_SERVER_URL!)) {
+ return;
+ }
+
+ if (!APP_ENVIRONMENT.IS_DEV && url.startsWith('file://')) {
+ return;
+ }
+
+ // Prevent navigation to external URLs
+ if (url.startsWith('http:') || url.startsWith('https:')) {
+ event.preventDefault();
+ shell.openExternal(url).catch(err =>
+ console.error('Failed to open external link via navigation:', err)
+ );
+ }
+ });
+
+ // Handle crashes
+ window.webContents.on('render-process-gone', (event, details) => {
+ console.error('Renderer process gone:', details);
+ if (details.reason === 'crashed') {
+ window.reload();
+ }
+ });
+ }
+
+ private static loadContent(window: BrowserWindow): void {
+ console.log('Loading app content - IS_DEV:', APP_ENVIRONMENT.IS_DEV);
+
+ if (APP_ENVIRONMENT.IS_DEV && APP_ENVIRONMENT.VITE_DEV_SERVER_URL) {
+ window.loadURL(APP_ENVIRONMENT.VITE_DEV_SERVER_URL);
+ // window.webContents.openDevTools();
+ } else {
+ window.loadFile(APP_PATHS.RENDERER_HTML);
+ }
+ }
+
+ static getMainWindow(): BrowserWindow | null {
+ return this.mainWindow;
+ }
+}
diff --git a/freemocap-ui-old/electron/preload/index.ts b/freemocap-ui-old/electron/preload/index.ts
new file mode 100644
index 00000000..337e7e50
--- /dev/null
+++ b/freemocap-ui-old/electron/preload/index.ts
@@ -0,0 +1,48 @@
+import { contextBridge, ipcRenderer } from 'electron';
+
+// Expose a simple tRPC bridge + menu action listener + menu label updater
+contextBridge.exposeInMainWorld('electronAPI', {
+ invoke: (path: string, input?: unknown) =>
+ ipcRenderer.invoke('trpc', { path, input }),
+
+ onMenuAction: (callback: (action: string) => void) => {
+ const handler = (_event: Electron.IpcRendererEvent, action: string) => {
+ callback(action);
+ };
+ ipcRenderer.on('menu-action', handler);
+
+ // Return a cleanup function to remove the listener
+ return () => {
+ ipcRenderer.removeListener('menu-action', handler);
+ };
+ },
+
+ sendMenuLabels: (params: Record<string, unknown>) => {
+ ipcRenderer.send('update-menu-labels', params);
+ },
+
+ // Auto-update event listeners
+ onUpdateAvailable: (callback: (info: { version: string; currentVersion: string }) => void) => {
+ const handler = (_event: Electron.IpcRendererEvent, info: { version: string; currentVersion: string }) => callback(info);
+ ipcRenderer.on('update-available', handler);
+ return () => { ipcRenderer.removeListener('update-available', handler); };
+ },
+
+ onDownloadProgress: (callback: (progress: { percent: number; bytesPerSecond: number; transferred: number; total: number }) => void) => {
+ const handler = (_event: Electron.IpcRendererEvent, progress: any) => callback(progress);
+ ipcRenderer.on('download-progress', handler);
+ return () => { ipcRenderer.removeListener('download-progress', handler); };
+ },
+
+ onUpdateDownloaded: (callback: (info: { version: string }) => void) => {
+ const handler = (_event: Electron.IpcRendererEvent, info: { version: string }) => callback(info);
+ ipcRenderer.on('update-downloaded', handler);
+ return () => { ipcRenderer.removeListener('update-downloaded', handler); };
+ },
+
+ onUpdateError: (callback: (error: { message: string }) => void) => {
+ const handler = (_event: Electron.IpcRendererEvent, error: { message: string }) => callback(error);
+ ipcRenderer.on('update-error', handler);
+ return () => { ipcRenderer.removeListener('update-error', handler); };
+ },
+});
diff --git a/freemocap-ui-old/index.html b/freemocap-ui-old/index.html
new file mode 100644
index 00000000..037bbe43
--- /dev/null
+++ b/freemocap-ui-old/index.html
@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta charset="UTF-8"/>
+ <link href="/favicon.ico" rel="icon" type="image/x-icon"/>
+ <meta content="width=device-width, initial-scale=1.0" name="viewport"/>
+ <meta content="script-src 'self' 'unsafe-inline'; worker-src blob:;" http-equiv="Content-Security-Policy"/>
+ <title>FreeMoCap💀✨</title>
+</head>
+<body>
+<div id="root"></div>
+<script src="/src/main.tsx" type="module"></script>
+</body>
+</html>
diff --git a/freemocap-ui-old/package.json b/freemocap-ui-old/package.json
new file mode 100644
index 00000000..583e221b
--- /dev/null
+++ b/freemocap-ui-old/package.json
@@ -0,0 +1,82 @@
+{
+ "name": "freemocap",
+ "version": "2.0.0",
+ "main": "dist-electron/main/index.js",
+ "description": "FreeMocap - Free open source markerless motion capture for everyone.",
+ "homepage": "https://freemocap.org",
+ "author": "Skelly FreeMocap <[email protected]>",
+ "license": "AGPL-3.0-or-later",
+ "debug": {
+ "env": {
+ "VITE_DEV_SERVER_URL": "http://127.0.0.1:7777/"
+ }
+ },
+ "type": "module",
+ "scripts": {
+ "dev": "cross-env NODE_ENV=development vite",
+ "demo": "cross-env NODE_ENV=production vite build && electron .",
+ "build": "cross-env NODE_ENV=production && tsc && vite build && electron-builder",
+ "preview": "vite preview",
+ "test": "vitest run",
+ "test:watch": "vitest",
+ "pree2e": "vite build --mode=test",
+ "e2e": "playwright test"
+ },
+ "dependencies": {
+ "@dnd-kit/core": "^6.3.1",
+ "@dnd-kit/modifiers": "^9.0.0",
+ "@dnd-kit/sortable": "^10.0.0",
+ "@dnd-kit/utilities": "^3.2.2",
+ "@emotion/react": "^11.13.3",
+ "@emotion/styled": "^11.13.0",
+ "@ffmpeg/ffmpeg": "^0.12.10",
+ "@ffmpeg/util": "^0.12.1",
+ "@fontsource/roboto": "^5.1.0",
+ "@monaco-editor/react": "^4.6.0",
+ "@msgpack/msgpack": "^3.0.0-beta2",
+ "@mui/icons-material": "^6.4.5",
+ "@mui/material": "^6.1.1",
+ "@mui/x-tree-view": "^7.29.1",
+ "@react-three/drei": "^10.4.2",
+ "@react-three/fiber": "^9.1.4",
+ "@reduxjs/toolkit": "^2.5.1",
+ "@trpc/client": "^11.5.1",
+ "@trpc/server": "^11.5.1",
+ "axios": "^1.7.7",
+ "country-flag-icons": "^1.6.14",
+ "d3": "^7.9.0",
+ "electron-updater": "^6.1.8",
+ "i18next-browser-languagedetector": "^8.2.1",
+ "exploration": "^1.6.0",
+ "js-yaml": "^4.1.0",
+ "react-i18next": "^16.5.4",
+ "react-grid-layout": "^2.2.2",
+ "react-redux": "^9.1.2",
+ "react-resizable-panels": "^2.1.7",
+ "react-router": "^6.26.2",
+ "react-router-dom": "^6.26.2",
+ "react-use": "^17.5.1",
+ "smol-toml": "^1.3.1",
+ "superjson": "^2.2.2",
+ "three": "^0.178.0",
+ "tree-kill": "^1.2.2",
+ "zod": "^4.1.5"
+ },
+ "devDependencies": {
+ "@playwright/test": "^1.42.1",
+ "@types/d3": "^7.4.3",
+ "@types/js-yaml": "^4.0.9",
+ "@types/react": "^19.2.14",
+ "@types/react-dom": "^19.2.3",
+ "@vitejs/plugin-react": "^4.3.3",
+ "cross-env": "^7.0.3",
+ "electron": "^35.0.3",
+ "electron-builder": "^26.8.1",
+ "react": "^19.1.0",
+ "react-dom": "^19.1.0",
+ "vite": "^7.3.1",
+ "vitest": "^3.2.1",
+ "vite-plugin-electron": "^0.28.8",
+ "vite-plugin-electron-renderer": "^0.14.5"
+ }
+}
diff --git a/freemocap-ui-old/playwright.config.ts b/freemocap-ui-old/playwright.config.ts
new file mode 100644
index 00000000..25b3278b
--- /dev/null
+++ b/freemocap-ui-old/playwright.config.ts
@@ -0,0 +1,54 @@
+import type {PlaywrightTestConfig} from "@playwright/test";
+
+/**
+ * Read environment variables from file.
+ * https://github.com/motdotla/dotenv
+ */
+// require('dotenv').config();
+
+/**
+ * See https://playwright.dev/docs/test-configuration.
+ */
+const config: PlaywrightTestConfig = {
+ testDir: "./e2e",
+ /* Maximum time one test can run for. */
+ timeout: 30 * 1000,
+ expect: {
+ /**
+ * Maximum time expect() should wait for the condition to be met.
+ * For example in `await expect(locator).toHaveText();`
+ */
+ timeout: 5000,
+ },
+ /* Run tests in files in parallel */
+ fullyParallel: true,
+ /* Fail the build on CI if you accidentally left test.only in the source code. */
+ forbidOnly: !!process.env.CI,
+ /* Retry on CI only */
+ retries: process.env.CI ? 2 : 0,
+ /* Opt out of parallel tests on CI. */
+ workers: process.env.CI ? 1 : undefined,
+ /* Reporter to use. See https://playwright.dev/docs/test-reporters */
+ reporter: "html",
+ /* Shared settings for all the projects below. See https://playwright.dev/docs/api/class-testoptions. */
+ use: {
+ /* Maximum time each action such as `click()` can take. Defaults to 0 (no limit). */
+ actionTimeout: 0,
+ /* Base URL to use in actions like `await page.goto('/')`. */
+ // baseURL: 'http://localhost:3000',
+
+ /* Collect trace when retrying the failed test. See https://playwright.dev/docs/trace-viewer */
+ trace: "on-first-retry",
+ },
+
+ /* Folder for test artifacts such as screenshots, videos, traces, etc. */
+ // outputDir: 'test-results/',
+
+ /* Run your local dev server before starting the tests */
+ // webServer: {
+ // command: 'npm run start',
+ // port: 3000,
+ // },
+};
+
+export default config;
diff --git a/freemocap-ui-old/public/freemocap-logo.png b/freemocap-ui-old/public/freemocap-logo.png
new file mode 100644
index 00000000..965d70bd
Binary files /dev/null and b/freemocap-ui-old/public/freemocap-logo.png differ
diff --git a/freemocap-ui-old/public/skellycam-logo.png b/freemocap-ui-old/public/skellycam-logo.png
new file mode 100644
index 00000000..f8596e6f
Binary files /dev/null and b/freemocap-ui-old/public/skellycam-logo.png differ
diff --git a/freemocap-ui-old/src/App.css b/freemocap-ui-old/src/App.css
new file mode 100644
index 00000000..1042d137
--- /dev/null
+++ b/freemocap-ui-old/src/App.css
@@ -0,0 +1,52 @@
+#root {
+ width: 100%;
+ height: 100vh;
+ overflow: hidden;
+}
+
+.logo-box {
+ position: relative;
+ height: 9em;
+}
+
+.logo {
+ position: absolute;
+ left: calc(50% - 4.5em);
+ height: 6em;
+ padding: 1.5em;
+ will-change: filter;
+ transition: filter 300ms;
+}
+
+.logo:hover {
+ filter: drop-shadow(0 0 2em #646cffaa);
+}
+
+@keyframes logo-spin {
+ from {
+ transform: rotate(0deg);
+ }
+ to {
+ transform: rotate(360deg);
+ }
+}
+
+@media (prefers-reduced-motion: no-preference) {
+ .logo.electron {
+ animation: logo-spin infinite 20s linear;
+ }
+}
+
+.card {
+ padding: 2em;
+}
+
+.read-the-docs {
+ color: #888;
+}
+
+.flex-center {
+ display: flex;
+ align-items: center;
+ justify-content: center;
+}
diff --git a/freemocap-ui-old/src/App.tsx b/freemocap-ui-old/src/App.tsx
new file mode 100644
index 00000000..ba07547f
--- /dev/null
+++ b/freemocap-ui-old/src/App.tsx
@@ -0,0 +1,18 @@
+import React from 'react';
+import {Provider} from 'react-redux';
+import {store} from '@/store';
+import {ServerContextProvider} from "@/services/server/ServerContextProvider";
+import {AppContent} from "@/layout/AppContent";
+
+
+function App() {
+ return (
+ <Provider store={store}>
+ <ServerContextProvider>
+ <AppContent/>
+ </ServerContextProvider>
+ </Provider>
+ );
+}
+
+export default App;
diff --git a/freemocap-ui-old/src/__tests__/calibration-slice.test.ts b/freemocap-ui-old/src/__tests__/calibration-slice.test.ts
new file mode 100644
index 00000000..03141e76
--- /dev/null
+++ b/freemocap-ui-old/src/__tests__/calibration-slice.test.ts
@@ -0,0 +1,287 @@
+import { describe, it, expect } from 'vitest';
+import {
+ calibrationSlice,
+ calibrationConfigUpdated,
+ calibrationProgressUpdated,
+ calibrationErrorCleared,
+ manualCalibrationRecordingPathChanged,
+ manualCalibrationRecordingPathCleared,
+ calibrationDirectoryInfoUpdated,
+ resetCalibrationState,
+ CalibrationConfig,
+ CalibrationState,
+ CalibrationDirectoryInfo,
+} from '@/store/slices/calibration/calibration-slice';
+
+const reducer = calibrationSlice.reducer;
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function getInitialState(): CalibrationState {
+ return reducer(undefined, { type: 'unknown' });
+}
+
+// ---------------------------------------------------------------------------
+// Initial state
+// ---------------------------------------------------------------------------
+
+describe('calibrationSlice initial state', () => {
+ it('has correct default config values matching backend defaults', () => {
+ const state = getInitialState();
+ // These MUST match CalibrationPipelineConfig defaults on the backend
+ expect(state.config.charucoBoardXSquares).toBe(5);
+ expect(state.config.charucoBoardYSquares).toBe(3);
+ expect(state.config.charucoSquareLength).toBe(1);
+ expect(state.config.solverMethod).toBe('anipose');
+ expect(state.config.useGroundplane).toBe(false);
+ });
+
+ it('starts not recording', () => {
+ const state = getInitialState();
+ expect(state.isRecording).toBe(false);
+ expect(state.recordingProgress).toBe(0);
+ });
+
+ it('starts with no error', () => {
+ const state = getInitialState();
+ expect(state.error).toBeNull();
+ });
+
+ it('starts with no loading', () => {
+ const state = getInitialState();
+ expect(state.isLoading).toBe(false);
+ });
+});
+
+// ---------------------------------------------------------------------------
+// calibrationConfigUpdated
+// ---------------------------------------------------------------------------
+
+describe('calibrationConfigUpdated', () => {
+ it('merges partial config update', () => {
+ const state = getInitialState();
+ const updated = reducer(state, calibrationConfigUpdated({
+ charucoBoardXSquares: 7,
+ }));
+ expect(updated.config.charucoBoardXSquares).toBe(7);
+ // Other fields should be preserved
+ expect(updated.config.charucoBoardYSquares).toBe(3);
+ expect(updated.config.charucoSquareLength).toBe(1);
+ expect(updated.config.solverMethod).toBe('anipose');
+ });
+
+ it('can update solver method', () => {
+ const state = getInitialState();
+ const updated = reducer(state, calibrationConfigUpdated({
+ solverMethod: 'pyceres',
+ }));
+ expect(updated.config.solverMethod).toBe('pyceres');
+ });
+
+ it('can update useGroundplane', () => {
+ const state = getInitialState();
+ const updated = reducer(state, calibrationConfigUpdated({
+ useGroundplane: true,
+ }));
+ expect(updated.config.useGroundplane).toBe(true);
+ });
+
+ it('can update multiple fields at once', () => {
+ const state = getInitialState();
+ const updated = reducer(state, calibrationConfigUpdated({
+ charucoBoardXSquares: 9,
+ charucoBoardYSquares: 7,
+ charucoSquareLength: 39.5,
+ }));
+ expect(updated.config.charucoBoardXSquares).toBe(9);
+ expect(updated.config.charucoBoardYSquares).toBe(7);
+ expect(updated.config.charucoSquareLength).toBe(39.5);
+ });
+});
+
+// ---------------------------------------------------------------------------
+// Progress and error
+// ---------------------------------------------------------------------------
+
+describe('calibrationProgressUpdated', () => {
+ it('sets recording progress', () => {
+ const state = getInitialState();
+ const updated = reducer(state, calibrationProgressUpdated(42.5));
+ expect(updated.recordingProgress).toBe(42.5);
+ });
+});
+
+describe('calibrationErrorCleared', () => {
+ it('clears error', () => {
+ const state: CalibrationState = {
+ ...getInitialState(),
+ error: 'something went wrong',
+ };
+ const updated = reducer(state, calibrationErrorCleared());
+ expect(updated.error).toBeNull();
+ });
+});
+
+// ---------------------------------------------------------------------------
+// Manual recording path
+// ---------------------------------------------------------------------------
+
+describe('manual recording path', () => {
+ it('sets manual path', () => {
+ const state = getInitialState();
+ const updated = reducer(state, manualCalibrationRecordingPathChanged('/custom/path'));
+ expect(updated.manualCalibrationRecordingPath).toBe('/custom/path');
+ });
+
+ it('clears manual path', () => {
+ const state: CalibrationState = {
+ ...getInitialState(),
+ manualCalibrationRecordingPath: '/custom/path',
+ };
+ const updated = reducer(state, manualCalibrationRecordingPathCleared());
+ expect(updated.manualCalibrationRecordingPath).toBeNull();
+ });
+});
+
+// ---------------------------------------------------------------------------
+// Directory info
+// ---------------------------------------------------------------------------
+
+describe('calibrationDirectoryInfoUpdated', () => {
+ it('stores directory info', () => {
+ const state = getInitialState();
+ const info: CalibrationDirectoryInfo = {
+ exists: true,
+ canRecord: true,
+ canCalibrate: true,
+ cameraCalibrationTomlPath: '/tmp/cal/calibration.toml',
+ hasSynchronizedVideos: true,
+ hasVideos: true,
+ errorMessage: null,
+ };
+ const updated = reducer(state, calibrationDirectoryInfoUpdated(info));
+ expect(updated.directoryInfo).toEqual(info);
+ });
+});
+
+// ---------------------------------------------------------------------------
+// Reset
+// ---------------------------------------------------------------------------
+
+describe('resetCalibrationState', () => {
+ it('resets everything to initial state', () => {
+ const modified: CalibrationState = {
+ config: {
+ liveTrackCharuco: false,
+ charucoBoardXSquares: 9,
+ charucoBoardYSquares: 7,
+ charucoSquareLength: 40,
+ minSharedViewsPerCamera: 300,
+ autoStopOnMinViewCount: false,
+ solverMethod: 'pyceres',
+ useGroundplane: true,
+ },
+ isRecording: true,
+ recordingProgress: 50,
+ isLoading: true,
+ error: 'some error',
+ lastCalibrationRecordingPath: '/some/path',
+ manualCalibrationRecordingPath: '/manual/path',
+ directoryInfo: null,
+ };
+ const reset = reducer(modified, resetCalibrationState());
+ const fresh = getInitialState();
+ expect(reset).toEqual(fresh);
+ });
+});
+
+// ---------------------------------------------------------------------------
+// Async thunk reducers (pending/fulfilled/rejected)
+// ---------------------------------------------------------------------------
+
+describe('startCalibrationRecording thunk reducers', () => {
+ it('pending sets isLoading and clears error', () => {
+ const state: CalibrationState = {
+ ...getInitialState(),
+ error: 'old error',
+ };
+ const updated = reducer(state, {
+ type: 'calibration/startRecording/pending',
+ });
+ expect(updated.isLoading).toBe(true);
+ expect(updated.error).toBeNull();
+ });
+
+ it('fulfilled sets isRecording and resets progress', () => {
+ const state: CalibrationState = {
+ ...getInitialState(),
+ isLoading: true,
+ };
+ const updated = reducer(state, {
+ type: 'calibration/startRecording/fulfilled',
+ payload: { success: true },
+ });
+ expect(updated.isLoading).toBe(false);
+ expect(updated.isRecording).toBe(true);
+ expect(updated.recordingProgress).toBe(0);
+ });
+
+ it('fulfilled stores calibrationRecordingPath if provided', () => {
+ const state: CalibrationState = {
+ ...getInitialState(),
+ isLoading: true,
+ };
+ const updated = reducer(state, {
+ type: 'calibration/startRecording/fulfilled',
+ payload: {
+ success: true,
+ calibrationRecordingPath: '/new/recording/path',
+ },
+ });
+ expect(updated.lastCalibrationRecordingPath).toBe('/new/recording/path');
+ });
+
+ it('rejected sets error', () => {
+ const state: CalibrationState = {
+ ...getInitialState(),
+ isLoading: true,
+ };
+ const updated = reducer(state, {
+ type: 'calibration/startRecording/rejected',
+ payload: 'Connection refused',
+ });
+ expect(updated.isLoading).toBe(false);
+ expect(updated.error).toBe('Connection refused');
+ });
+});
+
+describe('stopCalibrationRecording thunk reducers', () => {
+ it('fulfilled stops recording', () => {
+ const state: CalibrationState = {
+ ...getInitialState(),
+ isRecording: true,
+ isLoading: true,
+ recordingProgress: 80,
+ };
+ const updated = reducer(state, {
+ type: 'calibration/stopRecording/fulfilled',
+ payload: { success: true },
+ });
+ expect(updated.isLoading).toBe(false);
+ expect(updated.isRecording).toBe(false);
+ expect(updated.recordingProgress).toBe(0);
+ });
+});
+
+describe('updateCalibrationConfigOnServer thunk reducers', () => {
+ it('rejected sets error', () => {
+ const state = getInitialState();
+ const updated = reducer(state, {
+ type: 'calibration/updateConfig/rejected',
+ payload: 'Server error',
+ });
+ expect(updated.error).toBe('Server error');
+ });
+});
diff --git a/freemocap-ui-old/src/__tests__/message-type-guards.test.ts b/freemocap-ui-old/src/__tests__/message-type-guards.test.ts
new file mode 100644
index 00000000..2ce2c58e
--- /dev/null
+++ b/freemocap-ui-old/src/__tests__/message-type-guards.test.ts
@@ -0,0 +1,197 @@
+import { describe, it, expect } from 'vitest';
+import {
+ isSettingsStateMessage,
+ isLogRecord,
+ isFramerateUpdate,
+} from '@/services/server/server-helpers/websocket-message-types';
+
+// ---------------------------------------------------------------------------
+// isSettingsStateMessage
+// ---------------------------------------------------------------------------
+
+describe('isSettingsStateMessage', () => {
+ it('returns true for valid settings/state message', () => {
+ const msg = {
+ message_type: 'settings/state',
+ settings: {
+ cameras: {},
+ pipeline: {},
+ calibration: {},
+ mocap: {},
+ },
+ version: 1,
+ };
+ expect(isSettingsStateMessage(msg)).toBe(true);
+ });
+
+ it('returns false if message_type is wrong', () => {
+ const msg = {
+ message_type: 'settings/patch',
+ settings: {},
+ version: 1,
+ };
+ expect(isSettingsStateMessage(msg)).toBe(false);
+ });
+
+ it('returns false if message_type is missing', () => {
+ const msg = {
+ settings: {},
+ version: 1,
+ };
+ expect(isSettingsStateMessage(msg)).toBe(false);
+ });
+
+ it('returns false if settings is missing', () => {
+ const msg = {
+ message_type: 'settings/state',
+ version: 1,
+ };
+ expect(isSettingsStateMessage(msg)).toBe(false);
+ });
+
+ it('returns false if settings is null', () => {
+ const msg = {
+ message_type: 'settings/state',
+ settings: null,
+ version: 1,
+ };
+ expect(isSettingsStateMessage(msg)).toBe(false);
+ });
+
+ it('returns false if version is missing', () => {
+ const msg = {
+ message_type: 'settings/state',
+ settings: {},
+ };
+ expect(isSettingsStateMessage(msg)).toBe(false);
+ });
+
+ it('returns false if version is not a number', () => {
+ const msg = {
+ message_type: 'settings/state',
+ settings: {},
+ version: '1',
+ };
+ expect(isSettingsStateMessage(msg)).toBe(false);
+ });
+
+ it('returns false for null', () => {
+ expect(isSettingsStateMessage(null)).toBe(false);
+ });
+
+ it('returns false for undefined', () => {
+ expect(isSettingsStateMessage(undefined)).toBe(false);
+ });
+
+ it('returns false for a string', () => {
+ expect(isSettingsStateMessage('hello')).toBe(false);
+ });
+
+ it('returns false for a number', () => {
+ expect(isSettingsStateMessage(42)).toBe(false);
+ });
+
+ it('returns false for an empty object', () => {
+ expect(isSettingsStateMessage({})).toBe(false);
+ });
+});
+
+// ---------------------------------------------------------------------------
+// isLogRecord
+// ---------------------------------------------------------------------------
+
+describe('isLogRecord', () => {
+ it('returns true for valid log record', () => {
+ const msg = {
+ message_type: 'log_record',
+ levelname: 'INFO',
+ message: 'Something happened',
+ levelno: 20,
+ };
+ expect(isLogRecord(msg)).toBe(true);
+ });
+
+ it('returns false if message_type is wrong', () => {
+ const msg = {
+ message_type: 'not_log',
+ levelname: 'INFO',
+ message: 'nope',
+ };
+ expect(isLogRecord(msg)).toBe(false);
+ });
+
+ it('returns false if levelname missing', () => {
+ const msg = {
+ message_type: 'log_record',
+ message: 'no level',
+ };
+ expect(isLogRecord(msg)).toBe(false);
+ });
+
+ it('returns false if message missing', () => {
+ const msg = {
+ message_type: 'log_record',
+ levelname: 'INFO',
+ };
+ expect(isLogRecord(msg)).toBe(false);
+ });
+
+ it('returns false for null', () => {
+ expect(isLogRecord(null)).toBe(false);
+ });
+});
+
+// ---------------------------------------------------------------------------
+// isFramerateUpdate
+// ---------------------------------------------------------------------------
+
+describe('isFramerateUpdate', () => {
+ it('returns true for valid framerate update', () => {
+ const msg = {
+ message_type: 'framerate_update',
+ camera_group_id: 'group-0',
+ backend_framerate: { fps: 30 },
+ frontend_framerate: { fps: 28 },
+ };
+ expect(isFramerateUpdate(msg)).toBe(true);
+ });
+
+ it('returns false if message_type is wrong', () => {
+ const msg = {
+ message_type: 'not_framerate',
+ camera_group_id: 'group-0',
+ backend_framerate: {},
+ frontend_framerate: {},
+ };
+ expect(isFramerateUpdate(msg)).toBe(false);
+ });
+
+ it('returns false if camera_group_id missing', () => {
+ const msg = {
+ message_type: 'framerate_update',
+ backend_framerate: {},
+ frontend_framerate: {},
+ };
+ expect(isFramerateUpdate(msg)).toBe(false);
+ });
+
+ it('returns false if backend_framerate is not an object', () => {
+ const msg = {
+ message_type: 'framerate_update',
+ camera_group_id: 'group-0',
+ backend_framerate: 30,
+ frontend_framerate: {},
+ };
+ expect(isFramerateUpdate(msg)).toBe(false);
+ });
+
+ it('returns false if frontend_framerate is null', () => {
+ const msg = {
+ message_type: 'framerate_update',
+ camera_group_id: 'group-0',
+ backend_framerate: {},
+ frontend_framerate: null,
+ };
+ expect(isFramerateUpdate(msg)).toBe(false);
+ });
+});
diff --git a/freemocap-ui-old/src/__tests__/mocap-slice.test.ts b/freemocap-ui-old/src/__tests__/mocap-slice.test.ts
new file mode 100644
index 00000000..6877e6bb
--- /dev/null
+++ b/freemocap-ui-old/src/__tests__/mocap-slice.test.ts
@@ -0,0 +1,234 @@
+import { describe, it, expect } from 'vitest';
+import {
+ mocapSlice,
+ mocapDetectorConfigReplaced,
+ mocapDetectorConfigUpdated,
+ skeletonFilterConfigReplaced,
+ skeletonFilterConfigUpdated,
+ mocapErrorCleared,
+ resetMocapState,
+ MEDIAPIPE_REALTIME_PRESET,
+ MEDIAPIPE_POSTHOC_PRESET,
+ DEFAULT_ESTIMATOR_CONFIG,
+ DEFAULT_REALTIME_FILTER_CONFIG,
+ MocapState,
+} from '@/store/slices/mocap/mocap-slice';
+
+const reducer = mocapSlice.reducer;
+
+function getInitialState(): MocapState {
+ return reducer(undefined, { type: 'unknown' });
+}
+
+// ---------------------------------------------------------------------------
+// Initial state — defaults must match backend
+// ---------------------------------------------------------------------------
+
+describe('mocapSlice initial state', () => {
+ it('has detector config matching MEDIAPIPE_REALTIME_PRESET', () => {
+ const state = getInitialState();
+ expect(state.config.detector).toEqual(MEDIAPIPE_REALTIME_PRESET);
+ });
+
+ it('has skeleton_filter config matching DEFAULT_REALTIME_FILTER_CONFIG', () => {
+ const state = getInitialState();
+ expect(state.config.skeleton_filter).toEqual(DEFAULT_REALTIME_FILTER_CONFIG);
+ });
+
+ it('starts not recording', () => {
+ const state = getInitialState();
+ expect(state.isRecording).toBe(false);
+ expect(state.recordingProgress).toBe(0);
+ });
+
+ it('starts with no error', () => {
+ const state = getInitialState();
+ expect(state.error).toBeNull();
+ });
+});
+
+// ---------------------------------------------------------------------------
+// Default constants match backend values
+// ---------------------------------------------------------------------------
+
+describe('default constants match backend', () => {
+ describe('MEDIAPIPE_REALTIME_PRESET', () => {
+ // These must match MEDIAPIPE_TRACKER_REALTIME_PRESET in skellytracker
+ it('has model_complexity 0', () => {
+ expect(MEDIAPIPE_REALTIME_PRESET.model_complexity).toBe(0);
+ });
+ it('has static_image_mode false', () => {
+ expect(MEDIAPIPE_REALTIME_PRESET.static_image_mode).toBe(false);
+ });
+ it('has smooth_landmarks true', () => {
+ expect(MEDIAPIPE_REALTIME_PRESET.smooth_landmarks).toBe(true);
+ });
+ });
+
+ describe('DEFAULT_ESTIMATOR_CONFIG', () => {
+ // Must match EstimatorConfig defaults in bone_length_estimator.py
+ it('has max_samples 500', () => {
+ expect(DEFAULT_ESTIMATOR_CONFIG.max_samples).toBe(500);
+ });
+ it('has min_samples_for_full_confidence 100', () => {
+ expect(DEFAULT_ESTIMATOR_CONFIG.min_samples_for_full_confidence).toBe(100);
+ });
+ it('has iqr_confidence_sensitivity 10.0', () => {
+ expect(DEFAULT_ESTIMATOR_CONFIG.iqr_confidence_sensitivity).toBe(10.0);
+ });
+ });
+
+ describe('DEFAULT_REALTIME_FILTER_CONFIG', () => {
+ // Must match RealtimeFilterConfig defaults in realtime_skeleton_filter.py
+ it('has min_cutoff 0.005', () => {
+ expect(DEFAULT_REALTIME_FILTER_CONFIG.min_cutoff).toBe(0.005);
+ });
+ it('has beta 0.3', () => {
+ expect(DEFAULT_REALTIME_FILTER_CONFIG.beta).toBe(0.3);
+ });
+ it('has d_cutoff 1.0', () => {
+ expect(DEFAULT_REALTIME_FILTER_CONFIG.d_cutoff).toBe(1.0);
+ });
+ it('has height_meters 1.75', () => {
+ expect(DEFAULT_REALTIME_FILTER_CONFIG.height_meters).toBe(1.75);
+ });
+ it('has noise_sigma 0.015', () => {
+ expect(DEFAULT_REALTIME_FILTER_CONFIG.noise_sigma).toBe(0.015);
+ });
+ it('has max_reprojection_error_px 60.0', () => {
+ expect(DEFAULT_REALTIME_FILTER_CONFIG.max_reprojection_error_px).toBe(60.0);
+ });
+ it('has max_velocity_m_per_s 50.0', () => {
+ expect(DEFAULT_REALTIME_FILTER_CONFIG.max_velocity_m_per_s).toBe(50.0);
+ });
+ it('has max_rejected_streak 5', () => {
+ expect(DEFAULT_REALTIME_FILTER_CONFIG.max_rejected_streak).toBe(5);
+ });
+ it('has max_prediction_frames 15', () => {
+ expect(DEFAULT_REALTIME_FILTER_CONFIG.max_prediction_frames).toBe(15);
+ });
+ it('has prediction_velocity_decay 0.75', () => {
+ expect(DEFAULT_REALTIME_FILTER_CONFIG.prediction_velocity_decay).toBe(0.75);
+ });
+ });
+});
+
+// ---------------------------------------------------------------------------
+// Detector config reducers
+// ---------------------------------------------------------------------------
+
+describe('mocapDetectorConfigReplaced', () => {
+ it('replaces entire detector config', () => {
+ const state = getInitialState();
+ const updated = reducer(state, mocapDetectorConfigReplaced(MEDIAPIPE_POSTHOC_PRESET));
+ expect(updated.config.detector).toEqual(MEDIAPIPE_POSTHOC_PRESET);
+ expect(updated.config.detector.model_complexity).toBe(2);
+ });
+});
+
+describe('mocapDetectorConfigUpdated', () => {
+ it('merges partial update into detector config', () => {
+ const state = getInitialState();
+ const updated = reducer(state, mocapDetectorConfigUpdated({
+ model_complexity: 1,
+ }));
+ expect(updated.config.detector.model_complexity).toBe(1);
+ // Other fields preserved
+ expect(updated.config.detector.smooth_landmarks).toBe(true);
+ });
+});
+
+// ---------------------------------------------------------------------------
+// Skeleton filter config reducers
+// ---------------------------------------------------------------------------
+
+describe('skeletonFilterConfigReplaced', () => {
+ it('replaces entire filter config', () => {
+ const state = getInitialState();
+ const customFilter = {
+ ...DEFAULT_REALTIME_FILTER_CONFIG,
+ beta: 0.99,
+ max_rejected_streak: 10,
+ };
+ const updated = reducer(state, skeletonFilterConfigReplaced(customFilter));
+ expect(updated.config.skeleton_filter.beta).toBe(0.99);
+ expect(updated.config.skeleton_filter.max_rejected_streak).toBe(10);
+ });
+});
+
+describe('skeletonFilterConfigUpdated', () => {
+ it('merges partial update into filter config', () => {
+ const state = getInitialState();
+ const updated = reducer(state, skeletonFilterConfigUpdated({ beta: 0.1 }));
+ expect(updated.config.skeleton_filter.beta).toBe(0.1);
+ // Other fields preserved from DEFAULT_REALTIME_FILTER_CONFIG
+ expect(updated.config.skeleton_filter.min_cutoff).toBe(0.005);
+ expect(updated.config.skeleton_filter.max_rejected_streak).toBe(5);
+ });
+});
+
+// ---------------------------------------------------------------------------
+// Error handling
+// ---------------------------------------------------------------------------
+
+describe('mocapErrorCleared', () => {
+ it('clears error', () => {
+ const state: MocapState = { ...getInitialState(), error: 'oops' };
+ const updated = reducer(state, mocapErrorCleared());
+ expect(updated.error).toBeNull();
+ });
+});
+
+// ---------------------------------------------------------------------------
+// Reset
+// ---------------------------------------------------------------------------
+
+describe('resetMocapState', () => {
+ it('resets to initial state', () => {
+ const modified: MocapState = {
+ ...getInitialState(),
+ config: {
+ detector: MEDIAPIPE_POSTHOC_PRESET,
+ skeleton_filter: { ...DEFAULT_REALTIME_FILTER_CONFIG, beta: 99 },
+ },
+ isRecording: true,
+ error: 'err',
+ };
+ const reset = reducer(modified, resetMocapState());
+ expect(reset).toEqual(getInitialState());
+ });
+});
+
+// ---------------------------------------------------------------------------
+// Async thunk reducers
+// ---------------------------------------------------------------------------
+
+describe('startMocapRecording thunk reducers', () => {
+ it('pending sets isLoading', () => {
+ const state = getInitialState();
+ const updated = reducer(state, { type: 'mocap/startRecording/pending' });
+ expect(updated.isLoading).toBe(true);
+ expect(updated.error).toBeNull();
+ });
+
+ it('fulfilled sets isRecording', () => {
+ const state: MocapState = { ...getInitialState(), isLoading: true };
+ const updated = reducer(state, {
+ type: 'mocap/startRecording/fulfilled',
+ payload: { success: true },
+ });
+ expect(updated.isLoading).toBe(false);
+ expect(updated.isRecording).toBe(true);
+ expect(updated.recordingProgress).toBe(0);
+ });
+
+ it('rejected sets error', () => {
+ const state: MocapState = { ...getInitialState(), isLoading: true };
+ const updated = reducer(state, {
+ type: 'mocap/startRecording/rejected',
+ payload: 'Network error',
+ });
+ expect(updated.isLoading).toBe(false);
+ expect(updated.error).toBe('Network error');
+ });
+});
diff --git a/freemocap-ui-old/src/__tests__/settings-slice.test.ts b/freemocap-ui-old/src/__tests__/settings-slice.test.ts
new file mode 100644
index 00000000..2d655a4c
--- /dev/null
+++ b/freemocap-ui-old/src/__tests__/settings-slice.test.ts
@@ -0,0 +1,181 @@
+import { describe, it, expect } from 'vitest';
+import {
+ settingsSlice,
+ serverSettingsUpdated,
+ serverSettingsCleared,
+ ServerSettingsState,
+} from '@/store/slices/settings/settings-slice';
+import type {
+ FreeMoCapSettings,
+ SettingsStateMessage,
+} from '@/store/slices/settings/settings-types';
+
+const reducer = settingsSlice.reducer;
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeSettings(overrides?: Partial<FreeMoCapSettings>): FreeMoCapSettings {
+ return {
+ cameras: {},
+ pipeline: {
+ config: null,
+ is_connected: false,
+ pipeline_id: null,
+ camera_group_id: null,
+ is_paused: false,
+ },
+ calibration: {
+ config: {
+ calibration_recording_folder: null,
+ charuco_board_x_squares: 5,
+ charuco_board_y_squares: 3,
+ charuco_square_length: 1,
+ solver_method: 'anipose',
+ use_groundplane: false,
+ pyceres_solver_config: {},
+ },
+ is_recording: false,
+ recording_progress: 0,
+ last_recording_path: null,
+ has_calibration_toml: false,
+ },
+ mocap: {
+ config: {
+ detector: {},
+ skeleton_filter: {
+ min_cutoff: 0.005,
+ beta: 0.3,
+ d_cutoff: 1.0,
+ fabrik_tolerance: 1e-4,
+ fabrik_max_iterations: 20,
+ height_meters: 1.75,
+ noise_sigma: 0.015,
+ estimator_config: {
+ max_samples: 500,
+ min_samples_for_full_confidence: 100,
+ iqr_confidence_sensitivity: 10.0,
+ },
+ max_reprojection_error_px: 60.0,
+ max_velocity_m_per_s: 50.0,
+ max_rejected_streak: 5,
+ max_prediction_frames: 15,
+ prediction_velocity_decay: 0.75,
+ },
+ },
+ is_recording: false,
+ recording_progress: 0,
+ last_recording_path: null,
+ },
+ vmc: {
+ enabled: false,
+ host: '127.0.0.1',
+ port: 39539,
+ },
+ ...overrides,
+ };
+}
+
+function makeStateMessage(
+ version: number,
+ settingsOverrides?: Partial<FreeMoCapSettings>,
+): SettingsStateMessage {
+ return {
+ message_type: 'settings/state',
+ settings: makeSettings(settingsOverrides),
+ version,
+ };
+}
+
+const initialState: ServerSettingsState = {
+ settings: null,
+ version: -1,
+ lastUpdated: null,
+ isInitialized: false,
+};
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('settingsSlice', () => {
+ it('has correct initial state', () => {
+ const state = reducer(undefined, { type: 'unknown' });
+ expect(state.settings).toBeNull();
+ expect(state.version).toBe(-1);
+ expect(state.lastUpdated).toBeNull();
+ expect(state.isInitialized).toBe(false);
+ });
+
+ describe('serverSettingsUpdated', () => {
+ it('applies a settings/state message with version > current', () => {
+ const msg = makeStateMessage(1);
+ const state = reducer(initialState, serverSettingsUpdated(msg));
+ expect(state.settings).toEqual(msg.settings);
+ expect(state.version).toBe(1);
+ expect(state.isInitialized).toBe(true);
+ expect(state.lastUpdated).not.toBeNull();
+ });
+
+ it('ignores a settings/state message with version <= current', () => {
+ const firstMsg = makeStateMessage(5);
+ const state1 = reducer(initialState, serverSettingsUpdated(firstMsg));
+
+ const staleMsg = makeStateMessage(3, {
+ calibration: {
+ ...makeSettings().calibration,
+ is_recording: true,
+ },
+ });
+ const state2 = reducer(state1, serverSettingsUpdated(staleMsg));
+
+ // Should not have changed
+ expect(state2.version).toBe(5);
+ expect(state2.settings!.calibration.is_recording).toBe(false);
+ });
+
+ it('ignores a settings/state message with same version', () => {
+ const msg = makeStateMessage(5);
+ const state1 = reducer(initialState, serverSettingsUpdated(msg));
+
+ const sameVersionMsg = makeStateMessage(5, {
+ calibration: {
+ ...makeSettings().calibration,
+ is_recording: true,
+ },
+ });
+ const state2 = reducer(state1, serverSettingsUpdated(sameVersionMsg));
+ expect(state2.settings!.calibration.is_recording).toBe(false);
+ });
+
+ it('applies newer version after an older one', () => {
+ const msg1 = makeStateMessage(1);
+ const state1 = reducer(initialState, serverSettingsUpdated(msg1));
+
+ const msg2 = makeStateMessage(2, {
+ calibration: {
+ ...makeSettings().calibration,
+ is_recording: true,
+ },
+ });
+ const state2 = reducer(state1, serverSettingsUpdated(msg2));
+ expect(state2.version).toBe(2);
+ expect(state2.settings!.calibration.is_recording).toBe(true);
+ });
+ });
+
+ describe('serverSettingsCleared', () => {
+ it('resets to initial state', () => {
+ const msg = makeStateMessage(5);
+ const populated = reducer(initialState, serverSettingsUpdated(msg));
+ expect(populated.isInitialized).toBe(true);
+
+ const cleared = reducer(populated, serverSettingsCleared());
+ expect(cleared.settings).toBeNull();
+ expect(cleared.version).toBe(-1);
+ expect(cleared.lastUpdated).toBeNull();
+ expect(cleared.isInitialized).toBe(false);
+ });
+ });
+});
diff --git a/freemocap-ui-old/src/components/LogTerminal.tsx b/freemocap-ui-old/src/components/LogTerminal.tsx
new file mode 100644
index 00000000..a59d0524
--- /dev/null
+++ b/freemocap-ui-old/src/components/LogTerminal.tsx
@@ -0,0 +1,439 @@
+// LogTerminal.tsx
+import {
+ alpha,
+ Box,
+ Chip,
+ Collapse,
+ IconButton,
+ TextField,
+ ToggleButton,
+ ToggleButtonGroup,
+ Tooltip,
+ useTheme,
+} from "@mui/material";
+import {useEffect, useRef, useState} from "react";
+import {useAppDispatch, useAppSelector} from "@/store";
+import {
+ selectFilteredLogs,
+ selectHasErrors,
+ selectLogCountsByLevel,
+ selectLogsPaused
+} from "@/store/slices/log-records/logs-selectors";
+import {logsCleared, logsFiltered, logsPaused} from "@/store/slices/log-records/log-records-slice";
+import {LogRecord} from "@/store/slices/log-records/logs-types";
+import {
+ Delete as DeleteIcon,
+ Pause as PauseIcon,
+ PlayArrow as PlayArrowIcon,
+ Search as SearchIcon,
+ Warning as WarningIcon
+} from "@mui/icons-material";
+
+const LOG_COLORS = {
+ TRACE: "#ccc",
+ DEBUG: "#88ccFF",
+ INFO: "#00E5FF",
+ SUCCESS: "#FF66FF",
+ API: "#66FF66",
+ WARNING: "#FFFF66",
+ ERROR: "#FF6666",
+ CRITICAL: "#FF0000",
+} as const;
+
+const LogEntryComponent = ({ log }: { log: LogRecord }) => {
+ const [expanded, setExpanded] = useState(false);
+ const color =
+ LOG_COLORS[log.levelname.toUpperCase() as keyof typeof LOG_COLORS] || "#ccc";
+ const theme = useTheme();
+
+ const renderWithFormatting = (text: string | null | undefined): React.ReactNode => {
+ if (!text) return null;
+
+ return text.split("\n").map((line, i) => (
+ <div
+ key={i}
+ style={{
+ whiteSpace: "pre-wrap",
+ fontFamily: "monospace",
+ lineHeight: "1.2",
+ }}
+ >
+ {line}
+ </div>
+ ));
+ };
+
+ return (
+ <Box
+ sx={{
+ mb: 0.5,
+ borderLeft: `2px solid ${color}`,
+ pl: 1,
+ backgroundColor: expanded
+ ? alpha(color, 0.1)
+ : theme.palette.mode === "dark"
+ ? "rgba(0,0,0,0.2)"
+ : "rgba(0,0,0,0.05)",
+ cursor: "pointer",
+ transition: "background-color 0.1s",
+ "&:hover": {
+ backgroundColor: alpha(
+ color,
+ theme.palette.mode === "dark" ? 0.05 : 0.1
+ ),
+ },
+ }}
+ onClick={() => setExpanded(!expanded)}
+ >
+ <Box sx={{ display: "flex", gap: 1, alignItems: "center", py: 0.5 }}>
+ <span
+ style={{
+ color: theme.palette.mode === "dark" ? "#888" : "#555",
+ fontSize: "0.9em",
+ minWidth: "140px",
+ }}
+ >
+ {log.asctime}
+ </span>
+ <Chip
+ size="small"
+ label={log.levelname}
+ sx={{
+ backgroundColor: color,
+ color: "#000",
+ height: 16,
+ fontSize: "0.8em",
+ minWidth: "60px",
+ ".MuiChip-label": {
+ px: 1,
+ },
+ }}
+ />
+ <span
+ style={{
+ color: theme.palette.mode === "dark" ? "#fff" : "#000",
+ flexGrow: 1,
+ fontSize: "0.9em",
+ }}
+ >
+ {renderWithFormatting(log.message)}
+ </span>
+ </Box>
+
+ <Collapse in={expanded}>
+ <Box
+ sx={{
+ pl: 2,
+ py: 1,
+ fontSize: "0.8em",
+ color: theme.palette.mode === "dark" ? "#888" : "#555",
+ borderTop: "1px solid",
+ fontFamily: 'monospace',
+ borderColor:
+ theme.palette.mode === "dark"
+ ? "rgba(255,255,255,0.1)"
+ : "rgba(0,0,0,0.1)",
+ }}
+ >
+ <div>
+ Location: {log.module}:{log.funcName}:Line#{log.lineno}
+ </div>
+ <div>File: {log.filename}</div>
+ <div>Time delta: {log.delta_t}</div>
+ <div>Path: {log.pathname}</div>
+ {log.formatted_message && (
+ <div>Raw message: {renderWithFormatting(log.formatted_message)}</div>
+ )}
+ <div>
+ Thread: {log.threadName} (ID: {log.thread})
+ </div>
+ <div>
+ Process: {log.processName} (ID: {log.process})
+ </div>
+
+ {(log.exc_info || log.exc_text) && (
+ <div>
+ <div>Exception details:</div>
+ {log.exc_info && <div>{renderWithFormatting(log.exc_info)}</div>}
+ {log.exc_text && <div>{renderWithFormatting(log.exc_text)}</div>}
+ </div>
+ )}
+
+ {log.stack_info && (
+ <div>
+ <div>Stack Trace:</div>
+ <pre
+ style={{
+ whiteSpace: "pre-wrap",
+ background:
+ theme.palette.mode === "dark" ? "#111" : "#f5f5f5",
+ padding: 8,
+ borderRadius: 4,
+ margin: "8px 0",
+ }}
+ >
+ {renderWithFormatting(log.stack_info)}
+ </pre>
+ </div>
+ )}
+ </Box>
+ </Collapse>
+ </Box>
+ );
+};
+
+export const LogTerminal = () => {
+ const theme = useTheme();
+ const dispatch = useAppDispatch();
+ const logs = useAppSelector(selectFilteredLogs);
+ const isPaused = useAppSelector(selectLogsPaused);
+ const hasErrors = useAppSelector(selectHasErrors);
+ const logCounts = useAppSelector(selectLogCountsByLevel);
+
+ const [selectedLevels, setSelectedLevels] = useState<string[]>([]);
+ const [searchText, setSearchText] = useState<string>("");
+ const [showSearch, setShowSearch] = useState(false);
+ const logEndRef = useRef<HTMLDivElement>(null);
+ const shouldAutoScroll = useRef(true);
+
+ // Update filter when levels or search text changes
+ useEffect(() => {
+ dispatch(logsFiltered({
+ levels: selectedLevels,
+ searchText: searchText
+ }));
+ }, [selectedLevels, searchText, dispatch]);
+
+ // Auto-scroll to bottom when new logs arrive (if not paused)
+ useEffect(() => {
+ if (!isPaused && shouldAutoScroll.current) {
+ logEndRef.current?.scrollIntoView({ behavior: "smooth" });
+ }
+ }, [logs, isPaused]);
+
+ const handleLevelToggle = (_: React.MouseEvent<HTMLElement>, newLevels: string[]): void => {
+ setSelectedLevels(newLevels);
+ };
+
+ const handlePauseToggle = (): void => {
+ dispatch(logsPaused(!isPaused));
+ };
+
+ const handleClear = (): void => {
+ dispatch(logsCleared());
+ };
+
+ const handleScroll = (e: React.UIEvent<HTMLDivElement>): void => {
+ const element = e.currentTarget;
+ const isAtBottom = element.scrollHeight - element.scrollTop <= element.clientHeight + 50;
+ shouldAutoScroll.current = isAtBottom;
+ };
+
+ return (
+ <Box
+ sx={{
+ height: "100%",
+ display: "flex",
+ flexDirection: "column",
+ backgroundColor:
+ theme.palette.mode === "dark" ? "#1a1a1a" : theme.palette.grey[100],
+ }}
+ >
+ <Box
+ sx={{
+ p: 0.5,
+ borderBottom: "1px solid",
+ borderColor: theme.palette.divider,
+ display: "flex",
+ gap: 1,
+ alignItems: "center",
+ flexWrap: "wrap",
+ }}
+ >
+ <span
+ style={{
+ color: theme.palette.text.primary,
+ fontSize: "0.9em",
+ fontWeight: "bold",
+ }}
+ >
+ Server Logs
+ </span>
+
+ {hasErrors && (
+ <Tooltip title="Errors detected">
+ <WarningIcon
+ sx={{
+ color: LOG_COLORS.ERROR,
+ fontSize: "1.2em",
+ animation: "pulse 2s infinite",
+ "@keyframes pulse": {
+ "0%, 100%": { opacity: 1 },
+ "50%": { opacity: 0.5 },
+ },
+ }}
+ />
+ </Tooltip>
+ )}
+
+ <ToggleButtonGroup
+ size="small"
+ value={selectedLevels}
+ onChange={handleLevelToggle}
+ sx={{
+ ".MuiToggleButtonGroup-grouped": {
+ border: `1px solid ${theme.palette.divider} !important`,
+ mx: "1px",
+ "&:not(:first-of-type)": {
+ borderRadius: "2px",
+ },
+ "&:first-of-type": {
+ borderRadius: "2px",
+ },
+ },
+ }}
+ >
+ {Object.entries(LOG_COLORS).map(([level, color]) => {
+ const count = logCounts[level] || 0;
+ return (
+ <ToggleButton
+ key={level}
+ value={level.toLowerCase()}
+ sx={{
+ py: 0.25,
+ px: 1,
+ minWidth: 0,
+ fontSize: "0.75em",
+ position: "relative",
+ color: alpha(color, 0.7),
+ "&.Mui-selected": {
+ backgroundColor: alpha(color, 0.15),
+ color: color,
+ "&:hover": {
+ backgroundColor: alpha(color, 0.2),
+ },
+ },
+ "&:hover": {
+ backgroundColor: alpha(color, 0.1),
+ },
+ }}
+ >
+ {level}
+ {count > 0 && (
+ <span
+ style={{
+ marginLeft: "4px",
+ fontSize: "0.8em",
+ opacity: 0.7,
+ }}
+ >
+ ({count})
+ </span>
+ )}
+ </ToggleButton>
+ );
+ })}
+ </ToggleButtonGroup>
+
+ <Box sx={{ ml: "auto", display: "flex", gap: 0.5 }}>
+ <IconButton
+ size="small"
+ onClick={() => setShowSearch(!showSearch)}
+ sx={{ color: theme.palette.text.secondary }}
+ >
+ <SearchIcon fontSize="small" />
+ </IconButton>
+
+ <IconButton
+ size="small"
+ onClick={handlePauseToggle}
+ sx={{
+ color: isPaused ? theme.palette.warning.main : theme.palette.text.secondary
+ }}
+ >
+ {isPaused ? <PlayArrowIcon fontSize="small" /> : <PauseIcon fontSize="small" />}
+ </IconButton>
+
+ <IconButton
+ size="small"
+ onClick={handleClear}
+ sx={{ color: theme.palette.text.secondary }}
+ >
+ <DeleteIcon fontSize="small" />
+ </IconButton>
+ </Box>
+ </Box>
+
+ {showSearch && (
+ <Box sx={{ p: 1, borderBottom: "1px solid", borderColor: theme.palette.divider }}>
+ <TextField
+ size="small"
+ fullWidth
+ placeholder="Search logs..."
+ value={searchText}
+ onChange={(e) => setSearchText(e.target.value)}
+ InputProps={{
+ startAdornment: <SearchIcon sx={{ mr: 1, color: "text.secondary" }} />,
+ }}
+ />
+ </Box>
+ )}
+
+ <Box
+ sx={{
+ flex: 1,
+ overflowY: "auto",
+ p: 1,
+ "&::-webkit-scrollbar": {
+ width: "8px",
+ backgroundColor: "transparent",
+ },
+ "&::-webkit-scrollbar-thumb": {
+ backgroundColor:
+ theme.palette.mode === "dark"
+ ? "rgba(255, 255, 255, 0.2)"
+ : "rgba(0, 0, 0, 0.2)",
+ borderRadius: "4px",
+ "&:hover": {
+ backgroundColor:
+ theme.palette.mode === "dark"
+ ? "rgba(255, 255, 255, 0.3)"
+ : "rgba(0, 0, 0, 0.3)",
+ },
+ },
+ "&::-webkit-scrollbar-track": {
+ backgroundColor: "transparent",
+ },
+ // For Firefox
+ scrollbarWidth: "thin",
+ scrollbarColor:
+ theme.palette.mode === "dark"
+ ? "rgba(255, 255, 255, 0.2) transparent"
+ : "rgba(0, 0, 0, 0.2) transparent",
+ }}
+ onScroll={handleScroll}
+ >
+ {logs.length === 0 ? (
+ <Box
+ sx={{
+ display: "flex",
+ justifyContent: "center",
+ alignItems: "center",
+ height: "100%",
+ color: theme.palette.text.disabled,
+ }}
+ >
+ {isPaused ? "Logging paused" : "No logs to display"}
+ </Box>
+ ) : (
+ <>
+ {logs.map((log, i) => (
+ <LogEntryComponent key={`${log.created}-${log.thread}-${i}`} log={log} />
+ ))}
+ <div ref={logEndRef} />
+ </>
+ )}
+ </Box>
+ </Box>
+ );
+};
diff --git a/freemocap-ui-old/src/components/MenuNavigationListener.tsx b/freemocap-ui-old/src/components/MenuNavigationListener.tsx
new file mode 100644
index 00000000..ac7e41ee
--- /dev/null
+++ b/freemocap-ui-old/src/components/MenuNavigationListener.tsx
@@ -0,0 +1,26 @@
+import React, { useEffect } from 'react';
+import { useNavigate } from 'react-router-dom';
+
+/**
+ * Invisible component that listens for navigation events from the
+ * native Electron menu (via the 'navigate' IPC channel) and forwards
+ * them to react-router.
+ *
+ * Must be rendered inside a Router.
+ */
+export const MenuNavigationListener: React.FC = () => {
+ const navigate = useNavigate();
+
+ useEffect(() => {
+ const electronAPI = (window as any).electronAPI;
+ if (!electronAPI?.onNavigate) return;
+
+ const cleanup = electronAPI.onNavigate((route: string) => {
+ navigate(route);
+ });
+
+ return cleanup;
+ }, [navigate]);
+
+ return null;
+};
diff --git a/freemocap-ui-old/src/components/PauseUnpauseButton.tsx b/freemocap-ui-old/src/components/PauseUnpauseButton.tsx
new file mode 100644
index 00000000..f3e80222
--- /dev/null
+++ b/freemocap-ui-old/src/components/PauseUnpauseButton.tsx
@@ -0,0 +1,72 @@
+// freemocap-ui/src/components/PauseUnpauseButton.tsx
+import React, {useState} from 'react';
+import {Button, CircularProgress, keyframes, Tooltip} from '@mui/material';
+import {styled} from '@mui/system';
+import PlayArrowIcon from '@mui/icons-material/PlayArrow';
+import PauseIcon from '@mui/icons-material/Pause';
+import {pauseUnpauseThunk} from "@/store/slices/cameras/old-camera-thunks/pause-unpause-thunk";
+
+interface PauseUnpauseButtonProps {
+ disabled?: boolean;
+}
+
+const pulseAnimation = keyframes`
+ 0% {
+ background-color: rgba(25, 118, 210, 0.8);
+ }
+ 50% {
+ background-color: rgba(25, 118, 210, 1);
+ }
+ 100% {
+ background-color: rgba(25, 118, 210, 0.8);
+ }
+`;
+
+const PulsingButton = styled(Button)<{ pulsing?: boolean }>(({pulsing}) => ({
+ // backgroundColor: '#1976d2', // MUI primary blue
+ borderRadius: '80px',
+ padding: '16px',
+ '&:hover': {
+ backgroundColor: '#1565c0', // Darker blue on hover
+ },
+ ...(pulsing && {
+ animation: `${pulseAnimation} 1.5s infinite ease-in-out`,
+ }),
+
+}));
+
+export const PauseUnpauseButton: React.FC<PauseUnpauseButtonProps> = ({
+ disabled = false
+ }) => {
+ const [isPaused, setIsPaused] = useState(false);
+ const [isLoading, setIsLoading] = useState(false);
+
+
+ const handleClick = async () => {
+ setIsLoading(true);
+
+ try {
+ await pauseUnpauseThunk();
+ // Toggle the paused state after successful API call
+ setIsPaused(prev => !prev);
+ } catch (error) {
+ console.error('Failed to pause/unpause cameras:', error);
+ } finally {
+ setIsLoading(false);
+ }
+ };
+
+ return (
+ <Tooltip title={isPaused ? "Unpause all cameras" : "Pause all cameras"} >
+ <PulsingButton
+ onClick={handleClick}
+ variant="contained"
+ pulsing={isPaused ? true : undefined}
+ fullWidth
+ disabled={disabled || isLoading}
+ startIcon={isLoading ? <CircularProgress/> : isPaused ? <PlayArrowIcon/> : <PauseIcon/>}
+ >
+ </PulsingButton>
+ </Tooltip>
+ );
+};
diff --git a/freemocap-ui-old/src/components/ServerConnectionStatus.tsx b/freemocap-ui-old/src/components/ServerConnectionStatus.tsx
new file mode 100644
index 00000000..2da18b11
--- /dev/null
+++ b/freemocap-ui-old/src/components/ServerConnectionStatus.tsx
@@ -0,0 +1,112 @@
+import React from "react";
+import {Box, Chip, Tooltip, useTheme} from "@mui/material";
+import WifiIcon from "@mui/icons-material/Wifi";
+import WifiOffIcon from "@mui/icons-material/WifiOff";
+import CheckIcon from "@mui/icons-material/Check";
+import {CollapsibleSidebarSection} from "@/components/common/CollapsibleSidebarSection";
+import {useServer} from "@/hooks/useServer";
+
+export const ServerConnectionStatus: React.FC = () => {
+ const theme = useTheme();
+ const {isConnected, connect, disconnect, connectedCameraIds} = useServer();
+
+ const handleToggle = (e: React.MouseEvent): void => {
+ e.stopPropagation();
+ if (isConnected) {
+ disconnect();
+ } else {
+ connect();
+ }
+ };
+
+ // Original cyan/red color mapping
+ const colors = isConnected
+ ? {
+ bg: "rgba(0, 255, 255, 0.1)",
+ border: "rgba(0, 255, 255, 0.5)",
+ text: "#00ffff",
+ hoverBg: "rgba(0, 255, 255, 0.2)",
+ }
+ : {
+ bg: "rgba(255, 0, 0, 0.1)",
+ border: "rgba(255, 0, 0, 0.5)",
+ text: "#f44336",
+ hoverBg: "rgba(255, 0, 0, 0.2)",
+ };
+
+ return (
+ <CollapsibleSidebarSection
+ icon={
+ isConnected ? (
+ <WifiIcon sx={{color: "inherit"}} />
+ ) : (
+ <WifiOffIcon sx={{color: "inherit"}} />
+ )
+ }
+ title="WebSocket"
+ summaryContent={
+ isConnected && connectedCameraIds.length > 0 ? (
+ <Chip
+ label={`${connectedCameraIds.length} cam${connectedCameraIds.length !== 1 ? "s" : ""}`}
+ size="small"
+ variant="outlined"
+ sx={{
+ height: 18,
+ fontSize: 10,
+ borderColor: "rgba(255,255,255,0.4)",
+ color: "inherit",
+ }}
+ />
+ ) : null
+ }
+ primaryControl={
+ <Tooltip title={isConnected ? "Click to disconnect" : "Click to connect"}>
+ <Box
+ onClick={handleToggle}
+ sx={{
+ display: "flex",
+ alignItems: "center",
+ gap: 0.75,
+ cursor: "pointer",
+ borderRadius: 1,
+ border: `2px solid ${colors.border}`,
+ backgroundColor: colors.bg,
+ px: 2,
+ py: 0.5,
+ transition: "all 0.2s ease",
+ "&:hover": {
+ backgroundColor: colors.hoverBg,
+ transform: "translateY(-1px)",
+ boxShadow: `0 2px 8px ${colors.border}`,
+ },
+ }}
+ >
+ {isConnected ? (
+ <CheckIcon sx={{fontSize: 18, color: colors.text}} />
+ ) : null}
+ <Box
+ component="span"
+ sx={{
+ fontSize: 14,
+ fontWeight: 700,
+ lineHeight: 1,
+ color: colors.text,
+ whiteSpace: "nowrap",
+ }}
+ >
+ {isConnected ? "Connected" : "Connect"}
+ </Box>
+ </Box>
+ </Tooltip>
+ }
+ defaultExpanded={false}
+ >
+ {/* Future: server address, port, reconnect behavior settings */}
+ <Box sx={{p: 2, color: theme.palette.text.secondary, fontSize: 14}}>
+ {isConnected
+ ? "WebSocket connection active. Click the button to disconnect."
+ : "No active connection. Click the button to connect."}
+ </Box>
+ </CollapsibleSidebarSection>
+ );
+};
diff --git a/freemocap-ui-old/src/components/calibration-control-panel/CalibrationControlPanel.tsx b/freemocap-ui-old/src/components/calibration-control-panel/CalibrationControlPanel.tsx
new file mode 100644
index 00000000..dc296868
--- /dev/null
+++ b/freemocap-ui-old/src/components/calibration-control-panel/CalibrationControlPanel.tsx
@@ -0,0 +1,624 @@
+import React, {useCallback, useEffect, useMemo, useState} from "react";
+import {
+ Alert,
+ Box,
+ Button,
+ Checkbox,
+ Chip,
+ FormControl,
+ FormControlLabel,
+ IconButton,
+ InputAdornment,
+ InputLabel,
+ MenuItem,
+ Select,
+ Stack,
+ TextField,
+ Tooltip,
+ Typography,
+ useTheme,
+} from "@mui/material";
+import SquareFootIcon from "@mui/icons-material/SquareFoot";
+import PlayArrowIcon from "@mui/icons-material/PlayArrow";
+import StopIcon from "@mui/icons-material/Stop";
+import FolderOpenIcon from "@mui/icons-material/FolderOpen";
+import ClearIcon from "@mui/icons-material/Clear";
+import CheckCircleIcon from "@mui/icons-material/CheckCircle";
+import InfoIcon from "@mui/icons-material/Info";
+import CloseIcon from "@mui/icons-material/Close";
+import FiberManualRecordIcon from "@mui/icons-material/FiberManualRecord";
+import {CollapsibleSidebarSection} from "@/components/common/CollapsibleSidebarSection";
+import {useCalibration} from "@/hooks/useCalibration";
+import {useElectronIPC} from "@/services";
+import {CalibrationSolverSection} from "@/components/calibration-control-panel/CalibrationSolverSection";
+
+type BoardPreset = "5x3" | "7x5" | "custom";
+
+interface BoardPresetConfig {
+ xSquares: number;
+ ySquares: number;
+}
+
+const BOARD_PRESETS: Record<Exclude<BoardPreset, "custom">, BoardPresetConfig> = {
+ "5x3": {xSquares: 5, ySquares: 3},
+ "7x5": {xSquares: 7, ySquares: 5},
+};
+
+export const CalibrationControlPanel: React.FC = () => {
+ const theme = useTheme();
+ const [localError, setLocalError] = useState<string | null>(null);
+ const {api} = useElectronIPC();
+
+ const {
+ config,
+ error,
+ isLoading,
+ isRecording,
+ recordingProgress,
+ canStartRecording,
+ canCalibrate,
+ calibrationRecordingPath,
+ directoryInfo,
+ isUsingManualPath,
+ updateCalibrationConfig,
+ dispatchStopCalibrationRecording,
+ dispatchStartCalibrationRecording,
+ setManualRecordingPath,
+ clearManualRecordingPath,
+ validateDirectory,
+ calibrateSelectedRecording,
+ clearError,
+ } = useCalibration();
+
+ useEffect(() => {
+ if (calibrationRecordingPath) {
+ validateDirectory(calibrationRecordingPath);
+ }
+ }, [calibrationRecordingPath, validateDirectory]);
+
+ const currentPreset = useMemo<BoardPreset>(() => {
+ for (const [preset, presetConfig] of Object.entries(BOARD_PRESETS)) {
+ if (
+ presetConfig.xSquares === config.charucoBoardXSquares &&
+ presetConfig.ySquares === config.charucoBoardYSquares
+ ) {
+ return preset as BoardPreset;
+ }
+ }
+ return "custom";
+ }, [config.charucoBoardXSquares, config.charucoBoardYSquares]);
+
+ const handleClearError = useCallback((): void => {
+ clearError();
+ setLocalError(null);
+ }, [clearError]);
+
+ const handlePresetChange = useCallback(
+ (preset: BoardPreset): void => {
+ if (preset === "custom") return;
+ const presetConfig = BOARD_PRESETS[preset];
+ updateCalibrationConfig({
+ charucoBoardXSquares: presetConfig.xSquares,
+ charucoBoardYSquares: presetConfig.ySquares,
+ });
+ },
+ [updateCalibrationConfig]
+ );
+
+ const handleXSquaresChange = useCallback(
+ (value: string): void => {
+ const numValue = parseInt(value, 10);
+ if (!isNaN(numValue) && numValue > 0) {
+ updateCalibrationConfig({charucoBoardXSquares: numValue});
+ }
+ },
+ [updateCalibrationConfig]
+ );
+
+ const handleYSquaresChange = useCallback(
+ (value: string): void => {
+ const numValue = parseInt(value, 10);
+ if (!isNaN(numValue) && numValue > 0) {
+ updateCalibrationConfig({charucoBoardYSquares: numValue});
+ }
+ },
+ [updateCalibrationConfig]
+ );
+
+ const handleSelectDirectory = async (): Promise<void> => {
+ if (!api) {
+ console.warn("Electron API not available");
+ return;
+ }
+ try {
+ const result: string | null = await api.fileSystem.selectDirectory.mutate();
+ if (result) {
+ await setManualRecordingPath(result);
+ }
+ } catch (err) {
+ console.error("Failed to select directory:", err);
+ setLocalError("Failed to select directory");
+ }
+ };
+
+ const handlePathInputChange = async (
+ e: React.ChangeEvent<HTMLInputElement>
+ ): Promise<void> => {
+ const newPath: string = e.target.value;
+ if (newPath.includes("~") && api) {
+ try {
+ const home: string = await api.fileSystem.getHomeDirectory.query();
+ const expanded: string = newPath.replace(
+ /^~([/\\])?/,
+ home ? `${home}$1` : ""
+ );
+ await setManualRecordingPath(expanded);
+ } catch (err) {
+ console.error("Failed to expand home directory:", err);
+ await setManualRecordingPath(newPath);
+ }
+ } else {
+ await setManualRecordingPath(newPath);
+ }
+ };
+
+ const handleClearManualPath = useCallback((): void => {
+ clearManualRecordingPath();
+ }, [clearManualRecordingPath]);
+
+ const displayError = error || localError || directoryInfo?.errorMessage;
+
+ const pathHelperText = useMemo(() => {
+ if (isUsingManualPath) return "Using custom path";
+ return "Using default recording directory";
+ }, [isUsingManualPath]);
+
+ // Derive status for collapsed summary
+ const statusLabel = isRecording
+ ? `Recording ${recordingProgress.toFixed(0)}%`
+ : isLoading
+ ? "Processing..."
+ : directoryInfo?.cameraCalibrationTomlPath
+ ? "Calibrated"
+ : "Idle";
+
+ const statusColor = isRecording
+ ? theme.palette.error.main
+ : isLoading
+ ? theme.palette.warning.main
+ : directoryInfo?.cameraCalibrationTomlPath
+ ? theme.palette.success.main
+ : theme.palette.grey[600];
+
+ // Primary control: compact start/stop recording toggle in the header
+ const headerRecordButton = isRecording ? (
+ <Tooltip title="Stop calibration recording">
+ <IconButton
+ size="small"
+ onClick={(e: React.MouseEvent) => {
+ e.stopPropagation();
+ dispatchStopCalibrationRecording();
+ }}
+ disabled={isLoading}
+ sx={{
+ color: theme.palette.error.light,
+ border: `1.5px solid ${theme.palette.error.light}`,
+ borderRadius: 1,
+ p: 0.5,
+ "&:hover": {backgroundColor: "rgba(244,67,54,0.15)"},
+ }}
+ >
+ <StopIcon fontSize="small" />
+ </IconButton>
+ </Tooltip>
+ ) : (
+ <Tooltip title={canStartRecording ? "Start calibration recording" : "Cannot record yet"}>
+ <span>
+ <IconButton
+ size="small"
+ onClick={(e: React.MouseEvent) => {
+ e.stopPropagation();
+ dispatchStartCalibrationRecording();
+ }}
+ disabled={!canStartRecording || isLoading}
+ sx={{
+ color: "inherit",
+ border: "1.5px solid rgba(255,255,255,0.25)",
+ borderRadius: 1,
+ p: 0.5,
+ "&:hover": {backgroundColor: "rgba(255,255,255,0.1)"},
+ "&.Mui-disabled": {
+ color: "rgba(255,255,255,0.3)",
+ borderColor: "rgba(255,255,255,0.1)",
+ },
+ }}
+ >
+ <FiberManualRecordIcon fontSize="small" />
+ </IconButton>
+ </span>
+ </Tooltip>
+ );
+
+ return (
+ <CollapsibleSidebarSection
+ icon={<SquareFootIcon sx={{color: "inherit"}} />}
+ title="Calibration"
+ summaryContent={
+ <Chip
+ label={statusLabel}
+ size="small"
+ sx={{
+ height: 20,
+ fontSize: 11,
+ fontWeight: 600,
+ backgroundColor: statusColor,
+ color: theme.palette.getContrastText(statusColor),
+ }}
+ />
+ }
+ primaryControl={headerRecordButton}
+ defaultExpanded={false}
+ >
+ <Box sx={{p: 2, bgcolor: "background.paper"}}>
+ <Stack spacing={2}>
+ {/* Error Display */}
+ {displayError && (
+ <Alert severity="error" onClose={handleClearError}>
+ {displayError}
+ </Alert>
+ )}
+
+ {/* Live Tracker Toggle */}
+ <FormControlLabel
+ control={
+ <Checkbox
+ checked={config.liveTrackCharuco}
+ onChange={(e) =>
+ updateCalibrationConfig({
+ liveTrackCharuco: e.target.checked,
+ })
+ }
+ disabled={isLoading}
+ sx={{
+ "&.Mui-checked": {
+ color: theme.palette.text.primary,
+ },
+ }}
+ />
+ }
+ label="Live Track Charuco Board"
+ />
+
+ {/* Recording Controls */}
+ <Stack direction="row" spacing={2}>
+ <Button
+ variant="contained"
+ color="primary"
+ startIcon={<PlayArrowIcon />}
+ onClick={dispatchStartCalibrationRecording}
+ disabled={!canStartRecording || isLoading}
+ fullWidth
+ >
+ Start Calibration Recording
+ </Button>
+ {isRecording && (
+ <Button
+ variant="contained"
+ color="error"
+ startIcon={<StopIcon />}
+ onClick={dispatchStopCalibrationRecording}
+ disabled={isLoading}
+ fullWidth
+ >
+ Stop Recording
+ </Button>
+ )}
+ </Stack>
+
+ {/* Recording Path Input */}
+ <TextField
+ label="Calibration Recording Path"
+ value={calibrationRecordingPath}
+ onChange={handlePathInputChange}
+ fullWidth
+ size="small"
+ helperText={pathHelperText}
+ InputProps={{
+ endAdornment: (
+ <InputAdornment position="end">
+ {isUsingManualPath && (
+ <Tooltip title="Clear manual path (revert to default)">
+ <IconButton
+ onClick={handleClearManualPath}
+ edge="end"
+ size="small"
+ >
+ <ClearIcon fontSize="small" />
+ </IconButton>
+ </Tooltip>
+ )}
+ <Tooltip title="Select directory">
+ <IconButton
+ onClick={handleSelectDirectory}
+ edge="end"
+ >
+ <FolderOpenIcon />
+ </IconButton>
+ </Tooltip>
+ </InputAdornment>
+ ),
+ }}
+ />
+
+ {/* Directory Status Info */}
+ {directoryInfo && (
+ <Box
+ sx={{
+ p: 1.5,
+ borderRadius: 1,
+ border: `2px solid ${theme.palette.divider}`,
+ }}
+ >
+ <Stack spacing={1}>
+ <Box
+ sx={{
+ display: "flex",
+ alignItems: "center",
+ gap: 1,
+ }}
+ >
+ <InfoIcon fontSize="small" color="info" />
+ <Typography variant="caption" fontWeight="medium">
+ Calibration Folder Status
+ </Typography>
+ </Box>
+
+ <Box
+ sx={{
+ display: "flex",
+ gap: 1,
+ flexWrap: "wrap",
+ }}
+ >
+ <Chip
+ label={
+ directoryInfo.exists
+ ? "Directory exists"
+ : "Directory will be created"
+ }
+ size="small"
+ color={directoryInfo.exists ? "success" : "default"}
+ icon={
+ directoryInfo.exists ? (
+ <CheckCircleIcon />
+ ) : (
+ <CloseIcon />
+ )
+ }
+ variant={directoryInfo.exists ? "filled" : "outlined"}
+ sx={
+ !directoryInfo.exists
+ ? {
+ borderColor: theme.palette.grey[400],
+ "& .MuiChip-icon": {
+ color: theme.palette.grey[600],
+ },
+ }
+ : {}
+ }
+ />
+ <Chip
+ label="Has videos"
+ size="small"
+ color={directoryInfo.hasVideos ? "success" : "default"}
+ icon={
+ directoryInfo.hasVideos ? (
+ <CheckCircleIcon />
+ ) : (
+ <CloseIcon />
+ )
+ }
+ variant={directoryInfo.hasVideos ? "filled" : "outlined"}
+ sx={
+ !directoryInfo.hasVideos
+ ? {
+ borderColor: theme.palette.grey[400],
+ "& .MuiChip-icon": {
+ color: theme.palette.grey[600],
+ },
+ }
+ : {}
+ }
+ />
+ <Chip
+ label="Has synchronized_videos"
+ size="small"
+ color={
+ directoryInfo.hasSynchronizedVideos
+ ? "success"
+ : "default"
+ }
+ icon={
+ directoryInfo.hasSynchronizedVideos ? (
+ <CheckCircleIcon />
+ ) : (
+ <CloseIcon />
+ )
+ }
+ variant={
+ directoryInfo.hasSynchronizedVideos
+ ? "filled"
+ : "outlined"
+ }
+ sx={
+ !directoryInfo.hasSynchronizedVideos
+ ? {
+ borderColor: theme.palette.grey[400],
+ "& .MuiChip-icon": {
+ color: theme.palette.grey[600],
+ },
+ }
+ : {}
+ }
+ />
+ <Chip
+ label="Has calibration TOML"
+ size="small"
+ color={
+ directoryInfo.cameraCalibrationTomlPath
+ ? "success"
+ : "default"
+ }
+ icon={
+ directoryInfo.cameraCalibrationTomlPath ? (
+ <CheckCircleIcon />
+ ) : (
+ <CloseIcon />
+ )
+ }
+ variant={
+ directoryInfo.cameraCalibrationTomlPath
+ ? "filled"
+ : "outlined"
+ }
+ sx={
+ !directoryInfo.cameraCalibrationTomlPath
+ ? {
+ borderColor: theme.palette.grey[400],
+ "& .MuiChip-icon": {
+ color: theme.palette.grey[600],
+ },
+ }
+ : {}
+ }
+ />
+ </Box>
+
+ {directoryInfo.cameraCalibrationTomlPath && (
+ <Box sx={{mt: 1}}>
+ <Typography variant="caption" color="text.secondary">
+ Found calibration file:
+ </Typography>
+ <Typography
+ variant="caption"
+ sx={{
+ fontFamily: "monospace",
+ display: "block",
+ color: "success.main",
+ wordBreak: "break-all",
+ }}
+ >
+ {directoryInfo.cameraCalibrationTomlPath}
+ </Typography>
+ </Box>
+ )}
+ </Stack>
+ </Box>
+ )}
+
+ {/* Board Size Configuration */}
+ <Stack direction="row" spacing={2}>
+ <FormControl size="small" sx={{minWidth: 140}}>
+ <InputLabel id="board-preset-label">Preset</InputLabel>
+ <Select
+ labelId="board-preset-label"
+ value={currentPreset}
+ label="Preset"
+ onChange={(e) =>
+ handlePresetChange(e.target.value as BoardPreset)
+ }
+ disabled={isLoading}
+ sx={{color: theme.palette.text.primary}}
+ >
+ <MenuItem value="5x3">5×3</MenuItem>
+ <MenuItem value="7x5">7×5</MenuItem>
+ <MenuItem value="custom">Custom</MenuItem>
+ </Select>
+ </FormControl>
+ <TextField
+ label="X Squares"
+ type="number"
+ value={config.charucoBoardXSquares}
+ onChange={(e) => handleXSquaresChange(e.target.value)}
+ disabled={isLoading}
+ size="small"
+ sx={{flex: 1}}
+ inputProps={{min: 2, max: 20}}
+ />
+ <TextField
+ label="Y Squares"
+ type="number"
+ value={config.charucoBoardYSquares}
+ onChange={(e) => handleYSquaresChange(e.target.value)}
+ disabled={isLoading}
+ size="small"
+ sx={{flex: 1}}
+ inputProps={{min: 2, max: 20}}
+ />
+ </Stack>
+
+ {/* Square Length */}
+ <TextField
+ label="Square Length (mm)"
+ type="number"
+ value={config.charucoSquareLength}
+ onChange={(e) =>
+ updateCalibrationConfig({
+ charucoSquareLength: parseFloat(e.target.value) || 0,
+ })
+ }
+ disabled={isLoading}
+ size="small"
+ fullWidth
+ inputProps={{min: 1, step: 0.1}}
+ />
+
+ {/* Solver Method & Groundplane */}
+ <CalibrationSolverSection />
+
+ {/* Recording Progress */}
+ {isRecording && (
+ <Box sx={{width: "100%"}}>
+ <Typography
+ variant="caption"
+ color="text.secondary"
+ gutterBottom
+ >
+ Recording in Progress: {recordingProgress.toFixed(0)}%
+ </Typography>
+ <Box
+ sx={{
+ width: "100%",
+ height: 8,
+ bgcolor: "grey.300",
+ borderRadius: 1,
+ overflow: "hidden",
+ }}
+ >
+ <Box
+ sx={{
+ width: `${recordingProgress}%`,
+ height: "100%",
+ bgcolor: theme.palette.primary.main,
+ transition: "width 0.3s",
+ }}
+ />
+ </Box>
+ </Box>
+ )}
+
+ {/* Calibrate Button */}
+ <Button
+ variant="contained"
+ color="secondary"
+ onClick={calibrateSelectedRecording}
+ disabled={!canCalibrate || isLoading}
+ fullWidth
+ >
+ Calibrate Selected Recording
+ </Button>
+ </Stack>
+ </Box>
+ </CollapsibleSidebarSection>
+ );
+};
diff --git a/freemocap-ui-old/src/components/calibration-control-panel/CalibrationSolverSection.tsx b/freemocap-ui-old/src/components/calibration-control-panel/CalibrationSolverSection.tsx
new file mode 100644
index 00000000..4e2dee23
--- /dev/null
+++ b/freemocap-ui-old/src/components/calibration-control-panel/CalibrationSolverSection.tsx
@@ -0,0 +1,75 @@
+import React from "react";
+import {
+ FormControl,
+ FormControlLabel,
+ InputLabel,
+ MenuItem,
+ Select,
+ Stack,
+ Switch,
+ Typography,
+ useTheme,
+} from "@mui/material";
+import {useCalibration} from "@/hooks/useCalibration";
+import {CalibrationSolverMethod} from "@/store/slices/calibration";
+
+/**
+ * Calibration solver method and groundplane controls.
+ *
+ * Drop this into CalibrationControlPanel's Stack, after the
+ * square length TextField and before the recording progress section.
+ */
+export const CalibrationSolverSection: React.FC = () => {
+ const theme = useTheme();
+ const {config, updateCalibrationConfig, isLoading} = useCalibration();
+
+ return (
+ <Stack spacing={2}>
+ <Typography
+ variant="subtitle2"
+ sx={{color: theme.palette.text.secondary, fontWeight: 600}}
+ >
+ Solver Settings
+ </Typography>
+
+ {/* Solver Method */}
+ <FormControl size="small" fullWidth>
+ <InputLabel id="solver-method-label">Solver Method</InputLabel>
+ <Select
+ labelId="solver-method-label"
+ value={config.solverMethod}
+ label="Solver Method"
+ onChange={(e) =>
+ updateCalibrationConfig({
+ solverMethod: e.target.value as CalibrationSolverMethod,
+ })
+ }
+ disabled={isLoading}
+ sx={{color: theme.palette.text.primary}}
+ >
+ <MenuItem value="anipose">Anipose (legacy)</MenuItem>
+ <MenuItem value="pyceres">Pyceres (bundle adjustment)</MenuItem>
+ </Select>
+ </FormControl>
+
+ {/* Groundplane */}
+ <FormControlLabel
+ control={
+ <Switch
+ size="small"
+ checked={config.useGroundplane}
+ onChange={(_, checked) =>
+ updateCalibrationConfig({useGroundplane: checked})
+ }
+ disabled={isLoading}
+ />
+ }
+ label={
+ <Typography variant="body2">
+ Align to ground plane
+ </Typography>
+ }
+ />
+ </Stack>
+ );
+};
diff --git a/freemocap-ui-old/src/components/camera-config-tree-view/CameraConfigTreeSection.tsx b/freemocap-ui-old/src/components/camera-config-tree-view/CameraConfigTreeSection.tsx
new file mode 100644
index 00000000..20bf4c4e
--- /dev/null
+++ b/freemocap-ui-old/src/components/camera-config-tree-view/CameraConfigTreeSection.tsx
@@ -0,0 +1,38 @@
+import React from "react";
+import {TreeItem} from "@mui/x-tree-view/TreeItem";
+import {useAppDispatch} from "@/store";
+import {cameraDesiredConfigUpdated} from "@/store/slices/cameras/cameras-slice";
+import {Camera, CameraConfig} from "@/store/slices/cameras/cameras-types";
+import {CameraConfigPanel} from "@/components/camera-config-tree-view/camera-config-panel/CameraConfigPanel";
+
+interface CameraConfigTreeSectionProps {
+ camera: Camera;
+}
+
+export const CameraConfigTreeSection: React.FC<CameraConfigTreeSectionProps> = ({
+ camera,
+ }) => {
+ const dispatch = useAppDispatch();
+
+ const handleConfigChange = (newConfig: CameraConfig): void => {
+ dispatch(
+ cameraDesiredConfigUpdated({
+ cameraId: camera.id,
+ config: newConfig,
+ })
+ );
+ };
+
+ return (
+ <TreeItem
+ itemId={`camera-${camera.id}-config`}
+ label={
+ <CameraConfigPanel
+ config={camera.desiredConfig}
+ onConfigChange={handleConfigChange}
+ isExpanded={true}
+ />
+ }
+ />
+ );
+};
diff --git a/freemocap-ui-old/src/components/camera-config-tree-view/CameraConfigTreeView.tsx b/freemocap-ui-old/src/components/camera-config-tree-view/CameraConfigTreeView.tsx
new file mode 100644
index 00000000..9a6df270
--- /dev/null
+++ b/freemocap-ui-old/src/components/camera-config-tree-view/CameraConfigTreeView.tsx
@@ -0,0 +1,156 @@
+import React, {useEffect, useState} from "react";
+import {Box, Chip, Typography, useTheme} from "@mui/material";
+import {SimpleTreeView} from "@mui/x-tree-view/SimpleTreeView";
+import ExpandMore from "@mui/icons-material/ExpandMore";
+import ChevronRight from "@mui/icons-material/ChevronRight";
+import VideocamIcon from "@mui/icons-material/Videocam";
+import VideoCameraFrontIcon from "@mui/icons-material/VideoCameraFront";
+
+import {CollapsibleSidebarSection} from "@/components/common/CollapsibleSidebarSection";
+import {CameraHeaderActions} from "./CameraHeaderActions";
+import {CameraGroupTreeItem} from "./CameraGroupTreeItem";
+import {
+ Camera,
+ detectCameras,
+ selectCameras,
+ selectConnectedCameras,
+ selectIsLoading, selectSelectedCameras,
+ useAppDispatch,
+ useAppSelector,
+} from "@/store";
+import {useServer} from "@/hooks/useServer";
+
+export const CameraConfigTreeView: React.FC = () => {
+ const theme = useTheme();
+ const dispatch = useAppDispatch();
+ const {isConnected} = useServer();
+
+ const cameras = useAppSelector(selectCameras);
+ const isLoading = useAppSelector(selectIsLoading);
+ const connectedCameras = useAppSelector(selectConnectedCameras);
+ const selectedCameras = useAppSelector(selectSelectedCameras);
+
+ // Expand state for the inner camera group tree
+ const [expandedItems, setExpandedItems] = useState<string[]>([
+ "cameras-connected",
+ "cameras-available",
+ ]);
+ const [isPaused, setIsPaused] = useState<boolean>(false);
+
+ const availableCameras = cameras.filter(
+ (cam: Camera) => cam.connectionStatus !== "connected"
+ );
+ const isConnectedToCameras = connectedCameras.length > 0;
+
+ // Detect cameras on initial connection
+ useEffect(() => {
+ if (isConnected && cameras.length === 0) {
+ dispatch(detectCameras({filterVirtual: true}));
+ }
+ }, [isConnected, cameras.length, dispatch]);
+
+ const handleExpandedItemsChange = (
+ _event: React.SyntheticEvent,
+ itemIds: string[]
+ ): void => {
+ setExpandedItems(itemIds);
+ };
+
+ const handlePauseToggle = (): void => {
+ setIsPaused(!isPaused);
+ };
+
+ // Build summary content: camera count chips
+ const summaryChips = (
+ <Box sx={{display: "flex", gap: 0.5, alignItems: "center"}}>
+ {connectedCameras.length > 0 && (
+ <Chip
+ label={`${connectedCameras.length} connected`}
+ size="small"
+ sx={{
+ height: 18,
+ fontSize: 10,
+ fontWeight: 600,
+ backgroundColor: theme.palette.success.main,
+ color: theme.palette.getContrastText(theme.palette.success.main),
+ }}
+ />
+ )}
+ {cameras.length > 0 && connectedCameras.length === 0 && (
+ <Chip
+ label={`${cameras.length} detected`}
+ size="small"
+ variant="outlined"
+ sx={{
+ height: 18,
+ fontSize: 10,
+ borderColor: "rgba(255,255,255,0.4)",
+ color: "inherit",
+ }}
+ />
+ )}
+ </Box>
+ );
+
+ return (
+ <CollapsibleSidebarSection
+ icon={<VideocamIcon sx={{color: "inherit"}} />}
+ title="Cameras"
+ summaryContent={summaryChips}
+ primaryControl={
+ <CameraHeaderActions
+ isLoading={isLoading}
+ isPaused={isPaused}
+ onPauseToggle={handlePauseToggle}
+ />
+ }
+ defaultExpanded={true}
+ >
+ {cameras.length === 0 ? (
+ <Box sx={{p: 3, textAlign: "center"}}>
+ <Typography variant="body2" color="text.secondary">
+ No cameras detected
+ </Typography>
+ <Typography
+ variant="caption"
+ color="text.disabled"
+ sx={{mt: 1, display: "block"}}
+ >
+ Click refresh to scan for available cameras
+ </Typography>
+ </Box>
+ ) : (
+ <SimpleTreeView
+ expandedItems={expandedItems}
+ onExpandedItemsChange={handleExpandedItemsChange}
+ slots={{
+ collapseIcon: ExpandMore,
+ expandIcon: ChevronRight,
+ }}
+ >
+ {/* Connected Cameras Group */}
+ {isConnectedToCameras && connectedCameras.length > 0 && (
+ <CameraGroupTreeItem
+ groupId="cameras-connected"
+ title="Connected Cameras"
+ cameras={connectedCameras}
+ icon={<VideoCameraFrontIcon color="success" />}
+ expandedItems={expandedItems}
+ />
+ )}
+
+ {/* Available Cameras Group */}
+ {availableCameras.length > 0 && (
+ <CameraGroupTreeItem
+ groupId="cameras-available"
+ title="Available Cameras"
+ cameras={availableCameras}
+ icon={<VideoCameraFrontIcon color="info" />}
+ expandedItems={expandedItems}
+ />
+ )}
+ </SimpleTreeView>
+ )}
+ </CollapsibleSidebarSection>
+ );
+};
diff --git a/freemocap-ui-old/src/components/camera-config-tree-view/CameraConfigTreeViewHeader.tsx b/freemocap-ui-old/src/components/camera-config-tree-view/CameraConfigTreeViewHeader.tsx
new file mode 100644
index 00000000..4adf61d9
--- /dev/null
+++ b/freemocap-ui-old/src/components/camera-config-tree-view/CameraConfigTreeViewHeader.tsx
@@ -0,0 +1,182 @@
+import React from "react";
+import {Box, CircularProgress, IconButton, Stack, Tooltip, Typography, useTheme} from "@mui/material";
+import VideocamIcon from "@mui/icons-material/Videocam";
+import VideocamOffIcon from "@mui/icons-material/VideocamOff";
+import PauseIcon from "@mui/icons-material/Pause";
+import PlayArrowIcon from "@mui/icons-material/PlayArrow";
+import YoutubeSearchedForIcon from "@mui/icons-material/YoutubeSearchedFor";
+
+import {camerasConnectOrUpdate, closeCameras, pauseUnpauseCameras, useAppDispatch, useAppSelector} from "@/store";
+import {selectSelectedCameras} from "@/store/slices/cameras/cameras-selectors";
+import {detectCameras,} from "@/store/slices/cameras/cameras-thunks";
+
+
+interface CameraConfigTreeViewHeaderProps {
+ cameraCount: number;
+ isLoading: boolean;
+ isPaused: boolean;
+ onPauseToggle: () => void;
+ hasSelectedCameras: boolean;
+}
+
+export const CameraConfigTreeViewHeader: React.FC<CameraConfigTreeViewHeaderProps> = ({
+ cameraCount,
+ isLoading,
+ isPaused,
+ onPauseToggle,
+}) => {
+ const theme = useTheme();
+ const dispatch = useAppDispatch();
+ const selectedCameras = useAppSelector(selectSelectedCameras);
+ const hasSelected = selectedCameras.length > 0;
+
+ const [isActionInProgress, setIsActionInProgress] = React.useState(false);
+
+ const handleRefreshCameras = async (e: React.MouseEvent): Promise<void> => {
+ e.stopPropagation();
+
+ setIsActionInProgress(true);
+ try {
+ await dispatch(detectCameras({filterVirtual: true})).unwrap();
+ } catch (error) {
+ console.error('Error detecting cameras:', error);
+ } finally {
+ setIsActionInProgress(false);
+ }
+ };
+
+ const handleConnectOrApply = async (e: React.MouseEvent): Promise<void> => {
+ e.stopPropagation();
+
+ setIsActionInProgress(true);
+ try {
+ await dispatch(camerasConnectOrUpdate()).unwrap();
+ } catch (error) {
+ console.error('Error with camera operation:', error);
+ } finally {
+ setIsActionInProgress(false);
+ }
+ };
+
+ const handleCloseCameras = async (e: React.MouseEvent): Promise<void> => {
+ e.stopPropagation();
+
+ setIsActionInProgress(true);
+ try {
+ await dispatch(closeCameras()).unwrap();
+ console.log('Closed all cameras');
+ } catch (error) {
+ console.error('Error closing cameras:', error);
+ } finally {
+ setIsActionInProgress(false);
+ }
+ };
+
+ const handlePauseUnpause = async (e: React.MouseEvent): Promise<void> => {
+ e.stopPropagation();
+
+ setIsActionInProgress(true);
+ try {
+ await dispatch(pauseUnpauseCameras()).unwrap();
+ onPauseToggle();
+ } catch (error) {
+ console.error('Error pausing/unpausing cameras:', error);
+ } finally {
+ setIsActionInProgress(false);
+ }
+ };
+
+ const handleHeaderClick = (e: React.MouseEvent): void => {
+ e.stopPropagation();
+ };
+
+ return (
+ <Box
+ onClick={handleHeaderClick}
+ sx={{
+ display: "flex",
+ alignItems: "center",
+ py: 1,
+ backgroundColor: theme.palette.primary.main,
+ color: theme.palette.primary.contrastText,
+ }}
+ >
+ <VideocamIcon sx={{ml: 2, mr: 1}} />
+ <Typography variant="h6" sx={{flexGrow: 1}}>
+ Cameras ({cameraCount})
+ </Typography>
+
+ <Stack direction="row" spacing={1} sx={{mr: 2}}>
+ {/* Connect/Apply Button */}
+ <Tooltip title={"Connect to selected cameras or update connected cameras"}>
+ <span>
+ <IconButton
+ size="small"
+ onClick={handleConnectOrApply}
+ sx={{color: "inherit"}}
+ >
+
+ <VideocamIcon
+ sx={{
+ color: theme.palette.secondary.main,
+ border: `2px solid ${theme.palette.secondary.main}`,
+ borderRadius: '4px',
+ padding: '2px',
+ scale: '1.6'
+ }}
+ />
+
+ </IconButton>
+ </span>
+ </Tooltip>
+
+ {/* Pause/Play Button - Always visible, disabled when not connected */}
+ <Tooltip title={isPaused ? "Resume streaming" : "Pause streaming"}>
+ <span>
+ <IconButton
+ size="small"
+ onClick={handlePauseUnpause}
+ sx={{
+ color: "inherit",
+ }}
+ >
+ {isPaused ? <PlayArrowIcon /> : <PauseIcon />}
+ </IconButton>
+ </span>
+ </Tooltip>
+
+ {/* Close Button - Always visible, disabled when not connected */}
+ <Tooltip title={"Close all cameras"}>
+ <span>
+ <IconButton
+ size="small"
+ onClick={handleCloseCameras}
+ sx={{
+ color: "inherit",
+ }}
+ >
+ <VideocamOffIcon />
+ </IconButton>
+ </span>
+ </Tooltip>
+
+ {/* Refresh/Detect Button - Always visible */}
+ <Tooltip title="Detect available cameras">
+ <span>
+ <IconButton
+ size="small"
+ onClick={handleRefreshCameras}
+ sx={{color: "inherit"}}
+ >
+ {isLoading || isActionInProgress ? (
+ <CircularProgress size={20} sx={{color: "inherit"}} />
+ ) : (
+ <YoutubeSearchedForIcon />
+ )}
+ </IconButton>
+ </span>
+ </Tooltip>
+ </Stack>
+ </Box>
+ );
+};
diff --git a/freemocap-ui-old/src/components/camera-config-tree-view/CameraGroupTreeItem.tsx b/freemocap-ui-old/src/components/camera-config-tree-view/CameraGroupTreeItem.tsx
new file mode 100644
index 00000000..fc5e7767
--- /dev/null
+++ b/freemocap-ui-old/src/components/camera-config-tree-view/CameraGroupTreeItem.tsx
@@ -0,0 +1,43 @@
+import React from "react";
+import {Box, Typography} from "@mui/material";
+import {TreeItem} from "@mui/x-tree-view/TreeItem";
+import {CameraTreeItem} from "./CameraTreeItem";
+import {Camera} from "@/store/slices/cameras/cameras-types";
+
+interface CameraGroupTreeItemProps {
+ groupId: string;
+ title: string;
+ cameras: Camera[];
+ icon?: React.ReactNode;
+ expandedItems?: string[];
+}
+
+export const CameraGroupTreeItem: React.FC<CameraGroupTreeItemProps> = ({
+ groupId,
+ title,
+ cameras,
+ icon,
+ expandedItems,
+ }) => {
+ return (
+ <TreeItem
+ itemId={groupId}
+ label={
+ <Box sx={{ display: "flex", alignItems: "center" }}>
+ {icon}
+ <Typography variant="subtitle2" sx={{ ml: 1 }}>
+ {title} ({cameras.length})
+ </Typography>
+ </Box>
+ }
+ >
+ {cameras.map((camera: Camera) => (
+ <CameraTreeItem
+ key={camera.id}
+ camera={camera}
+ isExpanded={expandedItems?.includes(`camera-${camera.id}`)}
+ />
+ ))}
+ </TreeItem>
+ );
+};
diff --git a/freemocap-ui-old/src/components/camera-config-tree-view/CameraHeaderActions.tsx b/freemocap-ui-old/src/components/camera-config-tree-view/CameraHeaderActions.tsx
new file mode 100644
index 00000000..0cfc4016
--- /dev/null
+++ b/freemocap-ui-old/src/components/camera-config-tree-view/CameraHeaderActions.tsx
@@ -0,0 +1,154 @@
+import React, {useState} from "react";
+import {CircularProgress, IconButton, Stack, Tooltip} from "@mui/material";
+import VideocamIcon from "@mui/icons-material/Videocam";
+import VideocamOffIcon from "@mui/icons-material/VideocamOff";
+import PauseIcon from "@mui/icons-material/Pause";
+import PlayArrowIcon from "@mui/icons-material/PlayArrow";
+import YoutubeSearchedForIcon from "@mui/icons-material/YoutubeSearchedFor";
+import {
+ camerasConnectOrUpdate,
+ closeCameras,
+ pauseUnpauseCameras,
+ useAppDispatch,
+ useAppSelector,
+} from "@/store";
+import {selectSelectedCameras} from "@/store/slices/cameras/cameras-selectors";
+import {detectCameras} from "@/store/slices/cameras/cameras-thunks";
+
+interface CameraHeaderActionsProps {
+ isLoading: boolean;
+ isPaused: boolean;
+ onPauseToggle: () => void;
+}
+
+export const CameraHeaderActions: React.FC<CameraHeaderActionsProps> = ({
+ isLoading,
+ isPaused,
+ onPauseToggle,
+}) => {
+ const dispatch = useAppDispatch();
+ const selectedCameras = useAppSelector(selectSelectedCameras);
+ const hasSelected = selectedCameras.length > 0;
+ const [isActionInProgress, setIsActionInProgress] = useState(false);
+
+ const handleRefreshCameras = async (e: React.MouseEvent): Promise<void> => {
+ e.stopPropagation();
+ setIsActionInProgress(true);
+ try {
+ await dispatch(detectCameras({filterVirtual: true})).unwrap();
+ } catch (error) {
+ console.error("Error detecting cameras:", error);
+ } finally {
+ setIsActionInProgress(false);
+ }
+ };
+
+ const handleConnectOrApply = async (e: React.MouseEvent): Promise<void> => {
+ e.stopPropagation();
+ setIsActionInProgress(true);
+ try {
+ await dispatch(camerasConnectOrUpdate()).unwrap();
+ } catch (error) {
+ console.error("Error with camera operation:", error);
+ } finally {
+ setIsActionInProgress(false);
+ }
+ };
+
+ const handleCloseCameras = async (e: React.MouseEvent): Promise<void> => {
+ e.stopPropagation();
+ setIsActionInProgress(true);
+ try {
+ await dispatch(closeCameras()).unwrap();
+ } catch (error) {
+ console.error("Error closing cameras:", error);
+ } finally {
+ setIsActionInProgress(false);
+ }
+ };
+
+ const handlePauseUnpause = async (e: React.MouseEvent): Promise<void> => {
+ e.stopPropagation();
+ setIsActionInProgress(true);
+ try {
+ await dispatch(pauseUnpauseCameras()).unwrap();
+ onPauseToggle();
+ } catch (error) {
+ console.error("Error pausing/unpausing cameras:", error);
+ } finally {
+ setIsActionInProgress(false);
+ }
+ };
+
+ const iconButtonSx = {
+ color: "inherit",
+ "&:hover": {
+ backgroundColor: "rgba(255,255,255,0.1)",
+ },
+ };
+
+ return (
+ <Stack direction="row" spacing={0.5}>
+ {/* Connect/Apply */}
+ <Tooltip title="Connect selected cameras or apply config updates">
+ <span>
+ <IconButton
+ size="small"
+ onClick={handleConnectOrApply}
+ disabled={!hasSelected}
+ sx={iconButtonSx}
+ >
+ <VideocamIcon fontSize="small" />
+ </IconButton>
+ </span>
+ </Tooltip>
+
+ {/* Pause/Resume */}
+ <Tooltip title={isPaused ? "Resume streaming" : "Pause streaming"}>
+ <span>
+ <IconButton
+ size="small"
+ onClick={handlePauseUnpause}
+ sx={iconButtonSx}
+ >
+ {isPaused ? (
+ <PlayArrowIcon fontSize="small" />
+ ) : (
+ <PauseIcon fontSize="small" />
+ )}
+ </IconButton>
+ </span>
+ </Tooltip>
+
+ {/* Close All */}
+ <Tooltip title="Close all cameras">
+ <span>
+ <IconButton
+ size="small"
+ onClick={handleCloseCameras}
+ sx={iconButtonSx}
+ >
+ <VideocamOffIcon fontSize="small" />
+ </IconButton>
+ </span>
+ </Tooltip>
+
+ {/* Detect/Refresh */}
+ <Tooltip title="Detect available cameras">
+ <span>
+ <IconButton
+ size="small"
+ onClick={handleRefreshCameras}
+ sx={iconButtonSx}
+ >
+ {isLoading || isActionInProgress ? (
+ <CircularProgress size={18} sx={{color: "inherit"}} />
+ ) : (
+ <YoutubeSearchedForIcon fontSize="small" />
+ )}
+ </IconButton>
+ </span>
+ </Tooltip>
+ </Stack>
+ );
+};
diff --git a/freemocap-ui-old/src/components/camera-config-tree-view/CameraTreeItem.tsx b/freemocap-ui-old/src/components/camera-config-tree-view/CameraTreeItem.tsx
new file mode 100644
index 00000000..c4ba8949
--- /dev/null
+++ b/freemocap-ui-old/src/components/camera-config-tree-view/CameraTreeItem.tsx
@@ -0,0 +1,202 @@
+import React from "react";
+import {Box, Chip, IconButton, Typography, useTheme} from "@mui/material";
+import {TreeItem} from "@mui/x-tree-view/TreeItem";
+import CheckCircleIcon from "@mui/icons-material/CheckCircle";
+import RadioButtonUncheckedIcon from "@mui/icons-material/RadioButtonUnchecked";
+import VideocamIcon from "@mui/icons-material/Videocam";
+import SettingsIcon from "@mui/icons-material/Settings";
+
+import {CameraConfigTreeSection} from "./CameraConfigTreeSection";
+import {ROTATION_DEGREE_LABELS, RotationValue, useAppDispatch} from "@/store";
+import {cameraSelectionToggled} from "@/store/slices/cameras/cameras-slice";
+import {Camera} from "@/store/slices/cameras/cameras-types";
+
+interface CameraTreeItemProps {
+ camera: Camera;
+ isExpanded?: boolean;
+}
+
+// Helper function to format config summary
+const getConfigSummary = (config: any): string[] => {
+ const summary: string[] = [];
+
+ if (!config) return summary;
+
+ // Add resolution if available
+ if (config.resolution?.width && config.resolution?.height) {
+ summary.push(`${config.resolution.width}×${config.resolution.height}`);
+ }
+
+ if (config.framerate) {
+ summary.push(`${parseFloat(config.framerate).toFixed(2)}fps`);
+ }
+
+ // Add exposure if available and not AUTO
+ if (config.exposure !== undefined && config.exposure_mode === 'MANUAL') {
+ summary.push(`E:${config.exposure}`);
+ }
+
+ // Add pixel format if available and not default
+ if (config.pixel_format && config.pixel_format !== 'RGB') {
+ summary.push(config.pixel_format);
+ }
+
+ if (config.rotation) {
+ summary.push(ROTATION_DEGREE_LABELS[config.rotation as RotationValue]);
+ }
+ // Add capture format if different from default
+ if (config.capture_fourcc) {
+ summary.push(config.capture_fourcc);
+ }
+
+ return summary.filter(item => item); // Remove empty strings
+};
+
+export const CameraTreeItem: React.FC<CameraTreeItemProps> = ({camera, isExpanded = false}) => {
+ const dispatch = useAppDispatch();
+ const theme = useTheme();
+
+ const handleToggleSelection = (e: React.MouseEvent): void => {
+ e.stopPropagation();
+ dispatch(cameraSelectionToggled(camera.id));
+ };
+
+ const getStatusColor = (): string => {
+ switch (camera.connectionStatus) {
+ case "connected":
+ return theme.palette.success.main;
+ case "available":
+ return theme.palette.info.main;
+ case "error":
+ return theme.palette.error.main;
+ default:
+ return theme.palette.grey[500];
+ }
+ };
+
+ const configSummary = getConfigSummary(camera.desiredConfig);
+ const showConfigSummary = !isExpanded && configSummary.length > 0;
+
+ return (
+ <TreeItem
+ itemId={`camera-${camera.id}`}
+ label={
+ <Box
+ sx={{
+ display: "flex",
+ alignItems: "center",
+ py: 0.2,
+ pr: 1,
+ minHeight: 32,
+ }}
+ >
+ {/* Selection checkbox */}
+ <IconButton
+ size="small"
+ onClick={handleToggleSelection}
+ sx={{mr: 1, flexShrink: 0}}
+ >
+ {camera.selected ? (
+ <CheckCircleIcon color="info"/>
+ ) : (
+ <RadioButtonUncheckedIcon color="info"/>
+ )}
+ </IconButton>
+
+ {/* Camera icon */}
+ <VideocamIcon sx={{mr: 1, color: getStatusColor(), flexShrink: 0}}/>
+
+ {/* Camera name and config summary container */}
+ <Box sx={{
+ display: "flex",
+ alignItems: "center",
+ flexGrow: 1,
+ minWidth: 0, // Allow shrinking
+ gap: 1
+ }}>
+ {/* Camera name */}
+ <Typography
+ variant="body2"
+ sx={{
+ flexShrink: 0,
+ whiteSpace: "nowrap",
+ overflow: "hidden",
+ textOverflow: "ellipsis",
+ maxWidth: "200px" // Limit name width
+ }}
+ >
+ <span style={{fontSize: '0.75rem'}}>
+
+ Camera {camera.index}
+ </span>
+ <br/>
+ <span style={{fontSize: '0.6rem'}}>
+ {camera.name} (id: {camera.id})
+ </span>
+ </Typography>
+
+ {/* Config summary - only show when collapsed */}
+ {showConfigSummary && (
+ <Box sx={{
+ display: "flex",
+ alignItems: "center",
+ gap: 0.25,
+ flexGrow: 1,
+ minWidth: 0,
+ overflow: "hidden"
+ }}>
+ <SettingsIcon
+ sx={{
+ fontSize: 14,
+ color: theme.palette.text.secondary,
+ flexShrink: 0
+ }}
+ />
+ <Box sx={{
+ display: "flex",
+ gap: 0.5,
+ flexWrap: "wrap",
+ overflow: "hidden"
+ }}>
+ {configSummary.slice(0, 5).map((item, index) => (
+ <Chip
+ key={index}
+ label={item}
+ size="small"
+ variant="outlined"
+ sx={{
+ height: 10,
+ fontSize: 8,
+ '& .MuiChip-label': {
+ px: 0.75,
+ },
+ borderColor: theme.palette.divider,
+ color: theme.palette.text.secondary,
+ }}
+ />
+ ))}
+ </Box>
+ </Box>
+ )}
+ </Box>
+
+ {/* Status chip */}
+ <Chip
+ label={camera.connectionStatus.toUpperCase()}
+ size="small"
+ sx={{
+ ml: 1,
+ flexShrink: 0,
+ backgroundColor: getStatusColor(),
+ color: theme.palette.getContrastText(getStatusColor()),
+ fontSize: 10,
+ height: 20,
+ }}
+ />
+ </Box>
+ }
+ >
+ <CameraConfigTreeSection camera={camera}/>
+ </TreeItem>
+ );
+};
diff --git a/freemocap-ui-old/src/components/camera-config-tree-view/NoCamerasPlaceholder.tsx b/freemocap-ui-old/src/components/camera-config-tree-view/NoCamerasPlaceholder.tsx
new file mode 100644
index 00000000..901538bc
--- /dev/null
+++ b/freemocap-ui-old/src/components/camera-config-tree-view/NoCamerasPlaceholder.tsx
@@ -0,0 +1,31 @@
+import React from "react";
+import {Box, Typography} from "@mui/material";
+import {TreeItem} from "@mui/x-tree-view/TreeItem";
+
+export const NoCamerasPlaceholder: React.FC = () => {
+ return (
+ <TreeItem
+ itemId="no-cameras"
+ label={
+ <Box
+ sx={{
+ p: 3,
+ textAlign: "center",
+ bgcolor: "background.paper",
+ }}
+ >
+ <Typography variant="body1" color="text.secondary">
+ No cameras detected
+ </Typography>
+ <Typography
+ variant="caption"
+ color="text.disabled"
+ sx={{ mt: 1, display: "block" }}
+ >
+ Click refresh to scan for available cameras
+ </Typography>
+ </Box>
+ }
+ />
+ );
+};
diff --git a/freemocap-ui-old/src/components/camera-config-tree-view/camera-config-panel/CameraConfigExposure.tsx b/freemocap-ui-old/src/components/camera-config-tree-view/camera-config-panel/CameraConfigExposure.tsx
new file mode 100644
index 00000000..fb1bd382
--- /dev/null
+++ b/freemocap-ui-old/src/components/camera-config-tree-view/camera-config-panel/CameraConfigExposure.tsx
@@ -0,0 +1,138 @@
+import React from 'react';
+import {Box, Slider, ToggleButton, ToggleButtonGroup, Tooltip, Typography, useTheme} from '@mui/material';
+import {ExposureMode} from "@/store/slices/cameras/cameras-types";
+
+interface CameraConfigExposureProps {
+ exposureMode: ExposureMode;
+ exposure: number;
+ onExposureModeChange: (mode: ExposureMode) => void;
+ onExposureValueChange: (value: number) => void;
+}
+
+const ValueLabelComponent = (props: {
+ children: React.ReactElement;
+ value: number;
+}) => {
+ const { children, value } = props;
+
+ return (
+ <Tooltip title={
+ <span>
+ {`${(1000 / Math.pow(2, -1 * value)).toFixed(3)}ms (1/2`}
+ <sup>{value}</sup>
+ {` sec)`}
+ </span>
+ }>
+ {children}
+ </Tooltip>
+ );
+};
+
+// Default constraints for exposure
+const EXPOSURE_CONSTRAINTS = {
+ min: -13,
+ max: -4,
+ default: -7
+};
+
+export const CameraConfigExposure: React.FC<CameraConfigExposureProps> = ({
+ exposureMode = 'MANUAL',
+ exposure = EXPOSURE_CONSTRAINTS.default,
+ onExposureModeChange,
+ onExposureValueChange
+ }) => {
+ const theme = useTheme();
+
+ const handleModeChange = (
+ event: React.MouseEvent<HTMLElement>,
+ newMode: string | null,
+ ): void => {
+ if (newMode !== null) {
+ onExposureModeChange(newMode as ExposureMode);
+ }
+ };
+
+ const handleSliderChange = (event: Event, value: number | number[]): void => {
+ onExposureValueChange(value as number);
+ };
+
+ const baseMarks = [
+ { value: EXPOSURE_CONSTRAINTS.min, label: String(EXPOSURE_CONSTRAINTS.min) },
+ {
+ value: EXPOSURE_CONSTRAINTS.default,
+ label: `${EXPOSURE_CONSTRAINTS.default} (default)`
+ },
+ { value: EXPOSURE_CONSTRAINTS.max, label: String(EXPOSURE_CONSTRAINTS.max) }
+ ];
+
+ const marks = [
+ ...baseMarks,
+ ...(![
+ EXPOSURE_CONSTRAINTS.min as number,
+ EXPOSURE_CONSTRAINTS.default as number,
+ EXPOSURE_CONSTRAINTS.max as number
+ ].includes(exposure)
+ ? [{
+ value: exposure,
+ label: `${exposure}`,
+ }]
+ : []
+ )
+ ].sort((a, b) => a.value - b.value);
+
+ return (
+ <Box>
+ <Typography variant="body2" color="text.secondary" gutterBottom>
+ Camera Exposure
+ </Typography>
+ <Tooltip title="Choose between automatic or manual exposure control">
+ <ToggleButtonGroup
+ color={theme.palette.primary.main as any}
+ value={exposureMode}
+ exclusive
+ onChange={handleModeChange}
+ size="small"
+ sx={{
+ '& .MuiToggleButton-root.Mui-selected': {
+ backgroundColor: theme.palette.primary.main,
+ border: `1px solid ${theme.palette.text.secondary}`,
+ color: theme.palette.primary.contrastText,
+ '&:hover': {
+ backgroundColor: theme.palette.primary.light,
+ },
+ }
+ }}
+ >
+ <ToggleButton value="MANUAL">Manual</ToggleButton>
+ <ToggleButton value="AUTO">Auto</ToggleButton>
+ <ToggleButton value="RECOMMEND">Recommend</ToggleButton>
+ </ToggleButtonGroup>
+ </Tooltip>
+ <Tooltip title="Adjust exposure time, e.g. cv2.VideoCapture.set(cv2.CAP_PROP_EXPOSURE, value)">
+ <Box sx={{ flexGrow: 1 }}>
+ <Slider
+ value={exposure}
+ disabled={exposureMode === 'AUTO' || exposureMode === 'RECOMMEND'}
+ min={EXPOSURE_CONSTRAINTS.min}
+ max={EXPOSURE_CONSTRAINTS.max}
+ step={1}
+ marks={marks}
+ valueLabelDisplay="auto"
+ onChange={handleSliderChange}
+ components={{
+ ValueLabel: ValueLabelComponent
+ }}
+ sx={{
+ color: theme.palette.primary.light,
+ '& .MuiSlider-thumb': {
+ '&:hover, &.Mui-focusVisible': {
+ boxShadow: `0px 0px 0px 8px ${theme.palette.primary.light}33`,
+ },
+ },
+ }}
+ />
+ </Box>
+ </Tooltip>
+ </Box>
+ );
+};
diff --git a/freemocap-ui-old/src/components/camera-config-tree-view/camera-config-panel/CameraConfigPanel.tsx b/freemocap-ui-old/src/components/camera-config-tree-view/camera-config-panel/CameraConfigPanel.tsx
new file mode 100644
index 00000000..312d2d75
--- /dev/null
+++ b/freemocap-ui-old/src/components/camera-config-tree-view/camera-config-panel/CameraConfigPanel.tsx
@@ -0,0 +1,142 @@
+import React from "react";
+import {Box, Collapse, IconButton, Tooltip, useTheme,} from "@mui/material";
+import Grid from "@mui/material/Grid2";
+import MediationIcon from "@mui/icons-material/Mediation";
+import {CameraConfigResolution} from "./CameraConfigResolution";
+import {CameraConfigExposure} from "./CameraConfigExposure";
+import {CameraConfigRotation} from "./CameraConfigRotation";
+import {CameraConfig, ExposureMode} from "@/store/slices/cameras/cameras-types";
+import {useAppDispatch, useAppSelector} from "@/store";
+import {configCopiedToAll, selectCameras} from "@/store/slices/cameras";
+
+interface CameraConfigPanelProps {
+ config: CameraConfig;
+ onConfigChange: (newConfig: CameraConfig) => void;
+ isExpanded: boolean;
+}
+
+export const CameraConfigPanel: React.FC<CameraConfigPanelProps> = ({
+ config,
+ onConfigChange,
+ isExpanded,
+ }) => {
+ const theme = useTheme();
+ const dispatch = useAppDispatch();
+
+ // Get total camera count for UI feedback
+ const allCameras = useAppSelector(selectCameras);
+ const otherCamerasCount = allCameras.length - 1;
+
+ const handleChange = <K extends keyof CameraConfig>(
+ key: K,
+ value: CameraConfig[K]
+ ): void => {
+ onConfigChange({
+ ...config,
+ [key]: value,
+ });
+ };
+
+ const handleCopyToAllCameras = (): void => {
+ dispatch(configCopiedToAll(config.camera_id));
+ };
+
+ const handleResolutionChange = (width: number, height: number): void => {
+ handleChange("resolution", { width, height });
+ };
+
+ const handleRotationChange = (value: string): void => {
+ handleChange("rotation", value as CameraConfig['rotation']);
+ };
+
+ const handleExposureModeChange = (mode: ExposureMode): void => {
+ handleChange("exposure_mode", mode);
+ };
+
+ const handleExposureValueChange = (value: number): void => {
+ handleChange("exposure", value);
+ };
+
+ return (
+ <Collapse in={isExpanded} timeout="auto" unmountOnExit>
+ <Box
+ sx={{
+ p: 1.5,
+ ml: 7,
+ mr: 2,
+ mb: 1,
+ borderRadius: 1,
+ border: `1px solid ${theme.palette.divider}`,
+ backgroundColor: theme.palette.background.paper,
+ }}
+ >
+ <Grid container spacing={2}>
+ {/* Top row with Resolution and Rotation */}
+ <Grid size={{ xs: 12, md: 5 }}>
+ <CameraConfigResolution
+ resolution={config.resolution}
+ onChange={handleResolutionChange}
+ />
+ </Grid>
+
+ <Grid size={{ xs: 12, md: 5 }}>
+ <CameraConfigRotation
+ rotation={config.rotation}
+ onChange={handleRotationChange}
+ />
+ </Grid>
+
+ <Grid
+ size={{ xs: 12, md: 2 }}
+ sx={{
+ display: "flex",
+ alignItems: "center",
+ justifyContent: "center",
+ }}
+ >
+ <Tooltip
+ title={
+ otherCamerasCount > 0
+ ? `Copy settings to ${otherCamerasCount} other camera${
+ otherCamerasCount > 1 ? "s" : ""
+ }`
+ : "No other cameras to copy to"
+ }
+ >
+ <span>
+ <IconButton
+ size="small"
+ onClick={handleCopyToAllCameras}
+ disabled={otherCamerasCount === 0}
+ aria-label="Copy settings to all cameras"
+ sx={{
+ color: theme.palette.primary.main,
+ "&:hover": {
+ backgroundColor: theme.palette.primary.light,
+ color: theme.palette.primary.contrastText,
+ },
+ "&:disabled": {
+ color: theme.palette.action.disabled,
+ },
+ }}
+ >
+ <MediationIcon />
+ </IconButton>
+ </span>
+ </Tooltip>
+ </Grid>
+
+ {/* Bottom row with Exposure controls */}
+ <Grid size={12}>
+ <CameraConfigExposure
+ exposureMode={config.exposure_mode}
+ exposure={config.exposure}
+ onExposureModeChange={handleExposureModeChange}
+ onExposureValueChange={handleExposureValueChange}
+ />
+ </Grid>
+ </Grid>
+ </Box>
+ </Collapse>
+ );
+};
diff --git a/freemocap-ui-old/src/components/camera-config-tree-view/camera-config-panel/CameraConfigResolution.tsx b/freemocap-ui-old/src/components/camera-config-tree-view/camera-config-panel/CameraConfigResolution.tsx
new file mode 100644
index 00000000..ae59d11b
--- /dev/null
+++ b/freemocap-ui-old/src/components/camera-config-tree-view/camera-config-panel/CameraConfigResolution.tsx
@@ -0,0 +1,36 @@
+import React from "react";
+import {FormControl, InputLabel, MenuItem, Select, useTheme} from "@mui/material";
+import {CameraConfig} from "@/store/slices/cameras/cameras-types";
+
+interface CameraConfigResolutionProps {
+ resolution: CameraConfig['resolution'];
+ onChange: (width: number, height: number) => void;
+}
+
+export const CameraConfigResolution: React.FC<CameraConfigResolutionProps> = ({
+ resolution,
+ onChange
+ }) => {
+ const theme = useTheme();
+
+ const handleChange = (event: any): void => {
+ const [width, height] = event.target.value.split('x').map(Number);
+ onChange(width, height);
+ };
+
+ return (
+ <FormControl size="small" sx={{ flex: 1, color: theme.palette.text.primary }}>
+ <InputLabel sx={{ color: theme.palette.text.primary }}>Resolution</InputLabel>
+ <Select
+ value={`${resolution.width}x${resolution.height}`}
+ label="Resolution"
+ onChange={handleChange}
+ sx={{ color: theme.palette.text.primary }}
+ >
+ <MenuItem value="640x480">640 x 480</MenuItem>
+ <MenuItem value="1280x720">1280 x 720</MenuItem>
+ <MenuItem value="1920x1080">1920 x 1080</MenuItem>
+ </Select>
+ </FormControl>
+ );
+};
diff --git a/freemocap-ui-old/src/components/camera-config-tree-view/camera-config-panel/CameraConfigRotation.tsx b/freemocap-ui-old/src/components/camera-config-tree-view/camera-config-panel/CameraConfigRotation.tsx
new file mode 100644
index 00000000..eabca928
--- /dev/null
+++ b/freemocap-ui-old/src/components/camera-config-tree-view/camera-config-panel/CameraConfigRotation.tsx
@@ -0,0 +1,59 @@
+import React from 'react';
+import ToggleButton from '@mui/material/ToggleButton';
+import ToggleButtonGroup from '@mui/material/ToggleButtonGroup';
+import {Box, Tooltip, useTheme} from '@mui/material';
+import {ROTATION_DEGREE_LABELS, ROTATION_OPTIONS, RotationValue} from '@/store/slices/cameras/cameras-types';
+
+interface CameraConfigRotationProps {
+ rotation?: RotationValue;
+ onChange: (rotation: RotationValue) => void;
+}
+
+
+
+export const CameraConfigRotation: React.FC<CameraConfigRotationProps> = ({
+ rotation = -1,
+ onChange
+ }) => {
+ const theme = useTheme();
+
+ const handleChange = (
+ event: React.MouseEvent<HTMLElement>,
+ newRotation: RotationValue | null,
+ ): void => {
+ if (newRotation !== null) {
+ onChange(newRotation);
+ }
+ };
+
+ return (
+ <Box>
+ <Tooltip title="Select camera image rotation">
+ <ToggleButtonGroup
+ color={theme.palette.primary.main as any}
+ value={rotation}
+ size="small"
+ exclusive
+ onChange={handleChange}
+ aria-label="camera rotation"
+ sx={{
+ '& .MuiToggleButton-root.Mui-selected': {
+ backgroundColor: theme.palette.primary.main,
+ color: theme.palette.primary.contrastText,
+ border: `1px solid ${theme.palette.text.secondary}`,
+ '&:hover': {
+ backgroundColor: theme.palette.primary.light,
+ },
+ }
+ }}
+ >
+ {ROTATION_OPTIONS.map((option: RotationValue) => (
+ <ToggleButton key={option} value={option}>
+ {ROTATION_DEGREE_LABELS[option]}
+ </ToggleButton>
+ ))}
+ </ToggleButtonGroup>
+ </Tooltip>
+ </Box>
+ );
+};
diff --git a/freemocap-ui-old/src/components/camera-views/CameraView.tsx b/freemocap-ui-old/src/components/camera-views/CameraView.tsx
new file mode 100644
index 00000000..a506e5ab
--- /dev/null
+++ b/freemocap-ui-old/src/components/camera-views/CameraView.tsx
@@ -0,0 +1,126 @@
+import React, {memo, useEffect, useRef} from 'react';
+
+import {useServer} from "@/hooks/useServer";
+
+interface CameraViewProps {
+ cameraId: string;
+ scale?: number;
+ maxWidth?: boolean;
+}
+
+/**
+ * CameraView component - renders a canvas for a single camera feed.
+ * The overlay is now composited directly into the frame before rendering.
+ */
+export const CameraView: React.FC<CameraViewProps> = memo(({ cameraId, scale, maxWidth }) => {
+ const canvasRef = useRef<HTMLCanvasElement>(null);
+ const fpsDisplayRef = useRef<HTMLSpanElement>(null);
+
+ const { setCanvasForCamera, getFps } = useServer();
+ const animationFrameRef = useRef<number | null>(null);
+
+ // Set up canvas
+ useEffect(() => {
+ const canvas = canvasRef.current;
+ if (canvas && cameraId) {
+ console.log(`Setting up canvas for camera: ${cameraId}`);
+ setCanvasForCamera(cameraId, canvas);
+ }
+ }, [cameraId, setCanvasForCamera]);
+
+ // Update FPS display using direct DOM manipulation to avoid React re-renders
+ useEffect(() => {
+ const updateFps = (): void => {
+ const fps = getFps(cameraId);
+ if (fpsDisplayRef.current && fps !== null) {
+ fpsDisplayRef.current.textContent = `Display FPS ${fps.toFixed(1)}`;
+ }
+ animationFrameRef.current = requestAnimationFrame(updateFps);
+ };
+
+ animationFrameRef.current = requestAnimationFrame(updateFps);
+
+ return () => {
+ if (animationFrameRef.current !== null) {
+ cancelAnimationFrame(animationFrameRef.current);
+ }
+ };
+ }, [cameraId, getFps]);
+
+ // Calculate canvas styles based on scale and maxWidth settings
+ const getCanvasStyle = (): React.CSSProperties => {
+ const baseStyle: React.CSSProperties = {
+ width: '100%',
+ height: '100%',
+ objectFit: 'contain',
+ };
+
+ if (maxWidth) {
+ return baseStyle;
+ }
+
+ if (scale !== undefined && scale !== 1.0) {
+ return {
+ ...baseStyle,
+ width: `${scale * 100}%`,
+ height: `${scale * 100}%`,
+ };
+ }
+
+ return baseStyle;
+ };
+
+ const canvasStyle = getCanvasStyle();
+
+ return (
+ <div
+ style={{
+ width: '100%',
+ height: '100%',
+ display: 'flex',
+ flexDirection: 'column',
+ alignItems: 'center',
+ justifyContent: 'center',
+ backgroundColor: '#000',
+ position: 'relative',
+ overflow: 'hidden',
+ }}
+ >
+ {/* Single canvas with composited image + overlay */}
+ <canvas
+ ref={canvasRef}
+ style={canvasStyle}
+ />
+
+ {/* Info display */}
+ <div
+ style={{
+ position: 'absolute',
+ bottom: 8,
+ left: 8,
+ backgroundColor: 'rgba(0, 0, 0, 0.7)',
+ color: '#fff',
+ padding: '4px 8px',
+ borderRadius: 4,
+ fontSize: '12px',
+ fontFamily: 'monospace',
+ pointerEvents: 'none',
+ }}
+ >
+ <div>{cameraId}</div>
+ <div style={{ fontSize: '10px', marginTop: '2px', color: '#0f0' }}>
+ <span ref={fpsDisplayRef}>-- FPS</span>
+ </div>
+ </div>
+ </div>
+ );
+}, (prevProps, nextProps) => {
+ // Custom comparison: only re-render if relevant props change
+ return (
+ prevProps.cameraId === nextProps.cameraId &&
+ prevProps.scale === nextProps.scale &&
+ prevProps.maxWidth === nextProps.maxWidth
+ );
+});
+
+CameraView.displayName = 'CameraView';
diff --git a/freemocap-ui-old/src/components/camera-views/CameraViewsGrid.tsx b/freemocap-ui-old/src/components/camera-views/CameraViewsGrid.tsx
new file mode 100644
index 00000000..b134b423
--- /dev/null
+++ b/freemocap-ui-old/src/components/camera-views/CameraViewsGrid.tsx
@@ -0,0 +1,131 @@
+import React from "react";
+import {Box} from "@mui/material";
+import {Panel, PanelGroup, PanelResizeHandle} from "react-resizable-panels";
+import {useTheme} from "@mui/material/styles";
+import {CameraView} from "./CameraView";
+import {useServer} from "@/hooks/useServer";
+import {CameraSettings} from "@/pages/CamerasPage";
+
+interface CameraViewsGridProps {
+ settings: CameraSettings;
+ resetKey: number;
+}
+
+export const CameraViewsGrid: React.FC<CameraViewsGridProps> = ({settings, resetKey}) => {
+ const theme = useTheme();
+ const {connectedCameraIds} = useServer();
+
+ const getColumns = (total: number): number => {
+ if (settings.columns !== null && settings.columns !== undefined) {
+ return settings.columns;
+ }
+
+ if (total <= 1) return 1;
+ if (total <= 4) return 2;
+ if (total <= 9) return 3;
+ return 4;
+ };
+
+ if (connectedCameraIds.length === 0) {
+ return (
+ <Box sx={{
+ height: '100%',
+ width: '100%',
+ display: 'flex',
+ alignItems: 'center',
+ justifyContent: 'center',
+ color: 'text.secondary',
+ fontSize: '1.2rem',
+ padding: 4,
+ textAlign: 'center',
+ }}>
+ <div>
+ <div>No cameras connected</div>
+ <div style={{fontSize: '0.9rem', marginTop: '0.5rem'}}>
+ Waiting for camera streams...
+ </div>
+ </div>
+ </Box>
+ );
+ }
+
+ const columns = getColumns(connectedCameraIds.length);
+
+ // Organize cameras into rows
+ const rows: string[][] = [];
+ for (let i = 0; i < connectedCameraIds.length; i += columns) {
+ rows.push(connectedCameraIds.slice(i, i + columns));
+ }
+
+ const defaultRowSize = 100 / rows.length;
+ const minRowSize = Math.max(10, 100 / (rows.length * 2));
+
+ return (
+ <Box sx={{
+ height: '100%',
+ width: '100%',
+ overflow: 'hidden',
+ padding: 1,
+ }}>
+ <PanelGroup key={`camera-grid-${resetKey}`} direction="vertical">
+ {rows.map((row, rowIndex) => {
+ const defaultCameraSize = 100 / row.length;
+ const minCameraSize = Math.max(10, 100 / (row.length * 2));
+
+ return (
+ <React.Fragment key={`row-${rowIndex}`}>
+ <Panel
+ defaultSize={defaultRowSize}
+ minSize={minRowSize}
+ >
+ <PanelGroup direction="horizontal">
+ {row.map((cameraId, cameraIndex) => (
+ <React.Fragment key={cameraId}>
+ <Panel
+ defaultSize={defaultCameraSize}
+ minSize={minCameraSize}
+ >
+ <Box sx={{
+ height: '100%',
+ width: '100%',
+ display: 'flex',
+ alignItems: 'center',
+ justifyContent: 'center',
+ overflow: 'hidden',
+ }}>
+ <CameraView cameraId={cameraId}/>
+ </Box>
+ </Panel>
+
+ {/* Horizontal resize handle between cameras in same row */}
+ {cameraIndex < row.length - 1 && (
+ <PanelResizeHandle
+ style={{
+ width: "2px",
+ cursor: "col-resize",
+ backgroundColor: theme.palette.primary.dark,
+ }}
+ />
+ )}
+ </React.Fragment>
+ ))}
+ </PanelGroup>
+ </Panel>
+
+ {/* Vertical resize handle between rows */}
+ {rowIndex < rows.length - 1 && (
+ <PanelResizeHandle
+ style={{
+ height: "2px",
+ cursor: "row-resize",
+ backgroundColor: theme.palette.primary.dark,
+ }}
+ />
+ )}
+ </React.Fragment>
+ );
+ })}
+ </PanelGroup>
+ </Box>
+ );
+};
\ No newline at end of file
diff --git a/freemocap-ui-old/src/components/camera-views/camera-view-settings-overlay/CamerasViewSettingsOverlay.tsx b/freemocap-ui-old/src/components/camera-views/camera-view-settings-overlay/CamerasViewSettingsOverlay.tsx
new file mode 100644
index 00000000..4fb911aa
--- /dev/null
+++ b/freemocap-ui-old/src/components/camera-views/camera-view-settings-overlay/CamerasViewSettingsOverlay.tsx
@@ -0,0 +1,228 @@
+import React, {useState} from 'react';
+import {Box, Button, Checkbox, FormControlLabel, IconButton, Paper, TextField, ToggleButton, ToggleButtonGroup, Tooltip} from '@mui/material';
+import SettingsIcon from '@mui/icons-material/Settings';
+import CloseIcon from '@mui/icons-material/Close';
+import GridViewIcon from '@mui/icons-material/GridView';
+import ViewInArIcon from '@mui/icons-material/ViewInAr';
+import RestartAltIcon from '@mui/icons-material/RestartAlt';
+import ViewColumnIcon from '@mui/icons-material/ViewColumn';
+import TableRowsIcon from '@mui/icons-material/TableRows';
+import {useServer} from "@/hooks/useServer";
+import {CameraSettings, LayoutDirection} from "@/pages/CamerasPage";
+
+interface CamerasViewSettingsOverlayProps {
+ onSettingsChange: (settings: CameraSettings) => void;
+ onResetViews: () => void;
+}
+
+export const CamerasViewSettingsOverlay: React.FC<CamerasViewSettingsOverlayProps> = ({
+ onSettingsChange,
+ onResetViews
+ }) => {
+ const {connectedCameraIds} = useServer();
+ const [isOpen, setIsOpen] = useState<boolean>(false);
+ const [isAuto, setIsAuto] = useState<boolean>(true);
+ const [manualColumns, setManualColumns] = useState<number>(2);
+ const [show3dView, setShow3dView] = useState<boolean>(true);
+ const [layoutDirection, setLayoutDirection] = useState<LayoutDirection>('horizontal');
+
+ const getAutoColumns = (total: number): number => {
+ if (total <= 1) return 1;
+ if (total <= 4) return 2;
+ if (total <= 9) return 3;
+ return 4;
+ };
+
+ const autoColumns = getAutoColumns(connectedCameraIds.length);
+
+ const buildSettings = (overrides: Partial<{
+ columns: number | null;
+ show3dView: boolean;
+ layoutDirection: LayoutDirection;
+ }> = {}): CameraSettings => ({
+ columns: overrides.columns !== undefined ? overrides.columns : (isAuto ? null : manualColumns),
+ show3dView: overrides.show3dView !== undefined ? overrides.show3dView : show3dView,
+ layoutDirection: overrides.layoutDirection !== undefined ? overrides.layoutDirection : layoutDirection,
+ });
+
+ const handleAutoChange = (event: React.ChangeEvent<HTMLInputElement>) => {
+ const checked = event.target.checked;
+ setIsAuto(checked);
+ onSettingsChange(buildSettings({columns: checked ? null : manualColumns}));
+ };
+
+ const handleColumnsChange = (event: React.ChangeEvent<HTMLInputElement>) => {
+ const value = parseInt(event.target.value);
+ if (!isNaN(value) && value > 0) {
+ setManualColumns(value);
+ if (isAuto) {
+ setIsAuto(false);
+ }
+ onSettingsChange(buildSettings({columns: value}));
+ }
+ };
+
+ const handle3dViewChange = (event: React.ChangeEvent<HTMLInputElement>) => {
+ const checked = event.target.checked;
+ setShow3dView(checked);
+ onSettingsChange(buildSettings({show3dView: checked}));
+ };
+
+ const handleLayoutDirectionChange = (_event: React.MouseEvent<HTMLElement>, newDirection: LayoutDirection | null) => {
+ if (newDirection === null) return; // Prevent deselecting both
+ setLayoutDirection(newDirection);
+ onSettingsChange(buildSettings({layoutDirection: newDirection}));
+ };
+
+ const handleResetViews = () => {
+ onResetViews();
+ };
+
+ return (
+ <>
+ {/* Settings Button */}
+ <Box
+ sx={{
+ position: 'absolute',
+ top: 16,
+ right: 16,
+ zIndex: 1000,
+ }}
+ >
+ <Tooltip title={isOpen ? "Close settings" : "Grid settings"}>
+ <IconButton
+ onClick={() => setIsOpen(!isOpen)}
+ sx={{
+ backgroundColor: 'background.paper',
+ boxShadow: 2,
+ '&:hover': {
+ backgroundColor: 'action.hover',
+ },
+ }}
+ >
+ {isOpen ? <CloseIcon/> : <SettingsIcon/>}
+ </IconButton>
+ </Tooltip>
+ </Box>
+
+ {/* Settings Panel */}
+ {isOpen && (
+ <Paper
+ elevation={8}
+ sx={{
+ position: 'absolute',
+ top: 70,
+ right: 16,
+ zIndex: 999,
+ padding: 2,
+ minWidth: 250,
+ }}
+ >
+ <Box sx={{display: 'flex', alignItems: 'center', gap: 1, mb: 2}}>
+ <GridViewIcon fontSize="small"/>
+ <Box sx={{fontWeight: 600}}>Grid Columns</Box>
+ </Box>
+
+ <Box sx={{display: 'flex', alignItems: 'flex-start', gap: 1, mb: 3}}>
+ <FormControlLabel
+ control={
+ <Checkbox
+ checked={isAuto}
+ onChange={handleAutoChange}
+ sx={{
+ '&.Mui-checked': {
+ color: 'text.primary',
+ },
+ }}
+ />
+ }
+ label="Auto"
+ />
+
+ <TextField
+ type="number"
+ label="Columns"
+ value={isAuto ? autoColumns : manualColumns}
+ onChange={handleColumnsChange}
+ fullWidth
+ inputProps={{
+ min: 1,
+ step: 1,
+ }}
+ helperText={isAuto ? `Auto-detected: ${autoColumns}` : "Enter any positive number"}
+ />
+ </Box>
+
+ <Box sx={{display: 'flex', alignItems: 'center', gap: 1, mb: 2}}>
+ <ViewInArIcon fontSize="small"/>
+ <Box sx={{fontWeight: 600}}>3D View</Box>
+ </Box>
+
+ <Box sx={{display: 'flex', alignItems: 'flex-start', gap: 1, mb: 2}}>
+ <FormControlLabel
+ control={
+ <Checkbox
+ checked={show3dView}
+ onChange={handle3dViewChange}
+ sx={{
+ '&.Mui-checked': {
+ color: 'text.primary',
+ },
+ }}
+ />
+ }
+ label="Show 3D View"
+ />
+ </Box>
+
+ {/* Layout direction toggle — only meaningful when 3D view is visible */}
+ <Box sx={{
+ display: 'flex',
+ alignItems: 'center',
+ gap: 1,
+ mb: 1,
+ opacity: show3dView ? 1 : 0.4,
+ }}>
+ <Box sx={{fontWeight: 600, fontSize: 13}}>Layout</Box>
+ </Box>
+ <ToggleButtonGroup
+ value={layoutDirection}
+ exclusive
+ onChange={handleLayoutDirectionChange}
+ disabled={!show3dView}
+ size="small"
+ sx={{mb: 3, width: '100%'}}
+ >
+ <ToggleButton value="vertical" sx={{flex: 1, textTransform: 'none', fontSize: 12}}>
+ <TableRowsIcon sx={{mr: 0.5, fontSize: 16}}/>
+ Top / Bottom
+ </ToggleButton>
+ <ToggleButton value="horizontal" sx={{flex: 1, textTransform: 'none', fontSize: 12}}>
+ <ViewColumnIcon sx={{mr: 0.5, fontSize: 16}}/>
+ Side by Side
+ </ToggleButton>
+ </ToggleButtonGroup>
+
+ <Button
+ variant="outlined"
+ startIcon={<RestartAltIcon/>}
+ onClick={handleResetViews}
+ fullWidth
+ sx={{
+ mt: 1,
+ textTransform: 'none',
+ color: 'text.primary',
+ borderColor: 'text.primary',
+ '&:hover': {
+ borderColor: 'text.primary',
+ backgroundColor: 'action.hover',
+ },
+ }}
+ >
+ Reset Panel Sizes
+ </Button>
+ </Paper>
+ )}
+ </>
+ );
+};
\ No newline at end of file
diff --git a/freemocap-ui-old/src/components/camera-views/camera-view-settings-overlay/ImageScaleSlider.tsx b/freemocap-ui-old/src/components/camera-views/camera-view-settings-overlay/ImageScaleSlider.tsx
new file mode 100644
index 00000000..18beb8dd
--- /dev/null
+++ b/freemocap-ui-old/src/components/camera-views/camera-view-settings-overlay/ImageScaleSlider.tsx
@@ -0,0 +1,65 @@
+import React from 'react';
+import {Box, Slider, Tooltip, Typography, useTheme} from '@mui/material';
+
+interface ImageScaleSliderProps {
+ scale: number;
+ onScaleChange: (value: number) => void;
+}
+
+const ValueLabelComponent = (props: {
+ children: React.ReactElement;
+ value: number;
+}) => {
+ const {children, value} = props;
+
+ return (
+ <Tooltip title={
+ <span>
+ {`Scale: ${value.toFixed(1)}`}
+ </span>
+ }>
+ {children}
+ </Tooltip>
+ );
+};
+
+export const ImageScaleSlider: React.FC<ImageScaleSliderProps> = ({
+ scale = 0.5,
+ onScaleChange,
+ }) => {
+ const theme = useTheme();
+
+ const marks = [
+ {value: 0.1, label: '0.1'},
+ {value: 0.5, label: '0.5 (default)'},
+ {value: 2.0, label: '2.0'},
+ ];
+
+ return (
+ <Box>
+ <Typography variant="body2" color="text.secondary" gutterBottom>
+ Image Scale
+ </Typography>
+ <Slider
+ value={scale}
+ min={0.1}
+ max={2.0}
+ step={0.1}
+ marks={marks}
+ valueLabelDisplay="auto"
+ onChange={(_, value) => onScaleChange(value as number)}
+ components={{
+ ValueLabel: ValueLabelComponent,
+ }}
+ sx={{
+ color: theme.palette.primary.light,
+ '& .MuiSlider-thumb': {
+ '&:hover, &.Mui-focusVisible': {
+ boxShadow: `0px 0px 0px 8px ${theme.palette.primary.light}33`,
+ },
+ },
+ }}
+ />
+ </Box>
+ );
+};
diff --git a/freemocap-ui-old/src/components/common/CollapsibleSidebarSection.tsx b/freemocap-ui-old/src/components/common/CollapsibleSidebarSection.tsx
new file mode 100644
index 00000000..ede732ba
--- /dev/null
+++ b/freemocap-ui-old/src/components/common/CollapsibleSidebarSection.tsx
@@ -0,0 +1,173 @@
+import React, {ReactNode, useCallback, useState} from "react";
+import {Box, Collapse, Paper, Typography, useTheme} from "@mui/material";
+import ExpandMoreIcon from "@mui/icons-material/ExpandMore";
+import ChevronRightIcon from "@mui/icons-material/ChevronRight";
+import DragIndicatorIcon from "@mui/icons-material/DragIndicator";
+import {useDragHandle} from "@/components/common/DragHandleContext";
+
+interface CollapsibleSidebarSectionProps {
+ icon: ReactNode;
+ title: string;
+ primaryControl: ReactNode;
+ summaryContent: ReactNode;
+ children: ReactNode;
+ defaultExpanded: boolean;
+}
+
+export const CollapsibleSidebarSection: React.FC<CollapsibleSidebarSectionProps> = ({
+ icon,
+ title,
+ primaryControl,
+ summaryContent,
+ children,
+ defaultExpanded,
+ }) => {
+ const theme = useTheme();
+ const [expanded, setExpanded] = useState(defaultExpanded);
+ const dragHandle = useDragHandle();
+
+ const handleToggle = useCallback(() => {
+ setExpanded((prev) => !prev);
+ }, []);
+
+ const handlePrimaryControlClick = useCallback((e: React.MouseEvent) => {
+ e.stopPropagation();
+ }, []);
+
+ return (
+ <Paper
+ elevation={1}
+ sx={{
+ borderRadius: 1,
+ overflow: "hidden",
+ }}
+ >
+ {/* Header row — always visible, identical whether expanded or collapsed */}
+ <Box
+ onClick={handleToggle}
+ sx={{
+ display: "flex",
+ alignItems: "center",
+ cursor: "pointer",
+ py: 0.75,
+ px: dragHandle ? 0.5 : 1.5,
+ minHeight: 44,
+ backgroundColor: theme.palette.primary.main,
+ color: theme.palette.primary.contrastText,
+ userSelect: "none",
+ transition: "background-color 0.15s ease",
+ "&:hover": {
+ backgroundColor: theme.palette.primary.dark,
+ },
+ }}
+ >
+ {/* Drag handle — only rendered when inside a sortable context */}
+ {dragHandle && (
+ <Box
+ {...dragHandle.attributes}
+ {...dragHandle.listeners}
+ onClick={(e: React.MouseEvent) => e.stopPropagation()}
+ sx={{
+ display: "flex",
+ alignItems: "center",
+ cursor: "grab",
+ px: 0.25,
+ mr: 0.25,
+ flexShrink: 0,
+ opacity: 0.35,
+ borderRadius: 0.5,
+ transition: "opacity 0.15s ease, background-color 0.15s ease",
+ "&:hover": {
+ opacity: 0.9,
+ backgroundColor: "rgba(255,255,255,0.1)",
+ },
+ "&:active": {
+ cursor: "grabbing",
+ },
+ }}
+ >
+ <DragIndicatorIcon sx={{fontSize: 18}} />
+ </Box>
+ )}
+
+ {/* Expand/collapse chevron */}
+ <Box
+ sx={{
+ display: "flex",
+ alignItems: "center",
+ mr: 0.5,
+ flexShrink: 0,
+ }}
+ >
+ {expanded ? (
+ <ExpandMoreIcon fontSize="small" />
+ ) : (
+ <ChevronRightIcon fontSize="small" />
+ )}
+ </Box>
+
+ {/* Section icon */}
+ <Box
+ sx={{
+ display: "flex",
+ alignItems: "center",
+ mr: 1,
+ flexShrink: 0,
+ }}
+ >
+ {icon}
+ </Box>
+
+ {/* Title */}
+ <Typography
+ variant="subtitle1"
+ sx={{
+ fontWeight: 600,
+ flexShrink: 0,
+ lineHeight: 1.3,
+ }}
+ >
+ {title}
+ </Typography>
+
+ {/* Summary — fills remaining horizontal space */}
+ <Box
+ sx={{
+ flexGrow: 1,
+ mx: 1.5,
+ overflow: "hidden",
+ display: "flex",
+ alignItems: "center",
+ justifyContent: "flex-end",
+ }}
+ >
+ {summaryContent}
+ </Box>
+
+ {/* Primary control — click is isolated from expand/collapse */}
+ <Box
+ onClick={handlePrimaryControlClick}
+ sx={{
+ flexShrink: 0,
+ display: "flex",
+ alignItems: "center",
+ pr: 0.5,
+ }}
+ >
+ {primaryControl}
+ </Box>
+ </Box>
+
+ {/* Detail panel — only visible when expanded */}
+ <Collapse in={expanded} timeout="auto" unmountOnExit>
+ <Box
+ sx={{
+ backgroundColor: theme.palette.background.paper,
+ }}
+ >
+ {children}
+ </Box>
+ </Collapse>
+ </Paper>
+ );
+};
diff --git a/freemocap-ui-old/src/components/common/DragHandleContext.ts b/freemocap-ui-old/src/components/common/DragHandleContext.ts
new file mode 100644
index 00000000..7d8f9b82
--- /dev/null
+++ b/freemocap-ui-old/src/components/common/DragHandleContext.ts
@@ -0,0 +1,12 @@
+import {createContext, useContext} from "react";
+
+export interface DragHandleContextValue {
+ listeners: Record<string, Function> | undefined;
+ attributes: Record<string, any>;
+}
+
+export const DragHandleContext = createContext<DragHandleContextValue | null>(null);
+
+export const useDragHandle = (): DragHandleContextValue | null => {
+ return useContext(DragHandleContext);
+};
diff --git a/freemocap-ui-old/src/components/common/ErrorBoundary.tsx b/freemocap-ui-old/src/components/common/ErrorBoundary.tsx
new file mode 100644
index 00000000..cbe18797
--- /dev/null
+++ b/freemocap-ui-old/src/components/common/ErrorBoundary.tsx
@@ -0,0 +1,55 @@
+import React from "react";
+
+// Define the types for props and state
+interface ErrorBoundaryProps {
+ children: React.ReactNode;
+}
+
+interface ErrorBoundaryState {
+ hasError: boolean;
+ error: Error | null;
+ errorInfo: React.ErrorInfo | null;
+}
+
+class ErrorBoundary extends React.Component<ErrorBoundaryProps, ErrorBoundaryState> {
+ constructor(props: ErrorBoundaryProps) {
+ super(props);
+ this.state = {hasError: false, error: null, errorInfo: null};
+ }
+
+ static getDerivedStateFromError(error: Error): Partial<ErrorBoundaryState> {
+ // Update state so the next render shows the fallback UI.
+ return {hasError: true};
+ }
+
+ componentDidCatch(error: Error, errorInfo: React.ErrorInfo) {
+ // You can also log the error to an error reporting service
+ console.error('Error caught by ErrorBoundary', error, errorInfo);
+ // Store the error and errorInfo in state
+ this.setState({error, errorInfo});
+ }
+
+ render() {
+ if (this.state.hasError) {
+ // Render a custom fallback UI with error details
+ return (
+ <div>
+ <h1>Something went wrong :(</h1>
+ <details style={{whiteSpace: 'pre-wrap'}}>
+ {this.state.error && this.state.error.toString()}
+ <br/>
+ {this.state.errorInfo && this.state.errorInfo.componentStack}
+ </details>
+ </div>
+ );
+ }
+
+ return this.props.children;
+ }
+}
+
+export default ErrorBoundary;
+// // Usage
+// <ErrorBoundary>
+// <ThreeJSCanvas3d />
+// </ErrorBoundary>
diff --git a/freemocap-ui-old/src/components/common/SortableSectionWrapper.tsx b/freemocap-ui-old/src/components/common/SortableSectionWrapper.tsx
new file mode 100644
index 00000000..d5ca7140
--- /dev/null
+++ b/freemocap-ui-old/src/components/common/SortableSectionWrapper.tsx
@@ -0,0 +1,39 @@
+import React, {ReactNode} from "react";
+import {useSortable} from "@dnd-kit/sortable";
+import {CSS} from "@dnd-kit/utilities";
+import {DragHandleContext} from "@/components/common/DragHandleContext";
+
+interface SortableSectionWrapperProps {
+ id: string;
+ children: ReactNode;
+}
+
+export const SortableSectionWrapper: React.FC<SortableSectionWrapperProps> = ({
+ id,
+ children,
+}) => {
+ const {
+ attributes,
+ listeners,
+ setNodeRef,
+ transform,
+ transition,
+ isDragging,
+ } = useSortable({id});
+
+ const style: React.CSSProperties = {
+ transform: CSS.Transform.toString(transform),
+ transition,
+ zIndex: isDragging ? 10 : undefined,
+ position: "relative",
+ opacity: isDragging ? 0.85 : 1,
+ };
+
+ return (
+ <div ref={setNodeRef} style={style}>
+ <DragHandleContext.Provider value={{listeners, attributes}}>
+ {children}
+ </DragHandleContext.Provider>
+ </div>
+ );
+};
diff --git a/freemocap-ui-old/src/components/framerate-viewer/BaseD3ChartView.tsx b/freemocap-ui-old/src/components/framerate-viewer/BaseD3ChartView.tsx
new file mode 100644
index 00000000..1dc2aea4
--- /dev/null
+++ b/freemocap-ui-old/src/components/framerate-viewer/BaseD3ChartView.tsx
@@ -0,0 +1,203 @@
+// src/components/framerate-viewer/BaseD3ChartView.tsx
+import {useEffect, useRef, useState} from "react"
+import * as d3 from "d3"
+import {Box, Fade, IconButton, Tooltip, Typography} from "@mui/material"
+import {RestartAlt, ZoomIn, ZoomOut} from "@mui/icons-material"
+
+export type ChartMargins = {
+ top: number
+ right: number
+ bottom: number
+ left: number
+}
+
+// Define a type for elements that should be updated on zoom
+export type ZoomableElement = {
+ selector: string;
+ updateFn: (selection: d3.Selection<any, any, any, any>, transform: d3.ZoomTransform) => void;
+}
+
+type BaseChartViewProps = {
+ title?: string
+ renderChart: (params: {
+ svg: d3.Selection<SVGGElement, unknown, null, undefined>
+ chartArea: d3.Selection<SVGGElement, unknown, null, undefined>
+ width: number
+ height: number
+ margin: ChartMargins
+ transform: d3.ZoomTransform
+ }) => void
+ margin?: ChartMargins
+}
+
+export default function BaseD3ChartView({
+ title,
+ renderChart,
+ margin = {top: 20, right: 100, bottom: 30, left: 60}
+ }: BaseChartViewProps) {
+ const svgRef = useRef<SVGSVGElement>(null)
+ const chartRef = useRef<{
+ cleanup?: () => void
+ }>({})
+ const [transform, setTransform] = useState<d3.ZoomTransform>(d3.zoomIdentity)
+ const zoomRef = useRef<d3.ZoomBehavior<SVGSVGElement, unknown> | null>(null)
+ const [showControls, setShowControls] = useState(false)
+
+ useEffect(() => {
+ if (!svgRef.current) return
+
+ // Clear previous chart
+ d3.select(svgRef.current).selectAll("*").remove()
+
+ // Set up dimensions
+ let width = svgRef.current.clientWidth - margin.left - margin.right
+ let height = svgRef.current.clientHeight - margin.top - margin.bottom
+ if (width < 0) {
+ width = 0
+ }
+ if (height < 0) {
+ height = 0
+ }
+ // Create SVG with a clip path for zooming
+ const svg = d3.select(svgRef.current)
+ .append("g")
+ .attr("transform", `translate(${margin.left},${margin.top})`)
+
+ // Add clip path to prevent drawing outside the chart area
+ svg
+ .append("defs")
+ .append("clipPath")
+ .attr("id", "clip-chart")
+ .append("rect")
+ .attr("width", width)
+ .attr("height", height)
+
+ // Create a group for the chart content that will be clipped
+ const chartArea = svg.append("g").attr("clip-path", "url(#clip-chart)")
+
+ // Call the render function provided by the child component
+ const cleanup = renderChart({svg, chartArea, width, height, margin, transform})
+
+ // Store cleanup function if one is returned
+ if (typeof cleanup === 'function') {
+ chartRef.current.cleanup = cleanup
+ }
+
+ // Define zoom behavior
+ const zoom = d3
+ .zoom<SVGSVGElement, unknown>()
+ .scaleExtent([0.5, 20])
+ .extent([
+ [0, 0],
+ [width, height],
+ ])
+ .on("zoom", (event) => {
+ // Update the transform state
+ setTransform(event.transform)
+ })
+
+ // Store zoom reference for external controls
+ zoomRef.current = zoom
+
+ // Apply zoom to the SVG
+ d3.select(svgRef.current).call(zoom)
+
+ // Cleanup function
+ return () => {
+ if (chartRef.current.cleanup) {
+ chartRef.current.cleanup()
+ }
+ }
+ }, [renderChart, margin, transform])
+
+ // Zoom control handlers
+ const handleZoomIn = () => {
+ if (svgRef.current && zoomRef.current) {
+ d3.select(svgRef.current).transition().duration(300).call(zoomRef.current.scaleBy, 1.5)
+ }
+ }
+
+ const handleZoomOut = () => {
+ if (svgRef.current && zoomRef.current) {
+ d3.select(svgRef.current).transition().duration(300).call(zoomRef.current.scaleBy, 0.75)
+ }
+ }
+
+ const handleResetZoom = () => {
+ if (svgRef.current && zoomRef.current) {
+ d3.select(svgRef.current).transition().duration(300).call(zoomRef.current.transform, d3.zoomIdentity)
+ }
+ }
+
+ return (
+ <Box
+ sx={{
+ width: "100%",
+ height: "100%",
+ position: "relative",
+ overflow: "hidden"
+ }}
+ onMouseEnter={() => setShowControls(true)}
+ onMouseLeave={() => setShowControls(false)}
+ >
+ {title && (
+ <Typography
+ variant="caption"
+ sx={{
+ position: "absolute",
+ top: 5,
+ left: 10,
+ fontSize: '0.7rem',
+ opacity: 0.8
+ }}
+ >
+ {title}
+ </Typography>
+ )}
+
+ {/* Zoom controls that fade in/out on hover */}
+ <Fade in={showControls}>
+ <Box
+ sx={{
+ position: "absolute",
+ top: "50%",
+ right: 5,
+ transform: "translateY(-50%)",
+ zIndex: 10,
+ bgcolor: "background.paper",
+ borderRadius: 1,
+ boxShadow: 1,
+ display: "flex",
+ flexDirection: "column",
+ }}
+ >
+ <Tooltip title="Zoom In" placement="right">
+ <IconButton size="small" onClick={handleZoomIn} sx={{p: 0.5}}>
+ <ZoomIn fontSize="small"/>
+ </IconButton>
+ </Tooltip>
+ <Tooltip title="Zoom Out" placement="right">
+ <IconButton size="small" onClick={handleZoomOut} sx={{p: 0.5}}>
+ <ZoomOut fontSize="small"/>
+ </IconButton>
+ </Tooltip>
+ <Tooltip title="Reset Zoom" placement="right">
+ <IconButton size="small" onClick={handleResetZoom} sx={{p: 0.5}}>
+ <RestartAlt fontSize="small"/>
+ </IconButton>
+ </Tooltip>
+ </Box>
+ </Fade>
+
+ <svg
+ ref={svgRef}
+ width="100%"
+ height="100%"
+ style={{
+ display: 'block',
+ overflow: "visible"
+ }}
+ />
+ </Box>
+ )
+}
diff --git a/freemocap-ui-old/src/components/framerate-viewer/FrameRateViewer.tsx b/freemocap-ui-old/src/components/framerate-viewer/FrameRateViewer.tsx
new file mode 100644
index 00000000..d607e734
--- /dev/null
+++ b/freemocap-ui-old/src/components/framerate-viewer/FrameRateViewer.tsx
@@ -0,0 +1,168 @@
+// src/components/framerate-viewer/FrameRateViewer.tsx
+import {useState} from "react"
+import {Box, IconButton, Paper, Stack, Tooltip, Typography} from "@mui/material"
+import {BarChart, ShowChart, ViewCompact, ViewDay} from "@mui/icons-material"
+import {alpha, useTheme} from "@mui/material/styles"
+import FramerateTimeseriesView from "./FramerateTimeseriesView"
+import FramerateHistogramView from "./FramerateHistogramView"
+import FramerateStatisticsView from "./FramerateStatisticsView"
+import {selectFramerateViewerData, useAppSelector} from "@/store";
+
+type ViewType = "timeseries" | "histogram" | "both"
+export const frontendColor: string = "#1976D2"
+export const backendColor: string = "#ff4d00"
+
+export const FramerateViewerPanel = () => {
+ const theme = useTheme()
+ const [viewType, setViewType] = useState<ViewType>("both")
+
+ // Use the new selector to get all framerate data
+ const {
+ currentFrontendFramerate,
+ currentBackendFramerate,
+ recentFrontendFrameDurations,
+ recentBackendFrameDurations
+ } = useAppSelector(selectFramerateViewerData);
+
+ return (
+ <Box sx={{
+ height: '100%',
+ display: 'flex',
+ flexDirection: 'column',
+ backgroundColor: theme.palette.background.default,
+ p: 0.5,
+ overflow: 'hidden' // Prevent content overflow
+ }}>
+ {/* Ultra-compact header with controls */}
+ <Box sx={{
+ display: 'flex',
+ justifyContent: 'space-between',
+ alignItems: 'center',
+ mb: 0.25,
+ px: 0.5
+ }}>
+ <Typography variant="body2" fontWeight="medium" noWrap sx={{fontSize: '0.75rem'}}>
+ Camera Performance Metrics
+ </Typography>
+
+ {/* View type selector as icon buttons */}
+ <Stack direction="row" spacing={0.25}>
+ <Tooltip title="Timeline View">
+ <IconButton
+ size="small"
+ onClick={() => setViewType("timeseries")}
+ color={viewType === "timeseries" ? "primary" : "default"}
+ sx={{padding: '2px'}}
+ >
+ <ShowChart sx={{fontSize: '1rem'}}/>
+ </IconButton>
+ </Tooltip>
+ <Tooltip title="Distribution View">
+ <IconButton
+ size="small"
+ onClick={() => setViewType("histogram")}
+ color={viewType === "histogram" ? "primary" : "default"}
+ sx={{padding: '2px'}}
+ >
+ <BarChart sx={{fontSize: '1rem'}}/>
+ </IconButton>
+ </Tooltip>
+ <Tooltip title="Combined View">
+ <IconButton
+ size="small"
+ onClick={() => setViewType("both")}
+ color={viewType === "both" ? "primary" : "default"}
+ sx={{padding: '2px'}}
+ >
+ {theme.direction === 'ltr' ? (
+ <ViewDay sx={{fontSize: '1rem'}}/>
+ ) : (
+ <ViewCompact sx={{fontSize: '1rem'}}/>
+ )}
+ </IconButton>
+ </Tooltip>
+ </Stack>
+ </Box>
+
+ {/* Stats section - ultra compact */}
+ <Box sx={{
+ px: 0.25,
+ mb: 0.25,
+ }}>
+ <Paper
+ elevation={0}
+ sx={{
+ p: 0.25,
+ bgcolor: alpha(theme.palette.background.paper, theme.palette.mode === 'dark' ? 0.15 : 0.05),
+ border: `1px solid ${alpha(theme.palette.divider, 0.1)}`
+ }}
+ >
+ <FramerateStatisticsView
+ frontendFramerate={currentFrontendFramerate}
+ backendFramerate={currentBackendFramerate}
+ compact={true}
+ />
+ </Paper>
+ </Box>
+
+ {/* Main visualization area with flex-based layout */}
+ <Box sx={{
+ flex: 1,
+ display: 'flex',
+ flexDirection: viewType === 'both' ? 'row' : 'column',
+ gap: 0.25,
+ overflow: 'hidden' // Critical to prevent overflow
+ }}>
+ {(viewType === 'timeseries' || viewType === 'both') && (
+ <Paper
+ elevation={0}
+ sx={{
+ flex: 1,
+ display: 'flex',
+ flexDirection: 'column',
+ border: '1px solid',
+ borderColor: alpha(theme.palette.divider, 0.2),
+ overflow: 'hidden' // Ensure chart doesn't overflow
+ }}
+ >
+ <FramerateTimeseriesView
+ frontendFramerate={currentFrontendFramerate}
+ backendFramerate={currentBackendFramerate}
+ recentFrontendFrameDurations={recentFrontendFrameDurations}
+ recentBackendFrameDurations={recentBackendFrameDurations}
+ frontendColor={frontendColor}
+ backendColor={backendColor}
+ title="Frame Duration Timeline"
+ />
+ </Paper>
+ )}
+
+ {(viewType === 'histogram' || viewType === 'both') && (
+ <Paper
+ elevation={0}
+ sx={{
+ flex: 1,
+ display: 'flex',
+ flexDirection: 'column',
+ border: '1px solid',
+ borderColor: alpha(theme.palette.divider, 0.2),
+ overflow: 'hidden' // Ensure chart doesn't overflow
+ }}
+ >
+ <FramerateHistogramView
+ frontendFramerate={currentFrontendFramerate}
+ backendFramerate={currentBackendFramerate}
+ recentFrontendFrameDurations={recentFrontendFrameDurations}
+ recentBackendFrameDurations={recentBackendFrameDurations}
+ frontendColor={frontendColor}
+ backendColor={backendColor}
+ title="Frame Duration Distribution"
+ />
+ </Paper>
+ )}
+ </Box>
+ </Box>
+ )
+}
+
+export default FramerateViewerPanel
diff --git a/freemocap-ui-old/src/components/framerate-viewer/FramerateHistogramView.tsx b/freemocap-ui-old/src/components/framerate-viewer/FramerateHistogramView.tsx
new file mode 100644
index 00000000..38c485ce
--- /dev/null
+++ b/freemocap-ui-old/src/components/framerate-viewer/FramerateHistogramView.tsx
@@ -0,0 +1,294 @@
+// src/components/framerate-viewer/FramerateHistogramView.tsx
+import {useCallback} from "react"
+import * as d3 from "d3"
+import {useTheme} from "@mui/material/styles"
+import {applyAxisStyles, createTooltip, renderEmptyChart} from "./d3ChartUtils"
+import {CurrentFramerate} from "@/store/slices/framerate/framerate-slice";
+import BaseD3ChartView from "@/components/framerate-viewer/BaseD3ChartView";
+
+type FramerateHistogramProps = {
+ frontendFramerate: CurrentFramerate | null
+ backendFramerate: CurrentFramerate | null
+ recentFrontendFrameDurations: number[]
+ recentBackendFrameDurations: number[]
+ frontendColor: string
+ backendColor: string
+ title?: string
+}
+
+export default function FramerateHistogramView({
+ frontendFramerate,
+ backendFramerate,
+ recentFrontendFrameDurations,
+ recentBackendFrameDurations,
+ frontendColor,
+ backendColor,
+ title = "Frame Duration Distribution",
+ }: FramerateHistogramProps) {
+ const theme = useTheme()
+
+ // Generate histogram data
+ const generateHistogram = (data: number[], binCount = 100) => {
+ if (data.length === 0) return null;
+
+ // Calculate bins using d3's histogram generator
+ const histGenerator = d3.histogram()
+ .domain([0, d3.max(data) as number * 1.1]) // Add 10% padding to max
+ .thresholds(binCount);
+
+ const bins = histGenerator(data);
+
+ // Calculate densities (normalized counts)
+ const totalCount = data.length;
+ const binCounts = bins.map(bin => bin.length);
+ const binDensities = binCounts.map(count => count / totalCount);
+
+ return {
+ bin_edges: bins.map(bin => bin.x0 as number),
+ bin_counts: binCounts,
+ bin_densities: binDensities
+ };
+ };
+
+ const renderChart = useCallback(({
+ svg,
+ chartArea,
+ width,
+ height,
+ margin,
+ transform
+ }: {
+ svg: d3.Selection<SVGGElement, unknown, null, undefined>;
+ chartArea: d3.Selection<SVGGElement, unknown, null, undefined>;
+ width: number;
+ height: number;
+ margin: { top: number; right: number; bottom: number; left: number };
+ transform: d3.ZoomTransform;
+ }) => {
+ // Prepare the sources with histogram data
+ const sources = [
+ {
+ id: 'frontend',
+ name: frontendFramerate?.framerate_source || 'Frontend',
+ color: frontendColor,
+ histogram: generateHistogram(recentFrontendFrameDurations),
+ totalSamples: recentFrontendFrameDurations.length
+ },
+ {
+ id: 'backend',
+ name: backendFramerate?.framerate_source || 'Backend',
+ color: backendColor,
+ histogram: generateHistogram(recentBackendFrameDurations),
+ totalSamples: recentBackendFrameDurations.length
+ }
+ ];
+
+ // Check if we have valid histogram data
+ if (sources.every(s => !s.histogram)) {
+ renderEmptyChart(svg, width, height, theme);
+ return;
+ }
+
+ // Find domain bounds from all histograms
+ let minX = Infinity;
+ let maxX = -Infinity;
+ let maxDensity = 0;
+
+ sources.forEach(source => {
+ if (source.histogram) {
+ const edges = source.histogram.bin_edges;
+ const densities = source.histogram.bin_densities;
+
+ if (edges.length > 0) {
+ minX = Math.min(minX, edges[0]);
+ maxX = Math.max(maxX, edges[edges.length - 1]);
+ }
+
+ if (densities.length > 0) {
+ maxDensity = Math.max(maxDensity, Math.max(...densities));
+ }
+ }
+ });
+
+ // If we couldn't determine bounds, use defaults
+ if (minX === Infinity) minX = 0;
+ if (maxX === -Infinity) maxX = 100;
+ if (maxDensity === 0) maxDensity = 1;
+
+ // Add padding to domain
+ const xPadding = (maxX - minX) * 0.1;
+ const xDomain = [Math.max(0, minX - xPadding), maxX + xPadding];
+
+ // Set up scales
+ const xScale = d3.scaleLinear().domain(xDomain).range([0, width]);
+ const yScale = d3.scaleLinear().domain([0, maxDensity * 1.1]).range([height, 0]);
+
+ // Apply the current zoom transform
+ const xScaleZoomed = d3.scaleLinear()
+ .domain([Math.max(0, transform.rescaleX(xScale).domain()[0]), transform.rescaleX(xScale).domain()[1]])
+ .range([0, width]);
+
+ const yScaleZoomed = d3.scaleLinear()
+ .domain([Math.max(0, transform.rescaleY(yScale).domain()[0]), transform.rescaleY(yScale).domain()[1]])
+ .range([height, 0]);
+ // Create axes
+ const xAxis = d3.axisBottom(xScaleZoomed).ticks(10).tickSize(-height);
+ const yAxis = d3.axisLeft(yScaleZoomed).ticks(5).tickSize(-width);
+
+ // Add X axis with label
+ const xAxisGroup = svg
+ .append("g")
+ .attr("class", "x-axis")
+ .attr("transform", `translate(0,${height})`)
+ .call(xAxis);
+
+ svg
+ .append("text")
+ .attr("transform", `translate(${width / 2}, ${height + margin.bottom - 5})`)
+ .style("text-anchor", "middle")
+ .style("font-family", "monospace")
+ .style("font-size", "10px")
+ .style("fill", theme.palette.text.secondary)
+ .text("Frame Duration (ms)");
+
+ // Add Y axis with label
+ const yAxisGroup = svg
+ .append("g")
+ .attr("class", "y-axis")
+ .call(yAxis);
+
+ svg
+ .append("text")
+ .attr("transform", "rotate(-90)")
+ .attr("y", 0 - margin.left)
+ .attr("x", 0 - height / 2)
+ .attr("dy", "1em")
+ .style("text-anchor", "middle")
+ .style("font-family", "monospace")
+ .style("font-size", "10px")
+ .style("fill", theme.palette.text.secondary)
+ .text("Density");
+
+ // Style axes
+ applyAxisStyles(svg, theme);
+
+ // Add threshold lines
+ // const thresholds = [
+ // { value: 16.67, label: "60 FPS", color: theme.palette.success.main },
+ // { value: 33.33, label: "30 FPS", color: theme.palette.warning.main },
+ // ];
+ //
+ // renderThresholdLines(chartArea, thresholds, xScaleZoomed, yScaleZoomed, width, height, false);
+
+ // Draw histograms
+ sources.forEach(source => {
+ if (!source.histogram || source.histogram.bin_edges.length === 0) return;
+
+ const bins = source.histogram.bin_edges.map((edge, i) => ({
+ x0: edge,
+ x1: i < source.histogram!.bin_edges.length - 1 ? source.histogram!.bin_edges[i + 1] : edge + 0.1,
+ density: i < source.histogram!.bin_densities.length ? source.histogram!.bin_densities[i] : 0,
+ count: i < source.histogram!.bin_counts.length ? source.histogram!.bin_counts[i] : 0
+ }));
+
+ // Add histogram bars
+ chartArea
+ .selectAll(`.bar-${source.id}`)
+ .data(bins)
+ .enter()
+ .append("rect")
+ .attr("class", `bar-${source.id}`)
+ .attr("x", d => xScaleZoomed(d.x0))
+ .attr("width", d => Math.max(0, xScaleZoomed(d.x1) - xScaleZoomed(d.x0) - 1))
+ .attr("y", d => {
+ const y = yScaleZoomed(d.density);
+ // Ensure y is valid and not greater than height
+ return isNaN(y) ? height : Math.min(height, Math.max(0, y));
+ })
+ .attr("height", d => {
+ const y = yScaleZoomed(d.density);
+ // Calculate height ensuring it's always positive
+ if (isNaN(y)) return 0;
+ const barHeight = height - Math.min(height, Math.max(0, y));
+ return Math.max(0, barHeight);
+ })
+ .attr("fill", source.color)
+ .attr("stroke", theme.palette.background.paper)
+ .attr("stroke-width", 0.5)
+ .attr("opacity", 0.7);
+ });
+
+ // Add legend
+ const legend = svg
+ .append("g")
+ .attr("transform", `translate(${width + 10}, 0)`)
+ .attr("font-family", "monospace")
+ .attr("font-size", "10px");
+
+ sources.forEach((source, i) => {
+ if (!source.histogram) return;
+
+ const legendItem = legend.append("g").attr("transform", `translate(0, ${i * 20})`);
+ legendItem.append("rect").attr("width", 12).attr("height", 12).attr("fill", source.color);
+ legendItem.append("text")
+ .attr("x", 20)
+ .attr("y", 10)
+ .style("fill", theme.palette.text.primary)
+ .text(`${source.name} (${source.totalSamples})`);
+ });
+
+ // Add tooltip
+ const tooltip = createTooltip(theme);
+
+ // Add tooltip for histogram bars
+ sources.forEach(source => {
+ if (!source.histogram) return;
+
+ chartArea
+ .selectAll(`.bar-${source.id}`)
+ .on("mouseover", function (event, d: any) {
+ d3.select(this).attr("opacity", 1).attr("stroke-width", 1);
+
+ tooltip
+ .style("opacity", 1)
+ .html(`
+ <div style="display: grid; grid-template-columns: auto auto; gap: 4px;">
+ <span style="color: ${theme.palette.text.secondary};">SOURCE:</span>
+ <span style="color: ${source.color};">${source.name}</span>
+ <span style="color: ${theme.palette.text.secondary};">RANGE:</span>
+ <span>${d.x0.toFixed(2)} - ${d.x1.toFixed(2)} ms</span>
+ <span style="color: ${theme.palette.text.secondary};">COUNT:</span>
+ <span>${d.count} samples</span>
+ <span style="color: ${theme.palette.text.secondary};">PERCENTAGE:</span>
+ <span>${(d.density * 100).toFixed(1)}%</span>
+ <span style="color: ${theme.palette.text.secondary};">FPS RANGE:</span>
+ <span>${(1000 / d.x1).toFixed(1)} - ${(1000 / d.x0).toFixed(1)} fps</span>
+ </div>
+ `)
+ .style("left", event.pageX + 10 + "px")
+ .style("top", event.pageY - 28 + "px");
+ })
+ .on("mouseout", function () {
+ d3.select(this).attr("opacity", 0.7).attr("stroke-width", 0.5);
+ tooltip.style("opacity", 0);
+ });
+ });
+
+ return () => tooltip.remove();
+ }, [
+ frontendFramerate,
+ backendFramerate,
+ recentFrontendFrameDurations,
+ recentBackendFrameDurations,
+ frontendColor,
+ backendColor,
+ theme
+ ]);
+
+ return (
+ <BaseD3ChartView
+ title={title}
+ renderChart={renderChart}
+ />
+ );
+}
diff --git a/freemocap-ui-old/src/components/framerate-viewer/FramerateStatisticsView.tsx b/freemocap-ui-old/src/components/framerate-viewer/FramerateStatisticsView.tsx
new file mode 100644
index 00000000..d02a685f
--- /dev/null
+++ b/freemocap-ui-old/src/components/framerate-viewer/FramerateStatisticsView.tsx
@@ -0,0 +1,495 @@
+// src/components/framerate-viewer/FramerateStatisticsView.tsx
+import {
+ Box,
+ Divider,
+ Paper,
+ Table,
+ TableBody,
+ TableCell,
+ TableContainer,
+ TableHead,
+ TableRow,
+ Tooltip,
+ Typography,
+} from "@mui/material";
+import {alpha, useTheme} from "@mui/material/styles";
+import {CurrentFramerate} from "@/store/slices/framerate/framerate-slice";
+import {useState} from "react";
+
+type FramerateStatisticsViewProps = {
+ frontendFramerate: CurrentFramerate | null;
+ backendFramerate: CurrentFramerate | null;
+ compact?: boolean;
+};
+
+// Format number with fixed precision
+const formatNumber = (num: number | null, precision = 3) => {
+ return num !== null ? num.toFixed(precision) : "N/A";
+};
+
+type ProgressiveTooltipProps = {
+ shortInfo: string;
+ longInfo: string;
+ children: React.ReactElement;
+};
+
+// Progressive tooltip component that shows more info on click
+export const ProgressiveTooltip = ({
+ shortInfo,
+ longInfo,
+ children,
+ }: ProgressiveTooltipProps) => {
+ const [isExpanded, setIsExpanded] = useState(false);
+ const theme = useTheme();
+
+ const handleTooltipClick = (e: React.MouseEvent) => {
+ e.preventDefault();
+ setIsExpanded(!isExpanded);
+ };
+
+ return (
+ <Tooltip
+ title={
+ <Box onClick={handleTooltipClick} sx={{cursor: "pointer"}}>
+ <Typography variant="body2">
+ {isExpanded ? longInfo : shortInfo}
+ </Typography>
+ <Typography
+ variant="caption"
+ color="text.secondary"
+ sx={{display: "block", mt: 1, textAlign: "center"}}
+ >
+ {isExpanded ? "Click to show less" : "Click to learn more"}
+ </Typography>
+ </Box>
+ }
+ arrow
+ placement="top"
+ componentsProps={{
+ tooltip: {
+ sx: {
+ backgroundColor: theme.palette.background.paper,
+ color: theme.palette.text.primary,
+ border: `1px solid ${theme.palette.divider}`,
+ boxShadow: theme.shadows[3],
+ maxWidth: isExpanded ? 500 : 300,
+ p: 1.5,
+ },
+ },
+ }}
+ >
+ {children}
+ </Tooltip>
+ );
+};
+
+type HeaderCellWithTooltipProps = {
+ label: string;
+ shortInfo: string;
+ longInfo: string;
+ style?: object;
+ align?: "inherit" | "left" | "center" | "right" | "justify";
+};
+
+// Reusable tooltip component for column headers
+export const HeaderCellWithTooltip = ({
+ label,
+ shortInfo,
+ longInfo,
+ style = {},
+ align = "center",
+ }: HeaderCellWithTooltipProps) => {
+ return (
+ <ProgressiveTooltip shortInfo={shortInfo} longInfo={longInfo}>
+ <TableCell align={align} sx={style}>
+ {label}
+ </TableCell>
+ </ProgressiveTooltip>
+ );
+};
+
+type FramerateRowProps = {
+ framerateData: CurrentFramerate | null;
+ colorMap: Record<string, string>;
+ getCellStyle: (metricType: string) => object;
+ isDarkMode: boolean;
+ theme: any;
+ shortTooltip: string;
+ longTooltip: string;
+};
+
+const FramerateRow = ({
+ framerateData,
+ colorMap,
+ getCellStyle,
+ isDarkMode,
+ theme,
+ shortTooltip,
+ longTooltip,
+ }: FramerateRowProps) => {
+ const isBackend =
+ framerateData?.framerate_source === "Backend" ||
+ (!framerateData?.framerate_source && framerateData);
+
+ return (
+ <TableRow>
+ <ProgressiveTooltip shortInfo={shortTooltip} longInfo={longTooltip}>
+ <TableCell
+ sx={{
+ fontWeight: "bold",
+ borderLeft: `3px solid ${colorMap.current}`,
+ paddingY: 0.5,
+ color: isDarkMode
+ ? isBackend
+ ? theme.palette.secondary.light
+ : theme.palette.primary.light
+ : isBackend
+ ? theme.palette.secondary.main
+ : theme.palette.primary.main,
+ cursor: "help",
+ }}
+ >
+ {framerateData?.framerate_source ||
+ (isBackend ? "Backend" : "Frontend")}
+ <Typography
+ variant="caption"
+ display="block"
+ color="text.secondary"
+ sx={{fontSize: "0.6rem"}}
+ >
+ {framerateData?.calculation_window_size || 0} samples
+ </Typography>
+ </TableCell>
+ </ProgressiveTooltip>
+
+ <MetricCell
+ label="current"
+ colorMap={colorMap}
+ getCellStyle={getCellStyle}
+ primaryValue={framerateData?.mean_frame_duration_ms}
+ primarySuffix="ms"
+ secondaryValue={framerateData?.mean_frames_per_second}
+ secondarySuffix="fps"
+ />
+
+ <MetricCell
+ label="min"
+ colorMap={colorMap}
+ getCellStyle={getCellStyle}
+ primaryValue={framerateData?.frame_duration_min}
+ primarySuffix="ms"
+ secondaryValue={
+ framerateData?.frame_duration_min &&
+ framerateData.frame_duration_min > 0
+ ? 1000 / framerateData.frame_duration_min
+ : null
+ }
+ secondarySuffix="fps"
+ />
+
+ <MetricCell
+ label="max"
+ colorMap={colorMap}
+ getCellStyle={getCellStyle}
+ primaryValue={framerateData?.frame_duration_max}
+ primarySuffix="ms"
+ secondaryValue={
+ framerateData?.frame_duration_max &&
+ framerateData.frame_duration_max > 0
+ ? 1000 / framerateData.frame_duration_max
+ : null
+ }
+ secondarySuffix="fps"
+ />
+
+ <MetricCell
+ label="mean"
+ colorMap={colorMap}
+ getCellStyle={getCellStyle}
+ primaryValue={framerateData?.frame_duration_mean}
+ primarySuffix="ms"
+ secondaryValue={framerateData?.frame_duration_mean && framerateData.frame_duration_mean > 0
+ ? 1000 / framerateData.frame_duration_mean
+ : null}
+ secondarySuffix="fps"
+ />
+
+ <MetricCell
+ label="median"
+ colorMap={colorMap}
+ getCellStyle={getCellStyle}
+ primaryValue={framerateData?.frame_duration_median}
+ primarySuffix="ms"
+ secondaryValue={framerateData?.frame_duration_median && framerateData.frame_duration_median > 0
+ ? 1000 / framerateData.frame_duration_median
+ : null}
+ secondarySuffix="fps"
+ />
+
+ <MetricCell
+ label="stdDev"
+ colorMap={colorMap}
+ getCellStyle={getCellStyle}
+ primaryValue={framerateData?.frame_duration_stddev}
+ primarySuffix="ms"
+ secondaryValue={
+ framerateData
+ ? framerateData.frame_duration_coefficient_of_variation * 100
+ : null
+ }
+ secondarySuffix="CV%"
+ />
+ </TableRow>
+ );
+};
+
+type MetricCellProps = {
+ label: string;
+ colorMap: Record<string, string>;
+ getCellStyle: (metricType: string) => object;
+ primaryValue: number | null | undefined;
+ primarySuffix?: string;
+ secondaryValue?: number | null | undefined;
+ secondarySuffix?: string;
+};
+
+const MetricCell = ({
+ label,
+ colorMap,
+ getCellStyle,
+ primaryValue,
+ primarySuffix = "",
+ secondaryValue,
+ secondarySuffix = "",
+ }: MetricCellProps) => {
+ return (
+ <TableCell align="center" sx={getCellStyle(label)}>
+ <Typography
+ fontWeight="bold"
+ fontFamily="monospace"
+ color={colorMap[label]}
+ sx={{fontSize: "0.7rem", whiteSpace: "nowrap"}}
+ >
+ {formatNumber(primaryValue ?? null)} {primarySuffix}
+ </Typography>
+ {secondaryValue !== undefined && (
+ <Typography
+ variant="caption"
+ color={colorMap[label]}
+ sx={{fontSize: "0.6rem", opacity: 0.9, whiteSpace: "nowrap"}}
+ >
+ {formatNumber(secondaryValue ?? null)} {secondarySuffix}
+ </Typography>
+ )}
+ </TableCell>
+ );
+};
+
+export default function FramerateStatisticsView({
+ frontendFramerate,
+ backendFramerate,
+ compact = false,
+ }: FramerateStatisticsViewProps) {
+ const theme = useTheme();
+ const isDarkMode = theme.palette.mode === "dark";
+
+ // Define color map with high contrast for both light and dark themes
+ const colorMap: Record<string, string> = {
+ current: isDarkMode
+ ? theme.palette.success.light
+ : theme.palette.success.main,
+ min: isDarkMode ? theme.palette.info.light : theme.palette.info.main,
+ max: isDarkMode ? theme.palette.error.light : theme.palette.error.main,
+ mean: isDarkMode ? theme.palette.warning.light : theme.palette.warning.main,
+ median: isDarkMode
+ ? theme.palette.warning.dark
+ : theme.palette.warning.dark,
+ stdDev: isDarkMode
+ ? theme.palette.primary.light
+ : theme.palette.primary.main,
+ cv: isDarkMode
+ ? theme.palette.secondary.light
+ : theme.palette.secondary.main,
+ };
+
+ // Generate cell style based on metric type
+ const getCellStyle = (metricType: string) => {
+ return {
+ backgroundColor: alpha(
+ colorMap[metricType] || theme.palette.grey[500],
+ isDarkMode ? 0.2 : 0.1
+ ),
+ borderBottom: "none",
+ padding: "2px 4px",
+ };
+ };
+
+ // Common header cell styles
+ const headerCellStyle = {
+ fontWeight: "bold",
+ paddingY: 0.5,
+ };
+
+ // Tooltips content - short and long versions
+ const tooltips = {
+ source: {
+ short: "Frontend displays frames, Backend captures frames.",
+ long: "The backend is the true rate at which frames are pulled/recorded from the camera, while the frontend is the rate at which they are received and displayed. Skellycam prioritizes backend performance for recording quality, so that number should stay more stable. If the frontend framerate diverges from the backend, it indicates your system resources are taxed. Consider using fewer cameras or decreasing framerate/resolution.",
+ },
+ current: {
+ short: "Most recent frame time and corresponding FPS.",
+ long: "This shows the most recent measurement of how long it takes to process a single frame (in milliseconds) and the equivalent frames per second (FPS). Lower frame times and higher FPS indicate better performance.",
+ },
+ min: {
+ short: "Fastest frame time (lowest latency) and highest FPS achieved.",
+ long: "This represents the minimum time it took to process a single frame during the sampling window. This corresponds to the maximum FPS your system achieved during optimal conditions.",
+ },
+ max: {
+ short: "Slowest frame time (highest latency) and lowest FPS experienced.",
+ long: "This represents the maximum time it took to process a single frame during the sampling window. This corresponds to the minimum FPS your system achieved during worst-case conditions. Occasional spikes are normal, but consistently high values may indicate performance issues.",
+ },
+ mean: {
+ short: "Average frame time and FPS across all samples.",
+ long: "The arithmetic mean (average) of all frame times measured during the sampling window and the corresponding FPS. This gives a good overall picture of performance but may be skewed by outliers.",
+ },
+ median: {
+ short: "Middle value of all frame times (50th percentile).",
+ long: "The median represents the middle value when all frame times are sorted from fastest to slowest. Unlike the mean, the median is not affected by extreme outliers, making it a more stable indicator of typical performance.",
+ },
+ stdDev: {
+ short: "Measures frame time variability. CV% is relative variability.",
+ long: "Standard deviation measures the amount of variation in frame times. Lower values indicate more consistent performance. The Coefficient of Variation (CV%) expresses this variability as a percentage of the mean, making it easier to compare stability across different frame rates. Lower CV% indicates more stable performance.",
+ },
+ };
+
+ return (
+ <TableContainer
+ component={Paper}
+ elevation={0}
+ sx={{
+ backgroundColor: "transparent",
+ border: "none",
+ overflowX: "auto",
+ }}
+ >
+ <Table
+ size="small"
+ padding="none"
+ sx={{
+ "& .MuiTableCell-root": {
+ fontSize: "0.65rem",
+ lineHeight: "1.1",
+ whiteSpace: "nowrap",
+ },
+ }}
+ >
+ <TableHead>
+ <TableRow>
+ <HeaderCellWithTooltip
+ label="Source"
+ shortInfo={tooltips.source.short}
+ longInfo={tooltips.source.long}
+ style={{
+ ...headerCellStyle,
+ width: "12%",
+ color: theme.palette.text.primary,
+ }}
+ align="left"
+ />
+ <HeaderCellWithTooltip
+ label="Current"
+ shortInfo={tooltips.current.short}
+ longInfo={tooltips.current.long}
+ style={{
+ ...headerCellStyle,
+ ...getCellStyle("current"),
+ }}
+ />
+ <HeaderCellWithTooltip
+ label="Min"
+ shortInfo={tooltips.min.short}
+ longInfo={tooltips.min.long}
+ style={{
+ ...headerCellStyle,
+ ...getCellStyle("min"),
+ }}
+ />
+ <HeaderCellWithTooltip
+ label="Max"
+ shortInfo={tooltips.max.short}
+ longInfo={tooltips.max.long}
+ style={{
+ ...headerCellStyle,
+ ...getCellStyle("max"),
+ }}
+ />
+ <HeaderCellWithTooltip
+ label="Mean"
+ shortInfo={tooltips.mean.short}
+ longInfo={tooltips.mean.long}
+ style={{
+ ...headerCellStyle,
+ ...getCellStyle("mean"),
+ }}
+ />
+ <HeaderCellWithTooltip
+ label="Median"
+ shortInfo={tooltips.median.short}
+ longInfo={tooltips.median.long}
+ style={{
+ ...headerCellStyle,
+ ...getCellStyle("median"),
+ }}
+ />
+ <HeaderCellWithTooltip
+ label="StdDev/CV"
+ shortInfo={tooltips.stdDev.short}
+ longInfo={tooltips.stdDev.long}
+ style={{
+ ...headerCellStyle,
+ ...getCellStyle("stdDev"),
+ }}
+ />
+ </TableRow>
+ {/* Add the divider inside TableHead */}
+ <TableRow>
+ <TableCell colSpan={7} sx={{padding: 0}}>
+ <Divider sx={{borderColor: theme.palette.divider}}/>
+ </TableCell>
+ </TableRow>
+ </TableHead>
+
+ <TableBody>
+ {/* Frontend Row */}
+ <FramerateRow
+ framerateData={frontendFramerate}
+ colorMap={colorMap}
+ getCellStyle={getCellStyle}
+ isDarkMode={isDarkMode}
+ theme={theme}
+ shortTooltip="Displays received frames."
+ longTooltip="Frontend represents the UI rendering performance. It shows how quickly your display receives and renders frames. Performance issues here won't affect recording quality but may impact your ability to monitor cameras in real-time."
+ />
+
+ {/* Divider between rows - now properly inside TableBody */}
+ <TableRow>
+ <TableCell colSpan={7} sx={{padding: 0}}>
+ <Divider sx={{borderColor: theme.palette.divider}}/>
+ </TableCell>
+ </TableRow>
+
+ {/* Backend Row */}
+ <FramerateRow
+ framerateData={backendFramerate}
+ colorMap={colorMap}
+ getCellStyle={getCellStyle}
+ isDarkMode={isDarkMode}
+ theme={theme}
+ shortTooltip="Captures frames from camera."
+ longTooltip="Backend represents the camera frame-grabbing performance. This is the true rate at which frames are pulled from the camera and saved during recording. This is the most important metric for recording quality and should remain stable even if frontend performance fluctuates."
+ />
+ </TableBody>
+ </Table>
+ </TableContainer>
+ );
+}
diff --git a/freemocap-ui-old/src/components/framerate-viewer/FramerateTimeseriesView.tsx b/freemocap-ui-old/src/components/framerate-viewer/FramerateTimeseriesView.tsx
new file mode 100644
index 00000000..41e946a2
--- /dev/null
+++ b/freemocap-ui-old/src/components/framerate-viewer/FramerateTimeseriesView.tsx
@@ -0,0 +1,237 @@
+// src/components/framerate-viewer/FramerateTimeseriesView.tsx
+import {useCallback} from "react"
+import * as d3 from "d3"
+import {useTheme} from "@mui/material/styles"
+import {CurrentFramerate} from "@/store/slices/framerate/framerate-slice"
+import {applyAxisStyles, createTooltip, renderEmptyChart} from "@/components/framerate-viewer/d3ChartUtils";
+import BaseD3ChartView from "@/components/framerate-viewer/BaseD3ChartView";
+
+type FramerateTimeseriesProps = {
+ frontendFramerate: CurrentFramerate | null
+ backendFramerate: CurrentFramerate | null
+ recentFrontendFrameDurations: number[]
+ recentBackendFrameDurations: number[]
+ frontendColor: string
+ backendColor: string
+ title?: string
+}
+type ChartRenderProps = {
+ svg: d3.Selection<SVGGElement, unknown, null, undefined>;
+ chartArea: d3.Selection<SVGGElement, unknown, null, undefined>;
+ width: number;
+ height: number;
+ margin: { top: number; right: number; bottom: number; left: number };
+ transform: d3.ZoomTransform;
+};
+
+export default function FramerateTimeseriesView({
+ frontendFramerate,
+ backendFramerate,
+ recentFrontendFrameDurations,
+ recentBackendFrameDurations,
+ frontendColor,
+ backendColor,
+ title = "Frame Duration Over Time"
+ }: FramerateTimeseriesProps) {
+ const theme = useTheme()
+
+ const renderChart = useCallback(({svg, chartArea, width, height, margin, transform}: ChartRenderProps) => {
+ // Prepare data sources - using the recent frame durations arrays
+ const sources = [
+ {
+ id: "frontend",
+ name: frontendFramerate?.framerate_source || "Frontend",
+ color: frontendColor,
+ data: recentFrontendFrameDurations.map((value, index) => ({
+ timestamp: Date.now() - (recentFrontendFrameDurations.length - index) *
+ (frontendFramerate?.mean_frame_duration_ms || 16.67),
+ value
+ }))
+ },
+ {
+ id: "backend",
+ name: backendFramerate?.framerate_source || "Backend",
+ color: backendColor,
+ data: recentBackendFrameDurations.map((value, index) => ({
+ timestamp: Date.now() - (recentBackendFrameDurations.length - index) *
+ (backendFramerate?.mean_frame_duration_ms || 33.33),
+ value
+ }))
+ }
+ ];
+
+ if (sources.every((s) => s.data.length === 0)) {
+ renderEmptyChart(svg, width, height, theme);
+ return;
+ }
+
+ // Combine all data points to determine overall domain
+ const allData = sources.flatMap((s) => s.data);
+
+ // Set up scales
+ const xScale = d3
+ .scaleTime()
+ .domain(d3.extent(allData, (d) => new Date(d.timestamp)) as [Date, Date])
+ .range([0, width]);
+
+ // Calculate y domain with some padding
+ const yMax = d3.max(allData, (d) => d.value) as number;
+ const yPadding = Math.max(1, yMax * 0.1);
+
+ const yScale = d3
+ .scaleLinear()
+ .domain([0, yMax + yPadding])
+ .range([height, 0]);
+
+ // Apply the current zoom transform
+ const xScaleZoomed = transform.rescaleX(xScale);
+ const yScaleZoomed = transform.rescaleY(yScale);
+
+ // Create axes
+ const xAxis = d3
+ .axisBottom(xScaleZoomed)
+ .ticks(5)
+ .tickSize(-height)
+ .tickFormat(d3.timeFormat("%H:%M:%S") as any);
+
+ const yAxis = d3.axisLeft(yScaleZoomed).ticks(10).tickSize(-width);
+
+ // Add X axis
+ const xAxisGroup = svg
+ .append("g")
+ .attr("class", "x-axis")
+ .attr("transform", `translate(0,${height})`)
+ .call(xAxis);
+
+ xAxisGroup
+ .selectAll("text")
+ .style("text-anchor", "end")
+ .attr("dx", "-.8em")
+ .attr("dy", ".15em")
+ .attr("transform", "rotate(-45)");
+
+ // Add Y axis
+ const yAxisGroup = svg
+ .append("g")
+ .attr("class", "y-axis")
+ .call(yAxis);
+
+ // Add Y axis label
+ svg
+ .append("text")
+ .attr("transform", "rotate(-90)")
+ .attr("y", 0 - margin.left)
+ .attr("x", 0 - height / 2)
+ .attr("dy", "1em")
+ .style("text-anchor", "middle")
+ .style("font-family", "monospace")
+ .style("font-size", "14px")
+ .style("fill", theme.palette.text.secondary)
+ .text("Frame Duration (ms)");
+
+ // Style axes
+ applyAxisStyles(svg, theme);
+
+ // Add threshold lines
+ // const thresholds = [
+ // { value: 16.67, label: "60 FPS", color: theme.palette.success.main },
+ // { value: 33.33, label: "30 FPS", color: theme.palette.warning.main },
+ // ];
+ //
+ // renderThresholdLines(chartArea, thresholds, xScaleZoomed, yScaleZoomed, width, height, true);
+
+ // Create line generator
+ const line = d3
+ .line<{ timestamp: number, value: number }>()
+ .x((d) => xScaleZoomed(new Date(d.timestamp)))
+ .y((d) => yScaleZoomed(d.value))
+ .curve(d3.curveLinear);
+
+ // Add lines and points for each source
+ sources.forEach((source) => {
+ if (source.data.length === 0) return;
+
+ // Add the line path
+ chartArea
+ .append("path")
+ .datum(source.data)
+ .attr("fill", "none")
+ .attr("stroke", source.color)
+ .attr("stroke-width", 1.5)
+ .attr("d", line);
+
+ });
+
+ // Add legend
+ const legend = svg
+ .append("g")
+ .attr("transform", `translate(${width + 10}, 0)`)
+ .attr("font-family", "monospace")
+ .attr("font-size", "10px");
+
+ sources.forEach((source, i) => {
+ if (source.data.length === 0) return;
+
+ const legendItem = legend.append("g").attr("transform", `translate(0, ${i * 20})`);
+ legendItem.append("rect").attr("width", 12).attr("height", 12).attr("fill", source.color);
+ legendItem.append("text")
+ .attr("x", 20)
+ .attr("y", 10)
+ .style("fill", theme.palette.text.primary)
+ .text(source.name);
+ });
+
+ // Add tooltip
+ const tooltip = createTooltip(theme);
+
+ // Add tooltip for data points
+ sources.forEach((source) => {
+ if (source.data.length === 0) return;
+
+ chartArea
+ .selectAll(`.data-point-${source.id}`)
+ .on("mouseover", function (event: MouseEvent, d: any) {
+ const element = this as unknown as SVGCircleElement;
+ d3.select(element).attr("r", 5).attr("fill", d3.color(source.color)!.brighter(0.5).toString());
+
+ tooltip
+ .style("opacity", 1)
+ .html(`
+ <div style="display: grid; grid-template-columns: auto auto; gap: 4px;">
+ <span style="color: ${theme.palette.text.secondary};">SOURCE:</span>
+ <span style="color: ${source.color};">${source.name}</span>
+ <span style="color: ${theme.palette.text.secondary};">TIME:</span>
+ <span>${new Date(d.timestamp).toISOString().substr(11, 12)}</span>
+ <span style="color: ${theme.palette.text.secondary};">DURATION:</span>
+ <span>${d.value.toFixed(2)} ms</span>
+ <span style="color: ${theme.palette.text.secondary};">FPS:</span>
+ <span>${(1000 / d.value).toFixed(2)}</span>
+ </div>
+ `)
+ .style("left", event.pageX + 10 + "px")
+ .style("top", event.pageY - 28 + "px");
+ })
+ .on("mouseout", function (event: MouseEvent, d: any) {
+ d3.select(this).attr("r", 3).attr("fill", source.color);
+ tooltip.style("opacity", 0);
+ });
+ });
+
+ return () => tooltip.remove();
+ }, [
+ frontendFramerate,
+ backendFramerate,
+ recentFrontendFrameDurations,
+ recentBackendFrameDurations,
+ frontendColor,
+ backendColor,
+ theme
+ ]);
+
+ return (
+ <BaseD3ChartView
+ title={title}
+ renderChart={renderChart}
+ />
+ );
+}
diff --git a/freemocap-ui-old/src/components/framerate-viewer/d3ChartUtils.ts b/freemocap-ui-old/src/components/framerate-viewer/d3ChartUtils.ts
new file mode 100644
index 00000000..f29950d1
--- /dev/null
+++ b/freemocap-ui-old/src/components/framerate-viewer/d3ChartUtils.ts
@@ -0,0 +1,212 @@
+// src/components/framerate-viewer/d3ChartUtils.ts
+import * as d3 from "d3"
+import {Theme} from "@mui/material/styles"
+
+export function createTooltip(theme: Theme) {
+ return d3
+ .select("body")
+ .append("div")
+ .style("position", "absolute")
+ .style("background-color", theme.palette.mode === "dark" ? "rgba(0, 0, 0, 0.85)" : "rgba(255, 255, 255, 0.9)")
+ .style("border", `1px solid ${theme.palette.divider}`)
+ .style("border-radius", "4px")
+ .style("padding", "8px")
+ .style("font-family", "monospace")
+ .style("font-size", "12px")
+ .style("pointer-events", "none")
+ .style("opacity", 0)
+ .style("z-index", 1000)
+ .style("color", theme.palette.text.primary)
+}
+
+export function applyAxisStyles(
+ svg: d3.Selection<SVGGElement, unknown, null, undefined>,
+ theme: Theme
+) {
+ svg.selectAll(".tick line")
+ .attr("stroke", theme.palette.divider)
+ .attr("stroke-dasharray", "2,2")
+
+ svg.selectAll(".tick text")
+ .style("font-family", "monospace")
+ .style("font-size", "10px")
+ .style("color", theme.palette.text.secondary)
+}
+
+export function renderEmptyChart(
+ svg: d3.Selection<SVGGElement, unknown, null, undefined>,
+ width: number,
+ height: number,
+ theme: Theme
+) {
+ // Create empty scales
+ const xScale = d3.scaleLinear().domain([0, 100]).range([0, width])
+ const yScale = d3.scaleLinear().domain([0, 10]).range([height, 0])
+
+ // Create axes
+ const xAxis = d3.axisBottom(xScale).ticks(10).tickSize(-height)
+ const yAxis = d3.axisLeft(yScale).ticks(5).tickSize(-width)
+
+ // Add X axis
+ svg
+ .append("g")
+ .attr("class", "x-axis")
+ .style("font-family", "monospace")
+ .style("font-size", "10px")
+ .style("color", theme.palette.text.secondary)
+ .attr("transform", `translate(0,${height})`)
+ .call(xAxis)
+
+ // Add Y axis
+ svg
+ .append("g")
+ .attr("class", "y-axis")
+ .style("font-family", "monospace")
+ .style("font-size", "10px")
+ .style("color", theme.palette.text.secondary)
+ .call(yAxis)
+
+ // Style grid lines
+ svg.selectAll(".tick line").attr("stroke", theme.palette.divider).attr("stroke-dasharray", "2,2")
+
+ // Add "No data" message
+ svg
+ .append("text")
+ .attr("x", width / 2)
+ .attr("y", height / 2)
+ .attr("text-anchor", "middle")
+ .style("font-family", "monospace")
+ .style("font-size", "14px")
+ .style("fill", theme.palette.text.disabled)
+ .text("No data available")
+}
+
+export function renderThresholdLines(
+ chartArea: d3.Selection<SVGGElement, unknown, null, undefined>,
+ thresholds: { value: number, label: string, color: string }[],
+ xScale: any, // Allow both time and linear scales
+ yScale: d3.ScaleLinear<number, number>,
+ width: number,
+ height: number,
+ isHorizontal: boolean
+) {
+ thresholds.forEach((threshold) => {
+ if (isHorizontal) {
+ // Horizontal threshold line (for time series)
+ chartArea
+ .append("line")
+ .attr("class", "threshold-line")
+ .attr("x1", 0)
+ .attr("y1", yScale(threshold.value))
+ .attr("x2", width)
+ .attr("y2", yScale(threshold.value))
+ .attr("stroke", threshold.color)
+ .attr("stroke-width", 1)
+ .attr("stroke-dasharray", "4,4")
+
+ // Add threshold label
+ chartArea
+ .append("text")
+ .attr("class", "threshold-label")
+ .attr("x", width)
+ .attr("y", yScale(threshold.value) - 5)
+ .attr("text-anchor", "end")
+ .style("font-family", "monospace")
+ .style("font-size", "10px")
+ .style("fill", threshold.color)
+ .text(threshold.label)
+ } else {
+ // Vertical threshold line (for histogram)
+ chartArea
+ .append("line")
+ .attr("class", "threshold-line")
+ .attr("x1", xScale(threshold.value))
+ .attr("y1", 0)
+ .attr("x2", xScale(threshold.value))
+ .attr("y2", height)
+ .attr("stroke", threshold.color)
+ .attr("stroke-width", 1.5)
+ .attr("stroke-dasharray", "4,4")
+
+ // Add threshold label
+ chartArea
+ .append("text")
+ .attr("class", "threshold-label")
+ .attr("x", xScale(threshold.value))
+ .attr("y", 15)
+ .attr("text-anchor", "middle")
+ .style("font-family", "monospace")
+ .style("font-size", "10px")
+ .style("fill", threshold.color)
+ .text(threshold.label)
+ }
+ })
+}
+
+// Helper functions for zoom updates
+
+// Update thresholds on zoom
+export function updateThresholdsOnZoom(
+ chartArea: d3.Selection<SVGGElement, unknown, null, undefined>,
+ transform: d3.ZoomTransform,
+ xScale: any,
+ yScale: d3.ScaleLinear<number, number>,
+ isHorizontal: boolean
+) {
+ if (isHorizontal) {
+ // Update horizontal threshold lines
+ chartArea.selectAll(".threshold-line")
+ .attr("y1", (d: any) => transform.applyY(yScale(d.value)))
+ .attr("y2", (d: any) => transform.applyY(yScale(d.value)));
+
+ // Update labels
+ chartArea.selectAll(".threshold-label")
+ .attr("y", (d: any) => transform.applyY(yScale(d.value)) - 5);
+ } else {
+ // Update vertical threshold lines
+ chartArea.selectAll(".threshold-line")
+ .attr("x1", (d: any) => transform.applyX(xScale(d.value)))
+ .attr("x2", (d: any) => transform.applyX(xScale(d.value)));
+
+ // Update labels
+ chartArea.selectAll(".threshold-label")
+ .attr("x", (d: any) => transform.applyX(xScale(d.value)));
+ }
+}
+
+// Update histogram bars on zoom
+export function updateHistogramBarsOnZoom(
+ chartArea: d3.Selection<SVGGElement, unknown, null, undefined>,
+ selector: string,
+ transform: d3.ZoomTransform,
+ xScale: d3.ScaleLinear<number, number>,
+ yScale: d3.ScaleLinear<number, number>,
+ height: number
+) {
+ chartArea.selectAll(selector)
+ .attr("x", (d: any) => transform.applyX(xScale(d.x0)))
+ .attr("y", (d: any) => transform.applyY(yScale(d.density)))
+ .attr("width", (d: any) => Math.max(0, transform.k * (xScale(d.x1) - xScale(d.x0)) - 1))
+ .attr("height", (d: any) => height - transform.applyY(yScale(d.density)));
+}
+
+// Update time series lines on zoom
+export function updateTimeSeriesOnZoom(
+ chartArea: d3.Selection<SVGGElement, unknown, null, undefined>,
+ transform: d3.ZoomTransform,
+ xScale: d3.ScaleTime<number, number>,
+ yScale: d3.ScaleLinear<number, number>
+) {
+ // Update line paths
+ chartArea.selectAll("path")
+ .attr("d", (data) =>
+ d3.line<any>()
+ .x(d => transform.applyX(xScale(new Date(d.timestamp))))
+ .y(d => transform.applyY(yScale(d.value)))
+ .curve(d3.curveLinear)(data as any)
+ );
+ // Update data points
+ chartArea.selectAll("circle")
+ .attr("cx", (d: any) => transform.applyX(xScale(new Date(d.timestamp))))
+ .attr("cy", (d: any) => transform.applyY(yScale(d.value)));
+}
diff --git a/freemocap-ui-old/src/components/mocap-control-panel/MediapipeConfigPanel.tsx b/freemocap-ui-old/src/components/mocap-control-panel/MediapipeConfigPanel.tsx
new file mode 100644
index 00000000..0916d6a8
--- /dev/null
+++ b/freemocap-ui-old/src/components/mocap-control-panel/MediapipeConfigPanel.tsx
@@ -0,0 +1,229 @@
+import React, {useCallback} from "react";
+import {
+ Box,
+ Chip,
+ FormControl,
+ FormControlLabel,
+ InputLabel,
+ MenuItem,
+ Select,
+ Slider,
+ Stack,
+ Switch,
+ Typography,
+ useTheme,
+} from "@mui/material";
+import {useMocap} from "@/hooks/useMocap";
+import {
+ MEDIAPIPE_REALTIME_PRESET,
+ MEDIAPIPE_POSTHOC_PRESET,
+ MediapipeModelComplexity,
+} from "@/store/slices/mocap";
+
+const MODEL_COMPLEXITY_LABELS: Record<MediapipeModelComplexity, string> = {
+ 0: "Lite (fastest)",
+ 1: "Full (balanced)",
+ 2: "Heavy (most accurate)",
+};
+
+type DetectorPreset = "realtime" | "posthoc" | "custom";
+
+function detectPreset(
+ config: { model_complexity: number; enable_segmentation: boolean; smooth_segmentation: boolean }
+): DetectorPreset {
+ if (
+ config.model_complexity === 0 &&
+ !config.enable_segmentation &&
+ !config.smooth_segmentation
+ ) return "realtime";
+ if (
+ config.model_complexity === 2 &&
+ config.enable_segmentation &&
+ config.smooth_segmentation
+ ) return "posthoc";
+ return "custom";
+}
+
+/** Shared slider sx that matches the camera config panel style. */
+const useSliderSx = () => {
+ const theme = useTheme();
+ return {
+ color: theme.palette.primary.light,
+ "& .MuiSlider-thumb": {
+ "&:hover, &.Mui-focusVisible": {
+ boxShadow: `0px 0px 0px 8px ${theme.palette.primary.light}33`,
+ },
+ },
+ } as const;
+};
+
+export const MediapipeConfigPanel: React.FC = () => {
+ const theme = useTheme();
+ const sliderSx = useSliderSx();
+ const {detectorConfig, updateDetectorConfig, replaceDetectorConfig, isLoading} = useMocap();
+
+ const currentPreset = detectPreset(detectorConfig);
+
+ const handlePresetChange = useCallback(
+ (preset: DetectorPreset) => {
+ if (preset === "realtime") replaceDetectorConfig({...MEDIAPIPE_REALTIME_PRESET});
+ else if (preset === "posthoc") replaceDetectorConfig({...MEDIAPIPE_POSTHOC_PRESET});
+ },
+ [replaceDetectorConfig]
+ );
+
+ return (
+ <Stack spacing={2}>
+ <Typography variant="subtitle2" sx={{color: theme.palette.text.secondary, fontWeight: 600}}>
+ MediaPipe Detector
+ </Typography>
+
+ {/* Preset selector */}
+ <Stack direction="row" spacing={1} alignItems="center">
+ <Typography variant="caption" sx={{color: theme.palette.text.secondary, minWidth: 48}}>
+ Preset
+ </Typography>
+ <Chip
+ label="Realtime"
+ size="small"
+ variant={currentPreset === "realtime" ? "filled" : "outlined"}
+ color={currentPreset === "realtime" ? "primary" : "default"}
+ onClick={() => handlePresetChange("realtime")}
+ disabled={isLoading}
+ sx={{cursor: "pointer"}}
+ />
+ <Chip
+ label="Posthoc"
+ size="small"
+ variant={currentPreset === "posthoc" ? "filled" : "outlined"}
+ color={currentPreset === "posthoc" ? "primary" : "default"}
+ onClick={() => handlePresetChange("posthoc")}
+ disabled={isLoading}
+ sx={{cursor: "pointer"}}
+ />
+ {currentPreset === "custom" && (
+ <Chip label="Custom" size="small" variant="outlined" color="warning" />
+ )}
+ </Stack>
+
+ {/* Model complexity */}
+ <FormControl size="small" fullWidth>
+ <InputLabel id="model-complexity-label">Model Complexity</InputLabel>
+ <Select
+ labelId="model-complexity-label"
+ value={detectorConfig.model_complexity}
+ label="Model Complexity"
+ onChange={(e) =>
+ updateDetectorConfig({
+ model_complexity: e.target.value as MediapipeModelComplexity,
+ })
+ }
+ disabled={isLoading}
+ sx={{color: theme.palette.text.primary}}
+ >
+ <MenuItem value={0}>{MODEL_COMPLEXITY_LABELS[0]}</MenuItem>
+ <MenuItem value={1}>{MODEL_COMPLEXITY_LABELS[1]}</MenuItem>
+ <MenuItem value={2}>{MODEL_COMPLEXITY_LABELS[2]}</MenuItem>
+ </Select>
+ </FormControl>
+
+ {/* Confidence sliders */}
+ <Box>
+ <Typography variant="caption" color="text.secondary">
+ Min Detection Confidence: {detectorConfig.min_detection_confidence.toFixed(2)}
+ </Typography>
+ <Slider
+ value={detectorConfig.min_detection_confidence}
+ onChange={(_ , value) =>
+ updateDetectorConfig({min_detection_confidence: value as number})
+ }
+ min={0} max={1} step={0.05} size="small" disabled={isLoading}
+ sx={sliderSx}
+ />
+ </Box>
+
+ <Box>
+ <Typography variant="caption" color="text.secondary">
+ Min Tracking Confidence: {detectorConfig.min_tracking_confidence.toFixed(2)}
+ </Typography>
+ <Slider
+ value={detectorConfig.min_tracking_confidence}
+ onChange={(_, value) =>
+ updateDetectorConfig({min_tracking_confidence: value as number})
+ }
+ min={0} max={1} step={0.05} size="small" disabled={isLoading}
+ sx={sliderSx}
+ />
+ </Box>
+
+ {/* Boolean toggles */}
+ <Stack spacing={0}>
+ <FormControlLabel
+ control={
+ <Switch
+ size="small"
+ checked={detectorConfig.smooth_landmarks}
+ onChange={(_, checked) =>
+ updateDetectorConfig({smooth_landmarks: checked})
+ }
+ disabled={isLoading}
+ />
+ }
+ label={<Typography variant="body2">Smooth Landmarks</Typography>}
+ />
+ <FormControlLabel
+ control={
+ <Switch
+ size="small"
+ checked={detectorConfig.enable_segmentation}
+ onChange={(_, checked) =>
+ updateDetectorConfig({enable_segmentation: checked})
+ }
+ disabled={isLoading}
+ />
+ }
+ label={<Typography variant="body2">Enable Segmentation</Typography>}
+ />
+ <FormControlLabel
+ control={
+ <Switch
+ size="small"
+ checked={detectorConfig.smooth_segmentation}
+ onChange={(_, checked) =>
+ updateDetectorConfig({smooth_segmentation: checked})
+ }
+ disabled={isLoading || !detectorConfig.enable_segmentation}
+ />
+ }
+ label={<Typography variant="body2">Smooth Segmentation</Typography>}
+ />
+ <FormControlLabel
+ control={
+ <Switch
+ size="small"
+ checked={detectorConfig.refine_face_landmarks}
+ onChange={(_, checked) =>
+ updateDetectorConfig({refine_face_landmarks: checked})
+ }
+ disabled={isLoading}
+ />
+ }
+ label={<Typography variant="body2">Refine Face Landmarks</Typography>}
+ />
+ <FormControlLabel
+ control={
+ <Switch
+ size="small"
+ checked={detectorConfig.static_image_mode}
+ onChange={(_, checked) =>
+ updateDetectorConfig({static_image_mode: checked})
+ }
+ disabled={isLoading}
+ />
+ }
+ label={<Typography variant="body2">Static Image Mode</Typography>}
+ />
+ </Stack>
+ </Stack>
+ );
+};
diff --git a/freemocap-ui-old/src/components/mocap-control-panel/MocapTaskTreeItem.tsx b/freemocap-ui-old/src/components/mocap-control-panel/MocapTaskTreeItem.tsx
new file mode 100644
index 00000000..7fe7203b
--- /dev/null
+++ b/freemocap-ui-old/src/components/mocap-control-panel/MocapTaskTreeItem.tsx
@@ -0,0 +1,476 @@
+import React, {useCallback, useMemo, useState} from "react";
+import {
+ Alert,
+ Box,
+ Button,
+ Chip,
+ IconButton,
+ InputAdornment,
+ Stack,
+ TextField,
+ Tooltip,
+ Typography,
+ useTheme,
+} from "@mui/material";
+import DirectionsRunIcon from "@mui/icons-material/DirectionsRun";
+import PlayArrowIcon from "@mui/icons-material/PlayArrow";
+import StopIcon from "@mui/icons-material/Stop";
+import FolderOpenIcon from "@mui/icons-material/FolderOpen";
+import ClearIcon from "@mui/icons-material/Clear";
+import CheckCircleIcon from "@mui/icons-material/CheckCircle";
+import InfoIcon from "@mui/icons-material/Info";
+import CloseIcon from "@mui/icons-material/Close";
+import FiberManualRecordIcon from "@mui/icons-material/FiberManualRecord";
+import {CollapsibleSidebarSection} from "@/components/common/CollapsibleSidebarSection";
+import {useMocap} from "@/hooks/useMocap";
+import {useElectronIPC} from "@/services";
+import {MediapipeConfigPanel} from "@/components/mocap-control-panel/MediapipeConfigPanel";
+import {SkeletonFilterConfigPanel} from "@/components/mocap-control-panel/SkeletonFilterConfigPanel";
+
+export const MocapTaskTreeItem: React.FC = () => {
+ const theme = useTheme();
+ const [localError, setLocalError] = useState<string | null>(null);
+ const {api, isElectron} = useElectronIPC();
+
+ const {
+ error,
+ isLoading,
+ isRecording,
+ recordingProgress,
+ canStartRecording,
+ canProcessMocapRecording,
+ mocapRecordingPath,
+ directoryInfo,
+ isUsingManualPath,
+ dispatchStopMocapRecording,
+ dispatchStartMocapRecording,
+ setManualRecordingPath,
+ clearManualRecordingPath,
+ dispatchProcessMocapRecording,
+ clearError,
+ } = useMocap();
+
+ const handleClearError = useCallback((): void => {
+ clearError();
+ setLocalError(null);
+ }, [clearError]);
+
+ const handleSelectDirectory = async (): Promise<void> => {
+ if (!isElectron || !api) {
+ console.warn("Electron API not available");
+ return;
+ }
+ try {
+ const result: string | null = await api.fileSystem.selectDirectory.mutate();
+ if (result) {
+ await setManualRecordingPath(result);
+ }
+ } catch (err) {
+ console.error("Failed to select directory:", err);
+ setLocalError("Failed to select directory");
+ }
+ };
+
+ const handlePathInputChange = async (
+ e: React.ChangeEvent<HTMLInputElement>
+ ): Promise<void> => {
+ const newPath: string = e.target.value;
+ if (newPath.includes("~") && isElectron && api) {
+ try {
+ const home: string = await api.fileSystem.getHomeDirectory.query();
+ const expanded: string = newPath.replace(
+ /^~([/\\])?/,
+ home ? `${home}$1` : ""
+ );
+ await setManualRecordingPath(expanded);
+ } catch (err) {
+ console.error("Failed to expand home directory:", err);
+ await setManualRecordingPath(newPath);
+ }
+ } else {
+ await setManualRecordingPath(newPath);
+ }
+ };
+
+ const handleClearManualPath = useCallback((): void => {
+ clearManualRecordingPath();
+ }, [clearManualRecordingPath]);
+
+ const displayError = error || localError || directoryInfo?.errorMessage;
+
+ const pathHelperText = useMemo(() => {
+ if (isUsingManualPath) return "Using custom path";
+ return "Using default recording directory";
+ }, [isUsingManualPath]);
+
+ // Derive status for collapsed summary
+ const statusLabel = isRecording
+ ? `Recording ${recordingProgress.toFixed(0)}%`
+ : isLoading
+ ? "Processing..."
+ : "Idle";
+
+ const statusColor = isRecording
+ ? theme.palette.error.main
+ : isLoading
+ ? theme.palette.warning.main
+ : theme.palette.grey[600];
+
+ // Primary control: compact start/stop recording toggle in the header
+ const headerRecordButton = isRecording ? (
+ <Tooltip title="Stop mocap recording">
+ <IconButton
+ size="small"
+ onClick={(e: React.MouseEvent) => {
+ e.stopPropagation();
+ dispatchStopMocapRecording();
+ }}
+ disabled={isLoading}
+ sx={{
+ color: theme.palette.error.light,
+ border: `1.5px solid ${theme.palette.error.light}`,
+ borderRadius: 1,
+ p: 0.5,
+ "&:hover": {backgroundColor: "rgba(244,67,54,0.15)"},
+ }}
+ >
+ <StopIcon fontSize="small" />
+ </IconButton>
+ </Tooltip>
+ ) : (
+ <Tooltip title={canStartRecording ? "Start mocap recording" : "Cannot record yet"}>
+ <span>
+ <IconButton
+ size="small"
+ onClick={(e: React.MouseEvent) => {
+ e.stopPropagation();
+ dispatchStartMocapRecording();
+ }}
+ disabled={!canStartRecording || isLoading}
+ sx={{
+ color: "inherit",
+ border: "1.5px solid rgba(255,255,255,0.25)",
+ borderRadius: 1,
+ p: 0.5,
+ "&:hover": {backgroundColor: "rgba(255,255,255,0.1)"},
+ "&.Mui-disabled": {
+ color: "rgba(255,255,255,0.3)",
+ borderColor: "rgba(255,255,255,0.1)",
+ },
+ }}
+ >
+ <FiberManualRecordIcon fontSize="small" />
+ </IconButton>
+ </span>
+ </Tooltip>
+ );
+
+ return (
+ <CollapsibleSidebarSection
+ icon={<DirectionsRunIcon sx={{color: "inherit"}} />}
+ title="Motion Capture"
+ summaryContent={
+ <Chip
+ label={statusLabel}
+ size="small"
+ sx={{
+ height: 20,
+ fontSize: 11,
+ fontWeight: 600,
+ backgroundColor: statusColor,
+ color: theme.palette.getContrastText(statusColor),
+ }}
+ />
+ }
+ primaryControl={headerRecordButton}
+ defaultExpanded={false}
+ >
+ <Box sx={{p: 2, bgcolor: "background.paper"}}>
+ <Stack spacing={2}>
+ {/* Error Display */}
+ {displayError && (
+ <Alert severity="error" onClose={handleClearError}>
+ {displayError}
+ </Alert>
+ )}
+
+ {/* Recording Controls */}
+ <Stack direction="row" spacing={2}>
+ <Button
+ variant="contained"
+ color="primary"
+ startIcon={<PlayArrowIcon />}
+ onClick={dispatchStartMocapRecording}
+ disabled={!canStartRecording || isLoading}
+ fullWidth
+ >
+ Start Mocap Recording
+ </Button>
+ {isRecording && (
+ <Button
+ variant="contained"
+ color="error"
+ startIcon={<StopIcon />}
+ onClick={dispatchStopMocapRecording}
+ disabled={isLoading}
+ fullWidth
+ >
+ Stop Recording
+ </Button>
+ )}
+ </Stack>
+
+ {/* Recording Path Input */}
+ <TextField
+ label="Mocap Recording Path"
+ value={mocapRecordingPath}
+ onChange={handlePathInputChange}
+ fullWidth
+ size="small"
+ helperText={pathHelperText}
+ InputProps={{
+ endAdornment: (
+ <InputAdornment position="end">
+ {isUsingManualPath && (
+ <Tooltip title="Clear manual path (revert to default)">
+ <IconButton
+ onClick={handleClearManualPath}
+ edge="end"
+ size="small"
+ >
+ <ClearIcon fontSize="small" />
+ </IconButton>
+ </Tooltip>
+ )}
+ <Tooltip title="Select directory">
+ <IconButton
+ onClick={handleSelectDirectory}
+ edge="end"
+ disabled={!isElectron}
+ >
+ <FolderOpenIcon />
+ </IconButton>
+ </Tooltip>
+ </InputAdornment>
+ ),
+ }}
+ />
+
+ {/* Directory Status Info */}
+ {directoryInfo && (
+ <Box
+ sx={{
+ p: 1.5,
+ borderRadius: 1,
+ border: `2px solid ${theme.palette.divider}`,
+ }}
+ >
+ <Stack spacing={1}>
+ <Box
+ sx={{
+ display: "flex",
+ alignItems: "center",
+ gap: 1,
+ }}
+ >
+ <InfoIcon fontSize="small" color="info" />
+ <Typography variant="caption" fontWeight="medium">
+ Mocap Folder Status
+ </Typography>
+ </Box>
+
+ <Box
+ sx={{
+ display: "flex",
+ gap: 1,
+ flexWrap: "wrap",
+ }}
+ >
+ <Chip
+ label={
+ directoryInfo.exists
+ ? "Directory exists"
+ : "Directory will be created"
+ }
+ size="small"
+ color={directoryInfo.exists ? "success" : "default"}
+ icon={
+ directoryInfo.exists ? (
+ <CheckCircleIcon />
+ ) : (
+ <CloseIcon />
+ )
+ }
+ variant={directoryInfo.exists ? "filled" : "outlined"}
+ sx={
+ !directoryInfo.exists
+ ? {
+ borderColor: theme.palette.grey[400],
+ "& .MuiChip-icon": {
+ color: theme.palette.grey[600],
+ },
+ }
+ : {}
+ }
+ />
+ <Chip
+ label="Has videos"
+ size="small"
+ color={directoryInfo.hasVideos ? "success" : "default"}
+ icon={
+ directoryInfo.hasVideos ? (
+ <CheckCircleIcon />
+ ) : (
+ <CloseIcon />
+ )
+ }
+ variant={directoryInfo.hasVideos ? "filled" : "outlined"}
+ sx={
+ !directoryInfo.hasVideos
+ ? {
+ borderColor: theme.palette.grey[400],
+ "& .MuiChip-icon": {
+ color: theme.palette.grey[600],
+ },
+ }
+ : {}
+ }
+ />
+ <Chip
+ label="Has synchronized_videos"
+ size="small"
+ color={
+ directoryInfo.hasSynchronizedVideos
+ ? "success"
+ : "default"
+ }
+ icon={
+ directoryInfo.hasSynchronizedVideos ? (
+ <CheckCircleIcon />
+ ) : (
+ <CloseIcon />
+ )
+ }
+ variant={
+ directoryInfo.hasSynchronizedVideos
+ ? "filled"
+ : "outlined"
+ }
+ sx={
+ !directoryInfo.hasSynchronizedVideos
+ ? {
+ borderColor: theme.palette.grey[400],
+ "& .MuiChip-icon": {
+ color: theme.palette.grey[600],
+ },
+ }
+ : {}
+ }
+ />
+ <Chip
+ label="Has calibration TOML"
+ size="small"
+ color={
+ directoryInfo.cameraMocapTomlPath
+ ? "success"
+ : "default"
+ }
+ icon={
+ directoryInfo.cameraMocapTomlPath ? (
+ <CheckCircleIcon />
+ ) : (
+ <CloseIcon />
+ )
+ }
+ variant={
+ directoryInfo.cameraMocapTomlPath
+ ? "filled"
+ : "outlined"
+ }
+ sx={
+ !directoryInfo.cameraMocapTomlPath
+ ? {
+ borderColor: theme.palette.grey[400],
+ "& .MuiChip-icon": {
+ color: theme.palette.grey[600],
+ },
+ }
+ : {}
+ }
+ />
+ </Box>
+
+ {directoryInfo.cameraMocapTomlPath && (
+ <Box sx={{mt: 1}}>
+ <Typography variant="caption" color="text.secondary">
+ Found calibration file:
+ </Typography>
+ <Typography
+ variant="caption"
+ sx={{
+ fontFamily: "monospace",
+ display: "block",
+ color: "success.main",
+ wordBreak: "break-all",
+ }}
+ >
+ {directoryInfo.cameraMocapTomlPath}
+ </Typography>
+ </Box>
+ )}
+ </Stack>
+ </Box>
+ )}
+
+ {/* Recording Progress */}
+ {isRecording && (
+ <Box sx={{width: "100%"}}>
+ <Typography
+ variant="caption"
+ color="text.secondary"
+ gutterBottom
+ >
+ Recording in Progress: {recordingProgress.toFixed(0)}%
+ </Typography>
+ <Box
+ sx={{
+ width: "100%",
+ height: 8,
+ bgcolor: "grey.300",
+ borderRadius: 1,
+ overflow: "hidden",
+ }}
+ >
+ <Box
+ sx={{
+ width: `${recordingProgress}%`,
+ height: "100%",
+ bgcolor: theme.palette.primary.main,
+ transition: "width 0.3s",
+ }}
+ />
+ </Box>
+ </Box>
+ )}
+
+ {/* MediaPipe Detector Config */}
+ <MediapipeConfigPanel />
+
+ {/* Skeleton Filter Config */}
+ <SkeletonFilterConfigPanel />
+
+ {/* Process Recording Button */}
+ <Button
+ variant="contained"
+ color="secondary"
+ onClick={dispatchProcessMocapRecording}
+ disabled={!canProcessMocapRecording || isLoading}
+ fullWidth
+ >
+ Process Selected Recording
+ </Button>
+ </Stack>
+ </Box>
+ </CollapsibleSidebarSection>
+ );
+};
diff --git a/freemocap-ui-old/src/components/mocap-control-panel/SkeletonFilterConfigPanel.tsx b/freemocap-ui-old/src/components/mocap-control-panel/SkeletonFilterConfigPanel.tsx
new file mode 100644
index 00000000..776cc1ff
--- /dev/null
+++ b/freemocap-ui-old/src/components/mocap-control-panel/SkeletonFilterConfigPanel.tsx
@@ -0,0 +1,215 @@
+import React, {useCallback} from "react";
+import {
+ Box,
+ Button,
+ Divider,
+ Slider,
+ Stack,
+ TextField,
+ Tooltip,
+ Typography,
+ useTheme,
+} from "@mui/material";
+import {useMocap} from "@/hooks/useMocap";
+import {DEFAULT_REALTIME_FILTER_CONFIG} from "@/store/slices/mocap";
+
+/** Warm amber for section headings — visible on dark backgrounds. */
+const SECTION_COLOR = "#ffb74d";
+
+/** Shared slider sx that matches the camera config panel style. */
+const useSliderSx = () => {
+ const theme = useTheme();
+ return {
+ color: theme.palette.primary.light,
+ "& .MuiSlider-thumb": {
+ "&:hover, &.Mui-focusVisible": {
+ boxShadow: `0px 0px 0px 8px ${theme.palette.primary.light}33`,
+ },
+ },
+ } as const;
+};
+
+export const SkeletonFilterConfigPanel: React.FC = () => {
+ const theme = useTheme();
+ const sliderSx = useSliderSx();
+ const {skeletonFilterConfig, updateSkeletonFilterConfig, replaceSkeletonFilterConfig, isLoading} = useMocap();
+
+ const handleResetDefaults = useCallback(() => {
+ replaceSkeletonFilterConfig({...DEFAULT_REALTIME_FILTER_CONFIG});
+ }, [replaceSkeletonFilterConfig]);
+
+ return (
+ <Stack spacing={1}>
+ <Stack direction="row" justifyContent="space-between" alignItems="center">
+ <Typography variant="subtitle2" sx={{color: theme.palette.text.secondary, fontWeight: 600}}>
+ Skeleton Filter
+ </Typography>
+ <Button
+ size="small"
+ variant="text"
+ onClick={handleResetDefaults}
+ disabled={isLoading}
+ sx={{fontSize: 11, textTransform: "none"}}
+ >
+ Reset Defaults
+ </Button>
+ </Stack>
+
+ {/* === Point Gate === */}
+ <Typography variant="caption" sx={{color: SECTION_COLOR, fontWeight: 600}}>
+ Point Gate
+ </Typography>
+
+ <Tooltip title="Reject triangulated points whose mean reprojection error exceeds this. Higher = keep more (noisier) points." placement="right" arrow>
+ <Box>
+ <Typography variant="caption" color="text.secondary">
+ Max Reproj Error: {skeletonFilterConfig.max_reprojection_error_px.toFixed(0)} px
+ </Typography>
+ <Slider
+ value={skeletonFilterConfig.max_reprojection_error_px}
+ onChange={(_, v) => updateSkeletonFilterConfig({max_reprojection_error_px: v as number})}
+ min={5} max={200} step={1} size="small" disabled={isLoading}
+ sx={sliderSx}
+ />
+ </Box>
+ </Tooltip>
+
+ <Tooltip title="Reject points moving faster than this between frames. Catches teleportation spikes. Human limbs rarely exceed ~15 m/s." placement="right" arrow>
+ <Box>
+ <Typography variant="caption" color="text.secondary">
+ Max Velocity: {skeletonFilterConfig.max_velocity_m_per_s.toFixed(0)} m/s
+ </Typography>
+ <Slider
+ value={skeletonFilterConfig.max_velocity_m_per_s}
+ onChange={(_, v) => updateSkeletonFilterConfig({max_velocity_m_per_s: v as number})}
+ min={5} max={200} step={1} size="small" disabled={isLoading}
+ sx={sliderSx}
+ />
+ </Box>
+ </Tooltip>
+
+ <Tooltip title="After this many consecutive velocity rejections, accept unconditionally to prevent permanent lockout." placement="right" arrow>
+ <Box>
+ <Typography variant="caption" color="text.secondary">
+ Max Rejected Streak: {skeletonFilterConfig.max_rejected_streak}
+ </Typography>
+ <Slider
+ value={skeletonFilterConfig.max_rejected_streak}
+ onChange={(_, v) => updateSkeletonFilterConfig({max_rejected_streak: v as number})}
+ min={1} max={30} step={1} size="small" disabled={isLoading}
+ sx={sliderSx}
+ />
+ </Box>
+ </Tooltip>
+
+ <Divider />
+
+ {/* === One Euro Filter === */}
+ <Typography variant="caption" sx={{color: SECTION_COLOR, fontWeight: 600}}>
+ One Euro Filter
+ </Typography>
+
+ <Tooltip title="Minimum cutoff frequency (Hz). Lower = heavier smoothing (less jitter, more lag). Higher = more responsive." placement="right" arrow>
+ <Box>
+ <Typography variant="caption" color="text.secondary">
+ Min Cutoff: {skeletonFilterConfig.min_cutoff.toFixed(4)}
+ </Typography>
+ <Slider
+ value={skeletonFilterConfig.min_cutoff}
+ onChange={(_, v) => updateSkeletonFilterConfig({min_cutoff: v as number})}
+ min={0.0001} max={0.1} step={0.0005} size="small" disabled={isLoading}
+ sx={sliderSx}
+ />
+ </Box>
+ </Tooltip>
+
+ <Tooltip title="Speed coefficient. Higher = less lag during fast motion but more jitter. Zero = constant smoothing regardless of speed." placement="right" arrow>
+ <Box>
+ <Typography variant="caption" color="text.secondary">
+ Beta: {skeletonFilterConfig.beta.toFixed(2)}
+ </Typography>
+ <Slider
+ value={skeletonFilterConfig.beta}
+ onChange={(_, v) => updateSkeletonFilterConfig({beta: v as number})}
+ min={0} max={5} step={0.05} size="small" disabled={isLoading}
+ sx={sliderSx}
+ />
+ </Box>
+ </Tooltip>
+
+ <Tooltip title="Cutoff frequency for the speed estimator. Controls how quickly the filter reacts to speed changes. Usually fine at 1.0." placement="right" arrow>
+ <Box>
+ <Typography variant="caption" color="text.secondary">
+ D Cutoff: {skeletonFilterConfig.d_cutoff.toFixed(2)}
+ </Typography>
+ <Slider
+ value={skeletonFilterConfig.d_cutoff}
+ onChange={(_, v) => updateSkeletonFilterConfig({d_cutoff: v as number})}
+ min={0.1} max={5} step={0.1} size="small" disabled={isLoading}
+ sx={sliderSx}
+ />
+ </Box>
+ </Tooltip>
+
+ <Divider />
+
+ {/* === FABRIK === */}
+ <Typography variant="caption" sx={{color: SECTION_COLOR, fontWeight: 600}}>
+ FABRIK
+ </Typography>
+
+ <Tooltip title="Max solver iterations per frame for bone length constraint enforcement. 10–30 is usually plenty." placement="right" arrow>
+ <Box>
+ <Typography variant="caption" color="text.secondary">
+ Max Iterations: {skeletonFilterConfig.fabrik_max_iterations}
+ </Typography>
+ <Slider
+ value={skeletonFilterConfig.fabrik_max_iterations}
+ onChange={(_, v) => updateSkeletonFilterConfig({fabrik_max_iterations: v as number})}
+ min={1} max={100} step={1} size="small" disabled={isLoading}
+ sx={sliderSx}
+ />
+ </Box>
+ </Tooltip>
+
+ <Divider />
+
+ {/* === Body Model === */}
+ <Typography variant="caption" sx={{color: SECTION_COLOR, fontWeight: 600}}>
+ Body Model
+ </Typography>
+
+ <Tooltip title="Subject's approximate height. Scales the anthropometric bone length prior. Doesn't need to be exact." placement="right" arrow>
+ <TextField
+ label="Height (m)"
+ type="number"
+ size="small"
+ value={skeletonFilterConfig.height_meters}
+ onChange={(e) => {
+ const val = parseFloat(e.target.value);
+ if (!isNaN(val) && val > 0) {
+ updateSkeletonFilterConfig({height_meters: val});
+ }
+ }}
+ inputProps={{step: 0.01, min: 0.5, max: 3.0}}
+ disabled={isLoading}
+ fullWidth
+ />
+ </Tooltip>
+
+ <Tooltip title="Expected measurement noise (meters). Higher = trust raw positions less, rely more on prior estimates." placement="right" arrow>
+ <Box>
+ <Typography variant="caption" color="text.secondary">
+ Noise Sigma: {skeletonFilterConfig.noise_sigma.toFixed(4)} m
+ </Typography>
+ <Slider
+ value={skeletonFilterConfig.noise_sigma}
+ onChange={(_, v) => updateSkeletonFilterConfig({noise_sigma: v as number})}
+ min={0.001} max={0.05} step={0.001} size="small" disabled={isLoading}
+ sx={sliderSx}
+ />
+ </Box>
+ </Tooltip>
+ </Stack>
+ );
+};
diff --git a/freemocap-ui-old/src/components/processing-pipeline-panel/PipelineConnectionStatus.tsx b/freemocap-ui-old/src/components/processing-pipeline-panel/PipelineConnectionStatus.tsx
new file mode 100644
index 00000000..9c658847
--- /dev/null
+++ b/freemocap-ui-old/src/components/processing-pipeline-panel/PipelineConnectionStatus.tsx
@@ -0,0 +1,110 @@
+import {Box, CircularProgress, Typography} from "@mui/material";
+import CheckIcon from '@mui/icons-material/Check';
+import CloseIcon from '@mui/icons-material/Close';
+import {useAppDispatch, useAppSelector} from "@/store/hooks";
+import {
+ closePipeline,
+ connectRealtimePipeline,
+ selectCanConnectPipeline,
+ selectCanDisconnectPipeline,
+ selectIsPipelineConnected,
+ selectIsPipelineLoading,
+ selectPipelineError,
+ selectPipelineId,
+} from "@/store/slices/pipeline";
+
+export const PipelineConnectionStatus = () => {
+ const dispatch = useAppDispatch();
+
+ const isConnected = useAppSelector(selectIsPipelineConnected);
+ const pipelineId = useAppSelector(selectPipelineId);
+ const isLoading = useAppSelector(selectIsPipelineLoading);
+ const error = useAppSelector(selectPipelineError);
+ const canConnect = useAppSelector(selectCanConnectPipeline);
+ const canDisconnect = useAppSelector(selectCanDisconnectPipeline);
+
+ const handleToggleConnection = async (e: React.MouseEvent) => {
+ e.stopPropagation();
+
+ if (isLoading) return;
+
+ if (isConnected) {
+ console.log('Disconnecting from pipeline');
+ await dispatch(closePipeline());
+ } else {
+ console.log('Connecting to pipeline');
+ await dispatch(connectRealtimePipeline(undefined));
+ }
+ };
+
+ const isClickable = canConnect || canDisconnect;
+
+ return (
+ <Box
+ sx={{
+ display: 'flex',
+ justifyContent: 'flex-end',
+ padding: '10px',
+ flexDirection: 'column',
+ pl: 4,
+ cursor: isClickable ? 'pointer' : 'not-allowed',
+ border: '4px solid rgb(0, 125, 125)',
+ backgroundColor: isConnected ? '#005d94' : '#395067',
+ borderRadius: '8px',
+ opacity: isClickable ? 1 : 0.6,
+ ':hover': isClickable ? {
+ backgroundColor: 'rgba(255, 255, 255, 0.05)',
+ borderColor: 'rgb(0, 225, 225)',
+ } : {},
+ }}
+ onClick={isClickable ? handleToggleConnection : undefined}
+ >
+ <Typography
+ variant="body1"
+ component="div"
+ sx={{
+ display: 'flex',
+ alignItems: 'center',
+ gap: 1,
+ }}
+ >
+ <Box sx={{
+ border: '1px solid rgba(255, 255, 255, 0.3)',
+ width: '24px',
+ height: '24px',
+ marginRight: '8px',
+ cursor: isClickable ? 'pointer' : 'not-allowed',
+ borderRadius: '4px',
+ transition: 'background-color 0.3s, border-color 0.3s',
+ backgroundColor: isConnected ? 'rgba(0, 255, 255, 0.1)' : 'rgba(255, 0, 0, 0.1)',
+ borderColor: isConnected ? 'rgba(0, 255, 255, 0.5)' : 'rgba(255, 0, 0, 0.5)',
+ boxShadow: '0 2px 4px rgba(0, 0, 0, 0.1)',
+ display: 'flex',
+ alignItems: 'center',
+ padding: '4px',
+ justifyContent: 'center',
+ '&:hover': isClickable ? {
+ backgroundColor: 'rgba(255, 255, 255, 0.05)',
+ borderColor: 'rgba(255, 255, 255, 0.2)',
+ } : {},
+ }}>
+ {isLoading ? (
+ <CircularProgress size={16} sx={{ color: 'cyan' }} />
+ ) : isConnected ? (
+ <CheckIcon sx={{ color: 'green' }} />
+ ) : (
+ <CloseIcon fontSize="small" sx={{ color: 'red' }} />
+ )}
+ </Box>
+ Pipeline: {isConnected ? `connected (id: ${pipelineId})` : 'disconnected'}
+ {error && (
+ <Typography variant="caption" color="error" sx={{ ml: 1 }}>
+ {error}
+ </Typography>
+ )}
+ </Typography>
+ </Box>
+ );
+};
+
+export default PipelineConnectionStatus;
diff --git a/freemocap-ui-old/src/components/processing-pipeline-panel/PipelineConnectionToggle.tsx b/freemocap-ui-old/src/components/processing-pipeline-panel/PipelineConnectionToggle.tsx
new file mode 100644
index 00000000..a53a1d8c
--- /dev/null
+++ b/freemocap-ui-old/src/components/processing-pipeline-panel/PipelineConnectionToggle.tsx
@@ -0,0 +1,80 @@
+import React from "react";
+import {CircularProgress, IconButton, Tooltip, useTheme} from "@mui/material";
+import PowerSettingsNewIcon from "@mui/icons-material/PowerSettingsNew";
+import {useAppDispatch, useAppSelector} from "@/store/hooks";
+import {
+ closePipeline,
+ connectRealtimePipeline,
+ selectCanConnectPipeline,
+ selectCanDisconnectPipeline,
+ selectIsPipelineConnected,
+ selectIsPipelineLoading,
+} from "@/store/slices/pipeline";
+
+export const PipelineConnectionToggle: React.FC = () => {
+ const theme = useTheme();
+ const dispatch = useAppDispatch();
+
+ const isConnected = useAppSelector(selectIsPipelineConnected);
+ const isLoading = useAppSelector(selectIsPipelineLoading);
+ const canConnect = useAppSelector(selectCanConnectPipeline);
+ const canDisconnect = useAppSelector(selectCanDisconnectPipeline);
+
+ const isClickable = canConnect || canDisconnect;
+
+ const handleToggle = async (e: React.MouseEvent): Promise<void> => {
+ e.stopPropagation();
+ if (isLoading) return;
+
+ if (isConnected) {
+ await dispatch(closePipeline());
+ } else {
+ await dispatch(connectRealtimePipeline(undefined));
+ }
+ };
+
+ const tooltipText = isConnected
+ ? "Disconnect pipeline"
+ : canConnect
+ ? "Connect pipeline"
+ : "Select cameras first";
+
+ return (
+ <Tooltip title={tooltipText}>
+ <span>
+ <IconButton
+ size="small"
+ onClick={handleToggle}
+ disabled={!isClickable || isLoading}
+ sx={{
+ color: "inherit",
+ border: "1.5px solid",
+ borderColor: isConnected
+ ? theme.palette.success.light
+ : "rgba(255,255,255,0.25)",
+ borderRadius: 1,
+ p: 0.5,
+ backgroundColor: isConnected
+ ? "rgba(76, 175, 80, 0.2)"
+ : "transparent",
+ "&:hover": {
+ backgroundColor: isConnected
+ ? "rgba(76, 175, 80, 0.3)"
+ : "rgba(255,255,255,0.1)",
+ },
+ "&.Mui-disabled": {
+ color: "rgba(255,255,255,0.3)",
+ borderColor: "rgba(255,255,255,0.1)",
+ },
+ }}
+ >
+ {isLoading ? (
+ <CircularProgress size={18} sx={{color: "inherit"}} />
+ ) : (
+ <PowerSettingsNewIcon fontSize="small" />
+ )}
+ </IconButton>
+ </span>
+ </Tooltip>
+ );
+};
diff --git a/freemocap-ui-old/src/components/processing-pipeline-panel/PipelineSummary.tsx b/freemocap-ui-old/src/components/processing-pipeline-panel/PipelineSummary.tsx
new file mode 100644
index 00000000..05619890
--- /dev/null
+++ b/freemocap-ui-old/src/components/processing-pipeline-panel/PipelineSummary.tsx
@@ -0,0 +1,56 @@
+import React from "react";
+import {Chip, Typography, useTheme} from "@mui/material";
+import {useAppSelector} from "@/store/hooks";
+import {
+ selectIsPipelineConnected,
+ selectPipelineError,
+ selectPipelineId,
+} from "@/store/slices/pipeline";
+
+export const PipelineSummary: React.FC = () => {
+ const theme = useTheme();
+
+ const isConnected = useAppSelector(selectIsPipelineConnected);
+ const pipelineId = useAppSelector(selectPipelineId);
+ const error = useAppSelector(selectPipelineError);
+
+ if (error) {
+ return (
+ <Typography
+ variant="caption"
+ sx={{
+ color: theme.palette.error.light,
+ fontWeight: 500,
+ whiteSpace: "nowrap",
+ overflow: "hidden",
+ textOverflow: "ellipsis",
+ }}
+ >
+ Error
+ </Typography>
+ );
+ }
+
+ const statusColor = isConnected
+ ? theme.palette.success.main
+ : theme.palette.grey[600];
+
+ return (
+ <Chip
+ label={isConnected ? `Active (${pipelineId})` : "Inactive"}
+ size="small"
+ sx={{
+ height: 20,
+ fontSize: 11,
+ fontWeight: 600,
+ backgroundColor: statusColor,
+ color: theme.palette.getContrastText(statusColor),
+ maxWidth: 160,
+ "& .MuiChip-label": {
+ overflow: "hidden",
+ textOverflow: "ellipsis",
+ },
+ }}
+ />
+ );
+};
diff --git a/freemocap-ui-old/src/components/processing-pipeline-panel/ProcessingPipelinePanel.tsx b/freemocap-ui-old/src/components/processing-pipeline-panel/ProcessingPipelinePanel.tsx
new file mode 100644
index 00000000..3a7ac632
--- /dev/null
+++ b/freemocap-ui-old/src/components/processing-pipeline-panel/ProcessingPipelinePanel.tsx
@@ -0,0 +1,114 @@
+import React from "react";
+import {Box, FormControlLabel, Stack, Switch, Typography, useTheme} from "@mui/material";
+import LanIcon from "@mui/icons-material/Lan";
+import {CollapsibleSidebarSection} from "@/components/common/CollapsibleSidebarSection";
+import {PipelineConnectionToggle} from "@/components/processing-pipeline-panel/PipelineConnectionToggle";
+import {PipelineSummary} from "@/components/processing-pipeline-panel/PipelineSummary";
+import {useAppSelector} from "@/store/hooks";
+import {selectBackendPipeline} from "@/store/slices/settings";
+import {useServer} from "@/hooks/useServer";
+import {MediapipeConfigPanel} from "@/components/mocap-control-panel/MediapipeConfigPanel";
+import {SkeletonFilterConfigPanel} from "@/components/mocap-control-panel/SkeletonFilterConfigPanel";
+
+export const ProcessingPipelinePanel: React.FC = () => {
+ const theme = useTheme();
+ const {send, isConnected} = useServer();
+ const backendPipeline = useAppSelector(selectBackendPipeline);
+
+ const pipelineConfig = backendPipeline?.config;
+ const isPipelineConnected = backendPipeline?.is_connected ?? false;
+ const canToggle = isConnected && isPipelineConnected;
+
+ const handleToggleCalibrationDetection = (_: React.ChangeEvent, checked: boolean) => {
+ send({
+ message_type: "settings/patch",
+ patch: {
+ pipeline: {
+ config: {
+ calibration_detection_enabled: checked,
+ },
+ },
+ },
+ });
+ };
+
+ const handleToggleMocapDetection = (_: React.ChangeEvent, checked: boolean) => {
+ send({
+ message_type: "settings/patch",
+ patch: {
+ pipeline: {
+ config: {
+ mocap_detection_enabled: checked,
+ },
+ },
+ },
+ });
+ };
+
+ return (
+ <CollapsibleSidebarSection
+ icon={<LanIcon sx={{transform: "scaleY(-1.05)", color: "inherit"}} />}
+ title="Realtime Pipeline"
+ summaryContent={<PipelineSummary />}
+ primaryControl={<PipelineConnectionToggle />}
+ defaultExpanded={false}
+ >
+ <Box sx={{p: 2}}>
+ <Stack spacing={2}>
+ {/* Detection toggles — always visible, disabled when pipeline not connected */}
+ <Typography
+ variant="subtitle2"
+ sx={{color: theme.palette.text.secondary, fontWeight: 600}}
+ >
+ Detection Stages
+ </Typography>
+ {!isPipelineConnected && (
+ <Typography variant="caption" color="text.secondary" sx={{fontStyle: "italic"}}>
+ Connect a pipeline to enable detection toggles.
+ </Typography>
+ )}
+ <FormControlLabel
+ control={
+ <Switch
+ size="small"
+ checked={pipelineConfig?.calibration_detection_enabled ?? true}
+ onChange={handleToggleCalibrationDetection}
+ disabled={!canToggle}
+ />
+ }
+ label={
+ <Typography variant="body2">
+ Charuco Detection (Calibration)
+ </Typography>
+ }
+ />
+ <FormControlLabel
+ control={
+ <Switch
+ size="small"
+ checked={pipelineConfig?.mocap_detection_enabled ?? true}
+ onChange={handleToggleMocapDetection}
+ disabled={!canToggle}
+ />
+ }
+ label={
+ <Typography variant="body2">
+ MediaPipe Detection (MoCap)
+ </Typography>
+ }
+ />
+
+ {/* MediaPipe config — always visible */}
+ <Box sx={{mt: 1, pl: 1, borderLeft: `2px solid ${theme.palette.divider}`}}>
+ <MediapipeConfigPanel />
+ </Box>
+
+ {/* Skeleton filter config — always visible */}
+ <Box sx={{mt: 1, pl: 1, borderLeft: `2px solid ${theme.palette.divider}`}}>
+ <SkeletonFilterConfigPanel />
+ </Box>
+ </Stack>
+ </Box>
+ </CollapsibleSidebarSection>
+ );
+};
\ No newline at end of file
diff --git a/freemocap-ui-old/src/components/recording-info-panel/RecordingControlsTreeSection.tsx b/freemocap-ui-old/src/components/recording-info-panel/RecordingControlsTreeSection.tsx
new file mode 100644
index 00000000..b05994c8
--- /dev/null
+++ b/freemocap-ui-old/src/components/recording-info-panel/RecordingControlsTreeSection.tsx
@@ -0,0 +1,94 @@
+import React from 'react';
+import {Box} from '@mui/material';
+import {
+ DelayRecordingStartControl
+} from "@/components/recording-info-panel/recording-subcomponents/DelayRecordingStartControl";
+import {
+ BaseRecordingDirectoryInput
+} from "@/components/recording-info-panel/recording-subcomponents/BaseRecordingDirectoryInput";
+import {RecordingNamePreview} from "@/components/recording-info-panel/recording-subcomponents/RecordingNamePreview";
+import {
+ RecordingSettingsSection
+} from "@/components/recording-info-panel/recording-subcomponents/RecordingSettingsSection";
+
+interface RecordingControlsSectionProps {
+ recordingDirectory: string;
+ recordingTag: string;
+ useDelayStart: boolean;
+ delaySeconds: number;
+ useTimestamp: boolean;
+ baseName: string;
+ useIncrement: boolean;
+ currentIncrement: number;
+ createSubfolder: boolean;
+ customSubfolderName: string;
+ isRecording: boolean;
+ onDelayToggle: (value: boolean) => void;
+ onDelayChange: (value: number) => void;
+ onTagChange: (value: string) => void;
+ onUseTimestampChange: (value: boolean) => void;
+ onBaseNameChange: (value: string) => void;
+ onUseIncrementChange: (value: boolean) => void;
+ onIncrementChange: (value: number) => void;
+ onCreateSubfolderChange: (value: boolean) => void;
+ onCustomSubfolderNameChange: (value: string) => void;
+}
+
+export const RecordingControlsSection: React.FC<RecordingControlsSectionProps> = ({
+ recordingDirectory,
+ recordingTag,
+ useDelayStart,
+ delaySeconds,
+ useTimestamp,
+ baseName,
+ useIncrement,
+ currentIncrement,
+ createSubfolder,
+ customSubfolderName,
+ isRecording,
+ onDelayToggle,
+ onDelayChange,
+ onTagChange,
+ onUseTimestampChange,
+ onBaseNameChange,
+ onUseIncrementChange,
+ onIncrementChange,
+ onCreateSubfolderChange,
+ onCustomSubfolderNameChange
+ }) => {
+ return (
+ <Box sx={{pl: 2, pt: 1, display: 'flex', flexDirection: 'column', gap: 2}}>
+ <DelayRecordingStartControl
+ useDelay={useDelayStart}
+ delaySeconds={delaySeconds}
+ onDelayToggle={onDelayToggle}
+ onDelayChange={onDelayChange}
+ />
+
+ <BaseRecordingDirectoryInput
+ baseRecordingFolder={recordingDirectory}
+ />
+
+ <RecordingNamePreview
+ tag={recordingTag}
+ isRecording={isRecording}
+ onTagChange={onTagChange}
+ />
+
+ <RecordingSettingsSection
+ useTimestamp={useTimestamp}
+ baseName={baseName}
+ useIncrement={useIncrement}
+ currentIncrement={currentIncrement}
+ createSubfolder={createSubfolder}
+ customSubfolderName={customSubfolderName}
+ onUseTimestampChange={onUseTimestampChange}
+ onBaseNameChange={onBaseNameChange}
+ onUseIncrementChange={onUseIncrementChange}
+ onIncrementChange={onIncrementChange}
+ onCreateSubfolderChange={onCreateSubfolderChange}
+ onCustomSubfolderNameChange={onCustomSubfolderNameChange}
+ />
+ </Box>
+ );
+};
diff --git a/freemocap-ui-old/src/components/recording-info-panel/RecordingInfoPanel.tsx b/freemocap-ui-old/src/components/recording-info-panel/RecordingInfoPanel.tsx
new file mode 100644
index 00000000..2c26ae2a
--- /dev/null
+++ b/freemocap-ui-old/src/components/recording-info-panel/RecordingInfoPanel.tsx
@@ -0,0 +1,310 @@
+import React, {useEffect, useState} from "react";
+import {Box, Typography, useTheme} from "@mui/material";
+import {SimpleTreeView} from "@mui/x-tree-view/SimpleTreeView";
+import {TreeItem} from "@mui/x-tree-view/TreeItem";
+import ExpandMoreIcon from "@mui/icons-material/ExpandMore";
+import ChevronRightIcon from "@mui/icons-material/ChevronRight";
+import VideocamIcon from "@mui/icons-material/Videocam";
+import {recordingInfoUpdated, startRecording, stopRecording, useAppDispatch, useAppSelector} from "@/store";
+import {
+ StartStopRecordingButton
+} from "@/components/recording-info-panel/recording-subcomponents/StartStopRecordingButton";
+import {useElectronIPC} from "@/services";
+import {RecordingPathTreeItem} from "@/components/recording-info-panel/RecordingPathTreeItem";
+
+
+interface RecordingOperation {
+ type: 'start' | 'stop';
+ timestamp: number;
+}
+
+export const RecordingInfoPanel: React.FC = () => {
+ const theme = useTheme();
+ const dispatch = useAppDispatch();
+ const recordingInfo = useAppSelector(
+ (state) => state.recording
+ );
+
+ // Local UI state
+ const [createSubfolder, setCreateSubfolder] = useState<boolean>(false);
+ const [useDelayStart, setUseDelayStart] = useState<boolean>(false);
+ const [delaySeconds, setDelaySeconds] = useState<number>(3);
+ const [countdown, setCountdown] = useState<number | null>(null);
+
+ // Track pending operation and recording start time
+ const [pendingOperation, setPendingOperation] = useState<RecordingOperation | null>(null);
+ const [recordingStartTime, setRecordingStartTime] = useState<number | null>(null);
+
+ // Local recording naming
+ const [useTimestamp, setUseTimestamp] = useState<boolean>(true);
+ const [useIncrement, setUseIncrement] = useState<boolean>(false);
+ const [currentIncrement, setCurrentIncrement] = useState<number>(1);
+ const [baseName, setBaseName] = useState<string>("recording");
+ const [customSubfolderName, setCustomSubfolderName] = useState<string>("");
+ const [recordingTag, setRecordingTag] = useState<string>("");
+ const {isElectron, api} = useElectronIPC();
+
+ // Track when recording state changes to clear pending state
+ useEffect(() => {
+ if (pendingOperation) {
+ const isNowRecording = recordingInfo.isRecording;
+ const wasStarting = pendingOperation.type === 'start';
+ const wasStopping = pendingOperation.type === 'stop';
+
+ // Clear pending if state changed as expected
+ if ((wasStarting && isNowRecording) || (wasStopping && !isNowRecording)) {
+ setPendingOperation(null);
+
+ // Set or clear recording start time
+ if (wasStarting && isNowRecording) {
+ setRecordingStartTime(Date.now());
+ } else if (wasStopping && !isNowRecording) {
+ setRecordingStartTime(null);
+ }
+ }
+
+ // Timeout fallback - clear pending after 5 seconds if thunk hasn't responded
+ const timeoutMs = 5000;
+ const elapsed = Date.now() - pendingOperation.timestamp;
+ if (elapsed > timeoutMs) {
+ console.error(`Recording ${pendingOperation.type} operation timed out after ${timeoutMs}ms`);
+ setPendingOperation(null);
+ }
+ }
+ }, [recordingInfo.isRecording, pendingOperation]);
+
+ // Set initial recording start time if already recording on mount
+ useEffect(() => {
+ if (recordingInfo.isRecording && !recordingStartTime) {
+ setRecordingStartTime(Date.now());
+ }
+ }, []);
+
+ // replace ~ with user's home directory
+ useEffect(() => {
+ if (recordingInfo?.recordingDirectory?.startsWith("~") && isElectron && api) {
+ api.fileSystem.getHomeDirectory.query()
+ .then((homePath: string) => {
+ const updatedDirectory = recordingInfo.recordingDirectory.replace(
+ "~",
+ homePath
+ );
+ dispatch(recordingInfoUpdated({recordingDirectory: updatedDirectory}));
+ })
+ .catch((error: unknown) => {
+ console.error("Failed to get home directory:", error);
+ throw error; // Fail loudly as per preferences
+ });
+ }
+ }, [recordingInfo.recordingDirectory, isElectron, api, dispatch]);
+
+ // Handle countdown timer
+ useEffect(() => {
+ if (countdown !== null && countdown > 0) {
+ const timer = setTimeout(() => setCountdown(countdown - 1), 1000);
+ return () => clearTimeout(timer);
+ } else if (countdown === 0) {
+ handleStartRecording();
+ setCountdown(null);
+ }
+ }, [countdown]);
+
+ const getTimestampString = (): string => {
+ const now = new Date();
+
+ const dateOptions: Intl.DateTimeFormatOptions = {
+ year: "numeric",
+ month: "2-digit",
+ day: "2-digit",
+ hour: "2-digit",
+ minute: "2-digit",
+ second: "2-digit",
+ hour12: false,
+ timeZoneName: "shortOffset",
+ };
+
+ const formatter = new Intl.DateTimeFormat("en-US", dateOptions);
+ const parts = formatter.formatToParts(now);
+
+ const partMap: Record<string, string> = {};
+ parts.forEach((part) => {
+ partMap[part.type] = part.value;
+ });
+
+ return `${partMap.year}-${partMap.month}-${partMap.day}_${
+ partMap.hour
+ }-${partMap.minute}-${partMap.second}_${partMap.timeZoneName.replace(
+ ":",
+ ""
+ )}`;
+ };
+
+ const handleRecordingTagChange = (tag: string): void => {
+ setRecordingTag(tag);
+ };
+
+ const buildRecordingName = (): string => {
+ const parts: string[] = [];
+
+ if (useTimestamp) {
+ parts.push(getTimestampString());
+ } else {
+ parts.push(baseName);
+ }
+
+ if (recordingTag) {
+ parts.push(recordingTag);
+ }
+
+ return parts.join("_");
+ };
+
+ const handleStartRecording = async (): Promise<void> => {
+ console.log("Starting recording...");
+
+ const recordingName = buildRecordingName();
+ const subfolderName = createSubfolder
+ ? customSubfolderName || getTimestampString()
+ : "";
+ const recordingPath = createSubfolder
+ ? `${recordingInfo.recordingDirectory}/${subfolderName}`
+ : recordingInfo.recordingDirectory;
+
+ console.log("Recording path:", recordingPath);
+ console.log("Recording name:", recordingName);
+
+ if (useIncrement) {
+ setCurrentIncrement((prev) => prev + 1);
+ }
+
+ // Set pending state before dispatching
+ setPendingOperation({ type: 'start', timestamp: Date.now() });
+
+ try {
+ await dispatch(
+ startRecording({
+ recordingName,
+ recordingDirectory: recordingPath,
+ })
+ ).unwrap();
+ } catch (error) {
+ console.error("Failed to start recording:", error);
+ setPendingOperation(null);
+ throw error; // Fail loudly as per preferences
+ }
+ };
+
+ const handleRecordButtonClick = async (): Promise<void> => {
+ // Don't allow clicking while pending
+ if (pendingOperation) {
+ return;
+ }
+
+ if (recordingInfo.isRecording) {
+ console.log("Stopping recording...");
+ setPendingOperation({ type: 'stop', timestamp: Date.now() });
+
+ try {
+ await dispatch(stopRecording()).unwrap();
+ } catch (error) {
+ console.error("Failed to stop recording:", error);
+ setPendingOperation(null);
+ throw error; // Fail loudly as per preferences
+ }
+ } else if (useDelayStart) {
+ console.log(`Starting countdown from ${delaySeconds} seconds`);
+ setCountdown(delaySeconds);
+ } else {
+ await handleStartRecording();
+ }
+ };
+
+ const recordingName = buildRecordingName();
+ const subfolderName = createSubfolder
+ ? customSubfolderName || getTimestampString()
+ : undefined;
+
+ return (
+ <Box
+ sx={{
+ color: "text.primary",
+ backgroundColor: theme.palette.primary.main,
+ borderRadius: 1,
+ mx: 1,
+ my: 0.5,
+ }}
+ >
+ <SimpleTreeView
+ defaultExpandedItems={["recording-main"]}
+ slots={{
+ collapseIcon: ExpandMoreIcon,
+ expandIcon: ChevronRightIcon,
+ }}
+ sx={{
+ flexGrow: 1,
+ '& .MuiTreeItem-content': {
+ padding: '2px 4px',
+ margin: '1px 0',
+ },
+ '& .MuiTreeItem-label': {
+ fontSize: 13,
+ padding: '1px 0',
+ },
+ }}
+ >
+ <TreeItem
+ itemId="recording-main"
+ label={
+ <Box
+ sx={{
+ display: "flex",
+ alignItems: "center",
+ width: "100%",
+ py: 0.25,
+ }}
+ >
+ <VideocamIcon sx={{ fontSize: 16, mr: 0.5 }} />
+ <Typography sx={{ flexGrow: 1, fontSize: 13, fontWeight: 500 }}>
+ Record
+ </Typography>
+
+ <StartStopRecordingButton
+ isRecording={recordingInfo.isRecording}
+ isPending={pendingOperation !== null}
+ countdown={countdown}
+ recordingStartTime={recordingStartTime}
+ onClick={handleRecordButtonClick}
+ />
+ </Box>
+ }
+ >
+ <RecordingPathTreeItem
+ recordingDirectory={recordingInfo.recordingDirectory}
+ recordingName={recordingName}
+ subfolder={subfolderName}
+ countdown={countdown}
+ recordingTag={recordingTag}
+ useDelayStart={useDelayStart}
+ delaySeconds={delaySeconds}
+ useTimestamp={useTimestamp}
+ baseName={baseName}
+ useIncrement={useIncrement}
+ currentIncrement={currentIncrement}
+ createSubfolder={createSubfolder}
+ customSubfolderName={customSubfolderName}
+ isRecording={recordingInfo.isRecording}
+ onDelayToggle={setUseDelayStart}
+ onDelayChange={setDelaySeconds}
+ onTagChange={handleRecordingTagChange}
+ onUseTimestampChange={setUseTimestamp}
+ onBaseNameChange={setBaseName}
+ onUseIncrementChange={setUseIncrement}
+ onIncrementChange={setCurrentIncrement}
+ onCreateSubfolderChange={setCreateSubfolder}
+ onCustomSubfolderNameChange={setCustomSubfolderName}
+ />
+ </TreeItem>
+ </SimpleTreeView>
+ </Box>
+ );
+};
diff --git a/freemocap-ui-old/src/components/recording-info-panel/RecordingPathTreeItem.tsx b/freemocap-ui-old/src/components/recording-info-panel/RecordingPathTreeItem.tsx
new file mode 100644
index 00000000..92eb5578
--- /dev/null
+++ b/freemocap-ui-old/src/components/recording-info-panel/RecordingPathTreeItem.tsx
@@ -0,0 +1,103 @@
+import React from 'react';
+import {Box, Typography} from '@mui/material';
+import {TreeItem} from '@mui/x-tree-view/TreeItem';
+import {
+ FullRecordingPathPreview
+} from "@/components/recording-info-panel/recording-subcomponents/FullRecordingPathPreview";
+import {RecordingControlsSection} from "@/components/recording-info-panel/RecordingControlsTreeSection";
+import {useAppSelector} from '@/store';
+
+interface RecordingPathTreeItemProps {
+ countdown: number | null;
+ // Config props
+ recordingTag: string;
+ useDelayStart: boolean;
+ delaySeconds: number;
+ useTimestamp: boolean;
+ baseName: string;
+ useIncrement: boolean;
+ currentIncrement: number;
+ createSubfolder: boolean;
+ customSubfolderName: string;
+ isRecording: boolean;
+ onDelayToggle: (value: boolean) => void;
+ onDelayChange: (value: number) => void;
+ onTagChange: (value: string) => void;
+ onUseTimestampChange: (value: boolean) => void;
+ onBaseNameChange: (value: string) => void;
+ onUseIncrementChange: (value: boolean) => void;
+ onIncrementChange: (value: number) => void;
+ onCreateSubfolderChange: (value: boolean) => void;
+ onCustomSubfolderNameChange: (value: string) => void;
+}
+
+export const RecordingPathTreeItem: React.FC<RecordingPathTreeItemProps> = ({
+ countdown,
+ // Control props
+ recordingTag,
+ useDelayStart,
+ delaySeconds,
+ useTimestamp,
+ baseName,
+ useIncrement,
+ currentIncrement,
+ createSubfolder,
+ customSubfolderName,
+ isRecording,
+ onDelayToggle,
+ onDelayChange,
+ onTagChange,
+ onUseTimestampChange,
+ onBaseNameChange,
+ onUseIncrementChange,
+ onIncrementChange,
+ onCreateSubfolderChange,
+ onCustomSubfolderNameChange
+ }) => {
+ // Read computed values directly from store
+ const recordingDirectory = useAppSelector((state) => state.recording.recordingDirectory);
+ const computed = useAppSelector((state) => state.recording.computed);
+
+ return (
+ <TreeItem
+ itemId="recording-path"
+ label={
+ <Box sx={{display: 'flex', alignItems: 'center', gap: 1}}>
+ <FullRecordingPathPreview />
+ </Box>
+ }
+ >
+ <Box sx={{pl: 2, pt: 1, display: 'flex', flexDirection: 'column', gap: 2}}>
+ {/* Countdown display in controls section */}
+ {countdown !== null && (
+ <Typography variant="h4" align="center" color="secondary">
+ Starting in {countdown}...
+ </Typography>
+ )}
+
+ <RecordingControlsSection
+ recordingDirectory={recordingDirectory}
+ recordingTag={recordingTag}
+ useDelayStart={useDelayStart}
+ delaySeconds={delaySeconds}
+ useTimestamp={useTimestamp}
+ baseName={baseName}
+ useIncrement={useIncrement}
+ currentIncrement={currentIncrement}
+ createSubfolder={createSubfolder}
+ customSubfolderName={customSubfolderName}
+ isRecording={isRecording}
+ onDelayToggle={onDelayToggle}
+ onDelayChange={onDelayChange}
+ onTagChange={onTagChange}
+ onUseTimestampChange={onUseTimestampChange}
+ onBaseNameChange={onBaseNameChange}
+ onUseIncrementChange={onUseIncrementChange}
+ onIncrementChange={onIncrementChange}
+ onCreateSubfolderChange={onCreateSubfolderChange}
+ onCustomSubfolderNameChange={onCustomSubfolderNameChange}
+ />
+ </Box>
+ </TreeItem>
+ );
+};
diff --git a/freemocap-ui-old/src/components/recording-info-panel/recording-subcomponents/BaseRecordingDirectoryInput.tsx b/freemocap-ui-old/src/components/recording-info-panel/recording-subcomponents/BaseRecordingDirectoryInput.tsx
new file mode 100644
index 00000000..4c7ba33b
--- /dev/null
+++ b/freemocap-ui-old/src/components/recording-info-panel/recording-subcomponents/BaseRecordingDirectoryInput.tsx
@@ -0,0 +1,76 @@
+import React from 'react';
+import {IconButton, InputAdornment, TextField} from '@mui/material';
+import FolderOpenIcon from '@mui/icons-material/FolderOpen';
+import {useAppDispatch} from '@/store';
+import {recordingDirectoryChanged} from '@/store/slices/recording/recording-slice';
+import {useElectronIPC} from '@/services';
+
+interface DirectoryInputProps {
+ baseRecordingFolder: string;
+}
+
+export const BaseRecordingDirectoryInput: React.FC<DirectoryInputProps> = ({ baseRecordingFolder }) => {
+ const dispatch = useAppDispatch();
+ const { api, isElectron } = useElectronIPC();
+
+ const handleSelectDirectory = async (): Promise<void> => {
+ // Only try to use electron API if we're in electron environment
+ if (!isElectron || !api) {
+ console.warn('Electron API not available');
+ return;
+ }
+
+ try {
+ const result: string | null = await api.fileSystem.selectDirectory.mutate();
+ if (result) {
+ // Use the specific action for recording directory changes
+ dispatch(recordingDirectoryChanged(result));
+ }
+ } catch (error) {
+ console.error('Failed to select directory:', error);
+ }
+ };
+
+ const handleInputChange = async (e: React.ChangeEvent<HTMLInputElement>): Promise<void> => {
+ const newPath: string = e.target.value;
+
+ // Handle tilde expansion for home directory
+ if (newPath.includes('~') && isElectron && api) {
+ try {
+ const home: string = await api.fileSystem.getHomeDirectory.query();
+ // Replace ~ at the beginning of the path with home directory
+ const expanded: string = newPath.replace(/^~(\/|\\)?/, home ? `${home}$1` : '');
+ dispatch(recordingDirectoryChanged(expanded));
+ } catch (error) {
+ console.error('Failed to expand home directory:', error);
+ // Fall back to using the path as-is
+ dispatch(recordingDirectoryChanged(newPath));
+ }
+ } else {
+ dispatch(recordingDirectoryChanged(newPath));
+ }
+ };
+
+ return (
+ <TextField
+ label="Recording Directory"
+ value={baseRecordingFolder}
+ onChange={handleInputChange}
+ fullWidth
+ size="small"
+ InputProps={{
+ endAdornment: (
+ <InputAdornment position="end">
+ <IconButton
+ onClick={handleSelectDirectory}
+ edge="end"
+ disabled={!isElectron}
+ >
+ <FolderOpenIcon />
+ </IconButton>
+ </InputAdornment>
+ ),
+ }}
+ />
+ );
+};
diff --git a/freemocap-ui-old/src/components/recording-info-panel/recording-subcomponents/DelayRecordingStartControl.tsx b/freemocap-ui-old/src/components/recording-info-panel/recording-subcomponents/DelayRecordingStartControl.tsx
new file mode 100644
index 00000000..f961e2aa
--- /dev/null
+++ b/freemocap-ui-old/src/components/recording-info-panel/recording-subcomponents/DelayRecordingStartControl.tsx
@@ -0,0 +1,48 @@
+import React from 'react';
+import {Box, Checkbox, FormControlLabel, TextField, useTheme} from '@mui/material';
+
+interface DelayStartControlProps {
+ useDelay: boolean;
+ delaySeconds: number;
+ onDelayToggle: (checked: boolean) => void;
+ onDelayChange: (seconds: number) => void;
+}
+
+export const DelayRecordingStartControl: React.FC<DelayStartControlProps> = ({
+ useDelay,
+ delaySeconds,
+ onDelayToggle,
+ onDelayChange
+ }) => {
+ const theme = useTheme();
+ return (
+ <Box display="flex" alignItems="center" gap={2}>
+ <FormControlLabel
+ control={
+ <Checkbox
+ checked={useDelay}
+ onChange={(e) => onDelayToggle(e.target.checked)}
+ sx={{
+ color: theme.palette.text.primary,
+ '&.Mui-checked': {
+ color: theme.palette.text.primary,
+ },
+ }}
+ />
+ }
+ label="Delay Start"
+ />
+ {useDelay && (
+ <TextField
+ label="Seconds"
+ type="number"
+ value={delaySeconds}
+ onChange={(e) => onDelayChange(Math.max(1, parseInt(e.target.value) || 1))}
+ inputProps={{min: 1, step: 1}}
+ size="small"
+ sx={{width: 100}}
+ />
+ )}
+ </Box>
+ );
+};
diff --git a/freemocap-ui-old/src/components/recording-info-panel/recording-subcomponents/FullRecordingPathPreview.tsx b/freemocap-ui-old/src/components/recording-info-panel/recording-subcomponents/FullRecordingPathPreview.tsx
new file mode 100644
index 00000000..7b55e723
--- /dev/null
+++ b/freemocap-ui-old/src/components/recording-info-panel/recording-subcomponents/FullRecordingPathPreview.tsx
@@ -0,0 +1,130 @@
+import React from 'react';
+import {Box, IconButton, Paper, Tooltip, Typography, useTheme} from '@mui/material';
+import FolderIcon from '@mui/icons-material/Folder';
+import FolderSpecialIcon from '@mui/icons-material/FolderSpecial';
+import ChevronRightIcon from '@mui/icons-material/ChevronRight';
+import FolderOpenIcon from '@mui/icons-material/FolderOpen';
+import {useElectronIPC} from "@/services";
+import {useAppSelector} from '@/store';
+
+export const FullRecordingPathPreview: React.FC = () => {
+ const theme = useTheme();
+ const { api } = useElectronIPC();
+
+ // Read directly from RTK store
+ const recordingDirectory = useAppSelector((state) => state.recording.recordingDirectory);
+ const computed = useAppSelector((state) => state.recording.computed);
+
+ const parts = [
+ {icon: <FolderIcon/>, text: recordingDirectory},
+ ...(computed.subfolderName ? [{icon: <FolderIcon/>, text: computed.subfolderName}] : []),
+ {icon: <FolderSpecialIcon/>, text: computed.recordingName}
+ ];
+
+ const fullPath: string = parts.map(p => p.text).join('/');
+
+ // Get the directory path only (without the filename)
+ const directoryToOpen: string = computed.subfolderName
+ ? `${recordingDirectory}/${computed.subfolderName}`
+ : recordingDirectory;
+
+ const handleOpenFolder = async (): Promise<void> => {
+ try {
+ await api?.fileSystem.openFolder.mutate({ path: directoryToOpen });
+ } catch (error) {
+ console.error('Failed to open folder:', error);
+ }
+ };
+
+ return (
+ <Paper
+ elevation={0}
+ sx={{
+ p: 1.5,
+ backgroundColor: theme.palette.mode === 'dark'
+ ? 'rgba(255, 255, 255, 0.05)'
+ : 'rgba(0, 0, 0, 0.04)',
+ borderRadius: 1,
+ borderStyle: 'solid',
+ borderColor: theme.palette.divider,
+ }}
+ >
+ <Box sx={{
+ display: 'flex',
+ justifyContent: 'space-between',
+ alignItems: 'center',
+ mb: 1
+ }}>
+ {/* Mobile/Narrow view */}
+ <Box sx={{display: {xs: 'block', md: 'none'}}}>
+ <Tooltip title={fullPath} placement="bottom-start">
+ <Typography
+ noWrap
+ sx={{
+ fontFamily: 'monospace',
+ fontSize: '0.9rem',
+ cursor: 'pointer'
+ }}
+ >
+ {fullPath}
+ </Typography>
+ </Tooltip>
+ </Box>
+
+ {/* Desktop view */}
+ <Box
+ sx={{
+ display: {xs: 'none', md: 'flex'},
+ alignItems: 'center',
+ flexWrap: 'wrap',
+ gap: 0.5
+ }}
+ >
+ {parts.map((part, index) => (
+ <React.Fragment key={index}>
+ <Box sx={{
+ display: 'flex',
+ alignItems: 'center',
+ color: 'text.secondary',
+ borderRadius: 1,
+ px: 1,
+ py: 0.5,
+ }}>
+ {part.icon}
+ <Typography
+ sx={{
+ ml: 0.5,
+ fontFamily: 'monospace',
+ fontSize: '0.9rem'
+ }}
+ >
+ {part.text}
+ </Typography>
+ </Box>
+ {index < parts.length - 1 && (
+ <ChevronRightIcon sx={{color: 'text.secondary'}}/>
+ )}
+ </React.Fragment>
+ ))}
+ </Box>
+
+ <Tooltip title="Open folder in file explorer">
+ <IconButton
+ size="small"
+ onClick={handleOpenFolder}
+ sx={{
+ color: theme.palette.primary.contrastText,
+ '&:hover': {
+ backgroundColor: theme.palette.mode === 'dark'
+ ? 'rgba(255, 255, 255, 0.08)'
+ : 'rgba(0, 0, 0, 0.04)'
+ }
+ }}
+ >
+ <FolderOpenIcon fontSize="small"/>
+ </IconButton>
+ </Tooltip>
+ </Box>
+ </Paper>
+ );
+};
diff --git a/freemocap-ui-old/src/components/recording-info-panel/recording-subcomponents/RecordingNamePreview.tsx b/freemocap-ui-old/src/components/recording-info-panel/recording-subcomponents/RecordingNamePreview.tsx
new file mode 100644
index 00000000..5dea4ee4
--- /dev/null
+++ b/freemocap-ui-old/src/components/recording-info-panel/recording-subcomponents/RecordingNamePreview.tsx
@@ -0,0 +1,40 @@
+import React from 'react';
+import {TextField, Typography} from '@mui/material';
+import {useAppSelector} from '@/store';
+
+interface RecordingNamePreviewProps {
+ tag: string;
+ isRecording: boolean;
+ onTagChange: (tag: string) => void;
+}
+
+export const RecordingNamePreview: React.FC<RecordingNamePreviewProps> = ({
+ tag,
+ isRecording,
+ onTagChange
+ }) => {
+ // Read computed recording name from store
+ const recordingName = useAppSelector((state) => state.recording.computed.recordingName);
+
+ return (
+ <>
+ <Typography variant="body2" sx={{mb: 1}}>
+ Recording Name: {recordingName}
+ </Typography>
+ {!isRecording && (
+ <TextField
+ label="Recording Tag"
+ value={tag}
+ onChange={(e) => onTagChange(e.target.value)}
+ onKeyDown={(e) => {
+ // Stop the TreeView from intercepting keyboard navigation
+ e.stopPropagation();
+ }}
+ size="small"
+ fullWidth
+ placeholder="Optional tag"
+ />
+ )}
+ </>
+ );
+};
diff --git a/freemocap-ui-old/src/components/recording-info-panel/recording-subcomponents/RecordingSettingsSection.tsx b/freemocap-ui-old/src/components/recording-info-panel/recording-subcomponents/RecordingSettingsSection.tsx
new file mode 100644
index 00000000..bb8114bb
--- /dev/null
+++ b/freemocap-ui-old/src/components/recording-info-panel/recording-subcomponents/RecordingSettingsSection.tsx
@@ -0,0 +1,141 @@
+import React from 'react';
+import {Box, Checkbox, FormControlLabel, Grid, TextField, Typography, useTheme} from '@mui/material';
+
+interface RecordingSettingsProps {
+ useTimestamp: boolean;
+ baseName: string;
+ useIncrement: boolean;
+ currentIncrement: number;
+ createSubfolder: boolean;
+ customSubfolderName: string;
+ onUseTimestampChange: (value: boolean) => void;
+ onBaseNameChange: (value: string) => void;
+ onUseIncrementChange: (value: boolean) => void;
+ onIncrementChange: (value: number) => void;
+ onCreateSubfolderChange: (value: boolean) => void;
+ onCustomSubfolderNameChange: (value: string) => void;
+}
+
+export const RecordingSettingsSection: React.FC<RecordingSettingsProps> = ({
+ useTimestamp,
+ baseName,
+ useIncrement,
+ currentIncrement,
+ createSubfolder,
+ customSubfolderName,
+ onUseTimestampChange,
+ onBaseNameChange,
+ onUseIncrementChange,
+ onIncrementChange,
+ onCreateSubfolderChange,
+ onCustomSubfolderNameChange,
+ }) => {
+ const theme = useTheme();
+
+ return (
+ <Box sx={{
+ mt: 2,
+ p: 2,
+ bgcolor: theme.palette.mode === 'dark'
+ ? 'rgba(255, 255, 255, 0.05)'
+ : 'rgba(0, 0, 0, 0.04)',
+ borderRadius: 1
+ }}>
+ <Typography variant="subtitle1" sx={{mb: 2}}>Recording Settings</Typography>
+
+ <Grid container spacing={2} alignItems="center">
+ {/* Timestamp & Base name row */}
+ <Grid item xs={12} sm={4}>
+ <FormControlLabel
+ control={
+ <Checkbox
+ sx={{
+ color: theme.palette.text.primary,
+ '&.Mui-checked': {
+ color: theme.palette.text.primary,
+ },
+ }}
+ checked={useTimestamp}
+ onChange={(e) => onUseTimestampChange(e.target.checked)}
+ />
+ }
+ label="Use Timestamp"
+ />
+ </Grid>
+ <Grid item xs={12} sm={8}>
+ <TextField
+ label="Base Recording Name"
+ value={baseName}
+ onChange={(e) => onBaseNameChange(e.target.value)}
+ disabled={useTimestamp}
+ size="small"
+ fullWidth
+ />
+ </Grid>
+
+ {/* Subfolder row */}
+ <Grid item xs={12} sm={4}>
+ <FormControlLabel
+ control={
+ <Checkbox
+ sx={{
+ color: theme.palette.text.primary,
+ '&.Mui-checked': {
+ color: theme.palette.text.primary,
+ },
+ }}
+
+ checked={createSubfolder}
+ onChange={(e) => onCreateSubfolderChange(e.target.checked)}
+ />
+ }
+ label="Use Subfolder"
+ />
+ </Grid>
+ <Grid item xs={12} sm={8}>
+ <TextField
+ label="Custom Subfolder Name"
+ value={customSubfolderName}
+ onChange={(e) => onCustomSubfolderNameChange(e.target.value)}
+ disabled={!createSubfolder}
+ size="small"
+ fullWidth
+ placeholder="Leave empty to use timestamp"
+ />
+ </Grid>
+
+ {/* Auto increment row */}
+ <Grid item xs={12} sm={4}>
+ <FormControlLabel
+ control={
+ <Checkbox
+ checked={useIncrement}
+ onChange={(e) => onUseIncrementChange(e.target.checked)}
+ sx={{
+ color: theme.palette.text.primary,
+ '&.Mui-checked': {
+ color: theme.palette.text.primary,
+ },
+ }}
+ />
+ }
+ label="Auto Increment"
+ />
+ </Grid>
+ <Grid item xs={12} sm={4}>
+ <TextField
+ label="Increment Number"
+ type="number"
+ value={currentIncrement}
+ onChange={(e) => onIncrementChange(parseInt(e.target.value) || 1)}
+ disabled={!useIncrement}
+ inputProps={{min: 1, step: 1}}
+ size="small"
+ fullWidth
+ />
+ </Grid>
+
+ </Grid>
+ </Box>
+ );
+};
diff --git a/freemocap-ui-old/src/components/recording-info-panel/recording-subcomponents/StartStopRecordingButton.tsx b/freemocap-ui-old/src/components/recording-info-panel/recording-subcomponents/StartStopRecordingButton.tsx
new file mode 100644
index 00000000..0905a9d0
--- /dev/null
+++ b/freemocap-ui-old/src/components/recording-info-panel/recording-subcomponents/StartStopRecordingButton.tsx
@@ -0,0 +1,154 @@
+import React, {useEffect, useState} from 'react';
+import {Box, Button, CircularProgress, keyframes, Typography} from '@mui/material';
+import {styled} from '@mui/system';
+
+interface StartStopButtonProps {
+ isRecording: boolean;
+ isPending: boolean;
+ countdown: number | null;
+ recordingStartTime: number | null;
+ onClick: () => void;
+}
+
+const pulseAnimation = keyframes`
+ 0% {
+ background-color: #fb1402;
+ }
+ 50% {
+ background-color: #711c1c;
+ }
+ 100% {
+ background-color: #fb1402;
+ }
+`;
+
+// Use shouldForwardProp to prevent custom props from being passed to the DOM
+const PulsingButton = styled(Button, {
+ shouldForwardProp: (prop) => !['isRecording', 'isPending'].includes(prop as string)
+})<{ isRecording: boolean; isPending: boolean }>(({ isRecording, isPending }) => ({
+ backgroundColor: isRecording ? '#8d0a02' : '#005d94',
+ borderStyle: 'solid',
+ borderWidth: '3px',
+ borderColor: isPending ? '#ffa500' : '#ff55ff',
+ padding: 10,
+ position: 'relative',
+ transition: 'all 0.3s ease',
+ opacity: isPending ? 0.8 : 1,
+ '&:hover': {
+ borderColor: isPending ? '#ffa500' : '#fb1402',
+ borderWidth: '3px',
+ },
+ '&:disabled': {
+ opacity: 0.8,
+ cursor: 'not-allowed',
+ },
+ ...(isRecording && !isPending && {
+ animation: `${pulseAnimation} 3s infinite ease-in-out`,
+ }),
+}));
+
+const formatDuration = (seconds: number): string => {
+ const hours = Math.floor(seconds / 3600);
+ const minutes = Math.floor((seconds % 3600) / 60);
+ const secs = seconds % 60;
+
+ const parts: string[] = [];
+ if (hours > 0) {
+ parts.push(hours.toString().padStart(2, '0'));
+ }
+ parts.push(minutes.toString().padStart(2, '0'));
+ parts.push(secs.toString().padStart(2, '0'));
+
+ return parts.join(':');
+};
+
+export const StartStopRecordingButton: React.FC<StartStopButtonProps> = ({
+ isRecording,
+ isPending,
+ countdown,
+ recordingStartTime,
+ onClick
+}) => {
+ const [recordingDuration, setRecordingDuration] = useState<number>(0);
+
+ // Update recording duration every second
+ useEffect(() => {
+ if (!isRecording || !recordingStartTime || isPending) {
+ setRecordingDuration(0);
+ return;
+ }
+
+ const updateDuration = (): void => {
+ const now = Date.now();
+ const duration = Math.floor((now - recordingStartTime) / 1000);
+ setRecordingDuration(duration);
+ };
+
+ // Update immediately
+ updateDuration();
+
+ // Then update every second
+ const interval = setInterval(updateDuration, 1000);
+
+ return () => clearInterval(interval);
+ }, [isRecording, recordingStartTime, isPending]);
+
+ const getButtonContent = (): React.ReactNode => {
+ // Show countdown if active
+ if (countdown !== null && countdown > 0) {
+ return (
+ <Box display="flex" alignItems="center" gap={1}>
+ <Typography variant="h6">
+ Starting in {countdown}...
+ </Typography>
+ </Box>
+ );
+ }
+
+ // Show pending state
+ if (isPending) {
+ return (
+ <Box display="flex" alignItems="center" gap={1}>
+ <CircularProgress size={20} color="inherit" />
+ <Typography variant="h6">
+ {isRecording ? 'Stopping...' : 'Starting...'}
+ </Typography>
+ </Box>
+ );
+ }
+
+ // Show recording state with duration
+ if (isRecording) {
+ return (
+ <Box display="flex" flexDirection="column" alignItems="center">
+ <Typography variant="h6">
+ 🔴 Stop Recording
+ </Typography>
+ <Typography variant="caption" sx={{ fontSize: '0.9rem', fontFamily: 'monospace' }}>
+ {formatDuration(recordingDuration)}
+ </Typography>
+ </Box>
+ );
+ }
+
+ // Default start state
+ return (
+ <Typography variant="h6">
+ 🔴 Start Recording
+ </Typography>
+ );
+ };
+
+ return (
+ <PulsingButton
+ onClick={onClick}
+ variant="contained"
+ isRecording={isRecording}
+ isPending={isPending}
+ disabled={isPending || countdown !== null}
+ fullWidth
+ >
+ {getButtonContent()}
+ </PulsingButton>
+ );
+};
diff --git a/freemocap-ui-old/src/components/settings-editor/SettingsEditor.tsx b/freemocap-ui-old/src/components/settings-editor/SettingsEditor.tsx
new file mode 100644
index 00000000..16d67b9a
--- /dev/null
+++ b/freemocap-ui-old/src/components/settings-editor/SettingsEditor.tsx
@@ -0,0 +1,540 @@
+import React, { useState, useCallback, useRef, useMemo, useEffect } from 'react';
+import {
+ Box,
+ Button,
+ ButtonGroup,
+ Alert,
+ Snackbar,
+ Tooltip,
+ Divider,
+ CircularProgress,
+} from '@mui/material';
+import { useTheme } from '@mui/material/styles';
+import Editor, { OnMount } from '@monaco-editor/react';
+import UploadFileIcon from '@mui/icons-material/UploadFile';
+import DownloadIcon from '@mui/icons-material/Download';
+import CheckIcon from '@mui/icons-material/Check';
+import RestoreIcon from '@mui/icons-material/Restore';
+import ContentCopyIcon from '@mui/icons-material/ContentCopy';
+import {
+ useAppDispatch,
+ useAppSelector,
+ themeModeSet,
+ recordingDirectoryChanged,
+ configUpdated,
+ selectServerSettings,
+} from '@/store';
+import {
+ mocapDetectorConfigReplaced,
+ skeletonFilterConfigReplaced,
+ updateMocapConfigOnServer,
+} from '@/store/slices/mocap';
+import {calibrationConfigUpdated, updateCalibrationConfigOnServer } from '@/store/slices/calibration';
+import { ThemeMode } from '@/store/slices/theme/theme-types';
+import { useServer } from '@/hooks/useServer';
+import {
+ serialize,
+ deserialize,
+ convertFormat,
+ SerializationFormat,
+ FORMAT_EXTENSIONS,
+ FORMAT_MIME_TYPES,
+ FORMAT_MONACO_LANGUAGES,
+} from './format-converters';
+
+// ── Aggregated settings shape (config-only, no runtime state) ──
+
+interface AggregatedSettings {
+ appearance: {
+ mode: string;
+ };
+ recording: {
+ recording_directory: string;
+ use_delay_start: boolean;
+ delay_seconds: number;
+ use_timestamp: boolean;
+ use_increment: boolean;
+ current_increment: number;
+ base_name: string;
+ recording_tag: string;
+ create_subfolder: boolean;
+ custom_subfolder_name: string;
+ };
+ calibration: {
+ live_track_charuco: boolean;
+ charuco_board_x_squares: number;
+ charuco_board_y_squares: number;
+ charuco_square_length: number;
+ min_shared_views_per_camera: number;
+ auto_stop_on_min_view_count: boolean;
+ solver_method: string;
+ use_groundplane: boolean;
+ };
+ mocap: {
+ detector: Record<string, unknown>;
+ skeleton_filter: Record<string, unknown>;
+ };
+ // vmc: {
+ // enabled: boolean;
+ // host: string;
+ // port: number;
+ // };
+}
+
+// ── Hook: gather current settings into a flat config object ──
+
+function useAggregatedSettings(): AggregatedSettings {
+ const themeMode = useAppSelector(state => state.theme.mode);
+ const recording = useAppSelector(state => state.recording);
+ const calibration = useAppSelector(state => state.calibration.config);
+ const mocap = useAppSelector(state => state.mocap.config);
+ const serverSettings = useAppSelector(selectServerSettings);
+
+ return useMemo((): AggregatedSettings => ({
+ appearance: {
+ mode: themeMode,
+ },
+ recording: {
+ recording_directory: recording.recordingDirectory,
+ use_delay_start: recording.config.useDelayStart,
+ delay_seconds: recording.config.delaySeconds,
+ use_timestamp: recording.config.useTimestamp,
+ use_increment: recording.config.useIncrement,
+ current_increment: recording.config.currentIncrement,
+ base_name: recording.config.baseName,
+ recording_tag: recording.config.recordingTag,
+ create_subfolder: recording.config.createSubfolder,
+ custom_subfolder_name: recording.config.customSubfolderName,
+ },
+ calibration: {
+ live_track_charuco: calibration.liveTrackCharuco,
+ charuco_board_x_squares: calibration.charucoBoardXSquares,
+ charuco_board_y_squares: calibration.charucoBoardYSquares,
+ charuco_square_length: calibration.charucoSquareLength,
+ min_shared_views_per_camera: calibration.minSharedViewsPerCamera,
+ auto_stop_on_min_view_count: calibration.autoStopOnMinViewCount,
+ solver_method: calibration.solverMethod,
+ use_groundplane: calibration.useGroundplane,
+ },
+ mocap: {
+ detector: mocap.detector as unknown as Record<string, unknown>,
+ skeleton_filter: mocap.skeleton_filter as unknown as Record<string, unknown>,
+ },
+ // vmc: {
+ // enabled: serverSettings?.vmc?.enabled ?? false,
+ // host: serverSettings?.vmc?.host ?? '127.0.0.1',
+ // port: serverSettings?.vmc?.port ?? 39539,
+ // },
+ }), [themeMode, recording, calibration, mocap, serverSettings]);
+}
+
+// ── Apply parsed settings back to the Redux stores ──
+
+function useApplySettings() {
+ const dispatch = useAppDispatch();
+ const { send, isConnected } = useServer();
+
+ return useCallback((parsed: Record<string, unknown>) => {
+ const settings = parsed as unknown as Partial<AggregatedSettings>;
+
+ // Appearance
+ if (settings.appearance && typeof settings.appearance.mode === 'string') {
+ const mode = settings.appearance.mode;
+ if (mode === 'dark' || mode === 'light') {
+ dispatch(themeModeSet(mode as ThemeMode));
+ } else {
+ throw new Error(`Invalid appearance.mode: "${mode}" (must be "dark" or "light")`);
+ }
+ }
+
+ // Recording
+ if (settings.recording) {
+ const rec = settings.recording;
+ if (typeof rec.recording_directory === 'string') {
+ dispatch(recordingDirectoryChanged(rec.recording_directory));
+ }
+ dispatch(configUpdated({
+ useDelayStart: rec.use_delay_start,
+ delaySeconds: rec.delay_seconds,
+ useTimestamp: rec.use_timestamp,
+ useIncrement: rec.use_increment,
+ currentIncrement: rec.current_increment,
+ baseName: rec.base_name,
+ recordingTag: rec.recording_tag,
+ createSubfolder: rec.create_subfolder,
+ customSubfolderName: rec.custom_subfolder_name,
+ }));
+ }
+
+ // Calibration
+ if (settings.calibration) {
+ const cal = settings.calibration;
+ dispatch(calibrationConfigUpdated({
+ liveTrackCharuco: cal.live_track_charuco,
+ charucoBoardXSquares: cal.charuco_board_x_squares,
+ charucoBoardYSquares: cal.charuco_board_y_squares,
+ charucoSquareLength: cal.charuco_square_length,
+ minSharedViewsPerCamera: cal.min_shared_views_per_camera,
+ autoStopOnMinViewCount: cal.auto_stop_on_min_view_count,
+ solverMethod: cal.solver_method as 'anipose' | 'pyceres',
+ useGroundplane: cal.use_groundplane,
+ }));
+ dispatch(updateCalibrationConfigOnServer());
+ }
+
+ // Mocap
+ if (settings.mocap) {
+ if (settings.mocap.detector) {
+ dispatch(mocapDetectorConfigReplaced(settings.mocap.detector as any));
+ }
+ if (settings.mocap.skeleton_filter) {
+ dispatch(skeletonFilterConfigReplaced(settings.mocap.skeleton_filter as any));
+ }
+ dispatch(updateMocapConfigOnServer());
+ }
+
+ // VMC (patched via WebSocket)
+ if (settings.vmc && isConnected) {
+ send({
+ message_type: 'settings/patch',
+ patch: {
+ vmc: {
+ enabled: settings.vmc.enabled,
+ host: settings.vmc.host,
+ port: settings.vmc.port,
+ },
+ },
+ });
+ }
+ }, [dispatch, send, isConnected]);
+}
+
+// ── Format toggle button ──
+
+function FormatButton({
+ format,
+ active,
+ onClick,
+}: {
+ format: SerializationFormat;
+ active: boolean;
+ onClick: () => void;
+}) {
+ return (
+ <Button
+ size="small"
+ variant={active ? 'contained' : 'outlined'}
+ onClick={onClick}
+ sx={{
+ textTransform: 'uppercase',
+ fontWeight: 700,
+ fontSize: '0.7rem',
+ minWidth: 56,
+ letterSpacing: 0.8,
+ }}
+ >
+ {format}
+ </Button>
+ );
+}
+
+// ── Main editor component ──
+
+export const SettingsEditor: React.FC = () => {
+ const theme = useTheme();
+ const aggregated = useAggregatedSettings();
+ const applySettings = useApplySettings();
+
+ const [format, setFormat] = useState<SerializationFormat>('json');
+ const [editorContent, setEditorContent] = useState<string>('');
+ const [hasEdits, setHasEdits] = useState(false);
+ const [error, setError] = useState<string | null>(null);
+ const [snackbar, setSnackbar] = useState<{ message: string; severity: 'success' | 'error' } | null>(null);
+
+ const editorRef = useRef<any>(null);
+ const fileInputRef = useRef<HTMLInputElement>(null);
+
+ // Serialize current settings whenever aggregated state or format changes (only if no pending edits)
+ const serializedFromStore = useMemo(
+ () => serialize(aggregated as unknown as Record<string, unknown>, format),
+ [aggregated, format],
+ );
+
+ // Sync editor content from store when there are no pending edits
+ useEffect(() => {
+ if (!hasEdits) {
+ setEditorContent(serializedFromStore);
+ }
+ }, [serializedFromStore, hasEdits]);
+
+ // Initialize editor on first mount
+ useEffect(() => {
+ setEditorContent(serialize(aggregated as unknown as Record<string, unknown>, format));
+ // Only run on mount
+ // eslint-disable-next-line react-hooks/exhaustive-deps
+ }, []);
+
+ const handleEditorMount: OnMount = useCallback((editor) => {
+ editorRef.current = editor;
+ }, []);
+
+ const handleEditorChange = useCallback((value: string | undefined) => {
+ if (value === undefined) return;
+ setEditorContent(value);
+ setHasEdits(true);
+ setError(null);
+ }, []);
+
+ // Format switching — convert current content to new format
+ const handleFormatChange = useCallback((newFormat: SerializationFormat) => {
+ if (newFormat === format) return;
+ try {
+ const converted = convertFormat(editorContent, format, newFormat);
+ setEditorContent(converted);
+ setFormat(newFormat);
+ setError(null);
+ } catch (err) {
+ setError(`Cannot convert to ${newFormat.toUpperCase()}: ${err instanceof Error ? err.message : String(err)}`);
+ }
+ }, [editorContent, format]);
+
+ // Reset editor to current store state
+ const handleReset = useCallback(() => {
+ const fresh = serialize(aggregated as unknown as Record<string, unknown>, format);
+ setEditorContent(fresh);
+ setHasEdits(false);
+ setError(null);
+ }, [aggregated, format]);
+
+ // Apply edits to store
+ const handleApply = useCallback(() => {
+ try {
+ const parsed = deserialize(editorContent, format);
+ applySettings(parsed);
+ setHasEdits(false);
+ setError(null);
+ setSnackbar({ message: 'Settings applied successfully', severity: 'success' });
+ } catch (err) {
+ const message = err instanceof Error ? err.message : String(err);
+ setError(`Failed to apply: ${message}`);
+ setSnackbar({ message: `Failed to apply settings: ${message}`, severity: 'error' });
+ }
+ }, [editorContent, format, applySettings]);
+
+ // Copy to clipboard
+ const handleCopy = useCallback(async () => {
+ try {
+ await navigator.clipboard.writeText(editorContent);
+ setSnackbar({ message: 'Copied to clipboard', severity: 'success' });
+ } catch {
+ setSnackbar({ message: 'Failed to copy to clipboard', severity: 'error' });
+ }
+ }, [editorContent]);
+
+ // Download as file
+ const handleDownload = useCallback(() => {
+ const blob = new Blob([editorContent], { type: FORMAT_MIME_TYPES[format] });
+ const url = URL.createObjectURL(blob);
+ const a = document.createElement('a');
+ a.href = url;
+ a.download = `freemocap-settings${FORMAT_EXTENSIONS[format]}`;
+ a.click();
+ URL.revokeObjectURL(url);
+ }, [editorContent, format]);
+
+ // Upload from file
+ const handleUploadClick = useCallback(() => {
+ fileInputRef.current?.click();
+ }, []);
+
+ const handleFileSelected = useCallback((e: React.ChangeEvent<HTMLInputElement>) => {
+ const file = e.target.files?.[0];
+ if (!file) return;
+
+ // Detect format from file extension
+ const ext = file.name.split('.').pop()?.toLowerCase();
+ let detectedFormat: SerializationFormat = format;
+ if (ext === 'json') detectedFormat = 'json';
+ else if (ext === 'yaml' || ext === 'yml') detectedFormat = 'yaml';
+ else if (ext === 'toml') detectedFormat = 'toml';
+
+ const reader = new FileReader();
+ reader.onload = (event) => {
+ const text = event.target?.result;
+ if (typeof text !== 'string') {
+ setError('Failed to read file');
+ return;
+ }
+ try {
+ // Validate by parsing
+ deserialize(text, detectedFormat);
+ setFormat(detectedFormat);
+ setEditorContent(text);
+ setHasEdits(true);
+ setError(null);
+ setSnackbar({ message: `Loaded ${file.name} (${detectedFormat.toUpperCase()})`, severity: 'success' });
+ } catch (err) {
+ setError(`Invalid ${detectedFormat.toUpperCase()} in ${file.name}: ${err instanceof Error ? err.message : String(err)}`);
+ }
+ };
+ reader.onerror = () => {
+ setError(`Failed to read file: ${file.name}`);
+ };
+ reader.readAsText(file);
+
+ // Reset the input so the same file can be re-selected
+ e.target.value = '';
+ }, [format]);
+
+ const isDark = theme.palette.mode === 'dark';
+
+ return (
+ <Box sx={{ display: 'flex', flexDirection: 'column', height: '100%', gap: 1.5 }}>
+ {/* Toolbar */}
+ <Box
+ sx={{
+ display: 'flex',
+ alignItems: 'center',
+ justifyContent: 'space-between',
+ flexWrap: 'wrap',
+ gap: 1,
+ }}
+ >
+ {/* Format selector */}
+ <ButtonGroup size="small" variant="outlined">
+ <FormatButton format="json" active={format === 'json'} onClick={() => handleFormatChange('json')} />
+ <FormatButton format="yaml" active={format === 'yaml'} onClick={() => handleFormatChange('yaml')} />
+ <FormatButton format="toml" active={format === 'toml'} onClick={() => handleFormatChange('toml')} />
+ </ButtonGroup>
+
+ {/* Action buttons */}
+ <Box sx={{ display: 'flex', gap: 0.75 }}>
+ <Tooltip title="Copy to clipboard">
+ <Button size="small" variant="outlined" onClick={handleCopy} sx={{ minWidth: 0, px: 1 }}>
+ <ContentCopyIcon sx={{ fontSize: 16 }} />
+ </Button>
+ </Tooltip>
+ <Tooltip title="Upload settings file (.json, .yaml, .toml)">
+ <Button size="small" variant="outlined" onClick={handleUploadClick} startIcon={<UploadFileIcon sx={{ fontSize: 16 }} />}>
+ Upload
+ </Button>
+ </Tooltip>
+ <Tooltip title={`Download as ${format.toUpperCase()}`}>
+ <Button size="small" variant="outlined" onClick={handleDownload} startIcon={<DownloadIcon sx={{ fontSize: 16 }} />}>
+ Download
+ </Button>
+ </Tooltip>
+
+ <Divider orientation="vertical" flexItem sx={{ mx: 0.5 }} />
+
+ <Tooltip title="Reset to current app state">
+ <span>
+ <Button
+ size="small"
+ variant="outlined"
+ onClick={handleReset}
+ disabled={!hasEdits}
+ startIcon={<RestoreIcon sx={{ fontSize: 16 }} />}
+ >
+ Reset
+ </Button>
+ </span>
+ </Tooltip>
+ <Tooltip title="Apply edits to app">
+ <span>
+ <Button
+ size="small"
+ variant="contained"
+ color="success"
+ onClick={handleApply}
+ disabled={!hasEdits}
+ startIcon={<CheckIcon sx={{ fontSize: 16 }} />}
+ >
+ Apply
+ </Button>
+ </span>
+ </Tooltip>
+ </Box>
+ </Box>
+
+ {/* Status bar */}
+ {hasEdits && (
+ <Alert severity="info" sx={{ py: 0, fontSize: '0.75rem' }}>
+ You have unsaved edits. Click <strong>Apply</strong> to push changes to the app, or <strong>Reset</strong> to discard.
+ </Alert>
+ )}
+ {error && (
+ <Alert severity="error" sx={{ py: 0, fontSize: '0.75rem' }}>
+ {error}
+ </Alert>
+ )}
+
+ {/* Monaco Editor */}
+ <Box
+ sx={{
+ flex: 1,
+ minHeight: 400,
+ border: `1px solid ${theme.palette.divider}`,
+ borderRadius: 1,
+ overflow: 'hidden',
+ }}
+ >
+ <Editor
+ height="100%"
+ language={FORMAT_MONACO_LANGUAGES[format]}
+ value={editorContent}
+ theme={isDark ? 'vs-dark' : 'light'}
+ onChange={handleEditorChange}
+ onMount={handleEditorMount}
+ loading={
+ <Box sx={{ display: 'flex', alignItems: 'center', justifyContent: 'center', height: '100%' }}>
+ <CircularProgress size={32} />
+ </Box>
+ }
+ options={{
+ minimap: { enabled: false },
+ fontSize: 13,
+ fontFamily: "'JetBrains Mono', 'Fira Code', 'Cascadia Code', Consolas, monospace",
+ lineNumbers: 'on',
+ scrollBeyondLastLine: false,
+ wordWrap: 'on',
+ tabSize: 2,
+ automaticLayout: true,
+ renderWhitespace: 'selection',
+ bracketPairColorization: { enabled: true },
+ folding: true,
+ formatOnPaste: true,
+ }}
+ />
+ </Box>
+
+ {/* Hidden file input for upload */}
+ <input
+ ref={fileInputRef}
+ type="file"
+ accept=".json,.yaml,.yml,.toml"
+ style={{ display: 'none' }}
+ onChange={handleFileSelected}
+ />
+
+ {/* Snackbar for feedback */}
+ <Snackbar
+ open={snackbar !== null}
+ autoHideDuration={3000}
+ onClose={() => setSnackbar(null)}
+ anchorOrigin={{ vertical: 'bottom', horizontal: 'center' }}
+ >
+ {snackbar ? (
+ <Alert
+ onClose={() => setSnackbar(null)}
+ severity={snackbar.severity}
+ variant="filled"
+ sx={{ width: '100%' }}
+ >
+ {snackbar.message}
+ </Alert>
+ ) : undefined}
+ </Snackbar>
+ </Box>
+ );
+};
diff --git a/freemocap-ui-old/src/components/settings-editor/format-converters.ts b/freemocap-ui-old/src/components/settings-editor/format-converters.ts
new file mode 100644
index 00000000..dab7ab60
--- /dev/null
+++ b/freemocap-ui-old/src/components/settings-editor/format-converters.ts
@@ -0,0 +1,81 @@
+import yaml from 'js-yaml';
+import * as TOML from 'smol-toml';
+
+export type SerializationFormat = 'json' | 'yaml' | 'toml';
+
+/** Recursively remove null values from an object (TOML has no null concept). */
+function stripNulls(obj: Record<string, unknown>): Record<string, unknown> {
+ const result: Record<string, unknown> = {};
+ for (const [key, value] of Object.entries(obj)) {
+ if (value === null || value === undefined) continue;
+ if (typeof value === 'object' && !Array.isArray(value)) {
+ result[key] = stripNulls(value as Record<string, unknown>);
+ } else {
+ result[key] = value;
+ }
+ }
+ return result;
+}
+
+export function serialize(data: Record<string, unknown>, format: SerializationFormat): string {
+ switch (format) {
+ case 'json':
+ return JSON.stringify(data, null, 2);
+ case 'yaml':
+ return yaml.dump(data, {
+ indent: 2,
+ lineWidth: 120,
+ noRefs: true,
+ sortKeys: false,
+ });
+ case 'toml':
+ // smol-toml expects a plain record; strip null values since TOML has no null
+ return TOML.stringify(stripNulls(data) as any);
+ }
+}
+
+export function deserialize(text: string, format: SerializationFormat): Record<string, unknown> {
+ switch (format) {
+ case 'json': {
+ const parsed = JSON.parse(text);
+ if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+ throw new Error('JSON root must be an object');
+ }
+ return parsed as Record<string, unknown>;
+ }
+ case 'yaml': {
+ const parsed = yaml.load(text);
+ if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+ throw new Error('YAML root must be a mapping');
+ }
+ return parsed as Record<string, unknown>;
+ }
+ case 'toml': {
+ return TOML.parse(text) as Record<string, unknown>;
+ }
+ }
+}
+
+export function convertFormat(text: string, from: SerializationFormat, to: SerializationFormat): string {
+ if (from === to) return text;
+ const data = deserialize(text, from);
+ return serialize(data, to);
+}
+
+export const FORMAT_EXTENSIONS: Record<SerializationFormat, string> = {
+ json: '.json',
+ yaml: '.yaml',
+ toml: '.toml',
+};
+
+export const FORMAT_MIME_TYPES: Record<SerializationFormat, string> = {
+ json: 'application/json',
+ yaml: 'text/yaml',
+ toml: 'application/toml',
+};
+
+export const FORMAT_MONACO_LANGUAGES: Record<SerializationFormat, string> = {
+ json: 'json',
+ yaml: 'yaml',
+ toml: 'toml',
+};
diff --git a/freemocap-ui-old/src/components/setup-wizard/FirstLaunchRedirect.tsx b/freemocap-ui-old/src/components/setup-wizard/FirstLaunchRedirect.tsx
new file mode 100644
index 00000000..2021bb52
--- /dev/null
+++ b/freemocap-ui-old/src/components/setup-wizard/FirstLaunchRedirect.tsx
@@ -0,0 +1,26 @@
+import React, { useEffect } from 'react';
+import { useNavigate, useLocation } from 'react-router-dom';
+import { useSetupWizardRequired } from '@/components/setup-wizard/SetupWizard';
+
+/**
+ * Invisible component that redirects to /setup on first launch.
+ * Render this anywhere inside a HashRouter.
+ * Once setup is complete (persisted to ~/.freemocap/settings.json),
+ * this does nothing.
+ */
+export const FirstLaunchRedirect: React.FC = () => {
+ const { loading, required } = useSetupWizardRequired();
+ const navigate = useNavigate();
+ const location = useLocation();
+
+ useEffect(() => {
+ if (loading) return;
+ if (!required) return;
+ // Don't redirect if we're already on the settings page
+ if (location.pathname === '/settings') return;
+
+ navigate('/settings', { replace: true });
+ }, [loading, required, location.pathname, navigate]);
+
+ return null;
+};
diff --git a/freemocap-ui-old/src/components/setup-wizard/SetupWizard.tsx b/freemocap-ui-old/src/components/setup-wizard/SetupWizard.tsx
new file mode 100644
index 00000000..61c77eae
--- /dev/null
+++ b/freemocap-ui-old/src/components/setup-wizard/SetupWizard.tsx
@@ -0,0 +1,758 @@
+import React, { useState, useEffect, useCallback } from 'react';
+import {
+ Box,
+ Typography,
+ Button,
+ LinearProgress,
+ CircularProgress,
+ Chip,
+ Tooltip,
+ Alert,
+ Paper,
+ Stepper,
+ Step,
+ StepLabel,
+ IconButton,
+} from '@mui/material';
+import { useTheme } from '@mui/material/styles';
+import CheckCircleIcon from '@mui/icons-material/CheckCircle';
+import ErrorIcon from '@mui/icons-material/Error';
+import WarningIcon from '@mui/icons-material/Warning';
+import DownloadIcon from '@mui/icons-material/Download';
+import RefreshIcon from '@mui/icons-material/Refresh';
+import ComputerIcon from '@mui/icons-material/Computer';
+import MemoryIcon from '@mui/icons-material/Memory';
+import StorageIcon from '@mui/icons-material/Storage';
+import SpeedIcon from '@mui/icons-material/Speed';
+import VideocamIcon from '@mui/icons-material/Videocam';
+import ArrowForwardIcon from '@mui/icons-material/ArrowForward';
+import ArrowBackIcon from '@mui/icons-material/ArrowBack';
+import CloseIcon from '@mui/icons-material/Close';
+import { useElectronIPC } from '@/services';
+
+// ── Types (mirrors electron-side types) ──
+
+interface CpuInfo { model: string; cores: number; threads: number; speedMhz: number }
+interface RamInfo { totalGb: number; availableGb: number }
+interface GpuInfo { name: string; vendor: string; vramMb: number | null; cudaAvailable: boolean; cudaVersion: string | null }
+interface DiskInfo { path: string; totalGb: number; freeGb: number }
+interface OsInfo { platform: string; release: string; arch: string; hostname: string }
+type PerformanceTier = 'basic' | 'standard' | 'advanced' | 'pro';
+interface PerformanceRecommendation {
+ tier: PerformanceTier;
+ label: string;
+ description: string;
+ maxCameras: number;
+ maxResolution: string;
+ realtimeTracking: boolean;
+ warnings: string[];
+}
+interface SystemScanResult {
+ cpu: CpuInfo;
+ ram: RamInfo;
+ gpus: GpuInfo[];
+ disk: DiskInfo;
+ os: OsInfo;
+ recommendation: PerformanceRecommendation;
+ scannedAt: string;
+}
+
+type DependencyStatus = 'installed' | 'missing' | 'outdated' | 'checking' | 'installing' | 'error';
+interface DependencyInfo {
+ id: string;
+ name: string;
+ description: string;
+ required: boolean;
+ status: DependencyStatus;
+ version: string | null;
+ installedPath: string | null;
+ error: string | null;
+}
+
+// ── Constants ──
+
+const SETUP_COMPLETE_KEY = 'setupComplete';
+const SYSTEM_SCAN_KEY = 'lastSystemScan';
+const STEPS = ['System Scan', 'Dependencies', 'Ready'];
+
+const TIER_COLORS: Record<PerformanceTier, string> = {
+ basic: '#ff9800',
+ standard: '#2196f3',
+ advanced: '#4caf50',
+ pro: '#00e5ff',
+};
+
+const TIER_EMOJIS: Record<PerformanceTier, string> = {
+ basic: '🐢',
+ standard: '🏃',
+ advanced: '🚀',
+ pro: '⚡',
+};
+
+// ── Status icon helper ──
+
+function StatusIcon({ status }: { status: DependencyStatus }) {
+ switch (status) {
+ case 'installed':
+ return <CheckCircleIcon sx={{ color: '#4caf50', fontSize: 20 }} />;
+ case 'missing':
+ return <ErrorIcon sx={{ color: '#f44336', fontSize: 20 }} />;
+ case 'outdated':
+ return <WarningIcon sx={{ color: '#ff9800', fontSize: 20 }} />;
+ case 'checking':
+ case 'installing':
+ return <CircularProgress size={18} />;
+ case 'error':
+ return <ErrorIcon sx={{ color: '#f44336', fontSize: 20 }} />;
+ }
+}
+
+// ── Step 0: System Scan ──
+
+function SystemScanStep({
+ scanResult,
+ scanning,
+ onRescan,
+}: {
+ scanResult: SystemScanResult | null;
+ scanning: boolean;
+ onRescan: () => void;
+}) {
+ const theme = useTheme();
+
+ if (scanning) {
+ return (
+ <Box sx={{ textAlign: 'center', py: 6 }}>
+ <CircularProgress size={48} />
+ <Typography sx={{ mt: 2, color: theme.palette.text.secondary }}>
+ Scanning your system...
+ </Typography>
+ </Box>
+ );
+ }
+
+ if (!scanResult) {
+ return (
+ <Box sx={{ textAlign: 'center', py: 6 }}>
+ <Typography color="error">Scan failed. Please retry.</Typography>
+ <Button onClick={onRescan} startIcon={<RefreshIcon />} sx={{ mt: 2 }}>
+ Retry Scan
+ </Button>
+ </Box>
+ );
+ }
+
+ const { cpu, ram, gpus, disk, os: osInfo, recommendation } = scanResult;
+ const tierColor = TIER_COLORS[recommendation.tier];
+
+ return (
+ <Box sx={{ display: 'flex', flexDirection: 'column', gap: 2 }}>
+ {/* Performance Tier Badge */}
+ <Paper
+ elevation={0}
+ sx={{
+ p: 2,
+ border: `2px solid ${tierColor}`,
+ borderRadius: 2,
+ background: `${tierColor}11`,
+ textAlign: 'center',
+ }}
+ >
+ <Typography variant="h5" sx={{ fontWeight: 700, color: tierColor }}>
+ {TIER_EMOJIS[recommendation.tier]} {recommendation.label} System
+ </Typography>
+ <Typography variant="body2" sx={{ mt: 0.5, color: theme.palette.text.secondary }}>
+ {recommendation.description}
+ </Typography>
+ <Box sx={{ display: 'flex', justifyContent: 'center', gap: 2, mt: 1.5, flexWrap: 'wrap' }}>
+ <Chip
+ icon={<VideocamIcon />}
+ label={`Up to ${recommendation.maxCameras} cameras`}
+ size="small"
+ sx={{ borderColor: tierColor, color: tierColor }}
+ variant="outlined"
+ />
+ <Chip
+ label={`${recommendation.maxResolution} max`}
+ size="small"
+ sx={{ borderColor: tierColor, color: tierColor }}
+ variant="outlined"
+ />
+ {recommendation.realtimeTracking && (
+ <Chip
+ icon={<SpeedIcon />}
+ label="Real-time tracking"
+ size="small"
+ sx={{ borderColor: tierColor, color: tierColor }}
+ variant="outlined"
+ />
+ )}
+ </Box>
+ </Paper>
+
+ {/* Hardware Details Grid */}
+ <Box sx={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: 1.5 }}>
+ {/* CPU */}
+ <Paper elevation={0} sx={{ p: 1.5, border: `1px solid ${theme.palette.divider}`, borderRadius: 1 }}>
+ <Box sx={{ display: 'flex', alignItems: 'center', gap: 1, mb: 0.5 }}>
+ <MemoryIcon sx={{ fontSize: 18, color: theme.palette.text.secondary }} />
+ <Typography variant="caption" sx={{ fontWeight: 600, color: theme.palette.text.secondary }}>
+ CPU
+ </Typography>
+ </Box>
+ <Typography variant="body2" sx={{ fontWeight: 500, fontSize: '0.8rem' }}>
+ {cpu.model}
+ </Typography>
+ <Typography variant="caption" sx={{ color: theme.palette.text.secondary }}>
+ {cpu.threads} threads • {cpu.cores} cores • {cpu.speedMhz} MHz
+ </Typography>
+ </Paper>
+
+ {/* RAM */}
+ <Paper elevation={0} sx={{ p: 1.5, border: `1px solid ${theme.palette.divider}`, borderRadius: 1 }}>
+ <Box sx={{ display: 'flex', alignItems: 'center', gap: 1, mb: 0.5 }}>
+ <ComputerIcon sx={{ fontSize: 18, color: theme.palette.text.secondary }} />
+ <Typography variant="caption" sx={{ fontWeight: 600, color: theme.palette.text.secondary }}>
+ MEMORY
+ </Typography>
+ </Box>
+ <Typography variant="body2" sx={{ fontWeight: 500 }}>
+ {ram.totalGb} GB total
+ </Typography>
+ <Typography variant="caption" sx={{ color: theme.palette.text.secondary }}>
+ {ram.availableGb} GB available
+ </Typography>
+ </Paper>
+
+ {/* GPU */}
+ <Paper elevation={0} sx={{ p: 1.5, border: `1px solid ${theme.palette.divider}`, borderRadius: 1 }}>
+ <Box sx={{ display: 'flex', alignItems: 'center', gap: 1, mb: 0.5 }}>
+ <SpeedIcon sx={{ fontSize: 18, color: theme.palette.text.secondary }} />
+ <Typography variant="caption" sx={{ fontWeight: 600, color: theme.palette.text.secondary }}>
+ GPU
+ </Typography>
+ </Box>
+ {gpus.length > 0 ? gpus.map((gpu, i) => (
+ <Box key={i}>
+ <Typography variant="body2" sx={{ fontWeight: 500, fontSize: '0.8rem' }}>
+ {gpu.name}
+ </Typography>
+ <Typography variant="caption" sx={{ color: theme.palette.text.secondary }}>
+ {gpu.vramMb ? `${Math.round(gpu.vramMb / 1024)} GB VRAM` : 'VRAM unknown'}
+ {gpu.cudaAvailable ? ` • CUDA ${gpu.cudaVersion || '✓'}` : ''}
+ </Typography>
+ </Box>
+ )) : (
+ <Typography variant="body2" sx={{ color: theme.palette.text.disabled }}>
+ No dedicated GPU detected
+ </Typography>
+ )}
+ </Paper>
+
+ {/* Disk */}
+ <Paper elevation={0} sx={{ p: 1.5, border: `1px solid ${theme.palette.divider}`, borderRadius: 1 }}>
+ <Box sx={{ display: 'flex', alignItems: 'center', gap: 1, mb: 0.5 }}>
+ <StorageIcon sx={{ fontSize: 18, color: theme.palette.text.secondary }} />
+ <Typography variant="caption" sx={{ fontWeight: 600, color: theme.palette.text.secondary }}>
+ DISK
+ </Typography>
+ </Box>
+ <Typography variant="body2" sx={{ fontWeight: 500 }}>
+ {disk.freeGb} GB free
+ </Typography>
+ <Typography variant="caption" sx={{ color: theme.palette.text.secondary }}>
+ of {disk.totalGb} GB total
+ </Typography>
+ {disk.freeGb > 0 && disk.freeGb < 20 && (
+ <LinearProgress
+ variant="determinate"
+ value={((disk.totalGb - disk.freeGb) / disk.totalGb) * 100}
+ color="warning"
+ sx={{ mt: 0.5, height: 4, borderRadius: 1 }}
+ />
+ )}
+ </Paper>
+ </Box>
+
+ {/* Warnings */}
+ {recommendation.warnings.length > 0 && (
+ <Box sx={{ display: 'flex', flexDirection: 'column', gap: 0.5 }}>
+ {recommendation.warnings.map((w, i) => (
+ <Alert key={i} severity="warning" sx={{ py: 0, fontSize: '0.75rem' }}>
+ {w}
+ </Alert>
+ ))}
+ </Box>
+ )}
+
+ {/* Rescan button */}
+ <Box sx={{ display: 'flex', justifyContent: 'flex-end' }}>
+ <Button size="small" startIcon={<RefreshIcon />} onClick={onRescan}>
+ Rescan
+ </Button>
+ </Box>
+ </Box>
+ );
+}
+
+// ── Step 1: Dependencies ──
+
+function DependenciesStep({
+ dependencies,
+ installing,
+ onInstall,
+ onRefresh,
+}: {
+ dependencies: DependencyInfo[];
+ installing: string | null;
+ onInstall: (id: string) => void;
+ onRefresh: () => void;
+}) {
+ const theme = useTheme();
+
+ if (dependencies.length === 0) {
+ return (
+ <Box sx={{ textAlign: 'center', py: 6 }}>
+ <CircularProgress size={48} />
+ <Typography sx={{ mt: 2, color: theme.palette.text.secondary }}>
+ Checking dependencies...
+ </Typography>
+ </Box>
+ );
+ }
+
+ const required = dependencies.filter(d => d.required);
+ const optional = dependencies.filter(d => !d.required);
+
+ return (
+ <Box sx={{ display: 'flex', flexDirection: 'column', gap: 2 }}>
+ {/* Required */}
+ <Box>
+ <Typography variant="subtitle2" sx={{ mb: 1, color: theme.palette.text.secondary, fontWeight: 600 }}>
+ REQUIRED
+ </Typography>
+ <Box sx={{ display: 'flex', flexDirection: 'column', gap: 1 }}>
+ {required.map(dep => (
+ <DependencyRow
+ key={dep.id}
+ dep={dep}
+ installing={installing === dep.id}
+ onInstall={() => onInstall(dep.id)}
+ />
+ ))}
+ </Box>
+ </Box>
+
+ {/* Optional */}
+ <Box>
+ <Typography variant="subtitle2" sx={{ mb: 1, color: theme.palette.text.secondary, fontWeight: 600 }}>
+ OPTIONAL
+ </Typography>
+ <Box sx={{ display: 'flex', flexDirection: 'column', gap: 1 }}>
+ {optional.map(dep => (
+ <DependencyRow
+ key={dep.id}
+ dep={dep}
+ installing={installing === dep.id}
+ onInstall={() => onInstall(dep.id)}
+ />
+ ))}
+ </Box>
+ </Box>
+
+ <Box sx={{ display: 'flex', justifyContent: 'flex-end' }}>
+ <Button size="small" startIcon={<RefreshIcon />} onClick={onRefresh}>
+ Recheck All
+ </Button>
+ </Box>
+ </Box>
+ );
+}
+
+function DependencyRow({
+ dep,
+ installing,
+ onInstall,
+}: {
+ dep: DependencyInfo;
+ installing: boolean;
+ onInstall: () => void;
+}) {
+ const theme = useTheme();
+ const canInstall = dep.status === 'missing' || dep.status === 'outdated';
+ const isCuda = dep.id === 'cuda';
+
+ return (
+ <Paper
+ elevation={0}
+ sx={{
+ p: 1.5,
+ border: `1px solid ${theme.palette.divider}`,
+ borderRadius: 1,
+ display: 'flex',
+ alignItems: 'center',
+ gap: 1.5,
+ }}
+ >
+ <StatusIcon status={installing ? 'installing' : dep.status} />
+
+ <Box sx={{ flex: 1, minWidth: 0 }}>
+ <Box sx={{ display: 'flex', alignItems: 'center', gap: 1 }}>
+ <Typography variant="body2" sx={{ fontWeight: 600 }}>
+ {dep.name}
+ </Typography>
+ {dep.version && (
+ <Chip label={dep.version} size="small" sx={{ height: 18, fontSize: '0.65rem' }} />
+ )}
+ {dep.required && (
+ <Chip label="required" size="small" color="warning" variant="outlined" sx={{ height: 18, fontSize: '0.6rem' }} />
+ )}
+ </Box>
+ <Typography variant="caption" sx={{ color: theme.palette.text.secondary }}>
+ {dep.description}
+ </Typography>
+ {dep.error && (
+ <Typography variant="caption" sx={{ display: 'block', color: theme.palette.error.main, mt: 0.25 }}>
+ {dep.error}
+ </Typography>
+ )}
+ {dep.installedPath && dep.status === 'installed' && (
+ <Tooltip title={dep.installedPath}>
+ <Typography
+ variant="caption"
+ sx={{
+ display: 'block',
+ color: theme.palette.text.disabled,
+ fontSize: '0.6rem',
+ overflow: 'hidden',
+ textOverflow: 'ellipsis',
+ whiteSpace: 'nowrap',
+ maxWidth: 300,
+ }}
+ >
+ {dep.installedPath}
+ </Typography>
+ </Tooltip>
+ )}
+ </Box>
+
+ {canInstall && !isCuda && (
+ <Button
+ size="small"
+ variant="contained"
+ startIcon={installing ? <CircularProgress size={14} color="inherit" /> : <DownloadIcon />}
+ onClick={onInstall}
+ disabled={installing}
+ sx={{ textTransform: 'none', fontSize: '0.75rem', whiteSpace: 'nowrap' }}
+ >
+ {installing ? 'Installing...' : dep.status === 'outdated' ? 'Update' : 'Install'}
+ </Button>
+ )}
+ {canInstall && isCuda && (
+ <Tooltip title="CUDA must be installed manually from the NVIDIA website">
+ <Typography variant="caption" sx={{ color: theme.palette.text.disabled, fontStyle: 'italic' }}>
+ Manual install
+ </Typography>
+ </Tooltip>
+ )}
+ </Paper>
+ );
+}
+
+// ── Step 2: Ready ──
+
+function ReadyStep({ scanResult }: { scanResult: SystemScanResult | null }) {
+ const theme = useTheme();
+ const tier = scanResult?.recommendation.tier ?? 'standard';
+ const tierColor = TIER_COLORS[tier];
+
+ return (
+ <Box sx={{ textAlign: 'center', py: 4 }}>
+ <CheckCircleIcon sx={{ fontSize: 64, color: '#4caf50', mb: 2 }} />
+ <Typography variant="h5" sx={{ fontWeight: 700, mb: 1 }}>
+ You're all set!
+ </Typography>
+ <Typography sx={{ color: theme.palette.text.secondary, mb: 3, maxWidth: 400, mx: 'auto' }}>
+ FreeMoCap is ready to go. You can always re-run this setup from the settings menu.
+ </Typography>
+
+ {scanResult && (
+ <Box sx={{ display: 'flex', justifyContent: 'center', gap: 1, flexWrap: 'wrap' }}>
+ <Chip
+ label={`${scanResult.recommendation.label} System`}
+ sx={{ borderColor: tierColor, color: tierColor, fontWeight: 600 }}
+ variant="outlined"
+ />
+ <Chip
+ label={`Up to ${scanResult.recommendation.maxCameras} cameras @ ${scanResult.recommendation.maxResolution}`}
+ variant="outlined"
+ size="small"
+ />
+ </Box>
+ )}
+ </Box>
+ );
+}
+
+// ── Main Wizard ──
+
+interface SetupWizardProps {
+ onComplete: () => void;
+ /** When true, always shows the wizard regardless of persisted state */
+ forceShow?: boolean;
+}
+
+export const SetupWizard: React.FC<SetupWizardProps> = ({ onComplete, forceShow = false }) => {
+ const theme = useTheme();
+ const { isElectron, api } = useElectronIPC();
+
+ const [activeStep, setActiveStep] = useState(0);
+ const [scanning, setScanning] = useState(false);
+ const [scanResult, setScanResult] = useState<SystemScanResult | null>(null);
+ const [dependencies, setDependencies] = useState<DependencyInfo[]>([]);
+ const [installing, setInstalling] = useState<string | null>(null);
+
+ // ── System scan ──
+
+ const runScan = useCallback(async () => {
+ if (!isElectron || !api) return;
+ setScanning(true);
+ try {
+ const result = await api.system.scan.query();
+ const typed = result as SystemScanResult;
+ setScanResult(typed);
+ // Persist scan result to ~/.freemocap/settings.json
+ await api.settings.set.mutate({ key: SYSTEM_SCAN_KEY, value: typed });
+ } catch (err) {
+ console.error('System scan failed:', err);
+ } finally {
+ setScanning(false);
+ }
+ }, [isElectron, api]);
+
+ // ── Dependency detection ──
+
+ const detectDeps = useCallback(async () => {
+ if (!isElectron || !api) return;
+ try {
+ const result = await api.dependencies.detectAll.query();
+ setDependencies(result as DependencyInfo[]);
+ } catch (err) {
+ console.error('Dependency detection failed:', err);
+ }
+ }, [isElectron, api]);
+
+ // ── Install a dependency ──
+
+ const installDep = useCallback(async (depId: string) => {
+ if (!isElectron || !api) return;
+ setInstalling(depId);
+ try {
+ const updated = await api.dependencies.install.mutate({ dependencyId: depId });
+ setDependencies(prev =>
+ prev.map(d => d.id === depId ? (updated as DependencyInfo) : d),
+ );
+
+ // After installing uv, re-detect python-env too (it depends on uv)
+ if (depId === 'uv') {
+ const envInfo = await api.dependencies.detect.query({ dependencyId: 'python-env' });
+ setDependencies(prev =>
+ prev.map(d => d.id === 'python-env' ? (envInfo as DependencyInfo) : d),
+ );
+ }
+ } catch (err) {
+ console.error(`Failed to install ${depId}:`, err);
+ setDependencies(prev =>
+ prev.map(d =>
+ d.id === depId
+ ? { ...d, status: 'error' as DependencyStatus, error: err instanceof Error ? err.message : String(err) }
+ : d,
+ ),
+ );
+ } finally {
+ setInstalling(null);
+ }
+ }, [isElectron, api]);
+
+ // ── Load persisted scan result on mount ──
+
+ useEffect(() => {
+ if (!isElectron || !api) return;
+ api.settings.get.query({ key: SYSTEM_SCAN_KEY }).then(result => {
+ if (result && typeof result === 'object' && 'cpu' in (result as object)) {
+ setScanResult(result as SystemScanResult);
+ }
+ }).catch(() => { /* no persisted scan — will run fresh */ });
+ }, [isElectron, api]);
+
+ // ── Auto-run on step change ──
+
+ useEffect(() => {
+ if (activeStep === 0 && !scanResult && !scanning) {
+ runScan();
+ }
+ }, [activeStep, scanResult, scanning, runScan]);
+
+ useEffect(() => {
+ if (activeStep === 1 && dependencies.length === 0) {
+ detectDeps();
+ }
+ }, [activeStep, dependencies.length, detectDeps]);
+
+ // ── Completion ──
+
+ const handleFinish = useCallback(() => {
+ if (isElectron && api) {
+ api.settings.set.mutate({ key: SETUP_COMPLETE_KEY, value: true }).catch(err => {
+ console.error('Failed to persist setup complete state:', err);
+ });
+ }
+ onComplete();
+ }, [onComplete, isElectron, api]);
+
+ // ── Navigation ──
+
+ const canProceed = (): boolean => {
+ if (activeStep === 0) return scanResult !== null;
+ if (activeStep === 1) return true; // Dependencies are not blocking
+ return true;
+ };
+
+ // If not in Electron, show a simple non-Electron message
+ if (!isElectron) {
+ return (
+ <Box sx={{ p: 4, textAlign: 'center' }}>
+ <Typography variant="h6" sx={{ mb: 2 }}>Setup Wizard</Typography>
+ <Typography sx={{ color: theme.palette.text.secondary, mb: 3 }}>
+ The setup wizard is only available in the desktop app.
+ Connect to a running FreeMoCap server to get started.
+ </Typography>
+ <Button variant="contained" onClick={onComplete}>Continue</Button>
+ </Box>
+ );
+ }
+
+ return (
+ <Box
+ sx={{
+ width: '100%',
+ maxWidth: 640,
+ mx: 'auto',
+ p: 3,
+ display: 'flex',
+ flexDirection: 'column',
+ gap: 2,
+ }}
+ >
+ {/* Header */}
+ <Box sx={{ display: 'flex', alignItems: 'center', justifyContent: 'space-between' }}>
+ <Typography variant="h6" sx={{ fontWeight: 700 }}>
+ FreeMoCap Setup
+ </Typography>
+ <Tooltip title="Skip setup">
+ <IconButton size="small" onClick={handleFinish}>
+ <CloseIcon sx={{ fontSize: 18 }} />
+ </IconButton>
+ </Tooltip>
+ </Box>
+
+ {/* Stepper */}
+ <Stepper activeStep={activeStep} alternativeLabel sx={{ mb: 1 }}>
+ {STEPS.map(label => (
+ <Step key={label}>
+ <StepLabel>{label}</StepLabel>
+ </Step>
+ ))}
+ </Stepper>
+
+ {/* Step Content */}
+ <Box sx={{ minHeight: 300 }}>
+ {activeStep === 0 && (
+ <SystemScanStep
+ scanResult={scanResult}
+ scanning={scanning}
+ onRescan={runScan}
+ />
+ )}
+ {activeStep === 1 && (
+ <DependenciesStep
+ dependencies={dependencies}
+ installing={installing}
+ onInstall={installDep}
+ onRefresh={detectDeps}
+ />
+ )}
+ {activeStep === 2 && (
+ <ReadyStep scanResult={scanResult} />
+ )}
+ </Box>
+
+ {/* Navigation Buttons */}
+ <Box sx={{ display: 'flex', justifyContent: 'space-between', mt: 1 }}>
+ <Button
+ disabled={activeStep === 0}
+ onClick={() => setActiveStep(prev => prev - 1)}
+ startIcon={<ArrowBackIcon />}
+ sx={{ textTransform: 'none' }}
+ >
+ Back
+ </Button>
+
+ {activeStep < STEPS.length - 1 ? (
+ <Button
+ variant="contained"
+ disabled={!canProceed()}
+ onClick={() => setActiveStep(prev => prev + 1)}
+ endIcon={<ArrowForwardIcon />}
+ sx={{ textTransform: 'none' }}
+ >
+ Next
+ </Button>
+ ) : (
+ <Button
+ variant="contained"
+ color="success"
+ onClick={handleFinish}
+ sx={{ textTransform: 'none', fontWeight: 600 }}
+ >
+ Get Started
+ </Button>
+ )}
+ </Box>
+ </Box>
+ );
+};
+
+// ── Hook: should the wizard be shown? ──
+// Reads from ~/.freemocap/settings.json via electron IPC.
+// Returns { loading, required } — `required` is true until we've confirmed
+// the file says setup is complete.
+
+export function useSetupWizardRequired(): { loading: boolean; required: boolean } {
+ const { isElectron, api } = useElectronIPC();
+ const [loading, setLoading] = useState(true);
+ const [required, setRequired] = useState(true);
+
+ useEffect(() => {
+ if (!isElectron || !api) {
+ // Not in Electron — never show the wizard
+ setRequired(false);
+ setLoading(false);
+ return;
+ }
+
+ api.settings.get.query({ key: SETUP_COMPLETE_KEY })
+ .then(value => {
+ setRequired(value !== true);
+ })
+ .catch(() => {
+ // Settings file doesn't exist yet — setup is required
+ setRequired(true);
+ })
+ .finally(() => {
+ setLoading(false);
+ });
+ }, [isElectron, api]);
+
+ return { loading, required };
+}
\ No newline at end of file
diff --git a/freemocap-ui-old/src/components/ui-components/BottomPanelContent.tsx b/freemocap-ui-old/src/components/ui-components/BottomPanelContent.tsx
new file mode 100644
index 00000000..f1359035
--- /dev/null
+++ b/freemocap-ui-old/src/components/ui-components/BottomPanelContent.tsx
@@ -0,0 +1,41 @@
+// freemocap-ui/src/components/ui-components/BottomPanelContent.tsx
+import * as React from 'react';
+import Box from '@mui/material/Box';
+import {LogTerminal} from "@/components/LogTerminal";
+import {Panel, PanelGroup, PanelResizeHandle} from "react-resizable-panels";
+import {useTheme} from "@mui/material/styles";
+import FramerateViewerPanel from "@/components/framerate-viewer/FrameRateViewer";
+
+export default function BottomPanelContent() {
+ const theme = useTheme();
+
+ return (
+ <Box sx={{width: '100%', height: '100%'}}>
+ <PanelGroup direction="horizontal">
+ {/* Framerate Viewer Panel */}
+ <Panel defaultSize={30} minSize={20}>
+ <Box sx={{height: '100%', overflow: 'auto'}}>
+ <FramerateViewerPanel/>
+ Framerate Viewer
+ </Box>
+ </Panel>
+
+ {/* Resize Handle */}
+ <PanelResizeHandle
+ style={{
+ width: "4px",
+ cursor: "col-resize",
+ backgroundColor: theme.palette.primary.light,
+ }}
+ />
+
+ {/* Logs Terminal Panel */}
+ <Panel defaultSize={70} minSize={20}>
+ <Box sx={{height: '100%', overflow: 'auto'}}>
+ <LogTerminal/>
+ </Box>
+ </Panel>
+ </PanelGroup>
+ </Box>
+ );
+}
diff --git a/freemocap-ui-old/src/components/ui-components/Footer.tsx b/freemocap-ui-old/src/components/ui-components/Footer.tsx
new file mode 100644
index 00000000..441c19a8
--- /dev/null
+++ b/freemocap-ui-old/src/components/ui-components/Footer.tsx
@@ -0,0 +1,26 @@
+// Update Copyright.tsx
+import Typography from "@mui/material/Typography";
+import Link from "@mui/material/Link";
+import * as React from "react";
+import {useTheme} from "@mui/material";
+
+export const Footer = function () {
+ const theme = useTheme();
+
+ return (
+ <Typography
+ variant="body2"
+ color={theme.palette.mode === 'dark' ? "rgba(255,255,255,0.7)" : "rgba(0,0,0,0.6)"}
+ align="center"
+ >
+ {'w/ '}
+ <Link color="inherit" href="https://github.com/freemocap/">
+ ❤️
+ </Link>{' from the '}
+ <Link color="inherit" href="https://github.com/freemocap/">
+ FreeMoCap Foundation
+ </Link>{' '}
+ {new Date().getFullYear()}
+ </Typography>
+ );
+}
diff --git a/freemocap-ui-old/src/components/ui-components/Header.tsx b/freemocap-ui-old/src/components/ui-components/Header.tsx
new file mode 100644
index 00000000..bd443e8c
--- /dev/null
+++ b/freemocap-ui-old/src/components/ui-components/Header.tsx
@@ -0,0 +1,34 @@
+// Update Header.tsx
+import * as React from 'react';
+import AppBar from '@mui/material/AppBar';
+import Toolbar from '@mui/material/Toolbar';
+import Typography from '@mui/material/Typography';
+import {Box, useTheme} from '@mui/material';
+import ThemeToggle from './ThemeToggle';
+
+export const Header = function () {
+ const theme = useTheme();
+
+ return (
+ <AppBar
+ color="primary"
+ position="sticky"
+ elevation={0}
+ sx={{
+ borderBottom: '1px solid',
+ borderColor: theme.palette.divider
+ }}
+ >
+ <Toolbar>
+ <Typography variant="h6" color="inherit" sx={{flexGrow: 1}}>
+ FreeMoCap 💀📸
+ </Typography>
+ <Box sx={{display: 'flex', alignItems: 'center', gap: 1}}>
+ <ThemeToggle/>
+ </Box>
+ </Toolbar>
+ </AppBar>
+ );
+}
+
+export default Header;
diff --git a/freemocap-ui-old/src/components/ui-components/LeftSidePanelContent.tsx b/freemocap-ui-old/src/components/ui-components/LeftSidePanelContent.tsx
new file mode 100644
index 00000000..8cb8ec8d
--- /dev/null
+++ b/freemocap-ui-old/src/components/ui-components/LeftSidePanelContent.tsx
@@ -0,0 +1,290 @@
+import React, { useCallback, useMemo, useState } from 'react';
+import Box from '@mui/material/Box';
+import { IconButton, List, ListItem, Tooltip, useTheme } from '@mui/material';
+import {
+ closestCenter,
+ DndContext,
+ DragEndEvent,
+ KeyboardSensor,
+ PointerSensor,
+ useSensor,
+ useSensors,
+} from '@dnd-kit/core';
+import {
+ arrayMove,
+ SortableContext,
+ sortableKeyboardCoordinates,
+ verticalListSortingStrategy,
+} from '@dnd-kit/sortable';
+import { restrictToVerticalAxis, restrictToParentElement } from '@dnd-kit/modifiers';
+import ThemeToggle from '@/components/ui-components/ThemeToggle';
+import HomeIcon from '@mui/icons-material/Home';
+import { useLocation, useNavigate } from 'react-router-dom';
+import VideocamIcon from '@mui/icons-material/Videocam';
+import DirectionsRunIcon from '@mui/icons-material/DirectionsRun';
+import TuneIcon from '@mui/icons-material/Tune';
+import { VideoFolderPanel } from '@/components/video-folder-panel/VideoFolderPanel';
+import { SortableSectionWrapper } from '@/components/common/SortableSectionWrapper';
+import { ServerConnectionStatus } from '@/components/ServerConnectionStatus';
+import { ProcessingPipelinePanel } from '@/components/processing-pipeline-panel/ProcessingPipelinePanel';
+import { CameraConfigTreeView } from '@/components/camera-config-tree-view/CameraConfigTreeView';
+import { CalibrationControlPanel } from '@/components/calibration-control-panel/CalibrationControlPanel';
+import { MocapTaskTreeItem } from '@/components/mocap-control-panel/MocapTaskTreeItem';
+
+const STORAGE_KEY = 'freemocap-sidebar-section-order';
+
+const DEFAULT_SECTION_ORDER = [
+ 'connection',
+ 'pipeline',
+ 'cameras',
+ 'calibration',
+ 'mocap',
+] as const;
+
+type SectionId = (typeof DEFAULT_SECTION_ORDER)[number];
+
+const SECTION_COMPONENTS: Record<SectionId, React.FC> = {
+ connection: ServerConnectionStatus,
+ pipeline: ProcessingPipelinePanel,
+ cameras: CameraConfigTreeView,
+ calibration: CalibrationControlPanel,
+ mocap: MocapTaskTreeItem,
+};
+
+function loadSectionOrder(): SectionId[] {
+ try {
+ const stored = localStorage.getItem(STORAGE_KEY);
+ if (!stored) return [...DEFAULT_SECTION_ORDER];
+ const parsed = JSON.parse(stored) as string[];
+ const defaultSet = new Set<string>(DEFAULT_SECTION_ORDER);
+ const parsedSet = new Set(parsed);
+ if (
+ parsed.length !== DEFAULT_SECTION_ORDER.length ||
+ !parsed.every((id) => defaultSet.has(id)) ||
+ !DEFAULT_SECTION_ORDER.every((id) => parsedSet.has(id))
+ ) {
+ return [...DEFAULT_SECTION_ORDER];
+ }
+ return parsed as SectionId[];
+ } catch {
+ return [...DEFAULT_SECTION_ORDER];
+ }
+}
+
+function saveSectionOrder(order: SectionId[]): void {
+ try {
+ localStorage.setItem(STORAGE_KEY, JSON.stringify(order));
+ } catch {
+ // Storage full or unavailable — silently ignore
+ }
+}
+
+const scrollbarStyles = {
+ '&::-webkit-scrollbar': {
+ width: '6px',
+ backgroundColor: 'transparent',
+ },
+ '&::-webkit-scrollbar-thumb': {
+ backgroundColor: (theme: { palette: { mode: string } }) =>
+ theme.palette.mode === 'dark'
+ ? 'rgba(255, 255, 255, 0.2)'
+ : 'rgba(0, 0, 0, 0.2)',
+ borderRadius: '3px',
+ '&:hover': {
+ backgroundColor: (theme: { palette: { mode: string } }) =>
+ theme.palette.mode === 'dark'
+ ? 'rgba(255, 255, 255, 0.3)'
+ : 'rgba(0, 0, 0, 0.3)',
+ },
+ },
+ '&::-webkit-scrollbar-track': {
+ backgroundColor: 'transparent',
+ },
+ scrollbarWidth: 'thin',
+ scrollbarColor: (theme: { palette: { mode: string } }) =>
+ theme.palette.mode === 'dark'
+ ? 'rgba(255, 255, 255, 0.2) transparent'
+ : 'rgba(0, 0, 0, 0.2) transparent',
+};
+
+export const LeftSidePanelContent = () => {
+ const theme = useTheme();
+ const navigate = useNavigate();
+ const location = useLocation();
+ const [sectionOrder, setSectionOrder] = useState<SectionId[]>(loadSectionOrder);
+
+ const sensors = useSensors(
+ useSensor(PointerSensor, {
+ activationConstraint: {
+ distance: 5,
+ },
+ }),
+ useSensor(KeyboardSensor, {
+ coordinateGetter: sortableKeyboardCoordinates,
+ }),
+ );
+
+ const handleDragEnd = useCallback((event: DragEndEvent) => {
+ const { active, over } = event;
+ if (!over || active.id === over.id) return;
+
+ setSectionOrder((prev) => {
+ const oldIndex = prev.indexOf(active.id as SectionId);
+ const newIndex = prev.indexOf(over.id as SectionId);
+ const newOrder = arrayMove(prev, oldIndex, newIndex);
+ saveSectionOrder(newOrder);
+ return newOrder;
+ });
+ }, []);
+
+ const modifiers = useMemo(
+ () => [restrictToVerticalAxis, restrictToParentElement],
+ [],
+ );
+
+ return (
+ <Box
+ sx={{
+ width: '100%',
+ height: '100%',
+ backgroundColor:
+ theme.palette.mode === 'dark'
+ ? theme.palette.background.paper
+ : theme.palette.grey[50],
+ color: theme.palette.text.primary,
+ display: 'flex',
+ flexDirection: 'column',
+ overflowY: 'auto',
+ overflowX: 'hidden',
+ ...scrollbarStyles,
+ }}
+ >
+ {/* Header */}
+ <List disablePadding>
+ <ListItem
+ sx={{
+ borderBottom:
+ theme.palette.mode === 'dark'
+ ? '1px solid rgba(255,255,255,0.08)'
+ : '1px solid rgba(0,0,0,0.08)',
+ py: 0.75,
+ px: 1.5,
+ minHeight: 40,
+ display: 'flex',
+ justifyContent: 'space-between',
+ alignItems: 'center',
+ }}
+ >
+ <Box
+ component="span"
+ sx={{
+ fontSize: 16,
+ fontWeight: 600,
+ color: theme.palette.text.primary,
+ }}
+ >
+ FreeMoCap 💀📸
+ </Box>
+
+ <Box sx={{ display: 'flex', alignItems: 'center', gap: 0.25 }}>
+ <IconButton
+ size="small"
+ onClick={() => navigate('/')}
+ sx={{
+ padding: '4px',
+ color:
+ location.pathname === '/'
+ ? theme.palette.success.main
+ : theme.palette.text.secondary,
+ }}
+ >
+ <HomeIcon sx={{ fontSize: 18 }} />
+ </IconButton>
+ <IconButton
+ color="inherit"
+ onClick={() => navigate('/viewport3d')}
+ >
+ <DirectionsRunIcon />
+ </IconButton>
+
+ <IconButton
+ size="small"
+ onClick={() => navigate('/cameras')}
+ sx={{
+ padding: '4px',
+ color:
+ location.pathname === '/cameras'
+ ? theme.palette.success.main
+ : theme.palette.text.secondary,
+ }}
+ >
+ <VideocamIcon sx={{ fontSize: 18 }} />
+ </IconButton>
+
+ <Tooltip title="Settings">
+ <IconButton
+ size="small"
+ onClick={() => navigate('/settings')}
+ sx={{
+ padding: '4px',
+ color:
+ location.pathname === '/settings'
+ ? theme.palette.success.main
+ : theme.palette.text.secondary,
+ }}
+ >
+ <TuneIcon sx={{ fontSize: 18 }} />
+ </IconButton>
+ </Tooltip>
+
+ <ThemeToggle />
+ </Box>
+ </ListItem>
+ </List>
+
+ {/* Video Panel for Videos Page */}
+ {location.pathname === '/videos' && (
+ <Box
+ sx={{
+ borderTop: '1px solid',
+ borderColor: theme.palette.divider,
+ }}
+ >
+ <VideoFolderPanel />
+ </Box>
+ )}
+
+ {/* Sidebar Sections — drag-reorderable */}
+ <DndContext
+ sensors={sensors}
+ collisionDetection={closestCenter}
+ modifiers={modifiers}
+ onDragEnd={handleDragEnd}
+ >
+ <SortableContext
+ items={sectionOrder}
+ strategy={verticalListSortingStrategy}
+ >
+ <Box
+ sx={{
+ display: 'flex',
+ flexDirection: 'column',
+ gap: 0.75,
+ p: 0.75,
+ pb: 2,
+ }}
+ >
+ {sectionOrder.map((sectionId) => {
+ const Component = SECTION_COMPONENTS[sectionId];
+ return (
+ <SortableSectionWrapper key={sectionId} id={sectionId}>
+ <Component />
+ </SortableSectionWrapper>
+ );
+ })}
+ </Box>
+ </SortableContext>
+ </DndContext>
+ </Box>
+ );
+};
diff --git a/freemocap-ui-old/src/components/ui-components/ThemeToggle.tsx b/freemocap-ui-old/src/components/ui-components/ThemeToggle.tsx
new file mode 100644
index 00000000..9e8d4a40
--- /dev/null
+++ b/freemocap-ui-old/src/components/ui-components/ThemeToggle.tsx
@@ -0,0 +1,33 @@
+import React from 'react';
+import {IconButton, Tooltip, useTheme} from '@mui/material';
+import Brightness4Icon from '@mui/icons-material/Brightness4'; // Dark mode icon
+import Brightness7Icon from '@mui/icons-material/Brightness7'; // Light mode icon
+import {useAppDispatch, useAppSelector} from '@/store';
+import {themeModeToggled} from '@/store/slices/theme';
+
+export const ThemeToggle: React.FC = () => {
+ const dispatch = useAppDispatch();
+ const theme = useTheme();
+ const themeMode = useAppSelector(state => state.theme.mode);
+ const isDarkMode = themeMode === 'dark';
+
+ return (
+ <Tooltip title={isDarkMode ? "Switch to light mode" : "Switch to dark mode"}>
+ <IconButton
+ onClick={() => dispatch(themeModeToggled())}
+ color="inherit"
+ aria-label="toggle theme"
+ edge="end"
+ sx={{
+ '&:hover': {
+ backgroundColor: theme.palette.action.hover,
+ },
+ }}
+ >
+ {isDarkMode ? <Brightness7Icon /> : <Brightness4Icon />}
+ </IconButton>
+ </Tooltip>
+ );
+};
+
+export default ThemeToggle;
diff --git a/freemocap-ui-old/src/components/update/Modal/index.tsx b/freemocap-ui-old/src/components/update/Modal/index.tsx
new file mode 100644
index 00000000..45799665
--- /dev/null
+++ b/freemocap-ui-old/src/components/update/Modal/index.tsx
@@ -0,0 +1,69 @@
+import React, {ReactNode} from 'react'
+import {createPortal} from 'react-dom'
+import './modal.css'
+
+const ModalTemplate: React.FC<React.PropsWithChildren<{
+ title?: ReactNode
+ footer?: ReactNode
+ cancelText?: string
+ okText?: string
+ onCancel?: () => void
+ onOk?: () => void
+ width?: number
+}>> = props => {
+ const {
+ title,
+ children,
+ footer,
+ cancelText = 'Cancel',
+ okText = 'OK',
+ onCancel,
+ onOk,
+ width = 530,
+ } = props
+
+ return (
+ <div className='update-modal'>
+ <div className='update-modal__mask'/>
+ <div className='update-modal__warp'>
+ <div className='update-modal__content' style={{width}}>
+ <div className='content__header'>
+ <div className='content__header-text'>{title}</div>
+ <span
+ className='update-modal--close'
+ onClick={onCancel}
+ >
+ <svg
+ viewBox="0 0 1024 1024"
+ version="1.1" xmlns="http://www.w3.org/2000/svg"
+ >
+ <path
+ d="M557.312 513.248l265.28-263.904c12.544-12.48 12.608-32.704 0.128-45.248-12.512-12.576-32.704-12.608-45.248-0.128l-265.344 263.936-263.04-263.84C236.64 191.584 216.384 191.52 203.84 204 191.328 216.48 191.296 236.736 203.776 249.28l262.976 263.776L201.6 776.8c-12.544 12.48-12.608 32.704-0.128 45.248 6.24 6.272 14.464 9.44 22.688 9.44 8.16 0 16.32-3.104 22.56-9.312l265.216-263.808 265.44 266.24c6.24 6.272 14.432 9.408 22.656 9.408 8.192 0 16.352-3.136 22.592-9.344 12.512-12.48 12.544-32.704 0.064-45.248L557.312 513.248z"
+ p-id="2764" fill="currentColor">
+ </path>
+ </svg>
+ </span>
+ </div>
+ <div className='content__body'>{children}</div>
+ {typeof footer !== 'undefined' ? (
+ <div className='content__footer'>
+ <button onClick={onCancel}>{cancelText}</button>
+ <button onClick={onOk}>{okText}</button>
+ </div>
+ ) : footer}
+ </div>
+ </div>
+ </div>
+ )
+}
+
+const Modal = (props: Parameters<typeof ModalTemplate>[0] & { open: boolean }) => {
+ const {open, ...omit} = props
+
+ return createPortal(
+ open ? ModalTemplate(omit) : null,
+ document.body,
+ )
+}
+
+export default Modal
diff --git a/freemocap-ui-old/src/components/update/Modal/modal.css b/freemocap-ui-old/src/components/update/Modal/modal.css
new file mode 100644
index 00000000..77e2e17b
--- /dev/null
+++ b/freemocap-ui-old/src/components/update/Modal/modal.css
@@ -0,0 +1,87 @@
+.update-modal {
+ --primary-color: rgb(224, 30, 90);
+
+ .update-modal__mask {
+ width: 100vw;
+ height: 100vh;
+ position: fixed;
+ left: 0;
+ top: 0;
+ z-index: 9;
+ background: rgba(0, 0, 0, 0.45);
+ }
+
+ .update-modal__warp {
+ position: fixed;
+ top: 50%;
+ left: 50%;
+ transform: translate(-50%, -50%);
+ z-index: 19;
+ }
+
+ .update-modal__content {
+ box-shadow: 0 0 10px -4px rgb(130, 86, 208);
+ overflow: hidden;
+ border-radius: 4px;
+
+ .content__header {
+ display: flex;
+ line-height: 38px;
+ background-color: var(--primary-color);
+
+ .content__header-text {
+ font-weight: bold;
+ width: 0;
+ flex-grow: 1;
+ }
+ }
+
+ .update-modal--close {
+ width: 30px;
+ height: 30px;
+ margin: 4px;
+ line-height: 34px;
+ text-align: center;
+ cursor: pointer;
+
+ svg {
+ width: 17px;
+ height: 17px;
+ }
+ }
+
+ .content__body {
+ padding: 10px;
+ background-color: #fff;
+ color: #333;
+ }
+
+ .content__footer {
+ padding: 10px;
+ background-color: #fff;
+ display: flex;
+ justify-content: flex-end;
+
+ button {
+ padding: 7px 11px;
+ background-color: var(--primary-color);
+ font-size: 14px;
+ margin-left: 10px;
+
+ &:first-child {
+ margin-left: 0;
+ }
+ }
+ }
+ }
+
+ .icon {
+ padding: 0 15px;
+ width: 20px;
+ fill: currentColor;
+
+ &:hover {
+ color: rgba(0, 0, 0, 0.4);
+ }
+ }
+}
diff --git a/freemocap-ui-old/src/components/update/Progress/index.tsx b/freemocap-ui-old/src/components/update/Progress/index.tsx
new file mode 100644
index 00000000..8e393f40
--- /dev/null
+++ b/freemocap-ui-old/src/components/update/Progress/index.tsx
@@ -0,0 +1,22 @@
+import React from 'react'
+import './progress.css'
+
+const Progress: React.FC<React.PropsWithChildren<{
+ percent?: number
+}>> = props => {
+ const {percent = 0} = props
+
+ return (
+ <div className='update-progress'>
+ <div className='update-progress-pr'>
+ <div
+ className='update-progress-rate'
+ style={{width: `${3 * percent}px`}}
+ />
+ </div>
+ <span className='update-progress-num'>{(percent ?? 0).toString().substring(0, 4)}%</span>
+ </div>
+ )
+}
+
+export default Progress
diff --git a/freemocap-ui-old/src/components/update/Progress/progress.css b/freemocap-ui-old/src/components/update/Progress/progress.css
new file mode 100644
index 00000000..6abc00cc
--- /dev/null
+++ b/freemocap-ui-old/src/components/update/Progress/progress.css
@@ -0,0 +1,21 @@
+.update-progress {
+ display: flex;
+ align-items: center;
+
+ .update-progress-pr {
+ border: 1px solid #000;
+ border-radius: 3px;
+ height: 6px;
+ width: 300px;
+ }
+
+ .update-progress-rate {
+ height: 6px;
+ border-radius: 3px;
+ background-image: linear-gradient(to right, rgb(130, 86, 208) 0%, var(--primary-color) 100%)
+ }
+
+ .update-progress-num {
+ margin: 0 10px;
+ }
+}
diff --git a/freemocap-ui-old/src/components/update/README.md b/freemocap-ui-old/src/components/update/README.md
new file mode 100644
index 00000000..ca7f9eb0
--- /dev/null
+++ b/freemocap-ui-old/src/components/update/README.md
@@ -0,0 +1,56 @@
+# electron-updater
+
+English | [简体中文](README.zh-CN.md)
+
+> Use `electron-updater` to realize the update detection, download and installation of the electric program.
+
+```sh
+npm i electron-updater
+```
+
+### Main logic
+
+1. ##### Configuration of the update the service address and update information script:
+
+ Add a `publish` field to `electron-builder.json5` for configuring the update address and which strategy to use as the
+ update service.
+
+ ``` json5
+ {
+ "publish": {
+ "provider": "generic",
+ "channel": "latest",
+ "url": "https://foo.com/"
+ }
+ }
+ ```
+
+ For more information, please refer
+ to : [electron-builder.json5...](https://github.com/electron-vite/electron-vite-react/blob/2f2880a9f19de50ff14a0785b32a4d5427477e55/electron-builder.json5#L38)
+
+2. ##### The update logic of Electron:
+
+ - Checking if an update is available;
+ - Checking the version of the software on the server;
+ - Checking if an update is available;
+ - Downloading the new version of the software from the server (when an update is available);
+ - Installation method;
+
+ For more information, please refer
+ to : [update...](https://github.com/electron-vite/electron-vite-react/blob/main/electron/main/update.ts)
+
+3. ##### Updating UI pages in Electron:
+
+ The main function is to provide a UI page for users to trigger the update logic mentioned in (2.) above. Users can
+ click on the page to trigger different update functions in Electron.
+
+ For more information, please refer
+ to : [components/update...](https://github.com/electron-vite/electron-vite-react/blob/main/src/components/update/index.tsx)
+
+---
+
+Here it is recommended to trigger updates through user actions (in this project, Electron update function is triggered
+after the user clicks on the "Check for updates" button).
+
+For more information on using `electron-updater` for Electron updates, please refer to the
+documentation : [auto-update](https://www.electron.build/.html)
diff --git a/freemocap-ui-old/src/components/update/README.zh-CN.md b/freemocap-ui-old/src/components/update/README.zh-CN.md
new file mode 100644
index 00000000..8270f747
--- /dev/null
+++ b/freemocap-ui-old/src/components/update/README.zh-CN.md
@@ -0,0 +1,51 @@
+# electron-auto-update
+
+[English](README.md) | 简体中文
+
+使用`electron-updater`实现electron程序的更新检测、下载和安装等功能。
+
+```sh
+npm i electron-updater
+```
+
+### 主要逻辑
+
+1. ##### 更新地址、更新信息脚本的配置
+
+ 在`electron-builder.json5`添加`publish`字段,用来配置更新地址和使用哪种策略作为更新服务
+
+ ``` json5
+ {
+ "publish": {
+ "provider": "generic", // 提供者、提供商
+ "channel": "latest", // 生成yml文件的名称
+ "url": "https://foo.com/" //更新地址
+ }
+ }
+ ```
+
+更多见 : [electron-builder.json5...](xxx)
+
+2. ##### Electron更新逻辑
+
+ - 检测更新是否可用;
+
+ - 检测服务端的软件版本;
+
+ - 检测更新是否可用;
+
+ - 下载服务端新版软件(当更新可用);
+ - 安装方式;
+
+更多见 : [update...](https://github.com/electron-vite/electron-vite-react/blob/main/electron/main/update.ts)
+
+3. ##### Electron更新UI页面
+
+ 主要功能是:用户触发上述(2.)更新逻辑的UI页面。用户可以通过点击页面触发electron更新的不同功能。
+ 更多见 : [components/update.ts...](https://github.com/electron-vite/electron-vite-react/tree/main/src/components/update/index.tsx)
+
+---
+
+这里建议更新触发以用户操作触发(本项目的以用户点击 **更新检测** 后触发electron更新功能)
+
+关于更多使用`electron-updater`进行electron更新,见文档:[auto-update](https://www.electron.build/.html)
diff --git a/freemocap-ui-old/src/components/update/index.tsx b/freemocap-ui-old/src/components/update/index.tsx
new file mode 100644
index 00000000..fef88a9f
--- /dev/null
+++ b/freemocap-ui-old/src/components/update/index.tsx
@@ -0,0 +1,133 @@
+import type {ProgressInfo} from 'electron-updater'
+import {useCallback, useEffect, useState} from 'react'
+import Modal from '@/components/update/Modal'
+import Progress from '@/components/update/Progress'
+import './update.css'
+
+const Update = () => {
+ const [checking, setChecking] = useState(false)
+ const [updateAvailable, setUpdateAvailable] = useState(false)
+ const [versionInfo, setVersionInfo] = useState<VersionInfo>()
+ const [updateError, setUpdateError] = useState<ErrorType>()
+ const [progressInfo, setProgressInfo] = useState<Partial<ProgressInfo>>()
+ const [modalOpen, setModalOpen] = useState<boolean>(false)
+ const [modalBtn, setModalBtn] = useState<{
+ cancelText?: string
+ okText?: string
+ onCancel?: () => void
+ onOk?: () => void
+ }>({
+ onCancel: () => setModalOpen(false),
+ onOk: () => window.ipcRenderer.invoke('start-download'),
+ })
+
+ const checkUpdate = async () => {
+ setChecking(true)
+ /**
+ * @type {import('electron-updater').UpdateCheckResult | null | { message: string, error: Error }}
+ */
+ const result = await window.ipcRenderer.invoke('check-update')
+ setProgressInfo({percent: 0})
+ setChecking(false)
+ setModalOpen(true)
+ if (result?.error) {
+ setUpdateAvailable(false)
+ setUpdateError(result?.error)
+ }
+ }
+
+ const onUpdateCanAvailable = useCallback((_event: Electron.IpcRendererEvent, arg1: VersionInfo) => {
+ setVersionInfo(arg1)
+ setUpdateError(undefined)
+ // Can be update
+ if (arg1.update) {
+ setModalBtn(state => ({
+ ...state,
+ cancelText: 'Cancel',
+ okText: 'Update',
+ onOk: () => window.ipcRenderer.invoke('start-download'),
+ }))
+ setUpdateAvailable(true)
+ } else {
+ setUpdateAvailable(false)
+ }
+ }, [])
+
+ const onUpdateError = useCallback((_event: Electron.IpcRendererEvent, arg1: ErrorType) => {
+ setUpdateAvailable(false)
+ setUpdateError(arg1)
+ }, [])
+
+ const onDownloadProgress = useCallback((_event: Electron.IpcRendererEvent, arg1: ProgressInfo) => {
+ setProgressInfo(arg1)
+ }, [])
+
+ const onUpdateDownloaded = useCallback((_event: Electron.IpcRendererEvent, ...args: any[]) => {
+ setProgressInfo({percent: 100})
+ setModalBtn(state => ({
+ ...state,
+ cancelText: 'Later',
+ okText: 'Install now',
+ onOk: () => window.ipcRenderer.invoke('quit-and-install'),
+ }))
+ }, [])
+
+ useEffect(() => {
+ // Get version information and whether to update
+ window.ipcRenderer.on('update-can-available', onUpdateCanAvailable)
+ window.ipcRenderer.on('update-error', onUpdateError)
+ window.ipcRenderer.on('download-progress', onDownloadProgress)
+ window.ipcRenderer.on('update-downloaded', onUpdateDownloaded)
+
+ return () => {
+ window.ipcRenderer.off('update-can-available', onUpdateCanAvailable)
+ window.ipcRenderer.off('update-error', onUpdateError)
+ window.ipcRenderer.off('download-progress', onDownloadProgress)
+ window.ipcRenderer.off('update-downloaded', onUpdateDownloaded)
+ }
+ }, [])
+
+ return (
+ <>
+ <Modal
+ open={modalOpen}
+ cancelText={modalBtn?.cancelText}
+ okText={modalBtn?.okText}
+ onCancel={modalBtn?.onCancel}
+ onOk={modalBtn?.onOk}
+ footer={updateAvailable ? /* hide footer */null : undefined}
+ >
+ <div className='modal-slot'>
+ {updateError
+ ? (
+ <div>
+ <p>Error downloading the latest version.</p>
+ <p>{updateError.message}</p>
+ </div>
+ ) : updateAvailable
+ ? (
+ <div>
+ <div>The last version is: v{versionInfo?.newVersion}</div>
+ <div
+ className='new-version__target'>v{versionInfo?.version} -&gt; v{versionInfo?.newVersion}</div>
+ <div className='update__progress'>
+ <div className='progress__title'>Update progress:</div>
+ <div className='progress__bar'>
+ <Progress percent={progressInfo?.percent}></Progress>
+ </div>
+ </div>
+ </div>
+ )
+ : (
+ <div className='can-not-available'>{JSON.stringify(versionInfo ?? {}, null, 2)}</div>
+ )}
+ </div>
+ </Modal>
+ <button disabled={checking} onClick={checkUpdate}>
+ {checking ? 'Checking...' : 'Check update'}
+ </button>
+ </>
+ )
+}
+
+export default Update
diff --git a/freemocap-ui-old/src/components/update/update.css b/freemocap-ui-old/src/components/update/update.css
new file mode 100644
index 00000000..44bbb48b
--- /dev/null
+++ b/freemocap-ui-old/src/components/update/update.css
@@ -0,0 +1,24 @@
+.modal-slot {
+ .update-progress {
+ display: flex;
+ }
+
+ .new-version__target,
+ .update__progress {
+ margin-left: 40px;
+ }
+
+ .progress__title {
+ margin-right: 10px;
+ }
+
+ .progress__bar {
+ width: 0;
+ flex-grow: 1;
+ }
+
+ .can-not-available {
+ padding: 20px;
+ text-align: center;
+ }
+}
diff --git a/freemocap-ui-old/src/components/video-folder-panel/VideoFolderPanel.tsx b/freemocap-ui-old/src/components/video-folder-panel/VideoFolderPanel.tsx
new file mode 100644
index 00000000..3fb9f3da
--- /dev/null
+++ b/freemocap-ui-old/src/components/video-folder-panel/VideoFolderPanel.tsx
@@ -0,0 +1,301 @@
+// freemocap-ui/src/components/video-folder-panel/VideoFolderPanel.tsx
+import React, {useState} from 'react';
+import {
+ Accordion,
+ AccordionDetails,
+ AccordionSummary,
+ alpha,
+ Box,
+ Button,
+ Checkbox,
+ FormControlLabel,
+ IconButton,
+ List,
+ ListItem,
+ ListItemButton,
+ ListItemIcon,
+ ListItemText,
+ Paper,
+ Stack,
+ TextField,
+ Tooltip,
+ Typography,
+ useTheme
+} from '@mui/material';
+import SettingsIcon from '@mui/icons-material/Settings';
+import VideoLibraryIcon from '@mui/icons-material/VideoLibrary';
+import ExpandMoreIcon from '@mui/icons-material/ExpandMore';
+import FolderOpenIcon from '@mui/icons-material/FolderOpen';
+import PlayArrowIcon from '@mui/icons-material/PlayArrow';
+import VideoFileIcon from '@mui/icons-material/VideoFile';
+// Updated imports - using the videos thunks and selectors from the store barrel export
+import {loadVideos, openVideoFile, selectVideoLoadFolder, useAppDispatch, useAppSelector} from "@/store";
+
+export const VideoFolderPanel: React.FC = () => {
+ const theme = useTheme();
+ const dispatch = useAppDispatch();
+
+ // Updated selectors to match the store structure
+ const videoFolder = useAppSelector(state => state.videos.folder);
+ const videoFiles = useAppSelector(state => state.videos.files);
+ const isLoading = useAppSelector(state => state.videos.isLoading);
+ const error = useAppSelector(state => state.videos.error);
+
+ const [showSettings, setShowSettings] = useState(false);
+ const [selectedVideos, setSelectedVideos] = useState<string[]>([]);
+ const [filterText, setFilterText] = useState('');
+
+ const handleSelectFolder = async () => {
+ dispatch(selectVideoLoadFolder());
+ setSelectedVideos([]);
+ };
+
+ const handleLoadVideos = () => {
+ if (videoFiles.length === 0) return;
+
+ const filesToLoad = selectedVideos.length > 0
+ ? videoFiles.filter(file => selectedVideos.includes(file.path))
+ : videoFiles;
+ dispatch(loadVideos({folder: videoFolder, files: filesToLoad}));
+ };
+
+ const handleVideoSelect = (path: string) => {
+ setSelectedVideos(prev => prev.includes(path) ? prev.filter(p => p !== path) : [...prev, path]);
+ };
+
+ const handleSelectAll = () => {
+ setSelectedVideos(prev => prev.length === filteredVideos.length ? [] : filteredVideos.map(file => file.path));
+ };
+
+ const handleOpenVideo = (path: string) => {
+ dispatch(openVideoFile(path));
+ };
+
+ const filteredVideos = videoFiles.filter(file =>
+ file.name.toLowerCase().includes(filterText.toLowerCase())
+ );
+
+ return (
+ <Accordion
+ defaultExpanded
+ sx={{
+ borderRadius: 2,
+ '&:before': {display: 'none'},
+ boxShadow: theme.shadows[3]
+ }}
+ >
+ <Box sx={{
+ display: 'flex',
+ alignItems: 'center',
+ backgroundColor: theme.palette.primary.main,
+ borderTopLeftRadius: 8,
+ borderTopRightRadius: 8,
+ }}>
+ <AccordionSummary
+ expandIcon={<ExpandMoreIcon sx={{color: theme.palette.primary.contrastText}}/>}
+ sx={{
+ flex: 1,
+ color: theme.palette.primary.contrastText,
+ '&:hover': {
+ backgroundColor: theme.palette.primary.light,
+ }
+ }}
+ >
+ <Stack direction="row" alignItems="center" spacing={1}>
+ <VideoLibraryIcon/>
+ <Typography variant="subtitle1" fontWeight="medium">
+ Video Folder Selection
+ </Typography>
+ </Stack>
+ </AccordionSummary>
+
+ <Box sx={{pr: 2}}>
+ <Button
+ variant="contained"
+ color="secondary"
+ disabled={videoFiles.length === 0 || isLoading || (selectedVideos.length === 0 && videoFiles.length > 0)}
+ onClick={handleLoadVideos}
+ startIcon={<PlayArrowIcon/>}
+ sx={{minWidth: '120px'}}
+ >
+ Load Videos
+ </Button>
+ </Box>
+
+ <Box sx={{pr: 2}}>
+ <IconButton
+ onClick={() => setShowSettings(!showSettings)}
+ sx={{
+ color: showSettings
+ ? theme.palette.primary.contrastText
+ : alpha(theme.palette.primary.contrastText, 0.7)
+ }}
+ >
+ <SettingsIcon/>
+ </IconButton>
+ </Box>
+ </Box>
+
+ <AccordionDetails sx={{p: 2, bgcolor: 'background.default'}}>
+ <Paper
+ elevation={0}
+ sx={{
+ bgcolor: 'background.paper',
+ borderRadius: 2,
+ overflow: 'hidden',
+ p: 2
+ }}
+ >
+ <Stack spacing={2}>
+ <Box sx={{display: 'flex', alignItems: 'center', gap: 1}}>
+ <TextField
+ fullWidth
+ label="Video Folder Path"
+ variant="outlined"
+ value={videoFolder}
+ InputProps={{
+ readOnly: true,
+ }}
+ disabled={isLoading}
+ />
+ <Button
+ variant="outlined"
+ startIcon={<FolderOpenIcon/>}
+ onClick={handleSelectFolder}
+ disabled={isLoading}
+ >
+ Browse
+ </Button>
+ </Box>
+
+ {error && (
+ <Typography color="error" variant="body2">
+ Error: {error}
+ </Typography>
+ )}
+
+ {videoFiles.length > 0 && (
+ <Box>
+ <Box sx={{
+ display: 'flex',
+ justifyContent: 'space-between',
+ alignItems: 'center',
+ mb: 1
+ }}>
+ <Typography variant="subtitle2">
+ Found {videoFiles.length} video files
+ {filterText && ` (${filteredVideos.length} shown)`}:
+ </Typography>
+
+ <Box sx={{display: 'flex', alignItems: 'center', gap: 1}}>
+ <TextField
+ size="small"
+ placeholder="Filter videos..."
+ value={filterText}
+ onChange={(e) => setFilterText(e.target.value)}
+ sx={{width: '200px'}}
+ />
+ <FormControlLabel
+ control={
+ <Checkbox
+ checked={selectedVideos.length === filteredVideos.length && filteredVideos.length > 0}
+ indeterminate={selectedVideos.length > 0 && selectedVideos.length < filteredVideos.length}
+ onChange={handleSelectAll}
+ disabled={filteredVideos.length === 0}
+ />
+ }
+ label="Select All"
+ />
+ </Box>
+ </Box>
+
+ <Paper
+ variant="outlined"
+ sx={{
+ maxHeight: '200px',
+ overflow: 'auto',
+ p: 0,
+ }}
+ >
+ <List dense disablePadding>
+ {filteredVideos.map((file) => (
+ <ListItem
+ key={file.path}
+ disablePadding
+ secondaryAction={
+ <Tooltip title="Open video">
+ <IconButton
+ edge="end"
+ size="small"
+ onClick={() => handleOpenVideo(file.path)}
+ >
+ <PlayArrowIcon/>
+ </IconButton>
+ </Tooltip>
+ }
+ >
+ <ListItemButton
+ dense
+ onClick={() => handleVideoSelect(file.path)}
+ selected={selectedVideos.includes(file.path)}
+ >
+ <ListItemIcon sx={{minWidth: 36}}>
+ <Checkbox
+ edge="start"
+ checked={selectedVideos.includes(file.path)}
+ tabIndex={-1}
+ disableRipple
+ />
+ </ListItemIcon>
+ <ListItemIcon sx={{minWidth: 36}}>
+ <VideoFileIcon fontSize="small"/>
+ </ListItemIcon>
+ <ListItemText
+ primary={file.name}
+ primaryTypographyProps={{
+ variant: 'body2',
+ sx: {fontFamily: 'monospace'}
+ }}
+ />
+ </ListItemButton>
+ </ListItem>
+ ))}
+ </List>
+ </Paper>
+ </Box>
+ )}
+
+ {showSettings && (
+ <Paper
+ variant="outlined"
+ sx={{p: 2}}
+ >
+ <Typography variant="subtitle2" gutterBottom>
+ Video Loading Settings
+ </Typography>
+ <Typography variant="body2" color="text.secondary" gutterBottom>
+ Configure how videos are loaded and processed.
+ </Typography>
+
+ <Stack spacing={1} sx={{mt: 1}}>
+ <FormControlLabel
+ control={<Checkbox defaultChecked/>}
+ label="Automatically synchronize videos"
+ />
+ <FormControlLabel
+ control={<Checkbox/>}
+ label="Extract frames on load"
+ />
+ <FormControlLabel
+ control={<Checkbox/>}
+ label="Generate thumbnails"
+ />
+ </Stack>
+ </Paper>
+ )}
+ </Stack>
+ </Paper>
+ </AccordionDetails>
+ </Accordion>
+ );
+};
diff --git a/freemocap-ui-old/src/components/viewport3d/ImageMesh.tsx b/freemocap-ui-old/src/components/viewport3d/ImageMesh.tsx
new file mode 100644
index 00000000..3442bd69
--- /dev/null
+++ b/freemocap-ui-old/src/components/viewport3d/ImageMesh.tsx
@@ -0,0 +1,77 @@
+import { useEffect, useMemo, useRef } from 'react';
+import { useFrame } from '@react-three/fiber';
+import * as THREE from 'three';
+import { useServer } from '@/services';
+
+interface ImageMeshProps {
+ cameraId: string;
+ position: [number, number, number];
+}
+
+export function ImageMesh({ cameraId, position }: ImageMeshProps) {
+ const { subscribeToFrames } = useServer();
+
+ const currentBitmapRef = useRef<ImageBitmap | null>(null);
+ const textureRef = useRef<THREE.Texture | null>(null);
+ const hasNewFrameRef = useRef<boolean>(false);
+
+ // Base texture — updated each frame with the latest ImageBitmap
+ const texture = useMemo(() => {
+ const tex = new THREE.Texture();
+ tex.minFilter = THREE.LinearFilter;
+ tex.magFilter = THREE.LinearFilter;
+ tex.format = THREE.RGBAFormat;
+ tex.generateMipmaps = false;
+ textureRef.current = tex;
+ return tex;
+ }, []);
+
+ const material = useMemo(() => {
+ return new THREE.MeshBasicMaterial({
+ map: texture,
+ side: THREE.DoubleSide,
+ });
+ }, [texture]);
+
+ // Stream camera frames as ImageBitmaps
+ useEffect(() => {
+ const unsubscribe = subscribeToFrames(cameraId, (bitmap) => {
+ if (currentBitmapRef.current) {
+ currentBitmapRef.current.close();
+ }
+ currentBitmapRef.current = bitmap;
+ hasNewFrameRef.current = true;
+ });
+
+ return () => {
+ unsubscribe();
+ if (currentBitmapRef.current) {
+ currentBitmapRef.current.close();
+ currentBitmapRef.current = null;
+ }
+ };
+ }, [cameraId, subscribeToFrames]);
+
+ // Push the latest bitmap to the GPU texture each frame
+ useFrame(() => {
+ if (hasNewFrameRef.current && currentBitmapRef.current && textureRef.current) {
+ textureRef.current.image = currentBitmapRef.current;
+ textureRef.current.needsUpdate = true;
+ hasNewFrameRef.current = false;
+ }
+ });
+
+ const meshGeometry = useMemo(() => {
+ const height = 2.0;
+ const width = height * (16 / 9);
+ return new THREE.PlaneGeometry(width, height);
+ }, []);
+
+ return (
+ <mesh
+ position={position}
+ geometry={meshGeometry}
+ material={material}
+ />
+ );
+}
diff --git a/freemocap-ui-old/src/components/viewport3d/RigidBodyRenderer.tsx b/freemocap-ui-old/src/components/viewport3d/RigidBodyRenderer.tsx
new file mode 100644
index 00000000..4623d64f
--- /dev/null
+++ b/freemocap-ui-old/src/components/viewport3d/RigidBodyRenderer.tsx
@@ -0,0 +1,171 @@
+import { useEffect, useMemo, useRef } from "react";
+import {
+ InstancedMesh,
+ MeshStandardMaterial,
+ CylinderGeometry,
+ Object3D,
+ Vector3,
+} from "three";
+import { useFrame } from "@react-three/fiber";
+import { useServer } from "@/services";
+import { RigidBodyPose } from "@/components/viewport3d/viewport3d-types";
+import { Z_OFFSET } from "@/components/viewport3d/skeleton-config";
+import { SKELETON_COLORS } from "@/components/viewport3d/skeleton-colors";
+
+/** Maximum bone segments the instanced mesh can hold. */
+const MAX_RIGID_BODIES = 64;
+
+/** Cylinder cross-section radius in meters. */
+const BODY_RADIUS = 0.025;
+const HAND_RADIUS = 0.008;
+
+const DUMMY = new Object3D();
+const FAR_AWAY = new Vector3(10000, 10000, 10000);
+
+function getRigidBodyColor(boneKey: string): Color {
+ if (boneKey.includes("left_hand")) return SKELETON_COLORS.leftHand;
+ if (boneKey.includes("right_hand")) return SKELETON_COLORS.rightHand;
+ if (boneKey.includes("left")) return SKELETON_COLORS.left;
+ if (boneKey.includes("right")) return SKELETON_COLORS.right;
+ return SKELETON_COLORS.center;
+}
+
+function getRigidBodyRadius(boneKey: string): number {
+ if (boneKey.includes("hand")) return HAND_RADIUS;
+ return BODY_RADIUS;
+}
+
+/**
+ * Renders rigid body bone segments as instanced cylinders.
+ *
+ * Subscribes directly to the server's rigid-body stream and updates
+ * only dirty instances each frame to minimize GPU uploads. Follows the
+ * same mutable-ref + useFrame pattern as SkeletonRenderer.
+ */
+export function RigidBodyRenderer() {
+ const { subscribeToRigidBodies } = useServer();
+ const instancedMeshRef = useRef<InstancedMesh>(null);
+
+ // Mutable refs for frame-loop access without React re-renders
+ const rigidBodiesRef = useRef<Map<string, RigidBodyPose>>(new Map());
+ const boneKeyToIndexRef = useRef<Map<string, number>>(new Map());
+ const indexToBoneKeyRef = useRef<Map<number, string>>(new Map());
+ const nextIndexRef = useRef<number>(0);
+ const dirtyRef = useRef<boolean>(false);
+
+ // Unit cylinder centered at origin along +Y, then:
+ // - rotated so axis is +Z
+ // - translated so bottom face is at origin (extends 0 → +1 along Z)
+ // This way scale.z = bone length places the cylinder from parent → child.
+ const cylinderGeometry = useMemo(() => {
+ const geo = new CylinderGeometry(1, 1, 1, 8, 1);
+ geo.rotateX(Math.PI / 2); // +Y axis → +Z axis
+ geo.translate(0, 0, 0.5); // origin at bottom face (parent joint)
+ return geo;
+ }, []);
+
+ // Semi-transparent material — per-instance color tints it
+ const cylinderMaterial = useMemo(() => new MeshStandardMaterial({
+ color: '#ffffff',
+ roughness: 0.45,
+ metalness: 0.3,
+ transparent: true,
+ opacity: 0.6,
+ }), []);
+
+ // Assign stable instance index for a bone key
+ const assignIndex = (boneKey: string): number => {
+ if (nextIndexRef.current >= MAX_RIGID_BODIES) {
+ throw new Error(`Maximum rigid bodies (${MAX_RIGID_BODIES}) exceeded for bone "${boneKey}"`);
+ }
+ const index = nextIndexRef.current++;
+ boneKeyToIndexRef.current.set(boneKey, index);
+ indexToBoneKeyRef.current.set(index, boneKey);
+ return index;
+ };
+
+ // Subscribe to rigid body stream
+ useEffect(() => {
+ const unsubscribe = subscribeToRigidBodies((newPoses: Map<string, RigidBodyPose>) => {
+ rigidBodiesRef.current = newPoses;
+ dirtyRef.current = true;
+
+ // Assign indices for any new bones
+ for (const boneKey of newPoses.keys()) {
+ if (!boneKeyToIndexRef.current.has(boneKey)) {
+ assignIndex(boneKey);
+ }
+ }
+ });
+
+ return unsubscribe;
+ }, [subscribeToRigidBodies]);
+
+ // Initialize all instances as hidden
+ useEffect(() => {
+ if (!instancedMeshRef.current) return;
+ const mesh = instancedMeshRef.current;
+
+ for (let i = 0; i < MAX_RIGID_BODIES; i++) {
+ DUMMY.position.copy(FAR_AWAY);
+ DUMMY.scale.set(0, 0, 0);
+ DUMMY.updateMatrix();
+ mesh.setMatrixAt(i, DUMMY.matrix);
+ mesh.setColorAt(i, SKELETON_COLORS.hidden);
+ }
+ mesh.instanceMatrix.needsUpdate = true;
+ if (mesh.instanceColor) mesh.instanceColor.needsUpdate = true;
+ mesh.count = MAX_RIGID_BODIES;
+ }, []);
+
+ // Per-frame update: apply transforms for all assigned bones
+ useFrame(() => {
+ if (!instancedMeshRef.current || !dirtyRef.current) return;
+ const mesh = instancedMeshRef.current;
+ const poses = rigidBodiesRef.current;
+
+ for (let i = 0; i < nextIndexRef.current; i++) {
+ const boneKey = indexToBoneKeyRef.current.get(i);
+ if (!boneKey) continue;
+
+ const pose = poses.get(boneKey);
+ if (pose) {
+ const [px, py, pz] = pose.position;
+ const [qw, qx, qy, qz] = pose.orientation;
+ const radius = getRigidBodyRadius(boneKey);
+
+ DUMMY.position.set(px, py, pz + Z_OFFSET);
+
+ // Bone quaternion (local +Z = bone direction).
+ // Three.js Quaternion constructor: (x, y, z, w).
+ // The geometry is already pre-rotated so its axis is +Z,
+ // so we apply the bone quaternion directly.
+ DUMMY.quaternion.set(qx, qy, qz, qw);
+
+ // Scale: x/y = radius, z = bone length
+ DUMMY.scale.set(radius, radius, pose.length);
+
+ mesh.setColorAt(i, getRigidBodyColor(boneKey));
+ } else {
+ DUMMY.position.copy(FAR_AWAY);
+ DUMMY.scale.set(0, 0, 0);
+ mesh.setColorAt(i, SKELETON_COLORS.hidden);
+ }
+
+ DUMMY.updateMatrix();
+ mesh.setMatrixAt(i, DUMMY.matrix);
+ }
+
+ mesh.instanceMatrix.needsUpdate = true;
+ if (mesh.instanceColor) mesh.instanceColor.needsUpdate = true;
+ dirtyRef.current = false;
+ });
+
+ return (
+ <instancedMesh
+ ref={instancedMeshRef}
+ args={[cylinderGeometry, cylinderMaterial, MAX_RIGID_BODIES]}
+ frustumCulled={false}
+ />
+ );
+}
diff --git a/freemocap-ui-old/src/components/viewport3d/SceneEnvironment.tsx b/freemocap-ui-old/src/components/viewport3d/SceneEnvironment.tsx
new file mode 100644
index 00000000..7a234179
--- /dev/null
+++ b/freemocap-ui-old/src/components/viewport3d/SceneEnvironment.tsx
@@ -0,0 +1,36 @@
+import { Grid } from "@react-three/drei";
+
+/** Static scene environment: lighting, ground grid, and axes indicator. */
+export function SceneEnvironment() {
+ return (
+ <>
+ <ambientLight intensity={0.6} />
+ <directionalLight
+ castShadow
+ position={[5, 5, 5]}
+ intensity={0.5}
+ shadow-mapSize={1024}
+ />
+ {/* Fill light from below to prevent pure-black undersides */}
+ <directionalLight
+ position={[-3, -2, -3]}
+ intensity={0.15}
+ />
+
+ <Grid
+ renderOrder={-1}
+ position={[0, -0.01, 0]}
+ infiniteGrid
+ cellSize={1}
+ cellThickness={0.5}
+ sectionSize={3}
+ sectionThickness={1}
+ //@ts-ignore — drei Grid typing doesn't expose sectionColor as tuple
+ sectionColor={[0.25, 0, 0.25]}
+ fadeDistance={100}
+ />
+
+ <axesHelper />
+ </>
+ );
+}
diff --git a/freemocap-ui-old/src/components/viewport3d/SkeletonRenderer.tsx b/freemocap-ui-old/src/components/viewport3d/SkeletonRenderer.tsx
new file mode 100644
index 00000000..f5b0f899
--- /dev/null
+++ b/freemocap-ui-old/src/components/viewport3d/SkeletonRenderer.tsx
@@ -0,0 +1,250 @@
+import { useEffect, useMemo, useRef } from "react";
+import {
+ InstancedMesh,
+ MeshStandardMaterial,
+ SphereGeometry,
+ Object3D,
+ Vector3,
+ BufferGeometry,
+ BufferAttribute,
+ LineBasicMaterial,
+ LineSegments,
+} from "three";
+import { useFrame } from "@react-three/fiber";
+import { useServer } from "@/services";
+import { Point3d, PointStyle } from "@/components/viewport3d/viewport3d-types";
+import {
+ MAX_POINTS,
+ MAX_SEGMENTS,
+ Z_OFFSET,
+ SEGMENT_DEFINITIONS,
+ SEGMENT_COLORS,
+ getPointStyle,
+} from "@/components/viewport3d/skeleton-config";
+import { resolvePoint } from "@/components/viewport3d/virtual-points";
+import {SKELETON_COLORS} from "@/components/viewport3d/skeleton-colors";
+
+const DUMMY = new Object3D();
+const FAR_AWAY = new Vector3(10000, 10000, 10000);
+
+/**
+ * Renders the 3D skeleton using an InstancedMesh for landmark points
+ * and LineSegments for bone connections. Subscribes directly to the
+ * server's tracked-points stream and updates only dirty instances
+ * each frame to minimize GPU uploads.
+ */
+export function SkeletonRenderer() {
+ const { subscribeToTrackedPoints } = useServer();
+ const instancedMeshRef = useRef<InstancedMesh>(null);
+ const lineSegmentsRef = useRef<LineSegments>(null);
+
+ // Mutable refs for frame-loop access without triggering React re-renders
+ const trackedPointsRef = useRef<Map<string, Point3d>>(new Map());
+ const pointNameToIndexRef = useRef<Map<string, number>>(new Map());
+ const indexToPointNameRef = useRef<Map<number, string>>(new Map());
+ const cachedStylesRef = useRef<Map<string, PointStyle>>(new Map());
+ const nextAvailableIndexRef = useRef<number>(0);
+ const dirtyIndicesRef = useRef<Set<number>>(new Set());
+ const needsLineUpdateRef = useRef<boolean>(false);
+
+ // Shared geometry: unit sphere scaled per-instance
+ const sphereGeometry = useMemo(() => new SphereGeometry(1, 10, 8), []);
+
+ // White base material — per-instance color tints it
+ const sphereMaterial = useMemo(() => new MeshStandardMaterial({
+ color: '#ffffff',
+ roughness: 0.35,
+ metalness: 0.5,
+ }), []);
+
+ // Vertex-colored line material for skeleton segments
+ const lineMaterial = useMemo(() => new LineBasicMaterial({
+ vertexColors: true,
+ transparent: true,
+ opacity: 0.85,
+ }), []);
+
+ // Pre-allocated line geometry with position + color buffers
+ const lineGeometry = useMemo(() => {
+ const geometry = new BufferGeometry();
+ const numVerts = MAX_SEGMENTS * 2;
+ const positions = new Float32Array(numVerts * 3);
+ const colors = new Float32Array(numVerts * 3);
+
+ for (let i = 0; i < MAX_SEGMENTS; i++) {
+ const segColor = SEGMENT_COLORS[i];
+ for (let v = 0; v < 2; v++) {
+ const vi = (i * 2 + v) * 3;
+ positions[vi] = 10000;
+ positions[vi + 1] = 10000;
+ positions[vi + 2] = 10000;
+ colors[vi] = segColor.r;
+ colors[vi + 1] = segColor.g;
+ colors[vi + 2] = segColor.b;
+ }
+ }
+
+ geometry.setAttribute('position', new BufferAttribute(positions, 3));
+ geometry.setAttribute('color', new BufferAttribute(colors, 3));
+ return geometry;
+ }, []);
+
+ // Assign a stable instance index and cache the point style for a new point name
+ const assignIndex = (pointName: string): number => {
+ if (nextAvailableIndexRef.current >= MAX_POINTS) {
+ throw new Error(`Maximum tracked points (${MAX_POINTS}) exceeded for point "${pointName}"`);
+ }
+ const index = nextAvailableIndexRef.current++;
+ pointNameToIndexRef.current.set(pointName, index);
+ indexToPointNameRef.current.set(index, pointName);
+ cachedStylesRef.current.set(pointName, getPointStyle(pointName));
+ return index;
+ };
+
+ // Subscribe to tracked-points stream, mark dirty indices for changed/new/removed points
+ useEffect(() => {
+ const unsubscribe = subscribeToTrackedPoints((newPoints: Map<string, Point3d>) => {
+ const prevPoints = trackedPointsRef.current;
+ trackedPointsRef.current = newPoints;
+ needsLineUpdateRef.current = true;
+
+ for (const [pointName, point] of newPoints) {
+ if (!pointNameToIndexRef.current.has(pointName)) {
+ const newIndex = assignIndex(pointName);
+ dirtyIndicesRef.current.add(newIndex);
+ } else {
+ const prevPoint = prevPoints.get(pointName);
+ if (!prevPoint ||
+ prevPoint.x !== point.x ||
+ prevPoint.y !== point.y ||
+ prevPoint.z !== point.z) {
+ dirtyIndicesRef.current.add(pointNameToIndexRef.current.get(pointName)!);
+ }
+ }
+ }
+
+ // Mark removed points as dirty so they get hidden
+ for (const [pointName] of prevPoints) {
+ if (!newPoints.has(pointName)) {
+ const index = pointNameToIndexRef.current.get(pointName);
+ if (index !== undefined) {
+ dirtyIndicesRef.current.add(index);
+ }
+ }
+ }
+ });
+
+ return unsubscribe;
+ }, [subscribeToTrackedPoints]);
+
+ // Initialize all instances as hidden on mount
+ useEffect(() => {
+ if (!instancedMeshRef.current) return;
+ const mesh = instancedMeshRef.current;
+
+ for (let i = 0; i < MAX_POINTS; i++) {
+ DUMMY.position.copy(FAR_AWAY);
+ DUMMY.scale.set(0, 0, 0);
+ DUMMY.updateMatrix();
+ mesh.setMatrixAt(i, DUMMY.matrix);
+ mesh.setColorAt(i, SKELETON_COLORS.hidden);
+ }
+ mesh.instanceMatrix.needsUpdate = true;
+ if (mesh.instanceColor) mesh.instanceColor.needsUpdate = true;
+ mesh.count = MAX_POINTS;
+ }, []);
+
+ // Per-frame update: apply dirty point transforms and refresh line segment positions
+ useFrame(() => {
+ // Update dirty point instances
+ if (instancedMeshRef.current && dirtyIndicesRef.current.size > 0) {
+ const mesh = instancedMeshRef.current;
+ const points = trackedPointsRef.current;
+
+ for (const index of dirtyIndicesRef.current) {
+ const pointName = indexToPointNameRef.current.get(index);
+
+ if (pointName && points.has(pointName)) {
+ const point = points.get(pointName)!;
+ const style = cachedStylesRef.current.get(pointName)!;
+
+ DUMMY.position.set(point.x, point.y, point.z + Z_OFFSET);
+ DUMMY.scale.set(style.scale, style.scale, style.scale);
+ mesh.setColorAt(index, style.color);
+ } else {
+ DUMMY.position.copy(FAR_AWAY);
+ DUMMY.scale.set(0, 0, 0);
+ mesh.setColorAt(index, SKELETON_COLORS.hidden);
+ }
+
+ DUMMY.updateMatrix();
+ mesh.setMatrixAt(index, DUMMY.matrix);
+ }
+
+ mesh.instanceMatrix.needsUpdate = true;
+ if (mesh.instanceColor) mesh.instanceColor.needsUpdate = true;
+ dirtyIndicesRef.current.clear();
+ }
+
+ // Update line segment vertex positions
+ if (lineSegmentsRef.current && needsLineUpdateRef.current) {
+ const points = trackedPointsRef.current;
+ const positions = lineGeometry.attributes.position.array as Float32Array;
+ const colors = lineGeometry.attributes.color.array as Float32Array;
+ let segmentIndex = 0;
+
+ for (const segment of Object.values(SEGMENT_DEFINITIONS)) {
+ const proximal = resolvePoint(points, segment.proximal);
+ const distal = resolvePoint(points, segment.distal);
+ const segColor = SEGMENT_COLORS[segmentIndex];
+ const baseIdx = segmentIndex * 6;
+
+ if (proximal && distal) {
+ positions[baseIdx] = proximal.x;
+ positions[baseIdx + 1] = proximal.y;
+ positions[baseIdx + 2] = proximal.z + Z_OFFSET;
+
+ positions[baseIdx + 3] = distal.x;
+ positions[baseIdx + 4] = distal.y;
+ positions[baseIdx + 5] = distal.z + Z_OFFSET;
+
+ colors[baseIdx] = segColor.r;
+ colors[baseIdx + 1] = segColor.g;
+ colors[baseIdx + 2] = segColor.b;
+ colors[baseIdx + 3] = segColor.r;
+ colors[baseIdx + 4] = segColor.g;
+ colors[baseIdx + 5] = segColor.b;
+ } else {
+ for (let i = 0; i < 6; i++) {
+ positions[baseIdx + i] = 10000;
+ }
+ }
+
+ segmentIndex++;
+ }
+
+ lineGeometry.attributes.position.needsUpdate = true;
+ lineGeometry.attributes.color.needsUpdate = true;
+ needsLineUpdateRef.current = false;
+ }
+ });
+
+ return (
+ <>
+ {/* Per-instance colored landmark points */}
+ <instancedMesh
+ ref={instancedMeshRef}
+ args={[sphereGeometry, sphereMaterial, MAX_POINTS]}
+ frustumCulled={false}
+ />
+
+ {/* Vertex-colored skeleton segments */}
+ <lineSegments
+ ref={lineSegmentsRef}
+ geometry={lineGeometry}
+ material={lineMaterial}
+ frustumCulled={false}
+ />
+ </>
+ );
+}
diff --git a/freemocap-ui-old/src/components/viewport3d/ThreeJsCanvas.tsx b/freemocap-ui-old/src/components/viewport3d/ThreeJsCanvas.tsx
new file mode 100644
index 00000000..90f5ebae
--- /dev/null
+++ b/freemocap-ui-old/src/components/viewport3d/ThreeJsCanvas.tsx
@@ -0,0 +1,71 @@
+import { useCallback, useEffect, useRef } from "react";
+import { Canvas } from "@react-three/fiber";
+import { Box, IconButton, Tooltip } from "@mui/material";
+import CenterFocusStrongIcon from "@mui/icons-material/CenterFocusStrong";
+import type CameraControlsImpl from "camera-controls";
+import { ThreeJsScene } from "@/components/viewport3d/ThreeJsScene";
+import { fitCameraToSkeleton } from "@/components/viewport3d/fit-camera";
+import { useServer } from "@/services";
+
+export function ThreeJsCanvas() {
+ const cameraControlsRef = useRef<CameraControlsImpl>(null!);
+ const containerRef = useRef<HTMLDivElement>(null);
+ const { getLatestTrackedPoints } = useServer();
+
+ const handleFitToSkeleton = useCallback(() => {
+ fitCameraToSkeleton(cameraControlsRef.current, getLatestTrackedPoints());
+ }, [getLatestTrackedPoints]);
+
+ // Press "F" while the viewport container is focused to fit camera to skeleton
+ useEffect(() => {
+ const container = containerRef.current;
+ if (!container) return;
+
+ const handleKeyDown = (e: KeyboardEvent) => {
+ if (e.key === "f" || e.key === "F") {
+ e.preventDefault();
+ handleFitToSkeleton();
+ }
+ };
+
+ container.addEventListener("keydown", handleKeyDown);
+ return () => container.removeEventListener("keydown", handleKeyDown);
+ }, [handleFitToSkeleton]);
+
+ return (
+ <Box
+ ref={containerRef}
+ tabIndex={0}
+ sx={{
+ width: '100%',
+ height: '100%',
+ position: 'relative',
+ outline: 'none',
+ }}
+ >
+ <Canvas
+ shadows
+ camera={{ position: [5, 5, 5], fov: 75 }}
+ >
+ <ThreeJsScene cameraControlsRef={cameraControlsRef} />
+ </Canvas>
+
+ <Tooltip title="Fit camera to skeleton (F)" placement="left">
+ <IconButton
+ onClick={handleFitToSkeleton}
+ size="small"
+ sx={{
+ position: 'absolute',
+ bottom: 16,
+ right: 16,
+ bgcolor: 'background.paper',
+ boxShadow: 2,
+ '&:hover': { bgcolor: 'action.hover' },
+ }}
+ >
+ <CenterFocusStrongIcon fontSize="small" />
+ </IconButton>
+ </Tooltip>
+ </Box>
+ );
+}
\ No newline at end of file
diff --git a/freemocap-ui-old/src/components/viewport3d/ThreeJsScene.tsx b/freemocap-ui-old/src/components/viewport3d/ThreeJsScene.tsx
new file mode 100644
index 00000000..3f9f79d6
--- /dev/null
+++ b/freemocap-ui-old/src/components/viewport3d/ThreeJsScene.tsx
@@ -0,0 +1,22 @@
+import { RefObject } from "react";
+import { CameraControls } from "@react-three/drei";
+import type CameraControlsImpl from "camera-controls";
+import { SceneEnvironment } from "@/components/viewport3d/SceneEnvironment";
+import { SkeletonRenderer } from "@/components/viewport3d/SkeletonRenderer";
+import { RigidBodyRenderer } from "@/components/viewport3d/RigidBodyRenderer";
+
+interface ThreeJsSceneProps {
+ cameraControlsRef: RefObject<CameraControlsImpl>;
+}
+
+/** Top-level scene graph: camera controls, environment, and skeleton visualization. */
+export function ThreeJsScene({ cameraControlsRef }: ThreeJsSceneProps) {
+ return (
+ <>
+ <CameraControls ref={cameraControlsRef} makeDefault />
+ <SceneEnvironment />
+ <SkeletonRenderer />
+ <RigidBodyRenderer />
+ </>
+ );
+}
diff --git a/freemocap-ui-old/src/components/viewport3d/VMCPanel.tsx b/freemocap-ui-old/src/components/viewport3d/VMCPanel.tsx
new file mode 100644
index 00000000..7c1c07fb
--- /dev/null
+++ b/freemocap-ui-old/src/components/viewport3d/VMCPanel.tsx
@@ -0,0 +1,129 @@
+import React, { useCallback } from "react";
+import {
+ Box,
+ IconButton,
+ Stack,
+ Switch,
+ TextField,
+ Tooltip,
+ Typography,
+ useTheme,
+} from "@mui/material";
+import CastConnectedIcon from "@mui/icons-material/CastConnected";
+import { useAppSelector } from "@/store/hooks";
+import { selectServerSettings } from "@/store/slices/settings/settings-selectors";
+import { useServer } from "@/services";
+
+/**
+ * Compact VMC output controls. Shows a toggle to enable/disable VMC
+ * broadcasting and a port field. Patches are sent directly via the
+ * WebSocket settings/patch protocol.
+ */
+export const VMCPanel: React.FC = () => {
+ const theme = useTheme();
+ const { send, isConnected } = useServer();
+ const settings = useAppSelector(selectServerSettings);
+
+ const vmcEnabled = settings?.vmc?.enabled ?? false;
+ const vmcHost = settings?.vmc?.host ?? "127.0.0.1";
+ const vmcPort = settings?.vmc?.port ?? 39539;
+
+ const patchVMC = useCallback(
+ (patch: Record<string, unknown>) => {
+ send({ message_type: "settings/patch", patch: { vmc: patch } });
+ },
+ [send],
+ );
+
+ const handleToggle = useCallback(() => {
+ patchVMC({ enabled: !vmcEnabled });
+ }, [patchVMC, vmcEnabled]);
+
+ const handlePortChange = useCallback(
+ (e: React.ChangeEvent<HTMLInputElement>) => {
+ const val = parseInt(e.target.value, 10);
+ if (!isNaN(val) && val > 0 && val <= 65535) {
+ patchVMC({ port: val });
+ }
+ },
+ [patchVMC],
+ );
+
+ const handleHostChange = useCallback(
+ (e: React.ChangeEvent<HTMLInputElement>) => {
+ const val = e.target.value.trim();
+ if (val.length > 0) {
+ patchVMC({ host: val });
+ }
+ },
+ [patchVMC],
+ );
+
+ return (
+ <Box
+ sx={{
+ position: "absolute",
+ bottom: 16,
+ right: 16,
+ zIndex: 10,
+ backgroundColor: theme.palette.background.paper,
+ borderRadius: 2,
+ px: 2,
+ py: 1.5,
+ boxShadow: 3,
+ minWidth: 220,
+ opacity: 0.92,
+ }}
+ >
+ <Stack spacing={1}>
+ <Stack direction="row" alignItems="center" spacing={1}>
+ <CastConnectedIcon
+ fontSize="small"
+ sx={{ color: vmcEnabled ? theme.palette.success.main : theme.palette.text.disabled }}
+ />
+ <Typography variant="subtitle2" sx={{ flexGrow: 1, fontWeight: 600 }}>
+ VMC Output
+ </Typography>
+ <Tooltip title={vmcEnabled ? "Disable VMC streaming" : "Enable VMC streaming"} arrow>
+ <Switch
+ size="small"
+ checked={vmcEnabled}
+ onChange={handleToggle}
+ disabled={!isConnected}
+ />
+ </Tooltip>
+ </Stack>
+
+ {vmcEnabled && (
+ <Stack direction="row" spacing={1}>
+ <Tooltip title="Target host (IP address)" arrow placement="bottom">
+ <TextField
+ label="Host"
+ size="small"
+ value={vmcHost}
+ onChange={handleHostChange}
+ disabled={!isConnected}
+ sx={{ flex: 2 }}
+ inputProps={{ style: { fontSize: 12 } }}
+ InputLabelProps={{ style: { fontSize: 12 } }}
+ />
+ </Tooltip>
+ <Tooltip title="UDP port (default 39539)" arrow placement="bottom">
+ <TextField
+ label="Port"
+ size="small"
+ type="number"
+ value={vmcPort}
+ onChange={handlePortChange}
+ disabled={!isConnected}
+ sx={{ flex: 1 }}
+ inputProps={{ min: 1, max: 65535, style: { fontSize: 12 } }}
+ InputLabelProps={{ style: { fontSize: 12 } }}
+ />
+ </Tooltip>
+ </Stack>
+ )}
+ </Stack>
+ </Box>
+ );
+};
diff --git a/freemocap-ui-old/src/components/viewport3d/Viewport3dPage.tsx b/freemocap-ui-old/src/components/viewport3d/Viewport3dPage.tsx
new file mode 100644
index 00000000..b5964d1e
--- /dev/null
+++ b/freemocap-ui-old/src/components/viewport3d/Viewport3dPage.tsx
@@ -0,0 +1,13 @@
+import {Box} from "@mui/material";
+import React from "react";
+import {ThreeJsCanvas} from "@/components/viewport3d/ThreeJsCanvas";
+import {VMCPanel} from "@/components/viewport3d/VMCPanel";
+
+export const Viewport3dPage = () => {
+ return (
+ <Box sx={{width: '100%', height: '100%', position: 'relative'}}>
+ <ThreeJsCanvas/>
+ <VMCPanel/>
+ </Box>
+ );
+}
diff --git a/freemocap-ui-old/src/components/viewport3d/face-contours.ts b/freemocap-ui-old/src/components/viewport3d/face-contours.ts
new file mode 100644
index 00000000..abb43873
--- /dev/null
+++ b/freemocap-ui-old/src/components/viewport3d/face-contours.ts
@@ -0,0 +1,139 @@
+import { Color } from "three";
+import {SKELETON_COLORS} from "@/components/viewport3d/skeleton-colors";
+
+/**
+ * MediaPipe face mesh contour connections, matching the Python tracker's
+ * naming convention: `face.{group}_{raw_mediapipe_index}`.
+ *
+ * Connection pairs come from mediapipe.python.solutions.face_mesh_connections:
+ * FACEMESH_LIPS, FACEMESH_LEFT_EYE, FACEMESH_RIGHT_EYE,
+ * FACEMESH_LEFT_EYEBROW, FACEMESH_RIGHT_EYEBROW, FACEMESH_FACE_OVAL,
+ * FACEMESH_LEFT_IRIS, FACEMESH_RIGHT_IRIS
+ */
+
+interface FaceContourGroup {
+ prefix: string;
+ connections: [number, number][];
+ color: Color;
+}
+
+const FACE_CONTOUR_GROUPS: FaceContourGroup[] = [
+ {
+ prefix: "face.lips",
+ color: SKELETON_COLORS.face,
+ connections: [
+ // Outer lip upper
+ [61, 146], [146, 91], [91, 181], [181, 84], [84, 17],
+ [17, 314], [314, 405], [405, 321], [321, 375], [375, 291],
+ // Outer lip lower
+ [61, 185], [185, 40], [40, 39], [39, 37], [37, 0],
+ [0, 267], [267, 269], [269, 270], [270, 409], [409, 291],
+ // Inner lip upper
+ [78, 95], [95, 88], [88, 178], [178, 87], [87, 14],
+ [14, 317], [317, 402], [402, 318], [318, 324], [324, 308],
+ // Inner lip lower
+ [78, 191], [191, 80], [80, 81], [81, 82], [82, 13],
+ [13, 312], [312, 311], [311, 310], [310, 415], [415, 308],
+ ],
+ },
+ {
+ prefix: "face.left_eye",
+ color: SKELETON_COLORS.face,
+ connections: [
+ [263, 249], [249, 390], [390, 373], [373, 374], [374, 380],
+ [380, 381], [381, 382], [382, 362],
+ [263, 466], [466, 388], [388, 387], [387, 386], [386, 385],
+ [385, 384], [384, 398], [398, 362],
+ ],
+ },
+ {
+ prefix: "face.right_eye",
+ color: SKELETON_COLORS.face,
+ connections: [
+ [33, 7], [7, 163], [163, 144], [144, 145], [145, 153],
+ [153, 154], [154, 155], [155, 133],
+ [33, 246], [246, 161], [161, 160], [160, 159], [159, 158],
+ [158, 157], [157, 173], [173, 133],
+ ],
+ },
+ {
+ prefix: "face.left_eyebrow",
+ color: SKELETON_COLORS.face,
+ connections: [
+ [276, 283], [283, 282], [282, 295], [295, 285],
+ [300, 293], [293, 334], [334, 296], [296, 336],
+ ],
+ },
+ {
+ prefix: "face.right_eyebrow",
+ color: SKELETON_COLORS.face,
+ connections: [
+ [46, 53], [53, 52], [52, 65], [65, 55],
+ [70, 63], [63, 105], [105, 66], [66, 107],
+ ],
+ },
+ {
+ prefix: "face.face_oval",
+ color: SKELETON_COLORS.face,
+ connections: [
+ [10, 338], [338, 297], [297, 332], [332, 284], [284, 251],
+ [251, 389], [389, 356], [356, 454], [454, 323], [323, 361],
+ [361, 288], [288, 397], [397, 365], [365, 379], [379, 378],
+ [378, 400], [400, 377], [377, 152], [152, 148], [148, 176],
+ [176, 149], [149, 150], [150, 136], [136, 172], [172, 58],
+ [58, 132], [132, 93], [93, 234], [234, 127], [127, 162],
+ [162, 21], [21, 54], [54, 103], [103, 67], [67, 109],
+ [109, 10],
+ ],
+ },
+ {
+ prefix: "face.left_iris",
+ color: SKELETON_COLORS.face,
+ connections: [
+ [474, 475], [475, 476], [476, 477], [477, 474],
+ ],
+ },
+ {
+ prefix: "face.right_iris",
+ color: SKELETON_COLORS.face,
+ connections: [
+ [469, 470], [470, 471], [471, 472], [472, 469],
+ ],
+ },
+];
+
+/**
+ * Build segment definitions for all face contour groups.
+ * Each connection (a, b) becomes a segment from `{prefix}_{a}` to `{prefix}_{b}`.
+ */
+export function buildFaceContourSegments(): Record<string, { proximal: string; distal: string }> {
+ const segments: Record<string, { proximal: string; distal: string }> = {};
+
+ for (const group of FACE_CONTOUR_GROUPS) {
+ for (let i = 0; i < group.connections.length; i++) {
+ const [a, b] = group.connections[i];
+ segments[`${group.prefix}_seg_${i}`] = {
+ proximal: `${group.prefix}_${a}`,
+ distal: `${group.prefix}_${b}`,
+ };
+ }
+ }
+
+ return segments;
+}
+
+/**
+ * Build the color array for all face contour segments, in the same
+ * order as buildFaceContourSegments produces entries.
+ */
+export function buildFaceContourColors(): Color[] {
+ const colors: Color[] = [];
+
+ for (const group of FACE_CONTOUR_GROUPS) {
+ for (let _i = 0; _i < group.connections.length; _i++) {
+ colors.push(group.color);
+ }
+ }
+
+ return colors;
+}
diff --git a/freemocap-ui-old/src/components/viewport3d/fit-camera.ts b/freemocap-ui-old/src/components/viewport3d/fit-camera.ts
new file mode 100644
index 00000000..8bea125a
--- /dev/null
+++ b/freemocap-ui-old/src/components/viewport3d/fit-camera.ts
@@ -0,0 +1,26 @@
+import { Box3, Vector3 } from "three";
+import type CameraControlsImpl from "camera-controls";
+import { Z_OFFSET } from "@/components/viewport3d/skeleton-config";
+import {Point3d} from "@/services";
+
+const PADDING = 0.5;
+
+/**
+ * Compute a bounding box around all tracked points and smoothly
+ * transition the camera to frame it. No-ops if there are no points
+ * or CameraControls isn't ready.
+ */
+export function fitCameraToSkeleton(
+ controls: CameraControlsImpl | null,
+ points: Map<string, Point3d>,
+): void {
+ if (!controls || points.size === 0) return;
+
+ const box = new Box3();
+ for (const point of points.values()) {
+ box.expandByPoint(new Vector3(point.x, point.y, point.z + Z_OFFSET));
+ }
+ box.expandByScalar(PADDING);
+
+ controls.fitToBox(box, true);
+}
diff --git a/freemocap-ui-old/src/components/viewport3d/skeleton-colors.ts b/freemocap-ui-old/src/components/viewport3d/skeleton-colors.ts
new file mode 100644
index 00000000..06c29589
--- /dev/null
+++ b/freemocap-ui-old/src/components/viewport3d/skeleton-colors.ts
@@ -0,0 +1,11 @@
+import { Color } from "three";
+
+export const SKELETON_COLORS = {
+ left: new Color('#4488FF'),
+ right: new Color('#FF4444'),
+ center: new Color('#00AA00'),
+ leftHand: new Color('#00FFFF'),
+ rightHand: new Color('#FF00FF'),
+ face: new Color('#FFD700'),
+ hidden: new Color('#000000'),
+} as const;
diff --git a/freemocap-ui-old/src/components/viewport3d/skeleton-config.ts b/freemocap-ui-old/src/components/viewport3d/skeleton-config.ts
new file mode 100644
index 00000000..d69fb3f3
--- /dev/null
+++ b/freemocap-ui-old/src/components/viewport3d/skeleton-config.ts
@@ -0,0 +1,168 @@
+import { Color } from "three";
+import { PointStyle } from "@/components/viewport3d/viewport3d-types";
+import { buildFaceContourSegments, buildFaceContourColors } from "@/components/viewport3d/face-contours";
+import {SKELETON_COLORS} from "@/components/viewport3d/skeleton-colors";
+
+// Maximum tracked points the instanced mesh can hold
+export const MAX_POINTS = 1000;
+
+// Z-axis offset applied to all tracked points to center the skeleton in view
+export const Z_OFFSET = -15;
+
+// --- Color palette (matches 2D overlay) ---
+
+
+
+// --- Point styling: color + sphere scale per body part ---
+
+export function getPointStyle(name: string): PointStyle {
+ // Face landmarks — near-invisible dots, contour lines carry the visual
+ if (name.startsWith('face.')) {
+ return { color: SKELETON_COLORS.face, scale: 0.02 };
+ }
+
+ if (name.startsWith('left_hand.')) {
+ return { color: SKELETON_COLORS.leftHand, scale: 0.075 };
+ }
+ if (name.startsWith('right_hand.')) {
+ return { color: SKELETON_COLORS.rightHand, scale: 0.075 };
+ }
+
+ // Body — eyes, ears, mouth are small
+ if (name.includes('eye') || name.includes('ear') || name.includes('mouth')) {
+ const side = name.includes('left') ? SKELETON_COLORS.left
+ : name.includes('right') ? SKELETON_COLORS.right
+ : SKELETON_COLORS.center;
+ return { color: side, scale: 0.125 };
+ }
+
+ // Body — fingers at wrist level
+ if (name.includes('pinky') || name.includes('index') || name.includes('thumb')) {
+ const side = name.includes('left') ? SKELETON_COLORS.left : SKELETON_COLORS.right;
+ return { color: side, scale: 0.05 };
+ }
+
+ // Body — feet
+ if (name.includes('heel') || name.includes('foot_index') || name.includes('ankle')) {
+ const side = name.includes('left') ? SKELETON_COLORS.left : SKELETON_COLORS.right;
+ return { color: side, scale: 0.3 };
+ }
+
+ // Body — major joints (shoulder, elbow, wrist, hip, knee)
+ if (name.includes('left')) {
+ return { color: SKELETON_COLORS.left, scale: 0.2 };
+ }
+ if (name.includes('right')) {
+ return { color: SKELETON_COLORS.right, scale: 0.2 };
+ }
+
+ // Center (nose, etc.)
+ return { color: SKELETON_COLORS.center, scale: 0.15 };
+}
+
+// --- Segment color determined by segment name ---
+
+function getSegmentColor(segmentName: string): Color {
+ if (segmentName.startsWith('left_hand_')) return SKELETON_COLORS.leftHand;
+ if (segmentName.startsWith('right_hand_')) return SKELETON_COLORS.rightHand;
+ if (segmentName.startsWith('left')) return SKELETON_COLORS.left;
+ if (segmentName.startsWith('right')) return SKELETON_COLORS.right;
+ return SKELETON_COLORS.center;
+}
+
+// --- Hand connection template (MediaPipe hand landmark topology) ---
+
+const HAND_CONNECTIONS: [string, string][] = [
+ // Thumb
+ ['wrist', 'thumb_cmc'],
+ ['thumb_cmc', 'thumb_mcp'],
+ ['thumb_mcp', 'thumb_ip'],
+ ['thumb_ip', 'thumb_tip'],
+ // Index finger
+ ['wrist', 'index_finger_mcp'],
+ ['index_finger_mcp', 'index_finger_pip'],
+ ['index_finger_pip', 'index_finger_dip'],
+ ['index_finger_dip', 'index_finger_tip'],
+ // Middle finger
+ ['wrist', 'middle_finger_mcp'],
+ ['middle_finger_mcp', 'middle_finger_pip'],
+ ['middle_finger_pip', 'middle_finger_dip'],
+ ['middle_finger_dip', 'middle_finger_tip'],
+ // Ring finger
+ ['wrist', 'ring_finger_mcp'],
+ ['ring_finger_mcp', 'ring_finger_pip'],
+ ['ring_finger_pip', 'ring_finger_dip'],
+ ['ring_finger_dip', 'ring_finger_tip'],
+ // Pinky
+ ['wrist', 'pinky_mcp'],
+ ['pinky_mcp', 'pinky_pip'],
+ ['pinky_pip', 'pinky_dip'],
+ ['pinky_dip', 'pinky_tip'],
+ // Palm
+ ['index_finger_mcp', 'middle_finger_mcp'],
+ ['middle_finger_mcp', 'ring_finger_mcp'],
+ ['ring_finger_mcp', 'pinky_mcp'],
+];
+
+function buildHandSegments(handPrefix: string): Record<string, { proximal: string; distal: string }> {
+ const segments: Record<string, { proximal: string; distal: string }> = {};
+ HAND_CONNECTIONS.forEach(([proximal, distal], i) => {
+ segments[`${handPrefix}_seg_${i}`] = {
+ proximal: `${handPrefix}.${proximal}`,
+ distal: `${handPrefix}.${distal}`,
+ };
+ });
+ return segments;
+}
+
+// --- Body + hand segment definitions ---
+
+const BODY_HAND_SEGMENTS: Record<string, { proximal: string; distal: string }> = {
+ // Body
+ head: { proximal: "body.left_ear", distal: "body.right_ear" },
+ neck: { proximal: "head_center", distal: "neck_center" },
+ spine: { proximal: "neck_center", distal: "hips_center" },
+ right_shoulder: { proximal: "neck_center", distal: "body.right_shoulder" },
+ left_shoulder: { proximal: "neck_center", distal: "body.left_shoulder" },
+ right_upper_arm: { proximal: "body.right_shoulder", distal: "body.right_elbow" },
+ left_upper_arm: { proximal: "body.left_shoulder", distal: "body.left_elbow" },
+ right_forearm: { proximal: "body.right_elbow", distal: "body.right_wrist" },
+ left_forearm: { proximal: "body.left_elbow", distal: "body.left_wrist" },
+ right_hand_body: { proximal: "body.right_wrist", distal: "body.right_index" },
+ left_hand_body: { proximal: "body.left_wrist", distal: "body.left_index" },
+ right_pelvis: { proximal: "hips_center", distal: "body.right_hip" },
+ left_pelvis: { proximal: "hips_center", distal: "body.left_hip" },
+ right_thigh: { proximal: "body.right_hip", distal: "body.right_knee" },
+ left_thigh: { proximal: "body.left_hip", distal: "body.left_knee" },
+ right_shank: { proximal: "body.right_knee", distal: "body.right_ankle" },
+ left_shank: { proximal: "body.left_knee", distal: "body.left_ankle" },
+ right_foot: { proximal: "body.right_ankle", distal: "body.right_foot_index" },
+ left_foot: { proximal: "body.left_ankle", distal: "body.left_foot_index" },
+ right_heel: { proximal: "body.right_ankle", distal: "body.right_heel" },
+ left_heel: { proximal: "body.left_ankle", distal: "body.left_heel" },
+ right_foot_bottom: { proximal: "body.right_heel", distal: "body.right_foot_index" },
+ left_foot_bottom: { proximal: "body.left_heel", distal: "body.left_foot_index" },
+ // Hands
+ ...buildHandSegments('right_hand'),
+ ...buildHandSegments('left_hand'),
+};
+
+// Pre-compute body+hand segment colors
+const BODY_HAND_COLORS: Color[] = Object.keys(BODY_HAND_SEGMENTS).map(getSegmentColor);
+
+// --- Face contour segments ---
+
+const FACE_SEGMENTS = buildFaceContourSegments();
+const FACE_COLORS = buildFaceContourColors();
+
+// --- Combined: body + hands + face contours ---
+
+export const SEGMENT_DEFINITIONS: Record<string, { proximal: string; distal: string }> = {
+ ...BODY_HAND_SEGMENTS,
+ ...FACE_SEGMENTS,
+};
+
+export const MAX_SEGMENTS = Object.keys(SEGMENT_DEFINITIONS).length;
+
+// Colors in matching order: body+hand first, then face contours
+export const SEGMENT_COLORS: Color[] = [...BODY_HAND_COLORS, ...FACE_COLORS];
\ No newline at end of file
diff --git a/freemocap-ui-old/src/components/viewport3d/viewport3d-types.ts b/freemocap-ui-old/src/components/viewport3d/viewport3d-types.ts
new file mode 100644
index 00000000..7474ed3a
--- /dev/null
+++ b/freemocap-ui-old/src/components/viewport3d/viewport3d-types.ts
@@ -0,0 +1,16 @@
+import { Color } from "three";
+
+export type { Point3d } from "@/services/server/ServerContextProvider";
+
+export interface PointStyle {
+ color: Color;
+ scale: number;
+}
+
+/** Rigid body pose for a single bone segment, received from Python backend. */
+export interface RigidBodyPose {
+ bone_key: string;
+ position: [number, number, number]; // (x, y, z) origin at parent joint
+ orientation: [number, number, number, number]; // (w, x, y, z) quaternion
+ length: number; // meters
+}
diff --git a/freemocap-ui-old/src/components/viewport3d/virtual-points.ts b/freemocap-ui-old/src/components/viewport3d/virtual-points.ts
new file mode 100644
index 00000000..424cfb40
--- /dev/null
+++ b/freemocap-ui-old/src/components/viewport3d/virtual-points.ts
@@ -0,0 +1,31 @@
+import { Point3d } from "@/components/viewport3d/viewport3d-types";
+
+/**
+ * Resolve a point name to a 3D position. Handles both raw landmark names
+ * (looked up directly in the points map) and virtual midpoint names
+ * (head_center, neck_center, hips_center) computed from paired landmarks.
+ */
+export function resolvePoint(points: Map<string, Point3d>, name: string): Point3d | null {
+ switch (name) {
+ case "head_center": {
+ const l = points.get("body.left_ear");
+ const r = points.get("body.right_ear");
+ if (!l || !r) return null;
+ return { x: (l.x + r.x) / 2, y: (l.y + r.y) / 2, z: (l.z + r.z) / 2 };
+ }
+ case "neck_center": {
+ const l = points.get("body.left_shoulder");
+ const r = points.get("body.right_shoulder");
+ if (!l || !r) return null;
+ return { x: (l.x + r.x) / 2, y: (l.y + r.y) / 2, z: (l.z + r.z) / 2 };
+ }
+ case "hips_center": {
+ const l = points.get("body.left_hip");
+ const r = points.get("body.right_hip");
+ if (!l || !r) return null;
+ return { x: (l.x + r.x) / 2, y: (l.y + r.y) / 2, z: (l.z + r.z) / 2 };
+ }
+ default:
+ return points.get(name) ?? null;
+ }
+}
diff --git a/freemocap-ui-old/src/demos/ipc.ts b/freemocap-ui-old/src/demos/ipc.ts
new file mode 100644
index 00000000..808658c3
--- /dev/null
+++ b/freemocap-ui-old/src/demos/ipc.ts
@@ -0,0 +1,3 @@
+window.ipcRenderer.on('main-process-message', (_event, ...args) => {
+ console.log('[Receive Main-process message]:', ...args)
+})
diff --git a/freemocap-ui-old/src/demos/node.ts b/freemocap-ui-old/src/demos/node.ts
new file mode 100644
index 00000000..4ed5fb9f
--- /dev/null
+++ b/freemocap-ui-old/src/demos/node.ts
@@ -0,0 +1,8 @@
+import {lstat} from 'node:fs/promises'
+import {cwd} from 'node:process'
+
+lstat(cwd()).then(stats => {
+ console.log('[fs.lstat]', stats)
+}).catch(err => {
+ console.error(err)
+})
diff --git a/freemocap-ui-old/src/hooks/server-urls.ts b/freemocap-ui-old/src/hooks/server-urls.ts
new file mode 100644
index 00000000..183aefbd
--- /dev/null
+++ b/freemocap-ui-old/src/hooks/server-urls.ts
@@ -0,0 +1,91 @@
+const DEFAULT_HOST = 'localhost';
+const DEFAULT_PORT = 53117;
+
+type PortChangeCallback = (port: number) => void;
+
+class ServerUrls {
+ private readonly host = DEFAULT_HOST;
+ private port = DEFAULT_PORT;
+ private portChangeListeners = new Set<PortChangeCallback>();
+
+ /**
+ * Update the port at runtime. Notifies all subscribers so components
+ * can recreate connections with the correct URL.
+ */
+ setPort(port: number): void {
+ if (port === this.port) return;
+ console.log(`[ServerUrls] Port updated: ${this.port} → ${port}`);
+ this.port = port;
+ for (const listener of this.portChangeListeners) {
+ listener(port);
+ }
+ }
+
+ getPort(): number {
+ return this.port;
+ }
+
+ /**
+ * Subscribe to port changes. Returns an unsubscribe function.
+ */
+ onPortChange(callback: PortChangeCallback): () => void {
+ this.portChangeListeners.add(callback);
+ return () => {
+ this.portChangeListeners.delete(callback);
+ };
+ }
+
+ getHttpUrl(): string {
+ return `http://${this.host}:${this.port}`;
+ }
+
+ getWebSocketUrl(): string {
+ return `ws://${this.host}:${this.port}/websocket/connect`;
+ }
+
+ get endpoints() {
+ const baseUrl = this.getHttpUrl();
+
+ return {
+ // Server management
+ health: `${baseUrl}/health`,
+ shutdown: `${baseUrl}/shutdown`,
+ settings: `${baseUrl}/settings`,
+
+ // Camera endpoints
+ detectCameras: `${baseUrl}/skellycam/camera/detect`,
+ camerasConnectOrUpdate: `${baseUrl}/skellycam/camera/group/apply`,
+ closeAll: `${baseUrl}/skellycam/camera/group/close/all`,
+ updateConfigs: `${baseUrl}/skellycam/camera/update`,
+ pauseUnpauseCameras: `${baseUrl}/skellycam/camera/group/all/pause_unpause`,
+
+ // Recording endpoints
+ startRecording: `${baseUrl}/skellycam/camera/group/all/record/start`,
+ stopRecording: `${baseUrl}/skellycam/camera/group/all/record/stop`,
+
+ // Pipeline endpoints
+ pipelineConnectOrUpdate: `${baseUrl}/freemocap/pipeline/connect`,
+ pipelineClose: `${baseUrl}/freemocap/pipeline/all/close`,
+ pipelinePauseUnpause: `${baseUrl}/freemocap/pipeline/all/pause_unpause`,
+ pipelineRecordStart: `${baseUrl}/freemocap/pipeline/all/record/start`,
+ pipelineRecordStop: `${baseUrl}/freemocap/pipeline/all/record/stop`,
+
+ // Calibration endpoints
+ calibrationStartRecording: `${baseUrl}/freemocap/calibration/recording/start`,
+ calibrationStopRecording: `${baseUrl}/freemocap/calibration/recording/stop`,
+ calibrateRecording: `${baseUrl}/freemocap/calibration/recording/calibrate`,
+ updateCalibrationConfig: `${baseUrl}/freemocap/calibration/config/update/all`,
+
+ // Mocap endpoints
+ mocapStartRecording: `${baseUrl}/freemocap/mocap/recording/start`,
+ mocapStopRecording: `${baseUrl}/freemocap/mocap/recording/stop`,
+ processMocapRecording: `${baseUrl}/freemocap/mocap/recording/process`,
+ updateMocapConfig: `${baseUrl}/freemocap/mocap/config/update/all`,
+
+ // WebSocket
+ websocket: this.getWebSocketUrl(),
+ };
+ }
+}
+
+export const serverUrls = new ServerUrls();
\ No newline at end of file
diff --git a/freemocap-ui-old/src/hooks/useCalibration.ts b/freemocap-ui-old/src/hooks/useCalibration.ts
new file mode 100644
index 00000000..8888a26a
--- /dev/null
+++ b/freemocap-ui-old/src/hooks/useCalibration.ts
@@ -0,0 +1,114 @@
+// hooks/useCalibration.ts
+import {useCallback} from 'react';
+import {useAppDispatch, useAppSelector} from '@/store/hooks';
+
+import {useElectronIPC} from '@/services';
+import {
+ calibrateRecording,
+ CalibrationConfig,
+ calibrationConfigUpdated,
+ calibrationDirectoryInfoUpdated,
+ calibrationErrorCleared,
+ manualCalibrationRecordingPathChanged,
+ manualCalibrationRecordingPathCleared,
+ selectCalibration,
+ selectCalibrationDirectoryInfo,
+ selectCalibrationRecordingPath,
+ selectCanCalibrate,
+ selectCanStartCalibrationRecording,
+ selectIsUsingManualCalibrationPath,
+ startCalibrationRecording,
+ stopCalibrationRecording,
+ updateCalibrationConfigOnServer
+} from "@/store/slices/calibration";
+
+export function useCalibration() {
+ const dispatch = useAppDispatch();
+ const { api, isElectron } = useElectronIPC();
+ const calibrationState = useAppSelector(selectCalibration);
+ const canStartRecording = useAppSelector(selectCanStartCalibrationRecording);
+ const canCalibrate = useAppSelector(selectCanCalibrate);
+ const calibrationRecordingPath = useAppSelector(selectCalibrationRecordingPath);
+ const directoryInfo = useAppSelector(selectCalibrationDirectoryInfo);
+ const isUsingManualPath = useAppSelector(selectIsUsingManualCalibrationPath);
+
+ const updateCalibrationConfig = useCallback(
+ (updates: Partial<CalibrationConfig>) => {
+ // Update local state first
+ dispatch(calibrationConfigUpdated(updates));
+ // Then sync to server - this reads from the updated state
+ dispatch(updateCalibrationConfigOnServer());
+ },
+ [dispatch]
+ );
+
+ const validateDirectory = useCallback(
+ async (directoryPath: string) => {
+ if (!isElectron || !api) {
+ console.warn('Electron API not available - skipping directory validation');
+ return;
+ }
+
+ try {
+ const info = await api.fileSystem.validateCalibrationDirectory.query({ directoryPath });
+ dispatch(calibrationDirectoryInfoUpdated(info));
+ } catch (error) {
+ console.error('Failed to validate calibration directory:', error);
+ // Don't throw - just log the error
+ }
+ },
+ [dispatch, isElectron, api]
+ );
+
+ const setManualRecordingPath = useCallback(
+ async (path: string) => {
+ dispatch(manualCalibrationRecordingPathChanged(path));
+ // Validate the new path
+ await validateDirectory(path);
+ },
+ [dispatch, validateDirectory]
+ );
+
+ const clearManualRecordingPath = useCallback(() => {
+ dispatch(manualCalibrationRecordingPathCleared());
+ }, [dispatch]);
+
+ const dispatchStartCalibrationRecording = useCallback(() => {
+ dispatch(startCalibrationRecording());
+ }, [dispatch]);
+
+ const dispatchStopCalibrationRecording = useCallback(() => {
+ dispatch(stopCalibrationRecording());
+ }, [dispatch]);
+
+ const calibrate = useCallback(() => {
+ dispatch(calibrateRecording());
+ }, [dispatch]);
+
+ const clearError = useCallback(() => {
+ dispatch(calibrationErrorCleared());
+ }, [dispatch]);
+
+ return {
+ // State
+ config: calibrationState.config,
+ error: calibrationState.error,
+ isLoading: calibrationState.isLoading,
+ isRecording: calibrationState.isRecording,
+ recordingProgress: calibrationState.recordingProgress,
+ calibrationRecordingPath,
+ directoryInfo,
+ isUsingManualPath,
+ canStartRecording,
+ canCalibrate,
+ // Actions
+ updateCalibrationConfig,
+ setManualRecordingPath,
+ clearManualRecordingPath,
+ validateDirectory,
+ dispatchStartCalibrationRecording,
+ dispatchStopCalibrationRecording,
+ calibrateSelectedRecording: calibrate,
+ clearError,
+ };
+}
diff --git a/freemocap-ui-old/src/hooks/useElectronApi.ts b/freemocap-ui-old/src/hooks/useElectronApi.ts
new file mode 100644
index 00000000..97456743
--- /dev/null
+++ b/freemocap-ui-old/src/hooks/useElectronApi.ts
@@ -0,0 +1,125 @@
+// src/hooks/useElectronAPI.ts
+import {useEffect, useMemo, useState} from 'react';
+import {electronIpcClient, isElectron} from "@/services";
+import {serverUrls} from "@/hooks/server-urls";
+
+interface UseElectronAPIReturn {
+ isElectron: boolean;
+ isLoading: boolean;
+ api: typeof electronIpcClient | null;
+ pythonServer: {
+ start: (exePath?: string | null) => Promise<number>;
+ stop: () => Promise<void>;
+ isRunning: () => Promise<boolean>;
+ getPort: () => Promise<number>;
+ getStatus: () => Promise<{
+ running: boolean;
+ path: string | null;
+ processInfo: any;
+ }>;
+ } | null;
+ fileSystem: {
+ openSelectDirectoryDialog: () => Promise<string | null>;
+ selectExecutable: () => Promise<string | null>;
+ openFolder: (path: string) => Promise<boolean>;
+ getHomeDirectory: () => Promise<string>;
+ } | null;
+}
+
+export function useElectronAPI(): UseElectronAPIReturn {
+ const [isElectronEnv, setIsElectronEnv] = useState<boolean>(false);
+ const [isLoading, setIsLoading] = useState<boolean>(true);
+
+ useEffect(() => {
+ const electronAvailable = isElectron();
+ setIsElectronEnv(electronAvailable);
+ setIsLoading(false);
+
+ console.log('Electron environment detected:', electronAvailable);
+ }, []);
+
+ const pythonServer = useMemo(() => {
+ if (!isElectronEnv) return null;
+
+ return {
+ /**
+ * Start the Python server. Returns the port the server bound to.
+ * Also updates the global serverUrls singleton so all HTTP/WS
+ * connections automatically use the correct port.
+ */
+ start: async (exePath: string | null = null): Promise<number> => {
+ const port: number = await electronIpcClient.pythonServer.start.mutate({ exePath });
+ serverUrls.setPort(port);
+ return port;
+ },
+ stop: async () => {
+ await electronIpcClient.pythonServer.stop.mutate();
+ },
+ isRunning: async () => {
+ return await electronIpcClient.pythonServer.isRunning.query();
+ },
+ getPort: async (): Promise<number> => {
+ const port: number = await electronIpcClient.pythonServer.getPort.query();
+ serverUrls.setPort(port);
+ return port;
+ },
+ getStatus: async () => {
+ const [running, path, processInfo] = await Promise.all([
+ electronIpcClient.pythonServer.isRunning.query(),
+ electronIpcClient.pythonServer.getExecutablePath.query(),
+ electronIpcClient.pythonServer.getProcessInfo.query(),
+ ]);
+ return { running, path, processInfo };
+ },
+ };
+ }, [isElectronEnv]);
+
+ const fileSystem = useMemo(() => {
+ if (!isElectronEnv) return null;
+
+ return {
+ openSelectDirectoryDialog: async () => {
+ try {
+ return await electronIpcClient.fileSystem.selectDirectory.mutate();
+ } catch (error) {
+ console.error('Failed to select directory:', error);
+ return null;
+ }
+ },
+ selectExecutable: async () => {
+ try {
+ return await electronIpcClient.fileSystem.selectExecutableFile.mutate();
+ } catch (error) {
+ console.error('Failed to select executable:', error);
+ return null;
+ }
+ },
+ openFolder: async (path: string) => {
+ try {
+ return await electronIpcClient.fileSystem.openFolder.mutate({ path });
+ } catch (error) {
+ console.error('Failed to open folder:', error);
+ return false;
+ }
+ },
+ getHomeDirectory: async () => {
+ try {
+ return await electronIpcClient.fileSystem.getHomeDirectory.query();
+ } catch (error) {
+ console.error('Failed to get home directory:', error);
+ return '';
+ }
+ },
+ };
+ }, [isElectronEnv]);
+
+ return {
+ isElectron: isElectronEnv,
+ isLoading,
+ api: isElectronEnv ? electronIpcClient : null,
+ pythonServer,
+ fileSystem,
+ };
+}
+
+export const electronAPI = isElectron() ? electronIpcClient : null;
\ No newline at end of file
diff --git a/freemocap-ui-old/src/hooks/useMocap.ts b/freemocap-ui-old/src/hooks/useMocap.ts
new file mode 100644
index 00000000..0233834a
--- /dev/null
+++ b/freemocap-ui-old/src/hooks/useMocap.ts
@@ -0,0 +1,144 @@
+import {useCallback} from 'react';
+import {useAppDispatch, useAppSelector} from '@/store/hooks';
+import {useElectronIPC} from '@/services';
+import {
+ MediapipeDetectorConfig,
+ RealtimeFilterConfig,
+ mocapDetectorConfigReplaced,
+ mocapDetectorConfigUpdated,
+ skeletonFilterConfigReplaced,
+ skeletonFilterConfigUpdated,
+ mocapDirectoryInfoUpdated,
+ mocapErrorCleared,
+ manualMocapRecordingPathChanged,
+ manualMocapRecordingPathCleared,
+ selectMocap,
+ selectMocapDetectorConfig,
+ selectSkeletonFilterConfig,
+ selectMocapDirectoryInfo,
+ selectMocapRecordingPath,
+ selectCanProcessMocapRecording,
+ selectCanStartMocapRecording,
+ selectIsUsingManualMocapPath,
+ startMocapRecording,
+ stopMocapRecording,
+ processMocapRecording,
+ updateMocapConfigOnServer,
+} from "@/store/slices/mocap";
+
+export function useMocap() {
+ const dispatch = useAppDispatch();
+ const {api, isElectron} = useElectronIPC();
+ const mocapState = useAppSelector(selectMocap);
+ const detectorConfig = useAppSelector(selectMocapDetectorConfig);
+ const skeletonFilterConfig = useAppSelector(selectSkeletonFilterConfig);
+ const canStartRecording = useAppSelector(selectCanStartMocapRecording);
+ const canProcessMocapRecording = useAppSelector(selectCanProcessMocapRecording);
+ const mocapRecordingPath = useAppSelector(selectMocapRecordingPath);
+ const directoryInfo = useAppSelector(selectMocapDirectoryInfo);
+ const isUsingManualPath = useAppSelector(selectIsUsingManualMocapPath);
+
+ const updateDetectorConfig = useCallback(
+ (updates: Partial<MediapipeDetectorConfig>) => {
+ dispatch(mocapDetectorConfigUpdated(updates));
+ dispatch(updateMocapConfigOnServer());
+ },
+ [dispatch]
+ );
+
+ const replaceDetectorConfig = useCallback(
+ (config: MediapipeDetectorConfig) => {
+ dispatch(mocapDetectorConfigReplaced(config));
+ dispatch(updateMocapConfigOnServer());
+ },
+ [dispatch]
+ );
+
+ const updateSkeletonFilterConfig = useCallback(
+ (updates: Partial<RealtimeFilterConfig>) => {
+ dispatch(skeletonFilterConfigUpdated(updates));
+ dispatch(updateMocapConfigOnServer());
+ },
+ [dispatch]
+ );
+
+ const replaceSkeletonFilterConfig = useCallback(
+ (config: RealtimeFilterConfig) => {
+ dispatch(skeletonFilterConfigReplaced(config));
+ dispatch(updateMocapConfigOnServer());
+ },
+ [dispatch]
+ );
+
+ const validateDirectory = useCallback(
+ async (directoryPath: string) => {
+ if (!isElectron || !api) {
+ console.warn('Electron API not available - skipping directory validation');
+ return;
+ }
+
+ try {
+ const info = await api.fileSystem.validateMocapDirectory.query({directoryPath});
+ dispatch(mocapDirectoryInfoUpdated(info));
+ } catch (error) {
+ console.error('Failed to validate mocap directory:', error);
+ }
+ },
+ [dispatch, isElectron, api]
+ );
+
+ const setManualRecordingPath = useCallback(
+ async (path: string) => {
+ dispatch(manualMocapRecordingPathChanged(path));
+ await validateDirectory(path);
+ },
+ [dispatch, validateDirectory]
+ );
+
+ const clearManualRecordingPath = useCallback(() => {
+ dispatch(manualMocapRecordingPathCleared());
+ }, [dispatch]);
+
+ const dispatchStartMocapRecording = useCallback(() => {
+ dispatch(startMocapRecording());
+ }, [dispatch]);
+
+ const dispatchStopMocapRecording = useCallback(() => {
+ dispatch(stopMocapRecording());
+ }, [dispatch]);
+
+ const dispatchProcessMocapRecording = useCallback(() => {
+ dispatch(processMocapRecording());
+ }, [dispatch]);
+
+ const clearError = useCallback(() => {
+ dispatch(mocapErrorCleared());
+ }, [dispatch]);
+
+ return {
+ // State
+ config: mocapState.config,
+ detectorConfig,
+ skeletonFilterConfig,
+ error: mocapState.error,
+ isLoading: mocapState.isLoading,
+ isRecording: mocapState.isRecording,
+ recordingProgress: mocapState.recordingProgress,
+ mocapRecordingPath,
+ directoryInfo,
+ isUsingManualPath,
+ canStartRecording,
+ canProcessMocapRecording,
+ // Actions
+ updateDetectorConfig,
+ replaceDetectorConfig,
+ updateSkeletonFilterConfig,
+ replaceSkeletonFilterConfig,
+ setManualRecordingPath,
+ clearManualRecordingPath,
+ dispatchStartMocapRecording,
+ dispatchStopMocapRecording,
+ dispatchProcessMocapRecording,
+ clearError,
+ };
+}
diff --git a/freemocap-ui-old/src/hooks/useServer.ts b/freemocap-ui-old/src/hooks/useServer.ts
new file mode 100644
index 00000000..e09bb2a6
--- /dev/null
+++ b/freemocap-ui-old/src/hooks/useServer.ts
@@ -0,0 +1,10 @@
+import {useContext} from "react";
+import {ServerContext, ServerContextValue} from "@/services";
+
+export const useServer = (): ServerContextValue => {
+ const context = useContext(ServerContext);
+ if (!context) {
+ throw new Error('useServer must be used within ServerContextProvider');
+ }
+ return context;
+};
diff --git a/freemocap-ui-old/src/i18n/i18n.ts b/freemocap-ui-old/src/i18n/i18n.ts
new file mode 100644
index 00000000..fb47193a
--- /dev/null
+++ b/freemocap-ui-old/src/i18n/i18n.ts
@@ -0,0 +1,193 @@
+import i18n from "i18next";
+import { initReactI18next } from "react-i18next";
+import LanguageDetector from "i18next-browser-languagedetector";
+
+// Only eagerly load the fallback locale — all others are lazy-loaded on demand
+import en from "./locales/en-english.json";
+
+export const SUPPORTED_LOCALES = {
+ en: { label: "English", englishName: "English", dir: "ltr" as const, flag: "US" },
+ es: { label: "Español", englishName: "Spanish", dir: "ltr" as const, flag: "ES" },
+ fr: { label: "Français", englishName: "French", dir: "ltr" as const, flag: "FR" },
+ de: { label: "Deutsch", englishName: "German", dir: "ltr" as const, flag: "DE" },
+ it: { label: "Italiano", englishName: "Italian", dir: "ltr" as const, flag: "IT" },
+ "pt-BR": { label: "Português (Brasil)", englishName: "Portuguese (Brazil)", dir: "ltr" as const, flag: "BR" },
+ nl: { label: "Nederlands", englishName: "Dutch", dir: "ltr" as const, flag: "NL" },
+ sv: { label: "Svenska", englishName: "Swedish", dir: "ltr" as const, flag: "SE" },
+ pl: { label: "Polski", englishName: "Polish", dir: "ltr" as const, flag: "PL" },
+ cs: { label: "Čeština", englishName: "Czech", dir: "ltr" as const, flag: "CZ" },
+ uk: { label: "Українська", englishName: "Ukrainian", dir: "ltr" as const, flag: "UA" },
+ ru: { label: "Русский", englishName: "Russian", dir: "ltr" as const, flag: "RU" },
+ tr: { label: "Türkçe", englishName: "Turkish", dir: "ltr" as const, flag: "TR" },
+ ar: { label: "العربية", englishName: "Arabic", dir: "rtl" as const, flag: "PS" },
+ fa: { label: "فارسی", englishName: "Persian", dir: "rtl" as const, flag: "IR" },
+ ur: { label: "اردو", englishName: "Urdu", dir: "rtl" as const, flag: "PK" },
+ hi: { label: "हिन्दी", englishName: "Hindi", dir: "ltr" as const, flag: "IN" },
+ bn: { label: "বাংলা", englishName: "Bengali", dir: "ltr" as const, flag: "BD" },
+ ta: { label: "தமிழ்", englishName: "Tamil", dir: "ltr" as const, flag: "IN" },
+ ne: { label: "नेपाली", englishName: "Nepali", dir: "ltr" as const, flag: "NP" },
+ si: { label: "සිංහල", englishName: "Sinhala", dir: "ltr" as const, flag: "LK" },
+ "zh-CN": { label: "简体中文", englishName: "Chinese (Simplified)", dir: "ltr" as const, flag: "CN" },
+ ja: { label: "日本語", englishName: "Japanese", dir: "ltr" as const, flag: "JP" },
+ ko: { label: "한국어", englishName: "Korean", dir: "ltr" as const, flag: "KR" },
+ th: { label: "ไทย", englishName: "Thai", dir: "ltr" as const, flag: "TH" },
+ vi: { label: "Tiếng Việt", englishName: "Vietnamese", dir: "ltr" as const, flag: "VN" },
+ id: { label: "Bahasa Indonesia", englishName: "Indonesian", dir: "ltr" as const, flag: "ID" },
+ ms: { label: "Bahasa Melayu", englishName: "Malay", dir: "ltr" as const, flag: "MY" },
+ tl: { label: "Tagalog", englishName: "Tagalog", dir: "ltr" as const, flag: "PH" },
+ my: { label: "မြန်မာ", englishName: "Burmese", dir: "ltr" as const, flag: "MM" },
+ sw: { label: "Kiswahili", englishName: "Swahili", dir: "ltr" as const, flag: "KE" },
+ am: { label: "አማርኛ", englishName: "Amharic", dir: "ltr" as const, flag: "ET" },
+ ro: { label: "Română", englishName: "Romanian", dir: "ltr" as const, flag: "RO" },
+ el: { label: "Ελληνικά", englishName: "Greek", dir: "ltr" as const, flag: "GR" },
+ hu: { label: "Magyar", englishName: "Hungarian", dir: "ltr" as const, flag: "HU" },
+ ka: { label: "ქართული", englishName: "Georgian", dir: "ltr" as const, flag: "GE" },
+ sr: { label: "Српски", englishName: "Serbian", dir: "ltr" as const, flag: "RS" },
+ hr: { label: "Hrvatski", englishName: "Croatian", dir: "ltr" as const, flag: "HR" },
+ ca: { label: "Català", englishName: "Catalan", dir: "ltr" as const, flag: "ES" },
+ chr: { label: "ᏣᎳᎩ", englishName: "Cherokee", dir: "ltr" as const, flag: "CHEROKEE" },
+ yi: { label: "ייִדיש", englishName: "Yiddish", dir: "rtl" as const, flag: "YIDDISH" },
+} as const;
+
+export type SupportedLocale = keyof typeof SUPPORTED_LOCALES;
+
+export const FALLBACK_LOCALE: SupportedLocale = "en";
+
+/**
+ * Returns the text direction for the given locale.
+ * Defaults to "ltr" for unknown locales.
+ */
+export function getLocaleDirection(locale: string): "ltr" | "rtl" {
+ if (locale in SUPPORTED_LOCALES) {
+ return SUPPORTED_LOCALES[locale as SupportedLocale].dir;
+ }
+ return "ltr";
+}
+
+/**
+ * Dynamic import loaders for each non-English locale.
+ * Vite splits each into a separate chunk that's only fetched when needed.
+ */
+const LOCALE_LOADERS: Record<string, () => Promise<{ default: Record<string, any> }>> = {
+ es: () => import("./locales/es-espanol.json"),
+ fr: () => import("./locales/fr-francais.json"),
+ de: () => import("./locales/de-deutsch.json"),
+ it: () => import("./locales/it-italiano.json"),
+ "pt-BR": () => import("./locales/pt-BR-portugues-brasil.json"),
+ nl: () => import("./locales/nl-nederlands.json"),
+ sv: () => import("./locales/sv-svenska.json"),
+ pl: () => import("./locales/pl-polski.json"),
+ cs: () => import("./locales/cs-cestina.json"),
+ uk: () => import("./locales/uk-ukrainska.json"),
+ ru: () => import("./locales/ru-russkiy.json"),
+ tr: () => import("./locales/tr-turkce.json"),
+ ar: () => import("./locales/ar-arabic.json"),
+ fa: () => import("./locales/fa-farsi.json"),
+ ur: () => import("./locales/ur-urdu.json"),
+ hi: () => import("./locales/hi-hindi.json"),
+ bn: () => import("./locales/bn-bangla.json"),
+ ta: () => import("./locales/ta-tamil.json"),
+ ne: () => import("./locales/ne-nepali.json"),
+ si: () => import("./locales/si-sinhala.json"),
+ "zh-CN": () => import("./locales/zh-CN-zhongwen.json"),
+ ja: () => import("./locales/ja-nihongo.json"),
+ ko: () => import("./locales/ko-hangugeo.json"),
+ th: () => import("./locales/th-thai.json"),
+ vi: () => import("./locales/vi-tieng-viet.json"),
+ id: () => import("./locales/id-bahasa-indonesia.json"),
+ ms: () => import("./locales/ms-melayu.json"),
+ tl: () => import("./locales/tl-tagalog.json"),
+ my: () => import("./locales/my-myanmar.json"),
+ sw: () => import("./locales/sw-kiswahili.json"),
+ am: () => import("./locales/am-amharic.json"),
+ ro: () => import("./locales/ro-romana.json"),
+ el: () => import("./locales/el-ellinika.json"),
+ hu: () => import("./locales/hu-magyar.json"),
+ ka: () => import("./locales/ka-kartuli.json"),
+ sr: () => import("./locales/sr-srpski.json"),
+ hr: () => import("./locales/hr-hrvatski.json"),
+ ca: () => import("./locales/ca-catala.json"),
+ chr: () => import("./locales/chr-tsalagi.json"),
+ yi: () => import("./locales/yi-yidish.json"),
+};
+
+/** Tracks which locales have already been loaded to avoid duplicate fetches. */
+const loadedLocales = new Set<string>(["en"]);
+
+/**
+ * Load a locale's translations on demand. If already loaded, resolves immediately.
+ * Called automatically by the languageChanged event and can be called manually.
+ */
+export async function loadLocale(locale: string): Promise<void> {
+ if (loadedLocales.has(locale)) return;
+
+ const loader = LOCALE_LOADERS[locale];
+ if (!loader) {
+ throw new Error(`No locale loader registered for "${locale}". Supported: ${Object.keys(LOCALE_LOADERS).join(", ")}`);
+ }
+
+ const module = await loader();
+ const translations = module.default;
+ i18n.addResourceBundle(locale, "translation", translations, true, true);
+ loadedLocales.add(locale);
+
+ // Re-trigger changeLanguage after the bundle is loaded so react-i18next
+ // detects the new resources and re-renders all translated components.
+ if (i18n.language === locale) {
+ await i18n.changeLanguage(locale);
+ }
+}
+
+/**
+ * Returns the _meta.translationSource value from a locale's translations.
+ * Only works for locales that have already been loaded.
+ */
+export function getTranslationSource(
+ locale: string
+): "human-authored" | "ai-generated" | "human-validated" {
+ const resources = i18n.getResourceBundle(locale, "translation");
+ const meta = resources?._meta;
+ if (
+ meta?.translationSource === "human-authored" ||
+ meta?.translationSource === "ai-generated" ||
+ meta?.translationSource === "human-validated"
+ ) {
+ return meta.translationSource;
+ }
+ return "ai-generated";
+}
+
+i18n
+ .use(LanguageDetector)
+ .use(initReactI18next)
+ .init({
+ resources: {
+ en: { translation: en },
+ },
+ lng: FALLBACK_LOCALE,
+ fallbackLng: FALLBACK_LOCALE,
+ interpolation: {
+ escapeValue: false,
+ },
+ detection: {
+ order: ["localStorage"],
+ lookupLocalStorage: "freemocap:locale",
+ caches: ["localStorage"],
+ },
+ });
+
+// When the language changes (via user selection or detection), load the locale on demand.
+// The UI briefly shows English keys until the async load completes, then re-renders.
+i18n.on("languageChanged", (lng: string) => {
+ if (lng !== FALLBACK_LOCALE) {
+ loadLocale(lng);
+ }
+});
+
+// If the detected language on startup is not English, load it immediately
+const detectedLng = i18n.language;
+if (detectedLng && detectedLng !== FALLBACK_LOCALE && !loadedLocales.has(detectedLng)) {
+ loadLocale(detectedLng);
+}
+
+export default i18n;
diff --git a/freemocap-ui-old/src/i18n/index.ts b/freemocap-ui-old/src/i18n/index.ts
new file mode 100644
index 00000000..b520a9a9
--- /dev/null
+++ b/freemocap-ui-old/src/i18n/index.ts
@@ -0,0 +1,9 @@
+export {
+ default as i18n,
+ SUPPORTED_LOCALES,
+ FALLBACK_LOCALE,
+ getLocaleDirection,
+ getTranslationSource,
+ loadLocale,
+} from "./i18n";
+export type { SupportedLocale } from "./i18n";
diff --git a/freemocap-ui-old/src/i18n/locales/am-amharic.json b/freemocap-ui-old/src/i18n/locales/am-amharic.json
new file mode 100644
index 00000000..3d0cc3a0
--- /dev/null
+++ b/freemocap-ui-old/src/i18n/locales/am-amharic.json
@@ -0,0 +1,258 @@
+{
+ "_meta": {
+ "locale": "am",
+ "translationSource": "ai-generated",
+ "lastUpdated": "2026-02-23"
+ },
+ "appName": "SkellyCam",
+ "appNameDecorated": "SkellyCam 💀📸",
+ "welcomeTitle": "እንኳን ወደ SkellyCam በደህና መጡ",
+ "welcomeSubtitle": "የተመሳሰሉ ቪዲዮዎችን ይቅረጹ እና ይመልከቱ",
+ "sendAnonymousPings": "ስም-አልባ የአጠቃቀም ፒንጎችን ላክ",
+ "footerWith": "ከ",
+ "footerFrom": "ከ",
+ "footerOrgName": "FreeMoCap Foundation",
+ "home": "መነሻ",
+ "cameras": "ካሜራዎች",
+ "videos": "ቪዲዮዎች",
+ "expandSidebar": "የጎን አሞሌን አስፋ",
+ "collapseSidebar": "የጎን አሞሌን አሳንስ",
+ "startRecording": "መቅረጽ ጀምር",
+ "stopRecording": "መቅረጽ አቁም",
+ "toggleTheme": "ገጽታ ቀይር",
+ "switchToDark": "ወደ ጨለማ ሁነታ ቀይር",
+ "switchToLight": "ወደ ብርሃን ሁነታ ቀይር",
+ "connectWebSocket": "WebSocket አገናኝ",
+ "disconnectWebSocket": "WebSocket ግንኙነት አቋርጥ",
+ "launchServer": "አገልጋይ አስጀምር",
+ "stopServer": "አገልጋይ አቁም",
+ "browseForExecutable": "ሊሰራ የሚችል ፋይል ፈልግ",
+ "refreshCandidates": "እጩዎችን አድስ",
+ "executable": "ሊሰራ የሚችል",
+ "host": "አስተናጋጅ",
+ "port": "ወደብ",
+ "cameraCount_one": "{{count}} ካሜራ",
+ "cameraCount_other": "{{count}} ካሜራዎች",
+ "connectedCameras": "የተገናኙ ካሜራዎች",
+ "availableCameras": "ያሉ ካሜራዎች",
+ "noCamerasConnected": "ምንም ካሜራ አልተገናኘም",
+ "detectCameras": "ያሉ ካሜራዎችን ለይ",
+ "clearCameraSettings": "የተቀመጡ የካሜራ ቅንብሮችን ከማህደረ ትውስታ አጽዳ",
+ "copySettingsToAll": "ቅንብሮችን ለሁሉም ካሜራዎች ቅዳ",
+ "recordingTag": "የመቅረጫ መለያ",
+ "recordingTagPlaceholder": "አማራጭ መለያ",
+ "recordingDirectory": "የመቅረጫ ማውጫ",
+ "recordingFolderPath": "የመቅረጫ አቃፊ ዱካ",
+ "delayStart": "መጀመሪያ አዘግይ",
+ "seconds": "ሰከንዶች",
+ "subfolder": "ንዑስ አቃፊ",
+ "subfolderPlaceholder": "የንዑስ አቃፊ ስም",
+ "baseName": "መሰረታዊ ስም",
+ "increment": "ጭማሪ",
+ "resolution": "ጥራት",
+ "fps": "FPS",
+ "width": "ስፋት",
+ "height": "ቁመት",
+ "columns": "ዓምዶች",
+ "auto": "ራስ-ሰር",
+ "manual": "በእጅ",
+ "custom": "ብጁ",
+ "current": "አሁኑኑ",
+ "recommend": "አቅርብ",
+ "cameraRotation": "የካሜራ ማሽከርከር",
+ "selectCameraRotation": "የካሜራ ምስል ማሽከርከር ይምረጡ",
+ "exposureControl": "በራስ-ሰር ወይም በእጅ የመጋለጥ ቁጥጥር መካከል ይምረጡ",
+ "framerateControl": "በራስ-ሰር ወይም በእጅ የፍሬም ፍጥነት ቁጥጥር መካከል ይምረጡ",
+ "adjustExposure": "የመጋለጥ ጊዜን ያስተካክሉ፣ ለምሳሌ cv2.VideoCapture.set(cv2.CAP_PROP_EXPOSURE, value)",
+ "setTargetFps": "ለካሜራ ቀረጻ የታለመ ፍሬም በሰከንድ (FPS) ያዘጋጁ",
+ "recordingCaptureFps": "የቀረጻ ፍሬም ፍጥነት",
+ "playbackSpeed": "የማጫወቻ ፍጥነት (የቀረጻ fps ላይ ተጽዕኖ አያሳድርም)",
+ "framerateTimeline": "የፍሬም ፍጥነት ጊዜ መስመር",
+ "framerateDistribution": "የፍሬም ፍጥነት ስርጭት",
+ "timelineView": "የጊዜ መስመር ዕይታ",
+ "distributionView": "የስርጭት ዕይታ",
+ "combinedView": "የተቀናጀ ዕይታ",
+ "min": "ዝቅተኛ",
+ "max": "ከፍተኛ",
+ "mean": "አማካይ",
+ "median": "መካከለኛ",
+ "stdDevCv": "StdDev/CV",
+ "source": "ምንጭ",
+ "selectAll": "ሁሉንም ምረጥ",
+ "loadSynchronizedVideos": "የተመሳሰሉ ቪዲዮዎችን ጫን",
+ "loadSynchronizedVideosDescription": "ይህ ገጽ ቀድመው የተቀረጹ ቪዲዮዎችን እንዲጭኑ እና እንዲያመሳስሉ ያስችልዎታል።",
+ "automaticallySynchronizeVideos": "ቪዲዮዎችን በራስ-ሰር አመሳስል",
+ "extractFramesOnLoad": "ሲጫን ፍሬሞችን አውጣ",
+ "generateThumbnails": "ድቅል ምስሎችን ፍጠር",
+ "noVideosLoaded": "ምንም ቪዲዮ አልተጫነም",
+ "filterVideos": "ቪዲዮዎችን አጣራ...",
+ "openVideo": "ቪዲዮ ክፈት",
+ "openFolder": "አቃፊን በፋይል ማሰሻ ክፈት",
+ "videoFolderPath": "የቪዲዮ አቃፊ ዱካ",
+ "jumpToStart": "ወደ መጀመሪያ ዝለል (Home)",
+ "jumpToEnd": "ወደ መጨረሻ ዝለል (End)",
+ "loopOn": "ዑደት በርቷል (ለመቀያየር L ይጫኑ)",
+ "loopOff": "ዑደት ማጫወት (L)",
+ "syncInfo": "የማመሳሰል መረጃ",
+ "syncInfoTitle": "የብዙ ካሜራ ማመሳሰል ፍሬም-ፍጹም ላይሆን ይችላል",
+ "syncInfoBody": "የአሳሽ ቪዲዮ ማጫወት በብዙ ዥረቶች ላይ ናሙና-ትክክለኛ ማመሳሰልን አያረጋግጥም። ማጫወቻው የመሪ-ተከታይ ስልት ይጠቀማል እና ትንሽ መቻቻልን ሲያልፍ መዛባትን ያስተካክላል፣ ነገር ግን ጥቃቅን የማመሳሰል ብልሽት (1–2 ፍሬሞች) ሊከሰት ይችላል፣ በተለይ ከፍተኛ የማጫወት ፍጥነት ወይም አሳሹ ጫና ውስጥ ሲሆን። ለፍሬም-ትክክለኛ ትንተና፣ በእያንዳንዱ ቀረጻ ውስጥ የተካተቱትን ጥሬ የጊዜ ማህተም CSV ፋይሎችን ይጠቀሙ።",
+ "previousFrame": "ያለፈ ፍሬም (← / Shift+← ለ 10)",
+ "nextFrame": "ቀጣይ ፍሬም (→ / Shift+→ ለ 10)",
+ "zoomIn": "አቅርብ",
+ "zoomOut": "አራቅ",
+ "resetZoom": "ማቅረብ ዳግም አስጀምር",
+ "playbackSettings": "የማጫወቻ ቅንብሮች",
+ "totalRecordingSize": "በዲስክ ላይ ጠቅላላ የቀረጻ መጠን",
+ "estimatedTime": "የሚገመት ጊዜ (ፍሬም ÷ የቀረጻ fps)",
+ "estimatedDuration": "የሚገመት ቆይታ (ጠቅላላ ፍሬሞች ÷ የቀረጻ fps)",
+ "estimatedFromFrameNumber": "ከፍሬም ቁጥር × የቀረጻ fps የተገመተ — ከጊዜ ማህተም ውሂብ አልተነበበም",
+ "frameCountPerCamera": "በካሜራ የፍሬም ብዛት",
+ "cameraStreams": "በዚህ ቀረጻ ውስጥ ያሉ የካሜራ ዥረቶች",
+ "backToRecordings": "ወደ ቀረጻዎች ተመለስ",
+ "errorsDetected": "ስህተቶች ተገኝተዋል",
+ "somethingWentWrong": "የሆነ ነገር ተሳስቷል :(",
+ "searchLogs": "ምዝግብ ማስታወሻዎችን ፈልግ...",
+ "filter": "አጣራ…",
+ "refreshMicrophoneList": "የማይክሮፎን ዝርዝር አድስ",
+ "date": "ቀን",
+ "name": "ስም",
+ "size": "መጠን",
+ "duration": "ቆይታ",
+ "frames": "ፍሬሞች",
+ "timestamp": "የጊዜ ማህተም",
+ "language": "ቋንቋ",
+ "aiTranslated": "በ AI የተተረጎመ",
+ "humanTranslated": "በሰው የተተረጎመ",
+ "humanValidated": "በሰው የተረጋገጠ",
+ "connectCameras": "ከተመረጡ ካሜራዎች ጋር ይገናኙ ወይም የተገናኙ ካሜራዎችን ያዘምኑ",
+ "resumeStreaming": "ዥረት ቀጥል",
+ "pauseStreaming": "ዥረት አቁም",
+ "closeAllCameras": "ሁሉንም ካሜራዎች ዝጋ",
+ "framerate": "የፍሬም ፍጥነት",
+ "exposure": "መጋለጥ",
+ "fileLabel": "ፋይል",
+ "timeDelta": "የጊዜ ልዩነት",
+ "pathLabel": "ዱካ",
+ "exceptionDetails": "የልዩ ሁኔታ ዝርዝሮች",
+ "stackTrace": "ቁልል ዱካ",
+ "loadingVideos": "ቪዲዮዎችን በመጫን ላይ… ({{ready}}/{{total}} ዝግጁ)",
+ "gridColumns": "የፍርግርግ ዓምዶች",
+ "settings": "ቅንብሮች",
+ "appearance": "መልክ",
+ "themeMode": "ገጽታ",
+ "darkMode": "ጨለማ",
+ "lightMode": "ብርሃን",
+ "languageSettings": "ቋንቋ እና አካባቢያዊነት",
+ "showTranslationIndicator": "የትርጉም ምንጭ አመላካች አሳይ",
+ "showTranslationIndicatorDescription": "በ AI የተፈጠሩ ትርጉሞችን ሲጠቀሙ ባጅ አሳይ",
+ "translationSourceLabel": "የትርጉም ምንጭ",
+ "general": "አጠቃላይ",
+ "about": "ስለ",
+ "version": "ስሪት",
+ "serverSettings": "አገልጋይ",
+ "recordingSettings": "የቀረጻ ቅንብሮች",
+ "videoLoadingSettings": "የቪዲዮ መጫኛ ቅንብሮች",
+ "connected": "ተገናኝቷል",
+ "connecting": "በመገናኘት ላይ…",
+ "disconnected": "ተቋርጧል",
+ "disconnect": "ግንኙነት አቋርጥ",
+ "connect": "አገናኝ",
+ "off": "ጠፍቷል",
+ "running": "እየሰራ ነው",
+ "stopped": "ቆሟል",
+ "working": "እየሰራ ነው…",
+ "invalid": "ልክ ያልሆነ",
+ "autoLaunch": "ራስ-ሰር አስጀምር",
+ "autoConnect": "ራስ-ሰር አገናኝ",
+ "runningPath": "እየሰራ ነው: {{path}}",
+ "noMicrophone": "ማይክሮፎን የለም",
+ "audioRecordingEnabled": "የድምጽ ቀረጻ ነቅቷል",
+ "noMicrophoneSelected": "ማይክሮፎን አልተመረጠም",
+ "recordingName": "የቀረጻ ስም: {{name}}",
+ "startingIn": "በ {{countdown}} ይጀምራል...",
+ "stopping": "በማቆም ላይ...",
+ "starting": "በመጀመር ላይ...",
+ "stopRecordingButton": "🔴 መቅረጽ አቁም",
+ "startRecordingButton": "🔴 መቅረጽ ጀምር",
+ "camerasCount": "ካሜራዎች ({{count}})",
+ "availableCamerasCount": "ያሉ ({{count}})",
+ "server": "አገልጋይ",
+ "display": "ማሳያ",
+ "rawMessage": "ጥሬ መልዕክት",
+ "cameraPerformanceMetrics": "የካሜራ አፈጻጸም መለኪያዎች",
+ "serverLogs": "የአገልጋይ ምዝግብ ማስታወሻዎች",
+ "sortBy": "{{direction}} ደርድር",
+ "waitingForCameraStreams": "የካሜራ ዥረቶችን በመጠበቅ ላይ...",
+ "loggingPaused": "ምዝግብ ማስታወሻ ቆሟል",
+ "noLogsToDisplay": "የሚታይ ምዝግብ ማስታወሻ የለም",
+ "closeSettings": "ቅንብሮችን ዝጋ",
+ "gridSettings": "የፍርግርግ ቅንብሮች",
+ "clickToShowLess": "ያነሰ ለማሳየት ጠቅ ያድርጉ",
+ "clickToLearnMore": "ተጨማሪ ለማወቅ ጠቅ ያድርጉ",
+ "samples": "ናሙናዎች",
+ "framerateOverTime": "የፍሬም ፍጥነት በጊዜ ሂደት",
+ "framerateFps": "የፍሬም ፍጥነት (fps)",
+ "capturesFramesFromCamera": "ከካሜራ ፍሬሞችን ይይዛል።",
+ "rendersReceivedFrames": "የተቀበሉ ፍሬሞችን በማያ ገጽ ላይ ያሳያል።",
+ "displayTooltipLong": "ማሳያ የUI ማሳያ አፈጻጸምን ይወክላል። ማሳያዎ ፍሬሞችን ምን ያህል በፍጥነት እንደሚቀበል እና እንደሚያሳይ ያሳያል። እዚህ ያሉ የአፈጻጸም ችግሮች የቀረጻ ጥራትን አይጎዱም ነገር ግን ካሜራዎችን በቀጥታ የመከታተል ችሎታዎን ሊጎዱ ይችላሉ።",
+ "statsSourceShort": "ማሳያ ፍሬሞችን ያሳያል፣ አገልጋይ ፍሬሞችን ይይዛል።",
+ "statsSourceLong": "አገልጋይ ፍሬሞች ከካሜራ የሚጎተቱበት/የሚቀረጹበት ትክክለኛ ፍጥነት ነው፣ ማሳያ ደግሞ የሚቀበሉበት እና የሚሳዩበት ፍጥነት ነው። Skellycam ለቀረጻ ጥራት የአገልጋይ ወገን አፈጻጸምን ቅድሚያ ይሰጣል፣ ስለዚህ ያ ቁጥር የበለጠ የተረጋጋ መሆን አለበት። የማሳያ ፍሬም ፍጥነት ከአገልጋይ ከራቀ፣ የስርዓት ሀብቶችዎ እንደተጫኑ ያሳያል። ያነሱ ካሜራዎችን መጠቀም ወይም ፍሬም ፍጥነት/ጥራት መቀነስ ያስቡ።",
+ "statsCurrentShort": "በጣም የቅርብ የፍሬም ጊዜ እና ተዛማጅ FPS።",
+ "statsCurrentLong": "ይህ አንድ ፍሬም ለማስኬድ ምን ያህል ጊዜ እንደሚወስድ (በሚሊሰከንዶች) እና ተመጣጣኝ ፍሬሞች በሰከንድ (FPS) በጣም የቅርብ ልኬትን ያሳያል። ዝቅተኛ የፍሬም ጊዜዎች እና ከፍ ያለ FPS የተሻለ አፈጻጸምን ያሳያሉ።",
+ "statsMinShort": "ፈጣኑ የፍሬም ጊዜ (ዝቅተኛ መዘግየት) እና ከፍተኛ FPS የተገኘ።",
+ "statsMinLong": "ይህ በናሙና መስኮት ወቅት አንድ ፍሬም ለማስኬድ የወሰደውን ዝቅተኛ ጊዜ ይወክላል። ይህ ስርዓትዎ በተመቻቸ ሁኔታዎች ያገኘውን ከፍተኛ FPS ይመጣጠናል።",
+ "statsMaxShort": "ቀርፋፋው የፍሬም ጊዜ (ከፍተኛ መዘግየት) እና ዝቅተኛ FPS የተገኘ።",
+ "statsMaxLong": "ይህ በናሙና መስኮት ወቅት አንድ ፍሬም ለማስኬድ የወሰደውን ከፍተኛ ጊዜ ይወክላል። ይህ ስርዓትዎ በከፋ ሁኔታዎች ያገኘውን ዝቅተኛ FPS ይመጣጠናል። አልፎ አልፎ ከፍ ማለት ተለምዷዊ ነው፣ ነገር ግን ያለማቋረጥ ከፍ ያሉ ዋጋዎች የአፈጻጸም ችግሮችን ሊያሳዩ ይችላሉ።",
+ "statsMeanShort": "በሁሉም ናሙናዎች አማካይ የፍሬም ጊዜ እና FPS።",
+ "statsMeanLong": "በናሙና መስኮት ወቅት የተለኩ ሁሉም የፍሬም ጊዜዎች የሂሳብ አማካይ እና ተዛማጅ FPS። ይህ ጥሩ አጠቃላይ የአፈጻጸም ምስል ይሰጣል ነገር ግን በከፍተኛ ዋጋዎች ሊዛባ ይችላል።",
+ "statsMedianShort": "የሁሉም የፍሬም ጊዜዎች መካከለኛ ዋጋ (50ኛ መቶኛ)።",
+ "statsMedianLong": "መካከለኛ ሁሉም የፍሬም ጊዜዎች ከፈጣን ወደ ቀርፋፋ ሲደረደሩ መካከለኛውን ዋጋ ይወክላል። ከአማካይ በተለየ፣ መካከለኛ በከፍተኛ ዋጋዎች አይጎዳም፣ ይህም ለተለመደ አፈጻጸም የበለጠ ተረጋጋ አመላካች ያደርገዋል።",
+ "statsStdDevShort": "የፍሬም ጊዜ ተለዋዋጭነትን ይለካል። CV% አንጻራዊ ተለዋዋጭነት ነው።",
+ "statsStdDevLong": "ስታንዳርድ ዲቪየሽን በፍሬም ጊዜዎች ውስጥ ያለውን የለውጥ መጠን ይለካል። ዝቅተኛ ዋጋዎች የበለጠ ወጥ የሆነ አፈጻጸምን ያመለክታሉ። የለውጥ ኮኤፊሸንት (CV%) ይህንን ተለዋዋጭነት ከአማካዩ በመቶኛ ይገልጻል፣ ይህም በተለያዩ የፍሬም ፍጥነቶች ላይ ያለውን ጥንካሬ ማወዳደር ቀላል ያደርገዋል። ዝቅተኛ CV% የበለጠ ጠንካራ አፈጻጸምን ያመለክታል።",
+ "aiTranslatedTooltip": "ይህ ትርጉም በ AI ተፈጥሯል እና ስህተቶች ሊኖሩት ይችላሉ። ይህን ቋንቋ ከተናገሩ፣ በ GitHub ላይ pull request በመክፈት ለማሻሻል ሊረዱ ይችላሉ!",
+ "humanValidatedTooltip": "ይህ ትርጉም በሰው ተርጓሚ ተገምግሞ ተረጋግጧል።",
+ "helpTranslate": "SkellyCam ን ለመተርጎም ይረዱ",
+ "failedToFetch": "ማምጣት አልተሳካም",
+ "recordings": "ቀረጻዎች",
+ "noRecordingsFound": "ምንም ቀረጻዎች አልተገኙም። በእጅ ለመጫን ከላይ ዱካ ያስገቡ።",
+ "noCamerasDetected": "ምንም ካሜራ አልተገኘም",
+ "clickRefreshToScan": "ያሉ ካሜራዎችን ለመቃኘት አድስ ን ጠቅ ያድርጉ",
+ "waitingForData": "ውሂብ በመጠበቅ ላይ…",
+ "load": "ጫን",
+ "refresh": "አድስ",
+ "available": "ይገኛል",
+ "menuFile": "ፋይል",
+ "menuView": "እይታ",
+ "menuCamera": "ካሜራ",
+ "menuRecording": "ቀረጻ",
+ "menuHelp": "እገዛ",
+ "menuDetectCameras": "ካሜራዎችን ፈልግ",
+ "menuConnectCameras": "ካሜራዎችን ያገናኙ",
+ "menuCloseAllCameras": "ሁሉንም ካሜራዎች ዝጋ",
+ "menuOpenRecordingFolder": "የቀረጻ ማህደር ክፈት…",
+ "menuToggleSidebar": "ጎን አሞሌ ቀያይር",
+ "menuToggleTheme": "ገጽታ ቀይር",
+ "menuToggleFullScreen": "ሙሉ ማያ ገጽ",
+ "menuPauseUnpause": "አቁም / ቀጥል",
+ "menuConnectApplySettings": "አገናኝ / ቅንብሮችን ተግብር",
+ "menuCloseAll": "ሁሉንም ዝጋ",
+ "menuDocumentation": "ሰነድ",
+ "menuGitHubRepository": "የGitHub ማከማቻ",
+ "menuReportIssue": "ችግር ሪፖርት አድርግ…",
+ "menuAbout": "ስለ SkellyCam",
+ "menuPlayback": "ማጫወት",
+ "videoPlayback": "ማጫወት",
+ "copyLogsToClipboard": "ሎግ ወደ ቅንጥብ ሰሌዳ ቅዳ",
+ "saveLogsToFile": "ሎግ ወደ ፋይል አስቀምጥ",
+ "copied": "ተቀድቷል!",
+ "timestampFromRecording": "ከቀረጻ ውሂብ የጊዜ ማህተም",
+ "menuCheckForUpdates": "Check for Updates…",
+ "updateAvailable": "Update available",
+ "updateAvailableMessage": "Version {{version}} is available",
+ "downloading": "Downloading…",
+ "downloadComplete": "Download complete",
+ "restartToUpdate": "Restart to update",
+ "checkForUpdates": "Check for Updates",
+ "upToDate": "You are up to date",
+ "updateError": "Update check failed"
+}
diff --git a/freemocap-ui-old/src/i18n/locales/ar-arabic.json b/freemocap-ui-old/src/i18n/locales/ar-arabic.json
new file mode 100644
index 00000000..4bf6c5f0
--- /dev/null
+++ b/freemocap-ui-old/src/i18n/locales/ar-arabic.json
@@ -0,0 +1,261 @@
+{
+ "_meta": {
+ "locale": "ar",
+ "translationSource": "ai-generated",
+ "lastUpdated": "2026-02-22"
+ },
+ "appName": "SkellyCam",
+ "appNameDecorated": "📸💀 SkellyCam",
+ "welcomeTitle": "SkellyCam أهلاً بك في",
+ "welcomeSubtitle": "سجّل وشاهد مقاطع فيديو متزامنة",
+ "sendAnonymousPings": "إرسال بيانات استخدام مجهولة",
+ "footerWith": "بـ",
+ "footerFrom": "من",
+ "footerOrgName": "مؤسسة FreeMoCap",
+ "home": "الرئيسية",
+ "cameras": "الكاميرات",
+ "videos": "الفيديوهات",
+ "expandSidebar": "توسيع الشريط الجانبي",
+ "collapseSidebar": "طي الشريط الجانبي",
+ "startRecording": "بدء التسجيل",
+ "stopRecording": "إيقاف التسجيل",
+ "toggleTheme": "تبديل المظهر",
+ "switchToDark": "التبديل إلى الوضع الداكن",
+ "switchToLight": "التبديل إلى الوضع الفاتح",
+ "connectWebSocket": "اتصال WebSocket",
+ "disconnectWebSocket": "قطع اتصال WebSocket",
+ "launchServer": "تشغيل الخادم",
+ "stopServer": "إيقاف الخادم",
+ "browseForExecutable": "تصفح للملف التنفيذي",
+ "refreshCandidates": "تحديث المرشحين",
+ "executable": "الملف التنفيذي",
+ "host": "المضيف",
+ "port": "المنفذ",
+ "cameraCount_one": "كاميرا {{count}}",
+ "cameraCount_other": "{{count}} كاميرا",
+ "connectedCameras": "الكاميرات المتصلة",
+ "availableCameras": "الكاميرات المتاحة",
+ "noCamerasConnected": "لا توجد كاميرات متصلة",
+ "detectCameras": "كشف الكاميرات المتاحة",
+ "clearCameraSettings": "مسح إعدادات الكاميرا المحفوظة",
+ "copySettingsToAll": "نسخ الإعدادات لجميع الكاميرات",
+ "recordingTag": "وسم التسجيل",
+ "recordingTagPlaceholder": "وسم اختياري",
+ "recordingDirectory": "مجلد التسجيل",
+ "recordingFolderPath": "مسار مجلد التسجيل",
+ "delayStart": "تأخير البدء",
+ "seconds": "ثوانٍ",
+ "subfolder": "مجلد فرعي",
+ "subfolderPlaceholder": "اسم المجلد الفرعي",
+ "baseName": "الاسم الأساسي",
+ "increment": "زيادة",
+ "resolution": "الدقة",
+ "fps": "FPS",
+ "width": "العرض",
+ "height": "الارتفاع",
+ "columns": "الأعمدة",
+ "auto": "تلقائي",
+ "manual": "يدوي",
+ "custom": "مخصص",
+ "current": "الحالي",
+ "recommend": "موصى به",
+ "cameraRotation": "تدوير الكاميرا",
+ "selectCameraRotation": "اختيار تدوير صورة الكاميرا",
+ "exposureControl": "الاختيار بين التحكم التلقائي أو اليدوي في التعريض",
+ "framerateControl": "الاختيار بين التحكم التلقائي أو اليدوي في معدل الإطارات",
+ "adjustExposure": "ضبط وقت التعريض، مثال: cv2.VideoCapture.set(cv2.CAP_PROP_EXPOSURE, value)",
+ "setTargetFps": "تعيين معدل الإطارات المستهدف (FPS) لالتقاط الكاميرا",
+ "recordingCaptureFps": "معدل إطارات التقاط التسجيل",
+ "playbackSpeed": "سرعة التشغيل (لا تؤثر على FPS التسجيل)",
+ "framerateTimeline": "الجدول الزمني لمعدل الإطارات",
+ "framerateDistribution": "توزيع معدل الإطارات",
+ "timelineView": "عرض الجدول الزمني",
+ "distributionView": "عرض التوزيع",
+ "combinedView": "عرض مدمج",
+ "min": "أدنى",
+ "max": "أقصى",
+ "mean": "متوسط",
+ "median": "وسيط",
+ "stdDevCv": "انحراف معياري/CV",
+ "source": "المصدر",
+ "selectAll": "تحديد الكل",
+ "loadSynchronizedVideos": "تحميل فيديوهات متزامنة",
+ "loadSynchronizedVideosDescription": "ستتيح لك هذه الصفحة تحميل ومزامنة مقاطع الفيديو المسجلة مسبقاً.",
+ "automaticallySynchronizeVideos": "مزامنة الفيديوهات تلقائياً",
+ "extractFramesOnLoad": "استخراج الإطارات عند التحميل",
+ "generateThumbnails": "إنشاء صور مصغرة",
+ "noVideosLoaded": "لا توجد فيديوهات محملة",
+ "filterVideos": "تصفية الفيديوهات...",
+ "openVideo": "فتح الفيديو",
+ "openFolder": "فتح المجلد في مستكشف الملفات",
+ "videoFolderPath": "مسار مجلد الفيديو",
+ "jumpToStart": "الانتقال إلى البداية (Home)",
+ "jumpToEnd": "الانتقال إلى النهاية (End)",
+ "loopOn": "التكرار مفعّل (L للتبديل)",
+ "loopOff": "تكرار التشغيل (L)",
+ "syncInfo": "معلومات المزامنة",
+ "syncInfoTitle": "قد لا تكون مزامنة الكاميرات المتعددة دقيقة على مستوى الإطار",
+ "syncInfoBody": "لا يضمن تشغيل الفيديو في المتصفح مزامنة دقيقة على مستوى العينة عبر تدفقات متعددة. يستخدم المشغّل استراتيجية القائد والتابع ويصحح الانحراف عندما يتجاوز حدًا صغيرًا، لكن قد يحدث عدم تزامن طفيف (1–2 إطار)، خاصة عند سرعات التشغيل العالية أو عندما يكون المتصفح تحت الحمل. للتحليل الدقيق على مستوى الإطار، استخدم ملفات CSV للطوابع الزمنية الخام المضمّنة في كل تسجيل.",
+ "previousFrame": "الإطار السابق (← / Shift+← لـ 10)",
+ "nextFrame": "الإطار التالي (→ / Shift+→ لـ 10)",
+ "zoomIn": "تكبير",
+ "zoomOut": "تصغير",
+ "resetZoom": "إعادة تعيين التكبير",
+ "playbackSettings": "إعدادات التشغيل",
+ "totalRecordingSize": "حجم التسجيل الإجمالي على القرص",
+ "estimatedTime": "الوقت المقدر (الإطار ÷ FPS التسجيل)",
+ "estimatedDuration": "المدة المقدرة (إجمالي الإطارات ÷ FPS التسجيل)",
+ "estimatedFromFrameNumber": "مقدر من رقم الإطار × FPS التسجيل — لم يُقرأ من بيانات الطابع الزمني",
+ "frameCountPerCamera": "عدد الإطارات لكل كاميرا",
+ "cameraStreams": "بثوث الكاميرا في هذا التسجيل",
+ "backToRecordings": "العودة إلى التسجيلات",
+ "errorsDetected": "تم اكتشاف أخطاء",
+ "somethingWentWrong": "حدث خطأ ما :(",
+ "searchLogs": "البحث في السجلات...",
+ "filter": "تصفية…",
+ "refreshMicrophoneList": "تحديث قائمة الميكروفونات",
+ "date": "التاريخ",
+ "name": "الاسم",
+ "size": "الحجم",
+ "duration": "المدة",
+ "frames": "الإطارات",
+ "timestamp": "الطابع الزمني",
+ "language": "اللغة",
+ "aiTranslated": "ترجمة آلية",
+ "humanTranslated": "ترجمة بشرية",
+ "humanValidated": "ترجمة بشرية مُراجعة",
+ "connectCameras": "الاتصال بالكاميرات المحددة أو تحديث الكاميرات المتصلة",
+ "resumeStreaming": "استئناف البث",
+ "pauseStreaming": "إيقاف البث مؤقتاً",
+ "closeAllCameras": "إغلاق جميع الكاميرات",
+ "framerate": "معدل الإطارات",
+ "exposure": "التعريض",
+ "fileLabel": "الملف",
+ "timeDelta": "فارق الزمن",
+ "pathLabel": "المسار",
+ "exceptionDetails": "تفاصيل الاستثناء",
+ "stackTrace": "تتبع المكدس",
+ "loadingVideos": "جاري تحميل الفيديوهات… ({{ready}}/{{total}} جاهز)",
+ "gridColumns": "أعمدة الشبكة",
+ "settings": "الإعدادات",
+ "appearance": "المظهر",
+ "themeMode": "المظهر",
+ "darkMode": "داكن",
+ "lightMode": "فاتح",
+ "languageSettings": "اللغة والتوطين",
+ "showTranslationIndicator": "إظهار مؤشر مصدر الترجمة",
+ "showTranslationIndicatorDescription": "عرض شارة عند استخدام ترجمات مولدة بالذكاء الاصطناعي",
+ "translationSourceLabel": "مصدر الترجمة",
+ "general": "عام",
+ "about": "حول",
+ "version": "الإصدار",
+ "serverSettings": "الخادم",
+ "recordingSettings": "إعدادات التسجيل",
+ "videoLoadingSettings": "إعدادات تحميل الفيديو",
+ "connected": "متصل",
+ "connecting": "جارٍ الاتصال…",
+ "disconnected": "غير متصل",
+ "disconnect": "قطع الاتصال",
+ "connect": "اتصال",
+ "off": "مغلق",
+ "running": "قيد التشغيل",
+ "stopped": "متوقف",
+ "working": "جارٍ العمل…",
+ "invalid": "غير صالح",
+ "autoLaunch": "تشغيل تلقائي",
+ "autoConnect": "اتصال تلقائي",
+ "runningPath": "قيد التشغيل: {{path}}",
+ "noMicrophone": "بدون ميكروفون",
+ "audioRecordingEnabled": "تسجيل الصوت مفعّل",
+ "noMicrophoneSelected": "لم يتم تحديد ميكروفون",
+ "recordingName": "اسم التسجيل: {{name}}",
+ "startingIn": "يبدأ خلال {{countdown}}...",
+ "stopping": "جارٍ الإيقاف...",
+ "starting": "جارٍ البدء...",
+ "stopRecordingButton": "🔴 إيقاف التسجيل",
+ "startRecordingButton": "🔴 بدء التسجيل",
+ "camerasCount": "الكاميرات ({{count}})",
+ "availableCamerasCount": "المتاحة ({{count}})",
+ "server": "الخادم",
+ "display": "العرض",
+ "rawMessage": "الرسالة الأولية",
+ "cameraPerformanceMetrics": "مقاييس أداء الكاميرا",
+ "serverLogs": "سجلات الخادم",
+ "sortBy": "ترتيب {{direction}}",
+ "waitingForCameraStreams": "في انتظار بثوث الكاميرا...",
+ "loggingPaused": "السجلات متوقفة مؤقتاً",
+ "noLogsToDisplay": "لا توجد سجلات للعرض",
+ "closeSettings": "إغلاق الإعدادات",
+ "gridSettings": "إعدادات الشبكة",
+ "clickToShowLess": "انقر لإظهار أقل",
+ "clickToLearnMore": "انقر لمعرفة المزيد",
+ "samples": "عينة",
+ "framerateOverTime": "معدل الإطارات عبر الزمن",
+ "framerateFps": "معدل الإطارات (fps)",
+ "capturesFramesFromCamera": "يلتقط الإطارات من الكاميرا.",
+ "rendersReceivedFrames": "يعرض الإطارات المستلمة على الشاشة.",
+ "displayTooltipLong": "يمثل العرض أداء تصيير واجهة المستخدم. يوضح مدى سرعة استقبال شاشتك وتصيير الإطارات. مشاكل الأداء هنا لن تؤثر على جودة التسجيل لكنها قد تؤثر على قدرتك على مراقبة الكاميرات في الوقت الفعلي.",
+ "statsSourceShort": "العرض يقدم الإطارات، الخادم يلتقط الإطارات.",
+ "statsSourceLong": "الخادم هو المعدل الحقيقي الذي يتم فيه سحب/تسجيل الإطارات من الكاميرا، بينما العرض هو معدل استقبالها وتصييرها. يعطي SkellyCam الأولوية لأداء جانب الخادم لضمان جودة التسجيل، لذا يجب أن يبقى هذا الرقم أكثر استقرارًا. إذا انحرف معدل إطارات العرض عن الخادم، فهذا يشير إلى أن موارد نظامك مُجهدة. فكر في استخدام عدد أقل من الكاميرات أو تقليل معدل الإطارات/الدقة.",
+ "statsCurrentShort": "أحدث وقت إطار و FPS المقابل.",
+ "statsCurrentLong": "يعرض هذا أحدث قياس لمدة معالجة إطار واحد (بالمللي ثانية) وما يعادله من إطارات في الثانية (FPS). أوقات إطارات أقل ومعدل FPS أعلى يشيران إلى أداء أفضل.",
+ "statsMinShort": "أسرع وقت إطار (أقل تأخير) وأعلى FPS.",
+ "statsMinLong": "يمثل هذا الحد الأدنى للوقت الذي استغرقته معالجة إطار واحد خلال نافذة أخذ العينات. يتوافق هذا مع أقصى معدل FPS حققه نظامك في ظروف مثالية.",
+ "statsMaxShort": "أبطأ وقت إطار (أعلى تأخير) وأقل FPS.",
+ "statsMaxLong": "يمثل هذا الحد الأقصى للوقت الذي استغرقته معالجة إطار واحد خلال نافذة أخذ العينات. يتوافق هذا مع أدنى معدل FPS في ظروف أسوأ الحالات. الارتفاعات العرضية طبيعية، لكن القيم المرتفعة باستمرار قد تشير إلى مشاكل في الأداء.",
+ "statsMeanShort": "متوسط وقت الإطار و FPS عبر جميع العينات.",
+ "statsMeanLong": "المتوسط الحسابي لجميع أوقات الإطارات المقاسة خلال نافذة أخذ العينات ومعدل FPS المقابل. يعطي صورة عامة جيدة للأداء لكنه قد يتأثر بالقيم المتطرفة.",
+ "statsMedianShort": "القيمة الوسطى لجميع أوقات الإطارات (النسبة المئوية 50).",
+ "statsMedianLong": "يمثل الوسيط القيمة المتوسطة عند ترتيب جميع أوقات الإطارات من الأسرع إلى الأبطأ. على عكس المتوسط الحسابي، لا يتأثر الوسيط بالقيم المتطرفة، مما يجعله مؤشرًا أكثر استقرارًا للأداء النموذجي.",
+ "statsStdDevShort": "يقيس تباين وقت الإطار. CV% هو التباين النسبي.",
+ "statsStdDevLong": "يقيس الانحراف المعياري مقدار التباين في أوقات الإطارات. القيم الأقل تشير إلى أداء أكثر اتساقًا. يعبر معامل التباين (CV%) عن هذا التباين كنسبة مئوية من المتوسط، مما يسهل مقارنة الاستقرار عبر معدلات إطارات مختلفة. نسبة CV% أقل تشير إلى أداء أكثر استقرارًا.",
+ "aiTranslatedTooltip": "هذه الترجمة تم إنشاؤها بواسطة الذكاء الاصطناعي وقد تحتوي على أخطاء. إذا كنت تتحدث هذه اللغة، يمكنك المساعدة في تحسينها عبر فتح pull request على GitHub!",
+ "humanValidatedTooltip": "تمت مراجعة هذه الترجمة والتحقق منها بواسطة مترجم بشري.",
+ "helpTranslate": "ساعد في ترجمة SkellyCam",
+ "failedToFetch": "فشل في الجلب",
+ "recordings": "التسجيلات",
+ "noRecordingsFound": "لم يتم العثور على تسجيلات. أدخل مسارًا أعلاه للتحميل يدويًا.",
+ "noCamerasDetected": "لم يتم اكتشاف كاميرات",
+ "clickRefreshToScan": "انقر تحديث للبحث عن الكاميرات المتاحة",
+ "waitingForData": "في انتظار البيانات…",
+ "load": "تحميل",
+ "refresh": "تحديث",
+ "available": "متاحة",
+ "menuFile": "ملف",
+ "menuView": "عرض",
+ "menuCamera": "كاميرا",
+ "menuRecording": "تسجيل",
+ "menuHelp": "مساعدة",
+ "menuDetectCameras": "اكتشاف الكاميرات",
+ "menuConnectCameras": "توصيل الكاميرات",
+ "menuCloseAllCameras": "إغلاق جميع الكاميرات",
+ "menuOpenRecordingFolder": "فتح مجلد التسجيل…",
+ "menuToggleSidebar": "تبديل الشريط الجانبي",
+ "menuToggleTheme": "تبديل السمة",
+ "menuToggleFullScreen": "ملء الشاشة",
+ "menuPauseUnpause": "إيقاف مؤقت / استئناف",
+ "menuConnectApplySettings": "توصيل / تطبيق الإعدادات",
+ "menuCloseAll": "إغلاق الكل",
+ "menuDocumentation": "التوثيق",
+ "menuGitHubRepository": "مستودع GitHub",
+ "menuReportIssue": "الإبلاغ عن مشكلة…",
+ "menuAbout": "حول SkellyCam",
+ "menuPlayback": "تشغيل",
+ "videoPlayback": "التشغيل",
+ "copyLogsToClipboard": "نسخ السجلات إلى الحافظة",
+ "saveLogsToFile": "حفظ السجلات في ملف",
+ "copied": "تم النسخ!",
+ "timestampFromRecording": "طابع زمني من بيانات التسجيل",
+ "cameraCount_two": "كاميرتان",
+ "cameraCount_few": "{{count}} كاميرات",
+ "cameraCount_many": "{{count}} كاميرا",
+ "menuCheckForUpdates": "Check for Updates…",
+ "updateAvailable": "Update available",
+ "updateAvailableMessage": "Version {{version}} is available",
+ "downloading": "Downloading…",
+ "downloadComplete": "Download complete",
+ "restartToUpdate": "Restart to update",
+ "checkForUpdates": "Check for Updates",
+ "upToDate": "You are up to date",
+ "updateError": "Update check failed"
+}
diff --git a/freemocap-ui-old/src/i18n/locales/bn-bangla.json b/freemocap-ui-old/src/i18n/locales/bn-bangla.json
new file mode 100644
index 00000000..9619a33e
--- /dev/null
+++ b/freemocap-ui-old/src/i18n/locales/bn-bangla.json
@@ -0,0 +1,258 @@
+{
+ "_meta": {
+ "locale": "bn",
+ "translationSource": "ai-generated",
+ "lastUpdated": "2026-02-23"
+ },
+ "appName": "SkellyCam",
+ "appNameDecorated": "SkellyCam 💀📸",
+ "welcomeTitle": "SkellyCam-এ স্বাগতম",
+ "welcomeSubtitle": "সিঙ্ক্রোনাইজড ভিডিও রেকর্ড ও দেখুন",
+ "sendAnonymousPings": "বেনামী ব্যবহার ডেটা পাঠান",
+ "footerWith": "সাথে",
+ "footerFrom": "থেকে",
+ "footerOrgName": "FreeMoCap Foundation",
+ "home": "হোম",
+ "cameras": "ক্যামেরা",
+ "videos": "ভিডিও",
+ "expandSidebar": "সাইডবার প্রসারিত করুন",
+ "collapseSidebar": "সাইডবার সংকুচিত করুন",
+ "startRecording": "রেকর্ডিং শুরু করুন",
+ "stopRecording": "রেকর্ডিং বন্ধ করুন",
+ "toggleTheme": "থিম পরিবর্তন",
+ "switchToDark": "ডার্ক মোডে যান",
+ "switchToLight": "লাইট মোডে যান",
+ "connectWebSocket": "WebSocket সংযোগ করুন",
+ "disconnectWebSocket": "WebSocket সংযোগ বিচ্ছিন্ন করুন",
+ "launchServer": "সার্ভার চালু করুন",
+ "stopServer": "সার্ভার বন্ধ করুন",
+ "browseForExecutable": "এক্সিকিউটেবল খুঁজুন",
+ "refreshCandidates": "প্রার্থী রিফ্রেশ করুন",
+ "executable": "এক্সিকিউটেবল",
+ "host": "হোস্ট",
+ "port": "পোর্ট",
+ "cameraCount_one": "{{count}}টি ক্যামেরা",
+ "cameraCount_other": "{{count}}টি ক্যামেরা",
+ "connectedCameras": "সংযুক্ত ক্যামেরা",
+ "availableCameras": "উপলব্ধ ক্যামেরা",
+ "noCamerasConnected": "কোনো ক্যামেরা সংযুক্ত নেই",
+ "detectCameras": "উপলব্ধ ক্যামেরা সনাক্ত করুন",
+ "clearCameraSettings": "ক্যামেরা সেটিংস মুছুন",
+ "copySettingsToAll": "সব ক্যামেরায় সেটিংস কপি করুন",
+ "recordingTag": "রেকর্ডিং ট্যাগ",
+ "recordingTagPlaceholder": "ঐচ্ছিক ট্যাগ",
+ "recordingDirectory": "রেকর্ডিং ডিরেক্টরি",
+ "recordingFolderPath": "রেকর্ডিং ফোল্ডার পথ",
+ "delayStart": "বিলম্বিত শুরু",
+ "seconds": "সেকেন্ড",
+ "subfolder": "সাবফোল্ডার",
+ "subfolderPlaceholder": "সাবফোল্ডার নাম",
+ "baseName": "ভিত্তি নাম",
+ "increment": "বৃদ্ধি",
+ "resolution": "রেজোলিউশন",
+ "fps": "FPS",
+ "width": "প্রস্থ",
+ "height": "উচ্চতা",
+ "columns": "কলাম",
+ "auto": "স্বয়ংক্রিয়",
+ "manual": "ম্যানুয়াল",
+ "custom": "কাস্টম",
+ "current": "বর্তমান",
+ "recommend": "প্রস্তাবিত",
+ "cameraRotation": "ক্যামেরা রোটেশন",
+ "selectCameraRotation": "ক্যামেরা ইমেজ রোটেশন নির্বাচন করুন",
+ "exposureControl": "স্বয়ংক্রিয় বা ম্যানুয়াল এক্সপোজার নিয়ন্ত্রণ",
+ "framerateControl": "স্বয়ংক্রিয় বা ম্যানুয়াল ফ্রেমরেট নিয়ন্ত্রণ",
+ "adjustExposure": "এক্সপোজার সময় সামঞ্জস্য করুন",
+ "setTargetFps": "ক্যাপচারের জন্য লক্ষ্য FPS সেট করুন",
+ "recordingCaptureFps": "ক্যাপচার ফ্রেমরেট",
+ "playbackSpeed": "প্লেব্যাক গতি",
+ "framerateTimeline": "ফ্রেমরেট টাইমলাইন",
+ "framerateDistribution": "ফ্রেমরেট বিতরণ",
+ "timelineView": "টাইমলাইন দৃশ্য",
+ "distributionView": "বিতরণ দৃশ্য",
+ "combinedView": "সম্মিলিত দৃশ্য",
+ "min": "সর্বনিম্ন",
+ "max": "সর্বোচ্চ",
+ "mean": "গড়",
+ "median": "মধ্যমান",
+ "stdDevCv": "মানবিচ/CV",
+ "source": "উৎস",
+ "selectAll": "সব নির্বাচন করুন",
+ "loadSynchronizedVideos": "সিঙ্ক্রোনাইজড ভিডিও লোড করুন",
+ "loadSynchronizedVideosDescription": "এই পৃষ্ঠা পূর্ব-রেকর্ড করা ভিডিও লোড ও সিঙ্ক করতে দেবে।",
+ "automaticallySynchronizeVideos": "ভিডিও স্বয়ংক্রিয়ভাবে সিঙ্ক করুন",
+ "extractFramesOnLoad": "লোডে ফ্রেম বের করুন",
+ "generateThumbnails": "থাম্বনেইল তৈরি করুন",
+ "noVideosLoaded": "কোনো ভিডিও লোড হয়নি",
+ "filterVideos": "ভিডিও ফিল্টার করুন...",
+ "openVideo": "ভিডিও খুলুন",
+ "openFolder": "এক্সপ্লোরারে ফোল্ডার খুলুন",
+ "videoFolderPath": "ভিডিও ফোল্ডার পথ",
+ "jumpToStart": "শুরুতে যান (Home)",
+ "jumpToEnd": "শেষে যান (End)",
+ "loopOn": "লুপ চালু আছে (টগল করতে L)",
+ "loopOff": "লুপ প্লেব্যাক (L)",
+ "syncInfo": "সিঙ্ক তথ্য",
+ "syncInfoTitle": "মাল্টি-ক্যামেরা সিঙ্ক ফ্রেম-নিখুঁত নাও হতে পারে",
+ "syncInfoBody": "ব্রাউজার ভিডিও প্লেব্যাক একাধিক স্ট্রিম জুড়ে স্যাম্পল-সঠিক সিঙ্ক্রোনাইজেশনের নিশ্চয়তা দেয় না। প্লেয়ার একটি লিডার-ফলোয়ার কৌশল ব্যবহার করে এবং ড্রিফট একটি ছোট সহনশীলতা অতিক্রম করলে সংশোধন করে, তবে সামান্য ডিসিঙ্ক্রোনাইজেশন (1–2 ফ্রেম) ঘটতে পারে, বিশেষত উচ্চ প্লেব্যাক গতিতে বা ব্রাউজার লোডের মধ্যে থাকলে। ফ্রেম-সঠিক বিশ্লেষণের জন্য, প্রতিটি রেকর্ডিংয়ে অন্তর্ভুক্ত কাঁচা টাইমস্ট্যাম্প CSV ফাইলগুলি ব্যবহার করুন।",
+ "previousFrame": "পূর্ববর্তী ফ্রেম (← / Shift+← ১০)",
+ "nextFrame": "পরবর্তী ফ্রেম (→ / Shift+→ ১০)",
+ "zoomIn": "জুম ইন",
+ "zoomOut": "জুম আউট",
+ "resetZoom": "জুম রিসেট",
+ "playbackSettings": "প্লেব্যাক সেটিংস",
+ "totalRecordingSize": "ডিস্কে মোট রেকর্ডিং আকার",
+ "estimatedTime": "আনুমানিক সময় (ফ্রেম ÷ fps)",
+ "estimatedDuration": "আনুমানিক সময়কাল (মোট ফ্রেম ÷ fps)",
+ "estimatedFromFrameNumber": "ফ্রেম নম্বর × fps থেকে আনুমানিত",
+ "frameCountPerCamera": "প্রতি ক্যামেরায় ফ্রেম গণনা",
+ "cameraStreams": "এই রেকর্ডিংয়ে ক্যামেরা স্ট্রিম",
+ "backToRecordings": "রেকর্ডিংয়ে ফিরুন",
+ "errorsDetected": "ত্রুটি সনাক্ত হয়েছে",
+ "somethingWentWrong": "কিছু ভুল হয়েছে :(",
+ "searchLogs": "লগ অনুসন্ধান করুন...",
+ "filter": "ফিল্টার…",
+ "refreshMicrophoneList": "মাইক্রোফোন তালিকা রিফ্রেশ করুন",
+ "date": "তারিখ",
+ "name": "নাম",
+ "size": "আকার",
+ "duration": "সময়কাল",
+ "frames": "ফ্রেম",
+ "timestamp": "টাইমস্ট্যাম্প",
+ "language": "ভাষা",
+ "aiTranslated": "AI অনুবাদ",
+ "humanTranslated": "মানব অনুবাদ",
+ "humanValidated": "মানব যাচাইকৃত",
+ "connectCameras": "নির্বাচিত ক্যামেরায় সংযোগ করুন",
+ "resumeStreaming": "স্ট্রিমিং পুনরায় শুরু করুন",
+ "pauseStreaming": "স্ট্রিমিং বিরতি",
+ "closeAllCameras": "সব ক্যামেরা বন্ধ করুন",
+ "framerate": "ফ্রেমরেট",
+ "exposure": "এক্সপোজার",
+ "fileLabel": "ফাইল",
+ "timeDelta": "সময় পার্থক্য",
+ "pathLabel": "পথ",
+ "exceptionDetails": "ব্যতিক্রম বিবরণ",
+ "stackTrace": "স্ট্যাক ট্রেস",
+ "loadingVideos": "ভিডিও লোড হচ্ছে… ({{ready}}/{{total}} প্রস্তুত)",
+ "gridColumns": "গ্রিড কলাম",
+ "settings": "সেটিংস",
+ "appearance": "চেহারা",
+ "themeMode": "থিম",
+ "darkMode": "ডার্ক",
+ "lightMode": "লাইট",
+ "languageSettings": "ভাষা ও স্থানীয়করণ",
+ "showTranslationIndicator": "অনুবাদ উৎস সূচক দেখান",
+ "showTranslationIndicatorDescription": "AI-উৎপন্ন অনুবাদ ব্যবহার করার সময় ব্যাজ দেখান",
+ "translationSourceLabel": "অনুবাদ উৎস",
+ "general": "সাধারণ",
+ "about": "সম্পর্কে",
+ "version": "সংস্করণ",
+ "serverSettings": "সার্ভার",
+ "recordingSettings": "রেকর্ডিং সেটিংস",
+ "videoLoadingSettings": "ভিডিও লোডিং সেটিংস",
+ "connected": "সংযুক্ত",
+ "connecting": "সংযুক্ত হচ্ছে…",
+ "disconnected": "সংযোগ বিচ্ছিন্ন",
+ "disconnect": "সংযোগ বিচ্ছিন্ন করুন",
+ "connect": "সংযোগ করুন",
+ "off": "বন্ধ",
+ "running": "চলমান",
+ "stopped": "বন্ধ",
+ "working": "কাজ করছে…",
+ "invalid": "অবৈধ",
+ "autoLaunch": "স্বয়ংক্রিয় চালু",
+ "autoConnect": "স্বয়ংক্রিয় সংযোগ",
+ "runningPath": "চলমান: {{path}}",
+ "noMicrophone": "কোনো মাইক্রোফোন নেই",
+ "audioRecordingEnabled": "অডিও রেকর্ডিং সক্রিয়",
+ "noMicrophoneSelected": "কোনো মাইক্রোফোন নির্বাচিত নয়",
+ "recordingName": "রেকর্ডিং নাম: {{name}}",
+ "startingIn": "{{countdown}} এ শুরু হচ্ছে...",
+ "stopping": "থামছে...",
+ "starting": "শুরু হচ্ছে...",
+ "stopRecordingButton": "🔴 রেকর্ডিং বন্ধ করুন",
+ "startRecordingButton": "🔴 রেকর্ডিং শুরু করুন",
+ "camerasCount": "ক্যামেরা ({{count}})",
+ "availableCamerasCount": "উপলব্ধ ({{count}})",
+ "server": "সার্ভার",
+ "display": "ডিসপ্লে",
+ "rawMessage": "কাঁচা বার্তা",
+ "cameraPerformanceMetrics": "ক্যামেরা পারফরম্যান্স মেট্রিক্স",
+ "serverLogs": "সার্ভার লগ",
+ "sortBy": "সাজান {{direction}}",
+ "waitingForCameraStreams": "ক্যামেরা স্ট্রিমের জন্য অপেক্ষা করছে...",
+ "loggingPaused": "লগিং বিরতিতে",
+ "noLogsToDisplay": "দেখানোর জন্য কোনো লগ নেই",
+ "closeSettings": "সেটিংস বন্ধ করুন",
+ "gridSettings": "গ্রিড সেটিংস",
+ "clickToShowLess": "কম দেখতে ক্লিক করুন",
+ "clickToLearnMore": "আরও জানতে ক্লিক করুন",
+ "samples": "নমুনা",
+ "framerateOverTime": "সময়ের সাথে ফ্রেমরেট",
+ "framerateFps": "ফ্রেমরেট (fps)",
+ "capturesFramesFromCamera": "ক্যামেরা থেকে ফ্রেম ক্যাপচার করে।",
+ "rendersReceivedFrames": "স্ক্রিনে প্রাপ্ত ফ্রেম রেন্ডার করে।",
+ "displayTooltipLong": "ডিসপ্লে UI রেন্ডারিং কর্মক্ষমতা প্রতিনিধিত্ব করে। এটি দেখায় আপনার ডিসপ্লে কত দ্রুত ফ্রেম গ্রহণ করে এবং রেন্ডার করে। এখানে কর্মক্ষমতা সমস্যা রেকর্ডিং মানকে প্রভাবিত করবে না তবে রিয়েল-টাইমে ক্যামেরা পর্যবেক্ষণ করার আপনার ক্ষমতাকে প্রভাবিত করতে পারে।",
+ "statsSourceShort": "ডিসপ্লে ফ্রেম রেন্ডার করে, সার্ভার ফ্রেম ক্যাপচার করে।",
+ "statsSourceLong": "সার্ভার হল ক্যামেরা থেকে ফ্রেম টানা/রেকর্ড করার প্রকৃত হার, যেখানে ডিসপ্লে হল সেগুলি গ্রহণ ও রেন্ডার করার হার। SkellyCam রেকর্ডিং মানের জন্য সার্ভার-সাইড কর্মক্ষমতাকে অগ্রাধিকার দেয়, তাই সেই সংখ্যাটি আরও স্থিতিশীল থাকা উচিত। যদি ডিসপ্লে ফ্রেমরেট সার্ভার থেকে বিচ্যুত হয়, তাহলে এটি নির্দেশ করে যে আপনার সিস্টেম রিসোর্স চাপে আছে। কম ক্যামেরা ব্যবহার করুন বা ফ্রেমরেট/রেজোলিউশন কমানোর কথা বিবেচনা করুন।",
+ "statsCurrentShort": "সাম্প্রতিক ফ্রেম সময় এবং FPS।",
+ "statsCurrentLong": "এটি একটি একক ফ্রেম প্রক্রিয়াকরণে কত সময় লাগে (মিলিসেকেন্ডে) এবং সমতুল্য প্রতি সেকেন্ডে ফ্রেম (FPS) এর সাম্প্রতিকতম পরিমাপ দেখায়। কম ফ্রেম সময় এবং উচ্চ FPS ভাল কর্মক্ষমতা নির্দেশ করে।",
+ "statsMinShort": "দ্রুততম ফ্রেম সময় এবং সর্বোচ্চ FPS।",
+ "statsMinLong": "এটি স্যাম্পলিং উইন্ডোতে একটি একক ফ্রেম প্রক্রিয়াকরণে ন্যূনতম সময় প্রতিনিধিত্ব করে। এটি সর্বোত্তম পরিস্থিতিতে আপনার সিস্টেম যে সর্বোচ্চ FPS অর্জন করেছে তার সাথে সম্পর্কিত।",
+ "statsMaxShort": "ধীরতম ফ্রেম সময় এবং সর্বনিম্ন FPS।",
+ "statsMaxLong": "এটি স্যাম্পলিং উইন্ডোতে একটি একক ফ্রেম প্রক্রিয়াকরণে সর্বোচ্চ সময় প্রতিনিধিত্ব করে। এটি সবচেয়ে খারাপ পরিস্থিতিতে আপনার সিস্টেম যে সর্বনিম্ন FPS অর্জন করেছে তার সাথে সম্পর্কিত। মাঝে মাঝে স্পাইক স্বাভাবিক, তবে ধারাবাহিকভাবে উচ্চ মান কর্মক্ষমতা সমস্যা নির্দেশ করতে পারে।",
+ "statsMeanShort": "সমস্ত নমুনায় গড় ফ্রেম সময় এবং FPS।",
+ "statsMeanLong": "স্যাম্পলিং উইন্ডোতে পরিমাপ করা সমস্ত ফ্রেম সময়ের গাণিতিক গড় এবং সংশ্লিষ্ট FPS। এটি কর্মক্ষমতার একটি ভাল সামগ্রিক চিত্র দেয় তবে চরম মান দ্বারা বিকৃত হতে পারে।",
+ "statsMedianShort": "সমস্ত ফ্রেম সময়ের মধ্যমান (50তম শতাংশ)।",
+ "statsMedianLong": "মধ্যমান হল সমস্ত ফ্রেম সময়কে দ্রুততম থেকে ধীরতম পর্যন্ত সাজালে মাঝের মান। গড়ের বিপরীতে, মধ্যমান চরম মান দ্বারা প্রভাবিত হয় না, এটিকে সাধারণ কর্মক্ষমতার আরও স্থিতিশীল সূচক করে তোলে।",
+ "statsStdDevShort": "ফ্রেম সময়ের পরিবর্তনশীলতা পরিমাপ করে।",
+ "statsStdDevLong": "স্ট্যান্ডার্ড ডেভিয়েশন ফ্রেম সময়ের প্রকরণের পরিমাণ পরিমাপ করে। কম মান আরও সামঞ্জস্যপূর্ণ কর্মক্ষমতা নির্দেশ করে। ভেরিয়েশনের সহগ (CV%) এই পরিবর্তনশীলতাকে গড়ের শতাংশ হিসাবে প্রকাশ করে, বিভিন্ন ফ্রেম রেট জুড়ে স্থিতিশীলতা তুলনা করা সহজ করে। কম CV% আরও স্থিতিশীল কর্মক্ষমতা নির্দেশ করে।",
+ "aiTranslatedTooltip": "এই অনুবাদটি AI দ্বারা তৈরি এবং ত্রুটি থাকতে পারে। আপনি এই ভাষায় কথা বললে উন্নতিতে সাহায্য করুন!",
+ "humanValidatedTooltip": "এই অনুবাদটি একজন মানব অনুবাদক দ্বারা পর্যালোচনা করা হয়েছে।",
+ "helpTranslate": "SkellyCam অনুবাদে সাহায্য করুন",
+ "failedToFetch": "ডেটা আনতে ব্যর্থ",
+ "recordings": "রেকর্ডিং",
+ "noRecordingsFound": "কোনো রেকর্ডিং পাওয়া যায়নি। ম্যানুয়ালি লোড করতে উপরে একটি পাথ লিখুন।",
+ "noCamerasDetected": "কোনো ক্যামেরা সনাক্ত হয়নি",
+ "clickRefreshToScan": "উপলব্ধ ক্যামেরা খুঁজতে রিফ্রেশ ক্লিক করুন",
+ "waitingForData": "ডেটার জন্য অপেক্ষা…",
+ "load": "লোড",
+ "refresh": "রিফ্রেশ",
+ "available": "উপলব্ধ",
+ "menuFile": "ফাইল",
+ "menuView": "ভিউ",
+ "menuCamera": "ক্যামেরা",
+ "menuRecording": "রেকর্ডিং",
+ "menuHelp": "সাহায্য",
+ "menuDetectCameras": "ক্যামেরা শনাক্ত করুন",
+ "menuConnectCameras": "ক্যামেরা সংযুক্ত করুন",
+ "menuCloseAllCameras": "সব ক্যামেরা বন্ধ করুন",
+ "menuOpenRecordingFolder": "রেকর্ডিং ফোল্ডার খুলুন…",
+ "menuToggleSidebar": "সাইডবার টগল করুন",
+ "menuToggleTheme": "থিম পরিবর্তন করুন",
+ "menuToggleFullScreen": "পূর্ণ স্ক্রিন",
+ "menuPauseUnpause": "বিরতি / পুনরায় শুরু",
+ "menuConnectApplySettings": "সংযুক্ত / সেটিংস প্রয়োগ করুন",
+ "menuCloseAll": "সব বন্ধ করুন",
+ "menuDocumentation": "ডকুমেন্টেশন",
+ "menuGitHubRepository": "GitHub রিপোজিটরি",
+ "menuReportIssue": "সমস্যা রিপোর্ট করুন…",
+ "menuAbout": "SkellyCam সম্পর্কে",
+ "menuPlayback": "প্লেব্যাক",
+ "videoPlayback": "প্লেব্যাক",
+ "copyLogsToClipboard": "লগ ক্লিপবোর্ডে কপি করুন",
+ "saveLogsToFile": "লগ ফাইলে সংরক্ষণ করুন",
+ "copied": "কপি হয়েছে!",
+ "timestampFromRecording": "রেকর্ডিং ডেটা থেকে টাইমস্ট্যাম্প",
+ "menuCheckForUpdates": "Check for Updates…",
+ "updateAvailable": "Update available",
+ "updateAvailableMessage": "Version {{version}} is available",
+ "downloading": "Downloading…",
+ "downloadComplete": "Download complete",
+ "restartToUpdate": "Restart to update",
+ "checkForUpdates": "Check for Updates",
+ "upToDate": "You are up to date",
+ "updateError": "Update check failed"
+}
diff --git a/freemocap-ui-old/src/i18n/locales/ca-catala.json b/freemocap-ui-old/src/i18n/locales/ca-catala.json
new file mode 100644
index 00000000..8d78684a
--- /dev/null
+++ b/freemocap-ui-old/src/i18n/locales/ca-catala.json
@@ -0,0 +1,258 @@
+{
+ "_meta": {
+ "locale": "ca",
+ "translationSource": "ai-generated",
+ "lastUpdated": "2026-02-23"
+ },
+ "appName": "SkellyCam",
+ "appNameDecorated": "SkellyCam 💀📸",
+ "welcomeTitle": "Benvingut a SkellyCam",
+ "welcomeSubtitle": "Enregistra i visualitza vídeos sincronitzats",
+ "sendAnonymousPings": "Envia pings d'ús anònims",
+ "footerWith": "amb",
+ "footerFrom": "de la",
+ "footerOrgName": "FreeMoCap Foundation",
+ "home": "Inici",
+ "cameras": "Càmeres",
+ "videos": "Vídeos",
+ "expandSidebar": "Expandeix la barra lateral",
+ "collapseSidebar": "Redueix la barra lateral",
+ "startRecording": "Inicia l'enregistrament",
+ "stopRecording": "Atura l'enregistrament",
+ "toggleTheme": "canvia el tema",
+ "switchToDark": "Canvia al mode fosc",
+ "switchToLight": "Canvia al mode clar",
+ "connectWebSocket": "Connecta WebSocket",
+ "disconnectWebSocket": "Desconnecta WebSocket",
+ "launchServer": "Inicia el servidor",
+ "stopServer": "Atura el servidor",
+ "browseForExecutable": "Cerca l'executable",
+ "refreshCandidates": "Actualitza els candidats",
+ "executable": "Executable",
+ "host": "Amfitrió",
+ "port": "Port",
+ "cameraCount_one": "{{count}} càmera",
+ "cameraCount_other": "{{count}} càmeres",
+ "connectedCameras": "Càmeres connectades",
+ "availableCameras": "Càmeres disponibles",
+ "noCamerasConnected": "Cap càmera connectada",
+ "detectCameras": "Detecta les càmeres disponibles",
+ "clearCameraSettings": "Esborra la configuració de càmera desada de la memòria",
+ "copySettingsToAll": "Copia la configuració a totes les càmeres",
+ "recordingTag": "Etiqueta d'enregistrament",
+ "recordingTagPlaceholder": "Etiqueta opcional",
+ "recordingDirectory": "Directori d'enregistrament",
+ "recordingFolderPath": "Camí de la carpeta d'enregistrament",
+ "delayStart": "Retarda l'inici",
+ "seconds": "Segons",
+ "subfolder": "Subcarpeta",
+ "subfolderPlaceholder": "Nom de la subcarpeta",
+ "baseName": "Nom base",
+ "increment": "Increment",
+ "resolution": "Resolució",
+ "fps": "FPS",
+ "width": "Amplada",
+ "height": "Alçada",
+ "columns": "Columnes",
+ "auto": "Automàtic",
+ "manual": "Manual",
+ "custom": "Personalitzat",
+ "current": "Actual",
+ "recommend": "Recomanat",
+ "cameraRotation": "rotació de la càmera",
+ "selectCameraRotation": "Selecciona la rotació de la imatge de la càmera",
+ "exposureControl": "Tria entre el control d'exposició automàtic o manual",
+ "framerateControl": "Tria entre el control de taxa de fotogrames automàtic o manual",
+ "adjustExposure": "Ajusta el temps d'exposició, p. ex. cv2.VideoCapture.set(cv2.CAP_PROP_EXPOSURE, value)",
+ "setTargetFps": "Estableix els fotogrames per segon (FPS) objectiu per a la captura de la càmera",
+ "recordingCaptureFps": "Taxa de fotogrames de captura d'enregistrament",
+ "playbackSpeed": "Velocitat de reproducció (no afecta els fps d'enregistrament)",
+ "framerateTimeline": "Línia temporal de la taxa de fotogrames",
+ "framerateDistribution": "Distribució de la taxa de fotogrames",
+ "timelineView": "Vista de línia temporal",
+ "distributionView": "Vista de distribució",
+ "combinedView": "Vista combinada",
+ "min": "Mín",
+ "max": "Màx",
+ "mean": "Mitjana",
+ "median": "Mediana",
+ "stdDevCv": "StdDev/CV",
+ "source": "Font",
+ "selectAll": "Selecciona tot",
+ "loadSynchronizedVideos": "Carrega vídeos sincronitzats",
+ "loadSynchronizedVideosDescription": "Aquesta pàgina us permet carregar i sincronitzar vídeos preenregistrats.",
+ "automaticallySynchronizeVideos": "Sincronitza els vídeos automàticament",
+ "extractFramesOnLoad": "Extreu fotogrames en carregar",
+ "generateThumbnails": "Genera miniatures",
+ "noVideosLoaded": "Cap vídeo carregat",
+ "filterVideos": "Filtra vídeos...",
+ "openVideo": "Obre el vídeo",
+ "openFolder": "Obre la carpeta a l'explorador de fitxers",
+ "videoFolderPath": "Camí de la carpeta de vídeo",
+ "jumpToStart": "Salta a l'inici (Home)",
+ "jumpToEnd": "Salta al final (End)",
+ "loopOn": "Bucle activat (L per alternar)",
+ "loopOff": "Reproducció en bucle (L)",
+ "syncInfo": "Info de sincronització",
+ "syncInfoTitle": "La sincronització multicàmera pot no ser perfecta a nivell de fotograma",
+ "syncInfoBody": "La reproducció de vídeo al navegador no garanteix una sincronització exacta entre múltiples fluxos. El reproductor utilitza una estratègia de líder-seguidor i corregeix la desviació quan supera una petita tolerància, però pot produir-se una lleugera desincronització (1–2 fotogrames), especialment a velocitats de reproducció altes o quan el navegador està sota càrrega. Per a una anàlisi exacta per fotograma, utilitzeu els fitxers CSV de marques de temps inclosos a cada gravació.",
+ "previousFrame": "Fotograma anterior (← / Shift+← per 10)",
+ "nextFrame": "Fotograma següent (→ / Shift+→ per 10)",
+ "zoomIn": "Amplia",
+ "zoomOut": "Redueix",
+ "resetZoom": "Restableix el zoom",
+ "playbackSettings": "Configuració de reproducció",
+ "totalRecordingSize": "Mida total de l'enregistrament al disc",
+ "estimatedTime": "Temps estimat (fotograma ÷ fps d'enregistrament)",
+ "estimatedDuration": "Durada estimada (fotogrames totals ÷ fps d'enregistrament)",
+ "estimatedFromFrameNumber": "Estimat a partir del número de fotograma × fps d'enregistrament — no llegit de les dades de marca temporal",
+ "frameCountPerCamera": "Recompte de fotogrames per càmera",
+ "cameraStreams": "Fluxos de càmera en aquest enregistrament",
+ "backToRecordings": "Torna als enregistraments",
+ "errorsDetected": "Errors detectats",
+ "somethingWentWrong": "Alguna cosa ha anat malament :(",
+ "searchLogs": "Cerca als registres...",
+ "filter": "Filtre…",
+ "refreshMicrophoneList": "Actualitza la llista de micròfons",
+ "date": "Data",
+ "name": "Nom",
+ "size": "Mida",
+ "duration": "Durada",
+ "frames": "Fotogrames",
+ "timestamp": "Marca temporal",
+ "language": "Idioma",
+ "aiTranslated": "Traduït per IA",
+ "humanTranslated": "Traduït per un humà",
+ "humanValidated": "Validat per un humà",
+ "connectCameras": "Connecta a les càmeres seleccionades o actualitza les càmeres connectades",
+ "resumeStreaming": "Reprèn la transmissió",
+ "pauseStreaming": "Pausa la transmissió",
+ "closeAllCameras": "Tanca totes les càmeres",
+ "framerate": "Taxa de fotogrames",
+ "exposure": "Exposició",
+ "fileLabel": "Fitxer",
+ "timeDelta": "Diferència de temps",
+ "pathLabel": "Camí",
+ "exceptionDetails": "Detalls de l'excepció",
+ "stackTrace": "Traça de la pila",
+ "loadingVideos": "Carregant vídeos… ({{ready}}/{{total}} preparats)",
+ "gridColumns": "Columnes de la graella",
+ "settings": "Configuració",
+ "appearance": "Aparença",
+ "themeMode": "Tema",
+ "darkMode": "Fosc",
+ "lightMode": "Clar",
+ "languageSettings": "Idioma i localització",
+ "showTranslationIndicator": "Mostra l'indicador de font de traducció",
+ "showTranslationIndicatorDescription": "Mostra una insígnia quan s'utilitzen traduccions generades per IA",
+ "translationSourceLabel": "Font de traducció",
+ "general": "General",
+ "about": "Quant a",
+ "version": "Versió",
+ "serverSettings": "Servidor",
+ "recordingSettings": "Configuració d'enregistrament",
+ "videoLoadingSettings": "Configuració de càrrega de vídeo",
+ "connected": "Connectat",
+ "connecting": "Connectant…",
+ "disconnected": "Desconnectat",
+ "disconnect": "Desconnecta",
+ "connect": "Connecta",
+ "off": "Apagat",
+ "running": "En execució",
+ "stopped": "Aturat",
+ "working": "Treballant…",
+ "invalid": "No vàlid",
+ "autoLaunch": "Inici automàtic",
+ "autoConnect": "Connexió automàtica",
+ "runningPath": "En execució: {{path}}",
+ "noMicrophone": "Sense micròfon",
+ "audioRecordingEnabled": "Enregistrament d'àudio activat",
+ "noMicrophoneSelected": "Cap micròfon seleccionat",
+ "recordingName": "Nom de l'enregistrament: {{name}}",
+ "startingIn": "Començant en {{countdown}}...",
+ "stopping": "Aturant...",
+ "starting": "Iniciant...",
+ "stopRecordingButton": "🔴 Atura l'enregistrament",
+ "startRecordingButton": "🔴 Inicia l'enregistrament",
+ "camerasCount": "Càmeres ({{count}})",
+ "availableCamerasCount": "Disponibles ({{count}})",
+ "server": "Servidor",
+ "display": "Pantalla",
+ "rawMessage": "Missatge en brut",
+ "cameraPerformanceMetrics": "Mètriques de rendiment de la càmera",
+ "serverLogs": "Registres del servidor",
+ "sortBy": "Ordena {{direction}}",
+ "waitingForCameraStreams": "Esperant els fluxos de la càmera...",
+ "loggingPaused": "Registre en pausa",
+ "noLogsToDisplay": "No hi ha registres per mostrar",
+ "closeSettings": "Tanca la configuració",
+ "gridSettings": "Configuració de la graella",
+ "clickToShowLess": "Fes clic per mostrar menys",
+ "clickToLearnMore": "Fes clic per saber-ne més",
+ "samples": "mostres",
+ "framerateOverTime": "Taxa de fotogrames al llarg del temps",
+ "framerateFps": "Taxa de fotogrames (fps)",
+ "capturesFramesFromCamera": "Captura fotogrames de la càmera.",
+ "rendersReceivedFrames": "Renderitza els fotogrames rebuts a la pantalla.",
+ "displayTooltipLong": "La Pantalla representa el rendiment de renderització de la interfície d'usuari. Mostra com de ràpid la vostra pantalla rep i renderitza fotogrames. Els problemes de rendiment aquí no afectaran la qualitat de l'enregistrament, però poden afectar la vostra capacitat de supervisar les càmeres en temps real.",
+ "statsSourceShort": "La Pantalla renderitza fotogrames, el Servidor captura fotogrames.",
+ "statsSourceLong": "El servidor és la taxa real a la qual els fotogrames es capturen/enregistren de la càmera, mentre que la pantalla és la taxa a la qual es reben i es renderitzen. Skellycam prioritza el rendiment del servidor per a la qualitat de l'enregistrament, de manera que aquest número hauria de romandre més estable. Si la taxa de fotogrames de la pantalla divergeix del servidor, indica que els recursos del vostre sistema estan sobrecarregats. Considereu utilitzar menys càmeres o disminuir la taxa de fotogrames/resolució.",
+ "statsCurrentShort": "Temps de fotograma més recent i FPS corresponent.",
+ "statsCurrentLong": "Això mostra la mesura més recent de quant temps triga a processar un sol fotograma (en mil·lisegons) i els fotogrames per segon (FPS) equivalents. Temps de fotograma més baixos i FPS més alts indiquen un millor rendiment.",
+ "statsMinShort": "Temps de fotograma més ràpid (latència més baixa) i FPS més alt aconseguit.",
+ "statsMinLong": "Això representa el temps mínim necessari per processar un sol fotograma durant la finestra de mostreig. Això correspon al FPS màxim que el vostre sistema ha aconseguit en condicions òptimes.",
+ "statsMaxShort": "Temps de fotograma més lent (latència més alta) i FPS més baix experimentat.",
+ "statsMaxLong": "Això representa el temps màxim necessari per processar un sol fotograma durant la finestra de mostreig. Això correspon al FPS mínim que el vostre sistema ha aconseguit en les pitjors condicions. Els pics ocasionals són normals, però valors consistentment alts poden indicar problemes de rendiment.",
+ "statsMeanShort": "Temps de fotograma mitjà i FPS per a totes les mostres.",
+ "statsMeanLong": "La mitjana aritmètica de tots els temps de fotograma mesurats durant la finestra de mostreig i el FPS corresponent. Això dóna una bona imatge general del rendiment, però pot estar esbiaixat per valors atípics.",
+ "statsMedianShort": "Valor mitjà de tots els temps de fotograma (percentil 50).",
+ "statsMedianLong": "La mediana representa el valor mitjà quan tots els temps de fotograma s'ordenen del més ràpid al més lent. A diferència de la mitjana, la mediana no es veu afectada per valors atípics extrems, cosa que la fa un indicador més estable del rendiment típic.",
+ "statsStdDevShort": "Mesura la variabilitat del temps de fotograma. CV% és la variabilitat relativa.",
+ "statsStdDevLong": "La desviació estàndard mesura la quantitat de variació en els temps de fotograma. Valors més baixos indiquen un rendiment més consistent. El coeficient de variació (CV%) expressa aquesta variabilitat com a percentatge de la mitjana, facilitant la comparació de l'estabilitat entre diferents taxes de fotogrames. Un CV% més baix indica un rendiment més estable.",
+ "aiTranslatedTooltip": "Aquesta traducció ha estat generada per IA i pot contenir errors. Si parleu aquest idioma, podeu ajudar a millorar-la obrint una pull request a GitHub!",
+ "humanValidatedTooltip": "Aquesta traducció ha estat revisada i validada per un traductor humà.",
+ "helpTranslate": "Ajudeu a traduir SkellyCam",
+ "failedToFetch": "No s'ha pogut obtenir",
+ "recordings": "Enregistraments",
+ "noRecordingsFound": "No s'han trobat enregistraments. Introduïu un camí a dalt per carregar manualment.",
+ "noCamerasDetected": "No s'han detectat càmeres",
+ "clickRefreshToScan": "Feu clic a actualitzar per escanejar les càmeres disponibles",
+ "waitingForData": "Esperant dades…",
+ "load": "Carrega",
+ "refresh": "Actualitza",
+ "available": "Disponible",
+ "menuFile": "Fitxer",
+ "menuView": "Visualització",
+ "menuCamera": "Càmera",
+ "menuRecording": "Enregistrament",
+ "menuHelp": "Ajuda",
+ "menuDetectCameras": "Detectar càmeres",
+ "menuConnectCameras": "Connectar càmeres",
+ "menuCloseAllCameras": "Tanca totes les càmeres",
+ "menuOpenRecordingFolder": "Obre la carpeta d'enregistrament…",
+ "menuToggleSidebar": "Commuta la barra lateral",
+ "menuToggleTheme": "Canvia el tema",
+ "menuToggleFullScreen": "Pantalla completa",
+ "menuPauseUnpause": "Pausa / Reprèn",
+ "menuConnectApplySettings": "Connecta / Aplica configuració",
+ "menuCloseAll": "Tanca-ho tot",
+ "menuDocumentation": "Documentació",
+ "menuGitHubRepository": "Repositori GitHub",
+ "menuReportIssue": "Informar d'un problema…",
+ "menuAbout": "Sobre SkellyCam",
+ "menuPlayback": "Reproducció",
+ "videoPlayback": "Reproducció",
+ "copyLogsToClipboard": "Copiar registres al porta-retalls",
+ "saveLogsToFile": "Desar registres a fitxer",
+ "copied": "Copiat!",
+ "timestampFromRecording": "Marca de temps de les dades de gravació",
+ "menuCheckForUpdates": "Check for Updates…",
+ "updateAvailable": "Update available",
+ "updateAvailableMessage": "Version {{version}} is available",
+ "downloading": "Downloading…",
+ "downloadComplete": "Download complete",
+ "restartToUpdate": "Restart to update",
+ "checkForUpdates": "Check for Updates",
+ "upToDate": "You are up to date",
+ "updateError": "Update check failed"
+}
diff --git a/freemocap-ui-old/src/i18n/locales/chr-tsalagi.json b/freemocap-ui-old/src/i18n/locales/chr-tsalagi.json
new file mode 100644
index 00000000..e797b13a
--- /dev/null
+++ b/freemocap-ui-old/src/i18n/locales/chr-tsalagi.json
@@ -0,0 +1,258 @@
+{
+ "_meta": {
+ "locale": "chr",
+ "translationSource": "ai-generated",
+ "lastUpdated": "2026-02-24"
+ },
+ "appName": "SkellyCam",
+ "appNameDecorated": "SkellyCam 💀📸",
+ "welcomeTitle": "ᏙᎯᏱ SkellyCam",
+ "welcomeSubtitle": "ᏗᏓᎴᏂᏍᎬ ᎠᎴ ᎠᎦᏎᏍᏗ ᎤᎾᎵᎪᏒ ᏗᏓᏴᎳᏛᏍᎩ",
+ "sendAnonymousPings": "ᎠᏓᏅᏖᏗ ᎦᎸᎳᏗ ᎪᏪᎵᏍᎩ ᏗᎧᏃᎩᏍᏗ",
+ "footerWith": "ᎬᏗ",
+ "footerFrom": "ᎠᏓᎴᏂᏍᎬ",
+ "footerOrgName": "FreeMoCap Foundation",
+ "home": "ᎤᏪᏘ",
+ "cameras": "ᏗᏓᏴᎳᏛᏍᎩ",
+ "videos": "ᏗᏓᏴᎳᏛᏍᎩ",
+ "expandSidebar": "ᎠᏍᏚᎢᏍᏗ ᎠᎦᏍᎩ ᎦᏁᎸ",
+ "collapseSidebar": "ᎠᏍᏆᎵᏍᏗ ᎠᎦᏍᎩ ᎦᏁᎸ",
+ "startRecording": "ᏗᏓᎴᏂᏍᎬ ᎠᎴᏂᏙᎲ",
+ "stopRecording": "ᎠᎵᏍᏕᎸᏙᏗ ᏗᏓᎴᏂᏍᎬ",
+ "toggleTheme": "ᎠᏍᏓᏩᏛᏍᏗ ᎤᏙᏢᏒ",
+ "switchToDark": "ᎤᎵᏍᏓᏁᏗ ᎤᏲᏂ ᎤᏙᏢᏒ",
+ "switchToLight": "ᎤᎵᏍᏓᏁᏗ ᎢᎦ ᎡᎯ ᎤᏙᏢᏒ",
+ "connectWebSocket": "ᏓᏓᏂᎸᎢ WebSocket",
+ "disconnectWebSocket": "ᏓᏓᏂᎸᎢ ᎠᎵᏍᏕᎸᏙᏗ WebSocket",
+ "launchServer": "ᎠᎴᏂᏙᎲ ᎠᏍᏆᎵᏍᎩ",
+ "stopServer": "ᎠᎵᏍᏕᎸᏙᏗ ᎠᏍᏆᎵᏍᎩ",
+ "browseForExecutable": "ᎤᏴᏢ ᎠᏟᎶᏍᏗ",
+ "refreshCandidates": "ᎢᏤ ᎠᏟᎶᏍᏗ",
+ "executable": "ᎠᎵᏍᏚᎢᏍᏗ",
+ "host": "ᎠᏍᏆᎵᏍᎩ",
+ "port": "ᏧᎳᏍᏗ",
+ "cameraCount_one": "{{count}} ᏗᏓᏴᎳᏛᏍᎩ",
+ "cameraCount_other": "{{count}} ᏗᏓᏴᎳᏛᏍᎩ",
+ "connectedCameras": "ᏓᏓᏂᎸᎢ ᏗᏓᏴᎳᏛᏍᎩ",
+ "availableCameras": "ᎡᎵᏊ ᏗᏓᏴᎳᏛᏍᎩ",
+ "noCamerasConnected": "ᎥᏝ ᏗᏓᏴᎳᏛᏍᎩ ᏓᏓᏂᎸᎢ",
+ "detectCameras": "ᎤᏩᏌᏊ ᎡᎵᏊ ᏗᏓᏴᎳᏛᏍᎩ",
+ "clearCameraSettings": "ᏚᏍᏆᎸᎯᏍᏗ ᏗᏓᏴᎳᏛᏍᎩ ᏗᎧᏃᏗ",
+ "copySettingsToAll": "ᏗᎧᏃᏗ ᎠᏂᎩᏍᏗ ᏂᎦᏛ",
+ "recordingTag": "ᏗᏓᎴᏂᏍᎬ ᏓᏍᎪᎸᏓ",
+ "recordingTagPlaceholder": "ᎪᎱᏍᏗ ᏓᏍᎪᎸᏓ",
+ "recordingDirectory": "ᏗᏓᎴᏂᏍᎬ ᏗᎫᏓᎸᏗ",
+ "recordingFolderPath": "ᏗᏓᎴᏂᏍᎬ ᏗᎫᏓᎸᏗ ᏅᏃᎯ",
+ "delayStart": "ᎣᏏ ᎢᎦᏛ ᎠᎴᏂᏙᎲ",
+ "seconds": "ᎠᏎᏢ",
+ "subfolder": "ᎦᏛᎢ ᏗᎫᏓᎸᏗ",
+ "subfolderPlaceholder": "ᎦᏛᎢ ᏗᎫᏓᎸᏗ ᏧᏁᏨ",
+ "baseName": "ᎤᏟ ᏧᏁᏨ",
+ "increment": "ᎠᏓᏅᏗ",
+ "resolution": "ᎤᏙᏪᎸᏗ",
+ "fps": "FPS",
+ "width": "ᎤᏓᏟᏗ",
+ "height": "ᎦᎸᎳᏗ",
+ "columns": "ᏗᏂᏢᏒ",
+ "auto": "ᎤᏙᏢᏒ",
+ "manual": "ᎠᏏᏴᏫ ᎬᏗ",
+ "custom": "ᎠᏑᏰᏍᏗ",
+ "current": "ᎪᎯ ᎢᎦ",
+ "recommend": "ᎠᎵᏍᏓᏴᏗ",
+ "cameraRotation": "ᏗᏓᏴᎳᏛᏍᎩ ᎤᏂᏓᏛᎩ",
+ "selectCameraRotation": "ᎠᏑᏰᏍᏗ ᏗᏓᏴᎳᏛᏍᎩ ᎤᏂᏓᏛᎩ",
+ "exposureControl": "ᎤᏙᏢᏒ ᎠᎴ ᎠᏏᏴᏫ ᎠᏔᎴᏒ ᎤᏬᏢᏗ",
+ "framerateControl": "ᎤᏙᏢᏒ ᎠᎴ ᎠᏏᏴᏫ ᎤᏙᏪᎸᏗ ᎤᏬᏢᏗ",
+ "adjustExposure": "ᎠᏔᎴᏒ ᎢᎦᏛ ᎠᏍᏓᏩᏛᏍᏗ",
+ "setTargetFps": "ᎢᎦᏛ FPS ᎠᏍᏓᏅᏅ",
+ "recordingCaptureFps": "ᏗᏓᎴᏂᏍᎬ FPS",
+ "playbackSpeed": "ᎠᏔᎷᎩᏍᏗ ᎤᏂᎸᏉᏗ",
+ "framerateTimeline": "FPS ᎢᎦᏛ ᏅᏃᎯ",
+ "framerateDistribution": "FPS ᎤᏓᏔᏅ",
+ "timelineView": "ᎢᎦᏛ ᏅᏃᎯ ᎠᎦᏎᏍᏗ",
+ "distributionView": "ᎤᏓᏔᏅ ᎠᎦᏎᏍᏗ",
+ "combinedView": "ᏓᎾᎴᏂᏍᎬ ᎠᎦᏎᏍᏗ",
+ "min": "ᎤᏍᏗ",
+ "max": "ᎤᏔᎾ",
+ "mean": "ᎠᏰᎵ",
+ "median": "ᎠᏰᎵ ᎠᏎᏢ",
+ "stdDevCv": "ᎡᏍᏗ/CV",
+ "source": "ᎤᏙᎯᏴᏒ",
+ "selectAll": "ᏂᎦᏛ ᎠᏑᏰᏍᏗ",
+ "loadSynchronizedVideos": "ᎠᏫᏒᏗ ᎤᎾᎵᎪᏒ ᏗᏓᏴᎳᏛᏍᎩ",
+ "loadSynchronizedVideosDescription": "ᎯᎠ ᎠᏓᎴᏂᏍᎬᎢ ᏂᏓᏳᎵᏍᏔᏂ ᎤᎾᎵᎪᏒ ᏗᏓᏴᎳᏛᏍᎩ ᎠᏫᏒᏗ.",
+ "automaticallySynchronizeVideos": "ᎤᏙᏢᏒ ᎤᎾᎵᎪᏒ ᏗᏓᏴᎳᏛᏍᎩ",
+ "extractFramesOnLoad": "ᏗᏓᏟᎶᏍᏔᏅ ᎠᏫᏒᏗ",
+ "generateThumbnails": "ᎤᏍᏗᎢ ᏗᏓᏴᏁᎯ ᎠᎵᏍᏚᎢᏍᏗ",
+ "noVideosLoaded": "ᎥᏝ ᏗᏓᏴᎳᏛᏍᎩ ᎠᏫᏒᎢ",
+ "filterVideos": "ᏗᏓᏴᎳᏛᏍᎩ ᎠᏓᏱᏴᏍᏗ...",
+ "openVideo": "ᎠᏍᏚᎢᏍᏗ ᏗᏓᏴᎳᏛᏍᎩ",
+ "openFolder": "ᎠᏍᏚᎢᏍᏗ ᏗᎫᏓᎸᏗ",
+ "videoFolderPath": "ᏗᏓᏴᎳᏛᏍᎩ ᏗᎫᏓᎸᏗ ᏅᏃᎯ",
+ "jumpToStart": "ᎠᎴᏂᏙᎲ (Home)",
+ "jumpToEnd": "ᎠᎵᏍᏕᎸᏙᏗ (End)",
+ "loopOn": "ᎠᏕᎳᎰᏍᎩ ᎠᎴᏂᏙᎲᎢ (L ᎠᏓᏅᏖᏗ)",
+ "loopOff": "ᎠᏕᎳᎰᏍᎩ ᎠᎾᏗᏍᎬᎢ (L)",
+ "syncInfo": "ᏗᎦᎴᏴᏗ ᎪᏪᎵᎢ",
+ "syncInfoTitle": "ᎤᏍᏗ ᎧᏇᎳᏗ ᏗᎦᎴᏴᏗ ᎾᎥᎢ ᎤᏩᏒ ᏓᏟᎶᏍᏔᏅ ᎤᏙᎯᏳᎯ ᎨᏒᎢ",
+ "syncInfoBody": "ᎠᏕᎳᎰᏍᎩ ᏗᎾᏗᏍᎬᎢ ᎾᎥᎢ ᎤᏩᏒ ᏓᏟᎶᏍᏔᏅ ᎤᏙᎯᏳᎯ ᎨᏒᎢ ᎤᏍᏗ ᏗᏂᎧᎿᏩᏗᏙᎯ ᏚᏓᎴᎿᎥᎢ. ᎠᎾᏗᏍᎬᎢ ᎠᏯᏙᏗ-ᎠᏍᏆᏗ ᏚᎸᏫᏍᏓᏁᎲᎢ ᎠᎵᏍᎪᎸᏙᏗ ᎡᎳᏗ ᎤᏗᏗᎢ ᎤᏍᏆᏂᎪᏒ ᎢᎦ, ᎠᏎᏃ ᎢᎦᏛ ᎠᏍᏓᏩᏛᏍᏗ (1–2 ᏓᏟᎶᏍᏔᏅ) ᎢᏳᎵᏍᏙᏗ ᎨᏒᎢ. ᏓᏟᎶᏍᏔᏅ-ᎤᏙᎯᏳᎯ ᎠᏲᏓᏗᏍᏗ, ᎦᏅᎯᏓ ᎠᏟᎶᏍᏗ CSV ᏗᎪᏪᎵ ᎢᏗᎦᏘ ᏓᏍᏓᏅᏅᎢ.",
+ "previousFrame": "ᎢᎬᏱ ᏗᏓᏟᎶᏍᏔᏅ (← / Shift+← 10)",
+ "nextFrame": "ᎢᎦᏛ ᏗᏓᏟᎶᏍᏔᏅ (→ / Shift+→ 10)",
+ "zoomIn": "ᎠᏍᏚᎢᏍᏗ",
+ "zoomOut": "ᎠᏍᏆᎵᏍᏗ",
+ "resetZoom": "ᎢᏤ ᎠᏍᏚᎢᏍᏗ",
+ "playbackSettings": "ᎠᏔᎷᎩᏍᏗ ᏗᎧᏃᏗ",
+ "totalRecordingSize": "ᏗᏓᎴᏂᏍᎬ ᎤᏙᏪᎸᏗ",
+ "estimatedTime": "ᎤᏙᏪᎸᏗ ᎢᎦᏛ (ᏗᏓᏟᎶᏍᏔᏅ ÷ FPS)",
+ "estimatedDuration": "ᎤᏙᏪᎸᏗ ᎢᎦᏛ (ᏂᎦᏛ ᏗᏓᏟᎶᏍᏔᏅ ÷ FPS)",
+ "estimatedFromFrameNumber": "ᏗᏓᏟᎶᏍᏔᏅ ᏂᏓᏳᎵᏍᏔᏂ × FPS",
+ "frameCountPerCamera": "ᏗᏓᏟᎶᏍᏔᏅ ᏗᏓᏴᎳᏛᏍᎩ ᎢᏯᏓᏛ",
+ "cameraStreams": "ᏗᏓᏴᎳᏛᏍᎩ ᏗᎳᏏᏔᏍᏗ ᎯᎠ ᏗᏓᎴᏂᏍᎬ",
+ "backToRecordings": "ᏗᏓᎴᏂᏍᎬ ᎤᏪᏘ",
+ "errorsDetected": "ᏗᏍᎪᎵᏴᏓ ᎤᏩᏌᏊ",
+ "somethingWentWrong": "ᏙᏱᎩᏍᎬ ᎤᏲ ᎤᏙᏢᏒ :(",
+ "searchLogs": "ᏗᎧᏃᎩᏍᏗ ᎠᏟᎶᏍᏗ...",
+ "filter": "ᎠᏓᏱᏴᏍᏗ…",
+ "refreshMicrophoneList": "ᎢᏤ ᏗᎦᏬᏂᎯᏍᏗ ᏗᎧᏃᎩᏍᏗ",
+ "date": "ᎢᎦ ᎡᎯ",
+ "name": "ᏧᏁᏨ",
+ "size": "ᎤᏙᏪᎸᏗ",
+ "duration": "ᎢᎦᏛ",
+ "frames": "ᏗᏓᏟᎶᏍᏔᏅ",
+ "timestamp": "ᎢᎦᏛ ᏓᏍᎪᎸᏓ",
+ "language": "ᎦᏬᏂᎯᏍᏗ",
+ "aiTranslated": "AI ᎠᏁᏢᏔᏅ",
+ "humanTranslated": "ᏴᏫ ᎠᏁᏢᏔᏅ",
+ "humanValidated": "ᏴᏫ ᎤᏙᏪᎸᎢ",
+ "connectCameras": "ᏓᏓᏂᎸᎢ ᏗᏓᏴᎳᏛᏍᎩ",
+ "resumeStreaming": "ᎢᏤ ᏗᎳᏏᏔᏍᏗ",
+ "pauseStreaming": "ᏗᎳᏏᏔᏍᏗ ᎠᎵᏍᏕᎸᏙᏗ",
+ "closeAllCameras": "ᏂᎦᏛ ᏗᏓᏴᎳᏛᏍᎩ ᎠᏍᏆᎵᏍᏗ",
+ "framerate": "ᏗᏓᏟᎶᏍᏔᏅ ᎤᏂᎸᏉᏗ",
+ "exposure": "ᎠᏔᎴᏒ",
+ "fileLabel": "ᎠᏍᏓᏅᏅ",
+ "timeDelta": "ᎢᎦᏛ ᎤᏓᎴᎾ",
+ "pathLabel": "ᏅᏃᎯ",
+ "exceptionDetails": "ᏗᏍᎪᎵᏴᏓ ᏗᎧᏃᏗ",
+ "stackTrace": "ᏗᏍᎪᎵᏴᏓ ᏅᏃᎯ",
+ "loadingVideos": "ᏗᏓᏴᎳᏛᏍᎩ ᎠᏫᏒᏗ… ({{ready}}/{{total}} ᎡᎵᏊ)",
+ "gridColumns": "ᏗᏂᏢᏒ",
+ "settings": "ᏗᎧᏃᏗ",
+ "appearance": "ᎤᏙᏢᏒ",
+ "themeMode": "ᎤᏙᏢᏒ",
+ "darkMode": "ᎤᏲᏂ",
+ "lightMode": "ᎢᎦ ᎡᎯ",
+ "languageSettings": "ᎦᏬᏂᎯᏍᏗ ᎠᎴ ᎤᏙᏢᏒ",
+ "showTranslationIndicator": "ᎠᏁᏢᏔᏅ ᎤᏙᎯᏴᏒ ᎠᎦᏎᏍᏗ",
+ "showTranslationIndicatorDescription": "AI ᎠᏁᏢᏔᏅ ᏓᏍᎪᎸᏓ ᎠᎦᏎᏍᏗ",
+ "translationSourceLabel": "ᎠᏁᏢᏔᏅ ᎤᏙᎯᏴᏒ",
+ "general": "ᏂᎦᏛ",
+ "about": "ᏂᏛᏰᏍᎬ",
+ "version": "ᎤᏙᏪᎸᏗ",
+ "serverSettings": "ᎠᏍᏆᎵᏍᎩ",
+ "recordingSettings": "ᏗᏓᎴᏂᏍᎬ ᏗᎧᏃᏗ",
+ "videoLoadingSettings": "ᏗᏓᏴᎳᏛᏍᎩ ᎠᏫᏒᏗ ᏗᎧᏃᏗ",
+ "connected": "ᏓᏓᏂᎸᎢ",
+ "connecting": "ᏓᏓᏂᎸᎢ…",
+ "disconnected": "ᎥᏝ ᏓᏓᏂᎸᎢ",
+ "disconnect": "ᎠᎵᏍᏕᎸᏙᏗ",
+ "connect": "ᏓᏓᏂᎸᎢ",
+ "off": "ᎥᏝ",
+ "running": "ᎠᎾᎵᏐᏈ",
+ "stopped": "ᎠᎵᏍᏕᎸᏙᏗ",
+ "working": "ᎠᏛᏁᏗ…",
+ "invalid": "ᎥᏝ ᎣᏍᏛ",
+ "autoLaunch": "ᎤᏙᏢᏒ ᎠᎴᏂᏙᎲ",
+ "autoConnect": "ᎤᏙᏢᏒ ᏓᏓᏂᎸᎢ",
+ "runningPath": "ᎠᎾᎵᏐᏈ: {{path}}",
+ "noMicrophone": "ᎥᏝ ᏗᎦᏬᏂᎯᏍᏗ",
+ "audioRecordingEnabled": "ᎦᏬᏂᎯᏍᏗ ᏗᏓᎴᏂᏍᎬ ᎠᎴᏂᏙᎲ",
+ "noMicrophoneSelected": "ᎥᏝ ᏗᎦᏬᏂᎯᏍᏗ ᎠᏑᏰᏍᏗ",
+ "recordingName": "ᏗᏓᎴᏂᏍᎬ ᏧᏁᏨ: {{name}}",
+ "startingIn": "ᎠᎴᏂᏙᎲ {{countdown}}…",
+ "stopping": "ᎠᎵᏍᏕᎸᏙᏗ…",
+ "starting": "ᎠᎴᏂᏙᎲ…",
+ "stopRecordingButton": "🔴 ᎠᎵᏍᏕᎸᏙᏗ ᏗᏓᎴᏂᏍᎬ",
+ "startRecordingButton": "🔴 ᎠᎴᏂᏙᎲ ᏗᏓᎴᏂᏍᎬ",
+ "camerasCount": "ᏗᏓᏴᎳᏛᏍᎩ ({{count}})",
+ "availableCamerasCount": "ᎡᎵᏊ ({{count}})",
+ "server": "ᎠᏍᏆᎵᏍᎩ",
+ "display": "ᎠᎦᏎᏍᏗ",
+ "rawMessage": "ᎡᏆ ᎧᏃᎮᏛ",
+ "cameraPerformanceMetrics": "ᏗᏓᏴᎳᏛᏍᎩ ᏗᏙᏪᎵᏍᎩ",
+ "serverLogs": "ᎠᏍᏆᎵᏍᎩ ᏗᎧᏃᎩᏍᏗ",
+ "sortBy": "ᏗᎾᏢᏗ {{direction}}",
+ "waitingForCameraStreams": "ᏗᏓᏴᎳᏛᏍᎩ ᏗᎳᏏᏔᏍᏗ ᎠᏓᏙᎵᏍᏗ…",
+ "loggingPaused": "ᏗᎧᏃᎩᏍᏗ ᎠᎵᏍᏕᎸᏙᏗ",
+ "noLogsToDisplay": "ᎥᏝ ᏗᎧᏃᎩᏍᏗ ᎠᎦᏎᏍᏗ",
+ "closeSettings": "ᏗᎧᏃᏗ ᎠᏍᏆᎵᏍᏗ",
+ "gridSettings": "ᏗᏂᏢᏒ ᏗᎧᏃᏗ",
+ "clickToShowLess": "ᎠᏍᏆᎵᏍᏗ ᎠᎦᏎᏍᏗ",
+ "clickToLearnMore": "ᎢᏧᎳᎭ ᎠᏟᎶᏍᏗ",
+ "samples": "ᏗᏙᏪᎵᏍᎩ",
+ "framerateOverTime": "FPS ᎢᎦᏛ ᎢᏳᎾᏛᏗ",
+ "framerateFps": "ᏗᏓᏟᎶᏍᏔᏅ ᎤᏂᎸᏉᏗ (fps)",
+ "capturesFramesFromCamera": "ᏗᏓᏴᎳᏛᏍᎩ ᏗᏓᏟᎶᏍᏔᏅ ᎦᏂᏱᏍᎩ.",
+ "rendersReceivedFrames": "ᏗᏓᏟᎶᏍᏔᏅ ᎠᎦᏎᏍᏗ.",
+ "displayTooltipLong": "ᎠᎦᏎᏍᏗ ᎤᏙᏢᏒ UI ᏗᏙᏪᎵᏍᎩ ᎠᎦᏎᏍᏗ. ᏓᏍᎪᎸᏓ ᎾᏍᎩ ᏚᏳᎪᏛ ᎢᎦᏛ ᏗᏓᏟᎶᏍᏔᏅ ᎤᏂᎷᏤ ᎠᎦᏎᏍᏗ. ᎠᏍᏓᏩᏛᏍᏗ ᎠᎴ ᏗᏓᏟᎶᏍᏔᏅ ᏄᎵᏍᏔᏅ ᎥᏝ ᏱᏓᏟᎶᏍᏔᏅ ᏗᎪᏪᎵ ᎤᏩᏒ ᏧᎵᎬᏩᏗᏒᎢ ᎠᏎᏃ ᎤᎵᏍᏕᎸᏗ ᎨᏒᎢ ᎤᏍᏗ ᏗᏓᏴᎳᏛᏍᎩ ᎠᎦᏎᏍᏗ ᏂᎦᏛ ᎢᎦᏛ.",
+ "statsSourceShort": "ᎠᎦᏎᏍᏗ ᏗᏓᏟᎶᏍᏔᏅ ᎠᎦᏎᏍᏗ, ᎠᏍᏆᎵᏍᎩ ᏗᏓᏟᎶᏍᏔᏅ ᎦᏂᏱᏍᎩ.",
+ "statsSourceLong": "ᎠᏍᏆᎵᏍᎩ ᎨᏒᎢ ᏗᏓᏴᎳᏛᏍᎩ ᎤᏙᏢᏒ ᏗᏓᏟᎶᏍᏔᏅ ᎤᏂᎸᏉᏗ, ᎠᎦᏎᏍᏗ ᎨᏒᎢ ᎾᏍᎩ ᎤᏂᎷᏤ ᎠᎦᏎᏍᏗ ᎤᏂᎸᏉᏗ. SkellyCam ᏗᏓᎴᏂᏍᎬ ᎤᏙᏢᏒ ᎠᏍᏆᎵᏍᎩ ᎤᏙᏢᏒ ᏧᎵᎬᏩᏗᏒᎢ, ᎾᏍᎩ ᏗᏎᏍᏗ ᎤᏟ ᎤᏩᏒ ᎤᎵᏍᏕᎸᏗ. ᎠᎦᏎᏍᏗ FPS ᏓᏍᏓᏅᏅ ᎠᏍᏆᎵᏍᎩ, ᏄᎵᏍᏔᏅ ᎨᏒᎢ ᎢᏤ ᏗᏙᏪᎵᏍᎩ ᏚᎸᏫᏍᏓᏁᎲᎢ. ᎤᏍᏗ ᏗᏓᏴᎳᏛᏍᎩ ᏚᎸᏫᏍᏓᏁᎯ ᎠᎴ ᎤᏍᏗ FPS/ᏗᏙᏪᎵᏍᎩ ᎠᏍᏓᏅᏅᎢ.",
+ "statsCurrentShort": "ᎪᎯ ᏗᏓᏟᎶᏍᏔᏅ ᎢᎦᏛ ᎠᎴ FPS.",
+ "statsCurrentLong": "ᎯᎠ ᏓᏍᎪᎸᏓ ᏗᏓᏟᎶᏍᏔᏅ ᎢᎦᏛ ᏗᏙᏪᎵᏍᎩ ᏌᏊ ᏓᏟᎶᏍᏔᏅ (ᏗᎳᏏᏔᏛ) ᎠᎴ FPS. ᎤᏍᏗ ᏗᏓᏟᎶᏍᏔᏅ ᎢᎦᏛ ᎠᎴ ᎤᏔᎾ FPS ᎤᏙᏢᏒ ᎣᏍᏛ ᏗᏙᏪᎵᏍᎩ ᎠᎦᏎᏍᏗ.",
+ "statsMinShort": "ᎤᏓᏂᎳᏅ ᏗᏓᏟᎶᏍᏔᏅ ᎢᎦᏛ ᎠᎴ ᎤᏔᎾ FPS.",
+ "statsMinLong": "ᎯᎠ ᎤᏍᏗ ᏗᏓᏟᎶᏍᏔᏅ ᎢᎦᏛ ᏌᏊ ᏓᏟᎶᏍᏔᏅ ᏗᏙᏪᎵᏍᎩ ᏚᎸᏫᏍᏓᏁᎲᎢ. ᎯᎠ ᎤᏔᎾ FPS ᎢᏤ ᏗᏙᏪᎵᏍᎩ ᎣᏍᏛ ᏄᎵᏍᏔᏅ ᎠᏍᏓᏅᏅᎢ.",
+ "statsMaxShort": "ᏗᎵᏲᎢ ᏗᏓᏟᎶᏍᏔᏅ ᎢᎦᏛ ᎠᎴ ᎤᏍᏗ FPS.",
+ "statsMaxLong": "ᎯᎠ ᎤᏔᎾ ᏗᏓᏟᎶᏍᏔᏅ ᎢᎦᏛ ᏌᏊ ᏓᏟᎶᏍᏔᏅ ᏗᏙᏪᎵᏍᎩ ᏚᎸᏫᏍᏓᏁᎲᎢ. ᎯᎠ ᎤᏍᏗ FPS ᎤᏓᎴᎾ ᏄᎵᏍᏔᏅ ᎠᏍᏓᏅᏅᎢ. ᎢᎸᏍᎩ ᎤᏔᎾ ᏗᏙᏪᎵᏍᎩ ᎣᏍᏛ ᎨᏒᎢ, ᎠᏎᏃ ᏂᎦᏛ ᎤᏔᎾ ᏗᏙᏪᎵᏍᎩ ᎠᏍᏓᏩᏛᏍᏗ ᎢᏳᎵᏍᏙᏗ ᎨᏒᎢ.",
+ "statsMeanShort": "ᎠᏰᎵ ᏗᏓᏟᎶᏍᏔᏅ ᎢᎦᏛ ᎠᎴ FPS.",
+ "statsMeanLong": "ᏂᎦᏛ ᏗᏓᏟᎶᏍᏔᏅ ᎢᎦᏛ ᎠᏰᎵ ᎠᎴ FPS ᏚᎸᏫᏍᏓᏁᎲᎢ. ᎯᎠ ᎣᏍᏛ ᏗᏙᏪᎵᏍᎩ ᎠᎦᏎᏍᏗ ᎠᏎᏃ ᎤᏓᎴᎾ ᏗᏙᏪᎵᏍᎩ ᏗᏍᏓᏩᏛᏍᏗ ᎢᏳᎵᏍᏙᏗ ᎨᏒᎢ.",
+ "statsMedianShort": "ᎠᏰᎵ ᎠᏎᏢ ᏗᏓᏟᎶᏍᏔᏅ ᎢᎦᏛ.",
+ "statsMedianLong": "ᎠᏰᎵ ᎠᏎᏢ ᎨᏒᎢ ᏂᎦᏛ ᏗᏓᏟᎶᏍᏔᏅ ᎢᎦᏛ ᏗᏍᏓᏩᏛᏍᏗ ᎤᏍᏗ ᎤᏔᎾ. ᎠᏰᎵ ᎥᏝ ᏓᏍᏓᏩᏛᏍᏗ ᎤᏔᎾ ᏗᏙᏪᎵᏍᎩ, ᎤᏟ ᎤᏩᏒ ᏗᏙᏪᎵᏍᎩ ᎠᏍᏓᏅᏅᎢ.",
+ "statsStdDevShort": "ᏗᏓᏟᎶᏍᏔᏅ ᎢᎦᏛ ᎤᏓᎴᎾ ᏗᏙᏪᎵᏍᎩ.",
+ "statsStdDevLong": "ᎤᏓᎴᎾ ᏗᏙᏪᎵᏍᎩ ᏗᏓᏟᎶᏍᏔᏅ ᎢᎦᏛ ᎤᏓᎴᎾ ᏗᏍᏓᏩᏛᏍᏗ. ᎤᏍᏗ ᏗᏙᏪᎵᏍᎩ ᎤᏟ ᎤᏩᏒ ᎤᎵᏍᏕᎸᏗ ᎠᎦᏎᏍᏗ. CV% ᏄᎵᏍᏔᏅ ᎠᏰᎵ ᏗᏓᎴᎾ ᏗᏙᏪᎵᏍᎩ ᏚᎸᏫᏍᏓᏁᎲᎢ, ᎤᏍᏗ CV% ᎤᏟ ᎤᏩᏒ ᏗᏙᏪᎵᏍᎩ ᎠᎦᏎᏍᏗ.",
+ "aiTranslatedTooltip": "ᎯᎠ ᎠᏁᏢᏔᏅ AI ᎬᏗ ᎢᎬᏁᏗ ᎠᎴ ᏗᏍᎪᎵᏴᏓ ᎪᎱᏍᏗ. ᎯᎠ ᎦᏬᏂᎯᏍᏗ ᎨᏒ, ᎢᏍᏓᏍᏗ ᎢᎩᏍᏗᏱ GitHub!",
+ "humanValidatedTooltip": "ᎯᎠ ᎠᏁᏢᏔᏅ ᏴᏫ ᎠᏁᏢᏔᏅᎩ ᎤᏙᏪᎸᎢ.",
+ "helpTranslate": "ᎢᏍᏓᏍᏗ SkellyCam ᎠᏁᏢᏔᏅ",
+ "failedToFetch": "ᎥᏝ ᎬᏩᎵᏓ ᎠᏫᏒᏗ",
+ "recordings": "ᏗᏓᎴᏂᏍᎬ",
+ "noRecordingsFound": "ᎥᏝ ᏗᏓᎴᏂᏍᎬ ᎤᏩᏌᏊ. ᏅᏃᎯ ᏂᏓᏳᎵᏍᏔᏂ ᎠᏫᏒᏗ.",
+ "noCamerasDetected": "ᎥᏝ ᏗᏓᏴᎳᏛᏍᎩ ᎤᏩᏌᏊ",
+ "clickRefreshToScan": "ᎢᏤ ᎠᏟᎶᏍᏗ ᏗᏓᏴᎳᏛᏍᎩ ᎤᏩᏌᏊ",
+ "waitingForData": "ᏗᎧᏃᎩᏍᏗ ᎠᏓᏙᎵᏍᏗ…",
+ "load": "ᎠᏫᏒᏗ",
+ "refresh": "ᎢᏤ",
+ "available": "ᎡᎵᏊ",
+ "menuFile": "ᎠᏍᏓᏅᏅ",
+ "menuView": "ᎠᎦᏎᏍᏗ",
+ "menuCamera": "ᏗᏓᏴᎳᏛᏍᎩ",
+ "menuRecording": "ᏗᏓᎴᏂᏍᎬ",
+ "menuHelp": "ᎢᏍᏓᏍᏗ",
+ "menuDetectCameras": "ᏗᏓᏴᎳᏛᏍᎩ ᎤᏩᏌᏊ",
+ "menuConnectCameras": "ᏗᏓᏴᎳᏛᏍᎩ ᏓᏓᏂᎸᎢ",
+ "menuCloseAllCameras": "ᏂᎦᏛ ᏗᏓᏴᎳᏛᏍᎩ ᎠᏍᏆᎵᏍᏗ",
+ "menuOpenRecordingFolder": "ᏗᏓᎴᏂᏍᎬ ᏗᎫᏓᎸᏗ ᎠᏍᏚᎢᏍᏗ…",
+ "menuToggleSidebar": "ᎠᎦᏍᎩ ᎦᏁᎸ ᎠᏍᏓᏩᏛᏍᏗ",
+ "menuToggleTheme": "ᎤᏙᏢᏒ ᎠᏍᏓᏩᏛᏍᏗ",
+ "menuToggleFullScreen": "ᏂᎦᏛ ᎠᎦᏎᏍᏗ",
+ "menuPauseUnpause": "ᎠᎵᏍᏕᎸᏙᏗ / ᎢᏤ",
+ "menuConnectApplySettings": "ᏓᏓᏂᎸᎢ / ᏗᎧᏃᏗ ᎠᏓᏅᏖᏗ",
+ "menuCloseAll": "ᏂᎦᏛ ᎠᏍᏆᎵᏍᏗ",
+ "menuDocumentation": "ᏗᎪᏪᎵ",
+ "menuGitHubRepository": "GitHub ᏗᎫᏓᎸᏗ",
+ "menuReportIssue": "ᏗᏍᎪᎵᏴᏓ ᎧᏃᎮᏛ…",
+ "menuAbout": "ᏂᏛᏰᏍᎬ SkellyCam",
+ "menuPlayback": "ᎠᏔᎷᎩᏍᏗ",
+ "videoPlayback": "ᎠᏔᎷᎩᏍᏗ",
+ "copyLogsToClipboard": "ᏗᎧᏃᎩᏍᏗ ᎠᏂᎩᏍᏗ",
+ "saveLogsToFile": "ᏗᎧᏃᎩᏍᏗ ᎠᏍᏓᏅᏅ ᎠᏍᏓᏅᏅ",
+ "copied": "ᎠᏂᎩᏍᏗ!",
+ "timestampFromRecording": "ᎢᎦᏛ ᏓᏍᎪᎸᏓ ᏗᏓᎴᏂᏍᎬ ᏗᎧᏃᎩᏍᏗ",
+ "menuCheckForUpdates": "Check for Updates…",
+ "updateAvailable": "Update available",
+ "updateAvailableMessage": "Version {{version}} is available",
+ "downloading": "Downloading…",
+ "downloadComplete": "Download complete",
+ "restartToUpdate": "Restart to update",
+ "checkForUpdates": "Check for Updates",
+ "upToDate": "You are up to date",
+ "updateError": "Update check failed"
+}
diff --git a/freemocap-ui-old/src/i18n/locales/cs-cestina.json b/freemocap-ui-old/src/i18n/locales/cs-cestina.json
new file mode 100644
index 00000000..bba63684
--- /dev/null
+++ b/freemocap-ui-old/src/i18n/locales/cs-cestina.json
@@ -0,0 +1,258 @@
+{
+ "_meta": {
+ "locale": "cs",
+ "translationSource": "ai-generated",
+ "lastUpdated": "2026-02-23"
+ },
+ "appName": "SkellyCam",
+ "appNameDecorated": "SkellyCam 💀📸",
+ "welcomeTitle": "Vítejte v SkellyCam",
+ "welcomeSubtitle": "Nahrávejte a prohlížejte synchronizovaná videa",
+ "sendAnonymousPings": "Odesílat anonymní data o využití",
+ "footerWith": "s",
+ "footerFrom": "od",
+ "footerOrgName": "FreeMoCap Foundation",
+ "home": "Domů",
+ "cameras": "Kamery",
+ "videos": "Videa",
+ "expandSidebar": "Rozbalit postranní panel",
+ "collapseSidebar": "Sbalit postranní panel",
+ "startRecording": "Zahájit nahrávání",
+ "stopRecording": "Zastavit nahrávání",
+ "toggleTheme": "přepnout motiv",
+ "switchToDark": "Přepnout na tmavý režim",
+ "switchToLight": "Přepnout na světlý režim",
+ "connectWebSocket": "Připojit WebSocket",
+ "disconnectWebSocket": "Odpojit WebSocket",
+ "launchServer": "Spustit server",
+ "stopServer": "Zastavit server",
+ "browseForExecutable": "Vyhledat spustitelný soubor",
+ "refreshCandidates": "Obnovit kandidáty",
+ "executable": "Spustitelný soubor",
+ "host": "Hostitel",
+ "port": "Port",
+ "cameraCount_one": "{{count}} kamera",
+ "cameraCount_other": "{{count}} kamer",
+ "connectedCameras": "Připojené kamery",
+ "availableCameras": "Dostupné kamery",
+ "noCamerasConnected": "Žádné kamery nejsou připojeny",
+ "detectCameras": "Detekovat dostupné kamery",
+ "clearCameraSettings": "Vymazat nastavení kamer",
+ "copySettingsToAll": "Kopírovat nastavení na všechny",
+ "recordingTag": "Značka nahrávání",
+ "recordingTagPlaceholder": "Volitelná značka",
+ "recordingDirectory": "Adresář nahrávání",
+ "recordingFolderPath": "Cesta složky nahrávání",
+ "delayStart": "Opožděný start",
+ "seconds": "Sekundy",
+ "subfolder": "Podsložka",
+ "subfolderPlaceholder": "Název podsložky",
+ "baseName": "Základní název",
+ "increment": "Přírůstek",
+ "resolution": "Rozlišení",
+ "fps": "FPS",
+ "width": "Šířka",
+ "height": "Výška",
+ "columns": "Sloupce",
+ "auto": "Auto",
+ "manual": "Ruční",
+ "custom": "Vlastní",
+ "current": "Aktuální",
+ "recommend": "Doporučeno",
+ "cameraRotation": "rotace kamery",
+ "selectCameraRotation": "Vybrat rotaci obrazu kamery",
+ "exposureControl": "Automatické nebo ruční řízení expozice",
+ "framerateControl": "Automatické nebo ruční řízení snímkové frekvence",
+ "adjustExposure": "Upravit dobu expozice",
+ "setTargetFps": "Nastavit cílové FPS pro snímání",
+ "recordingCaptureFps": "FPS záznamu",
+ "playbackSpeed": "Rychlost přehrávání",
+ "framerateTimeline": "Časová osa snímkové frekvence",
+ "framerateDistribution": "Distribuce snímkové frekvence",
+ "timelineView": "Zobrazení časové osy",
+ "distributionView": "Zobrazení distribuce",
+ "combinedView": "Kombinované zobrazení",
+ "min": "Min",
+ "max": "Max",
+ "mean": "Průměr",
+ "median": "Medián",
+ "stdDevCv": "SmOdch/CV",
+ "source": "Zdroj",
+ "selectAll": "Vybrat vše",
+ "loadSynchronizedVideos": "Načíst synchronizovaná videa",
+ "loadSynchronizedVideosDescription": "Tato stránka vám umožní načíst a synchronizovat předem nahraná videa.",
+ "automaticallySynchronizeVideos": "Automaticky synchronizovat videa",
+ "extractFramesOnLoad": "Extrahovat snímky při načítání",
+ "generateThumbnails": "Generovat náhledy",
+ "noVideosLoaded": "Žádná videa nenačtena",
+ "filterVideos": "Filtrovat videa...",
+ "openVideo": "Otevřít video",
+ "openFolder": "Otevřít složku v průzkumníku",
+ "videoFolderPath": "Cesta složky videí",
+ "jumpToStart": "Na začátek (Home)",
+ "jumpToEnd": "Na konec (End)",
+ "loopOn": "Smyčka je zapnutá (L pro přepnutí)",
+ "loopOff": "Smyčkové přehrávání (L)",
+ "syncInfo": "Informace o synchronizaci",
+ "syncInfoTitle": "Synchronizace více kamer nemusí být přesná na úrovni snímků",
+ "syncInfoBody": "Přehrávání videa v prohlížeči nezaručuje přesnou synchronizaci vzorků napříč více proudy. Přehrávač používá strategii vůdce-následovník a opravuje odchylku, když překročí malou toleranci, ale může dojít k drobné desynchronizaci (1–2 snímky), zejména při vysokých rychlostech přehrávání nebo při zatížení prohlížeče. Pro analýzu přesnou na úrovni snímků použijte surové CSV soubory s časovými značkami zahrnuté v každém záznamu.",
+ "previousFrame": "Předchozí snímek (← / Shift+← pro 10)",
+ "nextFrame": "Další snímek (→ / Shift+→ pro 10)",
+ "zoomIn": "Přiblížit",
+ "zoomOut": "Oddálit",
+ "resetZoom": "Obnovit přiblížení",
+ "playbackSettings": "Nastavení přehrávání",
+ "totalRecordingSize": "Celková velikost záznamu na disku",
+ "estimatedTime": "Odhadovaný čas (snímek ÷ fps)",
+ "estimatedDuration": "Odhadovaná délka (celkem snímků ÷ fps)",
+ "estimatedFromFrameNumber": "Odhadnuto z čísla snímku × fps",
+ "frameCountPerCamera": "Počet snímků na kameru",
+ "cameraStreams": "Proudy kamer v tomto záznamu",
+ "backToRecordings": "Zpět k nahrávkám",
+ "errorsDetected": "Zjištěny chyby",
+ "somethingWentWrong": "Něco se pokazilo :(",
+ "searchLogs": "Hledat v záznamech...",
+ "filter": "Filtrovat…",
+ "refreshMicrophoneList": "Obnovit seznam mikrofonů",
+ "date": "Datum",
+ "name": "Název",
+ "size": "Velikost",
+ "duration": "Délka",
+ "frames": "Snímky",
+ "timestamp": "Časové razítko",
+ "language": "Jazyk",
+ "aiTranslated": "AI překlad",
+ "humanTranslated": "Lidský překlad",
+ "humanValidated": "Ověřeno člověkem",
+ "connectCameras": "Připojit vybrané kamery",
+ "resumeStreaming": "Pokračovat ve streamování",
+ "pauseStreaming": "Pozastavit streamování",
+ "closeAllCameras": "Zavřít všechny kamery",
+ "framerate": "Snímková frekvence",
+ "exposure": "Expozice",
+ "fileLabel": "Soubor",
+ "timeDelta": "Časový rozdíl",
+ "pathLabel": "Cesta",
+ "exceptionDetails": "Podrobnosti výjimky",
+ "stackTrace": "Zásobník volání",
+ "loadingVideos": "Načítání videí… ({{ready}}/{{total}} připraveno)",
+ "gridColumns": "Sloupce mřížky",
+ "settings": "Nastavení",
+ "appearance": "Vzhled",
+ "themeMode": "Motiv",
+ "darkMode": "Tmavý",
+ "lightMode": "Světlý",
+ "languageSettings": "Jazyk a lokalizace",
+ "showTranslationIndicator": "Zobrazit indikátor zdroje překladu",
+ "showTranslationIndicatorDescription": "Zobrazit odznak u AI překladů",
+ "translationSourceLabel": "Zdroj překladu",
+ "general": "Obecné",
+ "about": "O aplikaci",
+ "version": "Verze",
+ "serverSettings": "Server",
+ "recordingSettings": "Nastavení nahrávání",
+ "videoLoadingSettings": "Nastavení načítání videí",
+ "connected": "Připojeno",
+ "connecting": "Připojování…",
+ "disconnected": "Odpojeno",
+ "disconnect": "Odpojit",
+ "connect": "Připojit",
+ "off": "Vypnuto",
+ "running": "Běží",
+ "stopped": "Zastaveno",
+ "working": "Zpracování…",
+ "invalid": "Neplatný",
+ "autoLaunch": "Automatické spuštění",
+ "autoConnect": "Automatické připojení",
+ "runningPath": "Běží: {{path}}",
+ "noMicrophone": "Žádný mikrofon",
+ "audioRecordingEnabled": "Nahrávání zvuku aktivováno",
+ "noMicrophoneSelected": "Mikrofon není vybrán",
+ "recordingName": "Název nahrávání: {{name}}",
+ "startingIn": "Start za {{countdown}}...",
+ "stopping": "Zastavování...",
+ "starting": "Spouštění...",
+ "stopRecordingButton": "🔴 Zastavit nahrávání",
+ "startRecordingButton": "🔴 Zahájit nahrávání",
+ "camerasCount": "Kamery ({{count}})",
+ "availableCamerasCount": "Dostupné ({{count}})",
+ "server": "Server",
+ "display": "Zobrazení",
+ "rawMessage": "Surová zpráva",
+ "cameraPerformanceMetrics": "Metriky výkonu kamer",
+ "serverLogs": "Serverové záznamy",
+ "sortBy": "Řadit {{direction}}",
+ "waitingForCameraStreams": "Čekání na proudy z kamer...",
+ "loggingPaused": "Protokolování pozastaveno",
+ "noLogsToDisplay": "Žádné záznamy k zobrazení",
+ "closeSettings": "Zavřít nastavení",
+ "gridSettings": "Nastavení mřížky",
+ "clickToShowLess": "Klikněte pro skrytí",
+ "clickToLearnMore": "Klikněte pro více informací",
+ "samples": "vzorků",
+ "framerateOverTime": "Snímková frekvence v čase",
+ "framerateFps": "Snímková frekvence (fps)",
+ "capturesFramesFromCamera": "Snímá snímky z kamery.",
+ "rendersReceivedFrames": "Vykresluje přijaté snímky na obrazovce.",
+ "displayTooltipLong": "Zobrazení představuje výkon vykreslování uživatelského rozhraní. Ukazuje, jak rychle váš displej přijímá a vykresluje snímky. Problémy s výkonem zde neovlivní kvalitu záznamu, ale mohou ovlivnit vaši schopnost sledovat kamery v reálném čase.",
+ "statsSourceShort": "Displej vykresluje snímky, server je snímá.",
+ "statsSourceLong": "Server je skutečná rychlost, kterou jsou snímky stahovány/zaznamenávány z kamery, zatímco zobrazení je rychlost, kterou jsou přijímány a vykreslovány. SkellyCam upřednostňuje výkon na straně serveru pro kvalitu záznamu, takže toto číslo by mělo zůstat stabilnější. Pokud se snímková frekvence zobrazení liší od serveru, znamená to, že systémové zdroje jsou přetíženy. Zvažte použití méně kamer nebo snížení snímkové frekvence/rozlišení.",
+ "statsCurrentShort": "Nejnovější čas snímku a FPS.",
+ "statsCurrentLong": "Zobrazuje nejnovější měření doby zpracování jednoho snímku (v milisekundách) a odpovídající počet snímků za sekundu (FPS). Nižší časy snímků a vyšší FPS značí lepší výkon.",
+ "statsMinShort": "Nejrychlejší čas snímku a nejvyšší FPS.",
+ "statsMinLong": "Představuje minimální dobu zpracování jednoho snímku během okna vzorkování. Odpovídá maximálnímu FPS, kterého váš systém dosáhl za optimálních podmínek.",
+ "statsMaxShort": "Nejpomalejší čas snímku a nejnižší FPS.",
+ "statsMaxLong": "Představuje maximální dobu zpracování jednoho snímku během okna vzorkování. Odpovídá minimálnímu FPS za nejhorších podmínek. Občasné špičky jsou normální, ale trvale vysoké hodnoty mohou naznačovat problémy s výkonem.",
+ "statsMeanShort": "Průměrný čas snímku a FPS ze všech vzorků.",
+ "statsMeanLong": "Aritmetický průměr všech naměřených časů snímků během okna vzorkování a odpovídající FPS. Poskytuje dobrý celkový obraz o výkonu, ale může být zkreslen odlehlými hodnotami.",
+ "statsMedianShort": "Medián všech časů snímků (50. percentil).",
+ "statsMedianLong": "Medián představuje střední hodnotu, když jsou všechny časy snímků seřazeny od nejrychlejšího po nejpomalejší. Na rozdíl od průměru není medián ovlivněn extrémními odlehlými hodnotami, což z něj činí stabilnější ukazatel typického výkonu.",
+ "statsStdDevShort": "Měří variabilitu časů snímků. CV% je relativní.",
+ "statsStdDevLong": "Směrodatná odchylka měří míru rozptylu v časech snímků. Nižší hodnoty značí konzistentnější výkon. Koeficient variace (CV%) vyjadřuje tuto proměnlivost jako procento průměru, což usnadňuje porovnání stability napříč různými snímkovými frekvencemi. Nižší CV% značí stabilnější výkon.",
+ "aiTranslatedTooltip": "Tento překlad byl vytvořen umělou inteligencí a může obsahovat chyby. Pokud mluvíte tímto jazykem, pomozte nám jej vylepšit!",
+ "humanValidatedTooltip": "Tento překlad byl ověřen lidským překladatelem.",
+ "helpTranslate": "Pomozte přeložit SkellyCam",
+ "failedToFetch": "Nepodařilo se načíst",
+ "recordings": "Nahrávky",
+ "noRecordingsFound": "Nebyly nalezeny žádné nahrávky. Zadejte cestu výše pro ruční načtení.",
+ "noCamerasDetected": "Nebyly detekovány žádné kamery",
+ "clickRefreshToScan": "Klikněte na obnovit pro vyhledání kamer",
+ "waitingForData": "Čekání na data…",
+ "load": "Načíst",
+ "refresh": "Obnovit",
+ "available": "Dostupná",
+ "menuFile": "Soubor",
+ "menuView": "Zobrazení",
+ "menuCamera": "Kamera",
+ "menuRecording": "Nahrávání",
+ "menuHelp": "Nápověda",
+ "menuDetectCameras": "Detekovat kamery",
+ "menuConnectCameras": "Připojit kamery",
+ "menuCloseAllCameras": "Zavřít všechny kamery",
+ "menuOpenRecordingFolder": "Otevřít složku nahrávek…",
+ "menuToggleSidebar": "Přepnout postranní panel",
+ "menuToggleTheme": "Přepnout motiv",
+ "menuToggleFullScreen": "Celá obrazovka",
+ "menuPauseUnpause": "Pozastavit / Obnovit",
+ "menuConnectApplySettings": "Připojit / Použít nastavení",
+ "menuCloseAll": "Zavřít vše",
+ "menuDocumentation": "Dokumentace",
+ "menuGitHubRepository": "GitHub repozitář",
+ "menuReportIssue": "Nahlásit problém…",
+ "menuAbout": "O aplikaci SkellyCam",
+ "menuPlayback": "Přehrávání",
+ "videoPlayback": "Přehrávání",
+ "copyLogsToClipboard": "Kopírovat logy do schránky",
+ "saveLogsToFile": "Uložit logy do souboru",
+ "copied": "Zkopírováno!",
+ "timestampFromRecording": "Časové razítko z dat nahrávky",
+ "menuCheckForUpdates": "Check for Updates…",
+ "updateAvailable": "Update available",
+ "updateAvailableMessage": "Version {{version}} is available",
+ "downloading": "Downloading…",
+ "downloadComplete": "Download complete",
+ "restartToUpdate": "Restart to update",
+ "checkForUpdates": "Check for Updates",
+ "upToDate": "You are up to date",
+ "updateError": "Update check failed"
+}
diff --git a/freemocap-ui-old/src/i18n/locales/de-deutsch.json b/freemocap-ui-old/src/i18n/locales/de-deutsch.json
new file mode 100644
index 00000000..bbe0b195
--- /dev/null
+++ b/freemocap-ui-old/src/i18n/locales/de-deutsch.json
@@ -0,0 +1,258 @@
+{
+ "_meta": {
+ "locale": "de",
+ "translationSource": "ai-generated",
+ "lastUpdated": "2026-02-23"
+ },
+ "appName": "SkellyCam",
+ "appNameDecorated": "SkellyCam 💀📸",
+ "welcomeTitle": "Willkommen bei SkellyCam",
+ "welcomeSubtitle": "Synchronisierte Videos aufnehmen und ansehen",
+ "sendAnonymousPings": "Anonyme Nutzungsdaten senden",
+ "footerWith": "mit",
+ "footerFrom": "von der",
+ "footerOrgName": "FreeMoCap Foundation",
+ "home": "Startseite",
+ "cameras": "Kameras",
+ "videos": "Videos",
+ "expandSidebar": "Seitenleiste erweitern",
+ "collapseSidebar": "Seitenleiste einklappen",
+ "startRecording": "Aufnahme starten",
+ "stopRecording": "Aufnahme stoppen",
+ "toggleTheme": "Thema wechseln",
+ "switchToDark": "Zum dunklen Modus wechseln",
+ "switchToLight": "Zum hellen Modus wechseln",
+ "connectWebSocket": "WebSocket verbinden",
+ "disconnectWebSocket": "WebSocket trennen",
+ "launchServer": "Server starten",
+ "stopServer": "Server stoppen",
+ "browseForExecutable": "Ausführbare Datei suchen",
+ "refreshCandidates": "Kandidaten aktualisieren",
+ "executable": "Ausführbare Datei",
+ "host": "Host",
+ "port": "Port",
+ "cameraCount_one": "{{count}} Kamera",
+ "cameraCount_other": "{{count}} Kameras",
+ "connectedCameras": "Verbundene Kameras",
+ "availableCameras": "Verfügbare Kameras",
+ "noCamerasConnected": "Keine Kameras verbunden",
+ "detectCameras": "Verfügbare Kameras erkennen",
+ "clearCameraSettings": "Kameraeinstellungen löschen",
+ "copySettingsToAll": "Einstellungen auf alle kopieren",
+ "recordingTag": "Aufnahme-Tag",
+ "recordingTagPlaceholder": "Optionaler Tag",
+ "recordingDirectory": "Aufnahmeverzeichnis",
+ "recordingFolderPath": "Aufnahmeordner-Pfad",
+ "delayStart": "Verzögerter Start",
+ "seconds": "Sekunden",
+ "subfolder": "Unterordner",
+ "subfolderPlaceholder": "Unterordnername",
+ "baseName": "Basisname",
+ "increment": "Inkrement",
+ "resolution": "Auflösung",
+ "fps": "FPS",
+ "width": "Breite",
+ "height": "Höhe",
+ "columns": "Spalten",
+ "auto": "Auto",
+ "manual": "Manuell",
+ "custom": "Benutzerdefiniert",
+ "current": "Aktuell",
+ "recommend": "Empfohlen",
+ "cameraRotation": "Kamerarotation",
+ "selectCameraRotation": "Kamerabildrotation wählen",
+ "exposureControl": "Automatische oder manuelle Belichtungssteuerung",
+ "framerateControl": "Automatische oder manuelle Bildrate",
+ "adjustExposure": "Belichtungszeit anpassen",
+ "setTargetFps": "Ziel-FPS für Aufnahme setzen",
+ "recordingCaptureFps": "Aufnahme-Bildrate",
+ "playbackSpeed": "Wiedergabegeschwindigkeit",
+ "framerateTimeline": "Bildraten-Zeitachse",
+ "framerateDistribution": "Bildratenverteilung",
+ "timelineView": "Zeitachsenansicht",
+ "distributionView": "Verteilungsansicht",
+ "combinedView": "Kombinierte Ansicht",
+ "min": "Min",
+ "max": "Max",
+ "mean": "Mittel",
+ "median": "Median",
+ "stdDevCv": "StdAbw/CV",
+ "source": "Quelle",
+ "selectAll": "Alle auswählen",
+ "loadSynchronizedVideos": "Synchronisierte Videos laden",
+ "loadSynchronizedVideosDescription": "Auf dieser Seite können Sie voraufgenommene Videos laden und synchronisieren.",
+ "automaticallySynchronizeVideos": "Videos automatisch synchronisieren",
+ "extractFramesOnLoad": "Bilder beim Laden extrahieren",
+ "generateThumbnails": "Miniaturansichten erstellen",
+ "noVideosLoaded": "Keine Videos geladen",
+ "filterVideos": "Videos filtern...",
+ "openVideo": "Video öffnen",
+ "openFolder": "Ordner im Explorer öffnen",
+ "videoFolderPath": "Videoordner-Pfad",
+ "jumpToStart": "Zum Anfang (Home)",
+ "jumpToEnd": "Zum Ende (End)",
+ "loopOn": "Schleife ist an (L zum Umschalten)",
+ "loopOff": "Schleifenwiedergabe (L)",
+ "syncInfo": "Sync-Info",
+ "syncInfoTitle": "Multi-Kamera-Synchronisation ist möglicherweise nicht bildgenau",
+ "syncInfoBody": "Die Videowiedergabe im Browser garantiert keine samplegenaue Synchronisation über mehrere Streams hinweg. Der Player verwendet eine Leader-Follower-Strategie und korrigiert Drift, wenn er eine kleine Toleranz überschreitet, aber geringfügige Desynchronisation (1–2 Frames) kann auftreten, besonders bei hohen Wiedergabegeschwindigkeiten oder wenn der Browser unter Last steht. Für bildgenaue Analyse verwenden Sie die rohen Zeitstempel-CSV-Dateien, die in jeder Aufnahme enthalten sind.",
+ "previousFrame": "Vorheriges Bild (← / Shift+← für 10)",
+ "nextFrame": "Nächstes Bild (→ / Shift+→ für 10)",
+ "zoomIn": "Vergrößern",
+ "zoomOut": "Verkleinern",
+ "resetZoom": "Zoom zurücksetzen",
+ "playbackSettings": "Wiedergabeeinstellungen",
+ "totalRecordingSize": "Gesamtaufnahmegröße auf der Festplatte",
+ "estimatedTime": "Geschätzte Zeit (Bild ÷ fps)",
+ "estimatedDuration": "Geschätzte Dauer (Gesamtbilder ÷ fps)",
+ "estimatedFromFrameNumber": "Geschätzt aus Bildnummer × fps",
+ "frameCountPerCamera": "Bildanzahl pro Kamera",
+ "cameraStreams": "Kamerastreams in dieser Aufnahme",
+ "backToRecordings": "Zurück zu Aufnahmen",
+ "errorsDetected": "Fehler erkannt",
+ "somethingWentWrong": "Etwas ist schiefgelaufen :(",
+ "searchLogs": "Protokolle durchsuchen...",
+ "filter": "Filtern…",
+ "refreshMicrophoneList": "Mikrofonliste aktualisieren",
+ "date": "Datum",
+ "name": "Name",
+ "size": "Größe",
+ "duration": "Dauer",
+ "frames": "Bilder",
+ "timestamp": "Zeitstempel",
+ "language": "Sprache",
+ "aiTranslated": "KI-Übersetzung",
+ "humanTranslated": "Menschliche Übersetzung",
+ "humanValidated": "Menschlich validiert",
+ "connectCameras": "Ausgewählte Kameras verbinden",
+ "resumeStreaming": "Stream fortsetzen",
+ "pauseStreaming": "Stream pausieren",
+ "closeAllCameras": "Alle Kameras schließen",
+ "framerate": "Bildrate",
+ "exposure": "Belichtung",
+ "fileLabel": "Datei",
+ "timeDelta": "Zeitdelta",
+ "pathLabel": "Pfad",
+ "exceptionDetails": "Ausnahmedetails",
+ "stackTrace": "Stacktrace",
+ "loadingVideos": "Videos laden… ({{ready}}/{{total}} bereit)",
+ "gridColumns": "Rasterspalten",
+ "settings": "Einstellungen",
+ "appearance": "Darstellung",
+ "themeMode": "Thema",
+ "darkMode": "Dunkel",
+ "lightMode": "Hell",
+ "languageSettings": "Sprache und Lokalisierung",
+ "showTranslationIndicator": "Übersetzungsquelle anzeigen",
+ "showTranslationIndicatorDescription": "Badge bei KI-Übersetzungen anzeigen",
+ "translationSourceLabel": "Übersetzungsquelle",
+ "general": "Allgemein",
+ "about": "Über",
+ "version": "Version",
+ "serverSettings": "Server",
+ "recordingSettings": "Aufnahmeeinstellungen",
+ "videoLoadingSettings": "Video-Ladeeinstellungen",
+ "connected": "Verbunden",
+ "connecting": "Verbinden…",
+ "disconnected": "Getrennt",
+ "disconnect": "Trennen",
+ "connect": "Verbinden",
+ "off": "Aus",
+ "running": "Läuft",
+ "stopped": "Gestoppt",
+ "working": "Verarbeitung…",
+ "invalid": "Ungültig",
+ "autoLaunch": "Autostart",
+ "autoConnect": "Auto-Verbindung",
+ "runningPath": "Läuft: {{path}}",
+ "noMicrophone": "Kein Mikrofon",
+ "audioRecordingEnabled": "Audioaufnahme aktiviert",
+ "noMicrophoneSelected": "Kein Mikrofon ausgewählt",
+ "recordingName": "Aufnahmename: {{name}}",
+ "startingIn": "Start in {{countdown}}...",
+ "stopping": "Stoppen...",
+ "starting": "Starten...",
+ "stopRecordingButton": "🔴 Aufnahme stoppen",
+ "startRecordingButton": "🔴 Aufnahme starten",
+ "camerasCount": "Kameras ({{count}})",
+ "availableCamerasCount": "Verfügbar ({{count}})",
+ "server": "Server",
+ "display": "Anzeige",
+ "rawMessage": "Rohnachricht",
+ "cameraPerformanceMetrics": "Kamera-Leistungskennzahlen",
+ "serverLogs": "Serverprotokolle",
+ "sortBy": "Sortieren {{direction}}",
+ "waitingForCameraStreams": "Warte auf Kamerastreams...",
+ "loggingPaused": "Protokollierung pausiert",
+ "noLogsToDisplay": "Keine Protokolle vorhanden",
+ "closeSettings": "Einstellungen schließen",
+ "gridSettings": "Rastereinstellungen",
+ "clickToShowLess": "Klicken zum Zuklappen",
+ "clickToLearnMore": "Klicken für mehr Infos",
+ "samples": "Proben",
+ "framerateOverTime": "Bildrate über Zeit",
+ "framerateFps": "Bildrate (fps)",
+ "capturesFramesFromCamera": "Erfasst Bilder von der Kamera.",
+ "rendersReceivedFrames": "Zeigt empfangene Bilder auf dem Bildschirm an.",
+ "displayTooltipLong": "Die Anzeige stellt die UI-Rendering-Leistung dar. Sie zeigt, wie schnell Ihr Display Frames empfängt und rendert. Leistungsprobleme hier beeinträchtigen nicht die Aufnahmequalität, können aber Ihre Fähigkeit beeinflussen, Kameras in Echtzeit zu überwachen.",
+ "statsSourceShort": "Anzeige rendert Bilder, Server erfasst Bilder.",
+ "statsSourceLong": "Der Server ist die tatsächliche Rate, mit der Frames von der Kamera gezogen/aufgezeichnet werden, während die Anzeige die Rate ist, mit der sie empfangen und gerendert werden. SkellyCam priorisiert die serverseitige Leistung für die Aufnahmequalität, daher sollte diese Zahl stabiler bleiben. Wenn die Anzeige-Framerate vom Server abweicht, deutet das darauf hin, dass Ihre Systemressourcen ausgelastet sind. Erwägen Sie, weniger Kameras zu verwenden oder Framerate/Auflösung zu verringern.",
+ "statsCurrentShort": "Aktuellste Bildzeit und FPS.",
+ "statsCurrentLong": "Zeigt die neueste Messung der Verarbeitungszeit eines Einzelbilds (in Millisekunden) und die entsprechenden Frames pro Sekunde (FPS). Niedrigere Frame-Zeiten und höhere FPS weisen auf bessere Leistung hin.",
+ "statsMinShort": "Schnellste Bildzeit und höchste FPS.",
+ "statsMinLong": "Stellt die minimale Verarbeitungszeit eines Einzelbilds während des Abtastfensters dar. Entspricht der maximalen FPS, die Ihr System unter optimalen Bedingungen erreicht hat.",
+ "statsMaxShort": "Langsamste Bildzeit und niedrigste FPS.",
+ "statsMaxLong": "Stellt die maximale Verarbeitungszeit eines Einzelbilds während des Abtastfensters dar. Entspricht der minimalen FPS unter ungünstigsten Bedingungen. Gelegentliche Spitzen sind normal, aber durchgehend hohe Werte können auf Leistungsprobleme hinweisen.",
+ "statsMeanShort": "Durchschnittliche Bildzeit und FPS über alle Proben.",
+ "statsMeanLong": "Das arithmetische Mittel aller gemessenen Bildzeiten während des Abtastfensters und die entsprechenden FPS. Gibt ein gutes Gesamtbild der Leistung, kann aber durch Ausreißer verzerrt sein.",
+ "statsMedianShort": "Median aller Bildzeiten (50. Perzentil).",
+ "statsMedianLong": "Der Median stellt den mittleren Wert dar, wenn alle Bildzeiten von schnellstem zu langsamstem sortiert sind. Im Gegensatz zum Mittelwert wird der Median nicht von extremen Ausreißern beeinflusst, was ihn zu einem stabileren Indikator für die typische Leistung macht.",
+ "statsStdDevShort": "Misst die Variabilität der Bildzeit. CV% ist relativ.",
+ "statsStdDevLong": "Die Standardabweichung misst die Streuung der Bildzeiten. Niedrigere Werte weisen auf konsistentere Leistung hin. Der Variationskoeffizient (CV%) drückt diese Variabilität als Prozentsatz des Mittelwerts aus, was den Vergleich der Stabilität über verschiedene Bildraten hinweg erleichtert. Niedrigerer CV% zeigt stabilere Leistung an.",
+ "aiTranslatedTooltip": "Diese Übersetzung wurde von KI erstellt und kann Fehler enthalten. Helfen Sie uns, sie zu verbessern!",
+ "humanValidatedTooltip": "Diese Übersetzung wurde von einem menschlichen Übersetzer überprüft.",
+ "helpTranslate": "Helfen Sie SkellyCam zu übersetzen",
+ "failedToFetch": "Abruf fehlgeschlagen",
+ "recordings": "Aufnahmen",
+ "noRecordingsFound": "Keine Aufnahmen gefunden. Geben Sie oben einen Pfad ein, um manuell zu laden.",
+ "noCamerasDetected": "Keine Kameras erkannt",
+ "clickRefreshToScan": "Klicken Sie auf Aktualisieren, um nach Kameras zu suchen",
+ "waitingForData": "Warte auf Daten…",
+ "load": "Laden",
+ "refresh": "Aktualisieren",
+ "available": "Verfügbar",
+ "menuFile": "Datei",
+ "menuView": "Ansicht",
+ "menuCamera": "Kamera",
+ "menuRecording": "Aufnahme",
+ "menuHelp": "Hilfe",
+ "menuDetectCameras": "Kameras erkennen",
+ "menuConnectCameras": "Kameras verbinden",
+ "menuCloseAllCameras": "Alle Kameras schließen",
+ "menuOpenRecordingFolder": "Aufnahmeordner öffnen…",
+ "menuToggleSidebar": "Seitenleiste umschalten",
+ "menuToggleTheme": "Design umschalten",
+ "menuToggleFullScreen": "Vollbild umschalten",
+ "menuPauseUnpause": "Pause / Fortsetzen",
+ "menuConnectApplySettings": "Verbinden / Einstellungen anwenden",
+ "menuCloseAll": "Alle schließen",
+ "menuDocumentation": "Dokumentation",
+ "menuGitHubRepository": "GitHub-Repository",
+ "menuReportIssue": "Problem melden…",
+ "menuAbout": "Über SkellyCam",
+ "menuPlayback": "Wiedergabe",
+ "videoPlayback": "Wiedergabe",
+ "copyLogsToClipboard": "Protokolle in Zwischenablage kopieren",
+ "saveLogsToFile": "Protokolle in Datei speichern",
+ "copied": "Kopiert!",
+ "timestampFromRecording": "Zeitstempel aus Aufnahmedaten",
+ "menuCheckForUpdates": "Check for Updates…",
+ "updateAvailable": "Update available",
+ "updateAvailableMessage": "Version {{version}} is available",
+ "downloading": "Downloading…",
+ "downloadComplete": "Download complete",
+ "restartToUpdate": "Restart to update",
+ "checkForUpdates": "Check for Updates",
+ "upToDate": "You are up to date",
+ "updateError": "Update check failed"
+}
diff --git a/freemocap-ui-old/src/i18n/locales/el-ellinika.json b/freemocap-ui-old/src/i18n/locales/el-ellinika.json
new file mode 100644
index 00000000..08bbb5f7
--- /dev/null
+++ b/freemocap-ui-old/src/i18n/locales/el-ellinika.json
@@ -0,0 +1,258 @@
+{
+ "_meta": {
+ "locale": "el",
+ "translationSource": "ai-generated",
+ "lastUpdated": "2026-02-23"
+ },
+ "appName": "SkellyCam",
+ "appNameDecorated": "SkellyCam 💀📸",
+ "welcomeTitle": "Καλώς ήρθατε στο SkellyCam",
+ "welcomeSubtitle": "Εγγραφή και Προβολή Συγχρονισμένων Βίντεο",
+ "sendAnonymousPings": "Αποστολή ανώνυμων ping χρήσης",
+ "footerWith": "με",
+ "footerFrom": "από",
+ "footerOrgName": "FreeMoCap Foundation",
+ "home": "Αρχική",
+ "cameras": "Κάμερες",
+ "videos": "Βίντεο",
+ "expandSidebar": "Ανάπτυξη πλαϊνής μπάρας",
+ "collapseSidebar": "Σύμπτυξη πλαϊνής μπάρας",
+ "startRecording": "Έναρξη Εγγραφής",
+ "stopRecording": "Διακοπή Εγγραφής",
+ "toggleTheme": "εναλλαγή θέματος",
+ "switchToDark": "Εναλλαγή σε σκοτεινή λειτουργία",
+ "switchToLight": "Εναλλαγή σε φωτεινή λειτουργία",
+ "connectWebSocket": "Σύνδεση WebSocket",
+ "disconnectWebSocket": "Αποσύνδεση WebSocket",
+ "launchServer": "Εκκίνηση Διακομιστή",
+ "stopServer": "Διακοπή Διακομιστή",
+ "browseForExecutable": "Αναζήτηση εκτελέσιμου",
+ "refreshCandidates": "Ανανέωση υποψηφίων",
+ "executable": "Εκτελέσιμο",
+ "host": "Κεντρικός υπολογιστής",
+ "port": "Θύρα",
+ "cameraCount_one": "{{count}} κάμερα",
+ "cameraCount_other": "{{count}} κάμερες",
+ "connectedCameras": "Συνδεδεμένες Κάμερες",
+ "availableCameras": "Διαθέσιμες Κάμερες",
+ "noCamerasConnected": "Δεν υπάρχουν συνδεδεμένες κάμερες",
+ "detectCameras": "Εντοπισμός διαθέσιμων καμερών",
+ "clearCameraSettings": "Εκκαθάριση αποθηκευμένων ρυθμίσεων κάμερας από τη μνήμη",
+ "copySettingsToAll": "Αντιγραφή ρυθμίσεων σε όλες τις κάμερες",
+ "recordingTag": "Ετικέτα Εγγραφής",
+ "recordingTagPlaceholder": "Προαιρετική ετικέτα",
+ "recordingDirectory": "Κατάλογος Εγγραφής",
+ "recordingFolderPath": "Διαδρομή φακέλου εγγραφής",
+ "delayStart": "Καθυστέρηση Έναρξης",
+ "seconds": "Δευτερόλεπτα",
+ "subfolder": "Υποφάκελος",
+ "subfolderPlaceholder": "Όνομα Υποφακέλου",
+ "baseName": "Βασικό Όνομα",
+ "increment": "Αύξηση",
+ "resolution": "Ανάλυση",
+ "fps": "FPS",
+ "width": "Πλάτος",
+ "height": "Ύψος",
+ "columns": "Στήλες",
+ "auto": "Αυτόματο",
+ "manual": "Χειροκίνητο",
+ "custom": "Προσαρμοσμένο",
+ "current": "Τρέχον",
+ "recommend": "Προτεινόμενο",
+ "cameraRotation": "περιστροφή κάμερας",
+ "selectCameraRotation": "Επιλογή περιστροφής εικόνας κάμερας",
+ "exposureControl": "Επιλογή μεταξύ αυτόματου ή χειροκίνητου ελέγχου έκθεσης",
+ "framerateControl": "Επιλογή μεταξύ αυτόματου ή χειροκίνητου ελέγχου ρυθμού καρέ",
+ "adjustExposure": "Ρύθμιση χρόνου έκθεσης, π.χ. cv2.VideoCapture.set(cv2.CAP_PROP_EXPOSURE, value)",
+ "setTargetFps": "Ορισμός στόχου καρέ ανά δευτερόλεπτο (FPS) για λήψη κάμερας",
+ "recordingCaptureFps": "Ρυθμός καρέ λήψης εγγραφής",
+ "playbackSpeed": "Ταχύτητα αναπαραγωγής (δεν επηρεάζει τα fps εγγραφής)",
+ "framerateTimeline": "Χρονοδιάγραμμα Ρυθμού Καρέ",
+ "framerateDistribution": "Κατανομή Ρυθμού Καρέ",
+ "timelineView": "Προβολή Χρονοδιαγράμματος",
+ "distributionView": "Προβολή Κατανομής",
+ "combinedView": "Συνδυασμένη Προβολή",
+ "min": "Ελάχ",
+ "max": "Μέγ",
+ "mean": "Μέσος",
+ "median": "Διάμεσος",
+ "stdDevCv": "StdDev/CV",
+ "source": "Πηγή",
+ "selectAll": "Επιλογή Όλων",
+ "loadSynchronizedVideos": "Φόρτωση Συγχρονισμένων Βίντεο",
+ "loadSynchronizedVideosDescription": "Αυτή η σελίδα σας επιτρέπει να φορτώσετε και να συγχρονίσετε προεγγεγραμμένα βίντεο.",
+ "automaticallySynchronizeVideos": "Αυτόματος συγχρονισμός βίντεο",
+ "extractFramesOnLoad": "Εξαγωγή καρέ κατά τη φόρτωση",
+ "generateThumbnails": "Δημιουργία μικρογραφιών",
+ "noVideosLoaded": "Δεν φορτώθηκαν βίντεο",
+ "filterVideos": "Φιλτράρισμα βίντεο...",
+ "openVideo": "Άνοιγμα βίντεο",
+ "openFolder": "Άνοιγμα φακέλου στον εξερευνητή αρχείων",
+ "videoFolderPath": "Διαδρομή Φακέλου Βίντεο",
+ "jumpToStart": "Μετάβαση στην αρχή (Home)",
+ "jumpToEnd": "Μετάβαση στο τέλος (End)",
+ "loopOn": "Η επανάληψη είναι ενεργή (L για εναλλαγή)",
+ "loopOff": "Αναπαραγωγή σε βρόχο (L)",
+ "syncInfo": "Πληροφορίες συγχρονισμού",
+ "syncInfoTitle": "Ο συγχρονισμός πολλαπλών καμερών μπορεί να μην είναι ακριβής σε επίπεδο καρέ",
+ "syncInfoBody": "Η αναπαραγωγή βίντεο στο πρόγραμμα περιήγησης δεν εγγυάται ακριβή συγχρονισμό δειγμάτων σε πολλαπλές ροές. Ο αναπαραγωγέας χρησιμοποιεί στρατηγική ηγέτη-ακολούθου και διορθώνει την απόκλιση όταν υπερβαίνει μια μικρή ανοχή, αλλά μπορεί να παρουσιαστεί μικρή αποσυγχρόνιση (1–2 καρέ), ειδικά σε υψηλές ταχύτητες αναπαραγωγής ή όταν το πρόγραμμα περιήγησης είναι υπό φόρτο. Για ανάλυση ακριβή σε επίπεδο καρέ, χρησιμοποιήστε τα ακατέργαστα αρχεία CSV χρονοσημάτων που περιλαμβάνονται σε κάθε εγγραφή.",
+ "previousFrame": "Προηγούμενο καρέ (← / Shift+← για 10)",
+ "nextFrame": "Επόμενο καρέ (→ / Shift+→ για 10)",
+ "zoomIn": "Μεγέθυνση",
+ "zoomOut": "Σμίκρυνση",
+ "resetZoom": "Επαναφορά Ζουμ",
+ "playbackSettings": "Ρυθμίσεις αναπαραγωγής",
+ "totalRecordingSize": "Συνολικό μέγεθος εγγραφής στο δίσκο",
+ "estimatedTime": "Εκτιμώμενος χρόνος (καρέ ÷ fps εγγραφής)",
+ "estimatedDuration": "Εκτιμώμενη διάρκεια (συνολικά καρέ ÷ fps εγγραφής)",
+ "estimatedFromFrameNumber": "Εκτίμηση από αριθμό καρέ × fps εγγραφής — δεν αναγνώστηκε από δεδομένα χρονοσφραγίδας",
+ "frameCountPerCamera": "Αριθμός καρέ ανά κάμερα",
+ "cameraStreams": "Ροές κάμερας σε αυτή την εγγραφή",
+ "backToRecordings": "Επιστροφή στις εγγραφές",
+ "errorsDetected": "Εντοπίστηκαν σφάλματα",
+ "somethingWentWrong": "Κάτι πήγε στραβά :(",
+ "searchLogs": "Αναζήτηση αρχείων καταγραφής...",
+ "filter": "Φίλτρο…",
+ "refreshMicrophoneList": "Ανανέωση λίστας μικροφώνων",
+ "date": "Ημερομηνία",
+ "name": "Όνομα",
+ "size": "Μέγεθος",
+ "duration": "Διάρκεια",
+ "frames": "Καρέ",
+ "timestamp": "Χρονοσφραγίδα",
+ "language": "Γλώσσα",
+ "aiTranslated": "Μεταφρασμένο από AI",
+ "humanTranslated": "Μεταφρασμένο από άνθρωπο",
+ "humanValidated": "Επικυρωμένο από άνθρωπο",
+ "connectCameras": "Σύνδεση στις επιλεγμένες κάμερες ή ενημέρωση συνδεδεμένων καμερών",
+ "resumeStreaming": "Συνέχιση ροής",
+ "pauseStreaming": "Παύση ροής",
+ "closeAllCameras": "Κλείσιμο όλων των καμερών",
+ "framerate": "Ρυθμός καρέ",
+ "exposure": "Έκθεση",
+ "fileLabel": "Αρχείο",
+ "timeDelta": "Χρονική διαφορά",
+ "pathLabel": "Διαδρομή",
+ "exceptionDetails": "Λεπτομέρειες εξαίρεσης",
+ "stackTrace": "Ίχνος Στοίβας",
+ "loadingVideos": "Φόρτωση βίντεο… ({{ready}}/{{total}} έτοιμα)",
+ "gridColumns": "Στήλες Πλέγματος",
+ "settings": "Ρυθμίσεις",
+ "appearance": "Εμφάνιση",
+ "themeMode": "Θέμα",
+ "darkMode": "Σκοτεινό",
+ "lightMode": "Φωτεινό",
+ "languageSettings": "Γλώσσα & Τοπικοποίηση",
+ "showTranslationIndicator": "Εμφάνιση ένδειξης πηγής μετάφρασης",
+ "showTranslationIndicatorDescription": "Εμφάνιση σήματος κατά τη χρήση μεταφράσεων που δημιουργήθηκαν από AI",
+ "translationSourceLabel": "Πηγή μετάφρασης",
+ "general": "Γενικά",
+ "about": "Σχετικά",
+ "version": "Έκδοση",
+ "serverSettings": "Διακομιστής",
+ "recordingSettings": "Ρυθμίσεις Εγγραφής",
+ "videoLoadingSettings": "Ρυθμίσεις Φόρτωσης Βίντεο",
+ "connected": "Συνδεδεμένο",
+ "connecting": "Σύνδεση…",
+ "disconnected": "Αποσυνδεδεμένο",
+ "disconnect": "Αποσύνδεση",
+ "connect": "Σύνδεση",
+ "off": "Απενεργοποιημένο",
+ "running": "Εκτελείται",
+ "stopped": "Σταματημένο",
+ "working": "Εργασία…",
+ "invalid": "Μη έγκυρο",
+ "autoLaunch": "Αυτόματη εκκίνηση",
+ "autoConnect": "Αυτόματη σύνδεση",
+ "runningPath": "Εκτελείται: {{path}}",
+ "noMicrophone": "Χωρίς μικρόφωνο",
+ "audioRecordingEnabled": "Εγγραφή ήχου ενεργοποιημένη",
+ "noMicrophoneSelected": "Δεν επιλέχθηκε μικρόφωνο",
+ "recordingName": "Όνομα Εγγραφής: {{name}}",
+ "startingIn": "Έναρξη σε {{countdown}}...",
+ "stopping": "Διακοπή...",
+ "starting": "Εκκίνηση...",
+ "stopRecordingButton": "🔴 Διακοπή Εγγραφής",
+ "startRecordingButton": "🔴 Έναρξη Εγγραφής",
+ "camerasCount": "Κάμερες ({{count}})",
+ "availableCamerasCount": "Διαθέσιμες ({{count}})",
+ "server": "Διακομιστής",
+ "display": "Οθόνη",
+ "rawMessage": "Ακατέργαστο μήνυμα",
+ "cameraPerformanceMetrics": "Μετρικές Απόδοσης Κάμερας",
+ "serverLogs": "Αρχεία Καταγραφής Διακομιστή",
+ "sortBy": "Ταξινόμηση {{direction}}",
+ "waitingForCameraStreams": "Αναμονή για ροές κάμερας...",
+ "loggingPaused": "Η καταγραφή σε παύση",
+ "noLogsToDisplay": "Δεν υπάρχουν αρχεία καταγραφής",
+ "closeSettings": "Κλείσιμο ρυθμίσεων",
+ "gridSettings": "Ρυθμίσεις πλέγματος",
+ "clickToShowLess": "Κλικ για εμφάνιση λιγότερων",
+ "clickToLearnMore": "Κλικ για περισσότερα",
+ "samples": "δείγματα",
+ "framerateOverTime": "Ρυθμός Καρέ στο Χρόνο",
+ "framerateFps": "Ρυθμός καρέ (fps)",
+ "capturesFramesFromCamera": "Λαμβάνει καρέ από την κάμερα.",
+ "rendersReceivedFrames": "Αποδίδει τα ληφθέντα καρέ στην οθόνη.",
+ "displayTooltipLong": "Η Οθόνη αντιπροσωπεύει την απόδοση rendering του UI. Δείχνει πόσο γρήγορα η οθόνη σας λαμβάνει και αποδίδει καρέ. Τα προβλήματα απόδοσης εδώ δεν θα επηρεάσουν την ποιότητα εγγραφής αλλά μπορεί να επηρεάσουν τη δυνατότητα παρακολούθησης καμερών σε πραγματικό χρόνο.",
+ "statsSourceShort": "Η Οθόνη αποδίδει καρέ, ο Διακομιστής λαμβάνει καρέ.",
+ "statsSourceLong": "Ο διακομιστής είναι ο πραγματικός ρυθμός με τον οποίο τα καρέ τραβιούνται/εγγράφονται από την κάμερα, ενώ η οθόνη είναι ο ρυθμός με τον οποίο λαμβάνονται και αποδίδονται. Το Skellycam δίνει προτεραιότητα στην απόδοση στο διακομιστή για ποιότητα εγγραφής, επομένως αυτός ο αριθμός θα πρέπει να παραμένει πιο σταθερός. Αν ο ρυθμός καρέ της οθόνης αποκλίνει από τον διακομιστή, δείχνει ότι οι πόροι του συστήματός σας είναι υπερφορτωμένοι. Σκεφτείτε να χρησιμοποιήσετε λιγότερες κάμερες ή να μειώσετε τον ρυθμό καρέ/ανάλυση.",
+ "statsCurrentShort": "Πιο πρόσφατος χρόνος καρέ και αντίστοιχο FPS.",
+ "statsCurrentLong": "Αυτό δείχνει την πιο πρόσφατη μέτρηση του χρόνου που χρειάζεται για την επεξεργασία ενός καρέ (σε χιλιοστά του δευτερολέπτου) και τα αντίστοιχα καρέ ανά δευτερόλεπτο (FPS). Χαμηλότεροι χρόνοι καρέ και υψηλότερο FPS υποδεικνύουν καλύτερη απόδοση.",
+ "statsMinShort": "Ταχύτερος χρόνος καρέ (χαμηλότερη καθυστέρηση) και υψηλότερο FPS που επιτεύχθηκε.",
+ "statsMinLong": "Αντιπροσωπεύει τον ελάχιστο χρόνο για την επεξεργασία ενός καρέ κατά το παράθυρο δειγματοληψίας. Αντιστοιχεί στο μέγιστο FPS που πέτυχε το σύστημά σας σε βέλτιστες συνθήκες.",
+ "statsMaxShort": "Πιο αργός χρόνος καρέ (υψηλότερη καθυστέρηση) και χαμηλότερο FPS που παρατηρήθηκε.",
+ "statsMaxLong": "Αντιπροσωπεύει τον μέγιστο χρόνο για την επεξεργασία ενός καρέ κατά το παράθυρο δειγματοληψίας. Αντιστοιχεί στο ελάχιστο FPS που πέτυχε το σύστημά σας στις χειρότερες συνθήκες. Περιστασιακές αιχμές είναι φυσιολογικές, αλλά σταθερά υψηλές τιμές μπορεί να υποδεικνύουν προβλήματα απόδοσης.",
+ "statsMeanShort": "Μέσος χρόνος καρέ και FPS σε όλα τα δείγματα.",
+ "statsMeanLong": "Ο αριθμητικός μέσος όλων των χρόνων καρέ που μετρήθηκαν κατά το παράθυρο δειγματοληψίας και το αντίστοιχο FPS. Δίνει μια καλή συνολική εικόνα της απόδοσης αλλά μπορεί να παραμορφωθεί από ακραίες τιμές.",
+ "statsMedianShort": "Μεσαία τιμή όλων των χρόνων καρέ (50ό εκατοστημόριο).",
+ "statsMedianLong": "Η διάμεσος αντιπροσωπεύει τη μεσαία τιμή όταν όλοι οι χρόνοι καρέ ταξινομούνται από τον ταχύτερο στον πιο αργό. Σε αντίθεση με τον μέσο, η διάμεσος δεν επηρεάζεται από ακραίες τιμές, καθιστώντας την πιο σταθερό δείκτη τυπικής απόδοσης.",
+ "statsStdDevShort": "Μετρά τη μεταβλητότητα του χρόνου καρέ. CV% είναι η σχετική μεταβλητότητα.",
+ "statsStdDevLong": "Η τυπική απόκλιση μετρά το ποσό της διακύμανσης στους χρόνους καρέ. Χαμηλότερες τιμές υποδεικνύουν πιο συνεπή απόδοση. Ο Συντελεστής Διακύμανσης (CV%) εκφράζει αυτή τη μεταβλητότητα ως ποσοστό του μέσου, διευκολύνοντας τη σύγκριση σταθερότητας μεταξύ διαφορετικών ρυθμών καρέ. Χαμηλότερο CV% υποδεικνύει πιο σταθερή απόδοση.",
+ "aiTranslatedTooltip": "Αυτή η μετάφραση δημιουργήθηκε από AI και μπορεί να περιέχει σφάλματα. Αν μιλάτε αυτή τη γλώσσα, μπορείτε να βοηθήσετε στη βελτίωσή της ανοίγοντας ένα pull request στο GitHub!",
+ "humanValidatedTooltip": "Αυτή η μετάφραση έχει ελεγχθεί και επικυρωθεί από ανθρώπινο μεταφραστή.",
+ "helpTranslate": "Βοηθήστε στη μετάφραση του SkellyCam",
+ "failedToFetch": "Αποτυχία ανάκτησης",
+ "recordings": "Εγγραφές",
+ "noRecordingsFound": "Δεν βρέθηκαν εγγραφές. Εισάγετε μια διαδρομή παραπάνω για χειροκίνητη φόρτωση.",
+ "noCamerasDetected": "Δεν εντοπίστηκαν κάμερες",
+ "clickRefreshToScan": "Κλικ στην ανανέωση για σάρωση διαθέσιμων καμερών",
+ "waitingForData": "Αναμονή για δεδομένα…",
+ "load": "Φόρτωση",
+ "refresh": "Ανανέωση",
+ "available": "Διαθέσιμο",
+ "menuFile": "Αρχείο",
+ "menuView": "Προβολή",
+ "menuCamera": "Κάμερα",
+ "menuRecording": "Εγγραφή",
+ "menuHelp": "Βοήθεια",
+ "menuDetectCameras": "Ανίχνευση καμερών",
+ "menuConnectCameras": "Σύνδεση καμερών",
+ "menuCloseAllCameras": "Κλείσιμο όλων των καμερών",
+ "menuOpenRecordingFolder": "Άνοιγμα φακέλου εγγραφής…",
+ "menuToggleSidebar": "Εναλλαγή πλαϊνής μπάρας",
+ "menuToggleTheme": "Εναλλαγή θέματος",
+ "menuToggleFullScreen": "Πλήρης οθόνη",
+ "menuPauseUnpause": "Παύση / Συνέχεια",
+ "menuConnectApplySettings": "Σύνδεση / Εφαρμογή ρυθμίσεων",
+ "menuCloseAll": "Κλείσιμο όλων",
+ "menuDocumentation": "Τεκμηρίωση",
+ "menuGitHubRepository": "Αποθετήριο GitHub",
+ "menuReportIssue": "Αναφορά προβλήματος…",
+ "menuAbout": "Σχετικά με το SkellyCam",
+ "menuPlayback": "Αναπαραγωγή",
+ "videoPlayback": "Αναπαραγωγή",
+ "copyLogsToClipboard": "Αντιγραφή αρχείων καταγραφής στο πρόχειρο",
+ "saveLogsToFile": "Αποθήκευση αρχείων καταγραφής σε αρχείο",
+ "copied": "Αντιγράφηκε!",
+ "timestampFromRecording": "Χρονοσήμανση από δεδομένα εγγραφής",
+ "menuCheckForUpdates": "Check for Updates…",
+ "updateAvailable": "Update available",
+ "updateAvailableMessage": "Version {{version}} is available",
+ "downloading": "Downloading…",
+ "downloadComplete": "Download complete",
+ "restartToUpdate": "Restart to update",
+ "checkForUpdates": "Check for Updates",
+ "upToDate": "You are up to date",
+ "updateError": "Update check failed"
+}
diff --git a/freemocap-ui-old/src/i18n/locales/en-english.json b/freemocap-ui-old/src/i18n/locales/en-english.json
new file mode 100644
index 00000000..44777bd8
--- /dev/null
+++ b/freemocap-ui-old/src/i18n/locales/en-english.json
@@ -0,0 +1,262 @@
+{
+ "_meta": {
+ "locale": "en",
+ "translationSource": "human-authored",
+ "lastUpdated": "2026-02-22"
+ },
+ "appName": "SkellyCam",
+ "appNameDecorated": "SkellyCam 💀📸",
+ "welcomeTitle": "Welcome to SkellyCam",
+ "welcomeSubtitle": "Record and View Synchronized Videos",
+ "sendAnonymousPings": "Send anonymous usage pings",
+ "footerWith": "w/",
+ "footerFrom": "from the",
+ "footerOrgName": "FreeMoCap Foundation",
+ "home": "Home",
+ "cameras": "Cameras",
+ "videos": "Videos",
+ "expandSidebar": "Expand sidebar",
+ "collapseSidebar": "Collapse sidebar",
+ "startRecording": "Start Recording",
+ "stopRecording": "Stop Recording",
+ "toggleTheme": "toggle theme",
+ "switchToDark": "Switch to dark mode",
+ "switchToLight": "Switch to light mode",
+ "connectWebSocket": "Connect WebSocket",
+ "disconnectWebSocket": "Disconnect WebSocket",
+ "launchServer": "Launch Server",
+ "stopServer": "Stop Server",
+ "browseForExecutable": "Browse for executable",
+ "refreshCandidates": "Refresh candidates",
+ "executable": "Executable",
+ "host": "Host",
+ "port": "Port",
+ "cameraCount_one": "{{count}} cam",
+ "cameraCount_other": "{{count}} cams",
+ "connectedCameras": "Connected Cameras",
+ "availableCameras": "Available Cameras",
+ "noCamerasConnected": "No cameras connected",
+ "detectCameras": "Detect available cameras",
+ "clearCameraSettings": "Clear saved camera settings from memory",
+ "copySettingsToAll": "Copy settings to all cameras",
+ "recordingTag": "Recording Tag",
+ "recordingTagPlaceholder": "Optional tag",
+ "recordingDirectory": "Recording Directory",
+ "recordingFolderPath": "Recording folder path",
+ "delayStart": "Delay Start",
+ "seconds": "Seconds",
+ "subfolder": "Subfolder",
+ "subfolderPlaceholder": "Subfolder Name",
+ "baseName": "Base Name",
+ "increment": "Increment",
+ "resolution": "Resolution",
+ "fps": "FPS",
+ "width": "Width",
+ "height": "Height",
+ "columns": "Columns",
+ "auto": "Auto",
+ "manual": "Manual",
+ "custom": "Custom",
+ "current": "Current",
+ "recommend": "Recommend",
+ "cameraRotation": "camera rotation",
+ "selectCameraRotation": "Select camera image rotation",
+ "exposureControl": "Choose between automatic or manual exposure control",
+ "framerateControl": "Choose between automatic or manual framerate control",
+ "adjustExposure": "Adjust exposure time, e.g. cv2.VideoCapture.set(cv2.CAP_PROP_EXPOSURE, value)",
+ "setTargetFps": "Set target frames per second (FPS) for camera capture",
+ "recordingCaptureFps": "Recording capture framerate",
+ "playbackSpeed": "Playback speed (does not affect recording fps)",
+ "framerateTimeline": "Framerate Timeline",
+ "framerateDistribution": "Framerate Distribution",
+ "timelineView": "Timeline View",
+ "distributionView": "Distribution View",
+ "combinedView": "Combined View",
+ "min": "Min",
+ "max": "Max",
+ "mean": "Mean",
+ "median": "Median",
+ "stdDevCv": "StdDev/CV",
+ "source": "Source",
+ "selectAll": "Select All",
+ "loadSynchronizedVideos": "Load Synchronized Videos",
+ "loadSynchronizedVideosDescription": "This page will allow you to load and synchronize pre-recorded videos.",
+ "automaticallySynchronizeVideos": "Automatically synchronize videos",
+ "extractFramesOnLoad": "Extract frames on load",
+ "generateThumbnails": "Generate thumbnails",
+ "noVideosLoaded": "No videos loaded",
+ "filterVideos": "Filter videos...",
+ "openVideo": "Open video",
+ "openFolder": "Open folder in file explorer",
+ "videoFolderPath": "Video Folder Path",
+ "jumpToStart": "Jump to start (Home)",
+ "jumpToEnd": "Jump to end (End)",
+ "loopOn": "Loop is on (L to toggle)",
+ "loopOff": "Loop playback (L)",
+ "syncInfo": "Sync info",
+ "syncInfoTitle": "Recording playback may show desynchronization not present in the recorded videos. Matched frame numbers represent images from the same time slice. We are working on a fix. ",
+ "syncInfoBody": "Browser video playback does not guarantee sample-accurate synchronization across multiple streams. The player uses a leader-follower strategy and corrects drift when it exceeds a small tolerance, but minor desynchronization (1–2 frames) can occur",
+ "previousFrame": "Previous frame (← / Shift+← for 10)",
+ "nextFrame": "Next frame (→ / Shift+→ for 10)",
+ "zoomIn": "Zoom In",
+ "zoomOut": "Zoom Out",
+ "resetZoom": "Reset Zoom",
+ "playbackSettings": "Playback settings",
+ "totalRecordingSize": "Total recording size on disk",
+ "estimatedTime": "Estimated time (frame ÷ recording fps)",
+ "estimatedDuration": "Estimated duration (total frames ÷ recording fps)",
+ "estimatedFromFrameNumber": "Estimated from frame number × recording fps — not read from timestamp data",
+ "frameCountPerCamera": "Frame count per camera",
+ "cameraStreams": "Camera streams in this recording",
+ "backToRecordings": "Back to recordings",
+ "errorsDetected": "Errors detected",
+ "somethingWentWrong": "Something went wrong :(",
+ "searchLogs": "Search logs...",
+ "filter": "Filter…",
+ "refreshMicrophoneList": "Refresh microphone list",
+ "date": "Date",
+ "name": "Name",
+ "size": "Size",
+ "duration": "Duration",
+ "frames": "Frames",
+ "timestamp": "Timestamp",
+ "language": "Language",
+ "aiTranslated": "AI-translated",
+ "humanTranslated": "Human-translated",
+ "humanValidated": "Human-validated",
+ "connectCameras": "Connect to selected cameras or update connected cameras",
+ "connectToCameras": "Connect to Cameras",
+ "documentation": "Documentation",
+ "roadmap": "Roadmap",
+ "resumeStreaming": "Resume streaming",
+ "pauseStreaming": "Pause streaming",
+ "closeAllCameras": "Close all cameras",
+ "framerate": "Framerate",
+ "exposure": "Exposure",
+ "fileLabel": "File",
+ "timeDelta": "Time delta",
+ "pathLabel": "Path",
+ "exceptionDetails": "Exception details",
+ "stackTrace": "Stack Trace",
+ "loadingVideos": "Loading videos… ({{ready}}/{{total}} ready)",
+ "gridColumns": "Grid Columns",
+ "settings": "Settings",
+ "appearance": "Appearance",
+ "themeMode": "Theme",
+ "darkMode": "Dark",
+ "lightMode": "Light",
+ "languageSettings": "Language & Localization",
+ "showTranslationIndicator": "Show translation source indicator",
+ "showTranslationIndicatorDescription": "Display a badge when using AI-generated translations",
+ "translationSourceLabel": "Translation source",
+ "general": "General",
+ "about": "About",
+ "version": "Version",
+ "serverSettings": "Server",
+ "recordingSettings": "Recording Settings",
+ "videoLoadingSettings": "Video Loading Settings",
+ "connected": "Connected",
+ "connecting": "Connecting…",
+ "disconnected": "Disconnected",
+ "disconnect": "Disconnect",
+ "connect": "Connect",
+ "off": "Off",
+ "running": "Running",
+ "stopped": "Stopped",
+ "working": "Working…",
+ "invalid": "Invalid",
+ "autoLaunch": "Auto-launch",
+ "autoConnect": "Auto-connect",
+ "runningPath": "Running: {{path}}",
+ "noMicrophone": "No microphone",
+ "audioRecordingEnabled": "Audio recording enabled",
+ "noMicrophoneSelected": "No microphone selected",
+ "recordingName": "Recording Name: {{name}}",
+ "startingIn": "Starting in {{countdown}}...",
+ "stopping": "Stopping...",
+ "starting": "Starting...",
+ "stopRecordingButton": "🔴 Stop Recording",
+ "startRecordingButton": "🔴 Start Recording",
+ "camerasCount": "Cameras ({{count}})",
+ "availableCamerasCount": "Available ({{count}})",
+ "server": "Server",
+ "display": "Display",
+ "rawMessage": "Raw message",
+ "cameraPerformanceMetrics": "Camera Performance Metrics",
+ "serverLogs": "Server Logs",
+ "sortBy": "Sort {{direction}}",
+ "waitingForCameraStreams": "Waiting for camera streams...",
+ "loggingPaused": "Logging paused",
+ "noLogsToDisplay": "No logs to display",
+ "closeSettings": "Close settings",
+ "gridSettings": "Grid settings",
+ "clickToShowLess": "Click to show less",
+ "clickToLearnMore": "Click to learn more",
+ "samples": "samples",
+ "framerateOverTime": "Framerate Over Time",
+ "framerateFps": "Framerate (fps)",
+ "capturesFramesFromCamera": "Captures frames from camera.",
+ "rendersReceivedFrames": "Renders received frames on screen.",
+ "displayTooltipLong": "Display represents the UI rendering performance. It shows how quickly your display receives and renders frames. Performance issues here won't affect recording quality but may impact your ability to monitor cameras in real-time.",
+ "statsSourceShort": "Display renders frames, Server captures frames.",
+ "statsSourceLong": "The server is the true rate at which frames are pulled/recorded from the camera, while display is the rate at which they are received and rendered. Skellycam prioritizes server-side performance for recording quality, so that number should stay more stable. If the display framerate diverges from the server, it indicates your system resources are taxed. Consider using fewer cameras or decreasing framerate/resolution.",
+ "statsCurrentShort": "Most recent frame time and corresponding FPS.",
+ "statsCurrentLong": "This shows the most recent measurement of how long it takes to process a single frame (in milliseconds) and the equivalent frames per second (FPS). Lower frame times and higher FPS indicate better performance.",
+ "statsMinShort": "Fastest frame time (lowest latency) and highest FPS achieved.",
+ "statsMinLong": "This represents the minimum time it took to process a single frame during the sampling window. This corresponds to the maximum FPS your system achieved during optimal conditions.",
+ "statsMaxShort": "Slowest frame time (highest latency) and lowest FPS experienced.",
+ "statsMaxLong": "This represents the maximum time it took to process a single frame during the sampling window. This corresponds to the minimum FPS your system achieved during worst-case conditions. Occasional spikes are normal, but consistently high values may indicate performance issues.",
+ "statsMeanShort": "Average frame time and FPS across all samples.",
+ "statsMeanLong": "The arithmetic mean (average) of all frame times measured during the sampling window and the corresponding FPS. This gives a good overall picture of performance but may be skewed by outliers.",
+ "statsMedianShort": "Middle value of all frame times (50th percentile).",
+ "statsMedianLong": "The median represents the middle value when all frame times are sorted from fastest to slowest. Unlike the mean, the median is not affected by extreme outliers, making it a more stable indicator of typical performance.",
+ "statsStdDevShort": "Measures frame time variability. CV% is relative variability.",
+ "statsStdDevLong": "Standard deviation measures the amount of variation in frame times. Lower values indicate more consistent performance. The Coefficient of Variation (CV%) expresses this variability as a percentage of the mean, making it easier to compare stability across different frame rates. Lower CV% indicates more stable performance.",
+ "aiTranslatedTooltip": "This translation was generated by AI and may contain errors. If you speak this language, you can help improve it by opening a pull request on GitHub!",
+ "humanValidatedTooltip": "This translation has been reviewed and validated by a human translator.",
+ "helpTranslate": "Help translate SkellyCam",
+ "failedToFetch": "Failed to fetch",
+ "recordings": "Recordings",
+ "noRecordingsFound": "No recordings found. Enter a path above to load manually.",
+ "noCamerasDetected": "No cameras detected",
+ "clickRefreshToScan": "Click refresh to scan for available cameras",
+ "waitingForData": "Waiting for data…",
+ "load": "Load",
+ "refresh": "Refresh",
+ "available": "Available",
+ "menuFile": "File",
+ "menuView": "View",
+ "menuCamera": "Camera",
+ "menuRecording": "Recording",
+ "menuHelp": "Help",
+ "menuDetectCameras": "Detect Cameras",
+ "menuConnectCameras": "Connect Cameras",
+ "menuCloseAllCameras": "Close All Cameras",
+ "menuOpenRecordingFolder": "Open Recording Folder…",
+ "menuToggleSidebar": "Toggle Sidebar",
+ "menuToggleTheme": "Toggle Theme",
+ "menuToggleFullScreen": "Toggle Full Screen",
+ "menuPauseUnpause": "Pause / Unpause",
+ "menuConnectApplySettings": "Connect / Apply Settings",
+ "menuCloseAll": "Close All",
+ "menuDocumentation": "Documentation",
+ "menuGitHubRepository": "GitHub Repository",
+ "menuReportIssue": "Report an Issue…",
+ "menuAbout": "About SkellyCam",
+ "menuCheckForUpdates": "Check for Updates…",
+ "menuPlayback": "Playback",
+ "videoPlayback": "Playback",
+ "copyLogsToClipboard": "Copy logs to clipboard",
+ "saveLogsToFile": "Save logs to file",
+ "copied": "Copied!",
+ "timestampFromRecording": "Timestamp from recording data",
+ "updateAvailable": "Update available",
+ "updateAvailableMessage": "Version {{version}} is available",
+ "downloading": "Downloading…",
+ "downloadComplete": "Download complete",
+ "restartToUpdate": "Restart to update",
+ "checkForUpdates": "Check for Updates",
+ "upToDate": "You are up to date",
+ "updateError": "Update check failed",
+ "serverNotConnected": "Connect to server to enable controls"
+}
diff --git a/freemocap-ui-old/src/i18n/locales/es-espanol.json b/freemocap-ui-old/src/i18n/locales/es-espanol.json
new file mode 100644
index 00000000..9703f3c6
--- /dev/null
+++ b/freemocap-ui-old/src/i18n/locales/es-espanol.json
@@ -0,0 +1,258 @@
+{
+ "_meta": {
+ "locale": "es",
+ "translationSource": "ai-generated",
+ "lastUpdated": "2026-02-22"
+ },
+ "appName": "SkellyCam",
+ "appNameDecorated": "SkellyCam 💀📸",
+ "welcomeTitle": "Bienvenido a SkellyCam",
+ "welcomeSubtitle": "Graba y visualiza videos sincronizados",
+ "sendAnonymousPings": "Enviar pings de uso anónimos",
+ "footerWith": "con",
+ "footerFrom": "de la",
+ "footerOrgName": "FreeMoCap Foundation",
+ "home": "Inicio",
+ "cameras": "Cámaras",
+ "videos": "Videos",
+ "expandSidebar": "Expandir barra lateral",
+ "collapseSidebar": "Colapsar barra lateral",
+ "startRecording": "Iniciar grabación",
+ "stopRecording": "Detener grabación",
+ "toggleTheme": "cambiar tema",
+ "switchToDark": "Cambiar a modo oscuro",
+ "switchToLight": "Cambiar a modo claro",
+ "connectWebSocket": "Conectar WebSocket",
+ "disconnectWebSocket": "Desconectar WebSocket",
+ "launchServer": "Iniciar servidor",
+ "stopServer": "Detener servidor",
+ "browseForExecutable": "Buscar ejecutable",
+ "refreshCandidates": "Actualizar candidatos",
+ "executable": "Ejecutable",
+ "host": "Host",
+ "port": "Puerto",
+ "cameraCount_one": "{{count}} cámara",
+ "cameraCount_other": "{{count}} cámaras",
+ "connectedCameras": "Cámaras conectadas",
+ "availableCameras": "Cámaras disponibles",
+ "noCamerasConnected": "No hay cámaras conectadas",
+ "detectCameras": "Detectar cámaras disponibles",
+ "clearCameraSettings": "Borrar ajustes de cámara guardados",
+ "copySettingsToAll": "Copiar ajustes a todas las cámaras",
+ "recordingTag": "Etiqueta de grabación",
+ "recordingTagPlaceholder": "Etiqueta opcional",
+ "recordingDirectory": "Directorio de grabación",
+ "recordingFolderPath": "Ruta de carpeta de grabación",
+ "delayStart": "Retraso de inicio",
+ "seconds": "Segundos",
+ "subfolder": "Subcarpeta",
+ "subfolderPlaceholder": "Nombre de subcarpeta",
+ "baseName": "Nombre base",
+ "increment": "Incremento",
+ "resolution": "Resolución",
+ "fps": "FPS",
+ "width": "Ancho",
+ "height": "Alto",
+ "columns": "Columnas",
+ "auto": "Automático",
+ "manual": "Manual",
+ "custom": "Personalizado",
+ "current": "Actual",
+ "recommend": "Recomendado",
+ "cameraRotation": "rotación de cámara",
+ "selectCameraRotation": "Seleccionar rotación de imagen de cámara",
+ "exposureControl": "Elegir entre control de exposición automático o manual",
+ "framerateControl": "Elegir entre control de velocidad de cuadros automático o manual",
+ "adjustExposure": "Ajustar tiempo de exposición, ej. cv2.VideoCapture.set(cv2.CAP_PROP_EXPOSURE, valor)",
+ "setTargetFps": "Establecer cuadros por segundo (FPS) objetivo para captura de cámara",
+ "recordingCaptureFps": "FPS de captura de grabación",
+ "playbackSpeed": "Velocidad de reproducción (no afecta los FPS de grabación)",
+ "framerateTimeline": "Línea de tiempo de FPS",
+ "framerateDistribution": "Distribución de FPS",
+ "timelineView": "Vista de línea de tiempo",
+ "distributionView": "Vista de distribución",
+ "combinedView": "Vista combinada",
+ "min": "Mín",
+ "max": "Máx",
+ "mean": "Media",
+ "median": "Mediana",
+ "stdDevCv": "DesvEst/CV",
+ "source": "Fuente",
+ "selectAll": "Seleccionar todo",
+ "loadSynchronizedVideos": "Cargar videos sincronizados",
+ "loadSynchronizedVideosDescription": "Esta página te permitirá cargar y sincronizar videos pregrabados.",
+ "automaticallySynchronizeVideos": "Sincronizar videos automáticamente",
+ "extractFramesOnLoad": "Extraer cuadros al cargar",
+ "generateThumbnails": "Generar miniaturas",
+ "noVideosLoaded": "No hay videos cargados",
+ "filterVideos": "Filtrar videos...",
+ "openVideo": "Abrir video",
+ "openFolder": "Abrir carpeta en explorador de archivos",
+ "videoFolderPath": "Ruta de carpeta de video",
+ "jumpToStart": "Ir al inicio (Home)",
+ "jumpToEnd": "Ir al final (End)",
+ "loopOn": "Bucle activado (L para alternar)",
+ "loopOff": "Reproducción en bucle (L)",
+ "syncInfo": "Info de sincronización",
+ "syncInfoTitle": "La sincronización multicámara puede no ser perfecta a nivel de fotograma",
+ "syncInfoBody": "La reproducción de video en el navegador no garantiza una sincronización exacta entre múltiples flujos. El reproductor utiliza una estrategia de líder-seguidor y corrige la desviación cuando supera una pequeña tolerancia, pero puede producirse una ligera desincronización (1–2 fotogramas), especialmente a velocidades de reproducción altas o cuando el navegador está bajo carga. Para un análisis exacto por fotograma, utilice los archivos CSV de marcas de tiempo incluidos en cada grabación.",
+ "previousFrame": "Cuadro anterior (← / Shift+← para 10)",
+ "nextFrame": "Cuadro siguiente (→ / Shift+→ para 10)",
+ "zoomIn": "Acercar",
+ "zoomOut": "Alejar",
+ "resetZoom": "Restablecer zoom",
+ "playbackSettings": "Ajustes de reproducción",
+ "totalRecordingSize": "Tamaño total de grabación en disco",
+ "estimatedTime": "Tiempo estimado (cuadro ÷ FPS de grabación)",
+ "estimatedDuration": "Duración estimada (cuadros totales ÷ FPS de grabación)",
+ "estimatedFromFrameNumber": "Estimado del número de cuadro × FPS de grabación — no leído de datos de marca de tiempo",
+ "frameCountPerCamera": "Cantidad de cuadros por cámara",
+ "cameraStreams": "Flujos de cámara en esta grabación",
+ "backToRecordings": "Volver a grabaciones",
+ "errorsDetected": "Errores detectados",
+ "somethingWentWrong": "Algo salió mal :(",
+ "searchLogs": "Buscar registros...",
+ "filter": "Filtrar…",
+ "refreshMicrophoneList": "Actualizar lista de micrófonos",
+ "date": "Fecha",
+ "name": "Nombre",
+ "size": "Tamaño",
+ "duration": "Duración",
+ "frames": "Cuadros",
+ "timestamp": "Marca de tiempo",
+ "language": "Idioma",
+ "aiTranslated": "Traducido por IA",
+ "humanTranslated": "Traducido por humano",
+ "humanValidated": "Validado por humano",
+ "connectCameras": "Conectar a las cámaras seleccionadas o actualizar las conectadas",
+ "resumeStreaming": "Reanudar transmisión",
+ "pauseStreaming": "Pausar transmisión",
+ "closeAllCameras": "Cerrar todas las cámaras",
+ "framerate": "Velocidad de cuadros",
+ "exposure": "Exposición",
+ "fileLabel": "Archivo",
+ "timeDelta": "Delta de tiempo",
+ "pathLabel": "Ruta",
+ "exceptionDetails": "Detalles de excepción",
+ "stackTrace": "Traza de pila",
+ "loadingVideos": "Cargando videos… ({{ready}}/{{total}} listos)",
+ "gridColumns": "Columnas de cuadrícula",
+ "settings": "Configuración",
+ "appearance": "Apariencia",
+ "themeMode": "Tema",
+ "darkMode": "Oscuro",
+ "lightMode": "Claro",
+ "languageSettings": "Idioma y localización",
+ "showTranslationIndicator": "Mostrar indicador de fuente de traducción",
+ "showTranslationIndicatorDescription": "Muestra una insignia cuando se usan traducciones generadas por IA",
+ "translationSourceLabel": "Fuente de traducción",
+ "general": "General",
+ "about": "Acerca de",
+ "version": "Versión",
+ "serverSettings": "Servidor",
+ "recordingSettings": "Ajustes de grabación",
+ "videoLoadingSettings": "Ajustes de carga de video",
+ "connected": "Conectado",
+ "connecting": "Conectando…",
+ "disconnected": "Desconectado",
+ "disconnect": "Desconectar",
+ "connect": "Conectar",
+ "off": "Apagado",
+ "running": "Ejecutando",
+ "stopped": "Detenido",
+ "working": "Procesando…",
+ "invalid": "Inválido",
+ "autoLaunch": "Inicio automático",
+ "autoConnect": "Conexión automática",
+ "runningPath": "Ejecutando: {{path}}",
+ "noMicrophone": "Sin micrófono",
+ "audioRecordingEnabled": "Grabación de audio habilitada",
+ "noMicrophoneSelected": "Micrófono no seleccionado",
+ "recordingName": "Nombre de grabación: {{name}}",
+ "startingIn": "Iniciando en {{countdown}}...",
+ "stopping": "Deteniendo...",
+ "starting": "Iniciando...",
+ "stopRecordingButton": "🔴 Detener grabación",
+ "startRecordingButton": "🔴 Iniciar grabación",
+ "camerasCount": "Cámaras ({{count}})",
+ "availableCamerasCount": "Disponibles ({{count}})",
+ "server": "Servidor",
+ "display": "Pantalla",
+ "rawMessage": "Mensaje sin formato",
+ "cameraPerformanceMetrics": "Métricas de rendimiento de cámaras",
+ "serverLogs": "Registros del servidor",
+ "sortBy": "Ordenar {{direction}}",
+ "waitingForCameraStreams": "Esperando flujos de cámara...",
+ "loggingPaused": "Registro en pausa",
+ "noLogsToDisplay": "No hay registros para mostrar",
+ "closeSettings": "Cerrar ajustes",
+ "gridSettings": "Ajustes de cuadrícula",
+ "clickToShowLess": "Haz clic para ver menos",
+ "clickToLearnMore": "Haz clic para saber más",
+ "samples": "muestras",
+ "framerateOverTime": "Velocidad de cuadros en el tiempo",
+ "framerateFps": "Velocidad de cuadros (fps)",
+ "capturesFramesFromCamera": "Captura cuadros de la cámara.",
+ "rendersReceivedFrames": "Renderiza los cuadros recibidos en pantalla.",
+ "displayTooltipLong": "La pantalla representa el rendimiento de renderizado de la interfaz. Muestra la velocidad a la que tu pantalla recibe y renderiza los cuadros. Los problemas de rendimiento aquí no afectarán la calidad de la grabación, pero pueden afectar tu capacidad de monitorear las cámaras en tiempo real.",
+ "statsSourceShort": "Pantalla renderiza cuadros, Servidor captura cuadros.",
+ "statsSourceLong": "El servidor es la tasa real a la que se extraen/graban los cuadros de la cámara, mientras que la pantalla es la tasa a la que se reciben y renderizan. Skellycam prioriza el rendimiento del lado del servidor para la calidad de grabación, así que ese número debería mantenerse más estable. Si la velocidad de cuadros de la pantalla diverge del servidor, indica que los recursos del sistema están sobrecargados.",
+ "statsCurrentShort": "Tiempo de cuadro más reciente y FPS correspondiente.",
+ "statsCurrentLong": "Muestra la medición más reciente de cuánto tarda en procesar un solo cuadro (en milisegundos) y los cuadros por segundo (FPS) equivalentes. Tiempos de cuadro más bajos y FPS más altos indican mejor rendimiento.",
+ "statsMinShort": "Tiempo de cuadro más rápido (menor latencia) y FPS más alto alcanzado.",
+ "statsMinLong": "Representa el tiempo mínimo que tardó en procesar un solo cuadro durante la ventana de muestreo. Corresponde al FPS máximo que tu sistema alcanzó en condiciones óptimas.",
+ "statsMaxShort": "Tiempo de cuadro más lento (mayor latencia) y FPS más bajo experimentado.",
+ "statsMaxLong": "Representa el tiempo máximo que tardó en procesar un solo cuadro durante la ventana de muestreo. Corresponde al FPS mínimo que tu sistema alcanzó en las peores condiciones. Los picos ocasionales son normales, pero valores consistentemente altos pueden indicar problemas de rendimiento.",
+ "statsMeanShort": "Tiempo de cuadro promedio y FPS en todas las muestras.",
+ "statsMeanLong": "La media aritmética (promedio) de todos los tiempos de cuadro medidos durante la ventana de muestreo y los FPS correspondientes. Da una buena imagen general del rendimiento pero puede estar sesgada por valores atípicos.",
+ "statsMedianShort": "Valor medio de todos los tiempos de cuadro (percentil 50).",
+ "statsMedianLong": "La mediana representa el valor central cuando todos los tiempos de cuadro se ordenan de más rápido a más lento. A diferencia de la media, la mediana no se ve afectada por valores atípicos extremos, lo que la convierte en un indicador más estable del rendimiento típico.",
+ "statsStdDevShort": "Mide la variabilidad del tiempo de cuadro. CV% es la variabilidad relativa.",
+ "statsStdDevLong": "La desviación estándar mide la variación en los tiempos de cuadro. Valores más bajos indican un rendimiento más consistente. El Coeficiente de Variación (CV%) expresa esta variabilidad como porcentaje de la media, facilitando la comparación de estabilidad entre diferentes velocidades de cuadro.",
+ "aiTranslatedTooltip": "Esta traducción fue generada por IA y puede contener errores. Si hablas este idioma, ¡puedes ayudar a mejorarla abriendo un pull request en GitHub!",
+ "humanValidatedTooltip": "Esta traducción ha sido revisada y validada por un traductor humano.",
+ "helpTranslate": "Ayuda a traducir SkellyCam",
+ "failedToFetch": "Error al obtener datos",
+ "recordings": "Grabaciones",
+ "noRecordingsFound": "No se encontraron grabaciones. Ingrese una ruta arriba para cargar manualmente.",
+ "noCamerasDetected": "No se detectaron cámaras",
+ "clickRefreshToScan": "Haga clic en actualizar para buscar cámaras disponibles",
+ "waitingForData": "Esperando datos…",
+ "load": "Cargar",
+ "refresh": "Actualizar",
+ "available": "Disponible",
+ "menuFile": "Archivo",
+ "menuView": "Ver",
+ "menuCamera": "Cámara",
+ "menuRecording": "Grabación",
+ "menuHelp": "Ayuda",
+ "menuDetectCameras": "Detectar cámaras",
+ "menuConnectCameras": "Conectar cámaras",
+ "menuCloseAllCameras": "Cerrar todas las cámaras",
+ "menuOpenRecordingFolder": "Abrir carpeta de grabación…",
+ "menuToggleSidebar": "Alternar barra lateral",
+ "menuToggleTheme": "Cambiar tema",
+ "menuToggleFullScreen": "Pantalla completa",
+ "menuPauseUnpause": "Pausar / Reanudar",
+ "menuConnectApplySettings": "Conectar / Aplicar configuración",
+ "menuCloseAll": "Cerrar todo",
+ "menuDocumentation": "Documentación",
+ "menuGitHubRepository": "Repositorio de GitHub",
+ "menuReportIssue": "Reportar un problema…",
+ "menuAbout": "Acerca de SkellyCam",
+ "menuPlayback": "Reproducción",
+ "videoPlayback": "Reproducción",
+ "copyLogsToClipboard": "Copiar registros al portapapeles",
+ "saveLogsToFile": "Guardar registros en archivo",
+ "copied": "¡Copiado!",
+ "timestampFromRecording": "Marca de tiempo de los datos de grabación",
+ "menuCheckForUpdates": "Check for Updates…",
+ "updateAvailable": "Update available",
+ "updateAvailableMessage": "Version {{version}} is available",
+ "downloading": "Downloading…",
+ "downloadComplete": "Download complete",
+ "restartToUpdate": "Restart to update",
+ "checkForUpdates": "Check for Updates",
+ "upToDate": "You are up to date",
+ "updateError": "Update check failed"
+}
diff --git a/freemocap-ui-old/src/i18n/locales/fa-farsi.json b/freemocap-ui-old/src/i18n/locales/fa-farsi.json
new file mode 100644
index 00000000..3aa03467
--- /dev/null
+++ b/freemocap-ui-old/src/i18n/locales/fa-farsi.json
@@ -0,0 +1,258 @@
+{
+ "_meta": {
+ "locale": "fa",
+ "translationSource": "ai-generated",
+ "lastUpdated": "2026-02-23"
+ },
+ "appName": "SkellyCam",
+ "appNameDecorated": "SkellyCam 💀📸",
+ "welcomeTitle": "به SkellyCam خوش آمدید",
+ "welcomeSubtitle": "ضبط و مشاهده ویدیوهای همگام‌سازی شده",
+ "sendAnonymousPings": "ارسال داده‌های استفاده ناشناس",
+ "footerWith": "با",
+ "footerFrom": "از",
+ "footerOrgName": "FreeMoCap Foundation",
+ "home": "خانه",
+ "cameras": "دوربین‌ها",
+ "videos": "ویدیوها",
+ "expandSidebar": "باز کردن نوار کناری",
+ "collapseSidebar": "بستن نوار کناری",
+ "startRecording": "شروع ضبط",
+ "stopRecording": "توقف ضبط",
+ "toggleTheme": "تغییر پوسته",
+ "switchToDark": "تغییر به حالت تاریک",
+ "switchToLight": "تغییر به حالت روشن",
+ "connectWebSocket": "اتصال WebSocket",
+ "disconnectWebSocket": "قطع اتصال WebSocket",
+ "launchServer": "راه‌اندازی سرور",
+ "stopServer": "توقف سرور",
+ "browseForExecutable": "جستجوی فایل اجرایی",
+ "refreshCandidates": "به‌روزرسانی کاندیداها",
+ "executable": "فایل اجرایی",
+ "host": "میزبان",
+ "port": "پورت",
+ "cameraCount_one": "{{count}} دوربین",
+ "cameraCount_other": "{{count}} دوربین",
+ "connectedCameras": "دوربین‌های متصل",
+ "availableCameras": "دوربین‌های موجود",
+ "noCamerasConnected": "هیچ دوربینی متصل نیست",
+ "detectCameras": "شناسایی دوربین‌های موجود",
+ "clearCameraSettings": "پاک کردن تنظیمات دوربین",
+ "copySettingsToAll": "کپی تنظیمات به همه",
+ "recordingTag": "برچسب ضبط",
+ "recordingTagPlaceholder": "برچسب اختیاری",
+ "recordingDirectory": "پوشه ضبط",
+ "recordingFolderPath": "مسیر پوشه ضبط",
+ "delayStart": "شروع تأخیری",
+ "seconds": "ثانیه",
+ "subfolder": "زیرپوشه",
+ "subfolderPlaceholder": "نام زیرپوشه",
+ "baseName": "نام پایه",
+ "increment": "افزایش",
+ "resolution": "وضوح",
+ "fps": "FPS",
+ "width": "عرض",
+ "height": "ارتفاع",
+ "columns": "ستون‌ها",
+ "auto": "خودکار",
+ "manual": "دستی",
+ "custom": "سفارشی",
+ "current": "فعلی",
+ "recommend": "پیشنهادی",
+ "cameraRotation": "چرخش دوربین",
+ "selectCameraRotation": "انتخاب چرخش تصویر دوربین",
+ "exposureControl": "کنترل نوردهی خودکار یا دستی",
+ "framerateControl": "کنترل نرخ فریم خودکار یا دستی",
+ "adjustExposure": "تنظیم زمان نوردهی",
+ "setTargetFps": "تنظیم FPS هدف برای ضبط",
+ "recordingCaptureFps": "FPS ضبط",
+ "playbackSpeed": "سرعت پخش",
+ "framerateTimeline": "خط زمانی نرخ فریم",
+ "framerateDistribution": "توزیع نرخ فریم",
+ "timelineView": "نمای خط زمانی",
+ "distributionView": "نمای توزیع",
+ "combinedView": "نمای ترکیبی",
+ "min": "حداقل",
+ "max": "حداکثر",
+ "mean": "میانگین",
+ "median": "میانه",
+ "stdDevCv": "انحراف/CV",
+ "source": "منبع",
+ "selectAll": "انتخاب همه",
+ "loadSynchronizedVideos": "بارگذاری ویدیوهای همگام",
+ "loadSynchronizedVideosDescription": "این صفحه به شما امکان بارگذاری و همگام‌سازی ویدیوهای از پیش ضبط شده را می‌دهد.",
+ "automaticallySynchronizeVideos": "همگام‌سازی خودکار ویدیوها",
+ "extractFramesOnLoad": "استخراج فریم‌ها هنگام بارگذاری",
+ "generateThumbnails": "ایجاد تصاویر بندانگشتی",
+ "noVideosLoaded": "هیچ ویدیویی بارگذاری نشده",
+ "filterVideos": "فیلتر ویدیوها...",
+ "openVideo": "باز کردن ویدیو",
+ "openFolder": "باز کردن پوشه در مدیریت فایل",
+ "videoFolderPath": "مسیر پوشه ویدیو",
+ "jumpToStart": "رفتن به ابتدا (Home)",
+ "jumpToEnd": "رفتن به انتها (End)",
+ "loopOn": "حلقه روشن است (L برای تغییر وضعیت)",
+ "loopOff": "پخش حلقه‌ای (L)",
+ "syncInfo": "اطلاعات همگام‌سازی",
+ "syncInfoTitle": "همگام‌سازی چند دوربین ممکن است در سطح فریم دقیق نباشد",
+ "syncInfoBody": "پخش ویدیو در مرورگر همگام‌سازی دقیق نمونه‌ای را در چندین جریان تضمین نمی‌کند. پخش‌کننده از استراتژی رهبر-پیرو استفاده می‌کند و انحراف را زمانی که از تحمل کوچکی فراتر رود اصلاح می‌کند، اما عدم همگام‌سازی جزئی (1–2 فریم) ممکن است رخ دهد، به‌ویژه در سرعت‌های پخش بالا یا زمانی که مرورگر تحت بار است. برای تحلیل دقیق در سطح فریم، از فایل‌های CSV برچسب زمانی خام موجود در هر ضبط استفاده کنید.",
+ "previousFrame": "فریم قبلی (← / Shift+← برای 10)",
+ "nextFrame": "فریم بعدی (→ / Shift+→ برای 10)",
+ "zoomIn": "بزرگنمایی",
+ "zoomOut": "کوچکنمایی",
+ "resetZoom": "بازنشانی بزرگنمایی",
+ "playbackSettings": "تنظیمات پخش",
+ "totalRecordingSize": "اندازه کل ضبط روی دیسک",
+ "estimatedTime": "زمان تخمینی (فریم ÷ fps)",
+ "estimatedDuration": "مدت تخمینی (کل فریم‌ها ÷ fps)",
+ "estimatedFromFrameNumber": "تخمین از شماره فریم × fps",
+ "frameCountPerCamera": "تعداد فریم به ازای هر دوربین",
+ "cameraStreams": "جریان‌های دوربین در این ضبط",
+ "backToRecordings": "بازگشت به ضبط‌ها",
+ "errorsDetected": "خطاهایی شناسایی شد",
+ "somethingWentWrong": "مشکلی پیش آمد :(",
+ "searchLogs": "جستجوی گزارش‌ها...",
+ "filter": "فیلتر…",
+ "refreshMicrophoneList": "به‌روزرسانی لیست میکروفون‌ها",
+ "date": "تاریخ",
+ "name": "نام",
+ "size": "اندازه",
+ "duration": "مدت",
+ "frames": "فریم‌ها",
+ "timestamp": "مهر زمانی",
+ "language": "زبان",
+ "aiTranslated": "ترجمه هوش مصنوعی",
+ "humanTranslated": "ترجمه انسانی",
+ "humanValidated": "تأیید شده توسط انسان",
+ "connectCameras": "اتصال به دوربین‌های انتخاب شده",
+ "resumeStreaming": "ازسرگیری پخش زنده",
+ "pauseStreaming": "توقف پخش زنده",
+ "closeAllCameras": "بستن همه دوربین‌ها",
+ "framerate": "نرخ فریم",
+ "exposure": "نوردهی",
+ "fileLabel": "فایل",
+ "timeDelta": "اختلاف زمان",
+ "pathLabel": "مسیر",
+ "exceptionDetails": "جزئیات استثنا",
+ "stackTrace": "ردیابی پشته",
+ "loadingVideos": "بارگذاری ویدیوها… ({{ready}}/{{total}} آماده)",
+ "gridColumns": "ستون‌های شبکه",
+ "settings": "تنظیمات",
+ "appearance": "ظاهر",
+ "themeMode": "پوسته",
+ "darkMode": "تاریک",
+ "lightMode": "روشن",
+ "languageSettings": "زبان و بومی‌سازی",
+ "showTranslationIndicator": "نمایش نشانگر منبع ترجمه",
+ "showTranslationIndicatorDescription": "نمایش نشان هنگام استفاده از ترجمه‌های AI",
+ "translationSourceLabel": "منبع ترجمه",
+ "general": "عمومی",
+ "about": "درباره",
+ "version": "نسخه",
+ "serverSettings": "سرور",
+ "recordingSettings": "تنظیمات ضبط",
+ "videoLoadingSettings": "تنظیمات بارگذاری ویدیو",
+ "connected": "متصل",
+ "connecting": "در حال اتصال…",
+ "disconnected": "قطع شده",
+ "disconnect": "قطع اتصال",
+ "connect": "اتصال",
+ "off": "خاموش",
+ "running": "در حال اجرا",
+ "stopped": "متوقف",
+ "working": "در حال پردازش…",
+ "invalid": "نامعتبر",
+ "autoLaunch": "راه‌اندازی خودکار",
+ "autoConnect": "اتصال خودکار",
+ "runningPath": "در حال اجرا: {{path}}",
+ "noMicrophone": "بدون میکروفون",
+ "audioRecordingEnabled": "ضبط صدا فعال",
+ "noMicrophoneSelected": "میکروفونی انتخاب نشده",
+ "recordingName": "نام ضبط: {{name}}",
+ "startingIn": "شروع در {{countdown}}...",
+ "stopping": "در حال توقف...",
+ "starting": "در حال شروع...",
+ "stopRecordingButton": "🔴 توقف ضبط",
+ "startRecordingButton": "🔴 شروع ضبط",
+ "camerasCount": "دوربین‌ها ({{count}})",
+ "availableCamerasCount": "موجود ({{count}})",
+ "server": "سرور",
+ "display": "نمایش",
+ "rawMessage": "پیام خام",
+ "cameraPerformanceMetrics": "معیارهای عملکرد دوربین",
+ "serverLogs": "گزارش‌های سرور",
+ "sortBy": "مرتب‌سازی {{direction}}",
+ "waitingForCameraStreams": "در انتظار جریان‌های دوربین...",
+ "loggingPaused": "ثبت وقایع متوقف",
+ "noLogsToDisplay": "هیچ گزارشی برای نمایش نیست",
+ "closeSettings": "بستن تنظیمات",
+ "gridSettings": "تنظیمات شبکه",
+ "clickToShowLess": "برای نمایش کمتر کلیک کنید",
+ "clickToLearnMore": "برای اطلاعات بیشتر کلیک کنید",
+ "samples": "نمونه",
+ "framerateOverTime": "نرخ فریم در طول زمان",
+ "framerateFps": "نرخ فریم (fps)",
+ "capturesFramesFromCamera": "فریم‌ها را از دوربین ضبط می‌کند.",
+ "rendersReceivedFrames": "فریم‌های دریافتی را روی صفحه رندر می‌کند.",
+ "displayTooltipLong": "نمایش عملکرد رندر رابط کاربری را نشان می‌دهد. نشان می‌دهد نمایشگر شما چقدر سریع فریم‌ها را دریافت و رندر می‌کند. مشکلات عملکردی در اینجا کیفیت ضبط را تحت تأثیر قرار نمی‌دهد اما ممکن است بر توانایی شما در نظارت بر دوربین‌ها در زمان واقعی تأثیر بگذارد.",
+ "statsSourceShort": "نمایشگر فریم‌ها را رندر می‌کند، سرور فریم‌ها را ضبط می‌کند.",
+ "statsSourceLong": "سرور نرخ واقعی است که فریم‌ها از دوربین کشیده/ضبط می‌شوند، در حالی که نمایش نرخ دریافت و رندر آنهاست. SkellyCam عملکرد سمت سرور را برای کیفیت ضبط اولویت می‌دهد، بنابراین این عدد باید پایدارتر بماند. اگر نرخ فریم نمایش از سرور منحرف شود، نشان‌دهنده فشار بر منابع سیستم شماست. استفاده از دوربین‌های کمتر یا کاهش نرخ فریم/وضوح را در نظر بگیرید.",
+ "statsCurrentShort": "آخرین زمان فریم و FPS.",
+ "statsCurrentLong": "این آخرین اندازه‌گیری مدت زمان پردازش یک فریم (به میلی‌ثانیه) و معادل فریم در ثانیه (FPS) را نشان می‌دهد. زمان فریم کمتر و FPS بالاتر نشان‌دهنده عملکرد بهتر است.",
+ "statsMinShort": "سریع‌ترین زمان فریم و بالاترین FPS.",
+ "statsMinLong": "این حداقل زمان پردازش یک فریم در طول پنجره نمونه‌برداری را نشان می‌دهد. مطابق با حداکثر FPS است که سیستم شما در شرایط مطلوب به دست آورده است.",
+ "statsMaxShort": "کندترین زمان فریم و کمترین FPS.",
+ "statsMaxLong": "این حداکثر زمان پردازش یک فریم در طول پنجره نمونه‌برداری را نشان می‌دهد. مطابق با حداقل FPS در بدترین شرایط است. افزایش‌های گاه‌به‌گاه عادی است، اما مقادیر بالای مداوم ممکن است نشان‌دهنده مشکلات عملکردی باشد.",
+ "statsMeanShort": "میانگین زمان فریم و FPS در تمام نمونه‌ها.",
+ "statsMeanLong": "میانگین حسابی تمام زمان‌های فریم اندازه‌گیری شده در طول پنجره نمونه‌برداری و FPS مربوطه. تصویر کلی خوبی از عملکرد ارائه می‌دهد اما ممکن است تحت تأثیر مقادیر پرت قرار گیرد.",
+ "statsMedianShort": "مقدار میانه همه زمان‌های فریم (صدک 50).",
+ "statsMedianLong": "میانه مقدار وسط را نشان می‌دهد وقتی همه زمان‌های فریم از سریع‌ترین به آهسته‌ترین مرتب شوند. برخلاف میانگین، میانه تحت تأثیر مقادیر پرت افراطی قرار نمی‌گیرد، که آن را به شاخص پایدارتری از عملکرد معمول تبدیل می‌کند.",
+ "statsStdDevShort": "تغییرپذیری زمان فریم را اندازه‌گیری می‌کند.",
+ "statsStdDevLong": "انحراف معیار میزان تغییرات در زمان‌های فریم را اندازه‌گیری می‌کند. مقادیر کمتر نشان‌دهنده عملکرد سازگارتر است. ضریب تغییرات (CV%) این تغییرپذیری را به صورت درصدی از میانگین بیان می‌کند، که مقایسه پایداری در نرخ‌های فریم مختلف را آسان‌تر می‌کند. CV% کمتر نشان‌دهنده عملکرد پایدارتر است.",
+ "aiTranslatedTooltip": "این ترجمه توسط هوش مصنوعی تولید شده و ممکن است خطاهایی داشته باشد. اگر این زبان را صحبت می‌کنید، به بهبود آن کمک کنید!",
+ "humanValidatedTooltip": "این ترجمه توسط مترجم انسانی بررسی شده است.",
+ "helpTranslate": "به ترجمه SkellyCam کمک کنید",
+ "failedToFetch": "دریافت ناموفق",
+ "recordings": "ضبط‌ها",
+ "noRecordingsFound": "هیچ ضبطی یافت نشد. برای بارگذاری دستی، مسیری در بالا وارد کنید.",
+ "noCamerasDetected": "هیچ دوربینی شناسایی نشد",
+ "clickRefreshToScan": "برای جستجوی دوربین‌های موجود روی به‌روزرسانی کلیک کنید",
+ "waitingForData": "در انتظار داده…",
+ "load": "بارگذاری",
+ "refresh": "به‌روزرسانی",
+ "available": "موجود",
+ "menuFile": "فایل",
+ "menuView": "نمایش",
+ "menuCamera": "دوربین",
+ "menuRecording": "ضبط",
+ "menuHelp": "راهنما",
+ "menuDetectCameras": "شناسایی دوربین‌ها",
+ "menuConnectCameras": "اتصال دوربین‌ها",
+ "menuCloseAllCameras": "بستن همه دوربین‌ها",
+ "menuOpenRecordingFolder": "باز کردن پوشه ضبط…",
+ "menuToggleSidebar": "نوار کناری",
+ "menuToggleTheme": "تغییر پوسته",
+ "menuToggleFullScreen": "تمام صفحه",
+ "menuPauseUnpause": "مکث / ادامه",
+ "menuConnectApplySettings": "اتصال / اعمال تنظیمات",
+ "menuCloseAll": "بستن همه",
+ "menuDocumentation": "مستندات",
+ "menuGitHubRepository": "مخزن GitHub",
+ "menuReportIssue": "گزارش مشکل…",
+ "menuAbout": "درباره SkellyCam",
+ "menuPlayback": "پخش",
+ "videoPlayback": "پخش",
+ "copyLogsToClipboard": "کپی گزارش‌ها در کلیپ‌بورد",
+ "saveLogsToFile": "ذخیره گزارش‌ها در فایل",
+ "copied": "کپی شد!",
+ "timestampFromRecording": "مهر زمانی از داده‌های ضبط",
+ "menuCheckForUpdates": "Check for Updates…",
+ "updateAvailable": "Update available",
+ "updateAvailableMessage": "Version {{version}} is available",
+ "downloading": "Downloading…",
+ "downloadComplete": "Download complete",
+ "restartToUpdate": "Restart to update",
+ "checkForUpdates": "Check for Updates",
+ "upToDate": "You are up to date",
+ "updateError": "Update check failed"
+}
diff --git a/freemocap-ui-old/src/i18n/locales/fr-francais.json b/freemocap-ui-old/src/i18n/locales/fr-francais.json
new file mode 100644
index 00000000..90765405
--- /dev/null
+++ b/freemocap-ui-old/src/i18n/locales/fr-francais.json
@@ -0,0 +1,258 @@
+{
+ "_meta": {
+ "locale": "fr",
+ "translationSource": "ai-generated",
+ "lastUpdated": "2026-02-23"
+ },
+ "appName": "SkellyCam",
+ "appNameDecorated": "SkellyCam 💀📸",
+ "welcomeTitle": "Bienvenue sur SkellyCam",
+ "welcomeSubtitle": "Enregistrez et visionnez des vidéos synchronisées",
+ "sendAnonymousPings": "Envoyer des données d'utilisation anonymes",
+ "footerWith": "avec",
+ "footerFrom": "de la",
+ "footerOrgName": "FreeMoCap Foundation",
+ "home": "Accueil",
+ "cameras": "Caméras",
+ "videos": "Vidéos",
+ "expandSidebar": "Développer la barre latérale",
+ "collapseSidebar": "Réduire la barre latérale",
+ "startRecording": "Démarrer l'enregistrement",
+ "stopRecording": "Arrêter l'enregistrement",
+ "toggleTheme": "changer le thème",
+ "switchToDark": "Passer au mode sombre",
+ "switchToLight": "Passer au mode clair",
+ "connectWebSocket": "Connecter WebSocket",
+ "disconnectWebSocket": "Déconnecter WebSocket",
+ "launchServer": "Lancer le serveur",
+ "stopServer": "Arrêter le serveur",
+ "browseForExecutable": "Rechercher l'exécutable",
+ "refreshCandidates": "Actualiser les candidats",
+ "executable": "Exécutable",
+ "host": "Hôte",
+ "port": "Port",
+ "cameraCount_one": "{{count}} caméra",
+ "cameraCount_other": "{{count}} caméras",
+ "connectedCameras": "Caméras connectées",
+ "availableCameras": "Caméras disponibles",
+ "noCamerasConnected": "Aucune caméra connectée",
+ "detectCameras": "Détecter les caméras disponibles",
+ "clearCameraSettings": "Effacer les paramètres de caméra sauvegardés",
+ "copySettingsToAll": "Copier les paramètres sur toutes les caméras",
+ "recordingTag": "Étiquette d'enregistrement",
+ "recordingTagPlaceholder": "Étiquette optionnelle",
+ "recordingDirectory": "Répertoire d'enregistrement",
+ "recordingFolderPath": "Chemin du dossier d'enregistrement",
+ "delayStart": "Démarrage différé",
+ "seconds": "Secondes",
+ "subfolder": "Sous-dossier",
+ "subfolderPlaceholder": "Nom du sous-dossier",
+ "baseName": "Nom de base",
+ "increment": "Incrément",
+ "resolution": "Résolution",
+ "fps": "FPS",
+ "width": "Largeur",
+ "height": "Hauteur",
+ "columns": "Colonnes",
+ "auto": "Auto",
+ "manual": "Manuel",
+ "custom": "Personnalisé",
+ "current": "Actuel",
+ "recommend": "Recommandé",
+ "cameraRotation": "rotation de la caméra",
+ "selectCameraRotation": "Sélectionner la rotation de l'image",
+ "exposureControl": "Choisir entre contrôle d'exposition automatique ou manuel",
+ "framerateControl": "Choisir entre contrôle de fréquence d'images automatique ou manuel",
+ "adjustExposure": "Ajuster le temps d'exposition",
+ "setTargetFps": "Définir le FPS cible pour la capture",
+ "recordingCaptureFps": "FPS de capture d'enregistrement",
+ "playbackSpeed": "Vitesse de lecture (n'affecte pas le FPS d'enregistrement)",
+ "framerateTimeline": "Chronologie des images/s",
+ "framerateDistribution": "Distribution des images/s",
+ "timelineView": "Vue chronologique",
+ "distributionView": "Vue de distribution",
+ "combinedView": "Vue combinée",
+ "min": "Min",
+ "max": "Max",
+ "mean": "Moyenne",
+ "median": "Médiane",
+ "stdDevCv": "ÉcType/CV",
+ "source": "Source",
+ "selectAll": "Tout sélectionner",
+ "loadSynchronizedVideos": "Charger des vidéos synchronisées",
+ "loadSynchronizedVideosDescription": "Cette page vous permet de charger et synchroniser des vidéos pré-enregistrées.",
+ "automaticallySynchronizeVideos": "Synchroniser automatiquement les vidéos",
+ "extractFramesOnLoad": "Extraire les images au chargement",
+ "generateThumbnails": "Générer des miniatures",
+ "noVideosLoaded": "Aucune vidéo chargée",
+ "filterVideos": "Filtrer les vidéos...",
+ "openVideo": "Ouvrir la vidéo",
+ "openFolder": "Ouvrir le dossier dans l'explorateur",
+ "videoFolderPath": "Chemin du dossier vidéo",
+ "jumpToStart": "Aller au début (Home)",
+ "jumpToEnd": "Aller à la fin (End)",
+ "loopOn": "Boucle activée (L pour basculer)",
+ "loopOff": "Lecture en boucle (L)",
+ "syncInfo": "Info de synchronisation",
+ "syncInfoTitle": "La synchronisation multicaméra peut ne pas être parfaite au niveau de l'image",
+ "syncInfoBody": "La lecture vidéo dans le navigateur ne garantit pas une synchronisation précise au niveau de l'échantillon sur plusieurs flux. Le lecteur utilise une stratégie leader-suiveur et corrige la dérive lorsqu'elle dépasse une petite tolérance, mais une légère désynchronisation (1–2 images) peut se produire, en particulier à des vitesses de lecture élevées ou lorsque le navigateur est sous charge. Pour une analyse précise au niveau de l'image, utilisez les fichiers CSV d'horodatage bruts inclus dans chaque enregistrement.",
+ "previousFrame": "Image précédente (← / Shift+← pour 10)",
+ "nextFrame": "Image suivante (→ / Shift+→ pour 10)",
+ "zoomIn": "Zoom avant",
+ "zoomOut": "Zoom arrière",
+ "resetZoom": "Réinitialiser le zoom",
+ "playbackSettings": "Paramètres de lecture",
+ "totalRecordingSize": "Taille totale de l'enregistrement sur le disque",
+ "estimatedTime": "Temps estimé (image ÷ fps d'enregistrement)",
+ "estimatedDuration": "Durée estimée (images totales ÷ fps d'enregistrement)",
+ "estimatedFromFrameNumber": "Estimé à partir du numéro d'image × fps d'enregistrement",
+ "frameCountPerCamera": "Nombre d'images par caméra",
+ "cameraStreams": "Flux de caméra dans cet enregistrement",
+ "backToRecordings": "Retour aux enregistrements",
+ "errorsDetected": "Erreurs détectées",
+ "somethingWentWrong": "Quelque chose s'est mal passé :(",
+ "searchLogs": "Rechercher dans les journaux...",
+ "filter": "Filtrer…",
+ "refreshMicrophoneList": "Actualiser la liste des microphones",
+ "date": "Date",
+ "name": "Nom",
+ "size": "Taille",
+ "duration": "Durée",
+ "frames": "Images",
+ "timestamp": "Horodatage",
+ "language": "Langue",
+ "aiTranslated": "Traduction IA",
+ "humanTranslated": "Traduction humaine",
+ "humanValidated": "Validé par un humain",
+ "connectCameras": "Connecter aux caméras sélectionnées",
+ "resumeStreaming": "Reprendre le flux",
+ "pauseStreaming": "Suspendre le flux",
+ "closeAllCameras": "Fermer toutes les caméras",
+ "framerate": "Fréquence d'images",
+ "exposure": "Exposition",
+ "fileLabel": "Fichier",
+ "timeDelta": "Delta temporel",
+ "pathLabel": "Chemin",
+ "exceptionDetails": "Détails de l'exception",
+ "stackTrace": "Trace de pile",
+ "loadingVideos": "Chargement des vidéos… ({{ready}}/{{total}} prêtes)",
+ "gridColumns": "Colonnes de grille",
+ "settings": "Paramètres",
+ "appearance": "Apparence",
+ "themeMode": "Thème",
+ "darkMode": "Sombre",
+ "lightMode": "Clair",
+ "languageSettings": "Langue et localisation",
+ "showTranslationIndicator": "Afficher l'indicateur de source de traduction",
+ "showTranslationIndicatorDescription": "Afficher un badge lors de l'utilisation de traductions IA",
+ "translationSourceLabel": "Source de traduction",
+ "general": "Général",
+ "about": "À propos",
+ "version": "Version",
+ "serverSettings": "Serveur",
+ "recordingSettings": "Paramètres d'enregistrement",
+ "videoLoadingSettings": "Paramètres de chargement vidéo",
+ "connected": "Connecté",
+ "connecting": "Connexion…",
+ "disconnected": "Déconnecté",
+ "disconnect": "Déconnecter",
+ "connect": "Connecter",
+ "off": "Désactivé",
+ "running": "En cours",
+ "stopped": "Arrêté",
+ "working": "En cours…",
+ "invalid": "Invalide",
+ "autoLaunch": "Lancement auto",
+ "autoConnect": "Connexion auto",
+ "runningPath": "En cours : {{path}}",
+ "noMicrophone": "Pas de microphone",
+ "audioRecordingEnabled": "Enregistrement audio activé",
+ "noMicrophoneSelected": "Aucun microphone sélectionné",
+ "recordingName": "Nom de l'enregistrement : {{name}}",
+ "startingIn": "Démarrage dans {{countdown}}...",
+ "stopping": "Arrêt...",
+ "starting": "Démarrage...",
+ "stopRecordingButton": "🔴 Arrêter l'enregistrement",
+ "startRecordingButton": "🔴 Démarrer l'enregistrement",
+ "camerasCount": "Caméras ({{count}})",
+ "availableCamerasCount": "Disponibles ({{count}})",
+ "server": "Serveur",
+ "display": "Affichage",
+ "rawMessage": "Message brut",
+ "cameraPerformanceMetrics": "Métriques de performance caméra",
+ "serverLogs": "Journaux du serveur",
+ "sortBy": "Trier {{direction}}",
+ "waitingForCameraStreams": "En attente des flux de caméra...",
+ "loggingPaused": "Journalisation en pause",
+ "noLogsToDisplay": "Aucun journal à afficher",
+ "closeSettings": "Fermer les paramètres",
+ "gridSettings": "Paramètres de grille",
+ "clickToShowLess": "Cliquer pour réduire",
+ "clickToLearnMore": "Cliquer pour en savoir plus",
+ "samples": "échantillons",
+ "framerateOverTime": "Fréquence d'images dans le temps",
+ "framerateFps": "Images/s (fps)",
+ "capturesFramesFromCamera": "Capture les images depuis la caméra.",
+ "rendersReceivedFrames": "Affiche les images reçues à l'écran.",
+ "displayTooltipLong": "L'affichage représente les performances de rendu de l'interface utilisateur. Il montre la rapidité avec laquelle votre écran reçoit et affiche les images. Les problèmes de performances ici n'affecteront pas la qualité d'enregistrement mais peuvent impacter votre capacité à surveiller les caméras en temps réel.",
+ "statsSourceShort": "L'affichage rend les images, le serveur les capture.",
+ "statsSourceLong": "Le serveur est le taux réel auquel les images sont extraites/enregistrées depuis la caméra, tandis que l'affichage est le taux auquel elles sont reçues et rendues. SkellyCam priorise les performances côté serveur pour la qualité d'enregistrement, donc ce nombre devrait rester plus stable. Si la fréquence d'images de l'affichage diverge du serveur, cela indique que les ressources de votre système sont sollicitées. Envisagez d'utiliser moins de caméras ou de réduire la fréquence d'images/résolution.",
+ "statsCurrentShort": "Temps d'image et FPS les plus récents.",
+ "statsCurrentLong": "Affiche la mesure la plus récente du temps de traitement d'une image (en millisecondes) et les images par seconde (FPS) correspondantes. Des temps d'image plus bas et des FPS plus élevés indiquent de meilleures performances.",
+ "statsMinShort": "Temps d'image le plus rapide et FPS le plus élevé.",
+ "statsMinLong": "Représente le temps minimum de traitement d'une image pendant la fenêtre d'échantillonnage. Correspond au FPS maximum atteint par votre système dans des conditions optimales.",
+ "statsMaxShort": "Temps d'image le plus lent et FPS le plus bas.",
+ "statsMaxLong": "Représente le temps maximum de traitement d'une image pendant la fenêtre d'échantillonnage. Correspond au FPS minimum dans les pires conditions. Des pics occasionnels sont normaux, mais des valeurs élevées constantes peuvent indiquer des problèmes de performances.",
+ "statsMeanShort": "Temps d'image moyen et FPS sur tous les échantillons.",
+ "statsMeanLong": "La moyenne arithmétique de tous les temps d'image mesurés pendant la fenêtre d'échantillonnage et les FPS correspondants. Donne une bonne vue d'ensemble des performances mais peut être biaisée par les valeurs extrêmes.",
+ "statsMedianShort": "Valeur médiane de tous les temps d'image (50e percentile).",
+ "statsMedianLong": "La médiane représente la valeur centrale lorsque tous les temps d'image sont triés du plus rapide au plus lent. Contrairement à la moyenne, la médiane n'est pas affectée par les valeurs extrêmes, ce qui en fait un indicateur plus stable des performances typiques.",
+ "statsStdDevShort": "Mesure la variabilité du temps d'image.",
+ "statsStdDevLong": "L'écart-type mesure la variation des temps d'image. Des valeurs plus basses indiquent des performances plus régulières. Le coefficient de variation (CV%) exprime cette variabilité en pourcentage de la moyenne, facilitant la comparaison de la stabilité entre différentes fréquences d'images. Un CV% plus bas indique des performances plus stables.",
+ "aiTranslatedTooltip": "Cette traduction a été générée par IA et peut contenir des erreurs. Si vous parlez cette langue, aidez-nous à l'améliorer !",
+ "humanValidatedTooltip": "Cette traduction a été vérifiée par un traducteur humain.",
+ "helpTranslate": "Aider à traduire SkellyCam",
+ "failedToFetch": "Échec de la récupération",
+ "recordings": "Enregistrements",
+ "noRecordingsFound": "Aucun enregistrement trouvé. Entrez un chemin ci-dessus pour charger manuellement.",
+ "noCamerasDetected": "Aucune caméra détectée",
+ "clickRefreshToScan": "Cliquez sur actualiser pour rechercher les caméras disponibles",
+ "waitingForData": "En attente de données…",
+ "load": "Charger",
+ "refresh": "Actualiser",
+ "available": "Disponible",
+ "menuFile": "Fichier",
+ "menuView": "Affichage",
+ "menuCamera": "Caméra",
+ "menuRecording": "Enregistrement",
+ "menuHelp": "Aide",
+ "menuDetectCameras": "Détecter les caméras",
+ "menuConnectCameras": "Connecter les caméras",
+ "menuCloseAllCameras": "Fermer toutes les caméras",
+ "menuOpenRecordingFolder": "Ouvrir le dossier d'enregistrement…",
+ "menuToggleSidebar": "Basculer la barre latérale",
+ "menuToggleTheme": "Changer le thème",
+ "menuToggleFullScreen": "Basculer en plein écran",
+ "menuPauseUnpause": "Pause / Reprendre",
+ "menuConnectApplySettings": "Connecter / Appliquer les paramètres",
+ "menuCloseAll": "Tout fermer",
+ "menuDocumentation": "Documentation",
+ "menuGitHubRepository": "Dépôt GitHub",
+ "menuReportIssue": "Signaler un problème…",
+ "menuAbout": "À propos de SkellyCam",
+ "menuPlayback": "Lecture",
+ "videoPlayback": "Lecture",
+ "copyLogsToClipboard": "Copier les journaux dans le presse-papiers",
+ "saveLogsToFile": "Enregistrer les journaux dans un fichier",
+ "copied": "Copié !",
+ "timestampFromRecording": "Horodatage des données d'enregistrement",
+ "menuCheckForUpdates": "Check for Updates…",
+ "updateAvailable": "Update available",
+ "updateAvailableMessage": "Version {{version}} is available",
+ "downloading": "Downloading…",
+ "downloadComplete": "Download complete",
+ "restartToUpdate": "Restart to update",
+ "checkForUpdates": "Check for Updates",
+ "upToDate": "You are up to date",
+ "updateError": "Update check failed"
+}
diff --git a/freemocap-ui-old/src/i18n/locales/hi-hindi.json b/freemocap-ui-old/src/i18n/locales/hi-hindi.json
new file mode 100644
index 00000000..93a03c2c
--- /dev/null
+++ b/freemocap-ui-old/src/i18n/locales/hi-hindi.json
@@ -0,0 +1,258 @@
+{
+ "_meta": {
+ "locale": "hi",
+ "translationSource": "ai-generated",
+ "lastUpdated": "2026-02-23"
+ },
+ "appName": "SkellyCam",
+ "appNameDecorated": "SkellyCam 💀📸",
+ "welcomeTitle": "SkellyCam में आपका स्वागत है",
+ "welcomeSubtitle": "सिंक्रनाइज़्ड वीडियो रिकॉर्ड और देखें",
+ "sendAnonymousPings": "गुमनाम उपयोग डेटा भेजें",
+ "footerWith": "साथ",
+ "footerFrom": "से",
+ "footerOrgName": "FreeMoCap Foundation",
+ "home": "होम",
+ "cameras": "कैमरे",
+ "videos": "वीडियो",
+ "expandSidebar": "साइडबार विस्तारित करें",
+ "collapseSidebar": "साइडबार संक्षिप्त करें",
+ "startRecording": "रिकॉर्डिंग शुरू करें",
+ "stopRecording": "रिकॉर्डिंग बंद करें",
+ "toggleTheme": "थीम बदलें",
+ "switchToDark": "डार्क मोड में बदलें",
+ "switchToLight": "लाइट मोड में बदलें",
+ "connectWebSocket": "WebSocket कनेक्ट करें",
+ "disconnectWebSocket": "WebSocket डिस्कनेक्ट करें",
+ "launchServer": "सर्वर शुरू करें",
+ "stopServer": "सर्वर बंद करें",
+ "browseForExecutable": "निष्पादन योग्य फ़ाइल खोजें",
+ "refreshCandidates": "उम्मीदवारों को ताज़ा करें",
+ "executable": "निष्पादन योग्य",
+ "host": "होस्ट",
+ "port": "पोर्ट",
+ "cameraCount_one": "{{count}} कैमरा",
+ "cameraCount_other": "{{count}} कैमरे",
+ "connectedCameras": "कनेक्टेड कैमरे",
+ "availableCameras": "उपलब्ध कैमरे",
+ "noCamerasConnected": "कोई कैमरा कनेक्ट नहीं है",
+ "detectCameras": "उपलब्ध कैमरे खोजें",
+ "clearCameraSettings": "सहेजी गई कैमरा सेटिंग्स मिटाएं",
+ "copySettingsToAll": "सभी कैमरों में सेटिंग्स कॉपी करें",
+ "recordingTag": "रिकॉर्डिंग टैग",
+ "recordingTagPlaceholder": "वैकल्पिक टैग",
+ "recordingDirectory": "रिकॉर्डिंग निर्देशिका",
+ "recordingFolderPath": "रिकॉर्डिंग फ़ोल्डर पथ",
+ "delayStart": "विलंबित शुरुआत",
+ "seconds": "सेकंड",
+ "subfolder": "उप-फ़ोल्डर",
+ "subfolderPlaceholder": "उप-फ़ोल्डर नाम",
+ "baseName": "आधार नाम",
+ "increment": "वृद्धि",
+ "resolution": "रिज़ॉल्यूशन",
+ "fps": "FPS",
+ "width": "चौड़ाई",
+ "height": "ऊंचाई",
+ "columns": "स्तंभ",
+ "auto": "स्वचालित",
+ "manual": "मैनुअल",
+ "custom": "कस्टम",
+ "current": "वर्तमान",
+ "recommend": "अनुशंसित",
+ "cameraRotation": "कैमरा रोटेशन",
+ "selectCameraRotation": "कैमरा छवि रोटेशन चुनें",
+ "exposureControl": "स्वचालित या मैनुअल एक्सपोज़र नियंत्रण चुनें",
+ "framerateControl": "स्वचालित या मैनुअल फ्रेमरेट नियंत्रण चुनें",
+ "adjustExposure": "एक्सपोज़र समय समायोजित करें",
+ "setTargetFps": "कैमरा कैप्चर के लिए लक्ष्य FPS सेट करें",
+ "recordingCaptureFps": "रिकॉर्डिंग कैप्चर फ्रेमरेट",
+ "playbackSpeed": "प्लेबैक गति (रिकॉर्डिंग FPS प्रभावित नहीं होता)",
+ "framerateTimeline": "फ्रेमरेट टाइमलाइन",
+ "framerateDistribution": "फ्रेमरेट वितरण",
+ "timelineView": "टाइमलाइन दृश्य",
+ "distributionView": "वितरण दृश्य",
+ "combinedView": "संयुक्त दृश्य",
+ "min": "न्यूनतम",
+ "max": "अधिकतम",
+ "mean": "औसत",
+ "median": "मध्यमान",
+ "stdDevCv": "मानक विचलन/CV",
+ "source": "स्रोत",
+ "selectAll": "सभी चुनें",
+ "loadSynchronizedVideos": "सिंक्रनाइज़्ड वीडियो लोड करें",
+ "loadSynchronizedVideosDescription": "यह पेज आपको पूर्व-रिकॉर्ड किए गए वीडियो लोड और सिंक्रनाइज़ करने देगा।",
+ "automaticallySynchronizeVideos": "वीडियो स्वचालित रूप से सिंक्रनाइज़ करें",
+ "extractFramesOnLoad": "लोड पर फ्रेम निकालें",
+ "generateThumbnails": "थंबनेल बनाएं",
+ "noVideosLoaded": "कोई वीडियो लोड नहीं है",
+ "filterVideos": "वीडियो फ़िल्टर करें...",
+ "openVideo": "वीडियो खोलें",
+ "openFolder": "फ़ाइल एक्सप्लोरर में फ़ोल्डर खोलें",
+ "videoFolderPath": "वीडियो फ़ोल्डर पथ",
+ "jumpToStart": "शुरू में जाएं (Home)",
+ "jumpToEnd": "अंत में जाएं (End)",
+ "loopOn": "लूप चालू है (टॉगल करने के लिए L)",
+ "loopOff": "लूप प्लेबैक (L)",
+ "syncInfo": "सिंक जानकारी",
+ "syncInfoTitle": "मल्टी-कैमरा सिंक फ्रेम-परफेक्ट नहीं हो सकता",
+ "syncInfoBody": "ब्राउज़र वीडियो प्लेबैक कई स्ट्रीम पर सैंपल-सटीक सिंक्रोनाइज़ेशन की गारंटी नहीं देता। प्लेयर लीडर-फॉलोअर रणनीति का उपयोग करता है और ड्रिफ्ट को ठीक करता है जब यह एक छोटी सहनशीलता से अधिक हो जाता है, लेकिन मामूली डिसिंक्रोनाइज़ेशन (1–2 फ्रेम) हो सकता है, विशेष रूप से उच्च प्लेबैक गति पर या जब ब्राउज़र लोड में हो। फ्रेम-सटीक विश्लेषण के लिए, प्रत्येक रिकॉर्डिंग में शामिल कच्चे टाइमस्टैंप CSV फ़ाइलों का उपयोग करें।",
+ "previousFrame": "पिछला फ्रेम (← / Shift+← 10 के लिए)",
+ "nextFrame": "अगला फ्रेम (→ / Shift+→ 10 के लिए)",
+ "zoomIn": "ज़ूम इन",
+ "zoomOut": "ज़ूम आउट",
+ "resetZoom": "ज़ूम रीसेट",
+ "playbackSettings": "प्लेबैक सेटिंग्स",
+ "totalRecordingSize": "डिस्क पर कुल रिकॉर्डिंग आकार",
+ "estimatedTime": "अनुमानित समय (फ्रेम ÷ रिकॉर्डिंग fps)",
+ "estimatedDuration": "अनुमानित अवधि (कुल फ्रेम ÷ रिकॉर्डिंग fps)",
+ "estimatedFromFrameNumber": "फ्रेम संख्या × रिकॉर्डिंग fps से अनुमानित",
+ "frameCountPerCamera": "प्रति कैमरा फ्रेम गणना",
+ "cameraStreams": "इस रिकॉर्डिंग में कैमरा स्ट्रीम",
+ "backToRecordings": "रिकॉर्डिंग पर वापस",
+ "errorsDetected": "त्रुटियां पाई गईं",
+ "somethingWentWrong": "कुछ गलत हो गया :(",
+ "searchLogs": "लॉग खोजें...",
+ "filter": "फ़िल्टर…",
+ "refreshMicrophoneList": "माइक्रोफ़ोन सूची ताज़ा करें",
+ "date": "तारीख",
+ "name": "नाम",
+ "size": "आकार",
+ "duration": "अवधि",
+ "frames": "फ्रेम",
+ "timestamp": "समय चिह्न",
+ "language": "भाषा",
+ "aiTranslated": "AI अनुवादित",
+ "humanTranslated": "मानव अनुवादित",
+ "humanValidated": "मानव सत्यापित",
+ "connectCameras": "चयनित कैमरों से कनेक्ट करें",
+ "resumeStreaming": "स्ट्रीमिंग फिर शुरू करें",
+ "pauseStreaming": "स्ट्रीमिंग रोकें",
+ "closeAllCameras": "सभी कैमरे बंद करें",
+ "framerate": "फ्रेमरेट",
+ "exposure": "एक्सपोज़र",
+ "fileLabel": "फ़ाइल",
+ "timeDelta": "समय अंतर",
+ "pathLabel": "पथ",
+ "exceptionDetails": "अपवाद विवरण",
+ "stackTrace": "स्टैक ट्रेस",
+ "loadingVideos": "वीडियो लोड हो रहे हैं… ({{ready}}/{{total}} तैयार)",
+ "gridColumns": "ग्रिड स्तंभ",
+ "settings": "सेटिंग्स",
+ "appearance": "रूप",
+ "themeMode": "थीम",
+ "darkMode": "डार्क",
+ "lightMode": "लाइट",
+ "languageSettings": "भाषा और स्थानीयकरण",
+ "showTranslationIndicator": "अनुवाद स्रोत संकेतक दिखाएं",
+ "showTranslationIndicatorDescription": "AI-जनित अनुवाद उपयोग करते समय बैज दिखाएं",
+ "translationSourceLabel": "अनुवाद स्रोत",
+ "general": "सामान्य",
+ "about": "के बारे में",
+ "version": "संस्करण",
+ "serverSettings": "सर्वर",
+ "recordingSettings": "रिकॉर्डिंग सेटिंग्स",
+ "videoLoadingSettings": "वीडियो लोडिंग सेटिंग्स",
+ "connected": "कनेक्टेड",
+ "connecting": "कनेक्ट हो रहा है…",
+ "disconnected": "डिस्कनेक्टेड",
+ "disconnect": "डिस्कनेक्ट",
+ "connect": "कनेक्ट",
+ "off": "बंद",
+ "running": "चालू",
+ "stopped": "रुका हुआ",
+ "working": "काम कर रहा है…",
+ "invalid": "अमान्य",
+ "autoLaunch": "स्वचालित लॉन्च",
+ "autoConnect": "स्वचालित कनेक्ट",
+ "runningPath": "चालू: {{path}}",
+ "noMicrophone": "कोई माइक्रोफ़ोन नहीं",
+ "audioRecordingEnabled": "ऑडियो रिकॉर्डिंग सक्षम",
+ "noMicrophoneSelected": "कोई माइक्रोफ़ोन चयनित नहीं",
+ "recordingName": "रिकॉर्डिंग नाम: {{name}}",
+ "startingIn": "{{countdown}} में शुरू हो रहा है...",
+ "stopping": "रोक रहा है...",
+ "starting": "शुरू हो रहा है...",
+ "stopRecordingButton": "🔴 रिकॉर्डिंग बंद करें",
+ "startRecordingButton": "🔴 रिकॉर्डिंग शुरू करें",
+ "camerasCount": "कैमरे ({{count}})",
+ "availableCamerasCount": "उपलब्ध ({{count}})",
+ "server": "सर्वर",
+ "display": "डिस्प्ले",
+ "rawMessage": "कच्चा संदेश",
+ "cameraPerformanceMetrics": "कैमरा प्रदर्शन मेट्रिक्स",
+ "serverLogs": "सर्वर लॉग",
+ "sortBy": "क्रमबद्ध {{direction}}",
+ "waitingForCameraStreams": "कैमरा स्ट्रीम की प्रतीक्षा...",
+ "loggingPaused": "लॉगिंग रोकी गई",
+ "noLogsToDisplay": "दिखाने के लिए कोई लॉग नहीं",
+ "closeSettings": "सेटिंग्स बंद करें",
+ "gridSettings": "ग्रिड सेटिंग्स",
+ "clickToShowLess": "कम देखने के लिए क्लिक करें",
+ "clickToLearnMore": "अधिक जानने के लिए क्लिक करें",
+ "samples": "नमूने",
+ "framerateOverTime": "समय के साथ फ्रेमरेट",
+ "framerateFps": "फ्रेमरेट (fps)",
+ "capturesFramesFromCamera": "कैमरे से फ्रेम कैप्चर करता है।",
+ "rendersReceivedFrames": "प्राप्त फ्रेम स्क्रीन पर रेंडर करता है।",
+ "displayTooltipLong": "डिस्प्ले UI रेंडरिंग प्रदर्शन दर्शाता है। यह दिखाता है कि आपका डिस्प्ले कितनी तेज़ी से फ्रेम प्राप्त करता और रेंडर करता है। यहाँ प्रदर्शन समस्याएँ रिकॉर्डिंग गुणवत्ता को प्रभावित नहीं करेंगी लेकिन रियल-टाइम में कैमरों की निगरानी करने की आपकी क्षमता को प्रभावित कर सकती हैं।",
+ "statsSourceShort": "डिस्प्ले फ्रेम रेंडर करता है, सर्वर फ्रेम कैप्चर करता है।",
+ "statsSourceLong": "सर्वर वह वास्तविक दर है जिस पर कैमरे से फ्रेम खींचे/रिकॉर्ड किए जाते हैं, जबकि डिस्प्ले वह दर है जिस पर उन्हें प्राप्त और रेंडर किया जाता है। SkellyCam रिकॉर्डिंग गुणवत्ता के लिए सर्वर-साइड प्रदर्शन को प्राथमिकता देता है, इसलिए वह संख्या अधिक स्थिर रहनी चाहिए। यदि डिस्प्ले फ्रेमरेट सर्वर से भिन्न होता है, तो यह इंगित करता है कि आपके सिस्टम संसाधन तनाव में हैं। कम कैमरे उपयोग करने या फ्रेमरेट/रेज़ोल्यूशन कम करने पर विचार करें।",
+ "statsCurrentShort": "सबसे हालिया फ्रेम समय और FPS।",
+ "statsCurrentLong": "यह एक एकल फ्रेम को संसाधित करने में लगने वाले समय (मिलीसेकंड में) और समकक्ष प्रति सेकंड फ्रेम (FPS) का सबसे हालिया माप दिखाता है। कम फ्रेम समय और अधिक FPS बेहतर प्रदर्शन इंगित करता है।",
+ "statsMinShort": "सबसे तेज़ फ्रेम समय और उच्चतम FPS।",
+ "statsMinLong": "यह नमूना विंडो के दौरान एक एकल फ्रेम को संसाधित करने में लगा न्यूनतम समय दर्शाता है। यह आदर्श परिस्थितियों में आपके सिस्टम द्वारा प्राप्त अधिकतम FPS से मेल खाता है।",
+ "statsMaxShort": "सबसे धीमा फ्रेम समय और न्यूनतम FPS।",
+ "statsMaxLong": "यह नमूना विंडो के दौरान एक एकल फ्रेम को संसाधित करने में लगा अधिकतम समय दर्शाता है। यह सबसे खराब परिस्थितियों में न्यूनतम FPS से मेल खाता है। कभी-कभार स्पाइक सामान्य हैं, लेकिन लगातार उच्च मान प्रदर्शन समस्याओं का संकेत दे सकते हैं।",
+ "statsMeanShort": "सभी नमूनों का औसत फ्रेम समय और FPS।",
+ "statsMeanLong": "नमूना विंडो के दौरान मापे गए सभी फ्रेम समय का अंकगणितीय माध्य और संबंधित FPS। यह प्रदर्शन का एक अच्छा समग्र चित्र देता है लेकिन चरम मानों से विकृत हो सकता है।",
+ "statsMedianShort": "सभी फ्रेम समय का मध्य मान (50वां प्रतिशतक)।",
+ "statsMedianLong": "मध्यमान उस मध्य मान को दर्शाता है जब सभी फ्रेम समय सबसे तेज़ से सबसे धीमे तक क्रमबद्ध किए जाते हैं। माध्य के विपरीत, मध्यमान चरम बाहरी मानों से प्रभावित नहीं होता, जो इसे सामान्य प्रदर्शन का अधिक स्थिर संकेतक बनाता है।",
+ "statsStdDevShort": "फ्रेम समय परिवर्तनशीलता मापता है।",
+ "statsStdDevLong": "मानक विचलन फ्रेम समय में भिन्नता की मात्रा मापता है। कम मान अधिक सुसंगत प्रदर्शन इंगित करते हैं। परिवर्तन गुणांक (CV%) इस परिवर्तनशीलता को माध्य के प्रतिशत के रूप में व्यक्त करता है, जो विभिन्न फ्रेम दरों में स्थिरता की तुलना को आसान बनाता है। कम CV% अधिक स्थिर प्रदर्शन इंगित करता है।",
+ "aiTranslatedTooltip": "यह अनुवाद AI द्वारा बनाया गया है और इसमें त्रुटियां हो सकती हैं। यदि आप यह भाषा बोलते हैं, तो कृपया इसे सुधारने में मदद करें!",
+ "humanValidatedTooltip": "इस अनुवाद की मानव अनुवादक द्वारा समीक्षा की गई है।",
+ "helpTranslate": "SkellyCam का अनुवाद करने में मदद करें",
+ "failedToFetch": "डेटा प्राप्त करने में विफल",
+ "recordings": "रिकॉर्डिंग",
+ "noRecordingsFound": "कोई रिकॉर्डिंग नहीं मिली। मैन्युअल रूप से लोड करने के लिए ऊपर पथ दर्ज करें।",
+ "noCamerasDetected": "कोई कैमरा नहीं मिला",
+ "clickRefreshToScan": "उपलब्ध कैमरों को खोजने के लिए रिफ्रेश पर क्लिक करें",
+ "waitingForData": "डेटा की प्रतीक्षा…",
+ "load": "लोड",
+ "refresh": "रिफ्रेश",
+ "available": "उपलब्ध",
+ "menuFile": "फ़ाइल",
+ "menuView": "दृश्य",
+ "menuCamera": "कैमरा",
+ "menuRecording": "रिकॉर्डिंग",
+ "menuHelp": "सहायता",
+ "menuDetectCameras": "कैमरे खोजें",
+ "menuConnectCameras": "कैमरे कनेक्ट करें",
+ "menuCloseAllCameras": "सभी कैमरे बंद करें",
+ "menuOpenRecordingFolder": "रिकॉर्डिंग फ़ोल्डर खोलें…",
+ "menuToggleSidebar": "साइडबार टॉगल करें",
+ "menuToggleTheme": "थीम बदलें",
+ "menuToggleFullScreen": "पूर्ण स्क्रीन",
+ "menuPauseUnpause": "रोकें / जारी रखें",
+ "menuConnectApplySettings": "कनेक्ट / सेटिंग्स लागू करें",
+ "menuCloseAll": "सभी बंद करें",
+ "menuDocumentation": "दस्तावेज़ीकरण",
+ "menuGitHubRepository": "GitHub रिपॉजिटरी",
+ "menuReportIssue": "समस्या रिपोर्ट करें…",
+ "menuAbout": "SkellyCam के बारे में",
+ "menuPlayback": "प्लेबैक",
+ "videoPlayback": "प्लेबैक",
+ "copyLogsToClipboard": "लॉग क्लिपबोर्ड पर कॉपी करें",
+ "saveLogsToFile": "लॉग फ़ाइल में सहेजें",
+ "copied": "कॉपी हो गया!",
+ "timestampFromRecording": "रिकॉर्डिंग डेटा से टाइमस्टैम्प",
+ "menuCheckForUpdates": "Check for Updates…",
+ "updateAvailable": "Update available",
+ "updateAvailableMessage": "Version {{version}} is available",
+ "downloading": "Downloading…",
+ "downloadComplete": "Download complete",
+ "restartToUpdate": "Restart to update",
+ "checkForUpdates": "Check for Updates",
+ "upToDate": "You are up to date",
+ "updateError": "Update check failed"
+}
diff --git a/freemocap-ui-old/src/i18n/locales/hr-hrvatski.json b/freemocap-ui-old/src/i18n/locales/hr-hrvatski.json
new file mode 100644
index 00000000..19045423
--- /dev/null
+++ b/freemocap-ui-old/src/i18n/locales/hr-hrvatski.json
@@ -0,0 +1,258 @@
+{
+ "_meta": {
+ "locale": "hr",
+ "translationSource": "ai-generated",
+ "lastUpdated": "2026-02-23"
+ },
+ "appName": "SkellyCam",
+ "appNameDecorated": "SkellyCam 💀📸",
+ "welcomeTitle": "Dobrodošli u SkellyCam",
+ "welcomeSubtitle": "Snimajte i gledajte sinkronizirane videozapise",
+ "sendAnonymousPings": "Šalji anonimne pingove korištenja",
+ "footerWith": "s",
+ "footerFrom": "od",
+ "footerOrgName": "FreeMoCap Foundation",
+ "home": "Početna",
+ "cameras": "Kamere",
+ "videos": "Videozapisi",
+ "expandSidebar": "Proširi bočnu traku",
+ "collapseSidebar": "Skupi bočnu traku",
+ "startRecording": "Započni snimanje",
+ "stopRecording": "Zaustavi snimanje",
+ "toggleTheme": "promijeni temu",
+ "switchToDark": "Prebaci na tamni način",
+ "switchToLight": "Prebaci na svijetli način",
+ "connectWebSocket": "Poveži WebSocket",
+ "disconnectWebSocket": "Odspoji WebSocket",
+ "launchServer": "Pokreni poslužitelj",
+ "stopServer": "Zaustavi poslužitelj",
+ "browseForExecutable": "Potraži izvršnu datoteku",
+ "refreshCandidates": "Osvježi kandidate",
+ "executable": "Izvršna datoteka",
+ "host": "Domaćin",
+ "port": "Port",
+ "cameraCount_one": "{{count}} kamera",
+ "cameraCount_other": "{{count}} kamere",
+ "connectedCameras": "Povezane kamere",
+ "availableCameras": "Dostupne kamere",
+ "noCamerasConnected": "Nijedna kamera nije povezana",
+ "detectCameras": "Otkrij dostupne kamere",
+ "clearCameraSettings": "Obriši spremljene postavke kamere iz memorije",
+ "copySettingsToAll": "Kopiraj postavke na sve kamere",
+ "recordingTag": "Oznaka snimanja",
+ "recordingTagPlaceholder": "Neobvezna oznaka",
+ "recordingDirectory": "Direktorij snimanja",
+ "recordingFolderPath": "Putanja mape snimanja",
+ "delayStart": "Odgodi početak",
+ "seconds": "Sekunde",
+ "subfolder": "Podmapa",
+ "subfolderPlaceholder": "Naziv podmape",
+ "baseName": "Osnovni naziv",
+ "increment": "Inkrement",
+ "resolution": "Rezolucija",
+ "fps": "FPS",
+ "width": "Širina",
+ "height": "Visina",
+ "columns": "Stupci",
+ "auto": "Automatski",
+ "manual": "Ručno",
+ "custom": "Prilagođeno",
+ "current": "Trenutno",
+ "recommend": "Preporuči",
+ "cameraRotation": "rotacija kamere",
+ "selectCameraRotation": "Odaberite rotaciju slike kamere",
+ "exposureControl": "Odaberite između automatske ili ručne kontrole ekspozicije",
+ "framerateControl": "Odaberite između automatske ili ručne kontrole brzine kadrova",
+ "adjustExposure": "Prilagodite vrijeme ekspozicije, npr. cv2.VideoCapture.set(cv2.CAP_PROP_EXPOSURE, value)",
+ "setTargetFps": "Postavite ciljane kadrove u sekundi (FPS) za snimanje kamerom",
+ "recordingCaptureFps": "Brzina kadrova snimanja",
+ "playbackSpeed": "Brzina reprodukcije (ne utječe na fps snimanja)",
+ "framerateTimeline": "Vremenska crta brzine kadrova",
+ "framerateDistribution": "Distribucija brzine kadrova",
+ "timelineView": "Prikaz vremenske crte",
+ "distributionView": "Prikaz distribucije",
+ "combinedView": "Kombinirani prikaz",
+ "min": "Min",
+ "max": "Maks",
+ "mean": "Srednja vrijednost",
+ "median": "Medijan",
+ "stdDevCv": "StdDev/CV",
+ "source": "Izvor",
+ "selectAll": "Odaberi sve",
+ "loadSynchronizedVideos": "Učitaj sinkronizirane videozapise",
+ "loadSynchronizedVideosDescription": "Ova stranica vam omogućuje učitavanje i sinkronizaciju prethodno snimljenih videozapisa.",
+ "automaticallySynchronizeVideos": "Automatski sinkroniziraj videozapise",
+ "extractFramesOnLoad": "Izvuci kadrove pri učitavanju",
+ "generateThumbnails": "Generiraj minijature",
+ "noVideosLoaded": "Nema učitanih videozapisa",
+ "filterVideos": "Filtriraj videozapise...",
+ "openVideo": "Otvori videozapis",
+ "openFolder": "Otvori mapu u pregledniku datoteka",
+ "videoFolderPath": "Putanja video mape",
+ "jumpToStart": "Skoči na početak (Home)",
+ "jumpToEnd": "Skoči na kraj (End)",
+ "loopOn": "Petlja je uključena (L za prebacivanje)",
+ "loopOff": "Reprodukcija u petlji (L)",
+ "syncInfo": "Informacije o sinkronizaciji",
+ "syncInfoTitle": "Sinkronizacija više kamera možda nije savršena na razini okvira",
+ "syncInfoBody": "Reprodukcija videa u pregledniku ne jamči sinkronizaciju točnu na razini uzorka preko više tokova. Reproduktor koristi strategiju vođa-pratitelj i ispravlja odstupanje kada premaši malu toleranciju, ali može doći do manje desinkronizacije (1–2 okvira), posebno pri velikim brzinama reprodukcije ili kada je preglednik pod opterećenjem. Za analizu točnu na razini okvira koristite neobrađene CSV datoteke vremenskih oznaka uključene u svaki snimak.",
+ "previousFrame": "Prethodni kadar (← / Shift+← za 10)",
+ "nextFrame": "Sljedeći kadar (→ / Shift+→ za 10)",
+ "zoomIn": "Povećaj",
+ "zoomOut": "Smanji",
+ "resetZoom": "Resetiraj zum",
+ "playbackSettings": "Postavke reprodukcije",
+ "totalRecordingSize": "Ukupna veličina snimke na disku",
+ "estimatedTime": "Procijenjeno vrijeme (kadar ÷ fps snimanja)",
+ "estimatedDuration": "Procijenjeno trajanje (ukupno kadrova ÷ fps snimanja)",
+ "estimatedFromFrameNumber": "Procijenjeno iz broja kadra × fps snimanja — nije pročitano iz podataka vremenskog pečata",
+ "frameCountPerCamera": "Broj kadrova po kameri",
+ "cameraStreams": "Streamovi kamera u ovoj snimci",
+ "backToRecordings": "Natrag na snimke",
+ "errorsDetected": "Otkrivene pogreške",
+ "somethingWentWrong": "Nešto je pošlo po krivu :(",
+ "searchLogs": "Pretraži zapise...",
+ "filter": "Filtar…",
+ "refreshMicrophoneList": "Osvježi popis mikrofona",
+ "date": "Datum",
+ "name": "Naziv",
+ "size": "Veličina",
+ "duration": "Trajanje",
+ "frames": "Kadrovi",
+ "timestamp": "Vremenski pečat",
+ "language": "Jezik",
+ "aiTranslated": "AI prevedeno",
+ "humanTranslated": "Prevedeno od strane čovjeka",
+ "humanValidated": "Validirano od strane čovjeka",
+ "connectCameras": "Poveži se na odabrane kamere ili ažuriraj povezane kamere",
+ "resumeStreaming": "Nastavi streamanje",
+ "pauseStreaming": "Pauziraj streamanje",
+ "closeAllCameras": "Zatvori sve kamere",
+ "framerate": "Brzina kadrova",
+ "exposure": "Ekspozicija",
+ "fileLabel": "Datoteka",
+ "timeDelta": "Vremenska razlika",
+ "pathLabel": "Putanja",
+ "exceptionDetails": "Detalji iznimke",
+ "stackTrace": "Trag stoga",
+ "loadingVideos": "Učitavanje videozapisa… ({{ready}}/{{total}} spremno)",
+ "gridColumns": "Stupci mreže",
+ "settings": "Postavke",
+ "appearance": "Izgled",
+ "themeMode": "Tema",
+ "darkMode": "Tamno",
+ "lightMode": "Svijetlo",
+ "languageSettings": "Jezik i lokalizacija",
+ "showTranslationIndicator": "Prikaži indikator izvora prijevoda",
+ "showTranslationIndicatorDescription": "Prikaži značku kada se koriste AI generirani prijevodi",
+ "translationSourceLabel": "Izvor prijevoda",
+ "general": "Općenito",
+ "about": "O programu",
+ "version": "Verzija",
+ "serverSettings": "Poslužitelj",
+ "recordingSettings": "Postavke snimanja",
+ "videoLoadingSettings": "Postavke učitavanja videa",
+ "connected": "Povezano",
+ "connecting": "Povezivanje…",
+ "disconnected": "Odspojeno",
+ "disconnect": "Odspoji",
+ "connect": "Poveži",
+ "off": "Isključeno",
+ "running": "Pokrenuto",
+ "stopped": "Zaustavljeno",
+ "working": "Radi…",
+ "invalid": "Nevažeće",
+ "autoLaunch": "Automatsko pokretanje",
+ "autoConnect": "Automatsko povezivanje",
+ "runningPath": "Pokrenuto: {{path}}",
+ "noMicrophone": "Nema mikrofona",
+ "audioRecordingEnabled": "Snimanje zvuka omogućeno",
+ "noMicrophoneSelected": "Mikrofon nije odabran",
+ "recordingName": "Naziv snimke: {{name}}",
+ "startingIn": "Započinje za {{countdown}}...",
+ "stopping": "Zaustavljanje...",
+ "starting": "Pokretanje...",
+ "stopRecordingButton": "🔴 Zaustavi snimanje",
+ "startRecordingButton": "🔴 Započni snimanje",
+ "camerasCount": "Kamere ({{count}})",
+ "availableCamerasCount": "Dostupne ({{count}})",
+ "server": "Poslužitelj",
+ "display": "Zaslon",
+ "rawMessage": "Neobrađena poruka",
+ "cameraPerformanceMetrics": "Metrike performansi kamere",
+ "serverLogs": "Zapisi poslužitelja",
+ "sortBy": "Sortiraj {{direction}}",
+ "waitingForCameraStreams": "Čekanje na streamove kamera...",
+ "loggingPaused": "Zapisivanje pauzirano",
+ "noLogsToDisplay": "Nema zapisa za prikaz",
+ "closeSettings": "Zatvori postavke",
+ "gridSettings": "Postavke mreže",
+ "clickToShowLess": "Klikni za manje",
+ "clickToLearnMore": "Klikni za više",
+ "samples": "uzorci",
+ "framerateOverTime": "Brzina kadrova kroz vrijeme",
+ "framerateFps": "Brzina kadrova (fps)",
+ "capturesFramesFromCamera": "Snima kadrove s kamere.",
+ "rendersReceivedFrames": "Prikazuje primljene kadrove na zaslonu.",
+ "displayTooltipLong": "Zaslon predstavlja performanse renderiranja korisničkog sučelja. Pokazuje koliko brzo vaš zaslon prima i prikazuje kadrove. Problemi s performansama ovdje neće utjecati na kvalitetu snimanja, ali mogu utjecati na vašu sposobnost praćenja kamera u stvarnom vremenu.",
+ "statsSourceShort": "Zaslon prikazuje kadrove, Poslužitelj snima kadrove.",
+ "statsSourceLong": "Poslužitelj je stvarna brzina kojom se kadrovi povlače/snimaju s kamere, dok je zaslon brzina kojom se primaju i prikazuju. Skellycam daje prioritet performansama na strani poslužitelja za kvalitetu snimanja, tako da bi taj broj trebao ostati stabilniji. Ako se brzina kadrova zaslona razlikuje od poslužitelja, to ukazuje da su resursi vašeg sustava preopterećeni. Razmislite o korištenju manje kamera ili smanjenju brzine kadrova/rezolucije.",
+ "statsCurrentShort": "Najnovije vrijeme kadra i odgovarajući FPS.",
+ "statsCurrentLong": "Ovo prikazuje najnovije mjerenje koliko vremena treba za obradu jednog kadra (u milisekundama) i ekvivalentne kadrove u sekundi (FPS). Manje vrijeme kadra i veći FPS ukazuju na bolje performanse.",
+ "statsMinShort": "Najbrže vrijeme kadra (najmanje kašnjenje) i najveći postignuti FPS.",
+ "statsMinLong": "Ovo predstavlja minimalno vrijeme potrebno za obradu jednog kadra tijekom prozora uzorkovanja. Ovo odgovara maksimalnom FPS-u koji je vaš sustav postigao u optimalnim uvjetima.",
+ "statsMaxShort": "Najsporije vrijeme kadra (najveće kašnjenje) i najmanji doživljeni FPS.",
+ "statsMaxLong": "Ovo predstavlja maksimalno vrijeme potrebno za obradu jednog kadra tijekom prozora uzorkovanja. Ovo odgovara minimalnom FPS-u koji je vaš sustav postigao u najgorim uvjetima. Povremeni skokovi su normalni, ali stalno visoke vrijednosti mogu ukazivati na probleme s performansama.",
+ "statsMeanShort": "Prosječno vrijeme kadra i FPS za sve uzorke.",
+ "statsMeanLong": "Aritmetička sredina svih vremena kadrova izmjerenih tijekom prozora uzorkovanja i odgovarajući FPS. Ovo daje dobru ukupnu sliku performansi, ali može biti iskrivljeno ekstremnim vrijednostima.",
+ "statsMedianShort": "Srednja vrijednost svih vremena kadrova (50. percentil).",
+ "statsMedianLong": "Medijan predstavlja srednju vrijednost kada su sva vremena kadrova sortirana od najbržeg do najsporijeg. Za razliku od srednje vrijednosti, medijan nije pod utjecajem ekstremnih vrijednosti, što ga čini stabilnijim pokazateljem tipičnih performansi.",
+ "statsStdDevShort": "Mjeri varijabilnost vremena kadra. CV% je relativna varijabilnost.",
+ "statsStdDevLong": "Standardna devijacija mjeri količinu varijacije u vremenima kadrova. Niže vrijednosti ukazuju na konzistentnije performanse. Koeficijent varijacije (CV%) izražava ovu varijabilnost kao postotak srednje vrijednosti, olakšavajući usporedbu stabilnosti na različitim brzinama kadrova. Niži CV% ukazuje na stabilnije performanse.",
+ "aiTranslatedTooltip": "Ovaj prijevod je generiran pomoću umjetne inteligencije i može sadržavati pogreške. Ako govorite ovaj jezik, možete pomoći u poboljšanju otvaranjem pull requesta na GitHubu!",
+ "humanValidatedTooltip": "Ovaj prijevod je pregledao i potvrdio ljudski prevoditelj.",
+ "helpTranslate": "Pomozite prevesti SkellyCam",
+ "failedToFetch": "Preuzimanje neuspješno",
+ "recordings": "Snimke",
+ "noRecordingsFound": "Nema pronađenih snimaka. Unesite putanju iznad za ručno učitavanje.",
+ "noCamerasDetected": "Kamere nisu otkrivene",
+ "clickRefreshToScan": "Kliknite osvježi za skeniranje dostupnih kamera",
+ "waitingForData": "Čekanje na podatke…",
+ "load": "Učitaj",
+ "refresh": "Osvježi",
+ "available": "Dostupno",
+ "menuFile": "Datoteka",
+ "menuView": "Prikaz",
+ "menuCamera": "Kamera",
+ "menuRecording": "Snimanje",
+ "menuHelp": "Pomoć",
+ "menuDetectCameras": "Otkrij kamere",
+ "menuConnectCameras": "Poveži kamere",
+ "menuCloseAllCameras": "Zatvori sve kamere",
+ "menuOpenRecordingFolder": "Otvori mapu snimanja…",
+ "menuToggleSidebar": "Uključi/isključi bočnu traku",
+ "menuToggleTheme": "Promijeni temu",
+ "menuToggleFullScreen": "Cijeli zaslon",
+ "menuPauseUnpause": "Pauza / Nastavi",
+ "menuConnectApplySettings": "Poveži / Primijeni postavke",
+ "menuCloseAll": "Zatvori sve",
+ "menuDocumentation": "Dokumentacija",
+ "menuGitHubRepository": "GitHub repozitorij",
+ "menuReportIssue": "Prijavi problem…",
+ "menuAbout": "O SkellyCam-u",
+ "menuPlayback": "Reprodukcija",
+ "videoPlayback": "Reprodukcija",
+ "copyLogsToClipboard": "Kopiraj zapise u međuspremnik",
+ "saveLogsToFile": "Spremi zapise u datoteku",
+ "copied": "Kopirano!",
+ "timestampFromRecording": "Vremenska oznaka iz podataka snimke",
+ "menuCheckForUpdates": "Check for Updates…",
+ "updateAvailable": "Update available",
+ "updateAvailableMessage": "Version {{version}} is available",
+ "downloading": "Downloading…",
+ "downloadComplete": "Download complete",
+ "restartToUpdate": "Restart to update",
+ "checkForUpdates": "Check for Updates",
+ "upToDate": "You are up to date",
+ "updateError": "Update check failed"
+}
diff --git a/freemocap-ui-old/src/i18n/locales/hu-magyar.json b/freemocap-ui-old/src/i18n/locales/hu-magyar.json
new file mode 100644
index 00000000..87ce7375
--- /dev/null
+++ b/freemocap-ui-old/src/i18n/locales/hu-magyar.json
@@ -0,0 +1,258 @@
+{
+ "_meta": {
+ "locale": "hu",
+ "translationSource": "ai-generated",
+ "lastUpdated": "2026-02-23"
+ },
+ "appName": "SkellyCam",
+ "appNameDecorated": "SkellyCam 💀📸",
+ "welcomeTitle": "Üdvözöljük a SkellyCam-ben",
+ "welcomeSubtitle": "Szinkronizált Videók Rögzítése és Megtekintése",
+ "sendAnonymousPings": "Anonim használati pingek küldése",
+ "footerWith": "a",
+ "footerFrom": "a",
+ "footerOrgName": "FreeMoCap Foundation",
+ "home": "Kezdőlap",
+ "cameras": "Kamerák",
+ "videos": "Videók",
+ "expandSidebar": "Oldalsáv kibontása",
+ "collapseSidebar": "Oldalsáv összecsukása",
+ "startRecording": "Felvétel Indítása",
+ "stopRecording": "Felvétel Leállítása",
+ "toggleTheme": "téma váltása",
+ "switchToDark": "Váltás sötét módra",
+ "switchToLight": "Váltás világos módra",
+ "connectWebSocket": "WebSocket Csatlakoztatása",
+ "disconnectWebSocket": "WebSocket Leválasztása",
+ "launchServer": "Szerver Indítása",
+ "stopServer": "Szerver Leállítása",
+ "browseForExecutable": "Futtatható fájl keresése",
+ "refreshCandidates": "Jelöltek frissítése",
+ "executable": "Futtatható",
+ "host": "Gazdagép",
+ "port": "Port",
+ "cameraCount_one": "{{count}} kamera",
+ "cameraCount_other": "{{count}} kamera",
+ "connectedCameras": "Csatlakoztatott Kamerák",
+ "availableCameras": "Elérhető Kamerák",
+ "noCamerasConnected": "Nincs csatlakoztatott kamera",
+ "detectCameras": "Elérhető kamerák észlelése",
+ "clearCameraSettings": "Mentett kamerabeállítások törlése a memóriából",
+ "copySettingsToAll": "Beállítások másolása az összes kamerára",
+ "recordingTag": "Felvétel Címke",
+ "recordingTagPlaceholder": "Opcionális címke",
+ "recordingDirectory": "Felvétel Könyvtár",
+ "recordingFolderPath": "Felvétel mappa elérési útja",
+ "delayStart": "Késleltetett Indítás",
+ "seconds": "Másodperc",
+ "subfolder": "Almappa",
+ "subfolderPlaceholder": "Almappa Neve",
+ "baseName": "Alapnév",
+ "increment": "Növekmény",
+ "resolution": "Felbontás",
+ "fps": "FPS",
+ "width": "Szélesség",
+ "height": "Magasság",
+ "columns": "Oszlopok",
+ "auto": "Automatikus",
+ "manual": "Kézi",
+ "custom": "Egyéni",
+ "current": "Jelenlegi",
+ "recommend": "Ajánlott",
+ "cameraRotation": "kamera forgatás",
+ "selectCameraRotation": "Kamerakép forgatás kiválasztása",
+ "exposureControl": "Választás az automatikus vagy kézi expozíció vezérlés között",
+ "framerateControl": "Választás az automatikus vagy kézi képkockasebesség vezérlés között",
+ "adjustExposure": "Expozíciós idő beállítása, pl. cv2.VideoCapture.set(cv2.CAP_PROP_EXPOSURE, value)",
+ "setTargetFps": "Cél képkocka/másodperc (FPS) beállítása kamera rögzítéshez",
+ "recordingCaptureFps": "Felvétel rögzítési képkockasebesség",
+ "playbackSpeed": "Lejátszási sebesség (nem befolyásolja a felvételi fps-t)",
+ "framerateTimeline": "Képkockasebesség Idővonal",
+ "framerateDistribution": "Képkockasebesség Eloszlás",
+ "timelineView": "Idővonal Nézet",
+ "distributionView": "Eloszlás Nézet",
+ "combinedView": "Kombinált Nézet",
+ "min": "Min",
+ "max": "Max",
+ "mean": "Átlag",
+ "median": "Medián",
+ "stdDevCv": "StdDev/CV",
+ "source": "Forrás",
+ "selectAll": "Összes Kijelölése",
+ "loadSynchronizedVideos": "Szinkronizált Videók Betöltése",
+ "loadSynchronizedVideosDescription": "Ez az oldal lehetővé teszi előre rögzített videók betöltését és szinkronizálását.",
+ "automaticallySynchronizeVideos": "Videók automatikus szinkronizálása",
+ "extractFramesOnLoad": "Képkockák kinyerése betöltéskor",
+ "generateThumbnails": "Miniatűrök létrehozása",
+ "noVideosLoaded": "Nincsenek betöltött videók",
+ "filterVideos": "Videók szűrése...",
+ "openVideo": "Videó megnyitása",
+ "openFolder": "Mappa megnyitása a fájlkezelőben",
+ "videoFolderPath": "Videó Mappa Elérési Útja",
+ "jumpToStart": "Ugrás az elejére (Home)",
+ "jumpToEnd": "Ugrás a végére (End)",
+ "loopOn": "Ismétlés bekapcsolva (L a váltáshoz)",
+ "loopOff": "Ismételt lejátszás (L)",
+ "syncInfo": "Szinkronizálási információ",
+ "syncInfoTitle": "A többkamerás szinkronizálás nem feltétlenül képkockaszintű pontosságú",
+ "syncInfoBody": "A böngészős videólejátszás nem garantálja a mintapontos szinkronizálást több adatfolyamon keresztül. A lejátszó vezető-követő stratégiát használ, és korrigálja az eltolódást, ha az meghalad egy kis tűréshatárt, de kisebb deszinkronizáció (1–2 képkocka) előfordulhat, különösen nagy lejátszási sebességnél vagy amikor a böngésző terhelés alatt van. Képkockapontos elemzéshez használja az egyes felvételekben található nyers időbélyeg CSV fájlokat.",
+ "previousFrame": "Előző képkocka (← / Shift+← 10-hez)",
+ "nextFrame": "Következő képkocka (→ / Shift+→ 10-hez)",
+ "zoomIn": "Nagyítás",
+ "zoomOut": "Kicsinyítés",
+ "resetZoom": "Nagyítás Visszaállítása",
+ "playbackSettings": "Lejátszási beállítások",
+ "totalRecordingSize": "Teljes felvétel mérete a lemezen",
+ "estimatedTime": "Becsült idő (képkocka ÷ felvételi fps)",
+ "estimatedDuration": "Becsült időtartam (összes képkocka ÷ felvételi fps)",
+ "estimatedFromFrameNumber": "Képkockaszám × felvételi fps alapján becsülve — nem időbélyeg adatból olvasva",
+ "frameCountPerCamera": "Képkockák száma kameránként",
+ "cameraStreams": "Kamera streamek ebben a felvételben",
+ "backToRecordings": "Vissza a felvételekhez",
+ "errorsDetected": "Hibák észlelve",
+ "somethingWentWrong": "Valami hiba történt :(",
+ "searchLogs": "Naplók keresése...",
+ "filter": "Szűrő…",
+ "refreshMicrophoneList": "Mikrofon lista frissítése",
+ "date": "Dátum",
+ "name": "Név",
+ "size": "Méret",
+ "duration": "Időtartam",
+ "frames": "Képkockák",
+ "timestamp": "Időbélyeg",
+ "language": "Nyelv",
+ "aiTranslated": "AI-fordított",
+ "humanTranslated": "Ember által fordított",
+ "humanValidated": "Ember által ellenőrzött",
+ "connectCameras": "Csatlakozás a kiválasztott kamerákhoz vagy csatlakoztatott kamerák frissítése",
+ "resumeStreaming": "Streamelés folytatása",
+ "pauseStreaming": "Streamelés szüneteltetése",
+ "closeAllCameras": "Összes kamera bezárása",
+ "framerate": "Képkockasebesség",
+ "exposure": "Expozíció",
+ "fileLabel": "Fájl",
+ "timeDelta": "Időkülönbség",
+ "pathLabel": "Elérési út",
+ "exceptionDetails": "Kivétel részletei",
+ "stackTrace": "Verem Nyomkövetés",
+ "loadingVideos": "Videók betöltése… ({{ready}}/{{total}} kész)",
+ "gridColumns": "Rács Oszlopok",
+ "settings": "Beállítások",
+ "appearance": "Megjelenés",
+ "themeMode": "Téma",
+ "darkMode": "Sötét",
+ "lightMode": "Világos",
+ "languageSettings": "Nyelv és Honosítás",
+ "showTranslationIndicator": "Fordítási forrás jelző megjelenítése",
+ "showTranslationIndicatorDescription": "Jelvény megjelenítése AI-generált fordítások használatakor",
+ "translationSourceLabel": "Fordítás forrása",
+ "general": "Általános",
+ "about": "Névjegy",
+ "version": "Verzió",
+ "serverSettings": "Szerver",
+ "recordingSettings": "Felvételi Beállítások",
+ "videoLoadingSettings": "Videó Betöltési Beállítások",
+ "connected": "Csatlakoztatva",
+ "connecting": "Csatlakozás…",
+ "disconnected": "Leválasztva",
+ "disconnect": "Leválasztás",
+ "connect": "Csatlakozás",
+ "off": "Ki",
+ "running": "Fut",
+ "stopped": "Leállítva",
+ "working": "Dolgozik…",
+ "invalid": "Érvénytelen",
+ "autoLaunch": "Automatikus indítás",
+ "autoConnect": "Automatikus csatlakozás",
+ "runningPath": "Fut: {{path}}",
+ "noMicrophone": "Nincs mikrofon",
+ "audioRecordingEnabled": "Hangfelvétel engedélyezve",
+ "noMicrophoneSelected": "Nincs mikrofon kiválasztva",
+ "recordingName": "Felvétel Neve: {{name}}",
+ "startingIn": "Indítás {{countdown}} múlva...",
+ "stopping": "Leállítás...",
+ "starting": "Indítás...",
+ "stopRecordingButton": "🔴 Felvétel Leállítása",
+ "startRecordingButton": "🔴 Felvétel Indítása",
+ "camerasCount": "Kamerák ({{count}})",
+ "availableCamerasCount": "Elérhető ({{count}})",
+ "server": "Szerver",
+ "display": "Kijelző",
+ "rawMessage": "Nyers üzenet",
+ "cameraPerformanceMetrics": "Kamera Teljesítmény Metrikák",
+ "serverLogs": "Szerver Naplók",
+ "sortBy": "Rendezés {{direction}}",
+ "waitingForCameraStreams": "Várakozás a kamera streamekre...",
+ "loggingPaused": "Naplózás szüneteltetve",
+ "noLogsToDisplay": "Nincs megjeleníthető napló",
+ "closeSettings": "Beállítások bezárása",
+ "gridSettings": "Rács beállítások",
+ "clickToShowLess": "Kattintson a kevesebb megjelenítéséhez",
+ "clickToLearnMore": "Kattintson a részletekért",
+ "samples": "minták",
+ "framerateOverTime": "Képkockasebesség az Idő Függvényében",
+ "framerateFps": "Képkockasebesség (fps)",
+ "capturesFramesFromCamera": "Képkockákat rögzít a kamerából.",
+ "rendersReceivedFrames": "A fogadott képkockákat jeleníti meg a képernyőn.",
+ "displayTooltipLong": "A Kijelző a UI renderelési teljesítményt képviseli. Megmutatja, milyen gyorsan fogadja és jeleníti meg a kijelző a képkockákat. Az itt felmerülő teljesítményproblémák nem befolyásolják a felvétel minőségét, de hatással lehetnek a kamerák valós idejű megfigyelésére.",
+ "statsSourceShort": "A Kijelző megjeleníti a képkockákat, a Szerver rögzíti a képkockákat.",
+ "statsSourceLong": "A szerver az a valós sebesség, amellyel a képkockák húzódnak/rögzítődnek a kamerából, míg a kijelző az a sebesség, amellyel fogadja és megjeleníti őket. A Skellycam a szerver oldali teljesítményt helyezi előtérbe a felvétel minősége érdekében, ezért annak a számnak stabilabbnak kell maradnia. Ha a kijelző képkockasebessége eltér a szerverétől, az a rendszer erőforrásainak túlterheltségét jelzi. Fontolja meg kevesebb kamera használatát vagy a képkockasebesség/felbontás csökkentését.",
+ "statsCurrentShort": "Legutóbbi képkocka idő és megfelelő FPS.",
+ "statsCurrentLong": "Ez a legutóbbi mérést mutatja arról, mennyi ideig tart egy képkocka feldolgozása (ezredmásodpercben) és az egyenértékű képkocka/másodperc (FPS). Alacsonyabb képkocka idő és magasabb FPS jobb teljesítményt jelent.",
+ "statsMinShort": "Leggyorsabb képkocka idő (legalacsonyabb késleltetés) és legmagasabb elért FPS.",
+ "statsMinLong": "Ez a mintavételi ablak alatt egy képkocka feldolgozásához szükséges minimális időt képviseli. Ez megfelel a rendszer által optimális körülmények között elért maximális FPS-nek.",
+ "statsMaxShort": "Leglassabb képkocka idő (legmagasabb késleltetés) és legalacsonyabb tapasztalt FPS.",
+ "statsMaxLong": "Ez a mintavételi ablak alatt egy képkocka feldolgozásához szükséges maximális időt képviseli. Ez megfelel a rendszer által a legrosszabb körülmények között elért minimális FPS-nek. Alkalmi kiugrások normálisak, de tartósan magas értékek teljesítményproblémákat jelezhetnek.",
+ "statsMeanShort": "Átlagos képkocka idő és FPS az összes mintán.",
+ "statsMeanLong": "A mintavételi ablak alatt mért összes képkocka idő számtani átlaga és a megfelelő FPS. Ez jó általános képet ad a teljesítményről, de a kiugró értékek torzíthatják.",
+ "statsMedianShort": "Az összes képkocka idő középső értéke (50. percentilis).",
+ "statsMedianLong": "A medián a középső értéket képviseli, amikor az összes képkocka idő a leggyorsabbtól a leglassabbig van rendezve. Az átlaggal ellentétben a mediánt nem befolyásolják a szélsőséges kiugró értékek, így stabilabb mutatója a tipikus teljesítménynek.",
+ "statsStdDevShort": "A képkocka idő változékonyságát méri. CV% a relatív változékonyság.",
+ "statsStdDevLong": "A szórás a képkocka időkben lévő variáció mértékét méri. Az alacsonyabb értékek konzisztensebb teljesítményt jeleznek. A Variációs Együttható (CV%) ezt a változékonyságot az átlag százalékában fejezi ki, megkönnyítve a stabilitás összehasonlítását különböző képkockasebességek között. Az alacsonyabb CV% stabilabb teljesítményt jelez.",
+ "aiTranslatedTooltip": "Ezt a fordítást AI generálta és hibákat tartalmazhat. Ha beszéli ezt a nyelvet, segíthet a javításában egy pull request megnyitásával a GitHubon!",
+ "humanValidatedTooltip": "Ezt a fordítást ember fordító ellenőrizte és jóváhagyta.",
+ "helpTranslate": "Segítsen a SkellyCam fordításában",
+ "failedToFetch": "Lekérés sikertelen",
+ "recordings": "Felvételek",
+ "noRecordingsFound": "Nem találhatók felvételek. Adjon meg egy elérési utat fent a kézi betöltéshez.",
+ "noCamerasDetected": "Nem észlelhetők kamerák",
+ "clickRefreshToScan": "Kattintson a frissítésre az elérhető kamerák kereséséhez",
+ "waitingForData": "Várakozás az adatokra…",
+ "load": "Betöltés",
+ "refresh": "Frissítés",
+ "available": "Elérhető",
+ "menuFile": "Fájl",
+ "menuView": "Nézet",
+ "menuCamera": "Kamera",
+ "menuRecording": "Felvétel",
+ "menuHelp": "Súgó",
+ "menuDetectCameras": "Kamerák keresése",
+ "menuConnectCameras": "Kamerák csatlakoztatása",
+ "menuCloseAllCameras": "Összes kamera bezárása",
+ "menuOpenRecordingFolder": "Felvétel mappa megnyitása…",
+ "menuToggleSidebar": "Oldalsáv ki/be",
+ "menuToggleTheme": "Téma váltás",
+ "menuToggleFullScreen": "Teljes képernyő",
+ "menuPauseUnpause": "Szünet / Folytatás",
+ "menuConnectApplySettings": "Csatlakozás / Beállítások alkalmazása",
+ "menuCloseAll": "Összes bezárása",
+ "menuDocumentation": "Dokumentáció",
+ "menuGitHubRepository": "GitHub tárház",
+ "menuReportIssue": "Hiba bejelentése…",
+ "menuAbout": "A SkellyCam-ról",
+ "menuPlayback": "Lejátszás",
+ "videoPlayback": "Lejátszás",
+ "copyLogsToClipboard": "Naplók másolása a vágólapra",
+ "saveLogsToFile": "Naplók mentése fájlba",
+ "copied": "Másolva!",
+ "timestampFromRecording": "Időbélyeg a felvételi adatokból",
+ "menuCheckForUpdates": "Check for Updates…",
+ "updateAvailable": "Update available",
+ "updateAvailableMessage": "Version {{version}} is available",
+ "downloading": "Downloading…",
+ "downloadComplete": "Download complete",
+ "restartToUpdate": "Restart to update",
+ "checkForUpdates": "Check for Updates",
+ "upToDate": "You are up to date",
+ "updateError": "Update check failed"
+}
diff --git a/freemocap-ui-old/src/i18n/locales/id-bahasa-indonesia.json b/freemocap-ui-old/src/i18n/locales/id-bahasa-indonesia.json
new file mode 100644
index 00000000..4a881e93
--- /dev/null
+++ b/freemocap-ui-old/src/i18n/locales/id-bahasa-indonesia.json
@@ -0,0 +1,258 @@
+{
+ "_meta": {
+ "locale": "id",
+ "translationSource": "ai-generated",
+ "lastUpdated": "2026-02-23"
+ },
+ "appName": "SkellyCam",
+ "appNameDecorated": "SkellyCam 💀📸",
+ "welcomeTitle": "Selamat datang di SkellyCam",
+ "welcomeSubtitle": "Rekam dan lihat video tersinkronisasi",
+ "sendAnonymousPings": "Kirim data penggunaan anonim",
+ "footerWith": "dengan",
+ "footerFrom": "dari",
+ "footerOrgName": "FreeMoCap Foundation",
+ "home": "Beranda",
+ "cameras": "Kamera",
+ "videos": "Video",
+ "expandSidebar": "Perluas bilah sisi",
+ "collapseSidebar": "Ciutkan bilah sisi",
+ "startRecording": "Mulai merekam",
+ "stopRecording": "Berhenti merekam",
+ "toggleTheme": "ubah tema",
+ "switchToDark": "Beralih ke mode gelap",
+ "switchToLight": "Beralih ke mode terang",
+ "connectWebSocket": "Hubungkan WebSocket",
+ "disconnectWebSocket": "Putuskan WebSocket",
+ "launchServer": "Jalankan server",
+ "stopServer": "Hentikan server",
+ "browseForExecutable": "Cari file eksekusi",
+ "refreshCandidates": "Segarkan kandidat",
+ "executable": "Eksekusi",
+ "host": "Host",
+ "port": "Port",
+ "cameraCount_one": "{{count}} kamera",
+ "cameraCount_other": "{{count}} kamera",
+ "connectedCameras": "Kamera terhubung",
+ "availableCameras": "Kamera tersedia",
+ "noCamerasConnected": "Tidak ada kamera terhubung",
+ "detectCameras": "Deteksi kamera tersedia",
+ "clearCameraSettings": "Hapus pengaturan kamera",
+ "copySettingsToAll": "Salin pengaturan ke semua",
+ "recordingTag": "Tag rekaman",
+ "recordingTagPlaceholder": "Tag opsional",
+ "recordingDirectory": "Direktori rekaman",
+ "recordingFolderPath": "Jalur folder rekaman",
+ "delayStart": "Mulai tertunda",
+ "seconds": "Detik",
+ "subfolder": "Subfolder",
+ "subfolderPlaceholder": "Nama subfolder",
+ "baseName": "Nama dasar",
+ "increment": "Kenaikan",
+ "resolution": "Resolusi",
+ "fps": "FPS",
+ "width": "Lebar",
+ "height": "Tinggi",
+ "columns": "Kolom",
+ "auto": "Otomatis",
+ "manual": "Manual",
+ "custom": "Kustom",
+ "current": "Saat ini",
+ "recommend": "Disarankan",
+ "cameraRotation": "rotasi kamera",
+ "selectCameraRotation": "Pilih rotasi gambar kamera",
+ "exposureControl": "Kontrol eksposur otomatis atau manual",
+ "framerateControl": "Kontrol framerate otomatis atau manual",
+ "adjustExposure": "Sesuaikan waktu eksposur",
+ "setTargetFps": "Atur FPS target untuk tangkapan",
+ "recordingCaptureFps": "FPS tangkapan rekaman",
+ "playbackSpeed": "Kecepatan putar",
+ "framerateTimeline": "Timeline framerate",
+ "framerateDistribution": "Distribusi framerate",
+ "timelineView": "Tampilan timeline",
+ "distributionView": "Tampilan distribusi",
+ "combinedView": "Tampilan gabungan",
+ "min": "Min",
+ "max": "Maks",
+ "mean": "Rata-rata",
+ "median": "Median",
+ "stdDevCv": "StdDev/CV",
+ "source": "Sumber",
+ "selectAll": "Pilih semua",
+ "loadSynchronizedVideos": "Muat video tersinkronisasi",
+ "loadSynchronizedVideosDescription": "Halaman ini memungkinkan Anda memuat dan menyinkronkan video yang sudah direkam.",
+ "automaticallySynchronizeVideos": "Sinkronisasi video otomatis",
+ "extractFramesOnLoad": "Ekstrak frame saat memuat",
+ "generateThumbnails": "Buat thumbnail",
+ "noVideosLoaded": "Tidak ada video dimuat",
+ "filterVideos": "Filter video...",
+ "openVideo": "Buka video",
+ "openFolder": "Buka folder di file explorer",
+ "videoFolderPath": "Jalur folder video",
+ "jumpToStart": "Lompat ke awal (Home)",
+ "jumpToEnd": "Lompat ke akhir (End)",
+ "loopOn": "Perulangan aktif (L untuk beralih)",
+ "loopOff": "Pemutaran berulang (L)",
+ "syncInfo": "Info sinkronisasi",
+ "syncInfoTitle": "Sinkronisasi multi-kamera mungkin tidak sempurna per frame",
+ "syncInfoBody": "Pemutaran video di browser tidak menjamin sinkronisasi yang akurat per sampel di beberapa aliran. Pemutar menggunakan strategi pemimpin-pengikut dan mengoreksi penyimpangan saat melebihi toleransi kecil, tetapi desinkronisasi ringan (1–2 frame) dapat terjadi, terutama pada kecepatan pemutaran tinggi atau saat browser dalam beban berat. Untuk analisis yang akurat per frame, gunakan file CSV timestamp mentah yang disertakan dalam setiap rekaman.",
+ "previousFrame": "Frame sebelumnya (← / Shift+← untuk 10)",
+ "nextFrame": "Frame berikutnya (→ / Shift+→ untuk 10)",
+ "zoomIn": "Perbesar",
+ "zoomOut": "Perkecil",
+ "resetZoom": "Reset zoom",
+ "playbackSettings": "Pengaturan putar ulang",
+ "totalRecordingSize": "Ukuran total rekaman di disk",
+ "estimatedTime": "Estimasi waktu (frame ÷ fps)",
+ "estimatedDuration": "Estimasi durasi (total frame ÷ fps)",
+ "estimatedFromFrameNumber": "Estimasi dari nomor frame × fps",
+ "frameCountPerCamera": "Jumlah frame per kamera",
+ "cameraStreams": "Aliran kamera dalam rekaman ini",
+ "backToRecordings": "Kembali ke rekaman",
+ "errorsDetected": "Kesalahan terdeteksi",
+ "somethingWentWrong": "Terjadi kesalahan :(",
+ "searchLogs": "Cari log...",
+ "filter": "Filter…",
+ "refreshMicrophoneList": "Segarkan daftar mikrofon",
+ "date": "Tanggal",
+ "name": "Nama",
+ "size": "Ukuran",
+ "duration": "Durasi",
+ "frames": "Frame",
+ "timestamp": "Stempel waktu",
+ "language": "Bahasa",
+ "aiTranslated": "Terjemahan AI",
+ "humanTranslated": "Terjemahan manusia",
+ "humanValidated": "Divalidasi manusia",
+ "connectCameras": "Hubungkan ke kamera terpilih",
+ "resumeStreaming": "Lanjutkan streaming",
+ "pauseStreaming": "Jeda streaming",
+ "closeAllCameras": "Tutup semua kamera",
+ "framerate": "Framerate",
+ "exposure": "Eksposur",
+ "fileLabel": "File",
+ "timeDelta": "Delta waktu",
+ "pathLabel": "Jalur",
+ "exceptionDetails": "Detail pengecualian",
+ "stackTrace": "Stack trace",
+ "loadingVideos": "Memuat video… ({{ready}}/{{total}} siap)",
+ "gridColumns": "Kolom grid",
+ "settings": "Pengaturan",
+ "appearance": "Tampilan",
+ "themeMode": "Tema",
+ "darkMode": "Gelap",
+ "lightMode": "Terang",
+ "languageSettings": "Bahasa dan lokalisasi",
+ "showTranslationIndicator": "Tampilkan indikator sumber terjemahan",
+ "showTranslationIndicatorDescription": "Tampilkan lencana saat menggunakan terjemahan AI",
+ "translationSourceLabel": "Sumber terjemahan",
+ "general": "Umum",
+ "about": "Tentang",
+ "version": "Versi",
+ "serverSettings": "Server",
+ "recordingSettings": "Pengaturan rekaman",
+ "videoLoadingSettings": "Pengaturan pemuatan video",
+ "connected": "Terhubung",
+ "connecting": "Menghubungkan…",
+ "disconnected": "Terputus",
+ "disconnect": "Putuskan",
+ "connect": "Hubungkan",
+ "off": "Mati",
+ "running": "Berjalan",
+ "stopped": "Berhenti",
+ "working": "Memproses…",
+ "invalid": "Tidak valid",
+ "autoLaunch": "Mulai otomatis",
+ "autoConnect": "Hubung otomatis",
+ "runningPath": "Berjalan: {{path}}",
+ "noMicrophone": "Tanpa mikrofon",
+ "audioRecordingEnabled": "Rekaman audio diaktifkan",
+ "noMicrophoneSelected": "Mikrofon tidak dipilih",
+ "recordingName": "Nama rekaman: {{name}}",
+ "startingIn": "Mulai dalam {{countdown}}...",
+ "stopping": "Menghentikan...",
+ "starting": "Memulai...",
+ "stopRecordingButton": "🔴 Berhenti merekam",
+ "startRecordingButton": "🔴 Mulai merekam",
+ "camerasCount": "Kamera ({{count}})",
+ "availableCamerasCount": "Tersedia ({{count}})",
+ "server": "Server",
+ "display": "Tampilan",
+ "rawMessage": "Pesan mentah",
+ "cameraPerformanceMetrics": "Metrik kinerja kamera",
+ "serverLogs": "Log server",
+ "sortBy": "Urutkan {{direction}}",
+ "waitingForCameraStreams": "Menunggu aliran kamera...",
+ "loggingPaused": "Pencatatan dijeda",
+ "noLogsToDisplay": "Tidak ada log untuk ditampilkan",
+ "closeSettings": "Tutup pengaturan",
+ "gridSettings": "Pengaturan grid",
+ "clickToShowLess": "Klik untuk sembunyikan",
+ "clickToLearnMore": "Klik untuk info lebih lanjut",
+ "samples": "sampel",
+ "framerateOverTime": "Framerate seiring waktu",
+ "framerateFps": "Framerate (fps)",
+ "capturesFramesFromCamera": "Menangkap frame dari kamera.",
+ "rendersReceivedFrames": "Merender frame yang diterima di layar.",
+ "displayTooltipLong": "Tampilan merepresentasikan kinerja rendering antarmuka pengguna. Ini menunjukkan seberapa cepat layar Anda menerima dan merender frame. Masalah kinerja di sini tidak akan memengaruhi kualitas rekaman tetapi dapat memengaruhi kemampuan Anda untuk memantau kamera secara real-time.",
+ "statsSourceShort": "Display merender frame, server menangkap frame.",
+ "statsSourceLong": "Server adalah kecepatan nyata frame ditarik/direkam dari kamera, sedangkan tampilan adalah kecepatan penerimaan dan rendering. SkellyCam memprioritaskan kinerja sisi server untuk kualitas rekaman, sehingga angka tersebut seharusnya lebih stabil. Jika framerate tampilan menyimpang dari server, ini menunjukkan sumber daya sistem Anda sedang terbebani. Pertimbangkan untuk menggunakan lebih sedikit kamera atau menurunkan framerate/resolusi.",
+ "statsCurrentShort": "Waktu frame dan FPS terbaru.",
+ "statsCurrentLong": "Ini menunjukkan pengukuran terbaru berapa lama waktu yang dibutuhkan untuk memproses satu frame (dalam milidetik) dan frame per detik (FPS) yang setara. Waktu frame lebih rendah dan FPS lebih tinggi menunjukkan kinerja yang lebih baik.",
+ "statsMinShort": "Waktu frame tercepat dan FPS tertinggi.",
+ "statsMinLong": "Ini merepresentasikan waktu minimum yang dibutuhkan untuk memproses satu frame selama jendela sampling. Ini sesuai dengan FPS maksimum yang dicapai sistem Anda dalam kondisi optimal.",
+ "statsMaxShort": "Waktu frame terlambat dan FPS terendah.",
+ "statsMaxLong": "Ini merepresentasikan waktu maksimum yang dibutuhkan untuk memproses satu frame selama jendela sampling. Ini sesuai dengan FPS minimum dalam kondisi terburuk. Lonjakan sesekali adalah normal, tetapi nilai tinggi yang konsisten dapat mengindikasikan masalah kinerja.",
+ "statsMeanShort": "Rata-rata waktu frame dan FPS dari semua sampel.",
+ "statsMeanLong": "Rata-rata aritmetika dari semua waktu frame yang diukur selama jendela sampling dan FPS yang sesuai. Ini memberikan gambaran keseluruhan yang baik tentang kinerja tetapi dapat dipengaruhi oleh nilai ekstrem.",
+ "statsMedianShort": "Nilai median dari semua waktu frame (persentil ke-50).",
+ "statsMedianLong": "Median merepresentasikan nilai tengah ketika semua waktu frame diurutkan dari tercepat ke terlambat. Berbeda dengan rata-rata, median tidak terpengaruh oleh nilai ekstrem, menjadikannya indikator yang lebih stabil dari kinerja tipikal.",
+ "statsStdDevShort": "Mengukur variabilitas waktu frame. CV% relatif.",
+ "statsStdDevLong": "Deviasi standar mengukur jumlah variasi dalam waktu frame. Nilai lebih rendah menunjukkan kinerja yang lebih konsisten. Koefisien Variasi (CV%) menyatakan variabilitas ini sebagai persentase dari rata-rata, memudahkan perbandingan stabilitas di berbagai frame rate. CV% lebih rendah menunjukkan kinerja yang lebih stabil.",
+ "aiTranslatedTooltip": "Terjemahan ini dibuat oleh AI dan mungkin mengandung kesalahan. Jika Anda berbicara bahasa ini, bantu perbaiki!",
+ "humanValidatedTooltip": "Terjemahan ini telah diverifikasi oleh penerjemah manusia.",
+ "helpTranslate": "Bantu terjemahkan SkellyCam",
+ "failedToFetch": "Gagal mengambil data",
+ "recordings": "Rekaman",
+ "noRecordingsFound": "Tidak ada rekaman ditemukan. Masukkan jalur di atas untuk memuat secara manual.",
+ "noCamerasDetected": "Tidak ada kamera terdeteksi",
+ "clickRefreshToScan": "Klik segarkan untuk memindai kamera yang tersedia",
+ "waitingForData": "Menunggu data…",
+ "load": "Muat",
+ "refresh": "Segarkan",
+ "available": "Tersedia",
+ "menuFile": "Berkas",
+ "menuView": "Tampilan",
+ "menuCamera": "Kamera",
+ "menuRecording": "Perekaman",
+ "menuHelp": "Bantuan",
+ "menuDetectCameras": "Deteksi kamera",
+ "menuConnectCameras": "Hubungkan kamera",
+ "menuCloseAllCameras": "Tutup semua kamera",
+ "menuOpenRecordingFolder": "Buka folder perekaman…",
+ "menuToggleSidebar": "Alihkan bilah sisi",
+ "menuToggleTheme": "Ganti tema",
+ "menuToggleFullScreen": "Layar penuh",
+ "menuPauseUnpause": "Jeda / Lanjutkan",
+ "menuConnectApplySettings": "Hubungkan / Terapkan pengaturan",
+ "menuCloseAll": "Tutup semua",
+ "menuDocumentation": "Dokumentasi",
+ "menuGitHubRepository": "Repositori GitHub",
+ "menuReportIssue": "Laporkan masalah…",
+ "menuAbout": "Tentang SkellyCam",
+ "menuPlayback": "Pemutaran",
+ "videoPlayback": "Pemutaran",
+ "copyLogsToClipboard": "Salin log ke papan klip",
+ "saveLogsToFile": "Simpan log ke file",
+ "copied": "Disalin!",
+ "timestampFromRecording": "Cap waktu dari data rekaman",
+ "menuCheckForUpdates": "Check for Updates…",
+ "updateAvailable": "Update available",
+ "updateAvailableMessage": "Version {{version}} is available",
+ "downloading": "Downloading…",
+ "downloadComplete": "Download complete",
+ "restartToUpdate": "Restart to update",
+ "checkForUpdates": "Check for Updates",
+ "upToDate": "You are up to date",
+ "updateError": "Update check failed"
+}
diff --git a/freemocap-ui-old/src/i18n/locales/it-italiano.json b/freemocap-ui-old/src/i18n/locales/it-italiano.json
new file mode 100644
index 00000000..cb3a92b1
--- /dev/null
+++ b/freemocap-ui-old/src/i18n/locales/it-italiano.json
@@ -0,0 +1,258 @@
+{
+ "_meta": {
+ "locale": "it",
+ "translationSource": "ai-generated",
+ "lastUpdated": "2026-02-23"
+ },
+ "appName": "SkellyCam",
+ "appNameDecorated": "SkellyCam 💀📸",
+ "welcomeTitle": "Benvenuto in SkellyCam",
+ "welcomeSubtitle": "Registra e visualizza video sincronizzati",
+ "sendAnonymousPings": "Invia dati di utilizzo anonimi",
+ "footerWith": "con",
+ "footerFrom": "dalla",
+ "footerOrgName": "FreeMoCap Foundation",
+ "home": "Home",
+ "cameras": "Telecamere",
+ "videos": "Video",
+ "expandSidebar": "Espandi barra laterale",
+ "collapseSidebar": "Comprimi barra laterale",
+ "startRecording": "Avvia registrazione",
+ "stopRecording": "Ferma registrazione",
+ "toggleTheme": "cambia tema",
+ "switchToDark": "Passa alla modalità scura",
+ "switchToLight": "Passa alla modalità chiara",
+ "connectWebSocket": "Connetti WebSocket",
+ "disconnectWebSocket": "Disconnetti WebSocket",
+ "launchServer": "Avvia server",
+ "stopServer": "Ferma server",
+ "browseForExecutable": "Cerca eseguibile",
+ "refreshCandidates": "Aggiorna candidati",
+ "executable": "Eseguibile",
+ "host": "Host",
+ "port": "Porta",
+ "cameraCount_one": "{{count}} telecamera",
+ "cameraCount_other": "{{count}} telecamere",
+ "connectedCameras": "Telecamere connesse",
+ "availableCameras": "Telecamere disponibili",
+ "noCamerasConnected": "Nessuna telecamera connessa",
+ "detectCameras": "Rileva telecamere disponibili",
+ "clearCameraSettings": "Cancella impostazioni telecamera",
+ "copySettingsToAll": "Copia impostazioni su tutte",
+ "recordingTag": "Tag registrazione",
+ "recordingTagPlaceholder": "Tag opzionale",
+ "recordingDirectory": "Directory registrazione",
+ "recordingFolderPath": "Percorso cartella registrazione",
+ "delayStart": "Avvio ritardato",
+ "seconds": "Secondi",
+ "subfolder": "Sottocartella",
+ "subfolderPlaceholder": "Nome sottocartella",
+ "baseName": "Nome base",
+ "increment": "Incremento",
+ "resolution": "Risoluzione",
+ "fps": "FPS",
+ "width": "Larghezza",
+ "height": "Altezza",
+ "columns": "Colonne",
+ "auto": "Auto",
+ "manual": "Manuale",
+ "custom": "Personalizzato",
+ "current": "Corrente",
+ "recommend": "Consigliato",
+ "cameraRotation": "rotazione telecamera",
+ "selectCameraRotation": "Seleziona rotazione immagine",
+ "exposureControl": "Controllo esposizione automatico o manuale",
+ "framerateControl": "Controllo framerate automatico o manuale",
+ "adjustExposure": "Regola tempo di esposizione",
+ "setTargetFps": "Imposta FPS obiettivo per cattura",
+ "recordingCaptureFps": "FPS cattura registrazione",
+ "playbackSpeed": "Velocità riproduzione",
+ "framerateTimeline": "Timeline framerate",
+ "framerateDistribution": "Distribuzione framerate",
+ "timelineView": "Vista timeline",
+ "distributionView": "Vista distribuzione",
+ "combinedView": "Vista combinata",
+ "min": "Min",
+ "max": "Max",
+ "mean": "Media",
+ "median": "Mediana",
+ "stdDevCv": "DevStd/CV",
+ "source": "Sorgente",
+ "selectAll": "Seleziona tutto",
+ "loadSynchronizedVideos": "Carica video sincronizzati",
+ "loadSynchronizedVideosDescription": "Questa pagina permette di caricare e sincronizzare video pre-registrati.",
+ "automaticallySynchronizeVideos": "Sincronizza video automaticamente",
+ "extractFramesOnLoad": "Estrai fotogrammi al caricamento",
+ "generateThumbnails": "Genera miniature",
+ "noVideosLoaded": "Nessun video caricato",
+ "filterVideos": "Filtra video...",
+ "openVideo": "Apri video",
+ "openFolder": "Apri cartella in esplora risorse",
+ "videoFolderPath": "Percorso cartella video",
+ "jumpToStart": "Vai all'inizio (Home)",
+ "jumpToEnd": "Vai alla fine (End)",
+ "loopOn": "Ripetizione attiva (L per alternare)",
+ "loopOff": "Riproduzione in loop (L)",
+ "syncInfo": "Info sincronizzazione",
+ "syncInfoTitle": "La sincronizzazione multi-camera potrebbe non essere perfetta a livello di fotogramma",
+ "syncInfoBody": "La riproduzione video nel browser non garantisce una sincronizzazione precisa a livello di campione su più flussi. Il player utilizza una strategia leader-follower e corregge la deviazione quando supera una piccola tolleranza, ma può verificarsi una leggera desincronizzazione (1–2 fotogrammi), specialmente a velocità di riproduzione elevate o quando il browser è sotto carico. Per un'analisi precisa a livello di fotogramma, utilizzare i file CSV dei timestamp grezzi inclusi in ogni registrazione.",
+ "previousFrame": "Fotogramma precedente (← / Shift+← per 10)",
+ "nextFrame": "Fotogramma successivo (→ / Shift+→ per 10)",
+ "zoomIn": "Zoom avanti",
+ "zoomOut": "Zoom indietro",
+ "resetZoom": "Reimposta zoom",
+ "playbackSettings": "Impostazioni riproduzione",
+ "totalRecordingSize": "Dimensione totale registrazione su disco",
+ "estimatedTime": "Tempo stimato (frame ÷ fps)",
+ "estimatedDuration": "Durata stimata (frame totali ÷ fps)",
+ "estimatedFromFrameNumber": "Stimato dal numero fotogramma × fps",
+ "frameCountPerCamera": "Conteggio fotogrammi per telecamera",
+ "cameraStreams": "Flussi telecamera in questa registrazione",
+ "backToRecordings": "Torna alle registrazioni",
+ "errorsDetected": "Errori rilevati",
+ "somethingWentWrong": "Qualcosa è andato storto :(",
+ "searchLogs": "Cerca nei registri...",
+ "filter": "Filtra…",
+ "refreshMicrophoneList": "Aggiorna elenco microfoni",
+ "date": "Data",
+ "name": "Nome",
+ "size": "Dimensione",
+ "duration": "Durata",
+ "frames": "Fotogrammi",
+ "timestamp": "Timestamp",
+ "language": "Lingua",
+ "aiTranslated": "Traduzione IA",
+ "humanTranslated": "Traduzione umana",
+ "humanValidated": "Validato da umano",
+ "connectCameras": "Connetti alle telecamere selezionate",
+ "resumeStreaming": "Riprendi lo streaming",
+ "pauseStreaming": "Metti in pausa lo streaming",
+ "closeAllCameras": "Chiudi tutte le telecamere",
+ "framerate": "Framerate",
+ "exposure": "Esposizione",
+ "fileLabel": "File",
+ "timeDelta": "Delta temporale",
+ "pathLabel": "Percorso",
+ "exceptionDetails": "Dettagli eccezione",
+ "stackTrace": "Stack trace",
+ "loadingVideos": "Caricamento video… ({{ready}}/{{total}} pronti)",
+ "gridColumns": "Colonne griglia",
+ "settings": "Impostazioni",
+ "appearance": "Aspetto",
+ "themeMode": "Tema",
+ "darkMode": "Scuro",
+ "lightMode": "Chiaro",
+ "languageSettings": "Lingua e localizzazione",
+ "showTranslationIndicator": "Mostra indicatore fonte traduzione",
+ "showTranslationIndicatorDescription": "Mostra badge con traduzioni IA",
+ "translationSourceLabel": "Fonte traduzione",
+ "general": "Generale",
+ "about": "Informazioni",
+ "version": "Versione",
+ "serverSettings": "Server",
+ "recordingSettings": "Impostazioni registrazione",
+ "videoLoadingSettings": "Impostazioni caricamento video",
+ "connected": "Connesso",
+ "connecting": "Connessione…",
+ "disconnected": "Disconnesso",
+ "disconnect": "Disconnetti",
+ "connect": "Connetti",
+ "off": "Spento",
+ "running": "In esecuzione",
+ "stopped": "Fermato",
+ "working": "Elaborazione…",
+ "invalid": "Non valido",
+ "autoLaunch": "Avvio auto",
+ "autoConnect": "Connessione auto",
+ "runningPath": "In esecuzione: {{path}}",
+ "noMicrophone": "Nessun microfono",
+ "audioRecordingEnabled": "Registrazione audio attivata",
+ "noMicrophoneSelected": "Nessun microfono selezionato",
+ "recordingName": "Nome registrazione: {{name}}",
+ "startingIn": "Inizio tra {{countdown}}...",
+ "stopping": "Arresto...",
+ "starting": "Avvio...",
+ "stopRecordingButton": "🔴 Ferma registrazione",
+ "startRecordingButton": "🔴 Avvia registrazione",
+ "camerasCount": "Telecamere ({{count}})",
+ "availableCamerasCount": "Disponibili ({{count}})",
+ "server": "Server",
+ "display": "Display",
+ "rawMessage": "Messaggio grezzo",
+ "cameraPerformanceMetrics": "Metriche prestazioni telecamera",
+ "serverLogs": "Registri server",
+ "sortBy": "Ordina {{direction}}",
+ "waitingForCameraStreams": "In attesa dei flussi della telecamera...",
+ "loggingPaused": "Registrazione in pausa",
+ "noLogsToDisplay": "Nessun registro da mostrare",
+ "closeSettings": "Chiudi impostazioni",
+ "gridSettings": "Impostazioni griglia",
+ "clickToShowLess": "Clicca per ridurre",
+ "clickToLearnMore": "Clicca per saperne di più",
+ "samples": "campioni",
+ "framerateOverTime": "Framerate nel tempo",
+ "framerateFps": "Framerate (fps)",
+ "capturesFramesFromCamera": "Cattura fotogrammi dalla telecamera.",
+ "rendersReceivedFrames": "Renderizza i fotogrammi ricevuti sullo schermo.",
+ "displayTooltipLong": "Il display rappresenta le prestazioni di rendering dell'interfaccia utente. Mostra quanto velocemente il display riceve e renderizza i fotogrammi. Problemi di prestazioni qui non influenzeranno la qualità della registrazione ma possono influire sulla capacità di monitorare le telecamere in tempo reale.",
+ "statsSourceShort": "Il display renderizza, il server cattura i fotogrammi.",
+ "statsSourceLong": "Il server è la velocità reale con cui i fotogrammi vengono estratti/registrati dalla telecamera, mentre il display è la velocità con cui vengono ricevuti e renderizzati. SkellyCam dà priorità alle prestazioni lato server per la qualità della registrazione, quindi quel numero dovrebbe rimanere più stabile. Se il framerate del display diverge dal server, indica che le risorse del sistema sono sovraccaricate. Considera l'uso di meno telecamere o la riduzione di framerate/risoluzione.",
+ "statsCurrentShort": "Tempo fotogramma e FPS più recenti.",
+ "statsCurrentLong": "Mostra la misurazione più recente del tempo di elaborazione di un singolo fotogramma (in millisecondi) e i fotogrammi al secondo (FPS) equivalenti. Tempi fotogramma più bassi e FPS più alti indicano prestazioni migliori.",
+ "statsMinShort": "Tempo fotogramma più veloce e FPS più alto.",
+ "statsMinLong": "Rappresenta il tempo minimo di elaborazione di un singolo fotogramma durante la finestra di campionamento. Corrisponde al FPS massimo raggiunto dal sistema in condizioni ottimali.",
+ "statsMaxShort": "Tempo fotogramma più lento e FPS più basso.",
+ "statsMaxLong": "Rappresenta il tempo massimo di elaborazione di un singolo fotogramma durante la finestra di campionamento. Corrisponde al FPS minimo nelle peggiori condizioni. Picchi occasionali sono normali, ma valori costantemente alti possono indicare problemi di prestazioni.",
+ "statsMeanShort": "Tempo medio fotogramma e FPS su tutti i campioni.",
+ "statsMeanLong": "La media aritmetica di tutti i tempi fotogramma misurati durante la finestra di campionamento e i FPS corrispondenti. Fornisce un buon quadro generale delle prestazioni ma può essere distorta da valori anomali.",
+ "statsMedianShort": "Valore mediano di tutti i tempi fotogramma (50° percentile).",
+ "statsMedianLong": "La mediana rappresenta il valore centrale quando tutti i tempi fotogramma sono ordinati dal più veloce al più lento. A differenza della media, la mediana non è influenzata da valori anomali estremi, rendendola un indicatore più stabile delle prestazioni tipiche.",
+ "statsStdDevShort": "Misura la variabilità del tempo fotogramma.",
+ "statsStdDevLong": "La deviazione standard misura la variazione nei tempi fotogramma. Valori più bassi indicano prestazioni più consistenti. Il Coefficiente di Variazione (CV%) esprime questa variabilità come percentuale della media, facilitando il confronto della stabilità tra diversi frame rate. Un CV% più basso indica prestazioni più stabili.",
+ "aiTranslatedTooltip": "Questa traduzione è stata generata dall'IA e potrebbe contenere errori. Se parli questa lingua, aiutaci a migliorarla!",
+ "humanValidatedTooltip": "Questa traduzione è stata verificata da un traduttore umano.",
+ "helpTranslate": "Aiuta a tradurre SkellyCam",
+ "failedToFetch": "Recupero non riuscito",
+ "recordings": "Registrazioni",
+ "noRecordingsFound": "Nessuna registrazione trovata. Inserisci un percorso sopra per caricare manualmente.",
+ "noCamerasDetected": "Nessuna telecamera rilevata",
+ "clickRefreshToScan": "Clicca aggiorna per cercare le telecamere disponibili",
+ "waitingForData": "In attesa di dati…",
+ "load": "Carica",
+ "refresh": "Aggiorna",
+ "available": "Disponibile",
+ "menuFile": "File",
+ "menuView": "Vista",
+ "menuCamera": "Fotocamera",
+ "menuRecording": "Registrazione",
+ "menuHelp": "Aiuto",
+ "menuDetectCameras": "Rileva fotocamere",
+ "menuConnectCameras": "Connetti fotocamere",
+ "menuCloseAllCameras": "Chiudi tutte le fotocamere",
+ "menuOpenRecordingFolder": "Apri cartella registrazione…",
+ "menuToggleSidebar": "Mostra/nascondi barra laterale",
+ "menuToggleTheme": "Cambia tema",
+ "menuToggleFullScreen": "Schermo intero",
+ "menuPauseUnpause": "Pausa / Riprendi",
+ "menuConnectApplySettings": "Connetti / Applica impostazioni",
+ "menuCloseAll": "Chiudi tutto",
+ "menuDocumentation": "Documentazione",
+ "menuGitHubRepository": "Repository GitHub",
+ "menuReportIssue": "Segnala un problema…",
+ "menuAbout": "Informazioni su SkellyCam",
+ "menuPlayback": "Riproduzione",
+ "videoPlayback": "Riproduzione",
+ "copyLogsToClipboard": "Copia i log negli appunti",
+ "saveLogsToFile": "Salva i log su file",
+ "copied": "Copiato!",
+ "timestampFromRecording": "Timestamp dai dati di registrazione",
+ "menuCheckForUpdates": "Check for Updates…",
+ "updateAvailable": "Update available",
+ "updateAvailableMessage": "Version {{version}} is available",
+ "downloading": "Downloading…",
+ "downloadComplete": "Download complete",
+ "restartToUpdate": "Restart to update",
+ "checkForUpdates": "Check for Updates",
+ "upToDate": "You are up to date",
+ "updateError": "Update check failed"
+}
diff --git a/freemocap-ui-old/src/i18n/locales/ja-nihongo.json b/freemocap-ui-old/src/i18n/locales/ja-nihongo.json
new file mode 100644
index 00000000..446f7570
--- /dev/null
+++ b/freemocap-ui-old/src/i18n/locales/ja-nihongo.json
@@ -0,0 +1,258 @@
+{
+ "_meta": {
+ "locale": "ja",
+ "translationSource": "ai-generated",
+ "lastUpdated": "2026-02-23"
+ },
+ "appName": "SkellyCam",
+ "appNameDecorated": "SkellyCam 💀📸",
+ "welcomeTitle": "SkellyCamへようこそ",
+ "welcomeSubtitle": "同期ビデオの録画と再生",
+ "sendAnonymousPings": "匿名使用データを送信",
+ "footerWith": "で",
+ "footerFrom": "から",
+ "footerOrgName": "FreeMoCap Foundation",
+ "home": "ホーム",
+ "cameras": "カメラ",
+ "videos": "ビデオ",
+ "expandSidebar": "サイドバーを展開",
+ "collapseSidebar": "サイドバーを折りたたむ",
+ "startRecording": "録画開始",
+ "stopRecording": "録画停止",
+ "toggleTheme": "テーマ切替",
+ "switchToDark": "ダークモードに切替",
+ "switchToLight": "ライトモードに切替",
+ "connectWebSocket": "WebSocket接続",
+ "disconnectWebSocket": "WebSocket切断",
+ "launchServer": "サーバーを起動",
+ "stopServer": "サーバーを停止",
+ "browseForExecutable": "実行ファイルを参照",
+ "refreshCandidates": "候補を更新",
+ "executable": "実行ファイル",
+ "host": "ホスト",
+ "port": "ポート",
+ "cameraCount_one": "{{count}}台のカメラ",
+ "cameraCount_other": "{{count}}台のカメラ",
+ "connectedCameras": "接続済みカメラ",
+ "availableCameras": "利用可能なカメラ",
+ "noCamerasConnected": "カメラが接続されていません",
+ "detectCameras": "利用可能なカメラを検出",
+ "clearCameraSettings": "カメラ設定をクリア",
+ "copySettingsToAll": "全カメラに設定をコピー",
+ "recordingTag": "録画タグ",
+ "recordingTagPlaceholder": "オプションタグ",
+ "recordingDirectory": "録画ディレクトリ",
+ "recordingFolderPath": "録画フォルダのパス",
+ "delayStart": "遅延スタート",
+ "seconds": "秒",
+ "subfolder": "サブフォルダ",
+ "subfolderPlaceholder": "サブフォルダ名",
+ "baseName": "ベース名",
+ "increment": "インクリメント",
+ "resolution": "解像度",
+ "fps": "FPS",
+ "width": "幅",
+ "height": "高さ",
+ "columns": "列",
+ "auto": "自動",
+ "manual": "手動",
+ "custom": "カスタム",
+ "current": "現在",
+ "recommend": "推奨",
+ "cameraRotation": "カメラ回転",
+ "selectCameraRotation": "カメラ画像の回転を選択",
+ "exposureControl": "自動または手動の露出制御",
+ "framerateControl": "自動または手動のフレームレート制御",
+ "adjustExposure": "露出時間を調整",
+ "setTargetFps": "キャプチャの目標FPSを設定",
+ "recordingCaptureFps": "録画キャプチャFPS",
+ "playbackSpeed": "再生速度",
+ "framerateTimeline": "フレームレートタイムライン",
+ "framerateDistribution": "フレームレート分布",
+ "timelineView": "タイムライン表示",
+ "distributionView": "分布表示",
+ "combinedView": "複合表示",
+ "min": "最小",
+ "max": "最大",
+ "mean": "平均",
+ "median": "中央値",
+ "stdDevCv": "標準偏差/CV",
+ "source": "ソース",
+ "selectAll": "すべて選択",
+ "loadSynchronizedVideos": "同期ビデオを読み込む",
+ "loadSynchronizedVideosDescription": "このページで事前録画したビデオを読み込んで同期できます。",
+ "automaticallySynchronizeVideos": "ビデオを自動同期",
+ "extractFramesOnLoad": "読込時にフレームを抽出",
+ "generateThumbnails": "サムネイル生成",
+ "noVideosLoaded": "ビデオが読み込まれていません",
+ "filterVideos": "ビデオをフィルター...",
+ "openVideo": "ビデオを開く",
+ "openFolder": "エクスプローラーで開く",
+ "videoFolderPath": "ビデオフォルダのパス",
+ "jumpToStart": "先頭へ (Home)",
+ "jumpToEnd": "末尾へ (End)",
+ "loopOn": "ループオン(Lで切替)",
+ "loopOff": "ループ再生(L)",
+ "syncInfo": "同期情報",
+ "syncInfoTitle": "マルチカメラ同期はフレーム単位で完全ではない場合があります",
+ "syncInfoBody": "ブラウザのビデオ再生は、複数のストリーム間でサンプル精度の同期を保証しません。プレーヤーはリーダー・フォロワー戦略を使用し、小さな許容範囲を超えるとドリフトを補正しますが、特に高い再生速度やブラウザが負荷状態にある場合、わずかな非同期(1〜2フレーム)が発生する可能性があります。フレーム精度の分析には、各録画に含まれる生のタイムスタンプCSVファイルを使用してください。",
+ "previousFrame": "前のフレーム (← / Shift+←で10)",
+ "nextFrame": "次のフレーム (→ / Shift+→で10)",
+ "zoomIn": "ズームイン",
+ "zoomOut": "ズームアウト",
+ "resetZoom": "ズームリセット",
+ "playbackSettings": "再生設定",
+ "totalRecordingSize": "ディスク上の録画合計サイズ",
+ "estimatedTime": "推定時間 (フレーム ÷ fps)",
+ "estimatedDuration": "推定時間 (総フレーム ÷ fps)",
+ "estimatedFromFrameNumber": "フレーム番号 × fpsから推定",
+ "frameCountPerCamera": "カメラ別フレーム数",
+ "cameraStreams": "この録画のカメラストリーム",
+ "backToRecordings": "録画一覧に戻る",
+ "errorsDetected": "エラーが検出されました",
+ "somethingWentWrong": "問題が発生しました :(",
+ "searchLogs": "ログを検索...",
+ "filter": "フィルター…",
+ "refreshMicrophoneList": "マイクリストを更新",
+ "date": "日付",
+ "name": "名前",
+ "size": "サイズ",
+ "duration": "再生時間",
+ "frames": "フレーム",
+ "timestamp": "タイムスタンプ",
+ "language": "言語",
+ "aiTranslated": "AI翻訳",
+ "humanTranslated": "人間の翻訳",
+ "humanValidated": "人間が検証",
+ "connectCameras": "選択したカメラに接続",
+ "resumeStreaming": "ストリーミング再開",
+ "pauseStreaming": "ストリーミング一時停止",
+ "closeAllCameras": "全カメラを閉じる",
+ "framerate": "フレームレート",
+ "exposure": "露出",
+ "fileLabel": "ファイル",
+ "timeDelta": "時間差",
+ "pathLabel": "パス",
+ "exceptionDetails": "例外の詳細",
+ "stackTrace": "スタックトレース",
+ "loadingVideos": "ビデオ読込中… ({{ready}}/{{total}} 準備完了)",
+ "gridColumns": "グリッド列",
+ "settings": "設定",
+ "appearance": "外観",
+ "themeMode": "テーマ",
+ "darkMode": "ダーク",
+ "lightMode": "ライト",
+ "languageSettings": "言語とローカリゼーション",
+ "showTranslationIndicator": "翻訳ソースインジケーターを表示",
+ "showTranslationIndicatorDescription": "AI翻訳使用時にバッジを表示",
+ "translationSourceLabel": "翻訳ソース",
+ "general": "一般",
+ "about": "このアプリについて",
+ "version": "バージョン",
+ "serverSettings": "サーバー",
+ "recordingSettings": "録画設定",
+ "videoLoadingSettings": "ビデオ読込設定",
+ "connected": "接続済み",
+ "connecting": "接続中…",
+ "disconnected": "切断",
+ "disconnect": "切断",
+ "connect": "接続",
+ "off": "オフ",
+ "running": "実行中",
+ "stopped": "停止",
+ "working": "処理中…",
+ "invalid": "無効",
+ "autoLaunch": "自動起動",
+ "autoConnect": "自動接続",
+ "runningPath": "実行中: {{path}}",
+ "noMicrophone": "マイクなし",
+ "audioRecordingEnabled": "音声録音有効",
+ "noMicrophoneSelected": "マイク未選択",
+ "recordingName": "録画名: {{name}}",
+ "startingIn": "{{countdown}}秒後に開始...",
+ "stopping": "停止中...",
+ "starting": "開始中...",
+ "stopRecordingButton": "🔴 録画停止",
+ "startRecordingButton": "🔴 録画開始",
+ "camerasCount": "カメラ ({{count}})",
+ "availableCamerasCount": "利用可能 ({{count}})",
+ "server": "サーバー",
+ "display": "ディスプレイ",
+ "rawMessage": "生メッセージ",
+ "cameraPerformanceMetrics": "カメラパフォーマンス指標",
+ "serverLogs": "サーバーログ",
+ "sortBy": "並べ替え {{direction}}",
+ "waitingForCameraStreams": "カメラストリームを待機中...",
+ "loggingPaused": "ログ一時停止",
+ "noLogsToDisplay": "表示するログがありません",
+ "closeSettings": "設定を閉じる",
+ "gridSettings": "グリッド設定",
+ "clickToShowLess": "クリックで折りたたむ",
+ "clickToLearnMore": "詳細はクリック",
+ "samples": "サンプル",
+ "framerateOverTime": "フレームレートの推移",
+ "framerateFps": "フレームレート (fps)",
+ "capturesFramesFromCamera": "カメラからフレームをキャプチャ。",
+ "rendersReceivedFrames": "受信フレームを画面にレンダリング。",
+ "displayTooltipLong": "ディスプレイはUIレンダリング性能を表します。ディスプレイがフレームを受信しレンダリングする速度を示します。ここでのパフォーマンス問題は録画品質に影響しませんが、リアルタイムでカメラを監視する能力に影響する可能性があります。",
+ "statsSourceShort": "ディスプレイはフレームをレンダリング、サーバーはフレームをキャプチャ。",
+ "statsSourceLong": "サーバーはカメラからフレームが取得/録画される実際のレートであり、ディスプレイはフレームが受信・レンダリングされるレートです。SkellyCamは録画品質のためにサーバー側のパフォーマンスを優先するため、その数値はより安定しているはずです。ディスプレイのフレームレートがサーバーと乖離する場合、システムリソースが逼迫していることを示します。カメラの数を減らすか、フレームレート/解像度を下げることを検討してください。",
+ "statsCurrentShort": "最新のフレーム時間とFPS。",
+ "statsCurrentLong": "単一フレームの処理にかかる時間(ミリ秒)と、それに相当する毎秒フレーム数(FPS)の最新の測定値を表示します。フレーム時間が短く、FPSが高いほど、パフォーマンスが良いことを示します。",
+ "statsMinShort": "最速フレーム時間と最高FPS。",
+ "statsMinLong": "サンプリングウィンドウ中に単一フレームを処理するのにかかった最小時間を表します。最適な条件下でシステムが達成した最大FPSに相当します。",
+ "statsMaxShort": "最遅フレーム時間と最低FPS。",
+ "statsMaxLong": "サンプリングウィンドウ中に単一フレームを処理するのにかかった最大時間を表します。最悪の条件下での最小FPSに相当します。時折のスパイクは正常ですが、持続的に高い値はパフォーマンスの問題を示している可能性があります。",
+ "statsMeanShort": "全サンプルの平均フレーム時間とFPS。",
+ "statsMeanLong": "サンプリングウィンドウ中に測定されたすべてのフレーム時間の算術平均と対応するFPSです。パフォーマンスの全体像を良く把握できますが、外れ値によって歪む可能性があります。",
+ "statsMedianShort": "全フレーム時間の中央値(50パーセンタイル)。",
+ "statsMedianLong": "中央値は、すべてのフレーム時間を最速から最遅まで並べたときの中間値を表します。平均値と異なり、中央値は極端な外れ値の影響を受けないため、典型的なパフォーマンスのより安定した指標となります。",
+ "statsStdDevShort": "フレーム時間の変動性を測定。CV%は相対的。",
+ "statsStdDevLong": "標準偏差はフレーム時間のばらつきの量を測定します。低い値はより一貫したパフォーマンスを示します。変動係数(CV%)はこのばらつきを平均の割合として表し、異なるフレームレート間での安定性の比較を容易にします。低いCV%はより安定したパフォーマンスを示します。",
+ "aiTranslatedTooltip": "この翻訳はAIによって生成されたもので、誤りを含む可能性があります。この言語を話す方は改善にご協力ください!",
+ "humanValidatedTooltip": "この翻訳は人間の翻訳者によって確認されています。",
+ "helpTranslate": "SkellyCamの翻訳を手伝う",
+ "failedToFetch": "取得に失敗",
+ "recordings": "録画",
+ "noRecordingsFound": "録画が見つかりません。上にパスを入力して手動で読み込んでください。",
+ "noCamerasDetected": "カメラが検出されませんでした",
+ "clickRefreshToScan": "更新をクリックして利用可能なカメラを検索",
+ "waitingForData": "データ待機中…",
+ "load": "読込",
+ "refresh": "更新",
+ "available": "利用可能",
+ "menuFile": "ファイル",
+ "menuView": "表示",
+ "menuCamera": "カメラ",
+ "menuRecording": "録画",
+ "menuHelp": "ヘルプ",
+ "menuDetectCameras": "カメラを検出",
+ "menuConnectCameras": "カメラを接続",
+ "menuCloseAllCameras": "すべてのカメラを閉じる",
+ "menuOpenRecordingFolder": "録画フォルダを開く…",
+ "menuToggleSidebar": "サイドバーの切替",
+ "menuToggleTheme": "テーマの切替",
+ "menuToggleFullScreen": "フルスクリーンの切替",
+ "menuPauseUnpause": "一時停止 / 再開",
+ "menuConnectApplySettings": "接続 / 設定を適用",
+ "menuCloseAll": "すべて閉じる",
+ "menuDocumentation": "ドキュメント",
+ "menuGitHubRepository": "GitHubリポジトリ",
+ "menuReportIssue": "問題を報告…",
+ "menuAbout": "SkellyCamについて",
+ "menuPlayback": "再生",
+ "videoPlayback": "再生",
+ "copyLogsToClipboard": "ログをクリップボードにコピー",
+ "saveLogsToFile": "ログをファイルに保存",
+ "copied": "コピーしました!",
+ "timestampFromRecording": "録画データからのタイムスタンプ",
+ "menuCheckForUpdates": "Check for Updates…",
+ "updateAvailable": "Update available",
+ "updateAvailableMessage": "Version {{version}} is available",
+ "downloading": "Downloading…",
+ "downloadComplete": "Download complete",
+ "restartToUpdate": "Restart to update",
+ "checkForUpdates": "Check for Updates",
+ "upToDate": "You are up to date",
+ "updateError": "Update check failed"
+}
diff --git a/freemocap-ui-old/src/i18n/locales/ka-kartuli.json b/freemocap-ui-old/src/i18n/locales/ka-kartuli.json
new file mode 100644
index 00000000..3bdb2210
--- /dev/null
+++ b/freemocap-ui-old/src/i18n/locales/ka-kartuli.json
@@ -0,0 +1,258 @@
+{
+ "_meta": {
+ "locale": "ka",
+ "translationSource": "ai-generated",
+ "lastUpdated": "2026-02-23"
+ },
+ "appName": "SkellyCam",
+ "appNameDecorated": "SkellyCam 💀📸",
+ "welcomeTitle": "კეთილი იყოს თქვენი მობრძანება SkellyCam-ში",
+ "welcomeSubtitle": "ჩაწერეთ და ნახეთ სინქრონიზებული ვიდეოები",
+ "sendAnonymousPings": "ანონიმური გამოყენების პინგების გაგზავნა",
+ "footerWith": "თან",
+ "footerFrom": "-დან",
+ "footerOrgName": "FreeMoCap Foundation",
+ "home": "მთავარი",
+ "cameras": "კამერები",
+ "videos": "ვიდეოები",
+ "expandSidebar": "გვერდითი ზოლის გაშლა",
+ "collapseSidebar": "გვერდითი ზოლის შეკუმშვა",
+ "startRecording": "ჩაწერის დაწყება",
+ "stopRecording": "ჩაწერის შეწყვეტა",
+ "toggleTheme": "თემის შეცვლა",
+ "switchToDark": "მუქ რეჟიმზე გადართვა",
+ "switchToLight": "ნათელ რეჟიმზე გადართვა",
+ "connectWebSocket": "WebSocket-ის დაკავშირება",
+ "disconnectWebSocket": "WebSocket-ის გათიშვა",
+ "launchServer": "სერვერის გაშვება",
+ "stopServer": "სერვერის შეჩერება",
+ "browseForExecutable": "შესრულებადი ფაილის ძიება",
+ "refreshCandidates": "კანდიდატების განახლება",
+ "executable": "შესრულებადი",
+ "host": "ჰოსტი",
+ "port": "პორტი",
+ "cameraCount_one": "{{count}} კამერა",
+ "cameraCount_other": "{{count}} კამერა",
+ "connectedCameras": "დაკავშირებული კამერები",
+ "availableCameras": "ხელმისაწვდომი კამერები",
+ "noCamerasConnected": "კამერა არ არის დაკავშირებული",
+ "detectCameras": "ხელმისაწვდომი კამერების აღმოჩენა",
+ "clearCameraSettings": "შენახული კამერის პარამეტრების მეხსიერებიდან წაშლა",
+ "copySettingsToAll": "პარამეტრების ყველა კამერაზე კოპირება",
+ "recordingTag": "ჩაწერის ტეგი",
+ "recordingTagPlaceholder": "არასავალდებულო ტეგი",
+ "recordingDirectory": "ჩაწერის დირექტორია",
+ "recordingFolderPath": "ჩაწერის საქაღალდის ბილიკი",
+ "delayStart": "დაწყების შეფერხება",
+ "seconds": "წამი",
+ "subfolder": "ქვესაქაღალდე",
+ "subfolderPlaceholder": "ქვესაქაღალდის სახელი",
+ "baseName": "საბაზისო სახელი",
+ "increment": "ზრდა",
+ "resolution": "გარჩევადობა",
+ "fps": "FPS",
+ "width": "სიგანე",
+ "height": "სიმაღლე",
+ "columns": "სვეტები",
+ "auto": "ავტომატური",
+ "manual": "ხელით",
+ "custom": "მორგებული",
+ "current": "მიმდინარე",
+ "recommend": "რეკომენდაცია",
+ "cameraRotation": "კამერის როტაცია",
+ "selectCameraRotation": "კამერის სურათის როტაციის არჩევა",
+ "exposureControl": "აირჩიეთ ავტომატურ ან ხელით ექსპოზიციის კონტროლს შორის",
+ "framerateControl": "აირჩიეთ ავტომატურ ან ხელით კადრთა სიხშირის კონტროლს შორის",
+ "adjustExposure": "ექსპოზიციის დროის რეგულირება, მაგ. cv2.VideoCapture.set(cv2.CAP_PROP_EXPOSURE, value)",
+ "setTargetFps": "კამერის გადაღებისთვის სამიზნე კადრი/წამი (FPS) დაყენება",
+ "recordingCaptureFps": "ჩაწერის გადაღების კადრთა სიხშირე",
+ "playbackSpeed": "აღწარმოების სიჩქარე (არ მოქმედებს ჩაწერის fps-ზე)",
+ "framerateTimeline": "კადრთა სიხშირის ვადები",
+ "framerateDistribution": "კადრთა სიხშირის განაწილება",
+ "timelineView": "ვადების ხედი",
+ "distributionView": "განაწილების ხედი",
+ "combinedView": "კომბინირებული ხედი",
+ "min": "მინ",
+ "max": "მაქს",
+ "mean": "საშუალო",
+ "median": "მედიანა",
+ "stdDevCv": "StdDev/CV",
+ "source": "წყარო",
+ "selectAll": "ყველას არჩევა",
+ "loadSynchronizedVideos": "სინქრონიზებული ვიდეოების ჩატვირთვა",
+ "loadSynchronizedVideosDescription": "ეს გვერდი საშუალებას გაძლევთ ჩატვირთოთ და სინქრონიზება გაუკეთოთ წინასწარ ჩაწერილ ვიდეოებს.",
+ "automaticallySynchronizeVideos": "ვიდეოების ავტომატური სინქრონიზაცია",
+ "extractFramesOnLoad": "კადრების ამოღება ჩატვირთვისას",
+ "generateThumbnails": "მინიატურების შექმნა",
+ "noVideosLoaded": "ვიდეო არ არის ჩატვირთული",
+ "filterVideos": "ვიდეოების ფილტრაცია...",
+ "openVideo": "ვიდეოს გახსნა",
+ "openFolder": "საქაღალდის გახსნა ფაილ მენეჯერში",
+ "videoFolderPath": "ვიდეო საქაღალდის ბილიკი",
+ "jumpToStart": "დასაწყისზე გადასვლა (Home)",
+ "jumpToEnd": "ბოლოზე გადასვლა (End)",
+ "loopOn": "ციკლი ჩართულია (L გადასართავად)",
+ "loopOff": "ციკლური დაკვრა (L)",
+ "syncInfo": "სინქრონიზაციის ინფო",
+ "syncInfoTitle": "მრავალკამერიანი სინქრონიზაცია შეიძლება არ იყოს კადრის დონეზე ზუსტი",
+ "syncInfoBody": "ბრაუზერში ვიდეოს დაკვრა არ უზრუნველყოფს ნიმუშის დონეზე ზუსტ სინქრონიზაციას მრავალ ნაკადზე. პლეერი იყენებს ლიდერ-მიმდევრის სტრატეგიას და ასწორებს გადახრას, როცა ის მცირე ტოლერანტობას აჭარბებს, მაგრამ მცირე დესინქრონიზაცია (1–2 კადრი) შეიძლება მოხდეს, განსაკუთრებით მაღალი დაკვრის სიჩქარით ან როცა ბრაუზერი დატვირთულია. კადრის დონეზე ზუსტი ანალიზისთვის გამოიყენეთ თითოეულ ჩანაწერში შემავალი ნედლი დროის ნიშნულების CSV ფაილები.",
+ "previousFrame": "წინა კადრი (← / Shift+← 10-ისთვის)",
+ "nextFrame": "შემდეგი კადრი (→ / Shift+→ 10-ისთვის)",
+ "zoomIn": "გადიდება",
+ "zoomOut": "შემცირება",
+ "resetZoom": "მასშტაბის აღდგენა",
+ "playbackSettings": "აღწარმოების პარამეტრები",
+ "totalRecordingSize": "ჩაწერის საერთო ზომა დისკზე",
+ "estimatedTime": "სავარაუდო დრო (კადრი ÷ ჩაწერის fps)",
+ "estimatedDuration": "სავარაუდო ხანგრძლივობა (საერთო კადრები ÷ ჩაწერის fps)",
+ "estimatedFromFrameNumber": "კადრის ნომრიდან × ჩაწერის fps სავარაუდო — დროის ბეჭდის მონაცემებიდან არ არის წაკითხული",
+ "frameCountPerCamera": "კადრების რაოდენობა კამერაზე",
+ "cameraStreams": "კამერის ნაკადები ამ ჩაწერაში",
+ "backToRecordings": "ჩაწერებზე დაბრუნება",
+ "errorsDetected": "შეცდომები აღმოჩენილია",
+ "somethingWentWrong": "რაღაც შეცდომა მოხდა :(",
+ "searchLogs": "ჟურნალების ძიება...",
+ "filter": "ფილტრი…",
+ "refreshMicrophoneList": "მიკროფონის სიის განახლება",
+ "date": "თარიღი",
+ "name": "სახელი",
+ "size": "ზომა",
+ "duration": "ხანგრძლივობა",
+ "frames": "კადრები",
+ "timestamp": "დროის ბეჭედი",
+ "language": "ენა",
+ "aiTranslated": "AI-ით თარგმნილი",
+ "humanTranslated": "ადამიანის მიერ თარგმნილი",
+ "humanValidated": "ადამიანის მიერ შემოწმებული",
+ "connectCameras": "არჩეულ კამერებთან დაკავშირება ან დაკავშირებული კამერების განახლება",
+ "resumeStreaming": "სტრიმინგის განახლება",
+ "pauseStreaming": "სტრიმინგის შეჩერება",
+ "closeAllCameras": "ყველა კამერის დახურვა",
+ "framerate": "კადრთა სიხშირე",
+ "exposure": "ექსპოზიცია",
+ "fileLabel": "ფაილი",
+ "timeDelta": "დროის სხვაობა",
+ "pathLabel": "ბილიკი",
+ "exceptionDetails": "გამონაკლისის დეტალები",
+ "stackTrace": "სტეკის კვალი",
+ "loadingVideos": "ვიდეოების ჩატვირთვა… ({{ready}}/{{total}} მზადაა)",
+ "gridColumns": "ბადის სვეტები",
+ "settings": "პარამეტრები",
+ "appearance": "გარეგნობა",
+ "themeMode": "თემა",
+ "darkMode": "მუქი",
+ "lightMode": "ნათელი",
+ "languageSettings": "ენა და ლოკალიზაცია",
+ "showTranslationIndicator": "თარგმანის წყაროს ინდიკატორის ჩვენება",
+ "showTranslationIndicatorDescription": "AI-ით გენერირებული თარგმანების გამოყენებისას ბეჯის ჩვენება",
+ "translationSourceLabel": "თარგმანის წყარო",
+ "general": "ზოგადი",
+ "about": "შესახებ",
+ "version": "ვერსია",
+ "serverSettings": "სერვერი",
+ "recordingSettings": "ჩაწერის პარამეტრები",
+ "videoLoadingSettings": "ვიდეოს ჩატვირთვის პარამეტრები",
+ "connected": "დაკავშირებულია",
+ "connecting": "დაკავშირება…",
+ "disconnected": "გათიშულია",
+ "disconnect": "გათიშვა",
+ "connect": "დაკავშირება",
+ "off": "გამორთული",
+ "running": "მუშაობს",
+ "stopped": "შეჩერებულია",
+ "working": "მუშაობს…",
+ "invalid": "არასწორი",
+ "autoLaunch": "ავტომატური გაშვება",
+ "autoConnect": "ავტომატური დაკავშირება",
+ "runningPath": "მუშაობს: {{path}}",
+ "noMicrophone": "მიკროფონი არ არის",
+ "audioRecordingEnabled": "აუდიო ჩაწერა ჩართულია",
+ "noMicrophoneSelected": "მიკროფონი არ არის არჩეული",
+ "recordingName": "ჩაწერის სახელი: {{name}}",
+ "startingIn": "დაწყება {{countdown}}-ში...",
+ "stopping": "ჩერდება...",
+ "starting": "იწყება...",
+ "stopRecordingButton": "🔴 ჩაწერის შეწყვეტა",
+ "startRecordingButton": "🔴 ჩაწერის დაწყება",
+ "camerasCount": "კამერები ({{count}})",
+ "availableCamerasCount": "ხელმისაწვდომი ({{count}})",
+ "server": "სერვერი",
+ "display": "ეკრანი",
+ "rawMessage": "ნედლი შეტყობინება",
+ "cameraPerformanceMetrics": "კამერის წარმადობის მეტრიკები",
+ "serverLogs": "სერვერის ჟურნალები",
+ "sortBy": "{{direction}} დალაგება",
+ "waitingForCameraStreams": "კამერის ნაკადების მოლოდინში...",
+ "loggingPaused": "ჟურნალი შეჩერებულია",
+ "noLogsToDisplay": "საჩვენებელი ჟურნალი არ არის",
+ "closeSettings": "პარამეტრების დახურვა",
+ "gridSettings": "ბადის პარამეტრები",
+ "clickToShowLess": "ნაკლების საჩვენებლად დააწკაპუნეთ",
+ "clickToLearnMore": "მეტის გასაგებად დააწკაპუნეთ",
+ "samples": "ნიმუშები",
+ "framerateOverTime": "კადრთა სიხშირე დროის მიხედვით",
+ "framerateFps": "კადრთა სიხშირე (fps)",
+ "capturesFramesFromCamera": "კამერიდან კადრებს იღებს.",
+ "rendersReceivedFrames": "მიღებულ კადრებს ეკრანზე აჩვენებს.",
+ "displayTooltipLong": "ეკრანი წარმოადგენს UI-ს რენდერინგის წარმადობას. აჩვენებს რამდენად სწრაფად იღებს და აჩვენებს თქვენი ეკრანი კადრებს. წარმადობის პრობლემები აქ არ იმოქმედებს ჩაწერის ხარისხზე, მაგრამ შეიძლება გავლენა იქონიოს კამერების რეალურ დროში მონიტორინგზე.",
+ "statsSourceShort": "ეკრანი კადრებს აჩვენებს, სერვერი კადრებს იღებს.",
+ "statsSourceLong": "სერვერი არის რეალური სიჩქარე, რომლითაც კადრები მიიღება/იწერება კამერიდან, ხოლო ეკრანი არის სიჩქარე, რომლითაც ისინი მიიღება და ნაჩვენებია. Skellycam პრიორიტეტს ანიჭებს სერვერის მხარის წარმადობას ჩაწერის ხარისხისთვის, ამიტომ ეს რიცხვი უფრო სტაბილური უნდა იყოს. თუ ეკრანის კადრთა სიხშირე სერვერისგან განსხვავდება, ეს მიუთითებს რომ თქვენი სისტემის რესურსები გადატვირთულია. განიხილეთ ნაკლები კამერის გამოყენება ან კადრთა სიხშირის/გარჩევადობის შემცირება.",
+ "statsCurrentShort": "უახლესი კადრის დრო და შესაბამისი FPS.",
+ "statsCurrentLong": "აჩვენებს უახლეს გაზომვას თუ რამდენი დრო სჭირდება ერთი კადრის დამუშავებას (მილიწამებში) და ექვივალენტურ FPS-ს. უფრო დაბალი კადრის დრო და უფრო მაღალი FPS უკეთეს წარმადობას მიუთითებს.",
+ "statsMinShort": "ყველაზე სწრაფი კადრის დრო (ყველაზე დაბალი შეფერხება) და მიღწეული უმაღლესი FPS.",
+ "statsMinLong": "წარმოადგენს ნიმუშის ფანჯრის განმავლობაში ერთი კადრის დამუშავებისთვის საჭირო მინიმალურ დროს. ეს შეესაბამება თქვენი სისტემის მიერ ოპტიმალურ პირობებში მიღწეულ მაქსიმალურ FPS-ს.",
+ "statsMaxShort": "ყველაზე ნელი კადრის დრო (ყველაზე მაღალი შეფერხება) და განცდილი ყველაზე დაბალი FPS.",
+ "statsMaxLong": "წარმოადგენს ნიმუშის ფანჯრის განმავლობაში ერთი კადრის დამუშავებისთვის საჭირო მაქსიმალურ დროს. ეს შეესაბამება თქვენი სისტემის მიერ ყველაზე ცუდ პირობებში მიღწეულ მინიმალურ FPS-ს. ხანდახან ზრდა ნორმალურია, მაგრამ მუდმივად მაღალი მნიშვნელობები შეიძლება წარმადობის პრობლემებზე მიუთითებდეს.",
+ "statsMeanShort": "საშუალო კადრის დრო და FPS ყველა ნიმუშში.",
+ "statsMeanLong": "ნიმუშის ფანჯრის განმავლობაში გაზომილი ყველა კადრის დროის არითმეტიკული საშუალო და შესაბამისი FPS. ეს იძლევა წარმადობის კარგ საერთო სურათს, მაგრამ შეიძლება დამახინჯდეს ამოვარდნილი მნიშვნელობებით.",
+ "statsMedianShort": "ყველა კადრის დროის საშუალო მნიშვნელობა (50-ე პერცენტილი).",
+ "statsMedianLong": "მედიანა წარმოადგენს შუა მნიშვნელობას, როცა ყველა კადრის დრო დალაგებულია ყველაზე სწრაფიდან ყველაზე ნელამდე. საშუალოსგან განსხვავებით, მედიანაზე არ მოქმედებს ექსტრემალური ამოვარდნილი მნიშვნელობები, რაც მას ტიპიური წარმადობის უფრო სტაბილურ ინდიკატორად აქცევს.",
+ "statsStdDevShort": "ზომავს კადრის დროის ცვალებადობას. CV% არის ფარდობითი ცვალებადობა.",
+ "statsStdDevLong": "სტანდარტული გადახრა ზომავს კადრის დროებში ვარიაციის ოდენობას. უფრო დაბალი მნიშვნელობები უფრო თანმიმდევრულ წარმადობას მიუთითებს. ვარიაციის კოეფიციენტი (CV%) ამ ცვალებადობას საშუალოს პროცენტულად გამოხატავს, რაც ადვილებს სტაბილურობის შედარებას სხვადასხვა კადრთა სიხშირეებს შორის. უფრო დაბალი CV% უფრო სტაბილურ წარმადობას მიუთითებს.",
+ "aiTranslatedTooltip": "ეს თარგმანი AI-ით არის გენერირებული და შეიძლება შეცდომები შეიცავდეს. თუ ამ ენაზე ლაპარაკობთ, შეგიძლიათ დაეხმაროთ გაუმჯობესებაში GitHub-ზე pull request-ის გახსნით!",
+ "humanValidatedTooltip": "ეს თარგმანი ადამიანი მთარგმნელის მიერ არის განხილული და შემოწმებული.",
+ "helpTranslate": "დაეხმარეთ SkellyCam-ის თარგმნას",
+ "failedToFetch": "მიღება ვერ მოხერხდა",
+ "recordings": "ჩაწერები",
+ "noRecordingsFound": "ჩაწერები ვერ მოიძებნა. ხელით ჩასატვირთად ზემოთ შეიყვანეთ ბილიკი.",
+ "noCamerasDetected": "კამერები ვერ მოიძებნა",
+ "clickRefreshToScan": "ხელმისაწვდომი კამერების სკანირებისთვის დააწკაპუნეთ განახლება",
+ "waitingForData": "მონაცემების მოლოდინში…",
+ "load": "ჩატვირთვა",
+ "refresh": "განახლება",
+ "available": "ხელმისაწვდომი",
+ "menuFile": "ფაილი",
+ "menuView": "ხედი",
+ "menuCamera": "კამერა",
+ "menuRecording": "ჩაწერა",
+ "menuHelp": "დახმარება",
+ "menuDetectCameras": "კამერების აღმოჩენა",
+ "menuConnectCameras": "კამერების დაკავშირება",
+ "menuCloseAllCameras": "ყველა კამერის დახურვა",
+ "menuOpenRecordingFolder": "ჩაწერის საქაღალდის გახსნა…",
+ "menuToggleSidebar": "გვერდითი პანელის გადართვა",
+ "menuToggleTheme": "თემის გადართვა",
+ "menuToggleFullScreen": "სრული ეკრანი",
+ "menuPauseUnpause": "პაუზა / გაგრძელება",
+ "menuConnectApplySettings": "დაკავშირება / პარამეტრების გამოყენება",
+ "menuCloseAll": "ყველაფრის დახურვა",
+ "menuDocumentation": "დოკუმენტაცია",
+ "menuGitHubRepository": "GitHub რეპოზიტორია",
+ "menuReportIssue": "პრობლემის შეტყობინება…",
+ "menuAbout": "SkellyCam-ის შესახებ",
+ "menuPlayback": "დაკვრა",
+ "videoPlayback": "დაკვრა",
+ "copyLogsToClipboard": "ჟურნალის კოპირება ბუფერში",
+ "saveLogsToFile": "ჟურნალის შენახვა ფაილში",
+ "copied": "კოპირებულია!",
+ "timestampFromRecording": "დროის ნიშნული ჩანაწერის მონაცემებიდან",
+ "menuCheckForUpdates": "Check for Updates…",
+ "updateAvailable": "Update available",
+ "updateAvailableMessage": "Version {{version}} is available",
+ "downloading": "Downloading…",
+ "downloadComplete": "Download complete",
+ "restartToUpdate": "Restart to update",
+ "checkForUpdates": "Check for Updates",
+ "upToDate": "You are up to date",
+ "updateError": "Update check failed"
+}
diff --git a/freemocap-ui-old/src/i18n/locales/ko-hangugeo.json b/freemocap-ui-old/src/i18n/locales/ko-hangugeo.json
new file mode 100644
index 00000000..9f66a428
--- /dev/null
+++ b/freemocap-ui-old/src/i18n/locales/ko-hangugeo.json
@@ -0,0 +1,258 @@
+{
+ "_meta": {
+ "locale": "ko",
+ "translationSource": "ai-generated",
+ "lastUpdated": "2026-02-23"
+ },
+ "appName": "SkellyCam",
+ "appNameDecorated": "SkellyCam 💀📸",
+ "welcomeTitle": "SkellyCam에 오신 것을 환영합니다",
+ "welcomeSubtitle": "동기화된 비디오 녹화 및 보기",
+ "sendAnonymousPings": "익명 사용 데이터 보내기",
+ "footerWith": "와",
+ "footerFrom": "에서",
+ "footerOrgName": "FreeMoCap Foundation",
+ "home": "홈",
+ "cameras": "카메라",
+ "videos": "비디오",
+ "expandSidebar": "사이드바 펼치기",
+ "collapseSidebar": "사이드바 접기",
+ "startRecording": "녹화 시작",
+ "stopRecording": "녹화 중지",
+ "toggleTheme": "테마 전환",
+ "switchToDark": "다크 모드로 전환",
+ "switchToLight": "라이트 모드로 전환",
+ "connectWebSocket": "WebSocket 연결",
+ "disconnectWebSocket": "WebSocket 연결 해제",
+ "launchServer": "서버 시작",
+ "stopServer": "서버 중지",
+ "browseForExecutable": "실행 파일 찾기",
+ "refreshCandidates": "후보 새로고침",
+ "executable": "실행 파일",
+ "host": "호스트",
+ "port": "포트",
+ "cameraCount_one": "카메라 {{count}}대",
+ "cameraCount_other": "카메라 {{count}}대",
+ "connectedCameras": "연결된 카메라",
+ "availableCameras": "사용 가능한 카메라",
+ "noCamerasConnected": "연결된 카메라 없음",
+ "detectCameras": "사용 가능한 카메라 감지",
+ "clearCameraSettings": "카메라 설정 초기화",
+ "copySettingsToAll": "모든 카메라에 설정 복사",
+ "recordingTag": "녹화 태그",
+ "recordingTagPlaceholder": "선택적 태그",
+ "recordingDirectory": "녹화 디렉토리",
+ "recordingFolderPath": "녹화 폴더 경로",
+ "delayStart": "지연 시작",
+ "seconds": "초",
+ "subfolder": "하위 폴더",
+ "subfolderPlaceholder": "하위 폴더 이름",
+ "baseName": "기본 이름",
+ "increment": "증분",
+ "resolution": "해상도",
+ "fps": "FPS",
+ "width": "너비",
+ "height": "높이",
+ "columns": "열",
+ "auto": "자동",
+ "manual": "수동",
+ "custom": "사용자 지정",
+ "current": "현재",
+ "recommend": "추천",
+ "cameraRotation": "카메라 회전",
+ "selectCameraRotation": "카메라 이미지 회전 선택",
+ "exposureControl": "자동 또는 수동 노출 제어",
+ "framerateControl": "자동 또는 수동 프레임레이트 제어",
+ "adjustExposure": "노출 시간 조정",
+ "setTargetFps": "캡처 대상 FPS 설정",
+ "recordingCaptureFps": "녹화 캡처 FPS",
+ "playbackSpeed": "재생 속도",
+ "framerateTimeline": "프레임레이트 타임라인",
+ "framerateDistribution": "프레임레이트 분포",
+ "timelineView": "타임라인 보기",
+ "distributionView": "분포 보기",
+ "combinedView": "결합 보기",
+ "min": "최소",
+ "max": "최대",
+ "mean": "평균",
+ "median": "중앙값",
+ "stdDevCv": "표준편차/CV",
+ "source": "소스",
+ "selectAll": "모두 선택",
+ "loadSynchronizedVideos": "동기화된 비디오 로드",
+ "loadSynchronizedVideosDescription": "이 페이지에서 사전 녹화된 비디오를 로드하고 동기화할 수 있습니다.",
+ "automaticallySynchronizeVideos": "비디오 자동 동기화",
+ "extractFramesOnLoad": "로드 시 프레임 추출",
+ "generateThumbnails": "썸네일 생성",
+ "noVideosLoaded": "로드된 비디오 없음",
+ "filterVideos": "비디오 필터...",
+ "openVideo": "비디오 열기",
+ "openFolder": "탐색기에서 폴더 열기",
+ "videoFolderPath": "비디오 폴더 경로",
+ "jumpToStart": "처음으로 (Home)",
+ "jumpToEnd": "끝으로 (End)",
+ "loopOn": "반복 켜짐 (L로 전환)",
+ "loopOff": "반복 재생 (L)",
+ "syncInfo": "동기화 정보",
+ "syncInfoTitle": "다중 카메라 동기화가 프레임 단위로 완벽하지 않을 수 있습니다",
+ "syncInfoBody": "브라우저 비디오 재생은 여러 스트림 간 샘플 정확도의 동기화를 보장하지 않습니다. 플레이어는 리더-팔로워 전략을 사용하고 드리프트가 작은 허용 범위를 초과하면 보정하지만, 특히 높은 재생 속도나 브라우저에 부하가 있을 때 미세한 비동기화(1~2프레임)가 발생할 수 있습니다. 프레임 정확도의 분석을 위해서는 각 녹화에 포함된 원시 타임스탬프 CSV 파일을 사용하세요.",
+ "previousFrame": "이전 프레임 (← / Shift+← 10개)",
+ "nextFrame": "다음 프레임 (→ / Shift+→ 10개)",
+ "zoomIn": "확대",
+ "zoomOut": "축소",
+ "resetZoom": "줌 초기화",
+ "playbackSettings": "재생 설정",
+ "totalRecordingSize": "디스크의 총 녹화 크기",
+ "estimatedTime": "예상 시간 (프레임 ÷ fps)",
+ "estimatedDuration": "예상 재생 시간 (총 프레임 ÷ fps)",
+ "estimatedFromFrameNumber": "프레임 번호 × fps에서 추정",
+ "frameCountPerCamera": "카메라별 프레임 수",
+ "cameraStreams": "이 녹화의 카메라 스트림",
+ "backToRecordings": "녹화 목록으로",
+ "errorsDetected": "오류 감지됨",
+ "somethingWentWrong": "문제가 발생했습니다 :(",
+ "searchLogs": "로그 검색...",
+ "filter": "필터…",
+ "refreshMicrophoneList": "마이크 목록 새로고침",
+ "date": "날짜",
+ "name": "이름",
+ "size": "크기",
+ "duration": "재생 시간",
+ "frames": "프레임",
+ "timestamp": "타임스탬프",
+ "language": "언어",
+ "aiTranslated": "AI 번역",
+ "humanTranslated": "사람 번역",
+ "humanValidated": "사람이 검증",
+ "connectCameras": "선택한 카메라에 연결",
+ "resumeStreaming": "스트리밍 재개",
+ "pauseStreaming": "스트리밍 일시 중지",
+ "closeAllCameras": "모든 카메라 닫기",
+ "framerate": "프레임레이트",
+ "exposure": "노출",
+ "fileLabel": "파일",
+ "timeDelta": "시간 차이",
+ "pathLabel": "경로",
+ "exceptionDetails": "예외 세부사항",
+ "stackTrace": "스택 트레이스",
+ "loadingVideos": "비디오 로딩 중… ({{ready}}/{{total}} 준비됨)",
+ "gridColumns": "그리드 열",
+ "settings": "설정",
+ "appearance": "모양",
+ "themeMode": "테마",
+ "darkMode": "다크",
+ "lightMode": "라이트",
+ "languageSettings": "언어 및 현지화",
+ "showTranslationIndicator": "번역 출처 표시기 표시",
+ "showTranslationIndicatorDescription": "AI 번역 사용 시 배지 표시",
+ "translationSourceLabel": "번역 출처",
+ "general": "일반",
+ "about": "정보",
+ "version": "버전",
+ "serverSettings": "서버",
+ "recordingSettings": "녹화 설정",
+ "videoLoadingSettings": "비디오 로딩 설정",
+ "connected": "연결됨",
+ "connecting": "연결 중…",
+ "disconnected": "연결 해제됨",
+ "disconnect": "연결 해제",
+ "connect": "연결",
+ "off": "꺼짐",
+ "running": "실행 중",
+ "stopped": "중지됨",
+ "working": "처리 중…",
+ "invalid": "유효하지 않음",
+ "autoLaunch": "자동 시작",
+ "autoConnect": "자동 연결",
+ "runningPath": "실행 중: {{path}}",
+ "noMicrophone": "마이크 없음",
+ "audioRecordingEnabled": "오디오 녹음 활성화",
+ "noMicrophoneSelected": "마이크 선택 안 됨",
+ "recordingName": "녹화 이름: {{name}}",
+ "startingIn": "{{countdown}}초 후 시작...",
+ "stopping": "중지 중...",
+ "starting": "시작 중...",
+ "stopRecordingButton": "🔴 녹화 중지",
+ "startRecordingButton": "🔴 녹화 시작",
+ "camerasCount": "카메라 ({{count}})",
+ "availableCamerasCount": "사용 가능 ({{count}})",
+ "server": "서버",
+ "display": "디스플레이",
+ "rawMessage": "원시 메시지",
+ "cameraPerformanceMetrics": "카메라 성능 지표",
+ "serverLogs": "서버 로그",
+ "sortBy": "정렬 {{direction}}",
+ "waitingForCameraStreams": "카메라 스트림 대기 중...",
+ "loggingPaused": "로깅 일시 중지",
+ "noLogsToDisplay": "표시할 로그 없음",
+ "closeSettings": "설정 닫기",
+ "gridSettings": "그리드 설정",
+ "clickToShowLess": "접으려면 클릭",
+ "clickToLearnMore": "자세히 보려면 클릭",
+ "samples": "샘플",
+ "framerateOverTime": "시간별 프레임레이트",
+ "framerateFps": "프레임레이트 (fps)",
+ "capturesFramesFromCamera": "카메라에서 프레임 캡처.",
+ "rendersReceivedFrames": "받은 프레임을 화면에 렌더링.",
+ "displayTooltipLong": "디스플레이는 UI 렌더링 성능을 나타냅니다. 디스플레이가 프레임을 수신하고 렌더링하는 속도를 보여줍니다. 여기서의 성능 문제는 녹화 품질에 영향을 미치지 않지만 실시간으로 카메라를 모니터링하는 능력에 영향을 줄 수 있습니다.",
+ "statsSourceShort": "디스플레이는 프레임을 렌더링, 서버는 프레임을 캡처.",
+ "statsSourceLong": "서버는 카메라에서 프레임을 가져오거나 녹화하는 실제 속도이며, 디스플레이는 프레임을 수신하고 렌더링하는 속도입니다. SkellyCam은 녹화 품질을 위해 서버 측 성능을 우선시하므로 해당 수치가 더 안정적이어야 합니다. 디스플레이 프레임레이트가 서버와 다르면 시스템 리소스가 부족함을 나타냅니다. 카메라 수를 줄이거나 프레임레이트/해상도를 낮추는 것을 고려하세요.",
+ "statsCurrentShort": "최근 프레임 시간 및 FPS.",
+ "statsCurrentLong": "단일 프레임을 처리하는 데 걸리는 시간(밀리초)과 이에 해당하는 초당 프레임 수(FPS)의 최신 측정값을 보여줍니다. 낮은 프레임 시간과 높은 FPS는 더 나은 성능을 나타냅니다.",
+ "statsMinShort": "가장 빠른 프레임 시간 및 최고 FPS.",
+ "statsMinLong": "샘플링 윈도우 동안 단일 프레임을 처리하는 데 걸린 최소 시간을 나타냅니다. 최적 조건에서 시스템이 달성한 최대 FPS에 해당합니다.",
+ "statsMaxShort": "가장 느린 프레임 시간 및 최저 FPS.",
+ "statsMaxLong": "샘플링 윈도우 동안 단일 프레임을 처리하는 데 걸린 최대 시간을 나타냅니다. 최악의 조건에서의 최소 FPS에 해당합니다. 가끔 발생하는 스파이크는 정상이지만, 지속적으로 높은 값은 성능 문제를 나타낼 수 있습니다.",
+ "statsMeanShort": "모든 샘플의 평균 프레임 시간 및 FPS.",
+ "statsMeanLong": "샘플링 윈도우 동안 측정된 모든 프레임 시간의 산술 평균과 해당 FPS입니다. 성능의 전반적인 그림을 잘 보여주지만 이상값에 의해 왜곡될 수 있습니다.",
+ "statsMedianShort": "모든 프레임 시간의 중앙값 (50번째 백분위).",
+ "statsMedianLong": "중앙값은 모든 프레임 시간을 가장 빠른 것부터 가장 느린 것까지 정렬했을 때의 중간 값을 나타냅니다. 평균과 달리 중앙값은 극단적인 이상값의 영향을 받지 않아 일반적인 성능의 더 안정적인 지표가 됩니다.",
+ "statsStdDevShort": "프레임 시간 변동성 측정. CV%는 상대적 변동.",
+ "statsStdDevLong": "표준편차는 프레임 시간의 변동량을 측정합니다. 낮은 값은 더 일관된 성능을 나타냅니다. 변동계수(CV%)는 이 변동성을 평균의 백분율로 표현하여 서로 다른 프레임레이트 간의 안정성 비교를 용이하게 합니다. 낮은 CV%는 더 안정적인 성능을 나타냅니다.",
+ "aiTranslatedTooltip": "이 번역은 AI가 생성했으며 오류가 있을 수 있습니다. 이 언어를 구사하신다면 개선에 도움을 주세요!",
+ "humanValidatedTooltip": "이 번역은 사람 번역가가 검토했습니다.",
+ "helpTranslate": "SkellyCam 번역 도움",
+ "failedToFetch": "가져오기 실패",
+ "recordings": "녹화",
+ "noRecordingsFound": "녹화를 찾을 수 없습니다. 위에 경로를 입력하여 수동으로 로드하세요.",
+ "noCamerasDetected": "카메라가 감지되지 않았습니다",
+ "clickRefreshToScan": "새로고침을 클릭하여 사용 가능한 카메라 검색",
+ "waitingForData": "데이터 대기 중…",
+ "load": "로드",
+ "refresh": "새로고침",
+ "available": "사용 가능",
+ "menuFile": "파일",
+ "menuView": "보기",
+ "menuCamera": "카메라",
+ "menuRecording": "녹화",
+ "menuHelp": "도움말",
+ "menuDetectCameras": "카메라 감지",
+ "menuConnectCameras": "카메라 연결",
+ "menuCloseAllCameras": "모든 카메라 닫기",
+ "menuOpenRecordingFolder": "녹화 폴더 열기…",
+ "menuToggleSidebar": "사이드바 전환",
+ "menuToggleTheme": "테마 전환",
+ "menuToggleFullScreen": "전체 화면 전환",
+ "menuPauseUnpause": "일시정지 / 재개",
+ "menuConnectApplySettings": "연결 / 설정 적용",
+ "menuCloseAll": "모두 닫기",
+ "menuDocumentation": "문서",
+ "menuGitHubRepository": "GitHub 저장소",
+ "menuReportIssue": "문제 신고…",
+ "menuAbout": "SkellyCam 정보",
+ "menuPlayback": "재생",
+ "videoPlayback": "재생",
+ "copyLogsToClipboard": "로그를 클립보드에 복사",
+ "saveLogsToFile": "로그를 파일로 저장",
+ "copied": "복사됨!",
+ "timestampFromRecording": "녹화 데이터의 타임스탬프",
+ "menuCheckForUpdates": "Check for Updates…",
+ "updateAvailable": "Update available",
+ "updateAvailableMessage": "Version {{version}} is available",
+ "downloading": "Downloading…",
+ "downloadComplete": "Download complete",
+ "restartToUpdate": "Restart to update",
+ "checkForUpdates": "Check for Updates",
+ "upToDate": "You are up to date",
+ "updateError": "Update check failed"
+}
diff --git a/freemocap-ui-old/src/i18n/locales/ms-melayu.json b/freemocap-ui-old/src/i18n/locales/ms-melayu.json
new file mode 100644
index 00000000..7c505d5a
--- /dev/null
+++ b/freemocap-ui-old/src/i18n/locales/ms-melayu.json
@@ -0,0 +1,258 @@
+{
+ "_meta": {
+ "locale": "ms",
+ "translationSource": "ai-generated",
+ "lastUpdated": "2026-02-23"
+ },
+ "appName": "SkellyCam",
+ "appNameDecorated": "SkellyCam 💀📸",
+ "welcomeTitle": "Selamat Datang ke SkellyCam",
+ "welcomeSubtitle": "Rakam dan Tonton Video Tersegerak",
+ "sendAnonymousPings": "Hantar ping penggunaan tanpa nama",
+ "footerWith": "dgn",
+ "footerFrom": "dari",
+ "footerOrgName": "FreeMoCap Foundation",
+ "home": "Laman Utama",
+ "cameras": "Kamera",
+ "videos": "Video",
+ "expandSidebar": "Kembangkan bar sisi",
+ "collapseSidebar": "Kuncupkan bar sisi",
+ "startRecording": "Mula Rakaman",
+ "stopRecording": "Henti Rakaman",
+ "toggleTheme": "tukar tema",
+ "switchToDark": "Tukar ke mod gelap",
+ "switchToLight": "Tukar ke mod cerah",
+ "connectWebSocket": "Sambung WebSocket",
+ "disconnectWebSocket": "Putuskan WebSocket",
+ "launchServer": "Lancarkan Pelayan",
+ "stopServer": "Hentikan Pelayan",
+ "browseForExecutable": "Cari fail boleh laksana",
+ "refreshCandidates": "Muat semula calon",
+ "executable": "Boleh laksana",
+ "host": "Hos",
+ "port": "Port",
+ "cameraCount_one": "{{count}} kamera",
+ "cameraCount_other": "{{count}} kamera",
+ "connectedCameras": "Kamera Tersambung",
+ "availableCameras": "Kamera Tersedia",
+ "noCamerasConnected": "Tiada kamera tersambung",
+ "detectCameras": "Kesan kamera tersedia",
+ "clearCameraSettings": "Kosongkan tetapan kamera yang disimpan dari memori",
+ "copySettingsToAll": "Salin tetapan ke semua kamera",
+ "recordingTag": "Tag Rakaman",
+ "recordingTagPlaceholder": "Tag pilihan",
+ "recordingDirectory": "Direktori Rakaman",
+ "recordingFolderPath": "Laluan folder rakaman",
+ "delayStart": "Tangguh Mula",
+ "seconds": "Saat",
+ "subfolder": "Subfolder",
+ "subfolderPlaceholder": "Nama Subfolder",
+ "baseName": "Nama Asas",
+ "increment": "Kenaikan",
+ "resolution": "Resolusi",
+ "fps": "FPS",
+ "width": "Lebar",
+ "height": "Tinggi",
+ "columns": "Lajur",
+ "auto": "Auto",
+ "manual": "Manual",
+ "custom": "Tersuai",
+ "current": "Semasa",
+ "recommend": "Cadangkan",
+ "cameraRotation": "putaran kamera",
+ "selectCameraRotation": "Pilih putaran imej kamera",
+ "exposureControl": "Pilih antara kawalan pendedahan automatik atau manual",
+ "framerateControl": "Pilih antara kawalan kadar bingkai automatik atau manual",
+ "adjustExposure": "Laraskan masa pendedahan, cth. cv2.VideoCapture.set(cv2.CAP_PROP_EXPOSURE, value)",
+ "setTargetFps": "Tetapkan bingkai sesaat sasaran (FPS) untuk tangkapan kamera",
+ "recordingCaptureFps": "Kadar bingkai tangkapan rakaman",
+ "playbackSpeed": "Kelajuan main balik (tidak menjejaskan fps rakaman)",
+ "framerateTimeline": "Garis Masa Kadar Bingkai",
+ "framerateDistribution": "Taburan Kadar Bingkai",
+ "timelineView": "Paparan Garis Masa",
+ "distributionView": "Paparan Taburan",
+ "combinedView": "Paparan Gabungan",
+ "min": "Min",
+ "max": "Maks",
+ "mean": "Min Purata",
+ "median": "Median",
+ "stdDevCv": "StdDev/CV",
+ "source": "Sumber",
+ "selectAll": "Pilih Semua",
+ "loadSynchronizedVideos": "Muat Video Tersegerak",
+ "loadSynchronizedVideosDescription": "Halaman ini membolehkan anda memuat dan menyegerakkan video prarakaman.",
+ "automaticallySynchronizeVideos": "Segerakkan video secara automatik",
+ "extractFramesOnLoad": "Ekstrak bingkai semasa memuat",
+ "generateThumbnails": "Jana lakaran kecil",
+ "noVideosLoaded": "Tiada video dimuat",
+ "filterVideos": "Tapis video...",
+ "openVideo": "Buka video",
+ "openFolder": "Buka folder dalam penjelajah fail",
+ "videoFolderPath": "Laluan Folder Video",
+ "jumpToStart": "Lompat ke permulaan (Home)",
+ "jumpToEnd": "Lompat ke penghujung (End)",
+ "loopOn": "Gelung dihidupkan (L untuk togol)",
+ "loopOff": "Main balik bergelung (L)",
+ "syncInfo": "Info penyegerakan",
+ "syncInfoTitle": "Penyegerakan berbilang kamera mungkin tidak sempurna pada tahap bingkai",
+ "syncInfoBody": "Main balik video pelayar tidak menjamin penyegerakan tepat sampel merentas berbilang aliran. Pemain menggunakan strategi pemimpin-pengikut dan membetulkan hanyutan apabila melebihi toleransi kecil, tetapi penyahsegerakan kecil (1–2 bingkai) boleh berlaku, terutamanya pada kelajuan main balik tinggi atau apabila pelayar di bawah beban. Untuk analisis tepat bingkai, gunakan fail CSV cap masa mentah yang disertakan dalam setiap rakaman.",
+ "previousFrame": "Bingkai sebelumnya (← / Shift+← untuk 10)",
+ "nextFrame": "Bingkai seterusnya (→ / Shift+→ untuk 10)",
+ "zoomIn": "Zum Masuk",
+ "zoomOut": "Zum Keluar",
+ "resetZoom": "Set Semula Zum",
+ "playbackSettings": "Tetapan main balik",
+ "totalRecordingSize": "Jumlah saiz rakaman pada cakera",
+ "estimatedTime": "Masa dianggarkan (bingkai ÷ fps rakaman)",
+ "estimatedDuration": "Tempoh dianggarkan (jumlah bingkai ÷ fps rakaman)",
+ "estimatedFromFrameNumber": "Dianggarkan dari nombor bingkai × fps rakaman — bukan dibaca dari data cap masa",
+ "frameCountPerCamera": "Bilangan bingkai setiap kamera",
+ "cameraStreams": "Strim kamera dalam rakaman ini",
+ "backToRecordings": "Kembali ke rakaman",
+ "errorsDetected": "Ralat dikesan",
+ "somethingWentWrong": "Sesuatu tidak kena :(",
+ "searchLogs": "Cari log...",
+ "filter": "Tapis…",
+ "refreshMicrophoneList": "Muat semula senarai mikrofon",
+ "date": "Tarikh",
+ "name": "Nama",
+ "size": "Saiz",
+ "duration": "Tempoh",
+ "frames": "Bingkai",
+ "timestamp": "Cap masa",
+ "language": "Bahasa",
+ "aiTranslated": "Diterjemah oleh AI",
+ "humanTranslated": "Diterjemah oleh manusia",
+ "humanValidated": "Disahkan oleh manusia",
+ "connectCameras": "Sambung ke kamera terpilih atau kemas kini kamera tersambung",
+ "resumeStreaming": "Sambung semula penstriman",
+ "pauseStreaming": "Jeda penstriman",
+ "closeAllCameras": "Tutup semua kamera",
+ "framerate": "Kadar bingkai",
+ "exposure": "Pendedahan",
+ "fileLabel": "Fail",
+ "timeDelta": "Delta masa",
+ "pathLabel": "Laluan",
+ "exceptionDetails": "Butiran pengecualian",
+ "stackTrace": "Jejak Tindanan",
+ "loadingVideos": "Memuat video… ({{ready}}/{{total}} sedia)",
+ "gridColumns": "Lajur Grid",
+ "settings": "Tetapan",
+ "appearance": "Penampilan",
+ "themeMode": "Tema",
+ "darkMode": "Gelap",
+ "lightMode": "Cerah",
+ "languageSettings": "Bahasa & Penyetempatan",
+ "showTranslationIndicator": "Tunjukkan penunjuk sumber terjemahan",
+ "showTranslationIndicatorDescription": "Paparkan lencana apabila menggunakan terjemahan jana AI",
+ "translationSourceLabel": "Sumber terjemahan",
+ "general": "Umum",
+ "about": "Perihal",
+ "version": "Versi",
+ "serverSettings": "Pelayan",
+ "recordingSettings": "Tetapan Rakaman",
+ "videoLoadingSettings": "Tetapan Pemuatan Video",
+ "connected": "Tersambung",
+ "connecting": "Menyambung…",
+ "disconnected": "Terputus",
+ "disconnect": "Putuskan",
+ "connect": "Sambung",
+ "off": "Mati",
+ "running": "Berjalan",
+ "stopped": "Berhenti",
+ "working": "Sedang bekerja…",
+ "invalid": "Tidak sah",
+ "autoLaunch": "Lancar automatik",
+ "autoConnect": "Sambung automatik",
+ "runningPath": "Berjalan: {{path}}",
+ "noMicrophone": "Tiada mikrofon",
+ "audioRecordingEnabled": "Rakaman audio diaktifkan",
+ "noMicrophoneSelected": "Tiada mikrofon dipilih",
+ "recordingName": "Nama Rakaman: {{name}}",
+ "startingIn": "Bermula dalam {{countdown}}...",
+ "stopping": "Menghentikan...",
+ "starting": "Memulakan...",
+ "stopRecordingButton": "🔴 Henti Rakaman",
+ "startRecordingButton": "🔴 Mula Rakaman",
+ "camerasCount": "Kamera ({{count}})",
+ "availableCamerasCount": "Tersedia ({{count}})",
+ "server": "Pelayan",
+ "display": "Paparan",
+ "rawMessage": "Mesej mentah",
+ "cameraPerformanceMetrics": "Metrik Prestasi Kamera",
+ "serverLogs": "Log Pelayan",
+ "sortBy": "Isih {{direction}}",
+ "waitingForCameraStreams": "Menunggu strim kamera...",
+ "loggingPaused": "Pengelogan dijeda",
+ "noLogsToDisplay": "Tiada log untuk dipaparkan",
+ "closeSettings": "Tutup tetapan",
+ "gridSettings": "Tetapan grid",
+ "clickToShowLess": "Klik untuk tunjuk kurang",
+ "clickToLearnMore": "Klik untuk ketahui lebih lanjut",
+ "samples": "sampel",
+ "framerateOverTime": "Kadar Bingkai Mengikut Masa",
+ "framerateFps": "Kadar bingkai (fps)",
+ "capturesFramesFromCamera": "Menangkap bingkai dari kamera.",
+ "rendersReceivedFrames": "Merender bingkai diterima pada skrin.",
+ "displayTooltipLong": "Paparan mewakili prestasi rendering UI. Ia menunjukkan seberapa pantas paparan anda menerima dan merender bingkai. Isu prestasi di sini tidak akan menjejaskan kualiti rakaman tetapi mungkin menjejaskan keupayaan anda memantau kamera secara masa nyata.",
+ "statsSourceShort": "Paparan merender bingkai, Pelayan menangkap bingkai.",
+ "statsSourceLong": "Pelayan adalah kadar sebenar bingkai ditarik/dirakam dari kamera, manakala paparan adalah kadar ia diterima dan dirender. Skellycam mengutamakan prestasi sisi pelayan untuk kualiti rakaman, jadi nombor itu sepatutnya kekal lebih stabil. Jika kadar bingkai paparan menyimpang dari pelayan, ia menunjukkan sumber sistem anda terbeban. Pertimbangkan menggunakan kurang kamera atau menurunkan kadar bingkai/resolusi.",
+ "statsCurrentShort": "Masa bingkai terbaru dan FPS sepadan.",
+ "statsCurrentLong": "Ini menunjukkan ukuran terbaru berapa lama untuk memproses satu bingkai (dalam milisaat) dan bingkai sesaat (FPS) setara. Masa bingkai lebih rendah dan FPS lebih tinggi menunjukkan prestasi lebih baik.",
+ "statsMinShort": "Masa bingkai terpantas (latensi terendah) dan FPS tertinggi dicapai.",
+ "statsMinLong": "Ini mewakili masa minimum untuk memproses satu bingkai semasa tetingkap pensampelan. Ini sepadan dengan FPS maksimum sistem anda dicapai dalam keadaan optimum.",
+ "statsMaxShort": "Masa bingkai terperlahan (latensi tertinggi) dan FPS terendah dialami.",
+ "statsMaxLong": "Ini mewakili masa maksimum untuk memproses satu bingkai semasa tetingkap pensampelan. Ini sepadan dengan FPS minimum sistem anda dicapai dalam keadaan terburuk. Lonjakan sekali-sekala adalah normal, tetapi nilai tinggi secara konsisten mungkin menunjukkan isu prestasi.",
+ "statsMeanShort": "Purata masa bingkai dan FPS merentasi semua sampel.",
+ "statsMeanLong": "Min aritmetik (purata) semua masa bingkai diukur semasa tetingkap pensampelan dan FPS sepadan. Ini memberikan gambaran keseluruhan prestasi yang baik tetapi mungkin terpesong oleh nilai luar.",
+ "statsMedianShort": "Nilai tengah semua masa bingkai (persentil ke-50).",
+ "statsMedianLong": "Median mewakili nilai tengah apabila semua masa bingkai diisih dari terpantas ke terperlahan. Tidak seperti min, median tidak dipengaruhi oleh nilai luar yang melampau, menjadikannya penunjuk prestasi tipikal yang lebih stabil.",
+ "statsStdDevShort": "Mengukur kebolehubahan masa bingkai. CV% adalah kebolehubahan relatif.",
+ "statsStdDevLong": "Sisihan piawai mengukur jumlah variasi dalam masa bingkai. Nilai lebih rendah menunjukkan prestasi lebih konsisten. Pekali Variasi (CV%) menyatakan kebolehubahan ini sebagai peratusan min, memudahkan perbandingan kestabilan merentasi kadar bingkai berbeza. CV% lebih rendah menunjukkan prestasi lebih stabil.",
+ "aiTranslatedTooltip": "Terjemahan ini dijana oleh AI dan mungkin mengandungi ralat. Jika anda bertutur bahasa ini, anda boleh membantu memperbaikinya dengan membuka pull request di GitHub!",
+ "humanValidatedTooltip": "Terjemahan ini telah disemak dan disahkan oleh penterjemah manusia.",
+ "helpTranslate": "Bantu terjemah SkellyCam",
+ "failedToFetch": "Gagal mendapatkan",
+ "recordings": "Rakaman",
+ "noRecordingsFound": "Tiada rakaman ditemui. Masukkan laluan di atas untuk memuat secara manual.",
+ "noCamerasDetected": "Tiada kamera dikesan",
+ "clickRefreshToScan": "Klik muat semula untuk mengimbas kamera tersedia",
+ "waitingForData": "Menunggu data…",
+ "load": "Muat",
+ "refresh": "Muat Semula",
+ "available": "Tersedia",
+ "menuFile": "Fail",
+ "menuView": "Paparan",
+ "menuCamera": "Kamera",
+ "menuRecording": "Rakaman",
+ "menuHelp": "Bantuan",
+ "menuDetectCameras": "Kesan kamera",
+ "menuConnectCameras": "Sambung kamera",
+ "menuCloseAllCameras": "Tutup semua kamera",
+ "menuOpenRecordingFolder": "Buka folder rakaman…",
+ "menuToggleSidebar": "Togol bar sisi",
+ "menuToggleTheme": "Tukar tema",
+ "menuToggleFullScreen": "Skrin penuh",
+ "menuPauseUnpause": "Jeda / Sambung",
+ "menuConnectApplySettings": "Sambung / Gunakan tetapan",
+ "menuCloseAll": "Tutup semua",
+ "menuDocumentation": "Dokumentasi",
+ "menuGitHubRepository": "Repositori GitHub",
+ "menuReportIssue": "Laporkan masalah…",
+ "menuAbout": "Tentang SkellyCam",
+ "menuPlayback": "Main balik",
+ "videoPlayback": "Main Balik",
+ "copyLogsToClipboard": "Salin log ke papan klip",
+ "saveLogsToFile": "Simpan log ke fail",
+ "copied": "Disalin!",
+ "timestampFromRecording": "Cap masa daripada data rakaman",
+ "menuCheckForUpdates": "Check for Updates…",
+ "updateAvailable": "Update available",
+ "updateAvailableMessage": "Version {{version}} is available",
+ "downloading": "Downloading…",
+ "downloadComplete": "Download complete",
+ "restartToUpdate": "Restart to update",
+ "checkForUpdates": "Check for Updates",
+ "upToDate": "You are up to date",
+ "updateError": "Update check failed"
+}
diff --git a/freemocap-ui-old/src/i18n/locales/my-myanmar.json b/freemocap-ui-old/src/i18n/locales/my-myanmar.json
new file mode 100644
index 00000000..59bbfab6
--- /dev/null
+++ b/freemocap-ui-old/src/i18n/locales/my-myanmar.json
@@ -0,0 +1,258 @@
+{
+ "_meta": {
+ "locale": "my",
+ "translationSource": "ai-generated",
+ "lastUpdated": "2026-02-23"
+ },
+ "appName": "SkellyCam",
+ "appNameDecorated": "SkellyCam 💀📸",
+ "welcomeTitle": "SkellyCam မှ ကြိုဆိုပါသည်",
+ "welcomeSubtitle": "ချိန်ကိုက်ထားသော ဗီဒီယိုများကို ရိုက်ကူးပြီး ကြည့်ရှုပါ",
+ "sendAnonymousPings": "အမည်မသိ အသုံးပြုမှု ping များ ပို့ပါ",
+ "footerWith": "နှင့်",
+ "footerFrom": "မှ",
+ "footerOrgName": "FreeMoCap Foundation",
+ "home": "ပင်မ",
+ "cameras": "ကင်မရာများ",
+ "videos": "ဗီဒီယိုများ",
+ "expandSidebar": "ဘေးဘားကို ချဲ့ပါ",
+ "collapseSidebar": "ဘေးဘားကို ခေါက်ပါ",
+ "startRecording": "ရိုက်ကူးမှု စတင်ပါ",
+ "stopRecording": "ရိုက်ကူးမှု ရပ်ပါ",
+ "toggleTheme": "အပြင်အဆင် ပြောင်းပါ",
+ "switchToDark": "အမှောင်မုဒ်သို့ ပြောင်းပါ",
+ "switchToLight": "အလင်းမုဒ်သို့ ပြောင်းပါ",
+ "connectWebSocket": "WebSocket ချိတ်ဆက်ပါ",
+ "disconnectWebSocket": "WebSocket ဖြုတ်ပါ",
+ "launchServer": "ဆာဗာ စတင်ပါ",
+ "stopServer": "ဆာဗာ ရပ်ပါ",
+ "browseForExecutable": "အလုပ်လုပ်နိုင်သော ဖိုင် ရှာပါ",
+ "refreshCandidates": "ကိုယ်စားလှယ်လောင်းများ ပြန်လည်ရယူပါ",
+ "executable": "အလုပ်လုပ်နိုင်သော",
+ "host": "ဟို့စ်",
+ "port": "ပို့တ်",
+ "cameraCount_one": "ကင်မရာ {{count}} လုံး",
+ "cameraCount_other": "ကင်မရာ {{count}} လုံး",
+ "connectedCameras": "ချိတ်ဆက်ထားသော ကင်မရာများ",
+ "availableCameras": "ရရှိနိုင်သော ကင်မရာများ",
+ "noCamerasConnected": "ကင်မရာ ချိတ်ဆက်ထားခြင်း မရှိပါ",
+ "detectCameras": "ရရှိနိုင်သော ကင်မရာများကို ရှာဖွေပါ",
+ "clearCameraSettings": "မှတ်ဉာဏ်မှ သိမ်းထားသော ကင်မရာ ဆက်တင်များကို ရှင်းပါ",
+ "copySettingsToAll": "ဆက်တင်များကို ကင်မရာအားလုံးသို့ ကူးပါ",
+ "recordingTag": "ရိုက်ကူးမှု တဂ်",
+ "recordingTagPlaceholder": "ရွေးချယ်နိုင်သော တဂ်",
+ "recordingDirectory": "ရိုက်ကူးမှု လမ်းညွှန်",
+ "recordingFolderPath": "ရိုက်ကူးမှု ဖိုင်တွဲ လမ်းကြောင်း",
+ "delayStart": "နှောင့်နှေး စတင်ပါ",
+ "seconds": "စက္ကန့်",
+ "subfolder": "အခွဲဖိုင်တွဲ",
+ "subfolderPlaceholder": "အခွဲဖိုင်တွဲ အမည်",
+ "baseName": "အခြေခံ အမည်",
+ "increment": "တိုးမြှင့်ခြင်း",
+ "resolution": "ကြည်လင်ပြတ်သားမှု",
+ "fps": "FPS",
+ "width": "အကျယ်",
+ "height": "အမြင့်",
+ "columns": "ကော်လံများ",
+ "auto": "အလိုအလျောက်",
+ "manual": "လက်ဖြင့်",
+ "custom": "စိတ်ကြိုက်",
+ "current": "လက်ရှိ",
+ "recommend": "အကြံပြု",
+ "cameraRotation": "ကင်မရာ လှည့်ခြင်း",
+ "selectCameraRotation": "ကင်မရာ ပုံရိပ် လှည့်ခြင်းကို ရွေးချယ်ပါ",
+ "exposureControl": "အလိုအလျောက် သို့မဟုတ် လက်ဖြင့် ထိတွေ့မှု ထိန်းချုပ်ခြင်းကို ရွေးချယ်ပါ",
+ "framerateControl": "အလိုအလျောက် သို့မဟုတ် လက်ဖြင့် ဖရိမ်နှုန်း ထိန်းချုပ်ခြင်းကို ရွေးချယ်ပါ",
+ "adjustExposure": "ထိတွေ့မှု အချိန်ကို ချိန်ညှိပါ၊ ဥပမာ cv2.VideoCapture.set(cv2.CAP_PROP_EXPOSURE, value)",
+ "setTargetFps": "ကင်မရာ ဖမ်းယူခြင်းအတွက် ပစ်မှတ် ဖရိမ်/စက္ကန့် (FPS) သတ်မှတ်ပါ",
+ "recordingCaptureFps": "ရိုက်ကူးမှု ဖမ်းယူခြင်း ဖရိမ်နှုန်း",
+ "playbackSpeed": "ပြန်ဖွင့်မှု အမြန်နှုန်း (ရိုက်ကူးမှု fps ကို မသက်ရောက်ပါ)",
+ "framerateTimeline": "ဖရိမ်နှုန်း အချိန်မျဉ်း",
+ "framerateDistribution": "ဖရိမ်နှုန်း ဖြန့်ဝေမှု",
+ "timelineView": "အချိန်မျဉ်း မြင်ကွင်း",
+ "distributionView": "ဖြန့်ဝေမှု မြင်ကွင်း",
+ "combinedView": "ပေါင်းစပ် မြင်ကွင်း",
+ "min": "အနည်းဆုံး",
+ "max": "အများဆုံး",
+ "mean": "ပျမ်းမျှ",
+ "median": "အလယ်တန်ဖိုး",
+ "stdDevCv": "StdDev/CV",
+ "source": "ရင်းမြစ်",
+ "selectAll": "အားလုံး ရွေးချယ်ပါ",
+ "loadSynchronizedVideos": "ချိန်ကိုက်ထားသော ဗီဒီယိုများကို တင်ပါ",
+ "loadSynchronizedVideosDescription": "ဤစာမျက်နှာသည် ကြိုတင်ရိုက်ကူးထားသော ဗီဒီယိုများကို တင်ပြီး ချိန်ကိုက်နိုင်စေပါသည်။",
+ "automaticallySynchronizeVideos": "ဗီဒီယိုများကို အလိုအလျောက် ချိန်ကိုက်ပါ",
+ "extractFramesOnLoad": "တင်သည့်အခါ ဖရိမ်များကို ထုတ်ယူပါ",
+ "generateThumbnails": "ပုံငယ်များ ဖန်တီးပါ",
+ "noVideosLoaded": "ဗီဒီယို တင်ထားခြင်း မရှိပါ",
+ "filterVideos": "ဗီဒီယိုများကို စစ်ထုတ်ပါ...",
+ "openVideo": "ဗီဒီယို ဖွင့်ပါ",
+ "openFolder": "ဖိုင်ရှာဖွေသူတွင် ဖိုင်တွဲ ဖွင့်ပါ",
+ "videoFolderPath": "ဗီဒီယို ဖိုင်တွဲ လမ်းကြောင်း",
+ "jumpToStart": "အစသို့ ကူးပြောင်းပါ (Home)",
+ "jumpToEnd": "အဆုံးသို့ ကူးပြောင်းပါ (End)",
+ "loopOn": "ကွင်းပတ် ဖွင့်ထားသည် (ပြောင်းရန် L)",
+ "loopOff": "ကွင်းပတ် ပြန်ဖွင့်ခြင်း (L)",
+ "syncInfo": "ချိန်ကိုက်ခြင်း အချက်အလက်",
+ "syncInfoTitle": "ကင်မရာအများ ချိန်ကိုက်ခြင်းသည် ဖရိမ်အဆင့်တွင် တိကျမှု မရှိနိုင်ပါ",
+ "syncInfoBody": "ဘရောက်ဆာ ဗီဒီယို ပြန်ဖွင့်ခြင်းသည် များပြားသော stream များတွင် နမူနာတိကျသော ချိန်ကိုက်ခြင်းကို အာမခံမပေးပါ။ ပလေယာသည် ခေါင်းဆောင်-နောက်လိုက် ဗျူဟာကို အသုံးပြုပြီး သည်းခံနိုင်မှု အနည်းငယ်ထက် ကျော်လွန်သောအခါ drift ကို ပြင်ဆင်သည်၊ သို့သော် အနည်းငယ် ချိန်ကိုက်မှုလွဲခြင်း (1–2 ဖရိမ်) ဖြစ်နိုင်သည်၊ အထူးသဖြင့် မြင့်မားသော ပြန်ဖွင့်နှုန်းတွင် သို့မဟုတ် ဘရောက်ဆာ အလုပ်များနေချိန်တွင်။ ဖရိမ်တိကျသော ခွဲခြမ်းစိတ်ဖြာမှုအတွက်၊ အသံဖမ်းမှုတစ်ခုစီတွင် ပါဝင်သော မူရင်း timestamp CSV ဖိုင်များကို အသုံးပြုပါ။",
+ "previousFrame": "ယခင် ဖရိမ် (← / Shift+← 10 အတွက်)",
+ "nextFrame": "နောက် ဖရိမ် (→ / Shift+→ 10 အတွက်)",
+ "zoomIn": "ချဲ့ပါ",
+ "zoomOut": "ချုံ့ပါ",
+ "resetZoom": "ချဲ့ချုံ့ ပြန်လည်သတ်မှတ်ပါ",
+ "playbackSettings": "ပြန်ဖွင့်မှု ဆက်တင်များ",
+ "totalRecordingSize": "ဒစ်ခ်ပေါ်ရှိ စုစုပေါင်း ရိုက်ကူးမှု အရွယ်အစား",
+ "estimatedTime": "ခန့်မှန်း အချိန် (ဖရိမ် ÷ ရိုက်ကူးမှု fps)",
+ "estimatedDuration": "ခန့်မှန်း ကြာချိန် (စုစုပေါင်း ဖရိမ်များ ÷ ရိုက်ကူးမှု fps)",
+ "estimatedFromFrameNumber": "ဖရိမ်နံပါတ် × ရိုက်ကူးမှု fps မှ ခန့်မှန်း — အချိန်တံဆိပ် ဒေတာမှ မဖတ်ပါ",
+ "frameCountPerCamera": "ကင်မရာတစ်ခုစီ ဖရိမ် အရေအတွက်",
+ "cameraStreams": "ဤရိုက်ကူးမှုရှိ ကင်မရာ တိုက်ရိုက်လွှင့်များ",
+ "backToRecordings": "ရိုက်ကူးမှုများသို့ ပြန်သွားပါ",
+ "errorsDetected": "အမှားများ တွေ့ရှိသည်",
+ "somethingWentWrong": "တစ်ခုခု မှားသွားပါသည် :(",
+ "searchLogs": "မှတ်တမ်းများ ရှာဖွေပါ...",
+ "filter": "စစ်ထုတ်…",
+ "refreshMicrophoneList": "မိုက်ခရိုဖုန်း စာရင်း ပြန်လည်ရယူပါ",
+ "date": "ရက်စွဲ",
+ "name": "အမည်",
+ "size": "အရွယ်အစား",
+ "duration": "ကြာချိန်",
+ "frames": "ဖရိမ်များ",
+ "timestamp": "အချိန်တံဆိပ်",
+ "language": "ဘာသာစကား",
+ "aiTranslated": "AI ဘာသာပြန်ထားသော",
+ "humanTranslated": "လူ ဘာသာပြန်ထားသော",
+ "humanValidated": "လူ အတည်ပြုထားသော",
+ "connectCameras": "ရွေးချယ်ထားသော ကင်မရာများသို့ ချိတ်ဆက်ပါ သို့မဟုတ် ချိတ်ဆက်ထားသော ကင်မရာများကို အပ်ဒိတ်လုပ်ပါ",
+ "resumeStreaming": "တိုက်ရိုက်လွှင့်ခြင်း ပြန်လည်စတင်ပါ",
+ "pauseStreaming": "တိုက်ရိုက်လွှင့်ခြင်း ရပ်နားပါ",
+ "closeAllCameras": "ကင်မရာအားလုံး ပိတ်ပါ",
+ "framerate": "ဖရိမ်နှုန်း",
+ "exposure": "ထိတွေ့မှု",
+ "fileLabel": "ဖိုင်",
+ "timeDelta": "အချိန် ကွာဟချက်",
+ "pathLabel": "လမ်းကြောင်း",
+ "exceptionDetails": "ခြွင်းချက် အသေးစိတ်",
+ "stackTrace": "စတက် ခြေရာ",
+ "loadingVideos": "ဗီဒီယိုများ တင်နေသည်… ({{ready}}/{{total}} အဆင်သင့်)",
+ "gridColumns": "ဂရစ် ကော်လံများ",
+ "settings": "ဆက်တင်များ",
+ "appearance": "အသွင်အပြင်",
+ "themeMode": "အပြင်အဆင်",
+ "darkMode": "အမှောင်",
+ "lightMode": "အလင်း",
+ "languageSettings": "ဘာသာစကား နှင့် ဒေသအလိုက်ပြုပြင်ခြင်း",
+ "showTranslationIndicator": "ဘာသာပြန် ရင်းမြစ် ညွှန်ပြချက် ပြပါ",
+ "showTranslationIndicatorDescription": "AI ဖြင့် ဘာသာပြန်ထားသော ဘာသာပြန်များ အသုံးပြုသည့်အခါ တံဆိပ် ပြပါ",
+ "translationSourceLabel": "ဘာသာပြန် ရင်းမြစ်",
+ "general": "ယေဘုယျ",
+ "about": "အကြောင်း",
+ "version": "ဗားရှင်း",
+ "serverSettings": "ဆာဗာ",
+ "recordingSettings": "ရိုက်ကူးမှု ဆက်တင်များ",
+ "videoLoadingSettings": "ဗီဒီယို တင်ခြင်း ဆက်တင်များ",
+ "connected": "ချိတ်ဆက်ပြီး",
+ "connecting": "ချိတ်ဆက်နေသည်…",
+ "disconnected": "ချိတ်ဆက်မှု ပြတ်ပြီး",
+ "disconnect": "ချိတ်ဆက်မှု ဖြုတ်ပါ",
+ "connect": "ချိတ်ဆက်ပါ",
+ "off": "ပိတ်",
+ "running": "အလုပ်လုပ်နေသည်",
+ "stopped": "ရပ်ထားသည်",
+ "working": "အလုပ်လုပ်နေသည်…",
+ "invalid": "မမှန်ကန်",
+ "autoLaunch": "အလိုအလျောက် စတင်",
+ "autoConnect": "အလိုအလျောက် ချိတ်ဆက်",
+ "runningPath": "အလုပ်လုပ်နေသည်: {{path}}",
+ "noMicrophone": "မိုက်ခရိုဖုန်း မရှိပါ",
+ "audioRecordingEnabled": "အသံ ရိုက်ကူးခြင်း ဖွင့်ထားသည်",
+ "noMicrophoneSelected": "မိုက်ခရိုဖုန်း ရွေးချယ်ထားခြင်း မရှိပါ",
+ "recordingName": "ရိုက်ကူးမှု အမည်: {{name}}",
+ "startingIn": "{{countdown}} တွင် စတင်မည်...",
+ "stopping": "ရပ်နေသည်...",
+ "starting": "စတင်နေသည်...",
+ "stopRecordingButton": "🔴 ရိုက်ကူးမှု ရပ်ပါ",
+ "startRecordingButton": "🔴 ရိုက်ကူးမှု စတင်ပါ",
+ "camerasCount": "ကင်မရာများ ({{count}})",
+ "availableCamerasCount": "ရရှိနိုင်သော ({{count}})",
+ "server": "ဆာဗာ",
+ "display": "မျက်နှာပြင်",
+ "rawMessage": "မူရင်း မက်ဆေ့ခ်ျ",
+ "cameraPerformanceMetrics": "ကင်မရာ စွမ်းဆောင်ရည် တိုင်းတာချက်များ",
+ "serverLogs": "ဆာဗာ မှတ်တမ်းများ",
+ "sortBy": "{{direction}} စီရန်",
+ "waitingForCameraStreams": "ကင်မရာ တိုက်ရိုက်လွှင့်များကို စောင့်နေသည်...",
+ "loggingPaused": "မှတ်တမ်းတင်ခြင်း ရပ်နားထားသည်",
+ "noLogsToDisplay": "ပြသရန် မှတ်တမ်း မရှိပါ",
+ "closeSettings": "ဆက်တင်များ ပိတ်ပါ",
+ "gridSettings": "ဂရစ် ဆက်တင်များ",
+ "clickToShowLess": "လျှော့ပြရန် နှိပ်ပါ",
+ "clickToLearnMore": "ပိုမိုသိရှိရန် နှိပ်ပါ",
+ "samples": "နမူနာများ",
+ "framerateOverTime": "အချိန်အလိုက် ဖရိမ်နှုန်း",
+ "framerateFps": "ဖရိမ်နှုန်း (fps)",
+ "capturesFramesFromCamera": "ကင်မရာမှ ဖရိမ်များကို ဖမ်းယူသည်။",
+ "rendersReceivedFrames": "လက်ခံရရှိသော ဖရိမ်များကို မျက်နှာပြင်ပေါ်တွင် ပြသသည်။",
+ "displayTooltipLong": "မျက်နှာပြင်သည် UI ပုံဖော်ခြင်း စွမ်းဆောင်ရည်ကို ကိုယ်စားပြုသည်။ သင့်မျက်နှာပြင်သည် ဖရိမ်များကို မည်မျှ မြန်ဆန်စွာ လက်ခံပြီး ပုံဖော်သည်ကို ပြသည်။ ဤနေရာရှိ စွမ်းဆောင်ရည် ပြဿနာများသည် ရိုက်ကူးမှု အရည်အသွေးကို မထိခိုက်စေသော်လည်း ကင်မရာများကို အချိန်နှင့်တစ်ပြေးညီ စောင့်ကြည့်နိုင်စွမ်းကို ထိခိုက်နိုင်သည်။",
+ "statsSourceShort": "မျက်နှာပြင်သည် ဖရိမ်များကို ပုံဖော်သည်၊ ဆာဗာသည် ဖရိမ်များကို ဖမ်းယူသည်။",
+ "statsSourceLong": "ဆာဗာသည် ကင်မရာမှ ဖရိမ်များကို ဆွဲယူ/ရိုက်ကူးသည့် အမှန်တကယ် နှုန်းဖြစ်ပြီး၊ မျက်နှာပြင်သည် ၎င်းတို့ကို လက်ခံပြီး ပုံဖော်သည့် နှုန်းဖြစ်သည်။ Skellycam သည် ရိုက်ကူးမှု အရည်အသွေးအတွက် ဆာဗာဘက် စွမ်းဆောင်ရည်ကို ဦးစားပေးသောကြောင့် ထိုနံပါတ်သည် ပိုမိုတည်ငြိမ်သင့်သည်။ မျက်နှာပြင် ဖရိမ်နှုန်းသည် ဆာဗာမှ ကွဲလွဲပါက သင့်စနစ် အရင်းအမြစ်များ ဝန်ပိနေကြောင်း ညွှန်ပြသည်။ ကင်မရာ နည်းနည်း အသုံးပြုခြင်း သို့မဟုတ် ဖရိမ်နှုန်း/ကြည်လင်ပြတ်သားမှု လျှော့ချခြင်းကို စဉ်းစားပါ။",
+ "statsCurrentShort": "အနောက်ဆုံး ဖရိမ် အချိန် နှင့် သက်ဆိုင်ရာ FPS။",
+ "statsCurrentLong": "ဖရိမ်တစ်ခုကို စီမံဆောင်ရွက်ရန် မည်မျှ ကြာသည် (မီလီစက္ကန့်ဖြင့်) နှင့် ညီမျှသော FPS ၏ အနောက်ဆုံး တိုင်းတာချက်ကို ပြသည်။ ဖရိမ် အချိန် နိမ့်လေ FPS မြင့်လေ စွမ်းဆောင်ရည် ကောင်းလေ ဖြစ်သည်။",
+ "statsMinShort": "အမြန်ဆုံး ဖရိမ် အချိန် (အနိမ့်ဆုံး နှောင့်နှေးမှု) နှင့် ရရှိသော အမြင့်ဆုံး FPS။",
+ "statsMinLong": "နမူနာယူခြင်း ကာလအတွင်း ဖရိမ်တစ်ခုကို စီမံဆောင်ရွက်ရန် ယူသော အနည်းဆုံး အချိန်ကို ကိုယ်စားပြုသည်။ အကောင်းဆုံး အခြေအနေများတွင် သင့်စနစ် ရရှိသော အမြင့်ဆုံး FPS နှင့် သက်ဆိုင်သည်။",
+ "statsMaxShort": "အနှေးဆုံး ဖရိမ် အချိန် (အမြင့်ဆုံး နှောင့်နှေးမှု) နှင့် ကြုံတွေ့ရသော အနိမ့်ဆုံး FPS။",
+ "statsMaxLong": "နမူနာယူခြင်း ကာလအတွင်း ဖရိမ်တစ်ခုကို စီမံဆောင်ရွက်ရန် ယူသော အများဆုံး အချိန်ကို ကိုယ်စားပြုသည်။ အဆိုးဆုံး အခြေအနေများတွင် သင့်စနစ် ရရှိသော အနိမ့်ဆုံး FPS နှင့် သက်ဆိုင်သည်။ ရံဖန်ရံခါ တက်ခြင်းသည် ပုံမှန်ဖြစ်သော်လည်း တသမတ်တည်း မြင့်မားသော တန်ဖိုးများသည် စွမ်းဆောင်ရည် ပြဿနာများကို ညွှန်ပြနိုင်သည်။",
+ "statsMeanShort": "နမူနာအားလုံးရှိ ပျမ်းမျှ ဖရိမ် အချိန် နှင့် FPS။",
+ "statsMeanLong": "နမူနာယူခြင်း ကာလအတွင်း တိုင်းတာထားသော ဖရိမ် အချိန်အားလုံး၏ သင်္ချာ ပျမ်းမျှ နှင့် သက်ဆိုင်ရာ FPS။ စွမ်းဆောင်ရည်၏ ကောင်းမွန်သော ယေဘုယျ ပုံရိပ်ကို ပေးသော်လည်း ထူးခြား တန်ဖိုးများကြောင့် စောင်းနိုင်သည်။",
+ "statsMedianShort": "ဖရိမ် အချိန်အားလုံး၏ အလယ်တန်ဖိုး (ရာခိုင်နှုန်း 50)။",
+ "statsMedianLong": "အလယ်တန်ဖိုးသည် ဖရိမ် အချိန်အားလုံးကို အမြန်ဆုံးမှ အနှေးဆုံးသို့ စီတန်းသောအခါ အလယ်တန်ဖိုးကို ကိုယ်စားပြုသည်။ ပျမ်းမျှနှင့် မတူဘဲ အလယ်တန်ဖိုးသည် အစွန်းရောက် တန်ဖိုးများကြောင့် မထိခိုက်ဘဲ ပုံမှန် စွမ်းဆောင်ရည်၏ ပိုမိုတည်ငြိမ်သော ညွှန်ပြချက်ဖြစ်သည်။",
+ "statsStdDevShort": "ဖရိမ် အချိန် ကွဲပြားမှုကို တိုင်းတာသည်။ CV% သည် နှိုင်းယှဉ် ကွဲပြားမှု ဖြစ်သည်။",
+ "statsStdDevLong": "စံသွေဖည်မှုသည် ဖရိမ် အချိန်များတွင် ကွဲပြားမှု ပမာဏကို တိုင်းတာသည်။ တန်ဖိုး နိမ့်လေ စွမ်းဆောင်ရည် တသမတ်တည်း ကောင်းလေ ဖြစ်သည်။ ကွဲပြားမှု ကိန်းရှင် (CV%) သည် ဤကွဲပြားမှုကို ပျမ်းမျှ၏ ရာခိုင်နှုန်းအဖြစ် ဖော်ပြပြီး မတူညီသော ဖရိမ်နှုန်းများတွင် တည်ငြိမ်မှုကို နှိုင်းယှဉ်ရန် လွယ်ကူစေသည်။ CV% နိမ့်လေ စွမ်းဆောင်ရည် တည်ငြိမ်လေ ဖြစ်သည်။",
+ "aiTranslatedTooltip": "ဤဘာသာပြန်ကို AI ဖြင့် ဖန်တီးထားပြီး အမှားများ ပါဝင်နိုင်သည်။ ဤဘာသာစကားကို ပြောတတ်ပါက GitHub တွင် pull request ဖွင့်၍ ပိုမိုကောင်းမွန်အောင် ကူညီနိုင်ပါသည်!",
+ "humanValidatedTooltip": "ဤဘာသာပြန်ကို လူ ဘာသာပြန်သူက စစ်ဆေးပြီး အတည်ပြုထားပါသည်။",
+ "helpTranslate": "SkellyCam ဘာသာပြန်ရာတွင် ကူညီပါ",
+ "failedToFetch": "ရယူရန် မအောင်မြင်ပါ",
+ "recordings": "ရိုက်ကူးမှုများ",
+ "noRecordingsFound": "ရိုက်ကူးမှု မတွေ့ပါ။ လက်ဖြင့် တင်ရန် အထက်တွင် လမ်းကြောင်း ထည့်ပါ။",
+ "noCamerasDetected": "ကင်မရာ မတွေ့ပါ",
+ "clickRefreshToScan": "ရရှိနိုင်သော ကင်မရာများကို ရှာဖွေရန် ပြန်လည်ရယူ ကို နှိပ်ပါ",
+ "waitingForData": "ဒေတာ စောင့်နေသည်…",
+ "load": "တင်ပါ",
+ "refresh": "ပြန်လည်ရယူပါ",
+ "available": "ရရှိနိုင်",
+ "menuFile": "ဖိုင်",
+ "menuView": "မြင်ကွင်း",
+ "menuCamera": "ကင်မရာ",
+ "menuRecording": "အသံဖမ်း",
+ "menuHelp": "အကူအညီ",
+ "menuDetectCameras": "ကင်မရာများရှာဖွေ",
+ "menuConnectCameras": "ကင်မရာများချိတ်ဆက်",
+ "menuCloseAllCameras": "ကင်မရာအားလုံးပိတ်",
+ "menuOpenRecordingFolder": "အသံဖမ်းဖိုဒါဖွင့်…",
+ "menuToggleSidebar": "ဘေးဘားပြောင်း",
+ "menuToggleTheme": "အပြင်အဆင်ပြောင်း",
+ "menuToggleFullScreen": "မျက်နှာပြင်အပြည့်",
+ "menuPauseUnpause": "ခေတ္တရပ် / ဆက်လုပ်",
+ "menuConnectApplySettings": "ချိတ်ဆက် / ဆက်တင်များအသုံးပြု",
+ "menuCloseAll": "အားလုံးပိတ်",
+ "menuDocumentation": "စာရွက်စာတမ်း",
+ "menuGitHubRepository": "GitHub Repository",
+ "menuReportIssue": "ပြဿနာတင်ပြ…",
+ "menuAbout": "SkellyCam အကြောင်း",
+ "menuPlayback": "ပြန်ဖွင့်",
+ "videoPlayback": "ပြန်ဖွင့်",
+ "copyLogsToClipboard": "မှတ်တမ်းများကို ကလစ်ဘုတ်သို့ ကူးယူ",
+ "saveLogsToFile": "မှတ်တမ်းများကို ဖိုင်သို့ သိမ်းဆည်း",
+ "copied": "ကူးယူပြီး!",
+ "timestampFromRecording": "အသံဖမ်းဒေတာမှ အချိန်တံဆိပ်",
+ "menuCheckForUpdates": "Check for Updates…",
+ "updateAvailable": "Update available",
+ "updateAvailableMessage": "Version {{version}} is available",
+ "downloading": "Downloading…",
+ "downloadComplete": "Download complete",
+ "restartToUpdate": "Restart to update",
+ "checkForUpdates": "Check for Updates",
+ "upToDate": "You are up to date",
+ "updateError": "Update check failed"
+}
diff --git a/freemocap-ui-old/src/i18n/locales/ne-nepali.json b/freemocap-ui-old/src/i18n/locales/ne-nepali.json
new file mode 100644
index 00000000..e5482a60
--- /dev/null
+++ b/freemocap-ui-old/src/i18n/locales/ne-nepali.json
@@ -0,0 +1,258 @@
+{
+ "_meta": {
+ "locale": "ne",
+ "translationSource": "ai-generated",
+ "lastUpdated": "2026-02-23"
+ },
+ "appName": "SkellyCam",
+ "appNameDecorated": "SkellyCam 💀📸",
+ "welcomeTitle": "SkellyCam मा स्वागत छ",
+ "welcomeSubtitle": "सिङ्क्रोनाइज गरिएका भिडियोहरू रेकर्ड गर्नुहोस् र हेर्नुहोस्",
+ "sendAnonymousPings": "अज्ञात प्रयोग पिङहरू पठाउनुहोस्",
+ "footerWith": "सँग",
+ "footerFrom": "बाट",
+ "footerOrgName": "FreeMoCap Foundation",
+ "home": "गृहपृष्ठ",
+ "cameras": "क्यामेराहरू",
+ "videos": "भिडियोहरू",
+ "expandSidebar": "साइडबार विस्तार गर्नुहोस्",
+ "collapseSidebar": "साइडबार संकुचित गर्नुहोस्",
+ "startRecording": "रेकर्डिङ सुरु गर्नुहोस्",
+ "stopRecording": "रेकर्डिङ रोक्नुहोस्",
+ "toggleTheme": "थिम बदल्नुहोस्",
+ "switchToDark": "डार्क मोडमा स्विच गर्नुहोस्",
+ "switchToLight": "लाइट मोडमा स्विच गर्नुहोस्",
+ "connectWebSocket": "WebSocket जोड्नुहोस्",
+ "disconnectWebSocket": "WebSocket विच्छेद गर्नुहोस्",
+ "launchServer": "सर्भर सुरु गर्नुहोस्",
+ "stopServer": "सर्भर रोक्नुहोस्",
+ "browseForExecutable": "कार्यान्वयनयोग्य फाइल खोज्नुहोस्",
+ "refreshCandidates": "उम्मेदवारहरू ताजा गर्नुहोस्",
+ "executable": "कार्यान्वयनयोग्य",
+ "host": "होस्ट",
+ "port": "पोर्ट",
+ "cameraCount_one": "{{count}} क्यामेरा",
+ "cameraCount_other": "{{count}} क्यामेराहरू",
+ "connectedCameras": "जोडिएका क्यामेराहरू",
+ "availableCameras": "उपलब्ध क्यामेराहरू",
+ "noCamerasConnected": "कुनै क्यामेरा जोडिएको छैन",
+ "detectCameras": "उपलब्ध क्यामेराहरू पत्ता लगाउनुहोस्",
+ "clearCameraSettings": "मेमोरीबाट सेभ गरिएका क्यामेरा सेटिङहरू खाली गर्नुहोस्",
+ "copySettingsToAll": "सेटिङहरू सबै क्यामेरामा कपी गर्नुहोस्",
+ "recordingTag": "रेकर्डिङ ट्याग",
+ "recordingTagPlaceholder": "वैकल्पिक ट्याग",
+ "recordingDirectory": "रेकर्डिङ डाइरेक्टरी",
+ "recordingFolderPath": "रेकर्डिङ फोल्डर पथ",
+ "delayStart": "ढिलो सुरु",
+ "seconds": "सेकेन्ड",
+ "subfolder": "सबफोल्डर",
+ "subfolderPlaceholder": "सबफोल्डर नाम",
+ "baseName": "आधार नाम",
+ "increment": "वृद्धि",
+ "resolution": "रिजोल्युसन",
+ "fps": "FPS",
+ "width": "चौडाइ",
+ "height": "उचाइ",
+ "columns": "स्तम्भहरू",
+ "auto": "स्वचालित",
+ "manual": "म्यानुअल",
+ "custom": "अनुकूलित",
+ "current": "हालको",
+ "recommend": "सिफारिस",
+ "cameraRotation": "क्यामेरा घुमाउने",
+ "selectCameraRotation": "क्यामेरा छवि घुमाउने चयन गर्नुहोस्",
+ "exposureControl": "स्वचालित वा म्यानुअल एक्सपोजर नियन्त्रण बीच छनोट गर्नुहोस्",
+ "framerateControl": "स्वचालित वा म्यानुअल फ्रेमरेट नियन्त्रण बीच छनोट गर्नुहोस्",
+ "adjustExposure": "एक्सपोजर समय समायोजन गर्नुहोस्, जस्तै cv2.VideoCapture.set(cv2.CAP_PROP_EXPOSURE, value)",
+ "setTargetFps": "क्यामेरा क्याप्चरको लागि लक्षित फ्रेम प्रति सेकेन्ड (FPS) सेट गर्नुहोस्",
+ "recordingCaptureFps": "रेकर्डिङ क्याप्चर फ्रेमरेट",
+ "playbackSpeed": "प्लेब्याक गति (रेकर्डिङ fps मा असर गर्दैन)",
+ "framerateTimeline": "फ्रेमरेट टाइमलाइन",
+ "framerateDistribution": "फ्रेमरेट वितरण",
+ "timelineView": "टाइमलाइन दृश्य",
+ "distributionView": "वितरण दृश्य",
+ "combinedView": "संयुक्त दृश्य",
+ "min": "न्यूनतम",
+ "max": "अधिकतम",
+ "mean": "औसत",
+ "median": "मध्यमान",
+ "stdDevCv": "StdDev/CV",
+ "source": "स्रोत",
+ "selectAll": "सबै चयन गर्नुहोस्",
+ "loadSynchronizedVideos": "सिङ्क्रोनाइज गरिएका भिडियोहरू लोड गर्नुहोस्",
+ "loadSynchronizedVideosDescription": "यो पृष्ठले तपाईंलाई पूर्व-रेकर्ड गरिएका भिडियोहरू लोड र सिङ्क्रोनाइज गर्न अनुमति दिन्छ।",
+ "automaticallySynchronizeVideos": "भिडियोहरू स्वचालित रूपमा सिङ्क्रोनाइज गर्नुहोस्",
+ "extractFramesOnLoad": "लोड गर्दा फ्रेमहरू निकाल्नुहोस्",
+ "generateThumbnails": "थम्बनेलहरू बनाउनुहोस्",
+ "noVideosLoaded": "कुनै भिडियो लोड भएको छैन",
+ "filterVideos": "भिडियोहरू फिल्टर गर्नुहोस्...",
+ "openVideo": "भिडियो खोल्नुहोस्",
+ "openFolder": "फाइल एक्सप्लोररमा फोल्डर खोल्नुहोस्",
+ "videoFolderPath": "भिडियो फोल्डर पथ",
+ "jumpToStart": "सुरुमा जानुहोस् (Home)",
+ "jumpToEnd": "अन्तमा जानुहोस् (End)",
+ "loopOn": "लुप सक्रिय छ (टगल गर्न L)",
+ "loopOff": "लुप प्लेब्याक (L)",
+ "syncInfo": "सिंक जानकारी",
+ "syncInfoTitle": "मल्टि-क्यामेरा सिंक फ्रेम-सटीक नहुन सक्छ",
+ "syncInfoBody": "ब्राउजर भिडियो प्लेब्याकले धेरै स्ट्रिमहरूमा नमूना-सटीक सिंक्रोनाइजेशनको ग्यारेन्टी दिँदैन। प्लेयरले लिडर-फलोअर रणनीति प्रयोग गर्दछ र ड्रिफ्ट सानो सहनशीलता नाघ्दा सच्याउँछ, तर मामूली डिसिंक्रोनाइजेशन (1–2 फ्रेम) हुन सक्छ, विशेष गरी उच्च प्लेब्याक गतिमा वा ब्राउजर लोडमा हुँदा। फ्रेम-सटीक विश्लेषणको लागि, प्रत्येक रेकर्डिङमा समावेश गरिएका कच्चा टाइमस्ट्याम्प CSV फाइलहरू प्रयोग गर्नुहोस्।",
+ "previousFrame": "अघिल्लो फ्रेम (← / Shift+← 10 को लागि)",
+ "nextFrame": "अर्को फ्रेम (→ / Shift+→ 10 को लागि)",
+ "zoomIn": "ठूलो गर्नुहोस्",
+ "zoomOut": "सानो गर्नुहोस्",
+ "resetZoom": "जुम रिसेट गर्नुहोस्",
+ "playbackSettings": "प्लेब्याक सेटिङहरू",
+ "totalRecordingSize": "डिस्कमा कुल रेकर्डिङ आकार",
+ "estimatedTime": "अनुमानित समय (फ्रेम ÷ रेकर्डिङ fps)",
+ "estimatedDuration": "अनुमानित अवधि (कुल फ्रेमहरू ÷ रेकर्डिङ fps)",
+ "estimatedFromFrameNumber": "फ्रेम नम्बर × रेकर्डिङ fps बाट अनुमान — टाइमस्ट्याम्प डेटाबाट पढिएको होइन",
+ "frameCountPerCamera": "प्रति क्यामेरा फ्रेम गणना",
+ "cameraStreams": "यो रेकर्डिङमा क्यामेरा स्ट्रिमहरू",
+ "backToRecordings": "रेकर्डिङहरूमा फर्कनुहोस्",
+ "errorsDetected": "त्रुटिहरू पत्ता लागे",
+ "somethingWentWrong": "केही गलत भयो :(",
+ "searchLogs": "लगहरू खोज्नुहोस्...",
+ "filter": "फिल्टर…",
+ "refreshMicrophoneList": "माइक्रोफोन सूची ताजा गर्नुहोस्",
+ "date": "मिति",
+ "name": "नाम",
+ "size": "आकार",
+ "duration": "अवधि",
+ "frames": "फ्रेमहरू",
+ "timestamp": "टाइमस्ट्याम्प",
+ "language": "भाषा",
+ "aiTranslated": "AI अनुवादित",
+ "humanTranslated": "मानव अनुवादित",
+ "humanValidated": "मानव प्रमाणित",
+ "connectCameras": "चयन गरिएका क्यामेराहरूमा जोड्नुहोस् वा जोडिएका क्यामेराहरू अपडेट गर्नुहोस्",
+ "resumeStreaming": "स्ट्रिमिङ पुनः सुरु गर्नुहोस्",
+ "pauseStreaming": "स्ट्रिमिङ रोक्नुहोस्",
+ "closeAllCameras": "सबै क्यामेराहरू बन्द गर्नुहोस्",
+ "framerate": "फ्रेमरेट",
+ "exposure": "एक्सपोजर",
+ "fileLabel": "फाइल",
+ "timeDelta": "समय भिन्नता",
+ "pathLabel": "पथ",
+ "exceptionDetails": "अपवाद विवरणहरू",
+ "stackTrace": "स्ट्याक ट्रेस",
+ "loadingVideos": "भिडियोहरू लोड हुँदैछ… ({{ready}}/{{total}} तयार)",
+ "gridColumns": "ग्रिड स्तम्भहरू",
+ "settings": "सेटिङहरू",
+ "appearance": "रूप",
+ "themeMode": "थिम",
+ "darkMode": "डार्क",
+ "lightMode": "लाइट",
+ "languageSettings": "भाषा र स्थानीयकरण",
+ "showTranslationIndicator": "अनुवाद स्रोत सूचक देखाउनुहोस्",
+ "showTranslationIndicatorDescription": "AI-उत्पन्न अनुवादहरू प्रयोग गर्दा ब्याज देखाउनुहोस्",
+ "translationSourceLabel": "अनुवाद स्रोत",
+ "general": "सामान्य",
+ "about": "बारेमा",
+ "version": "संस्करण",
+ "serverSettings": "सर्भर",
+ "recordingSettings": "रेकर्डिङ सेटिङहरू",
+ "videoLoadingSettings": "भिडियो लोडिङ सेटिङहरू",
+ "connected": "जोडिएको",
+ "connecting": "जोड्दैछ…",
+ "disconnected": "विच्छेद भएको",
+ "disconnect": "विच्छेद गर्नुहोस्",
+ "connect": "जोड्नुहोस्",
+ "off": "बन्द",
+ "running": "चलिरहेको छ",
+ "stopped": "रोकिएको",
+ "working": "काम गरिरहेको छ…",
+ "invalid": "अमान्य",
+ "autoLaunch": "स्वचालित सुरु",
+ "autoConnect": "स्वचालित जोड्ने",
+ "runningPath": "चलिरहेको छ: {{path}}",
+ "noMicrophone": "माइक्रोफोन छैन",
+ "audioRecordingEnabled": "अडियो रेकर्डिङ सक्षम गरिएको",
+ "noMicrophoneSelected": "माइक्रोफोन चयन गरिएको छैन",
+ "recordingName": "रेकर्डिङ नाम: {{name}}",
+ "startingIn": "{{countdown}} मा सुरु हुँदैछ...",
+ "stopping": "रोकिँदैछ...",
+ "starting": "सुरु हुँदैछ...",
+ "stopRecordingButton": "🔴 रेकर्डिङ रोक्नुहोस्",
+ "startRecordingButton": "🔴 रेकर्डिङ सुरु गर्नुहोस्",
+ "camerasCount": "क्यामेराहरू ({{count}})",
+ "availableCamerasCount": "उपलब्ध ({{count}})",
+ "server": "सर्भर",
+ "display": "प्रदर्शन",
+ "rawMessage": "कच्चा सन्देश",
+ "cameraPerformanceMetrics": "क्यामेरा कार्यसम्पादन मापदण्डहरू",
+ "serverLogs": "सर्भर लगहरू",
+ "sortBy": "{{direction}} क्रमबद्ध गर्नुहोस्",
+ "waitingForCameraStreams": "क्यामेरा स्ट्रिमहरूको प्रतीक्षा गर्दै...",
+ "loggingPaused": "लग रोकिएको",
+ "noLogsToDisplay": "देखाउन कुनै लग छैन",
+ "closeSettings": "सेटिङहरू बन्द गर्नुहोस्",
+ "gridSettings": "ग्रिड सेटिङहरू",
+ "clickToShowLess": "कम देखाउन क्लिक गर्नुहोस्",
+ "clickToLearnMore": "थप जान्न क्लिक गर्नुहोस्",
+ "samples": "नमूनाहरू",
+ "framerateOverTime": "समयसँगै फ्रेमरेट",
+ "framerateFps": "फ्रेमरेट (fps)",
+ "capturesFramesFromCamera": "क्यामेराबाट फ्रेमहरू क्याप्चर गर्छ।",
+ "rendersReceivedFrames": "प्राप्त फ्रेमहरू स्क्रिनमा रेन्डर गर्छ।",
+ "displayTooltipLong": "प्रदर्शनले UI रेन्डरिङ कार्यसम्पादन प्रतिनिधित्व गर्छ। तपाईंको प्रदर्शनले कत्तिको छिटो फ्रेमहरू प्राप्त र रेन्डर गर्छ भनेर देखाउँछ। यहाँ कार्यसम्पादन समस्याहरूले रेकर्डिङ गुणस्तरलाई असर गर्दैन तर वास्तविक समयमा क्यामेरा निगरानी गर्ने तपाईंको क्षमतालाई असर गर्न सक्छ।",
+ "statsSourceShort": "प्रदर्शनले फ्रेमहरू रेन्डर गर्छ, सर्भरले फ्रेमहरू क्याप्चर गर्छ।",
+ "statsSourceLong": "सर्भर भनेको क्यामेराबाट फ्रेमहरू तानिने/रेकर्ड गरिने वास्तविक दर हो, जबकि प्रदर्शन भनेको तिनीहरू प्राप्त र रेन्डर गरिने दर हो। Skellycam ले रेकर्डिङ गुणस्तरको लागि सर्भर-साइड कार्यसम्पादनलाई प्राथमिकता दिन्छ, त्यसैले त्यो संख्या बढी स्थिर हुनुपर्छ। यदि प्रदर्शन फ्रेमरेट सर्भरबाट भिन्न हुन्छ भने, तपाईंको प्रणाली स्रोतहरू तनावमा छन् भन्ने संकेत गर्छ। कम क्यामेरा प्रयोग गर्ने वा फ्रेमरेट/रिजोल्युसन घटाउने विचार गर्नुहोस्।",
+ "statsCurrentShort": "सबैभन्दा भर्खरको फ्रेम समय र सम्बन्धित FPS।",
+ "statsCurrentLong": "एउटा फ्रेम प्रशोधन गर्न कति समय लाग्छ (मिलिसेकेन्डमा) र बराबर FPS को सबैभन्दा भर्खरको मापन देखाउँछ। कम फ्रेम समय र उच्च FPS ले राम्रो कार्यसम्पादन संकेत गर्छ।",
+ "statsMinShort": "सबैभन्दा छिटो फ्रेम समय (सबैभन्दा कम विलम्बता) र प्राप्त उच्चतम FPS।",
+ "statsMinLong": "नमूना विन्डो दौरान एउटा फ्रेम प्रशोधन गर्न लागेको न्यूनतम समय प्रतिनिधित्व गर्छ। यो तपाईंको प्रणालीले इष्टतम अवस्थामा प्राप्त गरेको अधिकतम FPS सँग मेल खान्छ।",
+ "statsMaxShort": "सबैभन्दा ढिलो फ्रेम समय (सबैभन्दा उच्च विलम्बता) र अनुभव गरिएको न्यूनतम FPS।",
+ "statsMaxLong": "नमूना विन्डो दौरान एउटा फ्रेम प्रशोधन गर्न लागेको अधिकतम समय प्रतिनिधित्व गर्छ। यो तपाईंको प्रणालीले खराब अवस्थामा प्राप्त गरेको न्यूनतम FPS सँग मेल खान्छ। कहिलेकाहीँ स्पाइकहरू सामान्य हुन्, तर लगातार उच्च मानहरूले कार्यसम्पादन समस्याहरू संकेत गर्न सक्छ।",
+ "statsMeanShort": "सबै नमूनाहरूमा औसत फ्रेम समय र FPS।",
+ "statsMeanLong": "नमूना विन्डो दौरान मापन गरिएका सबै फ्रेम समयहरूको अंकगणित औसत र सम्बन्धित FPS। यसले कार्यसम्पादनको राम्रो समग्र चित्र दिन्छ तर बाह्य मानहरूले स्क्यू गर्न सक्छ।",
+ "statsMedianShort": "सबै फ्रेम समयहरूको मध्य मान (50 औं प्रतिशत)।",
+ "statsMedianLong": "मध्यमान भनेको सबै फ्रेम समयहरू छिटोबाट ढिलोसम्म क्रमबद्ध गर्दा मध्य मान हो। औसतसँग भिन्न, मध्यमान चरम बाह्य मानहरूबाट प्रभावित हुँदैन, जसले यसलाई सामान्य कार्यसम्पादनको बढी स्थिर सूचक बनाउँछ।",
+ "statsStdDevShort": "फ्रेम समय परिवर्तनशीलता मापन गर्छ। CV% सापेक्ष परिवर्तनशीलता हो।",
+ "statsStdDevLong": "मानक विचलनले फ्रेम समयहरूमा भिन्नताको मात्रा मापन गर्छ। कम मानहरूले बढी एकरूप कार्यसम्पादन संकेत गर्छ। भिन्नता गुणांक (CV%) ले यो परिवर्तनशीलतालाई औसतको प्रतिशतको रूपमा व्यक्त गर्छ, विभिन्न फ्रेमरेटहरूमा स्थिरता तुलना गर्न सजिलो बनाउँछ। कम CV% ले बढी स्थिर कार्यसम्पादन संकेत गर्छ।",
+ "aiTranslatedTooltip": "यो अनुवाद AI द्वारा उत्पन्न गरिएको हो र त्रुटिहरू हुन सक्छ। यदि तपाईं यो भाषा बोल्नुहुन्छ भने, GitHub मा pull request खोलेर सुधार गर्न मद्दत गर्न सक्नुहुन्छ!",
+ "humanValidatedTooltip": "यो अनुवाद मानव अनुवादकद्वारा समीक्षा र प्रमाणित गरिएको छ।",
+ "helpTranslate": "SkellyCam अनुवाद गर्न मद्दत गर्नुहोस्",
+ "failedToFetch": "प्राप्त गर्न असफल",
+ "recordings": "रेकर्डिङहरू",
+ "noRecordingsFound": "कुनै रेकर्डिङ भेटिएन। म्यानुअल रूपमा लोड गर्न माथि पथ प्रविष्ट गर्नुहोस्।",
+ "noCamerasDetected": "कुनै क्यामेरा पत्ता लागेन",
+ "clickRefreshToScan": "उपलब्ध क्यामेराहरू स्क्यान गर्न ताजा गर्नुहोस् मा क्लिक गर्नुहोस्",
+ "waitingForData": "डेटाको प्रतीक्षा गर्दै…",
+ "load": "लोड",
+ "refresh": "ताजा गर्नुहोस्",
+ "available": "उपलब्ध",
+ "menuFile": "फाइल",
+ "menuView": "दृश्य",
+ "menuCamera": "क्यामेरा",
+ "menuRecording": "रेकर्डिङ",
+ "menuHelp": "मद्दत",
+ "menuDetectCameras": "क्यामेरा पत्ता लगाउनुहोस्",
+ "menuConnectCameras": "क्यामेरा जोड्नुहोस्",
+ "menuCloseAllCameras": "सबै क्यामेरा बन्द गर्नुहोस्",
+ "menuOpenRecordingFolder": "रेकर्डिङ फोल्डर खोल्नुहोस्…",
+ "menuToggleSidebar": "साइडबार टगल गर्नुहोस्",
+ "menuToggleTheme": "थिम परिवर्तन गर्नुहोस्",
+ "menuToggleFullScreen": "पूर्ण स्क्रिन",
+ "menuPauseUnpause": "पज / जारी राख्नुहोस्",
+ "menuConnectApplySettings": "जोड्नुहोस् / सेटिङ लागू गर्नुहोस्",
+ "menuCloseAll": "सबै बन्द गर्नुहोस्",
+ "menuDocumentation": "कागजात",
+ "menuGitHubRepository": "GitHub भण्डार",
+ "menuReportIssue": "समस्या रिपोर्ट गर्नुहोस्…",
+ "menuAbout": "SkellyCam बारेमा",
+ "menuPlayback": "प्लेब्याक",
+ "videoPlayback": "प्लेब्याक",
+ "copyLogsToClipboard": "लगहरू क्लिपबोर्डमा कपी गर्नुहोस्",
+ "saveLogsToFile": "लगहरू फाइलमा सेभ गर्नुहोस्",
+ "copied": "कपी भयो!",
+ "timestampFromRecording": "रेकर्डिङ डेटाबाट टाइमस्ट्याम्प",
+ "menuCheckForUpdates": "Check for Updates…",
+ "updateAvailable": "Update available",
+ "updateAvailableMessage": "Version {{version}} is available",
+ "downloading": "Downloading…",
+ "downloadComplete": "Download complete",
+ "restartToUpdate": "Restart to update",
+ "checkForUpdates": "Check for Updates",
+ "upToDate": "You are up to date",
+ "updateError": "Update check failed"
+}
diff --git a/freemocap-ui-old/src/i18n/locales/nl-nederlands.json b/freemocap-ui-old/src/i18n/locales/nl-nederlands.json
new file mode 100644
index 00000000..7690289b
--- /dev/null
+++ b/freemocap-ui-old/src/i18n/locales/nl-nederlands.json
@@ -0,0 +1,258 @@
+{
+ "_meta": {
+ "locale": "nl",
+ "translationSource": "ai-generated",
+ "lastUpdated": "2026-02-23"
+ },
+ "appName": "SkellyCam",
+ "appNameDecorated": "SkellyCam 💀📸",
+ "welcomeTitle": "Welkom bij SkellyCam",
+ "welcomeSubtitle": "Neem gesynchroniseerde video's op en bekijk ze",
+ "sendAnonymousPings": "Anonieme gebruiksgegevens verzenden",
+ "footerWith": "met",
+ "footerFrom": "van de",
+ "footerOrgName": "FreeMoCap Foundation",
+ "home": "Home",
+ "cameras": "Camera's",
+ "videos": "Video's",
+ "expandSidebar": "Zijbalk uitvouwen",
+ "collapseSidebar": "Zijbalk inklappen",
+ "startRecording": "Opname starten",
+ "stopRecording": "Opname stoppen",
+ "toggleTheme": "thema wisselen",
+ "switchToDark": "Naar donkere modus",
+ "switchToLight": "Naar lichte modus",
+ "connectWebSocket": "WebSocket verbinden",
+ "disconnectWebSocket": "WebSocket verbreken",
+ "launchServer": "Server starten",
+ "stopServer": "Server stoppen",
+ "browseForExecutable": "Zoek uitvoerbaar bestand",
+ "refreshCandidates": "Kandidaten verversen",
+ "executable": "Uitvoerbaar bestand",
+ "host": "Host",
+ "port": "Poort",
+ "cameraCount_one": "{{count}} camera",
+ "cameraCount_other": "{{count}} camera's",
+ "connectedCameras": "Verbonden camera's",
+ "availableCameras": "Beschikbare camera's",
+ "noCamerasConnected": "Geen camera's verbonden",
+ "detectCameras": "Beschikbare camera's detecteren",
+ "clearCameraSettings": "Camera-instellingen wissen",
+ "copySettingsToAll": "Instellingen naar alle kopiëren",
+ "recordingTag": "Opnametag",
+ "recordingTagPlaceholder": "Optionele tag",
+ "recordingDirectory": "Opnamedirectory",
+ "recordingFolderPath": "Pad opnamemap",
+ "delayStart": "Vertraagde start",
+ "seconds": "Seconden",
+ "subfolder": "Submap",
+ "subfolderPlaceholder": "Submapnaam",
+ "baseName": "Basisnaam",
+ "increment": "Verhoging",
+ "resolution": "Resolutie",
+ "fps": "FPS",
+ "width": "Breedte",
+ "height": "Hoogte",
+ "columns": "Kolommen",
+ "auto": "Auto",
+ "manual": "Handmatig",
+ "custom": "Aangepast",
+ "current": "Huidig",
+ "recommend": "Aanbevolen",
+ "cameraRotation": "camerarotatie",
+ "selectCameraRotation": "Camerabeeldrotatie selecteren",
+ "exposureControl": "Automatische of handmatige belichtingsregeling",
+ "framerateControl": "Automatische of handmatige framerate",
+ "adjustExposure": "Belichtingstijd aanpassen",
+ "setTargetFps": "Doel-FPS voor opname instellen",
+ "recordingCaptureFps": "Opname capture-FPS",
+ "playbackSpeed": "Afspeelsnelheid",
+ "framerateTimeline": "Framerate-tijdlijn",
+ "framerateDistribution": "Framerate-distributie",
+ "timelineView": "Tijdlijnweergave",
+ "distributionView": "Distributieweergave",
+ "combinedView": "Gecombineerde weergave",
+ "min": "Min",
+ "max": "Max",
+ "mean": "Gemiddeld",
+ "median": "Mediaan",
+ "stdDevCv": "StdDev/CV",
+ "source": "Bron",
+ "selectAll": "Alles selecteren",
+ "loadSynchronizedVideos": "Gesynchroniseerde video's laden",
+ "loadSynchronizedVideosDescription": "Op deze pagina kunt u vooraf opgenomen video's laden en synchroniseren.",
+ "automaticallySynchronizeVideos": "Video's automatisch synchroniseren",
+ "extractFramesOnLoad": "Frames extraheren bij laden",
+ "generateThumbnails": "Miniaturen genereren",
+ "noVideosLoaded": "Geen video's geladen",
+ "filterVideos": "Video's filteren...",
+ "openVideo": "Video openen",
+ "openFolder": "Map openen in verkenner",
+ "videoFolderPath": "Pad videomap",
+ "jumpToStart": "Naar begin (Home)",
+ "jumpToEnd": "Naar einde (End)",
+ "loopOn": "Herhaling is aan (L om te schakelen)",
+ "loopOff": "Herhaalde weergave (L)",
+ "syncInfo": "Synchronisatie-info",
+ "syncInfoTitle": "Multi-camera synchronisatie is mogelijk niet frame-perfect",
+ "syncInfoBody": "Videoweergave in de browser garandeert geen sample-nauwkeurige synchronisatie over meerdere streams. De speler gebruikt een leider-volger strategie en corrigeert drift wanneer deze een kleine tolerantie overschrijdt, maar geringe desynchronisatie (1–2 frames) kan optreden, vooral bij hoge afspeelsnelheden of wanneer de browser onder belasting staat. Voor frame-nauwkeurige analyse kunt u de onbewerkte timestamp-CSV-bestanden gebruiken die bij elke opname zijn inbegrepen.",
+ "previousFrame": "Vorig frame (← / Shift+← voor 10)",
+ "nextFrame": "Volgend frame (→ / Shift+→ voor 10)",
+ "zoomIn": "Inzoomen",
+ "zoomOut": "Uitzoomen",
+ "resetZoom": "Zoom resetten",
+ "playbackSettings": "Afspeelinstellingen",
+ "totalRecordingSize": "Totale opnamegrootte op schijf",
+ "estimatedTime": "Geschatte tijd (frame ÷ fps)",
+ "estimatedDuration": "Geschatte duur (totaal frames ÷ fps)",
+ "estimatedFromFrameNumber": "Geschat uit framenummer × fps",
+ "frameCountPerCamera": "Frames per camera",
+ "cameraStreams": "Camerastreams in deze opname",
+ "backToRecordings": "Terug naar opnames",
+ "errorsDetected": "Fouten gedetecteerd",
+ "somethingWentWrong": "Er is iets misgegaan :(",
+ "searchLogs": "Logboeken doorzoeken...",
+ "filter": "Filter…",
+ "refreshMicrophoneList": "Microfoonlijst verversen",
+ "date": "Datum",
+ "name": "Naam",
+ "size": "Grootte",
+ "duration": "Duur",
+ "frames": "Frames",
+ "timestamp": "Tijdstempel",
+ "language": "Taal",
+ "aiTranslated": "AI-vertaling",
+ "humanTranslated": "Menselijke vertaling",
+ "humanValidated": "Menselijk gevalideerd",
+ "connectCameras": "Verbind met geselecteerde camera's",
+ "resumeStreaming": "Stream hervatten",
+ "pauseStreaming": "Stream pauzeren",
+ "closeAllCameras": "Alle camera's sluiten",
+ "framerate": "Framerate",
+ "exposure": "Belichting",
+ "fileLabel": "Bestand",
+ "timeDelta": "Tijdsdelta",
+ "pathLabel": "Pad",
+ "exceptionDetails": "Uitzonderingsdetails",
+ "stackTrace": "Stacktrace",
+ "loadingVideos": "Video's laden… ({{ready}}/{{total}} gereed)",
+ "gridColumns": "Rasterkolommen",
+ "settings": "Instellingen",
+ "appearance": "Uiterlijk",
+ "themeMode": "Thema",
+ "darkMode": "Donker",
+ "lightMode": "Licht",
+ "languageSettings": "Taal en lokalisatie",
+ "showTranslationIndicator": "Vertaalbron-indicator tonen",
+ "showTranslationIndicatorDescription": "Badge tonen bij AI-vertalingen",
+ "translationSourceLabel": "Vertaalbron",
+ "general": "Algemeen",
+ "about": "Over",
+ "version": "Versie",
+ "serverSettings": "Server",
+ "recordingSettings": "Opname-instellingen",
+ "videoLoadingSettings": "Video-laadinstellingen",
+ "connected": "Verbonden",
+ "connecting": "Verbinden…",
+ "disconnected": "Verbroken",
+ "disconnect": "Verbreken",
+ "connect": "Verbinden",
+ "off": "Uit",
+ "running": "Actief",
+ "stopped": "Gestopt",
+ "working": "Verwerken…",
+ "invalid": "Ongeldig",
+ "autoLaunch": "Automatisch starten",
+ "autoConnect": "Automatisch verbinden",
+ "runningPath": "Actief: {{path}}",
+ "noMicrophone": "Geen microfoon",
+ "audioRecordingEnabled": "Audio-opname ingeschakeld",
+ "noMicrophoneSelected": "Geen microfoon geselecteerd",
+ "recordingName": "Opnamenaam: {{name}}",
+ "startingIn": "Start over {{countdown}}...",
+ "stopping": "Stoppen...",
+ "starting": "Starten...",
+ "stopRecordingButton": "🔴 Opname stoppen",
+ "startRecordingButton": "🔴 Opname starten",
+ "camerasCount": "Camera's ({{count}})",
+ "availableCamerasCount": "Beschikbaar ({{count}})",
+ "server": "Server",
+ "display": "Weergave",
+ "rawMessage": "Onbewerkt bericht",
+ "cameraPerformanceMetrics": "Cameraprestatie-statistieken",
+ "serverLogs": "Serverlogboeken",
+ "sortBy": "Sorteren {{direction}}",
+ "waitingForCameraStreams": "Wachten op camerastreams...",
+ "loggingPaused": "Logboek gepauzeerd",
+ "noLogsToDisplay": "Geen logboeken beschikbaar",
+ "closeSettings": "Instellingen sluiten",
+ "gridSettings": "Rasterinstellingen",
+ "clickToShowLess": "Klik om minder te tonen",
+ "clickToLearnMore": "Klik voor meer informatie",
+ "samples": "samples",
+ "framerateOverTime": "Framerate over tijd",
+ "framerateFps": "Framerate (fps)",
+ "capturesFramesFromCamera": "Vangt frames van de camera.",
+ "rendersReceivedFrames": "Rendert ontvangen frames op het scherm.",
+ "displayTooltipLong": "Weergave toont de UI-renderingprestaties. Het laat zien hoe snel uw scherm frames ontvangt en rendert. Prestatieproblemen hier hebben geen invloed op de opnamekwaliteit maar kunnen uw vermogen om camera's in realtime te monitoren beïnvloeden.",
+ "statsSourceShort": "Display rendert frames, server vangt frames.",
+ "statsSourceLong": "De server is de werkelijke snelheid waarmee frames van de camera worden opgehaald/opgenomen, terwijl weergave de snelheid is waarmee ze worden ontvangen en gerenderd. SkellyCam geeft prioriteit aan serverzijde prestaties voor opnamekwaliteit, dus dat getal zou stabieler moeten blijven. Als de weergave-framerate afwijkt van de server, geeft dit aan dat uw systeembronnen belast zijn. Overweeg minder camera's te gebruiken of framerate/resolutie te verlagen.",
+ "statsCurrentShort": "Meest recente frametijd en FPS.",
+ "statsCurrentLong": "Toont de meest recente meting van hoe lang het duurt om een enkel frame te verwerken (in milliseconden) en de equivalente frames per seconde (FPS). Lagere frametijden en hogere FPS wijzen op betere prestaties.",
+ "statsMinShort": "Snelste frametijd en hoogste FPS.",
+ "statsMinLong": "Vertegenwoordigt de minimale tijd om een enkel frame te verwerken tijdens het bemonsteringsvenster. Komt overeen met de maximale FPS die uw systeem bereikte onder optimale omstandigheden.",
+ "statsMaxShort": "Langzaamste frametijd en laagste FPS.",
+ "statsMaxLong": "Vertegenwoordigt de maximale tijd om een enkel frame te verwerken tijdens het bemonsteringsvenster. Komt overeen met de minimale FPS onder slechtste omstandigheden. Incidentele pieken zijn normaal, maar consistent hoge waarden kunnen wijzen op prestatieproblemen.",
+ "statsMeanShort": "Gemiddelde frametijd en FPS over alle samples.",
+ "statsMeanLong": "Het rekenkundig gemiddelde van alle gemeten frametijden tijdens het bemonsteringsvenster en de bijbehorende FPS. Geeft een goed totaalbeeld van de prestaties maar kan worden scheefgetrokken door uitschieters.",
+ "statsMedianShort": "Mediaan van alle frametijden (50e percentiel).",
+ "statsMedianLong": "De mediaan vertegenwoordigt de middelste waarde wanneer alle frametijden van snelste naar langzaamste worden gesorteerd. In tegenstelling tot het gemiddelde wordt de mediaan niet beïnvloed door extreme uitschieters, waardoor het een stabielere indicator is van typische prestaties.",
+ "statsStdDevShort": "Meet frametijdvariabiliteit. CV% is relatief.",
+ "statsStdDevLong": "Standaarddeviatie meet de spreiding in frametijden. Lagere waarden duiden op consistentere prestaties. De variatiecoëfficiënt (CV%) drukt deze variabiliteit uit als percentage van het gemiddelde, wat het vergelijken van stabiliteit over verschillende framerates vergemakkelijkt. Lagere CV% duidt op stabielere prestaties.",
+ "aiTranslatedTooltip": "Deze vertaling is gegenereerd door AI en kan fouten bevatten. Als u deze taal spreekt, help ons verbeteren!",
+ "humanValidatedTooltip": "Deze vertaling is gecontroleerd door een menselijke vertaler.",
+ "helpTranslate": "Help SkellyCam vertalen",
+ "failedToFetch": "Ophalen mislukt",
+ "recordings": "Opnames",
+ "noRecordingsFound": "Geen opnames gevonden. Voer hierboven een pad in om handmatig te laden.",
+ "noCamerasDetected": "Geen camera's gedetecteerd",
+ "clickRefreshToScan": "Klik op vernieuwen om te zoeken naar camera's",
+ "waitingForData": "Wachten op gegevens…",
+ "load": "Laden",
+ "refresh": "Vernieuwen",
+ "available": "Beschikbaar",
+ "menuFile": "Bestand",
+ "menuView": "Beeld",
+ "menuCamera": "Camera",
+ "menuRecording": "Opname",
+ "menuHelp": "Help",
+ "menuDetectCameras": "Camera's detecteren",
+ "menuConnectCameras": "Camera's verbinden",
+ "menuCloseAllCameras": "Alle camera's sluiten",
+ "menuOpenRecordingFolder": "Opnamemap openen…",
+ "menuToggleSidebar": "Zijbalk in-/uitschakelen",
+ "menuToggleTheme": "Thema wisselen",
+ "menuToggleFullScreen": "Volledig scherm",
+ "menuPauseUnpause": "Pauzeren / Hervatten",
+ "menuConnectApplySettings": "Verbinden / Instellingen toepassen",
+ "menuCloseAll": "Alles sluiten",
+ "menuDocumentation": "Documentatie",
+ "menuGitHubRepository": "GitHub-repository",
+ "menuReportIssue": "Probleem melden…",
+ "menuAbout": "Over SkellyCam",
+ "menuPlayback": "Afspelen",
+ "videoPlayback": "Afspelen",
+ "copyLogsToClipboard": "Logboeken naar klembord kopiëren",
+ "saveLogsToFile": "Logboeken opslaan als bestand",
+ "copied": "Gekopieerd!",
+ "timestampFromRecording": "Tijdstempel uit opnamegegevens",
+ "menuCheckForUpdates": "Check for Updates…",
+ "updateAvailable": "Update available",
+ "updateAvailableMessage": "Version {{version}} is available",
+ "downloading": "Downloading…",
+ "downloadComplete": "Download complete",
+ "restartToUpdate": "Restart to update",
+ "checkForUpdates": "Check for Updates",
+ "upToDate": "You are up to date",
+ "updateError": "Update check failed"
+}
diff --git a/freemocap-ui-old/src/i18n/locales/pl-polski.json b/freemocap-ui-old/src/i18n/locales/pl-polski.json
new file mode 100644
index 00000000..c03a9e84
--- /dev/null
+++ b/freemocap-ui-old/src/i18n/locales/pl-polski.json
@@ -0,0 +1,258 @@
+{
+ "_meta": {
+ "locale": "pl",
+ "translationSource": "ai-generated",
+ "lastUpdated": "2026-02-23"
+ },
+ "appName": "SkellyCam",
+ "appNameDecorated": "SkellyCam 💀📸",
+ "welcomeTitle": "Witamy w SkellyCam",
+ "welcomeSubtitle": "Nagrywaj i przeglądaj zsynchronizowane wideo",
+ "sendAnonymousPings": "Wysyłaj anonimowe dane użycia",
+ "footerWith": "z",
+ "footerFrom": "od",
+ "footerOrgName": "FreeMoCap Foundation",
+ "home": "Strona główna",
+ "cameras": "Kamery",
+ "videos": "Wideo",
+ "expandSidebar": "Rozwiń pasek boczny",
+ "collapseSidebar": "Zwiń pasek boczny",
+ "startRecording": "Rozpocznij nagrywanie",
+ "stopRecording": "Zatrzymaj nagrywanie",
+ "toggleTheme": "przełącz motyw",
+ "switchToDark": "Przełącz na tryb ciemny",
+ "switchToLight": "Przełącz na tryb jasny",
+ "connectWebSocket": "Połącz WebSocket",
+ "disconnectWebSocket": "Rozłącz WebSocket",
+ "launchServer": "Uruchom serwer",
+ "stopServer": "Zatrzymaj serwer",
+ "browseForExecutable": "Przeglądaj w poszukiwaniu pliku",
+ "refreshCandidates": "Odśwież kandydatów",
+ "executable": "Plik wykonywalny",
+ "host": "Host",
+ "port": "Port",
+ "cameraCount_one": "{{count}} kamera",
+ "cameraCount_other": "{{count}} kamer",
+ "connectedCameras": "Podłączone kamery",
+ "availableCameras": "Dostępne kamery",
+ "noCamerasConnected": "Brak podłączonych kamer",
+ "detectCameras": "Wykryj dostępne kamery",
+ "clearCameraSettings": "Wyczyść ustawienia kamer",
+ "copySettingsToAll": "Kopiuj ustawienia do wszystkich",
+ "recordingTag": "Tag nagrania",
+ "recordingTagPlaceholder": "Opcjonalny tag",
+ "recordingDirectory": "Katalog nagrań",
+ "recordingFolderPath": "Ścieżka folderu nagrań",
+ "delayStart": "Opóźniony start",
+ "seconds": "Sekundy",
+ "subfolder": "Podfolder",
+ "subfolderPlaceholder": "Nazwa podfolderu",
+ "baseName": "Nazwa bazowa",
+ "increment": "Inkrement",
+ "resolution": "Rozdzielczość",
+ "fps": "FPS",
+ "width": "Szerokość",
+ "height": "Wysokość",
+ "columns": "Kolumny",
+ "auto": "Auto",
+ "manual": "Ręczny",
+ "custom": "Niestandardowy",
+ "current": "Bieżący",
+ "recommend": "Zalecane",
+ "cameraRotation": "rotacja kamery",
+ "selectCameraRotation": "Wybierz obrót obrazu kamery",
+ "exposureControl": "Automatyczna lub ręczna kontrola ekspozycji",
+ "framerateControl": "Automatyczna lub ręczna kontrola klatek",
+ "adjustExposure": "Dostosuj czas ekspozycji",
+ "setTargetFps": "Ustaw docelowe FPS dla przechwytywania",
+ "recordingCaptureFps": "FPS przechwytywania",
+ "playbackSpeed": "Prędkość odtwarzania",
+ "framerateTimeline": "Oś czasu klatek",
+ "framerateDistribution": "Rozkład klatek",
+ "timelineView": "Widok osi czasu",
+ "distributionView": "Widok rozkładu",
+ "combinedView": "Widok połączony",
+ "min": "Min",
+ "max": "Maks",
+ "mean": "Średnia",
+ "median": "Mediana",
+ "stdDevCv": "OdchSt/CV",
+ "source": "Źródło",
+ "selectAll": "Zaznacz wszystkie",
+ "loadSynchronizedVideos": "Załaduj zsynchronizowane wideo",
+ "loadSynchronizedVideosDescription": "Ta strona pozwala załadować i zsynchronizować wcześniej nagrane wideo.",
+ "automaticallySynchronizeVideos": "Automatycznie synchronizuj wideo",
+ "extractFramesOnLoad": "Wyodrębnij klatki przy ładowaniu",
+ "generateThumbnails": "Generuj miniatury",
+ "noVideosLoaded": "Brak załadowanych wideo",
+ "filterVideos": "Filtruj wideo...",
+ "openVideo": "Otwórz wideo",
+ "openFolder": "Otwórz folder w eksploratorze",
+ "videoFolderPath": "Ścieżka folderu wideo",
+ "jumpToStart": "Przejdź na początek (Home)",
+ "jumpToEnd": "Przejdź na koniec (End)",
+ "loopOn": "Pętla jest włączona (L aby przełączyć)",
+ "loopOff": "Odtwarzanie w pętli (L)",
+ "syncInfo": "Informacje o synchronizacji",
+ "syncInfoTitle": "Synchronizacja wielu kamer może nie być idealna na poziomie klatek",
+ "syncInfoBody": "Odtwarzanie wideo w przeglądarce nie gwarantuje dokładnej synchronizacji próbek w wielu strumieniach. Odtwarzacz stosuje strategię lider-naśladowca i koryguje dryft, gdy przekracza małą tolerancję, ale niewielka desynchronizacja (1–2 klatki) może wystąpić, szczególnie przy dużych prędkościach odtwarzania lub gdy przeglądarka jest obciążona. Do analizy dokładnej na poziomie klatek użyj surowych plików CSV ze znacznikami czasu dołączonych do każdego nagrania.",
+ "previousFrame": "Poprzednia klatka (← / Shift+← po 10)",
+ "nextFrame": "Następna klatka (→ / Shift+→ po 10)",
+ "zoomIn": "Powiększ",
+ "zoomOut": "Pomniejsz",
+ "resetZoom": "Resetuj powiększenie",
+ "playbackSettings": "Ustawienia odtwarzania",
+ "totalRecordingSize": "Całkowity rozmiar nagrania na dysku",
+ "estimatedTime": "Szacowany czas (klatka ÷ fps)",
+ "estimatedDuration": "Szacowany czas (klatki ÷ fps)",
+ "estimatedFromFrameNumber": "Oszacowane z numeru klatki × fps",
+ "frameCountPerCamera": "Liczba klatek na kamerę",
+ "cameraStreams": "Strumienie kamer w tym nagraniu",
+ "backToRecordings": "Wróć do nagrań",
+ "errorsDetected": "Wykryto błędy",
+ "somethingWentWrong": "Coś poszło nie tak :(",
+ "searchLogs": "Szukaj w logach...",
+ "filter": "Filtruj…",
+ "refreshMicrophoneList": "Odśwież listę mikrofonów",
+ "date": "Data",
+ "name": "Nazwa",
+ "size": "Rozmiar",
+ "duration": "Czas trwania",
+ "frames": "Klatki",
+ "timestamp": "Znacznik czasu",
+ "language": "Język",
+ "aiTranslated": "Tłumaczenie AI",
+ "humanTranslated": "Tłumaczenie ludzkie",
+ "humanValidated": "Zweryfikowane przez człowieka",
+ "connectCameras": "Połącz z wybranymi kamerami",
+ "resumeStreaming": "Wznów strumieniowanie",
+ "pauseStreaming": "Wstrzymaj strumieniowanie",
+ "closeAllCameras": "Zamknij wszystkie kamery",
+ "framerate": "Klatki na sekundę",
+ "exposure": "Ekspozycja",
+ "fileLabel": "Plik",
+ "timeDelta": "Delta czasu",
+ "pathLabel": "Ścieżka",
+ "exceptionDetails": "Szczegóły wyjątku",
+ "stackTrace": "Ślad stosu",
+ "loadingVideos": "Ładowanie wideo… ({{ready}}/{{total}} gotowe)",
+ "gridColumns": "Kolumny siatki",
+ "settings": "Ustawienia",
+ "appearance": "Wygląd",
+ "themeMode": "Motyw",
+ "darkMode": "Ciemny",
+ "lightMode": "Jasny",
+ "languageSettings": "Język i lokalizacja",
+ "showTranslationIndicator": "Pokaż wskaźnik źródła tłumaczenia",
+ "showTranslationIndicatorDescription": "Pokaż odznakę przy tłumaczeniach AI",
+ "translationSourceLabel": "Źródło tłumaczenia",
+ "general": "Ogólne",
+ "about": "O aplikacji",
+ "version": "Wersja",
+ "serverSettings": "Serwer",
+ "recordingSettings": "Ustawienia nagrywania",
+ "videoLoadingSettings": "Ustawienia ładowania wideo",
+ "connected": "Połączony",
+ "connecting": "Łączenie…",
+ "disconnected": "Rozłączony",
+ "disconnect": "Rozłącz",
+ "connect": "Połącz",
+ "off": "Wyłączony",
+ "running": "Uruchomiony",
+ "stopped": "Zatrzymany",
+ "working": "Przetwarzanie…",
+ "invalid": "Nieprawidłowy",
+ "autoLaunch": "Automatyczny start",
+ "autoConnect": "Automatyczne łączenie",
+ "runningPath": "Uruchomiony: {{path}}",
+ "noMicrophone": "Brak mikrofonu",
+ "audioRecordingEnabled": "Nagrywanie dźwięku włączone",
+ "noMicrophoneSelected": "Nie wybrano mikrofonu",
+ "recordingName": "Nazwa nagrania: {{name}}",
+ "startingIn": "Start za {{countdown}}...",
+ "stopping": "Zatrzymywanie...",
+ "starting": "Uruchamianie...",
+ "stopRecordingButton": "🔴 Zatrzymaj nagrywanie",
+ "startRecordingButton": "🔴 Rozpocznij nagrywanie",
+ "camerasCount": "Kamery ({{count}})",
+ "availableCamerasCount": "Dostępne ({{count}})",
+ "server": "Serwer",
+ "display": "Wyświetlanie",
+ "rawMessage": "Surowa wiadomość",
+ "cameraPerformanceMetrics": "Metryki wydajności kamer",
+ "serverLogs": "Logi serwera",
+ "sortBy": "Sortuj {{direction}}",
+ "waitingForCameraStreams": "Oczekiwanie na strumienie kamer...",
+ "loggingPaused": "Logowanie wstrzymane",
+ "noLogsToDisplay": "Brak logów do wyświetlenia",
+ "closeSettings": "Zamknij ustawienia",
+ "gridSettings": "Ustawienia siatki",
+ "clickToShowLess": "Kliknij, aby zwinąć",
+ "clickToLearnMore": "Kliknij, aby dowiedzieć się więcej",
+ "samples": "próbek",
+ "framerateOverTime": "Klatki w czasie",
+ "framerateFps": "Klatki/s (fps)",
+ "capturesFramesFromCamera": "Przechwytuje klatki z kamery.",
+ "rendersReceivedFrames": "Renderuje otrzymane klatki na ekranie.",
+ "displayTooltipLong": "Wyświetlanie reprezentuje wydajność renderowania interfejsu użytkownika. Pokazuje, jak szybko ekran odbiera i renderuje klatki. Problemy z wydajnością tutaj nie wpłyną na jakość nagrania, ale mogą wpłynąć na zdolność monitorowania kamer w czasie rzeczywistym.",
+ "statsSourceShort": "Wyświetlacz renderuje klatki, serwer je przechwytuje.",
+ "statsSourceLong": "Serwer to rzeczywista szybkość, z jaką klatki są pobierane/nagrywane z kamery, podczas gdy wyświetlanie to szybkość ich odbierania i renderowania. SkellyCam priorytetowo traktuje wydajność po stronie serwera dla jakości nagrywania, więc ta liczba powinna być bardziej stabilna. Jeśli częstotliwość klatek wyświetlania odbiega od serwera, oznacza to, że zasoby systemu są obciążone. Rozważ użycie mniejszej liczby kamer lub zmniejszenie częstotliwości klatek/rozdzielczości.",
+ "statsCurrentShort": "Najnowszy czas klatki i FPS.",
+ "statsCurrentLong": "Pokazuje najnowszy pomiar czasu przetwarzania jednej klatki (w milisekundach) i odpowiadającą liczbę klatek na sekundę (FPS). Niższe czasy klatek i wyższe FPS wskazują na lepszą wydajność.",
+ "statsMinShort": "Najkrótszy czas klatki i najwyższe FPS.",
+ "statsMinLong": "Reprezentuje minimalny czas przetworzenia jednej klatki w oknie próbkowania. Odpowiada maksymalnemu FPS osiągniętemu przez system w optymalnych warunkach.",
+ "statsMaxShort": "Najdłuższy czas klatki i najniższe FPS.",
+ "statsMaxLong": "Reprezentuje maksymalny czas przetworzenia jednej klatki w oknie próbkowania. Odpowiada minimalnemu FPS w najgorszych warunkach. Sporadyczne skoki są normalne, ale stale wysokie wartości mogą wskazywać na problemy z wydajnością.",
+ "statsMeanShort": "Średni czas klatki i FPS ze wszystkich próbek.",
+ "statsMeanLong": "Średnia arytmetyczna wszystkich zmierzonych czasów klatek w oknie próbkowania i odpowiadające FPS. Daje dobry ogólny obraz wydajności, ale może być zniekształcona przez wartości odstające.",
+ "statsMedianShort": "Mediana wszystkich czasów klatek (50. percentyl).",
+ "statsMedianLong": "Mediana reprezentuje środkową wartość, gdy wszystkie czasy klatek są posortowane od najszybszego do najwolniejszego. W przeciwieństwie do średniej, mediana nie jest podatna na ekstremalne wartości odstające, co czyni ją bardziej stabilnym wskaźnikiem typowej wydajności.",
+ "statsStdDevShort": "Mierzy zmienność czasu klatek. CV% to względna.",
+ "statsStdDevLong": "Odchylenie standardowe mierzy rozrzut czasów klatek. Niższe wartości wskazują na bardziej spójną wydajność. Współczynnik zmienności (CV%) wyraża tę zmienność jako procent średniej, ułatwiając porównanie stabilności przy różnych częstotliwościach klatek. Niższe CV% oznacza bardziej stabilną wydajność.",
+ "aiTranslatedTooltip": "To tłumaczenie zostało wygenerowane przez AI i może zawierać błędy. Jeśli mówisz w tym języku, pomóż je ulepszyć!",
+ "humanValidatedTooltip": "To tłumaczenie zostało zweryfikowane przez tłumacza.",
+ "helpTranslate": "Pomóż przetłumaczyć SkellyCam",
+ "failedToFetch": "Nie udało się pobrać",
+ "recordings": "Nagrania",
+ "noRecordingsFound": "Nie znaleziono nagrań. Wprowadź ścieżkę powyżej, aby załadować ręcznie.",
+ "noCamerasDetected": "Nie wykryto kamer",
+ "clickRefreshToScan": "Kliknij odśwież, aby wyszukać dostępne kamery",
+ "waitingForData": "Oczekiwanie na dane…",
+ "load": "Załaduj",
+ "refresh": "Odśwież",
+ "available": "Dostępna",
+ "menuFile": "Plik",
+ "menuView": "Widok",
+ "menuCamera": "Kamera",
+ "menuRecording": "Nagrywanie",
+ "menuHelp": "Pomoc",
+ "menuDetectCameras": "Wykryj kamery",
+ "menuConnectCameras": "Połącz kamery",
+ "menuCloseAllCameras": "Zamknij wszystkie kamery",
+ "menuOpenRecordingFolder": "Otwórz folder nagrań…",
+ "menuToggleSidebar": "Pokaż/ukryj panel boczny",
+ "menuToggleTheme": "Zmień motyw",
+ "menuToggleFullScreen": "Pełny ekran",
+ "menuPauseUnpause": "Pauza / Wznów",
+ "menuConnectApplySettings": "Połącz / Zastosuj ustawienia",
+ "menuCloseAll": "Zamknij wszystko",
+ "menuDocumentation": "Dokumentacja",
+ "menuGitHubRepository": "Repozytorium GitHub",
+ "menuReportIssue": "Zgłoś problem…",
+ "menuAbout": "O SkellyCam",
+ "menuPlayback": "Odtwarzanie",
+ "videoPlayback": "Odtwarzanie",
+ "copyLogsToClipboard": "Kopiuj logi do schowka",
+ "saveLogsToFile": "Zapisz logi do pliku",
+ "copied": "Skopiowano!",
+ "timestampFromRecording": "Znacznik czasu z danych nagrania",
+ "menuCheckForUpdates": "Check for Updates…",
+ "updateAvailable": "Update available",
+ "updateAvailableMessage": "Version {{version}} is available",
+ "downloading": "Downloading…",
+ "downloadComplete": "Download complete",
+ "restartToUpdate": "Restart to update",
+ "checkForUpdates": "Check for Updates",
+ "upToDate": "You are up to date",
+ "updateError": "Update check failed"
+}
diff --git a/freemocap-ui-old/src/i18n/locales/pt-BR-portugues-brasil.json b/freemocap-ui-old/src/i18n/locales/pt-BR-portugues-brasil.json
new file mode 100644
index 00000000..5c2fb160
--- /dev/null
+++ b/freemocap-ui-old/src/i18n/locales/pt-BR-portugues-brasil.json
@@ -0,0 +1,258 @@
+{
+ "_meta": {
+ "locale": "pt-BR",
+ "translationSource": "ai-generated",
+ "lastUpdated": "2026-02-23"
+ },
+ "appName": "SkellyCam",
+ "appNameDecorated": "SkellyCam 💀📸",
+ "welcomeTitle": "Bem-vindo ao SkellyCam",
+ "welcomeSubtitle": "Grave e visualize vídeos sincronizados",
+ "sendAnonymousPings": "Enviar dados de uso anônimos",
+ "footerWith": "com",
+ "footerFrom": "da",
+ "footerOrgName": "FreeMoCap Foundation",
+ "home": "Início",
+ "cameras": "Câmeras",
+ "videos": "Vídeos",
+ "expandSidebar": "Expandir barra lateral",
+ "collapseSidebar": "Recolher barra lateral",
+ "startRecording": "Iniciar gravação",
+ "stopRecording": "Parar gravação",
+ "toggleTheme": "alternar tema",
+ "switchToDark": "Mudar para modo escuro",
+ "switchToLight": "Mudar para modo claro",
+ "connectWebSocket": "Conectar WebSocket",
+ "disconnectWebSocket": "Desconectar WebSocket",
+ "launchServer": "Iniciar servidor",
+ "stopServer": "Parar servidor",
+ "browseForExecutable": "Procurar executável",
+ "refreshCandidates": "Atualizar candidatos",
+ "executable": "Executável",
+ "host": "Host",
+ "port": "Porta",
+ "cameraCount_one": "{{count}} câmera",
+ "cameraCount_other": "{{count}} câmeras",
+ "connectedCameras": "Câmeras conectadas",
+ "availableCameras": "Câmeras disponíveis",
+ "noCamerasConnected": "Nenhuma câmera conectada",
+ "detectCameras": "Detectar câmeras disponíveis",
+ "clearCameraSettings": "Limpar configurações de câmera",
+ "copySettingsToAll": "Copiar configurações para todas",
+ "recordingTag": "Tag de gravação",
+ "recordingTagPlaceholder": "Tag opcional",
+ "recordingDirectory": "Diretório de gravação",
+ "recordingFolderPath": "Caminho da pasta de gravação",
+ "delayStart": "Início atrasado",
+ "seconds": "Segundos",
+ "subfolder": "Subpasta",
+ "subfolderPlaceholder": "Nome da subpasta",
+ "baseName": "Nome base",
+ "increment": "Incremento",
+ "resolution": "Resolução",
+ "fps": "FPS",
+ "width": "Largura",
+ "height": "Altura",
+ "columns": "Colunas",
+ "auto": "Automático",
+ "manual": "Manual",
+ "custom": "Personalizado",
+ "current": "Atual",
+ "recommend": "Recomendado",
+ "cameraRotation": "rotação da câmera",
+ "selectCameraRotation": "Selecionar rotação da imagem",
+ "exposureControl": "Controle de exposição automático ou manual",
+ "framerateControl": "Controle de taxa de quadros automático ou manual",
+ "adjustExposure": "Ajustar tempo de exposição",
+ "setTargetFps": "Definir FPS alvo para captura",
+ "recordingCaptureFps": "FPS de captura",
+ "playbackSpeed": "Velocidade de reprodução",
+ "framerateTimeline": "Linha do tempo da taxa de quadros",
+ "framerateDistribution": "Distribuição da taxa de quadros",
+ "timelineView": "Vista de linha do tempo",
+ "distributionView": "Vista de distribuição",
+ "combinedView": "Vista combinada",
+ "min": "Mín",
+ "max": "Máx",
+ "mean": "Média",
+ "median": "Mediana",
+ "stdDevCv": "DesvPad/CV",
+ "source": "Fonte",
+ "selectAll": "Selecionar tudo",
+ "loadSynchronizedVideos": "Carregar vídeos sincronizados",
+ "loadSynchronizedVideosDescription": "Esta página permite carregar e sincronizar vídeos pré-gravados.",
+ "automaticallySynchronizeVideos": "Sincronizar vídeos automaticamente",
+ "extractFramesOnLoad": "Extrair quadros ao carregar",
+ "generateThumbnails": "Gerar miniaturas",
+ "noVideosLoaded": "Nenhum vídeo carregado",
+ "filterVideos": "Filtrar vídeos...",
+ "openVideo": "Abrir vídeo",
+ "openFolder": "Abrir pasta no explorador",
+ "videoFolderPath": "Caminho da pasta de vídeo",
+ "jumpToStart": "Ir ao início (Home)",
+ "jumpToEnd": "Ir ao final (End)",
+ "loopOn": "Repetição ativada (L para alternar)",
+ "loopOff": "Reprodução em loop (L)",
+ "syncInfo": "Info de sincronização",
+ "syncInfoTitle": "A sincronização multicâmera pode não ser perfeita no nível de quadro",
+ "syncInfoBody": "A reprodução de vídeo no navegador não garante sincronização precisa por amostra em múltiplos fluxos. O player usa uma estratégia líder-seguidor e corrige o desvio quando ele excede uma pequena tolerância, mas uma leve dessincronização (1–2 quadros) pode ocorrer, especialmente em velocidades de reprodução altas ou quando o navegador está sob carga. Para análise precisa por quadro, use os arquivos CSV de timestamp brutos incluídos em cada gravação.",
+ "previousFrame": "Quadro anterior (← / Shift+← para 10)",
+ "nextFrame": "Próximo quadro (→ / Shift+→ para 10)",
+ "zoomIn": "Ampliar",
+ "zoomOut": "Reduzir",
+ "resetZoom": "Redefinir zoom",
+ "playbackSettings": "Configurações de reprodução",
+ "totalRecordingSize": "Tamanho total da gravação no disco",
+ "estimatedTime": "Tempo estimado (quadro ÷ fps)",
+ "estimatedDuration": "Duração estimada (quadros totais ÷ fps)",
+ "estimatedFromFrameNumber": "Estimado do número do quadro × fps",
+ "frameCountPerCamera": "Contagem de quadros por câmera",
+ "cameraStreams": "Fluxos de câmera nesta gravação",
+ "backToRecordings": "Voltar às gravações",
+ "errorsDetected": "Erros detectados",
+ "somethingWentWrong": "Algo deu errado :(",
+ "searchLogs": "Pesquisar logs...",
+ "filter": "Filtrar…",
+ "refreshMicrophoneList": "Atualizar lista de microfones",
+ "date": "Data",
+ "name": "Nome",
+ "size": "Tamanho",
+ "duration": "Duração",
+ "frames": "Quadros",
+ "timestamp": "Marca temporal",
+ "language": "Idioma",
+ "aiTranslated": "Tradução IA",
+ "humanTranslated": "Tradução humana",
+ "humanValidated": "Validado por humano",
+ "connectCameras": "Conectar às câmeras selecionadas",
+ "resumeStreaming": "Retomar streaming",
+ "pauseStreaming": "Pausar streaming",
+ "closeAllCameras": "Fechar todas as câmeras",
+ "framerate": "Taxa de quadros",
+ "exposure": "Exposição",
+ "fileLabel": "Arquivo",
+ "timeDelta": "Delta de tempo",
+ "pathLabel": "Caminho",
+ "exceptionDetails": "Detalhes da exceção",
+ "stackTrace": "Rastreamento de pilha",
+ "loadingVideos": "Carregando vídeos… ({{ready}}/{{total}} prontos)",
+ "gridColumns": "Colunas da grade",
+ "settings": "Configurações",
+ "appearance": "Aparência",
+ "themeMode": "Tema",
+ "darkMode": "Escuro",
+ "lightMode": "Claro",
+ "languageSettings": "Idioma e localização",
+ "showTranslationIndicator": "Mostrar indicador de fonte de tradução",
+ "showTranslationIndicatorDescription": "Exibir um selo ao usar traduções geradas por IA",
+ "translationSourceLabel": "Fonte da tradução",
+ "general": "Geral",
+ "about": "Sobre",
+ "version": "Versão",
+ "serverSettings": "Servidor",
+ "recordingSettings": "Configurações de gravação",
+ "videoLoadingSettings": "Configurações de carregamento de vídeo",
+ "connected": "Conectado",
+ "connecting": "Conectando…",
+ "disconnected": "Desconectado",
+ "disconnect": "Desconectar",
+ "connect": "Conectar",
+ "off": "Desligado",
+ "running": "Em execução",
+ "stopped": "Parado",
+ "working": "Processando…",
+ "invalid": "Inválido",
+ "autoLaunch": "Início automático",
+ "autoConnect": "Conexão automática",
+ "runningPath": "Em execução: {{path}}",
+ "noMicrophone": "Sem microfone",
+ "audioRecordingEnabled": "Gravação de áudio ativada",
+ "noMicrophoneSelected": "Nenhum microfone selecionado",
+ "recordingName": "Nome da gravação: {{name}}",
+ "startingIn": "Iniciando em {{countdown}}...",
+ "stopping": "Parando...",
+ "starting": "Iniciando...",
+ "stopRecordingButton": "🔴 Parar gravação",
+ "startRecordingButton": "🔴 Iniciar gravação",
+ "camerasCount": "Câmeras ({{count}})",
+ "availableCamerasCount": "Disponíveis ({{count}})",
+ "server": "Servidor",
+ "display": "Exibição",
+ "rawMessage": "Mensagem bruta",
+ "cameraPerformanceMetrics": "Métricas de desempenho da câmera",
+ "serverLogs": "Logs do servidor",
+ "sortBy": "Ordenar {{direction}}",
+ "waitingForCameraStreams": "Aguardando fluxos de câmera...",
+ "loggingPaused": "Registro pausado",
+ "noLogsToDisplay": "Nenhum registro para exibir",
+ "closeSettings": "Fechar configurações",
+ "gridSettings": "Configurações da grade",
+ "clickToShowLess": "Clique para ver menos",
+ "clickToLearnMore": "Clique para saber mais",
+ "samples": "amostras",
+ "framerateOverTime": "Taxa de quadros ao longo do tempo",
+ "framerateFps": "Taxa de quadros (fps)",
+ "capturesFramesFromCamera": "Captura quadros da câmera.",
+ "rendersReceivedFrames": "Renderiza quadros recebidos na tela.",
+ "displayTooltipLong": "A exibição representa o desempenho de renderização da interface do usuário. Mostra a rapidez com que seu display recebe e renderiza quadros. Problemas de desempenho aqui não afetarão a qualidade da gravação, mas podem impactar sua capacidade de monitorar câmeras em tempo real.",
+ "statsSourceShort": "Exibição renderiza quadros, servidor captura quadros.",
+ "statsSourceLong": "O servidor é a taxa real em que os quadros são puxados/gravados da câmera, enquanto a exibição é a taxa em que são recebidos e renderizados. O SkellyCam prioriza o desempenho do lado do servidor para qualidade de gravação, então esse número deve permanecer mais estável. Se o framerate de exibição divergir do servidor, isso indica que os recursos do sistema estão sobrecarregados. Considere usar menos câmeras ou diminuir o framerate/resolução.",
+ "statsCurrentShort": "Tempo de quadro e FPS mais recentes.",
+ "statsCurrentLong": "Mostra a medição mais recente de quanto tempo leva para processar um único quadro (em milissegundos) e os quadros por segundo (FPS) equivalentes. Tempos de quadro menores e FPS maiores indicam melhor desempenho.",
+ "statsMinShort": "Tempo de quadro mais rápido e FPS mais alto.",
+ "statsMinLong": "Representa o tempo mínimo para processar um único quadro durante a janela de amostragem. Corresponde ao FPS máximo que seu sistema alcançou em condições ideais.",
+ "statsMaxShort": "Tempo de quadro mais lento e FPS mais baixo.",
+ "statsMaxLong": "Representa o tempo máximo para processar um único quadro durante a janela de amostragem. Corresponde ao FPS mínimo nas piores condições. Picos ocasionais são normais, mas valores consistentemente altos podem indicar problemas de desempenho.",
+ "statsMeanShort": "Tempo médio de quadro e FPS em todas as amostras.",
+ "statsMeanLong": "A média aritmética de todos os tempos de quadro medidos durante a janela de amostragem e os FPS correspondentes. Fornece uma boa visão geral do desempenho, mas pode ser distorcida por valores atípicos.",
+ "statsMedianShort": "Valor mediano de todos os tempos de quadro (percentil 50).",
+ "statsMedianLong": "A mediana representa o valor central quando todos os tempos de quadro são ordenados do mais rápido ao mais lento. Diferente da média, a mediana não é afetada por valores atípicos extremos, tornando-a um indicador mais estável do desempenho típico.",
+ "statsStdDevShort": "Mede a variabilidade do tempo de quadro. CV% é relativa.",
+ "statsStdDevLong": "O desvio padrão mede a variação nos tempos de quadro. Valores menores indicam desempenho mais consistente. O Coeficiente de Variação (CV%) expressa essa variabilidade como porcentagem da média, facilitando a comparação de estabilidade entre diferentes taxas de quadro. CV% menor indica desempenho mais estável.",
+ "aiTranslatedTooltip": "Esta tradução foi gerada por IA e pode conter erros. Se você fala este idioma, ajude a melhorá-la!",
+ "humanValidatedTooltip": "Esta tradução foi verificada por um tradutor humano.",
+ "helpTranslate": "Ajude a traduzir o SkellyCam",
+ "failedToFetch": "Falha ao buscar",
+ "recordings": "Gravações",
+ "noRecordingsFound": "Nenhuma gravação encontrada. Insira um caminho acima para carregar manualmente.",
+ "noCamerasDetected": "Nenhuma câmera detectada",
+ "clickRefreshToScan": "Clique em atualizar para buscar câmeras disponíveis",
+ "waitingForData": "Aguardando dados…",
+ "load": "Carregar",
+ "refresh": "Atualizar",
+ "available": "Disponível",
+ "menuFile": "Arquivo",
+ "menuView": "Visualizar",
+ "menuCamera": "Câmera",
+ "menuRecording": "Gravação",
+ "menuHelp": "Ajuda",
+ "menuDetectCameras": "Detectar câmeras",
+ "menuConnectCameras": "Conectar câmeras",
+ "menuCloseAllCameras": "Fechar todas as câmeras",
+ "menuOpenRecordingFolder": "Abrir pasta de gravação…",
+ "menuToggleSidebar": "Alternar barra lateral",
+ "menuToggleTheme": "Alternar tema",
+ "menuToggleFullScreen": "Tela cheia",
+ "menuPauseUnpause": "Pausar / Retomar",
+ "menuConnectApplySettings": "Conectar / Aplicar configurações",
+ "menuCloseAll": "Fechar tudo",
+ "menuDocumentation": "Documentação",
+ "menuGitHubRepository": "Repositório GitHub",
+ "menuReportIssue": "Reportar um problema…",
+ "menuAbout": "Sobre o SkellyCam",
+ "menuPlayback": "Reprodução",
+ "videoPlayback": "Reprodução",
+ "copyLogsToClipboard": "Copiar logs para a área de transferência",
+ "saveLogsToFile": "Salvar logs em arquivo",
+ "copied": "Copiado!",
+ "timestampFromRecording": "Carimbo de tempo dos dados de gravação",
+ "menuCheckForUpdates": "Check for Updates…",
+ "updateAvailable": "Update available",
+ "updateAvailableMessage": "Version {{version}} is available",
+ "downloading": "Downloading…",
+ "downloadComplete": "Download complete",
+ "restartToUpdate": "Restart to update",
+ "checkForUpdates": "Check for Updates",
+ "upToDate": "You are up to date",
+ "updateError": "Update check failed"
+}
diff --git a/freemocap-ui-old/src/i18n/locales/ro-romana.json b/freemocap-ui-old/src/i18n/locales/ro-romana.json
new file mode 100644
index 00000000..56433878
--- /dev/null
+++ b/freemocap-ui-old/src/i18n/locales/ro-romana.json
@@ -0,0 +1,258 @@
+{
+ "_meta": {
+ "locale": "ro",
+ "translationSource": "ai-generated",
+ "lastUpdated": "2026-02-23"
+ },
+ "appName": "SkellyCam",
+ "appNameDecorated": "SkellyCam 💀📸",
+ "welcomeTitle": "Bun venit la SkellyCam",
+ "welcomeSubtitle": "Înregistrează și Vizualizează Videoclipuri Sincronizate",
+ "sendAnonymousPings": "Trimite ping-uri anonime de utilizare",
+ "footerWith": "cu",
+ "footerFrom": "de la",
+ "footerOrgName": "FreeMoCap Foundation",
+ "home": "Acasă",
+ "cameras": "Camere",
+ "videos": "Videoclipuri",
+ "expandSidebar": "Extinde bara laterală",
+ "collapseSidebar": "Restrânge bara laterală",
+ "startRecording": "Începe Înregistrarea",
+ "stopRecording": "Oprește Înregistrarea",
+ "toggleTheme": "comută tema",
+ "switchToDark": "Comută la modul întunecat",
+ "switchToLight": "Comută la modul luminos",
+ "connectWebSocket": "Conectează WebSocket",
+ "disconnectWebSocket": "Deconectează WebSocket",
+ "launchServer": "Lansează Serverul",
+ "stopServer": "Oprește Serverul",
+ "browseForExecutable": "Caută fișier executabil",
+ "refreshCandidates": "Reîmprospătează candidații",
+ "executable": "Executabil",
+ "host": "Gazdă",
+ "port": "Port",
+ "cameraCount_one": "{{count}} cameră",
+ "cameraCount_other": "{{count}} camere",
+ "connectedCameras": "Camere Conectate",
+ "availableCameras": "Camere Disponibile",
+ "noCamerasConnected": "Nicio cameră conectată",
+ "detectCameras": "Detectează camerele disponibile",
+ "clearCameraSettings": "Șterge setările camerei salvate din memorie",
+ "copySettingsToAll": "Copiază setările la toate camerele",
+ "recordingTag": "Etichetă Înregistrare",
+ "recordingTagPlaceholder": "Etichetă opțională",
+ "recordingDirectory": "Director Înregistrare",
+ "recordingFolderPath": "Calea folderului de înregistrare",
+ "delayStart": "Întârziere Start",
+ "seconds": "Secunde",
+ "subfolder": "Subfolder",
+ "subfolderPlaceholder": "Numele Subfolderului",
+ "baseName": "Nume de Bază",
+ "increment": "Increment",
+ "resolution": "Rezoluție",
+ "fps": "FPS",
+ "width": "Lățime",
+ "height": "Înălțime",
+ "columns": "Coloane",
+ "auto": "Auto",
+ "manual": "Manual",
+ "custom": "Personalizat",
+ "current": "Curent",
+ "recommend": "Recomandat",
+ "cameraRotation": "rotația camerei",
+ "selectCameraRotation": "Selectează rotația imaginii camerei",
+ "exposureControl": "Alege între controlul automat sau manual al expunerii",
+ "framerateControl": "Alege între controlul automat sau manual al ratei de cadre",
+ "adjustExposure": "Ajustează timpul de expunere, ex. cv2.VideoCapture.set(cv2.CAP_PROP_EXPOSURE, value)",
+ "setTargetFps": "Setează cadre pe secundă (FPS) țintă pentru captura camerei",
+ "recordingCaptureFps": "Rata de cadre a capturii de înregistrare",
+ "playbackSpeed": "Viteza de redare (nu afectează fps-ul de înregistrare)",
+ "framerateTimeline": "Cronologie Rată de Cadre",
+ "framerateDistribution": "Distribuția Ratei de Cadre",
+ "timelineView": "Vizualizare Cronologie",
+ "distributionView": "Vizualizare Distribuție",
+ "combinedView": "Vizualizare Combinată",
+ "min": "Min",
+ "max": "Max",
+ "mean": "Medie",
+ "median": "Mediană",
+ "stdDevCv": "StdDev/CV",
+ "source": "Sursă",
+ "selectAll": "Selectează Tot",
+ "loadSynchronizedVideos": "Încarcă Videoclipuri Sincronizate",
+ "loadSynchronizedVideosDescription": "Această pagină vă permite să încărcați și să sincronizați videoclipuri preînregistrate.",
+ "automaticallySynchronizeVideos": "Sincronizează automat videoclipurile",
+ "extractFramesOnLoad": "Extrage cadre la încărcare",
+ "generateThumbnails": "Generează miniaturi",
+ "noVideosLoaded": "Niciun videoclip încărcat",
+ "filterVideos": "Filtrează videoclipuri...",
+ "openVideo": "Deschide videoclipul",
+ "openFolder": "Deschide folderul în exploratorul de fișiere",
+ "videoFolderPath": "Calea Folderului Video",
+ "jumpToStart": "Salt la început (Home)",
+ "jumpToEnd": "Salt la sfârșit (End)",
+ "loopOn": "Buclă activată (L pentru comutare)",
+ "loopOff": "Redare în buclă (L)",
+ "syncInfo": "Informații sincronizare",
+ "syncInfoTitle": "Sincronizarea multi-cameră poate să nu fie perfectă la nivel de cadru",
+ "syncInfoBody": "Redarea video în browser nu garantează sincronizarea precisă la nivel de eșantion pe mai multe fluxuri. Playerul folosește o strategie lider-urmăritor și corectează deviația când depășește o toleranță mică, dar poate apărea o ușoară desincronizare (1–2 cadre), mai ales la viteze mari de redare sau când browserul este sub sarcină. Pentru analiză precisă la nivel de cadru, utilizați fișierele CSV cu marcaje temporale brute incluse în fiecare înregistrare.",
+ "previousFrame": "Cadrul anterior (← / Shift+← pentru 10)",
+ "nextFrame": "Cadrul următor (→ / Shift+→ pentru 10)",
+ "zoomIn": "Mărește",
+ "zoomOut": "Micșorează",
+ "resetZoom": "Resetează Zoom",
+ "playbackSettings": "Setări de redare",
+ "totalRecordingSize": "Dimensiunea totală a înregistrării pe disc",
+ "estimatedTime": "Timp estimat (cadru ÷ fps înregistrare)",
+ "estimatedDuration": "Durată estimată (total cadre ÷ fps înregistrare)",
+ "estimatedFromFrameNumber": "Estimat din numărul cadrului × fps înregistrare — nu citit din datele de marcaj temporal",
+ "frameCountPerCamera": "Număr de cadre per cameră",
+ "cameraStreams": "Fluxuri de cameră în această înregistrare",
+ "backToRecordings": "Înapoi la înregistrări",
+ "errorsDetected": "Erori detectate",
+ "somethingWentWrong": "Ceva nu a mers bine :(",
+ "searchLogs": "Caută în jurnale...",
+ "filter": "Filtrează…",
+ "refreshMicrophoneList": "Reîmprospătează lista de microfoane",
+ "date": "Dată",
+ "name": "Nume",
+ "size": "Dimensiune",
+ "duration": "Durată",
+ "frames": "Cadre",
+ "timestamp": "Marcaj temporal",
+ "language": "Limbă",
+ "aiTranslated": "Tradus de AI",
+ "humanTranslated": "Tradus de om",
+ "humanValidated": "Validat de om",
+ "connectCameras": "Conectează-te la camerele selectate sau actualizează camerele conectate",
+ "resumeStreaming": "Reia transmisia",
+ "pauseStreaming": "Pune pauză la transmisie",
+ "closeAllCameras": "Închide toate camerele",
+ "framerate": "Rată de cadre",
+ "exposure": "Expunere",
+ "fileLabel": "Fișier",
+ "timeDelta": "Delta timp",
+ "pathLabel": "Cale",
+ "exceptionDetails": "Detalii excepție",
+ "stackTrace": "Urmărire Stivă",
+ "loadingVideos": "Se încarcă videoclipuri… ({{ready}}/{{total}} gata)",
+ "gridColumns": "Coloane Grid",
+ "settings": "Setări",
+ "appearance": "Aspect",
+ "themeMode": "Temă",
+ "darkMode": "Întunecat",
+ "lightMode": "Luminos",
+ "languageSettings": "Limbă și Localizare",
+ "showTranslationIndicator": "Afișează indicatorul sursei de traducere",
+ "showTranslationIndicatorDescription": "Afișează o insignă când folosești traduceri generate de AI",
+ "translationSourceLabel": "Sursa traducerii",
+ "general": "General",
+ "about": "Despre",
+ "version": "Versiune",
+ "serverSettings": "Server",
+ "recordingSettings": "Setări de Înregistrare",
+ "videoLoadingSettings": "Setări de Încărcare Video",
+ "connected": "Conectat",
+ "connecting": "Se conectează…",
+ "disconnected": "Deconectat",
+ "disconnect": "Deconectează",
+ "connect": "Conectează",
+ "off": "Oprit",
+ "running": "Rulează",
+ "stopped": "Oprit",
+ "working": "Lucrează…",
+ "invalid": "Invalid",
+ "autoLaunch": "Lansare automată",
+ "autoConnect": "Conectare automată",
+ "runningPath": "Rulează: {{path}}",
+ "noMicrophone": "Niciun microfon",
+ "audioRecordingEnabled": "Înregistrarea audio activată",
+ "noMicrophoneSelected": "Niciun microfon selectat",
+ "recordingName": "Numele Înregistrării: {{name}}",
+ "startingIn": "Începe în {{countdown}}...",
+ "stopping": "Se oprește...",
+ "starting": "Se pornește...",
+ "stopRecordingButton": "🔴 Oprește Înregistrarea",
+ "startRecordingButton": "🔴 Începe Înregistrarea",
+ "camerasCount": "Camere ({{count}})",
+ "availableCamerasCount": "Disponibile ({{count}})",
+ "server": "Server",
+ "display": "Afișaj",
+ "rawMessage": "Mesaj brut",
+ "cameraPerformanceMetrics": "Metrici de Performanță Cameră",
+ "serverLogs": "Jurnale Server",
+ "sortBy": "Sortează {{direction}}",
+ "waitingForCameraStreams": "Se așteaptă fluxuri de cameră...",
+ "loggingPaused": "Jurnalizare în pauză",
+ "noLogsToDisplay": "Niciun jurnal de afișat",
+ "closeSettings": "Închide setările",
+ "gridSettings": "Setări grid",
+ "clickToShowLess": "Click pentru a arăta mai puțin",
+ "clickToLearnMore": "Click pentru a afla mai mult",
+ "samples": "eșantioane",
+ "framerateOverTime": "Rata de Cadre în Timp",
+ "framerateFps": "Rata de cadre (fps)",
+ "capturesFramesFromCamera": "Capturează cadre de la cameră.",
+ "rendersReceivedFrames": "Redă cadrele primite pe ecran.",
+ "displayTooltipLong": "Afișajul reprezintă performanța de randare a UI. Arată cât de repede afișajul tău primește și redă cadre. Problemele de performanță aici nu vor afecta calitatea înregistrării, dar pot afecta capacitatea de a monitoriza camerele în timp real.",
+ "statsSourceShort": "Afișajul redă cadre, Serverul capturează cadre.",
+ "statsSourceLong": "Serverul este rata reală la care cadrele sunt trase/înregistrate de la cameră, în timp ce afișajul este rata la care sunt primite și redate. Skellycam prioritizează performanța pe partea de server pentru calitatea înregistrării, deci acel număr ar trebui să rămână mai stabil. Dacă rata de cadre a afișajului diverge de cea a serverului, indică faptul că resursele sistemului sunt suprasolicitate. Luați în considerare utilizarea mai puțin camere sau reducerea ratei de cadre/rezoluție.",
+ "statsCurrentShort": "Cel mai recent timp de cadru și FPS corespunzător.",
+ "statsCurrentLong": "Aceasta arată cea mai recentă măsurătoare a timpului necesar pentru procesarea unui singur cadru (în milisecunde) și cadrele pe secundă (FPS) echivalente. Timpi de cadru mai mici și FPS mai mare indică performanță mai bună.",
+ "statsMinShort": "Cel mai rapid timp de cadru (latență minimă) și FPS maxim atins.",
+ "statsMinLong": "Aceasta reprezintă timpul minim necesar pentru procesarea unui singur cadru în fereastra de eșantionare. Corespunde FPS-ului maxim atins de sistemul tău în condiții optime.",
+ "statsMaxShort": "Cel mai lent timp de cadru (latență maximă) și FPS minim experimentat.",
+ "statsMaxLong": "Aceasta reprezintă timpul maxim necesar pentru procesarea unui singur cadru în fereastra de eșantionare. Corespunde FPS-ului minim atins de sistemul tău în cele mai defavorabile condiții. Vârfurile ocazionale sunt normale, dar valorile constant ridicate pot indica probleme de performanță.",
+ "statsMeanShort": "Timp mediu de cadru și FPS pe toate eșantioanele.",
+ "statsMeanLong": "Media aritmetică a tuturor timpilor de cadru măsurați în fereastra de eșantionare și FPS-ul corespunzător. Oferă o imagine de ansamblu bună a performanței, dar poate fi distorsionată de valori extreme.",
+ "statsMedianShort": "Valoarea de mijloc a tuturor timpilor de cadru (percentila 50).",
+ "statsMedianLong": "Mediana reprezintă valoarea de mijloc când toți timpii de cadru sunt sortați de la cel mai rapid la cel mai lent. Spre deosebire de medie, mediana nu este afectată de valorile extreme, făcând-o un indicator mai stabil al performanței tipice.",
+ "statsStdDevShort": "Măsoară variabilitatea timpului de cadru. CV% este variabilitatea relativă.",
+ "statsStdDevLong": "Deviația standard măsoară cantitatea de variație în timpii de cadru. Valorile mai mici indică performanță mai consistentă. Coeficientul de Variație (CV%) exprimă această variabilitate ca procent din medie, facilitând compararea stabilității între rate de cadre diferite. CV% mai mic indică performanță mai stabilă.",
+ "aiTranslatedTooltip": "Această traducere a fost generată de AI și poate conține erori. Dacă vorbiți această limbă, puteți ajuta la îmbunătățirea ei deschizând un pull request pe GitHub!",
+ "humanValidatedTooltip": "Această traducere a fost revizuită și validată de un traducător uman.",
+ "helpTranslate": "Ajută la traducerea SkellyCam",
+ "failedToFetch": "Obținere eșuată",
+ "recordings": "Înregistrări",
+ "noRecordingsFound": "Nicio înregistrare găsită. Introduceți o cale mai sus pentru încărcare manuală.",
+ "noCamerasDetected": "Nicio cameră detectată",
+ "clickRefreshToScan": "Click pe reîmprospătare pentru a scana camerele disponibile",
+ "waitingForData": "Se așteaptă date…",
+ "load": "Încarcă",
+ "refresh": "Reîmprospătează",
+ "available": "Disponibil",
+ "menuFile": "Fișier",
+ "menuView": "Vizualizare",
+ "menuCamera": "Cameră",
+ "menuRecording": "Înregistrare",
+ "menuHelp": "Ajutor",
+ "menuDetectCameras": "Detectare camere",
+ "menuConnectCameras": "Conectare camere",
+ "menuCloseAllCameras": "Închide toate camerele",
+ "menuOpenRecordingFolder": "Deschide folderul de înregistrare…",
+ "menuToggleSidebar": "Comutare bară laterală",
+ "menuToggleTheme": "Comutare temă",
+ "menuToggleFullScreen": "Ecran complet",
+ "menuPauseUnpause": "Pauză / Reluare",
+ "menuConnectApplySettings": "Conectare / Aplicare setări",
+ "menuCloseAll": "Închide tot",
+ "menuDocumentation": "Documentație",
+ "menuGitHubRepository": "Depozit GitHub",
+ "menuReportIssue": "Raportează o problemă…",
+ "menuAbout": "Despre SkellyCam",
+ "menuPlayback": "Redare",
+ "videoPlayback": "Redare",
+ "copyLogsToClipboard": "Copiază jurnalele în clipboard",
+ "saveLogsToFile": "Salvează jurnalele într-un fișier",
+ "copied": "Copiat!",
+ "timestampFromRecording": "Marcaj temporal din datele înregistrării",
+ "menuCheckForUpdates": "Check for Updates…",
+ "updateAvailable": "Update available",
+ "updateAvailableMessage": "Version {{version}} is available",
+ "downloading": "Downloading…",
+ "downloadComplete": "Download complete",
+ "restartToUpdate": "Restart to update",
+ "checkForUpdates": "Check for Updates",
+ "upToDate": "You are up to date",
+ "updateError": "Update check failed"
+}
diff --git a/freemocap-ui-old/src/i18n/locales/ru-russkiy.json b/freemocap-ui-old/src/i18n/locales/ru-russkiy.json
new file mode 100644
index 00000000..6275b984
--- /dev/null
+++ b/freemocap-ui-old/src/i18n/locales/ru-russkiy.json
@@ -0,0 +1,258 @@
+{
+ "_meta": {
+ "locale": "ru",
+ "translationSource": "ai-generated",
+ "lastUpdated": "2026-02-23"
+ },
+ "appName": "SkellyCam",
+ "appNameDecorated": "SkellyCam 💀📸",
+ "welcomeTitle": "Добро пожаловать в SkellyCam",
+ "welcomeSubtitle": "Записывайте и просматривайте синхронизированные видео",
+ "sendAnonymousPings": "Отправлять анонимные данные об использовании",
+ "footerWith": "с",
+ "footerFrom": "от",
+ "footerOrgName": "FreeMoCap Foundation",
+ "home": "Главная",
+ "cameras": "Камеры",
+ "videos": "Видео",
+ "expandSidebar": "Развернуть боковую панель",
+ "collapseSidebar": "Свернуть боковую панель",
+ "startRecording": "Начать запись",
+ "stopRecording": "Остановить запись",
+ "toggleTheme": "переключить тему",
+ "switchToDark": "Переключить на тёмный режим",
+ "switchToLight": "Переключить на светлый режим",
+ "connectWebSocket": "Подключить WebSocket",
+ "disconnectWebSocket": "Отключить WebSocket",
+ "launchServer": "Запустить сервер",
+ "stopServer": "Остановить сервер",
+ "browseForExecutable": "Найти исполняемый файл",
+ "refreshCandidates": "Обновить кандидатов",
+ "executable": "Исполняемый файл",
+ "host": "Хост",
+ "port": "Порт",
+ "cameraCount_one": "{{count}} камера",
+ "cameraCount_other": "{{count}} камер",
+ "connectedCameras": "Подключённые камеры",
+ "availableCameras": "Доступные камеры",
+ "noCamerasConnected": "Камеры не подключены",
+ "detectCameras": "Обнаружить доступные камеры",
+ "clearCameraSettings": "Очистить настройки камер",
+ "copySettingsToAll": "Скопировать настройки на все камеры",
+ "recordingTag": "Тег записи",
+ "recordingTagPlaceholder": "Необязательный тег",
+ "recordingDirectory": "Каталог записей",
+ "recordingFolderPath": "Путь к папке записей",
+ "delayStart": "Отложенный старт",
+ "seconds": "Секунды",
+ "subfolder": "Подпапка",
+ "subfolderPlaceholder": "Имя подпапки",
+ "baseName": "Базовое имя",
+ "increment": "Инкремент",
+ "resolution": "Разрешение",
+ "fps": "FPS",
+ "width": "Ширина",
+ "height": "Высота",
+ "columns": "Столбцы",
+ "auto": "Авто",
+ "manual": "Ручной",
+ "custom": "Пользовательский",
+ "current": "Текущий",
+ "recommend": "Рекомендуемый",
+ "cameraRotation": "поворот камеры",
+ "selectCameraRotation": "Выбрать поворот изображения",
+ "exposureControl": "Автоматическое или ручное управление экспозицией",
+ "framerateControl": "Автоматическое или ручное управление частотой кадров",
+ "adjustExposure": "Настроить время экспозиции",
+ "setTargetFps": "Установить целевой FPS для захвата",
+ "recordingCaptureFps": "Частота кадров записи",
+ "playbackSpeed": "Скорость воспроизведения",
+ "framerateTimeline": "Хронология частоты кадров",
+ "framerateDistribution": "Распределение частоты кадров",
+ "timelineView": "Вид хронологии",
+ "distributionView": "Вид распределения",
+ "combinedView": "Комбинированный вид",
+ "min": "Мин",
+ "max": "Макс",
+ "mean": "Среднее",
+ "median": "Медиана",
+ "stdDevCv": "СтОткл/CV",
+ "source": "Источник",
+ "selectAll": "Выбрать все",
+ "loadSynchronizedVideos": "Загрузить синхронизированные видео",
+ "loadSynchronizedVideosDescription": "Эта страница позволяет загружать и синхронизировать записанные видео.",
+ "automaticallySynchronizeVideos": "Автоматически синхронизировать видео",
+ "extractFramesOnLoad": "Извлечь кадры при загрузке",
+ "generateThumbnails": "Создать миниатюры",
+ "noVideosLoaded": "Видео не загружены",
+ "filterVideos": "Фильтр видео...",
+ "openVideo": "Открыть видео",
+ "openFolder": "Открыть папку в проводнике",
+ "videoFolderPath": "Путь к папке видео",
+ "jumpToStart": "К началу (Home)",
+ "jumpToEnd": "К концу (End)",
+ "loopOn": "Повтор включён (L для переключения)",
+ "loopOff": "Повторное воспроизведение (L)",
+ "syncInfo": "Информация о синхронизации",
+ "syncInfoTitle": "Синхронизация нескольких камер может быть не идеальной на уровне кадров",
+ "syncInfoBody": "Воспроизведение видео в браузере не гарантирует точную синхронизацию на уровне сэмплов для нескольких потоков. Плеер использует стратегию лидер-последователь и корректирует рассинхронизацию при превышении небольшого допуска, но незначительная десинхронизация (1–2 кадра) может возникать, особенно при высокой скорости воспроизведения или при нагрузке на браузер. Для покадрового анализа используйте необработанные CSV-файлы временных меток, включённые в каждую запись.",
+ "previousFrame": "Предыдущий кадр (← / Shift+← на 10)",
+ "nextFrame": "Следующий кадр (→ / Shift+→ на 10)",
+ "zoomIn": "Увеличить",
+ "zoomOut": "Уменьшить",
+ "resetZoom": "Сбросить масштаб",
+ "playbackSettings": "Настройки воспроизведения",
+ "totalRecordingSize": "Общий размер записи на диске",
+ "estimatedTime": "Примерное время (кадр ÷ fps)",
+ "estimatedDuration": "Примерная длительность (всего кадров ÷ fps)",
+ "estimatedFromFrameNumber": "Оценка по номеру кадра × fps",
+ "frameCountPerCamera": "Количество кадров на камеру",
+ "cameraStreams": "Потоки камер в этой записи",
+ "backToRecordings": "Назад к записям",
+ "errorsDetected": "Обнаружены ошибки",
+ "somethingWentWrong": "Что-то пошло не так :(",
+ "searchLogs": "Поиск в журнале...",
+ "filter": "Фильтр…",
+ "refreshMicrophoneList": "Обновить список микрофонов",
+ "date": "Дата",
+ "name": "Имя",
+ "size": "Размер",
+ "duration": "Длительность",
+ "frames": "Кадры",
+ "timestamp": "Отметка времени",
+ "language": "Язык",
+ "aiTranslated": "ИИ-перевод",
+ "humanTranslated": "Перевод человека",
+ "humanValidated": "Проверено человеком",
+ "connectCameras": "Подключить выбранные камеры",
+ "resumeStreaming": "Возобновить поток",
+ "pauseStreaming": "Приостановить поток",
+ "closeAllCameras": "Закрыть все камеры",
+ "framerate": "Частота кадров",
+ "exposure": "Экспозиция",
+ "fileLabel": "Файл",
+ "timeDelta": "Дельта времени",
+ "pathLabel": "Путь",
+ "exceptionDetails": "Детали исключения",
+ "stackTrace": "Трассировка стека",
+ "loadingVideos": "Загрузка видео… ({{ready}}/{{total}} готово)",
+ "gridColumns": "Столбцы сетки",
+ "settings": "Настройки",
+ "appearance": "Оформление",
+ "themeMode": "Тема",
+ "darkMode": "Тёмный",
+ "lightMode": "Светлый",
+ "languageSettings": "Язык и локализация",
+ "showTranslationIndicator": "Показать индикатор источника перевода",
+ "showTranslationIndicatorDescription": "Показывать значок при использовании ИИ-переводов",
+ "translationSourceLabel": "Источник перевода",
+ "general": "Общие",
+ "about": "О программе",
+ "version": "Версия",
+ "serverSettings": "Сервер",
+ "recordingSettings": "Настройки записи",
+ "videoLoadingSettings": "Настройки загрузки видео",
+ "connected": "Подключено",
+ "connecting": "Подключение…",
+ "disconnected": "Отключено",
+ "disconnect": "Отключить",
+ "connect": "Подключить",
+ "off": "Выкл",
+ "running": "Запущен",
+ "stopped": "Остановлен",
+ "working": "Обработка…",
+ "invalid": "Недействительный",
+ "autoLaunch": "Автозапуск",
+ "autoConnect": "Автоподключение",
+ "runningPath": "Запущено: {{path}}",
+ "noMicrophone": "Нет микрофона",
+ "audioRecordingEnabled": "Аудиозапись включена",
+ "noMicrophoneSelected": "Микрофон не выбран",
+ "recordingName": "Имя записи: {{name}}",
+ "startingIn": "Старт через {{countdown}}...",
+ "stopping": "Остановка...",
+ "starting": "Запуск...",
+ "stopRecordingButton": "🔴 Остановить запись",
+ "startRecordingButton": "🔴 Начать запись",
+ "camerasCount": "Камеры ({{count}})",
+ "availableCamerasCount": "Доступно ({{count}})",
+ "server": "Сервер",
+ "display": "Дисплей",
+ "rawMessage": "Исходное сообщение",
+ "cameraPerformanceMetrics": "Показатели производительности камеры",
+ "serverLogs": "Журнал сервера",
+ "sortBy": "Сортировать {{direction}}",
+ "waitingForCameraStreams": "Ожидание потоков камер...",
+ "loggingPaused": "Журнал приостановлен",
+ "noLogsToDisplay": "Нет журналов для отображения",
+ "closeSettings": "Закрыть настройки",
+ "gridSettings": "Настройки сетки",
+ "clickToShowLess": "Нажмите, чтобы свернуть",
+ "clickToLearnMore": "Нажмите, чтобы узнать больше",
+ "samples": "образцов",
+ "framerateOverTime": "Частота кадров во времени",
+ "framerateFps": "Частота кадров (fps)",
+ "capturesFramesFromCamera": "Захватывает кадры с камеры.",
+ "rendersReceivedFrames": "Отображает полученные кадры на экране.",
+ "displayTooltipLong": "Дисплей отображает производительность рендеринга пользовательского интерфейса. Показывает, насколько быстро ваш дисплей получает и отрисовывает кадры. Проблемы с производительностью здесь не повлияют на качество записи, но могут повлиять на возможность мониторинга камер в реальном времени.",
+ "statsSourceShort": "Дисплей рендерит кадры, сервер захватывает кадры.",
+ "statsSourceLong": "Сервер — это реальная скорость, с которой кадры извлекаются/записываются с камеры, а дисплей — скорость их приёма и отрисовки. SkellyCam отдаёт приоритет серверной производительности для качества записи, поэтому это значение должно оставаться более стабильным. Если частота кадров дисплея расходится с сервером, это указывает на нехватку системных ресурсов. Рассмотрите возможность использования меньшего количества камер или снижения частоты кадров/разрешения.",
+ "statsCurrentShort": "Последнее время кадра и FPS.",
+ "statsCurrentLong": "Показывает последнее измерение времени обработки одного кадра (в миллисекундах) и соответствующее количество кадров в секунду (FPS). Более низкое время кадра и более высокий FPS указывают на лучшую производительность.",
+ "statsMinShort": "Минимальное время кадра и максимальный FPS.",
+ "statsMinLong": "Представляет минимальное время обработки одного кадра в окне выборки. Соответствует максимальному FPS, достигнутому вашей системой в оптимальных условиях.",
+ "statsMaxShort": "Максимальное время кадра и минимальный FPS.",
+ "statsMaxLong": "Представляет максимальное время обработки одного кадра в окне выборки. Соответствует минимальному FPS в наихудших условиях. Случайные всплески нормальны, но стабильно высокие значения могут указывать на проблемы с производительностью.",
+ "statsMeanShort": "Среднее время кадра и FPS по всем образцам.",
+ "statsMeanLong": "Среднее арифметическое всех измеренных времён кадров в окне выборки и соответствующий FPS. Даёт хорошее общее представление о производительности, но может быть искажено выбросами.",
+ "statsMedianShort": "Медиана всех времён кадров (50-й процентиль).",
+ "statsMedianLong": "Медиана — это среднее значение при сортировке всех времён кадров от самого быстрого к самому медленному. В отличие от среднего, медиана не подвержена влиянию экстремальных выбросов, что делает её более стабильным показателем типичной производительности.",
+ "statsStdDevShort": "Измеряет изменчивость времени кадра.",
+ "statsStdDevLong": "Стандартное отклонение измеряет разброс времён кадров. Более низкие значения указывают на более стабильную производительность. Коэффициент вариации (CV%) выражает эту изменчивость как процент от среднего, что упрощает сравнение стабильности при разных частотах кадров. Более низкий CV% указывает на более стабильную производительность.",
+ "aiTranslatedTooltip": "Этот перевод создан ИИ и может содержать ошибки. Если вы говорите на этом языке, помогите улучшить его!",
+ "humanValidatedTooltip": "Этот перевод проверен переводчиком-человеком.",
+ "helpTranslate": "Помогите перевести SkellyCam",
+ "failedToFetch": "Не удалось загрузить",
+ "recordings": "Записи",
+ "noRecordingsFound": "Записей не найдено. Введите путь выше для загрузки вручную.",
+ "noCamerasDetected": "Камеры не обнаружены",
+ "clickRefreshToScan": "Нажмите обновить для поиска доступных камер",
+ "waitingForData": "Ожидание данных…",
+ "load": "Загрузить",
+ "refresh": "Обновить",
+ "available": "Доступна",
+ "menuFile": "Файл",
+ "menuView": "Вид",
+ "menuCamera": "Камера",
+ "menuRecording": "Запись",
+ "menuHelp": "Справка",
+ "menuDetectCameras": "Обнаружить камеры",
+ "menuConnectCameras": "Подключить камеры",
+ "menuCloseAllCameras": "Закрыть все камеры",
+ "menuOpenRecordingFolder": "Открыть папку записей…",
+ "menuToggleSidebar": "Переключить боковую панель",
+ "menuToggleTheme": "Сменить тему",
+ "menuToggleFullScreen": "Полный экран",
+ "menuPauseUnpause": "Пауза / Продолжить",
+ "menuConnectApplySettings": "Подключить / Применить настройки",
+ "menuCloseAll": "Закрыть все",
+ "menuDocumentation": "Документация",
+ "menuGitHubRepository": "Репозиторий GitHub",
+ "menuReportIssue": "Сообщить о проблеме…",
+ "menuAbout": "О SkellyCam",
+ "menuPlayback": "Воспроизведение",
+ "videoPlayback": "Воспроизведение",
+ "copyLogsToClipboard": "Копировать логи в буфер обмена",
+ "saveLogsToFile": "Сохранить логи в файл",
+ "copied": "Скопировано!",
+ "timestampFromRecording": "Временная метка из данных записи",
+ "menuCheckForUpdates": "Check for Updates…",
+ "updateAvailable": "Update available",
+ "updateAvailableMessage": "Version {{version}} is available",
+ "downloading": "Downloading…",
+ "downloadComplete": "Download complete",
+ "restartToUpdate": "Restart to update",
+ "checkForUpdates": "Check for Updates",
+ "upToDate": "You are up to date",
+ "updateError": "Update check failed"
+}
diff --git a/freemocap-ui-old/src/i18n/locales/si-sinhala.json b/freemocap-ui-old/src/i18n/locales/si-sinhala.json
new file mode 100644
index 00000000..4e4e1b38
--- /dev/null
+++ b/freemocap-ui-old/src/i18n/locales/si-sinhala.json
@@ -0,0 +1,258 @@
+{
+ "_meta": {
+ "locale": "si",
+ "translationSource": "ai-generated",
+ "lastUpdated": "2026-02-23"
+ },
+ "appName": "SkellyCam",
+ "appNameDecorated": "SkellyCam 💀📸",
+ "welcomeTitle": "SkellyCam වෙත සාදරයෙන් පිළිගනිමු",
+ "welcomeSubtitle": "සමමුහුර්ත වීඩියෝ පටිගත කර බලන්න",
+ "sendAnonymousPings": "නිර්නාමික භාවිත ping යවන්න",
+ "footerWith": "සමඟ",
+ "footerFrom": "සිට",
+ "footerOrgName": "FreeMoCap Foundation",
+ "home": "මුල් පිටුව",
+ "cameras": "කැමරා",
+ "videos": "වීඩියෝ",
+ "expandSidebar": "පැති තීරුව විහිදන්න",
+ "collapseSidebar": "පැති තීරුව හකුළන්න",
+ "startRecording": "පටිගත කිරීම ආරම්භ කරන්න",
+ "stopRecording": "පටිගත කිරීම නවත්වන්න",
+ "toggleTheme": "තේමාව මාරු කරන්න",
+ "switchToDark": "අඳුරු ප්‍රකාරයට මාරු වන්න",
+ "switchToLight": "ආලෝක ප්‍රකාරයට මාරු වන්න",
+ "connectWebSocket": "WebSocket සම්බන්ධ කරන්න",
+ "disconnectWebSocket": "WebSocket විසන්ධි කරන්න",
+ "launchServer": "සේවාදායකය ආරම්භ කරන්න",
+ "stopServer": "සේවාදායකය නවත්වන්න",
+ "browseForExecutable": "ක්‍රියාත්මක කළ හැකි ගොනුව සොයන්න",
+ "refreshCandidates": "අපේක්ෂකයින් නැවුම් කරන්න",
+ "executable": "ක්‍රියාත්මක කළ හැකි",
+ "host": "ධාරකය",
+ "port": "පෝට්ටුව",
+ "cameraCount_one": "කැමරා {{count}}",
+ "cameraCount_other": "කැමරා {{count}}",
+ "connectedCameras": "සම්බන්ධිත කැමරා",
+ "availableCameras": "ලබා ගත හැකි කැමරා",
+ "noCamerasConnected": "කැමරා සම්බන්ධ කර නැත",
+ "detectCameras": "ලබා ගත හැකි කැමරා හඳුනන්න",
+ "clearCameraSettings": "මතකයෙන් සුරැකි කැමරා සැකසීම් ඉවත් කරන්න",
+ "copySettingsToAll": "සැකසීම් සියලු කැමරාවලට පිටපත් කරන්න",
+ "recordingTag": "පටිගත කිරීමේ ටැගය",
+ "recordingTagPlaceholder": "විකල්ප ටැගය",
+ "recordingDirectory": "පටිගත කිරීමේ නාමාවලිය",
+ "recordingFolderPath": "පටිගත කිරීමේ ෆෝල්ඩර මාර්ගය",
+ "delayStart": "ප්‍රමාද ආරම්භය",
+ "seconds": "තත්පර",
+ "subfolder": "උප ෆෝල්ඩරය",
+ "subfolderPlaceholder": "උප ෆෝල්ඩර නම",
+ "baseName": "මූලික නම",
+ "increment": "වර්ධනය",
+ "resolution": "විභේදනය",
+ "fps": "FPS",
+ "width": "පළල",
+ "height": "උස",
+ "columns": "තීරු",
+ "auto": "ස්වයංක්‍රීය",
+ "manual": "අතින්",
+ "custom": "අභිරුචි",
+ "current": "වත්මන්",
+ "recommend": "නිර්දේශ",
+ "cameraRotation": "කැමරා භ්‍රමණය",
+ "selectCameraRotation": "කැමරා රූප භ්‍රමණය තෝරන්න",
+ "exposureControl": "ස්වයංක්‍රීය හෝ අතින් නිරාවරණ පාලනය අතර තෝරන්න",
+ "framerateControl": "ස්වයංක්‍රීය හෝ අතින් රාමු අනුපාත පාලනය අතර තෝරන්න",
+ "adjustExposure": "නිරාවරණ කාලය සකසන්න, උදා. cv2.VideoCapture.set(cv2.CAP_PROP_EXPOSURE, value)",
+ "setTargetFps": "කැමරා ග්‍රහණය සඳහා ඉලක්ක රාමු/තත්පරය (FPS) සකසන්න",
+ "recordingCaptureFps": "පටිගත කිරීමේ ග්‍රහණ රාමු අනුපාතය",
+ "playbackSpeed": "ප්ලේබැක් වේගය (පටිගත කිරීමේ fps වලට බලපාන්නේ නැත)",
+ "framerateTimeline": "රාමු අනුපාත කාල රේඛාව",
+ "framerateDistribution": "රාමු අනුපාත ව්‍යාප්තිය",
+ "timelineView": "කාල රේඛා දසුන",
+ "distributionView": "ව්‍යාප්ති දසුන",
+ "combinedView": "ඒකාබද්ධ දසුන",
+ "min": "අවම",
+ "max": "උපරිම",
+ "mean": "මධ්‍යන්‍ය",
+ "median": "මධ්‍යස්ථය",
+ "stdDevCv": "StdDev/CV",
+ "source": "මූලාශ්‍රය",
+ "selectAll": "සියල්ල තෝරන්න",
+ "loadSynchronizedVideos": "සමමුහුර්ත වීඩියෝ පූරණය කරන්න",
+ "loadSynchronizedVideosDescription": "මෙම පිටුව ඔබට පෙර-පටිගත කළ වීඩියෝ පූරණය කර සමමුහුර්ත කිරීමට ඉඩ දෙයි.",
+ "automaticallySynchronizeVideos": "වීඩියෝ ස්වයංක්‍රීයව සමමුහුර්ත කරන්න",
+ "extractFramesOnLoad": "පූරණය කරන විට රාමු උපුටන්න",
+ "generateThumbnails": "සිඟිති රූප සාදන්න",
+ "noVideosLoaded": "වීඩියෝ පූරණය කර නැත",
+ "filterVideos": "වීඩියෝ පෙරන්න...",
+ "openVideo": "වීඩියෝ විවෘත කරන්න",
+ "openFolder": "ගොනු ගවේෂකයේ ෆෝල්ඩරය විවෘත කරන්න",
+ "videoFolderPath": "වීඩියෝ ෆෝල්ඩර මාර්ගය",
+ "jumpToStart": "ආරම්භයට පනින්න (Home)",
+ "jumpToEnd": "අවසානයට පනින්න (End)",
+ "loopOn": "ලූපය ක්‍රියාත්මකයි (මාරු කිරීමට L)",
+ "loopOff": "ලූප් ප්ලේබැක් (L)",
+ "syncInfo": "සමමුහුර්ත තොරතුරු",
+ "syncInfoTitle": "බහු-කැමරා සමමුහුර්තය රාමු මට්ටමින් නිවැරදි නොවිය හැක",
+ "syncInfoBody": "බ්‍රවුසර වීඩියෝ ප්ලේබැක් බහු ප්‍රවාහ හරහා සාම්පල-නිවැරදි සමමුහුර්තය සහතික නොකරයි. ප්ලේයරය නායක-අනුගාමික උපාය මාර්ගයක් භාවිතා කරන අතර කුඩා ඉවසීමක් ඉක්මවන විට අපගමනය නිවැරදි කරයි, නමුත් සුළු අසමමුහුර්තය (රාමු 1–2) සිදුවිය හැක, විශේෂයෙන් ඉහළ ප්ලේබැක් වේගවලින් හෝ බ්‍රවුසරය බරට යටත් වූ විට. රාමු-නිවැරදි විශ්ලේෂණය සඳහා, සෑම පටිගත කිරීමකම ඇතුළත් අමු කාල මුද්‍රා CSV ගොනු භාවිතා කරන්න.",
+ "previousFrame": "පෙර රාමුව (← / Shift+← 10 සඳහා)",
+ "nextFrame": "මීළඟ රාමුව (→ / Shift+→ 10 සඳහා)",
+ "zoomIn": "විශාලනය",
+ "zoomOut": "කුඩාකරණය",
+ "resetZoom": "විශාලනය නැවත සකසන්න",
+ "playbackSettings": "ප්ලේබැක් සැකසීම්",
+ "totalRecordingSize": "තැටියේ මුළු පටිගත කිරීමේ ප්‍රමාණය",
+ "estimatedTime": "ඇස්තමේන්තු කාලය (රාමුව ÷ පටිගත කිරීමේ fps)",
+ "estimatedDuration": "ඇස්තමේන්තු කාල සීමාව (මුළු රාමු ÷ පටිගත කිරීමේ fps)",
+ "estimatedFromFrameNumber": "රාමු අංකය × පටිගත කිරීමේ fps වලින් ඇස්තමේන්තු — කාල මුද්දර දත්ත වලින් කියවා නැත",
+ "frameCountPerCamera": "කැමරාවකට රාමු ගණන",
+ "cameraStreams": "මෙම පටිගත කිරීමේ කැමරා ප්‍රවාහ",
+ "backToRecordings": "පටිගත කිරීම් වෙත ආපසු",
+ "errorsDetected": "දෝෂ හඳුනාගෙන ඇත",
+ "somethingWentWrong": "යමක් වැරදුණා :(",
+ "searchLogs": "ලොග් සොයන්න...",
+ "filter": "පෙරන්න…",
+ "refreshMicrophoneList": "මයික්‍රොෆෝන ලැයිස්තුව නැවුම් කරන්න",
+ "date": "දිනය",
+ "name": "නම",
+ "size": "ප්‍රමාණය",
+ "duration": "කාල සීමාව",
+ "frames": "රාමු",
+ "timestamp": "කාල මුද්දරය",
+ "language": "භාෂාව",
+ "aiTranslated": "AI පරිවර්තිත",
+ "humanTranslated": "මිනිස් පරිවර්තිත",
+ "humanValidated": "මිනිස් තහවුරු කළ",
+ "connectCameras": "තෝරාගත් කැමරා වෙත සම්බන්ධ වන්න හෝ සම්බන්ධිත කැමරා යාවත්කාලීන කරන්න",
+ "resumeStreaming": "ප්‍රවාහය නැවත ආරම්භ කරන්න",
+ "pauseStreaming": "ප්‍රවාහය විරාම කරන්න",
+ "closeAllCameras": "සියලු කැමරා වසන්න",
+ "framerate": "රාමු අනුපාතය",
+ "exposure": "නිරාවරණය",
+ "fileLabel": "ගොනුව",
+ "timeDelta": "කාල වෙනස",
+ "pathLabel": "මාර්ගය",
+ "exceptionDetails": "ව්‍යතිරේක විස්තර",
+ "stackTrace": "ස්ටැක් ට්‍රේස්",
+ "loadingVideos": "වීඩියෝ පූරණය වෙමින්… ({{ready}}/{{total}} සූදානම්)",
+ "gridColumns": "ජාලක තීරු",
+ "settings": "සැකසීම්",
+ "appearance": "පෙනුම",
+ "themeMode": "තේමාව",
+ "darkMode": "අඳුරු",
+ "lightMode": "ආලෝක",
+ "languageSettings": "භාෂාව සහ ස්ථානීයකරණය",
+ "showTranslationIndicator": "පරිවර්තන මූලාශ්‍ර දර්ශකය පෙන්වන්න",
+ "showTranslationIndicatorDescription": "AI-ජනිත පරිවර්තන භාවිත කරන විට බැජ් පෙන්වන්න",
+ "translationSourceLabel": "පරිවර්තන මූලාශ්‍රය",
+ "general": "සාමාන්‍ය",
+ "about": "ගැන",
+ "version": "අනුවාදය",
+ "serverSettings": "සේවාදායකය",
+ "recordingSettings": "පටිගත කිරීමේ සැකසීම්",
+ "videoLoadingSettings": "වීඩියෝ පූරණ සැකසීම්",
+ "connected": "සම්බන්ධිතයි",
+ "connecting": "සම්බන්ධ වෙමින්…",
+ "disconnected": "විසන්ධි වූ",
+ "disconnect": "විසන්ධි කරන්න",
+ "connect": "සම්බන්ධ කරන්න",
+ "off": "අක්‍රීය",
+ "running": "ක්‍රියාත්මක වෙමින්",
+ "stopped": "නැවතී ඇත",
+ "working": "වැඩ කරමින්…",
+ "invalid": "වලංගු නැත",
+ "autoLaunch": "ස්වයංක්‍රීය ආරම්භය",
+ "autoConnect": "ස්වයංක්‍රීය සම්බන්ධතාවය",
+ "runningPath": "ක්‍රියාත්මක වෙමින්: {{path}}",
+ "noMicrophone": "මයික්‍රොෆෝනයක් නැත",
+ "audioRecordingEnabled": "ශ්‍රව්‍ය පටිගත කිරීම සක්‍රීයයි",
+ "noMicrophoneSelected": "මයික්‍රොෆෝනයක් තෝරා නැත",
+ "recordingName": "පටිගත කිරීමේ නම: {{name}}",
+ "startingIn": "{{countdown}} කින් ආරම්භ වේ...",
+ "stopping": "නවතිමින්...",
+ "starting": "ආරම්භ වෙමින්...",
+ "stopRecordingButton": "🔴 පටිගත කිරීම නවත්වන්න",
+ "startRecordingButton": "🔴 පටිගත කිරීම ආරම්භ කරන්න",
+ "camerasCount": "කැමරා ({{count}})",
+ "availableCamerasCount": "ලබා ගත හැකි ({{count}})",
+ "server": "සේවාදායකය",
+ "display": "සංදර්ශකය",
+ "rawMessage": "අමු පණිවිඩය",
+ "cameraPerformanceMetrics": "කැමරා කාර්යසාධන මිනුම්",
+ "serverLogs": "සේවාදායක ලොග්",
+ "sortBy": "{{direction}} වර්ග කරන්න",
+ "waitingForCameraStreams": "කැමරා ප්‍රවාහ බලාපොරොත්තුවෙන්...",
+ "loggingPaused": "ලොග් කිරීම විරාම කර ඇත",
+ "noLogsToDisplay": "පෙන්වීමට ලොග් නැත",
+ "closeSettings": "සැකසීම් වසන්න",
+ "gridSettings": "ජාලක සැකසීම්",
+ "clickToShowLess": "අඩුවෙන් පෙන්වීමට ක්ලික් කරන්න",
+ "clickToLearnMore": "වැඩිදුර දැනගැනීමට ක්ලික් කරන්න",
+ "samples": "නියැදි",
+ "framerateOverTime": "කාලය හරහා රාමු අනුපාතය",
+ "framerateFps": "රාමු අනුපාතය (fps)",
+ "capturesFramesFromCamera": "කැමරාවෙන් රාමු ග්‍රහණය කරයි.",
+ "rendersReceivedFrames": "ලැබුණු රාමු තිරය මත ප්‍රතිදානය කරයි.",
+ "displayTooltipLong": "සංදර්ශකය UI ප්‍රතිදාන කාර්යසාධනය නියෝජනය කරයි. ඔබේ සංදර්ශකය කෙතරම් වේගයෙන් රාමු ලබාගෙන ප්‍රතිදානය කරන්නේද යන්න පෙන්වයි. මෙහි කාර්යසාධන ගැටළු පටිගත කිරීමේ ගුණත්වයට බලපාන්නේ නැත, නමුත් තත්‍ය කාලීනව කැමරා නිරීක්ෂණය කිරීමේ ඔබේ හැකියාවට බලපෑ හැක.",
+ "statsSourceShort": "සංදර්ශකය රාමු ප්‍රතිදානය කරයි, සේවාදායකය රාමු ග්‍රහණය කරයි.",
+ "statsSourceLong": "සේවාදායකය යනු කැමරාවෙන් රාමු අදින/පටිගත කරන සැබෑ අනුපාතයයි, සංදර්ශකය යනු ඒවා ලැබී ප්‍රතිදානය කරන අනුපාතයයි. Skellycam පටිගත කිරීමේ ගුණත්වය සඳහා සේවාදායක පාර්ශ්ව කාර්යසාධනයට ප්‍රමුඛතාවය දෙයි, එබැවින් එම අංකය වඩාත් ස්ථායී විය යුතුය. සංදර්ශක රාමු අනුපාතය සේවාදායකයෙන් වෙනස් වුවහොත්, ඔබේ පද්ධති සම්පත් අධික ලෙස භාවිත වෙමින් ඇති බව දක්වයි. අඩු කැමරා භාවිතය හෝ රාමු අනුපාතය/විභේදනය අඩු කිරීම සලකා බලන්න.",
+ "statsCurrentShort": "වඩාත්ම මෑත රාමු කාලය සහ අනුරූප FPS.",
+ "statsCurrentLong": "තනි රාමුවක් සැකසීමට කොපමණ කාලයක් ගතවේද (මිලිතත්පරවලින්) සහ සමාන FPS හි වඩාත්ම මෑත මිනුම පෙන්වයි. අඩු රාමු කාල සහ ඉහළ FPS වඩා හොඳ කාර්යසාධනය දක්වයි.",
+ "statsMinShort": "වේගවත්ම රාමු කාලය (අඩුම ප්‍රමාදය) සහ ලබාගත් ඉහළම FPS.",
+ "statsMinLong": "නියැදි කවුළුව තුළ තනි රාමුවක් සැකසීමට ගත වූ අවම කාලය නියෝජනය කරයි. මෙය ප්‍රශස්ත තත්ත්වයන්හිදී ඔබේ පද්ධතිය ලබාගත් උපරිම FPS හා අනුරූප වේ.",
+ "statsMaxShort": "මන්දගාමීතම රාමු කාලය (ඉහළම ප්‍රමාදය) සහ අත්දුටු අවම FPS.",
+ "statsMaxLong": "නියැදි කවුළුව තුළ තනි රාමුවක් සැකසීමට ගත වූ උපරිම කාලය නියෝජනය කරයි. මෙය නරකම තත්ත්වයන්හිදී ඔබේ පද්ධතිය ලබාගත් අවම FPS හා අනුරූප වේ. ඉඳහිට ඉහළ යාම් සාමාන්‍යයි, නමුත් නිරන්තරයෙන් ඉහළ අගයන් කාර්යසාධන ගැටළු දක්වයි.",
+ "statsMeanShort": "සියලු නියැදි හරහා සාමාන්‍ය රාමු කාලය සහ FPS.",
+ "statsMeanLong": "නියැදි කවුළුව තුළ මනින ලද සියලු රාමු කාලවල අංක ගණිත මධ්‍යන්‍යය සහ අනුරූප FPS. මෙය කාර්යසාධනයේ හොඳ සමස්ත පින්තූරයක් ලබාදෙයි, නමුත් අපූර්ව අගයන් මගින් විකෘති විය හැක.",
+ "statsMedianShort": "සියලු රාමු කාලවල මධ්‍ය අගය (50 වන ප්‍රතිශතය).",
+ "statsMedianLong": "මධ්‍යස්ථය යනු සියලු රාමු කාල වේගවත්ම සිට මන්දගාමීතම දක්වා වර්ග කළ විට මධ්‍ය අගයයි. මධ්‍යන්‍යයට වෙනස්ව, මධ්‍යස්ථය අපූර්ව අගයන්ගෙන් බලපෑමට ලක් නොවන බැවින්, සාමාන්‍ය කාර්යසාධනයේ වඩාත් ස්ථායී දර්ශකයකි.",
+ "statsStdDevShort": "රාමු කාල විචලනය මනිනවා. CV% සාපේක්ෂ විචලනයයි.",
+ "statsStdDevLong": "සම්මත අපගමනය රාමු කාලවල විචලන ප්‍රමාණය මනිනවා. අඩු අගයන් වඩාත් ස්ථාවර කාර්යසාධනය දක්වයි. විචලන සංගුණකය (CV%) මෙම විචලනය මධ්‍යන්‍යයේ ප්‍රතිශතයක් ලෙස ප්‍රකාශ කරයි, විවිධ රාමු අනුපාතවල ස්ථායිතාව සංසන්දනය කිරීම පහසු කරයි. අඩු CV% වඩාත් ස්ථායී කාර්යසාධනය දක්වයි.",
+ "aiTranslatedTooltip": "මෙම පරිවර්තනය AI මඟින් ජනනය කරන ලද අතර දෝෂ අඩංගු විය හැක. ඔබ මෙම භාෂාව කතා කරන්නේ නම්, GitHub හි pull request එකක් විවෘත කිරීමෙන් වැඩිදියුණු කිරීමට උපකාර කළ හැක!",
+ "humanValidatedTooltip": "මෙම පරිවර්තනය මිනිස් පරිවර්තකයෙකු විසින් සමාලෝචනය කර තහවුරු කර ඇත.",
+ "helpTranslate": "SkellyCam පරිවර්තනය කිරීමට උපකාර කරන්න",
+ "failedToFetch": "ලබා ගැනීමට අසමත් විය",
+ "recordings": "පටිගත කිරීම්",
+ "noRecordingsFound": "පටිගත කිරීම් හමු නොවීය. අතින් පූරණය කිරීමට ඉහත මාර්ගයක් ඇතුළත් කරන්න.",
+ "noCamerasDetected": "කැමරා හඳුනාගෙන නැත",
+ "clickRefreshToScan": "ලබා ගත හැකි කැමරා පරිලෝකනය කිරීමට නැවුම් කරන්න ක්ලික් කරන්න",
+ "waitingForData": "දත්ත බලාපොරොත්තුවෙන්…",
+ "load": "පූරණය",
+ "refresh": "නැවුම් කරන්න",
+ "available": "ලබා ගත හැක",
+ "menuFile": "ගොනුව",
+ "menuView": "දසුන",
+ "menuCamera": "කැමරාව",
+ "menuRecording": "පටිගත කිරීම",
+ "menuHelp": "උදව්",
+ "menuDetectCameras": "කැමරා හඳුනාගන්න",
+ "menuConnectCameras": "කැමරා සම්බන්ධ කරන්න",
+ "menuCloseAllCameras": "සියලුම කැමරා වසන්න",
+ "menuOpenRecordingFolder": "පටිගත කිරීමේ ෆෝල්ඩරය විවෘත කරන්න…",
+ "menuToggleSidebar": "පැති තීරුව මාරු කරන්න",
+ "menuToggleTheme": "තේමාව මාරු කරන්න",
+ "menuToggleFullScreen": "පූර්ණ තිරය",
+ "menuPauseUnpause": "විරාමය / නැවත ආරම්භ",
+ "menuConnectApplySettings": "සම්බන්ධ / සැකසුම් යොදන්න",
+ "menuCloseAll": "සියල්ල වසන්න",
+ "menuDocumentation": "ලේඛනකරණය",
+ "menuGitHubRepository": "GitHub ගබඩාව",
+ "menuReportIssue": "ගැටලුවක් වාර්තා කරන්න…",
+ "menuAbout": "SkellyCam ගැන",
+ "menuPlayback": "නැවත ධාවනය",
+ "videoPlayback": "නැවත ධාවනය",
+ "copyLogsToClipboard": "ලොග් පසුරු පුවරුවට පිටපත් කරන්න",
+ "saveLogsToFile": "ලොග් ගොනුවට සුරකින්න",
+ "copied": "පිටපත් කළා!",
+ "timestampFromRecording": "පටිගත කිරීමේ දත්ත වලින් කාල මුද්‍රාව",
+ "menuCheckForUpdates": "Check for Updates…",
+ "updateAvailable": "Update available",
+ "updateAvailableMessage": "Version {{version}} is available",
+ "downloading": "Downloading…",
+ "downloadComplete": "Download complete",
+ "restartToUpdate": "Restart to update",
+ "checkForUpdates": "Check for Updates",
+ "upToDate": "You are up to date",
+ "updateError": "Update check failed"
+}
diff --git a/freemocap-ui-old/src/i18n/locales/sr-srpski.json b/freemocap-ui-old/src/i18n/locales/sr-srpski.json
new file mode 100644
index 00000000..669be30b
--- /dev/null
+++ b/freemocap-ui-old/src/i18n/locales/sr-srpski.json
@@ -0,0 +1,258 @@
+{
+ "_meta": {
+ "locale": "sr",
+ "translationSource": "ai-generated",
+ "lastUpdated": "2026-02-23"
+ },
+ "appName": "SkellyCam",
+ "appNameDecorated": "SkellyCam 💀📸",
+ "welcomeTitle": "Добро дошли у SkellyCam",
+ "welcomeSubtitle": "Снимајте и гледајте синхронизоване видео записе",
+ "sendAnonymousPings": "Шаљи анонимне пингове коришћења",
+ "footerWith": "са",
+ "footerFrom": "од",
+ "footerOrgName": "FreeMoCap Foundation",
+ "home": "Почетна",
+ "cameras": "Камере",
+ "videos": "Видео записи",
+ "expandSidebar": "Прошири бочну траку",
+ "collapseSidebar": "Скупи бочну траку",
+ "startRecording": "Почни снимање",
+ "stopRecording": "Заустави снимање",
+ "toggleTheme": "промени тему",
+ "switchToDark": "Пребаци на тамни режим",
+ "switchToLight": "Пребаци на светли режим",
+ "connectWebSocket": "Повежи WebSocket",
+ "disconnectWebSocket": "Прекини WebSocket",
+ "launchServer": "Покрени сервер",
+ "stopServer": "Заустави сервер",
+ "browseForExecutable": "Потражи извршну датотеку",
+ "refreshCandidates": "Освежи кандидате",
+ "executable": "Извршна датотека",
+ "host": "Хост",
+ "port": "Порт",
+ "cameraCount_one": "{{count}} камера",
+ "cameraCount_other": "{{count}} камера",
+ "connectedCameras": "Повезане камере",
+ "availableCameras": "Доступне камере",
+ "noCamerasConnected": "Ниједна камера није повезана",
+ "detectCameras": "Откриј доступне камере",
+ "clearCameraSettings": "Обриши сачувана подешавања камере из меморије",
+ "copySettingsToAll": "Копирај подешавања на све камере",
+ "recordingTag": "Ознака снимања",
+ "recordingTagPlaceholder": "Опциона ознака",
+ "recordingDirectory": "Директоријум снимања",
+ "recordingFolderPath": "Путања фасцикле снимања",
+ "delayStart": "Одложи почетак",
+ "seconds": "Секунде",
+ "subfolder": "Подфасцикла",
+ "subfolderPlaceholder": "Назив подфасцикле",
+ "baseName": "Основни назив",
+ "increment": "Инкремент",
+ "resolution": "Резолуција",
+ "fps": "FPS",
+ "width": "Ширина",
+ "height": "Висина",
+ "columns": "Колоне",
+ "auto": "Аутоматски",
+ "manual": "Ручно",
+ "custom": "Прилагођено",
+ "current": "Тренутно",
+ "recommend": "Препоручи",
+ "cameraRotation": "ротација камере",
+ "selectCameraRotation": "Изаберите ротацију слике камере",
+ "exposureControl": "Изаберите између аутоматске или ручне контроле експозиције",
+ "framerateControl": "Изаберите између аутоматске или ручне контроле брзине кадрова",
+ "adjustExposure": "Подесите време експозиције, нпр. cv2.VideoCapture.set(cv2.CAP_PROP_EXPOSURE, value)",
+ "setTargetFps": "Подесите циљне кадрове у секунди (FPS) за снимање камером",
+ "recordingCaptureFps": "Брзина кадрова снимања",
+ "playbackSpeed": "Брзина репродукције (не утиче на fps снимања)",
+ "framerateTimeline": "Временска линија брзине кадрова",
+ "framerateDistribution": "Дистрибуција брзине кадрова",
+ "timelineView": "Приказ временске линије",
+ "distributionView": "Приказ дистрибуције",
+ "combinedView": "Комбиновани приказ",
+ "min": "Мин",
+ "max": "Макс",
+ "mean": "Средња вредност",
+ "median": "Медијана",
+ "stdDevCv": "StdDev/CV",
+ "source": "Извор",
+ "selectAll": "Изабери све",
+ "loadSynchronizedVideos": "Учитај синхронизоване видео записе",
+ "loadSynchronizedVideosDescription": "Ова страница вам омогућава да учитате и синхронизујете претходно снимљене видео записе.",
+ "automaticallySynchronizeVideos": "Аутоматски синхронизуј видео записе",
+ "extractFramesOnLoad": "Извуци кадрове при учитавању",
+ "generateThumbnails": "Генериши минијатуре",
+ "noVideosLoaded": "Нема учитаних видео записа",
+ "filterVideos": "Филтрирај видео записе...",
+ "openVideo": "Отвори видео",
+ "openFolder": "Отвори фасциклу у претраживачу датотека",
+ "videoFolderPath": "Путања видео фасцикле",
+ "jumpToStart": "Скочи на почетак (Home)",
+ "jumpToEnd": "Скочи на крај (End)",
+ "loopOn": "Петља је укључена (L за пребацивање)",
+ "loopOff": "Репродукција у петљи (L)",
+ "syncInfo": "Информације о синхронизацији",
+ "syncInfoTitle": "Синхронизација више камера можда неће бити савршена на нивоу кадрова",
+ "syncInfoBody": "Репродукција видеа у прегледачу не гарантује тачну синхронизацију узорака преко више токова. Плејер користи стратегију вођа-пратилац и коригује одступање када премаши малу толеранцију, али може доћи до благе десинхронизације (1–2 кадра), посебно при великим брзинама репродукције или када је прегледач под оптерећењем. За анализу тачну на нивоу кадрова користите необрађене CSV фајлове временских ознака укључене у сваки снимак.",
+ "previousFrame": "Претходни кадар (← / Shift+← за 10)",
+ "nextFrame": "Следећи кадар (→ / Shift+→ за 10)",
+ "zoomIn": "Увећај",
+ "zoomOut": "Умањи",
+ "resetZoom": "Ресетуј зум",
+ "playbackSettings": "Подешавања репродукције",
+ "totalRecordingSize": "Укупна величина снимка на диску",
+ "estimatedTime": "Процењено време (кадар ÷ fps снимања)",
+ "estimatedDuration": "Процењено трајање (укупно кадрова ÷ fps снимања)",
+ "estimatedFromFrameNumber": "Процењено из броја кадра × fps снимања — није прочитано из података временске ознаке",
+ "frameCountPerCamera": "Број кадрова по камери",
+ "cameraStreams": "Стримови камера у овом снимку",
+ "backToRecordings": "Назад на снимке",
+ "errorsDetected": "Откривене грешке",
+ "somethingWentWrong": "Нешто није у реду :(",
+ "searchLogs": "Претражи логове...",
+ "filter": "Филтер…",
+ "refreshMicrophoneList": "Освежи листу микрофона",
+ "date": "Датум",
+ "name": "Назив",
+ "size": "Величина",
+ "duration": "Трајање",
+ "frames": "Кадрови",
+ "timestamp": "Временска ознака",
+ "language": "Језик",
+ "aiTranslated": "AI преведено",
+ "humanTranslated": "Преведено од стране човека",
+ "humanValidated": "Валидирано од стране човека",
+ "connectCameras": "Повежи се на изабране камере или ажурирај повезане камере",
+ "resumeStreaming": "Настави стримовање",
+ "pauseStreaming": "Паузирај стримовање",
+ "closeAllCameras": "Затвори све камере",
+ "framerate": "Брзина кадрова",
+ "exposure": "Експозиција",
+ "fileLabel": "Датотека",
+ "timeDelta": "Временска разлика",
+ "pathLabel": "Путања",
+ "exceptionDetails": "Детаљи изузетка",
+ "stackTrace": "Стек траг",
+ "loadingVideos": "Учитавање видео записа… ({{ready}}/{{total}} спремно)",
+ "gridColumns": "Колоне мреже",
+ "settings": "Подешавања",
+ "appearance": "Изглед",
+ "themeMode": "Тема",
+ "darkMode": "Тамно",
+ "lightMode": "Светло",
+ "languageSettings": "Језик и локализација",
+ "showTranslationIndicator": "Прикажи индикатор извора превода",
+ "showTranslationIndicatorDescription": "Прикажи значку када се користе AI генерисани преводи",
+ "translationSourceLabel": "Извор превода",
+ "general": "Опште",
+ "about": "О програму",
+ "version": "Верзија",
+ "serverSettings": "Сервер",
+ "recordingSettings": "Подешавања снимања",
+ "videoLoadingSettings": "Подешавања учитавања видеа",
+ "connected": "Повезано",
+ "connecting": "Повезивање…",
+ "disconnected": "Прекинуто",
+ "disconnect": "Прекини везу",
+ "connect": "Повежи",
+ "off": "Искључено",
+ "running": "Покренуто",
+ "stopped": "Заустављено",
+ "working": "Ради…",
+ "invalid": "Неважеће",
+ "autoLaunch": "Аутоматско покретање",
+ "autoConnect": "Аутоматско повезивање",
+ "runningPath": "Покренуто: {{path}}",
+ "noMicrophone": "Нема микрофона",
+ "audioRecordingEnabled": "Снимање звука омогућено",
+ "noMicrophoneSelected": "Микрофон није изабран",
+ "recordingName": "Назив снимка: {{name}}",
+ "startingIn": "Почиње за {{countdown}}...",
+ "stopping": "Заустављање...",
+ "starting": "Покретање...",
+ "stopRecordingButton": "🔴 Заустави снимање",
+ "startRecordingButton": "🔴 Почни снимање",
+ "camerasCount": "Камере ({{count}})",
+ "availableCamerasCount": "Доступне ({{count}})",
+ "server": "Сервер",
+ "display": "Екран",
+ "rawMessage": "Необрађена порука",
+ "cameraPerformanceMetrics": "Метрике перформанси камере",
+ "serverLogs": "Логови сервера",
+ "sortBy": "Сортирај {{direction}}",
+ "waitingForCameraStreams": "Чекање на стримове камера...",
+ "loggingPaused": "Логовање паузирано",
+ "noLogsToDisplay": "Нема логова за приказ",
+ "closeSettings": "Затвори подешавања",
+ "gridSettings": "Подешавања мреже",
+ "clickToShowLess": "Кликни за мање",
+ "clickToLearnMore": "Кликни за више",
+ "samples": "узорци",
+ "framerateOverTime": "Брзина кадрова током времена",
+ "framerateFps": "Брзина кадрова (fps)",
+ "capturesFramesFromCamera": "Снима кадрове са камере.",
+ "rendersReceivedFrames": "Приказује примљене кадрове на екрану.",
+ "displayTooltipLong": "Екран представља перформансе рендеровања корисничког интерфејса. Показује колико брзо ваш екран прима и приказује кадрове. Проблеми са перформансама овде неће утицати на квалитет снимања, али могу утицати на вашу способност да пратите камере у реалном времену.",
+ "statsSourceShort": "Екран приказује кадрове, Сервер снима кадрове.",
+ "statsSourceLong": "Сервер је стварна брзина којом се кадрови преузимају/снимају са камере, док је екран брзина којом се примају и приказују. Skellycam даје приоритет перформансама на страни сервера за квалитет снимања, тако да би тај број требало да остане стабилнији. Ако се брзина кадрова екрана разликује од сервера, то указује да су ресурси вашег система преоптерећени. Размислите о коришћењу мање камера или смањењу брзине кадрова/резолуције.",
+ "statsCurrentShort": "Најновије време кадра и одговарајући FPS.",
+ "statsCurrentLong": "Ово приказује најновије мерење колико времена треба за обраду једног кадра (у милисекундама) и еквивалентне кадрове у секунди (FPS). Мање време кадра и већи FPS указују на боље перформансе.",
+ "statsMinShort": "Најбрже време кадра (најмање кашњење) и највећи постигнути FPS.",
+ "statsMinLong": "Ово представља минимално време потребно за обраду једног кадра током прозора узорковања. Ово одговара максималном FPS-у који је ваш систем постигао у оптималним условима.",
+ "statsMaxShort": "Најспорије време кадра (највеће кашњење) и најмањи доживљени FPS.",
+ "statsMaxLong": "Ово представља максимално време потребно за обраду једног кадра током прозора узорковања. Ово одговара минималном FPS-у који је ваш систем постигао у најгорим условима. Повремени скокови су нормални, али стално високе вредности могу указивати на проблеме са перформансама.",
+ "statsMeanShort": "Просечно време кадра и FPS за све узорке.",
+ "statsMeanLong": "Аритметичка средина свих времена кадрова измерених током прозора узорковања и одговарајући FPS. Ово даје добру укупну слику перформанси, али може бити искривљено екстремним вредностима.",
+ "statsMedianShort": "Средња вредност свих времена кадрова (50. перцентил).",
+ "statsMedianLong": "Медијана представља средњу вредност када су сва времена кадрова сортирана од најбржег до најспоријег. За разлику од средње вредности, медијана није под утицајем екстремних вредности, што је чини стабилнијим показатељем типичних перформанси.",
+ "statsStdDevShort": "Мери варијабилност времена кадра. CV% је релативна варијабилност.",
+ "statsStdDevLong": "Стандардна девијација мери количину варијације у временима кадрова. Ниже вредности указују на конзистентније перформансе. Коефицијент варијације (CV%) изражава ову варијабилност као проценат средње вредности, олакшавајући поређење стабилности на различитим брзинама кадрова. Нижи CV% указује на стабилније перформансе.",
+ "aiTranslatedTooltip": "Овај превод је генерисан помоћу вештачке интелигенције и може садржати грешке. Ако говорите овај језик, можете помоћи да га побољшате отварањем pull request-а на GitHub-у!",
+ "humanValidatedTooltip": "Овај превод је прегледан и валидиран од стране људског преводиоца.",
+ "helpTranslate": "Помозите у превођењу SkellyCam-а",
+ "failedToFetch": "Преузимање неуспешно",
+ "recordings": "Снимци",
+ "noRecordingsFound": "Нема пронађених снимака. Унесите путању изнад за ручно учитавање.",
+ "noCamerasDetected": "Камере нису откривене",
+ "clickRefreshToScan": "Кликните на освежи за скенирање доступних камера",
+ "waitingForData": "Чекање на податке…",
+ "load": "Учитај",
+ "refresh": "Освежи",
+ "available": "Доступно",
+ "menuFile": "Датотека",
+ "menuView": "Приказ",
+ "menuCamera": "Камера",
+ "menuRecording": "Снимање",
+ "menuHelp": "Помоћ",
+ "menuDetectCameras": "Откријте камере",
+ "menuConnectCameras": "Повежите камере",
+ "menuCloseAllCameras": "Затвори све камере",
+ "menuOpenRecordingFolder": "Отвори фасциклу снимања…",
+ "menuToggleSidebar": "Укључи/искључи бочну траку",
+ "menuToggleTheme": "Промени тему",
+ "menuToggleFullScreen": "Цео екран",
+ "menuPauseUnpause": "Пауза / Настави",
+ "menuConnectApplySettings": "Повежи / Примени подешавања",
+ "menuCloseAll": "Затвори све",
+ "menuDocumentation": "Документација",
+ "menuGitHubRepository": "GitHub складиште",
+ "menuReportIssue": "Пријавите проблем…",
+ "menuAbout": "О SkellyCam-у",
+ "menuPlayback": "Репродукција",
+ "videoPlayback": "Репродукција",
+ "copyLogsToClipboard": "Копирај логове у клипборд",
+ "saveLogsToFile": "Сачувај логове у фајл",
+ "copied": "Копирано!",
+ "timestampFromRecording": "Временска ознака из података снимка",
+ "menuCheckForUpdates": "Check for Updates…",
+ "updateAvailable": "Update available",
+ "updateAvailableMessage": "Version {{version}} is available",
+ "downloading": "Downloading…",
+ "downloadComplete": "Download complete",
+ "restartToUpdate": "Restart to update",
+ "checkForUpdates": "Check for Updates",
+ "upToDate": "You are up to date",
+ "updateError": "Update check failed"
+}
diff --git a/freemocap-ui-old/src/i18n/locales/sv-svenska.json b/freemocap-ui-old/src/i18n/locales/sv-svenska.json
new file mode 100644
index 00000000..2c9e5ab1
--- /dev/null
+++ b/freemocap-ui-old/src/i18n/locales/sv-svenska.json
@@ -0,0 +1,258 @@
+{
+ "_meta": {
+ "locale": "sv",
+ "translationSource": "ai-generated",
+ "lastUpdated": "2026-02-23"
+ },
+ "appName": "SkellyCam",
+ "appNameDecorated": "SkellyCam 💀📸",
+ "welcomeTitle": "Välkommen till SkellyCam",
+ "welcomeSubtitle": "Spela in och visa synkroniserade videor",
+ "sendAnonymousPings": "Skicka anonym användningsdata",
+ "footerWith": "med",
+ "footerFrom": "från",
+ "footerOrgName": "FreeMoCap Foundation",
+ "home": "Hem",
+ "cameras": "Kameror",
+ "videos": "Videor",
+ "expandSidebar": "Expandera sidopanelen",
+ "collapseSidebar": "Dölj sidopanelen",
+ "startRecording": "Starta inspelning",
+ "stopRecording": "Stoppa inspelning",
+ "toggleTheme": "byt tema",
+ "switchToDark": "Byt till mörkt läge",
+ "switchToLight": "Byt till ljust läge",
+ "connectWebSocket": "Anslut WebSocket",
+ "disconnectWebSocket": "Koppla från WebSocket",
+ "launchServer": "Starta server",
+ "stopServer": "Stoppa server",
+ "browseForExecutable": "Bläddra efter körbar fil",
+ "refreshCandidates": "Uppdatera kandidater",
+ "executable": "Körbar fil",
+ "host": "Värd",
+ "port": "Port",
+ "cameraCount_one": "{{count}} kamera",
+ "cameraCount_other": "{{count}} kameror",
+ "connectedCameras": "Anslutna kameror",
+ "availableCameras": "Tillgängliga kameror",
+ "noCamerasConnected": "Inga kameror anslutna",
+ "detectCameras": "Upptäck tillgängliga kameror",
+ "clearCameraSettings": "Rensa kamerainställningar",
+ "copySettingsToAll": "Kopiera inställningar till alla",
+ "recordingTag": "Inspelningstagg",
+ "recordingTagPlaceholder": "Valfri tagg",
+ "recordingDirectory": "Inspelningsmapp",
+ "recordingFolderPath": "Sökväg inspelningsmapp",
+ "delayStart": "Fördröjd start",
+ "seconds": "Sekunder",
+ "subfolder": "Undermapp",
+ "subfolderPlaceholder": "Undermappsnamn",
+ "baseName": "Basnamn",
+ "increment": "Ökning",
+ "resolution": "Upplösning",
+ "fps": "FPS",
+ "width": "Bredd",
+ "height": "Höjd",
+ "columns": "Kolumner",
+ "auto": "Auto",
+ "manual": "Manuell",
+ "custom": "Anpassad",
+ "current": "Aktuell",
+ "recommend": "Rekommenderad",
+ "cameraRotation": "kamerarotation",
+ "selectCameraRotation": "Välj kamerabildrotation",
+ "exposureControl": "Automatisk eller manuell exponeringskontroll",
+ "framerateControl": "Automatisk eller manuell bildfrekvens",
+ "adjustExposure": "Justera exponeringstid",
+ "setTargetFps": "Ställ in mål-FPS för inspelning",
+ "recordingCaptureFps": "Inspelnings-FPS",
+ "playbackSpeed": "Uppspelningshastighet",
+ "framerateTimeline": "Bildfrekvensdidlinje",
+ "framerateDistribution": "Bildfrekvensdistribution",
+ "timelineView": "Tidslinjevy",
+ "distributionView": "Distributionsvy",
+ "combinedView": "Kombinerad vy",
+ "min": "Min",
+ "max": "Max",
+ "mean": "Medel",
+ "median": "Median",
+ "stdDevCv": "StdAvv/CV",
+ "source": "Källa",
+ "selectAll": "Välj alla",
+ "loadSynchronizedVideos": "Ladda synkroniserade videor",
+ "loadSynchronizedVideosDescription": "Den här sidan låter dig ladda och synkronisera förinspelade videor.",
+ "automaticallySynchronizeVideos": "Synkronisera videor automatiskt",
+ "extractFramesOnLoad": "Extrahera bildrutor vid laddning",
+ "generateThumbnails": "Generera miniatyrbilder",
+ "noVideosLoaded": "Inga videor laddade",
+ "filterVideos": "Filtrera videor...",
+ "openVideo": "Öppna video",
+ "openFolder": "Öppna mapp i utforskaren",
+ "videoFolderPath": "Sökväg videomapp",
+ "jumpToStart": "Hoppa till början (Home)",
+ "jumpToEnd": "Hoppa till slut (End)",
+ "loopOn": "Upprepning är på (L för att växla)",
+ "loopOff": "Uppspelning i loop (L)",
+ "syncInfo": "Synkinfo",
+ "syncInfoTitle": "Synkronisering av flera kameror kanske inte är bildruteexakt",
+ "syncInfoBody": "Videouppspelning i webbläsaren garanterar inte sampelexakt synkronisering över flera strömmar. Spelaren använder en ledar-följar-strategi och korrigerar drift när den överskrider en liten tolerans, men mindre desynkronisering (1–2 bildrutor) kan förekomma, särskilt vid höga uppspelningshastigheter eller när webbläsaren är belastad. För bildruteexakt analys, använd de råa tidsstämpel-CSV-filerna som ingår i varje inspelning.",
+ "previousFrame": "Föregående bildruta (← / Shift+← för 10)",
+ "nextFrame": "Nästa bildruta (→ / Shift+→ för 10)",
+ "zoomIn": "Zooma in",
+ "zoomOut": "Zooma ut",
+ "resetZoom": "Återställ zoom",
+ "playbackSettings": "Uppspelningsinställningar",
+ "totalRecordingSize": "Total inspelningsstorlek på disk",
+ "estimatedTime": "Uppskattad tid (bild ÷ fps)",
+ "estimatedDuration": "Uppskattad varaktighet (totala bilder ÷ fps)",
+ "estimatedFromFrameNumber": "Uppskattat från bildnummer × fps",
+ "frameCountPerCamera": "Bildrutor per kamera",
+ "cameraStreams": "Kameraströmmar i denna inspelning",
+ "backToRecordings": "Tillbaka till inspelningar",
+ "errorsDetected": "Fel upptäckta",
+ "somethingWentWrong": "Något gick fel :(",
+ "searchLogs": "Sök i loggar...",
+ "filter": "Filtrera…",
+ "refreshMicrophoneList": "Uppdatera mikrofonlista",
+ "date": "Datum",
+ "name": "Namn",
+ "size": "Storlek",
+ "duration": "Varaktighet",
+ "frames": "Bildrutor",
+ "timestamp": "Tidsstämpel",
+ "language": "Språk",
+ "aiTranslated": "AI-översättning",
+ "humanTranslated": "Mänsklig översättning",
+ "humanValidated": "Humanvaliderad",
+ "connectCameras": "Anslut till valda kameror",
+ "resumeStreaming": "Återuppta strömning",
+ "pauseStreaming": "Pausa strömning",
+ "closeAllCameras": "Stäng alla kameror",
+ "framerate": "Bildfrekvens",
+ "exposure": "Exponering",
+ "fileLabel": "Fil",
+ "timeDelta": "Tidsdelta",
+ "pathLabel": "Sökväg",
+ "exceptionDetails": "Undantagsdetaljer",
+ "stackTrace": "Stackspårning",
+ "loadingVideos": "Laddar videor… ({{ready}}/{{total}} klara)",
+ "gridColumns": "Rutnätskolumner",
+ "settings": "Inställningar",
+ "appearance": "Utseende",
+ "themeMode": "Tema",
+ "darkMode": "Mörkt",
+ "lightMode": "Ljust",
+ "languageSettings": "Språk och lokalisering",
+ "showTranslationIndicator": "Visa översättningskälla",
+ "showTranslationIndicatorDescription": "Visa märke vid AI-översättningar",
+ "translationSourceLabel": "Översättningskälla",
+ "general": "Allmänt",
+ "about": "Om",
+ "version": "Version",
+ "serverSettings": "Server",
+ "recordingSettings": "Inspelningsinställningar",
+ "videoLoadingSettings": "Videoladdningsinställningar",
+ "connected": "Ansluten",
+ "connecting": "Ansluter…",
+ "disconnected": "Frånkopplad",
+ "disconnect": "Koppla från",
+ "connect": "Anslut",
+ "off": "Av",
+ "running": "Körs",
+ "stopped": "Stoppad",
+ "working": "Bearbetar…",
+ "invalid": "Ogiltig",
+ "autoLaunch": "Autostart",
+ "autoConnect": "Autoanslut",
+ "runningPath": "Körs: {{path}}",
+ "noMicrophone": "Ingen mikrofon",
+ "audioRecordingEnabled": "Ljudinspelning aktiverad",
+ "noMicrophoneSelected": "Ingen mikrofon vald",
+ "recordingName": "Inspelningsnamn: {{name}}",
+ "startingIn": "Startar om {{countdown}}...",
+ "stopping": "Stoppar...",
+ "starting": "Startar...",
+ "stopRecordingButton": "🔴 Stoppa inspelning",
+ "startRecordingButton": "🔴 Starta inspelning",
+ "camerasCount": "Kameror ({{count}})",
+ "availableCamerasCount": "Tillgängliga ({{count}})",
+ "server": "Server",
+ "display": "Visning",
+ "rawMessage": "Råmeddelande",
+ "cameraPerformanceMetrics": "Kameraprestanda",
+ "serverLogs": "Serverloggar",
+ "sortBy": "Sortera {{direction}}",
+ "waitingForCameraStreams": "Väntar på kameraströmmar...",
+ "loggingPaused": "Loggning pausad",
+ "noLogsToDisplay": "Inga loggar att visa",
+ "closeSettings": "Stäng inställningar",
+ "gridSettings": "Rutnätsinställningar",
+ "clickToShowLess": "Klicka för att visa mindre",
+ "clickToLearnMore": "Klicka för att läsa mer",
+ "samples": "sampel",
+ "framerateOverTime": "Bildfrekvens över tid",
+ "framerateFps": "Bildfrekvens (fps)",
+ "capturesFramesFromCamera": "Fångar bildrutor från kameran.",
+ "rendersReceivedFrames": "Renderar mottagna bildrutor på skärmen.",
+ "displayTooltipLong": "Visningen representerar UI-renderingsprestanda. Den visar hur snabbt din skärm tar emot och renderar bildrutor. Prestandaproblem här påverkar inte inspelningskvaliteten men kan påverka din förmåga att övervaka kameror i realtid.",
+ "statsSourceShort": "Display renderar bilder, servern fångar bilder.",
+ "statsSourceLong": "Servern är den faktiska hastigheten som bildrutor hämtas/spelas in från kameran, medan visningen är hastigheten de tas emot och renderas. SkellyCam prioriterar serversidans prestanda för inspelningskvalitet, så det numret bör förbli mer stabilt. Om visningens bildfrekvens avviker från servern indikerar det att dina systemresurser är belastade. Överväg att använda färre kameror eller minska bildfrekvens/upplösning.",
+ "statsCurrentShort": "Senaste bildtid och FPS.",
+ "statsCurrentLong": "Visar den senaste mätningen av hur lång tid det tar att behandla en enskild bildruta (i millisekunder) och motsvarande bildrutor per sekund (FPS). Lägre bildrutetider och högre FPS indikerar bättre prestanda.",
+ "statsMinShort": "Snabbaste bildtid och högsta FPS.",
+ "statsMinLong": "Representerar den minimala tiden att behandla en enskild bildruta under samplingsperioden. Motsvarar det maximala FPS ditt system uppnådde under optimala förhållanden.",
+ "statsMaxShort": "Långsammaste bildtid och lägsta FPS.",
+ "statsMaxLong": "Representerar den maximala tiden att behandla en enskild bildruta under samplingsperioden. Motsvarar det minimala FPS under sämsta förhållanden. Tillfälliga toppar är normala, men konsekvent höga värden kan indikera prestandaproblem.",
+ "statsMeanShort": "Genomsnittlig bildtid och FPS över alla sampel.",
+ "statsMeanLong": "Det aritmetiska medelvärdet av alla uppmätta bildrutetider under samplingsperioden och motsvarande FPS. Ger en bra övergripande bild av prestandan men kan påverkas av extremvärden.",
+ "statsMedianShort": "Medianvärde av alla bildtider (50:e percentilen).",
+ "statsMedianLong": "Medianen representerar mittvärdet när alla bildrutetider sorteras från snabbast till långsammast. Till skillnad från medelvärdet påverkas medianen inte av extrema avvikelser, vilket gör den till en mer stabil indikator på typisk prestanda.",
+ "statsStdDevShort": "Mäter bildtidsvariabilitet. CV% är relativ.",
+ "statsStdDevLong": "Standardavvikelsen mäter variationen i bildrutetider. Lägre värden indikerar mer konsekvent prestanda. Variationskoefficienten (CV%) uttrycker denna variabilitet som en procent av medelvärdet, vilket underlättar jämförelse av stabilitet över olika bildhastigheter. Lägre CV% indikerar mer stabil prestanda.",
+ "aiTranslatedTooltip": "Denna översättning genererades av AI och kan innehålla fel. Om du talar detta språk, hjälp oss förbättra den!",
+ "humanValidatedTooltip": "Denna översättning har granskats av en mänsklig översättare.",
+ "helpTranslate": "Hjälp till att översätta SkellyCam",
+ "failedToFetch": "Hämtning misslyckades",
+ "recordings": "Inspelningar",
+ "noRecordingsFound": "Inga inspelningar hittades. Ange en sökväg ovan för att ladda manuellt.",
+ "noCamerasDetected": "Inga kameror upptäckta",
+ "clickRefreshToScan": "Klicka på uppdatera för att söka efter kameror",
+ "waitingForData": "Väntar på data…",
+ "load": "Ladda",
+ "refresh": "Uppdatera",
+ "available": "Tillgänglig",
+ "menuFile": "Arkiv",
+ "menuView": "Visa",
+ "menuCamera": "Kamera",
+ "menuRecording": "Inspelning",
+ "menuHelp": "Hjälp",
+ "menuDetectCameras": "Identifiera kameror",
+ "menuConnectCameras": "Anslut kameror",
+ "menuCloseAllCameras": "Stäng alla kameror",
+ "menuOpenRecordingFolder": "Öppna inspelningsmapp…",
+ "menuToggleSidebar": "Visa/dölj sidopanel",
+ "menuToggleTheme": "Byt tema",
+ "menuToggleFullScreen": "Helskärm",
+ "menuPauseUnpause": "Pausa / Återuppta",
+ "menuConnectApplySettings": "Anslut / Tillämpa inställningar",
+ "menuCloseAll": "Stäng alla",
+ "menuDocumentation": "Dokumentation",
+ "menuGitHubRepository": "GitHub-förråd",
+ "menuReportIssue": "Rapportera ett problem…",
+ "menuAbout": "Om SkellyCam",
+ "menuPlayback": "Uppspelning",
+ "videoPlayback": "Uppspelning",
+ "copyLogsToClipboard": "Kopiera loggar till urklipp",
+ "saveLogsToFile": "Spara loggar till fil",
+ "copied": "Kopierat!",
+ "timestampFromRecording": "Tidsstämpel från inspelningsdata",
+ "menuCheckForUpdates": "Check for Updates…",
+ "updateAvailable": "Update available",
+ "updateAvailableMessage": "Version {{version}} is available",
+ "downloading": "Downloading…",
+ "downloadComplete": "Download complete",
+ "restartToUpdate": "Restart to update",
+ "checkForUpdates": "Check for Updates",
+ "upToDate": "You are up to date",
+ "updateError": "Update check failed"
+}
diff --git a/freemocap-ui-old/src/i18n/locales/sw-kiswahili.json b/freemocap-ui-old/src/i18n/locales/sw-kiswahili.json
new file mode 100644
index 00000000..8ae10bca
--- /dev/null
+++ b/freemocap-ui-old/src/i18n/locales/sw-kiswahili.json
@@ -0,0 +1,258 @@
+{
+ "_meta": {
+ "locale": "sw",
+ "translationSource": "ai-generated",
+ "lastUpdated": "2026-02-23"
+ },
+ "appName": "SkellyCam",
+ "appNameDecorated": "SkellyCam 💀📸",
+ "welcomeTitle": "Karibu SkellyCam",
+ "welcomeSubtitle": "Rekodi na Utazame Video Zilizosawazishwa",
+ "sendAnonymousPings": "Tuma pings za matumizi bila kutambulishwa",
+ "footerWith": "na",
+ "footerFrom": "kutoka",
+ "footerOrgName": "FreeMoCap Foundation",
+ "home": "Nyumbani",
+ "cameras": "Kamera",
+ "videos": "Video",
+ "expandSidebar": "Panua upau wa kando",
+ "collapseSidebar": "Kunja upau wa kando",
+ "startRecording": "Anza Kurekodi",
+ "stopRecording": "Simamisha Kurekodi",
+ "toggleTheme": "badilisha mandhari",
+ "switchToDark": "Badilisha hadi hali ya giza",
+ "switchToLight": "Badilisha hadi hali ya mwanga",
+ "connectWebSocket": "Unganisha WebSocket",
+ "disconnectWebSocket": "Tenganisha WebSocket",
+ "launchServer": "Zindua Seva",
+ "stopServer": "Simamisha Seva",
+ "browseForExecutable": "Tafuta programu inayoweza kutekelezwa",
+ "refreshCandidates": "Sasisha wagombea",
+ "executable": "Inayoweza kutekelezwa",
+ "host": "Mwenyeji",
+ "port": "Bandari",
+ "cameraCount_one": "kamera {{count}}",
+ "cameraCount_other": "kamera {{count}}",
+ "connectedCameras": "Kamera Zilizounganishwa",
+ "availableCameras": "Kamera Zinazopatikana",
+ "noCamerasConnected": "Hakuna kamera zilizounganishwa",
+ "detectCameras": "Gundua kamera zinazopatikana",
+ "clearCameraSettings": "Futa mipangilio ya kamera iliyohifadhiwa kwenye kumbukumbu",
+ "copySettingsToAll": "Nakili mipangilio kwa kamera zote",
+ "recordingTag": "Lebo ya Kurekodi",
+ "recordingTagPlaceholder": "Lebo ya hiari",
+ "recordingDirectory": "Saraka ya Kurekodi",
+ "recordingFolderPath": "Njia ya folda ya kurekodi",
+ "delayStart": "Chelewesha Kuanza",
+ "seconds": "Sekunde",
+ "subfolder": "Folda ndogo",
+ "subfolderPlaceholder": "Jina la Folda Ndogo",
+ "baseName": "Jina la Msingi",
+ "increment": "Ongezeko",
+ "resolution": "Ubora",
+ "fps": "FPS",
+ "width": "Upana",
+ "height": "Urefu",
+ "columns": "Safu wima",
+ "auto": "Otomatiki",
+ "manual": "Mwongozo",
+ "custom": "Maalum",
+ "current": "Sasa",
+ "recommend": "Pendekeza",
+ "cameraRotation": "mzunguko wa kamera",
+ "selectCameraRotation": "Chagua mzunguko wa picha ya kamera",
+ "exposureControl": "Chagua kati ya udhibiti wa mfichuo otomatiki au wa mwongozo",
+ "framerateControl": "Chagua kati ya udhibiti wa kasi ya fremu otomatiki au wa mwongozo",
+ "adjustExposure": "Rekebisha muda wa mfichuo, k.m. cv2.VideoCapture.set(cv2.CAP_PROP_EXPOSURE, value)",
+ "setTargetFps": "Weka fremu za lengo kwa sekunde (FPS) kwa kunasa kamera",
+ "recordingCaptureFps": "Kasi ya fremu ya kunasa kurekodi",
+ "playbackSpeed": "Kasi ya kucheza (haiathiri fps ya kurekodi)",
+ "framerateTimeline": "Mstari wa Wakati wa Kasi ya Fremu",
+ "framerateDistribution": "Usambazaji wa Kasi ya Fremu",
+ "timelineView": "Mwonekano wa Mstari wa Wakati",
+ "distributionView": "Mwonekano wa Usambazaji",
+ "combinedView": "Mwonekano Uliounganishwa",
+ "min": "Chini",
+ "max": "Juu",
+ "mean": "Wastani",
+ "median": "Kati",
+ "stdDevCv": "StdDev/CV",
+ "source": "Chanzo",
+ "selectAll": "Chagua Zote",
+ "loadSynchronizedVideos": "Pakia Video Zilizosawazishwa",
+ "loadSynchronizedVideosDescription": "Ukurasa huu utakuruhusu kupakia na kusawazisha video zilizorekodiwa awali.",
+ "automaticallySynchronizeVideos": "Sawazisha video kiotomatiki",
+ "extractFramesOnLoad": "Toa fremu wakati wa kupakia",
+ "generateThumbnails": "Tengeneza picha ndogo",
+ "noVideosLoaded": "Hakuna video zilizopakiwa",
+ "filterVideos": "Chuja video...",
+ "openVideo": "Fungua video",
+ "openFolder": "Fungua folda kwenye kichunguzi cha faili",
+ "videoFolderPath": "Njia ya Folda ya Video",
+ "jumpToStart": "Ruka mwanzoni (Home)",
+ "jumpToEnd": "Ruka mwishoni (End)",
+ "loopOn": "Rudia imewashwa (L kubadilisha)",
+ "loopOff": "Cheza kwa kurudia (L)",
+ "syncInfo": "Taarifa za usawazishaji",
+ "syncInfoTitle": "Usawazishaji wa kamera nyingi huenda usiwe kamili kwa kiwango cha fremu",
+ "syncInfoBody": "Uchezaji wa video kwenye kivinjari haudhaminii usawazishaji sahihi wa sampuli katika mitiririko mingi. Kichezaji hutumia mkakati wa kiongozi-mfuasi na kurekebisha mkengeuko unapozidi uvumilivu mdogo, lakini kutosawazishana kidogo (fremu 1–2) kunaweza kutokea, hasa kwa kasi ya juu ya uchezaji au wakati kivinjari kina mzigo mkubwa. Kwa uchambuzi sahihi wa fremu, tumia faili za CSV za muda halisi zilizojumuishwa katika kila rekodi.",
+ "previousFrame": "Fremu iliyotangulia (← / Shift+← kwa 10)",
+ "nextFrame": "Fremu inayofuata (→ / Shift+→ kwa 10)",
+ "zoomIn": "Kuza Ndani",
+ "zoomOut": "Kuza Nje",
+ "resetZoom": "Rejesha Ukuzaji",
+ "playbackSettings": "Mipangilio ya kucheza",
+ "totalRecordingSize": "Ukubwa wa jumla wa kurekodi kwenye diski",
+ "estimatedTime": "Muda uliokadiriwa (fremu ÷ fps ya kurekodi)",
+ "estimatedDuration": "Muda uliokadiriwa (fremu za jumla ÷ fps ya kurekodi)",
+ "estimatedFromFrameNumber": "Imekadiriwa kutoka kwa nambari ya fremu × fps ya kurekodi — haijasomwa kutoka kwa data ya muda",
+ "frameCountPerCamera": "Idadi ya fremu kwa kamera",
+ "cameraStreams": "Mikondo ya kamera katika rekodi hii",
+ "backToRecordings": "Rudi kwenye rekodi",
+ "errorsDetected": "Makosa yamegunduliwa",
+ "somethingWentWrong": "Kitu kimeharibika :(",
+ "searchLogs": "Tafuta kumbukumbu...",
+ "filter": "Chuja…",
+ "refreshMicrophoneList": "Sasisha orodha ya maikrofoni",
+ "date": "Tarehe",
+ "name": "Jina",
+ "size": "Ukubwa",
+ "duration": "Muda",
+ "frames": "Fremu",
+ "timestamp": "Muhuri wa wakati",
+ "language": "Lugha",
+ "aiTranslated": "Imetafsiriwa na AI",
+ "humanTranslated": "Imetafsiriwa na binadamu",
+ "humanValidated": "Imethibitishwa na binadamu",
+ "connectCameras": "Unganisha kwa kamera zilizochaguliwa au sasisha kamera zilizounganishwa",
+ "resumeStreaming": "Endelea kutiririka",
+ "pauseStreaming": "Simamisha kutiririka",
+ "closeAllCameras": "Funga kamera zote",
+ "framerate": "Kasi ya fremu",
+ "exposure": "Mfichuo",
+ "fileLabel": "Faili",
+ "timeDelta": "Tofauti ya wakati",
+ "pathLabel": "Njia",
+ "exceptionDetails": "Maelezo ya hitilafu",
+ "stackTrace": "Ufuatiliaji wa Rafu",
+ "loadingVideos": "Inapakia video… ({{ready}}/{{total}} tayari)",
+ "gridColumns": "Safu Wima za Gridi",
+ "settings": "Mipangilio",
+ "appearance": "Muonekano",
+ "themeMode": "Mandhari",
+ "darkMode": "Giza",
+ "lightMode": "Mwanga",
+ "languageSettings": "Lugha na Ujanibishaji",
+ "showTranslationIndicator": "Onyesha kiashirio cha chanzo cha tafsiri",
+ "showTranslationIndicatorDescription": "Onyesha beji unapotumia tafsiri zilizozalishwa na AI",
+ "translationSourceLabel": "Chanzo cha tafsiri",
+ "general": "Jumla",
+ "about": "Kuhusu",
+ "version": "Toleo",
+ "serverSettings": "Seva",
+ "recordingSettings": "Mipangilio ya Kurekodi",
+ "videoLoadingSettings": "Mipangilio ya Kupakia Video",
+ "connected": "Imeunganishwa",
+ "connecting": "Inaunganisha…",
+ "disconnected": "Imetenganishwa",
+ "disconnect": "Tenganisha",
+ "connect": "Unganisha",
+ "off": "Imezimwa",
+ "running": "Inafanya kazi",
+ "stopped": "Imesimamishwa",
+ "working": "Inafanya kazi…",
+ "invalid": "Batili",
+ "autoLaunch": "Zindua kiotomatiki",
+ "autoConnect": "Unganisha kiotomatiki",
+ "runningPath": "Inafanya kazi: {{path}}",
+ "noMicrophone": "Hakuna maikrofoni",
+ "audioRecordingEnabled": "Kurekodi sauti kumewezeshwa",
+ "noMicrophoneSelected": "Hakuna maikrofoni iliyochaguliwa",
+ "recordingName": "Jina la Rekodi: {{name}}",
+ "startingIn": "Inaanza kwa {{countdown}}...",
+ "stopping": "Inasimamisha...",
+ "starting": "Inaanza...",
+ "stopRecordingButton": "🔴 Simamisha Kurekodi",
+ "startRecordingButton": "🔴 Anza Kurekodi",
+ "camerasCount": "Kamera ({{count}})",
+ "availableCamerasCount": "Zinazopatikana ({{count}})",
+ "server": "Seva",
+ "display": "Onyesho",
+ "rawMessage": "Ujumbe ghafi",
+ "cameraPerformanceMetrics": "Vipimo vya Utendaji wa Kamera",
+ "serverLogs": "Kumbukumbu za Seva",
+ "sortBy": "Panga {{direction}}",
+ "waitingForCameraStreams": "Inasubiri mikondo ya kamera...",
+ "loggingPaused": "Uwekaji kumbukumbu umesimamishwa",
+ "noLogsToDisplay": "Hakuna kumbukumbu za kuonyesha",
+ "closeSettings": "Funga mipangilio",
+ "gridSettings": "Mipangilio ya gridi",
+ "clickToShowLess": "Bofya kuonyesha kidogo",
+ "clickToLearnMore": "Bofya kujifunza zaidi",
+ "samples": "sampuli",
+ "framerateOverTime": "Kasi ya Fremu Kwa Wakati",
+ "framerateFps": "Kasi ya fremu (fps)",
+ "capturesFramesFromCamera": "Inakamata fremu kutoka kwa kamera.",
+ "rendersReceivedFrames": "Inaonyesha fremu zilizopokelewa kwenye skrini.",
+ "displayTooltipLong": "Onyesho linawakilisha utendaji wa uonyeshaji wa UI. Linaonyesha jinsi onyesho lako linavyopokea na kuonyesha fremu haraka. Matatizo ya utendaji hapa hayataathiri ubora wa kurekodi lakini yanaweza kuathiri uwezo wako wa kufuatilia kamera kwa wakati halisi.",
+ "statsSourceShort": "Onyesho linaonyesha fremu, Seva inakamata fremu.",
+ "statsSourceLong": "Seva ni kasi halisi ambayo fremu zinachukuliwa/kurekodiwa kutoka kwa kamera, wakati onyesho ni kasi ambayo zinapokelewa na kuonyeshwa. Skellycam inatanguliza utendaji wa upande wa seva kwa ubora wa kurekodi, kwa hivyo nambari hiyo inapaswa kubaki thabiti zaidi. Ikiwa kasi ya fremu ya onyesho inatofautiana na seva, inaonyesha rasilimali za mfumo wako zimezidiwa. Fikiria kutumia kamera chache au kupunguza kasi ya fremu/ubora.",
+ "statsCurrentShort": "Muda wa fremu wa hivi karibuni na FPS inayolingana.",
+ "statsCurrentLong": "Hii inaonyesha kipimo cha hivi karibuni cha muda unaochukua kuchakata fremu moja (kwa milisekunde) na fremu sawa kwa sekunde (FPS). Muda mfupi wa fremu na FPS ya juu inaonyesha utendaji bora.",
+ "statsMinShort": "Muda wa fremu wa haraka zaidi (ucheleweshaji wa chini) na FPS ya juu zaidi iliyofikiwa.",
+ "statsMinLong": "Hii inawakilisha muda wa chini uliochukua kuchakata fremu moja wakati wa dirisha la sampuli. Hii inalingana na FPS ya juu zaidi mfumo wako uliofika wakati wa hali bora.",
+ "statsMaxShort": "Muda wa fremu wa polepole zaidi (ucheleweshaji wa juu) na FPS ya chini zaidi iliyopatikana.",
+ "statsMaxLong": "Hii inawakilisha muda wa juu uliochukua kuchakata fremu moja wakati wa dirisha la sampuli. Hii inalingana na FPS ya chini zaidi mfumo wako uliofika wakati wa hali mbaya zaidi. Kupanda mara kwa mara ni kawaida, lakini thamani za juu kwa mfululizo zinaweza kuonyesha matatizo ya utendaji.",
+ "statsMeanShort": "Wastani wa muda wa fremu na FPS kwa sampuli zote.",
+ "statsMeanLong": "Wastani wa hesabu wa nyakati zote za fremu zilizopimwa wakati wa dirisha la sampuli na FPS inayolingana. Hii inatoa picha nzuri ya jumla ya utendaji lakini inaweza kupotoshwa na thamani zilizo nje.",
+ "statsMedianShort": "Thamani ya kati ya nyakati zote za fremu (asilimia ya 50).",
+ "statsMedianLong": "Kati inawakilisha thamani ya kati wakati nyakati zote za fremu zinapangwa kutoka haraka hadi polepole. Tofauti na wastani, kati haiathiriwi na thamani kali zilizo nje, na kuifanya kuwa kiashirio thabiti zaidi cha utendaji wa kawaida.",
+ "statsStdDevShort": "Inapima utofauti wa muda wa fremu. CV% ni utofauti wa jamaa.",
+ "statsStdDevLong": "Kupotoka kwa kawaida kunapima kiasi cha tofauti katika nyakati za fremu. Thamani za chini zinaonyesha utendaji thabiti zaidi. Mgawo wa Tofauti (CV%) unaeleza utofauti huu kama asilimia ya wastani, na kurahisisha kulinganisha uthabiti kati ya viwango tofauti vya fremu. CV% ya chini inaonyesha utendaji thabiti zaidi.",
+ "aiTranslatedTooltip": "Tafsiri hii imezalishwa na AI na inaweza kuwa na makosa. Ikiwa unazungumza lugha hii, unaweza kusaidia kuiboresha kwa kufungua pull request kwenye GitHub!",
+ "humanValidatedTooltip": "Tafsiri hii imekaguliwa na kuthibitishwa na mtafsiri binadamu.",
+ "helpTranslate": "Saidia kutafsiri SkellyCam",
+ "failedToFetch": "Imeshindwa kupata",
+ "recordings": "Rekodi",
+ "noRecordingsFound": "Hakuna rekodi zilizopatikana. Ingiza njia hapo juu kupakia kwa mikono.",
+ "noCamerasDetected": "Hakuna kamera zilizogunduliwa",
+ "clickRefreshToScan": "Bofya sasisha kutafuta kamera zinazopatikana",
+ "waitingForData": "Inasubiri data…",
+ "load": "Pakia",
+ "refresh": "Sasisha",
+ "available": "Inapatikana",
+ "menuFile": "Faili",
+ "menuView": "Mwonekano",
+ "menuCamera": "Kamera",
+ "menuRecording": "Kurekodi",
+ "menuHelp": "Msaada",
+ "menuDetectCameras": "Gundua kamera",
+ "menuConnectCameras": "Unganisha kamera",
+ "menuCloseAllCameras": "Funga kamera zote",
+ "menuOpenRecordingFolder": "Fungua folda ya kurekodi…",
+ "menuToggleSidebar": "Badili upau wa pembeni",
+ "menuToggleTheme": "Badili mandhari",
+ "menuToggleFullScreen": "Skrini kamili",
+ "menuPauseUnpause": "Simamisha / Endelea",
+ "menuConnectApplySettings": "Unganisha / Tumia mipangilio",
+ "menuCloseAll": "Funga zote",
+ "menuDocumentation": "Nyaraka",
+ "menuGitHubRepository": "Hifadhi ya GitHub",
+ "menuReportIssue": "Ripoti tatizo…",
+ "menuAbout": "Kuhusu SkellyCam",
+ "menuPlayback": "Cheza upya",
+ "videoPlayback": "Uchezaji",
+ "copyLogsToClipboard": "Nakili kumbukumbu kwenye ubao wa kunakili",
+ "saveLogsToFile": "Hifadhi kumbukumbu kwenye faili",
+ "copied": "Imenakiliwa!",
+ "timestampFromRecording": "Mhuri wa wakati kutoka data ya kurekodi",
+ "menuCheckForUpdates": "Check for Updates…",
+ "updateAvailable": "Update available",
+ "updateAvailableMessage": "Version {{version}} is available",
+ "downloading": "Downloading…",
+ "downloadComplete": "Download complete",
+ "restartToUpdate": "Restart to update",
+ "checkForUpdates": "Check for Updates",
+ "upToDate": "You are up to date",
+ "updateError": "Update check failed"
+}
diff --git a/freemocap-ui-old/src/i18n/locales/ta-tamil.json b/freemocap-ui-old/src/i18n/locales/ta-tamil.json
new file mode 100644
index 00000000..66714458
--- /dev/null
+++ b/freemocap-ui-old/src/i18n/locales/ta-tamil.json
@@ -0,0 +1,258 @@
+{
+ "_meta": {
+ "locale": "ta",
+ "translationSource": "ai-generated",
+ "lastUpdated": "2026-02-23"
+ },
+ "appName": "SkellyCam",
+ "appNameDecorated": "SkellyCam 💀📸",
+ "welcomeTitle": "SkellyCam-க்கு வரவேற்கிறோம்",
+ "welcomeSubtitle": "ஒத்திசைக்கப்பட்ட வீடியோக்களைப் பதிவுசெய்து பாருங்கள்",
+ "sendAnonymousPings": "அநாமதேய பயன்பாட்டு பிங்குகளை அனுப்பு",
+ "footerWith": "உடன்",
+ "footerFrom": "இலிருந்து",
+ "footerOrgName": "FreeMoCap Foundation",
+ "home": "முகப்பு",
+ "cameras": "கேமராக்கள்",
+ "videos": "வீடியோக்கள்",
+ "expandSidebar": "பக்கப்பட்டியை விரிவாக்கு",
+ "collapseSidebar": "பக்கப்பட்டியைச் சுருக்கு",
+ "startRecording": "பதிவைத் தொடங்கு",
+ "stopRecording": "பதிவை நிறுத்து",
+ "toggleTheme": "தீம் மாற்று",
+ "switchToDark": "இருள் பயன்முறைக்கு மாறு",
+ "switchToLight": "ஒளி பயன்முறைக்கு மாறு",
+ "connectWebSocket": "WebSocket இணை",
+ "disconnectWebSocket": "WebSocket துண்டி",
+ "launchServer": "சர்வரைத் தொடங்கு",
+ "stopServer": "சர்வரை நிறுத்து",
+ "browseForExecutable": "இயங்கக்கூடிய கோப்பைத் தேடு",
+ "refreshCandidates": "வேட்பாளர்களைப் புதுப்பி",
+ "executable": "இயங்கக்கூடியது",
+ "host": "ஹோஸ்ட்",
+ "port": "போர்ட்",
+ "cameraCount_one": "{{count}} கேமரா",
+ "cameraCount_other": "{{count}} கேமராக்கள்",
+ "connectedCameras": "இணைக்கப்பட்ட கேமராக்கள்",
+ "availableCameras": "கிடைக்கும் கேமராக்கள்",
+ "noCamerasConnected": "கேமராக்கள் எதுவும் இணைக்கப்படவில்லை",
+ "detectCameras": "கிடைக்கும் கேமராக்களைக் கண்டறி",
+ "clearCameraSettings": "நினைவகத்திலிருந்து சேமிக்கப்பட்ட கேமரா அமைப்புகளை அழி",
+ "copySettingsToAll": "அமைப்புகளை எல்லா கேமராக்களுக்கும் நகலெடு",
+ "recordingTag": "பதிவு குறிச்சொல்",
+ "recordingTagPlaceholder": "விருப்ப குறிச்சொல்",
+ "recordingDirectory": "பதிவு அடைவு",
+ "recordingFolderPath": "பதிவு கோப்புறை பாதை",
+ "delayStart": "தொடக்கத்தைத் தாமதப்படுத்து",
+ "seconds": "நொடிகள்",
+ "subfolder": "உபகோப்புறை",
+ "subfolderPlaceholder": "உபகோப்புறை பெயர்",
+ "baseName": "அடிப்படைப் பெயர்",
+ "increment": "அதிகரிப்பு",
+ "resolution": "தெளிவுத்திறன்",
+ "fps": "FPS",
+ "width": "அகலம்",
+ "height": "உயரம்",
+ "columns": "நெடுவரிசைகள்",
+ "auto": "தானியங்கி",
+ "manual": "கைமுறை",
+ "custom": "தனிப்பயன்",
+ "current": "நடப்பு",
+ "recommend": "பரிந்துரை",
+ "cameraRotation": "கேமரா சுழற்சி",
+ "selectCameraRotation": "கேமரா பட சுழற்சியைத் தேர்ந்தெடு",
+ "exposureControl": "தானியங்கி அல்லது கைமுறை வெளிப்பாட்டுக் கட்டுப்பாட்டிற்கு இடையே தேர்ந்தெடு",
+ "framerateControl": "தானியங்கி அல்லது கைமுறை பிரேம் வேகக் கட்டுப்பாட்டிற்கு இடையே தேர்ந்தெடு",
+ "adjustExposure": "வெளிப்பாட்டு நேரத்தை சரிசெய், எ.கா. cv2.VideoCapture.set(cv2.CAP_PROP_EXPOSURE, value)",
+ "setTargetFps": "கேமரா பிடிப்புக்கான இலக்கு பிரேம்கள்/நொடி (FPS) அமை",
+ "recordingCaptureFps": "பதிவு பிடிப்பு பிரேம் வேகம்",
+ "playbackSpeed": "மீளியக்க வேகம் (பதிவு fps-ஐ பாதிக்காது)",
+ "framerateTimeline": "பிரேம் வேக காலவரிசை",
+ "framerateDistribution": "பிரேம் வேக விநியோகம்",
+ "timelineView": "காலவரிசை காட்சி",
+ "distributionView": "விநியோக காட்சி",
+ "combinedView": "ஒருங்கிணைந்த காட்சி",
+ "min": "குறை",
+ "max": "அதிக",
+ "mean": "சராசரி",
+ "median": "இடை",
+ "stdDevCv": "StdDev/CV",
+ "source": "மூலம்",
+ "selectAll": "அனைத்தையும் தேர்ந்தெடு",
+ "loadSynchronizedVideos": "ஒத்திசைக்கப்பட்ட வீடியோக்களை ஏற்று",
+ "loadSynchronizedVideosDescription": "இந்தப் பக்கம் முன்பதிவு செய்யப்பட்ட வீடியோக்களை ஏற்றவும் ஒத்திசைக்கவும் அனுமதிக்கிறது.",
+ "automaticallySynchronizeVideos": "வீடியோக்களைத் தானாக ஒத்திசை",
+ "extractFramesOnLoad": "ஏற்றும்போது பிரேம்களைப் பிரி",
+ "generateThumbnails": "சிறுபடங்களை உருவாக்கு",
+ "noVideosLoaded": "வீடியோக்கள் எதுவும் ஏற்றப்படவில்லை",
+ "filterVideos": "வீடியோக்களை வடிகட்டு...",
+ "openVideo": "வீடியோவைத் திற",
+ "openFolder": "கோப்பு எக்ஸ்ப்ளோரரில் கோப்புறையைத் திற",
+ "videoFolderPath": "வீடியோ கோப்புறை பாதை",
+ "jumpToStart": "தொடக்கத்திற்குச் செல் (Home)",
+ "jumpToEnd": "முடிவுக்குச் செல் (End)",
+ "loopOn": "லூப் இயக்கத்தில் உள்ளது (மாற்ற L)",
+ "loopOff": "லூப் பிளேபேக் (L)",
+ "syncInfo": "ஒத்திசைவு தகவல்",
+ "syncInfoTitle": "பல-கேமரா ஒத்திசைவு பிரேம் அளவில் துல்லியமாக இருக்காமல் போகலாம்",
+ "syncInfoBody": "உலாவி வீடியோ பிளேபேக் பல ஸ்ட்ரீம்களில் மாதிரி-துல்லிய ஒத்திசைவை உத்தரவாதம் செய்யாது. பிளேயர் தலைவர்-பின்தொடர்பவர் உத்தியைப் பயன்படுத்துகிறது மற்றும் சிறிய சகிப்புத்தன்மையை மீறும்போது சரிவை சரிசெய்கிறது, ஆனால் சிறிய ஒத்திசைவின்மை (1–2 பிரேம்கள்) ஏற்படலாம், குறிப்பாக அதிக பிளேபேக் வேகத்தில் அல்லது உலாவி சுமையில் இருக்கும்போது. பிரேம்-துல்லிய பகுப்பாய்விற்கு, ஒவ்வொரு பதிவிலும் சேர்க்கப்பட்டுள்ள மூல நேர முத்திரை CSV கோப்புகளைப் பயன்படுத்தவும்.",
+ "previousFrame": "முந்தைய பிரேம் (← / Shift+← 10-க்கு)",
+ "nextFrame": "அடுத்த பிரேம் (→ / Shift+→ 10-க்கு)",
+ "zoomIn": "பெரிதாக்கு",
+ "zoomOut": "சிறிதாக்கு",
+ "resetZoom": "பெரிதாக்கலை மீட்டமை",
+ "playbackSettings": "மீளியக்க அமைப்புகள்",
+ "totalRecordingSize": "வட்டில் மொத்த பதிவு அளவு",
+ "estimatedTime": "மதிப்பிடப்பட்ட நேரம் (பிரேம் ÷ பதிவு fps)",
+ "estimatedDuration": "மதிப்பிடப்பட்ட கால அளவு (மொத்த பிரேம்கள் ÷ பதிவு fps)",
+ "estimatedFromFrameNumber": "பிரேம் எண் × பதிவு fps இலிருந்து மதிப்பிடப்பட்டது — நேர முத்திரை தரவிலிருந்து படிக்கப்படவில்லை",
+ "frameCountPerCamera": "கேமராவுக்கான பிரேம் எண்ணிக்கை",
+ "cameraStreams": "இந்தப் பதிவில் உள்ள கேமரா ஸ்ட்ரீம்கள்",
+ "backToRecordings": "பதிவுகளுக்குத் திரும்பு",
+ "errorsDetected": "பிழைகள் கண்டறியப்பட்டன",
+ "somethingWentWrong": "ஏதோ தவறு நிகழ்ந்தது :(",
+ "searchLogs": "பதிவுகளைத் தேடு...",
+ "filter": "வடிகட்டு…",
+ "refreshMicrophoneList": "ஒலிவாங்கி பட்டியலைப் புதுப்பி",
+ "date": "தேதி",
+ "name": "பெயர்",
+ "size": "அளவு",
+ "duration": "கால அளவு",
+ "frames": "பிரேம்கள்",
+ "timestamp": "நேர முத்திரை",
+ "language": "மொழி",
+ "aiTranslated": "AI மொழிபெயர்ப்பு",
+ "humanTranslated": "மனித மொழிபெயர்ப்பு",
+ "humanValidated": "மனிதரால் சரிபார்க்கப்பட்டது",
+ "connectCameras": "தேர்ந்தெடுக்கப்பட்ட கேமராக்களை இணை அல்லது இணைக்கப்பட்ட கேமராக்களைப் புதுப்பி",
+ "resumeStreaming": "ஸ்ட்ரீமிங்கைத் தொடர்",
+ "pauseStreaming": "ஸ்ட்ரீமிங்கை இடைநிறுத்து",
+ "closeAllCameras": "அனைத்து கேமராக்களையும் மூடு",
+ "framerate": "பிரேம் வேகம்",
+ "exposure": "வெளிப்பாடு",
+ "fileLabel": "கோப்பு",
+ "timeDelta": "நேர வேறுபாடு",
+ "pathLabel": "பாதை",
+ "exceptionDetails": "விதிவிலக்கு விவரங்கள்",
+ "stackTrace": "அடுக்கு தடயம்",
+ "loadingVideos": "வீடியோக்களை ஏற்றுகிறது… ({{ready}}/{{total}} தயார்)",
+ "gridColumns": "கட்ட நெடுவரிசைகள்",
+ "settings": "அமைப்புகள்",
+ "appearance": "தோற்றம்",
+ "themeMode": "தீம்",
+ "darkMode": "இருள்",
+ "lightMode": "ஒளி",
+ "languageSettings": "மொழி & உள்ளூர்மயமாக்கல்",
+ "showTranslationIndicator": "மொழிபெயர்ப்பு மூலக் காட்டியைக் காட்டு",
+ "showTranslationIndicatorDescription": "AI உருவாக்கிய மொழிபெயர்ப்புகளைப் பயன்படுத்தும்போது பேட்ஜ் காட்டு",
+ "translationSourceLabel": "மொழிபெயர்ப்பு மூலம்",
+ "general": "பொது",
+ "about": "பற்றி",
+ "version": "பதிப்பு",
+ "serverSettings": "சர்வர்",
+ "recordingSettings": "பதிவு அமைப்புகள்",
+ "videoLoadingSettings": "வீடியோ ஏற்றல் அமைப்புகள்",
+ "connected": "இணைக்கப்பட்டது",
+ "connecting": "இணைக்கிறது…",
+ "disconnected": "துண்டிக்கப்பட்டது",
+ "disconnect": "துண்டி",
+ "connect": "இணை",
+ "off": "அணை",
+ "running": "இயங்குகிறது",
+ "stopped": "நிறுத்தப்பட்டது",
+ "working": "வேலை செய்கிறது…",
+ "invalid": "தவறானது",
+ "autoLaunch": "தானியங்கி தொடக்கம்",
+ "autoConnect": "தானியங்கி இணைப்பு",
+ "runningPath": "இயங்குகிறது: {{path}}",
+ "noMicrophone": "ஒலிவாங்கி இல்லை",
+ "audioRecordingEnabled": "ஒலிப் பதிவு இயக்கப்பட்டது",
+ "noMicrophoneSelected": "ஒலிவாங்கி தேர்ந்தெடுக்கப்படவில்லை",
+ "recordingName": "பதிவு பெயர்: {{name}}",
+ "startingIn": "{{countdown}} இல் தொடங்குகிறது...",
+ "stopping": "நிறுத்துகிறது...",
+ "starting": "தொடங்குகிறது...",
+ "stopRecordingButton": "🔴 பதிவை நிறுத்து",
+ "startRecordingButton": "🔴 பதிவைத் தொடங்கு",
+ "camerasCount": "கேமராக்கள் ({{count}})",
+ "availableCamerasCount": "கிடைக்கும் ({{count}})",
+ "server": "சர்வர்",
+ "display": "காட்சி",
+ "rawMessage": "மூல செய்தி",
+ "cameraPerformanceMetrics": "கேமரா செயல்திறன் அளவீடுகள்",
+ "serverLogs": "சர்வர் பதிவுகள்",
+ "sortBy": "{{direction}} வரிசைப்படுத்து",
+ "waitingForCameraStreams": "கேமரா ஸ்ட்ரீம்களுக்காகக் காத்திருக்கிறது...",
+ "loggingPaused": "பதிவு இடைநிறுத்தப்பட்டது",
+ "noLogsToDisplay": "காட்ட பதிவுகள் இல்லை",
+ "closeSettings": "அமைப்புகளை மூடு",
+ "gridSettings": "கட்ட அமைப்புகள்",
+ "clickToShowLess": "குறைவாகக் காட்ட கிளிக் செய்",
+ "clickToLearnMore": "மேலும் அறிய கிளிக் செய்",
+ "samples": "மாதிரிகள்",
+ "framerateOverTime": "நேரத்தின் மீதான பிரேம் வேகம்",
+ "framerateFps": "பிரேம் வேகம் (fps)",
+ "capturesFramesFromCamera": "கேமராவிலிருந்து பிரேம்களைப் பிடிக்கிறது.",
+ "rendersReceivedFrames": "பெறப்பட்ட பிரேம்களைத் திரையில் காட்டுகிறது.",
+ "displayTooltipLong": "காட்சி UI வழங்கல் செயல்திறனைக் குறிக்கிறது. உங்கள் காட்சி எவ்வளவு விரைவாக பிரேம்களைப் பெறுகிறது மற்றும் காட்டுகிறது என்பதைக் காட்டுகிறது. இங்கு செயல்திறன் சிக்கல்கள் பதிவு தரத்தை பாதிக்காது ஆனால் நிகழ்நேர கேமரா கண்காணிப்பைப் பாதிக்கலாம்.",
+ "statsSourceShort": "காட்சி பிரேம்களை வழங்குகிறது, சர்வர் பிரேம்களைப் பிடிக்கிறது.",
+ "statsSourceLong": "சர்வர் கேமராவிலிருந்து பிரேம்கள் இழுக்கப்படும்/பதிவு செய்யப்படும் உண்மையான வேகம், காட்சி அவை பெறப்பட்டு வழங்கப்படும் வேகம். Skellycam பதிவு தரத்திற்காக சர்வர் பக்க செயல்திறனுக்கு முன்னுரிமை அளிக்கிறது, எனவே அந்த எண் நிலையாக இருக்க வேண்டும். காட்சி பிரேம் வேகம் சர்வரிலிருந்து வேறுபட்டால், உங்கள் கணினி வளங்கள் அதிக சுமையில் உள்ளன என்பதைக் குறிக்கிறது. குறைவான கேமராக்களைப் பயன்படுத்துவதை அல்லது பிரேம் வேகம்/தெளிவுத்திறனைக் குறைப்பதைக் கருதுங்கள்.",
+ "statsCurrentShort": "மிக சமீபத்திய பிரேம் நேரம் மற்றும் தொடர்புடைய FPS.",
+ "statsCurrentLong": "ஒரு பிரேமை செயலாக்க எவ்வளவு நேரம் ஆகிறது (மில்லிசெகண்டுகளில்) மற்றும் சமமான FPS இன் மிக சமீபத்திய அளவீட்டைக் காட்டுகிறது. குறைந்த பிரேம் நேரங்கள் மற்றும் அதிக FPS சிறந்த செயல்திறனைக் குறிக்கிறது.",
+ "statsMinShort": "வேகமான பிரேம் நேரம் (குறைந்த தாமதம்) மற்றும் அடையப்பட்ட அதிகபட்ச FPS.",
+ "statsMinLong": "மாதிரி சாளரத்தின் போது ஒரு பிரேமை செயலாக்க எடுத்த குறைந்தபட்ச நேரத்தைக் குறிக்கிறது. உகந்த நிலைகளில் உங்கள் கணினி அடைந்த அதிகபட்ச FPS-க்கு ஒத்திருக்கிறது.",
+ "statsMaxShort": "மெதுவான பிரேம் நேரம் (அதிக தாமதம்) மற்றும் அனுபவித்த குறைந்தபட்ச FPS.",
+ "statsMaxLong": "மாதிரி சாளரத்தின் போது ஒரு பிரேமை செயலாக்க எடுத்த அதிகபட்ச நேரத்தைக் குறிக்கிறது. மோசமான நிலைகளில் உங்கள் கணினி அடைந்த குறைந்தபட்ச FPS-க்கு ஒத்திருக்கிறது. எப்போதாவது உயர்வுகள் இயல்பானவை, ஆனால் தொடர்ந்து அதிக மதிப்புகள் செயல்திறன் சிக்கல்களைக் குறிக்கலாம்.",
+ "statsMeanShort": "அனைத்து மாதிரிகளிலும் சராசரி பிரேம் நேரம் மற்றும் FPS.",
+ "statsMeanLong": "மாதிரி சாளரத்தின் போது அளவிடப்பட்ட அனைத்து பிரேம் நேரங்களின் எண்கணித சராசரி மற்றும் தொடர்புடைய FPS. செயல்திறனின் ஒட்டுமொத்த நல்ல படத்தை அளிக்கிறது ஆனால் விலகல்களால் சாய்க்கப்படலாம்.",
+ "statsMedianShort": "அனைத்து பிரேம் நேரங்களின் நடுத்தர மதிப்பு (50வது சதவிகிதம்).",
+ "statsMedianLong": "அனைத்து பிரேம் நேரங்கள் வேகமானதிலிருந்து மெதுவானது வரை வரிசைப்படுத்தப்படும்போது நடுத்தர மதிப்பைக் குறிக்கிறது. சராசரியைப் போலல்லாமல், இடை தீவிர விலகல்களால் பாதிக்கப்படாது, இது வழக்கமான செயல்திறனின் நிலையான குறிகாட்டியாக அமைகிறது.",
+ "statsStdDevShort": "பிரேம் நேர மாறுபாட்டை அளவிடுகிறது. CV% என்பது தொடர்பு மாறுபாடு.",
+ "statsStdDevLong": "நிலையான விலகல் பிரேம் நேரங்களில் உள்ள மாறுபாட்டின் அளவை அளவிடுகிறது. குறைந்த மதிப்புகள் நிலையான செயல்திறனைக் குறிக்கிறது. மாறுபாட்டுக் குணகம் (CV%) இந்த மாறுபாட்டை சராசரியின் சதவிகிதமாக வெளிப்படுத்துகிறது, வெவ்வேறு பிரேம் வேகங்களில் நிலைத்தன்மையை ஒப்பிடுவதை எளிதாக்குகிறது. குறைந்த CV% நிலையான செயல்திறனைக் குறிக்கிறது.",
+ "aiTranslatedTooltip": "இந்த மொழிபெயர்ப்பு AI ஆல் உருவாக்கப்பட்டது மற்றும் பிழைகள் இருக்கலாம். நீங்கள் இந்த மொழி பேசினால், GitHub இல் pull request திறந்து மேம்படுத்த உதவலாம்!",
+ "humanValidatedTooltip": "இந்த மொழிபெயர்ப்பு மனித மொழிபெயர்ப்பாளரால் மதிப்பாய்வு செய்யப்பட்டு சரிபார்க்கப்பட்டது.",
+ "helpTranslate": "SkellyCam மொழிபெயர்க்க உதவுங்கள்",
+ "failedToFetch": "பெற இயலவில்லை",
+ "recordings": "பதிவுகள்",
+ "noRecordingsFound": "பதிவுகள் எதுவும் கிடைக்கவில்லை. கைமுறையாக ஏற்ற மேலே ஒரு பாதையை உள்ளிடுக.",
+ "noCamerasDetected": "கேமராக்கள் எதுவும் கண்டறியப்படவில்லை",
+ "clickRefreshToScan": "கிடைக்கும் கேமராக்களை ஸ்கேன் செய்ய புதுப்பி கிளிக் செய்",
+ "waitingForData": "தரவுக்காகக் காத்திருக்கிறது…",
+ "load": "ஏற்று",
+ "refresh": "புதுப்பி",
+ "available": "கிடைக்கிறது",
+ "menuFile": "கோப்பு",
+ "menuView": "காட்சி",
+ "menuCamera": "கேமரா",
+ "menuRecording": "பதிவு",
+ "menuHelp": "உதவி",
+ "menuDetectCameras": "கேமராக்களைக் கண்டறி",
+ "menuConnectCameras": "கேமராக்களை இணை",
+ "menuCloseAllCameras": "அனைத்து கேமராக்களையும் மூடு",
+ "menuOpenRecordingFolder": "பதிவு கோப்புறையைத் திற…",
+ "menuToggleSidebar": "பக்கப்பட்டியை நிலைமாற்று",
+ "menuToggleTheme": "தீம் மாற்று",
+ "menuToggleFullScreen": "முழுத்திரை",
+ "menuPauseUnpause": "இடைநிறுத்தம் / தொடர்",
+ "menuConnectApplySettings": "இணை / அமைப்புகளைப் பயன்படுத்து",
+ "menuCloseAll": "அனைத்தையும் மூடு",
+ "menuDocumentation": "ஆவணமாக்கல்",
+ "menuGitHubRepository": "GitHub களஞ்சியம்",
+ "menuReportIssue": "சிக்கலைப் புகாரளி…",
+ "menuAbout": "SkellyCam பற்றி",
+ "menuPlayback": "பின்னோக்கி இயக்கு",
+ "videoPlayback": "மீளியக்கம்",
+ "copyLogsToClipboard": "பதிவுகளை கிளிப்போர்டுக்கு நகலெடு",
+ "saveLogsToFile": "பதிவுகளை கோப்பில் சேமி",
+ "copied": "நகலெடுக்கப்பட்டது!",
+ "timestampFromRecording": "பதிவுத் தரவிலிருந்து நேர முத்திரை",
+ "menuCheckForUpdates": "Check for Updates…",
+ "updateAvailable": "Update available",
+ "updateAvailableMessage": "Version {{version}} is available",
+ "downloading": "Downloading…",
+ "downloadComplete": "Download complete",
+ "restartToUpdate": "Restart to update",
+ "checkForUpdates": "Check for Updates",
+ "upToDate": "You are up to date",
+ "updateError": "Update check failed"
+}
diff --git a/freemocap-ui-old/src/i18n/locales/th-thai.json b/freemocap-ui-old/src/i18n/locales/th-thai.json
new file mode 100644
index 00000000..7d9dfc1d
--- /dev/null
+++ b/freemocap-ui-old/src/i18n/locales/th-thai.json
@@ -0,0 +1,258 @@
+{
+ "_meta": {
+ "locale": "th",
+ "translationSource": "ai-generated",
+ "lastUpdated": "2026-02-23"
+ },
+ "appName": "SkellyCam",
+ "appNameDecorated": "SkellyCam 💀📸",
+ "welcomeTitle": "ยินดีต้อนรับสู่ SkellyCam",
+ "welcomeSubtitle": "บันทึกและดูวิดีโอที่ซิงค์",
+ "sendAnonymousPings": "ส่งข้อมูลการใช้งานแบบไม่ระบุตัวตน",
+ "footerWith": "ด้วย",
+ "footerFrom": "จาก",
+ "footerOrgName": "FreeMoCap Foundation",
+ "home": "หน้าหลัก",
+ "cameras": "กล้อง",
+ "videos": "วิดีโอ",
+ "expandSidebar": "ขยายแถบด้านข้าง",
+ "collapseSidebar": "ย่อแถบด้านข้าง",
+ "startRecording": "เริ่มบันทึก",
+ "stopRecording": "หยุดบันทึก",
+ "toggleTheme": "สลับธีม",
+ "switchToDark": "สลับเป็นโหมดมืด",
+ "switchToLight": "สลับเป็นโหมดสว่าง",
+ "connectWebSocket": "เชื่อมต่อ WebSocket",
+ "disconnectWebSocket": "ตัดการเชื่อมต่อ WebSocket",
+ "launchServer": "เริ่มเซิร์ฟเวอร์",
+ "stopServer": "หยุดเซิร์ฟเวอร์",
+ "browseForExecutable": "เรียกดูไฟล์ที่เรียกใช้ได้",
+ "refreshCandidates": "รีเฟรชตัวเลือก",
+ "executable": "ไฟล์เรียกใช้",
+ "host": "โฮสต์",
+ "port": "พอร์ต",
+ "cameraCount_one": "{{count}} กล้อง",
+ "cameraCount_other": "{{count}} กล้อง",
+ "connectedCameras": "กล้องที่เชื่อมต่อ",
+ "availableCameras": "กล้องที่ใช้ได้",
+ "noCamerasConnected": "ไม่มีกล้องเชื่อมต่อ",
+ "detectCameras": "ตรวจหากล้องที่ใช้ได้",
+ "clearCameraSettings": "ล้างการตั้งค่ากล้อง",
+ "copySettingsToAll": "คัดลอกการตั้งค่าไปยังทั้งหมด",
+ "recordingTag": "แท็กบันทึก",
+ "recordingTagPlaceholder": "แท็กเสริม",
+ "recordingDirectory": "ไดเรกทอรีบันทึก",
+ "recordingFolderPath": "เส้นทางโฟลเดอร์บันทึก",
+ "delayStart": "เริ่มล่าช้า",
+ "seconds": "วินาที",
+ "subfolder": "โฟลเดอร์ย่อย",
+ "subfolderPlaceholder": "ชื่อโฟลเดอร์ย่อย",
+ "baseName": "ชื่อฐาน",
+ "increment": "เพิ่มขึ้น",
+ "resolution": "ความละเอียด",
+ "fps": "FPS",
+ "width": "ความกว้าง",
+ "height": "ความสูง",
+ "columns": "คอลัมน์",
+ "auto": "อัตโนมัติ",
+ "manual": "แมนนวล",
+ "custom": "กำหนดเอง",
+ "current": "ปัจจุบัน",
+ "recommend": "แนะนำ",
+ "cameraRotation": "การหมุนกล้อง",
+ "selectCameraRotation": "เลือกการหมุนภาพกล้อง",
+ "exposureControl": "การควบคุมการเปิดรับแสงอัตโนมัติหรือแมนนวล",
+ "framerateControl": "การควบคุมเฟรมเรตอัตโนมัติหรือแมนนวล",
+ "adjustExposure": "ปรับเวลาเปิดรับแสง",
+ "setTargetFps": "ตั้ง FPS เป้าหมายสำหรับการจับภาพ",
+ "recordingCaptureFps": "FPS การจับภาพ",
+ "playbackSpeed": "ความเร็วเล่น",
+ "framerateTimeline": "ไทม์ไลน์เฟรมเรต",
+ "framerateDistribution": "การกระจายเฟรมเรต",
+ "timelineView": "มุมมองไทม์ไลน์",
+ "distributionView": "มุมมองการกระจาย",
+ "combinedView": "มุมมองรวม",
+ "min": "ต่ำสุด",
+ "max": "สูงสุด",
+ "mean": "เฉลี่ย",
+ "median": "มัธยฐาน",
+ "stdDevCv": "ส่วนเบี่ยงเบน/CV",
+ "source": "แหล่ง",
+ "selectAll": "เลือกทั้งหมด",
+ "loadSynchronizedVideos": "โหลดวิดีโอที่ซิงค์",
+ "loadSynchronizedVideosDescription": "หน้านี้ช่วยให้คุณโหลดและซิงค์วิดีโอที่บันทึกไว้ล่วงหน้า",
+ "automaticallySynchronizeVideos": "ซิงค์วิดีโออัตโนมัติ",
+ "extractFramesOnLoad": "ดึงเฟรมเมื่อโหลด",
+ "generateThumbnails": "สร้างภาพขนาดย่อ",
+ "noVideosLoaded": "ไม่มีวิดีโอโหลด",
+ "filterVideos": "กรองวิดีโอ...",
+ "openVideo": "เปิดวิดีโอ",
+ "openFolder": "เปิดโฟลเดอร์ในตัวจัดการไฟล์",
+ "videoFolderPath": "เส้นทางโฟลเดอร์วิดีโอ",
+ "jumpToStart": "ข้ามไปต้น (Home)",
+ "jumpToEnd": "ข้ามไปท้าย (End)",
+ "loopOn": "เปิดการวนซ้ำ (L เพื่อสลับ)",
+ "loopOff": "เล่นวนซ้ำ (L)",
+ "syncInfo": "ข้อมูลการซิงค์",
+ "syncInfoTitle": "การซิงค์กล้องหลายตัวอาจไม่สมบูรณ์แบบในระดับเฟรม",
+ "syncInfoBody": "การเล่นวิดีโอในเบราว์เซอร์ไม่รับประกันการซิงโครไนซ์ที่แม่นยำระดับตัวอย่างข้ามหลายสตรีม เครื่องเล่นใช้กลยุทธ์ผู้นำ-ผู้ตาม และแก้ไขการเบี่ยงเบนเมื่อเกินค่าความคลาดเคลื่อนเล็กน้อย แต่การไม่ซิงค์เล็กน้อย (1–2 เฟรม) อาจเกิดขึ้นได้ โดยเฉพาะที่ความเร็วการเล่นสูงหรือเมื่อเบราว์เซอร์มีภาระงานหนัก สำหรับการวิเคราะห์ที่แม่นยำระดับเฟรม ให้ใช้ไฟล์ CSV ประทับเวลาดิบที่รวมอยู่ในแต่ละการบันทึก",
+ "previousFrame": "เฟรมก่อนหน้า (← / Shift+← สำหรับ 10)",
+ "nextFrame": "เฟรมถัดไป (→ / Shift+→ สำหรับ 10)",
+ "zoomIn": "ซูมเข้า",
+ "zoomOut": "ซูมออก",
+ "resetZoom": "รีเซ็ตซูม",
+ "playbackSettings": "การตั้งค่าเล่น",
+ "totalRecordingSize": "ขนาดบันทึกทั้งหมดบนดิสก์",
+ "estimatedTime": "เวลาโดยประมาณ (เฟรม ÷ fps)",
+ "estimatedDuration": "ระยะเวลาโดยประมาณ (เฟรมทั้งหมด ÷ fps)",
+ "estimatedFromFrameNumber": "ประมาณจากหมายเลขเฟรม × fps",
+ "frameCountPerCamera": "จำนวนเฟรมต่อกล้อง",
+ "cameraStreams": "สตรีมกล้องในการบันทึกนี้",
+ "backToRecordings": "กลับไปบันทึก",
+ "errorsDetected": "ตรวจพบข้อผิดพลาด",
+ "somethingWentWrong": "เกิดข้อผิดพลาด :(",
+ "searchLogs": "ค้นหาบันทึก...",
+ "filter": "กรอง…",
+ "refreshMicrophoneList": "รีเฟรชรายการไมโครโฟน",
+ "date": "วันที่",
+ "name": "ชื่อ",
+ "size": "ขนาด",
+ "duration": "ระยะเวลา",
+ "frames": "เฟรม",
+ "timestamp": "ประทับเวลา",
+ "language": "ภาษา",
+ "aiTranslated": "แปลโดย AI",
+ "humanTranslated": "แปลโดยคน",
+ "humanValidated": "ตรวจสอบโดยคน",
+ "connectCameras": "เชื่อมต่อกล้องที่เลือก",
+ "resumeStreaming": "กลับมาสตรีมต่อ",
+ "pauseStreaming": "หยุดสตรีมชั่วคราว",
+ "closeAllCameras": "ปิดกล้องทั้งหมด",
+ "framerate": "เฟรมเรต",
+ "exposure": "การเปิดรับแสง",
+ "fileLabel": "ไฟล์",
+ "timeDelta": "ส่วนต่างเวลา",
+ "pathLabel": "เส้นทาง",
+ "exceptionDetails": "รายละเอียดข้อยกเว้น",
+ "stackTrace": "สแต็กเทรซ",
+ "loadingVideos": "กำลังโหลดวิดีโอ… ({{ready}}/{{total}} พร้อม)",
+ "gridColumns": "คอลัมน์กริด",
+ "settings": "การตั้งค่า",
+ "appearance": "ลักษณะ",
+ "themeMode": "ธีม",
+ "darkMode": "มืด",
+ "lightMode": "สว่าง",
+ "languageSettings": "ภาษาและการแปล",
+ "showTranslationIndicator": "แสดงตัวบ่งชี้แหล่งที่มาการแปล",
+ "showTranslationIndicatorDescription": "แสดงป้ายเมื่อใช้การแปล AI",
+ "translationSourceLabel": "แหล่งที่มาการแปล",
+ "general": "ทั่วไป",
+ "about": "เกี่ยวกับ",
+ "version": "เวอร์ชัน",
+ "serverSettings": "เซิร์ฟเวอร์",
+ "recordingSettings": "การตั้งค่าบันทึก",
+ "videoLoadingSettings": "การตั้งค่าโหลดวิดีโอ",
+ "connected": "เชื่อมต่อแล้ว",
+ "connecting": "กำลังเชื่อมต่อ…",
+ "disconnected": "ตัดการเชื่อมต่อแล้ว",
+ "disconnect": "ตัดการเชื่อมต่อ",
+ "connect": "เชื่อมต่อ",
+ "off": "ปิด",
+ "running": "กำลังทำงาน",
+ "stopped": "หยุดแล้ว",
+ "working": "กำลังประมวลผล…",
+ "invalid": "ไม่ถูกต้อง",
+ "autoLaunch": "เริ่มอัตโนมัติ",
+ "autoConnect": "เชื่อมต่ออัตโนมัติ",
+ "runningPath": "กำลังทำงาน: {{path}}",
+ "noMicrophone": "ไม่มีไมโครโฟน",
+ "audioRecordingEnabled": "เปิดบันทึกเสียงแล้ว",
+ "noMicrophoneSelected": "ไม่ได้เลือกไมโครโฟน",
+ "recordingName": "ชื่อบันทึก: {{name}}",
+ "startingIn": "เริ่มใน {{countdown}}...",
+ "stopping": "กำลังหยุด...",
+ "starting": "กำลังเริ่ม...",
+ "stopRecordingButton": "🔴 หยุดบันทึก",
+ "startRecordingButton": "🔴 เริ่มบันทึก",
+ "camerasCount": "กล้อง ({{count}})",
+ "availableCamerasCount": "พร้อมใช้ ({{count}})",
+ "server": "เซิร์ฟเวอร์",
+ "display": "จอแสดงผล",
+ "rawMessage": "ข้อความดิบ",
+ "cameraPerformanceMetrics": "ตัวชี้วัดประสิทธิภาพกล้อง",
+ "serverLogs": "บันทึกเซิร์ฟเวอร์",
+ "sortBy": "เรียง {{direction}}",
+ "waitingForCameraStreams": "กำลังรอสตรีมกล้อง...",
+ "loggingPaused": "หยุดบันทึกชั่วคราว",
+ "noLogsToDisplay": "ไม่มีบันทึกให้แสดง",
+ "closeSettings": "ปิดการตั้งค่า",
+ "gridSettings": "การตั้งค่ากริด",
+ "clickToShowLess": "คลิกเพื่อแสดงน้อยลง",
+ "clickToLearnMore": "คลิกเพื่อเรียนรู้เพิ่มเติม",
+ "samples": "ตัวอย่าง",
+ "framerateOverTime": "เฟรมเรตตามเวลา",
+ "framerateFps": "เฟรมเรต (fps)",
+ "capturesFramesFromCamera": "จับเฟรมจากกล้อง",
+ "rendersReceivedFrames": "เรนเดอร์เฟรมที่ได้รับบนหน้าจอ",
+ "displayTooltipLong": "จอแสดงผลแสดงประสิทธิภาพการเรนเดอร์ UI แสดงให้เห็นว่าจอแสดงผลของคุณรับและเรนเดอร์เฟรมได้เร็วแค่ไหน ปัญหาประสิทธิภาพที่นี่จะไม่ส่งผลต่อคุณภาพการบันทึก แต่อาจส่งผลต่อความสามารถในการตรวจสอบกล้องแบบเรียลไทม์",
+ "statsSourceShort": "จอแสดงผลเรนเดอร์เฟรม เซิร์ฟเวอร์จับเฟรม",
+ "statsSourceLong": "เซิร์ฟเวอร์คืออัตราจริงที่เฟรมถูกดึง/บันทึกจากกล้อง ในขณะที่จอแสดงผลคืออัตราที่ได้รับและเรนเดอร์ SkellyCam ให้ความสำคัญกับประสิทธิภาพฝั่งเซิร์ฟเวอร์เพื่อคุณภาพการบันทึก ดังนั้นตัวเลขนั้นควรจะเสถียรกว่า หากเฟรมเรทการแสดงผลแตกต่างจากเซิร์ฟเวอร์ แสดงว่าทรัพยากรระบบของคุณถูกใช้งานหนัก ลองใช้กล้องน้อยลงหรือลดเฟรมเรท/ความละเอียด",
+ "statsCurrentShort": "เวลาเฟรมและ FPS ล่าสุด",
+ "statsCurrentLong": "แสดงการวัดล่าสุดของเวลาที่ใช้ในการประมวลผลเฟรมเดียว (เป็นมิลลิวินาที) และเฟรมต่อวินาที (FPS) ที่เทียบเท่า เวลาเฟรมต่ำกว่าและ FPS สูงกว่าบ่งบอกถึงประสิทธิภาพที่ดีกว่า",
+ "statsMinShort": "เวลาเฟรมเร็วที่สุดและ FPS สูงสุด",
+ "statsMinLong": "แสดงเวลาขั้นต่ำที่ใช้ในการประมวลผลเฟรมเดียวในช่วงหน้าต่างสุ่มตัวอย่าง สอดคล้องกับ FPS สูงสุดที่ระบบของคุณทำได้ในสภาวะที่เหมาะสม",
+ "statsMaxShort": "เวลาเฟรมช้าที่สุดและ FPS ต่ำสุด",
+ "statsMaxLong": "แสดงเวลาสูงสุดที่ใช้ในการประมวลผลเฟรมเดียวในช่วงหน้าต่างสุ่มตัวอย่าง สอดคล้องกับ FPS ต่ำสุดในสภาวะที่แย่ที่สุด การพุ่งขึ้นเป็นครั้งคราวเป็นเรื่องปกติ แต่ค่าที่สูงอย่างต่อเนื่องอาจบ่งบอกถึงปัญหาด้านประสิทธิภาพ",
+ "statsMeanShort": "เวลาเฟรมเฉลี่ยและ FPS ทุกตัวอย่าง",
+ "statsMeanLong": "ค่าเฉลี่ยเลขคณิตของเวลาเฟรมทั้งหมดที่วัดได้ในช่วงหน้าต่างสุ่มตัวอย่างและ FPS ที่สอดคล้อง ให้ภาพรวมที่ดีของประสิทธิภาพ แต่อาจถูกบิดเบือนโดยค่าผิดปกติ",
+ "statsMedianShort": "ค่ามัธยฐานของเวลาเฟรมทั้งหมด (เปอร์เซ็นไทล์ที่ 50)",
+ "statsMedianLong": "ค่ามัธยฐานแสดงค่ากลางเมื่อเรียงลำดับเวลาเฟรมทั้งหมดจากเร็วที่สุดไปช้าที่สุด ต่างจากค่าเฉลี่ย ค่ามัธยฐานไม่ได้รับผลกระทบจากค่าผิดปกติสุดขีด ทำให้เป็นตัวชี้วัดที่เสถียรกว่าของประสิทธิภาพทั่วไป",
+ "statsStdDevShort": "วัดความแปรปรวนของเวลาเฟรม CV% เป็นสัมพัทธ์",
+ "statsStdDevLong": "ส่วนเบี่ยงเบนมาตรฐานวัดปริมาณการเปลี่ยนแปลงในเวลาเฟรม ค่าต่ำกว่าบ่งบอกถึงประสิทธิภาพที่สม่ำเสมอมากขึ้น สัมประสิทธิ์การแปรผัน (CV%) แสดงความแปรปรวนนี้เป็นเปอร์เซ็นต์ของค่าเฉลี่ย ทำให้ง่ายต่อการเปรียบเทียบความเสถียรข้ามเฟรมเรทต่างๆ CV% ต่ำกว่าบ่งบอกถึงประสิทธิภาพที่เสถียรกว่า",
+ "aiTranslatedTooltip": "การแปลนี้สร้างโดย AI และอาจมีข้อผิดพลาด หากคุณพูดภาษานี้ ช่วยปรับปรุงได้!",
+ "humanValidatedTooltip": "การแปลนี้ได้รับการตรวจสอบโดยนักแปล",
+ "helpTranslate": "ช่วยแปล SkellyCam",
+ "failedToFetch": "ดึงข้อมูลล้มเหลว",
+ "recordings": "การบันทึก",
+ "noRecordingsFound": "ไม่พบการบันทึก กรุณาป้อนเส้นทางด้านบนเพื่อโหลดด้วยตนเอง",
+ "noCamerasDetected": "ไม่พบกล้อง",
+ "clickRefreshToScan": "คลิกรีเฟรชเพื่อค้นหากล้องที่ใช้ได้",
+ "waitingForData": "กำลังรอข้อมูล…",
+ "load": "โหลด",
+ "refresh": "รีเฟรช",
+ "available": "พร้อมใช้",
+ "menuFile": "ไฟล์",
+ "menuView": "มุมมอง",
+ "menuCamera": "กล้อง",
+ "menuRecording": "การบันทึก",
+ "menuHelp": "ช่วยเหลือ",
+ "menuDetectCameras": "ตรวจจับกล้อง",
+ "menuConnectCameras": "เชื่อมต่อกล้อง",
+ "menuCloseAllCameras": "ปิดกล้องทั้งหมด",
+ "menuOpenRecordingFolder": "เปิดโฟลเดอร์บันทึก…",
+ "menuToggleSidebar": "สลับแถบด้านข้าง",
+ "menuToggleTheme": "สลับธีม",
+ "menuToggleFullScreen": "สลับเต็มหน้าจอ",
+ "menuPauseUnpause": "หยุดชั่วคราว / เล่นต่อ",
+ "menuConnectApplySettings": "เชื่อมต่อ / ใช้การตั้งค่า",
+ "menuCloseAll": "ปิดทั้งหมด",
+ "menuDocumentation": "เอกสาร",
+ "menuGitHubRepository": "GitHub Repository",
+ "menuReportIssue": "รายงานปัญหา…",
+ "menuAbout": "เกี่ยวกับ SkellyCam",
+ "menuPlayback": "เล่นย้อน",
+ "videoPlayback": "เล่นย้อนหลัง",
+ "copyLogsToClipboard": "คัดลอกบันทึกไปยังคลิปบอร์ด",
+ "saveLogsToFile": "บันทึกล็อกลงไฟล์",
+ "copied": "คัดลอกแล้ว!",
+ "timestampFromRecording": "ประทับเวลาจากข้อมูลการบันทึก",
+ "menuCheckForUpdates": "Check for Updates…",
+ "updateAvailable": "Update available",
+ "updateAvailableMessage": "Version {{version}} is available",
+ "downloading": "Downloading…",
+ "downloadComplete": "Download complete",
+ "restartToUpdate": "Restart to update",
+ "checkForUpdates": "Check for Updates",
+ "upToDate": "You are up to date",
+ "updateError": "Update check failed"
+}
diff --git a/freemocap-ui-old/src/i18n/locales/tl-tagalog.json b/freemocap-ui-old/src/i18n/locales/tl-tagalog.json
new file mode 100644
index 00000000..e9a521e5
--- /dev/null
+++ b/freemocap-ui-old/src/i18n/locales/tl-tagalog.json
@@ -0,0 +1,258 @@
+{
+ "_meta": {
+ "locale": "tl",
+ "translationSource": "ai-generated",
+ "lastUpdated": "2026-02-23"
+ },
+ "appName": "SkellyCam",
+ "appNameDecorated": "SkellyCam 💀📸",
+ "welcomeTitle": "Maligayang pagdating sa SkellyCam",
+ "welcomeSubtitle": "Mag-record at Manood ng Naka-sync na mga Video",
+ "sendAnonymousPings": "Magpadala ng anonymous na usage pings",
+ "footerWith": "kasama ang",
+ "footerFrom": "mula sa",
+ "footerOrgName": "FreeMoCap Foundation",
+ "home": "Home",
+ "cameras": "Mga Camera",
+ "videos": "Mga Video",
+ "expandSidebar": "Palawakin ang sidebar",
+ "collapseSidebar": "I-collapse ang sidebar",
+ "startRecording": "Simulan ang Pag-record",
+ "stopRecording": "Itigil ang Pag-record",
+ "toggleTheme": "palitan ang tema",
+ "switchToDark": "Lumipat sa dark mode",
+ "switchToLight": "Lumipat sa light mode",
+ "connectWebSocket": "Ikonekta ang WebSocket",
+ "disconnectWebSocket": "Idiskonekta ang WebSocket",
+ "launchServer": "Ilunsad ang Server",
+ "stopServer": "Itigil ang Server",
+ "browseForExecutable": "Mag-browse para sa executable",
+ "refreshCandidates": "I-refresh ang mga kandidato",
+ "executable": "Executable",
+ "host": "Host",
+ "port": "Port",
+ "cameraCount_one": "{{count}} camera",
+ "cameraCount_other": "{{count}} cameras",
+ "connectedCameras": "Mga Nakakonektang Camera",
+ "availableCameras": "Mga Available na Camera",
+ "noCamerasConnected": "Walang nakakonektang camera",
+ "detectCameras": "Hanapin ang mga available na camera",
+ "clearCameraSettings": "I-clear ang mga naka-save na camera settings mula sa memory",
+ "copySettingsToAll": "Kopyahin ang settings sa lahat ng camera",
+ "recordingTag": "Tag ng Pag-record",
+ "recordingTagPlaceholder": "Opsyonal na tag",
+ "recordingDirectory": "Direktoryo ng Pag-record",
+ "recordingFolderPath": "Landas ng folder ng pag-record",
+ "delayStart": "I-delay ang Pagsisimula",
+ "seconds": "Segundo",
+ "subfolder": "Subfolder",
+ "subfolderPlaceholder": "Pangalan ng Subfolder",
+ "baseName": "Batayang Pangalan",
+ "increment": "Dagdagan",
+ "resolution": "Resolusyon",
+ "fps": "FPS",
+ "width": "Lapad",
+ "height": "Taas",
+ "columns": "Mga Kolum",
+ "auto": "Awtomatiko",
+ "manual": "Mano-mano",
+ "custom": "Pasadya",
+ "current": "Kasalukuyan",
+ "recommend": "Irekomenda",
+ "cameraRotation": "pag-ikot ng camera",
+ "selectCameraRotation": "Pumili ng pag-ikot ng imahe ng camera",
+ "exposureControl": "Pumili sa pagitan ng automatic o manual na exposure control",
+ "framerateControl": "Pumili sa pagitan ng automatic o manual na framerate control",
+ "adjustExposure": "I-adjust ang exposure time, hal. cv2.VideoCapture.set(cv2.CAP_PROP_EXPOSURE, value)",
+ "setTargetFps": "I-set ang target na frames per second (FPS) para sa camera capture",
+ "recordingCaptureFps": "Framerate ng pagkuha sa pag-record",
+ "playbackSpeed": "Bilis ng playback (hindi nakakaapekto sa recording fps)",
+ "framerateTimeline": "Timeline ng Framerate",
+ "framerateDistribution": "Distribusyon ng Framerate",
+ "timelineView": "View ng Timeline",
+ "distributionView": "View ng Distribusyon",
+ "combinedView": "Pinagsamang View",
+ "min": "Min",
+ "max": "Max",
+ "mean": "Katamtaman",
+ "median": "Gitna",
+ "stdDevCv": "StdDev/CV",
+ "source": "Pinagmulan",
+ "selectAll": "Piliin Lahat",
+ "loadSynchronizedVideos": "I-load ang mga Naka-sync na Video",
+ "loadSynchronizedVideosDescription": "Ang pahinang ito ay nagbibigay-daan sa iyo na i-load at i-synchronize ang mga naunang na-record na video.",
+ "automaticallySynchronizeVideos": "Awtomatikong i-synchronize ang mga video",
+ "extractFramesOnLoad": "I-extract ang mga frame kapag nag-load",
+ "generateThumbnails": "Gumawa ng mga thumbnail",
+ "noVideosLoaded": "Walang na-load na video",
+ "filterVideos": "I-filter ang mga video...",
+ "openVideo": "Buksan ang video",
+ "openFolder": "Buksan ang folder sa file explorer",
+ "videoFolderPath": "Landas ng Folder ng Video",
+ "jumpToStart": "Tumalon sa simula (Home)",
+ "jumpToEnd": "Tumalon sa dulo (End)",
+ "loopOn": "Naka-on ang loop (L para i-toggle)",
+ "loopOff": "I-loop ang playback (L)",
+ "syncInfo": "Impormasyon ng sync",
+ "syncInfoTitle": "Ang multi-camera sync ay maaaring hindi frame-perfect",
+ "syncInfoBody": "Ang pag-playback ng video sa browser ay hindi ginagarantiyahan ang sample-accurate na pag-synchronize sa maraming stream. Gumagamit ang player ng leader-follower na diskarte at tinutuwid ang drift kapag lumampas ito sa maliit na tolerance, ngunit maaaring magkaroon ng bahagyang desynchronization (1–2 frame), lalo na sa mataas na bilis ng playback o kapag naka-load ang browser. Para sa frame-exact na pagsusuri, gamitin ang mga raw na timestamp CSV file na kasama sa bawat recording.",
+ "previousFrame": "Nakaraang frame (← / Shift+← para sa 10)",
+ "nextFrame": "Susunod na frame (→ / Shift+→ para sa 10)",
+ "zoomIn": "Palakihin",
+ "zoomOut": "Paliitin",
+ "resetZoom": "I-reset ang Zoom",
+ "playbackSettings": "Mga setting ng playback",
+ "totalRecordingSize": "Kabuuang laki ng recording sa disk",
+ "estimatedTime": "Tinatayang oras (frame ÷ recording fps)",
+ "estimatedDuration": "Tinatayang tagal (kabuuang frames ÷ recording fps)",
+ "estimatedFromFrameNumber": "Tinataya mula sa frame number × recording fps — hindi binasa mula sa timestamp data",
+ "frameCountPerCamera": "Bilang ng frame bawat camera",
+ "cameraStreams": "Mga camera stream sa recording na ito",
+ "backToRecordings": "Bumalik sa mga recording",
+ "errorsDetected": "May nakitang mga error",
+ "somethingWentWrong": "May nangyaring mali :(",
+ "searchLogs": "Maghanap sa mga log...",
+ "filter": "I-filter…",
+ "refreshMicrophoneList": "I-refresh ang listahan ng mikropono",
+ "date": "Petsa",
+ "name": "Pangalan",
+ "size": "Laki",
+ "duration": "Tagal",
+ "frames": "Mga Frame",
+ "timestamp": "Tatak ng oras",
+ "language": "Wika",
+ "aiTranslated": "Na-translate ng AI",
+ "humanTranslated": "Na-translate ng tao",
+ "humanValidated": "Na-validate ng tao",
+ "connectCameras": "Kumonekta sa mga napiling camera o i-update ang mga nakakonektang camera",
+ "resumeStreaming": "Ipagpatuloy ang streaming",
+ "pauseStreaming": "I-pause ang streaming",
+ "closeAllCameras": "Isara ang lahat ng camera",
+ "framerate": "Framerate",
+ "exposure": "Pagkakalantad",
+ "fileLabel": "File",
+ "timeDelta": "Pagkakaiba ng oras",
+ "pathLabel": "Landas",
+ "exceptionDetails": "Mga detalye ng exception",
+ "stackTrace": "Stack Trace",
+ "loadingVideos": "Naglo-load ng mga video… ({{ready}}/{{total}} handa na)",
+ "gridColumns": "Mga Grid Column",
+ "settings": "Mga Setting",
+ "appearance": "Hitsura",
+ "themeMode": "Tema",
+ "darkMode": "Madilim",
+ "lightMode": "Maliwanag",
+ "languageSettings": "Wika at Lokalisasyon",
+ "showTranslationIndicator": "Ipakita ang translation source indicator",
+ "showTranslationIndicatorDescription": "Magpakita ng badge kapag gumagamit ng AI-generated na mga pagsasalin",
+ "translationSourceLabel": "Pinagmulan ng pagsasalin",
+ "general": "Pangkalahatan",
+ "about": "Tungkol",
+ "version": "Bersyon",
+ "serverSettings": "Server",
+ "recordingSettings": "Mga Setting ng Recording",
+ "videoLoadingSettings": "Mga Setting ng Video Loading",
+ "connected": "Nakakonekta",
+ "connecting": "Kumokonekta…",
+ "disconnected": "Hindi nakakonekta",
+ "disconnect": "Idiskonekta",
+ "connect": "Ikonekta",
+ "off": "Naka-off",
+ "running": "Tumatakbo",
+ "stopped": "Huminto",
+ "working": "Nagtatrabaho…",
+ "invalid": "Hindi wasto",
+ "autoLaunch": "Awtomatikong ilunsad",
+ "autoConnect": "Awtomatikong kumonekta",
+ "runningPath": "Tumatakbo: {{path}}",
+ "noMicrophone": "Walang mikropono",
+ "audioRecordingEnabled": "Naka-enable ang audio recording",
+ "noMicrophoneSelected": "Walang napiling mikropono",
+ "recordingName": "Pangalan ng Recording: {{name}}",
+ "startingIn": "Magsisimula sa {{countdown}}...",
+ "stopping": "Humihinto...",
+ "starting": "Nagsisimula...",
+ "stopRecordingButton": "🔴 Itigil ang Pag-record",
+ "startRecordingButton": "🔴 Simulan ang Pag-record",
+ "camerasCount": "Mga Camera ({{count}})",
+ "availableCamerasCount": "Magagamit ({{count}})",
+ "server": "Server",
+ "display": "Display",
+ "rawMessage": "Hilaw na mensahe",
+ "cameraPerformanceMetrics": "Mga Camera Performance Metric",
+ "serverLogs": "Mga Server Log",
+ "sortBy": "I-sort {{direction}}",
+ "waitingForCameraStreams": "Naghihintay ng mga camera stream...",
+ "loggingPaused": "Naka-pause ang logging",
+ "noLogsToDisplay": "Walang log na ipapakita",
+ "closeSettings": "Isara ang mga setting",
+ "gridSettings": "Mga grid setting",
+ "clickToShowLess": "I-click para magpakita ng mas kaunti",
+ "clickToLearnMore": "I-click para matuto pa",
+ "samples": "mga sample",
+ "framerateOverTime": "Framerate sa Paglipas ng Oras",
+ "framerateFps": "Framerate (fps)",
+ "capturesFramesFromCamera": "Kumukuha ng mga frame mula sa camera.",
+ "rendersReceivedFrames": "Nire-render ang mga natanggap na frame sa screen.",
+ "displayTooltipLong": "Ang Display ay kumakatawan sa UI rendering performance. Ipinapakita nito kung gaano kabilis ang iyong display sa pagtanggap at pag-render ng mga frame. Ang mga isyu sa performance dito ay hindi makakaapekto sa recording quality ngunit maaaring maapektuhan ang kakayahan mong mag-monitor ng mga camera sa real-time.",
+ "statsSourceShort": "Ang Display ay nagre-render ng mga frame, ang Server ay kumukuha ng mga frame.",
+ "statsSourceLong": "Ang server ang tunay na bilis kung saan kinukuha/nire-record ang mga frame mula sa camera, habang ang display ay ang bilis kung saan natatanggap at nire-render ang mga ito. Prayoridad ng Skellycam ang server-side performance para sa recording quality, kaya mas stable dapat ang numerong iyon. Kung nag-diverge ang display framerate mula sa server, ibig sabihin sobra na ang load sa system resources mo. Isaalang-alang ang paggamit ng mas kaunting camera o pagbaba ng framerate/resolution.",
+ "statsCurrentShort": "Pinakabagong frame time at katumbas na FPS.",
+ "statsCurrentLong": "Ipinapakita nito ang pinakabagong sukat kung gaano katagal mag-process ng isang frame (sa milliseconds) at ang katumbas na frames per second (FPS). Ang mas mababang frame time at mas mataas na FPS ay nagpapahiwatig ng mas magandang performance.",
+ "statsMinShort": "Pinakamabilis na frame time (pinakamababang latency) at pinakamataas na FPS na nakamit.",
+ "statsMinLong": "Kinakatawan nito ang pinakamababang oras na kinailangan para mag-process ng isang frame sa panahon ng sampling window. Ito ay katumbas ng pinakamataas na FPS na nakamit ng iyong system sa pinaka-optimal na kondisyon.",
+ "statsMaxShort": "Pinakamabagal na frame time (pinakamataas na latency) at pinakamababang FPS na naranasan.",
+ "statsMaxLong": "Kinakatawan nito ang pinakamataas na oras na kinailangan para mag-process ng isang frame sa panahon ng sampling window. Ito ay katumbas ng pinakamababang FPS na nakamit ng iyong system sa worst-case na kondisyon. Normal lang ang paminsan-minsang pagtaas, ngunit ang patuloy na mataas na halaga ay maaaring magpahiwatig ng mga isyu sa performance.",
+ "statsMeanShort": "Average na frame time at FPS sa lahat ng sample.",
+ "statsMeanLong": "Ang arithmetic mean (average) ng lahat ng frame time na nasukat sa panahon ng sampling window at ang katumbas na FPS. Nagbibigay ito ng magandang pangkalahatang larawan ng performance ngunit maaaring ma-skew ng mga outlier.",
+ "statsMedianShort": "Gitnang halaga ng lahat ng frame time (50th percentile).",
+ "statsMedianLong": "Ang median ay kumakatawan sa gitnang halaga kapag ang lahat ng frame time ay inayos mula sa pinakamabilis hanggang sa pinakamabagal. Hindi tulad ng mean, ang median ay hindi naaapektuhan ng matitinding outlier, kaya ito ay mas stable na indicator ng karaniwang performance.",
+ "statsStdDevShort": "Sinusukat ang variability ng frame time. CV% ay relative variability.",
+ "statsStdDevLong": "Sinusukat ng standard deviation ang dami ng variation sa mga frame time. Ang mas mababang halaga ay nagpapahiwatig ng mas consistent na performance. Ang Coefficient of Variation (CV%) ay nagpapahayag ng variability na ito bilang porsyento ng mean, na nagpapadali ng paghahambing ng stability sa iba't ibang frame rate. Ang mas mababang CV% ay nagpapahiwatig ng mas stable na performance.",
+ "aiTranslatedTooltip": "Ang pagsasaling ito ay nabuo ng AI at maaaring may mga pagkakamali. Kung nagsasalita ka ng wikang ito, makakatulong ka sa pagpapabuti nito sa pamamagitan ng pagbukas ng pull request sa GitHub!",
+ "humanValidatedTooltip": "Ang pagsasaling ito ay nasuri at na-validate ng isang taong tagapagsalin.",
+ "helpTranslate": "Tumulong magsalin ng SkellyCam",
+ "failedToFetch": "Hindi nakuha",
+ "recordings": "Mga Recording",
+ "noRecordingsFound": "Walang nakitang recording. Mag-enter ng path sa itaas para manual na mag-load.",
+ "noCamerasDetected": "Walang nakitang camera",
+ "clickRefreshToScan": "I-click ang refresh para mag-scan ng mga available na camera",
+ "waitingForData": "Naghihintay ng data…",
+ "load": "I-load",
+ "refresh": "I-refresh",
+ "available": "Magagamit",
+ "menuFile": "File",
+ "menuView": "Tingnan",
+ "menuCamera": "Camera",
+ "menuRecording": "Pagre-record",
+ "menuHelp": "Tulong",
+ "menuDetectCameras": "Hanapin ang mga camera",
+ "menuConnectCameras": "Ikonekta ang mga camera",
+ "menuCloseAllCameras": "Isara ang lahat ng camera",
+ "menuOpenRecordingFolder": "Buksan ang folder ng recording…",
+ "menuToggleSidebar": "I-toggle ang sidebar",
+ "menuToggleTheme": "Palitan ang tema",
+ "menuToggleFullScreen": "Buong screen",
+ "menuPauseUnpause": "I-pause / Ituloy",
+ "menuConnectApplySettings": "Ikonekta / I-apply ang settings",
+ "menuCloseAll": "Isara lahat",
+ "menuDocumentation": "Dokumentasyon",
+ "menuGitHubRepository": "GitHub Repository",
+ "menuReportIssue": "Mag-ulat ng isyu…",
+ "menuAbout": "Tungkol sa SkellyCam",
+ "menuPlayback": "Playback",
+ "videoPlayback": "Pag-playback",
+ "copyLogsToClipboard": "Kopyahin ang mga log sa clipboard",
+ "saveLogsToFile": "I-save ang mga log sa file",
+ "copied": "Nakopya!",
+ "timestampFromRecording": "Timestamp mula sa data ng recording",
+ "menuCheckForUpdates": "Check for Updates…",
+ "updateAvailable": "Update available",
+ "updateAvailableMessage": "Version {{version}} is available",
+ "downloading": "Downloading…",
+ "downloadComplete": "Download complete",
+ "restartToUpdate": "Restart to update",
+ "checkForUpdates": "Check for Updates",
+ "upToDate": "You are up to date",
+ "updateError": "Update check failed"
+}
diff --git a/freemocap-ui-old/src/i18n/locales/tr-turkce.json b/freemocap-ui-old/src/i18n/locales/tr-turkce.json
new file mode 100644
index 00000000..ad292e98
--- /dev/null
+++ b/freemocap-ui-old/src/i18n/locales/tr-turkce.json
@@ -0,0 +1,258 @@
+{
+ "_meta": {
+ "locale": "tr",
+ "translationSource": "ai-generated",
+ "lastUpdated": "2026-02-23"
+ },
+ "appName": "SkellyCam",
+ "appNameDecorated": "SkellyCam 💀📸",
+ "welcomeTitle": "SkellyCam'e Hoş Geldiniz",
+ "welcomeSubtitle": "Senkronize videoları kaydedin ve izleyin",
+ "sendAnonymousPings": "Anonim kullanım verileri gönder",
+ "footerWith": "ile",
+ "footerFrom": "'den",
+ "footerOrgName": "FreeMoCap Foundation",
+ "home": "Ana Sayfa",
+ "cameras": "Kameralar",
+ "videos": "Videolar",
+ "expandSidebar": "Kenar çubuğunu genişlet",
+ "collapseSidebar": "Kenar çubuğunu daralt",
+ "startRecording": "Kaydı başlat",
+ "stopRecording": "Kaydı durdur",
+ "toggleTheme": "temayı değiştir",
+ "switchToDark": "Karanlık moda geç",
+ "switchToLight": "Aydınlık moda geç",
+ "connectWebSocket": "WebSocket bağlan",
+ "disconnectWebSocket": "WebSocket bağlantısını kes",
+ "launchServer": "Sunucuyu başlat",
+ "stopServer": "Sunucuyu durdur",
+ "browseForExecutable": "Çalıştırılabilir dosyayı bul",
+ "refreshCandidates": "Adayları yenile",
+ "executable": "Çalıştırılabilir",
+ "host": "Ana makine",
+ "port": "Port",
+ "cameraCount_one": "{{count}} kamera",
+ "cameraCount_other": "{{count}} kamera",
+ "connectedCameras": "Bağlı kameralar",
+ "availableCameras": "Kullanılabilir kameralar",
+ "noCamerasConnected": "Bağlı kamera yok",
+ "detectCameras": "Kullanılabilir kameraları algıla",
+ "clearCameraSettings": "Kamera ayarlarını temizle",
+ "copySettingsToAll": "Ayarları tüm kameralara kopyala",
+ "recordingTag": "Kayıt etiketi",
+ "recordingTagPlaceholder": "İsteğe bağlı etiket",
+ "recordingDirectory": "Kayıt dizini",
+ "recordingFolderPath": "Kayıt klasörü yolu",
+ "delayStart": "Gecikmeli başlat",
+ "seconds": "Saniye",
+ "subfolder": "Alt klasör",
+ "subfolderPlaceholder": "Alt klasör adı",
+ "baseName": "Temel ad",
+ "increment": "Artış",
+ "resolution": "Çözünürlük",
+ "fps": "FPS",
+ "width": "Genişlik",
+ "height": "Yükseklik",
+ "columns": "Sütunlar",
+ "auto": "Otomatik",
+ "manual": "Manuel",
+ "custom": "Özel",
+ "current": "Geçerli",
+ "recommend": "Önerilen",
+ "cameraRotation": "kamera döndürme",
+ "selectCameraRotation": "Kamera görüntü döndürmesini seç",
+ "exposureControl": "Otomatik veya manuel pozlama kontrolü",
+ "framerateControl": "Otomatik veya manuel kare hızı kontrolü",
+ "adjustExposure": "Pozlama süresini ayarla",
+ "setTargetFps": "Yakalama için hedef FPS ayarla",
+ "recordingCaptureFps": "Kayıt yakalama FPS",
+ "playbackSpeed": "Oynatma hızı",
+ "framerateTimeline": "Kare hızı zaman çizelgesi",
+ "framerateDistribution": "Kare hızı dağılımı",
+ "timelineView": "Zaman çizelgesi görünümü",
+ "distributionView": "Dağılım görünümü",
+ "combinedView": "Birleşik görünüm",
+ "min": "Min",
+ "max": "Maks",
+ "mean": "Ortalama",
+ "median": "Medyan",
+ "stdDevCv": "StdSap/CV",
+ "source": "Kaynak",
+ "selectAll": "Tümünü seç",
+ "loadSynchronizedVideos": "Senkronize videoları yükle",
+ "loadSynchronizedVideosDescription": "Bu sayfa önceden kaydedilmiş videoları yüklemenizi ve senkronize etmenizi sağlar.",
+ "automaticallySynchronizeVideos": "Videoları otomatik senkronize et",
+ "extractFramesOnLoad": "Yüklemede kareleri çıkar",
+ "generateThumbnails": "Küçük resimler oluştur",
+ "noVideosLoaded": "Yüklü video yok",
+ "filterVideos": "Videoları filtrele...",
+ "openVideo": "Videoyu aç",
+ "openFolder": "Dosya gezgininde aç",
+ "videoFolderPath": "Video klasörü yolu",
+ "jumpToStart": "Başa git (Home)",
+ "jumpToEnd": "Sona git (End)",
+ "loopOn": "Döngü açık (L ile değiştir)",
+ "loopOff": "Döngülü oynatma (L)",
+ "syncInfo": "Senkronizasyon bilgisi",
+ "syncInfoTitle": "Çoklu kamera senkronizasyonu kare düzeyinde mükemmel olmayabilir",
+ "syncInfoBody": "Tarayıcıda video oynatma, birden fazla akış arasında örnek düzeyinde kesin senkronizasyonu garanti etmez. Oynatıcı, bir lider-takipçi stratejisi kullanır ve sapma küçük bir toleransı aştığında düzeltir, ancak özellikle yüksek oynatma hızlarında veya tarayıcı yük altındayken küçük bir senkronizasyon bozukluğu (1–2 kare) oluşabilir. Kare düzeyinde kesin analiz için, her kayıtta bulunan ham zaman damgası CSV dosyalarını kullanın.",
+ "previousFrame": "Önceki kare (← / Shift+← 10 için)",
+ "nextFrame": "Sonraki kare (→ / Shift+→ 10 için)",
+ "zoomIn": "Yakınlaştır",
+ "zoomOut": "Uzaklaştır",
+ "resetZoom": "Yakınlaşmayı sıfırla",
+ "playbackSettings": "Oynatma ayarları",
+ "totalRecordingSize": "Diskteki toplam kayıt boyutu",
+ "estimatedTime": "Tahmini zaman (kare ÷ fps)",
+ "estimatedDuration": "Tahmini süre (toplam kare ÷ fps)",
+ "estimatedFromFrameNumber": "Kare numarasından tahmini × fps",
+ "frameCountPerCamera": "Kamera başına kare sayısı",
+ "cameraStreams": "Bu kayıttaki kamera akışları",
+ "backToRecordings": "Kayıtlara dön",
+ "errorsDetected": "Hatalar tespit edildi",
+ "somethingWentWrong": "Bir şeyler yanlış gitti :(",
+ "searchLogs": "Günlüklerde ara...",
+ "filter": "Filtrele…",
+ "refreshMicrophoneList": "Mikrofon listesini yenile",
+ "date": "Tarih",
+ "name": "Ad",
+ "size": "Boyut",
+ "duration": "Süre",
+ "frames": "Kareler",
+ "timestamp": "Zaman damgası",
+ "language": "Dil",
+ "aiTranslated": "Yapay zeka çevirisi",
+ "humanTranslated": "İnsan çevirisi",
+ "humanValidated": "İnsan onaylı",
+ "connectCameras": "Seçili kameralara bağlan",
+ "resumeStreaming": "Akışı devam ettir",
+ "pauseStreaming": "Akışı duraklat",
+ "closeAllCameras": "Tüm kameraları kapat",
+ "framerate": "Kare hızı",
+ "exposure": "Pozlama",
+ "fileLabel": "Dosya",
+ "timeDelta": "Zaman farkı",
+ "pathLabel": "Yol",
+ "exceptionDetails": "İstisna detayları",
+ "stackTrace": "Yığın izi",
+ "loadingVideos": "Videolar yükleniyor… ({{ready}}/{{total}} hazır)",
+ "gridColumns": "Kılavuz sütunları",
+ "settings": "Ayarlar",
+ "appearance": "Görünüm",
+ "themeMode": "Tema",
+ "darkMode": "Koyu",
+ "lightMode": "Açık",
+ "languageSettings": "Dil ve yerelleştirme",
+ "showTranslationIndicator": "Çeviri kaynağı göstergesini göster",
+ "showTranslationIndicatorDescription": "Yapay zeka çevirisi kullanırken rozet göster",
+ "translationSourceLabel": "Çeviri kaynağı",
+ "general": "Genel",
+ "about": "Hakkında",
+ "version": "Sürüm",
+ "serverSettings": "Sunucu",
+ "recordingSettings": "Kayıt ayarları",
+ "videoLoadingSettings": "Video yükleme ayarları",
+ "connected": "Bağlı",
+ "connecting": "Bağlanıyor…",
+ "disconnected": "Bağlantı kesildi",
+ "disconnect": "Bağlantıyı kes",
+ "connect": "Bağlan",
+ "off": "Kapalı",
+ "running": "Çalışıyor",
+ "stopped": "Durduruldu",
+ "working": "Çalışılıyor…",
+ "invalid": "Geçersiz",
+ "autoLaunch": "Otomatik başlat",
+ "autoConnect": "Otomatik bağlan",
+ "runningPath": "Çalışıyor: {{path}}",
+ "noMicrophone": "Mikrofon yok",
+ "audioRecordingEnabled": "Ses kaydı etkin",
+ "noMicrophoneSelected": "Mikrofon seçilmedi",
+ "recordingName": "Kayıt adı: {{name}}",
+ "startingIn": "{{countdown}} içinde başlıyor...",
+ "stopping": "Durduruluyor...",
+ "starting": "Başlatılıyor...",
+ "stopRecordingButton": "🔴 Kaydı durdur",
+ "startRecordingButton": "🔴 Kaydı başlat",
+ "camerasCount": "Kameralar ({{count}})",
+ "availableCamerasCount": "Kullanılabilir ({{count}})",
+ "server": "Sunucu",
+ "display": "Ekran",
+ "rawMessage": "Ham mesaj",
+ "cameraPerformanceMetrics": "Kamera performans metrikleri",
+ "serverLogs": "Sunucu günlükleri",
+ "sortBy": "Sırala {{direction}}",
+ "waitingForCameraStreams": "Kamera akışları bekleniyor...",
+ "loggingPaused": "Günlükleme duraklatıldı",
+ "noLogsToDisplay": "Gösterilecek günlük yok",
+ "closeSettings": "Ayarları kapat",
+ "gridSettings": "Kılavuz ayarları",
+ "clickToShowLess": "Daraltmak için tıkla",
+ "clickToLearnMore": "Daha fazla bilgi için tıkla",
+ "samples": "örnek",
+ "framerateOverTime": "Zamana göre kare hızı",
+ "framerateFps": "Kare hızı (fps)",
+ "capturesFramesFromCamera": "Kameradan kare yakalar.",
+ "rendersReceivedFrames": "Alınan kareleri ekranda işler.",
+ "displayTooltipLong": "Ekran, kullanıcı arayüzü işleme performansını temsil eder. Ekranınızın kareleri ne kadar hızlı aldığını ve işlediğini gösterir. Buradaki performans sorunları kayıt kalitesini etkilemez ancak kameraları gerçek zamanlı izleme yeteneğinizi etkileyebilir.",
+ "statsSourceShort": "Ekran kareleri işler, sunucu kareleri yakalar.",
+ "statsSourceLong": "Sunucu, kameradan karelerin çekildiği/kaydedildiği gerçek hızdır; ekran ise alınma ve işlenme hızıdır. SkellyCam kayıt kalitesi için sunucu tarafı performansına öncelik verir, bu nedenle bu sayı daha kararlı kalmalıdır. Ekran kare hızı sunucudan saparsa, sistem kaynaklarınızın zorlandığını gösterir. Daha az kamera kullanmayı veya kare hızı/çözünürlüğü düşürmeyi düşünün.",
+ "statsCurrentShort": "En son kare süresi ve FPS.",
+ "statsCurrentLong": "Tek bir karenin işlenmesi için gereken sürenin (milisaniye cinsinden) ve karşılık gelen saniyedeki kare sayısının (FPS) en son ölçümünü gösterir. Daha düşük kare süreleri ve daha yüksek FPS daha iyi performans gösterir.",
+ "statsMinShort": "En hızlı kare süresi ve en yüksek FPS.",
+ "statsMinLong": "Örnekleme penceresinde tek bir karenin işlenmesi için gereken minimum süreyi temsil eder. Optimal koşullarda sisteminizin ulaştığı maksimum FPS'e karşılık gelir.",
+ "statsMaxShort": "En yavaş kare süresi ve en düşük FPS.",
+ "statsMaxLong": "Örnekleme penceresinde tek bir karenin işlenmesi için gereken maksimum süreyi temsil eder. En kötü koşullarda minimum FPS'e karşılık gelir. Ara sıra yaşanan artışlar normaldir, ancak sürekli yüksek değerler performans sorunlarına işaret edebilir.",
+ "statsMeanShort": "Tüm örneklerde ortalama kare süresi ve FPS.",
+ "statsMeanLong": "Örnekleme penceresi boyunca ölçülen tüm kare sürelerinin aritmetik ortalaması ve karşılık gelen FPS. Performansın iyi bir genel resmini verir ancak aykırı değerlerden etkilenebilir.",
+ "statsMedianShort": "Tüm kare sürelerinin medyan değeri (50. yüzdelik).",
+ "statsMedianLong": "Medyan, tüm kare süreleri en hızlıdan en yavaşa sıralandığında ortadaki değeri temsil eder. Ortalamadan farklı olarak, medyan aşırı aykırı değerlerden etkilenmez, bu da onu tipik performansın daha kararlı bir göstergesi yapar.",
+ "statsStdDevShort": "Kare süresi değişkenliğini ölçer. CV% göreceli.",
+ "statsStdDevLong": "Standart sapma, kare sürelerindeki değişim miktarını ölçer. Daha düşük değerler daha tutarlı performans gösterir. Değişim Katsayısı (CV%) bu değişkenliği ortalamanın yüzdesi olarak ifade eder, farklı kare hızları arasında kararlılık karşılaştırmasını kolaylaştırır. Daha düşük CV% daha kararlı performans gösterir.",
+ "aiTranslatedTooltip": "Bu çeviri yapay zeka tarafından oluşturuldu ve hatalar içerebilir. Bu dili konuşuyorsanız iyileştirmeye yardım edin!",
+ "humanValidatedTooltip": "Bu çeviri bir insan çevirmen tarafından doğrulanmıştır.",
+ "helpTranslate": "SkellyCam çevirisine yardım edin",
+ "failedToFetch": "Veri alınamadı",
+ "recordings": "Kayıtlar",
+ "noRecordingsFound": "Kayıt bulunamadı. Manuel olarak yüklemek için yukarıya bir yol girin.",
+ "noCamerasDetected": "Kamera algılanmadı",
+ "clickRefreshToScan": "Kullanılabilir kameraları aramak için yenile'ye tıklayın",
+ "waitingForData": "Veri bekleniyor…",
+ "load": "Yükle",
+ "refresh": "Yenile",
+ "available": "Kullanılabilir",
+ "menuFile": "Dosya",
+ "menuView": "Görünüm",
+ "menuCamera": "Kamera",
+ "menuRecording": "Kayıt",
+ "menuHelp": "Yardım",
+ "menuDetectCameras": "Kameraları algıla",
+ "menuConnectCameras": "Kameraları bağla",
+ "menuCloseAllCameras": "Tüm kameraları kapat",
+ "menuOpenRecordingFolder": "Kayıt klasörünü aç…",
+ "menuToggleSidebar": "Kenar çubuğunu aç/kapat",
+ "menuToggleTheme": "Temayı değiştir",
+ "menuToggleFullScreen": "Tam ekran",
+ "menuPauseUnpause": "Duraklat / Devam et",
+ "menuConnectApplySettings": "Bağla / Ayarları uygula",
+ "menuCloseAll": "Tümünü kapat",
+ "menuDocumentation": "Dokümantasyon",
+ "menuGitHubRepository": "GitHub deposu",
+ "menuReportIssue": "Sorun bildir…",
+ "menuAbout": "SkellyCam hakkında",
+ "menuPlayback": "Oynatma",
+ "videoPlayback": "Oynatma",
+ "copyLogsToClipboard": "Günlükleri panoya kopyala",
+ "saveLogsToFile": "Günlükleri dosyaya kaydet",
+ "copied": "Kopyalandı!",
+ "timestampFromRecording": "Kayıt verilerinden zaman damgası",
+ "menuCheckForUpdates": "Check for Updates…",
+ "updateAvailable": "Update available",
+ "updateAvailableMessage": "Version {{version}} is available",
+ "downloading": "Downloading…",
+ "downloadComplete": "Download complete",
+ "restartToUpdate": "Restart to update",
+ "checkForUpdates": "Check for Updates",
+ "upToDate": "You are up to date",
+ "updateError": "Update check failed"
+}
diff --git a/freemocap-ui-old/src/i18n/locales/uk-ukrainska.json b/freemocap-ui-old/src/i18n/locales/uk-ukrainska.json
new file mode 100644
index 00000000..247b6ff9
--- /dev/null
+++ b/freemocap-ui-old/src/i18n/locales/uk-ukrainska.json
@@ -0,0 +1,258 @@
+{
+ "_meta": {
+ "locale": "uk",
+ "translationSource": "ai-generated",
+ "lastUpdated": "2026-02-23"
+ },
+ "appName": "SkellyCam",
+ "appNameDecorated": "SkellyCam 💀📸",
+ "welcomeTitle": "Ласкаво просимо до SkellyCam",
+ "welcomeSubtitle": "Записуйте та переглядайте синхронізовані відео",
+ "sendAnonymousPings": "Надсилати анонімні дані використання",
+ "footerWith": "з",
+ "footerFrom": "від",
+ "footerOrgName": "FreeMoCap Foundation",
+ "home": "Головна",
+ "cameras": "Камери",
+ "videos": "Відео",
+ "expandSidebar": "Розгорнути бічну панель",
+ "collapseSidebar": "Згорнути бічну панель",
+ "startRecording": "Почати запис",
+ "stopRecording": "Зупинити запис",
+ "toggleTheme": "перемкнути тему",
+ "switchToDark": "Перемкнути на темну тему",
+ "switchToLight": "Перемкнути на світлу тему",
+ "connectWebSocket": "Підключити WebSocket",
+ "disconnectWebSocket": "Від'єднати WebSocket",
+ "launchServer": "Запустити сервер",
+ "stopServer": "Зупинити сервер",
+ "browseForExecutable": "Знайти виконуваний файл",
+ "refreshCandidates": "Оновити кандидатів",
+ "executable": "Виконуваний файл",
+ "host": "Хост",
+ "port": "Порт",
+ "cameraCount_one": "{{count}} камера",
+ "cameraCount_other": "{{count}} камер",
+ "connectedCameras": "Підключені камери",
+ "availableCameras": "Доступні камери",
+ "noCamerasConnected": "Камери не підключені",
+ "detectCameras": "Виявити доступні камери",
+ "clearCameraSettings": "Очистити налаштування камер",
+ "copySettingsToAll": "Скопіювати на всі камери",
+ "recordingTag": "Тег запису",
+ "recordingTagPlaceholder": "Необов'язковий тег",
+ "recordingDirectory": "Каталог записів",
+ "recordingFolderPath": "Шлях до папки записів",
+ "delayStart": "Відкладений старт",
+ "seconds": "Секунди",
+ "subfolder": "Підпапка",
+ "subfolderPlaceholder": "Назва підпапки",
+ "baseName": "Базове ім'я",
+ "increment": "Інкремент",
+ "resolution": "Роздільна здатність",
+ "fps": "FPS",
+ "width": "Ширина",
+ "height": "Висота",
+ "columns": "Стовпці",
+ "auto": "Авто",
+ "manual": "Ручний",
+ "custom": "Користувацький",
+ "current": "Поточний",
+ "recommend": "Рекомендовано",
+ "cameraRotation": "обертання камери",
+ "selectCameraRotation": "Вибрати обертання зображення",
+ "exposureControl": "Автоматичне або ручне керування експозицією",
+ "framerateControl": "Автоматичне або ручне керування частотою кадрів",
+ "adjustExposure": "Налаштувати час експозиції",
+ "setTargetFps": "Встановити цільовий FPS для захоплення",
+ "recordingCaptureFps": "Частота захоплення запису",
+ "playbackSpeed": "Швидкість відтворення",
+ "framerateTimeline": "Хронологія частоти кадрів",
+ "framerateDistribution": "Розподіл частоти кадрів",
+ "timelineView": "Вигляд хронології",
+ "distributionView": "Вигляд розподілу",
+ "combinedView": "Комбінований вигляд",
+ "min": "Мін",
+ "max": "Макс",
+ "mean": "Середнє",
+ "median": "Медіана",
+ "stdDevCv": "СтВідх/CV",
+ "source": "Джерело",
+ "selectAll": "Вибрати все",
+ "loadSynchronizedVideos": "Завантажити синхронізовані відео",
+ "loadSynchronizedVideosDescription": "Ця сторінка дозволяє завантажити та синхронізувати записані відео.",
+ "automaticallySynchronizeVideos": "Автоматично синхронізувати відео",
+ "extractFramesOnLoad": "Витягнути кадри при завантаженні",
+ "generateThumbnails": "Створити мініатюри",
+ "noVideosLoaded": "Відео не завантажені",
+ "filterVideos": "Фільтр відео...",
+ "openVideo": "Відкрити відео",
+ "openFolder": "Відкрити папку у провіднику",
+ "videoFolderPath": "Шлях до папки відео",
+ "jumpToStart": "До початку (Home)",
+ "jumpToEnd": "До кінця (End)",
+ "loopOn": "Повтор увімкнено (L для перемикання)",
+ "loopOff": "Повторне відтворення (L)",
+ "syncInfo": "Інформація про синхронізацію",
+ "syncInfoTitle": "Синхронізація кількох камер може бути не ідеальною на рівні кадрів",
+ "syncInfoBody": "Відтворення відео в браузері не гарантує точної синхронізації на рівні семплів для кількох потоків. Плеєр використовує стратегію лідер-послідовник і коригує розсинхронізацію при перевищенні невеликого допуску, але незначна десинхронізація (1–2 кадри) може виникати, особливо при високій швидкості відтворення або при навантаженні на браузер. Для покадрового аналізу використовуйте необроблені CSV-файли часових міток, включені до кожного запису.",
+ "previousFrame": "Попередній кадр (← / Shift+← на 10)",
+ "nextFrame": "Наступний кадр (→ / Shift+→ на 10)",
+ "zoomIn": "Збільшити",
+ "zoomOut": "Зменшити",
+ "resetZoom": "Скинути масштаб",
+ "playbackSettings": "Налаштування відтворення",
+ "totalRecordingSize": "Загальний розмір запису на диску",
+ "estimatedTime": "Орієнтовний час (кадр ÷ fps)",
+ "estimatedDuration": "Орієнтовна тривалість (кадри ÷ fps)",
+ "estimatedFromFrameNumber": "Оцінка з номера кадру × fps",
+ "frameCountPerCamera": "Кількість кадрів на камеру",
+ "cameraStreams": "Потоки камер у цьому записі",
+ "backToRecordings": "Назад до записів",
+ "errorsDetected": "Виявлено помилки",
+ "somethingWentWrong": "Щось пішло не так :(",
+ "searchLogs": "Пошук у журналі...",
+ "filter": "Фільтр…",
+ "refreshMicrophoneList": "Оновити список мікрофонів",
+ "date": "Дата",
+ "name": "Назва",
+ "size": "Розмір",
+ "duration": "Тривалість",
+ "frames": "Кадри",
+ "timestamp": "Мітка часу",
+ "language": "Мова",
+ "aiTranslated": "ШІ-переклад",
+ "humanTranslated": "Переклад людиною",
+ "humanValidated": "Перевірено людиною",
+ "connectCameras": "Підключити вибрані камери",
+ "resumeStreaming": "Відновити потік",
+ "pauseStreaming": "Призупинити потік",
+ "closeAllCameras": "Закрити всі камери",
+ "framerate": "Частота кадрів",
+ "exposure": "Експозиція",
+ "fileLabel": "Файл",
+ "timeDelta": "Дельта часу",
+ "pathLabel": "Шлях",
+ "exceptionDetails": "Деталі винятку",
+ "stackTrace": "Трасування стеку",
+ "loadingVideos": "Завантаження відео… ({{ready}}/{{total}} готово)",
+ "gridColumns": "Стовпці сітки",
+ "settings": "Налаштування",
+ "appearance": "Зовнішній вигляд",
+ "themeMode": "Тема",
+ "darkMode": "Темна",
+ "lightMode": "Світла",
+ "languageSettings": "Мова та локалізація",
+ "showTranslationIndicator": "Показувати індикатор джерела перекладу",
+ "showTranslationIndicatorDescription": "Показувати значок при ШІ-перекладах",
+ "translationSourceLabel": "Джерело перекладу",
+ "general": "Загальне",
+ "about": "Про програму",
+ "version": "Версія",
+ "serverSettings": "Сервер",
+ "recordingSettings": "Налаштування запису",
+ "videoLoadingSettings": "Налаштування завантаження відео",
+ "connected": "Підключено",
+ "connecting": "Підключення…",
+ "disconnected": "Від'єднано",
+ "disconnect": "Від'єднати",
+ "connect": "Підключити",
+ "off": "Вимк",
+ "running": "Запущено",
+ "stopped": "Зупинено",
+ "working": "Обробка…",
+ "invalid": "Недійсний",
+ "autoLaunch": "Автозапуск",
+ "autoConnect": "Автопідключення",
+ "runningPath": "Запущено: {{path}}",
+ "noMicrophone": "Немає мікрофона",
+ "audioRecordingEnabled": "Аудіозапис увімкнено",
+ "noMicrophoneSelected": "Мікрофон не вибрано",
+ "recordingName": "Назва запису: {{name}}",
+ "startingIn": "Старт через {{countdown}}...",
+ "stopping": "Зупинка...",
+ "starting": "Запуск...",
+ "stopRecordingButton": "🔴 Зупинити запис",
+ "startRecordingButton": "🔴 Почати запис",
+ "camerasCount": "Камери ({{count}})",
+ "availableCamerasCount": "Доступно ({{count}})",
+ "server": "Сервер",
+ "display": "Дисплей",
+ "rawMessage": "Вихідне повідомлення",
+ "cameraPerformanceMetrics": "Показники продуктивності камер",
+ "serverLogs": "Журнал сервера",
+ "sortBy": "Сортувати {{direction}}",
+ "waitingForCameraStreams": "Очікування потоків камер...",
+ "loggingPaused": "Журнал призупинено",
+ "noLogsToDisplay": "Немає журналів для відображення",
+ "closeSettings": "Закрити налаштування",
+ "gridSettings": "Налаштування сітки",
+ "clickToShowLess": "Натисніть, щоб згорнути",
+ "clickToLearnMore": "Натисніть, щоб дізнатися більше",
+ "samples": "зразків",
+ "framerateOverTime": "Частота кадрів у часі",
+ "framerateFps": "Частота кадрів (fps)",
+ "capturesFramesFromCamera": "Захоплює кадри з камери.",
+ "rendersReceivedFrames": "Відображає отримані кадри на екрані.",
+ "displayTooltipLong": "Дисплей відображає продуктивність рендерингу інтерфейсу користувача. Показує, наскільки швидко ваш дисплей отримує та відтворює кадри. Проблеми з продуктивністю тут не вплинуть на якість запису, але можуть вплинути на можливість моніторингу камер у реальному часі.",
+ "statsSourceShort": "Дисплей рендерить кадри, сервер захоплює кадри.",
+ "statsSourceLong": "Сервер — це реальна швидкість, з якою кадри отримуються/записуються з камери, а дисплей — швидкість їх отримання та відтворення. SkellyCam пріоритизує серверну продуктивність для якості запису, тому це значення повинно залишатися стабільнішим. Якщо частота кадрів дисплея відхиляється від сервера, це вказує на навантаження системних ресурсів. Розгляньте використання меншої кількості камер або зниження частоти кадрів/роздільної здатності.",
+ "statsCurrentShort": "Останній час кадру та FPS.",
+ "statsCurrentLong": "Показує останнє вимірювання часу обробки одного кадру (у мілісекундах) та відповідну кількість кадрів на секунду (FPS). Нижчий час кадру та вищий FPS вказують на кращу продуктивність.",
+ "statsMinShort": "Найшвидший час кадру та найвищий FPS.",
+ "statsMinLong": "Представляє мінімальний час обробки одного кадру у вікні вибірки. Відповідає максимальному FPS, досягнутому вашою системою в оптимальних умовах.",
+ "statsMaxShort": "Найповільніший час кадру та найнижчий FPS.",
+ "statsMaxLong": "Представляє максимальний час обробки одного кадру у вікні вибірки. Відповідає мінімальному FPS у найгірших умовах. Випадкові сплески є нормальними, але стабільно високі значення можуть вказувати на проблеми з продуктивністю.",
+ "statsMeanShort": "Середній час кадру та FPS по всіх зразках.",
+ "statsMeanLong": "Середнє арифметичне всіх виміряних часів кадрів у вікні вибірки та відповідний FPS. Дає гарне загальне уявлення про продуктивність, але може бути спотворене викидами.",
+ "statsMedianShort": "Медіана всіх часів кадрів (50-й процентиль).",
+ "statsMedianLong": "Медіана представляє середнє значення, коли всі часи кадрів відсортовані від найшвидшого до найповільнішого. На відміну від середнього, медіана не залежить від екстремальних викидів, що робить її більш стабільним показником типової продуктивності.",
+ "statsStdDevShort": "Вимірює мінливість часу кадру. CV% — відносна.",
+ "statsStdDevLong": "Стандартне відхилення вимірює розкид часів кадрів. Нижчі значення вказують на стабільнішу продуктивність. Коефіцієнт варіації (CV%) виражає цю мінливість як відсоток від середнього, що спрощує порівняння стабільності при різних частотах кадрів. Нижчий CV% вказує на стабільнішу продуктивність.",
+ "aiTranslatedTooltip": "Цей переклад створений ШІ і може містити помилки. Якщо ви володієте цією мовою, допоможіть покращити його!",
+ "humanValidatedTooltip": "Цей переклад перевірено перекладачем.",
+ "helpTranslate": "Допоможіть перекласти SkellyCam",
+ "failedToFetch": "Не вдалося отримати",
+ "recordings": "Записи",
+ "noRecordingsFound": "Записів не знайдено. Введіть шлях вище для завантаження вручну.",
+ "noCamerasDetected": "Камери не виявлені",
+ "clickRefreshToScan": "Натисніть оновити для пошуку доступних камер",
+ "waitingForData": "Очікування даних…",
+ "load": "Завантажити",
+ "refresh": "Оновити",
+ "available": "Доступна",
+ "menuFile": "Файл",
+ "menuView": "Вигляд",
+ "menuCamera": "Камера",
+ "menuRecording": "Запис",
+ "menuHelp": "Довідка",
+ "menuDetectCameras": "Виявити камери",
+ "menuConnectCameras": "Підключити камери",
+ "menuCloseAllCameras": "Закрити всі камери",
+ "menuOpenRecordingFolder": "Відкрити папку записів…",
+ "menuToggleSidebar": "Перемкнути бічну панель",
+ "menuToggleTheme": "Змінити тему",
+ "menuToggleFullScreen": "На весь екран",
+ "menuPauseUnpause": "Пауза / Продовжити",
+ "menuConnectApplySettings": "Підключити / Застосувати налаштування",
+ "menuCloseAll": "Закрити все",
+ "menuDocumentation": "Документація",
+ "menuGitHubRepository": "Репозиторій GitHub",
+ "menuReportIssue": "Повідомити про помилку…",
+ "menuAbout": "Про SkellyCam",
+ "menuPlayback": "Відтворення",
+ "videoPlayback": "Відтворення",
+ "copyLogsToClipboard": "Копіювати журнали в буфер обміну",
+ "saveLogsToFile": "Зберегти журнали у файл",
+ "copied": "Скопійовано!",
+ "timestampFromRecording": "Мітка часу з даних запису",
+ "menuCheckForUpdates": "Check for Updates…",
+ "updateAvailable": "Update available",
+ "updateAvailableMessage": "Version {{version}} is available",
+ "downloading": "Downloading…",
+ "downloadComplete": "Download complete",
+ "restartToUpdate": "Restart to update",
+ "checkForUpdates": "Check for Updates",
+ "upToDate": "You are up to date",
+ "updateError": "Update check failed"
+}
diff --git a/freemocap-ui-old/src/i18n/locales/ur-urdu.json b/freemocap-ui-old/src/i18n/locales/ur-urdu.json
new file mode 100644
index 00000000..8625e662
--- /dev/null
+++ b/freemocap-ui-old/src/i18n/locales/ur-urdu.json
@@ -0,0 +1,258 @@
+{
+ "_meta": {
+ "locale": "ur",
+ "translationSource": "ai-generated",
+ "lastUpdated": "2026-02-23"
+ },
+ "appName": "SkellyCam",
+ "appNameDecorated": "SkellyCam 💀📸",
+ "welcomeTitle": "SkellyCam میں خوش آمدید",
+ "welcomeSubtitle": "ہم آہنگ ویڈیوز ریکارڈ اور دیکھیں",
+ "sendAnonymousPings": "گمنام استعمال کے پنگ بھیجیں",
+ "footerWith": "کے ساتھ",
+ "footerFrom": "سے",
+ "footerOrgName": "FreeMoCap Foundation",
+ "home": "ہوم",
+ "cameras": "کیمرے",
+ "videos": "ویڈیوز",
+ "expandSidebar": "سائیڈ بار کو پھیلائیں",
+ "collapseSidebar": "سائیڈ بار کو سکیڑیں",
+ "startRecording": "ریکارڈنگ شروع کریں",
+ "stopRecording": "ریکارڈنگ بند کریں",
+ "toggleTheme": "تھیم تبدیل کریں",
+ "switchToDark": "ڈارک موڈ میں تبدیل کریں",
+ "switchToLight": "لائٹ موڈ میں تبدیل کریں",
+ "connectWebSocket": "WebSocket جوڑیں",
+ "disconnectWebSocket": "WebSocket منقطع کریں",
+ "launchServer": "سرور شروع کریں",
+ "stopServer": "سرور بند کریں",
+ "browseForExecutable": "قابل عمل فائل تلاش کریں",
+ "refreshCandidates": "امیدواروں کو تازہ کریں",
+ "executable": "قابل عمل",
+ "host": "ہوسٹ",
+ "port": "پورٹ",
+ "cameraCount_one": "{{count}} کیمرا",
+ "cameraCount_other": "{{count}} کیمرے",
+ "connectedCameras": "جڑے ہوئے کیمرے",
+ "availableCameras": "دستیاب کیمرے",
+ "noCamerasConnected": "کوئی کیمرا جڑا نہیں ہے",
+ "detectCameras": "دستیاب کیمرے تلاش کریں",
+ "clearCameraSettings": "میموری سے محفوظ کیمرا ترتیبات صاف کریں",
+ "copySettingsToAll": "ترتیبات تمام کیمروں میں کاپی کریں",
+ "recordingTag": "ریکارڈنگ ٹیگ",
+ "recordingTagPlaceholder": "اختیاری ٹیگ",
+ "recordingDirectory": "ریکارڈنگ ڈائریکٹری",
+ "recordingFolderPath": "ریکارڈنگ فولڈر کا راستہ",
+ "delayStart": "شروع میں تاخیر",
+ "seconds": "سیکنڈ",
+ "subfolder": "ذیلی فولڈر",
+ "subfolderPlaceholder": "ذیلی فولڈر کا نام",
+ "baseName": "بنیادی نام",
+ "increment": "اضافہ",
+ "resolution": "ریزولیوشن",
+ "fps": "FPS",
+ "width": "چوڑائی",
+ "height": "اونچائی",
+ "columns": "کالم",
+ "auto": "خودکار",
+ "manual": "دستی",
+ "custom": "حسب ضرورت",
+ "current": "موجودہ",
+ "recommend": "تجویز کریں",
+ "cameraRotation": "کیمرا گردش",
+ "selectCameraRotation": "کیمرا تصویر کی گردش منتخب کریں",
+ "exposureControl": "خودکار یا دستی ایکسپوژر کنٹرول میں سے منتخب کریں",
+ "framerateControl": "خودکار یا دستی فریم ریٹ کنٹرول میں سے منتخب کریں",
+ "adjustExposure": "ایکسپوژر ٹائم ایڈجسٹ کریں، مثلاً cv2.VideoCapture.set(cv2.CAP_PROP_EXPOSURE, value)",
+ "setTargetFps": "کیمرا کیپچر کے لیے ہدف فریم فی سیکنڈ (FPS) سیٹ کریں",
+ "recordingCaptureFps": "ریکارڈنگ کیپچر فریم ریٹ",
+ "playbackSpeed": "پلے بیک رفتار (ریکارڈنگ fps پر اثر نہیں ڈالتی)",
+ "framerateTimeline": "فریم ریٹ ٹائم لائن",
+ "framerateDistribution": "فریم ریٹ تقسیم",
+ "timelineView": "ٹائم لائن ویو",
+ "distributionView": "تقسیم ویو",
+ "combinedView": "مشترکہ ویو",
+ "min": "کم",
+ "max": "زیادہ",
+ "mean": "اوسط",
+ "median": "درمیانہ",
+ "stdDevCv": "StdDev/CV",
+ "source": "ذریعہ",
+ "selectAll": "سب منتخب کریں",
+ "loadSynchronizedVideos": "ہم آہنگ ویڈیوز لوڈ کریں",
+ "loadSynchronizedVideosDescription": "یہ صفحہ آپ کو پہلے سے ریکارڈ شدہ ویڈیوز لوڈ اور ہم آہنگ کرنے کی اجازت دیتا ہے۔",
+ "automaticallySynchronizeVideos": "ویڈیوز خودکار طور پر ہم آہنگ کریں",
+ "extractFramesOnLoad": "لوڈ کرتے وقت فریم نکالیں",
+ "generateThumbnails": "تھمب نیلز بنائیں",
+ "noVideosLoaded": "کوئی ویڈیو لوڈ نہیں ہوئی",
+ "filterVideos": "ویڈیوز فلٹر کریں...",
+ "openVideo": "ویڈیو کھولیں",
+ "openFolder": "فائل ایکسپلورر میں فولڈر کھولیں",
+ "videoFolderPath": "ویڈیو فولڈر کا راستہ",
+ "jumpToStart": "شروع میں جائیں (Home)",
+ "jumpToEnd": "آخر میں جائیں (End)",
+ "loopOn": "لوپ آن ہے (ٹوگل کرنے کے لیے L)",
+ "loopOff": "لوپ پلے بیک (L)",
+ "syncInfo": "سنک معلومات",
+ "syncInfoTitle": "ملٹی کیمرہ سنک فریم کی سطح پر مکمل نہیں ہو سکتا",
+ "syncInfoBody": "براؤزر ویڈیو پلے بیک متعدد سٹریمز میں سیمپل درست مطابقت پذیری کی ضمانت نہیں دیتا۔ پلیئر لیڈر-فالوور حکمت عملی استعمال کرتا ہے اور جب ڈرفٹ ایک چھوٹی برداشت سے تجاوز کرے تو اسے درست کرتا ہے، لیکن معمولی غیر مطابقت پذیری (1–2 فریم) ہو سکتی ہے، خاص طور پر تیز پلے بیک رفتار پر یا جب براؤزر بوجھ میں ہو۔ فریم-درست تجزیے کے لیے، ہر ریکارڈنگ میں شامل خام ٹائم اسٹیمپ CSV فائلیں استعمال کریں۔",
+ "previousFrame": "پچھلا فریم (← / Shift+← 10 کے لیے)",
+ "nextFrame": "اگلا فریم (→ / Shift+→ 10 کے لیے)",
+ "zoomIn": "زوم ان",
+ "zoomOut": "زوم آؤٹ",
+ "resetZoom": "زوم ری سیٹ",
+ "playbackSettings": "پلے بیک ترتیبات",
+ "totalRecordingSize": "ڈسک پر ریکارڈنگ کا کل سائز",
+ "estimatedTime": "تخمینی وقت (فریم ÷ ریکارڈنگ fps)",
+ "estimatedDuration": "تخمینی دورانیہ (کل فریمز ÷ ریکارڈنگ fps)",
+ "estimatedFromFrameNumber": "فریم نمبر × ریکارڈنگ fps سے تخمینہ — ٹائم اسٹیمپ ڈیٹا سے نہیں پڑھا گیا",
+ "frameCountPerCamera": "فی کیمرا فریم کی تعداد",
+ "cameraStreams": "اس ریکارڈنگ میں کیمرا اسٹریمز",
+ "backToRecordings": "ریکارڈنگز پر واپس",
+ "errorsDetected": "غلطیاں پائی گئیں",
+ "somethingWentWrong": "کچھ غلط ہو گیا :(",
+ "searchLogs": "لاگز تلاش کریں...",
+ "filter": "فلٹر…",
+ "refreshMicrophoneList": "مائیکروفون فہرست تازہ کریں",
+ "date": "تاریخ",
+ "name": "نام",
+ "size": "سائز",
+ "duration": "دورانیہ",
+ "frames": "فریمز",
+ "timestamp": "ٹائم اسٹیمپ",
+ "language": "زبان",
+ "aiTranslated": "AI ترجمہ شدہ",
+ "humanTranslated": "انسانی ترجمہ شدہ",
+ "humanValidated": "انسانی تصدیق شدہ",
+ "connectCameras": "منتخب کیمروں سے جڑیں یا جڑے ہوئے کیمرے اپ ڈیٹ کریں",
+ "resumeStreaming": "اسٹریمنگ دوبارہ شروع کریں",
+ "pauseStreaming": "اسٹریمنگ روکیں",
+ "closeAllCameras": "تمام کیمرے بند کریں",
+ "framerate": "فریم ریٹ",
+ "exposure": "ایکسپوژر",
+ "fileLabel": "فائل",
+ "timeDelta": "وقت کا فرق",
+ "pathLabel": "راستہ",
+ "exceptionDetails": "استثنا کی تفصیلات",
+ "stackTrace": "اسٹیک ٹریس",
+ "loadingVideos": "ویڈیوز لوڈ ہو رہی ہیں… ({{ready}}/{{total}} تیار)",
+ "gridColumns": "گرڈ کالم",
+ "settings": "ترتیبات",
+ "appearance": "ظاہری شکل",
+ "themeMode": "تھیم",
+ "darkMode": "ڈارک",
+ "lightMode": "لائٹ",
+ "languageSettings": "زبان اور مقامیت",
+ "showTranslationIndicator": "ترجمے کے ذریعے کا اشارہ دکھائیں",
+ "showTranslationIndicatorDescription": "AI سے تیار کردہ ترجمے استعمال کرتے وقت بیج دکھائیں",
+ "translationSourceLabel": "ترجمے کا ذریعہ",
+ "general": "عمومی",
+ "about": "بارے میں",
+ "version": "ورژن",
+ "serverSettings": "سرور",
+ "recordingSettings": "ریکارڈنگ ترتیبات",
+ "videoLoadingSettings": "ویڈیو لوڈنگ ترتیبات",
+ "connected": "جڑا ہوا",
+ "connecting": "جڑ رہا ہے…",
+ "disconnected": "منقطع",
+ "disconnect": "منقطع کریں",
+ "connect": "جوڑیں",
+ "off": "بند",
+ "running": "چل رہا ہے",
+ "stopped": "رکا ہوا",
+ "working": "کام ہو رہا ہے…",
+ "invalid": "غلط",
+ "autoLaunch": "خودکار شروع",
+ "autoConnect": "خودکار جڑیں",
+ "runningPath": "چل رہا ہے: {{path}}",
+ "noMicrophone": "کوئی مائیکروفون نہیں",
+ "audioRecordingEnabled": "آڈیو ریکارڈنگ فعال",
+ "noMicrophoneSelected": "کوئی مائیکروفون منتخب نہیں",
+ "recordingName": "ریکارڈنگ کا نام: {{name}}",
+ "startingIn": "{{countdown}} میں شروع ہو رہا ہے...",
+ "stopping": "بند ہو رہا ہے...",
+ "starting": "شروع ہو رہا ہے...",
+ "stopRecordingButton": "🔴 ریکارڈنگ بند کریں",
+ "startRecordingButton": "🔴 ریکارڈنگ شروع کریں",
+ "camerasCount": "کیمرے ({{count}})",
+ "availableCamerasCount": "دستیاب ({{count}})",
+ "server": "سرور",
+ "display": "ڈسپلے",
+ "rawMessage": "خام پیغام",
+ "cameraPerformanceMetrics": "کیمرا کارکردگی میٹرکس",
+ "serverLogs": "سرور لاگز",
+ "sortBy": "{{direction}} ترتیب دیں",
+ "waitingForCameraStreams": "کیمرا اسٹریمز کا انتظار...",
+ "loggingPaused": "لاگنگ روکی گئی",
+ "noLogsToDisplay": "دکھانے کے لیے کوئی لاگ نہیں",
+ "closeSettings": "ترتیبات بند کریں",
+ "gridSettings": "گرڈ ترتیبات",
+ "clickToShowLess": "کم دکھانے کے لیے کلک کریں",
+ "clickToLearnMore": "مزید جاننے کے لیے کلک کریں",
+ "samples": "نمونے",
+ "framerateOverTime": "وقت کے ساتھ فریم ریٹ",
+ "framerateFps": "فریم ریٹ (fps)",
+ "capturesFramesFromCamera": "کیمرے سے فریمز پکڑتا ہے۔",
+ "rendersReceivedFrames": "موصول شدہ فریمز کو اسکرین پر دکھاتا ہے۔",
+ "displayTooltipLong": "ڈسپلے UI رینڈرنگ کارکردگی کی نمائندگی کرتا ہے۔ یہ دکھاتا ہے کہ آپ کا ڈسپلے کتنی تیزی سے فریمز وصول کرتا اور دکھاتا ہے۔ یہاں کارکردگی کے مسائل ریکارڈنگ کے معیار کو متاثر نہیں کریں گے لیکن ریئل ٹائم میں کیمروں کی نگرانی کرنے کی آپ کی صلاحیت کو متاثر کر سکتے ہیں۔",
+ "statsSourceShort": "ڈسپلے فریمز دکھاتا ہے، سرور فریمز پکڑتا ہے۔",
+ "statsSourceLong": "سرور وہ اصل رفتار ہے جس پر فریمز کیمرے سے کھینچے/ریکارڈ کیے جاتے ہیں، جبکہ ڈسپلے وہ رفتار ہے جس پر وہ موصول اور دکھائے جاتے ہیں۔ Skellycam ریکارڈنگ کے معیار کے لیے سرور سائیڈ کارکردگی کو ترجیح دیتا ہے، اس لیے وہ نمبر زیادہ مستحکم رہنا چاہیے۔ اگر ڈسپلے فریم ریٹ سرور سے ہٹ جائے تو اس کا مطلب ہے کہ آپ کے سسٹم کے وسائل پر بوجھ ہے۔ کم کیمرے استعمال کرنے یا فریم ریٹ/ریزولیوشن کم کرنے پر غور کریں۔",
+ "statsCurrentShort": "تازہ ترین فریم ٹائم اور متعلقہ FPS۔",
+ "statsCurrentLong": "یہ ایک فریم پراسیس کرنے میں لگنے والے وقت (ملی سیکنڈ میں) اور مساوی FPS کی تازہ ترین پیمائش دکھاتا ہے۔ کم فریم ٹائم اور زیادہ FPS بہتر کارکردگی کی نشاندہی کرتی ہے۔",
+ "statsMinShort": "تیز ترین فریم ٹائم (کم ترین تاخیر) اور حاصل کردہ زیادہ سے زیادہ FPS۔",
+ "statsMinLong": "یہ نمونہ ونڈو کے دوران ایک فریم پراسیس کرنے کے لیے درکار کم سے کم وقت کی نمائندگی کرتا ہے۔ یہ بہترین حالات میں آپ کے سسٹم کی حاصل کردہ زیادہ سے زیادہ FPS سے مطابقت رکھتا ہے۔",
+ "statsMaxShort": "سست ترین فریم ٹائم (زیادہ ترین تاخیر) اور تجربہ کردہ کم ترین FPS۔",
+ "statsMaxLong": "یہ نمونہ ونڈو کے دوران ایک فریم پراسیس کرنے کے لیے درکار زیادہ سے زیادہ وقت کی نمائندگی کرتا ہے۔ بدترین حالات میں آپ کے سسٹم کی حاصل کردہ کم ترین FPS سے مطابقت رکھتا ہے۔ کبھی کبھار اچھالیں عام ہیں لیکن مسلسل زیادہ قدریں کارکردگی کے مسائل کی نشاندہی کر سکتی ہیں۔",
+ "statsMeanShort": "تمام نمونوں میں اوسط فریم ٹائم اور FPS۔",
+ "statsMeanLong": "نمونہ ونڈو کے دوران ناپے گئے تمام فریم ٹائمز کا حسابی اوسط اور متعلقہ FPS۔ یہ کارکردگی کی اچھی مجموعی تصویر دیتا ہے لیکن انتہائی قدروں سے متاثر ہو سکتا ہے۔",
+ "statsMedianShort": "تمام فریم ٹائمز کی درمیانی قدر (50واں فیصد)۔",
+ "statsMedianLong": "درمیانہ اس درمیانی قدر کی نمائندگی کرتا ہے جب تمام فریم ٹائمز تیز ترین سے سست ترین تک ترتیب دیے جائیں۔ اوسط کے برعکس، درمیانہ انتہائی اقدار سے متاثر نہیں ہوتا، جو اسے عام کارکردگی کا زیادہ مستحکم اشارہ بناتا ہے۔",
+ "statsStdDevShort": "فریم ٹائم تغیر پذیری کی پیمائش کرتا ہے۔ CV% نسبتی تغیر پذیری ہے۔",
+ "statsStdDevLong": "معیاری انحراف فریم ٹائمز میں تغیر کی مقدار ناپتا ہے۔ کم قدریں زیادہ مستقل کارکردگی کی نشاندہی کرتی ہیں۔ تغیر کا گتانک (CV%) اس تغیر پذیری کو اوسط کے فیصد کے طور پر ظاہر کرتا ہے، مختلف فریم ریٹس میں استحکام کا موازنہ آسان بناتا ہے۔ کم CV% زیادہ مستحکم کارکردگی کی نشاندہی کرتا ہے۔",
+ "aiTranslatedTooltip": "یہ ترجمہ AI کے ذریعے تیار کیا گیا ہے اور اس میں غلطیاں ہو سکتی ہیں۔ اگر آپ یہ زبان بولتے ہیں تو GitHub پر pull request کھول کر اسے بہتر بنانے میں مدد کر سکتے ہیں!",
+ "humanValidatedTooltip": "اس ترجمے کا انسانی مترجم نے جائزہ لیا اور تصدیق کی ہے۔",
+ "helpTranslate": "SkellyCam کا ترجمہ کرنے میں مدد کریں",
+ "failedToFetch": "حاصل کرنے میں ناکام",
+ "recordings": "ریکارڈنگز",
+ "noRecordingsFound": "کوئی ریکارڈنگ نہیں ملی۔ دستی طور پر لوڈ کرنے کے لیے اوپر راستہ درج کریں۔",
+ "noCamerasDetected": "کوئی کیمرا نہیں ملا",
+ "clickRefreshToScan": "دستیاب کیمروں کو اسکین کرنے کے لیے تازہ کریں پر کلک کریں",
+ "waitingForData": "ڈیٹا کا انتظار…",
+ "load": "لوڈ",
+ "refresh": "تازہ کریں",
+ "available": "دستیاب",
+ "menuFile": "فائل",
+ "menuView": "نظارہ",
+ "menuCamera": "کیمرہ",
+ "menuRecording": "ریکارڈنگ",
+ "menuHelp": "مدد",
+ "menuDetectCameras": "کیمرے تلاش کریں",
+ "menuConnectCameras": "کیمرے جوڑیں",
+ "menuCloseAllCameras": "تمام کیمرے بند کریں",
+ "menuOpenRecordingFolder": "ریکارڈنگ فولڈر کھولیں…",
+ "menuToggleSidebar": "سائیڈ بار ٹوگل کریں",
+ "menuToggleTheme": "تھیم تبدیل کریں",
+ "menuToggleFullScreen": "پوری سکرین",
+ "menuPauseUnpause": "روکیں / جاری رکھیں",
+ "menuConnectApplySettings": "جوڑیں / سیٹنگز لاگو کریں",
+ "menuCloseAll": "سب بند کریں",
+ "menuDocumentation": "دستاویزات",
+ "menuGitHubRepository": "GitHub ریپوزٹری",
+ "menuReportIssue": "مسئلے کی اطلاع دیں…",
+ "menuAbout": "SkellyCam کے بارے میں",
+ "menuPlayback": "پلے بیک",
+ "videoPlayback": "پلے بیک",
+ "copyLogsToClipboard": "لاگز کلپ بورڈ پر کاپی کریں",
+ "saveLogsToFile": "لاگز فائل میں محفوظ کریں",
+ "copied": "کاپی ہو گیا!",
+ "timestampFromRecording": "ریکارڈنگ ڈیٹا سے ٹائم اسٹیمپ",
+ "menuCheckForUpdates": "Check for Updates…",
+ "updateAvailable": "Update available",
+ "updateAvailableMessage": "Version {{version}} is available",
+ "downloading": "Downloading…",
+ "downloadComplete": "Download complete",
+ "restartToUpdate": "Restart to update",
+ "checkForUpdates": "Check for Updates",
+ "upToDate": "You are up to date",
+ "updateError": "Update check failed"
+}
diff --git a/freemocap-ui-old/src/i18n/locales/vi-tieng-viet.json b/freemocap-ui-old/src/i18n/locales/vi-tieng-viet.json
new file mode 100644
index 00000000..94872f30
--- /dev/null
+++ b/freemocap-ui-old/src/i18n/locales/vi-tieng-viet.json
@@ -0,0 +1,258 @@
+{
+ "_meta": {
+ "locale": "vi",
+ "translationSource": "ai-generated",
+ "lastUpdated": "2026-02-23"
+ },
+ "appName": "SkellyCam",
+ "appNameDecorated": "SkellyCam 💀📸",
+ "welcomeTitle": "Chào mừng đến với SkellyCam",
+ "welcomeSubtitle": "Ghi và xem video đồng bộ",
+ "sendAnonymousPings": "Gửi dữ liệu sử dụng ẩn danh",
+ "footerWith": "với",
+ "footerFrom": "từ",
+ "footerOrgName": "FreeMoCap Foundation",
+ "home": "Trang chủ",
+ "cameras": "Camera",
+ "videos": "Video",
+ "expandSidebar": "Mở rộng thanh bên",
+ "collapseSidebar": "Thu gọn thanh bên",
+ "startRecording": "Bắt đầu ghi",
+ "stopRecording": "Dừng ghi",
+ "toggleTheme": "đổi giao diện",
+ "switchToDark": "Chuyển sang chế độ tối",
+ "switchToLight": "Chuyển sang chế độ sáng",
+ "connectWebSocket": "Kết nối WebSocket",
+ "disconnectWebSocket": "Ngắt kết nối WebSocket",
+ "launchServer": "Khởi động máy chủ",
+ "stopServer": "Dừng máy chủ",
+ "browseForExecutable": "Tìm tệp thực thi",
+ "refreshCandidates": "Làm mới ứng viên",
+ "executable": "Tệp thực thi",
+ "host": "Máy chủ",
+ "port": "Cổng",
+ "cameraCount_one": "{{count}} camera",
+ "cameraCount_other": "{{count}} camera",
+ "connectedCameras": "Camera đã kết nối",
+ "availableCameras": "Camera có sẵn",
+ "noCamerasConnected": "Không có camera kết nối",
+ "detectCameras": "Phát hiện camera có sẵn",
+ "clearCameraSettings": "Xóa cài đặt camera",
+ "copySettingsToAll": "Sao chép cài đặt cho tất cả",
+ "recordingTag": "Thẻ ghi",
+ "recordingTagPlaceholder": "Thẻ tùy chọn",
+ "recordingDirectory": "Thư mục ghi",
+ "recordingFolderPath": "Đường dẫn thư mục ghi",
+ "delayStart": "Bắt đầu trễ",
+ "seconds": "Giây",
+ "subfolder": "Thư mục con",
+ "subfolderPlaceholder": "Tên thư mục con",
+ "baseName": "Tên cơ sở",
+ "increment": "Gia tăng",
+ "resolution": "Độ phân giải",
+ "fps": "FPS",
+ "width": "Chiều rộng",
+ "height": "Chiều cao",
+ "columns": "Cột",
+ "auto": "Tự động",
+ "manual": "Thủ công",
+ "custom": "Tùy chỉnh",
+ "current": "Hiện tại",
+ "recommend": "Đề xuất",
+ "cameraRotation": "xoay camera",
+ "selectCameraRotation": "Chọn xoay hình ảnh camera",
+ "exposureControl": "Điều khiển phơi sáng tự động hoặc thủ công",
+ "framerateControl": "Điều khiển tốc độ khung hình tự động hoặc thủ công",
+ "adjustExposure": "Điều chỉnh thời gian phơi sáng",
+ "setTargetFps": "Đặt FPS mục tiêu cho chụp",
+ "recordingCaptureFps": "FPS chụp ghi",
+ "playbackSpeed": "Tốc độ phát lại",
+ "framerateTimeline": "Dòng thời gian tốc độ khung",
+ "framerateDistribution": "Phân bố tốc độ khung hình",
+ "timelineView": "Xem dòng thời gian",
+ "distributionView": "Xem phân bố",
+ "combinedView": "Xem kết hợp",
+ "min": "Tối thiểu",
+ "max": "Tối đa",
+ "mean": "Trung bình",
+ "median": "Trung vị",
+ "stdDevCv": "ĐộLC/CV",
+ "source": "Nguồn",
+ "selectAll": "Chọn tất cả",
+ "loadSynchronizedVideos": "Tải video đồng bộ",
+ "loadSynchronizedVideosDescription": "Trang này cho phép bạn tải và đồng bộ video đã ghi trước.",
+ "automaticallySynchronizeVideos": "Tự động đồng bộ video",
+ "extractFramesOnLoad": "Trích xuất khung khi tải",
+ "generateThumbnails": "Tạo hình thu nhỏ",
+ "noVideosLoaded": "Chưa tải video nào",
+ "filterVideos": "Lọc video...",
+ "openVideo": "Mở video",
+ "openFolder": "Mở thư mục trong trình quản lý",
+ "videoFolderPath": "Đường dẫn thư mục video",
+ "jumpToStart": "Nhảy đến đầu (Home)",
+ "jumpToEnd": "Nhảy đến cuối (End)",
+ "loopOn": "Đã bật lặp (L để chuyển đổi)",
+ "loopOff": "Phát lặp (L)",
+ "syncInfo": "Thông tin đồng bộ",
+ "syncInfoTitle": "Đồng bộ đa camera có thể không chính xác ở mức khung hình",
+ "syncInfoBody": "Phát lại video trên trình duyệt không đảm bảo đồng bộ chính xác ở mức mẫu trên nhiều luồng. Trình phát sử dụng chiến lược dẫn đầu-theo sau và sửa lỗi trôi khi vượt quá dung sai nhỏ, nhưng sự lệch đồng bộ nhỏ (1–2 khung hình) có thể xảy ra, đặc biệt ở tốc độ phát cao hoặc khi trình duyệt đang tải nặng. Để phân tích chính xác theo khung hình, hãy sử dụng các tệp CSV dấu thời gian thô có trong mỗi bản ghi.",
+ "previousFrame": "Khung trước (← / Shift+← cho 10)",
+ "nextFrame": "Khung tiếp theo (→ / Shift+→ cho 10)",
+ "zoomIn": "Phóng to",
+ "zoomOut": "Thu nhỏ",
+ "resetZoom": "Đặt lại thu phóng",
+ "playbackSettings": "Cài đặt phát lại",
+ "totalRecordingSize": "Tổng dung lượng ghi trên đĩa",
+ "estimatedTime": "Thời gian ước tính (khung ÷ fps)",
+ "estimatedDuration": "Thời lượng ước tính (tổng khung ÷ fps)",
+ "estimatedFromFrameNumber": "Ước tính từ số khung × fps",
+ "frameCountPerCamera": "Số khung hình mỗi camera",
+ "cameraStreams": "Luồng camera trong bản ghi này",
+ "backToRecordings": "Quay lại bản ghi",
+ "errorsDetected": "Phát hiện lỗi",
+ "somethingWentWrong": "Đã xảy ra lỗi :(",
+ "searchLogs": "Tìm kiếm nhật ký...",
+ "filter": "Lọc…",
+ "refreshMicrophoneList": "Làm mới danh sách micro",
+ "date": "Ngày",
+ "name": "Tên",
+ "size": "Kích thước",
+ "duration": "Thời lượng",
+ "frames": "Khung hình",
+ "timestamp": "Dấu thời gian",
+ "language": "Ngôn ngữ",
+ "aiTranslated": "Dịch bằng AI",
+ "humanTranslated": "Dịch bởi người",
+ "humanValidated": "Người xác nhận",
+ "connectCameras": "Kết nối camera đã chọn",
+ "resumeStreaming": "Tiếp tục phát trực tiếp",
+ "pauseStreaming": "Tạm dừng phát trực tiếp",
+ "closeAllCameras": "Đóng tất cả camera",
+ "framerate": "Tốc độ khung hình",
+ "exposure": "Phơi sáng",
+ "fileLabel": "Tệp",
+ "timeDelta": "Chênh lệch thời gian",
+ "pathLabel": "Đường dẫn",
+ "exceptionDetails": "Chi tiết ngoại lệ",
+ "stackTrace": "Dấu vết ngăn xếp",
+ "loadingVideos": "Đang tải video… ({{ready}}/{{total}} sẵn sàng)",
+ "gridColumns": "Cột lưới",
+ "settings": "Cài đặt",
+ "appearance": "Giao diện",
+ "themeMode": "Chủ đề",
+ "darkMode": "Tối",
+ "lightMode": "Sáng",
+ "languageSettings": "Ngôn ngữ và bản địa hóa",
+ "showTranslationIndicator": "Hiện chỉ báo nguồn dịch",
+ "showTranslationIndicatorDescription": "Hiện huy hiệu khi dùng bản dịch AI",
+ "translationSourceLabel": "Nguồn dịch",
+ "general": "Chung",
+ "about": "Giới thiệu",
+ "version": "Phiên bản",
+ "serverSettings": "Máy chủ",
+ "recordingSettings": "Cài đặt ghi",
+ "videoLoadingSettings": "Cài đặt tải video",
+ "connected": "Đã kết nối",
+ "connecting": "Đang kết nối…",
+ "disconnected": "Đã ngắt kết nối",
+ "disconnect": "Ngắt kết nối",
+ "connect": "Kết nối",
+ "off": "Tắt",
+ "running": "Đang chạy",
+ "stopped": "Đã dừng",
+ "working": "Đang xử lý…",
+ "invalid": "Không hợp lệ",
+ "autoLaunch": "Tự khởi động",
+ "autoConnect": "Tự động kết nối",
+ "runningPath": "Đang chạy: {{path}}",
+ "noMicrophone": "Không có micro",
+ "audioRecordingEnabled": "Ghi âm đã bật",
+ "noMicrophoneSelected": "Chưa chọn micro",
+ "recordingName": "Tên bản ghi: {{name}}",
+ "startingIn": "Bắt đầu sau {{countdown}}...",
+ "stopping": "Đang dừng...",
+ "starting": "Đang bắt đầu...",
+ "stopRecordingButton": "🔴 Dừng ghi",
+ "startRecordingButton": "🔴 Bắt đầu ghi",
+ "camerasCount": "Camera ({{count}})",
+ "availableCamerasCount": "Có sẵn ({{count}})",
+ "server": "Máy chủ",
+ "display": "Hiển thị",
+ "rawMessage": "Tin nhắn gốc",
+ "cameraPerformanceMetrics": "Chỉ số hiệu suất camera",
+ "serverLogs": "Nhật ký máy chủ",
+ "sortBy": "Sắp xếp {{direction}}",
+ "waitingForCameraStreams": "Đang chờ luồng camera...",
+ "loggingPaused": "Ghi nhật ký tạm dừng",
+ "noLogsToDisplay": "Không có nhật ký để hiển thị",
+ "closeSettings": "Đóng cài đặt",
+ "gridSettings": "Cài đặt lưới",
+ "clickToShowLess": "Nhấn để thu gọn",
+ "clickToLearnMore": "Nhấn để tìm hiểu thêm",
+ "samples": "mẫu",
+ "framerateOverTime": "Tốc độ khung hình theo thời gian",
+ "framerateFps": "Tốc độ khung hình (fps)",
+ "capturesFramesFromCamera": "Chụp khung hình từ camera.",
+ "rendersReceivedFrames": "Render các khung nhận được lên màn hình.",
+ "displayTooltipLong": "Hiển thị thể hiện hiệu suất render giao diện người dùng. Cho thấy màn hình của bạn nhận và render khung hình nhanh đến mức nào. Vấn đề hiệu suất ở đây sẽ không ảnh hưởng đến chất lượng ghi hình nhưng có thể ảnh hưởng đến khả năng giám sát camera theo thời gian thực.",
+ "statsSourceShort": "Hiển thị render khung, máy chủ chụp khung.",
+ "statsSourceLong": "Máy chủ là tốc độ thực tế mà khung hình được kéo/ghi từ camera, trong khi hiển thị là tốc độ nhận và render chúng. SkellyCam ưu tiên hiệu suất phía máy chủ cho chất lượng ghi hình, vì vậy con số đó sẽ ổn định hơn. Nếu tốc độ khung hình hiển thị lệch so với máy chủ, điều này cho thấy tài nguyên hệ thống đang bị quá tải. Hãy cân nhắc sử dụng ít camera hơn hoặc giảm tốc độ khung hình/độ phân giải.",
+ "statsCurrentShort": "Thời gian khung và FPS mới nhất.",
+ "statsCurrentLong": "Hiển thị phép đo gần nhất về thời gian xử lý một khung hình đơn lẻ (tính bằng mili giây) và số khung hình mỗi giây (FPS) tương đương. Thời gian khung hình thấp hơn và FPS cao hơn cho thấy hiệu suất tốt hơn.",
+ "statsMinShort": "Thời gian khung nhanh nhất và FPS cao nhất.",
+ "statsMinLong": "Đại diện cho thời gian tối thiểu để xử lý một khung hình đơn lẻ trong cửa sổ lấy mẫu. Tương ứng với FPS tối đa mà hệ thống đạt được trong điều kiện tối ưu.",
+ "statsMaxShort": "Thời gian khung chậm nhất và FPS thấp nhất.",
+ "statsMaxLong": "Đại diện cho thời gian tối đa để xử lý một khung hình đơn lẻ trong cửa sổ lấy mẫu. Tương ứng với FPS tối thiểu trong điều kiện xấu nhất. Đỉnh nhọn thỉnh thoảng là bình thường, nhưng giá trị cao liên tục có thể chỉ ra vấn đề hiệu suất.",
+ "statsMeanShort": "Thời gian khung trung bình và FPS trên tất cả mẫu.",
+ "statsMeanLong": "Trung bình cộng của tất cả thời gian khung hình đo được trong cửa sổ lấy mẫu và FPS tương ứng. Cung cấp bức tranh tổng thể tốt về hiệu suất nhưng có thể bị lệch bởi các giá trị ngoại lai.",
+ "statsMedianShort": "Giá trị trung vị của tất cả thời gian khung (phần trăm thứ 50).",
+ "statsMedianLong": "Trung vị đại diện cho giá trị giữa khi tất cả thời gian khung hình được sắp xếp từ nhanh nhất đến chậm nhất. Khác với trung bình, trung vị không bị ảnh hưởng bởi các giá trị ngoại lai cực đoan, khiến nó trở thành chỉ báo ổn định hơn về hiệu suất điển hình.",
+ "statsStdDevShort": "Đo độ biến thiên thời gian khung. CV% là tương đối.",
+ "statsStdDevLong": "Độ lệch chuẩn đo lường sự biến thiên trong thời gian khung hình. Giá trị thấp hơn cho thấy hiệu suất nhất quán hơn. Hệ số biến thiên (CV%) biểu thị sự biến động này dưới dạng phần trăm của trung bình, giúp so sánh tính ổn định giữa các tốc độ khung hình khác nhau dễ dàng hơn. CV% thấp hơn cho thấy hiệu suất ổn định hơn.",
+ "aiTranslatedTooltip": "Bản dịch này được tạo bởi AI và có thể chứa lỗi. Nếu bạn nói ngôn ngữ này, hãy giúp cải thiện!",
+ "humanValidatedTooltip": "Bản dịch này đã được người dịch xác nhận.",
+ "helpTranslate": "Giúp dịch SkellyCam",
+ "failedToFetch": "Lấy dữ liệu thất bại",
+ "recordings": "Bản ghi",
+ "noRecordingsFound": "Không tìm thấy bản ghi. Nhập đường dẫn phía trên để tải thủ công.",
+ "noCamerasDetected": "Không phát hiện camera nào",
+ "clickRefreshToScan": "Nhấn làm mới để tìm camera có sẵn",
+ "waitingForData": "Đang chờ dữ liệu…",
+ "load": "Tải",
+ "refresh": "Làm mới",
+ "available": "Có sẵn",
+ "menuFile": "Tệp",
+ "menuView": "Xem",
+ "menuCamera": "Camera",
+ "menuRecording": "Ghi hình",
+ "menuHelp": "Trợ giúp",
+ "menuDetectCameras": "Phát hiện camera",
+ "menuConnectCameras": "Kết nối camera",
+ "menuCloseAllCameras": "Đóng tất cả camera",
+ "menuOpenRecordingFolder": "Mở thư mục ghi hình…",
+ "menuToggleSidebar": "Ẩn/hiện thanh bên",
+ "menuToggleTheme": "Chuyển đổi giao diện",
+ "menuToggleFullScreen": "Toàn màn hình",
+ "menuPauseUnpause": "Tạm dừng / Tiếp tục",
+ "menuConnectApplySettings": "Kết nối / Áp dụng cài đặt",
+ "menuCloseAll": "Đóng tất cả",
+ "menuDocumentation": "Tài liệu",
+ "menuGitHubRepository": "Kho lưu trữ GitHub",
+ "menuReportIssue": "Báo cáo sự cố…",
+ "menuAbout": "Về SkellyCam",
+ "menuPlayback": "Phát lại",
+ "videoPlayback": "Phát lại",
+ "copyLogsToClipboard": "Sao chép nhật ký vào bộ nhớ tạm",
+ "saveLogsToFile": "Lưu nhật ký vào tập tin",
+ "copied": "Đã sao chép!",
+ "timestampFromRecording": "Dấu thời gian từ dữ liệu ghi hình",
+ "menuCheckForUpdates": "Check for Updates…",
+ "updateAvailable": "Update available",
+ "updateAvailableMessage": "Version {{version}} is available",
+ "downloading": "Downloading…",
+ "downloadComplete": "Download complete",
+ "restartToUpdate": "Restart to update",
+ "checkForUpdates": "Check for Updates",
+ "upToDate": "You are up to date",
+ "updateError": "Update check failed"
+}
diff --git a/freemocap-ui-old/src/i18n/locales/yi-yidish.json b/freemocap-ui-old/src/i18n/locales/yi-yidish.json
new file mode 100644
index 00000000..69e459ca
--- /dev/null
+++ b/freemocap-ui-old/src/i18n/locales/yi-yidish.json
@@ -0,0 +1,258 @@
+{
+ "_meta": {
+ "locale": "yi",
+ "translationSource": "ai-generated",
+ "lastUpdated": "2026-02-24"
+ },
+ "appName": "SkellyCam",
+ "appNameDecorated": "SkellyCam 💀📸",
+ "welcomeTitle": "ברוכים הבאים צו SkellyCam",
+ "welcomeSubtitle": "אויפֿנעמען און באַקוקן סינכראָניזירטע ווידעאָס",
+ "sendAnonymousPings": "שיקן אַנאָנימע באַניצונג פּינגס",
+ "footerWith": "מיט",
+ "footerFrom": "פֿון",
+ "footerOrgName": "FreeMoCap Foundation",
+ "home": "היים",
+ "cameras": "קאַמעראַס",
+ "videos": "ווידעאָס",
+ "expandSidebar": "אויסברייטערן זייטלייסט",
+ "collapseSidebar": "צונויפֿקלאַפּן זייטלייסט",
+ "startRecording": "אָנהייבן אויפֿנעמען",
+ "stopRecording": "אָפּשטעלן אויפֿנעמען",
+ "toggleTheme": "בייטן טעמע",
+ "switchToDark": "בייטן צו טונקל",
+ "switchToLight": "בייטן צו ליכטיק",
+ "connectWebSocket": "פֿאַרבינדן WebSocket",
+ "disconnectWebSocket": "אָפּבינדן WebSocket",
+ "launchServer": "אָנהייבן סערווער",
+ "stopServer": "אָפּשטעלן סערווער",
+ "browseForExecutable": "זוכן אויספֿירבאַרע טעקע",
+ "refreshCandidates": "דערפֿרישן קאַנדידאַטן",
+ "executable": "אויספֿירבאַרע טעקע",
+ "host": "סערווער",
+ "port": "פּאָרט",
+ "cameraCount_one": "{{count}} קאַמעראַ",
+ "cameraCount_other": "{{count}} קאַמעראַס",
+ "connectedCameras": "פֿאַרבונדענע קאַמעראַס",
+ "availableCameras": "פֿאַראַנענע קאַמעראַס",
+ "noCamerasConnected": "קיין קאַמעראַס זענען נישט פֿאַרבונדן",
+ "detectCameras": "אויפֿגעפֿינען פֿאַראַנענע קאַמעראַס",
+ "clearCameraSettings": "אויסמעקן קאַמעראַ אײַנשטעלונגען",
+ "copySettingsToAll": "קאָפּירן אײַנשטעלונגען צו אַלע",
+ "recordingTag": "אויפֿנאַמע צייכן",
+ "recordingTagPlaceholder": "אָפּציאָנעלער צייכן",
+ "recordingDirectory": "אויפֿנאַמע מאַפּע",
+ "recordingFolderPath": "אויפֿנאַמע מאַפּע וועג",
+ "delayStart": "פֿאַרשפּעטיקטער אָנהייב",
+ "seconds": "סעקונדעס",
+ "subfolder": "אונטער-מאַפּע",
+ "subfolderPlaceholder": "אונטער-מאַפּע נאָמען",
+ "baseName": "באַזיס נאָמען",
+ "increment": "צוגאָב",
+ "resolution": "רעזאָלוציע",
+ "fps": "FPS",
+ "width": "ברייט",
+ "height": "הייך",
+ "columns": "זייַלן",
+ "auto": "אויטאָמאַטיש",
+ "manual": "מאַנועל",
+ "custom": "מנהג",
+ "current": "יעצטיק",
+ "recommend": "רעקאָמענדירט",
+ "cameraRotation": "קאַמעראַ דרייונג",
+ "selectCameraRotation": "אויסקלייַבן קאַמעראַ דרייונג",
+ "exposureControl": "אויטאָמאַטיש אָדער מאַנועלע עקספּאָזיציע",
+ "framerateControl": "אויטאָמאַטיש אָדער מאַנועלע בילדרייט",
+ "adjustExposure": "אײַנשטעלן עקספּאָזיציע צייַט",
+ "setTargetFps": "באַשטימען ציל FPS",
+ "recordingCaptureFps": "אויפֿנאַמע FPS",
+ "playbackSpeed": "שפּיל גיכקייט",
+ "framerateTimeline": "בילדרייט צייטלייַן",
+ "framerateDistribution": "בילדרייט פֿאַרטיילונג",
+ "timelineView": "צייטלייַן אַנזיכט",
+ "distributionView": "פֿאַרטיילונג אַנזיכט",
+ "combinedView": "קאָמבינירטע אַנזיכט",
+ "min": "מין",
+ "max": "מאַקס",
+ "mean": "מיטל",
+ "median": "מעדיאַן",
+ "stdDevCv": "סטד/CV",
+ "source": "מקור",
+ "selectAll": "אויסקלייַבן אַלע",
+ "loadSynchronizedVideos": "לאָדן סינכראָניזירטע ווידעאָס",
+ "loadSynchronizedVideosDescription": "דאָ קענט איר לאָדן און סינכראָניזירן פֿאָראויס אויפֿגענומענע ווידעאָס.",
+ "automaticallySynchronizeVideos": "אויטאָמאַטיש סינכראָניזירן ווידעאָס",
+ "extractFramesOnLoad": "אַרויסנעמען בילדער בײַם לאָדן",
+ "generateThumbnails": "שאַפֿן מיניאַטורן",
+ "noVideosLoaded": "קיין ווידעאָס נישט געלאָדן",
+ "filterVideos": "פֿילטערן ווידעאָס...",
+ "openVideo": "עפֿענען ווידעאָ",
+ "openFolder": "עפֿענען מאַפּע",
+ "videoFolderPath": "ווידעאָ מאַפּע וועג",
+ "jumpToStart": "שפּרינגען צום אָנהייב (Home)",
+ "jumpToEnd": "שפּרינגען צום סוף (End)",
+ "loopOn": "שלייף איז אָן (L צו טאָגלען)",
+ "loopOff": "שלייף אָפּשפּילן (L)",
+ "syncInfo": "סינכראָניזאַציע אינפֿאָ",
+ "syncInfoTitle": "מולטי-קאַמערע סינכראָניזאַציע קען נישט זיין פרעים-פּערפעקט",
+ "syncInfoBody": "בלעטערער ווידעאָ אָפּשפּילונג גאַראַנטירט נישט מוסטער-פּינטלעכע סינכראָניזאַציע איבער מערערע סטרימז. דער שפּילער נוצט אַ פירער-נאָכפֿאָלגער סטראַטעגיע און פאַרריכט דריפט ווען עס איבערשטײַגט אַ קליין טאָלעראַנץ, אָבער קליינע דעסינכראָניזאַציע (1–2 פרעימז) קען פאָרקומען, באַזונדערס ביי הויכע אָפּשפּילונג געשווינדיקייטן אָדער ווען דער בלעטערער איז אונטער באַלאַסט. פֿאַר פרעים-פּינטלעכע אַנאַליז, נוצט די רוי צייטשטעמפּל CSV טעקעס אַרײַנגערעכנט אין יעדער אויפנאַמע.",
+ "previousFrame": "פֿריִערדיקער בילד (← / Shift+← פֿאַר 10)",
+ "nextFrame": "קומענדיקער בילד (→ / Shift+→ פֿאַר 10)",
+ "zoomIn": "צוזום",
+ "zoomOut": "אַוועקזום",
+ "resetZoom": "צוריקשטעלן זום",
+ "playbackSettings": "שפּיל אײַנשטעלונגען",
+ "totalRecordingSize": "גאַנצע אויפֿנאַמע גרייס אויפֿן דיסק",
+ "estimatedTime": "געשאַצטע צייַט (בילד ÷ FPS)",
+ "estimatedDuration": "געשאַצטע דויער (אַלע בילדער ÷ FPS)",
+ "estimatedFromFrameNumber": "געשאַצט פֿון בילד נומער × FPS",
+ "frameCountPerCamera": "בילדער צאָל פֿאַר יעדער קאַמעראַ",
+ "cameraStreams": "קאַמעראַ סטרימס אין דער אויפֿנאַמע",
+ "backToRecordings": "צוריק צו אויפֿנאַמעס",
+ "errorsDetected": "טעותן אויפֿגעפֿונען",
+ "somethingWentWrong": "עפּעס איז שיפֿגעגאַנגען :(",
+ "searchLogs": "זוכן אין לאָגס...",
+ "filter": "פֿילטערן…",
+ "refreshMicrophoneList": "דערפֿרישן מיקראָפֿאָן ליסטע",
+ "date": "דאַטום",
+ "name": "נאָמען",
+ "size": "גרייס",
+ "duration": "דויער",
+ "frames": "בילדער",
+ "timestamp": "צייטשטעמפּל",
+ "language": "שפּראַך",
+ "aiTranslated": "AI איבערזעצט",
+ "humanTranslated": "מענטשלעך איבערזעצט",
+ "humanValidated": "מענטשלעך באַשטעטיקט",
+ "connectCameras": "פֿאַרבינדן אויסגעקליבענע קאַמעראַס",
+ "resumeStreaming": "פֿאָרזעצן סטרימינג",
+ "pauseStreaming": "פּויזירן סטרימינג",
+ "closeAllCameras": "שליסן אַלע קאַמעראַס",
+ "framerate": "בילדרייט",
+ "exposure": "עקספּאָזיציע",
+ "fileLabel": "טעקע",
+ "timeDelta": "צייט חילוק",
+ "pathLabel": "וועג",
+ "exceptionDetails": "טעות דעטאַלן",
+ "stackTrace": "סטעק שפּור",
+ "loadingVideos": "לאָדן ווידעאָס… ({{ready}}/{{total}} גרייט)",
+ "gridColumns": "ראַסטער זייַלן",
+ "settings": "אײַנשטעלונגען",
+ "appearance": "אויסזען",
+ "themeMode": "טעמע",
+ "darkMode": "טונקל",
+ "lightMode": "ליכטיק",
+ "languageSettings": "שפּראַך און לאָקאַליזאַציע",
+ "showTranslationIndicator": "ווייַזן איבערזעצונג מקור אינדיקאַטאָר",
+ "showTranslationIndicatorDescription": "ווייַזן אַ באַדזש בײַ AI-איבערזעצונגען",
+ "translationSourceLabel": "איבערזעצונג מקור",
+ "general": "אַלגעמיין",
+ "about": "וועגן",
+ "version": "ווערסיע",
+ "serverSettings": "סערווער",
+ "recordingSettings": "אויפֿנאַמע אײַנשטעלונגען",
+ "videoLoadingSettings": "ווידעאָ לאָדן אײַנשטעלונגען",
+ "connected": "פֿאַרבונדן",
+ "connecting": "פֿאַרבינדן…",
+ "disconnected": "אָפּגעבונדן",
+ "disconnect": "אָפּבינדן",
+ "connect": "פֿאַרבינדן",
+ "off": "אויס",
+ "running": "לויפֿט",
+ "stopped": "אָפּגעשטעלט",
+ "working": "אַרבעט…",
+ "invalid": "אומגילטיק",
+ "autoLaunch": "אויטאָ-אָנהייב",
+ "autoConnect": "אויטאָ-פֿאַרבינדן",
+ "runningPath": "לויפֿט: {{path}}",
+ "noMicrophone": "קיין מיקראָפֿאָן",
+ "audioRecordingEnabled": "אוידיאָ אויפֿנאַמע אַקטיוו",
+ "noMicrophoneSelected": "קיין מיקראָפֿאָן אויסגעקליבן",
+ "recordingName": "אויפֿנאַמע נאָמען: {{name}}",
+ "startingIn": "הייבט אָן אין {{countdown}}…",
+ "stopping": "שטעלט אָפּ…",
+ "starting": "הייבט אָן…",
+ "stopRecordingButton": "🔴 אָפּשטעלן אויפֿנעמען",
+ "startRecordingButton": "🔴 אָנהייבן אויפֿנעמען",
+ "camerasCount": "קאַמעראַס ({{count}})",
+ "availableCamerasCount": "פֿאַראַנענע ({{count}})",
+ "server": "סערווער",
+ "display": "אַנווייַז",
+ "rawMessage": "רויע מעלדונג",
+ "cameraPerformanceMetrics": "קאַמעראַ פֿאַרמעגן מעטריקן",
+ "serverLogs": "סערווער לאָגס",
+ "sortBy": "סאָרטירן {{direction}}",
+ "waitingForCameraStreams": "וואַרטן אויף קאַמעראַ סטרימס…",
+ "loggingPaused": "לאָגינג פּויזירט",
+ "noLogsToDisplay": "קיין לאָגס צו ווייַזן",
+ "closeSettings": "שליסן אײַנשטעלונגען",
+ "gridSettings": "ראַסטער אײַנשטעלונגען",
+ "clickToShowLess": "דריקט צו ווייַזן ווייניקער",
+ "clickToLearnMore": "דריקט צו לערנען מער",
+ "samples": "מוסטערן",
+ "framerateOverTime": "בילדרייט איבער צייַט",
+ "framerateFps": "בילדרייט (fps)",
+ "capturesFramesFromCamera": "כאַפּט בילדער פֿון קאַמעראַ.",
+ "rendersReceivedFrames": "רענדערט באַקומענע בילדער אויפֿן עקראַן.",
+ "displayTooltipLong": "אַנווייַז פֿאָרשטעלט די UI רענדערינג פֿאַרמעגן. עס ווייַזט ווי שנעל אייַער אַנווייַז באַקומט און רענדערט בילדער. פּראָבלעמען דאָ וועלן נישט באַווירקן אויפֿנאַמע קוואַליטעט אָבער קענען באַווירקן אייַער פֿעיִקייט צו מאָניטאָרן קאַמערעס אין עכט-צייַט.",
+ "statsSourceShort": "אַנווייַז רענדערט בילדער, סערווער כאַפּט בילדער.",
+ "statsSourceLong": "דער סערווער איז דער אמתער ראַטע אין וועלכע בילדער ווערן געצויגן/אויפֿגענומען פֿון דער קאַמערע, בעת אַנווייַז איז דער ראַטע אין וועלכע זיי ווערן באַקומען און רענדערט. SkellyCam פּריאָריטיזירט סערווער-זייַט פֿאַרמעגן פֿאַר אויפֿנאַמע קוואַליטעט, אַזוי דער נומער זאָל בלייַבן מער סטאַביל. אויב דער אַנווייַז פרעימרייט אַוועקגייט פֿונעם סערווער, ווייַזט עס אַז אייַערע סיסטעם רעסורסן זענען באַלאַסט. טראַכט וועגן ניצן ווייניקער קאַמערעס אָדער פֿאַרמינערן פרעימרייט/רעזאָלוציע.",
+ "statsCurrentShort": "לעצטער בילד צייַט און FPS.",
+ "statsCurrentLong": "ווייַזט דאָס לעצטע מעסטונג ווי לאַנג עס נעמט צו פּראָצעסירן אַ איינצל בילד (אין מיליסעקונדעס) און דער עקוויוואַלענט פרעימז פּער סעקונדע (FPS). נידעריקערע בילד צייַטן און העכערע FPS ווייַזן בעסערע פֿאַרמעגן.",
+ "statsMinShort": "שנעלסטער בילד צייַט און העכסטער FPS.",
+ "statsMinLong": "פֿאָרשטעלט דעם מינימאַלן צייַט צו פּראָצעסירן אַ איינצל בילד אין דער מעסטונג פֿענצטער. אַנטשפּרעכט דעם מאַקסימאַלן FPS וואָס אייַער סיסטעם האָט דערגרייכט אין אָפּטימאַלע באַדינגונגען.",
+ "statsMaxShort": "פּאַמעלסטער בילד צייַט און נידריקסטער FPS.",
+ "statsMaxLong": "פֿאָרשטעלט דעם מאַקסימאַלן צייַט צו פּראָצעסירן אַ איינצל בילד אין דער מעסטונג פֿענצטער. אַנטשפּרעכט דעם מינימאַלן FPS אין ערגסטע באַדינגונגען. געלעגנטלעכע שפּיצן זענען נאָרמאַל, אָבער קאָנסיסטענט הויכע ווערטן קענען ווייַזן פֿאַרמעגן פּראָבלעמען.",
+ "statsMeanShort": "דורכשניטלעכער בילד צייַט און FPS.",
+ "statsMeanLong": "דער אַריטמעטישער דורכשניט פֿון אַלע געמאָסטענע בילד צייַטן אין דער מעסטונג פֿענצטער און דער אַנטשפּרעכנדער FPS. גיט אַ גוטע אַלגעמיינע בילד פֿון פֿאַרמעגן אָבער קען זייַן באַאײַנפֿלוסט פֿון אויסנאַמען.",
+ "statsMedianShort": "מיטלסטער ווערט פֿון אַלע בילד צייַטן.",
+ "statsMedianLong": "דער מעדיאַן פֿאָרשטעלט דעם מיטלסטן ווערט ווען אַלע בילד צייַטן ווערן סאָרטירט פֿון שנעלסטן צום פּאַמעלסטן. אַנדערש ווי דער דורכשניט, דער מעדיאַן איז נישט באַאײַנפֿלוסט פֿון עקסטרעמע אויסנאַמען, וואָס מאַכט עס אַ מער סטאַבילער אינדיקאַטאָר פֿון טיפּישע פֿאַרמעגן.",
+ "statsStdDevShort": "מעסט בילד צייַט ענדערונג. CV% איז רעלאַטיוו.",
+ "statsStdDevLong": "סטאַנדאַרד אָפּוואייכונג מעסט די פֿאַריאַציע אין בילד צייַטן. נידעריקערע ווערטן ווייַזן מער קאָנסיסטענטע פֿאַרמעגן. דער קאָעפֿיציענט פֿון וואַריאַציע (CV%) דריקט אויס די פֿאַריאַבילקייט אַלס אַ פּראָצענט פֿונעם דורכשניט, וואָס מאַכט גרינגער צו פֿאַרגלייַכן סטאַבילקייט צווישן פֿאַרשידענע פרעימרייטן. נידעריקערער CV% ווייַזט מער סטאַבילע פֿאַרמעגן.",
+ "aiTranslatedTooltip": "די איבערזעצונג איז געשאַפֿן דורך AI און קען אַנטהאַלטן טעותן. אויב איר רעדט די שפּראַך, העלפֿט אונדז פֿאַרבעסערן אויף GitHub!",
+ "humanValidatedTooltip": "די איבערזעצונג איז איבערגעקוקט און באַשטעטיקט דורך אַ מענטשלעכן איבערזעצער.",
+ "helpTranslate": "העלפֿט איבערזעצן SkellyCam",
+ "failedToFetch": "נישט געלונגען צו לאָדן",
+ "recordings": "אויפֿנאַמעס",
+ "noRecordingsFound": "קיין אויפֿנאַמעס נישט געפֿונען. גיט אײַן אַ וועג אויבן צום לאָדן.",
+ "noCamerasDetected": "קיין קאַמעראַס נישט אויפֿגעפֿונען",
+ "clickRefreshToScan": "דריקט דערפֿרישן צו זוכן קאַמעראַס",
+ "waitingForData": "וואַרטן אויף דאַטן…",
+ "load": "לאָדן",
+ "refresh": "דערפֿרישן",
+ "available": "פֿאַראַנען",
+ "menuFile": "טעקע",
+ "menuView": "אַנזיכט",
+ "menuCamera": "קאַמעראַ",
+ "menuRecording": "אויפֿנאַמע",
+ "menuHelp": "הילף",
+ "menuDetectCameras": "אויפֿגעפֿינען קאַמעראַס",
+ "menuConnectCameras": "פֿאַרבינדן קאַמעראַס",
+ "menuCloseAllCameras": "שליסן אַלע קאַמעראַס",
+ "menuOpenRecordingFolder": "עפֿענען אויפֿנאַמע מאַפּע…",
+ "menuToggleSidebar": "בייטן זייטלייסט",
+ "menuToggleTheme": "בייטן טעמע",
+ "menuToggleFullScreen": "בייטן פֿולער עקראַן",
+ "menuPauseUnpause": "פּויזירן / פֿאָרזעצן",
+ "menuConnectApplySettings": "פֿאַרבינדן / אָנווענדן אײַנשטעלונגען",
+ "menuCloseAll": "שליסן אַלע",
+ "menuDocumentation": "דאָקומענטאַציע",
+ "menuGitHubRepository": "GitHub רעפּאָזיטאָריע",
+ "menuReportIssue": "מעלדן אַ פּראָבלעם…",
+ "menuAbout": "וועגן SkellyCam",
+ "menuPlayback": "שפּילן",
+ "videoPlayback": "שפּילן",
+ "copyLogsToClipboard": "קאָפּירן לאָגס צום קליפּבאָרד",
+ "saveLogsToFile": "אָפּהיטן לאָגס אין טעקע",
+ "copied": "קאָפּירט!",
+ "timestampFromRecording": "צייטשטעמפּל פֿון אויפֿנאַמע דאַטן",
+ "menuCheckForUpdates": "Check for Updates…",
+ "updateAvailable": "Update available",
+ "updateAvailableMessage": "Version {{version}} is available",
+ "downloading": "Downloading…",
+ "downloadComplete": "Download complete",
+ "restartToUpdate": "Restart to update",
+ "checkForUpdates": "Check for Updates",
+ "upToDate": "You are up to date",
+ "updateError": "Update check failed"
+}
diff --git a/freemocap-ui-old/src/i18n/locales/zh-CN-zhongwen.json b/freemocap-ui-old/src/i18n/locales/zh-CN-zhongwen.json
new file mode 100644
index 00000000..16909ec9
--- /dev/null
+++ b/freemocap-ui-old/src/i18n/locales/zh-CN-zhongwen.json
@@ -0,0 +1,258 @@
+{
+ "_meta": {
+ "locale": "zh-CN",
+ "translationSource": "ai-generated",
+ "lastUpdated": "2026-02-22"
+ },
+ "appName": "SkellyCam",
+ "appNameDecorated": "SkellyCam 💀📸",
+ "welcomeTitle": "欢迎使用 SkellyCam",
+ "welcomeSubtitle": "录制和查看同步视频",
+ "sendAnonymousPings": "发送匿名使用数据",
+ "footerWith": "以",
+ "footerFrom": "来自",
+ "footerOrgName": "FreeMoCap 基金会",
+ "home": "首页",
+ "cameras": "摄像头",
+ "videos": "视频",
+ "expandSidebar": "展开侧边栏",
+ "collapseSidebar": "折叠侧边栏",
+ "startRecording": "开始录制",
+ "stopRecording": "停止录制",
+ "toggleTheme": "切换主题",
+ "switchToDark": "切换到深色模式",
+ "switchToLight": "切换到浅色模式",
+ "connectWebSocket": "连接 WebSocket",
+ "disconnectWebSocket": "断开 WebSocket",
+ "launchServer": "启动服务器",
+ "stopServer": "停止服务器",
+ "browseForExecutable": "浏览可执行文件",
+ "refreshCandidates": "刷新候选项",
+ "executable": "可执行文件",
+ "host": "主机",
+ "port": "端口",
+ "cameraCount_one": "{{count}} 个摄像头",
+ "cameraCount_other": "{{count}} 个摄像头",
+ "connectedCameras": "已连接的摄像头",
+ "availableCameras": "可用摄像头",
+ "noCamerasConnected": "未连接摄像头",
+ "detectCameras": "检测可用摄像头",
+ "clearCameraSettings": "清除已保存的摄像头设置",
+ "copySettingsToAll": "将设置复制到所有摄像头",
+ "recordingTag": "录制标签",
+ "recordingTagPlaceholder": "可选标签",
+ "recordingDirectory": "录制目录",
+ "recordingFolderPath": "录制文件夹路径",
+ "delayStart": "延迟启动",
+ "seconds": "秒",
+ "subfolder": "子文件夹",
+ "subfolderPlaceholder": "子文件夹名称",
+ "baseName": "基本名称",
+ "increment": "递增",
+ "resolution": "分辨率",
+ "fps": "FPS",
+ "width": "宽度",
+ "height": "高度",
+ "columns": "列数",
+ "auto": "自动",
+ "manual": "手动",
+ "custom": "自定义",
+ "current": "当前",
+ "recommend": "推荐",
+ "cameraRotation": "摄像头旋转",
+ "selectCameraRotation": "选择摄像头图像旋转",
+ "exposureControl": "选择自动或手动曝光控制",
+ "framerateControl": "选择自动或手动帧率控制",
+ "adjustExposure": "调整曝光时间,例如 cv2.VideoCapture.set(cv2.CAP_PROP_EXPOSURE, value)",
+ "setTargetFps": "设置摄像头捕获的目标帧率 (FPS)",
+ "recordingCaptureFps": "录制捕获帧率",
+ "playbackSpeed": "播放速度(不影响录制帧率)",
+ "framerateTimeline": "帧率时间线",
+ "framerateDistribution": "帧率分布",
+ "timelineView": "时间线视图",
+ "distributionView": "分布视图",
+ "combinedView": "组合视图",
+ "min": "最小",
+ "max": "最大",
+ "mean": "平均",
+ "median": "中位数",
+ "stdDevCv": "标准差/CV",
+ "source": "来源",
+ "selectAll": "全选",
+ "loadSynchronizedVideos": "加载同步视频",
+ "loadSynchronizedVideosDescription": "此页面允许您加载和同步预录制的视频。",
+ "automaticallySynchronizeVideos": "自动同步视频",
+ "extractFramesOnLoad": "加载时提取帧",
+ "generateThumbnails": "生成缩略图",
+ "noVideosLoaded": "未加载视频",
+ "filterVideos": "筛选视频...",
+ "openVideo": "打开视频",
+ "openFolder": "在文件浏览器中打开文件夹",
+ "videoFolderPath": "视频文件夹路径",
+ "jumpToStart": "跳到开头 (Home)",
+ "jumpToEnd": "跳到结尾 (End)",
+ "loopOn": "循环已开启(L 切换)",
+ "loopOff": "循环播放(L)",
+ "syncInfo": "同步信息",
+ "syncInfoTitle": "多摄像头同步可能无法做到逐帧精确",
+ "syncInfoBody": "浏览器视频播放不保证多个流之间的采样精确同步。播放器使用领导者-跟随者策略,在偏差超过小容差时进行校正,但可能会出现轻微的不同步(1-2帧),尤其是在高播放速度或浏览器负载较高时。如需逐帧精确分析,请使用每次录制中包含的原始时间戳 CSV 文件。",
+ "previousFrame": "上一帧 (← / Shift+← 跳10帧)",
+ "nextFrame": "下一帧 (→ / Shift+→ 跳10帧)",
+ "zoomIn": "放大",
+ "zoomOut": "缩小",
+ "resetZoom": "重置缩放",
+ "playbackSettings": "播放设置",
+ "totalRecordingSize": "磁盘上的录制总大小",
+ "estimatedTime": "估计时间(帧 ÷ 录制帧率)",
+ "estimatedDuration": "估计时长(总帧数 ÷ 录制帧率)",
+ "estimatedFromFrameNumber": "根据帧号 × 录制帧率估算 — 非从时间戳数据读取",
+ "frameCountPerCamera": "每个摄像头的帧数",
+ "cameraStreams": "此录制中的摄像头流",
+ "backToRecordings": "返回录制列表",
+ "errorsDetected": "检测到错误",
+ "somethingWentWrong": "出错了 :(",
+ "searchLogs": "搜索日志...",
+ "filter": "筛选…",
+ "refreshMicrophoneList": "刷新麦克风列表",
+ "date": "日期",
+ "name": "名称",
+ "size": "大小",
+ "duration": "时长",
+ "frames": "帧数",
+ "timestamp": "时间戳",
+ "language": "语言",
+ "aiTranslated": "AI翻译",
+ "humanTranslated": "人工翻译",
+ "humanValidated": "人工审校",
+ "connectCameras": "连接选定的摄像头或更新已连接的摄像头",
+ "resumeStreaming": "恢复流媒体",
+ "pauseStreaming": "暂停流媒体",
+ "closeAllCameras": "关闭所有摄像头",
+ "framerate": "帧率",
+ "exposure": "曝光",
+ "fileLabel": "文件",
+ "timeDelta": "时间差",
+ "pathLabel": "路径",
+ "exceptionDetails": "异常详情",
+ "stackTrace": "堆栈跟踪",
+ "loadingVideos": "加载视频中… ({{ready}}/{{total}} 已就绪)",
+ "gridColumns": "网格列数",
+ "settings": "设置",
+ "appearance": "外观",
+ "themeMode": "主题",
+ "darkMode": "深色",
+ "lightMode": "浅色",
+ "languageSettings": "语言与本地化",
+ "showTranslationIndicator": "显示翻译来源指示器",
+ "showTranslationIndicatorDescription": "使用AI生成的翻译时显示标记",
+ "translationSourceLabel": "翻译来源",
+ "general": "通用",
+ "about": "关于",
+ "version": "版本",
+ "serverSettings": "服务器",
+ "recordingSettings": "录制设置",
+ "videoLoadingSettings": "视频加载设置",
+ "connected": "已连接",
+ "connecting": "连接中…",
+ "disconnected": "已断开",
+ "disconnect": "断开",
+ "connect": "连接",
+ "off": "关闭",
+ "running": "运行中",
+ "stopped": "已停止",
+ "working": "处理中…",
+ "invalid": "无效",
+ "autoLaunch": "自动启动",
+ "autoConnect": "自动连接",
+ "runningPath": "运行中: {{path}}",
+ "noMicrophone": "无麦克风",
+ "audioRecordingEnabled": "音频录制已启用",
+ "noMicrophoneSelected": "未选择麦克风",
+ "recordingName": "录制名称: {{name}}",
+ "startingIn": "{{countdown}}秒后开始...",
+ "stopping": "停止中...",
+ "starting": "启动中...",
+ "stopRecordingButton": "🔴 停止录制",
+ "startRecordingButton": "🔴 开始录制",
+ "camerasCount": "摄像头 ({{count}})",
+ "availableCamerasCount": "可用 ({{count}})",
+ "server": "服务器",
+ "display": "显示",
+ "rawMessage": "原始消息",
+ "cameraPerformanceMetrics": "摄像头性能指标",
+ "serverLogs": "服务器日志",
+ "sortBy": "排序 {{direction}}",
+ "waitingForCameraStreams": "等待摄像头流...",
+ "loggingPaused": "日志已暂停",
+ "noLogsToDisplay": "没有日志可显示",
+ "closeSettings": "关闭设置",
+ "gridSettings": "网格设置",
+ "clickToShowLess": "点击收起",
+ "clickToLearnMore": "点击了解更多",
+ "samples": "个样本",
+ "framerateOverTime": "帧率随时间变化",
+ "framerateFps": "帧率 (fps)",
+ "capturesFramesFromCamera": "从摄像头捕获帧。",
+ "rendersReceivedFrames": "在屏幕上渲染接收到的帧。",
+ "displayTooltipLong": "显示代表UI渲染性能。它显示显示器接收和渲染帧的速度。此处的性能问题不会影响录制质量,但可能影响您实时监控摄像头的能力。",
+ "statsSourceShort": "显示渲染帧,服务器捕获帧。",
+ "statsSourceLong": "服务器是从摄像头拉取/录制帧的真实速率,而显示是接收和渲染帧的速率。SkellyCam优先考虑服务器端性能以保证录制质量,因此该数字应保持更稳定。如果显示帧率与服务器偏差较大,表明系统资源紧张。",
+ "statsCurrentShort": "最近的帧时间和对应的FPS。",
+ "statsCurrentLong": "显示处理单帧所需时间(毫秒)的最新测量值及等效的每秒帧数(FPS)。更低的帧时间和更高的FPS表示更好的性能。",
+ "statsMinShort": "最快帧时间(最低延迟)和达到的最高FPS。",
+ "statsMinLong": "表示在采样窗口期间处理单帧所用的最短时间。对应于系统在最佳条件下达到的最大FPS。",
+ "statsMaxShort": "最慢帧时间(最高延迟)和经历的最低FPS。",
+ "statsMaxLong": "表示在采样窗口期间处理单帧所用的最长时间。对应于系统在最差条件下达到的最低FPS。偶尔的峰值是正常的,但持续的高值可能表示性能问题。",
+ "statsMeanShort": "所有样本的平均帧时间和FPS。",
+ "statsMeanLong": "采样窗口期间测量的所有帧时间的算术平均值及对应的FPS。提供性能的整体概览,但可能受异常值影响。",
+ "statsMedianShort": "所有帧时间的中间值(第50百分位)。",
+ "statsMedianLong": "中位数表示将所有帧时间从最快到最慢排序后的中间值。与平均值不同,中位数不受极端异常值影响,是典型性能更稳定的指标。",
+ "statsStdDevShort": "衡量帧时间的可变性。CV%是相对可变性。",
+ "statsStdDevLong": "标准差衡量帧时间的变化量。较低的值表示更一致的性能。变异系数(CV%)将此可变性表示为平均值的百分比,便于比较不同帧率下的稳定性。",
+ "aiTranslatedTooltip": "此翻译由AI生成,可能包含错误。如果您使用此语言,可以在GitHub上提交pull request来帮助改进翻译!",
+ "humanValidatedTooltip": "此翻译已经过人工译者审核和验证。",
+ "helpTranslate": "帮助翻译 SkellyCam",
+ "failedToFetch": "获取失败",
+ "recordings": "录制",
+ "noRecordingsFound": "未找到录制。请在上方输入路径手动加载。",
+ "noCamerasDetected": "未检测到摄像头",
+ "clickRefreshToScan": "点击刷新以搜索可用摄像头",
+ "waitingForData": "等待数据…",
+ "load": "加载",
+ "refresh": "刷新",
+ "available": "可用",
+ "menuFile": "文件",
+ "menuView": "视图",
+ "menuCamera": "摄像头",
+ "menuRecording": "录制",
+ "menuHelp": "帮助",
+ "menuDetectCameras": "检测摄像头",
+ "menuConnectCameras": "连接摄像头",
+ "menuCloseAllCameras": "关闭所有摄像头",
+ "menuOpenRecordingFolder": "打开录制文件夹…",
+ "menuToggleSidebar": "切换侧边栏",
+ "menuToggleTheme": "切换主题",
+ "menuToggleFullScreen": "切换全屏",
+ "menuPauseUnpause": "暂停 / 继续",
+ "menuConnectApplySettings": "连接 / 应用设置",
+ "menuCloseAll": "关闭全部",
+ "menuDocumentation": "文档",
+ "menuGitHubRepository": "GitHub 仓库",
+ "menuReportIssue": "报告问题…",
+ "menuAbout": "关于 SkellyCam",
+ "menuPlayback": "回放",
+ "videoPlayback": "回放",
+ "copyLogsToClipboard": "复制日志到剪贴板",
+ "saveLogsToFile": "保存日志到文件",
+ "copied": "已复制!",
+ "timestampFromRecording": "来自录制数据的时间戳",
+ "menuCheckForUpdates": "Check for Updates…",
+ "updateAvailable": "Update available",
+ "updateAvailableMessage": "Version {{version}} is available",
+ "downloading": "Downloading…",
+ "downloadComplete": "Download complete",
+ "restartToUpdate": "Restart to update",
+ "checkForUpdates": "Check for Updates",
+ "upToDate": "You are up to date",
+ "updateError": "Update check failed"
+}
diff --git a/freemocap-ui-old/src/index.css b/freemocap-ui-old/src/index.css
new file mode 100644
index 00000000..e79b5fbc
--- /dev/null
+++ b/freemocap-ui-old/src/index.css
@@ -0,0 +1,99 @@
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+:root {
+ font-family: Inter, system-ui, Avenir, Helvetica, Arial, sans-serif;
+ line-height: 1.5;
+ font-weight: 400;
+
+ color-scheme: light dark;
+ color: rgba(255, 255, 255, 0.87);
+ background-color: #242424;
+
+ font-synthesis: none;
+ text-rendering: optimizeLegibility;
+ -webkit-font-smoothing: antialiased;
+ -moz-osx-font-smoothing: grayscale;
+ -webkit-text-size-adjust: 100%;
+}
+
+a {
+ font-weight: 500;
+ color: #646cff;
+ text-decoration: inherit;
+}
+
+a:hover {
+ color: #535bf2;
+}
+
+body {
+ margin: 0;
+ padding: 0;
+ width: 100%;
+ height: 100vh;
+ overflow: hidden;
+}
+
+h1 {
+ font-size: 3.2em;
+ line-height: 1.1;
+}
+
+button {
+ border-radius: 8px;
+ border: 1px solid transparent;
+ padding: 0.6em 1.2em;
+ font-size: 1em;
+ font-weight: 500;
+ font-family: inherit;
+ background-color: #1a1a1a;
+ cursor: pointer;
+ transition: border-color 0.25s;
+}
+
+button:hover {
+ border-color: #646cff;
+}
+
+button:focus,
+button:focus-visible {
+ outline: 4px auto -webkit-focus-ring-color;
+}
+
+code {
+ background-color: #1a1a1a;
+ padding: 2px 4px;
+ margin: 0 4px;
+ border-radius: 4px;
+}
+
+.card {
+ padding: 2em;
+}
+
+#root {
+ width: 100%;
+ height: 100vh;
+ overflow: hidden;
+}
+
+@media (prefers-color-scheme: light) {
+ :root {
+ color: #213547;
+ background-color: #ffffff;
+ }
+
+ a:hover {
+ color: #747bff;
+ }
+
+ button {
+ background-color: #f9f9f9;
+ }
+
+ code {
+ background-color: #f9f9f9;
+ }
+}
diff --git a/freemocap-ui-old/src/layout/AppContent.tsx b/freemocap-ui-old/src/layout/AppContent.tsx
new file mode 100644
index 00000000..535275c4
--- /dev/null
+++ b/freemocap-ui-old/src/layout/AppContent.tsx
@@ -0,0 +1,32 @@
+import * as React from 'react';
+import { ThemeProvider } from '@mui/material/styles';
+import { HashRouter } from 'react-router-dom';
+import { CssBaseline } from '@mui/material';
+import { BasePanelLayout } from '@/layout/BasePanelLayout';
+import { createExtendedTheme } from '@/layout/paperbase-theme';
+import { useAppSelector } from '@/store';
+import { BaseContentRouter } from '@/layout/BaseContentRouter';
+import { FirstLaunchRedirect } from '@/components/setup-wizard/FirstLaunchRedirect';
+import { MenuNavigationListener } from '@/components/MenuNavigationListener';
+
+export const AppContent = function () {
+ const themeMode = useAppSelector(state => state.theme.mode);
+
+ const theme = React.useMemo(() =>
+ createExtendedTheme(themeMode),
+ [themeMode],
+ );
+
+ return (
+ <ThemeProvider theme={theme}>
+ <CssBaseline />
+ <HashRouter>
+ <FirstLaunchRedirect />
+ <MenuNavigationListener />
+ <BasePanelLayout>
+ <BaseContentRouter />
+ </BasePanelLayout>
+ </HashRouter>
+ </ThemeProvider>
+ );
+};
diff --git a/freemocap-ui-old/src/layout/BaseContentRouter.tsx b/freemocap-ui-old/src/layout/BaseContentRouter.tsx
new file mode 100644
index 00000000..34818701
--- /dev/null
+++ b/freemocap-ui-old/src/layout/BaseContentRouter.tsx
@@ -0,0 +1,22 @@
+import React from 'react';
+import { Navigate, Route, Routes } from 'react-router-dom';
+import { CamerasPage } from '@/pages/CamerasPage';
+import VideosPage from '@/pages/VideosPage';
+import WelcomePage from '@/pages/WelcomePage';
+import { Viewport3dPage } from '@/pages/Viewport3dPage';
+import { SettingsPage } from '@/pages/SettingsPage';
+
+export const BaseContentRouter: React.FC = () => {
+ return (
+ <Routes>
+ <Route path="/" element={<WelcomePage />} />
+ <Route path="/cameras" element={<CamerasPage />} />
+ <Route path="/videos" element={<VideosPage />} />
+ <Route path="/viewport3d" element={<Viewport3dPage />} />
+ <Route path="/settings" element={<SettingsPage />} />
+ {/* Legacy route redirect */}
+ <Route path="/setup" element={<Navigate to="/settings" replace />} />
+ <Route path="*" element={<Navigate to="/" replace />} />
+ </Routes>
+ );
+};
diff --git a/freemocap-ui-old/src/layout/BasePanelLayout.tsx b/freemocap-ui-old/src/layout/BasePanelLayout.tsx
new file mode 100644
index 00000000..cd5f4ae7
--- /dev/null
+++ b/freemocap-ui-old/src/layout/BasePanelLayout.tsx
@@ -0,0 +1,57 @@
+// freemocap-ui/src/layout/BasePanelLayout.tsx
+import React from "react";
+import {Panel, PanelGroup, PanelResizeHandle} from "react-resizable-panels";
+import {LeftSidePanelContent} from "@/components/ui-components/LeftSidePanelContent";
+import BottomPanelContent from "@/components/ui-components/BottomPanelContent";
+import {useTheme} from "@mui/material/styles";
+import {Box} from "@mui/material";
+import {useLocation} from "react-router-dom";
+
+export const BasePanelLayout = ({children}: { children: React.ReactNode }) => {
+ const theme = useTheme();
+ const location = useLocation();
+
+ return (
+ <Box sx={{display: 'flex', flexDirection: 'column', height: '100vh'}}>
+ <PanelGroup
+ direction="vertical"
+ style={{flex: 1}}
+ >
+ {/* Top section (horizontal panels) - 80% height */}
+ <Panel defaultSize={87} minSize={20}>
+ <PanelGroup direction="horizontal">
+ <Panel collapsible defaultSize={24} minSize={10} collapsedSize={4}>
+ <LeftSidePanelContent/>
+ </Panel>
+ {/* Horizontal Resize Handle */}
+ <PanelResizeHandle
+ style={{
+ width: "4px",
+ cursor: "col-resize",
+ backgroundColor: theme.palette.primary.light,
+ }}
+ />
+
+ {/*Main/Central Content Panel*/}
+ <Panel defaultSize={76} minSize={10}>
+ {children}
+ </Panel>
+ </PanelGroup>
+ </Panel>
+
+ {/* Vertical Resize Handle */}
+ <PanelResizeHandle
+ style={{
+ height: "4px",
+ cursor: "row-resize",
+ backgroundColor: theme.palette.primary.light,
+ }}
+ />
+
+ <Panel collapsible defaultSize={13} minSize={10} collapsedSize={4}>
+ <BottomPanelContent/>
+ </Panel>
+ </PanelGroup>
+ </Box>
+ );
+};
diff --git a/freemocap-ui-old/src/layout/paperbase-theme.ts b/freemocap-ui-old/src/layout/paperbase-theme.ts
new file mode 100644
index 00000000..e54b7202
--- /dev/null
+++ b/freemocap-ui-old/src/layout/paperbase-theme.ts
@@ -0,0 +1,412 @@
+// freemocap-ui/src/layout/paperbase_theme/paperbase-theme.ts
+import {createTheme, PaletteMode} from '@mui/material/styles';
+
+// Define common theme settings
+const getBaseTheme = (mode: PaletteMode) => ({
+ typography: {
+ h5: {
+ fontWeight: 500,
+ fontSize: 22,
+ letterSpacing: 0.5,
+ },
+ h6: {
+ fontSize: 16,
+ fontWeight: 500,
+ },
+ subtitle2: {
+ fontSize: 13,
+ fontWeight: 500,
+ },
+ body2: {
+ fontSize: 13,
+ },
+ caption: {
+ fontSize: 11,
+ }
+ },
+ shape: {
+ borderRadius: 6,
+ },
+ mixins: {
+ toolbar: {
+ minHeight: 40,
+ },
+ },
+ components: {
+ MuiTab: {
+ defaultProps: {
+ disableRipple: true,
+ },
+ },
+ },
+});
+
+// Define the dark theme palette with better visibility
+const darkPalette = {
+ mode: 'dark' as PaletteMode,
+ primary: {
+ light: '#5e92f3',
+ main: '#104172',
+ dark: '#002a60',
+ contrastText: '#ffffff',
+ },
+ secondary: {
+ light: '#ff6090',
+ main: '#f50057',
+ dark: '#c51162',
+ contrastText: '#ffffff',
+ },
+ background: {
+ default: '#0a0e1a',
+ paper: '#262f44',
+ },
+ text: {
+ primary: '#ffffff',
+ secondary: '#b3b9c6',
+ },
+ divider: 'rgba(255, 255, 255, 0.12)',
+ action: {
+ active: '#ffffff',
+ hover: 'rgba(255, 255, 255, 0.08)',
+ selected: 'rgba(255, 255, 255, 0.16)',
+ disabled: 'rgba(255, 255, 255, 0.3)',
+ disabledBackground: 'rgba(255, 255, 255, 0.12)',
+ },
+ success: {
+ main: '#4caf50',
+ light: '#80e27e',
+ dark: '#087f23',
+ },
+ warning: {
+ main: '#ff9800',
+ light: '#ffcc80',
+ dark: '#c66900',
+ },
+ error: {
+ main: '#f44336',
+ light: '#ff7961',
+ dark: '#ba000d',
+ },
+ info: {
+ main: '#29b6f6',
+ light: '#73e8ff',
+ dark: '#0086c3',
+ },
+ grey: {
+ 50: '#fafafa',
+ 100: '#f5f5f5',
+ 200: '#eeeeee',
+ 300: '#e0e0e0',
+ 400: '#bdbdbd',
+ 500: '#9e9e9e',
+ 600: '#757575',
+ 700: '#616161',
+ 800: '#424242',
+ 900: '#212121',
+ },
+};
+
+// Define the light theme palette
+const lightPalette = {
+ mode: 'light' as PaletteMode,
+ primary: {
+ light: '#4791db',
+ main: '#1976d2',
+ dark: '#115293',
+ contrastText: '#ffffff',
+ },
+ secondary: {
+ light: '#ff5983',
+ main: '#f50057',
+ dark: '#ab003c',
+ contrastText: '#ffffff',
+ },
+ background: {
+ default: '#f5f7fa',
+ paper: '#ffffff',
+ },
+ text: {
+ primary: '#2c3e50',
+ secondary: '#546e7a',
+ },
+ divider: 'rgba(0, 0, 0, 0.12)',
+ action: {
+ active: 'rgba(0, 0, 0, 0.54)',
+ hover: 'rgba(0, 0, 0, 0.04)',
+ selected: 'rgba(0, 0, 0, 0.08)',
+ disabled: 'rgba(0, 0, 0, 0.26)',
+ disabledBackground: 'rgba(0, 0, 0, 0.12)',
+ },
+ success: {
+ main: '#4caf50',
+ light: '#80e27e',
+ dark: '#087f23',
+ },
+ warning: {
+ main: '#ff9800',
+ light: '#ffcc80',
+ dark: '#c66900',
+ },
+ error: {
+ main: '#f44336',
+ light: '#ff7961',
+ dark: '#ba000d',
+ },
+ info: {
+ main: '#2196f3',
+ light: '#64b5f6',
+ dark: '#1565c0',
+ },
+};
+
+// Create theme based on the palette mode
+export const createAppTheme = (mode: PaletteMode) => {
+ const baseTheme = getBaseTheme(mode);
+ const palette = mode === 'dark' ? darkPalette : lightPalette;
+
+ return createTheme({
+ ...baseTheme,
+ palette,
+ });
+};
+
+// Export base themes for reference
+export const paperbaseThemeLight = createAppTheme('light');
+export const paperbaseThemeDark = createAppTheme('dark');
+
+// Create the extended theme components that apply to both light/dark modes
+export const createExtendedTheme = (mode: PaletteMode) => {
+ const baseTheme = createAppTheme(mode);
+
+ return {
+ ...baseTheme,
+ components: {
+ ...baseTheme.components,
+ MuiDrawer: {
+ styleOverrides: {
+ paper: {
+ backgroundColor: mode === 'dark' ? '#0f1419' : '#f8f9fa',
+ },
+ },
+ },
+ MuiButton: {
+ styleOverrides: {
+ root: {
+ textTransform: 'none',
+ fontSize: 12,
+ padding: '4px 12px',
+ minHeight: 28,
+ },
+ contained: {
+ boxShadow: 'none',
+ '&:active': {
+ boxShadow: 'none',
+ },
+ },
+ },
+ },
+ MuiIconButton: {
+ styleOverrides: {
+ root: {
+ padding: 6,
+ },
+ small: {
+ padding: 4,
+ },
+ },
+ },
+ MuiCheckbox: {
+ styleOverrides: {
+ root: {
+ color: mode === 'dark' ? baseTheme.palette.grey[400] : baseTheme.palette.grey[600],
+ '&.Mui-checked': {
+ color: baseTheme.palette.primary.main,
+ },
+ '&.Mui-disabled': {
+ color: mode === 'dark' ? baseTheme.palette.grey[700] : baseTheme.palette.grey[400],
+ },
+ },
+ },
+ },
+ MuiRadio: {
+ styleOverrides: {
+ root: {
+ color: mode === 'dark' ? baseTheme.palette.grey[400] : baseTheme.palette.grey[600],
+ '&.Mui-checked': {
+ color: baseTheme.palette.primary.main,
+ },
+ },
+ },
+ },
+ MuiSwitch: {
+ styleOverrides: {
+ root: {
+ padding: 8,
+ },
+ switchBase: {
+ padding: 9,
+ '&.Mui-checked': {
+ color: baseTheme.palette.primary.main,
+ '& + .MuiSwitch-track': {
+ backgroundColor: baseTheme.palette.primary.light,
+ opacity: 0.7,
+ },
+ },
+ },
+ track: {
+ backgroundColor: mode === 'dark' ? baseTheme.palette.grey[700] : baseTheme.palette.grey[400],
+ },
+ },
+ },
+ MuiFormControlLabel: {
+ styleOverrides: {
+ root: {
+ marginLeft: 0,
+ marginRight: 0,
+ },
+ label: {
+ fontSize: 12,
+ },
+ },
+ },
+ MuiTreeItem: {
+ styleOverrides: {
+ content: {
+ padding: '2px 8px',
+ margin: '2px 0',
+ },
+ label: {
+ fontSize: 13,
+ padding: '2px 0',
+ },
+ },
+ },
+ MuiChip: {
+ styleOverrides: {
+ root: {
+ height: 20,
+ fontSize: 11,
+ },
+ sizeSmall: {
+ height: 18,
+ fontSize: 10,
+ },
+ },
+ },
+ MuiTextField: {
+ styleOverrides: {
+ root: {
+ '& .MuiOutlinedInput-root': {
+ color: mode === 'dark' ? 'white' : 'rgba(0, 0, 0, 0.87)',
+ '& fieldset': {
+ borderColor: mode === 'dark' ? 'rgba(255, 255, 255, 0.3)' : 'rgba(0, 0, 0, 0.23)',
+ },
+ '&:hover fieldset': {
+ borderColor: mode === 'dark' ? 'rgba(255, 255, 255, 0.5)' : 'rgba(0, 0, 0, 0.87)',
+ },
+ '&.Mui-focused fieldset': {
+ borderColor: baseTheme.palette.primary.main,
+ },
+ },
+ '& .MuiInputLabel-root': {
+ color: mode === 'dark' ? 'rgba(255, 255, 255, 0.7)' : 'rgba(0, 0, 0, 0.6)',
+ fontSize: 13,
+ },
+ '& .MuiInputBase-input': {
+ color: mode === 'dark' ? 'white' : 'rgba(0, 0, 0, 0.87)',
+ fontSize: 13,
+ padding: '8px 12px',
+ },
+ '& .MuiInputBase-inputSizeSmall': {
+ padding: '4px 8px',
+ fontSize: 12,
+ },
+ },
+ },
+ },
+ MuiSelect: {
+ styleOverrides: {
+ root: {
+ fontSize: 13,
+ },
+ select: {
+ padding: '8px 12px',
+ },
+ },
+ },
+ MuiPaper: {
+ styleOverrides: {
+ root: {
+ backgroundImage: 'none',
+ },
+ },
+ },
+ MuiCard: {
+ styleOverrides: {
+ root: {
+ backgroundImage: 'none',
+ },
+ },
+ },
+ MuiTypography: {
+ styleOverrides: {
+ root: {
+ color: mode === 'dark' ? 'white' : 'rgba(0, 0, 0, 0.87)',
+ },
+ },
+ },
+ MuiDivider: {
+ styleOverrides: {
+ root: {
+ backgroundColor: mode === 'dark' ? 'rgba(255,255,255,0.08)' : 'rgba(0,0,0,0.08)',
+ },
+ },
+ },
+ MuiTooltip: {
+ styleOverrides: {
+ tooltip: {
+ borderRadius: 4,
+ fontSize: 11,
+ },
+ },
+ },
+ MuiListItemButton: {
+ styleOverrides: {
+ root: {
+ padding: '4px 8px',
+ '&.Mui-selected': {
+ backgroundColor: mode === 'dark'
+ ? 'rgba(25, 118, 210, 0.16)'
+ : 'rgba(25, 118, 210, 0.08)',
+ color: baseTheme.palette.primary.main,
+ },
+ },
+ },
+ },
+ MuiListItemText: {
+ styleOverrides: {
+ primary: {
+ fontSize: 13,
+ fontWeight: baseTheme.typography.fontWeightMedium,
+ },
+ },
+ },
+ MuiListItemIcon: {
+ styleOverrides: {
+ root: {
+ color: 'inherit',
+ minWidth: 'auto',
+ marginRight: baseTheme.spacing(1),
+ '& svg': {
+ fontSize: 18,
+ },
+ },
+ },
+ },
+ },
+ };
+};
+
+// Re-export the default theme for backward compatibility
+export const paperbaseTheme = paperbaseThemeDark;
+export default createExtendedTheme('dark');
diff --git a/freemocap-ui-old/src/layout/paperbase_theme/PaperbaseContent.tsx b/freemocap-ui-old/src/layout/paperbase_theme/PaperbaseContent.tsx
new file mode 100644
index 00000000..f4535106
--- /dev/null
+++ b/freemocap-ui-old/src/layout/paperbase_theme/PaperbaseContent.tsx
@@ -0,0 +1,29 @@
+import * as React from 'react';
+import {ThemeProvider} from '@mui/material/styles';
+import {HashRouter} from 'react-router-dom';
+import {CssBaseline} from "@mui/material";
+import {BasePanelLayout} from "@/layout/BasePanelLayout";
+import {createExtendedTheme} from "@/layout/paperbase_theme/paperbase-theme";
+import {useAppSelector} from "@/store/AppStateStore";
+import {BaseContentRouter} from "@/layout/BaseContentRouter";
+
+export const PaperbaseContent = function () {
+
+ const themeMode = useAppSelector(state => state.theme.mode);
+ // Create theme dynamically based on current mode
+
+ const theme = React.useMemo(() =>
+ createExtendedTheme(themeMode),
+ [themeMode]
+ );
+ return (
+ <ThemeProvider theme={theme}>
+ <CssBaseline/>
+ <HashRouter>
+ <BasePanelLayout>
+ <BaseContentRouter/>
+ </BasePanelLayout>
+ </HashRouter>
+ </ThemeProvider>
+ );
+}
diff --git a/freemocap-ui-old/src/layout/paperbase_theme/paperbase-theme.ts b/freemocap-ui-old/src/layout/paperbase_theme/paperbase-theme.ts
new file mode 100644
index 00000000..9718e96d
--- /dev/null
+++ b/freemocap-ui-old/src/layout/paperbase_theme/paperbase-theme.ts
@@ -0,0 +1,255 @@
+// freemocap-ui/src/layout/paperbase_theme/paperbase-theme.ts
+import {createTheme, PaletteMode} from '@mui/material/styles';
+
+// Define common theme settings
+const getBaseTheme = (mode: PaletteMode) => ({
+ typography: {
+ h5: {
+ fontWeight: 500,
+ fontSize: 26,
+ letterSpacing: 0.5,
+ },
+ },
+ shape: {
+ borderRadius: 8,
+ },
+ mixins: {
+ toolbar: {
+ minHeight: 48,
+ },
+ },
+ components: {
+ MuiTab: {
+ defaultProps: {
+ disableRipple: true,
+ },
+ },
+ },
+});
+
+// Define the dark theme palette
+const darkPalette = {
+ mode: 'dark' as PaletteMode,
+ primary: {
+ light: '#00597f',
+ main: '#002d46',
+ dark: '#000b10',
+ },
+ background: {
+ default: '#121212',
+ paper: '#1e1e1e',
+ },
+ text: {
+ primary: '#ffffff',
+ secondary: '#b0b0b0',
+ },
+ divider: 'rgba(255, 255, 255, 0.12)',
+};
+
+// Define the light theme palette
+const lightPalette = {
+ mode: 'light' as PaletteMode,
+ primary: {
+ light: '#4299e1',
+ main: '#0067a3',
+ dark: '#003e73',
+ },
+ background: {
+ default: '#f5f5f5',
+ paper: '#ffffff',
+ },
+ text: {
+ primary: '#333333',
+ secondary: '#555555',
+ },
+ divider: 'rgba(0, 0, 0, 0.12)',
+};
+
+// Create theme based on the palette mode
+export const createAppTheme = (mode: PaletteMode) => {
+ const baseTheme = getBaseTheme(mode);
+ const palette = mode === 'dark' ? darkPalette : lightPalette;
+
+ return createTheme({
+ ...baseTheme,
+ palette,
+ });
+};
+
+// Export base themes for reference
+export const paperbaseThemeLight = createAppTheme('light');
+export const paperbaseThemeDark = createAppTheme('dark');
+
+// Create the extended theme components that apply to both light/dark modes
+export const createExtendedTheme = (mode: PaletteMode) => {
+ const baseTheme = createAppTheme(mode);
+
+ return {
+ ...baseTheme,
+ components: {
+ ...baseTheme.components,
+ MuiDrawer: {
+ styleOverrides: {
+ paper: {
+ backgroundColor: mode === 'dark' ? '#081627' : '#f0f8ff',
+ },
+ },
+ },
+ MuiButton: {
+ styleOverrides: {
+ root: {
+ textTransform: 'none',
+ },
+ contained: {
+ boxShadow: 'none',
+ '&:active': {
+ boxShadow: 'none',
+ },
+ },
+ },
+ },
+ MuiTabs: {
+ styleOverrides: {
+ root: {
+ marginLeft: baseTheme.spacing(1),
+ },
+ indicator: {
+ height: 3,
+ borderTopLeftRadius: 3,
+ borderTopRightRadius: 3,
+ backgroundColor: mode === 'dark' ? baseTheme.palette.common.white : baseTheme.palette.primary.main,
+ },
+ },
+ },
+ MuiTab: {
+ styleOverrides: {
+ root: {
+ textTransform: 'none',
+ margin: '0 16px',
+ minWidth: 0,
+ padding: 0,
+ [baseTheme.breakpoints.up('md')]: {
+ padding: 0,
+ minWidth: 0,
+ },
+ },
+ },
+ },
+ MuiIconButton: {
+ styleOverrides: {
+ root: {
+ padding: baseTheme.spacing(1),
+ },
+ },
+ },
+ MuiTooltip: {
+ styleOverrides: {
+ tooltip: {
+ borderRadius: 4,
+ },
+ },
+ },
+ MuiDivider: {
+ styleOverrides: {
+ root: {
+ backgroundColor: mode === 'dark' ? 'rgba(255,255,255,0.15)' : 'rgba(0,0,0,0.12)',
+ },
+ },
+ },
+ MuiListItemButton: {
+ styleOverrides: {
+ root: {
+ '&.Mui-selected': {
+ color: mode === 'dark' ? '#4fc3f7' : '#0067a3',
+ },
+ },
+ },
+ },
+ MuiListItemText: {
+ styleOverrides: {
+ primary: {
+ fontSize: 14,
+ fontWeight: baseTheme.typography.fontWeightMedium,
+ },
+ },
+ },
+ MuiListItemIcon: {
+ styleOverrides: {
+ root: {
+ color: 'inherit',
+ minWidth: 'auto',
+ marginRight: baseTheme.spacing(2),
+ '& svg': {
+ fontSize: 20,
+ },
+ },
+ },
+ },
+ MuiAvatar: {
+ styleOverrides: {
+ root: {
+ width: 32,
+ height: 32,
+ },
+ },
+ },
+ MuiPanelResizeHandle: {
+ styleOverrides: {
+ root: {
+ backgroundColor: mode === 'dark' ? baseTheme.palette.primary.light : baseTheme.palette.primary.main,
+ width: 4,
+ '&[data-panel-group-direction="horizontal"]': {
+ cursor: 'col-resize',
+ },
+ '&[data-panel-group-direction="vertical"]': {
+ height: 4,
+ cursor: 'row-resize',
+ },
+ '&:hover': {
+ backgroundColor: baseTheme.palette.secondary.main,
+ },
+ transition: 'background-color 0.2s ease',
+ },
+ },
+ },
+ MuiTextField: {
+ styleOverrides: {
+ root: {
+ '& .MuiOutlinedInput-root': {
+ color: mode === 'dark' ? 'white' : 'rgba(0, 0, 0, 0.87)',
+ '& fieldset': {
+ borderColor: mode === 'dark' ? 'rgba(255, 255, 255, 0.5)' : 'rgba(0, 0, 0, 0.23)',
+ },
+ '&:hover fieldset': {
+ borderColor: mode === 'dark' ? 'rgba(255, 255, 255, 0.7)' : 'rgba(0, 0, 0, 0.87)',
+ },
+ '&.Mui-focused fieldset': {
+ borderColor: mode === 'dark' ? 'white' : baseTheme.palette.primary.main,
+ },
+ },
+ '& .MuiInputLabel-root': {
+ color: mode === 'dark' ? 'rgba(255, 255, 255, 0.7)' : 'rgba(0, 0, 0, 0.6)',
+ },
+ '& .MuiInputBase-input': {
+ color: mode === 'dark' ? 'white' : 'rgba(0, 0, 0, 0.87)',
+ },
+ '& .MuiIconButton-root': {
+ color: mode === 'dark' ? 'rgba(255, 255, 255, 0.7)' : 'rgba(0, 0, 0, 0.54)',
+ },
+ },
+ },
+ },
+ MuiTypography: {
+ styleOverrides: {
+ root: {
+ color: mode === 'dark' ? 'white' : 'rgba(0, 0, 0, 0.87)',
+ },
+ },
+ },
+ },
+ };
+};
+
+// Re-export the default theme for backward compatibility
+export const paperbaseTheme = paperbaseThemeDark;
+export default createExtendedTheme('dark');
diff --git a/freemocap-ui-old/src/main.tsx b/freemocap-ui-old/src/main.tsx
new file mode 100644
index 00000000..12cd2472
--- /dev/null
+++ b/freemocap-ui-old/src/main.tsx
@@ -0,0 +1,15 @@
+import React from 'react'
+import ReactDOM from 'react-dom/client'
+import App from './App'
+import './i18n/i18n'
+
+import './index.css'
+
+
+ReactDOM.createRoot(document.getElementById('root') as HTMLElement).render(
+ <React.StrictMode>
+ <App/>
+ </React.StrictMode>,
+)
+
+postMessage({payload: 'removeLoading'}, '*')
diff --git a/freemocap-ui-old/src/pages/CamerasPage.tsx b/freemocap-ui-old/src/pages/CamerasPage.tsx
new file mode 100644
index 00000000..ab3a34a7
--- /dev/null
+++ b/freemocap-ui-old/src/pages/CamerasPage.tsx
@@ -0,0 +1,108 @@
+import React, {useState} from 'react';
+import Box from "@mui/material/Box";
+import ErrorBoundary from "@/components/common/ErrorBoundary";
+import {Footer} from "@/components/ui-components/Footer";
+import {useTheme} from "@mui/material/styles";
+import {Panel, PanelGroup, PanelResizeHandle} from "react-resizable-panels";
+import {CameraViewsGrid} from "@/components/camera-views/CameraViewsGrid";
+import {
+ CamerasViewSettingsOverlay
+} from "@/components/camera-views/camera-view-settings-overlay/CamerasViewSettingsOverlay";
+import {ThreeJsCanvas} from "@/components/viewport3d/ThreeJsCanvas";
+
+export type LayoutDirection = 'vertical' | 'horizontal';
+
+export interface CameraSettings {
+ columns: number | null;
+ show3dView: boolean;
+ layoutDirection: LayoutDirection;
+}
+
+export const CamerasPage = () => {
+ const theme = useTheme();
+ const [settings, setSettings] = useState<CameraSettings>({
+ columns: null,
+ show3dView: true,
+ layoutDirection: 'horizontal',
+ });
+ const [resetKey, setResetKey] = useState<number>(0);
+
+ const handleSettingsChange = (newSettings: CameraSettings) => {
+ setSettings(newSettings);
+ };
+
+ const handleResetViews = () => {
+ setResetKey(prev => prev + 1);
+ };
+
+ const isHorizontal = settings.layoutDirection === 'horizontal';
+
+ return (
+ <React.Fragment>
+ <Box sx={{
+ py: 1,
+ px: 1,
+ flex: 1,
+ display: 'flex',
+ flexDirection: 'column',
+ height: '100%',
+ width: '100%',
+ backgroundColor: theme.palette.mode === 'dark'
+ ? theme.palette.background.default
+ : theme.palette.background.paper,
+ overflow: "hidden",
+ position: 'relative',
+ }}>
+ <CamerasViewSettingsOverlay
+ onSettingsChange={handleSettingsChange}
+ onResetViews={handleResetViews}
+ />
+
+ <Box sx={{flex: 1, overflow: 'hidden'}}>
+ {settings.show3dView ? (
+ <PanelGroup
+ key={`main-panels-${resetKey}-${settings.layoutDirection}`}
+ direction={settings.layoutDirection}
+ >
+ {/* Camera Grid View Panel */}
+ <Panel defaultSize={isHorizontal ? 60 : 80} minSize={20}>
+ <Box sx={{height: '100%', overflow: 'auto'}}>
+ <ErrorBoundary>
+ <CameraViewsGrid settings={settings} resetKey={resetKey}/>
+ </ErrorBoundary>
+ </Box>
+ </Panel>
+
+ {/* Resize Handle — adapts to layout direction */}
+ <PanelResizeHandle
+ style={{
+ ...(isHorizontal
+ ? {width: "4px", cursor: "col-resize"}
+ : {height: "2px", cursor: "row-resize"}),
+ backgroundColor: theme.palette.primary.dark,
+ }}
+ />
+
+ {/* 3D View Panel */}
+ <Panel defaultSize={isHorizontal ? 40 : 20} minSize={10}>
+ <Box sx={{height: '100%'}}>
+ <ThreeJsCanvas/>
+ </Box>
+ </Panel>
+ </PanelGroup>
+ ) : (
+ <Box sx={{height: '100%', overflow: 'auto'}}>
+ <ErrorBoundary>
+ <CameraViewsGrid settings={settings} resetKey={resetKey}/>
+ </ErrorBoundary>
+ </Box>
+ )}
+ </Box>
+
+ <Box component="footer" sx={{p: 1}}>
+ <Footer/>
+ </Box>
+ </Box>
+ </React.Fragment>
+ );
+};
\ No newline at end of file
diff --git a/freemocap-ui-old/src/pages/SettingsPage.tsx b/freemocap-ui-old/src/pages/SettingsPage.tsx
new file mode 100644
index 00000000..ffe2731b
--- /dev/null
+++ b/freemocap-ui-old/src/pages/SettingsPage.tsx
@@ -0,0 +1,1510 @@
+import React, { useState, useCallback, useEffect } from 'react';
+import {
+ Box,
+ Typography,
+ Switch,
+ FormControlLabel,
+ TextField,
+ Slider,
+ Select,
+ MenuItem,
+ FormControl,
+ InputLabel,
+ Paper,
+ List,
+ ListItemButton,
+ ListItemIcon,
+ ListItemText,
+ Divider,
+ Chip,
+ Button,
+ CircularProgress,
+ Alert,
+ Tooltip,
+ LinearProgress,
+ IconButton,
+} from '@mui/material';
+import { useTheme } from '@mui/material/styles';
+import PaletteIcon from '@mui/icons-material/Palette';
+import DnsIcon from '@mui/icons-material/Dns';
+import FiberManualRecordIcon from '@mui/icons-material/FiberManualRecord';
+import SquareFootIcon from '@mui/icons-material/SquareFoot';
+import DirectionsRunIcon from '@mui/icons-material/DirectionsRun';
+import CastConnectedIcon from '@mui/icons-material/CastConnected';
+import ComputerIcon from '@mui/icons-material/Computer';
+import MemoryIcon from '@mui/icons-material/Memory';
+import SpeedIcon from '@mui/icons-material/Speed';
+import StorageIcon from '@mui/icons-material/Storage';
+import VideocamIcon from '@mui/icons-material/Videocam';
+import CheckCircleIcon from '@mui/icons-material/CheckCircle';
+import ErrorIcon from '@mui/icons-material/Error';
+import WarningIcon from '@mui/icons-material/Warning';
+import DownloadIcon from '@mui/icons-material/Download';
+import RefreshIcon from '@mui/icons-material/Refresh';
+import ArrowBackIcon from '@mui/icons-material/ArrowBack';
+import CodeIcon from '@mui/icons-material/Code';
+import { useNavigate } from 'react-router-dom';
+import {
+ useAppDispatch,
+ useAppSelector,
+ themeModeSet,
+ themeModeToggled,
+ recordingDirectoryChanged,
+ useDelayStartToggled,
+ delaySecondsChanged,
+ useTimestampToggled,
+ useIncrementToggled,
+ baseNameChanged,
+ recordingTagChanged,
+ createSubfolderToggled,
+ customSubfolderNameChanged,
+ selectServerSettings,
+} from '@/store';
+import { ThemeMode } from '@/store/slices/theme/theme-types';
+import { useCalibration } from '@/hooks/useCalibration';
+import { useMocap } from '@/hooks/useMocap';
+import { useServer } from '@/hooks/useServer';
+import { useElectronIPC } from '@/services';
+import {
+ MediapipeModelComplexity,
+ MEDIAPIPE_REALTIME_PRESET,
+ MEDIAPIPE_POSTHOC_PRESET,
+ DEFAULT_REALTIME_FILTER_CONFIG,
+} from '@/store/slices/mocap';
+import { SettingsEditor } from '@/components/settings-editor/SettingsEditor';
+
+// ── Section IDs ──
+
+type SectionId =
+ | 'appearance'
+ | 'connection'
+ | 'recording'
+ | 'calibration'
+ | 'mocap'
+ | 'vmc'
+ | 'system'
+ | 'editor';
+
+interface SectionDef {
+ id: SectionId;
+ label: string;
+ icon: React.ReactNode;
+}
+
+const SECTIONS: SectionDef[] = [
+ { id: 'appearance', label: 'Appearance', icon: <PaletteIcon /> },
+ { id: 'connection', label: 'Server Connection', icon: <DnsIcon /> },
+ { id: 'recording', label: 'Recording', icon: <FiberManualRecordIcon /> },
+ { id: 'calibration', label: 'Calibration', icon: <SquareFootIcon /> },
+ { id: 'mocap', label: 'Motion Capture', icon: <DirectionsRunIcon /> },
+ { id: 'vmc', label: 'VMC Output', icon: <CastConnectedIcon /> },
+ { id: 'system', label: 'System Info', icon: <ComputerIcon /> },
+ { id: 'editor', label: 'Raw Editor', icon: <CodeIcon /> },
+];
+
+// ── Setup wizard types (mirrors electron-side types) ──
+
+interface CpuInfo { model: string; cores: number; threads: number; speedMhz: number }
+interface RamInfo { totalGb: number; availableGb: number }
+interface GpuInfo { name: string; vendor: string; vramMb: number | null; cudaAvailable: boolean; cudaVersion: string | null }
+interface DiskInfo { path: string; totalGb: number; freeGb: number }
+interface OsInfo { platform: string; release: string; arch: string; hostname: string }
+type PerformanceTier = 'basic' | 'standard' | 'advanced' | 'pro';
+interface PerformanceRecommendation {
+ tier: PerformanceTier;
+ label: string;
+ description: string;
+ maxCameras: number;
+ maxResolution: string;
+ realtimeTracking: boolean;
+ warnings: string[];
+}
+interface SystemScanResult {
+ cpu: CpuInfo;
+ ram: RamInfo;
+ gpus: GpuInfo[];
+ disk: DiskInfo;
+ os: OsInfo;
+ recommendation: PerformanceRecommendation;
+ scannedAt: string;
+}
+
+type DependencyStatus = 'installed' | 'missing' | 'outdated' | 'checking' | 'installing' | 'error';
+interface DependencyInfo {
+ id: string;
+ name: string;
+ description: string;
+ required: boolean;
+ status: DependencyStatus;
+ version: string | null;
+ installedPath: string | null;
+ error: string | null;
+}
+
+const SYSTEM_SCAN_KEY = 'lastSystemScan';
+
+const TIER_COLORS: Record<PerformanceTier, string> = {
+ basic: '#ff9800',
+ standard: '#2196f3',
+ advanced: '#4caf50',
+ pro: '#00e5ff',
+};
+
+const TIER_EMOJIS: Record<PerformanceTier, string> = {
+ basic: '🐢',
+ standard: '🏃',
+ advanced: '🚀',
+ pro: '⚡',
+};
+
+// ── Shared layout components ──
+
+function SectionHeader({ title, description }: { title: string; description?: string }) {
+ const theme = useTheme();
+ return (
+ <Box sx={{ mb: 3 }}>
+ <Typography variant="h5" sx={{ fontWeight: 700, mb: 0.5 }}>
+ {title}
+ </Typography>
+ {description && (
+ <Typography variant="body2" sx={{ color: theme.palette.text.secondary }}>
+ {description}
+ </Typography>
+ )}
+ </Box>
+ );
+}
+
+function SettingRow({ label, description, children }: { label: string; description?: string; children: React.ReactNode }) {
+ const theme = useTheme();
+ return (
+ <Box
+ sx={{
+ display: 'flex',
+ alignItems: 'flex-start',
+ justifyContent: 'space-between',
+ py: 1.5,
+ gap: 3,
+ }}
+ >
+ <Box sx={{ flex: 1, minWidth: 0 }}>
+ <Typography variant="body1" sx={{ fontWeight: 500 }}>
+ {label}
+ </Typography>
+ {description && (
+ <Typography variant="body2" sx={{ color: theme.palette.text.secondary, mt: 0.25 }}>
+ {description}
+ </Typography>
+ )}
+ </Box>
+ <Box sx={{ flexShrink: 0, display: 'flex', alignItems: 'center' }}>
+ {children}
+ </Box>
+ </Box>
+ );
+}
+
+function SettingGroup({ title, children }: { title: string; children: React.ReactNode }) {
+ const theme = useTheme();
+ return (
+ <Paper
+ elevation={0}
+ sx={{
+ border: `1px solid ${theme.palette.divider}`,
+ borderRadius: 2,
+ p: 2.5,
+ mb: 2,
+ }}
+ >
+ <Typography
+ variant="overline"
+ sx={{
+ fontWeight: 700,
+ color: theme.palette.text.secondary,
+ letterSpacing: 1.2,
+ mb: 1,
+ display: 'block',
+ }}
+ >
+ {title}
+ </Typography>
+ <Divider sx={{ mb: 1 }} />
+ {children}
+ </Paper>
+ );
+}
+
+// ── Section: Appearance ──
+
+function AppearanceSection() {
+ const dispatch = useAppDispatch();
+ const themeMode = useAppSelector(state => state.theme.mode);
+
+ return (
+ <>
+ <SectionHeader
+ title="Appearance"
+ description="Customize how FreeMoCap looks."
+ />
+ <SettingGroup title="Theme">
+ <SettingRow
+ label="Dark Mode"
+ description="Toggle between light and dark color schemes."
+ >
+ <Switch
+ checked={themeMode === 'dark'}
+ onChange={() => dispatch(themeModeToggled())}
+ />
+ </SettingRow>
+ <SettingRow
+ label="Color Scheme"
+ description="Choose your preferred theme."
+ >
+ <FormControl size="small" sx={{ minWidth: 140 }}>
+ <Select
+ value={themeMode}
+ onChange={(e) => dispatch(themeModeSet(e.target.value as ThemeMode))}
+ >
+ <MenuItem value="dark">Dark</MenuItem>
+ <MenuItem value="light">Light</MenuItem>
+ </Select>
+ </FormControl>
+ </SettingRow>
+ </SettingGroup>
+ </>
+ );
+}
+
+// ── Section: Server Connection ──
+
+function ConnectionSection() {
+ const { isConnected, connectionState, connect, disconnect } = useServer();
+ const theme = useTheme();
+
+ return (
+ <>
+ <SectionHeader
+ title="Server Connection"
+ description="Connection to the FreeMoCap backend server."
+ />
+ <SettingGroup title="Status">
+ <SettingRow
+ label="Connection Status"
+ description={`Current state: ${connectionState}`}
+ >
+ <Chip
+ label={isConnected ? 'Connected' : 'Disconnected'}
+ color={isConnected ? 'success' : 'error'}
+ size="small"
+ variant="outlined"
+ />
+ </SettingRow>
+ <SettingRow
+ label="Server Address"
+ description="Backend server URL (configured at build time)."
+ >
+ <Typography variant="body2" sx={{ fontFamily: 'monospace', color: theme.palette.text.secondary }}>
+ localhost:53117
+ </Typography>
+ </SettingRow>
+ <SettingRow label="Actions">
+ <Box sx={{ display: 'flex', gap: 1 }}>
+ <Button
+ size="small"
+ variant="outlined"
+ onClick={connect}
+ disabled={isConnected}
+ >
+ Connect
+ </Button>
+ <Button
+ size="small"
+ variant="outlined"
+ color="error"
+ onClick={disconnect}
+ disabled={!isConnected}
+ >
+ Disconnect
+ </Button>
+ </Box>
+ </SettingRow>
+ </SettingGroup>
+ </>
+ );
+}
+
+// ── Section: Recording ──
+
+function RecordingSection() {
+ const dispatch = useAppDispatch();
+ const recording = useAppSelector(state => state.recording);
+ const { isElectron, api } = useElectronIPC();
+
+ const handleBrowseDirectory = useCallback(async () => {
+ if (!isElectron || !api) return;
+ const result = await api.fileSystem.selectDirectory.query();
+ if (result) {
+ dispatch(recordingDirectoryChanged(result as string));
+ }
+ }, [dispatch, isElectron, api]);
+
+ return (
+ <>
+ <SectionHeader
+ title="Recording"
+ description="Configure how recordings are saved and named."
+ />
+ <SettingGroup title="Storage">
+ <SettingRow
+ label="Recording Directory"
+ description="Base folder for saving recordings."
+ >
+ <Box sx={{ display: 'flex', gap: 1, alignItems: 'center' }}>
+ <TextField
+ size="small"
+ value={recording.recordingDirectory}
+ onChange={(e) => dispatch(recordingDirectoryChanged(e.target.value))}
+ sx={{ minWidth: 260 }}
+ inputProps={{ style: { fontFamily: 'monospace', fontSize: 13 } }}
+ />
+ {isElectron && (
+ <Button size="small" variant="outlined" onClick={handleBrowseDirectory}>
+ Browse
+ </Button>
+ )}
+ </Box>
+ </SettingRow>
+ <SettingRow
+ label="Create Subfolder"
+ description="Put each recording session in its own subfolder."
+ >
+ <Switch
+ checked={recording.config.createSubfolder}
+ onChange={(_, v) => dispatch(createSubfolderToggled(v))}
+ />
+ </SettingRow>
+ {recording.config.createSubfolder && (
+ <SettingRow
+ label="Custom Subfolder Name"
+ description="Leave blank for auto-generated timestamp name."
+ >
+ <TextField
+ size="small"
+ value={recording.config.customSubfolderName}
+ onChange={(e) => dispatch(customSubfolderNameChanged(e.target.value))}
+ placeholder="(auto)"
+ sx={{ minWidth: 200 }}
+ />
+ </SettingRow>
+ )}
+ </SettingGroup>
+
+ <SettingGroup title="Naming">
+ <SettingRow
+ label="Use Timestamp"
+ description="Include timestamp in recording name."
+ >
+ <Switch
+ checked={recording.config.useTimestamp}
+ onChange={(_, v) => dispatch(useTimestampToggled(v))}
+ />
+ </SettingRow>
+ <SettingRow
+ label="Use Increment"
+ description="Append an auto-incrementing number."
+ >
+ <Switch
+ checked={recording.config.useIncrement}
+ onChange={(_, v) => dispatch(useIncrementToggled(v))}
+ />
+ </SettingRow>
+ {!recording.config.useTimestamp && (
+ <SettingRow
+ label="Base Name"
+ description="Base name for recordings when not using timestamp."
+ >
+ <TextField
+ size="small"
+ value={recording.config.baseName}
+ onChange={(e) => dispatch(baseNameChanged(e.target.value))}
+ sx={{ minWidth: 200 }}
+ />
+ </SettingRow>
+ )}
+ <SettingRow
+ label="Recording Tag"
+ description="Optional tag appended to the recording name."
+ >
+ <TextField
+ size="small"
+ value={recording.config.recordingTag}
+ onChange={(e) => dispatch(recordingTagChanged(e.target.value))}
+ placeholder="(none)"
+ sx={{ minWidth: 200 }}
+ />
+ </SettingRow>
+ </SettingGroup>
+
+ <SettingGroup title="Delay Start">
+ <SettingRow
+ label="Delay Before Recording"
+ description="Add a countdown before recording starts."
+ >
+ <Switch
+ checked={recording.config.useDelayStart}
+ onChange={(_, v) => dispatch(useDelayStartToggled(v))}
+ />
+ </SettingRow>
+ {recording.config.useDelayStart && (
+ <SettingRow
+ label="Delay Duration"
+ description="Seconds to wait before recording begins."
+ >
+ <TextField
+ size="small"
+ type="number"
+ value={recording.config.delaySeconds}
+ onChange={(e) => dispatch(delaySecondsChanged(Number(e.target.value)))}
+ inputProps={{ min: 1, max: 30 }}
+ sx={{ width: 100 }}
+ />
+ </SettingRow>
+ )}
+ </SettingGroup>
+
+ <SettingGroup title="Preview">
+ <Box sx={{ fontFamily: 'monospace', fontSize: 13, opacity: 0.7, p: 1 }}>
+ <Typography variant="caption" sx={{ display: 'block' }}>
+ Recording name: <strong>{recording.computed.recordingName || '(empty)'}</strong>
+ </Typography>
+ <Typography variant="caption" sx={{ display: 'block' }}>
+ Full path: <strong>{recording.computed.fullRecordingPath}</strong>
+ </Typography>
+ </Box>
+ </SettingGroup>
+ </>
+ );
+}
+
+// ── Section: Calibration ──
+
+function CalibrationSection() {
+ const { config, updateCalibrationConfig, isLoading } = useCalibration();
+
+ return (
+ <>
+ <SectionHeader
+ title="Calibration"
+ description="Camera calibration settings for multi-camera setups."
+ />
+ <SettingGroup title="ChArUco Board">
+ <SettingRow
+ label="X Squares"
+ description="Number of squares along the X axis."
+ >
+ <TextField
+ size="small"
+ type="number"
+ value={config.charucoBoardXSquares}
+ onChange={(e) => updateCalibrationConfig({ charucoBoardXSquares: Number(e.target.value) })}
+ inputProps={{ min: 2, max: 20 }}
+ disabled={isLoading}
+ sx={{ width: 100 }}
+ />
+ </SettingRow>
+ <SettingRow
+ label="Y Squares"
+ description="Number of squares along the Y axis."
+ >
+ <TextField
+ size="small"
+ type="number"
+ value={config.charucoBoardYSquares}
+ onChange={(e) => updateCalibrationConfig({ charucoBoardYSquares: Number(e.target.value) })}
+ inputProps={{ min: 2, max: 20 }}
+ disabled={isLoading}
+ sx={{ width: 100 }}
+ />
+ </SettingRow>
+ <SettingRow
+ label="Square Length (mm)"
+ description="Physical size of each square on the board."
+ >
+ <TextField
+ size="small"
+ type="number"
+ value={config.charucoSquareLength}
+ onChange={(e) => updateCalibrationConfig({ charucoSquareLength: Number(e.target.value) })}
+ inputProps={{ min: 1, step: 0.5 }}
+ disabled={isLoading}
+ sx={{ width: 100 }}
+ />
+ </SettingRow>
+ </SettingGroup>
+
+ <SettingGroup title="Solver">
+ <SettingRow
+ label="Solver Method"
+ description="Algorithm used to solve camera calibration."
+ >
+ <FormControl size="small" sx={{ minWidth: 140 }}>
+ <Select
+ value={config.solverMethod}
+ onChange={(e) => updateCalibrationConfig({ solverMethod: e.target.value as 'anipose' | 'pyceres' })}
+ disabled={isLoading}
+ >
+ <MenuItem value="anipose">Anipose</MenuItem>
+ <MenuItem value="pyceres">PyCeres</MenuItem>
+ </Select>
+ </FormControl>
+ </SettingRow>
+ <SettingRow
+ label="Use Ground Plane"
+ description="Apply ground plane constraint to calibration."
+ >
+ <Switch
+ checked={config.useGroundplane}
+ onChange={(_, v) => updateCalibrationConfig({ useGroundplane: v })}
+ disabled={isLoading}
+ />
+ </SettingRow>
+ </SettingGroup>
+
+ <SettingGroup title="Recording">
+ <SettingRow
+ label="Live Track ChArUco"
+ description="Show ChArUco detection overlay while recording."
+ >
+ <Switch
+ checked={config.liveTrackCharuco}
+ onChange={(_, v) => updateCalibrationConfig({ liveTrackCharuco: v })}
+ disabled={isLoading}
+ />
+ </SettingRow>
+ <SettingRow
+ label="Min Shared Views Per Camera"
+ description="Minimum board observations shared between camera pairs."
+ >
+ <TextField
+ size="small"
+ type="number"
+ value={config.minSharedViewsPerCamera}
+ onChange={(e) => updateCalibrationConfig({ minSharedViewsPerCamera: Number(e.target.value) })}
+ inputProps={{ min: 1, max: 200 }}
+ disabled={isLoading}
+ sx={{ width: 100 }}
+ />
+ </SettingRow>
+ <SettingRow
+ label="Auto-Stop on Min View Count"
+ description="Automatically stop recording when minimum views are reached."
+ >
+ <Switch
+ checked={config.autoStopOnMinViewCount}
+ onChange={(_, v) => updateCalibrationConfig({ autoStopOnMinViewCount: v })}
+ disabled={isLoading}
+ />
+ </SettingRow>
+ </SettingGroup>
+ </>
+ );
+}
+
+// ── Section: Motion Capture ──
+
+const MODEL_COMPLEXITY_LABELS: Record<MediapipeModelComplexity, string> = {
+ 0: 'Lite (fastest)',
+ 1: 'Full (balanced)',
+ 2: 'Heavy (most accurate)',
+};
+
+function MocapSection() {
+ const {
+ detectorConfig,
+ skeletonFilterConfig,
+ updateDetectorConfig,
+ replaceDetectorConfig,
+ updateSkeletonFilterConfig,
+ replaceSkeletonFilterConfig,
+ isLoading,
+ } = useMocap();
+
+ const detectPreset = useCallback(() => {
+ if (
+ detectorConfig.model_complexity === 0 &&
+ !detectorConfig.enable_segmentation &&
+ !detectorConfig.smooth_segmentation
+ ) return 'realtime';
+ if (
+ detectorConfig.model_complexity === 2 &&
+ detectorConfig.enable_segmentation &&
+ detectorConfig.smooth_segmentation
+ ) return 'posthoc';
+ return 'custom';
+ }, [detectorConfig]);
+
+ const currentPreset = detectPreset();
+
+ return (
+ <>
+ <SectionHeader
+ title="Motion Capture"
+ description="MediaPipe detector and skeleton filter configuration."
+ />
+
+ {/* Detector */}
+ <SettingGroup title="MediaPipe Detector">
+ <SettingRow
+ label="Preset"
+ description="Quick-select a tuned detector configuration."
+ >
+ <Box sx={{ display: 'flex', gap: 1 }}>
+ <Chip
+ label="Realtime"
+ size="small"
+ variant={currentPreset === 'realtime' ? 'filled' : 'outlined'}
+ color={currentPreset === 'realtime' ? 'primary' : 'default'}
+ onClick={() => replaceDetectorConfig({ ...MEDIAPIPE_REALTIME_PRESET })}
+ disabled={isLoading}
+ sx={{ cursor: 'pointer' }}
+ />
+ <Chip
+ label="Posthoc"
+ size="small"
+ variant={currentPreset === 'posthoc' ? 'filled' : 'outlined'}
+ color={currentPreset === 'posthoc' ? 'primary' : 'default'}
+ onClick={() => replaceDetectorConfig({ ...MEDIAPIPE_POSTHOC_PRESET })}
+ disabled={isLoading}
+ sx={{ cursor: 'pointer' }}
+ />
+ {currentPreset === 'custom' && (
+ <Chip label="Custom" size="small" variant="outlined" color="warning" />
+ )}
+ </Box>
+ </SettingRow>
+ <SettingRow
+ label="Model Complexity"
+ description="Controls accuracy vs. speed tradeoff."
+ >
+ <FormControl size="small" sx={{ minWidth: 180 }}>
+ <Select
+ value={detectorConfig.model_complexity}
+ onChange={(e) => updateDetectorConfig({ model_complexity: e.target.value as MediapipeModelComplexity })}
+ disabled={isLoading}
+ >
+ <MenuItem value={0}>{MODEL_COMPLEXITY_LABELS[0]}</MenuItem>
+ <MenuItem value={1}>{MODEL_COMPLEXITY_LABELS[1]}</MenuItem>
+ <MenuItem value={2}>{MODEL_COMPLEXITY_LABELS[2]}</MenuItem>
+ </Select>
+ </FormControl>
+ </SettingRow>
+ <SettingRow
+ label={`Min Detection Confidence: ${detectorConfig.min_detection_confidence.toFixed(2)}`}
+ description="Minimum score for initial pose detection."
+ >
+ <Slider
+ value={detectorConfig.min_detection_confidence}
+ onChange={(_, v) => updateDetectorConfig({ min_detection_confidence: v as number })}
+ min={0} max={1} step={0.05} size="small"
+ disabled={isLoading}
+ sx={{ width: 180 }}
+ />
+ </SettingRow>
+ <SettingRow
+ label={`Min Tracking Confidence: ${detectorConfig.min_tracking_confidence.toFixed(2)}`}
+ description="Minimum score for frame-to-frame tracking."
+ >
+ <Slider
+ value={detectorConfig.min_tracking_confidence}
+ onChange={(_, v) => updateDetectorConfig({ min_tracking_confidence: v as number })}
+ min={0} max={1} step={0.05} size="small"
+ disabled={isLoading}
+ sx={{ width: 180 }}
+ />
+ </SettingRow>
+ <SettingRow label="Smooth Landmarks">
+ <Switch
+ size="small"
+ checked={detectorConfig.smooth_landmarks}
+ onChange={(_, v) => updateDetectorConfig({ smooth_landmarks: v })}
+ disabled={isLoading}
+ />
+ </SettingRow>
+ <SettingRow label="Enable Segmentation">
+ <Switch
+ size="small"
+ checked={detectorConfig.enable_segmentation}
+ onChange={(_, v) => updateDetectorConfig({ enable_segmentation: v })}
+ disabled={isLoading}
+ />
+ </SettingRow>
+ <SettingRow label="Smooth Segmentation">
+ <Switch
+ size="small"
+ checked={detectorConfig.smooth_segmentation}
+ onChange={(_, v) => updateDetectorConfig({ smooth_segmentation: v })}
+ disabled={isLoading || !detectorConfig.enable_segmentation}
+ />
+ </SettingRow>
+ <SettingRow label="Refine Face Landmarks">
+ <Switch
+ size="small"
+ checked={detectorConfig.refine_face_landmarks}
+ onChange={(_, v) => updateDetectorConfig({ refine_face_landmarks: v })}
+ disabled={isLoading}
+ />
+ </SettingRow>
+ <SettingRow label="Static Image Mode">
+ <Switch
+ size="small"
+ checked={detectorConfig.static_image_mode}
+ onChange={(_, v) => updateDetectorConfig({ static_image_mode: v })}
+ disabled={isLoading}
+ />
+ </SettingRow>
+ </SettingGroup>
+
+ {/* Skeleton Filter */}
+ <SettingGroup title="Skeleton Filter">
+ <Box sx={{ display: 'flex', justifyContent: 'flex-end', mb: 1 }}>
+ <Button
+ size="small"
+ variant="text"
+ onClick={() => replaceSkeletonFilterConfig({ ...DEFAULT_REALTIME_FILTER_CONFIG })}
+ disabled={isLoading}
+ >
+ Reset Defaults
+ </Button>
+ </Box>
+
+ <SettingRow
+ label="Height (meters)"
+ description="Subject height for bone length estimation."
+ >
+ <TextField
+ size="small"
+ type="number"
+ value={skeletonFilterConfig.height_meters}
+ onChange={(e) => updateSkeletonFilterConfig({ height_meters: Number(e.target.value) })}
+ inputProps={{ min: 0.5, max: 2.5, step: 0.01 }}
+ disabled={isLoading}
+ sx={{ width: 100 }}
+ />
+ </SettingRow>
+
+ <Typography variant="caption" sx={{ display: 'block', mt: 1, mb: 0.5, fontWeight: 600, opacity: 0.6 }}>
+ ONE EURO FILTER
+ </Typography>
+ <SettingRow label={`Min Cutoff: ${skeletonFilterConfig.min_cutoff.toFixed(2)}`}>
+ <Slider
+ value={skeletonFilterConfig.min_cutoff}
+ onChange={(_, v) => updateSkeletonFilterConfig({ min_cutoff: v as number })}
+ min={0.01} max={10} step={0.01} size="small"
+ disabled={isLoading} sx={{ width: 180 }}
+ />
+ </SettingRow>
+ <SettingRow label={`Beta: ${skeletonFilterConfig.beta.toFixed(3)}`}>
+ <Slider
+ value={skeletonFilterConfig.beta}
+ onChange={(_, v) => updateSkeletonFilterConfig({ beta: v as number })}
+ min={0} max={1} step={0.001} size="small"
+ disabled={isLoading} sx={{ width: 180 }}
+ />
+ </SettingRow>
+ <SettingRow label={`D Cutoff: ${skeletonFilterConfig.d_cutoff.toFixed(2)}`}>
+ <Slider
+ value={skeletonFilterConfig.d_cutoff}
+ onChange={(_, v) => updateSkeletonFilterConfig({ d_cutoff: v as number })}
+ min={0.01} max={10} step={0.01} size="small"
+ disabled={isLoading} sx={{ width: 180 }}
+ />
+ </SettingRow>
+
+ <Typography variant="caption" sx={{ display: 'block', mt: 1, mb: 0.5, fontWeight: 600, opacity: 0.6 }}>
+ FABRIK IK
+ </Typography>
+ <SettingRow label={`Tolerance: ${skeletonFilterConfig.fabrik_tolerance.toFixed(4)}`}>
+ <Slider
+ value={skeletonFilterConfig.fabrik_tolerance}
+ onChange={(_, v) => updateSkeletonFilterConfig({ fabrik_tolerance: v as number })}
+ min={0.0001} max={0.1} step={0.0001} size="small"
+ disabled={isLoading} sx={{ width: 180 }}
+ />
+ </SettingRow>
+ <SettingRow label="Max Iterations">
+ <TextField
+ size="small"
+ type="number"
+ value={skeletonFilterConfig.fabrik_max_iterations}
+ onChange={(e) => updateSkeletonFilterConfig({ fabrik_max_iterations: Number(e.target.value) })}
+ inputProps={{ min: 1, max: 100 }}
+ disabled={isLoading}
+ sx={{ width: 100 }}
+ />
+ </SettingRow>
+
+ <Typography variant="caption" sx={{ display: 'block', mt: 1, mb: 0.5, fontWeight: 600, opacity: 0.6 }}>
+ POINT GATING
+ </Typography>
+ <SettingRow label="Max Reprojection Error (px)">
+ <TextField
+ size="small"
+ type="number"
+ value={skeletonFilterConfig.max_reprojection_error_px}
+ onChange={(e) => updateSkeletonFilterConfig({ max_reprojection_error_px: Number(e.target.value) })}
+ inputProps={{ min: 0, step: 1 }}
+ disabled={isLoading}
+ sx={{ width: 100 }}
+ />
+ </SettingRow>
+ <SettingRow label="Max Velocity (m/s)">
+ <TextField
+ size="small"
+ type="number"
+ value={skeletonFilterConfig.max_velocity_m_per_s}
+ onChange={(e) => updateSkeletonFilterConfig({ max_velocity_m_per_s: Number(e.target.value) })}
+ inputProps={{ min: 0, step: 0.5 }}
+ disabled={isLoading}
+ sx={{ width: 100 }}
+ />
+ </SettingRow>
+ <SettingRow label="Max Rejected Streak">
+ <TextField
+ size="small"
+ type="number"
+ value={skeletonFilterConfig.max_rejected_streak}
+ onChange={(e) => updateSkeletonFilterConfig({ max_rejected_streak: Number(e.target.value) })}
+ inputProps={{ min: 0 }}
+ disabled={isLoading}
+ sx={{ width: 100 }}
+ />
+ </SettingRow>
+ </SettingGroup>
+ </>
+ );
+}
+
+// ── Section: VMC Output ──
+
+function VMCSection() {
+ const { send, isConnected } = useServer();
+ const settings = useAppSelector(selectServerSettings);
+
+ const vmcEnabled = settings?.vmc?.enabled ?? false;
+ const vmcHost = settings?.vmc?.host ?? '127.0.0.1';
+ const vmcPort = settings?.vmc?.port ?? 39539;
+
+ const patchVMC = useCallback(
+ (patch: Record<string, unknown>) => {
+ send({ message_type: 'settings/patch', patch: { vmc: patch } });
+ },
+ [send],
+ );
+
+ return (
+ <>
+ <SectionHeader
+ title="VMC Output"
+ description="Virtual Motion Capture protocol streaming settings."
+ />
+ <SettingGroup title="VMC Streaming">
+ <SettingRow
+ label="Enable VMC Output"
+ description="Stream skeleton data via VMC protocol over UDP."
+ >
+ <Switch
+ checked={vmcEnabled}
+ onChange={() => patchVMC({ enabled: !vmcEnabled })}
+ disabled={!isConnected}
+ />
+ </SettingRow>
+ <SettingRow
+ label="Host"
+ description="Target IP address for VMC packets."
+ >
+ <TextField
+ size="small"
+ value={vmcHost}
+ onChange={(e) => {
+ const val = e.target.value.trim();
+ if (val.length > 0) patchVMC({ host: val });
+ }}
+ disabled={!isConnected || !vmcEnabled}
+ sx={{ width: 160 }}
+ inputProps={{ style: { fontFamily: 'monospace', fontSize: 13 } }}
+ />
+ </SettingRow>
+ <SettingRow
+ label="Port"
+ description="UDP port for VMC packets (default 39539)."
+ >
+ <TextField
+ size="small"
+ type="number"
+ value={vmcPort}
+ onChange={(e) => {
+ const val = parseInt(e.target.value, 10);
+ if (!isNaN(val) && val > 0 && val <= 65535) patchVMC({ port: val });
+ }}
+ disabled={!isConnected || !vmcEnabled}
+ inputProps={{ min: 1, max: 65535 }}
+ sx={{ width: 120 }}
+ />
+ </SettingRow>
+ {!isConnected && (
+ <Alert severity="info" sx={{ mt: 1 }}>
+ Connect to the backend server to configure VMC settings.
+ </Alert>
+ )}
+ </SettingGroup>
+ </>
+ );
+}
+
+// ── Section: System Info ──
+
+function DependencyStatusIcon({ status }: { status: DependencyStatus }) {
+ switch (status) {
+ case 'installed':
+ return <CheckCircleIcon sx={{ color: '#4caf50', fontSize: 20 }} />;
+ case 'missing':
+ return <ErrorIcon sx={{ color: '#f44336', fontSize: 20 }} />;
+ case 'outdated':
+ return <WarningIcon sx={{ color: '#ff9800', fontSize: 20 }} />;
+ case 'checking':
+ case 'installing':
+ return <CircularProgress size={18} />;
+ case 'error':
+ return <ErrorIcon sx={{ color: '#f44336', fontSize: 20 }} />;
+ }
+}
+
+function SystemSection() {
+ const theme = useTheme();
+ const { isElectron, api } = useElectronIPC();
+
+ const [scanning, setScanning] = useState(false);
+ const [scanResult, setScanResult] = useState<SystemScanResult | null>(null);
+ const [dependencies, setDependencies] = useState<DependencyInfo[]>([]);
+ const [installing, setInstalling] = useState<string | null>(null);
+
+ const runScan = useCallback(async () => {
+ if (!isElectron || !api) return;
+ setScanning(true);
+ try {
+ const result = await api.system.scan.query();
+ const typed = result as SystemScanResult;
+ setScanResult(typed);
+ await api.settings.set.mutate({ key: SYSTEM_SCAN_KEY, value: typed });
+ } catch (err) {
+ console.error('System scan failed:', err);
+ } finally {
+ setScanning(false);
+ }
+ }, [isElectron, api]);
+
+ const detectDeps = useCallback(async () => {
+ if (!isElectron || !api) return;
+ try {
+ const result = await api.dependencies.detectAll.query();
+ setDependencies(result as DependencyInfo[]);
+ } catch (err) {
+ console.error('Dependency detection failed:', err);
+ }
+ }, [isElectron, api]);
+
+ const installDep = useCallback(async (depId: string) => {
+ if (!isElectron || !api) return;
+ setInstalling(depId);
+ try {
+ const updated = await api.dependencies.install.mutate({ dependencyId: depId });
+ setDependencies(prev =>
+ prev.map(d => d.id === depId ? (updated as DependencyInfo) : d),
+ );
+ if (depId === 'uv') {
+ const envInfo = await api.dependencies.detect.query({ dependencyId: 'python-env' });
+ setDependencies(prev =>
+ prev.map(d => d.id === 'python-env' ? (envInfo as DependencyInfo) : d),
+ );
+ }
+ } catch (err) {
+ console.error(`Failed to install ${depId}:`, err);
+ setDependencies(prev =>
+ prev.map(d =>
+ d.id === depId
+ ? { ...d, status: 'error' as DependencyStatus, error: err instanceof Error ? err.message : String(err) }
+ : d,
+ ),
+ );
+ } finally {
+ setInstalling(null);
+ }
+ }, [isElectron, api]);
+
+ // Load persisted scan on mount
+ useEffect(() => {
+ if (!isElectron || !api) return;
+ api.settings.get.query({ key: SYSTEM_SCAN_KEY }).then(result => {
+ if (result && typeof result === 'object' && 'cpu' in (result as object)) {
+ setScanResult(result as SystemScanResult);
+ }
+ }).catch(() => { /* no persisted scan */ });
+ }, [isElectron, api]);
+
+ if (!isElectron) {
+ return (
+ <>
+ <SectionHeader
+ title="System Info"
+ description="System scanning is only available in the desktop app."
+ />
+ <Alert severity="info">
+ Connect to a running FreeMoCap server via the desktop app to view system information and manage dependencies.
+ </Alert>
+ </>
+ );
+ }
+
+ const rec = scanResult?.recommendation;
+ const tierColor = rec ? TIER_COLORS[rec.tier] : undefined;
+
+ return (
+ <>
+ <SectionHeader
+ title="System Info"
+ description="Hardware information, performance tier, and dependency status."
+ />
+
+ {/* Performance Tier */}
+ <SettingGroup title="Performance Tier">
+ {scanning ? (
+ <Box sx={{ textAlign: 'center', py: 4 }}>
+ <CircularProgress size={40} />
+ <Typography sx={{ mt: 1.5, color: theme.palette.text.secondary }}>
+ Scanning your system...
+ </Typography>
+ </Box>
+ ) : scanResult && rec ? (
+ <>
+ <Paper
+ elevation={0}
+ sx={{
+ p: 2, mb: 2,
+ border: `2px solid ${tierColor}`,
+ borderRadius: 2,
+ background: `${tierColor}11`,
+ textAlign: 'center',
+ }}
+ >
+ <Typography variant="h5" sx={{ fontWeight: 700, color: tierColor }}>
+ {TIER_EMOJIS[rec.tier]} {rec.label} System
+ </Typography>
+ <Typography variant="body2" sx={{ mt: 0.5, color: theme.palette.text.secondary }}>
+ {rec.description}
+ </Typography>
+ <Box sx={{ display: 'flex', justifyContent: 'center', gap: 1.5, mt: 1.5, flexWrap: 'wrap' }}>
+ <Chip
+ icon={<VideocamIcon />}
+ label={`Up to ${rec.maxCameras} cameras`}
+ size="small"
+ sx={{ borderColor: tierColor, color: tierColor }}
+ variant="outlined"
+ />
+ <Chip
+ label={`${rec.maxResolution} max`}
+ size="small"
+ sx={{ borderColor: tierColor, color: tierColor }}
+ variant="outlined"
+ />
+ {rec.realtimeTracking && (
+ <Chip
+ icon={<SpeedIcon />}
+ label="Real-time tracking"
+ size="small"
+ sx={{ borderColor: tierColor, color: tierColor }}
+ variant="outlined"
+ />
+ )}
+ </Box>
+ </Paper>
+
+ {/* Hardware grid */}
+ <Box sx={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: 1.5, mb: 2 }}>
+ <Paper elevation={0} sx={{ p: 1.5, border: `1px solid ${theme.palette.divider}`, borderRadius: 1 }}>
+ <Box sx={{ display: 'flex', alignItems: 'center', gap: 1, mb: 0.5 }}>
+ <MemoryIcon sx={{ fontSize: 18, color: theme.palette.text.secondary }} />
+ <Typography variant="caption" sx={{ fontWeight: 600, color: theme.palette.text.secondary }}>CPU</Typography>
+ </Box>
+ <Typography variant="body2" sx={{ fontWeight: 500, fontSize: '0.8rem' }}>
+ {scanResult.cpu.model}
+ </Typography>
+ <Typography variant="caption" sx={{ color: theme.palette.text.secondary }}>
+ {scanResult.cpu.threads} threads · {scanResult.cpu.cores} cores · {scanResult.cpu.speedMhz} MHz
+ </Typography>
+ </Paper>
+
+ <Paper elevation={0} sx={{ p: 1.5, border: `1px solid ${theme.palette.divider}`, borderRadius: 1 }}>
+ <Box sx={{ display: 'flex', alignItems: 'center', gap: 1, mb: 0.5 }}>
+ <ComputerIcon sx={{ fontSize: 18, color: theme.palette.text.secondary }} />
+ <Typography variant="caption" sx={{ fontWeight: 600, color: theme.palette.text.secondary }}>MEMORY</Typography>
+ </Box>
+ <Typography variant="body2" sx={{ fontWeight: 500 }}>
+ {scanResult.ram.totalGb} GB total
+ </Typography>
+ <Typography variant="caption" sx={{ color: theme.palette.text.secondary }}>
+ {scanResult.ram.availableGb} GB available
+ </Typography>
+ </Paper>
+
+ <Paper elevation={0} sx={{ p: 1.5, border: `1px solid ${theme.palette.divider}`, borderRadius: 1 }}>
+ <Box sx={{ display: 'flex', alignItems: 'center', gap: 1, mb: 0.5 }}>
+ <SpeedIcon sx={{ fontSize: 18, color: theme.palette.text.secondary }} />
+ <Typography variant="caption" sx={{ fontWeight: 600, color: theme.palette.text.secondary }}>GPU</Typography>
+ </Box>
+ {scanResult.gpus.length > 0 ? scanResult.gpus.map((gpu, i) => (
+ <Box key={i}>
+ <Typography variant="body2" sx={{ fontWeight: 500, fontSize: '0.8rem' }}>
+ {gpu.name}
+ </Typography>
+ <Typography variant="caption" sx={{ color: theme.palette.text.secondary }}>
+ {gpu.vramMb ? `${Math.round(gpu.vramMb / 1024)} GB VRAM` : 'VRAM unknown'}
+ {gpu.cudaAvailable ? ` · CUDA ${gpu.cudaVersion || '✓'}` : ''}
+ </Typography>
+ </Box>
+ )) : (
+ <Typography variant="body2" sx={{ color: theme.palette.text.disabled }}>
+ No dedicated GPU detected
+ </Typography>
+ )}
+ </Paper>
+
+ <Paper elevation={0} sx={{ p: 1.5, border: `1px solid ${theme.palette.divider}`, borderRadius: 1 }}>
+ <Box sx={{ display: 'flex', alignItems: 'center', gap: 1, mb: 0.5 }}>
+ <StorageIcon sx={{ fontSize: 18, color: theme.palette.text.secondary }} />
+ <Typography variant="caption" sx={{ fontWeight: 600, color: theme.palette.text.secondary }}>DISK</Typography>
+ </Box>
+ <Typography variant="body2" sx={{ fontWeight: 500 }}>
+ {scanResult.disk.freeGb} GB free
+ </Typography>
+ <Typography variant="caption" sx={{ color: theme.palette.text.secondary }}>
+ of {scanResult.disk.totalGb} GB total
+ </Typography>
+ {scanResult.disk.freeGb > 0 && scanResult.disk.freeGb < 20 && (
+ <LinearProgress
+ variant="determinate"
+ value={((scanResult.disk.totalGb - scanResult.disk.freeGb) / scanResult.disk.totalGb) * 100}
+ color="warning"
+ sx={{ mt: 0.5, height: 4, borderRadius: 1 }}
+ />
+ )}
+ </Paper>
+ </Box>
+
+ {rec.warnings.length > 0 && (
+ <Box sx={{ display: 'flex', flexDirection: 'column', gap: 0.5, mb: 2 }}>
+ {rec.warnings.map((w, i) => (
+ <Alert key={i} severity="warning" sx={{ py: 0, fontSize: '0.75rem' }}>
+ {w}
+ </Alert>
+ ))}
+ </Box>
+ )}
+ </>
+ ) : (
+ <Box sx={{ textAlign: 'center', py: 3 }}>
+ <Typography sx={{ color: theme.palette.text.secondary, mb: 1 }}>
+ No system scan data available.
+ </Typography>
+ </Box>
+ )}
+
+ <Box sx={{ display: 'flex', justifyContent: 'flex-end' }}>
+ <Button
+ size="small"
+ startIcon={scanning ? <CircularProgress size={14} /> : <RefreshIcon />}
+ onClick={runScan}
+ disabled={scanning}
+ >
+ {scanResult ? 'Rescan' : 'Scan System'}
+ </Button>
+ </Box>
+ </SettingGroup>
+
+ {/* Dependencies */}
+ <SettingGroup title="Dependencies">
+ {dependencies.length === 0 ? (
+ <Box sx={{ textAlign: 'center', py: 3 }}>
+ <Typography sx={{ color: theme.palette.text.secondary, mb: 1 }}>
+ No dependency data loaded.
+ </Typography>
+ <Button size="small" startIcon={<RefreshIcon />} onClick={detectDeps}>
+ Check Dependencies
+ </Button>
+ </Box>
+ ) : (
+ <>
+ {dependencies.filter(d => d.required).length > 0 && (
+ <Box sx={{ mb: 2 }}>
+ <Typography variant="caption" sx={{ fontWeight: 700, color: theme.palette.text.secondary, mb: 0.5, display: 'block' }}>
+ REQUIRED
+ </Typography>
+ {dependencies.filter(d => d.required).map(dep => (
+ <DependencyRow
+ key={dep.id}
+ dep={dep}
+ isInstalling={installing === dep.id}
+ onInstall={() => installDep(dep.id)}
+ />
+ ))}
+ </Box>
+ )}
+ {dependencies.filter(d => !d.required).length > 0 && (
+ <Box>
+ <Typography variant="caption" sx={{ fontWeight: 700, color: theme.palette.text.secondary, mb: 0.5, display: 'block' }}>
+ OPTIONAL
+ </Typography>
+ {dependencies.filter(d => !d.required).map(dep => (
+ <DependencyRow
+ key={dep.id}
+ dep={dep}
+ isInstalling={installing === dep.id}
+ onInstall={() => installDep(dep.id)}
+ />
+ ))}
+ </Box>
+ )}
+ <Box sx={{ display: 'flex', justifyContent: 'flex-end', mt: 1 }}>
+ <Button size="small" startIcon={<RefreshIcon />} onClick={detectDeps}>
+ Recheck All
+ </Button>
+ </Box>
+ </>
+ )}
+ </SettingGroup>
+ </>
+ );
+}
+
+function DependencyRow({ dep, isInstalling, onInstall }: { dep: DependencyInfo; isInstalling: boolean; onInstall: () => void }) {
+ const theme = useTheme();
+ const canInstall = dep.status === 'missing' || dep.status === 'outdated';
+ const isCuda = dep.id === 'cuda';
+
+ return (
+ <Paper
+ elevation={0}
+ sx={{
+ p: 1.5, mb: 0.5,
+ border: `1px solid ${theme.palette.divider}`,
+ borderRadius: 1,
+ display: 'flex',
+ alignItems: 'center',
+ gap: 1.5,
+ }}
+ >
+ <DependencyStatusIcon status={isInstalling ? 'installing' : dep.status} />
+ <Box sx={{ flex: 1, minWidth: 0 }}>
+ <Box sx={{ display: 'flex', alignItems: 'center', gap: 1 }}>
+ <Typography variant="body2" sx={{ fontWeight: 600 }}>
+ {dep.name}
+ </Typography>
+ {dep.version && (
+ <Chip label={dep.version} size="small" sx={{ height: 18, fontSize: '0.65rem' }} />
+ )}
+ {dep.required && (
+ <Chip label="required" size="small" color="warning" variant="outlined" sx={{ height: 18, fontSize: '0.6rem' }} />
+ )}
+ </Box>
+ <Typography variant="caption" sx={{ color: theme.palette.text.secondary }}>
+ {dep.description}
+ </Typography>
+ {dep.error && (
+ <Typography variant="caption" sx={{ display: 'block', color: theme.palette.error.main, mt: 0.25 }}>
+ {dep.error}
+ </Typography>
+ )}
+ {dep.installedPath && dep.status === 'installed' && (
+ <Tooltip title={dep.installedPath}>
+ <Typography
+ variant="caption"
+ sx={{
+ display: 'block',
+ color: theme.palette.text.disabled,
+ fontSize: '0.6rem',
+ overflow: 'hidden',
+ textOverflow: 'ellipsis',
+ whiteSpace: 'nowrap',
+ maxWidth: 300,
+ }}
+ >
+ {dep.installedPath}
+ </Typography>
+ </Tooltip>
+ )}
+ </Box>
+ {canInstall && !isCuda && (
+ <Button
+ size="small"
+ variant="contained"
+ startIcon={isInstalling ? <CircularProgress size={14} color="inherit" /> : <DownloadIcon />}
+ onClick={onInstall}
+ disabled={isInstalling}
+ sx={{ textTransform: 'none', fontSize: '0.75rem', whiteSpace: 'nowrap' }}
+ >
+ {isInstalling ? 'Installing...' : dep.status === 'outdated' ? 'Update' : 'Install'}
+ </Button>
+ )}
+ {canInstall && isCuda && (
+ <Typography variant="caption" sx={{ color: theme.palette.text.disabled, fontStyle: 'italic' }}>
+ Manual install
+ </Typography>
+ )}
+ </Paper>
+ );
+}
+
+// ── Section: Raw Editor ──
+
+function EditorSection() {
+ return (
+ <Box sx={{ display: 'flex', flexDirection: 'column', height: '100%' }}>
+ <SectionHeader
+ title="Raw Editor"
+ description="View and edit all settings as JSON, YAML, or TOML. Upload a file or edit directly, then apply."
+ />
+ <Box sx={{ flex: 1, minHeight: 0 }}>
+ <SettingsEditor />
+ </Box>
+ </Box>
+ );
+}
+
+// ── Section Map ──
+
+const SECTION_RENDERERS: Record<SectionId, React.FC> = {
+ appearance: AppearanceSection,
+ connection: ConnectionSection,
+ recording: RecordingSection,
+ calibration: CalibrationSection,
+ mocap: MocapSection,
+ vmc: VMCSection,
+ system: SystemSection,
+ editor: EditorSection,
+};
+
+// ── Main Settings Page ──
+
+export const SettingsPage: React.FC = () => {
+ const theme = useTheme();
+ const navigate = useNavigate();
+ const [activeSection, setActiveSection] = useState<SectionId>('appearance');
+
+ const SectionContent = SECTION_RENDERERS[activeSection];
+
+ return (
+ <Box
+ sx={{
+ width: '100%',
+ height: '100%',
+ display: 'flex',
+ backgroundColor: theme.palette.mode === 'dark'
+ ? theme.palette.background.default
+ : theme.palette.grey[50],
+ overflow: 'hidden',
+ }}
+ >
+ {/* Left navigation panel */}
+ <Paper
+ elevation={0}
+ sx={{
+ width: 240,
+ minWidth: 240,
+ height: '100%',
+ borderRight: `1px solid ${theme.palette.divider}`,
+ borderRadius: 0,
+ display: 'flex',
+ flexDirection: 'column',
+ overflow: 'hidden',
+ }}
+ >
+ {/* Settings header with back button */}
+ <Box
+ sx={{
+ px: 2,
+ py: 1.5,
+ borderBottom: `1px solid ${theme.palette.divider}`,
+ display: 'flex',
+ alignItems: 'center',
+ gap: 1,
+ }}
+ >
+ <IconButton size="small" onClick={() => navigate('/')}>
+ <ArrowBackIcon sx={{ fontSize: 18 }} />
+ </IconButton>
+ <Typography variant="h6" sx={{ fontWeight: 700, fontSize: '1.1rem' }}>
+ Settings
+ </Typography>
+ </Box>
+
+ {/* Section list */}
+ <List
+ sx={{
+ flex: 1,
+ overflowY: 'auto',
+ py: 1,
+ }}
+ >
+ {SECTIONS.map((section) => (
+ <ListItemButton
+ key={section.id}
+ selected={activeSection === section.id}
+ onClick={() => setActiveSection(section.id)}
+ sx={{
+ mx: 1,
+ borderRadius: 1.5,
+ mb: 0.25,
+ py: 1,
+ '&.Mui-selected': {
+ backgroundColor: theme.palette.mode === 'dark'
+ ? 'rgba(255, 255, 255, 0.08)'
+ : 'rgba(0, 0, 0, 0.06)',
+ '&:hover': {
+ backgroundColor: theme.palette.mode === 'dark'
+ ? 'rgba(255, 255, 255, 0.12)'
+ : 'rgba(0, 0, 0, 0.09)',
+ },
+ },
+ }}
+ >
+ <ListItemIcon sx={{ minWidth: 36, color: activeSection === section.id ? theme.palette.primary.main : theme.palette.text.secondary }}>
+ {section.icon}
+ </ListItemIcon>
+ <ListItemText
+ primary={section.label}
+ primaryTypographyProps={{
+ fontSize: '0.875rem',
+ fontWeight: activeSection === section.id ? 600 : 400,
+ }}
+ />
+ </ListItemButton>
+ ))}
+ </List>
+ </Paper>
+
+ {/* Right content area */}
+ <Box
+ sx={{
+ flex: 1,
+ height: '100%',
+ overflowY: activeSection === 'editor' ? 'hidden' : 'auto',
+ p: activeSection === 'editor' ? 2 : 4,
+ maxWidth: activeSection === 'editor' ? undefined : 800,
+ display: 'flex',
+ flexDirection: 'column',
+ }}
+ >
+ <SectionContent />
+ </Box>
+ </Box>
+ );
+};
diff --git a/freemocap-ui-old/src/pages/VideosPage.tsx b/freemocap-ui-old/src/pages/VideosPage.tsx
new file mode 100644
index 00000000..f144b3b7
--- /dev/null
+++ b/freemocap-ui-old/src/pages/VideosPage.tsx
@@ -0,0 +1,53 @@
+import React from 'react';
+import Box from "@mui/material/Box";
+import ErrorBoundary from "@/components/common/ErrorBoundary";
+import {Footer} from "@/components/ui-components/Footer";
+import {useTheme} from "@mui/material/styles";
+import {Typography} from '@mui/material';
+
+const VideosPage: React.FC = () => {
+ const theme = useTheme();
+
+ return (
+ <React.Fragment>
+ <Box sx={{
+ py: 1,
+ px: 1,
+ flex: 1,
+ display: 'flex',
+ flexDirection: 'column',
+ height: '100%',
+ backgroundColor: theme.palette.mode === 'dark'
+ ? theme.palette.background.default
+ : theme.palette.background.paper,
+ borderStyle: 'solid',
+ borderWidth: '1px',
+ borderColor: theme.palette.divider
+ }}>
+ <Box sx={{
+ flex: 1,
+ display: 'flex',
+ flexDirection: 'column',
+ justifyContent: 'center',
+ alignItems: 'center',
+ overflow: 'hidden',
+ }}>
+ <ErrorBoundary>
+ <Typography variant="h4" gutterBottom>
+ Load Synchronized Videos
+ </Typography>
+ <Typography variant="body1">
+ This page will allow you to load and synchronize pre-recorded videos.
+ </Typography>
+ {/* Add your video loading components here */}
+ </ErrorBoundary>
+ </Box>
+ <Box component="footer" sx={{p: 1}}>
+ <Footer/>
+ </Box>
+ </Box>
+ </React.Fragment>
+ );
+};
+
+export default VideosPage;
diff --git a/freemocap-ui-old/src/pages/Viewport3dPage.tsx b/freemocap-ui-old/src/pages/Viewport3dPage.tsx
new file mode 100644
index 00000000..860dd0a0
--- /dev/null
+++ b/freemocap-ui-old/src/pages/Viewport3dPage.tsx
@@ -0,0 +1,13 @@
+import {Box} from "@mui/material";
+import React from "react";
+import {ThreeJsCanvas} from "@/components/viewport3d/ThreeJsCanvas";
+
+export const Viewport3dPage = () => {
+ return (
+ <Box sx={{width: '100%',
+ height: '100%',
+ }}>
+ <ThreeJsCanvas/>
+ </Box>
+ );
+}
diff --git a/freemocap-ui-old/src/pages/WelcomePage.tsx b/freemocap-ui-old/src/pages/WelcomePage.tsx
new file mode 100644
index 00000000..d4dec084
--- /dev/null
+++ b/freemocap-ui-old/src/pages/WelcomePage.tsx
@@ -0,0 +1,303 @@
+import React, {useEffect, useRef, useState} from 'react';
+import {
+ Box,
+ Button,
+ CircularProgress,
+ Container,
+ darken,
+ Fade,
+ Grow,
+ Link as MuiLink,
+ Paper,
+ Typography
+} from '@mui/material';
+import {useNavigate} from 'react-router-dom';
+import {useTheme} from '@mui/material/styles';
+import VideocamIcon from '@mui/icons-material/Videocam';
+import {Footer} from '@/components/ui-components/Footer';
+import {useElectronIPC} from "@/services";
+import {connectRealtimePipeline, useAppDispatch} from "@/store";
+import {useServer} from "@/hooks/useServer";
+
+const WelcomePage: React.FC = () => {
+ const theme = useTheme();
+ const navigate = useNavigate();
+ const dispatch = useAppDispatch();
+ const [logoDataUrl, setLogoDataUrl] = useState<string | null>(null);
+ const [isConnecting, setIsConnecting] = useState<boolean>(false);
+ const { isElectron, api } = useElectronIPC();
+ const { connectedCameraIds } = useServer();
+
+ // Track previous camera count to detect 0 -> >0 transition
+ const prevCountRef = useRef(connectedCameraIds.length);
+
+ useEffect(() => {
+ const prevCount = prevCountRef.current;
+ const currentCount = connectedCameraIds.length;
+
+ // Auto-navigate to cameras page only when first camera connects (0 -> >0 transition)
+ if (prevCount === 0 && currentCount > 0) {
+ navigate('/cameras');
+ }
+
+ prevCountRef.current = currentCount;
+ }, [connectedCameraIds, navigate]);
+
+ useEffect(() => {
+ const fetchLogo = async (): Promise<void> => {
+ try {
+ if (isElectron && api) {
+ // Use the new base64 method that returns a data URL
+ const dataUrl = await api.assets.getLogoBase64.query();
+ if (dataUrl) {
+ setLogoDataUrl(dataUrl);
+ } else {
+ console.warn('Logo image not found...');
+ }
+ }
+ } catch (error) {
+ console.error('Failed to load logo:', error);
+ }
+ };
+
+ fetchLogo();
+ }, [isElectron, api]);
+
+ const handleConnectCameras = async (): Promise<void> => {
+ setIsConnecting(true);
+ try {
+ await dispatch(connectRealtimePipeline()).unwrap();
+ // Navigation will happen automatically via the useEffect above
+ } catch (error) {
+ console.error('Error connecting to cameras:', error);
+ setIsConnecting(false);
+ }
+ };
+
+ return (
+ <Box sx={{
+ height: '100%',
+ width: '100%',
+ overflow: 'auto',
+ bgcolor: theme.palette.background.default,
+ }}>
+ <Container maxWidth="md" sx={{
+ minHeight: '100%',
+ width: '100%',
+ display: 'flex',
+ flexDirection: 'column',
+ justifyContent: 'center',
+ alignItems: 'center',
+ py: 1,
+ gap: 3
+ }}>
+ <Fade in={true} timeout={800}>
+ <Paper
+ elevation={6}
+ sx={{
+ p: { xs: 3, sm: 5 },
+ display: 'flex',
+ flexDirection: 'column',
+ alignItems: 'center',
+ width: '100%',
+ backgroundColor: theme.palette.background.paper,
+ mx: 'auto',
+ borderRadius: 3,
+ boxShadow: theme.palette.mode === 'dark'
+ ? '0 8px 32px rgba(0, 0, 0, 0.5)'
+ : '0 8px 32px rgba(0, 0, 0, 0.1)',
+ overflow: 'hidden',
+ position: 'relative',
+ }}
+ >
+ {/* Background accent */}
+ <Box sx={{
+ position: 'absolute',
+ top: 0,
+ left: 0,
+ width: '100%',
+ height: '8px',
+ background: `linear-gradient(90deg, ${theme.palette.primary.main}, ${theme.palette.secondary.main})`,
+ }} />
+
+ <Grow in={true} timeout={1000}>
+ <Box
+ sx={{
+ width: 240,
+ height: 240,
+ mb: 1,
+ display: 'flex',
+ justifyContent: 'center',
+ alignItems: 'center',
+ transition: 'transform 0.3s ease-in-out',
+ '&:hover': {
+ transform: 'scale(1.05)'
+ }
+ }}
+ >
+ {logoDataUrl && (
+ <img
+ src={logoDataUrl}
+ alt="FreeMoCap Logo"
+ style={{
+ maxWidth: '100%',
+ maxHeight: '100%',
+ objectFit: 'contain',
+ filter: theme.palette.mode === 'dark'
+ ? 'drop-shadow(0 0 10px rgba(255,255,255,0.2))'
+ : 'drop-shadow(0 0 10px rgba(0,0,0,0.1))'
+ }}
+ />
+ )}
+ </Box>
+ </Grow>
+
+ <Typography
+ variant="h3"
+ component="h1"
+ gutterBottom
+ sx={{
+ fontWeight: 'bold',
+ textAlign: 'center',
+ background: theme.palette.text.primary,
+ WebkitBackgroundClip: 'text',
+ WebkitTextFillColor: 'transparent',
+ backgroundClip: 'text',
+ mb: 1
+ }}
+ >
+ Welcome to FreeMoCap
+ </Typography>
+
+ <Typography
+ variant="subtitle1"
+ color="text.secondary"
+ sx={{
+ mb:2,
+ textAlign: 'center',
+ maxWidth: '80%',
+ fontSize: '1.1rem'
+ }}
+ >
+ Free and open source markerless motion capture for everyone.
+ </Typography>
+
+ <Button
+ variant="contained"
+ size="large"
+ onClick={handleConnectCameras}
+ disabled={isConnecting}
+ startIcon={isConnecting ? <CircularProgress size={20} color="inherit" /> : <VideocamIcon />}
+ sx={{
+ py: 2,
+ px: 6,
+ fontSize: '1.2rem',
+ fontWeight: 'bold',
+ borderRadius: 3,
+ textTransform: 'none',
+ boxShadow: theme.palette.mode === 'dark'
+ ? '0 4px 20px rgba(0, 0, 0, 0.5)'
+ : '0 4px 20px rgba(0, 0, 0, 0.15)',
+ // background: `linear-gradient(135deg, ${theme.palette.primary.main}, ${darken(theme.palette.secondary.main, 0.25)})`,
+ background: darken(theme.palette.secondary.main, 0.25),
+ transition: 'all 0.3s ease-in-out',
+ '&:hover': {
+ transform: 'translateY(-2px)',
+ boxShadow: theme.palette.mode === 'dark'
+ ? '0 6px 24px rgba(0, 0, 0, 0.6)'
+ : '0 6px 24px rgba(0, 0, 0, 0.2)',
+ },
+ '&:disabled': {
+ background: theme.palette.action.disabledBackground,
+ }
+ }}
+ >
+ {isConnecting ? 'Connecting...' : 'Connect Cameras'}
+ </Button>
+
+ <Box component="footer" sx={{ p: 3 }}>
+ <Footer />
+ </Box>
+ </Paper>
+ </Fade>
+
+ {/* Research Tool Disclaimer - Outside main clickable area */}
+ <Paper
+ elevation={1}
+ sx={{
+ p: 2.5,
+ width: '100%',
+ backgroundColor: theme.palette.mode === 'dark'
+ ? 'rgba(255, 255, 255, 0.03)'
+ : 'rgba(0, 0, 0, 0.02)',
+ borderRadius: 2,
+ }}
+ >
+ <Typography
+ variant="body2"
+ color="text.secondary"
+ sx={{
+ fontSize: '0.85rem',
+ lineHeight: 1.8,
+ '& a': {
+ color: theme.palette.mode === 'dark'
+ ? theme.palette.primary.light
+ : theme.palette.primary.main,
+ textDecoration: 'none',
+ fontWeight: 500,
+ transition: 'all 0.2s',
+ '&:hover': {
+ textDecoration: 'underline',
+ color: theme.palette.mode === 'dark'
+ ? theme.palette.primary.main
+ : theme.palette.primary.dark
+ }
+ }
+ }}
+ >
+ FreeMoCap is currently a research and educational tool, not cleared by the FDA for clinical use. Motion capture devices are regulated under{' '}
+ <MuiLink
+ href="https://www.ecfr.gov/current/title-21/chapter-I/subchapter-H/part-890"
+ target="_blank"
+ rel="noopener noreferrer"
+ onClick={(e: React.MouseEvent) => e.stopPropagation()}
+ >
+ 21 CFR Part 890 (Physical Medicine Devices)
+ </MuiLink>
+ {' '}and require{' '}
+ <MuiLink
+ href="https://www.fda.gov/medical-devices/premarket-submissions-selecting-and-preparing-correct-submission/premarket-notification-510k"
+ target="_blank"
+ rel="noopener noreferrer"
+ onClick={(e: React.MouseEvent) => e.stopPropagation()}
+ >
+ 510(k) clearance
+ </MuiLink>
+ {' '}for clinical applications.
+ <br />
+ <br />
+ <MuiLink
+ href="https://aaroncherian.github.io/freemocap_validation/"
+ target="_blank"
+ rel="noopener noreferrer"
+ onClick={(e: React.MouseEvent) => e.stopPropagation()}
+ >
+ - View our validation studies
+ </MuiLink>
+ <br />
+ <MuiLink
+ href="https://github.com/freemocap/freemocap_foundation/issues/32"
+ target="_blank"
+ rel="noopener noreferrer"
+ onClick={(e: React.MouseEvent) => e.stopPropagation()}
+ >
+ - Join our journey towards FDA certification
+ </MuiLink>
+ </Typography>
+ </Paper>
+ </Container>
+ </Box>
+ );
+};
+
+export default WelcomePage;
diff --git a/freemocap-ui-old/src/services/electron-ipc/electron-ipc-client.ts b/freemocap-ui-old/src/services/electron-ipc/electron-ipc-client.ts
new file mode 100644
index 00000000..087b27fc
--- /dev/null
+++ b/freemocap-ui-old/src/services/electron-ipc/electron-ipc-client.ts
@@ -0,0 +1,98 @@
+// src/hooks/electron-service/electron-ipc-client.ts
+import {createTRPCProxyClient} from '@trpc/client';
+import superjson from 'superjson';
+import type {AppAPI} from '../../../electron/main/api';
+
+// Type for the electron API exposed via preload
+interface ElectronAPI {
+ invoke: (path: string, input?: any) => Promise<any>;
+}
+
+declare global {
+ interface Window {
+ electronAPI: ElectronAPI;
+ }
+}
+
+// Observable-like class to satisfy tRPC requirements
+class IPCObservable<T> {
+ constructor(
+ private subscribeFn: (observer: {
+ next: (value: T) => void;
+ error: (error: any) => void;
+ complete: () => void;
+ }) => { unsubscribe: () => void }
+ ) {}
+
+ subscribe(observer: {
+ next: (value: T) => void;
+ error: (error: any) => void;
+ complete: () => void;
+ }) {
+ return this.subscribeFn(observer);
+ }
+
+ // Required pipe method for tRPC compatibility
+ pipe(..._operations: any[]): any {
+ // For IPC, we don't need complex piping, just return this
+ return this;
+ }
+}
+
+// Custom link for Electron IPC
+const createElectronLink = () => {
+ return () => {
+ return ({ op }: any) => {
+ return new IPCObservable((observer) => {
+ const execute = async () => {
+ try {
+ // Check if electronAPI is available
+ if (!window.electronAPI) {
+ throw new Error('Electron API not available');
+ }
+
+ // Call through the IPC bridge
+ const serializedResult = await window.electronAPI.invoke(
+ op.path,
+ op.input
+ );
+
+ // Deserialize the result
+ const result = superjson.deserialize(serializedResult);
+
+ observer.next({
+ result: {
+ type: 'data',
+ data: result,
+ },
+ });
+ observer.complete();
+ } catch (error) {
+ console.error(`IPC Error for ${op.path}:`, error);
+ observer.error(
+ error instanceof Error
+ ? error
+ : new Error(String(error))
+ );
+ }
+ };
+
+ // Execute the request
+ execute();
+
+ // Return unsubscribe function
+ return {
+ unsubscribe: () => {
+ // No-op for now, but could be used for cancellation
+ },
+ };
+ });
+ };
+ };
+};
+
+// Create the typed client - transformer moved to link if using newer tRPC
+export const electronIpcClient = createTRPCProxyClient<AppAPI>({
+ links: [createElectronLink()],
+});
+
diff --git a/freemocap-ui-old/src/services/electron-ipc/electron-ipc.ts b/freemocap-ui-old/src/services/electron-ipc/electron-ipc.ts
new file mode 100644
index 00000000..002d0a4a
--- /dev/null
+++ b/freemocap-ui-old/src/services/electron-ipc/electron-ipc.ts
@@ -0,0 +1,23 @@
+// Check if running in Electron
+import {electronIpcClient} from "@/services/electron-ipc/electron-ipc-client";
+// Type-safe wrapper hook for React components
+import {useMemo} from 'react';
+
+export const isElectron = (): boolean => {
+ return typeof window !== 'undefined' && !!window.electronAPI;
+};
+
+// Export the API client or null if not in Electron
+export const electronIpc = isElectron() ? electronIpcClient : null;
+
+export function useElectronIPC() {
+ const api = useMemo(() => {
+ if (!isElectron()) return null;
+ return electronIpcClient;
+ }, []);
+
+ return {
+ isElectron: isElectron(),
+ api,
+ };
+}
diff --git a/freemocap-ui-old/src/services/electron-ipc/index.ts b/freemocap-ui-old/src/services/electron-ipc/index.ts
new file mode 100644
index 00000000..d560975e
--- /dev/null
+++ b/freemocap-ui-old/src/services/electron-ipc/index.ts
@@ -0,0 +1,3 @@
+// services/index.ts
+export * from './electron-ipc'
+export * from './electron-ipc-client'
diff --git a/freemocap-ui-old/src/services/index.ts b/freemocap-ui-old/src/services/index.ts
new file mode 100644
index 00000000..7d4a9d34
--- /dev/null
+++ b/freemocap-ui-old/src/services/index.ts
@@ -0,0 +1,2 @@
+export * from './electron-ipc'
+export * from './server'
diff --git a/freemocap-ui-old/src/services/server/ServerContextProvider.tsx b/freemocap-ui-old/src/services/server/ServerContextProvider.tsx
new file mode 100644
index 00000000..1a557181
--- /dev/null
+++ b/freemocap-ui-old/src/services/server/ServerContextProvider.tsx
@@ -0,0 +1,361 @@
+import React, {createContext, ReactNode, useCallback, useEffect, useRef, useState} from 'react';
+import {useDispatch} from 'react-redux';
+import {AppDispatch} from '@/store/types';
+
+import {ConnectionState, WebSocketConnection} from "@/services/server/server-helpers/websocket-connection";
+import {FrameProcessor} from "@/services/server/server-helpers/frame-processor/frame-processor";
+import {CanvasManager} from "@/services/server/server-helpers/canvas-manager";
+import {
+ backendFramerateUpdated,
+ frontendFramerateUpdated,
+ logAdded,
+ serverSettingsCleared,
+ serverSettingsUpdated,
+} from '@/store';
+
+import {serverUrls} from "@/hooks/server-urls";
+import {CharucoObservation} from "@/services/server/server-helpers/image-overlay/charuco-types";
+import {OverlayManager} from "@/services/server/server-helpers/image-overlay/overlay-renderer-factory";
+import {MediapipeObservation} from "@/services/server/server-helpers/image-overlay/mediapipe-overlay-renderer";
+import {
+ arraysEqual, handleModelInfoUpdate,
+ isCharucoOverlayDataMessage, isFramerateUpdate, isLogRecord, isMediapipeOverlayDataMessage,
+ isSettingsStateMessage
+} from "@/services/server/server-helpers/websocket-message-types";
+import {RigidBodyPose} from "@/components/viewport3d/viewport3d-types";
+
+type FrameSubscriber = (bitmap: ImageBitmap) => void;
+type TrackedPointsSubscriber = (points: Map<string, Point3d>) => void;
+type RigidBodiesSubscriber = (poses: Map<string, RigidBodyPose>) => void;
+
+export interface Point3d {
+ x: number;
+ y: number;
+ z: number;
+}
+
+export interface ServerContextValue {
+ isConnected: boolean;
+ connectionState: ConnectionState;
+ connect: () => void;
+ disconnect: () => void;
+ send: (data: string | object) => void;
+ setCanvasForCamera: (cameraId: string, canvas: HTMLCanvasElement) => void;
+ getFps: (cameraId: string) => number | null;
+ connectedCameraIds: string[];
+ subscribeToFrames: (cameraId: string, callback: FrameSubscriber) => () => void;
+ subscribeToTrackedPoints: (callback: TrackedPointsSubscriber) => () => void;
+ getLatestTrackedPoints: () => Map<string, Point3d>;
+ subscribeToRigidBodies: (callback: RigidBodiesSubscriber) => () => void;
+}
+
+export const ServerContext = createContext<ServerContextValue | null>(null);
+
+export const ServerContextProvider: React.FC<{ children: ReactNode }> = ({children}) => {
+ const dispatch = useDispatch<AppDispatch>();
+
+ const [isConnected, setIsConnected] = useState<boolean>(false);
+ const [connectionState, setConnectionState] = useState<ConnectionState>(ConnectionState.DISCONNECTED);
+ const [connectedCameraIds, setConnectedCameraIds] = useState<string[]>([]);
+ // Tracks the port so the WebSocket connection is recreated when it changes.
+ // Updated via serverUrls.onPortChange() subscription.
+ const [serverPort, setServerPort] = useState<number>(serverUrls.getPort());
+
+ const wsConnectionRef = useRef<WebSocketConnection | null>(null);
+ const frameProcessorRef = useRef<FrameProcessor | null>(null);
+ const canvasManagerRef = useRef<CanvasManager | null>(null);
+ const overlayManagerRef = useRef<OverlayManager | null>(null);
+ const frameSubscribersRef = useRef<Map<string, Set<FrameSubscriber>>>(new Map());
+ const latestCharucoRef = useRef<Map<string, CharucoObservation>>(new Map());
+ const latestMediapipeRef = useRef<Map<string, MediapipeObservation>>(new Map());
+ const latestTrackedPoints = useRef<Map<string, Point3d>>(new Map());
+ const trackedPointsSubscribersRef = useRef<Set<TrackedPointsSubscriber>>(new Set());
+ const latestRigidBodies = useRef<Map<string, RigidBodyPose>>(new Map());
+ const rigidBodiesSubscribersRef = useRef<Set<RigidBodiesSubscriber>>(new Set());
+
+ // Subscribe to port changes from the serverUrls singleton.
+ // When useElectronAPI().pythonServer.start() resolves, it calls serverUrls.setPort(),
+ // which triggers this callback and causes the WebSocket to reconnect on the correct port.
+ useEffect(() => {
+ return serverUrls.onPortChange((port: number) => {
+ console.log(`[ServerContext] Port changed to ${port}, will recreate WebSocket connection`);
+ setServerPort(port);
+ });
+ }, []);
+
+ // Create / recreate the WebSocket connection whenever the port changes.
+ useEffect(() => {
+ if (wsConnectionRef.current) {
+ wsConnectionRef.current.disconnect();
+ }
+ canvasManagerRef.current?.terminateAllWorkers();
+ frameProcessorRef.current?.reset();
+
+ wsConnectionRef.current = new WebSocketConnection({
+ url: serverUrls.getWebSocketUrl(),
+ reconnectDelay: 1000,
+ maxReconnectAttempts: 5,
+ heartbeatInterval: 30000,
+ autoConnect: true,
+ autoConnectInterval: 3000,
+ });
+ frameProcessorRef.current = new FrameProcessor();
+ canvasManagerRef.current = new CanvasManager();
+ overlayManagerRef.current = new OverlayManager();
+
+ return () => {
+ if (wsConnectionRef.current) {
+ wsConnectionRef.current.disconnect();
+ }
+ if (canvasManagerRef.current) {
+ canvasManagerRef.current.terminateAllWorkers();
+ }
+ if (frameProcessorRef.current) {
+ frameProcessorRef.current.reset();
+ }
+ latestCharucoRef.current.clear();
+ latestMediapipeRef.current.clear();
+ latestTrackedPoints.current.clear();
+ trackedPointsSubscribersRef.current.clear();
+ latestRigidBodies.current.clear();
+ rigidBodiesSubscribersRef.current.clear();
+ };
+ }, [serverPort]);
+
+ useEffect(() => {
+ const ws = wsConnectionRef.current;
+ if (!ws) return;
+
+ const handleStateChange = (newState: ConnectionState, previousState: ConnectionState): void => {
+ const connected = newState === ConnectionState.CONNECTED;
+ console.log(`[WS] State transition: ${previousState} → ${newState} (connected=${connected})`);
+ setIsConnected(connected);
+ setConnectionState(newState);
+
+ if (previousState === ConnectionState.CONNECTED && !connected) {
+ console.log('[WS] Lost connection — clearing state');
+ canvasManagerRef.current?.terminateAllWorkers();
+ frameProcessorRef.current?.reset();
+ overlayManagerRef.current?.clearAll();
+ latestCharucoRef.current.clear();
+ latestMediapipeRef.current.clear();
+ latestTrackedPoints.current.clear();
+ setConnectedCameraIds([]);
+ dispatch(serverSettingsCleared());
+ latestRigidBodies.current.clear();
+ }
+ };
+
+ const handleMessage = async (event: MessageEvent): Promise<void> => {
+ if (event.data instanceof ArrayBuffer) {
+ try {
+ const result = await frameProcessorRef.current!.processFramePayload(event.data);
+ if (!result) return;
+
+ const {frames, cameraIds, frameNumbers} = result;
+
+ const currentCameraIds = Array.from(cameraIds).sort();
+ setConnectedCameraIds(prevIds => {
+ if (!arraysEqual(prevIds, currentCameraIds)) {
+ console.log(`Camera list updated: ${currentCameraIds.join(', ')}`);
+
+ const removedCameras = prevIds.filter(id => !cameraIds.has(id));
+ for (const cameraId of removedCameras) {
+ console.log(`Removing camera ${cameraId} - not in latest payload`);
+ canvasManagerRef.current?.terminateWorker(cameraId);
+ latestCharucoRef.current.delete(cameraId);
+ latestMediapipeRef.current.delete(cameraId);
+ }
+
+ return currentCameraIds;
+ }
+ return prevIds;
+ });
+
+ // Acknowledge receipt immediately so the backend can prepare
+ // the next frame without waiting for rendering to complete.
+ if (frameNumbers.size > 0) {
+ const maxFrameNumber = Math.max(...Array.from(frameNumbers));
+ ws.send({type: 'frameAcknowledgment', frameNumber: maxFrameNumber});
+ }
+
+ const overlayManager = overlayManagerRef.current!;
+ for (const frameData of frames) {
+ const charucoObservation = latestCharucoRef.current.get(frameData.cameraId) ?? null;
+ const mediapipeObservation = latestMediapipeRef.current.get(frameData.cameraId) ?? null;
+
+ let compositeBitmap: ImageBitmap;
+ if (charucoObservation || mediapipeObservation) {
+ compositeBitmap = await overlayManager.processFrame(
+ frameData.cameraId,
+ frameData.bitmap,
+ charucoObservation,
+ mediapipeObservation,
+ );
+ } else {
+ compositeBitmap = frameData.bitmap;
+ }
+
+ {
+ const subscribers = frameSubscribersRef.current.get(frameData.cameraId);
+ if (subscribers && subscribers.size > 0) {
+ for (const callback of subscribers) {
+ const clonedBitmap = await createImageBitmap(compositeBitmap);
+ callback(clonedBitmap);
+ }
+ }
+ }
+
+ canvasManagerRef.current!.sendFrameToWorker(
+ frameData.cameraId,
+ compositeBitmap,
+ );
+ }
+ } catch (error) {
+ console.error('Error processing frame:', error);
+ throw error;
+ }
+ } else if (typeof event.data === 'string') {
+ const text = event.data;
+
+ if (text === 'pong') {
+ return;
+ }
+ if (text.startsWith('ping')) {
+ ws.send('pong');
+ return;
+ }
+
+ const jsonData = JSON.parse(text);
+
+ if (isSettingsStateMessage(jsonData)) {
+ console.log(`[WS] Received settings/state v${jsonData.version}`, jsonData.settings);
+ dispatch(serverSettingsUpdated(jsonData));
+ } else if (isCharucoOverlayDataMessage(jsonData)) {
+ for (const [cameraId, observation] of Object.entries(jsonData)) {
+ latestCharucoRef.current.set(cameraId, observation as CharucoObservation);
+ }
+ } else if (isMediapipeOverlayDataMessage(jsonData)) {
+ for (const [cameraId, observation] of Object.entries(jsonData)) {
+ latestMediapipeRef.current.set(cameraId, observation as MediapipeObservation);
+ }
+ } else if ('model_info' in jsonData && jsonData.model_info) {
+ handleModelInfoUpdate(jsonData.model_info);
+ } else if ('tracked_points3d' in jsonData) {
+ latestTrackedPoints.current = new Map(Object.entries(jsonData.tracked_points3d));
+ for (const subscriber of trackedPointsSubscribersRef.current) {
+ subscriber(latestTrackedPoints.current);
+ }
+ } else if ('rigid_body_poses' in jsonData) {
+ latestRigidBodies.current = new Map(
+ Object.entries(jsonData.rigid_body_poses as Record<string, RigidBodyPose>)
+ );
+ for (const subscriber of rigidBodiesSubscribersRef.current) {
+ subscriber(latestRigidBodies.current);
+ }
+ } else if (isLogRecord(jsonData)) {
+ dispatch(logAdded(jsonData));
+ } else if (isFramerateUpdate(jsonData)) {
+ dispatch(backendFramerateUpdated(jsonData.backend_framerate));
+ dispatch(frontendFramerateUpdated(jsonData.frontend_framerate));
+ } else {
+ console.warn('[WS] Unhandled JSON message:', Object.keys(jsonData));
+ }
+ }
+ };
+
+ ws.on('state-change', handleStateChange);
+ ws.on('message', handleMessage);
+
+ // Start in auto-discovery mode — silently poll until the server appears
+ ws.startDiscovery();
+
+ return () => {
+ ws.off('state-change', handleStateChange);
+ ws.off('message', handleMessage);
+ ws.disconnect();
+ };
+ }, [dispatch, serverPort]);
+
+ const connect = useCallback((): void => {
+ wsConnectionRef.current?.connect();
+ }, []);
+
+ const disconnect = useCallback((): void => {
+ wsConnectionRef.current?.disconnect();
+ }, []);
+
+ const send = useCallback((data: string | object): void => {
+ wsConnectionRef.current?.send(data);
+ }, []);
+
+ const setCanvasForCamera = useCallback((cameraId: string, canvas: HTMLCanvasElement): void => {
+ canvasManagerRef.current?.setCanvasForCamera(cameraId, canvas);
+ }, []);
+
+ const getFps = useCallback((cameraId: string): number | null => {
+ return frameProcessorRef.current?.getFps(cameraId) ?? null;
+ }, []);
+
+ const subscribeToFrames = useCallback((cameraId: string, callback: FrameSubscriber): (() => void) => {
+ if (!frameSubscribersRef.current.has(cameraId)) {
+ frameSubscribersRef.current.set(cameraId, new Set());
+ }
+ frameSubscribersRef.current.get(cameraId)!.add(callback);
+
+ return () => {
+ const subscribers = frameSubscribersRef.current.get(cameraId);
+ subscribers?.delete(callback);
+ if (subscribers?.size === 0) {
+ frameSubscribersRef.current.delete(cameraId);
+ }
+ };
+ }, []);
+
+ const subscribeToTrackedPoints = useCallback((callback: TrackedPointsSubscriber): (() => void) => {
+ trackedPointsSubscribersRef.current.add(callback);
+
+ if (latestTrackedPoints.current.size > 0) {
+ callback(latestTrackedPoints.current);
+ }
+
+ return () => {
+ trackedPointsSubscribersRef.current.delete(callback);
+ };
+ }, []);
+
+ const getLatestTrackedPoints = useCallback((): Map<string, Point3d> => {
+ return latestTrackedPoints.current;
+ }, []);
+
+ const subscribeToRigidBodies = useCallback((callback: RigidBodiesSubscriber): (() => void) => {
+ rigidBodiesSubscribersRef.current.add(callback);
+
+ if (latestRigidBodies.current.size > 0) {
+ callback(latestRigidBodies.current);
+ }
+
+ return () => {
+ rigidBodiesSubscribersRef.current.delete(callback);
+ };
+ }, []);
+
+ return (
+ <ServerContext.Provider value={{
+ isConnected,
+ connectionState,
+ connect,
+ disconnect,
+ send,
+ setCanvasForCamera,
+ getFps,
+ connectedCameraIds,
+ subscribeToFrames,
+ subscribeToTrackedPoints,
+ getLatestTrackedPoints,
+ subscribeToRigidBodies,
+ }}>
+ {children}
+ </ServerContext.Provider>
+ );
+};
\ No newline at end of file
diff --git a/freemocap-ui-old/src/services/server/index.ts b/freemocap-ui-old/src/services/server/index.ts
new file mode 100644
index 00000000..8f1b48fe
--- /dev/null
+++ b/freemocap-ui-old/src/services/server/index.ts
@@ -0,0 +1,8 @@
+export * from './ServerContextProvider'
+export * from '@/services/server/server-helpers/frame-processor/binary-frame-parser'
+export * from './server-helpers/canvas-manager'
+export * from '@/services/server/server-helpers/frame-processor/frame-processor'
+export * from './server-helpers/offscreen-renderer.worker'
+export * from '../../hooks/server-urls'
+export * from './server-helpers/websocket-connection'
+export {useServer} from "@/hooks/useServer";
diff --git a/freemocap-ui-old/src/services/server/server-helpers/canvas-manager.ts b/freemocap-ui-old/src/services/server/server-helpers/canvas-manager.ts
new file mode 100644
index 00000000..921963b5
--- /dev/null
+++ b/freemocap-ui-old/src/services/server/server-helpers/canvas-manager.ts
@@ -0,0 +1,197 @@
+import {workerCode} from "@/services/server/server-helpers/offscreen-renderer.worker";
+
+export interface FrameData {
+ cameraId: string;
+ frameNumber: number;
+ bitmap: ImageBitmap;
+}
+
+export interface CanvasWorker {
+ worker: Worker;
+ canvas: HTMLCanvasElement;
+ initialized: boolean;
+}
+
+export class CanvasManager {
+ private workers: Map<string, CanvasWorker> = new Map();
+ private workerErrors: Map<string, number> = new Map();
+ private pendingCanvases: Map<string, HTMLCanvasElement> = new Map();
+ private renderCallbacks: Map<string, () => void> = new Map(); // cameraId -> callback
+ private readonly maxWorkerErrors: number = 3;
+
+ public setCanvasForCamera(cameraId: string, canvas: HTMLCanvasElement): boolean {
+ const existing = this.workers.get(cameraId);
+ if (existing?.canvas === canvas && existing.initialized) {
+ return true;
+ }
+
+ if (existing && existing.canvas !== canvas) {
+ console.log(`Canvas changed for camera ${cameraId}, recreating worker`);
+ this.terminateWorker(cameraId);
+ }
+
+ this.pendingCanvases.set(cameraId, canvas);
+
+ try {
+ const worker = this.createWorker(cameraId);
+ const offscreen = canvas.transferControlToOffscreen();
+
+ worker.postMessage(
+ { type: 'init', canvas: offscreen },
+ [offscreen]
+ );
+
+ this.workers.set(cameraId, {
+ worker,
+ canvas,
+ initialized: true
+ });
+
+ this.workerErrors.delete(cameraId);
+ this.pendingCanvases.delete(cameraId);
+
+ console.log(`Worker created for camera ${cameraId}`);
+ return true;
+
+ } catch (error) {
+ console.error(`Failed to create worker for camera ${cameraId}:`, error);
+ this.recordWorkerError(cameraId);
+ return false;
+ }
+ }
+
+ public sendFrameToWorker(
+ cameraId: string,
+ bitmap: ImageBitmap,
+ onRendered?: () => void
+ ): boolean {
+ const workerInfo = this.workers.get(cameraId);
+
+ if (!workerInfo?.initialized) {
+ const pendingCanvas = this.pendingCanvases.get(cameraId);
+ if (pendingCanvas) {
+ console.log(`Worker not ready for ${cameraId}, attempting to create from pending canvas`);
+ if (this.setCanvasForCamera(cameraId, pendingCanvas)) {
+ return this.sendFrameToWorker(cameraId, bitmap, onRendered);
+ }
+ }
+
+ console.warn(`No initialized worker for camera ${cameraId}, dropping frame`);
+ bitmap.close();
+ onRendered?.();
+ return false;
+ }
+
+ try {
+ // Store callback for this camera
+ if (onRendered) {
+ this.renderCallbacks.set(cameraId, onRendered);
+ }
+
+ workerInfo.worker.postMessage(
+ { type: 'frame', bitmap },
+ [bitmap]
+ );
+ return true;
+ } catch (error) {
+ console.error(`Failed to send frame to worker ${cameraId}:`, error);
+ bitmap.close();
+ onRendered?.();
+ this.recordWorkerError(cameraId);
+ return false;
+ }
+ }
+
+ public terminateWorker(cameraId: string): void {
+ const workerInfo = this.workers.get(cameraId);
+ if (workerInfo) {
+ try {
+ workerInfo.worker.terminate();
+ console.log(`Worker terminated for camera ${cameraId}`);
+ } catch (error) {
+ console.error(`Error terminating worker for ${cameraId}:`, error);
+ }
+ this.workers.delete(cameraId);
+ }
+
+ // Clean up callback
+ this.renderCallbacks.delete(cameraId);
+ this.pendingCanvases.delete(cameraId);
+ }
+
+ public terminateAllWorkers(): void {
+ console.log(`Terminating all workers (${this.workers.size} active)`);
+ for (const [cameraId] of this.workers) {
+ this.terminateWorker(cameraId);
+ }
+ this.workerErrors.clear();
+ this.pendingCanvases.clear();
+ this.renderCallbacks.clear();
+ }
+
+ public getActiveCameraIds(): string[] {
+ return Array.from(this.workers.keys());
+ }
+
+ public hasWorker(cameraId: string): boolean {
+ const worker = this.workers.get(cameraId);
+ return worker?.initialized ?? false;
+ }
+
+ private createWorker(cameraId: string): Worker {
+ const blob = new Blob([workerCode], { type: 'application/javascript' });
+ const workerUrl = URL.createObjectURL(blob);
+
+ try {
+ const worker = new Worker(workerUrl);
+
+ worker.onerror = (error) => {
+ console.error(`Worker error for camera ${cameraId}:`, error);
+ this.recordWorkerError(cameraId);
+ };
+
+ worker.onmessageerror = (error) => {
+ console.error(`Worker message error for camera ${cameraId}:`, error);
+ };
+
+ worker.onmessage = (e) => {
+ if (e.data.type === 'frameRendered') {
+ const callback = this.renderCallbacks.get(cameraId);
+ if (callback) {
+ callback();
+ this.renderCallbacks.delete(cameraId);
+ }
+ }
+ };
+
+ return worker;
+ } finally {
+ URL.revokeObjectURL(workerUrl);
+ }
+ }
+
+ private recordWorkerError(cameraId: string): void {
+ const errorCount = (this.workerErrors.get(cameraId) ?? 0) + 1;
+ this.workerErrors.set(cameraId, errorCount);
+
+ if (errorCount >= this.maxWorkerErrors) {
+ console.error(
+ `Worker for camera ${cameraId} has failed ${errorCount} times, disabling. ` +
+ `Worker will be recreated if canvas is set again.`
+ );
+ this.terminateWorker(cameraId);
+ }
+ }
+
+ public getWorkerStatus(cameraId: string): {
+ hasWorker: boolean;
+ errorCount: number;
+ hasPendingCanvas: boolean;
+ } {
+ return {
+ hasWorker: this.workers.has(cameraId),
+ errorCount: this.workerErrors.get(cameraId) ?? 0,
+ hasPendingCanvas: this.pendingCanvases.has(cameraId)
+ };
+ }
+}
diff --git a/freemocap-ui-old/src/services/server/server-helpers/frame-processor/binary-frame-parser.ts b/freemocap-ui-old/src/services/server/server-helpers/frame-processor/binary-frame-parser.ts
new file mode 100644
index 00000000..e75eeeb3
--- /dev/null
+++ b/freemocap-ui-old/src/services/server/server-helpers/frame-processor/binary-frame-parser.ts
@@ -0,0 +1,251 @@
+// binary-frame-parser.ts
+import {
+ FRAME_HEADER_FIELDS,
+ FRAME_HEADER_SIZE,
+ MESSAGE_TYPE,
+ PAYLOAD_FOOTER_FIELDS,
+ PAYLOAD_FOOTER_SIZE,
+ PAYLOAD_HEADER_FIELDS,
+ PAYLOAD_HEADER_SIZE,
+} from './binary-protocol';
+
+export interface ParsedFrame {
+ cameraId: string;
+ cameraIndex: number;
+ frameNumber: number;
+ width: number;
+ height: number;
+ colorChannels: number;
+ bitmap: ImageBitmap;
+}
+
+// Single reusable TextDecoder
+const sharedTextDecoder = new TextDecoder();
+
+// Optimized ImageBitmap options for camera feeds
+const BITMAP_OPTIONS: ImageBitmapOptions = {
+ premultiplyAlpha: 'none',
+ colorSpaceConversion: 'none',
+ resizeQuality: 'pixelated'
+};
+
+/**
+ * Parse an ASCII string field from the buffer (16-byte fixed-length camera_id)
+ */
+function parseAsciiField(view: DataView, baseOffset: number, fieldOffset: number, size: number): string {
+ const offset = baseOffset + fieldOffset;
+
+ // Find actual string length (until null terminator)
+ let length = 0;
+ while (length < size && view.getUint8(offset + length) !== 0) {
+ length++;
+ }
+
+ if (length === 0) return '';
+
+ const bytes = new Uint8Array(view.buffer, view.byteOffset + offset, length);
+ return sharedTextDecoder.decode(bytes);
+}
+
+/**
+ * Parse a multi-frame payload from binary data
+ * Matches the Python create_frontend_payload function's output format
+ */
+export async function parseMultiFramePayload(
+ data: ArrayBuffer
+): Promise<ParsedFrame[] | null> {
+ const view = new DataView(data);
+
+ // Validate minimum size
+ if (data.byteLength < PAYLOAD_HEADER_SIZE) {
+ console.warn(`Payload too small: ${data.byteLength} bytes`);
+ return null;
+ }
+
+ // Validate payload header
+ const messageType = view.getUint8(PAYLOAD_HEADER_FIELDS.message_type.offset);
+ if (messageType !== MESSAGE_TYPE.PAYLOAD_HEADER) {
+ console.warn(`Invalid payload header: expected ${MESSAGE_TYPE.PAYLOAD_HEADER}, got ${messageType}`);
+ return null;
+ }
+
+ // Extract payload header fields
+ const frameNumber = Number(
+ view.getBigInt64(PAYLOAD_HEADER_FIELDS.frame_number.offset, true)
+ );
+
+ const numCameras = view.getInt32(
+ PAYLOAD_HEADER_FIELDS.number_of_cameras.offset,
+ true
+ );
+
+ // Validate camera count
+ if (numCameras <= 0 ) {
+ console.warn(`Invalid camera count: ${numCameras}`);
+ return null;
+ }
+
+ // Pre-allocate array for frame metadata
+ const frameMetadata: Array<{
+ cameraId: string;
+ cameraIndex: number;
+ frameNumber: number;
+ width: number;
+ height: number;
+ colorChannels: number;
+ jpegStart: number;
+ jpegLength: number;
+ }> = new Array(numCameras);
+
+ let currentOffset = PAYLOAD_HEADER_SIZE;
+ let validFrameCount = 0;
+
+ // Parse each frame header
+ for (let i = 0; i < numCameras; i++) {
+ // Check if we have enough bytes for the frame header
+ if (currentOffset + FRAME_HEADER_SIZE > data.byteLength) {
+ console.warn(`Not enough bytes for frame header at offset ${currentOffset}`);
+ break;
+ }
+
+ // Validate frame header message type
+ const frameMessageType = view.getUint8(
+ currentOffset + FRAME_HEADER_FIELDS.message_type.offset
+ );
+
+ if (frameMessageType !== MESSAGE_TYPE.FRAME_METADATA) {
+ console.warn(
+ `Invalid frame header at offset ${currentOffset}: ` +
+ `expected ${MESSAGE_TYPE.FRAME_METADATA}, got ${frameMessageType}`
+ );
+ break;
+ }
+
+ // Extract frame number
+ const frameNum = Number(
+ view.getBigInt64(
+ currentOffset + FRAME_HEADER_FIELDS.frame_number.offset,
+ true
+ )
+ );
+
+ // Extract camera_id (16-byte ASCII string)
+ const cameraId = parseAsciiField(
+ view,
+ currentOffset,
+ FRAME_HEADER_FIELDS.camera_id.offset,
+ FRAME_HEADER_FIELDS.camera_id.size
+ );
+
+ // Extract camera_index
+ const cameraIndex = view.getInt32(
+ currentOffset + FRAME_HEADER_FIELDS.camera_index.offset,
+ true
+ );
+
+ // Extract image metadata
+ const width = view.getInt32(
+ currentOffset + FRAME_HEADER_FIELDS.image_width.offset,
+ true
+ );
+
+ const height = view.getInt32(
+ currentOffset + FRAME_HEADER_FIELDS.image_height.offset,
+ true
+ );
+
+ const colorChannels = view.getInt32(
+ currentOffset + FRAME_HEADER_FIELDS.color_channels.offset,
+ true
+ );
+
+ const jpegLength = view.getInt32(
+ currentOffset + FRAME_HEADER_FIELDS.jpeg_string_length.offset,
+ true
+ );
+
+ // Validate JPEG length
+ if (jpegLength <= 0 ) {
+ console.warn(`Invalid JPEG length: ${jpegLength}`);
+ break;
+ }
+
+ // Check if we have enough bytes for the JPEG data
+ const jpegStart = currentOffset + FRAME_HEADER_SIZE;
+ if (jpegStart + jpegLength > data.byteLength) {
+ console.warn(
+ `Not enough bytes for JPEG data: need ${jpegLength} bytes ` +
+ `at offset ${jpegStart}, but buffer only has ${data.byteLength} bytes`
+ );
+ break;
+ }
+
+ // Store metadata
+ frameMetadata[validFrameCount] = {
+ cameraId: cameraId,
+ cameraIndex: cameraIndex,
+ frameNumber: frameNum,
+ width: width,
+ height: height,
+ colorChannels: colorChannels,
+ jpegStart: jpegStart,
+ jpegLength: jpegLength
+ };
+
+ validFrameCount++;
+ currentOffset += FRAME_HEADER_SIZE + jpegLength;
+ }
+
+ if (validFrameCount === 0) {
+ console.warn('No valid frames found in payload');
+ return null;
+ }
+
+ // Optional: Validate footer if present
+ if (currentOffset + PAYLOAD_FOOTER_SIZE <= data.byteLength) {
+ const footerMessageType = view.getUint8(currentOffset + PAYLOAD_FOOTER_FIELDS.message_type.offset);
+ if (footerMessageType === MESSAGE_TYPE.PAYLOAD_FOOTER) {
+ const footerFrameNumber = Number(
+ view.getBigInt64(currentOffset + PAYLOAD_FOOTER_FIELDS.frame_number.offset, true)
+ );
+ const footerNumCameras = view.getInt32(
+ currentOffset + PAYLOAD_FOOTER_FIELDS.number_of_cameras.offset,
+ true
+ );
+
+ if (footerFrameNumber !== frameNumber || footerNumCameras !== numCameras) {
+ console.warn(
+ `Footer mismatch: header(frame=${frameNumber}, cameras=${numCameras}) ` +
+ `footer(frame=${footerFrameNumber}, cameras=${footerNumCameras})`
+ );
+ }
+ }
+ }
+
+ // Trim array to actual size.
+ frameMetadata.length = validFrameCount;
+
+ // Create ImageBitmaps in parallel
+ const bitmapPromises = frameMetadata.map(async (metadata) => {
+ try {
+ const jpegData = new Uint8Array(data, metadata.jpegStart, metadata.jpegLength);
+ const blob = new Blob([jpegData], { type: 'image/jpeg' });
+ const bitmap = await createImageBitmap(blob, BITMAP_OPTIONS);
+
+ return {
+ cameraId: metadata.cameraId,
+ cameraIndex: metadata.cameraIndex,
+ frameNumber: metadata.frameNumber,
+ width: metadata.width,
+ height: metadata.height,
+ colorChannels: metadata.colorChannels,
+ bitmap: bitmap,
+ } as ParsedFrame;
+ } catch (error) {
+ console.error(`Failed to create bitmap for camera ${metadata.cameraId}:`, error);
+ throw error;
+ }
+ });
+
+ return Promise.all(bitmapPromises);
+}
diff --git a/freemocap-ui-old/src/services/server/server-helpers/frame-processor/binary-protocol.ts b/freemocap-ui-old/src/services/server/server-helpers/frame-processor/binary-protocol.ts
new file mode 100644
index 00000000..a6d625af
--- /dev/null
+++ b/freemocap-ui-old/src/services/server/server-helpers/frame-processor/binary-protocol.ts
@@ -0,0 +1,78 @@
+// binary-protocol.ts
+/**
+ * Binary protocol definition for frame payloads
+ * Matches the Python FRONTEND_PAYLOAD_HEADER_FOOTER_DTYPE and FRONTEND_FRAME_HEADER_DTYPE
+ * WITH align=True (includes padding for natural alignment)
+ * All offsets and sizes are in bytes
+ */
+
+// Message type constants (matches Python MessageType class)
+export const MESSAGE_TYPE = {
+ PAYLOAD_HEADER: 0,
+ FRAME_METADATA: 1,
+ PAYLOAD_FOOTER: 2,
+} as const;
+
+// Field sizes (in bytes)
+const FIELD_SIZES = {
+ // Primitive types
+ U1: 1, // unsigned 8-bit
+ I4: 4, // signed 32-bit integer
+ I8: 8, // signed 64-bit integer
+ S16: 16, // 16-byte ASCII string (for camera_id)
+} as const;
+
+// Payload header structure (matches FRONTEND_PAYLOAD_HEADER_FOOTER_DTYPE with align=True)
+// Structure with padding:
+// message_type (1 byte) + padding (7 bytes) + frame_number (8 bytes) + number_of_cameras (4 bytes) + padding (4 bytes)
+export const PAYLOAD_HEADER_FIELDS = {
+ message_type: { offset: 0, size: FIELD_SIZES.U1, type: 'uint8' },
+ // 7 bytes padding here for 8-byte alignment of frame_number
+ frame_number: { offset: 8, size: FIELD_SIZES.I8, type: 'int64' },
+ number_of_cameras: { offset: 16, size: FIELD_SIZES.I4, type: 'int32' },
+ // 4 bytes padding here for struct alignment
+} as const;
+
+export const PAYLOAD_HEADER_SIZE = 24; // Total: 1 + 7 padding + 8 + 4 + 4 padding
+
+// Frame header structure (matches FRONTEND_FRAME_HEADER_DTYPE with align=True)
+// Structure with padding:
+// message_type (1 byte) + padding (7 bytes) + frame_number (8 bytes) + camera_id (16 bytes) +
+// camera_index (4 bytes) + image_width (4 bytes) + image_height (4 bytes) +
+// color_channels (4 bytes) + jpeg_string_length (4 bytes) + padding (4 bytes)
+export const FRAME_HEADER_FIELDS = {
+ message_type: { offset: 0, size: FIELD_SIZES.U1, type: 'uint8' },
+ // 7 bytes padding here for 8-byte alignment of frame_number
+ frame_number: { offset: 8, size: FIELD_SIZES.I8, type: 'int64' },
+ camera_id: { offset: 16, size: FIELD_SIZES.S16, type: 'ascii' },
+ camera_index: { offset: 32, size: FIELD_SIZES.I4, type: 'int32' },
+ image_width: { offset: 36, size: FIELD_SIZES.I4, type: 'int32' },
+ image_height: { offset: 40, size: FIELD_SIZES.I4, type: 'int32' },
+ color_channels: { offset: 44, size: FIELD_SIZES.I4, type: 'int32' },
+ jpeg_string_length: { offset: 48, size: FIELD_SIZES.I4, type: 'int32' },
+ // 4 bytes padding here for struct alignment
+} as const;
+
+export const FRAME_HEADER_SIZE = 56; // Total: 1 + 7 padding + 8 + 16 + 4 + 4 + 4 + 4 + 4 + 4 padding
+
+// Payload footer structure (matches FRONTEND_PAYLOAD_HEADER_FOOTER_DTYPE with align=True)
+export const PAYLOAD_FOOTER_FIELDS = {
+ message_type: { offset: 0, size: FIELD_SIZES.U1, type: 'uint8' },
+ // 7 bytes padding here for 8-byte alignment of frame_number
+ frame_number: { offset: 8, size: FIELD_SIZES.I8, type: 'int64' },
+ number_of_cameras: { offset: 16, size: FIELD_SIZES.I4, type: 'int32' },
+ // 4 bytes padding here for struct alignment
+} as const;
+
+export const PAYLOAD_FOOTER_SIZE = 24; // Total: 1 + 7 padding + 8 + 4 + 4 padding
+
+// Helper type definitions
+export type FieldType = 'uint8' | 'int32' | 'int64' | 'ascii';
+
+export interface FieldDefinition {
+ offset: number;
+ size: number;
+ type: FieldType;
+}
+
+export type MessageType = typeof MESSAGE_TYPE[keyof typeof MESSAGE_TYPE];
diff --git a/freemocap-ui-old/src/services/server/server-helpers/frame-processor/frame-processor.ts b/freemocap-ui-old/src/services/server/server-helpers/frame-processor/frame-processor.ts
new file mode 100644
index 00000000..089a2526
--- /dev/null
+++ b/freemocap-ui-old/src/services/server/server-helpers/frame-processor/frame-processor.ts
@@ -0,0 +1,78 @@
+// frame-processor.ts
+import {
+ ParsedFrame,
+ parseMultiFramePayload
+} from "@/services/server/server-helpers/frame-processor/binary-frame-parser";
+
+export interface FrameData {
+ cameraId: string;
+ cameraIndex: number;
+ frameNumber: number;
+ width: number;
+ height: number;
+ colorChannels: number;
+ bitmap: ImageBitmap;
+}
+
+export interface ProcessedFrameResult {
+ frames: FrameData[];
+ cameraIds: Set<string>;
+ frameNumbers: Set<number>;
+}
+
+export class FrameProcessor {
+ private lastFrameTime: Map<string, number> = new Map();
+ private currentFps: Map<string, number> = new Map();
+
+ public async processFramePayload(data: ArrayBuffer): Promise<ProcessedFrameResult | null> {
+ try {
+ const parsedFrames = await parseMultiFramePayload(data);
+ if (!parsedFrames) {
+ console.warn('Failed to parse frame payload');
+ return null;
+ }
+
+ const cameraIds = new Set<string>();
+ const frameNumbers = new Set<number>();
+
+ // Convert ParsedFrame to FrameData (they have the same structure now)
+ const frames: FrameData[] = parsedFrames.map((frame: ParsedFrame) => ({
+ cameraId: frame.cameraId,
+ cameraIndex: frame.cameraIndex,
+ frameNumber: frame.frameNumber,
+ width: frame.width,
+ height: frame.height,
+ colorChannels: frame.colorChannels,
+ bitmap: frame.bitmap
+ }));
+
+ for (const frame of frames) {
+ cameraIds.add(frame.cameraId);
+ frameNumbers.add(frame.frameNumber);
+
+ // Track frame timing and calculate FPS
+ const now = performance.now();
+ const lastTime = this.lastFrameTime.get(frame.cameraId);
+ if (lastTime) {
+ const fps = 1000 / (now - lastTime);
+ this.currentFps.set(frame.cameraId, fps);
+ }
+ this.lastFrameTime.set(frame.cameraId, now);
+ }
+
+ return { frames, cameraIds, frameNumbers };
+ } catch (error) {
+ console.error('Error processing frame payload:', error);
+ throw new Error(`Frame processing failed: ${error}`);
+ }
+ }
+
+ public getFps(cameraId: string): number | null {
+ return this.currentFps.get(cameraId) ?? null;
+ }
+
+ public reset(): void {
+ this.lastFrameTime.clear();
+ this.currentFps.clear();
+ }
+}
diff --git a/freemocap-ui-old/src/services/server/server-helpers/frame_compositor.ts b/freemocap-ui-old/src/services/server/server-helpers/frame_compositor.ts
new file mode 100644
index 00000000..50486d2c
--- /dev/null
+++ b/freemocap-ui-old/src/services/server/server-helpers/frame_compositor.ts
@@ -0,0 +1,216 @@
+import {ArucoMarker, CharucoObservation, CharucoPoint} from "@/services/server/server-helpers/charuco_types";
+
+/**
+ * Composites overlay graphics directly onto an ImageBitmap.
+ * Returns a new ImageBitmap with the overlay drawn on top.
+ */
+export class FrameCompositor {
+ private offscreenCanvas: OffscreenCanvas;
+ private ctx: OffscreenCanvasRenderingContext2D;
+
+ // Style constants
+ private readonly CHARUCO_COLOR = '#00FF00';
+ private readonly CHARUCO_STROKE = '#009600';
+ private readonly ARUCO_COLOR = '#FF6400';
+ private readonly ARUCO_STROKE = '#C85000';
+ private readonly TEXT_COLOR = '#ccc';
+ private readonly TEXT_STROKE = '#111';
+ private readonly INFO_BG = 'rgba(0, 0, 0, 0.7)';
+ private readonly SCALE: number = 1.0;
+
+ constructor() {
+ // Create a reusable offscreen canvas for compositing
+ this.offscreenCanvas = new OffscreenCanvas(1, 1);
+ const ctx = this.offscreenCanvas.getContext('2d', {
+ alpha: true,
+ desynchronized: true,
+ });
+
+ if (!ctx) {
+ throw new Error('Failed to get 2D context for compositor');
+ }
+
+ this.ctx = ctx;
+ }
+
+ /**
+ * Composite overlay onto an ImageBitmap and return a new ImageBitmap
+ */
+ public async compositeFrame(
+ sourceBitmap: ImageBitmap,
+ observation: CharucoObservation | null,
+ ): Promise<ImageBitmap> {
+ const { width, height } = sourceBitmap;
+
+ // Resize canvas if needed
+ if (this.offscreenCanvas.width !== width || this.offscreenCanvas.height !== height) {
+ this.offscreenCanvas.width = width;
+ this.offscreenCanvas.height = height;
+ }
+
+ // Draw source image
+ this.ctx.clearRect(0, 0, width, height);
+ this.ctx.drawImage(sourceBitmap, 0, 0);
+
+ // Draw overlay if we have observation data
+ if (observation) {
+ this.drawOverlay(observation);
+ }
+
+ // Create new bitmap from composited result
+ const compositeBitmap = await createImageBitmap(this.offscreenCanvas);
+
+ // Close the source bitmap since we're done with it
+ sourceBitmap.close();
+
+ return compositeBitmap;
+ }
+
+ private drawOverlay(observation: CharucoObservation): void {
+ this.ctx.save();
+ this.ctx.scale(this.SCALE, this.SCALE);
+
+ // Draw ArUco markers (behind Charuco corners)
+ this.drawArucoMarkers(observation.aruco_markers);
+
+ // Draw Charuco corners
+ this.drawCharucoCorners(observation.charuco_corners);
+
+ // Draw info overlay
+ this.drawInfoOverlay(observation);
+
+ this.ctx.restore();
+ }
+
+ private drawCharucoCorners(corners: CharucoPoint[]): void {
+ if (corners.length === 0) return;
+
+ for (const corner of corners) {
+ // Draw filled circle
+ this.ctx.fillStyle = this.CHARUCO_COLOR;
+ this.ctx.beginPath();
+ this.ctx.arc(corner.x, corner.y, 5, 0, Math.PI * 2);
+ this.ctx.fill();
+
+ // Draw stroke
+ this.ctx.strokeStyle = this.CHARUCO_STROKE;
+ this.ctx.lineWidth = 2;
+ this.ctx.stroke();
+
+ // Draw ID label
+ this.drawText(
+ corner.id.toString(),
+ corner.x + 8,
+ corner.y - 8,
+ 10,
+ this.CHARUCO_COLOR,
+ this.TEXT_STROKE,
+ 2
+ );
+ }
+ }
+
+ private drawArucoMarkers(markers: ArucoMarker[]): void {
+ if (markers.length === 0) return;
+
+ for (const marker of markers) {
+ // Draw marker outline
+ this.ctx.strokeStyle = this.ARUCO_COLOR;
+ this.ctx.lineWidth = 3;
+ this.ctx.beginPath();
+
+ // Draw square connecting the 4 corners
+ this.ctx.moveTo(marker.corners[0][0], marker.corners[0][1]);
+ for (let i = 1; i < 4; i++) {
+ this.ctx.lineTo(marker.corners[i][0], marker.corners[i][1]);
+ }
+ this.ctx.closePath();
+ this.ctx.stroke();
+
+ // Draw corner points
+ this.ctx.fillStyle = this.ARUCO_COLOR;
+ for (const corner of marker.corners) {
+ this.ctx.beginPath();
+ this.ctx.arc(corner[0], corner[1], 4, 0, Math.PI * 2);
+ this.ctx.fill();
+ }
+
+ // Draw marker ID at center
+ const centerX = marker.corners.reduce((sum, c) => sum + c[0], 0) / marker.corners.length;
+ const centerY = marker.corners.reduce((sum, c) => sum + c[1], 0) / marker.corners.length;
+
+ this.drawText(
+ marker.id.toString(),
+ centerX,
+ centerY,
+ 14,
+ this.TEXT_COLOR,
+ this.ARUCO_COLOR,
+ 3,
+ 'bold'
+ );
+ }
+ }
+
+ private drawInfoOverlay(observation: CharucoObservation): void {
+ const { metadata, frame_number } = observation;
+
+ // Info text
+ const infoText =
+ `Frame: ${frame_number} | ` +
+ `Charuco: ${metadata.n_charuco_detected}/${metadata.n_charuco_total} | ` +
+ `ArUco: ${metadata.n_aruco_detected}/${metadata.n_aruco_total}` +
+ (metadata.has_pose ? ' | POSE ✓' : '');
+
+ // Status text
+ let statusText = '';
+ let statusColor = '';
+ if (metadata.n_charuco_detected === 0 && metadata.n_aruco_detected === 0) {
+ statusText = '⚠ NO BOARD DETECTED';
+ statusColor = '#FF4444';
+ } else if (metadata.n_charuco_detected < 4) {
+ statusText = '⚠ INSUFFICIENT CORNERS';
+ statusColor = '#FFAA00';
+ } else {
+ statusText = '✓ BOARD DETECTED';
+ statusColor = '#00FF00';
+ }
+
+ // Draw info background
+ this.ctx.fillStyle = this.INFO_BG;
+ this.ctx.fillRect(5, 5, 500, 60);
+
+ // Draw info text
+ this.drawText(infoText, 10, 25, 14, this.TEXT_COLOR, this.TEXT_STROKE, 2);
+
+ // Draw status text
+ this.drawText(statusText, 10, 50, 16, statusColor, this.TEXT_STROKE, 2);
+ }
+
+ private drawText(
+ text: string,
+ x: number,
+ y: number,
+ fontSize: number,
+ fillColor: string,
+ strokeColor: string,
+ strokeWidth: number,
+ fontWeight: string = 'normal'
+ ): void {
+ this.ctx.font = `${fontWeight} ${fontSize}px Arial, sans-serif`;
+ this.ctx.textBaseline = 'middle';
+
+ // Draw stroke (outline)
+ this.ctx.strokeStyle = strokeColor;
+ this.ctx.lineWidth = strokeWidth + 2;
+ this.ctx.strokeText(text, x, y);
+
+ // Draw fill
+ this.ctx.fillStyle = fillColor;
+ this.ctx.fillText(text, x, y);
+ }
+
+ public destroy(): void {
+ // Cleanup if needed
+ }
+}
diff --git a/freemocap-ui-old/src/services/server/server-helpers/image-overlay/charuco-overlay-renderer.ts b/freemocap-ui-old/src/services/server/server-helpers/image-overlay/charuco-overlay-renderer.ts
new file mode 100644
index 00000000..6416d25f
--- /dev/null
+++ b/freemocap-ui-old/src/services/server/server-helpers/image-overlay/charuco-overlay-renderer.ts
@@ -0,0 +1,184 @@
+// charuco-overlay-renderer.ts
+
+import {
+ BaseOverlayRenderer,
+ DrawStyle,
+ Point2D
+} from "@/services/server/server-helpers/image-overlay/image-overlay-system";
+import {
+ ArucoMarker,
+ CharucoObservation,
+ CharucoPoint
+} from "@/services/server/server-helpers/image-overlay/charuco-types";
+
+export class CharucoOverlayRenderer extends BaseOverlayRenderer {
+ // Charuco-specific styles
+ private readonly charucoStyle: DrawStyle = {
+ pointColor: '#00FF00',
+ pointStroke: '#009600',
+ pointRadius: 5,
+ lineColor: '#00FF00',
+ lineWidth: 2,
+ labelColor: '#00FF00',
+ labelStroke: this.TEXT_STROKE,
+ labelFontSize: 10,
+ showLabels: true,
+ };
+
+ private readonly arucoStyle: DrawStyle = {
+ pointColor: '#FF6400',
+ pointStroke: '#C85000',
+ pointRadius: 4,
+ lineColor: '#FF6400',
+ lineWidth: 3,
+ labelColor: this.TEXT_COLOR,
+ labelStroke: '#FF6400',
+ labelFontSize: 14,
+ showLabels: true,
+ };
+
+ /**
+ * Composite charuco overlay onto frame
+ */
+ public async compositeFrame(
+ sourceBitmap: ImageBitmap,
+ observation: CharucoObservation | null,
+ ): Promise<ImageBitmap> {
+ this.prepareCanvas(sourceBitmap);
+
+ if (observation) {
+ this.drawCharucoOverlay(observation);
+ }
+
+ return this.createBitmap(sourceBitmap);
+ }
+
+ private drawCharucoOverlay(observation: CharucoObservation): void {
+ this.ctx.save();
+
+ // Draw ArUco markers first (behind Charuco corners)
+ this.drawArucoMarkers(observation.aruco_markers);
+
+ // Draw Charuco corners
+ this.drawCharucoCorners(observation.charuco_corners);
+
+ // Draw segments if model info is available
+ if (this.modelInfo) {
+ this.drawCharucoSegments(observation.charuco_corners);
+ }
+
+ // Draw info overlay
+ this.drawCharucoInfo(observation);
+
+ this.ctx.restore();
+ }
+
+ private drawCharucoCorners(corners: CharucoPoint[]): void {
+ if (corners.length === 0) return;
+
+ // Convert CharucoPoint[] to Point2D[]
+ const points: Point2D[] = corners.map(corner => ({
+ x: corner.x,
+ y: corner.y,
+ id: corner.id,
+ }));
+
+ this.drawPoints(points, this.charucoStyle);
+ }
+
+ private drawCharucoSegments(corners: CharucoPoint[]): void {
+ if (!this.modelInfo || corners.length === 0) return;
+
+ // Create a map of corner ID to Point2D
+ const pointMap = new Map<string | number, Point2D>();
+ for (const corner of corners) {
+ pointMap.set(corner.id.toString(), {
+ x: corner.x,
+ y: corner.y,
+ id: corner.id,
+ });
+ }
+
+ // Get segments from model info
+ const bodyAspect = this.modelInfo.aspects['body'];
+ if (bodyAspect?.segment_connections) {
+ this.drawSegments(pointMap, bodyAspect.segment_connections, {
+ ...this.charucoStyle,
+ lineColor: 'rgba(0, 255, 0, 0.5)', // Semi-transparent green
+ lineWidth: 1,
+ });
+ }
+ }
+
+ private drawArucoMarkers(markers: ArucoMarker[]): void {
+ if (markers.length === 0) return;
+
+ for (const marker of markers) {
+ this.drawPolygon(
+ marker.corners,
+ this.arucoStyle,
+ true,
+ marker.id.toString()
+ );
+ }
+ }
+
+ private drawCharucoInfo(observation: CharucoObservation): void {
+ const { metadata, frame_number } = observation;
+
+ // Build status info
+ let statusText = '';
+ let statusColor = '';
+ if (metadata.n_charuco_detected === 0 && metadata.n_aruco_detected === 0) {
+ statusText = '⚠ NO BOARD DETECTED';
+ statusColor = '#FF4444';
+ } else if (metadata.n_charuco_detected < 4) {
+ statusText = '⚠ INSUFFICIENT CORNERS';
+ statusColor = '#FFAA00';
+ } else {
+ statusText = '✔ BOARD DETECTED';
+ statusColor = '#00FF00';
+ }
+
+ const additionalInfo = [
+ `Charuco: ${metadata.n_charuco_detected}/${metadata.n_charuco_total} | ` +
+ `ArUco: ${metadata.n_aruco_detected}/${metadata.n_aruco_total}` +
+ (metadata.has_pose ? ' | POSE ✔' : ''),
+ statusText,
+ ];
+
+ // Draw background and info
+ this.ctx.fillStyle = this.INFO_BG;
+ this.ctx.fillRect(5, 5, 500, 85);
+
+ this.drawText(
+ `Frame: ${frame_number}`,
+ 10,
+ 25,
+ 14,
+ this.TEXT_COLOR,
+ this.TEXT_STROKE,
+ 2
+ );
+
+ this.drawText(
+ additionalInfo[0],
+ 10,
+ 50,
+ 14,
+ this.TEXT_COLOR,
+ this.TEXT_STROKE,
+ 2
+ );
+
+ this.drawText(
+ additionalInfo[1],
+ 10,
+ 75,
+ 16,
+ statusColor,
+ this.TEXT_STROKE,
+ 2
+ );
+ }
+}
diff --git a/freemocap-ui-old/src/services/server/server-helpers/image-overlay/charuco-types.ts b/freemocap-ui-old/src/services/server/server-helpers/image-overlay/charuco-types.ts
new file mode 100644
index 00000000..74fa788a
--- /dev/null
+++ b/freemocap-ui-old/src/services/server/server-helpers/image-overlay/charuco-types.ts
@@ -0,0 +1,43 @@
+import {z} from 'zod';
+
+// Zod schemas for CharucoObservation data
+export const CharucoPointSchema = z.object({
+ id: z.number(),
+ x: z.number(),
+ y: z.number(),
+});
+
+export const ArucoMarkerSchema = z.object({
+ id: z.number(),
+ corners: z.array(z.tuple([z.number(), z.number()])).length(4),
+});
+
+export const CharucoMetadataSchema = z.object({
+ n_charuco_detected: z.number(),
+ n_charuco_total: z.number(),
+ n_aruco_detected: z.number(),
+ n_aruco_total: z.number(),
+ has_pose: z.boolean(),
+ image_width: z.number(),
+ image_height: z.number(),
+});
+
+// Schema for a single camera's charuco observation
+export const CharucoOverlaySchema = z.object({
+ message_type: z.literal("charuco_overlay"),
+ camera_id: z.string(),
+ frame_number: z.number(),
+ charuco_corners: z.array(CharucoPointSchema),
+ aruco_markers: z.array(ArucoMarkerSchema),
+ metadata: CharucoMetadataSchema,
+});
+
+// Schema for the websocket message containing multiple camera observations
+// Structure: { "camera_1": {...}, "camera_2": {...}, ... }
+export const CharucoOverlayDataMessageSchema = z.record(z.string(), CharucoOverlaySchema);
+
+// Type exports
+export type CharucoPoint = z.infer<typeof CharucoPointSchema>;
+export type ArucoMarker = z.infer<typeof ArucoMarkerSchema>;
+export type CharucoObservation = z.infer<typeof CharucoOverlaySchema>;
+export type CharucoOverlayDataMessage = z.infer<typeof CharucoOverlayDataMessageSchema>;
diff --git a/freemocap-ui-old/src/services/server/server-helpers/image-overlay/image-overlay-system.ts b/freemocap-ui-old/src/services/server/server-helpers/image-overlay/image-overlay-system.ts
new file mode 100644
index 00000000..f0fe2b21
--- /dev/null
+++ b/freemocap-ui-old/src/services/server/server-helpers/image-overlay/image-overlay-system.ts
@@ -0,0 +1,303 @@
+// base-overlay-renderer.ts
+import { z } from 'zod';
+
+// Generic types for any observation
+export interface Point2D {
+ x: number;
+ y: number;
+ id?: string | number;
+ visibility?: number; // 0-1, for confidence/visibility
+}
+
+export interface Segment {
+ proximal: string | number;
+ distal: string | number;
+}
+
+export interface ModelInfo {
+ name: string;
+ tracker_name: string;
+ aspects: Record<string, AspectInfo>;
+ order: string[];
+}
+
+export interface AspectInfo {
+ tracked_points: {
+ type: 'list' | 'generated';
+ names?: string[];
+ convention?: string;
+ count?: number;
+ };
+ segment_connections?: Record<string, Segment>;
+ joint_hierarchy?: Record<string, string[]>;
+}
+
+export interface DrawStyle {
+ pointColor: string;
+ pointStroke: string;
+ pointRadius: number;
+ lineColor: string;
+ lineWidth: number;
+ labelColor: string;
+ labelStroke: string;
+ labelFontSize: number;
+ showLabels: boolean;
+}
+
+export interface ObservationMetadata {
+ frame_number: number;
+ [key: string]: any; // Allow additional metadata
+}
+
+export abstract class BaseOverlayRenderer {
+ protected offscreenCanvas: OffscreenCanvas;
+ protected ctx: OffscreenCanvasRenderingContext2D;
+ protected modelInfo: ModelInfo | null = null;
+
+ // Common style constants
+ protected readonly INFO_BG = 'rgba(0, 0, 0, 0.7)';
+ protected readonly TEXT_COLOR = '#ccc';
+ protected readonly TEXT_STROKE = '#111';
+
+ constructor() {
+ this.offscreenCanvas = new OffscreenCanvas(1, 1);
+ const ctx = this.offscreenCanvas.getContext('2d', {
+ alpha: true,
+ desynchronized: true,
+ });
+
+ if (!ctx) {
+ throw new Error('Failed to get 2D context for overlay renderer');
+ }
+
+ this.ctx = ctx;
+ }
+
+ /**
+ * Set the model info for this renderer
+ */
+ public setModelInfo(modelInfo: ModelInfo): void {
+ this.modelInfo = modelInfo;
+ }
+
+ /**
+ * Main composite method - to be implemented by specific renderers
+ */
+ public abstract compositeFrame(
+ sourceBitmap: ImageBitmap,
+ observation: any | null,
+ ): Promise<ImageBitmap>;
+
+ /**
+ * Resize canvas if needed and draw source image
+ */
+ protected prepareCanvas(sourceBitmap: ImageBitmap): void {
+ const { width, height } = sourceBitmap;
+
+ if (this.offscreenCanvas.width !== width || this.offscreenCanvas.height !== height) {
+ this.offscreenCanvas.width = width;
+ this.offscreenCanvas.height = height;
+ }
+
+ this.ctx.clearRect(0, 0, width, height);
+ this.ctx.drawImage(sourceBitmap, 0, 0);
+ }
+
+ /**
+ * Generic method to draw points
+ */
+ protected drawPoints(
+ points: Point2D[],
+ style: DrawStyle
+ ): void {
+ for (const point of points) {
+ // Skip invalid points
+ if (!this.isValidPoint(point)) continue;
+
+ // Optional visibility threshold
+ if (point.visibility !== undefined && point.visibility < 0.5) continue;
+
+ // Draw filled circle
+ this.ctx.fillStyle = style.pointColor;
+ this.ctx.beginPath();
+ this.ctx.arc(point.x, point.y, style.pointRadius, 0, Math.PI * 2);
+ this.ctx.fill();
+
+ // Draw stroke
+ this.ctx.strokeStyle = style.pointStroke;
+ this.ctx.lineWidth = 2;
+ this.ctx.stroke();
+
+ // Draw label if enabled
+ if (style.showLabels && point.id !== undefined) {
+ this.drawText(
+ point.id.toString(),
+ point.x + style.pointRadius + 3,
+ point.y - style.pointRadius - 3,
+ style.labelFontSize,
+ style.labelColor,
+ style.labelStroke,
+ 2
+ );
+ }
+ }
+ }
+
+ /**
+ * Generic method to draw segments/connections between points
+ */
+ protected drawSegments(
+ points: Map<string | number, Point2D>,
+ segments: Record<string, Segment>,
+ style: DrawStyle
+ ): void {
+ for (const [_, segment] of Object.entries(segments)) {
+ const proximalPoint = points.get(segment.proximal);
+ const distalPoint = points.get(segment.distal);
+
+ if (!proximalPoint || !distalPoint) continue;
+ if (!this.isValidPoint(proximalPoint) || !this.isValidPoint(distalPoint)) continue;
+
+ // Draw line
+ this.ctx.strokeStyle = style.lineColor;
+ this.ctx.lineWidth = style.lineWidth;
+ this.ctx.beginPath();
+ this.ctx.moveTo(proximalPoint.x, proximalPoint.y);
+ this.ctx.lineTo(distalPoint.x, distalPoint.y);
+ this.ctx.stroke();
+ }
+ }
+
+ /**
+ * Generic method to draw a polygon (like ArUco markers)
+ */
+ protected drawPolygon(
+ corners: [number, number][],
+ style: DrawStyle,
+ fillPoints: boolean = true,
+ label?: string
+ ): void {
+ if (corners.length < 3) return;
+
+ // Draw outline
+ this.ctx.strokeStyle = style.lineColor;
+ this.ctx.lineWidth = style.lineWidth;
+ this.ctx.beginPath();
+ this.ctx.moveTo(corners[0][0], corners[0][1]);
+ for (let i = 1; i < corners.length; i++) {
+ this.ctx.lineTo(corners[i][0], corners[i][1]);
+ }
+ this.ctx.closePath();
+ this.ctx.stroke();
+
+ // Draw corner points if requested
+ if (fillPoints) {
+ this.ctx.fillStyle = style.pointColor;
+ for (const corner of corners) {
+ this.ctx.beginPath();
+ this.ctx.arc(corner[0], corner[1], style.pointRadius, 0, Math.PI * 2);
+ this.ctx.fill();
+ }
+ }
+
+ // Draw label at center if provided
+ if (label) {
+ const centerX = corners.reduce((sum, c) => sum + c[0], 0) / corners.length;
+ const centerY = corners.reduce((sum, c) => sum + c[1], 0) / corners.length;
+
+ this.drawText(
+ label,
+ centerX,
+ centerY,
+ style.labelFontSize * 1.2,
+ this.TEXT_COLOR,
+ style.pointColor,
+ 3,
+ 'bold'
+ );
+ }
+ }
+
+ /**
+ * Draw text with stroke (outline)
+ */
+ protected drawText(
+ text: string,
+ x: number,
+ y: number,
+ fontSize: number,
+ fillColor: string,
+ strokeColor: string,
+ strokeWidth: number,
+ fontWeight: string = 'normal'
+ ): void {
+ this.ctx.font = `${fontWeight} ${fontSize}px Arial, sans-serif`;
+ this.ctx.textBaseline = 'middle';
+
+ // Draw stroke (outline)
+ this.ctx.strokeStyle = strokeColor;
+ this.ctx.lineWidth = strokeWidth + 2;
+ this.ctx.strokeText(text, x, y);
+
+ // Draw fill
+ this.ctx.fillStyle = fillColor;
+ this.ctx.fillText(text, x, y);
+ }
+
+ /**
+ * Draw info overlay with metadata
+ */
+ protected drawInfoOverlay(
+ metadata: ObservationMetadata,
+ additionalInfo?: string[]
+ ): void {
+ const lines: string[] = [
+ `Frame: ${metadata.frame_number}`,
+ ...(additionalInfo || [])
+ ];
+
+ // Calculate background size
+ const lineHeight = 25;
+ const bgHeight = lines.length * lineHeight + 10;
+ const bgWidth = 500;
+
+ // Draw background
+ this.ctx.fillStyle = this.INFO_BG;
+ this.ctx.fillRect(5, 5, bgWidth, bgHeight);
+
+ // Draw lines
+ let y = 25;
+ for (const line of lines) {
+ this.drawText(line, 10, y, 14, this.TEXT_COLOR, this.TEXT_STROKE, 2);
+ y += lineHeight;
+ }
+ }
+
+ /**
+ * Check if a point is valid (not NaN or undefined)
+ */
+ protected isValidPoint(point: Point2D): boolean {
+ return (
+ point &&
+ typeof point.x === 'number' &&
+ typeof point.y === 'number' &&
+ !isNaN(point.x) &&
+ !isNaN(point.y) &&
+ isFinite(point.x) &&
+ isFinite(point.y)
+ );
+ }
+
+ /**
+ * Create final bitmap from canvas
+ */
+ protected async createBitmap(sourceBitmap: ImageBitmap): Promise<ImageBitmap> {
+ const compositeBitmap = await createImageBitmap(this.offscreenCanvas);
+ sourceBitmap.close();
+ return compositeBitmap;
+ }
+
+ public destroy(): void {
+ // Cleanup if needed
+ }
+}
\ No newline at end of file
diff --git a/freemocap-ui-old/src/services/server/server-helpers/image-overlay/mediapipe-overlay-renderer.ts b/freemocap-ui-old/src/services/server/server-helpers/image-overlay/mediapipe-overlay-renderer.ts
new file mode 100644
index 00000000..59d6ddbc
--- /dev/null
+++ b/freemocap-ui-old/src/services/server/server-helpers/image-overlay/mediapipe-overlay-renderer.ts
@@ -0,0 +1,471 @@
+// mediapipe-overlay-renderer.ts
+
+import {
+ BaseOverlayRenderer,
+ DrawStyle,
+ Point2D
+} from "@/services/server/server-helpers/image-overlay/image-overlay-system";
+
+export interface MediapipePoint {
+ name: string;
+ x: number;
+ y: number;
+ z?: number;
+ visibility?: number;
+}
+
+export interface MediapipeObservation {
+ message_type: 'mediapipe_overlay';
+ camera_id: string;
+ frame_number: number;
+ body_points?: MediapipePoint[];
+ right_hand_points?: MediapipePoint[];
+ left_hand_points?: MediapipePoint[];
+ face_points?: MediapipePoint[];
+ metadata: {
+ image_width: number;
+ image_height: number;
+ n_body_detected: number;
+ n_right_hand_detected: number;
+ n_left_hand_detected: number;
+ n_face_detected: number;
+ };
+}
+
+export class MediapipeOverlayRenderer extends BaseOverlayRenderer {
+ // Body styles split by side
+ private readonly bodyStyleCenter: DrawStyle = {
+ pointColor: '#00AA00',
+ pointStroke: '#008800',
+ pointRadius: 4,
+ lineColor: 'rgba(20, 255, 20, 0.6)',
+ lineWidth: 2,
+ labelColor: '#00AA00',
+ labelStroke: this.TEXT_STROKE,
+ labelFontSize: 8,
+ showLabels: false,
+ };
+
+ private readonly bodyStyleRight: DrawStyle = {
+ pointColor: '#FF4444',
+ pointStroke: '#AA0000',
+ pointRadius: 4,
+ lineColor: 'rgba(255, 68, 68, 0.6)',
+ lineWidth: 2,
+ labelColor: '#FF4444',
+ labelStroke: this.TEXT_STROKE,
+ labelFontSize: 8,
+ showLabels: false,
+ };
+
+ private readonly bodyStyleLeft: DrawStyle = {
+ pointColor: '#4488FF',
+ pointStroke: '#0044AA',
+ pointRadius: 4,
+ lineColor: 'rgba(68, 136, 255, 0.6)',
+ lineWidth: 2,
+ labelColor: '#4488FF',
+ labelStroke: this.TEXT_STROKE,
+ labelFontSize: 8,
+ showLabels: false,
+ };
+
+ private readonly rightHandStyle: DrawStyle = {
+ pointColor: '#FF6400',
+ pointStroke: '#AA4400',
+ pointRadius: 3,
+ lineColor: '#FF6400',
+ lineWidth: 1.5,
+ labelColor: '#FF6400',
+ labelStroke: this.TEXT_STROKE,
+ labelFontSize: 8,
+ showLabels: false,
+ };
+
+ private readonly leftHandStyle: DrawStyle = {
+ pointColor: '#00AAFF',
+ pointStroke: '#0066AA',
+ pointRadius: 3,
+ lineColor: '#00AAFF',
+ lineWidth: 1.5,
+ labelColor: '#00AAFF',
+ labelStroke: this.TEXT_STROKE,
+ labelFontSize: 8,
+ showLabels: false,
+ };
+
+ private readonly faceStyle: DrawStyle = {
+ pointColor: '#FFD700',
+ pointStroke: '#AA9900',
+ pointRadius: 1,
+ lineColor: '#FFD700',
+ lineWidth: 1,
+ labelColor: '#FFD700',
+ labelStroke: this.TEXT_STROKE,
+ labelFontSize: 6,
+ showLabels: false,
+ };
+
+ /**
+ * Composite mediapipe overlay onto frame
+ */
+ public async compositeFrame(
+ sourceBitmap: ImageBitmap,
+ observation: MediapipeObservation | null,
+ ): Promise<ImageBitmap> {
+ this.prepareCanvas(sourceBitmap);
+
+ if (observation) {
+ this.drawMediapipeOverlay(observation);
+ }
+
+ return this.createBitmap(sourceBitmap);
+ }
+
+ private drawMediapipeOverlay(observation: MediapipeObservation): void {
+ this.ctx.save();
+
+ // Draw each aspect in order (face behind, body in middle, hands on top)
+ if (observation.face_points) {
+ this.drawFaceAspect(observation.face_points);
+ }
+
+ if (observation.body_points) {
+ this.drawBodyAspect(observation.body_points);
+ }
+
+ if (observation.right_hand_points) {
+ this.drawHandAspect(observation.right_hand_points, 'right_hand', this.rightHandStyle);
+ }
+
+ if (observation.left_hand_points) {
+ this.drawHandAspect(observation.left_hand_points, 'left_hand', this.leftHandStyle);
+ }
+
+ // Draw info overlay
+ this.drawMediapipeInfo(observation);
+
+ this.ctx.restore();
+ }
+
+ private getBodySide(name: string): 'left' | 'right' | 'center' {
+ if (name.includes('left')) return 'left';
+ if (name.includes('right')) return 'right';
+ return 'center';
+ }
+
+ private getBodyStyleForSide(side: 'left' | 'right' | 'center'): DrawStyle {
+ switch (side) {
+ case 'left': return this.bodyStyleLeft;
+ case 'right': return this.bodyStyleRight;
+ case 'center': return this.bodyStyleCenter;
+ }
+ }
+
+ private drawBodyAspect(points: MediapipePoint[]): void {
+ if (points.length === 0) return;
+
+ // Create point map for segment drawing
+ const pointMap = new Map<string | number, Point2D>();
+ const leftPoints: Point2D[] = [];
+ const rightPoints: Point2D[] = [];
+ const centerPoints: Point2D[] = [];
+
+ for (const point of points) {
+ const point2D: Point2D = {
+ x: point.x,
+ y: point.y,
+ id: point.name,
+ visibility: point.visibility,
+ };
+ pointMap.set(point.name, point2D);
+
+ const side = this.getBodySide(point.name);
+ if (side === 'left') leftPoints.push(point2D);
+ else if (side === 'right') rightPoints.push(point2D);
+ else centerPoints.push(point2D);
+ }
+
+ // Draw body skeleton connections (behind points)
+ this.drawBodyConnections(pointMap);
+
+ // Draw points on top, color-coded by side
+ this.drawPoints(leftPoints, this.bodyStyleLeft);
+ this.drawPoints(rightPoints, this.bodyStyleRight);
+ this.drawPoints(centerPoints, this.bodyStyleCenter);
+
+ // Highlight key points with labels
+ this.drawKeyBodyPoints(pointMap);
+ }
+
+ private drawKeyBodyPoints(pointMap: Map<string | number, Point2D>): void {
+ // Label only important landmarks for clarity
+ const keyPoints = ['body.nose', 'body.left_shoulder', 'body.right_shoulder', 'body.left_hip', 'body.right_hip'];
+
+ for (const key of keyPoints) {
+ const point = pointMap.get(key);
+ if (point && this.isValidPoint(point)) {
+ const style = this.getBodyStyleForSide(this.getBodySide(key));
+ this.drawText(
+ key.replace('body.', '').replace('_', ' '),
+ point.x + 5,
+ point.y - 5,
+ 8,
+ style.labelColor,
+ style.labelStroke,
+ 1
+ );
+ }
+ }
+ }
+
+ private drawBodyConnections(
+ pointMap: Map<string | number, Point2D>,
+ ): void {
+ // Connections grouped by side for color coding
+ const centerConnections = [
+ ['body.nose', 'body.left_eye_inner'],
+ ['body.nose', 'body.right_eye_inner'],
+ ['body.mouth_left', 'body.mouth_right'],
+ ['body.left_shoulder', 'body.right_shoulder'],
+ ['body.left_hip', 'body.right_hip'],
+ ];
+
+ const leftConnections = [
+ ['body.left_eye_inner', 'body.left_eye'],
+ ['body.left_eye', 'body.left_eye_outer'],
+ ['body.left_eye_outer', 'body.left_ear'],
+ ['body.left_shoulder', 'body.left_hip'],
+ ['body.left_shoulder', 'body.left_elbow'],
+ ['body.left_elbow', 'body.left_wrist'],
+ ['body.left_wrist', 'body.left_pinky'],
+ ['body.left_wrist', 'body.left_index'],
+ ['body.left_wrist', 'body.left_thumb'],
+ ['body.left_index', 'body.left_pinky'],
+ ['body.left_hip', 'body.left_knee'],
+ ['body.left_knee', 'body.left_ankle'],
+ ['body.left_ankle', 'body.left_heel'],
+ ['body.left_heel', 'body.left_foot_index'],
+ ['body.left_ankle', 'body.left_foot_index'],
+ ];
+
+ const rightConnections = [
+ ['body.right_eye_inner', 'body.right_eye'],
+ ['body.right_eye', 'body.right_eye_outer'],
+ ['body.right_eye_outer', 'body.right_ear'],
+ ['body.right_shoulder', 'body.right_hip'],
+ ['body.right_shoulder', 'body.right_elbow'],
+ ['body.right_elbow', 'body.right_wrist'],
+ ['body.right_wrist', 'body.right_pinky'],
+ ['body.right_wrist', 'body.right_index'],
+ ['body.right_wrist', 'body.right_thumb'],
+ ['body.right_index', 'body.right_pinky'],
+ ['body.right_hip', 'body.right_knee'],
+ ['body.right_knee', 'body.right_ankle'],
+ ['body.right_ankle', 'body.right_heel'],
+ ['body.right_heel', 'body.right_foot_index'],
+ ['body.right_ankle', 'body.right_foot_index'],
+ ];
+
+ const groups: [string[][], DrawStyle][] = [
+ [centerConnections, this.bodyStyleCenter],
+ [leftConnections, this.bodyStyleLeft],
+ [rightConnections, this.bodyStyleRight],
+ ];
+
+ for (const [connections, style] of groups) {
+ for (const [start, end] of connections) {
+ const startPoint = pointMap.get(start);
+ const endPoint = pointMap.get(end);
+
+ if (startPoint && endPoint && this.isValidPoint(startPoint) && this.isValidPoint(endPoint)) {
+ this.ctx.strokeStyle = style.lineColor;
+ this.ctx.lineWidth = style.lineWidth;
+ this.ctx.beginPath();
+ this.ctx.moveTo(startPoint.x, startPoint.y);
+ this.ctx.lineTo(endPoint.x, endPoint.y);
+ this.ctx.stroke();
+ }
+ }
+ }
+ }
+
+ private drawHandAspect(
+ points: MediapipePoint[],
+ aspectName: string,
+ style: DrawStyle
+ ): void {
+ if (points.length === 0) return;
+
+ const pointMap = new Map<string | number, Point2D>();
+ const point2DArray: Point2D[] = [];
+
+ for (const point of points) {
+ const point2D: Point2D = {
+ x: point.x,
+ y: point.y,
+ id: point.name,
+ visibility: point.visibility,
+ };
+ pointMap.set(point.name, point2D);
+ point2DArray.push(point2D);
+ }
+
+ // Draw hand skeleton connections
+ this.drawHandConnections(pointMap, style);
+
+ // Draw points
+ this.drawPoints(point2DArray, style);
+ }
+
+ private drawHandConnections(
+ pointMap: Map<string | number, Point2D>,
+ style: DrawStyle
+ ): void {
+ // Define hand connections (MediaPipe hand landmark connections)
+ const handConnections = [
+ // Thumb
+ ['wrist', 'thumb_cmc'],
+ ['thumb_cmc', 'thumb_mcp'],
+ ['thumb_mcp', 'thumb_ip'],
+ ['thumb_ip', 'thumb_tip'],
+ // Index finger
+ ['wrist', 'index_finger_mcp'],
+ ['index_finger_mcp', 'index_finger_pip'],
+ ['index_finger_pip', 'index_finger_dip'],
+ ['index_finger_dip', 'index_finger_tip'],
+ // Middle finger
+ ['wrist', 'middle_finger_mcp'],
+ ['middle_finger_mcp', 'middle_finger_pip'],
+ ['middle_finger_pip', 'middle_finger_dip'],
+ ['middle_finger_dip', 'middle_finger_tip'],
+ // Ring finger
+ ['wrist', 'ring_finger_mcp'],
+ ['ring_finger_mcp', 'ring_finger_pip'],
+ ['ring_finger_pip', 'ring_finger_dip'],
+ ['ring_finger_dip', 'ring_finger_tip'],
+ // Pinky
+ ['wrist', 'pinky_mcp'],
+ ['pinky_mcp', 'pinky_pip'],
+ ['pinky_pip', 'pinky_dip'],
+ ['pinky_dip', 'pinky_tip'],
+ // Palm connections
+ ['index_finger_mcp', 'middle_finger_mcp'],
+ ['middle_finger_mcp', 'ring_finger_mcp'],
+ ['ring_finger_mcp', 'pinky_mcp'],
+ ];
+
+ for (const [start, end] of handConnections) {
+ const startPoint = pointMap.get(start);
+ const endPoint = pointMap.get(end);
+
+ if (startPoint && endPoint && this.isValidPoint(startPoint) && this.isValidPoint(endPoint)) {
+ this.ctx.strokeStyle = style.lineColor;
+ this.ctx.lineWidth = style.lineWidth;
+ this.ctx.beginPath();
+ this.ctx.moveTo(startPoint.x, startPoint.y);
+ this.ctx.lineTo(endPoint.x, endPoint.y);
+ this.ctx.stroke();
+ }
+ }
+ }
+
+ private drawFaceAspect(points: MediapipePoint[]): void {
+ if (points.length === 0) return;
+
+ // For face, we just draw the points as a mesh without connections
+ // (too many points to draw connections clearly)
+ const point2DArray: Point2D[] = points.map(point => ({
+ x: point.x,
+ y: point.y,
+ id: point.name,
+ visibility: point.visibility,
+ }));
+
+ this.drawPoints(point2DArray, this.faceStyle);
+
+ // Draw face contour highlights for key features
+ this.drawFaceContour(points);
+ }
+
+ private drawFaceContour(points: MediapipePoint[]): void {
+ // Draw simplified face contour for better visibility
+ // This would use the face contour indices from the model info
+ // For now, just highlight key face points
+ const keyFacePoints = points.filter(p =>
+ p.name.includes('eye') ||
+ p.name.includes('mouth') ||
+ p.name.includes('nose')
+ );
+
+ const highlightStyle = {
+ ...this.faceStyle,
+ pointRadius: 2,
+ pointColor: '#FFFF00',
+ };
+
+ this.drawPoints(
+ keyFacePoints.map(p => ({
+ x: p.x,
+ y: p.y,
+ id: p.name,
+ visibility: p.visibility,
+ })),
+ highlightStyle
+ );
+ }
+
+ private drawMediapipeInfo(observation: MediapipeObservation): void {
+ const { metadata, frame_number } = observation;
+
+ // Build detection status
+ const detections: string[] = [];
+ if (metadata.n_body_detected > 0) detections.push('Body');
+ if (metadata.n_right_hand_detected > 0) detections.push('R-Hand');
+ if (metadata.n_left_hand_detected > 0) detections.push('L-Hand');
+ if (metadata.n_face_detected > 0) detections.push('Face');
+
+ const statusText = detections.length > 0
+ ? `✔ Detected: ${detections.join(', ')}`
+ : '⚠ No detection';
+
+ const statusColor = detections.length > 0 ? '#00FF00' : '#FF4444';
+
+ // Draw info background
+ this.ctx.fillStyle = this.INFO_BG;
+ this.ctx.fillRect(5, 5, 500, 85);
+
+ // Draw frame info
+ this.drawText(
+ `Frame: ${frame_number}`,
+ 10,
+ 25,
+ 14,
+ this.TEXT_COLOR,
+ this.TEXT_STROKE,
+ 2
+ );
+
+ // Draw detection counts
+ this.drawText(
+ `Body: ${metadata.n_body_detected} | Hands: ${metadata.n_right_hand_detected + metadata.n_left_hand_detected} | Face: ${metadata.n_face_detected > 0 ? '✔' : '✗'}`,
+ 10,
+ 50,
+ 14,
+ this.TEXT_COLOR,
+ this.TEXT_STROKE,
+ 2
+ );
+
+ // Draw status
+ this.drawText(
+ statusText,
+ 10,
+ 75,
+ 16,
+ statusColor,
+ this.TEXT_STROKE,
+ 2
+ );
+ }
+}
\ No newline at end of file
diff --git a/freemocap-ui-old/src/services/server/server-helpers/image-overlay/mediapipe-types.ts b/freemocap-ui-old/src/services/server/server-helpers/image-overlay/mediapipe-types.ts
new file mode 100644
index 00000000..2bf9d74e
--- /dev/null
+++ b/freemocap-ui-old/src/services/server/server-helpers/image-overlay/mediapipe-types.ts
@@ -0,0 +1,41 @@
+import z from "zod";
+
+// Individual point schema
+export const MediapipePointSchema = z.object({
+ name: z.string(),
+ x: z.number(),
+ y: z.number(),
+ z: z.number(),
+ visibility: z.number(),
+});
+
+// Metadata schema
+export const MediapipeMetadataSchema = z.object({
+ n_body_detected: z.number(),
+ n_right_hand_detected: z.number(),
+ n_left_hand_detected: z.number(),
+ n_face_detected: z.number(),
+ image_width: z.number(),
+ image_height: z.number(),
+});
+
+// Single camera observation schema
+export const MediapipeOverlaySchema = z.object({
+ message_type: z.literal("mediapipe_overlay"),
+ camera_id: z.string(),
+ frame_number: z.number(),
+ body_points: z.array(MediapipePointSchema),
+ right_hand_points: z.array(MediapipePointSchema),
+ left_hand_points: z.array(MediapipePointSchema),
+ face_points: z.array(MediapipePointSchema),
+ metadata: MediapipeMetadataSchema,
+});
+
+// Multi-camera message schema (matches CharucoOverlayDataMessage structure)
+export const MediapipeOverlayDataMessageSchema = z.record(z.string(), MediapipeOverlaySchema);
+
+// Type exports
+export type MediapipePoint = z.infer<typeof MediapipePointSchema>;
+export type MediapipeMetadata = z.infer<typeof MediapipeMetadataSchema>;
+export type MediapipeObservation = z.infer<typeof MediapipeOverlaySchema>;
+export type MediapipeOverlayDataMessage = z.infer<typeof MediapipeOverlayDataMessageSchema>;
diff --git a/freemocap-ui-old/src/services/server/server-helpers/image-overlay/overlay-renderer-factory.ts b/freemocap-ui-old/src/services/server/server-helpers/image-overlay/overlay-renderer-factory.ts
new file mode 100644
index 00000000..060463b3
--- /dev/null
+++ b/freemocap-ui-old/src/services/server/server-helpers/image-overlay/overlay-renderer-factory.ts
@@ -0,0 +1,145 @@
+// overlay-renderer-factory.ts
+import { CharucoOverlayRenderer } from './charuco-overlay-renderer';
+import { MediapipeOverlayRenderer, MediapipeObservation } from './mediapipe-overlay-renderer';
+import {BaseOverlayRenderer, ModelInfo} from "@/services/server/server-helpers/image-overlay/image-overlay-system";
+import {CharucoObservation} from "@/services/server/server-helpers/image-overlay/charuco-types";
+
+export type ObservationType = 'charuco_overlay' | 'mediapipe_overlay' | 'rtmpose_overlay';
+
+
+/**
+ * Factory for creating appropriate overlay renderers based on observation type
+ */
+export class OverlayRendererFactory {
+ private static rendererCache: Map<ObservationType, BaseOverlayRenderer> = new Map();
+ private static modelInfoCache: Map<string, ModelInfo> = new Map();
+
+ /**
+ * Get or create a renderer for the specified observation type
+ */
+ public static getRenderer(type: ObservationType): BaseOverlayRenderer {
+ // Check cache first
+ let renderer = this.rendererCache.get(type);
+ if (renderer) {
+ return renderer;
+ }
+
+ // Create new renderer based on type
+ switch (type) {
+ case 'charuco_overlay':
+ renderer = new CharucoOverlayRenderer();
+ break;
+ case 'mediapipe_overlay':
+ renderer = new MediapipeOverlayRenderer();
+ break;
+ case 'rtmpose_overlay':
+ // Future: implement RTMPoseOverlayRenderer
+ throw new Error('RTMPose overlay not yet implemented');
+ default:
+ throw new Error(`Unknown observation type: ${type}`);
+ }
+
+ this.rendererCache.set(type, renderer);
+ return renderer;
+ }
+
+ /**
+ * Set model info for a specific tracker type
+ */
+ public static setModelInfo(trackerName: string, modelInfo: ModelInfo): void {
+ this.modelInfoCache.set(trackerName, modelInfo);
+
+ // Update all renderers that might use this model info
+ for (const [type, renderer] of this.rendererCache) {
+ if (this.shouldUseModelInfo(type, trackerName)) {
+ renderer.setModelInfo(modelInfo);
+ }
+ }
+ }
+
+ /**
+ * Clear all cached renderers
+ */
+ public static clearCache(): void {
+ for (const renderer of this.rendererCache.values()) {
+ renderer.destroy();
+ }
+ this.rendererCache.clear();
+ this.modelInfoCache.clear();
+ }
+
+ /**
+ * Determine if a renderer type should use a specific model info
+ */
+ private static shouldUseModelInfo(
+ rendererType: ObservationType,
+ trackerName: string
+ ): boolean {
+ const mapping: Record<ObservationType, string[]> = {
+ 'charuco_overlay': ['CharucoTracker'],
+ 'mediapipe_overlay': ['MediapipeHolisticTracker', 'MediapipeTracker'],
+ 'rtmpose_overlay': ['RTMPoseTracker'],
+ };
+
+ return mapping[rendererType]?.includes(trackerName) || false;
+ }
+}
+
+/**
+ * Manager for handling overlay rendering across multiple cameras.
+ *
+ * Composites both charuco and mediapipe overlays sequentially onto each
+ * frame: source → charuco → mediapipe. Each renderer draws on top of
+ * the previous result rather than clearing and redrawing from scratch.
+ */
+export class OverlayManager {
+ private charucoRenderer: CharucoOverlayRenderer = new CharucoOverlayRenderer();
+ private mediapipeRenderer: MediapipeOverlayRenderer = new MediapipeOverlayRenderer();
+
+ /**
+ * Composite both overlay types onto a single frame, chained sequentially.
+ * The charuco overlay is drawn first, then mediapipe on top of the result.
+ */
+ public async processFrame(
+ cameraId: string,
+ sourceBitmap: ImageBitmap,
+ charucoObservation: CharucoObservation | null,
+ mediapipeObservation: MediapipeObservation | null,
+ ): Promise<ImageBitmap> {
+ let currentBitmap = sourceBitmap;
+
+ if (charucoObservation) {
+ currentBitmap = await this.charucoRenderer.compositeFrame(
+ currentBitmap,
+ charucoObservation,
+ );
+ }
+
+ if (mediapipeObservation) {
+ currentBitmap = await this.mediapipeRenderer.compositeFrame(
+ currentBitmap,
+ mediapipeObservation,
+ );
+ }
+
+ return currentBitmap;
+ }
+
+ /**
+ * Set model info on both renderers
+ */
+ public setModelInfo(modelInfo: ModelInfo): void {
+ this.charucoRenderer.setModelInfo(modelInfo);
+ this.mediapipeRenderer.setModelInfo(modelInfo);
+ }
+
+ /**
+ * Clear all renderers
+ */
+ public clearAll(): void {
+ this.charucoRenderer.destroy();
+ this.mediapipeRenderer.destroy();
+ this.charucoRenderer = new CharucoOverlayRenderer();
+ this.mediapipeRenderer = new MediapipeOverlayRenderer();
+ }
+}
\ No newline at end of file
diff --git a/freemocap-ui-old/src/services/server/server-helpers/image-overlay/overlay-types.ts b/freemocap-ui-old/src/services/server/server-helpers/image-overlay/overlay-types.ts
new file mode 100644
index 00000000..ea043a32
--- /dev/null
+++ b/freemocap-ui-old/src/services/server/server-helpers/image-overlay/overlay-types.ts
@@ -0,0 +1,17 @@
+import {CharucoObservation, CharucoOverlayDataMessage} from "@/services/server/server-helpers/image-overlay/charuco-types";
+import {MediapipeObservation, MediapipeOverlayDataMessage} from "@/services/server/server-helpers/image-overlay/mediapipe-types";
+
+// Union type for all observation data messages
+export type ObservationDataMessage = CharucoOverlayDataMessage | MediapipeOverlayDataMessage;
+
+// Union type for individual observations
+export type Observation = CharucoObservation | MediapipeObservation;
+
+// Type guard functions
+export function isCharucoObservation(obs: Observation): obs is CharucoObservation {
+ return obs.message_type === 'charuco_overlay';
+}
+
+export function isMediapipeObservation(obs: Observation): obs is MediapipeObservation {
+ return obs.message_type === 'mediapipe_overlay';
+}
diff --git a/freemocap-ui-old/src/services/server/server-helpers/offscreen-renderer.worker.ts b/freemocap-ui-old/src/services/server/server-helpers/offscreen-renderer.worker.ts
new file mode 100644
index 00000000..6b982fd4
--- /dev/null
+++ b/freemocap-ui-old/src/services/server/server-helpers/offscreen-renderer.worker.ts
@@ -0,0 +1,89 @@
+export const workerCode = `
+let offscreenCanvas;
+let ctx;
+let pendingFrame = null;
+let isRendering = false;
+let stats = {
+ framesRendered: 0,
+ framesDropped: 0,
+ totalRenderTime: 0
+};
+
+self.onmessage = (e) => {
+ const { type } = e.data;
+
+ switch (type) {
+ case 'init':
+ initCanvas(e.data);
+ break;
+
+ case 'frame':
+ handleFrame(e.data);
+ break;
+
+ case 'getStats':
+ self.postMessage({ type: 'stats', stats });
+ break;
+ }
+};
+
+function initCanvas(data) {
+ offscreenCanvas = data.canvas;
+ ctx = offscreenCanvas.getContext('bitmaprenderer');
+ renderLoop();
+ self.postMessage({ type: 'initialized' });
+}
+
+function handleFrame(data) {
+ const bitmap = data.bitmap;
+
+ if (!bitmap || bitmap.width <= 0 || bitmap.height <= 0) {
+ console.error('Invalid bitmap dimensions:', bitmap?.width, bitmap?.height);
+ if (bitmap) bitmap.close();
+ return;
+ }
+
+ // Resize canvas if needed
+ if (offscreenCanvas.width !== bitmap.width || offscreenCanvas.height !== bitmap.height) {
+ offscreenCanvas.width = bitmap.width;
+ offscreenCanvas.height = bitmap.height;
+ }
+
+ // Drop old frame if still pending
+ if (pendingFrame) {
+ pendingFrame.close();
+ stats.framesDropped++;
+ }
+
+ pendingFrame = bitmap;
+}
+
+function renderLoop() {
+ const startTime = performance.now();
+
+ if (pendingFrame && !isRendering) {
+ isRendering = true;
+
+ // Render the frame
+ ctx.transferFromImageBitmap(pendingFrame);
+ pendingFrame.close();
+ pendingFrame = null;
+
+ // Update stats
+ stats.framesRendered++;
+ const renderTime = performance.now() - startTime;
+ stats.totalRenderTime += renderTime;
+
+ if (renderTime > 16.67) {
+ console.warn(\`Slow frame: \${renderTime.toFixed(2)}ms\`);
+ }
+
+ isRendering = false;
+
+ // Notify that frame is rendered
+ self.postMessage({ type: 'frameRendered' });
+ }
+
+ requestAnimationFrame(renderLoop);
+}
+`;
diff --git a/freemocap-ui-old/src/services/server/server-helpers/websocket-connection.ts b/freemocap-ui-old/src/services/server/server-helpers/websocket-connection.ts
new file mode 100644
index 00000000..45a99752
--- /dev/null
+++ b/freemocap-ui-old/src/services/server/server-helpers/websocket-connection.ts
@@ -0,0 +1,316 @@
+export interface WebSocketConfig {
+ url: string;
+ reconnectDelay?: number;
+ maxReconnectAttempts?: number;
+ heartbeatInterval?: number;
+ /** When true, silently poll for the server and auto-connect when it appears. */
+ autoConnect?: boolean;
+ /** Polling interval (ms) when in auto-connect discovery mode. */
+ autoConnectInterval?: number;
+}
+
+export enum ConnectionState {
+ /** Idle — not trying to connect. */
+ DISCONNECTED = 'DISCONNECTED',
+ /** Actively opening a WebSocket connection. */
+ CONNECTING = 'CONNECTING',
+ /** WebSocket is open. */
+ CONNECTED = 'CONNECTED',
+ /** Lost connection, attempting to re-establish. */
+ RECONNECTING = 'RECONNECTING',
+ /** Silently polling for the server to become available. */
+ DISCOVERING = 'DISCOVERING',
+}
+
+/** Typed event map — each key declares its callback signature. */
+interface WebSocketEventMap {
+ 'state-change': (newState: ConnectionState, previousState: ConnectionState) => void;
+ 'message': (event: MessageEvent) => void;
+ 'open': () => void;
+ 'close': (event: CloseEvent) => void;
+ 'error': (event: Event) => void;
+ 'send-failed': (data: string | object) => void;
+ 'send-error': (error: unknown) => void;
+ 'max-reconnect-attempts': () => void;
+}
+
+type EventName = keyof WebSocketEventMap;
+
+export class WebSocketConnection {
+ private ws: WebSocket | null = null;
+ private config: Required<WebSocketConfig>;
+ private reconnectAttempts: number = 0;
+ private reconnectTimer: number | null = null;
+ private heartbeatTimer: number | null = null;
+ private discoveryTimer: number | null = null;
+ private state: ConnectionState = ConnectionState.DISCONNECTED;
+
+ private listeners: { [K in EventName]?: Set<WebSocketEventMap[K]> } = {};
+
+ constructor(config: WebSocketConfig) {
+ this.config = {
+ reconnectDelay: config.reconnectDelay ?? 1000,
+ maxReconnectAttempts: config.maxReconnectAttempts ?? 5,
+ heartbeatInterval: config.heartbeatInterval ?? 30000,
+ autoConnect: config.autoConnect ?? false,
+ autoConnectInterval: config.autoConnectInterval ?? 3000,
+ url: config.url,
+ };
+ }
+
+ public on<K extends EventName>(event: K, callback: WebSocketEventMap[K]): void {
+ if (!this.listeners[event]) {
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ this.listeners[event] = new Set() as any;
+ }
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ (this.listeners[event] as any).add(callback);
+ }
+
+ public off<K extends EventName>(event: K, callback: WebSocketEventMap[K]): void {
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ (this.listeners[event] as any)?.delete(callback);
+ }
+
+ private emit<K extends EventName>(event: K, ...args: Parameters<WebSocketEventMap[K]>): void {
+ const set = this.listeners[event];
+ if (!set) return;
+ for (const callback of set) {
+ try {
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ (callback as any)(...args);
+ } catch (error) {
+ console.error(`Error in event listener for ${event}:`, error);
+ }
+ }
+ }
+
+ /**
+ * Begin actively trying to open the WebSocket connection.
+ * If autoConnect is enabled and the attempt fails, falls back to discovery mode.
+ */
+ public connect(): void {
+ if (this.state === ConnectionState.CONNECTING || this.state === ConnectionState.CONNECTED) {
+ return;
+ }
+
+ this.stopDiscovery();
+ this.setState(ConnectionState.CONNECTING);
+
+ try {
+ this.ws = new WebSocket(this.config.url);
+ this.ws.binaryType = 'arraybuffer';
+
+ this.ws.onopen = this.handleOpen.bind(this);
+ this.ws.onclose = this.handleClose.bind(this);
+ this.ws.onerror = this.handleError.bind(this);
+ this.ws.onmessage = this.handleMessage.bind(this);
+ } catch (error) {
+ this.handleError(error as Event);
+ }
+ }
+
+ /**
+ * Cleanly close the connection and stop all reconnection/discovery.
+ */
+ public disconnect(): void {
+ this.clearTimers();
+ this.stopDiscovery();
+ this.reconnectAttempts = 0;
+
+ if (this.ws) {
+ this.ws.onclose = null;
+ this.ws.close();
+ this.ws = null;
+ }
+
+ this.setState(ConnectionState.DISCONNECTED);
+ }
+
+ /**
+ * Enter discovery mode: silently poll for the server at a fixed interval.
+ * Does not surface errors — just keeps trying until the server appears.
+ */
+ public startDiscovery(): void {
+ if (this.state === ConnectionState.CONNECTED || this.state === ConnectionState.CONNECTING) {
+ return;
+ }
+
+ console.log(`[WS] Entering discovery mode (polling every ${this.config.autoConnectInterval}ms)`);
+ this.setState(ConnectionState.DISCOVERING);
+ this.scheduleDiscoveryAttempt();
+ }
+
+ public send(data: string | object): boolean {
+ if (!this.isConnected()) {
+ this.emit('send-failed', data);
+ return false;
+ }
+
+ try {
+ const payload = typeof data === 'string' ? data : JSON.stringify(data);
+ this.ws!.send(payload);
+ return true;
+ } catch (error) {
+ console.error('Failed to send WebSocket message:', error);
+ this.emit('send-error', error);
+ return false;
+ }
+ }
+
+ public isConnected(): boolean {
+ return this.ws?.readyState === WebSocket.OPEN;
+ }
+
+ public getState(): ConnectionState {
+ return this.state;
+ }
+
+ // -----------------------------------------------------------
+ // Private
+ // -----------------------------------------------------------
+
+ private setState(state: ConnectionState): void {
+ const previousState = this.state;
+ this.state = state;
+ this.emit('state-change', state, previousState);
+ }
+
+ private handleOpen(): void {
+ console.log('WebSocket connected');
+ this.reconnectAttempts = 0;
+ this.stopDiscovery();
+ this.setState(ConnectionState.CONNECTED);
+ this.startHeartbeat();
+ this.emit('open');
+ }
+
+ private handleClose(event: CloseEvent): void {
+ console.log(`WebSocket closed: code=${event.code}, reason=${event.reason}`);
+ this.clearTimers();
+ this.ws = null;
+
+ // Always transition to DISCONNECTED first — this triggers cleanup
+ // in listeners (e.g. ServerContextProvider dispatches serverSettingsCleared)
+ this.setState(ConnectionState.DISCONNECTED);
+ this.emit('close', event);
+
+ // If autoConnect is on, immediately start polling for the server again
+ if (this.config.autoConnect) {
+ this.startDiscovery();
+ return;
+ }
+
+ if (this.reconnectAttempts < this.config.maxReconnectAttempts) {
+ this.scheduleReconnect();
+ } else {
+ this.emit('max-reconnect-attempts');
+ }
+ }
+
+ private handleError(_error: Event): void {
+ // In discovery mode, errors are expected and silenced
+ if (this.state === ConnectionState.DISCOVERING) {
+ return;
+ }
+ this.emit('error', _error);
+ }
+
+ private handleMessage(event: MessageEvent): void {
+ this.emit('message', event);
+ }
+
+ private scheduleReconnect(): void {
+ if (this.reconnectTimer) return;
+
+ this.setState(ConnectionState.RECONNECTING);
+ const delay = Math.min(
+ this.config.reconnectDelay * Math.pow(2, this.reconnectAttempts),
+ 10000,
+ );
+
+ console.log(`Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts + 1}/${this.config.maxReconnectAttempts})`);
+
+ this.reconnectTimer = window.setTimeout(() => {
+ this.reconnectTimer = null;
+ this.reconnectAttempts++;
+ this.connect();
+ }, delay);
+ }
+
+ /**
+ * Schedule one discovery probe. On failure, schedule the next one.
+ * On success, handleOpen() takes over.
+ */
+ private scheduleDiscoveryAttempt(): void {
+ if (this.discoveryTimer !== null) return;
+
+ this.discoveryTimer = window.setTimeout(() => {
+ this.discoveryTimer = null;
+
+ if (this.state !== ConnectionState.DISCOVERING) return;
+
+ try {
+ const probe = new WebSocket(this.config.url);
+ probe.binaryType = 'arraybuffer';
+
+ probe.onopen = () => {
+ console.log('[WS] Discovery probe succeeded — promoting to main connection');
+ // Discovery succeeded — promote this socket to the main connection
+ this.ws = probe;
+ probe.onclose = this.handleClose.bind(this);
+ probe.onerror = this.handleError.bind(this);
+ probe.onmessage = this.handleMessage.bind(this);
+ this.handleOpen();
+ };
+
+ probe.onerror = () => {
+ // Silently swallow — try again on the next interval
+ try { probe.close(); } catch { /* ignore */ }
+ if (this.state === ConnectionState.DISCOVERING) {
+ this.scheduleDiscoveryAttempt();
+ }
+ };
+
+ probe.onclose = () => {
+ // If we get a close without ever opening, try again
+ if (this.state === ConnectionState.DISCOVERING) {
+ this.scheduleDiscoveryAttempt();
+ }
+ };
+ } catch {
+ // WebSocket constructor threw — try again
+ if (this.state === ConnectionState.DISCOVERING) {
+ this.scheduleDiscoveryAttempt();
+ }
+ }
+ }, this.config.autoConnectInterval);
+ }
+
+ private stopDiscovery(): void {
+ if (this.discoveryTimer !== null) {
+ clearTimeout(this.discoveryTimer);
+ this.discoveryTimer = null;
+ }
+ }
+
+ private startHeartbeat(): void {
+ this.heartbeatTimer = window.setInterval(() => {
+ if (this.isConnected()) {
+ // Send plain text "ping" — the backend expects this format
+ this.ws!.send('ping');
+ }
+ }, this.config.heartbeatInterval);
+ }
+
+ private clearTimers(): void {
+ if (this.reconnectTimer) {
+ clearTimeout(this.reconnectTimer);
+ this.reconnectTimer = null;
+ }
+ if (this.heartbeatTimer) {
+ clearInterval(this.heartbeatTimer);
+ this.heartbeatTimer = null;
+ }
+ }
+}
diff --git a/freemocap-ui-old/src/services/server/server-helpers/websocket-message-types.ts b/freemocap-ui-old/src/services/server/server-helpers/websocket-message-types.ts
new file mode 100644
index 00000000..eb1e424d
--- /dev/null
+++ b/freemocap-ui-old/src/services/server/server-helpers/websocket-message-types.ts
@@ -0,0 +1,76 @@
+import {DetailedFramerate, LogRecord} from '@/store';
+import {SettingsStateMessage} from '@/store/slices/settings/settings-types';
+import {
+ CharucoOverlayDataMessage,
+ CharucoOverlayDataMessageSchema,
+} from "@/services/server/server-helpers/image-overlay/charuco-types";
+import {
+ MediapipeOverlayDataMessage,
+ MediapipeOverlayDataMessageSchema,
+} from "@/services/server/server-helpers/image-overlay/mediapipe-types";
+import {ModelInfo} from "@/services/server/server-helpers/image-overlay/image-overlay-system";
+import {OverlayRendererFactory} from "@/services/server/server-helpers/image-overlay/overlay-renderer-factory";
+
+export interface FramerateUpdateMessage {
+ message_type: 'framerate_update';
+ camera_group_id: string;
+ backend_framerate: DetailedFramerate;
+ frontend_framerate: DetailedFramerate;
+}
+
+export function arraysEqual(a: string[], b: string[]): boolean {
+ if (a.length !== b.length) return false;
+ const sortedA = [...a].sort();
+ const sortedB = [...b].sort();
+ return sortedA.every((val, idx) => val === sortedB[idx]);
+}
+
+export function isLogRecord(data: unknown): data is LogRecord {
+ return (
+ typeof data === 'object' &&
+ data !== null &&
+ (data as Record<string, unknown>).message_type === 'log_record' &&
+ typeof (data as Record<string, unknown>).levelname === 'string' &&
+ typeof (data as Record<string, unknown>).message === 'string'
+ );
+}
+
+export function isSettingsStateMessage(data: unknown): data is SettingsStateMessage {
+ return (
+ typeof data === 'object' &&
+ data !== null &&
+ (data as Record<string, unknown>).message_type === 'settings/state' &&
+ typeof (data as Record<string, unknown>).settings === 'object' &&
+ (data as Record<string, unknown>).settings !== null &&
+ typeof (data as Record<string, unknown>).version === 'number'
+ );
+}
+
+export function isFramerateUpdate(data: unknown): data is FramerateUpdateMessage {
+ const d = data as Record<string, unknown>;
+ return (
+ typeof data === 'object' &&
+ data !== null &&
+ d.message_type === 'framerate_update' &&
+ typeof d.camera_group_id === 'string' &&
+ typeof d.backend_framerate === 'object' &&
+ d.backend_framerate !== null &&
+ typeof d.frontend_framerate === 'object' &&
+ d.frontend_framerate !== null
+ );
+}
+
+export function isCharucoOverlayDataMessage(data: unknown): data is CharucoOverlayDataMessage {
+ const result = CharucoOverlayDataMessageSchema.safeParse(data);
+ return result.success;
+}
+
+export function isMediapipeOverlayDataMessage(data: unknown): data is MediapipeOverlayDataMessage {
+ const result = MediapipeOverlayDataMessageSchema.safeParse(data);
+ return result.success;
+}
+
+export function handleModelInfoUpdate(modelInfo: ModelInfo): void {
+ console.log(`Received model info for tracker: ${modelInfo.tracker_name}`);
+ OverlayRendererFactory.setModelInfo(modelInfo.tracker_name, modelInfo);
+}
\ No newline at end of file
diff --git a/freemocap-ui-old/src/store/hooks.ts b/freemocap-ui-old/src/store/hooks.ts
new file mode 100644
index 00000000..fd5b5512
--- /dev/null
+++ b/freemocap-ui-old/src/store/hooks.ts
@@ -0,0 +1,5 @@
+import {TypedUseSelectorHook, useDispatch, useSelector} from 'react-redux';
+import type {AppDispatch, RootState} from './types';
+
+export const useAppDispatch = (): AppDispatch => useDispatch<AppDispatch>();
+export const useAppSelector: TypedUseSelectorHook<RootState> = useSelector;
diff --git a/freemocap-ui-old/src/store/index.ts b/freemocap-ui-old/src/store/index.ts
new file mode 100644
index 00000000..c57b7807
--- /dev/null
+++ b/freemocap-ui-old/src/store/index.ts
@@ -0,0 +1,15 @@
+export { store } from './store';
+export type { RootState, AppDispatch, AppThunk } from './types';
+export { useAppDispatch, useAppSelector } from './hooks';
+
+
+// Re-export all slice actions and selectors for a nice 'barrel' design pattern, which makes imports cleaner
+export * from './slices/cameras';
+export * from './slices/recording';
+export * from './slices/framerate';
+export * from './slices/log-records';
+export * from './slices/theme';
+export * from './slices/videos';
+export * from './slices/pipeline';
+export * from './slices/mocap';
+export * from './slices/settings';
diff --git a/freemocap-ui-old/src/store/slices/calibration/calibration-slice.ts b/freemocap-ui-old/src/store/slices/calibration/calibration-slice.ts
new file mode 100644
index 00000000..65124964
--- /dev/null
+++ b/freemocap-ui-old/src/store/slices/calibration/calibration-slice.ts
@@ -0,0 +1,221 @@
+import {createSelector, createSlice, PayloadAction} from '@reduxjs/toolkit';
+import {RootState} from '../../types';
+import {
+ calibrateRecording,
+ startCalibrationRecording,
+ stopCalibrationRecording,
+ updateCalibrationConfigOnServer,
+} from "@/store/slices/calibration/calibration-thunks";
+
+// ==================== Types ====================
+
+export type CalibrationSolverMethod = 'anipose' | 'pyceres';
+
+export interface CalibrationConfig {
+ liveTrackCharuco: boolean;
+ charucoBoardXSquares: number;
+ charucoBoardYSquares: number;
+ charucoSquareLength: number;
+ minSharedViewsPerCamera: number;
+ autoStopOnMinViewCount: boolean;
+ solverMethod: CalibrationSolverMethod;
+ useGroundplane: boolean;
+}
+
+export interface CalibrationDirectoryInfo {
+ exists: boolean;
+ canRecord: boolean;
+ canCalibrate: boolean;
+ cameraCalibrationTomlPath: string | null;
+ hasSynchronizedVideos: boolean;
+ hasVideos: boolean;
+ errorMessage: string | null;
+}
+
+export interface CalibrationState {
+ config: CalibrationConfig;
+ isRecording: boolean;
+ recordingProgress: number;
+ isLoading: boolean;
+ error: string | null;
+ lastCalibrationRecordingPath: string | null;
+ manualCalibrationRecordingPath: string | null;
+ directoryInfo: CalibrationDirectoryInfo | null;
+}
+
+// ==================== Initial State ====================
+
+const initialState: CalibrationState = {
+ config: {
+ liveTrackCharuco: true,
+ charucoBoardXSquares: 5,
+ charucoBoardYSquares: 3,
+ charucoSquareLength: 1,
+ minSharedViewsPerCamera: 200,
+ autoStopOnMinViewCount: true,
+ solverMethod: 'anipose',
+ useGroundplane: false,
+ },
+ isRecording: false,
+ recordingProgress: 0,
+ isLoading: false,
+ error: null,
+ lastCalibrationRecordingPath: null,
+ manualCalibrationRecordingPath: null,
+ directoryInfo: null,
+};
+
+// ==================== Slice ====================
+
+export const calibrationSlice = createSlice({
+ name: 'calibration',
+ initialState,
+ reducers: {
+ calibrationConfigUpdated: (state, action: PayloadAction<Partial<CalibrationConfig>>) => {
+ state.config = { ...state.config, ...action.payload };
+ },
+
+ calibrationProgressUpdated: (state, action: PayloadAction<number>) => {
+ state.recordingProgress = action.payload;
+ },
+
+ calibrationErrorCleared: (state) => {
+ state.error = null;
+ },
+
+ manualCalibrationRecordingPathChanged: (state, action: PayloadAction<string>) => {
+ state.manualCalibrationRecordingPath = action.payload;
+ },
+
+ manualCalibrationRecordingPathCleared: (state) => {
+ state.manualCalibrationRecordingPath = null;
+ },
+
+ calibrationDirectoryInfoUpdated: (state, action: PayloadAction<CalibrationDirectoryInfo>) => {
+ state.directoryInfo = action.payload;
+ },
+
+ resetCalibrationState: () => initialState,
+ },
+
+ extraReducers: (builder) => {
+ builder
+ .addCase(startCalibrationRecording.pending, (state) => {
+ state.isLoading = true;
+ state.error = null;
+ })
+ .addCase(startCalibrationRecording.fulfilled, (state, action) => {
+ state.isLoading = false;
+ state.isRecording = true;
+ state.recordingProgress = 0;
+ if (action.payload.calibrationRecordingPath) {
+ state.lastCalibrationRecordingPath = action.payload.calibrationRecordingPath;
+ }
+ })
+ .addCase(startCalibrationRecording.rejected, (state, action) => {
+ state.isLoading = false;
+ state.error = action.payload || 'Failed to start recording';
+ });
+
+ builder
+ .addCase(stopCalibrationRecording.pending, (state) => {
+ state.isLoading = true;
+ state.error = null;
+ })
+ .addCase(stopCalibrationRecording.fulfilled, (state) => {
+ state.isLoading = false;
+ state.isRecording = false;
+ state.recordingProgress = 0;
+ })
+ .addCase(stopCalibrationRecording.rejected, (state, action) => {
+ state.isLoading = false;
+ state.error = action.payload || 'Failed to stop recording';
+ });
+
+ builder
+ .addCase(calibrateRecording.pending, (state) => {
+ state.isLoading = true;
+ state.error = null;
+ })
+ .addCase(calibrateRecording.fulfilled, (state) => {
+ state.isLoading = false;
+ })
+ .addCase(calibrateRecording.rejected, (state, action) => {
+ state.isLoading = false;
+ state.error = action.payload || 'Failed to calibrate recording';
+ });
+
+ builder
+ .addCase(updateCalibrationConfigOnServer.rejected, (state, action) => {
+ state.error = action.payload || 'Failed to sync config to server';
+ });
+ },
+});
+
+// ==================== Selectors ====================
+
+export const selectCalibration = (state: RootState) => state.calibration;
+export const selectCalibrationConfig = (state: RootState) => state.calibration.config;
+export const selectCalibrationIsLoading = (state: RootState) => state.calibration.isLoading;
+export const selectCalibrationIsRecording = (state: RootState) => state.calibration.isRecording;
+export const selectCalibrationProgress = (state: RootState) => state.calibration.recordingProgress;
+export const selectCalibrationError = (state: RootState) => state.calibration.error;
+export const selectCalibrationDirectoryInfo = (state: RootState) => state.calibration.directoryInfo;
+
+export const selectCalibrationRecordingPath = createSelector(
+ [
+ (state: RootState) => state.calibration.manualCalibrationRecordingPath,
+ (state: RootState) => state.calibration.lastCalibrationRecordingPath,
+ (state: RootState) => state.recording.computed,
+ ],
+ (manualPath, lastPath, recordingComputed) => {
+ if (manualPath) return manualPath;
+ if (lastPath) return lastPath;
+
+ const calibrationFolderName = `${recordingComputed.recordingName}_calibration`;
+ return `${recordingComputed.fullRecordingPath}/${calibrationFolderName}`;
+ }
+);
+
+export const selectIsUsingManualCalibrationPath = createSelector(
+ [(state: RootState) => state.calibration.manualCalibrationRecordingPath],
+ (manualPath) => manualPath !== null
+);
+
+export const selectCanStartCalibrationRecording = createSelector(
+ [
+ selectCalibrationIsRecording,
+ selectCalibrationIsLoading,
+ selectCalibrationRecordingPath,
+ selectCalibrationDirectoryInfo
+ ],
+ (isRecording, isLoading, recordingPath, directoryInfo) => {
+ return !isRecording && !isLoading && !!recordingPath && (directoryInfo?.canRecord ?? true);
+ }
+);
+
+export const selectCanCalibrate = createSelector(
+ [
+ selectCalibrationRecordingPath,
+ selectCalibrationIsLoading,
+ selectCalibrationIsRecording,
+ selectCalibrationDirectoryInfo
+ ],
+ (calibrationPath, isLoading, isRecording, directoryInfo) => {
+ return !!calibrationPath && !isLoading && !isRecording && (directoryInfo?.canCalibrate ?? false);
+ }
+);
+
+// ==================== Actions Export ====================
+
+export const {
+ calibrationConfigUpdated,
+ calibrationProgressUpdated,
+ calibrationErrorCleared,
+ manualCalibrationRecordingPathChanged,
+ manualCalibrationRecordingPathCleared,
+ calibrationDirectoryInfoUpdated,
+ resetCalibrationState
+} = calibrationSlice.actions;
+
+export default calibrationSlice.reducer;
diff --git a/freemocap-ui-old/src/store/slices/calibration/calibration-thunks.ts b/freemocap-ui-old/src/store/slices/calibration/calibration-thunks.ts
new file mode 100644
index 00000000..eaddc923
--- /dev/null
+++ b/freemocap-ui-old/src/store/slices/calibration/calibration-thunks.ts
@@ -0,0 +1,169 @@
+import {createAsyncThunk} from "@reduxjs/toolkit";
+import {RootState} from "@/store";
+import {serverUrls} from "@/hooks/server-urls";
+import {selectCalibrationRecordingPath} from "./calibration-slice";
+import {getDetailedErrorMessage} from "@/store/slices/thunk-helpers";
+
+export const startCalibrationRecording = createAsyncThunk<
+ { success: boolean; message?: string; calibrationRecordingPath?: string },
+ void,
+ { state: RootState; rejectValue: string }
+>(
+ 'calibration/startRecording',
+ async (_, { getState, rejectWithValue }) => {
+ try {
+ const state = getState();
+ const calibrationTaskConfig = state.calibration.config;
+ const calibrationRecordingDirectory = selectCalibrationRecordingPath(state);
+
+ if (!calibrationRecordingDirectory) {
+ return rejectWithValue('Recording directory is not set');
+ }
+
+ console.log('🎬 Starting calibration recording with:', {
+ calibrationRecordingDirectory,
+ calibrationTaskConfig,
+ });
+
+ const response = await fetch(serverUrls.endpoints.calibrationStartRecording, {
+ method: 'POST',
+ headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify({
+ calibrationRecordingDirectory,
+ calibrationTaskConfig,
+ }),
+ });
+
+ if (!response.ok) {
+ const errorMessage = await getDetailedErrorMessage(response);
+ return rejectWithValue(errorMessage);
+ }
+
+ const result = await response.json();
+ console.log('✅ Started calibration recording:', result);
+ return result;
+ } catch (error) {
+ const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+ console.error('❌ Failed to start calibration recording:', errorMessage);
+ return rejectWithValue(errorMessage);
+ }
+ }
+);
+
+export const stopCalibrationRecording = createAsyncThunk<
+ { success: boolean },
+ void,
+ { state: RootState; rejectValue: string }
+>(
+ 'calibration/stopRecording',
+ async (_, { getState, rejectWithValue }) => {
+ try {
+ const state = getState();
+ const calibrationTaskConfig = state.calibration.config;
+
+
+ console.log(`🎬 Stoping calibration recording and starting calibration with: ${JSON.stringify(calibrationTaskConfig, null, 2)}`);
+
+
+ const response = await fetch(serverUrls.endpoints.calibrationStopRecording, {
+ method: 'POST',
+ headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify({calibrationTaskConfig}),
+ });
+
+ if (!response.ok) {
+ const errorMessage = await getDetailedErrorMessage(response);
+ return rejectWithValue(errorMessage);
+ }
+
+ const result = await response.json();
+ console.log('✅ Stopped calibration recording:', result);
+ return result;
+ } catch (error) {
+ const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+ console.error('❌ Failed to stop calibration recording:', errorMessage);
+ return rejectWithValue(errorMessage);
+ }
+ }
+);
+
+export const calibrateRecording = createAsyncThunk<
+ { success: boolean; message?: string; results?: unknown },
+ void,
+ { state: RootState; rejectValue: string }
+>(
+ 'calibration/calibrateRecording',
+ async (_, { getState, rejectWithValue }) => {
+ try {
+ const state = getState();
+ const calibrationTaskConfig = state.calibration.config;
+ const calibrationRecordingDirectory = selectCalibrationRecordingPath(state);
+
+ if (!calibrationRecordingDirectory) {
+ return rejectWithValue('No calibration recording path available. Please set a recording directory or record a calibration first.');
+ }
+
+ console.log('🔧 Calibrating recording:', {
+ calibrationRecordingDirectory,
+ calibrationTaskConfig,
+ });
+
+ const response = await fetch(serverUrls.endpoints.calibrateRecording, {
+ method: 'POST',
+ headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify({
+ calibrationRecordingDirectory,
+ calibrationTaskConfig,
+ }),
+ });
+
+ if (!response.ok) {
+ const errorMessage = await getDetailedErrorMessage(response);
+ return rejectWithValue(errorMessage);
+ }
+
+ const result = await response.json();
+ console.log('✅ Calibration completed:', result);
+ return result;
+ } catch (error) {
+ const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+ console.error('❌ Failed to calibrate recording:', errorMessage);
+ return rejectWithValue(errorMessage);
+ }
+ }
+);
+
+export const updateCalibrationConfigOnServer = createAsyncThunk<
+ { success: boolean; message?: string },
+ void,
+ { state: RootState; rejectValue: string }
+>(
+ 'calibration/updateConfig',
+ async (_, { getState, rejectWithValue }) => {
+ try {
+ const state = getState();
+ const config = state.calibration.config;
+
+ console.log('⚙️ Updating calibration config on server:', config);
+
+ const response = await fetch(serverUrls.endpoints.updateCalibrationConfig, {
+ method: 'POST',
+ headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify({ config }),
+ });
+
+ if (!response.ok) {
+ const errorMessage = await getDetailedErrorMessage(response);
+ return rejectWithValue(errorMessage);
+ }
+
+ const result = await response.json();
+ console.log('✅ Config updated on server:', result);
+ return result;
+ } catch (error) {
+ const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+ console.error('❌ Failed to update config on server:', errorMessage);
+ return rejectWithValue(errorMessage);
+ }
+ }
+);
diff --git a/freemocap-ui-old/src/store/slices/calibration/index.ts b/freemocap-ui-old/src/store/slices/calibration/index.ts
new file mode 100644
index 00000000..b50cd008
--- /dev/null
+++ b/freemocap-ui-old/src/store/slices/calibration/index.ts
@@ -0,0 +1,3 @@
+
+export * from './calibration-slice';
+export * from './calibration-thunks';
diff --git a/freemocap-ui-old/src/store/slices/cameras/cameras-selectors.ts b/freemocap-ui-old/src/store/slices/cameras/cameras-selectors.ts
new file mode 100644
index 00000000..bab7b94c
--- /dev/null
+++ b/freemocap-ui-old/src/store/slices/cameras/cameras-selectors.ts
@@ -0,0 +1,159 @@
+// cameras-selectors.ts
+import {createSelector} from '@reduxjs/toolkit';
+import {RootState} from '../../types';
+import {CameraConfig} from './cameras-types';
+
+// ========== Basic Selectors ==========
+export const selectCameras = (state: RootState) => state.cameras.cameras;
+export const selectIsLoading = (state: RootState) => state.cameras.isLoading;
+export const selectError = (state: RootState) => state.cameras.error;
+
+// ========== Derived Selectors ==========
+export const selectCameraById = createSelector(
+ [selectCameras, (_: RootState, cameraId: string) => cameraId],
+ (cameras, cameraId) => cameras.find(cam => cam.id === cameraId)
+);
+
+export const selectSelectedCameras = createSelector(
+ [selectCameras],
+ (cameras) => cameras.filter(cam => cam.selected)
+);
+
+export const selectConnectedCameras = createSelector(
+ [selectCameras],
+ (cameras) => cameras.filter(cam => cam.connectionStatus === 'connected')
+);
+
+// Get desired configs for selected cameras (for API calls)
+export const selectSelectedCameraConfigs = createSelector(
+ [selectSelectedCameras],
+ (cameras): Record<string, CameraConfig> => {
+ return cameras.reduce(
+ (configs, camera) => ({
+ ...configs,
+ [camera.id]: camera.desiredConfig, // Use desired config
+ }),
+ {} as Record<string, CameraConfig>
+ );
+ }
+);
+
+
+
+// ========== Mismatch Selectors ==========
+export const selectCamerasWithConfigMismatch = createSelector(
+ [selectCameras],
+ (cameras) => cameras.filter(cam => cam.hasConfigMismatch)
+);
+
+export const selectHasAnyConfigMismatch = createSelector(
+ [selectCamerasWithConfigMismatch],
+ (camerasWithMismatch) => camerasWithMismatch.length > 0
+);
+
+export const selectCameraHasConfigMismatch = createSelector(
+ [selectCameraById],
+ (camera) => camera?.hasConfigMismatch ?? false
+);
+
+// Get config comparison for a specific camera
+export const selectCameraConfigComparison = createSelector(
+ [selectCameraById],
+ (camera) => {
+ if (!camera) return null;
+
+ return {
+ actual: camera.actualConfig,
+ desired: camera.desiredConfig,
+ hasMismatch: camera.hasConfigMismatch,
+ differences: camera.hasConfigMismatch ?
+ getConfigDifferences(camera.actualConfig, camera.desiredConfig) : []
+ };
+ }
+);
+
+// ========== Count Selectors ==========
+export const selectCameraCount = createSelector(
+ [selectCameras],
+ (cameras) => cameras.length
+);
+
+export const selectHasConnectedCameras = createSelector(
+ [selectConnectedCameras],
+ (cameras) => cameras.length > 0
+);
+
+// ========== Helper Functions ==========
+function getConfigDifferences(
+ actual: CameraConfig,
+ desired: CameraConfig
+): Array<{ field: string; actual: any; desired: any }> {
+ const differences: Array<{ field: string; actual: any; desired: any }> = [];
+
+ // Compare each field
+ if (actual.resolution.width !== desired.resolution.width) {
+ differences.push({
+ field: 'resolution.width',
+ actual: actual.resolution.width,
+ desired: desired.resolution.width
+ });
+ }
+ if (actual.resolution.height !== desired.resolution.height) {
+ differences.push({
+ field: 'resolution.height',
+ actual: actual.resolution.height,
+ desired: desired.resolution.height
+ });
+ }
+ if (actual.framerate !== desired.framerate) {
+ differences.push({
+ field: 'framerate',
+ actual: actual.framerate,
+ desired: desired.framerate
+ });
+ }
+ if (actual.exposure_mode !== desired.exposure_mode) {
+ differences.push({
+ field: 'exposure_mode',
+ actual: actual.exposure_mode,
+ desired: desired.exposure_mode
+ });
+ }
+ if (actual.exposure !== desired.exposure) {
+ differences.push({
+ field: 'exposure',
+ actual: actual.exposure,
+ desired: desired.exposure
+ });
+ }
+ if (actual.rotation !== desired.rotation) {
+ differences.push({
+ field: 'rotation',
+ actual: actual.rotation,
+ desired: desired.rotation
+ });
+ }
+ if (actual.pixel_format !== desired.pixel_format) {
+ differences.push({
+ field: 'pixel_format',
+ actual: actual.pixel_format,
+ desired: desired.pixel_format
+ });
+ }
+ if (actual.capture_fourcc !== desired.capture_fourcc) {
+ differences.push({
+ field: 'capture_fourcc',
+ actual: actual.capture_fourcc,
+ desired: desired.capture_fourcc
+ });
+ }
+ if (actual.writer_fourcc !== desired.writer_fourcc) {
+ differences.push({
+ field: 'writer_fourcc',
+ actual: actual.writer_fourcc,
+ desired: desired.writer_fourcc
+ });
+ }
+
+ return differences;
+}
diff --git a/freemocap-ui-old/src/store/slices/cameras/cameras-slice.ts b/freemocap-ui-old/src/store/slices/cameras/cameras-slice.ts
new file mode 100644
index 00000000..b0691567
--- /dev/null
+++ b/freemocap-ui-old/src/store/slices/cameras/cameras-slice.ts
@@ -0,0 +1,145 @@
+import {createSlice, PayloadAction} from '@reduxjs/toolkit';
+import {areConfigsEqual, CameraConfig, CamerasState, extractConfigSettings,} from './cameras-types';
+import {detectCameras,} from './cameras-thunks';
+import {closePipeline, connectRealtimePipeline} from '../pipeline/pipeline-thunks';
+import {serverSettingsCleared, serverSettingsUpdated} from '../settings/settings-slice';
+
+
+const initialState: CamerasState = {
+ cameras: [],
+ isLoading: false,
+ error: null,
+};
+
+export const cameraSlice = createSlice({
+ name: 'cameras',
+ initialState,
+ reducers: {
+ // ========== Selection ==========
+ cameraSelectionToggled: (state, action: PayloadAction<string>) => {
+ const camera = state.cameras.find(cam => cam.id === action.payload);
+ if (camera) {
+ camera.selected = !camera.selected;
+ camera.desiredConfig.use_this_camera = camera.selected;
+ }
+ },
+
+ // ========== Configuration ==========
+ cameraDesiredConfigUpdated: (
+ state,
+ action: PayloadAction<{
+ cameraId: string;
+ config: Partial<CameraConfig>
+ }>
+ ) => {
+ const camera = state.cameras.find(
+ cam => cam.id === action.payload.cameraId
+ );
+ if (camera) {
+ camera.desiredConfig = {...camera.desiredConfig, ...action.payload.config};
+ camera.hasConfigMismatch = !areConfigsEqual(camera.actualConfig, camera.desiredConfig);
+ }
+ },
+
+ configCopiedToAll: (state, action: PayloadAction<string>) => {
+ const sourceCamera = state.cameras.find(cam => cam.id === action.payload);
+ if (!sourceCamera) return;
+
+ const settings = extractConfigSettings(sourceCamera.desiredConfig);
+
+ state.cameras.forEach(camera => {
+ if (camera.id !== action.payload) {
+ camera.desiredConfig = {
+ ...camera.desiredConfig,
+ ...settings
+ };
+ camera.hasConfigMismatch = !areConfigsEqual(camera.actualConfig, camera.desiredConfig);
+ }
+ });
+ },
+ },
+
+ extraReducers: (builder) => {
+ builder
+ // ========== Detect Cameras ==========
+ .addCase(detectCameras.pending, (state) => {
+ state.isLoading = true;
+ state.error = null;
+ })
+ .addCase(detectCameras.fulfilled, (state, action) => {
+ state.isLoading = false;
+ state.cameras = action.payload;
+ })
+ .addCase(detectCameras.rejected, (state, action) => {
+ state.isLoading = false;
+ state.error = action.error.message || 'Failed to detect cameras';
+ })
+
+ // ========== Connect Pipeline (HTTP) ==========
+ .addCase(connectRealtimePipeline.pending, (state) => {
+ state.isLoading = true;
+ state.error = null;
+ })
+ .addCase(connectRealtimePipeline.fulfilled, (state, action) => {
+ state.isLoading = false;
+ Object.entries(action.payload.camera_configs).forEach(
+ ([cameraId, config]) => {
+ const camera = state.cameras.find(cam => cam.id === cameraId);
+ if (camera) {
+ camera.actualConfig = config as CameraConfig;
+ camera.hasConfigMismatch = !areConfigsEqual(camera.actualConfig, camera.desiredConfig);
+ camera.connectionStatus = 'connected';
+ }
+ }
+ );
+ })
+ .addCase(connectRealtimePipeline.rejected, (state, action) => {
+ state.isLoading = false;
+ state.error = action.error.message || 'Failed to connect to cameras';
+ })
+
+ // ========== Close Pipeline (HTTP) ==========
+ .addCase(closePipeline.fulfilled, (state) => {
+ state.cameras.forEach(camera => {
+ camera.connectionStatus = 'available';
+ camera.metrics = undefined;
+ camera.hasConfigMismatch = false;
+ });
+ })
+
+ // ========== WebSocket settings/state — sync camera connection status ==========
+ .addCase(serverSettingsUpdated, (state, action) => {
+ const backendCameras = action.payload.settings.cameras;
+ for (const camera of state.cameras) {
+ const backendCam = backendCameras[camera.id];
+ if (backendCam) {
+ // Sync connection status from authoritative backend state
+ if (backendCam.status === 'connected') {
+ camera.connectionStatus = 'connected';
+ } else if (backendCam.status === 'error') {
+ camera.connectionStatus = 'error';
+ } else {
+ camera.connectionStatus = 'available';
+ }
+ } else {
+ // Backend doesn't know about this camera — it's not connected
+ camera.connectionStatus = 'available';
+ }
+ }
+ })
+
+ // ========== WebSocket disconnected — clear all connected state ==========
+ .addCase(serverSettingsCleared, (state) => {
+ state.cameras.forEach(camera => {
+ camera.connectionStatus = 'available';
+ camera.metrics = undefined;
+ });
+ });
+ },
+});
+
+export const {
+ cameraSelectionToggled,
+ cameraDesiredConfigUpdated,
+ configCopiedToAll,
+} = cameraSlice.actions;
diff --git a/freemocap-ui-old/src/store/slices/cameras/cameras-thunks.ts b/freemocap-ui-old/src/store/slices/cameras/cameras-thunks.ts
new file mode 100644
index 00000000..775fbcc3
--- /dev/null
+++ b/freemocap-ui-old/src/store/slices/cameras/cameras-thunks.ts
@@ -0,0 +1,123 @@
+// cameras-thunks.ts
+import {createAsyncThunk} from '@reduxjs/toolkit';
+import {RootState} from '../../types';
+import {serverUrls} from '@/services';
+import {
+ Camera,
+ CamerasConnectOrUpdateRequest,
+ ConnectCamerasResponse,
+ createDefaultCameraConfig,
+ DetectCamerasRequest,
+ DetectCamerasResponse,
+} from './cameras-types';
+import {selectSelectedCameraConfigs} from "@/store";
+
+export const detectCameras = createAsyncThunk<
+ Camera[],
+ DetectCamerasRequest | undefined,
+ { state: RootState }
+>(
+ 'cameras/detect',
+ async (request = { filterVirtual: true }, { getState }) => {
+ const state = getState();
+ const existingCameras = state.cameras.cameras;
+
+ const response = await fetch(serverUrls.endpoints.detectCameras, {
+ method: 'POST',
+ headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify(request),
+ });
+
+ if (!response.ok) {
+ throw new Error(`Failed to detect cameras: ${response.statusText}`);
+ }
+
+ const data: DetectCamerasResponse = await response.json();
+
+ return data.cameras.map((serverCamera): Camera => {
+ const cameraId = serverCamera.index.toString();
+ const existing = existingCameras.find(cam => cam.id === cameraId);
+
+ const defaultConfig = createDefaultCameraConfig(
+ cameraId,
+ serverCamera.index,
+ serverCamera.name,
+ );
+
+ return {
+ id: cameraId,
+ name: serverCamera.name,
+ index: serverCamera.index,
+ // If camera exists, preserve its configs, otherwise use defaults
+ actualConfig: existing?.actualConfig || defaultConfig,
+ desiredConfig: existing?.desiredConfig || { ...defaultConfig },
+ hasConfigMismatch: existing?.hasConfigMismatch ?? false,
+ connectionStatus: 'available',
+ selected: existing?.selected ?? true,
+ deviceInfo: {
+ vendorId: serverCamera.vendor_id,
+ productId: serverCamera.product_id,
+ },
+ metrics: existing?.metrics,
+ };
+ });
+ }
+);
+
+export const camerasConnectOrUpdate = createAsyncThunk<
+ ConnectCamerasResponse,
+ void,
+ { state: RootState }
+>(
+ 'cameras/connect',
+ async (_, { getState }) => {
+ const state = getState();
+ const cameraConfigs = selectSelectedCameraConfigs(state);
+
+ if (Object.keys(cameraConfigs).length === 0) {
+ throw new Error('No cameras selected for connection');
+ }
+
+ const request: CamerasConnectOrUpdateRequest = { camera_configs: cameraConfigs };
+
+ const response = await fetch(serverUrls.endpoints.camerasConnectOrUpdate, {
+ method: 'POST',
+ headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify(request),
+ });
+
+ if (!response.ok) {
+ const error = await response.json();
+ throw new Error(error.detail || 'Failed to connect to cameras');
+ }
+
+ return await response.json() as Promise<ConnectCamerasResponse>;
+ }
+);
+
+
+export const closeCameras = createAsyncThunk<void, void, { state: RootState }>(
+ 'cameras/close',
+ async () => {
+ const response = await fetch(serverUrls.endpoints.closeAll, {
+ method: 'DELETE',
+ });
+
+ if (!response.ok) {
+ throw new Error(`Failed to close cameras: ${response.statusText}`);
+ }
+ }
+);
+
+export const pauseUnpauseCameras = createAsyncThunk<void, void, { state: RootState }>(
+ 'cameras/pause',
+ async () => {
+ const response = await fetch(serverUrls.endpoints.pauseUnpauseCameras, {
+ method: 'GET',
+ });
+
+ if (!response.ok) {
+ throw new Error(`Failed to pause/unpause cameras: ${response.statusText}`);
+ }
+ }
+);
diff --git a/freemocap-ui-old/src/store/slices/cameras/cameras-types.ts b/freemocap-ui-old/src/store/slices/cameras/cameras-types.ts
new file mode 100644
index 00000000..a7455fec
--- /dev/null
+++ b/freemocap-ui-old/src/store/slices/cameras/cameras-types.ts
@@ -0,0 +1,175 @@
+// cameras-viewport3d-types.ts
+import {z} from 'zod';
+
+// ==================== Constants ====================
+export const PIXEL_FORMATS = ['RGB', 'BGR', 'GRAY'] as const;
+export const EXPOSURE_MODES = ['MANUAL', 'AUTO', 'RECOMMEND'] as const;
+export const CONNECTION_STATUS = ['disconnected', 'connecting', 'connected', 'error'] as const;
+
+
+export const ROTATION_DEGREE_LABELS: Record<RotationValue, string> = {
+ [-1]: '0°',
+ [0]: '90°',
+ [1]: '180°',
+ [2]: '270°',
+};
+
+export const ROTATION_OPTIONS = [-1, 0, 1, 2] as const;
+export const FOURCC_OPTIONS = ['MJPG', 'X264', 'YUYV', 'H264'] as const;
+
+export type PixelFormat = typeof PIXEL_FORMATS[number];
+export type ExposureMode = typeof EXPOSURE_MODES[number];
+export type ConnectionStatus = typeof CONNECTION_STATUS[number];
+export type RotationValue = typeof ROTATION_OPTIONS[number];
+export type FourccOption = typeof FOURCC_OPTIONS[number];
+
+// Helper to get rotation label for UI
+export const ROTATION_LABELS: Record<RotationValue, string> = {
+ [-1]: 'No Rotation',
+ [0]: '90°',
+ [1]: '180°',
+ [2]: '270°',
+};
+
+// ==================== Camera Configuration ====================
+const CameraConfigSchema = z.object({
+ // Identity
+ camera_id: z.string(),
+ camera_index: z.number(),
+ camera_name: z.string(),
+ use_this_camera: z.boolean(),
+
+ // Video settings
+ resolution: z.object({
+ width: z.number().int(),
+ height: z.number().int()
+ }),
+ framerate: z.number().min(1).max(1000),
+
+ // Image settings
+ color_channels: z.number().int().min(1).max(4),
+ pixel_format: z.enum(PIXEL_FORMATS),
+ rotation: z.union([z.literal(-1), z.literal(0), z.literal(1), z.literal(2)]),
+
+ // Exposure settings
+ exposure_mode: z.enum(EXPOSURE_MODES),
+ exposure: z.number(),
+
+ // Codec settings
+ capture_fourcc: z.enum(FOURCC_OPTIONS),
+ writer_fourcc: z.enum(FOURCC_OPTIONS),
+});
+
+export type CameraConfig = z.infer<typeof CameraConfigSchema>;
+
+// ==================== Camera State ====================
+export interface Camera {
+ id: string; // Primary key (same as camera_id in config) - must be unique
+ index: number; // Device index, e.g. the port number used in cv2.VideoCapture() - must be unique
+ name: string; // Human-readable name, e.g. "Logitech C920" - not necessarily unique
+ actualConfig: CameraConfig; // Configuration extracted from camera stream
+ desiredConfig: CameraConfig; // User's desired configuration
+ hasConfigMismatch: boolean; // Whether actual differs from desired
+ connectionStatus: 'available' | 'connected' | 'error'; // Connection state
+ selected: boolean; // UI selection state
+
+ // Device info (from detection)
+ deviceInfo: {
+ virtual?: boolean;
+ vendorId?: string;
+ productId?: string;
+ };
+
+ // Performance metrics (optional, updated from websocket)
+ metrics?: {
+ fps: number;
+ droppedFrames: number;
+ lastFrameTime: number;
+ };
+}
+
+// ==================== Store State ====================
+export interface CamerasState {
+ cameras: Camera[];
+ isLoading: boolean;
+ error: string | null;
+}
+
+// ==================== API Types ====================
+export interface DetectCamerasRequest {
+ filterVirtual?: boolean;
+}
+
+export interface DetectCamerasResponse {
+ cameras: Array<{
+ index: number;
+ name: string;
+ vendor_id?: string;
+ product_id?: string;
+ }>;
+}
+
+export interface CamerasConnectOrUpdateRequest {
+ camera_configs: Record<string, CameraConfig>;
+}
+
+export interface ConnectCamerasResponse {
+ camera_configs: Record<string, CameraConfig>;
+}
+
+// ==================== Helper Functions ====================
+export function createDefaultCameraConfig(
+ id: string,
+ index: number,
+ name: string,
+): CameraConfig {
+ return {
+ camera_id: id,
+ camera_index: index,
+ camera_name: name,
+ use_this_camera: true,
+ resolution: { width: 1280, height: 720 },
+ framerate: 30,
+ color_channels: 3,
+ pixel_format: 'RGB',
+ rotation: -1,
+ exposure_mode: 'MANUAL',
+ exposure: -7,
+ capture_fourcc: 'MJPG',
+ writer_fourcc: 'X264',
+ };
+}
+
+export function areConfigsEqual(
+ config1: CameraConfig,
+ config2: CameraConfig
+): boolean {
+ return (
+ config1.resolution.width === config2.resolution.width &&
+ config1.resolution.height === config2.resolution.height &&
+ config1.framerate === config2.framerate &&
+ config1.exposure_mode === config2.exposure_mode &&
+ config1.exposure === config2.exposure &&
+ config1.rotation === config2.rotation &&
+ config1.pixel_format === config2.pixel_format &&
+ config1.capture_fourcc === config2.capture_fourcc &&
+ config1.writer_fourcc === config2.writer_fourcc
+ );
+}
+
+export function extractConfigSettings(
+ config: CameraConfig
+): Partial<CameraConfig> {
+ // Extract copyable settings (exclude identity fields)
+ return {
+ resolution: { ...config.resolution },
+ framerate: config.framerate,
+ color_channels: config.color_channels,
+ pixel_format: config.pixel_format,
+ rotation: config.rotation,
+ exposure_mode: config.exposure_mode,
+ exposure: config.exposure,
+ capture_fourcc: config.capture_fourcc,
+ writer_fourcc: config.writer_fourcc,
+ };
+}
diff --git a/freemocap-ui-old/src/store/slices/cameras/index.ts b/freemocap-ui-old/src/store/slices/cameras/index.ts
new file mode 100644
index 00000000..3fe15df1
--- /dev/null
+++ b/freemocap-ui-old/src/store/slices/cameras/index.ts
@@ -0,0 +1,4 @@
+export * from './cameras-slice';
+export * from './cameras-types';
+export * from './cameras-selectors';
+export * from './cameras-thunks';
diff --git a/freemocap-ui-old/src/store/slices/framerate/framerate-selectors.ts b/freemocap-ui-old/src/store/slices/framerate/framerate-selectors.ts
new file mode 100644
index 00000000..81ca51b8
--- /dev/null
+++ b/freemocap-ui-old/src/store/slices/framerate/framerate-selectors.ts
@@ -0,0 +1,98 @@
+// framerate-selectors.ts
+import {createSelector} from '@reduxjs/toolkit';
+import {RootState} from '../../types';
+import {DetailedFramerate} from './framerate-types';
+
+// Basic selectors for current framerates
+export const selectCurrentFrontendFramerate = (state: RootState): DetailedFramerate | null =>
+ state.framerate.currentFrontendFramerate;
+
+export const selectCurrentBackendFramerate = (state: RootState): DetailedFramerate | null =>
+ state.framerate.currentBackendFramerate;
+
+// Quick FPS value selectors
+export const selectFrontendFps = (state: RootState): number =>
+ state.framerate.currentFrontendFramerate?.mean_frames_per_second ?? 0;
+
+export const selectBackendFps = (state: RootState): number =>
+ state.framerate.currentBackendFramerate?.mean_frames_per_second ?? 0;
+
+// Historical data selectors
+export const selectRecentFrontendFrameDurations = (state: RootState): number[] =>
+ state.framerate.recentFrontendFrameDurations;
+
+export const selectRecentBackendFrameDurations = (state: RootState): number[] =>
+ state.framerate.recentBackendFrameDurations;
+
+// Calculated average framerates from historical data
+export const selectAverageFramerates = createSelector(
+ [selectRecentFrontendFrameDurations, selectRecentBackendFrameDurations],
+ (frontendDurations, backendDurations) => {
+ const calcAverage = (durations: number[]): number => {
+ if (durations.length === 0) return 0;
+ const sum = durations.reduce((a, b) => a + b, 0);
+ return 1000 / (sum / durations.length); // Convert ms to FPS
+ };
+
+ return {
+ frontend: calcAverage(frontendDurations),
+ backend: calcAverage(backendDurations),
+ };
+ }
+);
+
+// Statistics selectors
+export const selectFramerateStatistics = createSelector(
+ [selectCurrentFrontendFramerate, selectCurrentBackendFramerate],
+ (frontend, backend) => ({
+ frontend: {
+ mean: frontend?.mean_frames_per_second ?? 0,
+ std: frontend?.frame_duration_stddev ?? 0,
+ current: frontend?.mean_frames_per_second ?? 0,
+ },
+ backend: {
+ mean: backend?.mean_frames_per_second ?? 0,
+ std: backend?.frame_duration_stddev ?? 0,
+ current: backend?.mean_frames_per_second ?? 0,
+ },
+ })
+);
+
+// Combined selector for UI components that need all framerate info
+export const selectFramerateInfo = createSelector(
+ [
+ selectCurrentFrontendFramerate,
+ selectCurrentBackendFramerate,
+ selectAverageFramerates,
+ ],
+ (frontend, backend, averages) => ({
+ frontend: {
+ current: frontend?.mean_frames_per_second ?? 0,
+ mean: frontend?.mean_frames_per_second ?? 0,
+ std: frontend?.frame_duration_stddev ?? 0,
+ average: averages.frontend,
+ },
+ backend: {
+ current: backend?.mean_frames_per_second ?? 0,
+ mean: backend?.mean_frames_per_second ?? 0,
+ std: backend?.frame_duration_stddev ?? 0,
+ average: averages.backend,
+ },
+ })
+);
+
+// Selector for all framerate data needed by the viewer components
+export const selectFramerateViewerData = createSelector(
+ [
+ selectCurrentFrontendFramerate,
+ selectCurrentBackendFramerate,
+ selectRecentFrontendFrameDurations,
+ selectRecentBackendFrameDurations,
+ ],
+ (currentFrontendFramerate, currentBackendFramerate, recentFrontendFrameDurations, recentBackendFrameDurations) => ({
+ currentFrontendFramerate,
+ currentBackendFramerate,
+ recentFrontendFrameDurations,
+ recentBackendFrameDurations,
+ })
+);
diff --git a/freemocap-ui-old/src/store/slices/framerate/framerate-slice.ts b/freemocap-ui-old/src/store/slices/framerate/framerate-slice.ts
new file mode 100644
index 00000000..2eb2ac5f
--- /dev/null
+++ b/freemocap-ui-old/src/store/slices/framerate/framerate-slice.ts
@@ -0,0 +1,60 @@
+// framerate-slice.ts
+import {createSlice, PayloadAction} from '@reduxjs/toolkit';
+import {DetailedFramerate} from './framerate-types';
+
+// Export DetailedFramerate as CurrentFramerate for component compatibility
+export type CurrentFramerate = DetailedFramerate;
+
+interface FramerateState {
+ currentBackendFramerate: DetailedFramerate | null;
+ currentFrontendFramerate: DetailedFramerate | null;
+ // Arrays for historical data to calculate averages and render charts
+ recentFrontendFrameDurations: number[];
+ recentBackendFrameDurations: number[];
+}
+
+const initialState: FramerateState = {
+ currentBackendFramerate: null,
+ currentFrontendFramerate: null,
+ recentFrontendFrameDurations: [],
+ recentBackendFrameDurations: [],
+};
+
+const MAX_DURATION_HISTORY = 100; // Keep last 100 frame durations
+
+export const framerateSlice = createSlice({
+ name: 'framerate',
+ initialState,
+ reducers: {
+ backendFramerateUpdated: (state, action: PayloadAction<DetailedFramerate>) => {
+ state.currentBackendFramerate = action.payload;
+ // Add mean frame duration to history
+ if (action.payload.mean_frame_duration_ms > 0) {
+ state.recentBackendFrameDurations = [
+ ...state.recentBackendFrameDurations.slice(-(MAX_DURATION_HISTORY - 1)),
+ action.payload.mean_frame_duration_ms
+ ];
+ }
+ },
+ frontendFramerateUpdated: (state, action: PayloadAction<DetailedFramerate>) => {
+ state.currentFrontendFramerate = action.payload;
+ // Add mean frame duration to history
+ if (action.payload.mean_frame_duration_ms > 0) {
+ state.recentFrontendFrameDurations = [
+ ...state.recentFrontendFrameDurations.slice(-(MAX_DURATION_HISTORY - 1)),
+ action.payload.mean_frame_duration_ms
+ ];
+ }
+ },
+ clearFramerateHistory: (state) => {
+ state.recentFrontendFrameDurations = [];
+ state.recentBackendFrameDurations = [];
+ },
+ },
+});
+
+export const {
+ backendFramerateUpdated,
+ frontendFramerateUpdated,
+ clearFramerateHistory
+} = framerateSlice.actions;
diff --git a/freemocap-ui-old/src/store/slices/framerate/framerate-types.ts b/freemocap-ui-old/src/store/slices/framerate/framerate-types.ts
new file mode 100644
index 00000000..48819b03
--- /dev/null
+++ b/freemocap-ui-old/src/store/slices/framerate/framerate-types.ts
@@ -0,0 +1,37 @@
+// framerate-viewport3d-types.ts
+import {z} from 'zod';
+
+// The actual framerate data structure used in the Redux store
+export const FramerateDataSchema = z.object({
+ mean: z.number(),
+ std: z.number(),
+ current: z.number(),
+});
+
+export type FramerateData = z.infer<typeof FramerateDataSchema>;
+
+// If you have a different schema from the backend with more detailed stats,
+// you can keep it separate for parsing/validation but transform it to FramerateData
+export const DetailedFramerateSchema = z.object({
+ mean_frame_duration_ms: z.number(),
+ mean_frames_per_second: z.number(),
+ frame_duration_max: z.number(),
+ frame_duration_min: z.number(),
+ frame_duration_mean: z.number(),
+ frame_duration_stddev: z.number(),
+ frame_duration_median: z.number(),
+ frame_duration_coefficient_of_variation: z.number(),
+ calculation_window_size: z.number(),
+ framerate_source: z.string(),
+});
+
+export type DetailedFramerate = z.infer<typeof DetailedFramerateSchema>;
+
+// Helper function to convert detailed framerate to simple framerate data
+export function detailedToSimpleFramerate(detailed: DetailedFramerate): FramerateData {
+ return {
+ mean: detailed.mean_frames_per_second,
+ std: detailed.frame_duration_stddev,
+ current: detailed.mean_frames_per_second, // or calculate from mean_frame_duration_ms
+ };
+}
diff --git a/freemocap-ui-old/src/store/slices/framerate/index.ts b/freemocap-ui-old/src/store/slices/framerate/index.ts
new file mode 100644
index 00000000..cbf3bf84
--- /dev/null
+++ b/freemocap-ui-old/src/store/slices/framerate/index.ts
@@ -0,0 +1,3 @@
+export * from './framerate-slice';
+export * from './framerate-types';
+export * from './framerate-selectors';
diff --git a/freemocap-ui-old/src/store/slices/log-records/index.ts b/freemocap-ui-old/src/store/slices/log-records/index.ts
new file mode 100644
index 00000000..e48b73b3
--- /dev/null
+++ b/freemocap-ui-old/src/store/slices/log-records/index.ts
@@ -0,0 +1,3 @@
+export * from './log-records-slice';
+export * from './logs-types';
+export * from './logs-selectors';
diff --git a/freemocap-ui-old/src/store/slices/log-records/log-records-slice.ts b/freemocap-ui-old/src/store/slices/log-records/log-records-slice.ts
new file mode 100644
index 00000000..8924cc42
--- /dev/null
+++ b/freemocap-ui-old/src/store/slices/log-records/log-records-slice.ts
@@ -0,0 +1,86 @@
+// log-records-slice.ts
+import {createSlice, PayloadAction} from '@reduxjs/toolkit';
+import {LogRecord} from './logs-types';
+
+interface LogRecordsState {
+ entries: LogRecord[];
+ maxEntries: number;
+ isPaused: boolean;
+ filter: {
+ levels: string[];
+ searchText: string;
+ };
+}
+
+const initialState: LogRecordsState = {
+ entries: [],
+ maxEntries: 1000,
+ isPaused: false,
+ filter: {
+ levels: [],
+ searchText: '',
+ },
+};
+
+export const logRecordsSlice = createSlice({
+ name: 'logs',
+ initialState,
+ reducers: {
+ logAdded: (state, action: PayloadAction<LogRecord>) => {
+ if (state.isPaused) return;
+
+ state.entries.push(action.payload);
+
+ // Keep only the last maxEntries
+ if (state.entries.length > state.maxEntries) {
+ state.entries = state.entries.slice(-state.maxEntries);
+ }
+ },
+
+ logsAdded: (state, action: PayloadAction<LogRecord[]>) => {
+ if (state.isPaused) return;
+
+ state.entries.push(...action.payload);
+
+ // Keep only the last maxEntries
+ if (state.entries.length > state.maxEntries) {
+ state.entries = state.entries.slice(-state.maxEntries);
+ }
+ },
+
+ logsCleared: (state) => {
+ state.entries = [];
+ },
+
+ logsPaused: (state, action: PayloadAction<boolean>) => {
+ state.isPaused = action.payload;
+ },
+
+ logsFiltered: (state, action: PayloadAction<{ levels?: string[]; searchText?: string }>) => {
+ if (action.payload.levels !== undefined) {
+ state.filter.levels = action.payload.levels;
+ }
+ if (action.payload.searchText !== undefined) {
+ state.filter.searchText = action.payload.searchText;
+ }
+ },
+
+ maxEntriesUpdated: (state, action: PayloadAction<number>) => {
+ state.maxEntries = action.payload;
+
+ // Trim entries if new max is smaller
+ if (state.entries.length > action.payload) {
+ state.entries = state.entries.slice(-action.payload);
+ }
+ },
+ },
+});
+
+export const {
+ logAdded,
+ logsAdded,
+ logsCleared,
+ logsPaused,
+ logsFiltered,
+ maxEntriesUpdated
+} = logRecordsSlice.actions;
diff --git a/freemocap-ui-old/src/store/slices/log-records/logs-selectors.ts b/freemocap-ui-old/src/store/slices/log-records/logs-selectors.ts
new file mode 100644
index 00000000..3f1905ed
--- /dev/null
+++ b/freemocap-ui-old/src/store/slices/log-records/logs-selectors.ts
@@ -0,0 +1,96 @@
+// logs-selectors.ts
+import {createSelector} from '@reduxjs/toolkit';
+import {RootState} from '../../types';
+import {LogRecord} from './logs-types';
+
+// Basic selectors
+export const selectAllLogs = (state: RootState): LogRecord[] =>
+ state.logs.entries;
+
+export const selectLogsPaused = (state: RootState): boolean =>
+ state.logs.isPaused;
+
+export const selectLogsFilter = (state: RootState) =>
+ state.logs.filter;
+
+export const selectMaxLogEntries = (state: RootState): number =>
+ state.logs.maxEntries;
+
+// Filtered logs based on current filter settings
+export const selectFilteredLogs = createSelector(
+ [selectAllLogs, selectLogsFilter],
+ (logs, filter) => {
+ let filtered = logs;
+
+ // Filter by levels if any are selected
+ if (filter.levels.length > 0) {
+ filtered = filtered.filter(log =>
+ filter.levels.includes(log.levelname.toLowerCase())
+ );
+ }
+
+ // Filter by search text if provided
+ if (filter.searchText) {
+ const searchLower = filter.searchText.toLowerCase();
+ filtered = filtered.filter(log =>
+ log.message.toLowerCase().includes(searchLower) ||
+ log.module.toLowerCase().includes(searchLower) ||
+ log.funcName.toLowerCase().includes(searchLower) ||
+ log.formatted_message?.toLowerCase().includes(searchLower)
+ );
+ }
+
+ return filtered;
+ }
+);
+
+// Get logs by specific level
+export const selectLogsByLevel = createSelector(
+ [selectAllLogs, (_: RootState, level: string) => level],
+ (logs, level) => logs.filter(log => log.levelname === level)
+);
+
+// Get recent logs (last N entries)
+export const selectRecentLogs = createSelector(
+ [selectAllLogs, (_: RootState, count: number = 10) => count],
+ (logs, count) => logs.slice(-count)
+);
+
+// Get filtered recent logs
+export const selectRecentFilteredLogs = createSelector(
+ [selectFilteredLogs, (_: RootState, count: number = 10) => count],
+ (logs, count) => logs.slice(-count)
+);
+
+// Count logs by level
+export const selectLogCountsByLevel = createSelector(
+ [selectAllLogs],
+ (logs) => {
+ const counts: Record<string, number> = {};
+ logs.forEach(log => {
+ const level = log.levelname;
+ counts[level] = (counts[level] || 0) + 1;
+ });
+ return counts;
+ }
+);
+
+// Get error and critical logs
+export const selectErrorLogs = createSelector(
+ [selectAllLogs],
+ (logs) => logs.filter(log =>
+ log.levelname === 'ERROR' || log.levelname === 'CRITICAL'
+ )
+);
+
+// Check if there are any errors
+export const selectHasErrors = createSelector(
+ [selectErrorLogs],
+ (errorLogs) => errorLogs.length > 0
+);
+
+// Get the most recent error
+export const selectMostRecentError = createSelector(
+ [selectErrorLogs],
+ (errorLogs) => errorLogs[errorLogs.length - 1] || null
+);
diff --git a/freemocap-ui-old/src/store/slices/log-records/logs-types.ts b/freemocap-ui-old/src/store/slices/log-records/logs-types.ts
new file mode 100644
index 00000000..d899112c
--- /dev/null
+++ b/freemocap-ui-old/src/store/slices/log-records/logs-types.ts
@@ -0,0 +1,31 @@
+import {z} from 'zod';
+
+export const LogRecordSchema = z.object({
+ name: z.string(),
+ msg: z.string().nullable().default(""),
+ args: z.array(z.any()),
+ levelname: z.string(),
+ levelno: z.number(),
+ pathname: z.string(),
+ filename: z.string(),
+ module: z.string(),
+ exc_info: z.string().nullable(),
+ exc_text: z.string().nullable(),
+ stack_info: z.string().nullable(),
+ lineno: z.number(),
+ funcName: z.string(),
+ created: z.number(),
+ msecs: z.number(),
+ relativeCreated: z.number(),
+ thread: z.number(),
+ threadName: z.string(),
+ processName: z.string(),
+ process: z.number(),
+ delta_t: z.string(),
+ message: z.string(),
+ asctime: z.string(),
+ formatted_message: z.string(),
+ type: z.string(),
+});
+
+export type LogRecord = z.infer<typeof LogRecordSchema>;
diff --git a/freemocap-ui-old/src/store/slices/mocap/index.ts b/freemocap-ui-old/src/store/slices/mocap/index.ts
new file mode 100644
index 00000000..f3a3b8e3
--- /dev/null
+++ b/freemocap-ui-old/src/store/slices/mocap/index.ts
@@ -0,0 +1,3 @@
+
+export * from './mocap-slice';
+export * from './mocap-thunks';
diff --git a/freemocap-ui-old/src/store/slices/mocap/mocap-slice.ts b/freemocap-ui-old/src/store/slices/mocap/mocap-slice.ts
new file mode 100644
index 00000000..3309db49
--- /dev/null
+++ b/freemocap-ui-old/src/store/slices/mocap/mocap-slice.ts
@@ -0,0 +1,337 @@
+import {createSelector, createSlice, PayloadAction} from '@reduxjs/toolkit';
+import {RootState} from '../../types';
+import {
+ processMocapRecording,
+ startMocapRecording,
+ stopMocapRecording,
+ updateMocapConfigOnServer,
+} from "@/store/slices/mocap/mocap-thunks";
+
+// ==================== Types ====================
+
+/**
+ * Mirrors skellytracker MediapipeModelComplexity enum.
+ * 0 = LITE (fastest), 1 = FULL (balanced), 2 = HEAVY (most accurate)
+ */
+export type MediapipeModelComplexity = 0 | 1 | 2;
+
+/**
+ * Mirrors skellytracker MediapipeDetectorConfig.
+ * Field names use snake_case to match the backend JSON.
+ */
+export interface MediapipeDetectorConfig {
+ model_complexity: MediapipeModelComplexity;
+ min_detection_confidence: number;
+ min_tracking_confidence: number;
+ confidence_threshold: number;
+ static_image_mode: boolean;
+ smooth_landmarks: boolean;
+ enable_segmentation: boolean;
+ smooth_segmentation: boolean;
+ refine_face_landmarks: boolean;
+}
+
+/**
+ * Mirrors backend EstimatorConfig (bone length estimation tuning).
+ */
+export interface EstimatorConfig {
+ max_samples: number;
+ min_samples_for_full_confidence: number;
+ iqr_confidence_sensitivity: number;
+}
+
+/**
+ * Mirrors backend RealtimeFilterConfig (skeleton smoothing + gating).
+ * Field names use snake_case to match the backend JSON.
+ */
+export interface RealtimeFilterConfig {
+ // One Euro Filter params
+ min_cutoff: number;
+ beta: number;
+ d_cutoff: number;
+ // FABRIK params
+ fabrik_tolerance: number;
+ fabrik_max_iterations: number;
+ // Bone length estimation params
+ height_meters: number;
+ noise_sigma: number;
+ estimator_config: EstimatorConfig;
+ // Point gate params
+ max_reprojection_error_px: number;
+ max_velocity_m_per_s: number;
+ max_rejected_streak: number;
+ // Prediction params
+ max_prediction_frames: number;
+ prediction_velocity_decay: number;
+}
+
+/**
+ * Mirrors backend MocapPipelineConfig.
+ */
+export interface MocapConfig {
+ detector: MediapipeDetectorConfig;
+ skeleton_filter: RealtimeFilterConfig;
+}
+
+/** Realtime preset matching MEDIAPIPE_TRACKER_REALTIME_PRESET on the backend. */
+export const MEDIAPIPE_REALTIME_PRESET: MediapipeDetectorConfig = {
+ model_complexity: 0,
+ min_detection_confidence: 0.5,
+ min_tracking_confidence: 0.5,
+ confidence_threshold: 0.5,
+ static_image_mode: false,
+ smooth_landmarks: true,
+ enable_segmentation: false,
+ smooth_segmentation: false,
+ refine_face_landmarks: true,
+};
+
+/** Posthoc preset matching MEDIAPIPE_TRACKER_POSTHOC_PRESET on the backend. */
+export const MEDIAPIPE_POSTHOC_PRESET: MediapipeDetectorConfig = {
+ model_complexity: 2,
+ min_detection_confidence: 0.5,
+ min_tracking_confidence: 0.5,
+ confidence_threshold: 0.5,
+ static_image_mode: false,
+ smooth_landmarks: true,
+ enable_segmentation: true,
+ smooth_segmentation: true,
+ refine_face_landmarks: true,
+};
+
+/** Default EstimatorConfig matching backend defaults. */
+export const DEFAULT_ESTIMATOR_CONFIG: EstimatorConfig = {
+ max_samples: 500,
+ min_samples_for_full_confidence: 100,
+ iqr_confidence_sensitivity: 10.0,
+};
+
+/** Default RealtimeFilterConfig matching backend defaults. */
+export const DEFAULT_REALTIME_FILTER_CONFIG: RealtimeFilterConfig = {
+ min_cutoff: 0.005,
+ beta: 0.3,
+ d_cutoff: 1.0,
+ fabrik_tolerance: 1e-4,
+ fabrik_max_iterations: 20,
+ height_meters: 1.75,
+ noise_sigma: 0.015,
+ estimator_config: { ...DEFAULT_ESTIMATOR_CONFIG },
+ max_reprojection_error_px: 60.0,
+ max_velocity_m_per_s: 50.0,
+ max_rejected_streak: 5,
+ max_prediction_frames: 15,
+ prediction_velocity_decay: 0.75,
+};
+
+export interface MocapDirectoryInfo {
+ exists: boolean;
+ canRecord: boolean;
+ canCalibrate: boolean;
+ cameraMocapTomlPath: string | null;
+ hasSynchronizedVideos: boolean;
+ hasVideos: boolean;
+ errorMessage: string | null;
+}
+
+export interface MocapState {
+ config: MocapConfig;
+ isRecording: boolean;
+ recordingProgress: number;
+ isLoading: boolean;
+ error: string | null;
+ lastMocapRecordingPath: string | null;
+ manualMocapRecordingPath: string | null;
+ directoryInfo: MocapDirectoryInfo | null;
+}
+
+// ==================== Initial State ====================
+
+const initialState: MocapState = {
+ config: {
+ detector: { ...MEDIAPIPE_REALTIME_PRESET },
+ skeleton_filter: { ...DEFAULT_REALTIME_FILTER_CONFIG },
+ },
+ isRecording: false,
+ recordingProgress: 0,
+ isLoading: false,
+ error: null,
+ lastMocapRecordingPath: null,
+ manualMocapRecordingPath: null,
+ directoryInfo: null,
+};
+
+// ==================== Slice ====================
+
+export const mocapSlice = createSlice({
+ name: 'mocap',
+ initialState,
+ reducers: {
+ /** Replace the entire detector config (e.g. applying a preset). */
+ mocapDetectorConfigReplaced: (state, action: PayloadAction<MediapipeDetectorConfig>) => {
+ state.config.detector = action.payload;
+ },
+
+ /** Partially update individual detector fields. */
+ mocapDetectorConfigUpdated: (state, action: PayloadAction<Partial<MediapipeDetectorConfig>>) => {
+ state.config.detector = { ...state.config.detector, ...action.payload };
+ },
+
+ /** Replace the entire skeleton filter config. */
+ skeletonFilterConfigReplaced: (state, action: PayloadAction<RealtimeFilterConfig>) => {
+ state.config.skeleton_filter = action.payload;
+ },
+
+ /** Partially update individual skeleton filter fields. */
+ skeletonFilterConfigUpdated: (state, action: PayloadAction<Partial<RealtimeFilterConfig>>) => {
+ state.config.skeleton_filter = { ...state.config.skeleton_filter, ...action.payload };
+ },
+
+ mocapProgressUpdated: (state, action: PayloadAction<number>) => {
+ state.recordingProgress = action.payload;
+ },
+
+ mocapErrorCleared: (state) => {
+ state.error = null;
+ },
+
+ manualMocapRecordingPathChanged: (state, action: PayloadAction<string>) => {
+ state.manualMocapRecordingPath = action.payload;
+ },
+
+ manualMocapRecordingPathCleared: (state) => {
+ state.manualMocapRecordingPath = null;
+ },
+
+ mocapDirectoryInfoUpdated: (state, action: PayloadAction<MocapDirectoryInfo>) => {
+ state.directoryInfo = action.payload;
+ },
+
+ resetMocapState: () => initialState,
+ },
+
+ extraReducers: (builder) => {
+ builder
+ .addCase(startMocapRecording.pending, (state) => {
+ state.isLoading = true;
+ state.error = null;
+ })
+ .addCase(startMocapRecording.fulfilled, (state, action) => {
+ state.isLoading = false;
+ state.isRecording = true;
+ state.recordingProgress = 0;
+ if (action.payload.mocapRecordingPath) {
+ state.lastMocapRecordingPath = action.payload.mocapRecordingPath;
+ }
+ })
+ .addCase(startMocapRecording.rejected, (state, action) => {
+ state.isLoading = false;
+ state.error = action.payload || 'Failed to start recording';
+ });
+
+ builder
+ .addCase(stopMocapRecording.pending, (state) => {
+ state.isLoading = true;
+ state.error = null;
+ })
+ .addCase(stopMocapRecording.fulfilled, (state) => {
+ state.isLoading = false;
+ state.isRecording = false;
+ state.recordingProgress = 0;
+ })
+ .addCase(stopMocapRecording.rejected, (state, action) => {
+ state.isLoading = false;
+ state.error = action.payload || 'Failed to stop recording';
+ });
+
+ builder
+ .addCase(processMocapRecording.pending, (state) => {
+ state.isLoading = true;
+ state.error = null;
+ })
+ .addCase(processMocapRecording.fulfilled, (state) => {
+ state.isLoading = false;
+ })
+ .addCase(processMocapRecording.rejected, (state, action) => {
+ state.isLoading = false;
+ state.error = action.payload || 'Failed to process recording';
+ });
+
+ builder
+ .addCase(updateMocapConfigOnServer.rejected, (state, action) => {
+ state.error = action.payload || 'Failed to sync config to server';
+ });
+ },
+});
+
+// ==================== Selectors ====================
+
+export const selectMocap = (state: RootState) => state.mocap;
+export const selectMocapConfig = (state: RootState) => state.mocap.config;
+export const selectMocapDetectorConfig = (state: RootState) => state.mocap.config.detector;
+export const selectSkeletonFilterConfig = (state: RootState) => state.mocap.config.skeleton_filter;
+export const selectMocapIsLoading = (state: RootState) => state.mocap.isLoading;
+export const selectMocapIsRecording = (state: RootState) => state.mocap.isRecording;
+export const selectMocapProgress = (state: RootState) => state.mocap.recordingProgress;
+export const selectMocapError = (state: RootState) => state.mocap.error;
+export const selectMocapDirectoryInfo = (state: RootState) => state.mocap.directoryInfo;
+
+export const selectMocapRecordingPath = createSelector(
+ [
+ (state: RootState) => state.mocap.manualMocapRecordingPath,
+ (state: RootState) => state.mocap.lastMocapRecordingPath,
+ (state: RootState) => state.recording.computed,
+ ],
+ (manualPath, lastPath, recordingComputed) => {
+ if (manualPath) return manualPath;
+ if (lastPath) return lastPath;
+
+ const mocapFolderName = `${recordingComputed.recordingName}_mocap`;
+ return `${recordingComputed.fullRecordingPath}/${mocapFolderName}`;
+ }
+);
+
+export const selectIsUsingManualMocapPath = createSelector(
+ [(state: RootState) => state.mocap.manualMocapRecordingPath],
+ (manualPath) => manualPath !== null
+);
+
+export const selectCanStartMocapRecording = createSelector(
+ [
+ selectMocapIsRecording,
+ selectMocapIsLoading,
+ selectMocapRecordingPath,
+ selectMocapDirectoryInfo
+ ],
+ (isRecording, isLoading, recordingPath, directoryInfo) => {
+ return !isRecording && !isLoading && !!recordingPath && (directoryInfo?.canRecord ?? true);
+ }
+);
+
+export const selectCanProcessMocapRecording = createSelector(
+ [
+ selectMocapRecordingPath,
+ selectMocapIsLoading,
+ selectMocapIsRecording,
+ selectMocapDirectoryInfo
+ ],
+ (mocapPath, isLoading, isRecording, directoryInfo) => {
+ return !!mocapPath && !isLoading && !isRecording && (directoryInfo?.canCalibrate ?? false);
+ }
+);
+
+// ==================== Actions Export ====================
+
+export const {
+ mocapDetectorConfigReplaced,
+ mocapDetectorConfigUpdated,
+ skeletonFilterConfigReplaced,
+ skeletonFilterConfigUpdated,
+ mocapProgressUpdated,
+ mocapErrorCleared,
+ manualMocapRecordingPathChanged,
+ manualMocapRecordingPathCleared,
+ mocapDirectoryInfoUpdated,
+ resetMocapState
+} = mocapSlice.actions;
+
+export default mocapSlice.reducer;
diff --git a/freemocap-ui-old/src/store/slices/mocap/mocap-thunks.ts b/freemocap-ui-old/src/store/slices/mocap/mocap-thunks.ts
new file mode 100644
index 00000000..9785476c
--- /dev/null
+++ b/freemocap-ui-old/src/store/slices/mocap/mocap-thunks.ts
@@ -0,0 +1,169 @@
+import {createAsyncThunk} from "@reduxjs/toolkit";
+import {RootState} from "@/store";
+import {serverUrls} from "@/hooks/server-urls";
+import {selectMocapRecordingPath} from "./mocap-slice";
+import {getDetailedErrorMessage} from "@/store/slices/thunk-helpers";
+
+export const startMocapRecording = createAsyncThunk<
+ { success: boolean; message?: string; mocapRecordingPath?: string },
+ void,
+ { state: RootState; rejectValue: string }
+>(
+ 'mocap/startRecording',
+ async (_, { getState, rejectWithValue }) => {
+ try {
+ const state = getState();
+ const mocapTaskConfig = state.mocap.config;
+ const mocapRecordingDirectory = selectMocapRecordingPath(state);
+
+ if (!mocapRecordingDirectory) {
+ return rejectWithValue('Recording directory is not set');
+ }
+
+ console.log('🎬 Starting mocap recording with:', {
+ mocapRecordingDirectory,
+ mocapTaskConfig,
+ });
+
+ const response = await fetch(serverUrls.endpoints.mocapStartRecording, {
+ method: 'POST',
+ headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify({
+ mocapRecordingDirectory,
+ mocapTaskConfig,
+ }),
+ });
+
+ if (!response.ok) {
+ const errorMessage = await getDetailedErrorMessage(response);
+ return rejectWithValue(errorMessage);
+ }
+
+ const result = await response.json();
+ console.log('✅ Started mocap recording:', result);
+ return result;
+ } catch (error) {
+ const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+ console.error('❌ Failed to start mocap recording:', errorMessage);
+ return rejectWithValue(errorMessage);
+ }
+ }
+);
+
+export const stopMocapRecording = createAsyncThunk<
+ { success: boolean },
+ void,
+ { state: RootState; rejectValue: string }
+>(
+ 'mocap/stopRecording',
+ async (_, { getState, rejectWithValue }) => {
+ try {
+ const state = getState();
+ const mocapTaskConfig = state.mocap.config;
+
+
+ console.log(`🎬 Stoping mocap recording and starting mocap with: ${JSON.stringify(mocapTaskConfig, null, 2)}`);
+
+
+ const response = await fetch(serverUrls.endpoints.mocapStopRecording, {
+ method: 'POST',
+ headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify({mocapTaskConfig}),
+ });
+
+ if (!response.ok) {
+ const errorMessage = await getDetailedErrorMessage(response);
+ return rejectWithValue(errorMessage);
+ }
+
+ const result = await response.json();
+ console.log('✅ Stopped mocap recording:', result);
+ return result;
+ } catch (error) {
+ const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+ console.error('❌ Failed to stop mocap recording:', errorMessage);
+ return rejectWithValue(errorMessage);
+ }
+ }
+);
+
+export const processMocapRecording = createAsyncThunk<
+ { success: boolean; message?: string; results?: unknown },
+ void,
+ { state: RootState; rejectValue: string }
+>(
+ 'mocap/processMocapRecording',
+ async (_, { getState, rejectWithValue }) => {
+ try {
+ const state = getState();
+ const mocapTaskConfig = state.mocap.config;
+ const mocapRecordingDirectory = selectMocapRecordingPath(state);
+
+ if (!mocapRecordingDirectory) {
+ return rejectWithValue('No mocap recording path available. Please set a recording directory or record a mocap first.');
+ }
+
+ console.log('🔧 Calibrating recording:', {
+ mocapRecordingDirectory,
+ mocapTaskConfig,
+ });
+
+ const response = await fetch(serverUrls.endpoints.processMocapRecording, {
+ method: 'POST',
+ headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify({
+ mocapRecordingDirectory,
+ mocapTaskConfig,
+ }),
+ });
+
+ if (!response.ok) {
+ const errorMessage = await getDetailedErrorMessage(response);
+ return rejectWithValue(errorMessage);
+ }
+
+ const result = await response.json();
+ console.log('✅ Mocap completed:', result);
+ return result;
+ } catch (error) {
+ const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+ console.error('❌ Failed to process recording:', errorMessage);
+ return rejectWithValue(errorMessage);
+ }
+ }
+);
+
+export const updateMocapConfigOnServer = createAsyncThunk<
+ { success: boolean; message?: string },
+ void,
+ { state: RootState; rejectValue: string }
+>(
+ 'mocap/updateConfig',
+ async (_, { getState, rejectWithValue }) => {
+ try {
+ const state = getState();
+ const config = state.mocap.config;
+
+ console.log('⚙️ Updating mocap config on server:', config);
+
+ const response = await fetch(serverUrls.endpoints.updateMocapConfig, {
+ method: 'POST',
+ headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify({ config }),
+ });
+
+ if (!response.ok) {
+ const errorMessage = await getDetailedErrorMessage(response);
+ return rejectWithValue(errorMessage);
+ }
+
+ const result = await response.json();
+ console.log('✅ Config updated on server:', result);
+ return result;
+ } catch (error) {
+ const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+ console.error('❌ Failed to update config on server:', errorMessage);
+ return rejectWithValue(errorMessage);
+ }
+ }
+);
diff --git a/freemocap-ui-old/src/store/slices/pipeline/index.ts b/freemocap-ui-old/src/store/slices/pipeline/index.ts
new file mode 100644
index 00000000..09453243
--- /dev/null
+++ b/freemocap-ui-old/src/store/slices/pipeline/index.ts
@@ -0,0 +1,4 @@
+export * from './pipeline-slice';
+export * from './pipeline-selectors';
+export * from './pipeline-thunks';
+export * from './pipeline-types';
diff --git a/freemocap-ui-old/src/store/slices/pipeline/pipeline-selectors.ts b/freemocap-ui-old/src/store/slices/pipeline/pipeline-selectors.ts
new file mode 100644
index 00000000..74365541
--- /dev/null
+++ b/freemocap-ui-old/src/store/slices/pipeline/pipeline-selectors.ts
@@ -0,0 +1,34 @@
+// basic selectors
+import {RootState} from "@/store";
+import {createSelector} from "@reduxjs/toolkit";
+
+export const selectPipelineState = (state: RootState) => state.pipeline;
+export const selectIsPipelineConnected = (state: RootState) => state.pipeline.isConnected;
+export const selectPipelineId = (state: RootState) => state.pipeline.pipelineId;
+export const selectCameraGroupId = (state: RootState) => state.pipeline.cameraGroupId;
+export const selectIsPipelineLoading = (state: RootState) => state.pipeline.isLoading;
+export const selectPipelineError = (state: RootState) => state.pipeline.error;
+
+// derived selectors
+export const selectPipelineInfo = createSelector(
+ [selectIsPipelineConnected, selectPipelineId, selectCameraGroupId],
+ (isConnected, pipelineId, cameraGroupId) => ({
+ isConnected,
+ pipelineId,
+ cameraGroupId,
+ })
+);
+
+export const selectCanConnectPipeline = createSelector(
+ [selectIsPipelineConnected, selectIsPipelineLoading, (state: RootState) => state.cameras.cameras],
+ (isConnected, isLoading, cameras) => {
+ const anyCameraSelected = cameras.some(cam => cam.selected);
+ return !isConnected && !isLoading && anyCameraSelected;
+ }
+);
+
+export const selectCanDisconnectPipeline = createSelector(
+ [selectIsPipelineConnected, selectIsPipelineLoading],
+ (isConnected, isLoading) => isConnected && !isLoading
+);
+
diff --git a/freemocap-ui-old/src/store/slices/pipeline/pipeline-slice.ts b/freemocap-ui-old/src/store/slices/pipeline/pipeline-slice.ts
new file mode 100644
index 00000000..c8ab05c8
--- /dev/null
+++ b/freemocap-ui-old/src/store/slices/pipeline/pipeline-slice.ts
@@ -0,0 +1,82 @@
+import {createSlice} from "@reduxjs/toolkit";
+import {PipelineState} from "@/store/slices/pipeline/pipeline-types";
+import {closePipeline, connectRealtimePipeline} from "@/store/slices/pipeline/pipeline-thunks";
+import {serverSettingsCleared, serverSettingsUpdated} from "@/store/slices/settings/settings-slice";
+
+const initialState: PipelineState = {
+ cameraGroupId: null,
+ pipelineId: null,
+ isConnected: false,
+ isLoading: false,
+ error: null,
+}
+
+export const pipelineSlice = createSlice({
+ name: 'pipeline',
+ initialState,
+ reducers: {
+ pipelineStateReset: (state) => {
+ state.cameraGroupId = null;
+ state.pipelineId = null;
+ state.isConnected = false;
+ state.isLoading = false;
+ state.error = null;
+ }
+ },
+ extraReducers: (builder) => {
+ builder
+ // ========== Connect Pipeline (HTTP) ==========
+ .addCase(connectRealtimePipeline.pending, (state) => {
+ state.isLoading = true;
+ state.error = null;
+ })
+ .addCase(connectRealtimePipeline.fulfilled, (state, action) => {
+ state.cameraGroupId = action.payload.camera_group_id;
+ state.pipelineId = action.payload.pipeline_id;
+ state.isConnected = true;
+ state.isLoading = false;
+ })
+ .addCase(connectRealtimePipeline.rejected, (state, action) => {
+ state.isLoading = false;
+ state.error = action.error.message || 'Failed to connect pipeline';
+ })
+
+ // ========== Close Pipeline (HTTP) ==========
+ .addCase(closePipeline.pending, (state) => {
+ state.isLoading = true;
+ state.error = null;
+ })
+ .addCase(closePipeline.fulfilled, (state) => {
+ state.cameraGroupId = null;
+ state.pipelineId = null;
+ state.isConnected = false;
+ state.isLoading = false;
+ })
+ .addCase(closePipeline.rejected, (state, action) => {
+ state.isLoading = false;
+ state.error = action.error.message || 'Failed to disconnect pipeline';
+ })
+
+ // ========== WebSocket settings/state — sync pipeline status ==========
+ .addCase(serverSettingsUpdated, (state, action) => {
+ const backendPipeline = action.payload.settings.pipeline;
+ // Only overwrite if not mid-HTTP-request (isLoading guards against races)
+ if (!state.isLoading) {
+ state.isConnected = backendPipeline.is_connected;
+ state.pipelineId = backendPipeline.pipeline_id;
+ state.cameraGroupId = backendPipeline.camera_group_id;
+ }
+ })
+
+ // ========== WebSocket disconnected — clear pipeline state ==========
+ .addCase(serverSettingsCleared, (state) => {
+ state.cameraGroupId = null;
+ state.pipelineId = null;
+ state.isConnected = false;
+ state.isLoading = false;
+ state.error = null;
+ });
+ },
+});
+
+export const {pipelineStateReset} = pipelineSlice.actions;
diff --git a/freemocap-ui-old/src/store/slices/pipeline/pipeline-thunks.ts b/freemocap-ui-old/src/store/slices/pipeline/pipeline-thunks.ts
new file mode 100644
index 00000000..1815b84c
--- /dev/null
+++ b/freemocap-ui-old/src/store/slices/pipeline/pipeline-thunks.ts
@@ -0,0 +1,56 @@
+import {createAsyncThunk} from "@reduxjs/toolkit";
+import {RootState, selectSelectedCameraConfigs} from "@/store";
+import {serverUrls} from "@/services";
+import {PipelineConnectRequest, PipelineConnectResponse,} from "@/store/slices/pipeline/pipeline-types";
+
+export const connectRealtimePipeline = createAsyncThunk<
+ PipelineConnectResponse,
+ PipelineConnectRequest | undefined,
+ { state: RootState }>(
+ 'pipeline/connect',
+ async (request={}, {getState}) => {
+ const state = getState();
+
+ const cameraConfigs = selectSelectedCameraConfigs(state);
+ const response = await fetch(serverUrls.endpoints.pipelineConnectOrUpdate, {
+ method: 'POST',
+ headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify({ camera_configs: cameraConfigs, ...request }),
+ });
+
+ if (!response.ok) {
+ const error = await response.json()
+ throw new Error(`Failed to connect pipeline: ${error.message || response.statusText}`);
+ }
+ return await response.json() as Promise<PipelineConnectResponse>;
+ })
+
+
+export const closePipeline = createAsyncThunk<void, void, { state: RootState }>(
+ 'pipeline/close',
+ async () => {
+ const response = await fetch(serverUrls.endpoints.pipelineClose, {
+ method: 'DELETE',
+ });
+
+ if (!response.ok) {
+ console.error(`Failed to close pipeline: ${response.statusText}`);
+ }
+ }
+);
+
+
+
+
+export const pauseUnpausePipeline = createAsyncThunk<void, void, { state: RootState }>(
+ 'cameras/pause',
+ async () => {
+ const response = await fetch(serverUrls.endpoints.pipelinePauseUnpause, {
+ method: 'GET',
+ });
+
+ if (!response.ok) {
+ throw new Error(`Failed to pause/unpause cameras: ${response.statusText}`);
+ }
+ }
+);
diff --git a/freemocap-ui-old/src/store/slices/pipeline/pipeline-types.ts b/freemocap-ui-old/src/store/slices/pipeline/pipeline-types.ts
new file mode 100644
index 00000000..1444992c
--- /dev/null
+++ b/freemocap-ui-old/src/store/slices/pipeline/pipeline-types.ts
@@ -0,0 +1,45 @@
+import {z} from 'zod';
+import {CameraConfig} from "@/store";
+
+// ==================== API Request/Response Types ====================
+export interface PipelineConnectRequest {
+ camera_configs?: string[];
+}
+
+export interface PipelineConnectResponse {
+ camera_group_id: string;
+ pipeline_id: string;
+ camera_configs: Record<string, CameraConfig>;
+}
+
+// ==================== Pipeline State ====================
+export interface PipelineState {
+ cameraGroupId: string | null;
+ pipelineId: string | null;
+ isConnected: boolean;
+ isLoading: boolean;
+ error: string | null;
+}
+
+
+const ProcessingPipelineConfigSchema = z.object({
+ pipeline_id: z.string(),
+ parameters: z.record(z.string(), z.any()),
+})
+
+
+export type ProcessingPipelineConfig = z.infer<typeof ProcessingPipelineConfigSchema>;
+export interface ProcessingPipeline {
+ id: string;
+ name: string;
+ isActive: boolean;
+ config: ProcessingPipelineConfig
+}
+
+export interface ProcessingPipelineState {
+ pipelines: ProcessingPipeline[];
+ isLoading: boolean;
+ isActive: boolean;
+ error: string | null;
+}
+
diff --git a/freemocap-ui-old/src/store/slices/recording/index.ts b/freemocap-ui-old/src/store/slices/recording/index.ts
new file mode 100644
index 00000000..bc073c3e
--- /dev/null
+++ b/freemocap-ui-old/src/store/slices/recording/index.ts
@@ -0,0 +1,3 @@
+export * from './recording-slice';
+export * from './recording-types';
+export * from './recording-thunks';
diff --git a/freemocap-ui-old/src/store/slices/recording/recording-slice.ts b/freemocap-ui-old/src/store/slices/recording/recording-slice.ts
new file mode 100644
index 00000000..255dd726
--- /dev/null
+++ b/freemocap-ui-old/src/store/slices/recording/recording-slice.ts
@@ -0,0 +1,197 @@
+import {createSlice, PayloadAction} from '@reduxjs/toolkit';
+import {ComputedRecordingPath, RecordingConfig, RecordingInfo} from './recording-types';
+import {startRecording, stopRecording} from './recording-thunks';
+
+const getTimestampString = (): string => {
+ const now = new Date();
+
+ const dateOptions: Intl.DateTimeFormatOptions = {
+ year: "numeric",
+ month: "2-digit",
+ day: "2-digit",
+ hour: "2-digit",
+ minute: "2-digit",
+ second: "2-digit",
+ hour12: false,
+ timeZoneName: "shortOffset",
+ };
+
+ const formatter = new Intl.DateTimeFormat("en-US", dateOptions);
+ const parts = formatter.formatToParts(now);
+
+ const partMap: Record<string, string> = {};
+ parts.forEach((part) => {
+ partMap[part.type] = part.value;
+ });
+
+ return `${partMap.year}-${partMap.month}-${partMap.day}_${partMap.hour}-${partMap.minute}-${partMap.second}_${partMap.timeZoneName.replace(":", "")}`;
+};
+
+const computeRecordingPath = (
+ recordingDirectory: string,
+ config: RecordingConfig
+): ComputedRecordingPath => {
+ const parts: string[] = [];
+
+ if (config.useTimestamp) {
+ parts.push(getTimestampString());
+ } else {
+ parts.push(config.baseName);
+ }
+
+ if (config.useIncrement) {
+ parts.push(String(config.currentIncrement).padStart(3, '0'));
+ }
+
+ if (config.recordingTag) {
+ parts.push(config.recordingTag);
+ }
+
+ const recordingName = parts.join("_");
+
+ const subfolderName = config.createSubfolder
+ ? config.customSubfolderName || getTimestampString()
+ : "";
+
+ const fullRecordingPath = config.createSubfolder
+ ? `${recordingDirectory}/${subfolderName}`
+ : recordingDirectory;
+
+ return {
+ recordingName,
+ subfolderName,
+ fullRecordingPath,
+ };
+};
+
+const initialState: RecordingInfo = {
+ isRecording: false,
+ recordingDirectory: '~/freemocap_data/recordings',
+ recordingName: null,
+ startedAt: null,
+ duration: 0,
+ config: {
+ useDelayStart: false,
+ delaySeconds: 3,
+ useTimestamp: true,
+ useIncrement: false,
+ currentIncrement: 1,
+ baseName: 'recording',
+ recordingTag: '',
+ createSubfolder: false,
+ customSubfolderName: '',
+ },
+ computed: {
+ recordingName: '',
+ subfolderName: '',
+ fullRecordingPath: '~/freemocap_data/recordings',
+ },
+};
+
+// Initialize computed values
+initialState.computed = computeRecordingPath(
+ initialState.recordingDirectory,
+ initialState.config
+);
+
+export const recordingSlice = createSlice({
+ name: 'recording',
+ initialState,
+ reducers: {
+ recordingInfoUpdated: (state, action: PayloadAction<Partial<RecordingInfo>>) => {
+ Object.assign(state, action.payload);
+ state.computed = computeRecordingPath(state.recordingDirectory, state.config);
+ },
+ recordingDirectoryChanged: (state, action: PayloadAction<string>) => {
+ state.recordingDirectory = action.payload;
+ state.computed = computeRecordingPath(state.recordingDirectory, state.config);
+ },
+ recordingDurationUpdated: (state, action: PayloadAction<number>) => {
+ state.duration = action.payload;
+ },
+
+ // Config updates
+ configUpdated: (state, action: PayloadAction<Partial<RecordingConfig>>) => {
+ Object.assign(state.config, action.payload);
+ state.computed = computeRecordingPath(state.recordingDirectory, state.config);
+ },
+ useDelayStartToggled: (state, action: PayloadAction<boolean>) => {
+ state.config.useDelayStart = action.payload;
+ // No need to recompute path for delay settings
+ },
+ delaySecondsChanged: (state, action: PayloadAction<number>) => {
+ state.config.delaySeconds = action.payload;
+ // No need to recompute path for delay settings
+ },
+ useTimestampToggled: (state, action: PayloadAction<boolean>) => {
+ state.config.useTimestamp = action.payload;
+ state.computed = computeRecordingPath(state.recordingDirectory, state.config);
+ },
+ useIncrementToggled: (state, action: PayloadAction<boolean>) => {
+ state.config.useIncrement = action.payload;
+ state.computed = computeRecordingPath(state.recordingDirectory, state.config);
+ },
+ currentIncrementChanged: (state, action: PayloadAction<number>) => {
+ state.config.currentIncrement = action.payload;
+ state.computed = computeRecordingPath(state.recordingDirectory, state.config);
+ },
+ currentIncrementIncremented: (state) => {
+ state.config.currentIncrement += 1;
+ state.computed = computeRecordingPath(state.recordingDirectory, state.config);
+ },
+ baseNameChanged: (state, action: PayloadAction<string>) => {
+ state.config.baseName = action.payload;
+ state.computed = computeRecordingPath(state.recordingDirectory, state.config);
+ },
+ recordingTagChanged: (state, action: PayloadAction<string>) => {
+ state.config.recordingTag = action.payload;
+ state.computed = computeRecordingPath(state.recordingDirectory, state.config);
+ },
+ createSubfolderToggled: (state, action: PayloadAction<boolean>) => {
+ state.config.createSubfolder = action.payload;
+ state.computed = computeRecordingPath(state.recordingDirectory, state.config);
+ },
+ customSubfolderNameChanged: (state, action: PayloadAction<string>) => {
+ state.config.customSubfolderName = action.payload;
+ state.computed = computeRecordingPath(state.recordingDirectory, state.config);
+ },
+ // Force recomputation of path (useful for timestamp updates)
+ pathRecomputed: (state) => {
+ state.computed = computeRecordingPath(state.recordingDirectory, state.config);
+ },
+ },
+ extraReducers: (builder) => {
+ builder
+ .addCase(startRecording.fulfilled, (state, action) => {
+ state.isRecording = true;
+ state.recordingName = action.meta.arg.recordingName;
+ state.recordingDirectory = action.meta.arg.recordingDirectory;
+ state.startedAt = new Date().toISOString();
+ state.duration = 0;
+ })
+ .addCase(stopRecording.fulfilled, (state) => {
+ state.isRecording = false;
+ state.recordingName = null;
+ state.startedAt = null;
+ state.duration = 0;
+ });
+ },
+});
+
+export const {
+ recordingInfoUpdated,
+ recordingDirectoryChanged,
+ recordingDurationUpdated,
+ configUpdated,
+ useDelayStartToggled,
+ delaySecondsChanged,
+ useTimestampToggled,
+ useIncrementToggled,
+ currentIncrementChanged,
+ currentIncrementIncremented,
+ baseNameChanged,
+ recordingTagChanged,
+ createSubfolderToggled,
+ customSubfolderNameChanged,
+ pathRecomputed,
+} = recordingSlice.actions;
diff --git a/freemocap-ui-old/src/store/slices/recording/recording-thunks.ts b/freemocap-ui-old/src/store/slices/recording/recording-thunks.ts
new file mode 100644
index 00000000..06730f18
--- /dev/null
+++ b/freemocap-ui-old/src/store/slices/recording/recording-thunks.ts
@@ -0,0 +1,62 @@
+import {createAsyncThunk} from '@reduxjs/toolkit';
+import {z} from 'zod';
+import {RootState} from '@/store/types';
+import {serverUrls} from "@/services";
+
+const RecordStartRequestSchema = z.object({
+ recording_name: z.string(),
+ recording_directory: z.string(),
+ mic_device_index: z.number().default(-1),
+});
+
+interface StartRecordingParams {
+ recordingName: string;
+ recordingDirectory: string;
+ micDeviceIndex?: number;
+}
+
+export const startRecording = createAsyncThunk<
+ void,
+ StartRecordingParams,
+ { state: RootState }
+>(
+ 'recording/start',
+ async ({ recordingName, recordingDirectory, micDeviceIndex = -1 }, { getState }) => {
+ const state = getState();
+
+ const payload = RecordStartRequestSchema.parse({
+ recording_name: recordingName,
+ recording_directory: recordingDirectory,
+ mic_device_index: micDeviceIndex,
+ });
+
+ const response = await fetch(serverUrls.endpoints.pipelineRecordStart, {
+ method: 'POST',
+ headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify(payload),
+ });
+
+ if (!response.ok) {
+ throw new Error(`Failed to start recording: ${response.statusText}`);
+ }
+ }
+);
+
+export const stopRecording = createAsyncThunk<
+ void,
+ void,
+ { state: RootState }
+>(
+ 'recording/stop',
+ async (_, { getState }) => {
+ const state = getState();
+
+ const response = await fetch(serverUrls.endpoints.pipelineRecordStop, {
+ method: 'GET',
+ });
+
+ if (!response.ok) {
+ throw new Error(`Failed to stop recording: ${response.statusText}`);
+ }
+ }
+);
diff --git a/freemocap-ui-old/src/store/slices/recording/recording-types.ts b/freemocap-ui-old/src/store/slices/recording/recording-types.ts
new file mode 100644
index 00000000..353973cb
--- /dev/null
+++ b/freemocap-ui-old/src/store/slices/recording/recording-types.ts
@@ -0,0 +1,38 @@
+import {z} from 'zod';
+
+export const RecordingConfigSchema = z.object({
+ // Recording behavior settings
+ useDelayStart: z.boolean(),
+ delaySeconds: z.number(),
+
+ // Naming settings
+ useTimestamp: z.boolean(),
+ useIncrement: z.boolean(),
+ currentIncrement: z.number(),
+ baseName: z.string(),
+ recordingTag: z.string(),
+
+ // Folder settings
+ createSubfolder: z.boolean(),
+ customSubfolderName: z.string(),
+});
+
+export const ComputedRecordingPathSchema = z.object({
+ recordingName: z.string(),
+ subfolderName: z.string(),
+ fullRecordingPath: z.string(),
+});
+
+export const RecordingInfoSchema = z.object({
+ isRecording: z.boolean(),
+ recordingDirectory: z.string(),
+ recordingName: z.string().nullable(),
+ startedAt: z.string().nullable(),
+ duration: z.number().nullable(),
+ config: RecordingConfigSchema,
+ computed: ComputedRecordingPathSchema,
+});
+
+export type RecordingConfig = z.infer<typeof RecordingConfigSchema>;
+export type ComputedRecordingPath = z.infer<typeof ComputedRecordingPathSchema>;
+export type RecordingInfo = z.infer<typeof RecordingInfoSchema>;
diff --git a/freemocap-ui-old/src/store/slices/settings/index.ts b/freemocap-ui-old/src/store/slices/settings/index.ts
new file mode 100644
index 00000000..1d68c6f4
--- /dev/null
+++ b/freemocap-ui-old/src/store/slices/settings/index.ts
@@ -0,0 +1,3 @@
+export * from "./settings-slice";
+export * from "./settings-selectors";
+export * from "./settings-types";
diff --git a/freemocap-ui-old/src/store/slices/settings/settings-selectors.ts b/freemocap-ui-old/src/store/slices/settings/settings-selectors.ts
new file mode 100644
index 00000000..e22616d6
--- /dev/null
+++ b/freemocap-ui-old/src/store/slices/settings/settings-selectors.ts
@@ -0,0 +1,116 @@
+import {createSelector} from "@reduxjs/toolkit";
+import {RootState} from "@/store/types";
+import {
+ BackendCalibrationConfig,
+ BackendCalibrationSettings,
+ BackendCameraState,
+ BackendMocapConfig,
+ BackendMocapSettings,
+ BackendPipelineSettings,
+ FreeMoCapSettings,
+} from "./settings-types";
+
+// ---------------------------------------------------------------------------
+// Root selectors
+// ---------------------------------------------------------------------------
+
+export const selectServerSettings = (state: RootState): FreeMoCapSettings | null =>
+ state.settings.settings;
+
+export const selectServerSettingsVersion = (state: RootState): number =>
+ state.settings.version;
+
+export const selectServerSettingsInitialized = (state: RootState): boolean =>
+ state.settings.isInitialized;
+
+// ---------------------------------------------------------------------------
+// Camera selectors
+// ---------------------------------------------------------------------------
+
+export const selectBackendCameras = createSelector(
+ [selectServerSettings],
+ (settings): Record<string, BackendCameraState> => settings?.cameras ?? {},
+);
+
+export const selectBackendCameraIds = createSelector(
+ [selectBackendCameras],
+ (cameras): string[] => Object.keys(cameras),
+);
+
+export const selectBackendConnectedCameraCount = createSelector(
+ [selectBackendCameras],
+ (cameras): number =>
+ Object.values(cameras).filter((c) => c.status === "connected").length,
+);
+
+// ---------------------------------------------------------------------------
+// Pipeline selectors
+// ---------------------------------------------------------------------------
+
+export const selectBackendPipeline = createSelector(
+ [selectServerSettings],
+ (settings): BackendPipelineSettings | null => settings?.pipeline ?? null,
+);
+
+export const selectBackendPipelineIsConnected = createSelector(
+ [selectBackendPipeline],
+ (pipeline): boolean => pipeline?.is_connected ?? false,
+);
+
+export const selectBackendPipelineId = createSelector(
+ [selectBackendPipeline],
+ (pipeline): string | null => pipeline?.pipeline_id ?? null,
+);
+
+// ---------------------------------------------------------------------------
+// Calibration selectors
+// ---------------------------------------------------------------------------
+
+export const selectBackendCalibration = createSelector(
+ [selectServerSettings],
+ (settings): BackendCalibrationSettings | null => settings?.calibration ?? null,
+);
+
+export const selectBackendCalibrationConfig = createSelector(
+ [selectBackendCalibration],
+ (cal): BackendCalibrationConfig | null => cal?.config ?? null,
+);
+
+export const selectBackendCalibrationIsRecording = createSelector(
+ [selectBackendCalibration],
+ (cal): boolean => cal?.is_recording ?? false,
+);
+
+export const selectBackendCalibrationProgress = createSelector(
+ [selectBackendCalibration],
+ (cal): number => cal?.recording_progress ?? 0,
+);
+
+export const selectBackendHasCalibrationToml = createSelector(
+ [selectBackendCalibration],
+ (cal): boolean => cal?.has_calibration_toml ?? false,
+);
+
+// ---------------------------------------------------------------------------
+// MoCap selectors
+// ---------------------------------------------------------------------------
+
+export const selectBackendMocap = createSelector(
+ [selectServerSettings],
+ (settings): BackendMocapSettings | null => settings?.mocap ?? null,
+);
+
+export const selectBackendMocapConfig = createSelector(
+ [selectBackendMocap],
+ (moc): BackendMocapConfig | null => moc?.config ?? null,
+);
+
+export const selectBackendMocapIsRecording = createSelector(
+ [selectBackendMocap],
+ (moc): boolean => moc?.is_recording ?? false,
+);
+
+export const selectBackendMocapProgress = createSelector(
+ [selectBackendMocap],
+ (moc): number => moc?.recording_progress ?? 0,
+);
diff --git a/freemocap-ui-old/src/store/slices/settings/settings-slice.ts b/freemocap-ui-old/src/store/slices/settings/settings-slice.ts
new file mode 100644
index 00000000..ba661a4c
--- /dev/null
+++ b/freemocap-ui-old/src/store/slices/settings/settings-slice.ts
@@ -0,0 +1,52 @@
+import {createSlice, PayloadAction} from "@reduxjs/toolkit";
+import {FreeMoCapSettings, SettingsStateMessage} from "./settings-types";
+
+export interface ServerSettingsState {
+ settings: FreeMoCapSettings | null;
+ version: number;
+ lastUpdated: string | null;
+ isInitialized: boolean;
+}
+
+const initialState: ServerSettingsState = {
+ settings: null,
+ version: -1,
+ lastUpdated: null,
+ isInitialized: false,
+};
+
+export const settingsSlice = createSlice({
+ name: "serverSettings",
+ initialState,
+ reducers: {
+ /**
+ * Replace the entire settings blob from a backend settings/state message.
+ * Only applies if the incoming version is newer than what we have.
+ */
+ serverSettingsUpdated: (state, action: PayloadAction<SettingsStateMessage>) => {
+ const {settings, version} = action.payload;
+ if (version <= state.version) {
+ return; // Stale message — ignore
+ }
+ state.settings = settings;
+ state.version = version;
+ state.lastUpdated = new Date().toISOString();
+ state.isInitialized = true;
+ },
+
+ /**
+ * Reset to initial state (e.g., on WebSocket disconnect).
+ */
+ serverSettingsCleared: (state) => {
+ state.settings = null;
+ state.version = -1;
+ state.lastUpdated = null;
+ state.isInitialized = false;
+ },
+ },
+});
+
+export const {
+ serverSettingsUpdated,
+ serverSettingsCleared,
+} = settingsSlice.actions;
diff --git a/freemocap-ui-old/src/store/slices/settings/settings-types.ts b/freemocap-ui-old/src/store/slices/settings/settings-types.ts
new file mode 100644
index 00000000..f81ef937
--- /dev/null
+++ b/freemocap-ui-old/src/store/slices/settings/settings-types.ts
@@ -0,0 +1,174 @@
+/**
+ * TypeScript types mirroring the backend FreeMoCapSettings Pydantic models.
+ *
+ * These represent the authoritative backend state pushed over WebSocket.
+ * Field names use snake_case to match the JSON the backend sends.
+ */
+
+// ---------------------------------------------------------------------------
+// Camera layer (mirrors skellycam CameraConfig + runtime status)
+// ---------------------------------------------------------------------------
+
+export interface BackendImageResolution {
+ height: number;
+ width: number;
+}
+
+export interface BackendCameraConfig {
+ camera_id: string;
+ camera_index: number;
+ camera_name: string;
+ use_this_camera: boolean;
+ resolution: BackendImageResolution;
+ color_channels: number;
+ pixel_format: string;
+ exposure_mode: string;
+ exposure: number;
+ framerate: number;
+ rotation: number;
+ capture_fourcc: string;
+ writer_fourcc: string;
+}
+
+export type BackendCameraStatus = "disconnected" | "connected" | "error";
+
+export interface BackendCameraState {
+ config: BackendCameraConfig;
+ status: BackendCameraStatus;
+}
+
+// ---------------------------------------------------------------------------
+// Calibration config (mirrors CalibrationPipelineConfig)
+// ---------------------------------------------------------------------------
+
+export type CalibrationSolverMethod = "anipose" | "pyceres";
+
+export interface BackendCalibrationConfig {
+ calibration_recording_folder: string | null;
+ charuco_board_x_squares: number;
+ charuco_board_y_squares: number;
+ charuco_square_length: number;
+ solver_method: CalibrationSolverMethod;
+ use_groundplane: boolean;
+ pyceres_solver_config: Record<string, unknown>;
+}
+
+export interface BackendCalibrationSettings {
+ config: BackendCalibrationConfig;
+ is_recording: boolean;
+ recording_progress: number;
+ last_recording_path: string | null;
+ has_calibration_toml: boolean;
+}
+
+// ---------------------------------------------------------------------------
+// MoCap config (mirrors MocapPipelineConfig)
+// ---------------------------------------------------------------------------
+
+export interface BackendEstimatorConfig {
+ max_samples: number;
+ min_samples_for_full_confidence: number;
+ iqr_confidence_sensitivity: number;
+}
+
+export interface BackendRealtimeFilterConfig {
+ min_cutoff: number;
+ beta: number;
+ d_cutoff: number;
+ fabrik_tolerance: number;
+ fabrik_max_iterations: number;
+ height_meters: number;
+ noise_sigma: number;
+ estimator_config: BackendEstimatorConfig;
+ max_reprojection_error_px: number;
+ max_velocity_m_per_s: number;
+ max_rejected_streak: number;
+ max_prediction_frames: number;
+ prediction_velocity_decay: number;
+}
+
+export interface BackendMocapConfig {
+ detector: Record<string, unknown>;
+ skeleton_filter: BackendRealtimeFilterConfig;
+}
+
+export interface BackendMocapSettings {
+ config: BackendMocapConfig;
+ is_recording: boolean;
+ recording_progress: number;
+ last_recording_path: string | null;
+}
+
+// ---------------------------------------------------------------------------
+// Pipeline config (mirrors RealtimePipelineConfig + runtime status)
+// ---------------------------------------------------------------------------
+
+export interface BackendRealtimePipelineConfig {
+ camera_configs: Record<string, BackendCameraConfig>;
+ calibration_config: BackendCalibrationConfig;
+ mocap_config: BackendMocapConfig;
+ calibration_detection_enabled: boolean;
+ mocap_detection_enabled: boolean;
+}
+
+export interface BackendPipelineSettings {
+ config: BackendRealtimePipelineConfig | null;
+ is_connected: boolean;
+ pipeline_id: string | null;
+ camera_group_id: string | null;
+ is_paused: boolean;
+}
+
+// ---------------------------------------------------------------------------
+// VMC settings (mirrors VMCSettings)
+// ---------------------------------------------------------------------------
+
+export interface BackendVMCSettings {
+ enabled: boolean;
+ host: string;
+ port: number;
+}
+
+// ---------------------------------------------------------------------------
+// Top-level settings blob
+// ---------------------------------------------------------------------------
+
+export interface FreeMoCapSettings {
+ cameras: Record<string, BackendCameraState>;
+ pipeline: BackendPipelineSettings;
+ calibration: BackendCalibrationSettings;
+ mocap: BackendMocapSettings;
+ vmc: BackendVMCSettings;
+}
+
+// ---------------------------------------------------------------------------
+// WebSocket message types
+// ---------------------------------------------------------------------------
+
+export interface SettingsStateMessage {
+ message_type: "settings/state";
+ settings: FreeMoCapSettings;
+ version: number;
+}
+
+export interface SettingsPatchMessage {
+ message_type: "settings/patch";
+ patch: DeepPartial<FreeMoCapSettings>;
+}
+
+export interface SettingsRequestMessage {
+ message_type: "settings/request";
+}
+
+export type SettingsMessage =
+ | SettingsStateMessage
+ | SettingsPatchMessage
+ | SettingsRequestMessage;
+
+// ---------------------------------------------------------------------------
+// Utility: deep partial for patch payloads
+// ---------------------------------------------------------------------------
+
+export type DeepPartial<T> = {
+ [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
diff --git a/freemocap-ui-old/src/store/slices/theme/index.ts b/freemocap-ui-old/src/store/slices/theme/index.ts
new file mode 100644
index 00000000..dd1ab93b
--- /dev/null
+++ b/freemocap-ui-old/src/store/slices/theme/index.ts
@@ -0,0 +1,3 @@
+export * from './theme-slice';
+export * from './theme-types';
+export * from './theme-selectors';
diff --git a/freemocap-ui-old/src/store/slices/theme/theme-selectors.ts b/freemocap-ui-old/src/store/slices/theme/theme-selectors.ts
new file mode 100644
index 00000000..f9d12576
--- /dev/null
+++ b/freemocap-ui-old/src/store/slices/theme/theme-selectors.ts
@@ -0,0 +1,5 @@
+import {RootState} from '../../types';
+
+export const selectThemeMode = (state: RootState) => state.theme.mode;
+export const selectSystemThemePreference = (state: RootState) =>
+ state.theme.systemPreference;
diff --git a/freemocap-ui-old/src/store/slices/theme/theme-slice.ts b/freemocap-ui-old/src/store/slices/theme/theme-slice.ts
new file mode 100644
index 00000000..3cf18110
--- /dev/null
+++ b/freemocap-ui-old/src/store/slices/theme/theme-slice.ts
@@ -0,0 +1,50 @@
+import {createSlice, PayloadAction} from '@reduxjs/toolkit';
+import {ThemeMode} from './theme-types';
+
+const getInitialTheme = (): ThemeMode => {
+ if (typeof window !== 'undefined') {
+ const saved = localStorage.getItem('themeMode');
+ if (saved === 'light' || saved === 'dark') {
+ return saved;
+ }
+ // Check system preference
+ if (window.matchMedia?.('(prefers-color-scheme: dark)').matches) {
+ return 'dark';
+ }
+ }
+ return 'dark';
+};
+
+interface ThemeState {
+ mode: ThemeMode;
+ systemPreference: ThemeMode | null;
+}
+
+const initialState: ThemeState = {
+ mode: getInitialTheme(),
+ systemPreference: null,
+};
+
+export const themeSlice = createSlice({
+ name: 'theme',
+ initialState,
+ reducers: {
+ themeModeSet: (state, action: PayloadAction<ThemeMode>) => {
+ state.mode = action.payload;
+ localStorage.setItem('themeMode', action.payload);
+ },
+ themeModeToggled: (state) => {
+ state.mode = state.mode === 'dark' ? 'light' : 'dark';
+ localStorage.setItem('themeMode', state.mode);
+ },
+ systemPreferenceUpdated: (state, action: PayloadAction<ThemeMode>) => {
+ state.systemPreference = action.payload;
+ },
+ },
+});
+
+export const {
+ themeModeSet,
+ themeModeToggled,
+ systemPreferenceUpdated,
+} = themeSlice.actions;
diff --git a/freemocap-ui-old/src/store/slices/theme/theme-types.ts b/freemocap-ui-old/src/store/slices/theme/theme-types.ts
new file mode 100644
index 00000000..c5ad70d8
--- /dev/null
+++ b/freemocap-ui-old/src/store/slices/theme/theme-types.ts
@@ -0,0 +1 @@
+export type ThemeMode = 'light' | 'dark';
diff --git a/freemocap-ui-old/src/store/slices/thunk-helpers.ts b/freemocap-ui-old/src/store/slices/thunk-helpers.ts
new file mode 100644
index 00000000..f6b9fc8a
--- /dev/null
+++ b/freemocap-ui-old/src/store/slices/thunk-helpers.ts
@@ -0,0 +1,35 @@
+/**
+ * Shared utilities for async thunks that call the backend HTTP API.
+ */
+
+/**
+ * Extract a detailed error message from a failed HTTP response.
+ * Attempts to parse JSON first, falls back to text, builds a
+ * comprehensive error string including status code and body.
+ */
+export async function getDetailedErrorMessage(response: Response): Promise<string> {
+ let errorDetails: unknown;
+
+ try {
+ errorDetails = await response.json();
+ console.error('❌ Server returned validation/error details:', errorDetails);
+ } catch {
+ try {
+ errorDetails = await response.text();
+ console.error('❌ Server returned error text:', errorDetails);
+ } catch {
+ console.error('❌ Could not read error response body');
+ }
+ }
+
+ const baseError = `HTTP ${response.status}: ${response.statusText}`;
+
+ if (errorDetails) {
+ const detailsStr = typeof errorDetails === 'string'
+ ? errorDetails
+ : JSON.stringify(errorDetails, null, 2);
+ return `${baseError}\n\nValidation/Error Details:\n${detailsStr}`;
+ }
+
+ return baseError;
+}
diff --git a/freemocap-ui-old/src/store/slices/videos/index.ts b/freemocap-ui-old/src/store/slices/videos/index.ts
new file mode 100644
index 00000000..99a7ab8b
--- /dev/null
+++ b/freemocap-ui-old/src/store/slices/videos/index.ts
@@ -0,0 +1,4 @@
+export * from './videos-slice';
+export * from './videos-types';
+export * from './videos-thunks';
+export * from './videos-selectors';
diff --git a/freemocap-ui-old/src/store/slices/videos/videos-selectors.ts b/freemocap-ui-old/src/store/slices/videos/videos-selectors.ts
new file mode 100644
index 00000000..558c7fda
--- /dev/null
+++ b/freemocap-ui-old/src/store/slices/videos/videos-selectors.ts
@@ -0,0 +1,20 @@
+import {createSelector} from '@reduxjs/toolkit';
+import {RootState} from '../../types';
+
+export const selectVideoFolder = (state: RootState) => state.videos.folder;
+export const selectVideoFiles = (state: RootState) => state.videos.files;
+export const selectSelectedVideo = (state: RootState) => state.videos.selectedFile;
+export const selectVideoPlaybackState = (state: RootState) => state.videos.playbackState;
+export const selectVideoLoadingState = (state: RootState) => state.videos.isLoading;
+export const selectVideoError = (state: RootState) => state.videos.error;
+
+export const selectVideosByExtension = createSelector(
+ [selectVideoFiles, (_: RootState, extension: string) => extension],
+ (files, extension) =>
+ files.filter((file: { name: string; }) => file.name.toLowerCase().endsWith(extension))
+);
+
+export const selectIsVideoPlaying = createSelector(
+ [selectVideoPlaybackState],
+ (playback) => playback.isPlaying
+);
diff --git a/freemocap-ui-old/src/store/slices/videos/videos-slice.ts b/freemocap-ui-old/src/store/slices/videos/videos-slice.ts
new file mode 100644
index 00000000..d5c74b44
--- /dev/null
+++ b/freemocap-ui-old/src/store/slices/videos/videos-slice.ts
@@ -0,0 +1,94 @@
+import {createSlice, PayloadAction} from '@reduxjs/toolkit';
+import {VideoFile, VideosState} from './videos-types';
+import {loadVideos, openVideoFile, selectVideoLoadFolder,} from './videos-thunks';
+
+
+const initialState: VideosState = {
+ folder: '',
+ files: [],
+ selectedFile: null,
+ isLoading: false,
+ error: null,
+ playbackState: {
+ isPlaying: false,
+ currentTime: 0,
+ duration: 0,
+ volume: 1,
+ playbackRate: 1,
+ },
+};
+
+export const videosSlice = createSlice({
+ name: 'videos',
+ initialState,
+ reducers: {
+ videoFolderSet: (state, action: PayloadAction<string>) => {
+ state.folder = action.payload;
+ },
+ videoFilesSet: (state, action: PayloadAction<VideoFile[]>) => {
+ state.files = action.payload;
+ },
+ videoFileSelected: (state, action: PayloadAction<VideoFile | null>) => {
+ state.selectedFile = action.payload;
+ if (action.payload) {
+ state.playbackState = {
+ ...state.playbackState,
+ isPlaying: false,
+ currentTime: 0,
+ duration: 0,
+ };
+ }
+ },
+ playbackStateUpdated: (
+ state,
+ action: PayloadAction<Partial<VideosState['playbackState']>>
+ ) => {
+ state.playbackState = { ...state.playbackState, ...action.payload };
+ },
+ videosCleared: () => initialState,
+ },
+ extraReducers: (builder) => {
+ builder
+ // Select folder
+ .addCase(selectVideoLoadFolder.pending, (state) => {
+ state.isLoading = true;
+ state.error = null;
+ })
+ .addCase(selectVideoLoadFolder.fulfilled, (state, action) => {
+ state.isLoading = false;
+ if (action.payload) {
+ state.folder = action.payload.folder;
+ state.files = action.payload.files;
+ }
+ })
+ .addCase(selectVideoLoadFolder.rejected, (state, action) => {
+ state.isLoading = false;
+ state.error = action.error.message || 'Failed to select folder';
+ })
+ // Load videos
+ .addCase(loadVideos.pending, (state) => {
+ state.isLoading = true;
+ })
+ .addCase(loadVideos.fulfilled, (state) => {
+ state.isLoading = false;
+ })
+ .addCase(loadVideos.rejected, (state, action) => {
+ state.isLoading = false;
+ state.error = action.error.message || 'Failed to load videos';
+ })
+ // Open video file
+ .addCase(openVideoFile.fulfilled, (state, action) => {
+ if (!action.payload.success && action.payload.error) {
+ state.error = action.payload.error.message || 'Failed to open video';
+ }
+ });
+ },
+});
+
+export const {
+ videoFolderSet,
+ videoFilesSet,
+ videoFileSelected,
+ playbackStateUpdated,
+ videosCleared,
+} = videosSlice.actions;
diff --git a/freemocap-ui-old/src/store/slices/videos/videos-thunks.ts b/freemocap-ui-old/src/store/slices/videos/videos-thunks.ts
new file mode 100644
index 00000000..26e93e23
--- /dev/null
+++ b/freemocap-ui-old/src/store/slices/videos/videos-thunks.ts
@@ -0,0 +1,80 @@
+import {createAsyncThunk} from '@reduxjs/toolkit';
+import {electronIpc} from "@/services/electron-ipc/electron-ipc";
+import {VideoFile} from "@/store";
+
+const VIDEO_EXTENSIONS = ['.mp4', '.avi', '.mov', '.mkv', '.webm'];
+
+interface FolderEntry {
+ name: string;
+ path: string;
+ isDirectory: boolean;
+ isFile: boolean;
+ size: number;
+ modified: string | number | Date;
+}
+
+export const selectVideoLoadFolder = createAsyncThunk<
+ { folder: string; files: VideoFile[] } | null
+>('videos/selectFolder', async () => {
+ if (!electronIpc) {
+ throw new Error('Electron API not available');
+ }
+
+ const selectedFolder = await electronIpc.fileSystem.selectDirectory.mutate();
+ if (!selectedFolder) return null;
+
+ const entries: FolderEntry[] = await electronIpc.fileSystem.getFolderContents.query({
+ path: selectedFolder,
+ });
+
+ const videoFiles = (entries ?? [])
+ .filter(
+ (item) =>
+ item.isFile &&
+ VIDEO_EXTENSIONS.some((ext) => item.name.toLowerCase().endsWith(ext))
+ )
+ .map((file) => ({
+ name: file.name,
+ path: file.path,
+ size: file.size,
+ }));
+
+ return { folder: selectedFolder, files: videoFiles };
+});
+
+export const loadVideos = createAsyncThunk<
+ { success: boolean },
+ { folder: string; files: VideoFile[] }
+>('videos/load', async ({ folder }) => {
+ if (!electronIpc) {
+ throw new Error('Electron API not available');
+ }
+
+ const success = await electronIpc.fileSystem.openFolder.mutate({ path: folder });
+ if (!success) {
+ throw new Error('Failed to open folder');
+ }
+ return { success: true };
+});
+
+export const openVideoFile = createAsyncThunk<
+ { success: boolean; error?: Error },
+ string
+>('videos/openFile', async (filePath) => {
+ if (!electronIpc) {
+ return { success: false, error: new Error('Electron API not available') };
+ }
+
+ try {
+ const idx = Math.max(filePath.lastIndexOf('/'), filePath.lastIndexOf('\\'));
+ const folderPath = idx >= 0 ? filePath.substring(0, idx) : filePath;
+ await electronIpc.fileSystem.openFolder.mutate({ path: folderPath });
+ return { success: true };
+ } catch (error) {
+ console.error('Failed to open video file:', error);
+ return {
+ success: false,
+ error: error instanceof Error ? error : new Error('Unknown error'),
+ };
+ }
+});
diff --git a/freemocap-ui-old/src/store/slices/videos/videos-types.ts b/freemocap-ui-old/src/store/slices/videos/videos-types.ts
new file mode 100644
index 00000000..570b86f8
--- /dev/null
+++ b/freemocap-ui-old/src/store/slices/videos/videos-types.ts
@@ -0,0 +1,22 @@
+export interface VideoFile {
+ name: string;
+ path: string;
+ size?: number;
+ duration?: number;
+ thumbnail?: string;
+}
+
+export interface VideosState {
+ folder: string;
+ files: VideoFile[];
+ selectedFile: VideoFile | null;
+ isLoading: boolean;
+ error: string | null;
+ playbackState: {
+ isPlaying: boolean;
+ currentTime: number;
+ duration: number;
+ volume: number;
+ playbackRate: number;
+ };
+}
diff --git a/freemocap-ui-old/src/store/store.ts b/freemocap-ui-old/src/store/store.ts
new file mode 100644
index 00000000..c5dd136d
--- /dev/null
+++ b/freemocap-ui-old/src/store/store.ts
@@ -0,0 +1,26 @@
+import {configureStore} from "@reduxjs/toolkit";
+import {framerateSlice} from "./slices/framerate/framerate-slice";
+import {cameraSlice} from "./slices/cameras/cameras-slice";
+import {recordingSlice} from "./slices/recording/recording-slice";
+import {themeSlice} from "./slices/theme/theme-slice";
+import {videosSlice} from "./slices/videos/videos-slice";
+import {logRecordsSlice} from "./slices/log-records/log-records-slice";
+import {pipelineSlice} from "./slices/pipeline/pipeline-slice";
+import {calibrationSlice} from "@/store/slices/calibration/calibration-slice";
+import {mocapSlice} from "@/store/slices/mocap/mocap-slice";
+import {settingsSlice} from "@/store/slices/settings/settings-slice";
+
+export const store = configureStore({
+ reducer: {
+ cameras: cameraSlice.reducer,
+ recording: recordingSlice.reducer,
+ framerate: framerateSlice.reducer,
+ logs: logRecordsSlice.reducer,
+ theme: themeSlice.reducer,
+ videos: videosSlice.reducer,
+ pipeline: pipelineSlice.reducer,
+ calibration: calibrationSlice.reducer,
+ mocap: mocapSlice.reducer,
+ settings: settingsSlice.reducer,
+ },
+});
diff --git a/freemocap-ui-old/src/store/types.ts b/freemocap-ui-old/src/store/types.ts
new file mode 100644
index 00000000..be6112cd
--- /dev/null
+++ b/freemocap-ui-old/src/store/types.ts
@@ -0,0 +1,11 @@
+import {store} from './store';
+import {Action, ThunkAction} from '@reduxjs/toolkit';
+
+export type RootState = ReturnType<typeof store.getState>;
+export type AppDispatch = typeof store.dispatch;
+export type AppThunk<ReturnType = void> = ThunkAction<
+ ReturnType,
+ RootState,
+ unknown,
+ Action<string>
+>;
diff --git a/freemocap-ui-old/src/vite-env.d.ts b/freemocap-ui-old/src/vite-env.d.ts
new file mode 100644
index 00000000..c574b80c
--- /dev/null
+++ b/freemocap-ui-old/src/vite-env.d.ts
@@ -0,0 +1,6 @@
+/// <reference types="vite/client" />
+
+interface Window {
+ // expose in the `electron/preload/index.ts`
+ ipcRenderer: import('electron').IpcRenderer
+}
diff --git a/freemocap-ui-old/tsconfig.json b/freemocap-ui-old/tsconfig.json
new file mode 100644
index 00000000..66956867
--- /dev/null
+++ b/freemocap-ui-old/tsconfig.json
@@ -0,0 +1,38 @@
+{
+ "compilerOptions": {
+ "target": "ESNext",
+ "useDefineForClassFields": true,
+ "lib": [
+ "DOM",
+ "DOM.Iterable",
+ "ESNext"
+ ],
+ "allowJs": false,
+ "skipLibCheck": true,
+ "esModuleInterop": false,
+ "allowSyntheticDefaultImports": true,
+ "strict": true,
+ "forceConsistentCasingInFileNames": true,
+ "module": "ESNext",
+ "moduleResolution": "Node",
+ "resolveJsonModule": true,
+ "isolatedModules": true,
+ "noEmit": true,
+ "jsx": "react-jsx",
+ "baseUrl": "./",
+ "paths": {
+ "@/*": [
+ "src/*"
+ ]
+ }
+ },
+ "include": [
+ "src",
+ "src/lib/**/*"
+ ],
+ "references": [
+ {
+ "path": "./tsconfig.node.json"
+ }
+ ]
+}
diff --git a/freemocap-ui-old/tsconfig.node.json b/freemocap-ui-old/tsconfig.node.json
new file mode 100644
index 00000000..46b61ba0
--- /dev/null
+++ b/freemocap-ui-old/tsconfig.node.json
@@ -0,0 +1,13 @@
+{
+ "compilerOptions": {
+ "composite": true,
+ "module": "ESNext",
+ "moduleResolution": "Node",
+ "resolveJsonModule": true,
+ "allowSyntheticDefaultImports": true
+ },
+ "include": [
+ "vite.config.ts",
+ "package.json"
+ ]
+}
diff --git a/freemocap-ui-old/vite.config.flat.txt b/freemocap-ui-old/vite.config.flat.txt
new file mode 100644
index 00000000..66b0dcd2
--- /dev/null
+++ b/freemocap-ui-old/vite.config.flat.txt
@@ -0,0 +1,78 @@
+import { rmSync } from 'node:fs'
+import path from 'node:path'
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+import electron from 'vite-plugin-electron'
+import renderer from 'vite-plugin-electron-renderer'
+import pkg from './package.json'
+
+// https://vitejs.dev/config/
+export default defineConfig(({ command }) => {
+ rmSync('dist-electron', { recursive: true, force: true })
+
+ const isServe = command === 'serve'
+ const isBuild = command === 'build'
+ const sourcemap = isServe || !!process.env.VSCODE_DEBUG
+
+ return {
+ resolve: {
+ alias: {
+ '@': path.join(__dirname, 'src')
+ },
+ },
+ plugins: [
+ react(),
+ electron([
+ {
+ // Main-Process entry file of the Electron App.
+ entry: 'electron/main/index.ts',
+ onstart(options) {
+ if (process.env.VSCODE_DEBUG) {
+ console.log(/* For `.vscode/.debug.script.mjs` */'[startup] Electron App')
+ } else {
+ options.startup()
+ }
+ },
+ vite: {
+ build: {
+ sourcemap,
+ minify: isBuild,
+ outDir: 'dist-electron/main',
+ rollupOptions: {
+ external: Object.keys('dependencies' in pkg ? pkg.dependencies : {}),
+ },
+ },
+ },
+ },
+ {
+ entry: 'electron/preload/index.ts',
+ onstart(options) {
+ // Notify the Renderer-Process to reload the page when the Preload-Scripts build is complete,
+ // instead of restarting the entire Electron App.
+ options.reload()
+ },
+ vite: {
+ build: {
+ sourcemap: sourcemap ? 'inline' : undefined, // #332
+ minify: isBuild,
+ outDir: 'dist-electron/preload',
+ rollupOptions: {
+ external: Object.keys('dependencies' in pkg ? pkg.dependencies : {}),
+ },
+ },
+ },
+ }
+ ]),
+ // Use Node.js API in the Renderer-process
+ renderer(),
+ ],
+ server: process.env.VSCODE_DEBUG && (() => {
+ const url = new URL(pkg.debug.env.VITE_DEV_SERVER_URL)
+ return {
+ host: url.hostname,
+ port: +url.port,
+ }
+ })(),
+ clearScreen: false,
+ }
+})
diff --git a/freemocap-ui-old/vite.config.ts b/freemocap-ui-old/vite.config.ts
new file mode 100644
index 00000000..5ec6d289
--- /dev/null
+++ b/freemocap-ui-old/vite.config.ts
@@ -0,0 +1,76 @@
+import {rmSync} from 'node:fs'
+import path from 'node:path'
+import {defineConfig} from 'vite'
+import react from '@vitejs/plugin-react'
+import electron from 'vite-plugin-electron/simple'
+import pkg from './package.json'
+
+const __dirname = import.meta.dirname
+
+// https://vitejs.dev/config/
+export default defineConfig(({command}) => {
+ rmSync('dist-electron', {recursive: true, force: true})
+
+ const isServe = command === 'serve'
+ const isBuild = command === 'build'
+ const sourcemap = isServe || !!process.env.VSCODE_DEBUG
+
+ return {
+ resolve: {
+ alias: {
+ '@': path.join(__dirname, 'src')
+ },
+ },
+ plugins: [
+ react(),
+ electron({
+ main: {
+ entry: 'electron/main/index.ts',
+ onstart(args) {
+ if (process.env.VSCODE_DEBUG) {
+ console.log(/* For `.vscode/.debug.script.mjs` */'[startup] Electron App')
+ } else {
+ args.startup()
+ }
+ },
+ vite: {
+ build: {
+ sourcemap,
+ minify: isBuild,
+ outDir: 'dist-electron/main',
+ rollupOptions: {
+ external: Object.keys('dependencies' in pkg ? pkg.dependencies : {}),
+ },
+ },
+ },
+ },
+ preload: {
+ input: 'electron/preload/index.ts',
+ vite: {
+ build: {
+ sourcemap: sourcemap ? 'inline' : undefined,
+ minify: isBuild,
+ outDir: 'dist-electron/preload',
+ rollupOptions: {
+ external: Object.keys('dependencies' in pkg ? pkg.dependencies : {}),
+ },
+ },
+ },
+ },
+ renderer: {},
+ }),
+ ],
+ optimizeDeps: {
+ exclude: ["@ffmpeg/ffmpeg", "@ffmpeg/util"],
+ },
+ server: {
+ host: '127.0.0.1',
+ port: 7877,
+ headers: {
+ "Cross-Origin-Opener-Policy": "same-origin",
+ "Cross-Origin-Embedder-Policy": "require-corp",
+ },
+ },
+ clearScreen: false,
+ }
+})
diff --git a/freemocap-ui-old/vitest.config.ts b/freemocap-ui-old/vitest.config.ts
new file mode 100644
index 00000000..24dce78d
--- /dev/null
+++ b/freemocap-ui-old/vitest.config.ts
@@ -0,0 +1,16 @@
+/// <reference types="vitest" />
+import { defineConfig } from 'vite';
+import path from 'path';
+
+export default defineConfig({
+ test: {
+ globals: true,
+ environment: 'node',
+ include: ['src/**/*.test.ts', 'src/**/*.test.tsx'],
+ },
+ resolve: {
+ alias: {
+ '@': path.resolve(__dirname, './src'),
+ },
+ },
+});
diff --git a/freemocap-ui/package-lock.json b/freemocap-ui/package-lock.json
new file mode 100644
index 00000000..0a6271fc
--- /dev/null
+++ b/freemocap-ui/package-lock.json
@@ -0,0 +1,9114 @@
+{
+ "name": "freemocap",
+ "version": "2.0.0-alpha.1",
+ "lockfileVersion": 3,
+ "requires": true,
+ "packages": {
+ "": {
+ "name": "freemocap",
+ "version": "2.0.0-alpha.1",
+ "license": "AGPL-3.0-or-later",
+ "dependencies": {
+ "@emotion/react": "^11.13.3",
+ "@emotion/styled": "^11.13.0",
+ "@fontsource/roboto": "^5.1.0",
+ "@mui/icons-material": "^6.4.5",
+ "@mui/material": "^6.1.1",
+ "@mui/x-tree-view": "^7.29.1",
+ "@reduxjs/toolkit": "^2.5.1",
+ "@trpc/client": "^11.5.1",
+ "@trpc/server": "^11.5.1",
+ "country-flag-icons": "^1.6.14",
+ "d3": "^7.9.0",
+ "electron-updater": "^6.1.8",
+ "i18next-browser-languagedetector": "^8.2.1",
+ "react-grid-layout": "^2.2.2",
+ "react-i18next": "^16.5.4",
+ "react-redux": "^9.1.2",
+ "react-resizable-panels": "^2.1.7",
+ "react-router-dom": "^6.26.2",
+ "superjson": "^2.2.2",
+ "tree-kill": "^1.2.2",
+ "zod": "^4.1.5"
+ },
+ "devDependencies": {
+ "@playwright/test": "^1.42.1",
+ "@types/d3": "^7.4.3",
+ "@types/react": "^19.2.14",
+ "@types/react-dom": "^19.2.3",
+ "@vitejs/plugin-react": "^4.3.3",
+ "cross-env": "^7.0.3",
+ "electron": "^35.0.3",
+ "electron-builder": "^26.8.1",
+ "electron-devtools-installer": "^4.0.0",
+ "react": "^19.1.0",
+ "react-dom": "^19.1.0",
+ "vite": "^7.3.1",
+ "vite-plugin-electron": "^0.28.8",
+ "vite-plugin-electron-renderer": "^0.14.5"
+ }
+ },
+ "node_modules/@babel/code-frame": {
+ "version": "7.29.0",
+ "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.29.0.tgz",
+ "integrity": "sha512-9NhCeYjq9+3uxgdtp20LSiJXJvN0FeCtNGpJxuMFZ1Kv3cWUNb6DOhJwUvcVCzKGR66cw4njwM6hrJLqgOwbcw==",
+ "license": "MIT",
+ "dependencies": {
+ "@babel/helper-validator-identifier": "^7.28.5",
+ "js-tokens": "^4.0.0",
+ "picocolors": "^1.1.1"
+ },
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/compat-data": {
+ "version": "7.29.0",
+ "resolved": "https://registry.npmjs.org/@babel/compat-data/-/compat-data-7.29.0.tgz",
+ "integrity": "sha512-T1NCJqT/j9+cn8fvkt7jtwbLBfLC/1y1c7NtCeXFRgzGTsafi68MRv8yzkYSapBnFA6L3U2VSc02ciDzoAJhJg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/core": {
+ "version": "7.29.0",
+ "resolved": "https://registry.npmjs.org/@babel/core/-/core-7.29.0.tgz",
+ "integrity": "sha512-CGOfOJqWjg2qW/Mb6zNsDm+u5vFQ8DxXfbM09z69p5Z6+mE1ikP2jUXw+j42Pf1XTYED2Rni5f95npYeuwMDQA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/code-frame": "^7.29.0",
+ "@babel/generator": "^7.29.0",
+ "@babel/helper-compilation-targets": "^7.28.6",
+ "@babel/helper-module-transforms": "^7.28.6",
+ "@babel/helpers": "^7.28.6",
+ "@babel/parser": "^7.29.0",
+ "@babel/template": "^7.28.6",
+ "@babel/traverse": "^7.29.0",
+ "@babel/types": "^7.29.0",
+ "@jridgewell/remapping": "^2.3.5",
+ "convert-source-map": "^2.0.0",
+ "debug": "^4.1.0",
+ "gensync": "^1.0.0-beta.2",
+ "json5": "^2.2.3",
+ "semver": "^6.3.1"
+ },
+ "engines": {
+ "node": ">=6.9.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/babel"
+ }
+ },
+ "node_modules/@babel/core/node_modules/convert-source-map": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-2.0.0.tgz",
+ "integrity": "sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@babel/generator": {
+ "version": "7.29.1",
+ "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.29.1.tgz",
+ "integrity": "sha512-qsaF+9Qcm2Qv8SRIMMscAvG4O3lJ0F1GuMo5HR/Bp02LopNgnZBC/EkbevHFeGs4ls/oPz9v+Bsmzbkbe+0dUw==",
+ "license": "MIT",
+ "dependencies": {
+ "@babel/parser": "^7.29.0",
+ "@babel/types": "^7.29.0",
+ "@jridgewell/gen-mapping": "^0.3.12",
+ "@jridgewell/trace-mapping": "^0.3.28",
+ "jsesc": "^3.0.2"
+ },
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/helper-compilation-targets": {
+ "version": "7.28.6",
+ "resolved": "https://registry.npmjs.org/@babel/helper-compilation-targets/-/helper-compilation-targets-7.28.6.tgz",
+ "integrity": "sha512-JYtls3hqi15fcx5GaSNL7SCTJ2MNmjrkHXg4FSpOA/grxK8KwyZ5bubHsCq8FXCkua6xhuaaBit+3b7+VZRfcA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/compat-data": "^7.28.6",
+ "@babel/helper-validator-option": "^7.27.1",
+ "browserslist": "^4.24.0",
+ "lru-cache": "^5.1.1",
+ "semver": "^6.3.1"
+ },
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/helper-globals": {
+ "version": "7.28.0",
+ "resolved": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.28.0.tgz",
+ "integrity": "sha512-+W6cISkXFa1jXsDEdYA8HeevQT/FULhxzR99pxphltZcVaugps53THCeiWA8SguxxpSp3gKPiuYfSWopkLQ4hw==",
+ "license": "MIT",
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/helper-module-imports": {
+ "version": "7.28.6",
+ "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.28.6.tgz",
+ "integrity": "sha512-l5XkZK7r7wa9LucGw9LwZyyCUscb4x37JWTPz7swwFE/0FMQAGpiWUZn8u9DzkSBWEcK25jmvubfpw2dnAMdbw==",
+ "license": "MIT",
+ "dependencies": {
+ "@babel/traverse": "^7.28.6",
+ "@babel/types": "^7.28.6"
+ },
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/helper-module-transforms": {
+ "version": "7.28.6",
+ "resolved": "https://registry.npmjs.org/@babel/helper-module-transforms/-/helper-module-transforms-7.28.6.tgz",
+ "integrity": "sha512-67oXFAYr2cDLDVGLXTEABjdBJZ6drElUSI7WKp70NrpyISso3plG9SAGEF6y7zbha/wOzUByWWTJvEDVNIUGcA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/helper-module-imports": "^7.28.6",
+ "@babel/helper-validator-identifier": "^7.28.5",
+ "@babel/traverse": "^7.28.6"
+ },
+ "engines": {
+ "node": ">=6.9.0"
+ },
+ "peerDependencies": {
+ "@babel/core": "^7.0.0"
+ }
+ },
+ "node_modules/@babel/helper-plugin-utils": {
+ "version": "7.28.6",
+ "resolved": "https://registry.npmjs.org/@babel/helper-plugin-utils/-/helper-plugin-utils-7.28.6.tgz",
+ "integrity": "sha512-S9gzZ/bz83GRysI7gAD4wPT/AI3uCnY+9xn+Mx/KPs2JwHJIz1W8PZkg2cqyt3RNOBM8ejcXhV6y8Og7ly/Dug==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/helper-string-parser": {
+ "version": "7.27.1",
+ "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz",
+ "integrity": "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==",
+ "license": "MIT",
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/helper-validator-identifier": {
+ "version": "7.28.5",
+ "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.28.5.tgz",
+ "integrity": "sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==",
+ "license": "MIT",
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/helper-validator-option": {
+ "version": "7.27.1",
+ "resolved": "https://registry.npmjs.org/@babel/helper-validator-option/-/helper-validator-option-7.27.1.tgz",
+ "integrity": "sha512-YvjJow9FxbhFFKDSuFnVCe2WxXk1zWc22fFePVNEaWJEu8IrZVlda6N0uHwzZrUM1il7NC9Mlp4MaJYbYd9JSg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/helpers": {
+ "version": "7.29.2",
+ "resolved": "https://registry.npmjs.org/@babel/helpers/-/helpers-7.29.2.tgz",
+ "integrity": "sha512-HoGuUs4sCZNezVEKdVcwqmZN8GoHirLUcLaYVNBK2J0DadGtdcqgr3BCbvH8+XUo4NGjNl3VOtSjEKNzqfFgKw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/template": "^7.28.6",
+ "@babel/types": "^7.29.0"
+ },
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/parser": {
+ "version": "7.29.2",
+ "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.2.tgz",
+ "integrity": "sha512-4GgRzy/+fsBa72/RZVJmGKPmZu9Byn8o4MoLpmNe1m8ZfYnz5emHLQz3U4gLud6Zwl0RZIcgiLD7Uq7ySFuDLA==",
+ "license": "MIT",
+ "dependencies": {
+ "@babel/types": "^7.29.0"
+ },
+ "bin": {
+ "parser": "bin/babel-parser.js"
+ },
+ "engines": {
+ "node": ">=6.0.0"
+ }
+ },
+ "node_modules/@babel/plugin-transform-react-jsx-self": {
+ "version": "7.27.1",
+ "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-self/-/plugin-transform-react-jsx-self-7.27.1.tgz",
+ "integrity": "sha512-6UzkCs+ejGdZ5mFFC/OCUrv028ab2fp1znZmCZjAOBKiBK2jXD1O+BPSfX8X2qjJ75fZBMSnQn3Rq2mrBJK2mw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/helper-plugin-utils": "^7.27.1"
+ },
+ "engines": {
+ "node": ">=6.9.0"
+ },
+ "peerDependencies": {
+ "@babel/core": "^7.0.0-0"
+ }
+ },
+ "node_modules/@babel/plugin-transform-react-jsx-source": {
+ "version": "7.27.1",
+ "resolved": "https://registry.npmjs.org/@babel/plugin-transform-react-jsx-source/-/plugin-transform-react-jsx-source-7.27.1.tgz",
+ "integrity": "sha512-zbwoTsBruTeKB9hSq73ha66iFeJHuaFkUbwvqElnygoNbj/jHRsSeokowZFN3CZ64IvEqcmmkVe89OPXc7ldAw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/helper-plugin-utils": "^7.27.1"
+ },
+ "engines": {
+ "node": ">=6.9.0"
+ },
+ "peerDependencies": {
+ "@babel/core": "^7.0.0-0"
+ }
+ },
+ "node_modules/@babel/runtime": {
+ "version": "7.29.2",
+ "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.29.2.tgz",
+ "integrity": "sha512-JiDShH45zKHWyGe4ZNVRrCjBz8Nh9TMmZG1kh4QTK8hCBTWBi8Da+i7s1fJw7/lYpM4ccepSNfqzZ/QvABBi5g==",
+ "license": "MIT",
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/template": {
+ "version": "7.28.6",
+ "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.28.6.tgz",
+ "integrity": "sha512-YA6Ma2KsCdGb+WC6UpBVFJGXL58MDA6oyONbjyF/+5sBgxY/dwkhLogbMT2GXXyU84/IhRw/2D1Os1B/giz+BQ==",
+ "license": "MIT",
+ "dependencies": {
+ "@babel/code-frame": "^7.28.6",
+ "@babel/parser": "^7.28.6",
+ "@babel/types": "^7.28.6"
+ },
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/traverse": {
+ "version": "7.29.0",
+ "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.29.0.tgz",
+ "integrity": "sha512-4HPiQr0X7+waHfyXPZpWPfWL/J7dcN1mx9gL6WdQVMbPnF3+ZhSMs8tCxN7oHddJE9fhNE7+lxdnlyemKfJRuA==",
+ "license": "MIT",
+ "dependencies": {
+ "@babel/code-frame": "^7.29.0",
+ "@babel/generator": "^7.29.0",
+ "@babel/helper-globals": "^7.28.0",
+ "@babel/parser": "^7.29.0",
+ "@babel/template": "^7.28.6",
+ "@babel/types": "^7.29.0",
+ "debug": "^4.3.1"
+ },
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@babel/types": {
+ "version": "7.29.0",
+ "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.0.tgz",
+ "integrity": "sha512-LwdZHpScM4Qz8Xw2iKSzS+cfglZzJGvofQICy7W7v4caru4EaAmyUuO6BGrbyQ2mYV11W0U8j5mBhd14dd3B0A==",
+ "license": "MIT",
+ "dependencies": {
+ "@babel/helper-string-parser": "^7.27.1",
+ "@babel/helper-validator-identifier": "^7.28.5"
+ },
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/@develar/schema-utils": {
+ "version": "2.6.5",
+ "resolved": "https://registry.npmjs.org/@develar/schema-utils/-/schema-utils-2.6.5.tgz",
+ "integrity": "sha512-0cp4PsWQ/9avqTVMCtZ+GirikIA36ikvjtHweU4/j8yLtgObI0+JUPhYFScgwlteveGB1rt3Cm8UhN04XayDig==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "ajv": "^6.12.0",
+ "ajv-keywords": "^3.4.1"
+ },
+ "engines": {
+ "node": ">= 8.9.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/webpack"
+ }
+ },
+ "node_modules/@electron/asar": {
+ "version": "3.4.1",
+ "resolved": "https://registry.npmjs.org/@electron/asar/-/asar-3.4.1.tgz",
+ "integrity": "sha512-i4/rNPRS84t0vSRa2HorerGRXWyF4vThfHesw0dmcWHp+cspK743UanA0suA5Q5y8kzY2y6YKrvbIUn69BCAiA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "commander": "^5.0.0",
+ "glob": "^7.1.6",
+ "minimatch": "^3.0.4"
+ },
+ "bin": {
+ "asar": "bin/asar.js"
+ },
+ "engines": {
+ "node": ">=10.12.0"
+ }
+ },
+ "node_modules/@electron/asar/node_modules/balanced-match": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+ "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@electron/asar/node_modules/brace-expansion": {
+ "version": "1.1.13",
+ "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.13.tgz",
+ "integrity": "sha512-9ZLprWS6EENmhEOpjCYW2c8VkmOvckIJZfkr7rBW6dObmfgJ/L1GpSYW5Hpo9lDz4D1+n0Ckz8rU7FwHDQiG/w==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "balanced-match": "^1.0.0",
+ "concat-map": "0.0.1"
+ }
+ },
+ "node_modules/@electron/asar/node_modules/commander": {
+ "version": "5.1.0",
+ "resolved": "https://registry.npmjs.org/commander/-/commander-5.1.0.tgz",
+ "integrity": "sha512-P0CysNDQ7rtVw4QIQtm+MRxV66vKFSvlsQvGYXZWR3qFU0jlMKHZZZgw8e+8DSah4UDKMqnknRDQz+xuQXQ/Zg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 6"
+ }
+ },
+ "node_modules/@electron/asar/node_modules/minimatch": {
+ "version": "3.1.5",
+ "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz",
+ "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "brace-expansion": "^1.1.7"
+ },
+ "engines": {
+ "node": "*"
+ }
+ },
+ "node_modules/@electron/fuses": {
+ "version": "1.8.0",
+ "resolved": "https://registry.npmjs.org/@electron/fuses/-/fuses-1.8.0.tgz",
+ "integrity": "sha512-zx0EIq78WlY/lBb1uXlziZmDZI4ubcCXIMJ4uGjXzZW0nS19TjSPeXPAjzzTmKQlJUZm0SbmZhPKP7tuQ1SsEw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "chalk": "^4.1.1",
+ "fs-extra": "^9.0.1",
+ "minimist": "^1.2.5"
+ },
+ "bin": {
+ "electron-fuses": "dist/bin.js"
+ }
+ },
+ "node_modules/@electron/fuses/node_modules/fs-extra": {
+ "version": "9.1.0",
+ "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-9.1.0.tgz",
+ "integrity": "sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "at-least-node": "^1.0.0",
+ "graceful-fs": "^4.2.0",
+ "jsonfile": "^6.0.1",
+ "universalify": "^2.0.0"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/@electron/fuses/node_modules/jsonfile": {
+ "version": "6.2.0",
+ "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.0.tgz",
+ "integrity": "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "universalify": "^2.0.0"
+ },
+ "optionalDependencies": {
+ "graceful-fs": "^4.1.6"
+ }
+ },
+ "node_modules/@electron/fuses/node_modules/universalify": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
+ "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 10.0.0"
+ }
+ },
+ "node_modules/@electron/get": {
+ "version": "2.0.3",
+ "resolved": "https://registry.npmjs.org/@electron/get/-/get-2.0.3.tgz",
+ "integrity": "sha512-Qkzpg2s9GnVV2I2BjRksUi43U5e6+zaQMcjoJy0C+C5oxaKl+fmckGDQFtRpZpZV0NQekuZZ+tGz7EA9TVnQtQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "debug": "^4.1.1",
+ "env-paths": "^2.2.0",
+ "fs-extra": "^8.1.0",
+ "got": "^11.8.5",
+ "progress": "^2.0.3",
+ "semver": "^6.2.0",
+ "sumchecker": "^3.0.1"
+ },
+ "engines": {
+ "node": ">=12"
+ },
+ "optionalDependencies": {
+ "global-agent": "^3.0.0"
+ }
+ },
+ "node_modules/@electron/notarize": {
+ "version": "2.5.0",
+ "resolved": "https://registry.npmjs.org/@electron/notarize/-/notarize-2.5.0.tgz",
+ "integrity": "sha512-jNT8nwH1f9X5GEITXaQ8IF/KdskvIkOFfB2CvwumsveVidzpSc+mvhhTMdAGSYF3O+Nq49lJ7y+ssODRXu06+A==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "debug": "^4.1.1",
+ "fs-extra": "^9.0.1",
+ "promise-retry": "^2.0.1"
+ },
+ "engines": {
+ "node": ">= 10.0.0"
+ }
+ },
+ "node_modules/@electron/notarize/node_modules/fs-extra": {
+ "version": "9.1.0",
+ "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-9.1.0.tgz",
+ "integrity": "sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "at-least-node": "^1.0.0",
+ "graceful-fs": "^4.2.0",
+ "jsonfile": "^6.0.1",
+ "universalify": "^2.0.0"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/@electron/notarize/node_modules/jsonfile": {
+ "version": "6.2.0",
+ "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.0.tgz",
+ "integrity": "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "universalify": "^2.0.0"
+ },
+ "optionalDependencies": {
+ "graceful-fs": "^4.1.6"
+ }
+ },
+ "node_modules/@electron/notarize/node_modules/universalify": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
+ "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 10.0.0"
+ }
+ },
+ "node_modules/@electron/osx-sign": {
+ "version": "1.3.3",
+ "resolved": "https://registry.npmjs.org/@electron/osx-sign/-/osx-sign-1.3.3.tgz",
+ "integrity": "sha512-KZ8mhXvWv2rIEgMbWZ4y33bDHyUKMXnx4M0sTyPNK/vcB81ImdeY9Ggdqy0SWbMDgmbqyQ+phgejh6V3R2QuSg==",
+ "dev": true,
+ "license": "BSD-2-Clause",
+ "dependencies": {
+ "compare-version": "^0.1.2",
+ "debug": "^4.3.4",
+ "fs-extra": "^10.0.0",
+ "isbinaryfile": "^4.0.8",
+ "minimist": "^1.2.6",
+ "plist": "^3.0.5"
+ },
+ "bin": {
+ "electron-osx-flat": "bin/electron-osx-flat.js",
+ "electron-osx-sign": "bin/electron-osx-sign.js"
+ },
+ "engines": {
+ "node": ">=12.0.0"
+ }
+ },
+ "node_modules/@electron/osx-sign/node_modules/fs-extra": {
+ "version": "10.1.0",
+ "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-10.1.0.tgz",
+ "integrity": "sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "graceful-fs": "^4.2.0",
+ "jsonfile": "^6.0.1",
+ "universalify": "^2.0.0"
+ },
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/@electron/osx-sign/node_modules/isbinaryfile": {
+ "version": "4.0.10",
+ "resolved": "https://registry.npmjs.org/isbinaryfile/-/isbinaryfile-4.0.10.tgz",
+ "integrity": "sha512-iHrqe5shvBUcFbmZq9zOQHBoeOhZJu6RQGrDpBgenUm/Am+F3JM2MgQj+rK3Z601fzrL5gLZWtAPH2OBaSVcyw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 8.0.0"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/gjtorikian/"
+ }
+ },
+ "node_modules/@electron/osx-sign/node_modules/jsonfile": {
+ "version": "6.2.0",
+ "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.0.tgz",
+ "integrity": "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "universalify": "^2.0.0"
+ },
+ "optionalDependencies": {
+ "graceful-fs": "^4.1.6"
+ }
+ },
+ "node_modules/@electron/osx-sign/node_modules/universalify": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
+ "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 10.0.0"
+ }
+ },
+ "node_modules/@electron/rebuild": {
+ "version": "4.0.3",
+ "resolved": "https://registry.npmjs.org/@electron/rebuild/-/rebuild-4.0.3.tgz",
+ "integrity": "sha512-u9vpTHRMkOYCs/1FLiSVAFZ7FbjsXK+bQuzviJZa+lG7BHZl1nz52/IcGvwa3sk80/fc3llutBkbCq10Vh8WQA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@malept/cross-spawn-promise": "^2.0.0",
+ "debug": "^4.1.1",
+ "detect-libc": "^2.0.1",
+ "got": "^11.7.0",
+ "graceful-fs": "^4.2.11",
+ "node-abi": "^4.2.0",
+ "node-api-version": "^0.2.1",
+ "node-gyp": "^11.2.0",
+ "ora": "^5.1.0",
+ "read-binary-file-arch": "^1.0.6",
+ "semver": "^7.3.5",
+ "tar": "^7.5.6",
+ "yargs": "^17.0.1"
+ },
+ "bin": {
+ "electron-rebuild": "lib/cli.js"
+ },
+ "engines": {
+ "node": ">=22.12.0"
+ }
+ },
+ "node_modules/@electron/rebuild/node_modules/semver": {
+ "version": "7.7.4",
+ "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz",
+ "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==",
+ "dev": true,
+ "license": "ISC",
+ "bin": {
+ "semver": "bin/semver.js"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/@electron/universal": {
+ "version": "2.0.3",
+ "resolved": "https://registry.npmjs.org/@electron/universal/-/universal-2.0.3.tgz",
+ "integrity": "sha512-Wn9sPYIVFRFl5HmwMJkARCCf7rqK/EurkfQ/rJZ14mHP3iYTjZSIOSVonEAnhWeAXwtw7zOekGRlc6yTtZ0t+g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@electron/asar": "^3.3.1",
+ "@malept/cross-spawn-promise": "^2.0.0",
+ "debug": "^4.3.1",
+ "dir-compare": "^4.2.0",
+ "fs-extra": "^11.1.1",
+ "minimatch": "^9.0.3",
+ "plist": "^3.1.0"
+ },
+ "engines": {
+ "node": ">=16.4"
+ }
+ },
+ "node_modules/@electron/universal/node_modules/balanced-match": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+ "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@electron/universal/node_modules/brace-expansion": {
+ "version": "2.0.3",
+ "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.3.tgz",
+ "integrity": "sha512-MCV/fYJEbqx68aE58kv2cA/kiky1G8vux3OR6/jbS+jIMe/6fJWa0DTzJU7dqijOWYwHi1t29FlfYI9uytqlpA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "balanced-match": "^1.0.0"
+ }
+ },
+ "node_modules/@electron/universal/node_modules/fs-extra": {
+ "version": "11.3.4",
+ "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.3.4.tgz",
+ "integrity": "sha512-CTXd6rk/M3/ULNQj8FBqBWHYBVYybQ3VPBw0xGKFe3tuH7ytT6ACnvzpIQ3UZtB8yvUKC2cXn1a+x+5EVQLovA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "graceful-fs": "^4.2.0",
+ "jsonfile": "^6.0.1",
+ "universalify": "^2.0.0"
+ },
+ "engines": {
+ "node": ">=14.14"
+ }
+ },
+ "node_modules/@electron/universal/node_modules/jsonfile": {
+ "version": "6.2.0",
+ "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.0.tgz",
+ "integrity": "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "universalify": "^2.0.0"
+ },
+ "optionalDependencies": {
+ "graceful-fs": "^4.1.6"
+ }
+ },
+ "node_modules/@electron/universal/node_modules/minimatch": {
+ "version": "9.0.9",
+ "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.9.tgz",
+ "integrity": "sha512-OBwBN9AL4dqmETlpS2zasx+vTeWclWzkblfZk7KTA5j3jeOONz/tRCnZomUyvNg83wL5Zv9Ss6HMJXAgL8R2Yg==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "brace-expansion": "^2.0.2"
+ },
+ "engines": {
+ "node": ">=16 || 14 >=14.17"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/isaacs"
+ }
+ },
+ "node_modules/@electron/universal/node_modules/universalify": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
+ "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 10.0.0"
+ }
+ },
+ "node_modules/@electron/windows-sign": {
+ "version": "1.2.2",
+ "resolved": "https://registry.npmjs.org/@electron/windows-sign/-/windows-sign-1.2.2.tgz",
+ "integrity": "sha512-dfZeox66AvdPtb2lD8OsIIQh12Tp0GNCRUDfBHIKGpbmopZto2/A8nSpYYLoedPIHpqkeblZ/k8OV0Gy7PYuyQ==",
+ "dev": true,
+ "license": "BSD-2-Clause",
+ "optional": true,
+ "peer": true,
+ "dependencies": {
+ "cross-dirname": "^0.1.0",
+ "debug": "^4.3.4",
+ "fs-extra": "^11.1.1",
+ "minimist": "^1.2.8",
+ "postject": "^1.0.0-alpha.6"
+ },
+ "bin": {
+ "electron-windows-sign": "bin/electron-windows-sign.js"
+ },
+ "engines": {
+ "node": ">=14.14"
+ }
+ },
+ "node_modules/@electron/windows-sign/node_modules/fs-extra": {
+ "version": "11.3.4",
+ "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.3.4.tgz",
+ "integrity": "sha512-CTXd6rk/M3/ULNQj8FBqBWHYBVYybQ3VPBw0xGKFe3tuH7ytT6ACnvzpIQ3UZtB8yvUKC2cXn1a+x+5EVQLovA==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "peer": true,
+ "dependencies": {
+ "graceful-fs": "^4.2.0",
+ "jsonfile": "^6.0.1",
+ "universalify": "^2.0.0"
+ },
+ "engines": {
+ "node": ">=14.14"
+ }
+ },
+ "node_modules/@electron/windows-sign/node_modules/jsonfile": {
+ "version": "6.2.0",
+ "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.0.tgz",
+ "integrity": "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "peer": true,
+ "dependencies": {
+ "universalify": "^2.0.0"
+ },
+ "optionalDependencies": {
+ "graceful-fs": "^4.1.6"
+ }
+ },
+ "node_modules/@electron/windows-sign/node_modules/universalify": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
+ "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "peer": true,
+ "engines": {
+ "node": ">= 10.0.0"
+ }
+ },
+ "node_modules/@emotion/babel-plugin": {
+ "version": "11.13.5",
+ "resolved": "https://registry.npmjs.org/@emotion/babel-plugin/-/babel-plugin-11.13.5.tgz",
+ "integrity": "sha512-pxHCpT2ex+0q+HH91/zsdHkw/lXd468DIN2zvfvLtPKLLMo6gQj7oLObq8PhkrxOZb/gGCq03S3Z7PDhS8pduQ==",
+ "license": "MIT",
+ "dependencies": {
+ "@babel/helper-module-imports": "^7.16.7",
+ "@babel/runtime": "^7.18.3",
+ "@emotion/hash": "^0.9.2",
+ "@emotion/memoize": "^0.9.0",
+ "@emotion/serialize": "^1.3.3",
+ "babel-plugin-macros": "^3.1.0",
+ "convert-source-map": "^1.5.0",
+ "escape-string-regexp": "^4.0.0",
+ "find-root": "^1.1.0",
+ "source-map": "^0.5.7",
+ "stylis": "4.2.0"
+ }
+ },
+ "node_modules/@emotion/cache": {
+ "version": "11.14.0",
+ "resolved": "https://registry.npmjs.org/@emotion/cache/-/cache-11.14.0.tgz",
+ "integrity": "sha512-L/B1lc/TViYk4DcpGxtAVbx0ZyiKM5ktoIyafGkH6zg/tj+mA+NE//aPYKG0k8kCHSHVJrpLpcAlOBEXQ3SavA==",
+ "license": "MIT",
+ "dependencies": {
+ "@emotion/memoize": "^0.9.0",
+ "@emotion/sheet": "^1.4.0",
+ "@emotion/utils": "^1.4.2",
+ "@emotion/weak-memoize": "^0.4.0",
+ "stylis": "4.2.0"
+ }
+ },
+ "node_modules/@emotion/hash": {
+ "version": "0.9.2",
+ "resolved": "https://registry.npmjs.org/@emotion/hash/-/hash-0.9.2.tgz",
+ "integrity": "sha512-MyqliTZGuOm3+5ZRSaaBGP3USLw6+EGykkwZns2EPC5g8jJ4z9OrdZY9apkl3+UP9+sdz76YYkwCKP5gh8iY3g==",
+ "license": "MIT"
+ },
+ "node_modules/@emotion/is-prop-valid": {
+ "version": "1.4.0",
+ "resolved": "https://registry.npmjs.org/@emotion/is-prop-valid/-/is-prop-valid-1.4.0.tgz",
+ "integrity": "sha512-QgD4fyscGcbbKwJmqNvUMSE02OsHUa+lAWKdEUIJKgqe5IwRSKd7+KhibEWdaKwgjLj0DRSHA9biAIqGBk05lw==",
+ "license": "MIT",
+ "dependencies": {
+ "@emotion/memoize": "^0.9.0"
+ }
+ },
+ "node_modules/@emotion/memoize": {
+ "version": "0.9.0",
+ "resolved": "https://registry.npmjs.org/@emotion/memoize/-/memoize-0.9.0.tgz",
+ "integrity": "sha512-30FAj7/EoJ5mwVPOWhAyCX+FPfMDrVecJAM+Iw9NRoSl4BBAQeqj4cApHHUXOVvIPgLVDsCFoz/hGD+5QQD1GQ==",
+ "license": "MIT"
+ },
+ "node_modules/@emotion/react": {
+ "version": "11.14.0",
+ "resolved": "https://registry.npmjs.org/@emotion/react/-/react-11.14.0.tgz",
+ "integrity": "sha512-O000MLDBDdk/EohJPFUqvnp4qnHeYkVP5B0xEG0D/L7cOKP9kefu2DXn8dj74cQfsEzUqh+sr1RzFqiL1o+PpA==",
+ "license": "MIT",
+ "dependencies": {
+ "@babel/runtime": "^7.18.3",
+ "@emotion/babel-plugin": "^11.13.5",
+ "@emotion/cache": "^11.14.0",
+ "@emotion/serialize": "^1.3.3",
+ "@emotion/use-insertion-effect-with-fallbacks": "^1.2.0",
+ "@emotion/utils": "^1.4.2",
+ "@emotion/weak-memoize": "^0.4.0",
+ "hoist-non-react-statics": "^3.3.1"
+ },
+ "peerDependencies": {
+ "react": ">=16.8.0"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@emotion/serialize": {
+ "version": "1.3.3",
+ "resolved": "https://registry.npmjs.org/@emotion/serialize/-/serialize-1.3.3.tgz",
+ "integrity": "sha512-EISGqt7sSNWHGI76hC7x1CksiXPahbxEOrC5RjmFRJTqLyEK9/9hZvBbiYn70dw4wuwMKiEMCUlR6ZXTSWQqxA==",
+ "license": "MIT",
+ "dependencies": {
+ "@emotion/hash": "^0.9.2",
+ "@emotion/memoize": "^0.9.0",
+ "@emotion/unitless": "^0.10.0",
+ "@emotion/utils": "^1.4.2",
+ "csstype": "^3.0.2"
+ }
+ },
+ "node_modules/@emotion/sheet": {
+ "version": "1.4.0",
+ "resolved": "https://registry.npmjs.org/@emotion/sheet/-/sheet-1.4.0.tgz",
+ "integrity": "sha512-fTBW9/8r2w3dXWYM4HCB1Rdp8NLibOw2+XELH5m5+AkWiL/KqYX6dc0kKYlaYyKjrQ6ds33MCdMPEwgs2z1rqg==",
+ "license": "MIT"
+ },
+ "node_modules/@emotion/styled": {
+ "version": "11.14.1",
+ "resolved": "https://registry.npmjs.org/@emotion/styled/-/styled-11.14.1.tgz",
+ "integrity": "sha512-qEEJt42DuToa3gurlH4Qqc1kVpNq8wO8cJtDzU46TjlzWjDlsVyevtYCRijVq3SrHsROS+gVQ8Fnea108GnKzw==",
+ "license": "MIT",
+ "dependencies": {
+ "@babel/runtime": "^7.18.3",
+ "@emotion/babel-plugin": "^11.13.5",
+ "@emotion/is-prop-valid": "^1.3.0",
+ "@emotion/serialize": "^1.3.3",
+ "@emotion/use-insertion-effect-with-fallbacks": "^1.2.0",
+ "@emotion/utils": "^1.4.2"
+ },
+ "peerDependencies": {
+ "@emotion/react": "^11.0.0-rc.0",
+ "react": ">=16.8.0"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@emotion/unitless": {
+ "version": "0.10.0",
+ "resolved": "https://registry.npmjs.org/@emotion/unitless/-/unitless-0.10.0.tgz",
+ "integrity": "sha512-dFoMUuQA20zvtVTuxZww6OHoJYgrzfKM1t52mVySDJnMSEa08ruEvdYQbhvyu6soU+NeLVd3yKfTfT0NeV6qGg==",
+ "license": "MIT"
+ },
+ "node_modules/@emotion/use-insertion-effect-with-fallbacks": {
+ "version": "1.2.0",
+ "resolved": "https://registry.npmjs.org/@emotion/use-insertion-effect-with-fallbacks/-/use-insertion-effect-with-fallbacks-1.2.0.tgz",
+ "integrity": "sha512-yJMtVdH59sxi/aVJBpk9FQq+OR8ll5GT8oWd57UpeaKEVGab41JWaCFA7FRLoMLloOZF/c/wsPoe+bfGmRKgDg==",
+ "license": "MIT",
+ "peerDependencies": {
+ "react": ">=16.8.0"
+ }
+ },
+ "node_modules/@emotion/utils": {
+ "version": "1.4.2",
+ "resolved": "https://registry.npmjs.org/@emotion/utils/-/utils-1.4.2.tgz",
+ "integrity": "sha512-3vLclRofFziIa3J2wDh9jjbkUz9qk5Vi3IZ/FSTKViB0k+ef0fPV7dYrUIugbgupYDx7v9ud/SjrtEP8Y4xLoA==",
+ "license": "MIT"
+ },
+ "node_modules/@emotion/weak-memoize": {
+ "version": "0.4.0",
+ "resolved": "https://registry.npmjs.org/@emotion/weak-memoize/-/weak-memoize-0.4.0.tgz",
+ "integrity": "sha512-snKqtPW01tN0ui7yu9rGv69aJXr/a/Ywvl11sUjNtEcRc+ng/mQriFL0wLXMef74iHa/EkftbDzU9F8iFbH+zg==",
+ "license": "MIT"
+ },
+ "node_modules/@esbuild/aix-ppc64": {
+ "version": "0.27.4",
+ "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.27.4.tgz",
+ "integrity": "sha512-cQPwL2mp2nSmHHJlCyoXgHGhbEPMrEEU5xhkcy3Hs/O7nGZqEpZ2sUtLaL9MORLtDfRvVl2/3PAuEkYZH0Ty8Q==",
+ "cpu": [
+ "ppc64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "aix"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/android-arm": {
+ "version": "0.27.4",
+ "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.27.4.tgz",
+ "integrity": "sha512-X9bUgvxiC8CHAGKYufLIHGXPJWnr0OCdR0anD2e21vdvgCI8lIfqFbnoeOz7lBjdrAGUhqLZLcQo6MLhTO2DKQ==",
+ "cpu": [
+ "arm"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "android"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/android-arm64": {
+ "version": "0.27.4",
+ "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.27.4.tgz",
+ "integrity": "sha512-gdLscB7v75wRfu7QSm/zg6Rx29VLdy9eTr2t44sfTW7CxwAtQghZ4ZnqHk3/ogz7xao0QAgrkradbBzcqFPasw==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "android"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/android-x64": {
+ "version": "0.27.4",
+ "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.27.4.tgz",
+ "integrity": "sha512-PzPFnBNVF292sfpfhiyiXCGSn9HZg5BcAz+ivBuSsl6Rk4ga1oEXAamhOXRFyMcjwr2DVtm40G65N3GLeH1Lvw==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "android"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/darwin-arm64": {
+ "version": "0.27.4",
+ "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.27.4.tgz",
+ "integrity": "sha512-b7xaGIwdJlht8ZFCvMkpDN6uiSmnxxK56N2GDTMYPr2/gzvfdQN8rTfBsvVKmIVY/X7EM+/hJKEIbbHs9oA4tQ==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "darwin"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/darwin-x64": {
+ "version": "0.27.4",
+ "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.27.4.tgz",
+ "integrity": "sha512-sR+OiKLwd15nmCdqpXMnuJ9W2kpy0KigzqScqHI3Hqwr7IXxBp3Yva+yJwoqh7rE8V77tdoheRYataNKL4QrPw==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "darwin"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/freebsd-arm64": {
+ "version": "0.27.4",
+ "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.27.4.tgz",
+ "integrity": "sha512-jnfpKe+p79tCnm4GVav68A7tUFeKQwQyLgESwEAUzyxk/TJr4QdGog9sqWNcUbr/bZt/O/HXouspuQDd9JxFSw==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "freebsd"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/freebsd-x64": {
+ "version": "0.27.4",
+ "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.27.4.tgz",
+ "integrity": "sha512-2kb4ceA/CpfUrIcTUl1wrP/9ad9Atrp5J94Lq69w7UwOMolPIGrfLSvAKJp0RTvkPPyn6CIWrNy13kyLikZRZQ==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "freebsd"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/linux-arm": {
+ "version": "0.27.4",
+ "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.27.4.tgz",
+ "integrity": "sha512-aBYgcIxX/wd5n2ys0yESGeYMGF+pv6g0DhZr3G1ZG4jMfruU9Tl1i2Z+Wnj9/KjGz1lTLCcorqE2viePZqj4Eg==",
+ "cpu": [
+ "arm"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/linux-arm64": {
+ "version": "0.27.4",
+ "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.27.4.tgz",
+ "integrity": "sha512-7nQOttdzVGth1iz57kxg9uCz57dxQLHWxopL6mYuYthohPKEK0vU0C3O21CcBK6KDlkYVcnDXY099HcCDXd9dA==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/linux-ia32": {
+ "version": "0.27.4",
+ "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.27.4.tgz",
+ "integrity": "sha512-oPtixtAIzgvzYcKBQM/qZ3R+9TEUd1aNJQu0HhGyqtx6oS7qTpvjheIWBbes4+qu1bNlo2V4cbkISr8q6gRBFA==",
+ "cpu": [
+ "ia32"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/linux-loong64": {
+ "version": "0.27.4",
+ "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.27.4.tgz",
+ "integrity": "sha512-8mL/vh8qeCoRcFH2nM8wm5uJP+ZcVYGGayMavi8GmRJjuI3g1v6Z7Ni0JJKAJW+m0EtUuARb6Lmp4hMjzCBWzA==",
+ "cpu": [
+ "loong64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/linux-mips64el": {
+ "version": "0.27.4",
+ "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.27.4.tgz",
+ "integrity": "sha512-1RdrWFFiiLIW7LQq9Q2NES+HiD4NyT8Itj9AUeCl0IVCA459WnPhREKgwrpaIfTOe+/2rdntisegiPWn/r/aAw==",
+ "cpu": [
+ "mips64el"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/linux-ppc64": {
+ "version": "0.27.4",
+ "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.27.4.tgz",
+ "integrity": "sha512-tLCwNG47l3sd9lpfyx9LAGEGItCUeRCWeAx6x2Jmbav65nAwoPXfewtAdtbtit/pJFLUWOhpv0FpS6GQAmPrHA==",
+ "cpu": [
+ "ppc64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/linux-riscv64": {
+ "version": "0.27.4",
+ "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.27.4.tgz",
+ "integrity": "sha512-BnASypppbUWyqjd1KIpU4AUBiIhVr6YlHx/cnPgqEkNoVOhHg+YiSVxM1RLfiy4t9cAulbRGTNCKOcqHrEQLIw==",
+ "cpu": [
+ "riscv64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/linux-s390x": {
+ "version": "0.27.4",
+ "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.27.4.tgz",
+ "integrity": "sha512-+eUqgb/Z7vxVLezG8bVB9SfBie89gMueS+I0xYh2tJdw3vqA/0ImZJ2ROeWwVJN59ihBeZ7Tu92dF/5dy5FttA==",
+ "cpu": [
+ "s390x"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/linux-x64": {
+ "version": "0.27.4",
+ "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.27.4.tgz",
+ "integrity": "sha512-S5qOXrKV8BQEzJPVxAwnryi2+Iq5pB40gTEIT69BQONqR7JH1EPIcQ/Uiv9mCnn05jff9umq/5nqzxlqTOg9NA==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/netbsd-arm64": {
+ "version": "0.27.4",
+ "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.27.4.tgz",
+ "integrity": "sha512-xHT8X4sb0GS8qTqiwzHqpY00C95DPAq7nAwX35Ie/s+LO9830hrMd3oX0ZMKLvy7vsonee73x0lmcdOVXFzd6Q==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "netbsd"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/netbsd-x64": {
+ "version": "0.27.4",
+ "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.27.4.tgz",
+ "integrity": "sha512-RugOvOdXfdyi5Tyv40kgQnI0byv66BFgAqjdgtAKqHoZTbTF2QqfQrFwa7cHEORJf6X2ht+l9ABLMP0dnKYsgg==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "netbsd"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/openbsd-arm64": {
+ "version": "0.27.4",
+ "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.27.4.tgz",
+ "integrity": "sha512-2MyL3IAaTX+1/qP0O1SwskwcwCoOI4kV2IBX1xYnDDqthmq5ArrW94qSIKCAuRraMgPOmG0RDTA74mzYNQA9ow==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "openbsd"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/openbsd-x64": {
+ "version": "0.27.4",
+ "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.27.4.tgz",
+ "integrity": "sha512-u8fg/jQ5aQDfsnIV6+KwLOf1CmJnfu1ShpwqdwC0uA7ZPwFws55Ngc12vBdeUdnuWoQYx/SOQLGDcdlfXhYmXQ==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "openbsd"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/openharmony-arm64": {
+ "version": "0.27.4",
+ "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.27.4.tgz",
+ "integrity": "sha512-JkTZrl6VbyO8lDQO3yv26nNr2RM2yZzNrNHEsj9bm6dOwwu9OYN28CjzZkH57bh4w0I2F7IodpQvUAEd1mbWXg==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "openharmony"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/sunos-x64": {
+ "version": "0.27.4",
+ "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.27.4.tgz",
+ "integrity": "sha512-/gOzgaewZJfeJTlsWhvUEmUG4tWEY2Spp5M20INYRg2ZKl9QPO3QEEgPeRtLjEWSW8FilRNacPOg8R1uaYkA6g==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "sunos"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/win32-arm64": {
+ "version": "0.27.4",
+ "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.27.4.tgz",
+ "integrity": "sha512-Z9SExBg2y32smoDQdf1HRwHRt6vAHLXcxD2uGgO/v2jK7Y718Ix4ndsbNMU/+1Qiem9OiOdaqitioZwxivhXYg==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "win32"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/win32-ia32": {
+ "version": "0.27.4",
+ "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.27.4.tgz",
+ "integrity": "sha512-DAyGLS0Jz5G5iixEbMHi5KdiApqHBWMGzTtMiJ72ZOLhbu/bzxgAe8Ue8CTS3n3HbIUHQz/L51yMdGMeoxXNJw==",
+ "cpu": [
+ "ia32"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "win32"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@esbuild/win32-x64": {
+ "version": "0.27.4",
+ "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.27.4.tgz",
+ "integrity": "sha512-+knoa0BDoeXgkNvvV1vvbZX4+hizelrkwmGJBdT17t8FNPwG2lKemmuMZlmaNQ3ws3DKKCxpb4zRZEIp3UxFCg==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "win32"
+ ],
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@fontsource/roboto": {
+ "version": "5.2.10",
+ "resolved": "https://registry.npmjs.org/@fontsource/roboto/-/roboto-5.2.10.tgz",
+ "integrity": "sha512-8HlA5FtSfz//oFSr2eL7GFXAiE7eIkcGOtx7tjsLKq+as702x9+GU7K95iDeWFapHC4M2hv9RrpXKRTGGBI8Zg==",
+ "license": "OFL-1.1",
+ "funding": {
+ "url": "https://github.com/sponsors/ayuhito"
+ }
+ },
+ "node_modules/@isaacs/cliui": {
+ "version": "8.0.2",
+ "resolved": "https://registry.npmjs.org/@isaacs/cliui/-/cliui-8.0.2.tgz",
+ "integrity": "sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "string-width": "^5.1.2",
+ "string-width-cjs": "npm:string-width@^4.2.0",
+ "strip-ansi": "^7.0.1",
+ "strip-ansi-cjs": "npm:strip-ansi@^6.0.1",
+ "wrap-ansi": "^8.1.0",
+ "wrap-ansi-cjs": "npm:wrap-ansi@^7.0.0"
+ },
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/@isaacs/cliui/node_modules/ansi-regex": {
+ "version": "6.2.2",
+ "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.2.2.tgz",
+ "integrity": "sha512-Bq3SmSpyFHaWjPk8If9yc6svM8c56dB5BAtW4Qbw5jHTwwXXcTLoRMkpDJp6VL0XzlWaCHTXrkFURMYmD0sLqg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=12"
+ },
+ "funding": {
+ "url": "https://github.com/chalk/ansi-regex?sponsor=1"
+ }
+ },
+ "node_modules/@isaacs/cliui/node_modules/ansi-styles": {
+ "version": "6.2.3",
+ "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.3.tgz",
+ "integrity": "sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=12"
+ },
+ "funding": {
+ "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+ }
+ },
+ "node_modules/@isaacs/cliui/node_modules/emoji-regex": {
+ "version": "9.2.2",
+ "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz",
+ "integrity": "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@isaacs/cliui/node_modules/string-width": {
+ "version": "5.1.2",
+ "resolved": "https://registry.npmjs.org/string-width/-/string-width-5.1.2.tgz",
+ "integrity": "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "eastasianwidth": "^0.2.0",
+ "emoji-regex": "^9.2.2",
+ "strip-ansi": "^7.0.1"
+ },
+ "engines": {
+ "node": ">=12"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/@isaacs/cliui/node_modules/strip-ansi": {
+ "version": "7.2.0",
+ "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.2.0.tgz",
+ "integrity": "sha512-yDPMNjp4WyfYBkHnjIRLfca1i6KMyGCtsVgoKe/z1+6vukgaENdgGBZt+ZmKPc4gavvEZ5OgHfHdrazhgNyG7w==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "ansi-regex": "^6.2.2"
+ },
+ "engines": {
+ "node": ">=12"
+ },
+ "funding": {
+ "url": "https://github.com/chalk/strip-ansi?sponsor=1"
+ }
+ },
+ "node_modules/@isaacs/cliui/node_modules/wrap-ansi": {
+ "version": "8.1.0",
+ "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-8.1.0.tgz",
+ "integrity": "sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "ansi-styles": "^6.1.0",
+ "string-width": "^5.0.1",
+ "strip-ansi": "^7.0.1"
+ },
+ "engines": {
+ "node": ">=12"
+ },
+ "funding": {
+ "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
+ }
+ },
+ "node_modules/@isaacs/fs-minipass": {
+ "version": "4.0.1",
+ "resolved": "https://registry.npmjs.org/@isaacs/fs-minipass/-/fs-minipass-4.0.1.tgz",
+ "integrity": "sha512-wgm9Ehl2jpeqP3zw/7mo3kRHFp5MEDhqAdwy1fTGkHAwnkGOVsgpvQhL8B5n1qlb01jV3n/bI0ZfZp5lWA1k4w==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "minipass": "^7.0.4"
+ },
+ "engines": {
+ "node": ">=18.0.0"
+ }
+ },
+ "node_modules/@jridgewell/gen-mapping": {
+ "version": "0.3.13",
+ "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",
+ "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==",
+ "license": "MIT",
+ "dependencies": {
+ "@jridgewell/sourcemap-codec": "^1.5.0",
+ "@jridgewell/trace-mapping": "^0.3.24"
+ }
+ },
+ "node_modules/@jridgewell/remapping": {
+ "version": "2.3.5",
+ "resolved": "https://registry.npmjs.org/@jridgewell/remapping/-/remapping-2.3.5.tgz",
+ "integrity": "sha512-LI9u/+laYG4Ds1TDKSJW2YPrIlcVYOwi2fUC6xB43lueCjgxV4lffOCZCtYFiH6TNOX+tQKXx97T4IKHbhyHEQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@jridgewell/gen-mapping": "^0.3.5",
+ "@jridgewell/trace-mapping": "^0.3.24"
+ }
+ },
+ "node_modules/@jridgewell/resolve-uri": {
+ "version": "3.1.2",
+ "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
+ "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
+ "license": "MIT",
+ "engines": {
+ "node": ">=6.0.0"
+ }
+ },
+ "node_modules/@jridgewell/sourcemap-codec": {
+ "version": "1.5.5",
+ "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
+ "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
+ "license": "MIT"
+ },
+ "node_modules/@jridgewell/trace-mapping": {
+ "version": "0.3.31",
+ "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz",
+ "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==",
+ "license": "MIT",
+ "dependencies": {
+ "@jridgewell/resolve-uri": "^3.1.0",
+ "@jridgewell/sourcemap-codec": "^1.4.14"
+ }
+ },
+ "node_modules/@malept/cross-spawn-promise": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/@malept/cross-spawn-promise/-/cross-spawn-promise-2.0.0.tgz",
+ "integrity": "sha512-1DpKU0Z5ThltBwjNySMC14g0CkbyhCaz9FkhxqNsZI6uAPJXFS8cMXlBKo26FJ8ZuW6S9GCMcR9IO5k2X5/9Fg==",
+ "dev": true,
+ "funding": [
+ {
+ "type": "individual",
+ "url": "https://github.com/sponsors/malept"
+ },
+ {
+ "type": "tidelift",
+ "url": "https://tidelift.com/subscription/pkg/npm-.malept-cross-spawn-promise?utm_medium=referral&utm_source=npm_fund"
+ }
+ ],
+ "license": "Apache-2.0",
+ "dependencies": {
+ "cross-spawn": "^7.0.1"
+ },
+ "engines": {
+ "node": ">= 12.13.0"
+ }
+ },
+ "node_modules/@malept/flatpak-bundler": {
+ "version": "0.4.0",
+ "resolved": "https://registry.npmjs.org/@malept/flatpak-bundler/-/flatpak-bundler-0.4.0.tgz",
+ "integrity": "sha512-9QOtNffcOF/c1seMCDnjckb3R9WHcG34tky+FHpNKKCW0wc/scYLwMtO+ptyGUfMW0/b/n4qRiALlaFHc9Oj7Q==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "debug": "^4.1.1",
+ "fs-extra": "^9.0.0",
+ "lodash": "^4.17.15",
+ "tmp-promise": "^3.0.2"
+ },
+ "engines": {
+ "node": ">= 10.0.0"
+ }
+ },
+ "node_modules/@malept/flatpak-bundler/node_modules/fs-extra": {
+ "version": "9.1.0",
+ "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-9.1.0.tgz",
+ "integrity": "sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "at-least-node": "^1.0.0",
+ "graceful-fs": "^4.2.0",
+ "jsonfile": "^6.0.1",
+ "universalify": "^2.0.0"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/@malept/flatpak-bundler/node_modules/jsonfile": {
+ "version": "6.2.0",
+ "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.0.tgz",
+ "integrity": "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "universalify": "^2.0.0"
+ },
+ "optionalDependencies": {
+ "graceful-fs": "^4.1.6"
+ }
+ },
+ "node_modules/@malept/flatpak-bundler/node_modules/universalify": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
+ "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 10.0.0"
+ }
+ },
+ "node_modules/@mui/core-downloads-tracker": {
+ "version": "6.5.0",
+ "resolved": "https://registry.npmjs.org/@mui/core-downloads-tracker/-/core-downloads-tracker-6.5.0.tgz",
+ "integrity": "sha512-LGb8t8i6M2ZtS3Drn3GbTI1DVhDY6FJ9crEey2lZ0aN2EMZo8IZBZj9wRf4vqbZHaWjsYgtbOnJw5V8UWbmK2Q==",
+ "license": "MIT",
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/mui-org"
+ }
+ },
+ "node_modules/@mui/icons-material": {
+ "version": "6.5.0",
+ "resolved": "https://registry.npmjs.org/@mui/icons-material/-/icons-material-6.5.0.tgz",
+ "integrity": "sha512-VPuPqXqbBPlcVSA0BmnoE4knW4/xG6Thazo8vCLWkOKusko6DtwFV6B665MMWJ9j0KFohTIf3yx2zYtYacvG1g==",
+ "license": "MIT",
+ "dependencies": {
+ "@babel/runtime": "^7.26.0"
+ },
+ "engines": {
+ "node": ">=14.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/mui-org"
+ },
+ "peerDependencies": {
+ "@mui/material": "^6.5.0",
+ "@types/react": "^17.0.0 || ^18.0.0 || ^19.0.0",
+ "react": "^17.0.0 || ^18.0.0 || ^19.0.0"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@mui/material": {
+ "version": "6.5.0",
+ "resolved": "https://registry.npmjs.org/@mui/material/-/material-6.5.0.tgz",
+ "integrity": "sha512-yjvtXoFcrPLGtgKRxFaH6OQPtcLPhkloC0BML6rBG5UeldR0nPULR/2E2BfXdo5JNV7j7lOzrrLX2Qf/iSidow==",
+ "license": "MIT",
+ "dependencies": {
+ "@babel/runtime": "^7.26.0",
+ "@mui/core-downloads-tracker": "^6.5.0",
+ "@mui/system": "^6.5.0",
+ "@mui/types": "~7.2.24",
+ "@mui/utils": "^6.4.9",
+ "@popperjs/core": "^2.11.8",
+ "@types/react-transition-group": "^4.4.12",
+ "clsx": "^2.1.1",
+ "csstype": "^3.1.3",
+ "prop-types": "^15.8.1",
+ "react-is": "^19.0.0",
+ "react-transition-group": "^4.4.5"
+ },
+ "engines": {
+ "node": ">=14.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/mui-org"
+ },
+ "peerDependencies": {
+ "@emotion/react": "^11.5.0",
+ "@emotion/styled": "^11.3.0",
+ "@mui/material-pigment-css": "^6.5.0",
+ "@types/react": "^17.0.0 || ^18.0.0 || ^19.0.0",
+ "react": "^17.0.0 || ^18.0.0 || ^19.0.0",
+ "react-dom": "^17.0.0 || ^18.0.0 || ^19.0.0"
+ },
+ "peerDependenciesMeta": {
+ "@emotion/react": {
+ "optional": true
+ },
+ "@emotion/styled": {
+ "optional": true
+ },
+ "@mui/material-pigment-css": {
+ "optional": true
+ },
+ "@types/react": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@mui/material/node_modules/@mui/private-theming": {
+ "version": "6.4.9",
+ "resolved": "https://registry.npmjs.org/@mui/private-theming/-/private-theming-6.4.9.tgz",
+ "integrity": "sha512-LktcVmI5X17/Q5SkwjCcdOLBzt1hXuc14jYa7NPShog0GBDCDvKtcnP0V7a2s6EiVRlv7BzbWEJzH6+l/zaCxw==",
+ "license": "MIT",
+ "dependencies": {
+ "@babel/runtime": "^7.26.0",
+ "@mui/utils": "^6.4.9",
+ "prop-types": "^15.8.1"
+ },
+ "engines": {
+ "node": ">=14.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/mui-org"
+ },
+ "peerDependencies": {
+ "@types/react": "^17.0.0 || ^18.0.0 || ^19.0.0",
+ "react": "^17.0.0 || ^18.0.0 || ^19.0.0"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@mui/material/node_modules/@mui/styled-engine": {
+ "version": "6.5.0",
+ "resolved": "https://registry.npmjs.org/@mui/styled-engine/-/styled-engine-6.5.0.tgz",
+ "integrity": "sha512-8woC2zAqF4qUDSPIBZ8v3sakj+WgweolpyM/FXf8jAx6FMls+IE4Y8VDZc+zS805J7PRz31vz73n2SovKGaYgw==",
+ "license": "MIT",
+ "dependencies": {
+ "@babel/runtime": "^7.26.0",
+ "@emotion/cache": "^11.13.5",
+ "@emotion/serialize": "^1.3.3",
+ "@emotion/sheet": "^1.4.0",
+ "csstype": "^3.1.3",
+ "prop-types": "^15.8.1"
+ },
+ "engines": {
+ "node": ">=14.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/mui-org"
+ },
+ "peerDependencies": {
+ "@emotion/react": "^11.4.1",
+ "@emotion/styled": "^11.3.0",
+ "react": "^17.0.0 || ^18.0.0 || ^19.0.0"
+ },
+ "peerDependenciesMeta": {
+ "@emotion/react": {
+ "optional": true
+ },
+ "@emotion/styled": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@mui/material/node_modules/@mui/system": {
+ "version": "6.5.0",
+ "resolved": "https://registry.npmjs.org/@mui/system/-/system-6.5.0.tgz",
+ "integrity": "sha512-XcbBYxDS+h/lgsoGe78ExXFZXtuIlSBpn/KsZq8PtZcIkUNJInkuDqcLd2rVBQrDC1u+rvVovdaWPf2FHKJf3w==",
+ "license": "MIT",
+ "dependencies": {
+ "@babel/runtime": "^7.26.0",
+ "@mui/private-theming": "^6.4.9",
+ "@mui/styled-engine": "^6.5.0",
+ "@mui/types": "~7.2.24",
+ "@mui/utils": "^6.4.9",
+ "clsx": "^2.1.1",
+ "csstype": "^3.1.3",
+ "prop-types": "^15.8.1"
+ },
+ "engines": {
+ "node": ">=14.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/mui-org"
+ },
+ "peerDependencies": {
+ "@emotion/react": "^11.5.0",
+ "@emotion/styled": "^11.3.0",
+ "@types/react": "^17.0.0 || ^18.0.0 || ^19.0.0",
+ "react": "^17.0.0 || ^18.0.0 || ^19.0.0"
+ },
+ "peerDependenciesMeta": {
+ "@emotion/react": {
+ "optional": true
+ },
+ "@emotion/styled": {
+ "optional": true
+ },
+ "@types/react": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@mui/private-theming": {
+ "version": "7.3.9",
+ "resolved": "https://registry.npmjs.org/@mui/private-theming/-/private-theming-7.3.9.tgz",
+ "integrity": "sha512-ErIyRQvsiQEq7Yvcvfw9UDHngaqjMy9P3JDPnRAaKG5qhpl2C4tX/W1S4zJvpu+feihmZJStjIyvnv6KDbIrlw==",
+ "license": "MIT",
+ "peer": true,
+ "dependencies": {
+ "@babel/runtime": "^7.28.6",
+ "@mui/utils": "^7.3.9",
+ "prop-types": "^15.8.1"
+ },
+ "engines": {
+ "node": ">=14.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/mui-org"
+ },
+ "peerDependencies": {
+ "@types/react": "^17.0.0 || ^18.0.0 || ^19.0.0",
+ "react": "^17.0.0 || ^18.0.0 || ^19.0.0"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@mui/private-theming/node_modules/@mui/types": {
+ "version": "7.4.12",
+ "resolved": "https://registry.npmjs.org/@mui/types/-/types-7.4.12.tgz",
+ "integrity": "sha512-iKNAF2u9PzSIj40CjvKJWxFXJo122jXVdrmdh0hMYd+FR+NuJMkr/L88XwWLCRiJ5P1j+uyac25+Kp6YC4hu6w==",
+ "license": "MIT",
+ "peer": true,
+ "dependencies": {
+ "@babel/runtime": "^7.28.6"
+ },
+ "peerDependencies": {
+ "@types/react": "^17.0.0 || ^18.0.0 || ^19.0.0"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@mui/private-theming/node_modules/@mui/utils": {
+ "version": "7.3.9",
+ "resolved": "https://registry.npmjs.org/@mui/utils/-/utils-7.3.9.tgz",
+ "integrity": "sha512-U6SdZaGbfb65fqTsH3V5oJdFj9uYwyLE2WVuNvmbggTSDBb8QHrFsqY8BN3taK9t3yJ8/BPHD/kNvLNyjwM7Yw==",
+ "license": "MIT",
+ "peer": true,
+ "dependencies": {
+ "@babel/runtime": "^7.28.6",
+ "@mui/types": "^7.4.12",
+ "@types/prop-types": "^15.7.15",
+ "clsx": "^2.1.1",
+ "prop-types": "^15.8.1",
+ "react-is": "^19.2.3"
+ },
+ "engines": {
+ "node": ">=14.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/mui-org"
+ },
+ "peerDependencies": {
+ "@types/react": "^17.0.0 || ^18.0.0 || ^19.0.0",
+ "react": "^17.0.0 || ^18.0.0 || ^19.0.0"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@mui/styled-engine": {
+ "version": "7.3.9",
+ "resolved": "https://registry.npmjs.org/@mui/styled-engine/-/styled-engine-7.3.9.tgz",
+ "integrity": "sha512-JqujWt5bX4okjUPGpVof/7pvgClqh7HvIbsIBIOOlCh2u3wG/Bwp4+E1bc1dXSwkrkp9WUAoNdI5HEC+5HKvMw==",
+ "license": "MIT",
+ "peer": true,
+ "dependencies": {
+ "@babel/runtime": "^7.28.6",
+ "@emotion/cache": "^11.14.0",
+ "@emotion/serialize": "^1.3.3",
+ "@emotion/sheet": "^1.4.0",
+ "csstype": "^3.2.3",
+ "prop-types": "^15.8.1"
+ },
+ "engines": {
+ "node": ">=14.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/mui-org"
+ },
+ "peerDependencies": {
+ "@emotion/react": "^11.4.1",
+ "@emotion/styled": "^11.3.0",
+ "react": "^17.0.0 || ^18.0.0 || ^19.0.0"
+ },
+ "peerDependenciesMeta": {
+ "@emotion/react": {
+ "optional": true
+ },
+ "@emotion/styled": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@mui/system": {
+ "version": "7.3.9",
+ "resolved": "https://registry.npmjs.org/@mui/system/-/system-7.3.9.tgz",
+ "integrity": "sha512-aL1q9am8XpRrSabv9qWf5RHhJICJql34wnrc1nz0MuOglPRYF/liN+c8VqZdTvUn9qg+ZjRVbKf4sJVFfIDtmg==",
+ "license": "MIT",
+ "peer": true,
+ "dependencies": {
+ "@babel/runtime": "^7.28.6",
+ "@mui/private-theming": "^7.3.9",
+ "@mui/styled-engine": "^7.3.9",
+ "@mui/types": "^7.4.12",
+ "@mui/utils": "^7.3.9",
+ "clsx": "^2.1.1",
+ "csstype": "^3.2.3",
+ "prop-types": "^15.8.1"
+ },
+ "engines": {
+ "node": ">=14.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/mui-org"
+ },
+ "peerDependencies": {
+ "@emotion/react": "^11.5.0",
+ "@emotion/styled": "^11.3.0",
+ "@types/react": "^17.0.0 || ^18.0.0 || ^19.0.0",
+ "react": "^17.0.0 || ^18.0.0 || ^19.0.0"
+ },
+ "peerDependenciesMeta": {
+ "@emotion/react": {
+ "optional": true
+ },
+ "@emotion/styled": {
+ "optional": true
+ },
+ "@types/react": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@mui/system/node_modules/@mui/types": {
+ "version": "7.4.12",
+ "resolved": "https://registry.npmjs.org/@mui/types/-/types-7.4.12.tgz",
+ "integrity": "sha512-iKNAF2u9PzSIj40CjvKJWxFXJo122jXVdrmdh0hMYd+FR+NuJMkr/L88XwWLCRiJ5P1j+uyac25+Kp6YC4hu6w==",
+ "license": "MIT",
+ "peer": true,
+ "dependencies": {
+ "@babel/runtime": "^7.28.6"
+ },
+ "peerDependencies": {
+ "@types/react": "^17.0.0 || ^18.0.0 || ^19.0.0"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@mui/system/node_modules/@mui/utils": {
+ "version": "7.3.9",
+ "resolved": "https://registry.npmjs.org/@mui/utils/-/utils-7.3.9.tgz",
+ "integrity": "sha512-U6SdZaGbfb65fqTsH3V5oJdFj9uYwyLE2WVuNvmbggTSDBb8QHrFsqY8BN3taK9t3yJ8/BPHD/kNvLNyjwM7Yw==",
+ "license": "MIT",
+ "peer": true,
+ "dependencies": {
+ "@babel/runtime": "^7.28.6",
+ "@mui/types": "^7.4.12",
+ "@types/prop-types": "^15.7.15",
+ "clsx": "^2.1.1",
+ "prop-types": "^15.8.1",
+ "react-is": "^19.2.3"
+ },
+ "engines": {
+ "node": ">=14.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/mui-org"
+ },
+ "peerDependencies": {
+ "@types/react": "^17.0.0 || ^18.0.0 || ^19.0.0",
+ "react": "^17.0.0 || ^18.0.0 || ^19.0.0"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@mui/types": {
+ "version": "7.2.24",
+ "resolved": "https://registry.npmjs.org/@mui/types/-/types-7.2.24.tgz",
+ "integrity": "sha512-3c8tRt/CbWZ+pEg7QpSwbdxOk36EfmhbKf6AGZsD1EcLDLTSZoxxJ86FVtcjxvjuhdyBiWKSTGZFaXCnidO2kw==",
+ "license": "MIT",
+ "peerDependencies": {
+ "@types/react": "^17.0.0 || ^18.0.0 || ^19.0.0"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@mui/utils": {
+ "version": "6.4.9",
+ "resolved": "https://registry.npmjs.org/@mui/utils/-/utils-6.4.9.tgz",
+ "integrity": "sha512-Y12Q9hbK9g+ZY0T3Rxrx9m2m10gaphDuUMgWxyV5kNJevVxXYCLclYUCC9vXaIk1/NdNDTcW2Yfr2OGvNFNmHg==",
+ "license": "MIT",
+ "dependencies": {
+ "@babel/runtime": "^7.26.0",
+ "@mui/types": "~7.2.24",
+ "@types/prop-types": "^15.7.14",
+ "clsx": "^2.1.1",
+ "prop-types": "^15.8.1",
+ "react-is": "^19.0.0"
+ },
+ "engines": {
+ "node": ">=14.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/mui-org"
+ },
+ "peerDependencies": {
+ "@types/react": "^17.0.0 || ^18.0.0 || ^19.0.0",
+ "react": "^17.0.0 || ^18.0.0 || ^19.0.0"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@mui/x-internals": {
+ "version": "7.29.0",
+ "resolved": "https://registry.npmjs.org/@mui/x-internals/-/x-internals-7.29.0.tgz",
+ "integrity": "sha512-+Gk6VTZIFD70XreWvdXBwKd8GZ2FlSCuecQFzm6znwqXg1ZsndavrhG9tkxpxo2fM1Zf7Tk8+HcOO0hCbhTQFA==",
+ "license": "MIT",
+ "dependencies": {
+ "@babel/runtime": "^7.25.7",
+ "@mui/utils": "^5.16.6 || ^6.0.0 || ^7.0.0"
+ },
+ "engines": {
+ "node": ">=14.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/mui-org"
+ },
+ "peerDependencies": {
+ "react": "^17.0.0 || ^18.0.0 || ^19.0.0"
+ }
+ },
+ "node_modules/@mui/x-tree-view": {
+ "version": "7.29.10",
+ "resolved": "https://registry.npmjs.org/@mui/x-tree-view/-/x-tree-view-7.29.10.tgz",
+ "integrity": "sha512-/ZcM582yIaQN2PmadIlQYRJzc3yXV7bh463J4GHtTmFw+PEjzUfzETBWe3VxmU3EPgIFzVQPjqAAJwylmQSJOg==",
+ "license": "MIT",
+ "dependencies": {
+ "@babel/runtime": "^7.25.7",
+ "@mui/utils": "^5.16.6 || ^6.0.0 || ^7.0.0",
+ "@mui/x-internals": "7.29.0",
+ "@types/react-transition-group": "^4.4.11",
+ "clsx": "^2.1.1",
+ "prop-types": "^15.8.1",
+ "react-transition-group": "^4.4.5"
+ },
+ "engines": {
+ "node": ">=14.0.0"
+ },
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/mui-org"
+ },
+ "peerDependencies": {
+ "@emotion/react": "^11.9.0",
+ "@emotion/styled": "^11.8.1",
+ "@mui/material": "^5.15.14 || ^6.0.0 || ^7.0.0",
+ "@mui/system": "^5.15.14 || ^6.0.0 || ^7.0.0",
+ "react": "^17.0.0 || ^18.0.0 || ^19.0.0",
+ "react-dom": "^17.0.0 || ^18.0.0 || ^19.0.0"
+ },
+ "peerDependenciesMeta": {
+ "@emotion/react": {
+ "optional": true
+ },
+ "@emotion/styled": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@npmcli/agent": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/@npmcli/agent/-/agent-3.0.0.tgz",
+ "integrity": "sha512-S79NdEgDQd/NGCay6TCoVzXSj74skRZIKJcpJjC5lOq34SZzyI6MqtiiWoiVWoVrTcGjNeC4ipbh1VIHlpfF5Q==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "agent-base": "^7.1.0",
+ "http-proxy-agent": "^7.0.0",
+ "https-proxy-agent": "^7.0.1",
+ "lru-cache": "^10.0.1",
+ "socks-proxy-agent": "^8.0.3"
+ },
+ "engines": {
+ "node": "^18.17.0 || >=20.5.0"
+ }
+ },
+ "node_modules/@npmcli/agent/node_modules/lru-cache": {
+ "version": "10.4.3",
+ "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-10.4.3.tgz",
+ "integrity": "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==",
+ "dev": true,
+ "license": "ISC"
+ },
+ "node_modules/@npmcli/fs": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/@npmcli/fs/-/fs-4.0.0.tgz",
+ "integrity": "sha512-/xGlezI6xfGO9NwuJlnwz/K14qD1kCSAGtacBHnGzeAIuJGazcp45KP5NuyARXoKb7cwulAGWVsbeSxdG/cb0Q==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "semver": "^7.3.5"
+ },
+ "engines": {
+ "node": "^18.17.0 || >=20.5.0"
+ }
+ },
+ "node_modules/@npmcli/fs/node_modules/semver": {
+ "version": "7.7.4",
+ "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz",
+ "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==",
+ "dev": true,
+ "license": "ISC",
+ "bin": {
+ "semver": "bin/semver.js"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/@pkgjs/parseargs": {
+ "version": "0.11.0",
+ "resolved": "https://registry.npmjs.org/@pkgjs/parseargs/-/parseargs-0.11.0.tgz",
+ "integrity": "sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "engines": {
+ "node": ">=14"
+ }
+ },
+ "node_modules/@playwright/test": {
+ "version": "1.59.0",
+ "resolved": "https://registry.npmjs.org/@playwright/test/-/test-1.59.0.tgz",
+ "integrity": "sha512-TOA5sTLd49rTDaZpYpvCQ9hGefHQq/OYOyCVnGqS2mjMfX+lGZv2iddIJd0I48cfxqSPttS9S3OuLKyylHcO1w==",
+ "dev": true,
+ "license": "Apache-2.0",
+ "dependencies": {
+ "playwright": "1.59.0"
+ },
+ "bin": {
+ "playwright": "cli.js"
+ },
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/@popperjs/core": {
+ "version": "2.11.8",
+ "resolved": "https://registry.npmjs.org/@popperjs/core/-/core-2.11.8.tgz",
+ "integrity": "sha512-P1st0aksCrn9sGZhp8GMYwBnQsbvAWsZAX44oXNNvLHGqAOcoVxmjZiohstwQ7SqKnbR47akdNi+uleWD8+g6A==",
+ "license": "MIT",
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/popperjs"
+ }
+ },
+ "node_modules/@reduxjs/toolkit": {
+ "version": "2.11.2",
+ "resolved": "https://registry.npmjs.org/@reduxjs/toolkit/-/toolkit-2.11.2.tgz",
+ "integrity": "sha512-Kd6kAHTA6/nUpp8mySPqj3en3dm0tdMIgbttnQ1xFMVpufoj+ADi8pXLBsd4xzTRHQa7t/Jv8W5UnCuW4kuWMQ==",
+ "license": "MIT",
+ "dependencies": {
+ "@standard-schema/spec": "^1.0.0",
+ "@standard-schema/utils": "^0.3.0",
+ "immer": "^11.0.0",
+ "redux": "^5.0.1",
+ "redux-thunk": "^3.1.0",
+ "reselect": "^5.1.0"
+ },
+ "peerDependencies": {
+ "react": "^16.9.0 || ^17.0.0 || ^18 || ^19",
+ "react-redux": "^7.2.1 || ^8.1.3 || ^9.0.0"
+ },
+ "peerDependenciesMeta": {
+ "react": {
+ "optional": true
+ },
+ "react-redux": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/@remix-run/router": {
+ "version": "1.23.2",
+ "resolved": "https://registry.npmjs.org/@remix-run/router/-/router-1.23.2.tgz",
+ "integrity": "sha512-Ic6m2U/rMjTkhERIa/0ZtXJP17QUi2CbWE7cqx4J58M8aA3QTfW+2UlQ4psvTX9IO1RfNVhK3pcpdjej7L+t2w==",
+ "license": "MIT",
+ "engines": {
+ "node": ">=14.0.0"
+ }
+ },
+ "node_modules/@rolldown/pluginutils": {
+ "version": "1.0.0-beta.27",
+ "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-beta.27.tgz",
+ "integrity": "sha512-+d0F4MKMCbeVUJwG96uQ4SgAznZNSq93I3V+9NHA4OpvqG8mRCpGdKmK8l/dl02h2CCDHwW2FqilnTyDcAnqjA==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@rollup/rollup-android-arm-eabi": {
+ "version": "4.60.1",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.60.1.tgz",
+ "integrity": "sha512-d6FinEBLdIiK+1uACUttJKfgZREXrF0Qc2SmLII7W2AD8FfiZ9Wjd+rD/iRuf5s5dWrr1GgwXCvPqOuDquOowA==",
+ "cpu": [
+ "arm"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "android"
+ ]
+ },
+ "node_modules/@rollup/rollup-android-arm64": {
+ "version": "4.60.1",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.60.1.tgz",
+ "integrity": "sha512-YjG/EwIDvvYI1YvYbHvDz/BYHtkY4ygUIXHnTdLhG+hKIQFBiosfWiACWortsKPKU/+dUwQQCKQM3qrDe8c9BA==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "android"
+ ]
+ },
+ "node_modules/@rollup/rollup-darwin-arm64": {
+ "version": "4.60.1",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.60.1.tgz",
+ "integrity": "sha512-mjCpF7GmkRtSJwon+Rq1N8+pI+8l7w5g9Z3vWj4T7abguC4Czwi3Yu/pFaLvA3TTeMVjnu3ctigusqWUfjZzvw==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "darwin"
+ ]
+ },
+ "node_modules/@rollup/rollup-darwin-x64": {
+ "version": "4.60.1",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.60.1.tgz",
+ "integrity": "sha512-haZ7hJ1JT4e9hqkoT9R/19XW2QKqjfJVv+i5AGg57S+nLk9lQnJ1F/eZloRO3o9Scy9CM3wQ9l+dkXtcBgN5Ew==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "darwin"
+ ]
+ },
+ "node_modules/@rollup/rollup-freebsd-arm64": {
+ "version": "4.60.1",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.60.1.tgz",
+ "integrity": "sha512-czw90wpQq3ZsAVBlinZjAYTKduOjTywlG7fEeWKUA7oCmpA8xdTkxZZlwNJKWqILlq0wehoZcJYfBvOyhPTQ6w==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "freebsd"
+ ]
+ },
+ "node_modules/@rollup/rollup-freebsd-x64": {
+ "version": "4.60.1",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.60.1.tgz",
+ "integrity": "sha512-KVB2rqsxTHuBtfOeySEyzEOB7ltlB/ux38iu2rBQzkjbwRVlkhAGIEDiiYnO2kFOkJp+Z7pUXKyrRRFuFUKt+g==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "freebsd"
+ ]
+ },
+ "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
+ "version": "4.60.1",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.60.1.tgz",
+ "integrity": "sha512-L+34Qqil+v5uC0zEubW7uByo78WOCIrBvci69E7sFASRl0X7b/MB6Cqd1lky/CtcSVTydWa2WZwFuWexjS5o6g==",
+ "cpu": [
+ "arm"
+ ],
+ "dev": true,
+ "libc": [
+ "glibc"
+ ],
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ]
+ },
+ "node_modules/@rollup/rollup-linux-arm-musleabihf": {
+ "version": "4.60.1",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.60.1.tgz",
+ "integrity": "sha512-n83O8rt4v34hgFzlkb1ycniJh7IR5RCIqt6mz1VRJD6pmhRi0CXdmfnLu9dIUS6buzh60IvACM842Ffb3xd6Gg==",
+ "cpu": [
+ "arm"
+ ],
+ "dev": true,
+ "libc": [
+ "musl"
+ ],
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ]
+ },
+ "node_modules/@rollup/rollup-linux-arm64-gnu": {
+ "version": "4.60.1",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.60.1.tgz",
+ "integrity": "sha512-Nql7sTeAzhTAja3QXeAI48+/+GjBJ+QmAH13snn0AJSNL50JsDqotyudHyMbO2RbJkskbMbFJfIJKWA6R1LCJQ==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "libc": [
+ "glibc"
+ ],
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ]
+ },
+ "node_modules/@rollup/rollup-linux-arm64-musl": {
+ "version": "4.60.1",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.60.1.tgz",
+ "integrity": "sha512-+pUymDhd0ys9GcKZPPWlFiZ67sTWV5UU6zOJat02M1+PiuSGDziyRuI/pPue3hoUwm2uGfxdL+trT6Z9rxnlMA==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "libc": [
+ "musl"
+ ],
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ]
+ },
+ "node_modules/@rollup/rollup-linux-loong64-gnu": {
+ "version": "4.60.1",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.60.1.tgz",
+ "integrity": "sha512-VSvgvQeIcsEvY4bKDHEDWcpW4Yw7BtlKG1GUT4FzBUlEKQK0rWHYBqQt6Fm2taXS+1bXvJT6kICu5ZwqKCnvlQ==",
+ "cpu": [
+ "loong64"
+ ],
+ "dev": true,
+ "libc": [
+ "glibc"
+ ],
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ]
+ },
+ "node_modules/@rollup/rollup-linux-loong64-musl": {
+ "version": "4.60.1",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.60.1.tgz",
+ "integrity": "sha512-4LqhUomJqwe641gsPp6xLfhqWMbQV04KtPp7/dIp0nzPxAkNY1AbwL5W0MQpcalLYk07vaW9Kp1PBhdpZYYcEw==",
+ "cpu": [
+ "loong64"
+ ],
+ "dev": true,
+ "libc": [
+ "musl"
+ ],
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ]
+ },
+ "node_modules/@rollup/rollup-linux-ppc64-gnu": {
+ "version": "4.60.1",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.60.1.tgz",
+ "integrity": "sha512-tLQQ9aPvkBxOc/EUT6j3pyeMD6Hb8QF2BTBnCQWP/uu1lhc9AIrIjKnLYMEroIz/JvtGYgI9dF3AxHZNaEH0rw==",
+ "cpu": [
+ "ppc64"
+ ],
+ "dev": true,
+ "libc": [
+ "glibc"
+ ],
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ]
+ },
+ "node_modules/@rollup/rollup-linux-ppc64-musl": {
+ "version": "4.60.1",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.60.1.tgz",
+ "integrity": "sha512-RMxFhJwc9fSXP6PqmAz4cbv3kAyvD1etJFjTx4ONqFP9DkTkXsAMU4v3Vyc5BgzC+anz7nS/9tp4obsKfqkDHg==",
+ "cpu": [
+ "ppc64"
+ ],
+ "dev": true,
+ "libc": [
+ "musl"
+ ],
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ]
+ },
+ "node_modules/@rollup/rollup-linux-riscv64-gnu": {
+ "version": "4.60.1",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.60.1.tgz",
+ "integrity": "sha512-QKgFl+Yc1eEk6MmOBfRHYF6lTxiiiV3/z/BRrbSiW2I7AFTXoBFvdMEyglohPj//2mZS4hDOqeB0H1ACh3sBbg==",
+ "cpu": [
+ "riscv64"
+ ],
+ "dev": true,
+ "libc": [
+ "glibc"
+ ],
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ]
+ },
+ "node_modules/@rollup/rollup-linux-riscv64-musl": {
+ "version": "4.60.1",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.60.1.tgz",
+ "integrity": "sha512-RAjXjP/8c6ZtzatZcA1RaQr6O1TRhzC+adn8YZDnChliZHviqIjmvFwHcxi4JKPSDAt6Uhf/7vqcBzQJy0PDJg==",
+ "cpu": [
+ "riscv64"
+ ],
+ "dev": true,
+ "libc": [
+ "musl"
+ ],
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ]
+ },
+ "node_modules/@rollup/rollup-linux-s390x-gnu": {
+ "version": "4.60.1",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.60.1.tgz",
+ "integrity": "sha512-wcuocpaOlaL1COBYiA89O6yfjlp3RwKDeTIA0hM7OpmhR1Bjo9j31G1uQVpDlTvwxGn2nQs65fBFL5UFd76FcQ==",
+ "cpu": [
+ "s390x"
+ ],
+ "dev": true,
+ "libc": [
+ "glibc"
+ ],
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ]
+ },
+ "node_modules/@rollup/rollup-linux-x64-gnu": {
+ "version": "4.60.1",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.60.1.tgz",
+ "integrity": "sha512-77PpsFQUCOiZR9+LQEFg9GClyfkNXj1MP6wRnzYs0EeWbPcHs02AXu4xuUbM1zhwn3wqaizle3AEYg5aeoohhg==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "libc": [
+ "glibc"
+ ],
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ]
+ },
+ "node_modules/@rollup/rollup-linux-x64-musl": {
+ "version": "4.60.1",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.60.1.tgz",
+ "integrity": "sha512-5cIATbk5vynAjqqmyBjlciMJl1+R/CwX9oLk/EyiFXDWd95KpHdrOJT//rnUl4cUcskrd0jCCw3wpZnhIHdD9w==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "libc": [
+ "musl"
+ ],
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "linux"
+ ]
+ },
+ "node_modules/@rollup/rollup-openbsd-x64": {
+ "version": "4.60.1",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.60.1.tgz",
+ "integrity": "sha512-cl0w09WsCi17mcmWqqglez9Gk8isgeWvoUZ3WiJFYSR3zjBQc2J5/ihSjpl+VLjPqjQ/1hJRcqBfLjssREQILw==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "openbsd"
+ ]
+ },
+ "node_modules/@rollup/rollup-openharmony-arm64": {
+ "version": "4.60.1",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.60.1.tgz",
+ "integrity": "sha512-4Cv23ZrONRbNtbZa37mLSueXUCtN7MXccChtKpUnQNgF010rjrjfHx3QxkS2PI7LqGT5xXyYs1a7LbzAwT0iCA==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "openharmony"
+ ]
+ },
+ "node_modules/@rollup/rollup-win32-arm64-msvc": {
+ "version": "4.60.1",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.60.1.tgz",
+ "integrity": "sha512-i1okWYkA4FJICtr7KpYzFpRTHgy5jdDbZiWfvny21iIKky5YExiDXP+zbXzm3dUcFpkEeYNHgQ5fuG236JPq0g==",
+ "cpu": [
+ "arm64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "win32"
+ ]
+ },
+ "node_modules/@rollup/rollup-win32-ia32-msvc": {
+ "version": "4.60.1",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.60.1.tgz",
+ "integrity": "sha512-u09m3CuwLzShA0EYKMNiFgcjjzwqtUMLmuCJLeZWjjOYA3IT2Di09KaxGBTP9xVztWyIWjVdsB2E9goMjZvTQg==",
+ "cpu": [
+ "ia32"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "win32"
+ ]
+ },
+ "node_modules/@rollup/rollup-win32-x64-gnu": {
+ "version": "4.60.1",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.60.1.tgz",
+ "integrity": "sha512-k+600V9Zl1CM7eZxJgMyTUzmrmhB/0XZnF4pRypKAlAgxmedUA+1v9R+XOFv56W4SlHEzfeMtzujLJD22Uz5zg==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "win32"
+ ]
+ },
+ "node_modules/@rollup/rollup-win32-x64-msvc": {
+ "version": "4.60.1",
+ "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.60.1.tgz",
+ "integrity": "sha512-lWMnixq/QzxyhTV6NjQJ4SFo1J6PvOX8vUx5Wb4bBPsEb+8xZ89Bz6kOXpfXj9ak9AHTQVQzlgzBEc1SyM27xQ==",
+ "cpu": [
+ "x64"
+ ],
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "win32"
+ ]
+ },
+ "node_modules/@sindresorhus/is": {
+ "version": "4.6.0",
+ "resolved": "https://registry.npmjs.org/@sindresorhus/is/-/is-4.6.0.tgz",
+ "integrity": "sha512-t09vSN3MdfsyCHoFcTRCH/iUtG7OJ0CsjzB8cjAmKc/va/kIgeDI/TxsigdncE/4be734m0cvIYwNaV4i2XqAw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/sindresorhus/is?sponsor=1"
+ }
+ },
+ "node_modules/@standard-schema/spec": {
+ "version": "1.1.0",
+ "resolved": "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.1.0.tgz",
+ "integrity": "sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==",
+ "license": "MIT"
+ },
+ "node_modules/@standard-schema/utils": {
+ "version": "0.3.0",
+ "resolved": "https://registry.npmjs.org/@standard-schema/utils/-/utils-0.3.0.tgz",
+ "integrity": "sha512-e7Mew686owMaPJVNNLs55PUvgz371nKgwsc4vxE49zsODpJEnxgxRo2y/OKrqueavXgZNMDVj3DdHFlaSAeU8g==",
+ "license": "MIT"
+ },
+ "node_modules/@szmarczak/http-timer": {
+ "version": "4.0.6",
+ "resolved": "https://registry.npmjs.org/@szmarczak/http-timer/-/http-timer-4.0.6.tgz",
+ "integrity": "sha512-4BAffykYOgO+5nzBWYwE3W90sBgLJoUPRWWcL8wlyiM8IB8ipJz3UMJ9KXQd1RKQXpKp8Tutn80HZtWsu2u76w==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "defer-to-connect": "^2.0.0"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/@trpc/client": {
+ "version": "11.16.0",
+ "resolved": "https://registry.npmjs.org/@trpc/client/-/client-11.16.0.tgz",
+ "integrity": "sha512-TxIzm7OoK3baKZ0XCbuMUbI3GhgjcbKHIc4nWVKaRpCRnbSh0T31BT6fTPYwtnA/Nur8pBCGqC2B4J5hEPiPFQ==",
+ "funding": [
+ "https://trpc.io/sponsor"
+ ],
+ "license": "MIT",
+ "bin": {
+ "intent": "bin/intent.js"
+ },
+ "peerDependencies": {
+ "@trpc/server": "11.16.0",
+ "typescript": ">=5.7.2"
+ }
+ },
+ "node_modules/@trpc/server": {
+ "version": "11.16.0",
+ "resolved": "https://registry.npmjs.org/@trpc/server/-/server-11.16.0.tgz",
+ "integrity": "sha512-XgGuUMddrUTd04+za/WE5GFuZ1/YU9XQG0t3VL5WOIu2JspkOlq6k4RYEiqS6HSJt+S0RXaPdIoE2anIP/BBRQ==",
+ "funding": [
+ "https://trpc.io/sponsor"
+ ],
+ "license": "MIT",
+ "bin": {
+ "intent": "bin/intent.js"
+ },
+ "peerDependencies": {
+ "typescript": ">=5.7.2"
+ }
+ },
+ "node_modules/@types/babel__core": {
+ "version": "7.20.5",
+ "resolved": "https://registry.npmjs.org/@types/babel__core/-/babel__core-7.20.5.tgz",
+ "integrity": "sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/parser": "^7.20.7",
+ "@babel/types": "^7.20.7",
+ "@types/babel__generator": "*",
+ "@types/babel__template": "*",
+ "@types/babel__traverse": "*"
+ }
+ },
+ "node_modules/@types/babel__generator": {
+ "version": "7.27.0",
+ "resolved": "https://registry.npmjs.org/@types/babel__generator/-/babel__generator-7.27.0.tgz",
+ "integrity": "sha512-ufFd2Xi92OAVPYsy+P4n7/U7e68fex0+Ee8gSG9KX7eo084CWiQ4sdxktvdl0bOPupXtVJPY19zk6EwWqUQ8lg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/types": "^7.0.0"
+ }
+ },
+ "node_modules/@types/babel__template": {
+ "version": "7.4.4",
+ "resolved": "https://registry.npmjs.org/@types/babel__template/-/babel__template-7.4.4.tgz",
+ "integrity": "sha512-h/NUaSyG5EyxBIp8YRxo4RMe2/qQgvyowRwVMzhYhBCONbW8PUsg4lkFMrhgZhUe5z3L3MiLDuvyJ/CaPa2A8A==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/parser": "^7.1.0",
+ "@babel/types": "^7.0.0"
+ }
+ },
+ "node_modules/@types/babel__traverse": {
+ "version": "7.28.0",
+ "resolved": "https://registry.npmjs.org/@types/babel__traverse/-/babel__traverse-7.28.0.tgz",
+ "integrity": "sha512-8PvcXf70gTDZBgt9ptxJ8elBeBjcLOAcOtoO/mPJjtji1+CdGbHgm77om1GrsPxsiE+uXIpNSK64UYaIwQXd4Q==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/types": "^7.28.2"
+ }
+ },
+ "node_modules/@types/cacheable-request": {
+ "version": "6.0.3",
+ "resolved": "https://registry.npmjs.org/@types/cacheable-request/-/cacheable-request-6.0.3.tgz",
+ "integrity": "sha512-IQ3EbTzGxIigb1I3qPZc1rWJnH0BmSKv5QYTalEwweFvyBDLSAe24zP0le/hyi7ecGfZVlIVAg4BZqb8WBwKqw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@types/http-cache-semantics": "*",
+ "@types/keyv": "^3.1.4",
+ "@types/node": "*",
+ "@types/responselike": "^1.0.0"
+ }
+ },
+ "node_modules/@types/d3": {
+ "version": "7.4.3",
+ "resolved": "https://registry.npmjs.org/@types/d3/-/d3-7.4.3.tgz",
+ "integrity": "sha512-lZXZ9ckh5R8uiFVt8ogUNf+pIrK4EsWrx2Np75WvF/eTpJ0FMHNhjXk8CKEx/+gpHbNQyJWehbFaTvqmHWB3ww==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@types/d3-array": "*",
+ "@types/d3-axis": "*",
+ "@types/d3-brush": "*",
+ "@types/d3-chord": "*",
+ "@types/d3-color": "*",
+ "@types/d3-contour": "*",
+ "@types/d3-delaunay": "*",
+ "@types/d3-dispatch": "*",
+ "@types/d3-drag": "*",
+ "@types/d3-dsv": "*",
+ "@types/d3-ease": "*",
+ "@types/d3-fetch": "*",
+ "@types/d3-force": "*",
+ "@types/d3-format": "*",
+ "@types/d3-geo": "*",
+ "@types/d3-hierarchy": "*",
+ "@types/d3-interpolate": "*",
+ "@types/d3-path": "*",
+ "@types/d3-polygon": "*",
+ "@types/d3-quadtree": "*",
+ "@types/d3-random": "*",
+ "@types/d3-scale": "*",
+ "@types/d3-scale-chromatic": "*",
+ "@types/d3-selection": "*",
+ "@types/d3-shape": "*",
+ "@types/d3-time": "*",
+ "@types/d3-time-format": "*",
+ "@types/d3-timer": "*",
+ "@types/d3-transition": "*",
+ "@types/d3-zoom": "*"
+ }
+ },
+ "node_modules/@types/d3-array": {
+ "version": "3.2.2",
+ "resolved": "https://registry.npmjs.org/@types/d3-array/-/d3-array-3.2.2.tgz",
+ "integrity": "sha512-hOLWVbm7uRza0BYXpIIW5pxfrKe0W+D5lrFiAEYR+pb6w3N2SwSMaJbXdUfSEv+dT4MfHBLtn5js0LAWaO6otw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@types/d3-axis": {
+ "version": "3.0.6",
+ "resolved": "https://registry.npmjs.org/@types/d3-axis/-/d3-axis-3.0.6.tgz",
+ "integrity": "sha512-pYeijfZuBd87T0hGn0FO1vQ/cgLk6E1ALJjfkC0oJ8cbwkZl3TpgS8bVBLZN+2jjGgg38epgxb2zmoGtSfvgMw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@types/d3-selection": "*"
+ }
+ },
+ "node_modules/@types/d3-brush": {
+ "version": "3.0.6",
+ "resolved": "https://registry.npmjs.org/@types/d3-brush/-/d3-brush-3.0.6.tgz",
+ "integrity": "sha512-nH60IZNNxEcrh6L1ZSMNA28rj27ut/2ZmI3r96Zd+1jrZD++zD3LsMIjWlvg4AYrHn/Pqz4CF3veCxGjtbqt7A==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@types/d3-selection": "*"
+ }
+ },
+ "node_modules/@types/d3-chord": {
+ "version": "3.0.6",
+ "resolved": "https://registry.npmjs.org/@types/d3-chord/-/d3-chord-3.0.6.tgz",
+ "integrity": "sha512-LFYWWd8nwfwEmTZG9PfQxd17HbNPksHBiJHaKuY1XeqscXacsS2tyoo6OdRsjf+NQYeB6XrNL3a25E3gH69lcg==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@types/d3-color": {
+ "version": "3.1.3",
+ "resolved": "https://registry.npmjs.org/@types/d3-color/-/d3-color-3.1.3.tgz",
+ "integrity": "sha512-iO90scth9WAbmgv7ogoq57O9YpKmFBbmoEoCHDB2xMBY0+/KVrqAaCDyCE16dUspeOvIxFFRI+0sEtqDqy2b4A==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@types/d3-contour": {
+ "version": "3.0.6",
+ "resolved": "https://registry.npmjs.org/@types/d3-contour/-/d3-contour-3.0.6.tgz",
+ "integrity": "sha512-BjzLgXGnCWjUSYGfH1cpdo41/hgdWETu4YxpezoztawmqsvCeep+8QGfiY6YbDvfgHz/DkjeIkkZVJavB4a3rg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@types/d3-array": "*",
+ "@types/geojson": "*"
+ }
+ },
+ "node_modules/@types/d3-delaunay": {
+ "version": "6.0.4",
+ "resolved": "https://registry.npmjs.org/@types/d3-delaunay/-/d3-delaunay-6.0.4.tgz",
+ "integrity": "sha512-ZMaSKu4THYCU6sV64Lhg6qjf1orxBthaC161plr5KuPHo3CNm8DTHiLw/5Eq2b6TsNP0W0iJrUOFscY6Q450Hw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@types/d3-dispatch": {
+ "version": "3.0.7",
+ "resolved": "https://registry.npmjs.org/@types/d3-dispatch/-/d3-dispatch-3.0.7.tgz",
+ "integrity": "sha512-5o9OIAdKkhN1QItV2oqaE5KMIiXAvDWBDPrD85e58Qlz1c1kI/J0NcqbEG88CoTwJrYe7ntUCVfeUl2UJKbWgA==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@types/d3-drag": {
+ "version": "3.0.7",
+ "resolved": "https://registry.npmjs.org/@types/d3-drag/-/d3-drag-3.0.7.tgz",
+ "integrity": "sha512-HE3jVKlzU9AaMazNufooRJ5ZpWmLIoc90A37WU2JMmeq28w1FQqCZswHZ3xR+SuxYftzHq6WU6KJHvqxKzTxxQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@types/d3-selection": "*"
+ }
+ },
+ "node_modules/@types/d3-dsv": {
+ "version": "3.0.7",
+ "resolved": "https://registry.npmjs.org/@types/d3-dsv/-/d3-dsv-3.0.7.tgz",
+ "integrity": "sha512-n6QBF9/+XASqcKK6waudgL0pf/S5XHPPI8APyMLLUHd8NqouBGLsU8MgtO7NINGtPBtk9Kko/W4ea0oAspwh9g==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@types/d3-ease": {
+ "version": "3.0.2",
+ "resolved": "https://registry.npmjs.org/@types/d3-ease/-/d3-ease-3.0.2.tgz",
+ "integrity": "sha512-NcV1JjO5oDzoK26oMzbILE6HW7uVXOHLQvHshBUW4UMdZGfiY6v5BeQwh9a9tCzv+CeefZQHJt5SRgK154RtiA==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@types/d3-fetch": {
+ "version": "3.0.7",
+ "resolved": "https://registry.npmjs.org/@types/d3-fetch/-/d3-fetch-3.0.7.tgz",
+ "integrity": "sha512-fTAfNmxSb9SOWNB9IoG5c8Hg6R+AzUHDRlsXsDZsNp6sxAEOP0tkP3gKkNSO/qmHPoBFTxNrjDprVHDQDvo5aA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@types/d3-dsv": "*"
+ }
+ },
+ "node_modules/@types/d3-force": {
+ "version": "3.0.10",
+ "resolved": "https://registry.npmjs.org/@types/d3-force/-/d3-force-3.0.10.tgz",
+ "integrity": "sha512-ZYeSaCF3p73RdOKcjj+swRlZfnYpK1EbaDiYICEEp5Q6sUiqFaFQ9qgoshp5CzIyyb/yD09kD9o2zEltCexlgw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@types/d3-format": {
+ "version": "3.0.4",
+ "resolved": "https://registry.npmjs.org/@types/d3-format/-/d3-format-3.0.4.tgz",
+ "integrity": "sha512-fALi2aI6shfg7vM5KiR1wNJnZ7r6UuggVqtDA+xiEdPZQwy/trcQaHnwShLuLdta2rTymCNpxYTiMZX/e09F4g==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@types/d3-geo": {
+ "version": "3.1.0",
+ "resolved": "https://registry.npmjs.org/@types/d3-geo/-/d3-geo-3.1.0.tgz",
+ "integrity": "sha512-856sckF0oP/diXtS4jNsiQw/UuK5fQG8l/a9VVLeSouf1/PPbBE1i1W852zVwKwYCBkFJJB7nCFTbk6UMEXBOQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@types/geojson": "*"
+ }
+ },
+ "node_modules/@types/d3-hierarchy": {
+ "version": "3.1.7",
+ "resolved": "https://registry.npmjs.org/@types/d3-hierarchy/-/d3-hierarchy-3.1.7.tgz",
+ "integrity": "sha512-tJFtNoYBtRtkNysX1Xq4sxtjK8YgoWUNpIiUee0/jHGRwqvzYxkq0hGVbbOGSz+JgFxxRu4K8nb3YpG3CMARtg==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@types/d3-interpolate": {
+ "version": "3.0.4",
+ "resolved": "https://registry.npmjs.org/@types/d3-interpolate/-/d3-interpolate-3.0.4.tgz",
+ "integrity": "sha512-mgLPETlrpVV1YRJIglr4Ez47g7Yxjl1lj7YKsiMCb27VJH9W8NVM6Bb9d8kkpG/uAQS5AmbA48q2IAolKKo1MA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@types/d3-color": "*"
+ }
+ },
+ "node_modules/@types/d3-path": {
+ "version": "3.1.1",
+ "resolved": "https://registry.npmjs.org/@types/d3-path/-/d3-path-3.1.1.tgz",
+ "integrity": "sha512-VMZBYyQvbGmWyWVea0EHs/BwLgxc+MKi1zLDCONksozI4YJMcTt8ZEuIR4Sb1MMTE8MMW49v0IwI5+b7RmfWlg==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@types/d3-polygon": {
+ "version": "3.0.2",
+ "resolved": "https://registry.npmjs.org/@types/d3-polygon/-/d3-polygon-3.0.2.tgz",
+ "integrity": "sha512-ZuWOtMaHCkN9xoeEMr1ubW2nGWsp4nIql+OPQRstu4ypeZ+zk3YKqQT0CXVe/PYqrKpZAi+J9mTs05TKwjXSRA==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@types/d3-quadtree": {
+ "version": "3.0.6",
+ "resolved": "https://registry.npmjs.org/@types/d3-quadtree/-/d3-quadtree-3.0.6.tgz",
+ "integrity": "sha512-oUzyO1/Zm6rsxKRHA1vH0NEDG58HrT5icx/azi9MF1TWdtttWl0UIUsjEQBBh+SIkrpd21ZjEv7ptxWys1ncsg==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@types/d3-random": {
+ "version": "3.0.3",
+ "resolved": "https://registry.npmjs.org/@types/d3-random/-/d3-random-3.0.3.tgz",
+ "integrity": "sha512-Imagg1vJ3y76Y2ea0871wpabqp613+8/r0mCLEBfdtqC7xMSfj9idOnmBYyMoULfHePJyxMAw3nWhJxzc+LFwQ==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@types/d3-scale": {
+ "version": "4.0.9",
+ "resolved": "https://registry.npmjs.org/@types/d3-scale/-/d3-scale-4.0.9.tgz",
+ "integrity": "sha512-dLmtwB8zkAeO/juAMfnV+sItKjlsw2lKdZVVy6LRr0cBmegxSABiLEpGVmSJJ8O08i4+sGR6qQtb6WtuwJdvVw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@types/d3-time": "*"
+ }
+ },
+ "node_modules/@types/d3-scale-chromatic": {
+ "version": "3.1.0",
+ "resolved": "https://registry.npmjs.org/@types/d3-scale-chromatic/-/d3-scale-chromatic-3.1.0.tgz",
+ "integrity": "sha512-iWMJgwkK7yTRmWqRB5plb1kadXyQ5Sj8V/zYlFGMUBbIPKQScw+Dku9cAAMgJG+z5GYDoMjWGLVOvjghDEFnKQ==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@types/d3-selection": {
+ "version": "3.0.11",
+ "resolved": "https://registry.npmjs.org/@types/d3-selection/-/d3-selection-3.0.11.tgz",
+ "integrity": "sha512-bhAXu23DJWsrI45xafYpkQ4NtcKMwWnAC/vKrd2l+nxMFuvOT3XMYTIj2opv8vq8AO5Yh7Qac/nSeP/3zjTK0w==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@types/d3-shape": {
+ "version": "3.1.8",
+ "resolved": "https://registry.npmjs.org/@types/d3-shape/-/d3-shape-3.1.8.tgz",
+ "integrity": "sha512-lae0iWfcDeR7qt7rA88BNiqdvPS5pFVPpo5OfjElwNaT2yyekbM0C9vK+yqBqEmHr6lDkRnYNoTBYlAgJa7a4w==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@types/d3-path": "*"
+ }
+ },
+ "node_modules/@types/d3-time": {
+ "version": "3.0.4",
+ "resolved": "https://registry.npmjs.org/@types/d3-time/-/d3-time-3.0.4.tgz",
+ "integrity": "sha512-yuzZug1nkAAaBlBBikKZTgzCeA+k1uy4ZFwWANOfKw5z5LRhV0gNA7gNkKm7HoK+HRN0wX3EkxGk0fpbWhmB7g==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@types/d3-time-format": {
+ "version": "4.0.3",
+ "resolved": "https://registry.npmjs.org/@types/d3-time-format/-/d3-time-format-4.0.3.tgz",
+ "integrity": "sha512-5xg9rC+wWL8kdDj153qZcsJ0FWiFt0J5RB6LYUNZjwSnesfblqrI/bJ1wBdJ8OQfncgbJG5+2F+qfqnqyzYxyg==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@types/d3-timer": {
+ "version": "3.0.2",
+ "resolved": "https://registry.npmjs.org/@types/d3-timer/-/d3-timer-3.0.2.tgz",
+ "integrity": "sha512-Ps3T8E8dZDam6fUyNiMkekK3XUsaUEik+idO9/YjPtfj2qruF8tFBXS7XhtE4iIXBLxhmLjP3SXpLhVf21I9Lw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@types/d3-transition": {
+ "version": "3.0.9",
+ "resolved": "https://registry.npmjs.org/@types/d3-transition/-/d3-transition-3.0.9.tgz",
+ "integrity": "sha512-uZS5shfxzO3rGlu0cC3bjmMFKsXv+SmZZcgp0KD22ts4uGXp5EVYGzu/0YdwZeKmddhcAccYtREJKkPfXkZuCg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@types/d3-selection": "*"
+ }
+ },
+ "node_modules/@types/d3-zoom": {
+ "version": "3.0.8",
+ "resolved": "https://registry.npmjs.org/@types/d3-zoom/-/d3-zoom-3.0.8.tgz",
+ "integrity": "sha512-iqMC4/YlFCSlO8+2Ii1GGGliCAY4XdeG748w5vQUbevlbDu0zSjH/+jojorQVBK/se0j6DUFNPBGSqD3YWYnDw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@types/d3-interpolate": "*",
+ "@types/d3-selection": "*"
+ }
+ },
+ "node_modules/@types/debug": {
+ "version": "4.1.13",
+ "resolved": "https://registry.npmjs.org/@types/debug/-/debug-4.1.13.tgz",
+ "integrity": "sha512-KSVgmQmzMwPlmtljOomayoR89W4FynCAi3E8PPs7vmDVPe84hT+vGPKkJfThkmXs0x0jAaa9U8uW8bbfyS2fWw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@types/ms": "*"
+ }
+ },
+ "node_modules/@types/estree": {
+ "version": "1.0.8",
+ "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz",
+ "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@types/fs-extra": {
+ "version": "9.0.13",
+ "resolved": "https://registry.npmjs.org/@types/fs-extra/-/fs-extra-9.0.13.tgz",
+ "integrity": "sha512-nEnwB++1u5lVDM2UI4c1+5R+FYaKfaAzS4OococimjVm3nQw3TuzH5UNsocrcTBbhnerblyHj4A49qXbIiZdpA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@types/node": "*"
+ }
+ },
+ "node_modules/@types/geojson": {
+ "version": "7946.0.16",
+ "resolved": "https://registry.npmjs.org/@types/geojson/-/geojson-7946.0.16.tgz",
+ "integrity": "sha512-6C8nqWur3j98U6+lXDfTUWIfgvZU+EumvpHKcYjujKH7woYyLj2sUmff0tRhrqM7BohUw7Pz3ZB1jj2gW9Fvmg==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@types/http-cache-semantics": {
+ "version": "4.2.0",
+ "resolved": "https://registry.npmjs.org/@types/http-cache-semantics/-/http-cache-semantics-4.2.0.tgz",
+ "integrity": "sha512-L3LgimLHXtGkWikKnsPg0/VFx9OGZaC+eN1u4r+OB1XRqH3meBIAVC2zr1WdMH+RHmnRkqliQAOHNJ/E0j/e0Q==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@types/keyv": {
+ "version": "3.1.4",
+ "resolved": "https://registry.npmjs.org/@types/keyv/-/keyv-3.1.4.tgz",
+ "integrity": "sha512-BQ5aZNSCpj7D6K2ksrRCTmKRLEpnPvWDiLPfoGyhZ++8YtiK9d/3DBKPJgry359X/P1PfruyYwvnvwFjuEiEIg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@types/node": "*"
+ }
+ },
+ "node_modules/@types/ms": {
+ "version": "2.1.0",
+ "resolved": "https://registry.npmjs.org/@types/ms/-/ms-2.1.0.tgz",
+ "integrity": "sha512-GsCCIZDE/p3i96vtEqx+7dBUGXrc7zeSK3wwPHIaRThS+9OhWIXRqzs4d6k1SVU8g91DrNRWxWUGhp5KXQb2VA==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/@types/node": {
+ "version": "22.19.15",
+ "resolved": "https://registry.npmjs.org/@types/node/-/node-22.19.15.tgz",
+ "integrity": "sha512-F0R/h2+dsy5wJAUe3tAU6oqa2qbWY5TpNfL/RGmo1y38hiyO1w3x2jPtt76wmuaJI4DQnOBu21cNXQ2STIUUWg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "undici-types": "~6.21.0"
+ }
+ },
+ "node_modules/@types/parse-json": {
+ "version": "4.0.2",
+ "resolved": "https://registry.npmjs.org/@types/parse-json/-/parse-json-4.0.2.tgz",
+ "integrity": "sha512-dISoDXWWQwUquiKsyZ4Ng+HX2KsPL7LyHKHQwgGFEA3IaKac4Obd+h2a/a6waisAoepJlBcx9paWqjA8/HVjCw==",
+ "license": "MIT"
+ },
+ "node_modules/@types/plist": {
+ "version": "3.0.5",
+ "resolved": "https://registry.npmjs.org/@types/plist/-/plist-3.0.5.tgz",
+ "integrity": "sha512-E6OCaRmAe4WDmWNsL/9RMqdkkzDCY1etutkflWk4c+AcjDU07Pcz1fQwTX0TQz+Pxqn9i4L1TU3UFpjnrcDgxA==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "dependencies": {
+ "@types/node": "*",
+ "xmlbuilder": ">=11.0.1"
+ }
+ },
+ "node_modules/@types/prop-types": {
+ "version": "15.7.15",
+ "resolved": "https://registry.npmjs.org/@types/prop-types/-/prop-types-15.7.15.tgz",
+ "integrity": "sha512-F6bEyamV9jKGAFBEmlQnesRPGOQqS2+Uwi0Em15xenOxHaf2hv6L8YCVn3rPdPJOiJfPiCnLIRyvwVaqMY3MIw==",
+ "license": "MIT"
+ },
+ "node_modules/@types/react": {
+ "version": "19.2.14",
+ "resolved": "https://registry.npmjs.org/@types/react/-/react-19.2.14.tgz",
+ "integrity": "sha512-ilcTH/UniCkMdtexkoCN0bI7pMcJDvmQFPvuPvmEaYA/NSfFTAgdUSLAoVjaRJm7+6PvcM+q1zYOwS4wTYMF9w==",
+ "license": "MIT",
+ "dependencies": {
+ "csstype": "^3.2.2"
+ }
+ },
+ "node_modules/@types/react-dom": {
+ "version": "19.2.3",
+ "resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-19.2.3.tgz",
+ "integrity": "sha512-jp2L/eY6fn+KgVVQAOqYItbF0VY/YApe5Mz2F0aykSO8gx31bYCZyvSeYxCHKvzHG5eZjc+zyaS5BrBWya2+kQ==",
+ "dev": true,
+ "license": "MIT",
+ "peerDependencies": {
+ "@types/react": "^19.2.0"
+ }
+ },
+ "node_modules/@types/react-transition-group": {
+ "version": "4.4.12",
+ "resolved": "https://registry.npmjs.org/@types/react-transition-group/-/react-transition-group-4.4.12.tgz",
+ "integrity": "sha512-8TV6R3h2j7a91c+1DXdJi3Syo69zzIZbz7Lg5tORM5LEJG7X/E6a1V3drRyBRZq7/utz7A+c4OgYLiLcYGHG6w==",
+ "license": "MIT",
+ "peerDependencies": {
+ "@types/react": "*"
+ }
+ },
+ "node_modules/@types/responselike": {
+ "version": "1.0.3",
+ "resolved": "https://registry.npmjs.org/@types/responselike/-/responselike-1.0.3.tgz",
+ "integrity": "sha512-H/+L+UkTV33uf49PH5pCAUBVPNj2nDBXTN+qS1dOwyyg24l3CcicicCA7ca+HMvJBZcFgl5r8e+RR6elsb4Lyw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@types/node": "*"
+ }
+ },
+ "node_modules/@types/use-sync-external-store": {
+ "version": "0.0.6",
+ "resolved": "https://registry.npmjs.org/@types/use-sync-external-store/-/use-sync-external-store-0.0.6.tgz",
+ "integrity": "sha512-zFDAD+tlpf2r4asuHEj0XH6pY6i0g5NeAHPn+15wk3BV6JA69eERFXC1gyGThDkVa1zCyKr5jox1+2LbV/AMLg==",
+ "license": "MIT"
+ },
+ "node_modules/@types/verror": {
+ "version": "1.10.11",
+ "resolved": "https://registry.npmjs.org/@types/verror/-/verror-1.10.11.tgz",
+ "integrity": "sha512-RlDm9K7+o5stv0Co8i8ZRGxDbrTxhJtgjqjFyVh/tXQyl/rYtTKlnTvZ88oSTeYREWurwx20Js4kTuKCsFkUtg==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true
+ },
+ "node_modules/@types/yauzl": {
+ "version": "2.10.3",
+ "resolved": "https://registry.npmjs.org/@types/yauzl/-/yauzl-2.10.3.tgz",
+ "integrity": "sha512-oJoftv0LSuaDZE3Le4DbKX+KS9G36NzOeSap90UIK0yMA/NhKJhqlSGtNDORNRaIbQfzjXDrQa0ytJ6mNRGz/Q==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "dependencies": {
+ "@types/node": "*"
+ }
+ },
+ "node_modules/@vitejs/plugin-react": {
+ "version": "4.7.0",
+ "resolved": "https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-4.7.0.tgz",
+ "integrity": "sha512-gUu9hwfWvvEDBBmgtAowQCojwZmJ5mcLn3aufeCsitijs3+f2NsrPtlAWIR6OPiqljl96GVCUbLe0HyqIpVaoA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@babel/core": "^7.28.0",
+ "@babel/plugin-transform-react-jsx-self": "^7.27.1",
+ "@babel/plugin-transform-react-jsx-source": "^7.27.1",
+ "@rolldown/pluginutils": "1.0.0-beta.27",
+ "@types/babel__core": "^7.20.5",
+ "react-refresh": "^0.17.0"
+ },
+ "engines": {
+ "node": "^14.18.0 || >=16.0.0"
+ },
+ "peerDependencies": {
+ "vite": "^4.2.0 || ^5.0.0 || ^6.0.0 || ^7.0.0"
+ }
+ },
+ "node_modules/@xmldom/xmldom": {
+ "version": "0.8.12",
+ "resolved": "https://registry.npmjs.org/@xmldom/xmldom/-/xmldom-0.8.12.tgz",
+ "integrity": "sha512-9k/gHF6n/pAi/9tqr3m3aqkuiNosYTurLLUtc7xQ9sxB/wm7WPygCv8GYa6mS0fLJEHhqMC1ATYhz++U/lRHqg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=10.0.0"
+ }
+ },
+ "node_modules/7zip-bin": {
+ "version": "5.2.0",
+ "resolved": "https://registry.npmjs.org/7zip-bin/-/7zip-bin-5.2.0.tgz",
+ "integrity": "sha512-ukTPVhqG4jNzMro2qA9HSCSSVJN3aN7tlb+hfqYCt3ER0yWroeA2VR38MNrOHLQ/cVj+DaIMad0kFCtWWowh/A==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/abbrev": {
+ "version": "3.0.1",
+ "resolved": "https://registry.npmjs.org/abbrev/-/abbrev-3.0.1.tgz",
+ "integrity": "sha512-AO2ac6pjRB3SJmGJo+v5/aK6Omggp6fsLrs6wN9bd35ulu4cCwaAU9+7ZhXjeqHVkaHThLuzH0nZr0YpCDhygg==",
+ "dev": true,
+ "license": "ISC",
+ "engines": {
+ "node": "^18.17.0 || >=20.5.0"
+ }
+ },
+ "node_modules/agent-base": {
+ "version": "7.1.4",
+ "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.4.tgz",
+ "integrity": "sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 14"
+ }
+ },
+ "node_modules/ajv": {
+ "version": "6.14.0",
+ "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.14.0.tgz",
+ "integrity": "sha512-IWrosm/yrn43eiKqkfkHis7QioDleaXQHdDVPKg0FSwwd/DuvyX79TZnFOnYpB7dcsFAMmtFztZuXPDvSePkFw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "fast-deep-equal": "^3.1.1",
+ "fast-json-stable-stringify": "^2.0.0",
+ "json-schema-traverse": "^0.4.1",
+ "uri-js": "^4.2.2"
+ },
+ "funding": {
+ "type": "github",
+ "url": "https://github.com/sponsors/epoberezkin"
+ }
+ },
+ "node_modules/ajv-keywords": {
+ "version": "3.5.2",
+ "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-3.5.2.tgz",
+ "integrity": "sha512-5p6WTN0DdTGVQk6VjcEju19IgaHudalcfabD7yhDGeA6bcQnmL+CpveLJq/3hvfwd1aof6L386Ougkx6RfyMIQ==",
+ "dev": true,
+ "license": "MIT",
+ "peerDependencies": {
+ "ajv": "^6.9.1"
+ }
+ },
+ "node_modules/ansi-regex": {
+ "version": "5.0.1",
+ "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+ "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/ansi-styles": {
+ "version": "4.3.0",
+ "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+ "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "color-convert": "^2.0.1"
+ },
+ "engines": {
+ "node": ">=8"
+ },
+ "funding": {
+ "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+ }
+ },
+ "node_modules/app-builder-bin": {
+ "version": "5.0.0-alpha.12",
+ "resolved": "https://registry.npmjs.org/app-builder-bin/-/app-builder-bin-5.0.0-alpha.12.tgz",
+ "integrity": "sha512-j87o0j6LqPL3QRr8yid6c+Tt5gC7xNfYo6uQIQkorAC6MpeayVMZrEDzKmJJ/Hlv7EnOQpaRm53k6ktDYZyB6w==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/app-builder-lib": {
+ "version": "26.8.1",
+ "resolved": "https://registry.npmjs.org/app-builder-lib/-/app-builder-lib-26.8.1.tgz",
+ "integrity": "sha512-p0Im/Dx5C4tmz8QEE1Yn4MkuPC8PrnlRneMhWJj7BBXQfNTJUshM/bp3lusdEsDbvvfJZpXWnYesgSLvwtM2Zw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@develar/schema-utils": "~2.6.5",
+ "@electron/asar": "3.4.1",
+ "@electron/fuses": "^1.8.0",
+ "@electron/get": "^3.0.0",
+ "@electron/notarize": "2.5.0",
+ "@electron/osx-sign": "1.3.3",
+ "@electron/rebuild": "^4.0.3",
+ "@electron/universal": "2.0.3",
+ "@malept/flatpak-bundler": "^0.4.0",
+ "@types/fs-extra": "9.0.13",
+ "async-exit-hook": "^2.0.1",
+ "builder-util": "26.8.1",
+ "builder-util-runtime": "9.5.1",
+ "chromium-pickle-js": "^0.2.0",
+ "ci-info": "4.3.1",
+ "debug": "^4.3.4",
+ "dotenv": "^16.4.5",
+ "dotenv-expand": "^11.0.6",
+ "ejs": "^3.1.8",
+ "electron-publish": "26.8.1",
+ "fs-extra": "^10.1.0",
+ "hosted-git-info": "^4.1.0",
+ "isbinaryfile": "^5.0.0",
+ "jiti": "^2.4.2",
+ "js-yaml": "^4.1.0",
+ "json5": "^2.2.3",
+ "lazy-val": "^1.0.5",
+ "minimatch": "^10.0.3",
+ "plist": "3.1.0",
+ "proper-lockfile": "^4.1.2",
+ "resedit": "^1.7.0",
+ "semver": "~7.7.3",
+ "tar": "^7.5.7",
+ "temp-file": "^3.4.0",
+ "tiny-async-pool": "1.3.0",
+ "which": "^5.0.0"
+ },
+ "engines": {
+ "node": ">=14.0.0"
+ },
+ "peerDependencies": {
+ "dmg-builder": "26.8.1",
+ "electron-builder-squirrel-windows": "26.8.1"
+ }
+ },
+ "node_modules/app-builder-lib/node_modules/@electron/get": {
+ "version": "3.1.0",
+ "resolved": "https://registry.npmjs.org/@electron/get/-/get-3.1.0.tgz",
+ "integrity": "sha512-F+nKc0xW+kVbBRhFzaMgPy3KwmuNTYX1fx6+FxxoSnNgwYX6LD7AKBTWkU0MQ6IBoe7dz069CNkR673sPAgkCQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "debug": "^4.1.1",
+ "env-paths": "^2.2.0",
+ "fs-extra": "^8.1.0",
+ "got": "^11.8.5",
+ "progress": "^2.0.3",
+ "semver": "^6.2.0",
+ "sumchecker": "^3.0.1"
+ },
+ "engines": {
+ "node": ">=14"
+ },
+ "optionalDependencies": {
+ "global-agent": "^3.0.0"
+ }
+ },
+ "node_modules/app-builder-lib/node_modules/@electron/get/node_modules/fs-extra": {
+ "version": "8.1.0",
+ "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-8.1.0.tgz",
+ "integrity": "sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "graceful-fs": "^4.2.0",
+ "jsonfile": "^4.0.0",
+ "universalify": "^0.1.0"
+ },
+ "engines": {
+ "node": ">=6 <7 || >=8"
+ }
+ },
+ "node_modules/app-builder-lib/node_modules/@electron/get/node_modules/semver": {
+ "version": "6.3.1",
+ "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
+ "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
+ "dev": true,
+ "license": "ISC",
+ "bin": {
+ "semver": "bin/semver.js"
+ }
+ },
+ "node_modules/app-builder-lib/node_modules/ci-info": {
+ "version": "4.3.1",
+ "resolved": "https://registry.npmjs.org/ci-info/-/ci-info-4.3.1.tgz",
+ "integrity": "sha512-Wdy2Igu8OcBpI2pZePZ5oWjPC38tmDVx5WKUXKwlLYkA0ozo85sLsLvkBbBn/sZaSCMFOGZJ14fvW9t5/d7kdA==",
+ "dev": true,
+ "funding": [
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/sibiraj-s"
+ }
+ ],
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/app-builder-lib/node_modules/fs-extra": {
+ "version": "10.1.0",
+ "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-10.1.0.tgz",
+ "integrity": "sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "graceful-fs": "^4.2.0",
+ "jsonfile": "^6.0.1",
+ "universalify": "^2.0.0"
+ },
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/app-builder-lib/node_modules/fs-extra/node_modules/jsonfile": {
+ "version": "6.2.0",
+ "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.0.tgz",
+ "integrity": "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "universalify": "^2.0.0"
+ },
+ "optionalDependencies": {
+ "graceful-fs": "^4.1.6"
+ }
+ },
+ "node_modules/app-builder-lib/node_modules/fs-extra/node_modules/universalify": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
+ "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 10.0.0"
+ }
+ },
+ "node_modules/app-builder-lib/node_modules/isexe": {
+ "version": "3.1.5",
+ "resolved": "https://registry.npmjs.org/isexe/-/isexe-3.1.5.tgz",
+ "integrity": "sha512-6B3tLtFqtQS4ekarvLVMZ+X+VlvQekbe4taUkf/rhVO3d/h0M2rfARm/pXLcPEsjjMsFgrFgSrhQIxcSVrBz8w==",
+ "dev": true,
+ "license": "BlueOak-1.0.0",
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/app-builder-lib/node_modules/semver": {
+ "version": "7.7.4",
+ "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz",
+ "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==",
+ "dev": true,
+ "license": "ISC",
+ "bin": {
+ "semver": "bin/semver.js"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/app-builder-lib/node_modules/which": {
+ "version": "5.0.0",
+ "resolved": "https://registry.npmjs.org/which/-/which-5.0.0.tgz",
+ "integrity": "sha512-JEdGzHwwkrbWoGOlIHqQ5gtprKGOenpDHpxE9zVR1bWbOtYRyPPHMe9FaP6x61CmNaTThSkb0DAJte5jD+DmzQ==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "isexe": "^3.1.1"
+ },
+ "bin": {
+ "node-which": "bin/which.js"
+ },
+ "engines": {
+ "node": "^18.17.0 || >=20.5.0"
+ }
+ },
+ "node_modules/argparse": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
+ "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==",
+ "license": "Python-2.0"
+ },
+ "node_modules/assert-plus": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/assert-plus/-/assert-plus-1.0.0.tgz",
+ "integrity": "sha512-NfJ4UzBCcQGLDlQq7nHxH+tv3kyZ0hHQqF5BO6J7tNJeP5do1llPr8dZ8zHonfhAu0PHAdMkSo+8o0wxg9lZWw==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "engines": {
+ "node": ">=0.8"
+ }
+ },
+ "node_modules/astral-regex": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/astral-regex/-/astral-regex-2.0.0.tgz",
+ "integrity": "sha512-Z7tMw1ytTXt5jqMcOP+OQteU1VuNK9Y02uuJtKQ1Sv69jXQKKg5cibLwGJow8yzZP+eAc18EmLGPal0bp36rvQ==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/async": {
+ "version": "3.2.6",
+ "resolved": "https://registry.npmjs.org/async/-/async-3.2.6.tgz",
+ "integrity": "sha512-htCUDlxyyCLMgaM3xXg0C0LW2xqfuQ6p05pCEIsXuyQ+a1koYKTuBMzRNwmybfLgvJDMd0r1LTn4+E0Ti6C2AA==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/async-exit-hook": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/async-exit-hook/-/async-exit-hook-2.0.1.tgz",
+ "integrity": "sha512-NW2cX8m1Q7KPA7a5M2ULQeZ2wR5qI5PAbw5L0UOMxdioVk9PMZ0h1TmyZEkPYrCvYjDlFICusOu1dlEKAAeXBw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=0.12.0"
+ }
+ },
+ "node_modules/asynckit": {
+ "version": "0.4.0",
+ "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
+ "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/at-least-node": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/at-least-node/-/at-least-node-1.0.0.tgz",
+ "integrity": "sha512-+q/t7Ekv1EDY2l6Gda6LLiX14rU9TV20Wa3ofeQmwPFZbOMo9DXrLbOjFaaclkXKWidIaopwAObQDqwWtGUjqg==",
+ "dev": true,
+ "license": "ISC",
+ "engines": {
+ "node": ">= 4.0.0"
+ }
+ },
+ "node_modules/babel-plugin-macros": {
+ "version": "3.1.0",
+ "resolved": "https://registry.npmjs.org/babel-plugin-macros/-/babel-plugin-macros-3.1.0.tgz",
+ "integrity": "sha512-Cg7TFGpIr01vOQNODXOOaGz2NpCU5gl8x1qJFbb6hbZxR7XrcE2vtbAsTAbJ7/xwJtUuJEw8K8Zr/AE0LHlesg==",
+ "license": "MIT",
+ "dependencies": {
+ "@babel/runtime": "^7.12.5",
+ "cosmiconfig": "^7.0.0",
+ "resolve": "^1.19.0"
+ },
+ "engines": {
+ "node": ">=10",
+ "npm": ">=6"
+ }
+ },
+ "node_modules/balanced-match": {
+ "version": "4.0.4",
+ "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz",
+ "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": "18 || 20 || >=22"
+ }
+ },
+ "node_modules/base64-js": {
+ "version": "1.5.1",
+ "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz",
+ "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==",
+ "dev": true,
+ "funding": [
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/feross"
+ },
+ {
+ "type": "patreon",
+ "url": "https://www.patreon.com/feross"
+ },
+ {
+ "type": "consulting",
+ "url": "https://feross.org/support"
+ }
+ ],
+ "license": "MIT"
+ },
+ "node_modules/baseline-browser-mapping": {
+ "version": "2.10.13",
+ "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.10.13.tgz",
+ "integrity": "sha512-BL2sTuHOdy0YT1lYieUxTw/QMtPBC3pmlJC6xk8BBYVv6vcw3SGdKemQ+Xsx9ik2F/lYDO9tqsFQH1r9PFuHKw==",
+ "dev": true,
+ "license": "Apache-2.0",
+ "bin": {
+ "baseline-browser-mapping": "dist/cli.cjs"
+ },
+ "engines": {
+ "node": ">=6.0.0"
+ }
+ },
+ "node_modules/bl": {
+ "version": "4.1.0",
+ "resolved": "https://registry.npmjs.org/bl/-/bl-4.1.0.tgz",
+ "integrity": "sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "buffer": "^5.5.0",
+ "inherits": "^2.0.4",
+ "readable-stream": "^3.4.0"
+ }
+ },
+ "node_modules/boolean": {
+ "version": "3.2.0",
+ "resolved": "https://registry.npmjs.org/boolean/-/boolean-3.2.0.tgz",
+ "integrity": "sha512-d0II/GO9uf9lfUHH2BQsjxzRJZBdsjgsBiW4BvhWk/3qoKwQFjIDVN19PfX8F2D/r9PCMTtLWjYVCFrpeYUzsw==",
+ "deprecated": "Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.",
+ "dev": true,
+ "license": "MIT",
+ "optional": true
+ },
+ "node_modules/brace-expansion": {
+ "version": "5.0.5",
+ "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.5.tgz",
+ "integrity": "sha512-VZznLgtwhn+Mact9tfiwx64fA9erHH/MCXEUfB/0bX/6Fz6ny5EGTXYltMocqg4xFAQZtnO3DHWWXi8RiuN7cQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "balanced-match": "^4.0.2"
+ },
+ "engines": {
+ "node": "18 || 20 || >=22"
+ }
+ },
+ "node_modules/browserslist": {
+ "version": "4.28.2",
+ "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.28.2.tgz",
+ "integrity": "sha512-48xSriZYYg+8qXna9kwqjIVzuQxi+KYWp2+5nCYnYKPTr0LvD89Jqk2Or5ogxz0NUMfIjhh2lIUX/LyX9B4oIg==",
+ "dev": true,
+ "funding": [
+ {
+ "type": "opencollective",
+ "url": "https://opencollective.com/browserslist"
+ },
+ {
+ "type": "tidelift",
+ "url": "https://tidelift.com/funding/github/npm/browserslist"
+ },
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/ai"
+ }
+ ],
+ "license": "MIT",
+ "dependencies": {
+ "baseline-browser-mapping": "^2.10.12",
+ "caniuse-lite": "^1.0.30001782",
+ "electron-to-chromium": "^1.5.328",
+ "node-releases": "^2.0.36",
+ "update-browserslist-db": "^1.2.3"
+ },
+ "bin": {
+ "browserslist": "cli.js"
+ },
+ "engines": {
+ "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7"
+ }
+ },
+ "node_modules/buffer": {
+ "version": "5.7.1",
+ "resolved": "https://registry.npmjs.org/buffer/-/buffer-5.7.1.tgz",
+ "integrity": "sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==",
+ "dev": true,
+ "funding": [
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/feross"
+ },
+ {
+ "type": "patreon",
+ "url": "https://www.patreon.com/feross"
+ },
+ {
+ "type": "consulting",
+ "url": "https://feross.org/support"
+ }
+ ],
+ "license": "MIT",
+ "dependencies": {
+ "base64-js": "^1.3.1",
+ "ieee754": "^1.1.13"
+ }
+ },
+ "node_modules/buffer-crc32": {
+ "version": "0.2.13",
+ "resolved": "https://registry.npmjs.org/buffer-crc32/-/buffer-crc32-0.2.13.tgz",
+ "integrity": "sha512-VO9Ht/+p3SN7SKWqcrgEzjGbRSJYTx+Q1pTQC0wrWqHx0vpJraQ6GtHx8tvcg1rlK1byhU5gccxgOgj7B0TDkQ==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": "*"
+ }
+ },
+ "node_modules/buffer-from": {
+ "version": "1.1.2",
+ "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz",
+ "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/builder-util": {
+ "version": "26.8.1",
+ "resolved": "https://registry.npmjs.org/builder-util/-/builder-util-26.8.1.tgz",
+ "integrity": "sha512-pm1lTYbGyc90DHgCDO7eo8Rl4EqKLciayNbZqGziqnH9jrlKe8ZANGdityLZU+pJh16dfzjAx2xQq9McuIPEtw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@types/debug": "^4.1.6",
+ "7zip-bin": "~5.2.0",
+ "app-builder-bin": "5.0.0-alpha.12",
+ "builder-util-runtime": "9.5.1",
+ "chalk": "^4.1.2",
+ "cross-spawn": "^7.0.6",
+ "debug": "^4.3.4",
+ "fs-extra": "^10.1.0",
+ "http-proxy-agent": "^7.0.0",
+ "https-proxy-agent": "^7.0.0",
+ "js-yaml": "^4.1.0",
+ "sanitize-filename": "^1.6.3",
+ "source-map-support": "^0.5.19",
+ "stat-mode": "^1.0.0",
+ "temp-file": "^3.4.0",
+ "tiny-async-pool": "1.3.0"
+ }
+ },
+ "node_modules/builder-util-runtime": {
+ "version": "9.5.1",
+ "resolved": "https://registry.npmjs.org/builder-util-runtime/-/builder-util-runtime-9.5.1.tgz",
+ "integrity": "sha512-qt41tMfgHTllhResqM5DcnHyDIWNgzHvuY2jDcYP9iaGpkWxTUzV6GQjDeLnlR1/DtdlcsWQbA7sByMpmJFTLQ==",
+ "license": "MIT",
+ "dependencies": {
+ "debug": "^4.3.4",
+ "sax": "^1.2.4"
+ },
+ "engines": {
+ "node": ">=12.0.0"
+ }
+ },
+ "node_modules/builder-util/node_modules/fs-extra": {
+ "version": "10.1.0",
+ "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-10.1.0.tgz",
+ "integrity": "sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "graceful-fs": "^4.2.0",
+ "jsonfile": "^6.0.1",
+ "universalify": "^2.0.0"
+ },
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/builder-util/node_modules/jsonfile": {
+ "version": "6.2.0",
+ "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.0.tgz",
+ "integrity": "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "universalify": "^2.0.0"
+ },
+ "optionalDependencies": {
+ "graceful-fs": "^4.1.6"
+ }
+ },
+ "node_modules/builder-util/node_modules/universalify": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
+ "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 10.0.0"
+ }
+ },
+ "node_modules/cacache": {
+ "version": "19.0.1",
+ "resolved": "https://registry.npmjs.org/cacache/-/cacache-19.0.1.tgz",
+ "integrity": "sha512-hdsUxulXCi5STId78vRVYEtDAjq99ICAUktLTeTYsLoTE6Z8dS0c8pWNCxwdrk9YfJeobDZc2Y186hD/5ZQgFQ==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "@npmcli/fs": "^4.0.0",
+ "fs-minipass": "^3.0.0",
+ "glob": "^10.2.2",
+ "lru-cache": "^10.0.1",
+ "minipass": "^7.0.3",
+ "minipass-collect": "^2.0.1",
+ "minipass-flush": "^1.0.5",
+ "minipass-pipeline": "^1.2.4",
+ "p-map": "^7.0.2",
+ "ssri": "^12.0.0",
+ "tar": "^7.4.3",
+ "unique-filename": "^4.0.0"
+ },
+ "engines": {
+ "node": "^18.17.0 || >=20.5.0"
+ }
+ },
+ "node_modules/cacache/node_modules/balanced-match": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+ "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/cacache/node_modules/brace-expansion": {
+ "version": "2.0.3",
+ "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.3.tgz",
+ "integrity": "sha512-MCV/fYJEbqx68aE58kv2cA/kiky1G8vux3OR6/jbS+jIMe/6fJWa0DTzJU7dqijOWYwHi1t29FlfYI9uytqlpA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "balanced-match": "^1.0.0"
+ }
+ },
+ "node_modules/cacache/node_modules/glob": {
+ "version": "10.5.0",
+ "resolved": "https://registry.npmjs.org/glob/-/glob-10.5.0.tgz",
+ "integrity": "sha512-DfXN8DfhJ7NH3Oe7cFmu3NCu1wKbkReJ8TorzSAFbSKrlNaQSKfIzqYqVY8zlbs2NLBbWpRiU52GX2PbaBVNkg==",
+ "deprecated": "Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting [email protected]",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "foreground-child": "^3.1.0",
+ "jackspeak": "^3.1.2",
+ "minimatch": "^9.0.4",
+ "minipass": "^7.1.2",
+ "package-json-from-dist": "^1.0.0",
+ "path-scurry": "^1.11.1"
+ },
+ "bin": {
+ "glob": "dist/esm/bin.mjs"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/isaacs"
+ }
+ },
+ "node_modules/cacache/node_modules/lru-cache": {
+ "version": "10.4.3",
+ "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-10.4.3.tgz",
+ "integrity": "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==",
+ "dev": true,
+ "license": "ISC"
+ },
+ "node_modules/cacache/node_modules/minimatch": {
+ "version": "9.0.9",
+ "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.9.tgz",
+ "integrity": "sha512-OBwBN9AL4dqmETlpS2zasx+vTeWclWzkblfZk7KTA5j3jeOONz/tRCnZomUyvNg83wL5Zv9Ss6HMJXAgL8R2Yg==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "brace-expansion": "^2.0.2"
+ },
+ "engines": {
+ "node": ">=16 || 14 >=14.17"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/isaacs"
+ }
+ },
+ "node_modules/cacheable-lookup": {
+ "version": "5.0.4",
+ "resolved": "https://registry.npmjs.org/cacheable-lookup/-/cacheable-lookup-5.0.4.tgz",
+ "integrity": "sha512-2/kNscPhpcxrOigMZzbiWF7dz8ilhb/nIHU3EyZiXWXpeq/au8qJ8VhdftMkty3n7Gj6HIGalQG8oiBNB3AJgA==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=10.6.0"
+ }
+ },
+ "node_modules/cacheable-request": {
+ "version": "7.0.4",
+ "resolved": "https://registry.npmjs.org/cacheable-request/-/cacheable-request-7.0.4.tgz",
+ "integrity": "sha512-v+p6ongsrp0yTGbJXjgxPow2+DL93DASP4kXCDKb8/bwRtt9OEF3whggkkDkGNzgcWy2XaF4a8nZglC7uElscg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "clone-response": "^1.0.2",
+ "get-stream": "^5.1.0",
+ "http-cache-semantics": "^4.0.0",
+ "keyv": "^4.0.0",
+ "lowercase-keys": "^2.0.0",
+ "normalize-url": "^6.0.1",
+ "responselike": "^2.0.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/call-bind-apply-helpers": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
+ "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "es-errors": "^1.3.0",
+ "function-bind": "^1.1.2"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ }
+ },
+ "node_modules/callsites": {
+ "version": "3.1.0",
+ "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz",
+ "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==",
+ "license": "MIT",
+ "engines": {
+ "node": ">=6"
+ }
+ },
+ "node_modules/caniuse-lite": {
+ "version": "1.0.30001784",
+ "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001784.tgz",
+ "integrity": "sha512-WU346nBTklUV9YfUl60fqRbU5ZqyXlqvo1SgigE1OAXK5bFL8LL9q1K7aap3N739l4BvNqnkm3YrGHiY9sfUQw==",
+ "dev": true,
+ "funding": [
+ {
+ "type": "opencollective",
+ "url": "https://opencollective.com/browserslist"
+ },
+ {
+ "type": "tidelift",
+ "url": "https://tidelift.com/funding/github/npm/caniuse-lite"
+ },
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/ai"
+ }
+ ],
+ "license": "CC-BY-4.0"
+ },
+ "node_modules/chalk": {
+ "version": "4.1.2",
+ "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
+ "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "ansi-styles": "^4.1.0",
+ "supports-color": "^7.1.0"
+ },
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/chalk/chalk?sponsor=1"
+ }
+ },
+ "node_modules/chownr": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/chownr/-/chownr-3.0.0.tgz",
+ "integrity": "sha512-+IxzY9BZOQd/XuYPRmrvEVjF/nqj5kgT4kEq7VofrDoM1MxoRjEWkrCC3EtLi59TVawxTAn+orJwFQcrqEN1+g==",
+ "dev": true,
+ "license": "BlueOak-1.0.0",
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/chromium-pickle-js": {
+ "version": "0.2.0",
+ "resolved": "https://registry.npmjs.org/chromium-pickle-js/-/chromium-pickle-js-0.2.0.tgz",
+ "integrity": "sha512-1R5Fho+jBq0DDydt+/vHWj5KJNJCKdARKOCwZUen84I5BreWoLqRLANH1U87eJy1tiASPtMnGqJJq0ZsLoRPOw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/ci-info": {
+ "version": "4.4.0",
+ "resolved": "https://registry.npmjs.org/ci-info/-/ci-info-4.4.0.tgz",
+ "integrity": "sha512-77PSwercCZU2Fc4sX94eF8k8Pxte6JAwL4/ICZLFjJLqegs7kCuAsqqj/70NQF6TvDpgFjkubQB2FW2ZZddvQg==",
+ "dev": true,
+ "funding": [
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/sibiraj-s"
+ }
+ ],
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/cli-cursor": {
+ "version": "3.1.0",
+ "resolved": "https://registry.npmjs.org/cli-cursor/-/cli-cursor-3.1.0.tgz",
+ "integrity": "sha512-I/zHAwsKf9FqGoXM4WWRACob9+SNukZTd94DWF57E4toouRulbCxcUh6RKUEOQlYTHJnzkPMySvPNaaSLNfLZw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "restore-cursor": "^3.1.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/cli-spinners": {
+ "version": "2.9.2",
+ "resolved": "https://registry.npmjs.org/cli-spinners/-/cli-spinners-2.9.2.tgz",
+ "integrity": "sha512-ywqV+5MmyL4E7ybXgKys4DugZbX0FC6LnwrhjuykIjnK9k8OQacQ7axGKnjDXWNhns0xot3bZI5h55H8yo9cJg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=6"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/cli-truncate": {
+ "version": "2.1.0",
+ "resolved": "https://registry.npmjs.org/cli-truncate/-/cli-truncate-2.1.0.tgz",
+ "integrity": "sha512-n8fOixwDD6b/ObinzTrp1ZKFzbgvKZvuz/TvejnLn1aQfC6r52XEx85FmuC+3HI+JM7coBRXUvNqEU2PHVrHpg==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "dependencies": {
+ "slice-ansi": "^3.0.0",
+ "string-width": "^4.2.0"
+ },
+ "engines": {
+ "node": ">=8"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/cliui": {
+ "version": "8.0.1",
+ "resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz",
+ "integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "string-width": "^4.2.0",
+ "strip-ansi": "^6.0.1",
+ "wrap-ansi": "^7.0.0"
+ },
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/clone": {
+ "version": "1.0.4",
+ "resolved": "https://registry.npmjs.org/clone/-/clone-1.0.4.tgz",
+ "integrity": "sha512-JQHZ2QMW6l3aH/j6xCqQThY/9OH4D/9ls34cgkUBiEeocRTU04tHfKPBsUK1PqZCUQM7GiA0IIXJSuXHI64Kbg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=0.8"
+ }
+ },
+ "node_modules/clone-response": {
+ "version": "1.0.3",
+ "resolved": "https://registry.npmjs.org/clone-response/-/clone-response-1.0.3.tgz",
+ "integrity": "sha512-ROoL94jJH2dUVML2Y/5PEDNaSHgeOdSDicUyS7izcF63G6sTc/FTjLub4b8Il9S8S0beOfYt0TaA5qvFK+w0wA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "mimic-response": "^1.0.0"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/clsx": {
+ "version": "2.1.1",
+ "resolved": "https://registry.npmjs.org/clsx/-/clsx-2.1.1.tgz",
+ "integrity": "sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==",
+ "license": "MIT",
+ "engines": {
+ "node": ">=6"
+ }
+ },
+ "node_modules/color-convert": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
+ "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "color-name": "~1.1.4"
+ },
+ "engines": {
+ "node": ">=7.0.0"
+ }
+ },
+ "node_modules/color-name": {
+ "version": "1.1.4",
+ "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
+ "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/combined-stream": {
+ "version": "1.0.8",
+ "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
+ "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "delayed-stream": "~1.0.0"
+ },
+ "engines": {
+ "node": ">= 0.8"
+ }
+ },
+ "node_modules/commander": {
+ "version": "7.2.0",
+ "resolved": "https://registry.npmjs.org/commander/-/commander-7.2.0.tgz",
+ "integrity": "sha512-QrWXB+ZQSVPmIWIhtEO9H+gwHaMGYiF5ChvoJ+K9ZGHG/sVsa6yiesAD1GC/x46sET00Xlwo1u49RVVVzvcSkw==",
+ "license": "MIT",
+ "engines": {
+ "node": ">= 10"
+ }
+ },
+ "node_modules/compare-version": {
+ "version": "0.1.2",
+ "resolved": "https://registry.npmjs.org/compare-version/-/compare-version-0.1.2.tgz",
+ "integrity": "sha512-pJDh5/4wrEnXX/VWRZvruAGHkzKdr46z11OlTPN+VrATlWWhSKewNCJ1futCO5C7eJB3nPMFZA1LeYtcFboZ2A==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/concat-map": {
+ "version": "0.0.1",
+ "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
+ "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/convert-source-map": {
+ "version": "1.9.0",
+ "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.9.0.tgz",
+ "integrity": "sha512-ASFBup0Mz1uyiIjANan1jzLQami9z1PoYSZCiiYW2FczPbenXc45FZdBZLzOT+r6+iciuEModtmCti+hjaAk0A==",
+ "license": "MIT"
+ },
+ "node_modules/copy-anything": {
+ "version": "4.0.5",
+ "resolved": "https://registry.npmjs.org/copy-anything/-/copy-anything-4.0.5.tgz",
+ "integrity": "sha512-7Vv6asjS4gMOuILabD3l739tsaxFQmC+a7pLZm02zyvs8p977bL3zEgq3yDk5rn9B0PbYgIv++jmHcuUab4RhA==",
+ "license": "MIT",
+ "dependencies": {
+ "is-what": "^5.2.0"
+ },
+ "engines": {
+ "node": ">=18"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/mesqueeb"
+ }
+ },
+ "node_modules/core-util-is": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.2.tgz",
+ "integrity": "sha512-3lqz5YjWTYnW6dlDa5TLaTCcShfar1e40rmcJVwCBJC6mWlFuj0eCHIElmG1g5kyuJ/GD+8Wn4FFCcz4gJPfaQ==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/cosmiconfig": {
+ "version": "7.1.0",
+ "resolved": "https://registry.npmjs.org/cosmiconfig/-/cosmiconfig-7.1.0.tgz",
+ "integrity": "sha512-AdmX6xUzdNASswsFtmwSt7Vj8po9IuqXm0UXz7QKPuEUmPB4XyjGfaAr2PSuELMwkRMVH1EpIkX5bTZGRB3eCA==",
+ "license": "MIT",
+ "dependencies": {
+ "@types/parse-json": "^4.0.0",
+ "import-fresh": "^3.2.1",
+ "parse-json": "^5.0.0",
+ "path-type": "^4.0.0",
+ "yaml": "^1.10.0"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/cosmiconfig/node_modules/yaml": {
+ "version": "1.10.3",
+ "resolved": "https://registry.npmjs.org/yaml/-/yaml-1.10.3.tgz",
+ "integrity": "sha512-vIYeF1u3CjlhAFekPPAk2h/Kv4T3mAkMox5OymRiJQB0spDP10LHvt+K7G9Ny6NuuMAb25/6n1qyUjAcGNf/AA==",
+ "license": "ISC",
+ "engines": {
+ "node": ">= 6"
+ }
+ },
+ "node_modules/country-flag-icons": {
+ "version": "1.6.15",
+ "resolved": "https://registry.npmjs.org/country-flag-icons/-/country-flag-icons-1.6.15.tgz",
+ "integrity": "sha512-92HoA8l6DluEidku8tKBftjuFRj4Rv3zDW1lXxCuNnqAxhUSkvso9gM/Afj4F5BnK+wneHIe3ydI+s+4NA29/Q==",
+ "license": "MIT"
+ },
+ "node_modules/crc": {
+ "version": "3.8.0",
+ "resolved": "https://registry.npmjs.org/crc/-/crc-3.8.0.tgz",
+ "integrity": "sha512-iX3mfgcTMIq3ZKLIsVFAbv7+Mc10kxabAGQb8HvjA1o3T1PIYprbakQ65d3I+2HGHt6nSKkM9PYjgoJO2KcFBQ==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "dependencies": {
+ "buffer": "^5.1.0"
+ }
+ },
+ "node_modules/cross-dirname": {
+ "version": "0.1.0",
+ "resolved": "https://registry.npmjs.org/cross-dirname/-/cross-dirname-0.1.0.tgz",
+ "integrity": "sha512-+R08/oI0nl3vfPcqftZRpytksBXDzOUveBq/NBVx0sUp1axwzPQrKinNx5yd5sxPu8j1wIy8AfnVQ+5eFdha6Q==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "peer": true
+ },
+ "node_modules/cross-env": {
+ "version": "7.0.3",
+ "resolved": "https://registry.npmjs.org/cross-env/-/cross-env-7.0.3.tgz",
+ "integrity": "sha512-+/HKd6EgcQCJGh2PSjZuUitQBQynKor4wrFbRg4DtAgS1aWO+gU52xpH7M9ScGgXSYmAVS9bIJ8EzuaGw0oNAw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "cross-spawn": "^7.0.1"
+ },
+ "bin": {
+ "cross-env": "src/bin/cross-env.js",
+ "cross-env-shell": "src/bin/cross-env-shell.js"
+ },
+ "engines": {
+ "node": ">=10.14",
+ "npm": ">=6",
+ "yarn": ">=1"
+ }
+ },
+ "node_modules/cross-spawn": {
+ "version": "7.0.6",
+ "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
+ "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "path-key": "^3.1.0",
+ "shebang-command": "^2.0.0",
+ "which": "^2.0.1"
+ },
+ "engines": {
+ "node": ">= 8"
+ }
+ },
+ "node_modules/csstype": {
+ "version": "3.2.3",
+ "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz",
+ "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==",
+ "license": "MIT"
+ },
+ "node_modules/d3": {
+ "version": "7.9.0",
+ "resolved": "https://registry.npmjs.org/d3/-/d3-7.9.0.tgz",
+ "integrity": "sha512-e1U46jVP+w7Iut8Jt8ri1YsPOvFpg46k+K8TpCb0P+zjCkjkPnV7WzfDJzMHy1LnA+wj5pLT1wjO901gLXeEhA==",
+ "license": "ISC",
+ "dependencies": {
+ "d3-array": "3",
+ "d3-axis": "3",
+ "d3-brush": "3",
+ "d3-chord": "3",
+ "d3-color": "3",
+ "d3-contour": "4",
+ "d3-delaunay": "6",
+ "d3-dispatch": "3",
+ "d3-drag": "3",
+ "d3-dsv": "3",
+ "d3-ease": "3",
+ "d3-fetch": "3",
+ "d3-force": "3",
+ "d3-format": "3",
+ "d3-geo": "3",
+ "d3-hierarchy": "3",
+ "d3-interpolate": "3",
+ "d3-path": "3",
+ "d3-polygon": "3",
+ "d3-quadtree": "3",
+ "d3-random": "3",
+ "d3-scale": "4",
+ "d3-scale-chromatic": "3",
+ "d3-selection": "3",
+ "d3-shape": "3",
+ "d3-time": "3",
+ "d3-time-format": "4",
+ "d3-timer": "3",
+ "d3-transition": "3",
+ "d3-zoom": "3"
+ },
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/d3-array": {
+ "version": "3.2.4",
+ "resolved": "https://registry.npmjs.org/d3-array/-/d3-array-3.2.4.tgz",
+ "integrity": "sha512-tdQAmyA18i4J7wprpYq8ClcxZy3SC31QMeByyCFyRt7BVHdREQZ5lpzoe5mFEYZUWe+oq8HBvk9JjpibyEV4Jg==",
+ "license": "ISC",
+ "dependencies": {
+ "internmap": "1 - 2"
+ },
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/d3-axis": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/d3-axis/-/d3-axis-3.0.0.tgz",
+ "integrity": "sha512-IH5tgjV4jE/GhHkRV0HiVYPDtvfjHQlQfJHs0usq7M30XcSBvOotpmH1IgkcXsO/5gEQZD43B//fc7SRT5S+xw==",
+ "license": "ISC",
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/d3-brush": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/d3-brush/-/d3-brush-3.0.0.tgz",
+ "integrity": "sha512-ALnjWlVYkXsVIGlOsuWH1+3udkYFI48Ljihfnh8FZPF2QS9o+PzGLBslO0PjzVoHLZ2KCVgAM8NVkXPJB2aNnQ==",
+ "license": "ISC",
+ "dependencies": {
+ "d3-dispatch": "1 - 3",
+ "d3-drag": "2 - 3",
+ "d3-interpolate": "1 - 3",
+ "d3-selection": "3",
+ "d3-transition": "3"
+ },
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/d3-chord": {
+ "version": "3.0.1",
+ "resolved": "https://registry.npmjs.org/d3-chord/-/d3-chord-3.0.1.tgz",
+ "integrity": "sha512-VE5S6TNa+j8msksl7HwjxMHDM2yNK3XCkusIlpX5kwauBfXuyLAtNg9jCp/iHH61tgI4sb6R/EIMWCqEIdjT/g==",
+ "license": "ISC",
+ "dependencies": {
+ "d3-path": "1 - 3"
+ },
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/d3-color": {
+ "version": "3.1.0",
+ "resolved": "https://registry.npmjs.org/d3-color/-/d3-color-3.1.0.tgz",
+ "integrity": "sha512-zg/chbXyeBtMQ1LbD/WSoW2DpC3I0mpmPdW+ynRTj/x2DAWYrIY7qeZIHidozwV24m4iavr15lNwIwLxRmOxhA==",
+ "license": "ISC",
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/d3-contour": {
+ "version": "4.0.2",
+ "resolved": "https://registry.npmjs.org/d3-contour/-/d3-contour-4.0.2.tgz",
+ "integrity": "sha512-4EzFTRIikzs47RGmdxbeUvLWtGedDUNkTcmzoeyg4sP/dvCexO47AaQL7VKy/gul85TOxw+IBgA8US2xwbToNA==",
+ "license": "ISC",
+ "dependencies": {
+ "d3-array": "^3.2.0"
+ },
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/d3-delaunay": {
+ "version": "6.0.4",
+ "resolved": "https://registry.npmjs.org/d3-delaunay/-/d3-delaunay-6.0.4.tgz",
+ "integrity": "sha512-mdjtIZ1XLAM8bm/hx3WwjfHt6Sggek7qH043O8KEjDXN40xi3vx/6pYSVTwLjEgiXQTbvaouWKynLBiUZ6SK6A==",
+ "license": "ISC",
+ "dependencies": {
+ "delaunator": "5"
+ },
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/d3-dispatch": {
+ "version": "3.0.1",
+ "resolved": "https://registry.npmjs.org/d3-dispatch/-/d3-dispatch-3.0.1.tgz",
+ "integrity": "sha512-rzUyPU/S7rwUflMyLc1ETDeBj0NRuHKKAcvukozwhshr6g6c5d8zh4c2gQjY2bZ0dXeGLWc1PF174P2tVvKhfg==",
+ "license": "ISC",
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/d3-drag": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/d3-drag/-/d3-drag-3.0.0.tgz",
+ "integrity": "sha512-pWbUJLdETVA8lQNJecMxoXfH6x+mO2UQo8rSmZ+QqxcbyA3hfeprFgIT//HW2nlHChWeIIMwS2Fq+gEARkhTkg==",
+ "license": "ISC",
+ "dependencies": {
+ "d3-dispatch": "1 - 3",
+ "d3-selection": "3"
+ },
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/d3-dsv": {
+ "version": "3.0.1",
+ "resolved": "https://registry.npmjs.org/d3-dsv/-/d3-dsv-3.0.1.tgz",
+ "integrity": "sha512-UG6OvdI5afDIFP9w4G0mNq50dSOsXHJaRE8arAS5o9ApWnIElp8GZw1Dun8vP8OyHOZ/QJUKUJwxiiCCnUwm+Q==",
+ "license": "ISC",
+ "dependencies": {
+ "commander": "7",
+ "iconv-lite": "0.6",
+ "rw": "1"
+ },
+ "bin": {
+ "csv2json": "bin/dsv2json.js",
+ "csv2tsv": "bin/dsv2dsv.js",
+ "dsv2dsv": "bin/dsv2dsv.js",
+ "dsv2json": "bin/dsv2json.js",
+ "json2csv": "bin/json2dsv.js",
+ "json2dsv": "bin/json2dsv.js",
+ "json2tsv": "bin/json2dsv.js",
+ "tsv2csv": "bin/dsv2dsv.js",
+ "tsv2json": "bin/dsv2json.js"
+ },
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/d3-ease": {
+ "version": "3.0.1",
+ "resolved": "https://registry.npmjs.org/d3-ease/-/d3-ease-3.0.1.tgz",
+ "integrity": "sha512-wR/XK3D3XcLIZwpbvQwQ5fK+8Ykds1ip7A2Txe0yxncXSdq1L9skcG7blcedkOX+ZcgxGAmLX1FrRGbADwzi0w==",
+ "license": "BSD-3-Clause",
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/d3-fetch": {
+ "version": "3.0.1",
+ "resolved": "https://registry.npmjs.org/d3-fetch/-/d3-fetch-3.0.1.tgz",
+ "integrity": "sha512-kpkQIM20n3oLVBKGg6oHrUchHM3xODkTzjMoj7aWQFq5QEM+R6E4WkzT5+tojDY7yjez8KgCBRoj4aEr99Fdqw==",
+ "license": "ISC",
+ "dependencies": {
+ "d3-dsv": "1 - 3"
+ },
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/d3-force": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/d3-force/-/d3-force-3.0.0.tgz",
+ "integrity": "sha512-zxV/SsA+U4yte8051P4ECydjD/S+qeYtnaIyAs9tgHCqfguma/aAQDjo85A9Z6EKhBirHRJHXIgJUlffT4wdLg==",
+ "license": "ISC",
+ "dependencies": {
+ "d3-dispatch": "1 - 3",
+ "d3-quadtree": "1 - 3",
+ "d3-timer": "1 - 3"
+ },
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/d3-format": {
+ "version": "3.1.2",
+ "resolved": "https://registry.npmjs.org/d3-format/-/d3-format-3.1.2.tgz",
+ "integrity": "sha512-AJDdYOdnyRDV5b6ArilzCPPwc1ejkHcoyFarqlPqT7zRYjhavcT3uSrqcMvsgh2CgoPbK3RCwyHaVyxYcP2Arg==",
+ "license": "ISC",
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/d3-geo": {
+ "version": "3.1.1",
+ "resolved": "https://registry.npmjs.org/d3-geo/-/d3-geo-3.1.1.tgz",
+ "integrity": "sha512-637ln3gXKXOwhalDzinUgY83KzNWZRKbYubaG+fGVuc/dxO64RRljtCTnf5ecMyE1RIdtqpkVcq0IbtU2S8j2Q==",
+ "license": "ISC",
+ "dependencies": {
+ "d3-array": "2.5.0 - 3"
+ },
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/d3-hierarchy": {
+ "version": "3.1.2",
+ "resolved": "https://registry.npmjs.org/d3-hierarchy/-/d3-hierarchy-3.1.2.tgz",
+ "integrity": "sha512-FX/9frcub54beBdugHjDCdikxThEqjnR93Qt7PvQTOHxyiNCAlvMrHhclk3cD5VeAaq9fxmfRp+CnWw9rEMBuA==",
+ "license": "ISC",
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/d3-interpolate": {
+ "version": "3.0.1",
+ "resolved": "https://registry.npmjs.org/d3-interpolate/-/d3-interpolate-3.0.1.tgz",
+ "integrity": "sha512-3bYs1rOD33uo8aqJfKP3JWPAibgw8Zm2+L9vBKEHJ2Rg+viTR7o5Mmv5mZcieN+FRYaAOWX5SJATX6k1PWz72g==",
+ "license": "ISC",
+ "dependencies": {
+ "d3-color": "1 - 3"
+ },
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/d3-path": {
+ "version": "3.1.0",
+ "resolved": "https://registry.npmjs.org/d3-path/-/d3-path-3.1.0.tgz",
+ "integrity": "sha512-p3KP5HCf/bvjBSSKuXid6Zqijx7wIfNW+J/maPs+iwR35at5JCbLUT0LzF1cnjbCHWhqzQTIN2Jpe8pRebIEFQ==",
+ "license": "ISC",
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/d3-polygon": {
+ "version": "3.0.1",
+ "resolved": "https://registry.npmjs.org/d3-polygon/-/d3-polygon-3.0.1.tgz",
+ "integrity": "sha512-3vbA7vXYwfe1SYhED++fPUQlWSYTTGmFmQiany/gdbiWgU/iEyQzyymwL9SkJjFFuCS4902BSzewVGsHHmHtXg==",
+ "license": "ISC",
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/d3-quadtree": {
+ "version": "3.0.1",
+ "resolved": "https://registry.npmjs.org/d3-quadtree/-/d3-quadtree-3.0.1.tgz",
+ "integrity": "sha512-04xDrxQTDTCFwP5H6hRhsRcb9xxv2RzkcsygFzmkSIOJy3PeRJP7sNk3VRIbKXcog561P9oU0/rVH6vDROAgUw==",
+ "license": "ISC",
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/d3-random": {
+ "version": "3.0.1",
+ "resolved": "https://registry.npmjs.org/d3-random/-/d3-random-3.0.1.tgz",
+ "integrity": "sha512-FXMe9GfxTxqd5D6jFsQ+DJ8BJS4E/fT5mqqdjovykEB2oFbTMDVdg1MGFxfQW+FBOGoB++k8swBrgwSHT1cUXQ==",
+ "license": "ISC",
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/d3-scale": {
+ "version": "4.0.2",
+ "resolved": "https://registry.npmjs.org/d3-scale/-/d3-scale-4.0.2.tgz",
+ "integrity": "sha512-GZW464g1SH7ag3Y7hXjf8RoUuAFIqklOAq3MRl4OaWabTFJY9PN/E1YklhXLh+OQ3fM9yS2nOkCoS+WLZ6kvxQ==",
+ "license": "ISC",
+ "dependencies": {
+ "d3-array": "2.10.0 - 3",
+ "d3-format": "1 - 3",
+ "d3-interpolate": "1.2.0 - 3",
+ "d3-time": "2.1.1 - 3",
+ "d3-time-format": "2 - 4"
+ },
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/d3-scale-chromatic": {
+ "version": "3.1.0",
+ "resolved": "https://registry.npmjs.org/d3-scale-chromatic/-/d3-scale-chromatic-3.1.0.tgz",
+ "integrity": "sha512-A3s5PWiZ9YCXFye1o246KoscMWqf8BsD9eRiJ3He7C9OBaxKhAd5TFCdEx/7VbKtxxTsu//1mMJFrEt572cEyQ==",
+ "license": "ISC",
+ "dependencies": {
+ "d3-color": "1 - 3",
+ "d3-interpolate": "1 - 3"
+ },
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/d3-selection": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/d3-selection/-/d3-selection-3.0.0.tgz",
+ "integrity": "sha512-fmTRWbNMmsmWq6xJV8D19U/gw/bwrHfNXxrIN+HfZgnzqTHp9jOmKMhsTUjXOJnZOdZY9Q28y4yebKzqDKlxlQ==",
+ "license": "ISC",
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/d3-shape": {
+ "version": "3.2.0",
+ "resolved": "https://registry.npmjs.org/d3-shape/-/d3-shape-3.2.0.tgz",
+ "integrity": "sha512-SaLBuwGm3MOViRq2ABk3eLoxwZELpH6zhl3FbAoJ7Vm1gofKx6El1Ib5z23NUEhF9AsGl7y+dzLe5Cw2AArGTA==",
+ "license": "ISC",
+ "dependencies": {
+ "d3-path": "^3.1.0"
+ },
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/d3-time": {
+ "version": "3.1.0",
+ "resolved": "https://registry.npmjs.org/d3-time/-/d3-time-3.1.0.tgz",
+ "integrity": "sha512-VqKjzBLejbSMT4IgbmVgDjpkYrNWUYJnbCGo874u7MMKIWsILRX+OpX/gTk8MqjpT1A/c6HY2dCA77ZN0lkQ2Q==",
+ "license": "ISC",
+ "dependencies": {
+ "d3-array": "2 - 3"
+ },
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/d3-time-format": {
+ "version": "4.1.0",
+ "resolved": "https://registry.npmjs.org/d3-time-format/-/d3-time-format-4.1.0.tgz",
+ "integrity": "sha512-dJxPBlzC7NugB2PDLwo9Q8JiTR3M3e4/XANkreKSUxF8vvXKqm1Yfq4Q5dl8budlunRVlUUaDUgFt7eA8D6NLg==",
+ "license": "ISC",
+ "dependencies": {
+ "d3-time": "1 - 3"
+ },
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/d3-timer": {
+ "version": "3.0.1",
+ "resolved": "https://registry.npmjs.org/d3-timer/-/d3-timer-3.0.1.tgz",
+ "integrity": "sha512-ndfJ/JxxMd3nw31uyKoY2naivF+r29V+Lc0svZxe1JvvIRmi8hUsrMvdOwgS1o6uBHmiz91geQ0ylPP0aj1VUA==",
+ "license": "ISC",
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/d3-transition": {
+ "version": "3.0.1",
+ "resolved": "https://registry.npmjs.org/d3-transition/-/d3-transition-3.0.1.tgz",
+ "integrity": "sha512-ApKvfjsSR6tg06xrL434C0WydLr7JewBB3V+/39RMHsaXTOG0zmt/OAXeng5M5LBm0ojmxJrpomQVZ1aPvBL4w==",
+ "license": "ISC",
+ "dependencies": {
+ "d3-color": "1 - 3",
+ "d3-dispatch": "1 - 3",
+ "d3-ease": "1 - 3",
+ "d3-interpolate": "1 - 3",
+ "d3-timer": "1 - 3"
+ },
+ "engines": {
+ "node": ">=12"
+ },
+ "peerDependencies": {
+ "d3-selection": "2 - 3"
+ }
+ },
+ "node_modules/d3-zoom": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/d3-zoom/-/d3-zoom-3.0.0.tgz",
+ "integrity": "sha512-b8AmV3kfQaqWAuacbPuNbL6vahnOJflOhexLzMMNLga62+/nh0JzvJ0aO/5a5MVgUFGS7Hu1P9P03o3fJkDCyw==",
+ "license": "ISC",
+ "dependencies": {
+ "d3-dispatch": "1 - 3",
+ "d3-drag": "2 - 3",
+ "d3-interpolate": "1 - 3",
+ "d3-selection": "2 - 3",
+ "d3-transition": "2 - 3"
+ },
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/debug": {
+ "version": "4.4.3",
+ "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
+ "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
+ "license": "MIT",
+ "dependencies": {
+ "ms": "^2.1.3"
+ },
+ "engines": {
+ "node": ">=6.0"
+ },
+ "peerDependenciesMeta": {
+ "supports-color": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/decompress-response": {
+ "version": "6.0.0",
+ "resolved": "https://registry.npmjs.org/decompress-response/-/decompress-response-6.0.0.tgz",
+ "integrity": "sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "mimic-response": "^3.1.0"
+ },
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/decompress-response/node_modules/mimic-response": {
+ "version": "3.1.0",
+ "resolved": "https://registry.npmjs.org/mimic-response/-/mimic-response-3.1.0.tgz",
+ "integrity": "sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/defaults": {
+ "version": "1.0.4",
+ "resolved": "https://registry.npmjs.org/defaults/-/defaults-1.0.4.tgz",
+ "integrity": "sha512-eFuaLoy/Rxalv2kr+lqMlUnrDWV+3j4pljOIJgLIhI058IQfWJ7vXhyEIHu+HtC738klGALYxOKDO0bQP3tg8A==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "clone": "^1.0.2"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/defer-to-connect": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/defer-to-connect/-/defer-to-connect-2.0.1.tgz",
+ "integrity": "sha512-4tvttepXG1VaYGrRibk5EwJd1t4udunSOVMdLSAL6mId1ix438oPwPZMALY41FCijukO1L0twNcGsdzS7dHgDg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/define-data-property": {
+ "version": "1.1.4",
+ "resolved": "https://registry.npmjs.org/define-data-property/-/define-data-property-1.1.4.tgz",
+ "integrity": "sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "dependencies": {
+ "es-define-property": "^1.0.0",
+ "es-errors": "^1.3.0",
+ "gopd": "^1.0.1"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/define-properties": {
+ "version": "1.2.1",
+ "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.2.1.tgz",
+ "integrity": "sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "dependencies": {
+ "define-data-property": "^1.0.1",
+ "has-property-descriptors": "^1.0.0",
+ "object-keys": "^1.1.1"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/delaunator": {
+ "version": "5.1.0",
+ "resolved": "https://registry.npmjs.org/delaunator/-/delaunator-5.1.0.tgz",
+ "integrity": "sha512-AGrQ4QSgssa1NGmWmLPqN5NY2KajF5MqxetNEO+o0n3ZwZZeTmt7bBnvzHWrmkZFxGgr4HdyFgelzgi06otLuQ==",
+ "license": "ISC",
+ "dependencies": {
+ "robust-predicates": "^3.0.2"
+ }
+ },
+ "node_modules/delayed-stream": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
+ "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=0.4.0"
+ }
+ },
+ "node_modules/detect-libc": {
+ "version": "2.1.2",
+ "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz",
+ "integrity": "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==",
+ "dev": true,
+ "license": "Apache-2.0",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/detect-node": {
+ "version": "2.1.0",
+ "resolved": "https://registry.npmjs.org/detect-node/-/detect-node-2.1.0.tgz",
+ "integrity": "sha512-T0NIuQpnTvFDATNuHN5roPwSBG83rFsuO+MXXH9/3N1eFbn4wcPjttvjMLEPWJ0RGUYgQE7cGgS3tNxbqCGM7g==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true
+ },
+ "node_modules/dir-compare": {
+ "version": "4.2.0",
+ "resolved": "https://registry.npmjs.org/dir-compare/-/dir-compare-4.2.0.tgz",
+ "integrity": "sha512-2xMCmOoMrdQIPHdsTawECdNPwlVFB9zGcz3kuhmBO6U3oU+UQjsue0i8ayLKpgBcm+hcXPMVSGUN9d+pvJ6+VQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "minimatch": "^3.0.5",
+ "p-limit": "^3.1.0 "
+ }
+ },
+ "node_modules/dir-compare/node_modules/balanced-match": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+ "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/dir-compare/node_modules/brace-expansion": {
+ "version": "1.1.13",
+ "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.13.tgz",
+ "integrity": "sha512-9ZLprWS6EENmhEOpjCYW2c8VkmOvckIJZfkr7rBW6dObmfgJ/L1GpSYW5Hpo9lDz4D1+n0Ckz8rU7FwHDQiG/w==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "balanced-match": "^1.0.0",
+ "concat-map": "0.0.1"
+ }
+ },
+ "node_modules/dir-compare/node_modules/minimatch": {
+ "version": "3.1.5",
+ "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz",
+ "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "brace-expansion": "^1.1.7"
+ },
+ "engines": {
+ "node": "*"
+ }
+ },
+ "node_modules/dmg-builder": {
+ "version": "26.8.1",
+ "resolved": "https://registry.npmjs.org/dmg-builder/-/dmg-builder-26.8.1.tgz",
+ "integrity": "sha512-glMJgnTreo8CFINujtAhCgN96QAqApDMZ8Vl1r8f0QT8QprvC1UCltV4CcWj20YoIyLZx6IUskaJZ0NV8fokcg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "app-builder-lib": "26.8.1",
+ "builder-util": "26.8.1",
+ "fs-extra": "^10.1.0",
+ "iconv-lite": "^0.6.2",
+ "js-yaml": "^4.1.0"
+ },
+ "optionalDependencies": {
+ "dmg-license": "^1.0.11"
+ }
+ },
+ "node_modules/dmg-builder/node_modules/fs-extra": {
+ "version": "10.1.0",
+ "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-10.1.0.tgz",
+ "integrity": "sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "graceful-fs": "^4.2.0",
+ "jsonfile": "^6.0.1",
+ "universalify": "^2.0.0"
+ },
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/dmg-builder/node_modules/jsonfile": {
+ "version": "6.2.0",
+ "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.0.tgz",
+ "integrity": "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "universalify": "^2.0.0"
+ },
+ "optionalDependencies": {
+ "graceful-fs": "^4.1.6"
+ }
+ },
+ "node_modules/dmg-builder/node_modules/universalify": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
+ "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 10.0.0"
+ }
+ },
+ "node_modules/dmg-license": {
+ "version": "1.0.11",
+ "resolved": "https://registry.npmjs.org/dmg-license/-/dmg-license-1.0.11.tgz",
+ "integrity": "sha512-ZdzmqwKmECOWJpqefloC5OJy1+WZBBse5+MR88z9g9Zn4VY+WYUkAyojmhzJckH5YbbZGcYIuGAkY5/Ys5OM2Q==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "darwin"
+ ],
+ "dependencies": {
+ "@types/plist": "^3.0.1",
+ "@types/verror": "^1.10.3",
+ "ajv": "^6.10.0",
+ "crc": "^3.8.0",
+ "iconv-corefoundation": "^1.1.7",
+ "plist": "^3.0.4",
+ "smart-buffer": "^4.0.2",
+ "verror": "^1.10.0"
+ },
+ "bin": {
+ "dmg-license": "bin/dmg-license.js"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/dom-helpers": {
+ "version": "5.2.1",
+ "resolved": "https://registry.npmjs.org/dom-helpers/-/dom-helpers-5.2.1.tgz",
+ "integrity": "sha512-nRCa7CK3VTrM2NmGkIy4cbK7IZlgBE/PYMn55rrXefr5xXDP0LdtfPnblFDoVdcAfslJ7or6iqAUnx0CCGIWQA==",
+ "license": "MIT",
+ "dependencies": {
+ "@babel/runtime": "^7.8.7",
+ "csstype": "^3.0.2"
+ }
+ },
+ "node_modules/dotenv": {
+ "version": "16.6.1",
+ "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-16.6.1.tgz",
+ "integrity": "sha512-uBq4egWHTcTt33a72vpSG0z3HnPuIl6NqYcTrKEg2azoEyl2hpW0zqlxysq2pK9HlDIHyHyakeYaYnSAwd8bow==",
+ "dev": true,
+ "license": "BSD-2-Clause",
+ "engines": {
+ "node": ">=12"
+ },
+ "funding": {
+ "url": "https://dotenvx.com"
+ }
+ },
+ "node_modules/dotenv-expand": {
+ "version": "11.0.7",
+ "resolved": "https://registry.npmjs.org/dotenv-expand/-/dotenv-expand-11.0.7.tgz",
+ "integrity": "sha512-zIHwmZPRshsCdpMDyVsqGmgyP0yT8GAgXUnkdAoJisxvf33k7yO6OuoKmcTGuXPWSsm8Oh88nZicRLA9Y0rUeA==",
+ "dev": true,
+ "license": "BSD-2-Clause",
+ "dependencies": {
+ "dotenv": "^16.4.5"
+ },
+ "engines": {
+ "node": ">=12"
+ },
+ "funding": {
+ "url": "https://dotenvx.com"
+ }
+ },
+ "node_modules/dunder-proto": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
+ "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "call-bind-apply-helpers": "^1.0.1",
+ "es-errors": "^1.3.0",
+ "gopd": "^1.2.0"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ }
+ },
+ "node_modules/eastasianwidth": {
+ "version": "0.2.0",
+ "resolved": "https://registry.npmjs.org/eastasianwidth/-/eastasianwidth-0.2.0.tgz",
+ "integrity": "sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/ejs": {
+ "version": "3.1.10",
+ "resolved": "https://registry.npmjs.org/ejs/-/ejs-3.1.10.tgz",
+ "integrity": "sha512-UeJmFfOrAQS8OJWPZ4qtgHyWExa088/MtK5UEyoJGFH67cDEXkZSviOiKRCZ4Xij0zxI3JECgYs3oKx+AizQBA==",
+ "dev": true,
+ "license": "Apache-2.0",
+ "dependencies": {
+ "jake": "^10.8.5"
+ },
+ "bin": {
+ "ejs": "bin/cli.js"
+ },
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/electron": {
+ "version": "35.7.5",
+ "resolved": "https://registry.npmjs.org/electron/-/electron-35.7.5.tgz",
+ "integrity": "sha512-dnL+JvLraKZl7iusXTVTGYs10TKfzUi30uEDTqsmTm0guN9V2tbOjTzyIZbh9n3ygUjgEYyo+igAwMRXIi3IPw==",
+ "dev": true,
+ "hasInstallScript": true,
+ "license": "MIT",
+ "dependencies": {
+ "@electron/get": "^2.0.0",
+ "@types/node": "^22.7.7",
+ "extract-zip": "^2.0.1"
+ },
+ "bin": {
+ "electron": "cli.js"
+ },
+ "engines": {
+ "node": ">= 12.20.55"
+ }
+ },
+ "node_modules/electron-builder": {
+ "version": "26.8.1",
+ "resolved": "https://registry.npmjs.org/electron-builder/-/electron-builder-26.8.1.tgz",
+ "integrity": "sha512-uWhx1r74NGpCagG0ULs/P9Nqv2nsoo+7eo4fLUOB8L8MdWltq9odW/uuLXMFCDGnPafknYLZgjNX0ZIFRzOQAw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "app-builder-lib": "26.8.1",
+ "builder-util": "26.8.1",
+ "builder-util-runtime": "9.5.1",
+ "chalk": "^4.1.2",
+ "ci-info": "^4.2.0",
+ "dmg-builder": "26.8.1",
+ "fs-extra": "^10.1.0",
+ "lazy-val": "^1.0.5",
+ "simple-update-notifier": "2.0.0",
+ "yargs": "^17.6.2"
+ },
+ "bin": {
+ "electron-builder": "cli.js",
+ "install-app-deps": "install-app-deps.js"
+ },
+ "engines": {
+ "node": ">=14.0.0"
+ }
+ },
+ "node_modules/electron-builder-squirrel-windows": {
+ "version": "26.8.1",
+ "resolved": "https://registry.npmjs.org/electron-builder-squirrel-windows/-/electron-builder-squirrel-windows-26.8.1.tgz",
+ "integrity": "sha512-o288fIdgPLHA76eDrFADHPoo7VyGkDCYbLV1GzndaMSAVBoZrGvM9m2IehdcVMzdAZJ2eV9bgyissQXHv5tGzA==",
+ "dev": true,
+ "license": "MIT",
+ "peer": true,
+ "dependencies": {
+ "app-builder-lib": "26.8.1",
+ "builder-util": "26.8.1",
+ "electron-winstaller": "5.4.0"
+ }
+ },
+ "node_modules/electron-builder/node_modules/fs-extra": {
+ "version": "10.1.0",
+ "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-10.1.0.tgz",
+ "integrity": "sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "graceful-fs": "^4.2.0",
+ "jsonfile": "^6.0.1",
+ "universalify": "^2.0.0"
+ },
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/electron-builder/node_modules/jsonfile": {
+ "version": "6.2.0",
+ "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.0.tgz",
+ "integrity": "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "universalify": "^2.0.0"
+ },
+ "optionalDependencies": {
+ "graceful-fs": "^4.1.6"
+ }
+ },
+ "node_modules/electron-builder/node_modules/universalify": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
+ "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 10.0.0"
+ }
+ },
+ "node_modules/electron-devtools-installer": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/electron-devtools-installer/-/electron-devtools-installer-4.0.0.tgz",
+ "integrity": "sha512-9Tntu/jtfSn0n6N/ZI6IdvRqXpDyLQiDuuIbsBI+dL+1Ef7C8J2JwByw58P3TJiNeuqyV3ZkphpNWuZK5iSY2w==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "unzip-crx-3": "^0.2.0"
+ }
+ },
+ "node_modules/electron-publish": {
+ "version": "26.8.1",
+ "resolved": "https://registry.npmjs.org/electron-publish/-/electron-publish-26.8.1.tgz",
+ "integrity": "sha512-q+jrSTIh/Cv4eGZa7oVR+grEJo/FoLMYBAnSL5GCtqwUpr1T+VgKB/dn1pnzxIxqD8S/jP1yilT9VrwCqINR4w==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@types/fs-extra": "^9.0.11",
+ "builder-util": "26.8.1",
+ "builder-util-runtime": "9.5.1",
+ "chalk": "^4.1.2",
+ "form-data": "^4.0.5",
+ "fs-extra": "^10.1.0",
+ "lazy-val": "^1.0.5",
+ "mime": "^2.5.2"
+ }
+ },
+ "node_modules/electron-publish/node_modules/fs-extra": {
+ "version": "10.1.0",
+ "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-10.1.0.tgz",
+ "integrity": "sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "graceful-fs": "^4.2.0",
+ "jsonfile": "^6.0.1",
+ "universalify": "^2.0.0"
+ },
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/electron-publish/node_modules/jsonfile": {
+ "version": "6.2.0",
+ "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.0.tgz",
+ "integrity": "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "universalify": "^2.0.0"
+ },
+ "optionalDependencies": {
+ "graceful-fs": "^4.1.6"
+ }
+ },
+ "node_modules/electron-publish/node_modules/universalify": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
+ "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 10.0.0"
+ }
+ },
+ "node_modules/electron-to-chromium": {
+ "version": "1.5.330",
+ "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.330.tgz",
+ "integrity": "sha512-jFNydB5kFtYUobh4IkWUnXeyDbjf/r9gcUEXe1xcrcUxIGfTdzPXA+ld6zBRbwvgIGVzDll/LTIiDztEtckSnA==",
+ "dev": true,
+ "license": "ISC"
+ },
+ "node_modules/electron-updater": {
+ "version": "6.8.3",
+ "resolved": "https://registry.npmjs.org/electron-updater/-/electron-updater-6.8.3.tgz",
+ "integrity": "sha512-Z6sgw3jgbikWKXei1ENdqFOxBP0WlXg3TtKfz0rgw2vIZFJUyI4pD7ZN7jrkm7EoMK+tcm/qTnPUdqfZukBlBQ==",
+ "license": "MIT",
+ "dependencies": {
+ "builder-util-runtime": "9.5.1",
+ "fs-extra": "^10.1.0",
+ "js-yaml": "^4.1.0",
+ "lazy-val": "^1.0.5",
+ "lodash.escaperegexp": "^4.1.2",
+ "lodash.isequal": "^4.5.0",
+ "semver": "~7.7.3",
+ "tiny-typed-emitter": "^2.1.0"
+ }
+ },
+ "node_modules/electron-updater/node_modules/fs-extra": {
+ "version": "10.1.0",
+ "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-10.1.0.tgz",
+ "integrity": "sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==",
+ "license": "MIT",
+ "dependencies": {
+ "graceful-fs": "^4.2.0",
+ "jsonfile": "^6.0.1",
+ "universalify": "^2.0.0"
+ },
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/electron-updater/node_modules/jsonfile": {
+ "version": "6.2.0",
+ "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.0.tgz",
+ "integrity": "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg==",
+ "license": "MIT",
+ "dependencies": {
+ "universalify": "^2.0.0"
+ },
+ "optionalDependencies": {
+ "graceful-fs": "^4.1.6"
+ }
+ },
+ "node_modules/electron-updater/node_modules/semver": {
+ "version": "7.7.4",
+ "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz",
+ "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==",
+ "license": "ISC",
+ "bin": {
+ "semver": "bin/semver.js"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/electron-updater/node_modules/universalify": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
+ "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
+ "license": "MIT",
+ "engines": {
+ "node": ">= 10.0.0"
+ }
+ },
+ "node_modules/electron-winstaller": {
+ "version": "5.4.0",
+ "resolved": "https://registry.npmjs.org/electron-winstaller/-/electron-winstaller-5.4.0.tgz",
+ "integrity": "sha512-bO3y10YikuUwUuDUQRM4KfwNkKhnpVO7IPdbsrejwN9/AABJzzTQ4GeHwyzNSrVO+tEH3/Np255a3sVZpZDjvg==",
+ "dev": true,
+ "hasInstallScript": true,
+ "license": "MIT",
+ "peer": true,
+ "dependencies": {
+ "@electron/asar": "^3.2.1",
+ "debug": "^4.1.1",
+ "fs-extra": "^7.0.1",
+ "lodash": "^4.17.21",
+ "temp": "^0.9.0"
+ },
+ "engines": {
+ "node": ">=8.0.0"
+ },
+ "optionalDependencies": {
+ "@electron/windows-sign": "^1.1.2"
+ }
+ },
+ "node_modules/electron-winstaller/node_modules/fs-extra": {
+ "version": "7.0.1",
+ "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-7.0.1.tgz",
+ "integrity": "sha512-YJDaCJZEnBmcbw13fvdAM9AwNOJwOzrE4pqMqBq5nFiEqXUqHwlK4B+3pUw6JNvfSPtX05xFHtYy/1ni01eGCw==",
+ "dev": true,
+ "license": "MIT",
+ "peer": true,
+ "dependencies": {
+ "graceful-fs": "^4.1.2",
+ "jsonfile": "^4.0.0",
+ "universalify": "^0.1.0"
+ },
+ "engines": {
+ "node": ">=6 <7 || >=8"
+ }
+ },
+ "node_modules/emoji-regex": {
+ "version": "8.0.0",
+ "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+ "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/encoding": {
+ "version": "0.1.13",
+ "resolved": "https://registry.npmjs.org/encoding/-/encoding-0.1.13.tgz",
+ "integrity": "sha512-ETBauow1T35Y/WZMkio9jiM0Z5xjHHmJ4XmjZOq1l/dXz3lr2sRn87nJy20RupqSh1F2m3HHPSp8ShIPQJrJ3A==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "dependencies": {
+ "iconv-lite": "^0.6.2"
+ }
+ },
+ "node_modules/end-of-stream": {
+ "version": "1.4.5",
+ "resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.5.tgz",
+ "integrity": "sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "once": "^1.4.0"
+ }
+ },
+ "node_modules/env-paths": {
+ "version": "2.2.1",
+ "resolved": "https://registry.npmjs.org/env-paths/-/env-paths-2.2.1.tgz",
+ "integrity": "sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=6"
+ }
+ },
+ "node_modules/err-code": {
+ "version": "2.0.3",
+ "resolved": "https://registry.npmjs.org/err-code/-/err-code-2.0.3.tgz",
+ "integrity": "sha512-2bmlRpNKBxT/CRmPOlyISQpNj+qSeYvcym/uT0Jx2bMOlKLtSy1ZmLuVxSEKKyor/N5yhvp/ZiG1oE3DEYMSFA==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/error-ex": {
+ "version": "1.3.4",
+ "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.4.tgz",
+ "integrity": "sha512-sqQamAnR14VgCr1A618A3sGrygcpK+HEbenA/HiEAkkUwcZIIB/tgWqHFxWgOyDh4nB4JCRimh79dR5Ywc9MDQ==",
+ "license": "MIT",
+ "dependencies": {
+ "is-arrayish": "^0.2.1"
+ }
+ },
+ "node_modules/es-define-property": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
+ "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.4"
+ }
+ },
+ "node_modules/es-errors": {
+ "version": "1.3.0",
+ "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
+ "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.4"
+ }
+ },
+ "node_modules/es-object-atoms": {
+ "version": "1.1.1",
+ "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz",
+ "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "es-errors": "^1.3.0"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ }
+ },
+ "node_modules/es-set-tostringtag": {
+ "version": "2.1.0",
+ "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz",
+ "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "es-errors": "^1.3.0",
+ "get-intrinsic": "^1.2.6",
+ "has-tostringtag": "^1.0.2",
+ "hasown": "^2.0.2"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ }
+ },
+ "node_modules/es6-error": {
+ "version": "4.1.1",
+ "resolved": "https://registry.npmjs.org/es6-error/-/es6-error-4.1.1.tgz",
+ "integrity": "sha512-Um/+FxMr9CISWh0bi5Zv0iOD+4cFh5qLeks1qhAopKVAJw3drgKbKySikp7wGhDL0HPeaja0P5ULZrxLkniUVg==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true
+ },
+ "node_modules/esbuild": {
+ "version": "0.27.4",
+ "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.27.4.tgz",
+ "integrity": "sha512-Rq4vbHnYkK5fws5NF7MYTU68FPRE1ajX7heQ/8QXXWqNgqqJ/GkmmyxIzUnf2Sr/bakf8l54716CcMGHYhMrrQ==",
+ "dev": true,
+ "hasInstallScript": true,
+ "license": "MIT",
+ "bin": {
+ "esbuild": "bin/esbuild"
+ },
+ "engines": {
+ "node": ">=18"
+ },
+ "optionalDependencies": {
+ "@esbuild/aix-ppc64": "0.27.4",
+ "@esbuild/android-arm": "0.27.4",
+ "@esbuild/android-arm64": "0.27.4",
+ "@esbuild/android-x64": "0.27.4",
+ "@esbuild/darwin-arm64": "0.27.4",
+ "@esbuild/darwin-x64": "0.27.4",
+ "@esbuild/freebsd-arm64": "0.27.4",
+ "@esbuild/freebsd-x64": "0.27.4",
+ "@esbuild/linux-arm": "0.27.4",
+ "@esbuild/linux-arm64": "0.27.4",
+ "@esbuild/linux-ia32": "0.27.4",
+ "@esbuild/linux-loong64": "0.27.4",
+ "@esbuild/linux-mips64el": "0.27.4",
+ "@esbuild/linux-ppc64": "0.27.4",
+ "@esbuild/linux-riscv64": "0.27.4",
+ "@esbuild/linux-s390x": "0.27.4",
+ "@esbuild/linux-x64": "0.27.4",
+ "@esbuild/netbsd-arm64": "0.27.4",
+ "@esbuild/netbsd-x64": "0.27.4",
+ "@esbuild/openbsd-arm64": "0.27.4",
+ "@esbuild/openbsd-x64": "0.27.4",
+ "@esbuild/openharmony-arm64": "0.27.4",
+ "@esbuild/sunos-x64": "0.27.4",
+ "@esbuild/win32-arm64": "0.27.4",
+ "@esbuild/win32-ia32": "0.27.4",
+ "@esbuild/win32-x64": "0.27.4"
+ }
+ },
+ "node_modules/escalade": {
+ "version": "3.2.0",
+ "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+ "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=6"
+ }
+ },
+ "node_modules/escape-string-regexp": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
+ "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==",
+ "license": "MIT",
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/exponential-backoff": {
+ "version": "3.1.3",
+ "resolved": "https://registry.npmjs.org/exponential-backoff/-/exponential-backoff-3.1.3.tgz",
+ "integrity": "sha512-ZgEeZXj30q+I0EN+CbSSpIyPaJ5HVQD18Z1m+u1FXbAeT94mr1zw50q4q6jiiC447Nl/YTcIYSAftiGqetwXCA==",
+ "dev": true,
+ "license": "Apache-2.0"
+ },
+ "node_modules/extract-zip": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/extract-zip/-/extract-zip-2.0.1.tgz",
+ "integrity": "sha512-GDhU9ntwuKyGXdZBUgTIe+vXnWj0fppUEtMDL0+idd5Sta8TGpHssn/eusA9mrPr9qNDym6SxAYZjNvCn/9RBg==",
+ "dev": true,
+ "license": "BSD-2-Clause",
+ "dependencies": {
+ "debug": "^4.1.1",
+ "get-stream": "^5.1.0",
+ "yauzl": "^2.10.0"
+ },
+ "bin": {
+ "extract-zip": "cli.js"
+ },
+ "engines": {
+ "node": ">= 10.17.0"
+ },
+ "optionalDependencies": {
+ "@types/yauzl": "^2.9.1"
+ }
+ },
+ "node_modules/extsprintf": {
+ "version": "1.4.1",
+ "resolved": "https://registry.npmjs.org/extsprintf/-/extsprintf-1.4.1.tgz",
+ "integrity": "sha512-Wrk35e8ydCKDj/ArClo1VrPVmN8zph5V4AtHwIuHhvMXsKf73UT3BOD+azBIW+3wOJ4FhEH7zyaJCFvChjYvMA==",
+ "dev": true,
+ "engines": [
+ "node >=0.6.0"
+ ],
+ "license": "MIT",
+ "optional": true
+ },
+ "node_modules/fast-deep-equal": {
+ "version": "3.1.3",
+ "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
+ "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/fast-equals": {
+ "version": "4.0.3",
+ "resolved": "https://registry.npmjs.org/fast-equals/-/fast-equals-4.0.3.tgz",
+ "integrity": "sha512-G3BSX9cfKttjr+2o1O22tYMLq0DPluZnYtq1rXumE1SpL/F/SLIfHx08WYQoWSIpeMYf8sRbJ8++71+v6Pnxfg==",
+ "license": "MIT"
+ },
+ "node_modules/fast-json-stable-stringify": {
+ "version": "2.1.0",
+ "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz",
+ "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/fd-slicer": {
+ "version": "1.1.0",
+ "resolved": "https://registry.npmjs.org/fd-slicer/-/fd-slicer-1.1.0.tgz",
+ "integrity": "sha512-cE1qsB/VwyQozZ+q1dGxR8LBYNZeofhEdUNGSMbQD3Gw2lAzX9Zb3uIU6Ebc/Fmyjo9AWWfnn0AUCHqtevs/8g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "pend": "~1.2.0"
+ }
+ },
+ "node_modules/fdir": {
+ "version": "6.5.0",
+ "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
+ "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=12.0.0"
+ },
+ "peerDependencies": {
+ "picomatch": "^3 || ^4"
+ },
+ "peerDependenciesMeta": {
+ "picomatch": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/filelist": {
+ "version": "1.0.6",
+ "resolved": "https://registry.npmjs.org/filelist/-/filelist-1.0.6.tgz",
+ "integrity": "sha512-5giy2PkLYY1cP39p17Ech+2xlpTRL9HLspOfEgm0L6CwBXBTgsK5ou0JtzYuepxkaQ/tvhCFIJ5uXo0OrM2DxA==",
+ "dev": true,
+ "license": "Apache-2.0",
+ "dependencies": {
+ "minimatch": "^5.0.1"
+ }
+ },
+ "node_modules/filelist/node_modules/balanced-match": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+ "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/filelist/node_modules/brace-expansion": {
+ "version": "2.0.3",
+ "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.3.tgz",
+ "integrity": "sha512-MCV/fYJEbqx68aE58kv2cA/kiky1G8vux3OR6/jbS+jIMe/6fJWa0DTzJU7dqijOWYwHi1t29FlfYI9uytqlpA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "balanced-match": "^1.0.0"
+ }
+ },
+ "node_modules/filelist/node_modules/minimatch": {
+ "version": "5.1.9",
+ "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.9.tgz",
+ "integrity": "sha512-7o1wEA2RyMP7Iu7GNba9vc0RWWGACJOCZBJX2GJWip0ikV+wcOsgVuY9uE8CPiyQhkGFSlhuSkZPavN7u1c2Fw==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "brace-expansion": "^2.0.1"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/find-root": {
+ "version": "1.1.0",
+ "resolved": "https://registry.npmjs.org/find-root/-/find-root-1.1.0.tgz",
+ "integrity": "sha512-NKfW6bec6GfKc0SGx1e07QZY9PE99u0Bft/0rzSD5k3sO/vwkVUpDUKVm5Gpp5Ue3YfShPFTX2070tDs5kB9Ng==",
+ "license": "MIT"
+ },
+ "node_modules/foreground-child": {
+ "version": "3.3.1",
+ "resolved": "https://registry.npmjs.org/foreground-child/-/foreground-child-3.3.1.tgz",
+ "integrity": "sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "cross-spawn": "^7.0.6",
+ "signal-exit": "^4.0.1"
+ },
+ "engines": {
+ "node": ">=14"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/isaacs"
+ }
+ },
+ "node_modules/foreground-child/node_modules/signal-exit": {
+ "version": "4.1.0",
+ "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz",
+ "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==",
+ "dev": true,
+ "license": "ISC",
+ "engines": {
+ "node": ">=14"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/isaacs"
+ }
+ },
+ "node_modules/form-data": {
+ "version": "4.0.5",
+ "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.5.tgz",
+ "integrity": "sha512-8RipRLol37bNs2bhoV67fiTEvdTrbMUYcFTiy3+wuuOnUog2QBHCZWXDRijWQfAkhBj2Uf5UnVaiWwA5vdd82w==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "asynckit": "^0.4.0",
+ "combined-stream": "^1.0.8",
+ "es-set-tostringtag": "^2.1.0",
+ "hasown": "^2.0.2",
+ "mime-types": "^2.1.12"
+ },
+ "engines": {
+ "node": ">= 6"
+ }
+ },
+ "node_modules/fs-extra": {
+ "version": "8.1.0",
+ "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-8.1.0.tgz",
+ "integrity": "sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "graceful-fs": "^4.2.0",
+ "jsonfile": "^4.0.0",
+ "universalify": "^0.1.0"
+ },
+ "engines": {
+ "node": ">=6 <7 || >=8"
+ }
+ },
+ "node_modules/fs-minipass": {
+ "version": "3.0.3",
+ "resolved": "https://registry.npmjs.org/fs-minipass/-/fs-minipass-3.0.3.tgz",
+ "integrity": "sha512-XUBA9XClHbnJWSfBzjkm6RvPsyg3sryZt06BEQoXcF7EK/xpGaQYJgQKDJSUH5SGZ76Y7pFx1QBnXz09rU5Fbw==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "minipass": "^7.0.3"
+ },
+ "engines": {
+ "node": "^14.17.0 || ^16.13.0 || >=18.0.0"
+ }
+ },
+ "node_modules/fs.realpath": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
+ "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==",
+ "dev": true,
+ "license": "ISC"
+ },
+ "node_modules/fsevents": {
+ "version": "2.3.2",
+ "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz",
+ "integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==",
+ "dev": true,
+ "hasInstallScript": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "darwin"
+ ],
+ "engines": {
+ "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+ }
+ },
+ "node_modules/function-bind": {
+ "version": "1.1.2",
+ "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
+ "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
+ "license": "MIT",
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/gensync": {
+ "version": "1.0.0-beta.2",
+ "resolved": "https://registry.npmjs.org/gensync/-/gensync-1.0.0-beta.2.tgz",
+ "integrity": "sha512-3hN7NaskYvMDLQY55gnW3NQ+mesEAepTqlg+VEbj7zzqEMBVNhzcGYYeqFo/TlYz6eQiFcp1HcsCZO+nGgS8zg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=6.9.0"
+ }
+ },
+ "node_modules/get-caller-file": {
+ "version": "2.0.5",
+ "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz",
+ "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==",
+ "dev": true,
+ "license": "ISC",
+ "engines": {
+ "node": "6.* || 8.* || >= 10.*"
+ }
+ },
+ "node_modules/get-intrinsic": {
+ "version": "1.3.0",
+ "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
+ "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "call-bind-apply-helpers": "^1.0.2",
+ "es-define-property": "^1.0.1",
+ "es-errors": "^1.3.0",
+ "es-object-atoms": "^1.1.1",
+ "function-bind": "^1.1.2",
+ "get-proto": "^1.0.1",
+ "gopd": "^1.2.0",
+ "has-symbols": "^1.1.0",
+ "hasown": "^2.0.2",
+ "math-intrinsics": "^1.1.0"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/get-proto": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
+ "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "dunder-proto": "^1.0.1",
+ "es-object-atoms": "^1.0.0"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ }
+ },
+ "node_modules/get-stream": {
+ "version": "5.2.0",
+ "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-5.2.0.tgz",
+ "integrity": "sha512-nBF+F1rAZVCu/p7rjzgA+Yb4lfYXrpl7a6VmJrU8wF9I1CKvP/QwPNZHnOlwbTkY6dvtFIzFMSyQXbLoTQPRpA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "pump": "^3.0.0"
+ },
+ "engines": {
+ "node": ">=8"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/glob": {
+ "version": "7.2.3",
+ "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz",
+ "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==",
+ "deprecated": "Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting [email protected]",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "fs.realpath": "^1.0.0",
+ "inflight": "^1.0.4",
+ "inherits": "2",
+ "minimatch": "^3.1.1",
+ "once": "^1.3.0",
+ "path-is-absolute": "^1.0.0"
+ },
+ "engines": {
+ "node": "*"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/isaacs"
+ }
+ },
+ "node_modules/glob/node_modules/balanced-match": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+ "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/glob/node_modules/brace-expansion": {
+ "version": "1.1.13",
+ "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.13.tgz",
+ "integrity": "sha512-9ZLprWS6EENmhEOpjCYW2c8VkmOvckIJZfkr7rBW6dObmfgJ/L1GpSYW5Hpo9lDz4D1+n0Ckz8rU7FwHDQiG/w==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "balanced-match": "^1.0.0",
+ "concat-map": "0.0.1"
+ }
+ },
+ "node_modules/glob/node_modules/minimatch": {
+ "version": "3.1.5",
+ "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz",
+ "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "brace-expansion": "^1.1.7"
+ },
+ "engines": {
+ "node": "*"
+ }
+ },
+ "node_modules/global-agent": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/global-agent/-/global-agent-3.0.0.tgz",
+ "integrity": "sha512-PT6XReJ+D07JvGoxQMkT6qji/jVNfX/h364XHZOWeRzy64sSFr+xJ5OX7LI3b4MPQzdL4H8Y8M0xzPpsVMwA8Q==",
+ "dev": true,
+ "license": "BSD-3-Clause",
+ "optional": true,
+ "dependencies": {
+ "boolean": "^3.0.1",
+ "es6-error": "^4.1.1",
+ "matcher": "^3.0.0",
+ "roarr": "^2.15.3",
+ "semver": "^7.3.2",
+ "serialize-error": "^7.0.1"
+ },
+ "engines": {
+ "node": ">=10.0"
+ }
+ },
+ "node_modules/global-agent/node_modules/semver": {
+ "version": "7.7.4",
+ "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz",
+ "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==",
+ "dev": true,
+ "license": "ISC",
+ "optional": true,
+ "bin": {
+ "semver": "bin/semver.js"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/globalthis": {
+ "version": "1.0.4",
+ "resolved": "https://registry.npmjs.org/globalthis/-/globalthis-1.0.4.tgz",
+ "integrity": "sha512-DpLKbNU4WylpxJykQujfCcwYWiV/Jhm50Goo0wrVILAv5jOr9d+H+UR3PhSCD2rCCEIg0uc+G+muBTwD54JhDQ==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "dependencies": {
+ "define-properties": "^1.2.1",
+ "gopd": "^1.0.1"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/gopd": {
+ "version": "1.2.0",
+ "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
+ "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.4"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/got": {
+ "version": "11.8.6",
+ "resolved": "https://registry.npmjs.org/got/-/got-11.8.6.tgz",
+ "integrity": "sha512-6tfZ91bOr7bOXnK7PRDCGBLa1H4U080YHNaAQ2KsMGlLEzRbk44nsZF2E1IeRc3vtJHPVbKCYgdFbaGO2ljd8g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@sindresorhus/is": "^4.0.0",
+ "@szmarczak/http-timer": "^4.0.5",
+ "@types/cacheable-request": "^6.0.1",
+ "@types/responselike": "^1.0.0",
+ "cacheable-lookup": "^5.0.3",
+ "cacheable-request": "^7.0.2",
+ "decompress-response": "^6.0.0",
+ "http2-wrapper": "^1.0.0-beta.5.2",
+ "lowercase-keys": "^2.0.0",
+ "p-cancelable": "^2.0.0",
+ "responselike": "^2.0.0"
+ },
+ "engines": {
+ "node": ">=10.19.0"
+ },
+ "funding": {
+ "url": "https://github.com/sindresorhus/got?sponsor=1"
+ }
+ },
+ "node_modules/graceful-fs": {
+ "version": "4.2.11",
+ "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz",
+ "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==",
+ "license": "ISC"
+ },
+ "node_modules/has-flag": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
+ "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/has-property-descriptors": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.2.tgz",
+ "integrity": "sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "dependencies": {
+ "es-define-property": "^1.0.0"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/has-symbols": {
+ "version": "1.1.0",
+ "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
+ "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.4"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/has-tostringtag": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz",
+ "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "has-symbols": "^1.0.3"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/hasown": {
+ "version": "2.0.2",
+ "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz",
+ "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==",
+ "license": "MIT",
+ "dependencies": {
+ "function-bind": "^1.1.2"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ }
+ },
+ "node_modules/hoist-non-react-statics": {
+ "version": "3.3.2",
+ "resolved": "https://registry.npmjs.org/hoist-non-react-statics/-/hoist-non-react-statics-3.3.2.tgz",
+ "integrity": "sha512-/gGivxi8JPKWNm/W0jSmzcMPpfpPLc3dY/6GxhX2hQ9iGj3aDfklV4ET7NjKpSinLpJ5vafa9iiGIEZg10SfBw==",
+ "license": "BSD-3-Clause",
+ "dependencies": {
+ "react-is": "^16.7.0"
+ }
+ },
+ "node_modules/hoist-non-react-statics/node_modules/react-is": {
+ "version": "16.13.1",
+ "resolved": "https://registry.npmjs.org/react-is/-/react-is-16.13.1.tgz",
+ "integrity": "sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==",
+ "license": "MIT"
+ },
+ "node_modules/hosted-git-info": {
+ "version": "4.1.0",
+ "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-4.1.0.tgz",
+ "integrity": "sha512-kyCuEOWjJqZuDbRHzL8V93NzQhwIB71oFWSyzVo+KPZI+pnQPPxucdkrOZvkLRnrf5URsQM+IJ09Dw29cRALIA==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "lru-cache": "^6.0.0"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/hosted-git-info/node_modules/lru-cache": {
+ "version": "6.0.0",
+ "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz",
+ "integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "yallist": "^4.0.0"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/hosted-git-info/node_modules/yallist": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz",
+ "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==",
+ "dev": true,
+ "license": "ISC"
+ },
+ "node_modules/html-parse-stringify": {
+ "version": "3.0.1",
+ "resolved": "https://registry.npmjs.org/html-parse-stringify/-/html-parse-stringify-3.0.1.tgz",
+ "integrity": "sha512-KknJ50kTInJ7qIScF3jeaFRpMpE8/lfiTdzf/twXyPBLAGrLRTmkz3AdTnKeh40X8k9L2fdYwEp/42WGXIRGcg==",
+ "license": "MIT",
+ "dependencies": {
+ "void-elements": "3.1.0"
+ }
+ },
+ "node_modules/http-cache-semantics": {
+ "version": "4.2.0",
+ "resolved": "https://registry.npmjs.org/http-cache-semantics/-/http-cache-semantics-4.2.0.tgz",
+ "integrity": "sha512-dTxcvPXqPvXBQpq5dUr6mEMJX4oIEFv6bwom3FDwKRDsuIjjJGANqhBuoAn9c1RQJIdAKav33ED65E2ys+87QQ==",
+ "dev": true,
+ "license": "BSD-2-Clause"
+ },
+ "node_modules/http-proxy-agent": {
+ "version": "7.0.2",
+ "resolved": "https://registry.npmjs.org/http-proxy-agent/-/http-proxy-agent-7.0.2.tgz",
+ "integrity": "sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "agent-base": "^7.1.0",
+ "debug": "^4.3.4"
+ },
+ "engines": {
+ "node": ">= 14"
+ }
+ },
+ "node_modules/http2-wrapper": {
+ "version": "1.0.3",
+ "resolved": "https://registry.npmjs.org/http2-wrapper/-/http2-wrapper-1.0.3.tgz",
+ "integrity": "sha512-V+23sDMr12Wnz7iTcDeJr3O6AIxlnvT/bmaAAAP/Xda35C90p9599p0F1eHR/N1KILWSoWVAiOMFjBBXaXSMxg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "quick-lru": "^5.1.1",
+ "resolve-alpn": "^1.0.0"
+ },
+ "engines": {
+ "node": ">=10.19.0"
+ }
+ },
+ "node_modules/https-proxy-agent": {
+ "version": "7.0.6",
+ "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz",
+ "integrity": "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "agent-base": "^7.1.2",
+ "debug": "4"
+ },
+ "engines": {
+ "node": ">= 14"
+ }
+ },
+ "node_modules/i18next": {
+ "version": "26.0.3",
+ "resolved": "https://registry.npmjs.org/i18next/-/i18next-26.0.3.tgz",
+ "integrity": "sha512-1571kXINxHKY7LksWp8wP+zP0YqHSSpl/OW0Y0owFEf2H3s8gCAffWaZivcz14rMkOvn3R/psiQxVsR9t2Nafg==",
+ "funding": [
+ {
+ "type": "individual",
+ "url": "https://www.locize.com/i18next"
+ },
+ {
+ "type": "individual",
+ "url": "https://www.i18next.com/how-to/faq#i18next-is-awesome.-how-can-i-support-the-project"
+ },
+ {
+ "type": "individual",
+ "url": "https://www.locize.com"
+ }
+ ],
+ "license": "MIT",
+ "peer": true,
+ "dependencies": {
+ "@babel/runtime": "^7.29.2"
+ },
+ "peerDependencies": {
+ "typescript": "^5 || ^6"
+ },
+ "peerDependenciesMeta": {
+ "typescript": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/i18next-browser-languagedetector": {
+ "version": "8.2.1",
+ "resolved": "https://registry.npmjs.org/i18next-browser-languagedetector/-/i18next-browser-languagedetector-8.2.1.tgz",
+ "integrity": "sha512-bZg8+4bdmaOiApD7N7BPT9W8MLZG+nPTOFlLiJiT8uzKXFjhxw4v2ierCXOwB5sFDMtuA5G4kgYZ0AznZxQ/cw==",
+ "license": "MIT",
+ "dependencies": {
+ "@babel/runtime": "^7.23.2"
+ }
+ },
+ "node_modules/iconv-corefoundation": {
+ "version": "1.1.7",
+ "resolved": "https://registry.npmjs.org/iconv-corefoundation/-/iconv-corefoundation-1.1.7.tgz",
+ "integrity": "sha512-T10qvkw0zz4wnm560lOEg0PovVqUXuOFhhHAkixw8/sycy7TJt7v/RrkEKEQnAw2viPSJu6iAkErxnzR0g8PpQ==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "darwin"
+ ],
+ "dependencies": {
+ "cli-truncate": "^2.1.0",
+ "node-addon-api": "^1.6.3"
+ },
+ "engines": {
+ "node": "^8.11.2 || >=10"
+ }
+ },
+ "node_modules/iconv-lite": {
+ "version": "0.6.3",
+ "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz",
+ "integrity": "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==",
+ "license": "MIT",
+ "dependencies": {
+ "safer-buffer": ">= 2.1.2 < 3.0.0"
+ },
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/ieee754": {
+ "version": "1.2.1",
+ "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz",
+ "integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==",
+ "dev": true,
+ "funding": [
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/feross"
+ },
+ {
+ "type": "patreon",
+ "url": "https://www.patreon.com/feross"
+ },
+ {
+ "type": "consulting",
+ "url": "https://feross.org/support"
+ }
+ ],
+ "license": "BSD-3-Clause"
+ },
+ "node_modules/immediate": {
+ "version": "3.0.6",
+ "resolved": "https://registry.npmjs.org/immediate/-/immediate-3.0.6.tgz",
+ "integrity": "sha512-XXOFtyqDjNDAQxVfYxuF7g9Il/IbWmmlQg2MYKOH8ExIT1qg6xc4zyS3HaEEATgs1btfzxq15ciUiY7gjSXRGQ==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/immer": {
+ "version": "11.1.4",
+ "resolved": "https://registry.npmjs.org/immer/-/immer-11.1.4.tgz",
+ "integrity": "sha512-XREFCPo6ksxVzP4E0ekD5aMdf8WMwmdNaz6vuvxgI40UaEiu6q3p8X52aU6GdyvLY3XXX/8R7JOTXStz/nBbRw==",
+ "license": "MIT",
+ "funding": {
+ "type": "opencollective",
+ "url": "https://opencollective.com/immer"
+ }
+ },
+ "node_modules/import-fresh": {
+ "version": "3.3.1",
+ "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.1.tgz",
+ "integrity": "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==",
+ "license": "MIT",
+ "dependencies": {
+ "parent-module": "^1.0.0",
+ "resolve-from": "^4.0.0"
+ },
+ "engines": {
+ "node": ">=6"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/imurmurhash": {
+ "version": "0.1.4",
+ "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz",
+ "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=0.8.19"
+ }
+ },
+ "node_modules/inflight": {
+ "version": "1.0.6",
+ "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
+ "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==",
+ "deprecated": "This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful.",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "once": "^1.3.0",
+ "wrappy": "1"
+ }
+ },
+ "node_modules/inherits": {
+ "version": "2.0.4",
+ "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+ "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
+ "dev": true,
+ "license": "ISC"
+ },
+ "node_modules/internmap": {
+ "version": "2.0.3",
+ "resolved": "https://registry.npmjs.org/internmap/-/internmap-2.0.3.tgz",
+ "integrity": "sha512-5Hh7Y1wQbvY5ooGgPbDaL5iYLAPzMTUrjMulskHLH6wnv/A+1q5rgEaiuqEjB+oxGXIVZs1FF+R/KPN3ZSQYYg==",
+ "license": "ISC",
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/ip-address": {
+ "version": "10.1.0",
+ "resolved": "https://registry.npmjs.org/ip-address/-/ip-address-10.1.0.tgz",
+ "integrity": "sha512-XXADHxXmvT9+CRxhXg56LJovE+bmWnEWB78LB83VZTprKTmaC5QfruXocxzTZ2Kl0DNwKuBdlIhjL8LeY8Sf8Q==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 12"
+ }
+ },
+ "node_modules/is-arrayish": {
+ "version": "0.2.1",
+ "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz",
+ "integrity": "sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==",
+ "license": "MIT"
+ },
+ "node_modules/is-core-module": {
+ "version": "2.16.1",
+ "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.16.1.tgz",
+ "integrity": "sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w==",
+ "license": "MIT",
+ "dependencies": {
+ "hasown": "^2.0.2"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/is-fullwidth-code-point": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
+ "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/is-interactive": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/is-interactive/-/is-interactive-1.0.0.tgz",
+ "integrity": "sha512-2HvIEKRoqS62guEC+qBjpvRubdX910WCMuJTZ+I9yvqKU2/12eSL549HMwtabb4oupdj2sMP50k+XJfB/8JE6w==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/is-unicode-supported": {
+ "version": "0.1.0",
+ "resolved": "https://registry.npmjs.org/is-unicode-supported/-/is-unicode-supported-0.1.0.tgz",
+ "integrity": "sha512-knxG2q4UC3u8stRGyAVJCOdxFmv5DZiRcdlIaAQXAbSfJya+OhopNotLQrstBhququ4ZpuKbDc/8S6mgXgPFPw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/is-what": {
+ "version": "5.5.0",
+ "resolved": "https://registry.npmjs.org/is-what/-/is-what-5.5.0.tgz",
+ "integrity": "sha512-oG7cgbmg5kLYae2N5IVd3jm2s+vldjxJzK1pcu9LfpGuQ93MQSzo0okvRna+7y5ifrD+20FE8FvjusyGaz14fw==",
+ "license": "MIT",
+ "engines": {
+ "node": ">=18"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/mesqueeb"
+ }
+ },
+ "node_modules/isarray": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz",
+ "integrity": "sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/isbinaryfile": {
+ "version": "5.0.7",
+ "resolved": "https://registry.npmjs.org/isbinaryfile/-/isbinaryfile-5.0.7.tgz",
+ "integrity": "sha512-gnWD14Jh3FzS3CPhF0AxNOJ8CxqeblPTADzI38r0wt8ZyQl5edpy75myt08EG2oKvpyiqSqsx+Wkz9vtkbTqYQ==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 18.0.0"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/gjtorikian/"
+ }
+ },
+ "node_modules/isexe": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
+ "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
+ "dev": true,
+ "license": "ISC"
+ },
+ "node_modules/jackspeak": {
+ "version": "3.4.3",
+ "resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-3.4.3.tgz",
+ "integrity": "sha512-OGlZQpz2yfahA/Rd1Y8Cd9SIEsqvXkLVoSw/cgwhnhFMDbsQFeZYoJJ7bIZBS9BcamUW96asq/npPWugM+RQBw==",
+ "dev": true,
+ "license": "BlueOak-1.0.0",
+ "dependencies": {
+ "@isaacs/cliui": "^8.0.2"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/isaacs"
+ },
+ "optionalDependencies": {
+ "@pkgjs/parseargs": "^0.11.0"
+ }
+ },
+ "node_modules/jake": {
+ "version": "10.9.4",
+ "resolved": "https://registry.npmjs.org/jake/-/jake-10.9.4.tgz",
+ "integrity": "sha512-wpHYzhxiVQL+IV05BLE2Xn34zW1S223hvjtqk0+gsPrwd/8JNLXJgZZM/iPFsYc1xyphF+6M6EvdE5E9MBGkDA==",
+ "dev": true,
+ "license": "Apache-2.0",
+ "dependencies": {
+ "async": "^3.2.6",
+ "filelist": "^1.0.4",
+ "picocolors": "^1.1.1"
+ },
+ "bin": {
+ "jake": "bin/cli.js"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/jiti": {
+ "version": "2.6.1",
+ "resolved": "https://registry.npmjs.org/jiti/-/jiti-2.6.1.tgz",
+ "integrity": "sha512-ekilCSN1jwRvIbgeg/57YFh8qQDNbwDb9xT/qu2DAHbFFZUicIl4ygVaAvzveMhMVr3LnpSKTNnwt8PoOfmKhQ==",
+ "dev": true,
+ "license": "MIT",
+ "bin": {
+ "jiti": "lib/jiti-cli.mjs"
+ }
+ },
+ "node_modules/js-tokens": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
+ "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
+ "license": "MIT"
+ },
+ "node_modules/js-yaml": {
+ "version": "4.1.1",
+ "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz",
+ "integrity": "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==",
+ "license": "MIT",
+ "dependencies": {
+ "argparse": "^2.0.1"
+ },
+ "bin": {
+ "js-yaml": "bin/js-yaml.js"
+ }
+ },
+ "node_modules/jsesc": {
+ "version": "3.1.0",
+ "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz",
+ "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==",
+ "license": "MIT",
+ "bin": {
+ "jsesc": "bin/jsesc"
+ },
+ "engines": {
+ "node": ">=6"
+ }
+ },
+ "node_modules/json-buffer": {
+ "version": "3.0.1",
+ "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz",
+ "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/json-parse-even-better-errors": {
+ "version": "2.3.1",
+ "resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz",
+ "integrity": "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==",
+ "license": "MIT"
+ },
+ "node_modules/json-schema-traverse": {
+ "version": "0.4.1",
+ "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
+ "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/json-stringify-safe": {
+ "version": "5.0.1",
+ "resolved": "https://registry.npmjs.org/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz",
+ "integrity": "sha512-ZClg6AaYvamvYEE82d3Iyd3vSSIjQ+odgjaTzRuO3s7toCdFKczob2i0zCh7JE8kWn17yvAWhUVxvqGwUalsRA==",
+ "dev": true,
+ "license": "ISC",
+ "optional": true
+ },
+ "node_modules/json5": {
+ "version": "2.2.3",
+ "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz",
+ "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==",
+ "dev": true,
+ "license": "MIT",
+ "bin": {
+ "json5": "lib/cli.js"
+ },
+ "engines": {
+ "node": ">=6"
+ }
+ },
+ "node_modules/jsonfile": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-4.0.0.tgz",
+ "integrity": "sha512-m6F1R3z8jjlf2imQHS2Qez5sjKWQzbuuhuJ/FKYFRZvPE3PuHcSMVZzfsLhGVOkfd20obL5SWEBew5ShlquNxg==",
+ "dev": true,
+ "license": "MIT",
+ "optionalDependencies": {
+ "graceful-fs": "^4.1.6"
+ }
+ },
+ "node_modules/jszip": {
+ "version": "3.10.1",
+ "resolved": "https://registry.npmjs.org/jszip/-/jszip-3.10.1.tgz",
+ "integrity": "sha512-xXDvecyTpGLrqFrvkrUSoxxfJI5AH7U8zxxtVclpsUtMCq4JQ290LY8AW5c7Ggnr/Y/oK+bQMbqK2qmtk3pN4g==",
+ "dev": true,
+ "license": "(MIT OR GPL-3.0-or-later)",
+ "dependencies": {
+ "lie": "~3.3.0",
+ "pako": "~1.0.2",
+ "readable-stream": "~2.3.6",
+ "setimmediate": "^1.0.5"
+ }
+ },
+ "node_modules/jszip/node_modules/readable-stream": {
+ "version": "2.3.8",
+ "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.8.tgz",
+ "integrity": "sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "core-util-is": "~1.0.0",
+ "inherits": "~2.0.3",
+ "isarray": "~1.0.0",
+ "process-nextick-args": "~2.0.0",
+ "safe-buffer": "~5.1.1",
+ "string_decoder": "~1.1.1",
+ "util-deprecate": "~1.0.1"
+ }
+ },
+ "node_modules/jszip/node_modules/safe-buffer": {
+ "version": "5.1.2",
+ "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
+ "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/jszip/node_modules/string_decoder": {
+ "version": "1.1.1",
+ "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz",
+ "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "safe-buffer": "~5.1.0"
+ }
+ },
+ "node_modules/keyv": {
+ "version": "4.5.4",
+ "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz",
+ "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "json-buffer": "3.0.1"
+ }
+ },
+ "node_modules/lazy-val": {
+ "version": "1.0.5",
+ "resolved": "https://registry.npmjs.org/lazy-val/-/lazy-val-1.0.5.tgz",
+ "integrity": "sha512-0/BnGCCfyUMkBpeDgWihanIAF9JmZhHBgUhEqzvf+adhNGLoP6TaiI5oF8oyb3I45P+PcnrqihSf01M0l0G5+Q==",
+ "license": "MIT"
+ },
+ "node_modules/lie": {
+ "version": "3.3.0",
+ "resolved": "https://registry.npmjs.org/lie/-/lie-3.3.0.tgz",
+ "integrity": "sha512-UaiMJzeWRlEujzAuw5LokY1L5ecNQYZKfmyZ9L7wDHb/p5etKaxXhohBcrw0EYby+G/NA52vRSN4N39dxHAIwQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "immediate": "~3.0.5"
+ }
+ },
+ "node_modules/lines-and-columns": {
+ "version": "1.2.4",
+ "resolved": "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.2.4.tgz",
+ "integrity": "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==",
+ "license": "MIT"
+ },
+ "node_modules/lodash": {
+ "version": "4.17.23",
+ "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.23.tgz",
+ "integrity": "sha512-LgVTMpQtIopCi79SJeDiP0TfWi5CNEc/L/aRdTh3yIvmZXTnheWpKjSZhnvMl8iXbC1tFg9gdHHDMLoV7CnG+w==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/lodash.escaperegexp": {
+ "version": "4.1.2",
+ "resolved": "https://registry.npmjs.org/lodash.escaperegexp/-/lodash.escaperegexp-4.1.2.tgz",
+ "integrity": "sha512-TM9YBvyC84ZxE3rgfefxUWiQKLilstD6k7PTGt6wfbtXF8ixIJLOL3VYyV/z+ZiPLsVxAsKAFVwWlWeb2Y8Yyw==",
+ "license": "MIT"
+ },
+ "node_modules/lodash.isequal": {
+ "version": "4.5.0",
+ "resolved": "https://registry.npmjs.org/lodash.isequal/-/lodash.isequal-4.5.0.tgz",
+ "integrity": "sha512-pDo3lu8Jhfjqls6GkMgpahsF9kCyayhgykjyLMNFTKWrpVdAQtYyB4muAMWozBB4ig/dtWAmsMxLEI8wuz+DYQ==",
+ "deprecated": "This package is deprecated. Use require('node:util').isDeepStrictEqual instead.",
+ "license": "MIT"
+ },
+ "node_modules/log-symbols": {
+ "version": "4.1.0",
+ "resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-4.1.0.tgz",
+ "integrity": "sha512-8XPvpAA8uyhfteu8pIvQxpJZ7SYYdpUivZpGy6sFsBuKRY/7rQGavedeB8aK+Zkyq6upMFVL/9AW6vOYzfRyLg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "chalk": "^4.1.0",
+ "is-unicode-supported": "^0.1.0"
+ },
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/loose-envify": {
+ "version": "1.4.0",
+ "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz",
+ "integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==",
+ "license": "MIT",
+ "dependencies": {
+ "js-tokens": "^3.0.0 || ^4.0.0"
+ },
+ "bin": {
+ "loose-envify": "cli.js"
+ }
+ },
+ "node_modules/lowercase-keys": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/lowercase-keys/-/lowercase-keys-2.0.0.tgz",
+ "integrity": "sha512-tqNXrS78oMOE73NMxK4EMLQsQowWf8jKooH9g7xPavRT706R6bkQJ6DY2Te7QukaZsulxa30wQ7bk0pm4XiHmA==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/lru-cache": {
+ "version": "5.1.1",
+ "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-5.1.1.tgz",
+ "integrity": "sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "yallist": "^3.0.2"
+ }
+ },
+ "node_modules/make-fetch-happen": {
+ "version": "14.0.3",
+ "resolved": "https://registry.npmjs.org/make-fetch-happen/-/make-fetch-happen-14.0.3.tgz",
+ "integrity": "sha512-QMjGbFTP0blj97EeidG5hk/QhKQ3T4ICckQGLgz38QF7Vgbk6e6FTARN8KhKxyBbWn8R0HU+bnw8aSoFPD4qtQ==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "@npmcli/agent": "^3.0.0",
+ "cacache": "^19.0.1",
+ "http-cache-semantics": "^4.1.1",
+ "minipass": "^7.0.2",
+ "minipass-fetch": "^4.0.0",
+ "minipass-flush": "^1.0.5",
+ "minipass-pipeline": "^1.2.4",
+ "negotiator": "^1.0.0",
+ "proc-log": "^5.0.0",
+ "promise-retry": "^2.0.1",
+ "ssri": "^12.0.0"
+ },
+ "engines": {
+ "node": "^18.17.0 || >=20.5.0"
+ }
+ },
+ "node_modules/matcher": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/matcher/-/matcher-3.0.0.tgz",
+ "integrity": "sha512-OkeDaAZ/bQCxeFAozM55PKcKU0yJMPGifLwV4Qgjitu+5MoAfSQN4lsLJeXZ1b8w0x+/Emda6MZgXS1jvsapng==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "dependencies": {
+ "escape-string-regexp": "^4.0.0"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/math-intrinsics": {
+ "version": "1.1.0",
+ "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
+ "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.4"
+ }
+ },
+ "node_modules/mime": {
+ "version": "2.6.0",
+ "resolved": "https://registry.npmjs.org/mime/-/mime-2.6.0.tgz",
+ "integrity": "sha512-USPkMeET31rOMiarsBNIHZKLGgvKc/LrjofAnBlOttf5ajRvqiRA8QsenbcooctK6d6Ts6aqZXBA+XbkKthiQg==",
+ "dev": true,
+ "license": "MIT",
+ "bin": {
+ "mime": "cli.js"
+ },
+ "engines": {
+ "node": ">=4.0.0"
+ }
+ },
+ "node_modules/mime-db": {
+ "version": "1.52.0",
+ "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
+ "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.6"
+ }
+ },
+ "node_modules/mime-types": {
+ "version": "2.1.35",
+ "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz",
+ "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "mime-db": "1.52.0"
+ },
+ "engines": {
+ "node": ">= 0.6"
+ }
+ },
+ "node_modules/mimic-fn": {
+ "version": "2.1.0",
+ "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-2.1.0.tgz",
+ "integrity": "sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=6"
+ }
+ },
+ "node_modules/mimic-response": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/mimic-response/-/mimic-response-1.0.1.tgz",
+ "integrity": "sha512-j5EctnkH7amfV/q5Hgmoal1g2QHFJRraOtmx0JpIqkxhBhI/lJSl1nMpQ45hVarwNETOoWEimndZ4QK0RHxuxQ==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=4"
+ }
+ },
+ "node_modules/minimatch": {
+ "version": "10.2.5",
+ "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.5.tgz",
+ "integrity": "sha512-MULkVLfKGYDFYejP07QOurDLLQpcjk7Fw+7jXS2R2czRQzR56yHRveU5NDJEOviH+hETZKSkIk5c+T23GjFUMg==",
+ "dev": true,
+ "license": "BlueOak-1.0.0",
+ "dependencies": {
+ "brace-expansion": "^5.0.5"
+ },
+ "engines": {
+ "node": "18 || 20 || >=22"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/isaacs"
+ }
+ },
+ "node_modules/minimist": {
+ "version": "1.2.8",
+ "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz",
+ "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==",
+ "dev": true,
+ "license": "MIT",
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/minipass": {
+ "version": "7.1.3",
+ "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.3.tgz",
+ "integrity": "sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A==",
+ "dev": true,
+ "license": "BlueOak-1.0.0",
+ "engines": {
+ "node": ">=16 || 14 >=14.17"
+ }
+ },
+ "node_modules/minipass-collect": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/minipass-collect/-/minipass-collect-2.0.1.tgz",
+ "integrity": "sha512-D7V8PO9oaz7PWGLbCACuI1qEOsq7UKfLotx/C0Aet43fCUB/wfQ7DYeq2oR/svFJGYDHPr38SHATeaj/ZoKHKw==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "minipass": "^7.0.3"
+ },
+ "engines": {
+ "node": ">=16 || 14 >=14.17"
+ }
+ },
+ "node_modules/minipass-fetch": {
+ "version": "4.0.1",
+ "resolved": "https://registry.npmjs.org/minipass-fetch/-/minipass-fetch-4.0.1.tgz",
+ "integrity": "sha512-j7U11C5HXigVuutxebFadoYBbd7VSdZWggSe64NVdvWNBqGAiXPL2QVCehjmw7lY1oF9gOllYbORh+hiNgfPgQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "minipass": "^7.0.3",
+ "minipass-sized": "^1.0.3",
+ "minizlib": "^3.0.1"
+ },
+ "engines": {
+ "node": "^18.17.0 || >=20.5.0"
+ },
+ "optionalDependencies": {
+ "encoding": "^0.1.13"
+ }
+ },
+ "node_modules/minipass-flush": {
+ "version": "1.0.7",
+ "resolved": "https://registry.npmjs.org/minipass-flush/-/minipass-flush-1.0.7.tgz",
+ "integrity": "sha512-TbqTz9cUwWyHS2Dy89P3ocAGUGxKjjLuR9z8w4WUTGAVgEj17/4nhgo2Du56i0Fm3Pm30g4iA8Lcqctc76jCzA==",
+ "dev": true,
+ "license": "BlueOak-1.0.0",
+ "dependencies": {
+ "minipass": "^3.0.0"
+ },
+ "engines": {
+ "node": ">= 8"
+ }
+ },
+ "node_modules/minipass-flush/node_modules/minipass": {
+ "version": "3.3.6",
+ "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz",
+ "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "yallist": "^4.0.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/minipass-flush/node_modules/yallist": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz",
+ "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==",
+ "dev": true,
+ "license": "ISC"
+ },
+ "node_modules/minipass-pipeline": {
+ "version": "1.2.4",
+ "resolved": "https://registry.npmjs.org/minipass-pipeline/-/minipass-pipeline-1.2.4.tgz",
+ "integrity": "sha512-xuIq7cIOt09RPRJ19gdi4b+RiNvDFYe5JH+ggNvBqGqpQXcru3PcRmOZuHBKWK1Txf9+cQ+HMVN4d6z46LZP7A==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "minipass": "^3.0.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/minipass-pipeline/node_modules/minipass": {
+ "version": "3.3.6",
+ "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz",
+ "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "yallist": "^4.0.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/minipass-pipeline/node_modules/yallist": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz",
+ "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==",
+ "dev": true,
+ "license": "ISC"
+ },
+ "node_modules/minipass-sized": {
+ "version": "1.0.3",
+ "resolved": "https://registry.npmjs.org/minipass-sized/-/minipass-sized-1.0.3.tgz",
+ "integrity": "sha512-MbkQQ2CTiBMlA2Dm/5cY+9SWFEN8pzzOXi6rlM5Xxq0Yqbda5ZQy9sU75a673FE9ZK0Zsbr6Y5iP6u9nktfg2g==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "minipass": "^3.0.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/minipass-sized/node_modules/minipass": {
+ "version": "3.3.6",
+ "resolved": "https://registry.npmjs.org/minipass/-/minipass-3.3.6.tgz",
+ "integrity": "sha512-DxiNidxSEK+tHG6zOIklvNOwm3hvCrbUrdtzY74U6HKTJxvIDfOUL5W5P2Ghd3DTkhhKPYGqeNUIh5qcM4YBfw==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "yallist": "^4.0.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/minipass-sized/node_modules/yallist": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz",
+ "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==",
+ "dev": true,
+ "license": "ISC"
+ },
+ "node_modules/minizlib": {
+ "version": "3.1.0",
+ "resolved": "https://registry.npmjs.org/minizlib/-/minizlib-3.1.0.tgz",
+ "integrity": "sha512-KZxYo1BUkWD2TVFLr0MQoM8vUUigWD3LlD83a/75BqC+4qE0Hb1Vo5v1FgcfaNXvfXzr+5EhQ6ing/CaBijTlw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "minipass": "^7.1.2"
+ },
+ "engines": {
+ "node": ">= 18"
+ }
+ },
+ "node_modules/mkdirp": {
+ "version": "0.5.6",
+ "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.6.tgz",
+ "integrity": "sha512-FP+p8RB8OWpF3YZBCrP5gtADmtXApB5AMLn+vdyA+PyxCjrCs00mjyUozssO33cwDeT3wNGdLxJ5M//YqtHAJw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "minimist": "^1.2.6"
+ },
+ "bin": {
+ "mkdirp": "bin/cmd.js"
+ }
+ },
+ "node_modules/ms": {
+ "version": "2.1.3",
+ "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+ "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+ "license": "MIT"
+ },
+ "node_modules/nanoid": {
+ "version": "3.3.11",
+ "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz",
+ "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==",
+ "dev": true,
+ "funding": [
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/ai"
+ }
+ ],
+ "license": "MIT",
+ "bin": {
+ "nanoid": "bin/nanoid.cjs"
+ },
+ "engines": {
+ "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+ }
+ },
+ "node_modules/negotiator": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-1.0.0.tgz",
+ "integrity": "sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.6"
+ }
+ },
+ "node_modules/node-abi": {
+ "version": "4.28.0",
+ "resolved": "https://registry.npmjs.org/node-abi/-/node-abi-4.28.0.tgz",
+ "integrity": "sha512-Qfp5XZL1cJDOabOT8H5gnqMTmM4NjvYzHp4I/Kt/Sl76OVkOBBHRFlPspGV0hYvMoqQsypFjT/Yp7Km0beXW9g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "semver": "^7.6.3"
+ },
+ "engines": {
+ "node": ">=22.12.0"
+ }
+ },
+ "node_modules/node-abi/node_modules/semver": {
+ "version": "7.7.4",
+ "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz",
+ "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==",
+ "dev": true,
+ "license": "ISC",
+ "bin": {
+ "semver": "bin/semver.js"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/node-addon-api": {
+ "version": "1.7.2",
+ "resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-1.7.2.tgz",
+ "integrity": "sha512-ibPK3iA+vaY1eEjESkQkM0BbCqFOaZMiXRTtdB0u7b4djtY6JnsjvPdUHVMg6xQt3B8fpTTWHI9A+ADjM9frzg==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true
+ },
+ "node_modules/node-api-version": {
+ "version": "0.2.1",
+ "resolved": "https://registry.npmjs.org/node-api-version/-/node-api-version-0.2.1.tgz",
+ "integrity": "sha512-2xP/IGGMmmSQpI1+O/k72jF/ykvZ89JeuKX3TLJAYPDVLUalrshrLHkeVcCCZqG/eEa635cr8IBYzgnDvM2O8Q==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "semver": "^7.3.5"
+ }
+ },
+ "node_modules/node-api-version/node_modules/semver": {
+ "version": "7.7.4",
+ "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz",
+ "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==",
+ "dev": true,
+ "license": "ISC",
+ "bin": {
+ "semver": "bin/semver.js"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/node-gyp": {
+ "version": "11.5.0",
+ "resolved": "https://registry.npmjs.org/node-gyp/-/node-gyp-11.5.0.tgz",
+ "integrity": "sha512-ra7Kvlhxn5V9Slyus0ygMa2h+UqExPqUIkfk7Pc8QTLT956JLSy51uWFwHtIYy0vI8cB4BDhc/S03+880My/LQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "env-paths": "^2.2.0",
+ "exponential-backoff": "^3.1.1",
+ "graceful-fs": "^4.2.6",
+ "make-fetch-happen": "^14.0.3",
+ "nopt": "^8.0.0",
+ "proc-log": "^5.0.0",
+ "semver": "^7.3.5",
+ "tar": "^7.4.3",
+ "tinyglobby": "^0.2.12",
+ "which": "^5.0.0"
+ },
+ "bin": {
+ "node-gyp": "bin/node-gyp.js"
+ },
+ "engines": {
+ "node": "^18.17.0 || >=20.5.0"
+ }
+ },
+ "node_modules/node-gyp/node_modules/isexe": {
+ "version": "3.1.5",
+ "resolved": "https://registry.npmjs.org/isexe/-/isexe-3.1.5.tgz",
+ "integrity": "sha512-6B3tLtFqtQS4ekarvLVMZ+X+VlvQekbe4taUkf/rhVO3d/h0M2rfARm/pXLcPEsjjMsFgrFgSrhQIxcSVrBz8w==",
+ "dev": true,
+ "license": "BlueOak-1.0.0",
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/node-gyp/node_modules/semver": {
+ "version": "7.7.4",
+ "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz",
+ "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==",
+ "dev": true,
+ "license": "ISC",
+ "bin": {
+ "semver": "bin/semver.js"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/node-gyp/node_modules/which": {
+ "version": "5.0.0",
+ "resolved": "https://registry.npmjs.org/which/-/which-5.0.0.tgz",
+ "integrity": "sha512-JEdGzHwwkrbWoGOlIHqQ5gtprKGOenpDHpxE9zVR1bWbOtYRyPPHMe9FaP6x61CmNaTThSkb0DAJte5jD+DmzQ==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "isexe": "^3.1.1"
+ },
+ "bin": {
+ "node-which": "bin/which.js"
+ },
+ "engines": {
+ "node": "^18.17.0 || >=20.5.0"
+ }
+ },
+ "node_modules/node-releases": {
+ "version": "2.0.36",
+ "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.36.tgz",
+ "integrity": "sha512-TdC8FSgHz8Mwtw9g5L4gR/Sh9XhSP/0DEkQxfEFXOpiul5IiHgHan2VhYYb6agDSfp4KuvltmGApc8HMgUrIkA==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/nopt": {
+ "version": "8.1.0",
+ "resolved": "https://registry.npmjs.org/nopt/-/nopt-8.1.0.tgz",
+ "integrity": "sha512-ieGu42u/Qsa4TFktmaKEwM6MQH0pOWnaB3htzh0JRtx84+Mebc0cbZYN5bC+6WTZ4+77xrL9Pn5m7CV6VIkV7A==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "abbrev": "^3.0.0"
+ },
+ "bin": {
+ "nopt": "bin/nopt.js"
+ },
+ "engines": {
+ "node": "^18.17.0 || >=20.5.0"
+ }
+ },
+ "node_modules/normalize-url": {
+ "version": "6.1.0",
+ "resolved": "https://registry.npmjs.org/normalize-url/-/normalize-url-6.1.0.tgz",
+ "integrity": "sha512-DlL+XwOy3NxAQ8xuC0okPgK46iuVNAK01YN7RueYBqqFeGsBjV9XmCAzAdgt+667bCl5kPh9EqKKDwnaPG1I7A==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/object-assign": {
+ "version": "4.1.1",
+ "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
+ "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==",
+ "license": "MIT",
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/object-keys": {
+ "version": "1.1.1",
+ "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz",
+ "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "engines": {
+ "node": ">= 0.4"
+ }
+ },
+ "node_modules/once": {
+ "version": "1.4.0",
+ "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
+ "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "wrappy": "1"
+ }
+ },
+ "node_modules/onetime": {
+ "version": "5.1.2",
+ "resolved": "https://registry.npmjs.org/onetime/-/onetime-5.1.2.tgz",
+ "integrity": "sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "mimic-fn": "^2.1.0"
+ },
+ "engines": {
+ "node": ">=6"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/ora": {
+ "version": "5.4.1",
+ "resolved": "https://registry.npmjs.org/ora/-/ora-5.4.1.tgz",
+ "integrity": "sha512-5b6Y85tPxZZ7QytO+BQzysW31HJku27cRIlkbAXaNx+BdcVi+LlRFmVXzeF6a7JCwJpyw5c4b+YSVImQIrBpuQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "bl": "^4.1.0",
+ "chalk": "^4.1.0",
+ "cli-cursor": "^3.1.0",
+ "cli-spinners": "^2.5.0",
+ "is-interactive": "^1.0.0",
+ "is-unicode-supported": "^0.1.0",
+ "log-symbols": "^4.1.0",
+ "strip-ansi": "^6.0.0",
+ "wcwidth": "^1.0.1"
+ },
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/p-cancelable": {
+ "version": "2.1.1",
+ "resolved": "https://registry.npmjs.org/p-cancelable/-/p-cancelable-2.1.1.tgz",
+ "integrity": "sha512-BZOr3nRQHOntUjTrH8+Lh54smKHoHyur8We1V8DSMVrl5A2malOOwuJRnKRDjSnkoeBh4at6BwEnb5I7Jl31wg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/p-limit": {
+ "version": "3.1.0",
+ "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz",
+ "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "yocto-queue": "^0.1.0"
+ },
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/p-map": {
+ "version": "7.0.4",
+ "resolved": "https://registry.npmjs.org/p-map/-/p-map-7.0.4.tgz",
+ "integrity": "sha512-tkAQEw8ysMzmkhgw8k+1U/iPhWNhykKnSk4Rd5zLoPJCuJaGRPo6YposrZgaxHKzDHdDWWZvE/Sk7hsL2X/CpQ==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=18"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/package-json-from-dist": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/package-json-from-dist/-/package-json-from-dist-1.0.1.tgz",
+ "integrity": "sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==",
+ "dev": true,
+ "license": "BlueOak-1.0.0"
+ },
+ "node_modules/pako": {
+ "version": "1.0.11",
+ "resolved": "https://registry.npmjs.org/pako/-/pako-1.0.11.tgz",
+ "integrity": "sha512-4hLB8Py4zZce5s4yd9XzopqwVv/yGNhV1Bl8NTmCq1763HeK2+EwVTv+leGeL13Dnh2wfbqowVPXCIO0z4taYw==",
+ "dev": true,
+ "license": "(MIT AND Zlib)"
+ },
+ "node_modules/parent-module": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz",
+ "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==",
+ "license": "MIT",
+ "dependencies": {
+ "callsites": "^3.0.0"
+ },
+ "engines": {
+ "node": ">=6"
+ }
+ },
+ "node_modules/parse-json": {
+ "version": "5.2.0",
+ "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-5.2.0.tgz",
+ "integrity": "sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==",
+ "license": "MIT",
+ "dependencies": {
+ "@babel/code-frame": "^7.0.0",
+ "error-ex": "^1.3.1",
+ "json-parse-even-better-errors": "^2.3.0",
+ "lines-and-columns": "^1.1.6"
+ },
+ "engines": {
+ "node": ">=8"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/path-is-absolute": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
+ "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/path-key": {
+ "version": "3.1.1",
+ "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
+ "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/path-parse": {
+ "version": "1.0.7",
+ "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz",
+ "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==",
+ "license": "MIT"
+ },
+ "node_modules/path-scurry": {
+ "version": "1.11.1",
+ "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-1.11.1.tgz",
+ "integrity": "sha512-Xa4Nw17FS9ApQFJ9umLiJS4orGjm7ZzwUrwamcGQuHSzDyth9boKDaycYdDcZDuqYATXw4HFXgaqWTctW/v1HA==",
+ "dev": true,
+ "license": "BlueOak-1.0.0",
+ "dependencies": {
+ "lru-cache": "^10.2.0",
+ "minipass": "^5.0.0 || ^6.0.2 || ^7.0.0"
+ },
+ "engines": {
+ "node": ">=16 || 14 >=14.18"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/isaacs"
+ }
+ },
+ "node_modules/path-scurry/node_modules/lru-cache": {
+ "version": "10.4.3",
+ "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-10.4.3.tgz",
+ "integrity": "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==",
+ "dev": true,
+ "license": "ISC"
+ },
+ "node_modules/path-type": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz",
+ "integrity": "sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==",
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/pe-library": {
+ "version": "0.4.1",
+ "resolved": "https://registry.npmjs.org/pe-library/-/pe-library-0.4.1.tgz",
+ "integrity": "sha512-eRWB5LBz7PpDu4PUlwT0PhnQfTQJlDDdPa35urV4Osrm0t0AqQFGn+UIkU3klZvwJ8KPO3VbBFsXquA6p6kqZw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=12",
+ "npm": ">=6"
+ },
+ "funding": {
+ "type": "github",
+ "url": "https://github.com/sponsors/jet2jet"
+ }
+ },
+ "node_modules/pend": {
+ "version": "1.2.0",
+ "resolved": "https://registry.npmjs.org/pend/-/pend-1.2.0.tgz",
+ "integrity": "sha512-F3asv42UuXchdzt+xXqfW1OGlVBe+mxa2mqI0pg5yAHZPvFmY3Y6drSf/GQ1A86WgWEN9Kzh/WrgKa6iGcHXLg==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/picocolors": {
+ "version": "1.1.1",
+ "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+ "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+ "license": "ISC"
+ },
+ "node_modules/picomatch": {
+ "version": "4.0.4",
+ "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.4.tgz",
+ "integrity": "sha512-QP88BAKvMam/3NxH6vj2o21R6MjxZUAd6nlwAS/pnGvN9IVLocLHxGYIzFhg6fUQ+5th6P4dv4eW9jX3DSIj7A==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=12"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/jonschlinkert"
+ }
+ },
+ "node_modules/playwright": {
+ "version": "1.59.0",
+ "resolved": "https://registry.npmjs.org/playwright/-/playwright-1.59.0.tgz",
+ "integrity": "sha512-wihGScriusvATUxmhfENxg0tj1vHEFeIwxlnPFKQTOQVd7aG08mUfvvniRP/PtQOC+2Bs52kBOC/Up1jTXeIbw==",
+ "dev": true,
+ "license": "Apache-2.0",
+ "dependencies": {
+ "playwright-core": "1.59.0"
+ },
+ "bin": {
+ "playwright": "cli.js"
+ },
+ "engines": {
+ "node": ">=18"
+ },
+ "optionalDependencies": {
+ "fsevents": "2.3.2"
+ }
+ },
+ "node_modules/playwright-core": {
+ "version": "1.59.0",
+ "resolved": "https://registry.npmjs.org/playwright-core/-/playwright-core-1.59.0.tgz",
+ "integrity": "sha512-PW/X/IoZ6BMUUy8rpwHEZ8Kc0IiLIkgKYGNFaMs5KmQhcfLILNx9yCQD0rnWeWfz1PNeqcFP1BsihQhDOBCwZw==",
+ "dev": true,
+ "license": "Apache-2.0",
+ "bin": {
+ "playwright-core": "cli.js"
+ },
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/plist": {
+ "version": "3.1.0",
+ "resolved": "https://registry.npmjs.org/plist/-/plist-3.1.0.tgz",
+ "integrity": "sha512-uysumyrvkUX0rX/dEVqt8gC3sTBzd4zoWfLeS29nb53imdaXVvLINYXTI2GNqzaMuvacNx4uJQ8+b3zXR0pkgQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@xmldom/xmldom": "^0.8.8",
+ "base64-js": "^1.5.1",
+ "xmlbuilder": "^15.1.1"
+ },
+ "engines": {
+ "node": ">=10.4.0"
+ }
+ },
+ "node_modules/postcss": {
+ "version": "8.5.8",
+ "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.8.tgz",
+ "integrity": "sha512-OW/rX8O/jXnm82Ey1k44pObPtdblfiuWnrd8X7GJ7emImCOstunGbXUpp7HdBrFQX6rJzn3sPT397Wp5aCwCHg==",
+ "dev": true,
+ "funding": [
+ {
+ "type": "opencollective",
+ "url": "https://opencollective.com/postcss/"
+ },
+ {
+ "type": "tidelift",
+ "url": "https://tidelift.com/funding/github/npm/postcss"
+ },
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/ai"
+ }
+ ],
+ "license": "MIT",
+ "dependencies": {
+ "nanoid": "^3.3.11",
+ "picocolors": "^1.1.1",
+ "source-map-js": "^1.2.1"
+ },
+ "engines": {
+ "node": "^10 || ^12 || >=14"
+ }
+ },
+ "node_modules/postject": {
+ "version": "1.0.0-alpha.6",
+ "resolved": "https://registry.npmjs.org/postject/-/postject-1.0.0-alpha.6.tgz",
+ "integrity": "sha512-b9Eb8h2eVqNE8edvKdwqkrY6O7kAwmI8kcnBv1NScolYJbo59XUF0noFq+lxbC1yN20bmC0WBEbDC5H/7ASb0A==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "peer": true,
+ "dependencies": {
+ "commander": "^9.4.0"
+ },
+ "bin": {
+ "postject": "dist/cli.js"
+ },
+ "engines": {
+ "node": ">=14.0.0"
+ }
+ },
+ "node_modules/postject/node_modules/commander": {
+ "version": "9.5.0",
+ "resolved": "https://registry.npmjs.org/commander/-/commander-9.5.0.tgz",
+ "integrity": "sha512-KRs7WVDKg86PWiuAqhDrAQnTXZKraVcCc6vFdL14qrZ/DcWwuRo7VoiYXalXO7S5GKpqYiVEwCbgFDfxNHKJBQ==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "peer": true,
+ "engines": {
+ "node": "^12.20.0 || >=14"
+ }
+ },
+ "node_modules/proc-log": {
+ "version": "5.0.0",
+ "resolved": "https://registry.npmjs.org/proc-log/-/proc-log-5.0.0.tgz",
+ "integrity": "sha512-Azwzvl90HaF0aCz1JrDdXQykFakSSNPaPoiZ9fm5qJIMHioDZEi7OAdRwSm6rSoPtY3Qutnm3L7ogmg3dc+wbQ==",
+ "dev": true,
+ "license": "ISC",
+ "engines": {
+ "node": "^18.17.0 || >=20.5.0"
+ }
+ },
+ "node_modules/process-nextick-args": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz",
+ "integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/progress": {
+ "version": "2.0.3",
+ "resolved": "https://registry.npmjs.org/progress/-/progress-2.0.3.tgz",
+ "integrity": "sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=0.4.0"
+ }
+ },
+ "node_modules/promise-retry": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/promise-retry/-/promise-retry-2.0.1.tgz",
+ "integrity": "sha512-y+WKFlBR8BGXnsNlIHFGPZmyDf3DFMoLhaflAnyZgV6rG6xu+JwesTo2Q9R6XwYmtmwAFCkAk3e35jEdoeh/3g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "err-code": "^2.0.2",
+ "retry": "^0.12.0"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/prop-types": {
+ "version": "15.8.1",
+ "resolved": "https://registry.npmjs.org/prop-types/-/prop-types-15.8.1.tgz",
+ "integrity": "sha512-oj87CgZICdulUohogVAR7AjlC0327U4el4L6eAvOqCeudMDVU0NThNaV+b9Df4dXgSP1gXMTnPdhfe/2qDH5cg==",
+ "license": "MIT",
+ "dependencies": {
+ "loose-envify": "^1.4.0",
+ "object-assign": "^4.1.1",
+ "react-is": "^16.13.1"
+ }
+ },
+ "node_modules/prop-types/node_modules/react-is": {
+ "version": "16.13.1",
+ "resolved": "https://registry.npmjs.org/react-is/-/react-is-16.13.1.tgz",
+ "integrity": "sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==",
+ "license": "MIT"
+ },
+ "node_modules/proper-lockfile": {
+ "version": "4.1.2",
+ "resolved": "https://registry.npmjs.org/proper-lockfile/-/proper-lockfile-4.1.2.tgz",
+ "integrity": "sha512-TjNPblN4BwAWMXU8s9AEz4JmQxnD1NNL7bNOY/AKUzyamc379FWASUhc/K1pL2noVb+XmZKLL68cjzLsiOAMaA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "graceful-fs": "^4.2.4",
+ "retry": "^0.12.0",
+ "signal-exit": "^3.0.2"
+ }
+ },
+ "node_modules/pump": {
+ "version": "3.0.4",
+ "resolved": "https://registry.npmjs.org/pump/-/pump-3.0.4.tgz",
+ "integrity": "sha512-VS7sjc6KR7e1ukRFhQSY5LM2uBWAUPiOPa/A3mkKmiMwSmRFUITt0xuj+/lesgnCv+dPIEYlkzrcyXgquIHMcA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "end-of-stream": "^1.1.0",
+ "once": "^1.3.1"
+ }
+ },
+ "node_modules/punycode": {
+ "version": "2.3.1",
+ "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
+ "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=6"
+ }
+ },
+ "node_modules/quick-lru": {
+ "version": "5.1.1",
+ "resolved": "https://registry.npmjs.org/quick-lru/-/quick-lru-5.1.1.tgz",
+ "integrity": "sha512-WuyALRjWPDGtt/wzJiadO5AXY+8hZ80hVpe6MyivgraREW751X3SbhRvG3eLKOYN+8VEvqLcf3wdnt44Z4S4SA==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/react": {
+ "version": "19.2.4",
+ "resolved": "https://registry.npmjs.org/react/-/react-19.2.4.tgz",
+ "integrity": "sha512-9nfp2hYpCwOjAN+8TZFGhtWEwgvWHXqESH8qT89AT/lWklpLON22Lc8pEtnpsZz7VmawabSU0gCjnj8aC0euHQ==",
+ "license": "MIT",
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/react-dom": {
+ "version": "19.2.4",
+ "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.2.4.tgz",
+ "integrity": "sha512-AXJdLo8kgMbimY95O2aKQqsz2iWi9jMgKJhRBAxECE4IFxfcazB2LmzloIoibJI3C12IlY20+KFaLv+71bUJeQ==",
+ "license": "MIT",
+ "dependencies": {
+ "scheduler": "^0.27.0"
+ },
+ "peerDependencies": {
+ "react": "^19.2.4"
+ }
+ },
+ "node_modules/react-draggable": {
+ "version": "4.5.0",
+ "resolved": "https://registry.npmjs.org/react-draggable/-/react-draggable-4.5.0.tgz",
+ "integrity": "sha512-VC+HBLEZ0XJxnOxVAZsdRi8rD04Iz3SiiKOoYzamjylUcju/hP9np/aZdLHf/7WOD268WMoNJMvYfB5yAK45cw==",
+ "license": "MIT",
+ "dependencies": {
+ "clsx": "^2.1.1",
+ "prop-types": "^15.8.1"
+ },
+ "peerDependencies": {
+ "react": ">= 16.3.0",
+ "react-dom": ">= 16.3.0"
+ }
+ },
+ "node_modules/react-grid-layout": {
+ "version": "2.2.3",
+ "resolved": "https://registry.npmjs.org/react-grid-layout/-/react-grid-layout-2.2.3.tgz",
+ "integrity": "sha512-OAEJHBxmfuxQfVtZwRzmsokijGlBgzYIJ7MUlLk/VSa43SaGzu15w5D0P2RDrfX5EvP9POMbL6bFrai/huDzbQ==",
+ "license": "MIT",
+ "dependencies": {
+ "clsx": "^2.1.1",
+ "fast-equals": "^4.0.3",
+ "prop-types": "^15.8.1",
+ "react-draggable": "^4.4.6",
+ "react-resizable": "^3.1.3",
+ "resize-observer-polyfill": "^1.5.1"
+ },
+ "peerDependencies": {
+ "react": ">= 16.3.0",
+ "react-dom": ">= 16.3.0"
+ }
+ },
+ "node_modules/react-i18next": {
+ "version": "16.6.6",
+ "resolved": "https://registry.npmjs.org/react-i18next/-/react-i18next-16.6.6.tgz",
+ "integrity": "sha512-ZgL2HUoW34UKUkOV7uSQFE1CDnRPD+tCR3ywSuWH7u2iapnz86U8Bi3Vrs620qNDzCf1F47NxglCEkchCTDOHw==",
+ "license": "MIT",
+ "dependencies": {
+ "@babel/runtime": "^7.29.2",
+ "html-parse-stringify": "^3.0.1",
+ "use-sync-external-store": "^1.6.0"
+ },
+ "peerDependencies": {
+ "i18next": ">= 25.10.9",
+ "react": ">= 16.8.0",
+ "typescript": "^5 || ^6"
+ },
+ "peerDependenciesMeta": {
+ "react-dom": {
+ "optional": true
+ },
+ "react-native": {
+ "optional": true
+ },
+ "typescript": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/react-is": {
+ "version": "19.2.4",
+ "resolved": "https://registry.npmjs.org/react-is/-/react-is-19.2.4.tgz",
+ "integrity": "sha512-W+EWGn2v0ApPKgKKCy/7s7WHXkboGcsrXE+2joLyVxkbyVQfO3MUEaUQDHoSmb8TFFrSKYa9mw64WZHNHSDzYA==",
+ "license": "MIT"
+ },
+ "node_modules/react-redux": {
+ "version": "9.2.0",
+ "resolved": "https://registry.npmjs.org/react-redux/-/react-redux-9.2.0.tgz",
+ "integrity": "sha512-ROY9fvHhwOD9ySfrF0wmvu//bKCQ6AeZZq1nJNtbDC+kk5DuSuNX/n6YWYF/SYy7bSba4D4FSz8DJeKY/S/r+g==",
+ "license": "MIT",
+ "dependencies": {
+ "@types/use-sync-external-store": "^0.0.6",
+ "use-sync-external-store": "^1.4.0"
+ },
+ "peerDependencies": {
+ "@types/react": "^18.2.25 || ^19",
+ "react": "^18.0 || ^19",
+ "redux": "^5.0.0"
+ },
+ "peerDependenciesMeta": {
+ "@types/react": {
+ "optional": true
+ },
+ "redux": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/react-refresh": {
+ "version": "0.17.0",
+ "resolved": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.17.0.tgz",
+ "integrity": "sha512-z6F7K9bV85EfseRCp2bzrpyQ0Gkw1uLoCel9XBVWPg/TjRj94SkJzUTGfOa4bs7iJvBWtQG0Wq7wnI0syw3EBQ==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/react-resizable": {
+ "version": "3.1.3",
+ "resolved": "https://registry.npmjs.org/react-resizable/-/react-resizable-3.1.3.tgz",
+ "integrity": "sha512-liJBNayhX7qA4tBJiBD321FDhJxgGTJ07uzH5zSORXoE8h7PyEZ8mLqmosST7ppf6C4zUsbd2gzDMmBCfFp9Lw==",
+ "license": "MIT",
+ "dependencies": {
+ "prop-types": "15.x",
+ "react-draggable": "^4.5.0"
+ },
+ "peerDependencies": {
+ "react": ">= 16.3",
+ "react-dom": ">= 16.3"
+ }
+ },
+ "node_modules/react-resizable-panels": {
+ "version": "2.1.9",
+ "resolved": "https://registry.npmjs.org/react-resizable-panels/-/react-resizable-panels-2.1.9.tgz",
+ "integrity": "sha512-z77+X08YDIrgAes4jl8xhnUu1LNIRp4+E7cv4xHmLOxxUPO/ML7PSrE813b90vj7xvQ1lcf7g2uA9GeMZonjhQ==",
+ "license": "MIT",
+ "peerDependencies": {
+ "react": "^16.14.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc",
+ "react-dom": "^16.14.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 || ^19.0.0-rc"
+ }
+ },
+ "node_modules/react-router": {
+ "version": "6.30.3",
+ "resolved": "https://registry.npmjs.org/react-router/-/react-router-6.30.3.tgz",
+ "integrity": "sha512-XRnlbKMTmktBkjCLE8/XcZFlnHvr2Ltdr1eJX4idL55/9BbORzyZEaIkBFDhFGCEWBBItsVrDxwx3gnisMitdw==",
+ "license": "MIT",
+ "dependencies": {
+ "@remix-run/router": "1.23.2"
+ },
+ "engines": {
+ "node": ">=14.0.0"
+ },
+ "peerDependencies": {
+ "react": ">=16.8"
+ }
+ },
+ "node_modules/react-router-dom": {
+ "version": "6.30.3",
+ "resolved": "https://registry.npmjs.org/react-router-dom/-/react-router-dom-6.30.3.tgz",
+ "integrity": "sha512-pxPcv1AczD4vso7G4Z3TKcvlxK7g7TNt3/FNGMhfqyntocvYKj+GCatfigGDjbLozC4baguJ0ReCigoDJXb0ag==",
+ "license": "MIT",
+ "dependencies": {
+ "@remix-run/router": "1.23.2",
+ "react-router": "6.30.3"
+ },
+ "engines": {
+ "node": ">=14.0.0"
+ },
+ "peerDependencies": {
+ "react": ">=16.8",
+ "react-dom": ">=16.8"
+ }
+ },
+ "node_modules/react-transition-group": {
+ "version": "4.4.5",
+ "resolved": "https://registry.npmjs.org/react-transition-group/-/react-transition-group-4.4.5.tgz",
+ "integrity": "sha512-pZcd1MCJoiKiBR2NRxeCRg13uCXbydPnmB4EOeRrY7480qNWO8IIgQG6zlDkm6uRMsURXPuKq0GWtiM59a5Q6g==",
+ "license": "BSD-3-Clause",
+ "dependencies": {
+ "@babel/runtime": "^7.5.5",
+ "dom-helpers": "^5.0.1",
+ "loose-envify": "^1.4.0",
+ "prop-types": "^15.6.2"
+ },
+ "peerDependencies": {
+ "react": ">=16.6.0",
+ "react-dom": ">=16.6.0"
+ }
+ },
+ "node_modules/read-binary-file-arch": {
+ "version": "1.0.6",
+ "resolved": "https://registry.npmjs.org/read-binary-file-arch/-/read-binary-file-arch-1.0.6.tgz",
+ "integrity": "sha512-BNg9EN3DD3GsDXX7Aa8O4p92sryjkmzYYgmgTAc6CA4uGLEDzFfxOxugu21akOxpcXHiEgsYkC6nPsQvLLLmEg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "debug": "^4.3.4"
+ },
+ "bin": {
+ "read-binary-file-arch": "cli.js"
+ }
+ },
+ "node_modules/readable-stream": {
+ "version": "3.6.2",
+ "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz",
+ "integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "inherits": "^2.0.3",
+ "string_decoder": "^1.1.1",
+ "util-deprecate": "^1.0.1"
+ },
+ "engines": {
+ "node": ">= 6"
+ }
+ },
+ "node_modules/redux": {
+ "version": "5.0.1",
+ "resolved": "https://registry.npmjs.org/redux/-/redux-5.0.1.tgz",
+ "integrity": "sha512-M9/ELqF6fy8FwmkpnF0S3YKOqMyoWJ4+CS5Efg2ct3oY9daQvd/Pc71FpGZsVsbl3Cpb+IIcjBDUnnyBdQbq4w==",
+ "license": "MIT"
+ },
+ "node_modules/redux-thunk": {
+ "version": "3.1.0",
+ "resolved": "https://registry.npmjs.org/redux-thunk/-/redux-thunk-3.1.0.tgz",
+ "integrity": "sha512-NW2r5T6ksUKXCabzhL9z+h206HQw/NJkcLm1GPImRQ8IzfXwRGqjVhKJGauHirT0DAuyy6hjdnMZaRoAcy0Klw==",
+ "license": "MIT",
+ "peerDependencies": {
+ "redux": "^5.0.0"
+ }
+ },
+ "node_modules/require-directory": {
+ "version": "2.1.1",
+ "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz",
+ "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/resedit": {
+ "version": "1.7.2",
+ "resolved": "https://registry.npmjs.org/resedit/-/resedit-1.7.2.tgz",
+ "integrity": "sha512-vHjcY2MlAITJhC0eRD/Vv8Vlgmu9Sd3LX9zZvtGzU5ZImdTN3+d6e/4mnTyV8vEbyf1sgNIrWxhWlrys52OkEA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "pe-library": "^0.4.1"
+ },
+ "engines": {
+ "node": ">=12",
+ "npm": ">=6"
+ },
+ "funding": {
+ "type": "github",
+ "url": "https://github.com/sponsors/jet2jet"
+ }
+ },
+ "node_modules/reselect": {
+ "version": "5.1.1",
+ "resolved": "https://registry.npmjs.org/reselect/-/reselect-5.1.1.tgz",
+ "integrity": "sha512-K/BG6eIky/SBpzfHZv/dd+9JBFiS4SWV7FIujVyJRux6e45+73RaUHXLmIR1f7WOMaQ0U1km6qwklRQxpJJY0w==",
+ "license": "MIT"
+ },
+ "node_modules/resize-observer-polyfill": {
+ "version": "1.5.1",
+ "resolved": "https://registry.npmjs.org/resize-observer-polyfill/-/resize-observer-polyfill-1.5.1.tgz",
+ "integrity": "sha512-LwZrotdHOo12nQuZlHEmtuXdqGoOD0OhaxopaNFxWzInpEgaLWoVuAMbTzixuosCx2nEG58ngzW3vxdWoxIgdg==",
+ "license": "MIT"
+ },
+ "node_modules/resolve": {
+ "version": "1.22.11",
+ "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.11.tgz",
+ "integrity": "sha512-RfqAvLnMl313r7c9oclB1HhUEAezcpLjz95wFH4LVuhk9JF/r22qmVP9AMmOU4vMX7Q8pN8jwNg/CSpdFnMjTQ==",
+ "license": "MIT",
+ "dependencies": {
+ "is-core-module": "^2.16.1",
+ "path-parse": "^1.0.7",
+ "supports-preserve-symlinks-flag": "^1.0.0"
+ },
+ "bin": {
+ "resolve": "bin/resolve"
+ },
+ "engines": {
+ "node": ">= 0.4"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/resolve-alpn": {
+ "version": "1.2.1",
+ "resolved": "https://registry.npmjs.org/resolve-alpn/-/resolve-alpn-1.2.1.tgz",
+ "integrity": "sha512-0a1F4l73/ZFZOakJnQ3FvkJ2+gSTQWz/r2KE5OdDY0TxPm5h4GkqkWWfM47T7HsbnOtcJVEF4epCVy6u7Q3K+g==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/resolve-from": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz",
+ "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==",
+ "license": "MIT",
+ "engines": {
+ "node": ">=4"
+ }
+ },
+ "node_modules/responselike": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/responselike/-/responselike-2.0.1.tgz",
+ "integrity": "sha512-4gl03wn3hj1HP3yzgdI7d3lCkF95F21Pz4BPGvKHinyQzALR5CapwC8yIi0Rh58DEMQ/SguC03wFj2k0M/mHhw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "lowercase-keys": "^2.0.0"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/restore-cursor": {
+ "version": "3.1.0",
+ "resolved": "https://registry.npmjs.org/restore-cursor/-/restore-cursor-3.1.0.tgz",
+ "integrity": "sha512-l+sSefzHpj5qimhFSE5a8nufZYAM3sBSVMAPtYkmC+4EH2anSGaEMXSD0izRQbu9nfyQ9y5JrVmp7E8oZrUjvA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "onetime": "^5.1.0",
+ "signal-exit": "^3.0.2"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/retry": {
+ "version": "0.12.0",
+ "resolved": "https://registry.npmjs.org/retry/-/retry-0.12.0.tgz",
+ "integrity": "sha512-9LkiTwjUh6rT555DtE9rTX+BKByPfrMzEAtnlEtdEwr3Nkffwiihqe2bWADg+OQRjt9gl6ICdmB/ZFDCGAtSow==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 4"
+ }
+ },
+ "node_modules/rimraf": {
+ "version": "2.6.3",
+ "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.6.3.tgz",
+ "integrity": "sha512-mwqeW5XsA2qAejG46gYdENaxXjx9onRNCfn7L0duuP4hCuTIi/QO7PDK07KJfp1d+izWPrzEJDcSqBa0OZQriA==",
+ "deprecated": "Rimraf versions prior to v4 are no longer supported",
+ "dev": true,
+ "license": "ISC",
+ "peer": true,
+ "dependencies": {
+ "glob": "^7.1.3"
+ },
+ "bin": {
+ "rimraf": "bin.js"
+ }
+ },
+ "node_modules/roarr": {
+ "version": "2.15.4",
+ "resolved": "https://registry.npmjs.org/roarr/-/roarr-2.15.4.tgz",
+ "integrity": "sha512-CHhPh+UNHD2GTXNYhPWLnU8ONHdI+5DI+4EYIAOaiD63rHeYlZvyh8P+in5999TTSFgUYuKUAjzRI4mdh/p+2A==",
+ "dev": true,
+ "license": "BSD-3-Clause",
+ "optional": true,
+ "dependencies": {
+ "boolean": "^3.0.1",
+ "detect-node": "^2.0.4",
+ "globalthis": "^1.0.1",
+ "json-stringify-safe": "^5.0.1",
+ "semver-compare": "^1.0.0",
+ "sprintf-js": "^1.1.2"
+ },
+ "engines": {
+ "node": ">=8.0"
+ }
+ },
+ "node_modules/robust-predicates": {
+ "version": "3.0.3",
+ "resolved": "https://registry.npmjs.org/robust-predicates/-/robust-predicates-3.0.3.tgz",
+ "integrity": "sha512-NS3levdsRIUOmiJ8FZWCP7LG3QpJyrs/TE0Zpf1yvZu8cAJJ6QMW92H1c7kWpdIHo8RvmLxN/o2JXTKHp74lUA==",
+ "license": "Unlicense"
+ },
+ "node_modules/rollup": {
+ "version": "4.60.1",
+ "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.60.1.tgz",
+ "integrity": "sha512-VmtB2rFU/GroZ4oL8+ZqXgSA38O6GR8KSIvWmEFv63pQ0G6KaBH9s07PO8XTXP4vI+3UJUEypOfjkGfmSBBR0w==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "@types/estree": "1.0.8"
+ },
+ "bin": {
+ "rollup": "dist/bin/rollup"
+ },
+ "engines": {
+ "node": ">=18.0.0",
+ "npm": ">=8.0.0"
+ },
+ "optionalDependencies": {
+ "@rollup/rollup-android-arm-eabi": "4.60.1",
+ "@rollup/rollup-android-arm64": "4.60.1",
+ "@rollup/rollup-darwin-arm64": "4.60.1",
+ "@rollup/rollup-darwin-x64": "4.60.1",
+ "@rollup/rollup-freebsd-arm64": "4.60.1",
+ "@rollup/rollup-freebsd-x64": "4.60.1",
+ "@rollup/rollup-linux-arm-gnueabihf": "4.60.1",
+ "@rollup/rollup-linux-arm-musleabihf": "4.60.1",
+ "@rollup/rollup-linux-arm64-gnu": "4.60.1",
+ "@rollup/rollup-linux-arm64-musl": "4.60.1",
+ "@rollup/rollup-linux-loong64-gnu": "4.60.1",
+ "@rollup/rollup-linux-loong64-musl": "4.60.1",
+ "@rollup/rollup-linux-ppc64-gnu": "4.60.1",
+ "@rollup/rollup-linux-ppc64-musl": "4.60.1",
+ "@rollup/rollup-linux-riscv64-gnu": "4.60.1",
+ "@rollup/rollup-linux-riscv64-musl": "4.60.1",
+ "@rollup/rollup-linux-s390x-gnu": "4.60.1",
+ "@rollup/rollup-linux-x64-gnu": "4.60.1",
+ "@rollup/rollup-linux-x64-musl": "4.60.1",
+ "@rollup/rollup-openbsd-x64": "4.60.1",
+ "@rollup/rollup-openharmony-arm64": "4.60.1",
+ "@rollup/rollup-win32-arm64-msvc": "4.60.1",
+ "@rollup/rollup-win32-ia32-msvc": "4.60.1",
+ "@rollup/rollup-win32-x64-gnu": "4.60.1",
+ "@rollup/rollup-win32-x64-msvc": "4.60.1",
+ "fsevents": "~2.3.2"
+ }
+ },
+ "node_modules/rw": {
+ "version": "1.3.3",
+ "resolved": "https://registry.npmjs.org/rw/-/rw-1.3.3.tgz",
+ "integrity": "sha512-PdhdWy89SiZogBLaw42zdeqtRJ//zFd2PgQavcICDUgJT5oW10QCRKbJ6bg4r0/UY2M6BWd5tkxuGFRvCkgfHQ==",
+ "license": "BSD-3-Clause"
+ },
+ "node_modules/safe-buffer": {
+ "version": "5.2.1",
+ "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+ "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+ "dev": true,
+ "funding": [
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/feross"
+ },
+ {
+ "type": "patreon",
+ "url": "https://www.patreon.com/feross"
+ },
+ {
+ "type": "consulting",
+ "url": "https://feross.org/support"
+ }
+ ],
+ "license": "MIT"
+ },
+ "node_modules/safer-buffer": {
+ "version": "2.1.2",
+ "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
+ "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
+ "license": "MIT"
+ },
+ "node_modules/sanitize-filename": {
+ "version": "1.6.4",
+ "resolved": "https://registry.npmjs.org/sanitize-filename/-/sanitize-filename-1.6.4.tgz",
+ "integrity": "sha512-9ZyI08PsvdQl2r/bBIGubpVdR3RR9sY6RDiWFPreA21C/EFlQhmgo20UZlNjZMMZNubusLhAQozkA0Od5J21Eg==",
+ "dev": true,
+ "license": "WTFPL OR ISC",
+ "dependencies": {
+ "truncate-utf8-bytes": "^1.0.0"
+ }
+ },
+ "node_modules/sax": {
+ "version": "1.6.0",
+ "resolved": "https://registry.npmjs.org/sax/-/sax-1.6.0.tgz",
+ "integrity": "sha512-6R3J5M4AcbtLUdZmRv2SygeVaM7IhrLXu9BmnOGmmACak8fiUtOsYNWUS4uK7upbmHIBbLBeFeI//477BKLBzA==",
+ "license": "BlueOak-1.0.0",
+ "engines": {
+ "node": ">=11.0.0"
+ }
+ },
+ "node_modules/scheduler": {
+ "version": "0.27.0",
+ "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.27.0.tgz",
+ "integrity": "sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q==",
+ "license": "MIT"
+ },
+ "node_modules/semver": {
+ "version": "6.3.1",
+ "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
+ "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
+ "dev": true,
+ "license": "ISC",
+ "bin": {
+ "semver": "bin/semver.js"
+ }
+ },
+ "node_modules/semver-compare": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/semver-compare/-/semver-compare-1.0.0.tgz",
+ "integrity": "sha512-YM3/ITh2MJ5MtzaM429anh+x2jiLVjqILF4m4oyQB18W7Ggea7BfqdH/wGMK7dDiMghv/6WG7znWMwUDzJiXow==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true
+ },
+ "node_modules/serialize-error": {
+ "version": "7.0.1",
+ "resolved": "https://registry.npmjs.org/serialize-error/-/serialize-error-7.0.1.tgz",
+ "integrity": "sha512-8I8TjW5KMOKsZQTvoxjuSIa7foAwPWGOts+6o7sgjz41/qMD9VQHEDxi6PBvK2l0MXUmqZyNpUK+T2tQaaElvw==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "dependencies": {
+ "type-fest": "^0.13.1"
+ },
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/setimmediate": {
+ "version": "1.0.5",
+ "resolved": "https://registry.npmjs.org/setimmediate/-/setimmediate-1.0.5.tgz",
+ "integrity": "sha512-MATJdZp8sLqDl/68LfQmbP8zKPLQNV6BIZoIgrscFDQ+RsvK/BxeDQOgyxKKoh0y/8h3BqVFnCqQ/gd+reiIXA==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/shebang-command": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
+ "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "shebang-regex": "^3.0.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/shebang-regex": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
+ "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/signal-exit": {
+ "version": "3.0.7",
+ "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz",
+ "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==",
+ "dev": true,
+ "license": "ISC"
+ },
+ "node_modules/simple-update-notifier": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/simple-update-notifier/-/simple-update-notifier-2.0.0.tgz",
+ "integrity": "sha512-a2B9Y0KlNXl9u/vsW6sTIu9vGEpfKu2wRV6l1H3XEas/0gUIzGzBoP/IouTcUQbm9JWZLH3COxyn03TYlFax6w==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "semver": "^7.5.3"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/simple-update-notifier/node_modules/semver": {
+ "version": "7.7.4",
+ "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz",
+ "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==",
+ "dev": true,
+ "license": "ISC",
+ "bin": {
+ "semver": "bin/semver.js"
+ },
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/slice-ansi": {
+ "version": "3.0.0",
+ "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-3.0.0.tgz",
+ "integrity": "sha512-pSyv7bSTC7ig9Dcgbw9AuRNUb5k5V6oDudjZoMBSr13qpLBG7tB+zgCkARjq7xIUgdz5P1Qe8u+rSGdouOOIyQ==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "dependencies": {
+ "ansi-styles": "^4.0.0",
+ "astral-regex": "^2.0.0",
+ "is-fullwidth-code-point": "^3.0.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/smart-buffer": {
+ "version": "4.2.0",
+ "resolved": "https://registry.npmjs.org/smart-buffer/-/smart-buffer-4.2.0.tgz",
+ "integrity": "sha512-94hK0Hh8rPqQl2xXc3HsaBoOXKV20MToPkcXvwbISWLEs+64sBq5kFgn2kJDHb1Pry9yrP0dxrCI9RRci7RXKg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 6.0.0",
+ "npm": ">= 3.0.0"
+ }
+ },
+ "node_modules/socks": {
+ "version": "2.8.7",
+ "resolved": "https://registry.npmjs.org/socks/-/socks-2.8.7.tgz",
+ "integrity": "sha512-HLpt+uLy/pxB+bum/9DzAgiKS8CX1EvbWxI4zlmgGCExImLdiad2iCwXT5Z4c9c3Eq8rP2318mPW2c+QbtjK8A==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "ip-address": "^10.0.1",
+ "smart-buffer": "^4.2.0"
+ },
+ "engines": {
+ "node": ">= 10.0.0",
+ "npm": ">= 3.0.0"
+ }
+ },
+ "node_modules/socks-proxy-agent": {
+ "version": "8.0.5",
+ "resolved": "https://registry.npmjs.org/socks-proxy-agent/-/socks-proxy-agent-8.0.5.tgz",
+ "integrity": "sha512-HehCEsotFqbPW9sJ8WVYB6UbmIMv7kUUORIF2Nncq4VQvBfNBLibW9YZR5dlYCSUhwcD628pRllm7n+E+YTzJw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "agent-base": "^7.1.2",
+ "debug": "^4.3.4",
+ "socks": "^2.8.3"
+ },
+ "engines": {
+ "node": ">= 14"
+ }
+ },
+ "node_modules/source-map": {
+ "version": "0.5.7",
+ "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz",
+ "integrity": "sha512-LbrmJOMUSdEVxIKvdcJzQC+nQhe8FUZQTXQy6+I75skNgn3OoQ0DZA8YnFa7gp8tqtL3KPf1kmo0R5DoApeSGQ==",
+ "license": "BSD-3-Clause",
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/source-map-js": {
+ "version": "1.2.1",
+ "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
+ "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
+ "dev": true,
+ "license": "BSD-3-Clause",
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/source-map-support": {
+ "version": "0.5.21",
+ "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.21.tgz",
+ "integrity": "sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "buffer-from": "^1.0.0",
+ "source-map": "^0.6.0"
+ }
+ },
+ "node_modules/source-map-support/node_modules/source-map": {
+ "version": "0.6.1",
+ "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
+ "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
+ "dev": true,
+ "license": "BSD-3-Clause",
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/sprintf-js": {
+ "version": "1.1.3",
+ "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.1.3.tgz",
+ "integrity": "sha512-Oo+0REFV59/rz3gfJNKQiBlwfHaSESl1pcGyABQsnnIfWOFt6JNj5gCog2U6MLZ//IGYD+nA8nI+mTShREReaA==",
+ "dev": true,
+ "license": "BSD-3-Clause",
+ "optional": true
+ },
+ "node_modules/ssri": {
+ "version": "12.0.0",
+ "resolved": "https://registry.npmjs.org/ssri/-/ssri-12.0.0.tgz",
+ "integrity": "sha512-S7iGNosepx9RadX82oimUkvr0Ct7IjJbEbs4mJcTxst8um95J3sDYU1RBEOvdu6oL1Wek2ODI5i4MAw+dZ6cAQ==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "minipass": "^7.0.3"
+ },
+ "engines": {
+ "node": "^18.17.0 || >=20.5.0"
+ }
+ },
+ "node_modules/stat-mode": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/stat-mode/-/stat-mode-1.0.0.tgz",
+ "integrity": "sha512-jH9EhtKIjuXZ2cWxmXS8ZP80XyC3iasQxMDV8jzhNJpfDb7VbQLVW4Wvsxz9QZvzV+G4YoSfBUVKDOyxLzi/sg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 6"
+ }
+ },
+ "node_modules/string_decoder": {
+ "version": "1.3.0",
+ "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz",
+ "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "safe-buffer": "~5.2.0"
+ }
+ },
+ "node_modules/string-width": {
+ "version": "4.2.3",
+ "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+ "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "emoji-regex": "^8.0.0",
+ "is-fullwidth-code-point": "^3.0.0",
+ "strip-ansi": "^6.0.1"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/string-width-cjs": {
+ "name": "string-width",
+ "version": "4.2.3",
+ "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
+ "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "emoji-regex": "^8.0.0",
+ "is-fullwidth-code-point": "^3.0.0",
+ "strip-ansi": "^6.0.1"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/strip-ansi": {
+ "version": "6.0.1",
+ "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+ "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "ansi-regex": "^5.0.1"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/strip-ansi-cjs": {
+ "name": "strip-ansi",
+ "version": "6.0.1",
+ "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
+ "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "ansi-regex": "^5.0.1"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/stylis": {
+ "version": "4.2.0",
+ "resolved": "https://registry.npmjs.org/stylis/-/stylis-4.2.0.tgz",
+ "integrity": "sha512-Orov6g6BB1sDfYgzWfTHDOxamtX1bE/zo104Dh9e6fqJ3PooipYyfJ0pUmrZO2wAvO8YbEyeFrkV91XTsGMSrw==",
+ "license": "MIT"
+ },
+ "node_modules/sumchecker": {
+ "version": "3.0.1",
+ "resolved": "https://registry.npmjs.org/sumchecker/-/sumchecker-3.0.1.tgz",
+ "integrity": "sha512-MvjXzkz/BOfyVDkG0oFOtBxHX2u3gKbMHIF/dXblZsgD3BWOFLmHovIpZY7BykJdAjcqRCBi1WYBNdEC9yI7vg==",
+ "dev": true,
+ "license": "Apache-2.0",
+ "dependencies": {
+ "debug": "^4.1.0"
+ },
+ "engines": {
+ "node": ">= 8.0"
+ }
+ },
+ "node_modules/superjson": {
+ "version": "2.2.6",
+ "resolved": "https://registry.npmjs.org/superjson/-/superjson-2.2.6.tgz",
+ "integrity": "sha512-H+ue8Zo4vJmV2nRjpx86P35lzwDT3nItnIsocgumgr0hHMQ+ZGq5vrERg9kJBo5AWGmxZDhzDo+WVIJqkB0cGA==",
+ "license": "MIT",
+ "dependencies": {
+ "copy-anything": "^4"
+ },
+ "engines": {
+ "node": ">=16"
+ }
+ },
+ "node_modules/supports-color": {
+ "version": "7.2.0",
+ "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
+ "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "has-flag": "^4.0.0"
+ },
+ "engines": {
+ "node": ">=8"
+ }
+ },
+ "node_modules/supports-preserve-symlinks-flag": {
+ "version": "1.0.0",
+ "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz",
+ "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==",
+ "license": "MIT",
+ "engines": {
+ "node": ">= 0.4"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/ljharb"
+ }
+ },
+ "node_modules/tar": {
+ "version": "7.5.13",
+ "resolved": "https://registry.npmjs.org/tar/-/tar-7.5.13.tgz",
+ "integrity": "sha512-tOG/7GyXpFevhXVh8jOPJrmtRpOTsYqUIkVdVooZYJS/z8WhfQUX8RJILmeuJNinGAMSu1veBr4asSHFt5/hng==",
+ "dev": true,
+ "license": "BlueOak-1.0.0",
+ "dependencies": {
+ "@isaacs/fs-minipass": "^4.0.0",
+ "chownr": "^3.0.0",
+ "minipass": "^7.1.2",
+ "minizlib": "^3.1.0",
+ "yallist": "^5.0.0"
+ },
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/tar/node_modules/yallist": {
+ "version": "5.0.0",
+ "resolved": "https://registry.npmjs.org/yallist/-/yallist-5.0.0.tgz",
+ "integrity": "sha512-YgvUTfwqyc7UXVMrB+SImsVYSmTS8X/tSrtdNZMImM+n7+QTriRXyXim0mBrTXNeqzVF0KWGgHPeiyViFFrNDw==",
+ "dev": true,
+ "license": "BlueOak-1.0.0",
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/temp": {
+ "version": "0.9.4",
+ "resolved": "https://registry.npmjs.org/temp/-/temp-0.9.4.tgz",
+ "integrity": "sha512-yYrrsWnrXMcdsnu/7YMYAofM1ktpL5By7vZhf15CrXijWWrEYZks5AXBudalfSWJLlnen/QUJUB5aoB0kqZUGA==",
+ "dev": true,
+ "license": "MIT",
+ "peer": true,
+ "dependencies": {
+ "mkdirp": "^0.5.1",
+ "rimraf": "~2.6.2"
+ },
+ "engines": {
+ "node": ">=6.0.0"
+ }
+ },
+ "node_modules/temp-file": {
+ "version": "3.4.0",
+ "resolved": "https://registry.npmjs.org/temp-file/-/temp-file-3.4.0.tgz",
+ "integrity": "sha512-C5tjlC/HCtVUOi3KWVokd4vHVViOmGjtLwIh4MuzPo/nMYTV/p1urt3RnMz2IWXDdKEGJH3k5+KPxtqRsUYGtg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "async-exit-hook": "^2.0.1",
+ "fs-extra": "^10.0.0"
+ }
+ },
+ "node_modules/temp-file/node_modules/fs-extra": {
+ "version": "10.1.0",
+ "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-10.1.0.tgz",
+ "integrity": "sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "graceful-fs": "^4.2.0",
+ "jsonfile": "^6.0.1",
+ "universalify": "^2.0.0"
+ },
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/temp-file/node_modules/jsonfile": {
+ "version": "6.2.0",
+ "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.0.tgz",
+ "integrity": "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "universalify": "^2.0.0"
+ },
+ "optionalDependencies": {
+ "graceful-fs": "^4.1.6"
+ }
+ },
+ "node_modules/temp-file/node_modules/universalify": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
+ "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 10.0.0"
+ }
+ },
+ "node_modules/tiny-async-pool": {
+ "version": "1.3.0",
+ "resolved": "https://registry.npmjs.org/tiny-async-pool/-/tiny-async-pool-1.3.0.tgz",
+ "integrity": "sha512-01EAw5EDrcVrdgyCLgoSPvqznC0sVxDSVeiOz09FUpjh71G79VCqneOr+xvt7T1r76CF6ZZfPjHorN2+d+3mqA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "semver": "^5.5.0"
+ }
+ },
+ "node_modules/tiny-async-pool/node_modules/semver": {
+ "version": "5.7.2",
+ "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.2.tgz",
+ "integrity": "sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g==",
+ "dev": true,
+ "license": "ISC",
+ "bin": {
+ "semver": "bin/semver"
+ }
+ },
+ "node_modules/tiny-typed-emitter": {
+ "version": "2.1.0",
+ "resolved": "https://registry.npmjs.org/tiny-typed-emitter/-/tiny-typed-emitter-2.1.0.tgz",
+ "integrity": "sha512-qVtvMxeXbVej0cQWKqVSSAHmKZEHAvxdF8HEUBFWts8h+xEo5m/lEiPakuyZ3BnCBjOD8i24kzNOiOLLgsSxhA==",
+ "license": "MIT"
+ },
+ "node_modules/tinyglobby": {
+ "version": "0.2.15",
+ "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz",
+ "integrity": "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "fdir": "^6.5.0",
+ "picomatch": "^4.0.3"
+ },
+ "engines": {
+ "node": ">=12.0.0"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/SuperchupuDev"
+ }
+ },
+ "node_modules/tmp": {
+ "version": "0.2.5",
+ "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.2.5.tgz",
+ "integrity": "sha512-voyz6MApa1rQGUxT3E+BK7/ROe8itEx7vD8/HEvt4xwXucvQ5G5oeEiHkmHZJuBO21RpOf+YYm9MOivj709jow==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=14.14"
+ }
+ },
+ "node_modules/tmp-promise": {
+ "version": "3.0.3",
+ "resolved": "https://registry.npmjs.org/tmp-promise/-/tmp-promise-3.0.3.tgz",
+ "integrity": "sha512-RwM7MoPojPxsOBYnyd2hy0bxtIlVrihNs9pj5SUvY8Zz1sQcQG2tG1hSr8PDxfgEB8RNKDhqbIlroIarSNDNsQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "tmp": "^0.2.0"
+ }
+ },
+ "node_modules/tree-kill": {
+ "version": "1.2.2",
+ "resolved": "https://registry.npmjs.org/tree-kill/-/tree-kill-1.2.2.tgz",
+ "integrity": "sha512-L0Orpi8qGpRG//Nd+H90vFB+3iHnue1zSSGmNOOCh1GLJ7rUKVwV2HvijphGQS2UmhUZewS9VgvxYIdgr+fG1A==",
+ "license": "MIT",
+ "bin": {
+ "tree-kill": "cli.js"
+ }
+ },
+ "node_modules/truncate-utf8-bytes": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/truncate-utf8-bytes/-/truncate-utf8-bytes-1.0.2.tgz",
+ "integrity": "sha512-95Pu1QXQvruGEhv62XCMO3Mm90GscOCClvrIUwCM0PYOXK3kaF3l3sIHxx71ThJfcbM2O5Au6SO3AWCSEfW4mQ==",
+ "dev": true,
+ "license": "WTFPL",
+ "dependencies": {
+ "utf8-byte-length": "^1.0.1"
+ }
+ },
+ "node_modules/type-fest": {
+ "version": "0.13.1",
+ "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.13.1.tgz",
+ "integrity": "sha512-34R7HTnG0XIJcBSn5XhDd7nNFPRcXYRZrBB2O2jdKqYODldSzBAqzsWoZYYvduky73toYS/ESqxPvkDf/F0XMg==",
+ "dev": true,
+ "license": "(MIT OR CC0-1.0)",
+ "optional": true,
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/typescript": {
+ "version": "6.0.2",
+ "resolved": "https://registry.npmjs.org/typescript/-/typescript-6.0.2.tgz",
+ "integrity": "sha512-bGdAIrZ0wiGDo5l8c++HWtbaNCWTS4UTv7RaTH/ThVIgjkveJt83m74bBHMJkuCbslY8ixgLBVZJIOiQlQTjfQ==",
+ "license": "Apache-2.0",
+ "peer": true,
+ "bin": {
+ "tsc": "bin/tsc",
+ "tsserver": "bin/tsserver"
+ },
+ "engines": {
+ "node": ">=14.17"
+ }
+ },
+ "node_modules/undici-types": {
+ "version": "6.21.0",
+ "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
+ "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/unique-filename": {
+ "version": "4.0.0",
+ "resolved": "https://registry.npmjs.org/unique-filename/-/unique-filename-4.0.0.tgz",
+ "integrity": "sha512-XSnEewXmQ+veP7xX2dS5Q4yZAvO40cBN2MWkJ7D/6sW4Dg6wYBNwM1Vrnz1FhH5AdeLIlUXRI9e28z1YZi71NQ==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "unique-slug": "^5.0.0"
+ },
+ "engines": {
+ "node": "^18.17.0 || >=20.5.0"
+ }
+ },
+ "node_modules/unique-slug": {
+ "version": "5.0.0",
+ "resolved": "https://registry.npmjs.org/unique-slug/-/unique-slug-5.0.0.tgz",
+ "integrity": "sha512-9OdaqO5kwqR+1kVgHAhsp5vPNU0hnxRa26rBFNfNgM7M6pNtgzeBn3s/xbyCQL3dcjzOatcef6UUHpB/6MaETg==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "imurmurhash": "^0.1.4"
+ },
+ "engines": {
+ "node": "^18.17.0 || >=20.5.0"
+ }
+ },
+ "node_modules/universalify": {
+ "version": "0.1.2",
+ "resolved": "https://registry.npmjs.org/universalify/-/universalify-0.1.2.tgz",
+ "integrity": "sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">= 4.0.0"
+ }
+ },
+ "node_modules/unzip-crx-3": {
+ "version": "0.2.0",
+ "resolved": "https://registry.npmjs.org/unzip-crx-3/-/unzip-crx-3-0.2.0.tgz",
+ "integrity": "sha512-0+JiUq/z7faJ6oifVB5nSwt589v1KCduqIJupNVDoWSXZtWDmjDGO3RAEOvwJ07w90aoXoP4enKsR7ecMrJtWQ==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "jszip": "^3.1.0",
+ "mkdirp": "^0.5.1",
+ "yaku": "^0.16.6"
+ }
+ },
+ "node_modules/update-browserslist-db": {
+ "version": "1.2.3",
+ "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.2.3.tgz",
+ "integrity": "sha512-Js0m9cx+qOgDxo0eMiFGEueWztz+d4+M3rGlmKPT+T4IS/jP4ylw3Nwpu6cpTTP8R1MAC1kF4VbdLt3ARf209w==",
+ "dev": true,
+ "funding": [
+ {
+ "type": "opencollective",
+ "url": "https://opencollective.com/browserslist"
+ },
+ {
+ "type": "tidelift",
+ "url": "https://tidelift.com/funding/github/npm/browserslist"
+ },
+ {
+ "type": "github",
+ "url": "https://github.com/sponsors/ai"
+ }
+ ],
+ "license": "MIT",
+ "dependencies": {
+ "escalade": "^3.2.0",
+ "picocolors": "^1.1.1"
+ },
+ "bin": {
+ "update-browserslist-db": "cli.js"
+ },
+ "peerDependencies": {
+ "browserslist": ">= 4.21.0"
+ }
+ },
+ "node_modules/uri-js": {
+ "version": "4.4.1",
+ "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz",
+ "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==",
+ "dev": true,
+ "license": "BSD-2-Clause",
+ "dependencies": {
+ "punycode": "^2.1.0"
+ }
+ },
+ "node_modules/use-sync-external-store": {
+ "version": "1.6.0",
+ "resolved": "https://registry.npmjs.org/use-sync-external-store/-/use-sync-external-store-1.6.0.tgz",
+ "integrity": "sha512-Pp6GSwGP/NrPIrxVFAIkOQeyw8lFenOHijQWkUTrDvrF4ALqylP2C/KCkeS9dpUM3KvYRQhna5vt7IL95+ZQ9w==",
+ "license": "MIT",
+ "peerDependencies": {
+ "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
+ }
+ },
+ "node_modules/utf8-byte-length": {
+ "version": "1.0.5",
+ "resolved": "https://registry.npmjs.org/utf8-byte-length/-/utf8-byte-length-1.0.5.tgz",
+ "integrity": "sha512-Xn0w3MtiQ6zoz2vFyUVruaCL53O/DwUvkEeOvj+uulMm0BkUGYWmBYVyElqZaSLhY6ZD0ulfU3aBra2aVT4xfA==",
+ "dev": true,
+ "license": "(WTFPL OR MIT)"
+ },
+ "node_modules/util-deprecate": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
+ "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/verror": {
+ "version": "1.10.1",
+ "resolved": "https://registry.npmjs.org/verror/-/verror-1.10.1.tgz",
+ "integrity": "sha512-veufcmxri4e3XSrT0xwfUR7kguIkaxBeosDg00yDWhk49wdwkSUrvvsm7nc75e1PUyvIeZj6nS8VQRYz2/S4Xg==",
+ "dev": true,
+ "license": "MIT",
+ "optional": true,
+ "dependencies": {
+ "assert-plus": "^1.0.0",
+ "core-util-is": "1.0.2",
+ "extsprintf": "^1.2.0"
+ },
+ "engines": {
+ "node": ">=0.6.0"
+ }
+ },
+ "node_modules/vite": {
+ "version": "7.3.1",
+ "resolved": "https://registry.npmjs.org/vite/-/vite-7.3.1.tgz",
+ "integrity": "sha512-w+N7Hifpc3gRjZ63vYBXA56dvvRlNWRczTdmCBBa+CotUzAPf5b7YMdMR/8CQoeYE5LX3W4wj6RYTgonm1b9DA==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "esbuild": "^0.27.0",
+ "fdir": "^6.5.0",
+ "picomatch": "^4.0.3",
+ "postcss": "^8.5.6",
+ "rollup": "^4.43.0",
+ "tinyglobby": "^0.2.15"
+ },
+ "bin": {
+ "vite": "bin/vite.js"
+ },
+ "engines": {
+ "node": "^20.19.0 || >=22.12.0"
+ },
+ "funding": {
+ "url": "https://github.com/vitejs/vite?sponsor=1"
+ },
+ "optionalDependencies": {
+ "fsevents": "~2.3.3"
+ },
+ "peerDependencies": {
+ "@types/node": "^20.19.0 || >=22.12.0",
+ "jiti": ">=1.21.0",
+ "less": "^4.0.0",
+ "lightningcss": "^1.21.0",
+ "sass": "^1.70.0",
+ "sass-embedded": "^1.70.0",
+ "stylus": ">=0.54.8",
+ "sugarss": "^5.0.0",
+ "terser": "^5.16.0",
+ "tsx": "^4.8.1",
+ "yaml": "^2.4.2"
+ },
+ "peerDependenciesMeta": {
+ "@types/node": {
+ "optional": true
+ },
+ "jiti": {
+ "optional": true
+ },
+ "less": {
+ "optional": true
+ },
+ "lightningcss": {
+ "optional": true
+ },
+ "sass": {
+ "optional": true
+ },
+ "sass-embedded": {
+ "optional": true
+ },
+ "stylus": {
+ "optional": true
+ },
+ "sugarss": {
+ "optional": true
+ },
+ "terser": {
+ "optional": true
+ },
+ "tsx": {
+ "optional": true
+ },
+ "yaml": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/vite-plugin-electron": {
+ "version": "0.28.8",
+ "resolved": "https://registry.npmjs.org/vite-plugin-electron/-/vite-plugin-electron-0.28.8.tgz",
+ "integrity": "sha512-ir+B21oSGK9j23OEvt4EXyco9xDCaF6OGFe0V/8Zc0yL2+HMyQ6mmNQEIhXsEsZCSfIowBpwQBeHH4wVsfraeg==",
+ "dev": true,
+ "license": "MIT",
+ "peerDependencies": {
+ "vite-plugin-electron-renderer": "*"
+ },
+ "peerDependenciesMeta": {
+ "vite-plugin-electron-renderer": {
+ "optional": true
+ }
+ }
+ },
+ "node_modules/vite-plugin-electron-renderer": {
+ "version": "0.14.6",
+ "resolved": "https://registry.npmjs.org/vite-plugin-electron-renderer/-/vite-plugin-electron-renderer-0.14.6.tgz",
+ "integrity": "sha512-oqkWFa7kQIkvHXG7+Mnl1RTroA4sP0yesKatmAy0gjZC4VwUqlvF9IvOpHd1fpLWsqYX/eZlVxlhULNtaQ78Jw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/vite/node_modules/fsevents": {
+ "version": "2.3.3",
+ "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
+ "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==",
+ "dev": true,
+ "hasInstallScript": true,
+ "license": "MIT",
+ "optional": true,
+ "os": [
+ "darwin"
+ ],
+ "engines": {
+ "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+ }
+ },
+ "node_modules/void-elements": {
+ "version": "3.1.0",
+ "resolved": "https://registry.npmjs.org/void-elements/-/void-elements-3.1.0.tgz",
+ "integrity": "sha512-Dhxzh5HZuiHQhbvTW9AMetFfBHDMYpo23Uo9btPXgdYP+3T5S+p+jgNy7spra+veYhBP2dCSgxR/i2Y02h5/6w==",
+ "license": "MIT",
+ "engines": {
+ "node": ">=0.10.0"
+ }
+ },
+ "node_modules/wcwidth": {
+ "version": "1.0.1",
+ "resolved": "https://registry.npmjs.org/wcwidth/-/wcwidth-1.0.1.tgz",
+ "integrity": "sha512-XHPEwS0q6TaxcvG85+8EYkbiCux2XtWG2mkc47Ng2A77BQu9+DqIOJldST4HgPkuea7dvKSj5VgX3P1d4rW8Tg==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "defaults": "^1.0.3"
+ }
+ },
+ "node_modules/which": {
+ "version": "2.0.2",
+ "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
+ "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
+ "dev": true,
+ "license": "ISC",
+ "dependencies": {
+ "isexe": "^2.0.0"
+ },
+ "bin": {
+ "node-which": "bin/node-which"
+ },
+ "engines": {
+ "node": ">= 8"
+ }
+ },
+ "node_modules/wrap-ansi": {
+ "version": "7.0.0",
+ "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
+ "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "ansi-styles": "^4.0.0",
+ "string-width": "^4.1.0",
+ "strip-ansi": "^6.0.0"
+ },
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
+ }
+ },
+ "node_modules/wrap-ansi-cjs": {
+ "name": "wrap-ansi",
+ "version": "7.0.0",
+ "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
+ "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "ansi-styles": "^4.0.0",
+ "string-width": "^4.1.0",
+ "strip-ansi": "^6.0.0"
+ },
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
+ }
+ },
+ "node_modules/wrappy": {
+ "version": "1.0.2",
+ "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
+ "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",
+ "dev": true,
+ "license": "ISC"
+ },
+ "node_modules/xmlbuilder": {
+ "version": "15.1.1",
+ "resolved": "https://registry.npmjs.org/xmlbuilder/-/xmlbuilder-15.1.1.tgz",
+ "integrity": "sha512-yMqGBqtXyeN1e3TGYvgNgDVZ3j84W4cwkOXQswghol6APgZWaff9lnbvN7MHYJOiXsvGPXtjTYJEiC9J2wv9Eg==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=8.0"
+ }
+ },
+ "node_modules/y18n": {
+ "version": "5.0.8",
+ "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz",
+ "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==",
+ "dev": true,
+ "license": "ISC",
+ "engines": {
+ "node": ">=10"
+ }
+ },
+ "node_modules/yaku": {
+ "version": "0.16.7",
+ "resolved": "https://registry.npmjs.org/yaku/-/yaku-0.16.7.tgz",
+ "integrity": "sha512-Syu3IB3rZvKvYk7yTiyl1bo/jiEFaaStrgv1V2TIJTqYPStSMQVO8EQjg/z+DRzLq/4LIIharNT3iH1hylEIRw==",
+ "dev": true,
+ "license": "MIT"
+ },
+ "node_modules/yallist": {
+ "version": "3.1.1",
+ "resolved": "https://registry.npmjs.org/yallist/-/yallist-3.1.1.tgz",
+ "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==",
+ "dev": true,
+ "license": "ISC"
+ },
+ "node_modules/yaml": {
+ "version": "2.8.3",
+ "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.8.3.tgz",
+ "integrity": "sha512-AvbaCLOO2Otw/lW5bmh9d/WEdcDFdQp2Z2ZUH3pX9U2ihyUY0nvLv7J6TrWowklRGPYbB/IuIMfYgxaCPg5Bpg==",
+ "extraneous": true,
+ "license": "ISC",
+ "bin": {
+ "yaml": "bin.mjs"
+ },
+ "engines": {
+ "node": ">= 14.6"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/eemeli"
+ }
+ },
+ "node_modules/yargs": {
+ "version": "17.7.2",
+ "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz",
+ "integrity": "sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "cliui": "^8.0.1",
+ "escalade": "^3.1.1",
+ "get-caller-file": "^2.0.5",
+ "require-directory": "^2.1.1",
+ "string-width": "^4.2.3",
+ "y18n": "^5.0.5",
+ "yargs-parser": "^21.1.1"
+ },
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/yargs-parser": {
+ "version": "21.1.1",
+ "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz",
+ "integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==",
+ "dev": true,
+ "license": "ISC",
+ "engines": {
+ "node": ">=12"
+ }
+ },
+ "node_modules/yauzl": {
+ "version": "2.10.0",
+ "resolved": "https://registry.npmjs.org/yauzl/-/yauzl-2.10.0.tgz",
+ "integrity": "sha512-p4a9I6X6nu6IhoGmBqAcbJy1mlC4j27vEPZX9F4L4/vZT3Lyq1VkFHw/V/PUcB9Buo+DG3iHkT0x3Qya58zc3g==",
+ "dev": true,
+ "license": "MIT",
+ "dependencies": {
+ "buffer-crc32": "~0.2.3",
+ "fd-slicer": "~1.1.0"
+ }
+ },
+ "node_modules/yocto-queue": {
+ "version": "0.1.0",
+ "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz",
+ "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==",
+ "dev": true,
+ "license": "MIT",
+ "engines": {
+ "node": ">=10"
+ },
+ "funding": {
+ "url": "https://github.com/sponsors/sindresorhus"
+ }
+ },
+ "node_modules/zod": {
+ "version": "4.3.6",
+ "resolved": "https://registry.npmjs.org/zod/-/zod-4.3.6.tgz",
+ "integrity": "sha512-rftlrkhHZOcjDwkGlnUtZZkvaPHCsDATp4pGpuOOMDaTdDDXF91wuVDJoWoPsKX/3YPQ5fHuF3STjcYyKr+Qhg==",
+ "license": "MIT",
+ "funding": {
+ "url": "https://github.com/sponsors/colinhacks"
+ }
+ }
+ }
+}
diff --git a/freemocap-ui/src/components/camera-config-panel/CameraConfigExposure.tsx b/freemocap-ui/src/components/camera-config-panel/CameraConfigExposure.tsx
new file mode 100644
index 00000000..62b9764a
--- /dev/null
+++ b/freemocap-ui/src/components/camera-config-panel/CameraConfigExposure.tsx
@@ -0,0 +1,153 @@
+import React from 'react';
+import { Box, Slider, ToggleButton, ToggleButtonGroup, Tooltip, Typography, useTheme } from '@mui/material';
+import { ExposureMode } from "@/store/slices/cameras/cameras-types";
+import { useTranslation } from 'react-i18next';
+
+interface CameraConfigExposureProps {
+ exposureMode: ExposureMode;
+ exposure: number;
+ onExposureModeChange: (mode: ExposureMode) => void;
+ onExposureValueChange: (value: number) => void;
+}
+
+const ValueLabelComponent = (props: {
+ children: React.ReactElement;
+ value: number;
+}) => {
+ const { children, value } = props;
+
+ return (
+ <Tooltip title={
+ <span>
+ {`${(1000 / Math.pow(2, -1 * value)).toFixed(3)}ms (1/2`}
+ <sup>{value}</sup>
+ {` sec)`}
+ </span>
+ }>
+ {children}
+ </Tooltip>
+ );
+};
+
+// Default constraints for exposure
+const EXPOSURE_CONSTRAINTS = {
+ min: -13,
+ max: -4,
+ default: -7
+};
+
+export const CameraConfigExposure: React.FC<CameraConfigExposureProps> = ({
+ exposureMode = 'MANUAL',
+ exposure = EXPOSURE_CONSTRAINTS.default,
+ onExposureModeChange,
+ onExposureValueChange
+ }) => {
+ const theme = useTheme();
+ const { t } = useTranslation();
+
+ const handleModeChange = (
+ event: React.MouseEvent<HTMLElement>,
+ newMode: string | null,
+ ): void => {
+ if (newMode !== null) {
+ onExposureModeChange(newMode as ExposureMode);
+ }
+ };
+
+ const handleSliderChange = (event: Event, value: number | number[]): void => {
+ onExposureValueChange(value as number);
+ };
+
+ const baseMarks = [
+ { value: EXPOSURE_CONSTRAINTS.min, label: String(EXPOSURE_CONSTRAINTS.min) },
+ {
+ value: EXPOSURE_CONSTRAINTS.default,
+ label: `${EXPOSURE_CONSTRAINTS.default} (default)`
+ },
+ { value: EXPOSURE_CONSTRAINTS.max, label: String(EXPOSURE_CONSTRAINTS.max) }
+ ];
+
+ const marks = [
+ ...baseMarks,
+ ...(![
+ EXPOSURE_CONSTRAINTS.min as number,
+ EXPOSURE_CONSTRAINTS.default as number,
+ EXPOSURE_CONSTRAINTS.max as number
+ ].includes(exposure)
+ ? [{
+ value: exposure,
+ label: `${exposure}`,
+ }]
+ : []
+ )
+ ].sort((a, b) => a.value - b.value);
+
+ return (
+ <Box>
+ {/* Label and mode toggle on the same line */}
+ <Box sx={{display: 'flex', alignItems: 'center', gap: 1.5, mb: 0.5}}>
+ <Typography variant="body2" color="text.secondary" sx={{whiteSpace: 'nowrap', fontSize: 12}}>
+ {t("exposure")}
+ </Typography>
+ <Tooltip title={t("exposureControl")}>
+ <ToggleButtonGroup
+ color={theme.palette.primary.main as any}
+ value={exposureMode}
+ exclusive
+ onChange={handleModeChange}
+ size="small"
+ sx={{
+ '& .MuiToggleButton-root': {
+ py: 0.25,
+ px: 1,
+ fontSize: 11,
+ },
+ '& .MuiToggleButton-root.Mui-selected': {
+ backgroundColor: theme.palette.primary.dark,
+ border: `1px solid ${theme.palette.text.secondary}`,
+ color: theme.palette.primary.contrastText,
+ '&:hover': {
+ backgroundColor: theme.palette.primary.light,
+ },
+ }
+ }}
+ >
+ <ToggleButton value="MANUAL">{t("manual")}</ToggleButton>
+ <ToggleButton value="AUTO">{t("auto")}</ToggleButton>
+ <ToggleButton value="RECOMMEND">{t("recommend")}</ToggleButton>
+ </ToggleButtonGroup>
+ </Tooltip>
+ </Box>
+ <Tooltip title={t("adjustExposure")}>
+ <Box sx={{px: 1}}>
+ <Slider
+ value={exposure}
+ disabled={exposureMode === 'AUTO' || exposureMode === 'RECOMMEND'}
+ min={EXPOSURE_CONSTRAINTS.min}
+ max={EXPOSURE_CONSTRAINTS.max}
+ step={1}
+ marks={marks}
+ valueLabelDisplay="auto"
+ onChange={handleSliderChange}
+ components={{
+ ValueLabel: ValueLabelComponent
+ }}
+ sx={{
+ color: theme.palette.primary.light,
+ '& .MuiSlider-markLabel': {
+ fontSize: 11,
+ },
+ '& .MuiSlider-thumb': {
+ width: 16,
+ height: 16,
+ '&:hover, &.Mui-focusVisible': {
+ boxShadow: `0px 0px 0px 8px ${theme.palette.primary.light}33`,
+ },
+ },
+ }}
+ />
+ </Box>
+ </Tooltip>
+ </Box>
+ );
+};
diff --git a/freemocap-ui/src/components/camera-config-panel/CameraConfigFramerate.tsx b/freemocap-ui/src/components/camera-config-panel/CameraConfigFramerate.tsx
new file mode 100644
index 00000000..4ecaa843
--- /dev/null
+++ b/freemocap-ui/src/components/camera-config-panel/CameraConfigFramerate.tsx
@@ -0,0 +1,174 @@
+import React, { useState } from 'react';
+import { Box, TextField, ToggleButton, ToggleButtonGroup, Tooltip, Typography, useTheme } from '@mui/material';
+import { useTranslation } from 'react-i18next';
+
+interface CameraConfigFramerateProps {
+ framerate: number | null;
+ onChange: (value: number | null) => void;
+}
+
+const FRAMERATE_CONSTRAINTS = {
+ min: 1,
+ max: 1000,
+ default: 30
+};
+
+export const CameraConfigFramerate: React.FC<CameraConfigFramerateProps> = ({
+ framerate = FRAMERATE_CONSTRAINTS.default,
+ onChange
+}) => {
+ const theme = useTheme();
+ const { t } = useTranslation();
+ const isAuto = framerate === null;
+ const [mode, setMode] = useState<'AUTO' | 'MANUAL'>(isAuto ? 'AUTO' : 'MANUAL');
+ const [localValue, setLocalValue] = useState<string>(
+ isAuto ? FRAMERATE_CONSTRAINTS.default.toFixed(2) : framerate.toFixed(2)
+ );
+ const [error, setError] = useState<string>('');
+
+ const validateAndUpdate = (value: string): void => {
+ const numValue = parseFloat(value);
+
+ if (value === '' || isNaN(numValue)) {
+ setError('Enter a valid number');
+ return;
+ }
+
+ if (numValue < FRAMERATE_CONSTRAINTS.min) {
+ setError(`Min: ${FRAMERATE_CONSTRAINTS.min} FPS`);
+ return;
+ }
+
+ if (numValue > FRAMERATE_CONSTRAINTS.max) {
+ setError(`Max: ${FRAMERATE_CONSTRAINTS.max} FPS`);
+ return;
+ }
+
+ setError('');
+ const roundedValue = Math.round(numValue * 100) / 100;
+ onChange(roundedValue);
+ };
+
+ const handleModeChange = (
+ event: React.MouseEvent<HTMLElement>,
+ newMode: 'AUTO' | 'MANUAL' | null
+ ): void => {
+ if (newMode === null) return;
+
+ setMode(newMode);
+
+ if (newMode === 'AUTO') {
+ setError('');
+ onChange(null);
+ } else {
+ // Switch to manual mode with the last valid value
+ validateAndUpdate(localValue);
+ }
+ };
+
+ const handleChange = (event: React.ChangeEvent<HTMLInputElement>): void => {
+ const value = event.target.value;
+ setLocalValue(value);
+ };
+
+ const handleBlur = (): void => {
+ validateAndUpdate(localValue);
+
+ // Reset to valid value if invalid, otherwise format to 2 decimals
+ if (error) {
+ const validValue = framerate === null ? FRAMERATE_CONSTRAINTS.default : framerate;
+ setLocalValue(validValue.toFixed(2));
+ setError('');
+ } else {
+ setLocalValue(parseFloat(localValue).toFixed(2));
+ }
+ };
+
+ const handleKeyDown = (event: React.KeyboardEvent<HTMLInputElement>): void => {
+ if (event.key === 'Enter') {
+ validateAndUpdate(localValue);
+ if (error) {
+ const validValue = framerate === null ? FRAMERATE_CONSTRAINTS.default : framerate;
+ setLocalValue(validValue.toFixed(2));
+ setError('');
+ } else {
+ setLocalValue(parseFloat(localValue).toFixed(2));
+ }
+ event.currentTarget.blur();
+ }
+ };
+
+ return (
+ <Box>
+ <Typography variant="body2" color="text.secondary" gutterBottom>
+ {t("framerate")}
+ </Typography>
+ <Tooltip title={t("framerateControl")}>
+ <ToggleButtonGroup
+ color={theme.palette.primary.main as any}
+ value={mode}
+ exclusive
+ onChange={handleModeChange}
+ size="small"
+ fullWidth
+ sx={{
+ mb: mode === 'MANUAL' ? 1 : 0,
+ '& .MuiToggleButton-root.Mui-selected': {
+ backgroundColor: theme.palette.primary.dark,
+ border: `1px solid ${theme.palette.text.secondary}`,
+ color: theme.palette.primary.contrastText,
+ '&:hover': {
+ backgroundColor: theme.palette.primary.light,
+ },
+ }
+ }}
+ >
+ <ToggleButton value="AUTO">{t("auto")}</ToggleButton>
+ <ToggleButton value="MANUAL">{t("manual")}</ToggleButton>
+ </ToggleButtonGroup>
+ </Tooltip>
+
+ {mode === 'MANUAL' && (
+ <Tooltip title={t("setTargetFps")}>
+ <TextField
+ label={t("fps")}
+ value={localValue}
+ onChange={handleChange}
+ onBlur={handleBlur}
+ onKeyDown={handleKeyDown}
+ type="number"
+ size="small"
+ error={!!error}
+ helperText={error}
+ fullWidth
+ inputProps={{
+ min: FRAMERATE_CONSTRAINTS.min,
+ max: FRAMERATE_CONSTRAINTS.max,
+ step: 0.01,
+ }}
+ sx={{
+ '& .MuiInputLabel-root': {
+ color: theme.palette.text.primary,
+ },
+ '& .MuiOutlinedInput-root': {
+ color: theme.palette.text.primary,
+ '& fieldset': {
+ borderColor: theme.palette.divider,
+ },
+ '&:hover fieldset': {
+ borderColor: theme.palette.primary.main,
+ },
+ '&.Mui-focused fieldset': {
+ borderColor: theme.palette.primary.main,
+ },
+ },
+ '& .MuiFormHelperText-root': {
+ color: error ? theme.palette.error.main : theme.palette.text.secondary,
+ },
+ }}
+ />
+ </Tooltip>
+ )}
+ </Box>
+ );
+};
\ No newline at end of file
diff --git a/freemocap-ui/src/components/camera-config-panel/CameraConfigPanel.tsx b/freemocap-ui/src/components/camera-config-panel/CameraConfigPanel.tsx
new file mode 100644
index 00000000..4dc4a634
--- /dev/null
+++ b/freemocap-ui/src/components/camera-config-panel/CameraConfigPanel.tsx
@@ -0,0 +1,143 @@
+import React from "react";
+import {
+ Box,
+ Collapse,
+ IconButton,
+ Tooltip,
+ useTheme,
+} from "@mui/material";
+import MediationIcon from "@mui/icons-material/Mediation";
+import { CameraConfigResolution } from "./CameraConfigResolution";
+import { CameraConfigExposure } from "./CameraConfigExposure";
+import { CameraConfigRotation } from "./CameraConfigRotation";
+import { CameraConfig, ExposureMode, RotationValue } from "@/store/slices/cameras/cameras-types";
+import { useAppDispatch, useAppSelector } from "@/store";
+import { selectCameras, configCopiedToAll } from "@/store/slices/cameras";
+import { useTranslation } from 'react-i18next';
+
+interface CameraConfigPanelProps {
+ config: CameraConfig;
+ onConfigChange: (newConfig: CameraConfig) => void;
+ isExpanded: boolean;
+}
+
+export const CameraConfigPanel: React.FC<CameraConfigPanelProps> = ({
+ config,
+ onConfigChange,
+ isExpanded,
+}) => {
+ const theme = useTheme();
+ const dispatch = useAppDispatch();
+ const { t } = useTranslation();
+ const allCameras = useAppSelector(selectCameras);
+ const otherCamerasCount = allCameras.length - 1;
+
+ const handleChange = <K extends keyof CameraConfig>(
+ key: K,
+ value: CameraConfig[K]
+ ): void => {
+ onConfigChange({
+ ...config,
+ [key]: value,
+ });
+ };
+
+ const handleCopyToAllCameras = (): void => {
+ dispatch(configCopiedToAll(config.camera_id));
+ };
+
+ const handleResolutionChange = (width: number, height: number): void => {
+ handleChange("resolution", { width, height });
+ };
+
+ const handleRotationChange = (value: RotationValue): void => {
+ handleChange("rotation", value);
+ };
+
+ const handleExposureModeChange = (mode: ExposureMode): void => {
+ handleChange("exposure_mode", mode);
+ };
+
+ const handleExposureValueChange = (value: number): void => {
+ handleChange("exposure", value);
+ };
+
+ return (
+ <Collapse in={isExpanded} timeout="auto" unmountOnExit>
+ <Box
+ sx={{
+ px: 1.5,
+ py: 1,
+ ml: 5,
+ mr: 1,
+ mb: 0.5,
+ borderRadius: 1,
+ border: `1px solid ${theme.palette.divider}`,
+ backgroundColor: theme.palette.background.paper,
+ display: 'flex',
+ flexDirection: 'column',
+ gap: 1,
+ }}
+ >
+ {/* Top row: Resolution, Rotation, then Copy to All pushed right */}
+ <Box sx={{display: 'flex', alignItems: 'center', gap: 1.5, flexWrap: 'wrap'}}>
+ <CameraConfigResolution
+ resolution={config.resolution}
+ onChange={handleResolutionChange}
+ />
+
+ <CameraConfigRotation
+ rotation={config.rotation}
+ onChange={handleRotationChange}
+ />
+
+ {/* Spacer pushes Copy to All to the right */}
+ <Box sx={{flex: 1}}/>
+
+ <Tooltip
+ title={
+ otherCamerasCount > 0
+ ? `Copy settings to ${otherCamerasCount} other camera${
+ otherCamerasCount > 1 ? "s" : ""
+ }`
+ : "No other cameras to copy to"
+ }
+ >
+ <span>
+ <IconButton
+ size="small"
+ onClick={handleCopyToAllCameras}
+ disabled={otherCamerasCount === 0}
+ aria-label={t("copySettingsToAll")}
+ sx={{
+ color: theme.palette.primary.contrastText,
+ border: `1px solid ${theme.palette.divider}`,
+ '&:hover': {
+ backgroundColor: theme.palette.primary.dark,
+ color: theme.palette.primary.contrastText,
+ borderColor: theme.palette.primary.dark,
+ },
+ '&:disabled': {
+ color: theme.palette.action.disabled,
+ },
+ }}
+ >
+ <MediationIcon fontSize="small"/>
+ </IconButton>
+ </span>
+ </Tooltip>
+ </Box>
+
+ {/* Exposure controls */}
+ <Box sx={{pt: 0.5, borderTop: `1px solid ${theme.palette.divider}`}}>
+ <CameraConfigExposure
+ exposureMode={config.exposure_mode}
+ exposure={config.exposure}
+ onExposureModeChange={handleExposureModeChange}
+ onExposureValueChange={handleExposureValueChange}
+ />
+ </Box>
+ </Box>
+ </Collapse>
+ );
+};
diff --git a/freemocap-ui/src/components/camera-config-panel/CameraConfigResolution.tsx b/freemocap-ui/src/components/camera-config-panel/CameraConfigResolution.tsx
new file mode 100644
index 00000000..2c31e0b9
--- /dev/null
+++ b/freemocap-ui/src/components/camera-config-panel/CameraConfigResolution.tsx
@@ -0,0 +1,247 @@
+import React, { useState, useEffect } from "react";
+import {
+ Box,
+ FormControl,
+ InputLabel,
+ MenuItem,
+ Select,
+ TextField,
+ useTheme
+} from "@mui/material";
+import { CameraConfig } from "@/store/slices/cameras/cameras-types";
+import { useTranslation } from 'react-i18next';
+
+interface CameraConfigResolutionProps {
+ resolution: CameraConfig['resolution'];
+ onChange: (width: number, height: number) => void;
+}
+
+const PRESET_RESOLUTIONS = [
+ { width: 640, height: 480, label: "640 x 480" },
+ { width: 1280, height: 720, label: "1280 x 720" },
+ { width: 1920, height: 1080, label: "1920 x 1080" },
+];
+
+const RESOLUTION_CONSTRAINTS = {
+ min: 1,
+ max: 7680, // 8K width probably plent lol
+ default: { width: 1280, height: 720 }
+};
+
+export const CameraConfigResolution: React.FC<CameraConfigResolutionProps> = ({
+ resolution,
+ onChange
+}) => {
+ const theme = useTheme();
+ const { t } = useTranslation();
+ const isPreset = PRESET_RESOLUTIONS.some(
+ preset => preset.width === resolution.width && preset.height === resolution.height
+ );
+
+ const [selectedValue, setSelectedValue] = useState<string>(
+ isPreset ? `${resolution.width}x${resolution.height}` : 'custom'
+ );
+
+ const [customWidth, setCustomWidth] = useState<string>(resolution.width.toString());
+ const [customHeight, setCustomHeight] = useState<string>(resolution.height.toString());
+ const [widthError, setWidthError] = useState<string>('');
+ const [heightError, setHeightError] = useState<string>('');
+
+ // Update custom inputs when resolution prop changes externally
+ useEffect(() => {
+ if (selectedValue === 'custom') {
+ setCustomWidth(resolution.width.toString());
+ setCustomHeight(resolution.height.toString());
+ }
+ }, [resolution.width, resolution.height, selectedValue]);
+
+ const validateDimension = (value: string, dimension: 'width' | 'height'): string => {
+ const numValue = parseInt(value, 10);
+
+ if (value === '' || isNaN(numValue)) {
+ return 'Enter a valid number';
+ }
+
+ if (numValue < RESOLUTION_CONSTRAINTS.min) {
+ return `Min: ${RESOLUTION_CONSTRAINTS.min}px`;
+ }
+
+ if (numValue > RESOLUTION_CONSTRAINTS.max) {
+ return `Max: ${RESOLUTION_CONSTRAINTS.max}px`;
+ }
+
+ return '';
+ };
+
+ const handleSelectChange = (event: any): void => {
+ const value = event.target.value;
+ setSelectedValue(value);
+
+ if (value !== 'custom') {
+ const [width, height] = value.split('x').map(Number);
+ onChange(width, height);
+ }
+ };
+
+ const handleCustomWidthChange = (event: React.ChangeEvent<HTMLInputElement>): void => {
+ const value = event.target.value;
+ setCustomWidth(value);
+
+ const error = validateDimension(value, 'width');
+ setWidthError(error);
+
+ if (!error) {
+ const width = parseInt(value, 10);
+ const height = parseInt(customHeight, 10);
+ if (!isNaN(height)) {
+ onChange(width, height);
+ }
+ }
+ };
+
+ const handleCustomHeightChange = (event: React.ChangeEvent<HTMLInputElement>): void => {
+ const value = event.target.value;
+ setCustomHeight(value);
+
+ const error = validateDimension(value, 'height');
+ setHeightError(error);
+
+ if (!error) {
+ const width = parseInt(customWidth, 10);
+ const height = parseInt(value, 10);
+ if (!isNaN(width)) {
+ onChange(width, height);
+ }
+ }
+ };
+
+ const handleCustomBlur = (dimension: 'width' | 'height'): void => {
+ const value = dimension === 'width' ? customWidth : customHeight;
+ const error = validateDimension(value, dimension);
+
+ if (error) {
+ // Reset to current valid value
+ if (dimension === 'width') {
+ setCustomWidth(resolution.width.toString());
+ setWidthError('');
+ } else {
+ setCustomHeight(resolution.height.toString());
+ setHeightError('');
+ }
+ }
+ };
+
+ const handleKeyDown = (
+ event: React.KeyboardEvent<HTMLDivElement>,
+ dimension: 'width' | 'height'
+ ): void => {
+ if (event.key === 'Enter') {
+ handleCustomBlur(dimension);
+ (event.target as HTMLElement).blur();
+ }
+ };
+
+ return (
+ <Box>
+ <FormControl
+ size="small"
+ fullWidth
+ sx={{
+ color: theme.palette.text.primary,
+ mb: selectedValue === 'custom' ? 1 : 0
+ }}
+ >
+ <InputLabel sx={{ color: theme.palette.text.primary }}>
+ Resolution
+ </InputLabel>
+ <Select
+ value={selectedValue}
+ label={t("resolution")}
+ onChange={handleSelectChange}
+ sx={{ color: theme.palette.text.primary }}
+ >
+ {PRESET_RESOLUTIONS.map(preset => (
+ <MenuItem
+ key={`${preset.width}x${preset.height}`}
+ value={`${preset.width}x${preset.height}`}
+ >
+ {preset.label}
+ </MenuItem>
+ ))}
+ <MenuItem value="custom">{t("custom")}</MenuItem>
+ </Select>
+ </FormControl>
+
+ {selectedValue === 'custom' && (
+ <Box sx={{ display: 'flex', gap: 1, mt: 1 }}>
+ <TextField
+ label={t("width")}
+ value={customWidth}
+ onChange={handleCustomWidthChange}
+ onBlur={() => handleCustomBlur('width')}
+ onKeyDown={(e) => handleKeyDown(e, 'width')}
+ type="number"
+ size="small"
+ error={!!widthError}
+ helperText={widthError}
+ inputProps={{
+ min: RESOLUTION_CONSTRAINTS.min,
+ max: RESOLUTION_CONSTRAINTS.max,
+ }}
+ sx={{
+ flex: 1,
+ '& .MuiInputLabel-root': {
+ color: theme.palette.text.primary,
+ },
+ '& .MuiOutlinedInput-root': {
+ color: theme.palette.text.primary,
+ '& fieldset': {
+ borderColor: theme.palette.primary.contrastText,
+ },
+ '&:hover fieldset': {
+ borderColor: theme.palette.primary.contrastText,
+ },
+ '&.Mui-focused fieldset': {
+ borderColor: theme.palette.primary.contrastText,
+ },
+ },
+ }}
+ />
+ <TextField
+ label={t("height")}
+ value={customHeight}
+ onChange={handleCustomHeightChange}
+ onBlur={() => handleCustomBlur('height')}
+ onKeyDown={(e) => handleKeyDown(e, 'height')}
+ type="number"
+ size="small"
+ error={!!heightError}
+ helperText={heightError}
+ inputProps={{
+ min: RESOLUTION_CONSTRAINTS.min,
+ max: RESOLUTION_CONSTRAINTS.max,
+ }}
+ sx={{
+ flex: 1,
+ '& .MuiInputLabel-root': {
+ color: theme.palette.text.primary,
+ },
+ '& .MuiOutlinedInput-root': {
+ color: theme.palette.text.primary,
+ '& fieldset': {
+ borderColor: theme.palette.primary.contrastText
+ },
+ '&:hover fieldset': {
+ borderColor: theme.palette.primary.contrastText,
+ },
+ '&.Mui-focused fieldset': {
+ borderColor: theme.palette.primary.contrastText
+ },
+ },
+ }}
+ />
+ </Box>
+ )}
+ </Box>
+ );
+};
\ No newline at end of file
diff --git a/freemocap-ui/src/components/camera-config-panel/CameraConfigRotation.tsx b/freemocap-ui/src/components/camera-config-panel/CameraConfigRotation.tsx
new file mode 100644
index 00000000..852ee89d
--- /dev/null
+++ b/freemocap-ui/src/components/camera-config-panel/CameraConfigRotation.tsx
@@ -0,0 +1,61 @@
+import React from 'react';
+import ToggleButton from '@mui/material/ToggleButton';
+import ToggleButtonGroup from '@mui/material/ToggleButtonGroup';
+import { Box, Tooltip, useTheme } from '@mui/material';
+import {ROTATION_DEGREE_LABELS, ROTATION_OPTIONS, RotationValue} from '@/store/slices/cameras/cameras-types';
+import { useTranslation } from 'react-i18next';
+
+interface CameraConfigRotationProps {
+ rotation?: RotationValue;
+ onChange: (rotation: RotationValue) => void;
+}
+
+
+
+export const CameraConfigRotation: React.FC<CameraConfigRotationProps> = ({
+ rotation = -1,
+ onChange
+ }) => {
+ const theme = useTheme();
+ const { t } = useTranslation();
+
+ const handleChange = (
+ event: React.MouseEvent<HTMLElement>,
+ newRotation: RotationValue | null,
+ ): void => {
+ if (newRotation !== null) {
+ onChange(newRotation);
+ }
+ };
+
+ return (
+ <Box>
+ <Tooltip title={t("selectCameraRotation")}>
+ <ToggleButtonGroup
+ color={theme.palette.primary.main as any}
+ value={rotation}
+ size="small"
+ exclusive
+ onChange={handleChange}
+ aria-label={t("cameraRotation")}
+ sx={{
+ '& .MuiToggleButton-root.Mui-selected': {
+ backgroundColor: theme.palette.primary.dark,
+ color: theme.palette.primary.contrastText,
+ border: `1px solid ${theme.palette.text.secondary}`,
+ '&:hover': {
+ backgroundColor: theme.palette.primary.light,
+ },
+ }
+ }}
+ >
+ {ROTATION_OPTIONS.map((option: RotationValue) => (
+ <ToggleButton key={option} value={option}>
+ {ROTATION_DEGREE_LABELS[option]}
+ </ToggleButton>
+ ))}
+ </ToggleButtonGroup>
+ </Tooltip>
+ </Box>
+ );
+};
diff --git a/freemocap-ui/src/components/camera-view-settings-overlay/CamerasViewSettingsOverlay.tsx b/freemocap-ui/src/components/camera-view-settings-overlay/CamerasViewSettingsOverlay.tsx
new file mode 100644
index 00000000..e4b55044
--- /dev/null
+++ b/freemocap-ui/src/components/camera-view-settings-overlay/CamerasViewSettingsOverlay.tsx
@@ -0,0 +1,134 @@
+import React, { useState } from 'react';
+import { Box, Button, IconButton, Paper, TextField, Checkbox, FormControlLabel, Tooltip } from '@mui/material';
+import SettingsIcon from '@mui/icons-material/Settings';
+import CloseIcon from '@mui/icons-material/Close';
+import GridViewIcon from '@mui/icons-material/GridView';
+import RestartAltIcon from '@mui/icons-material/RestartAlt';
+import { useServer } from '@/services/server/ServerContextProvider';
+import { useTranslation } from 'react-i18next';
+
+interface CameraSettings {
+ columns: number | null;
+}
+
+interface CamerasViewSettingsOverlayProps {
+ onSettingsChange: (settings: CameraSettings) => void;
+ onResetLayout: () => void;
+}
+
+export const CamerasViewSettingsOverlay: React.FC<CamerasViewSettingsOverlayProps> = ({
+ onSettingsChange,
+ onResetLayout,
+ }) => {
+ const { connectedCameraIds } = useServer();
+ const { t } = useTranslation();
+ const [isOpen, setIsOpen] = useState<boolean>(false);
+ const [isAuto, setIsAuto] = useState<boolean>(true);
+ const [manualColumns, setManualColumns] = useState<number>(2);
+
+ const getAutoColumns = (total: number): number => {
+ if (total <= 1) return 1;
+ if (total <= 4) return 2;
+ if (total <= 9) return 3;
+ return 4;
+ };
+
+ const autoColumns = getAutoColumns(connectedCameraIds.length);
+
+ const handleAutoChange = (event: React.ChangeEvent<HTMLInputElement>) => {
+ const checked = event.target.checked;
+ setIsAuto(checked);
+ onSettingsChange({ columns: checked ? null : manualColumns });
+ };
+
+ const handleColumnsChange = (event: React.ChangeEvent<HTMLInputElement>) => {
+ const value = parseInt(event.target.value);
+ if (!isNaN(value) && value > 0) {
+ setManualColumns(value);
+ if (isAuto) {
+ setIsAuto(false);
+ }
+ onSettingsChange({ columns: value });
+ }
+ };
+
+ return (
+ <>
+ {/* Settings Button */}
+ <Box
+ sx={{
+ position: 'absolute',
+ top: 16,
+ right: 16,
+ zIndex: 1000,
+ }}
+ >
+ <Tooltip title={isOpen ? t("closeSettings") : t("gridSettings")}>
+ <IconButton
+ onClick={() => setIsOpen(!isOpen)}
+ sx={{
+ backgroundColor: 'background.paper',
+ boxShadow: 2,
+ '&:hover': {
+ backgroundColor: 'action.hover',
+ },
+ }}
+ >
+ {isOpen ? <CloseIcon /> : <SettingsIcon />}
+ </IconButton>
+ </Tooltip>
+ </Box>
+
+ {/* Settings Panel */}
+ {isOpen && (
+ <Paper
+ elevation={8}
+ sx={{
+ position: 'absolute',
+ top: 70,
+ right: 16,
+ zIndex: 999,
+ padding: 2,
+ minWidth: 250,
+ }}
+ >
+ <Box sx={{ display: 'flex', alignItems: 'center', gap: 1, mb: 2 }}>
+ <GridViewIcon fontSize="small" />
+ <Box sx={{ fontWeight: 600 }}>{t("gridColumns")}</Box>
+ </Box>
+
+ <Box sx={{ display: 'flex', alignItems: 'flex-start', gap: 1, mb: 2 }}>
+ <FormControlLabel
+ control={
+ <Checkbox
+ checked={isAuto}
+ onChange={handleAutoChange}
+ sx={{
+ '&.Mui-checked': {
+ color: 'text.primary',
+ },
+ }}
+ />
+ }
+ label={t("auto")}
+ />
+
+ <TextField
+ type="number"
+ label={t("columns")}
+ value={isAuto ? autoColumns : manualColumns}
+ onChange={handleColumnsChange}
+ fullWidth
+ inputProps={{
+ min: 1,
+ step: 1,
+ }}
+ helperText={isAuto ? `Auto-detected: ${autoColumns}` : "Enter any positive number"}
+ />
+ </Box>
+
+ </Paper>
+ )}
+ </>
+ );
+};
diff --git a/freemocap-ui/src/components/camera-view-settings-overlay/ImageScaleSlider.tsx b/freemocap-ui/src/components/camera-view-settings-overlay/ImageScaleSlider.tsx
new file mode 100644
index 00000000..18beb8dd
--- /dev/null
+++ b/freemocap-ui/src/components/camera-view-settings-overlay/ImageScaleSlider.tsx
@@ -0,0 +1,65 @@
+import React from 'react';
+import {Box, Slider, Tooltip, Typography, useTheme} from '@mui/material';
+
+interface ImageScaleSliderProps {
+ scale: number;
+ onScaleChange: (value: number) => void;
+}
+
+const ValueLabelComponent = (props: {
+ children: React.ReactElement;
+ value: number;
+}) => {
+ const {children, value} = props;
+
+ return (
+ <Tooltip title={
+ <span>
+ {`Scale: ${value.toFixed(1)}`}
+ </span>
+ }>
+ {children}
+ </Tooltip>
+ );
+};
+
+export const ImageScaleSlider: React.FC<ImageScaleSliderProps> = ({
+ scale = 0.5,
+ onScaleChange,
+ }) => {
+ const theme = useTheme();
+
+ const marks = [
+ {value: 0.1, label: '0.1'},
+ {value: 0.5, label: '0.5 (default)'},
+ {value: 2.0, label: '2.0'},
+ ];
+
+ return (
+ <Box>
+ <Typography variant="body2" color="text.secondary" gutterBottom>
+ Image Scale
+ </Typography>
+ <Slider
+ value={scale}
+ min={0.1}
+ max={2.0}
+ step={0.1}
+ marks={marks}
+ valueLabelDisplay="auto"
+ onChange={(_, value) => onScaleChange(value as number)}
+ components={{
+ ValueLabel: ValueLabelComponent,
+ }}
+ sx={{
+ color: theme.palette.primary.light,
+ '& .MuiSlider-thumb': {
+ '&:hover, &.Mui-focusVisible': {
+ boxShadow: `0px 0px 0px 8px ${theme.palette.primary.light}33`,
+ },
+ },
+ }}
+ />
+ </Box>
+ );
+};
diff --git a/freemocap-ui/src/components/camera-views/ResizableCameraView.tsx b/freemocap-ui/src/components/camera-views/ResizableCameraView.tsx
new file mode 100644
index 00000000..b3cf65ef
--- /dev/null
+++ b/freemocap-ui/src/components/camera-views/ResizableCameraView.tsx
@@ -0,0 +1,206 @@
+import React, { useState, useCallback, useRef, useEffect } from 'react';
+import { Box } from '@mui/material';
+import { CameraView } from './CameraView';
+
+interface ResizableCameraViewProps {
+ cameraId: string;
+ /** Initial position/size from the auto-layout */
+ initialX: number;
+ initialY: number;
+ initialWidth: number;
+ initialHeight: number;
+ /** Called when the user finishes moving or resizing this view */
+ onLayoutChange: (cameraId: string, x: number, y: number, w: number, h: number) => void;
+ /** Bring this camera to front when interacted with */
+ onFocus: (cameraId: string) => void;
+ zIndex: number;
+}
+
+const MIN_WIDTH = 120;
+const MIN_HEIGHT = 90;
+
+const HANDLE_SIZE = 16;
+
+type DragMode = 'none' | 'move' | 'resize';
+
+/**
+ * A single camera view window that can be freely dragged (by its body)
+ * and resized (by a bottom-right handle) within an absolute-positioned container.
+ */
+export const ResizableCameraView: React.FC<ResizableCameraViewProps> = ({
+ cameraId,
+ initialX,
+ initialY,
+ initialWidth,
+ initialHeight,
+ onLayoutChange,
+ onFocus,
+ zIndex,
+}) => {
+ const [x, setX] = useState<number>(initialX);
+ const [y, setY] = useState<number>(initialY);
+ const [width, setWidth] = useState<number>(initialWidth);
+ const [height, setHeight] = useState<number>(initialHeight);
+ const [dragMode, setDragMode] = useState<DragMode>('none');
+
+ // Sync when parent resets layout
+ useEffect(() => {
+ setX(initialX);
+ setY(initialY);
+ setWidth(initialWidth);
+ setHeight(initialHeight);
+ }, [initialX, initialY, initialWidth, initialHeight]);
+
+ const dragRef = useRef<{
+ startMouseX: number;
+ startMouseY: number;
+ startX: number;
+ startY: number;
+ startW: number;
+ startH: number;
+ } | null>(null);
+
+ const handlePointerDown = useCallback((e: React.PointerEvent<HTMLDivElement>, mode: DragMode) => {
+ e.preventDefault();
+ e.stopPropagation();
+ onFocus(cameraId);
+
+ dragRef.current = {
+ startMouseX: e.clientX,
+ startMouseY: e.clientY,
+ startX: x,
+ startY: y,
+ startW: width,
+ startH: height,
+ };
+ setDragMode(mode);
+ (e.target as HTMLElement).setPointerCapture(e.pointerId);
+ }, [cameraId, x, y, width, height, onFocus]);
+
+ const handlePointerMove = useCallback((e: React.PointerEvent<HTMLDivElement>) => {
+ if (dragMode === 'none' || !dragRef.current) return;
+
+ const { startMouseX, startMouseY, startX, startY, startW, startH } = dragRef.current;
+ const dx = e.clientX - startMouseX;
+ const dy = e.clientY - startMouseY;
+
+ if (dragMode === 'move') {
+ setX(startX + dx);
+ setY(startY + dy);
+ } else if (dragMode === 'resize') {
+ setWidth(Math.max(MIN_WIDTH, startW + dx));
+ setHeight(Math.max(MIN_HEIGHT, startH + dy));
+ }
+ }, [dragMode]);
+
+ const handlePointerUp = useCallback((e: React.PointerEvent<HTMLDivElement>) => {
+ if (dragMode === 'none' || !dragRef.current) return;
+
+ const { startMouseX, startMouseY, startX, startY, startW, startH } = dragRef.current;
+ const dx = e.clientX - startMouseX;
+ const dy = e.clientY - startMouseY;
+
+ let finalX = startX;
+ let finalY = startY;
+ let finalW = startW;
+ let finalH = startH;
+
+ if (dragMode === 'move') {
+ finalX = startX + dx;
+ finalY = startY + dy;
+ } else if (dragMode === 'resize') {
+ finalW = Math.max(MIN_WIDTH, startW + dx);
+ finalH = Math.max(MIN_HEIGHT, startH + dy);
+ }
+
+ setX(finalX);
+ setY(finalY);
+ setWidth(finalW);
+ setHeight(finalH);
+ onLayoutChange(cameraId, finalX, finalY, finalW, finalH);
+
+ setDragMode('none');
+ dragRef.current = null;
+ (e.target as HTMLElement).releasePointerCapture(e.pointerId);
+ }, [dragMode, cameraId, onLayoutChange]);
+
+ // Suppress text selection during drag
+ useEffect(() => {
+ if (dragMode !== 'none') {
+ document.body.style.userSelect = 'none';
+ document.body.style.cursor = dragMode === 'move' ? 'grabbing' : 'nwse-resize';
+ return () => {
+ document.body.style.userSelect = '';
+ document.body.style.cursor = '';
+ };
+ }
+ }, [dragMode]);
+
+ const isActive = dragMode !== 'none';
+
+ return (
+ <Box
+ sx={{
+ position: 'absolute',
+ left: x,
+ top: y,
+ width,
+ height,
+ zIndex,
+ border: '1px solid',
+ borderColor: isActive ? 'primary.main' : 'rgba(255,255,255,0.15)',
+ borderRadius: '4px',
+ overflow: 'hidden',
+ boxShadow: isActive ? 4 : 1,
+ transition: isActive ? 'none' : 'border-color 0.15s ease, box-shadow 0.15s ease',
+ '&:hover': {
+ borderColor: 'rgba(255,255,255,0.4)',
+ },
+ }}
+ >
+ {/* Draggable move area covers the entire camera view */}
+ <Box
+ onPointerDown={(e) => handlePointerDown(e, 'move')}
+ onPointerMove={handlePointerMove}
+ onPointerUp={handlePointerUp}
+ sx={{
+ width: '100%',
+ height: '100%',
+ cursor: dragMode === 'move' ? 'grabbing' : 'grab',
+ }}
+ >
+ <CameraView cameraId={cameraId} />
+ </Box>
+
+ {/* Resize handle in the bottom-right corner */}
+ <Box
+ onPointerDown={(e) => handlePointerDown(e, 'resize')}
+ onPointerMove={handlePointerMove}
+ onPointerUp={handlePointerUp}
+ sx={{
+ position: 'absolute',
+ bottom: 0,
+ right: 0,
+ width: HANDLE_SIZE,
+ height: HANDLE_SIZE,
+ cursor: 'nwse-resize',
+ zIndex: 2,
+ '&::after': {
+ content: '""',
+ position: 'absolute',
+ bottom: 2,
+ right: 2,
+ width: 8,
+ height: 8,
+ borderRight: '2px solid',
+ borderBottom: '2px solid',
+ borderColor: isActive ? 'primary.main' : 'rgba(255,255,255,0.45)',
+ },
+ '&:hover::after': {
+ borderColor: 'primary.main',
+ },
+ }}
+ />
+ </Box>
+ );
+};
diff --git a/freemocap-ui/src/components/languages/LanguageSwitcher.tsx b/freemocap-ui/src/components/languages/LanguageSwitcher.tsx
new file mode 100644
index 00000000..d542b345
--- /dev/null
+++ b/freemocap-ui/src/components/languages/LanguageSwitcher.tsx
@@ -0,0 +1,179 @@
+import React, { useCallback } from "react";
+import { useTranslation } from "react-i18next";
+import {
+ Box,
+ Chip,
+ FormControl,
+ InputLabel,
+ MenuItem,
+ Select,
+ Tooltip,
+ Typography,
+} from "@mui/material";
+import type { SelectChangeEvent } from "@mui/material/Select";
+import SmartToyIcon from "@mui/icons-material/SmartToy";
+import VerifiedIcon from "@mui/icons-material/Verified";
+import {EXTERNAL_URLS} from "@/constants/external-urls";
+import { useAppDispatch, useAppSelector } from "@/store";
+import {
+ localeChanged,
+ selectLocale,
+ selectShowTranslationIndicator,
+} from "@/store/slices/settings";
+import {
+ SUPPORTED_LOCALES,
+ getTranslationSource,
+} from "@/i18n";
+import type { SupportedLocale } from "@/i18n";
+import * as Flags from "country-flag-icons/react/3x2";
+import {CherokeeFlag} from "@/components/languages/custom-flag-icons/CherokeeFlag";
+import {YiddishFlag} from "@/components/languages/custom-flag-icons/YiddishFlag";
+
+const FlagIcon: React.FC<{ countryCode: string }> = ({ countryCode }) => {
+ if (countryCode === "CHEROKEE") return <CherokeeFlag />;
+ if (countryCode === "YIDDISH") return <YiddishFlag />;
+ const Flag = Flags[countryCode as keyof typeof Flags];
+ if (!Flag) return null;
+ return <Flag style={{ width: 20, height: 14, borderRadius: 2, flexShrink: 0 }} />;
+};
+
+export const LanguageSwitcher: React.FC = () => {
+ const { t } = useTranslation();
+ const dispatch = useAppDispatch();
+ const currentLocale = useAppSelector(selectLocale);
+ const showIndicator = useAppSelector(selectShowTranslationIndicator);
+ const translationSource = getTranslationSource(currentLocale);
+
+ const handleChange = useCallback(
+ (event: SelectChangeEvent<string>) => {
+ dispatch(localeChanged(event.target.value as SupportedLocale));
+ },
+ [dispatch]
+ );
+
+ const sourceLabel =
+ translationSource === "human-authored"
+ ? t("humanTranslated")
+ : translationSource === "human-validated"
+ ? t("humanValidated")
+ : t("aiTranslated");
+
+ const sourceIcon =
+ translationSource === "ai-generated" ? (
+ <SmartToyIcon sx={{ fontSize: 14 }} />
+ ) : (
+ <VerifiedIcon sx={{ fontSize: 14 }} />
+ );
+
+ const sourceColor =
+ translationSource === "ai-generated"
+ ? "warning"
+ : translationSource === "human-validated"
+ ? "success"
+ : ("info" as const);
+
+ return (
+ <Box
+ sx={{
+ display: "flex",
+ alignItems: "center",
+ gap: 1,
+ }}
+ >
+ <FormControl size="small" sx={{
+ minWidth: 200,
+ "& .MuiInputLabel-root": {
+ color: "text.secondary",
+ },
+ "& .MuiInputLabel-root.Mui-focused": {
+ color: "text.primary",
+ },
+ }}>
+ <InputLabel id="language-select-label">{t("language")}</InputLabel>
+ <Select
+ labelId="language-select-label"
+ value={currentLocale}
+ label={t("language")}
+ onChange={handleChange}
+ sx={{
+ fontSize: 13,
+ "& .MuiSelect-select": {
+ py: 0.75,
+ },
+ }}
+ >
+ {Object.entries(SUPPORTED_LOCALES).map(([code, { label, englishName, dir, flag }]) => (
+ <MenuItem key={code} value={code}>
+ <Box sx={{ display: "flex", alignItems: "center", gap: 1 }}>
+ <FlagIcon countryCode={flag} />
+ <Typography
+ component="span"
+ sx={{
+ fontSize: 13,
+ direction: dir,
+ }}
+ >
+ {label}
+ </Typography>
+ {label !== englishName && (
+ <Typography
+ component="span"
+ sx={{
+ fontSize: 11,
+ color: "text.secondary",
+ }}
+ >
+ {englishName}
+ </Typography>
+ )}
+ <Typography
+ component="span"
+ sx={{
+ fontSize: 11,
+ color: "text.disabled",
+ fontFamily: "monospace",
+ }}
+ >
+ {code}
+ </Typography>
+ </Box>
+ </MenuItem>
+ ))}
+ </Select>
+ </FormControl>
+
+ {showIndicator && translationSource !== "human-authored" && (
+ <Tooltip
+ title={
+ translationSource === "ai-generated"
+ ? t("aiTranslatedTooltip")
+ : t("humanValidatedTooltip")
+ }
+ arrow
+ placement="bottom"
+ >
+ <Chip
+ icon={sourceIcon}
+ label={sourceLabel}
+ size="small"
+ color={sourceColor}
+ variant="outlined"
+ clickable
+ component="a"
+ href={EXTERNAL_URLS.TRANSLATION_LOCALES}
+ target="_blank"
+ rel="noopener noreferrer"
+ sx={{
+ height: 24,
+ fontSize: 11,
+ cursor: "pointer",
+ "& .MuiChip-icon": {
+ fontSize: 14,
+ },
+ }}
+ />
+ </Tooltip>
+ )}
+ </Box>
+ );
+};
diff --git a/freemocap-ui/src/components/languages/custom-flag-icons/CherokeeFlag.tsx b/freemocap-ui/src/components/languages/custom-flag-icons/CherokeeFlag.tsx
new file mode 100644
index 00000000..6c320a2b
--- /dev/null
+++ b/freemocap-ui/src/components/languages/custom-flag-icons/CherokeeFlag.tsx
@@ -0,0 +1,43 @@
+import React from "react";
+
+/**
+ * Simplified Cherokee Nation flag icon.
+ *
+ * Renders a gold seven-pointed star (representing the seven Cherokee clans)
+ * centered on an orange field, matching the proportions and style used by
+ * the country-flag-icons library (3:2 aspect ratio, 20×14px default).
+ */
+export const CherokeeFlag: React.FC<React.SVGProps<SVGSVGElement>> = (props) => {
+ // Seven-pointed star vertices, computed for a unit circle centered at (10, 7)
+ // with outer radius 5.5 and inner radius 2.5, starting from the top point.
+ const outerRadius = 5.5;
+ const innerRadius = 2.5;
+ const cx = 10;
+ const cy = 7;
+ const points = 7;
+ const angleStep = Math.PI / points;
+ const startAngle = -Math.PI / 2; // top
+
+ const starPoints: string[] = [];
+ for (let i = 0; i < points * 2; i++) {
+ const radius = i % 2 === 0 ? outerRadius : innerRadius;
+ const angle = startAngle + i * angleStep;
+ const x = cx + radius * Math.cos(angle);
+ const y = cy + radius * Math.sin(angle);
+ starPoints.push(`${x.toFixed(2)},${y.toFixed(2)}`);
+ }
+
+ return (
+ <svg
+ xmlns="http://www.w3.org/2000/svg"
+ viewBox="0 0 20 14"
+ width={20}
+ height={14}
+ style={{ borderRadius: 2, flexShrink: 0 }}
+ {...props}
+ >
+ <rect width="20" height="14" fill="#CF6924" />
+ <polygon points={starPoints.join(" ")} fill="#F2C75C" />
+ </svg>
+ );
+};
diff --git a/freemocap-ui/src/components/languages/custom-flag-icons/YiddishFlag.tsx b/freemocap-ui/src/components/languages/custom-flag-icons/YiddishFlag.tsx
new file mode 100644
index 00000000..a5c55de9
--- /dev/null
+++ b/freemocap-ui/src/components/languages/custom-flag-icons/YiddishFlag.tsx
@@ -0,0 +1,59 @@
+import React from "react";
+
+/**
+ * Yiddish language flag icon.
+ *
+ * Renders two horizontal black stripes on a white field (evoking the
+ * Ashkenazi tallit / prayer shawl) with a seven-branched menorah centered
+ * between the stripes. Matches the 3:2 aspect ratio and sizing conventions
+ * used by the country-flag-icons library (20×14px default).
+ */
+export const YiddishFlag: React.FC<React.SVGProps<SVGSVGElement>> = (props) => (
+ <svg
+ xmlns="http://www.w3.org/2000/svg"
+ viewBox="0 0 60 42"
+ width={20}
+ height={14}
+ style={{ borderRadius: 2, flexShrink: 0 }}
+ {...props}
+ >
+ {/* White background */}
+ <rect width="60" height="42" fill="#fff" />
+
+ {/* Top and bottom black stripes (tallit) */}
+ <rect x="0" y="6" width="60" height="4" fill="#222" />
+ <rect x="0" y="32" width="60" height="4" fill="#222" />
+
+ {/* Seven-branched menorah — centered at (30, 22) */}
+ <g fill="none" stroke="#222" strokeWidth="1.8" strokeLinecap="round" strokeLinejoin="round">
+ {/* Base */}
+ <line x1="25" y1="30" x2="35" y2="30" />
+ {/* Stem */}
+ <line x1="30" y1="30" x2="30" y2="16" />
+
+ {/* Center branch (tallest) — just the flame holder */}
+ <line x1="30" y1="16" x2="30" y2="14" />
+
+ {/* Inner branches (2) */}
+ <path d="M30,22 C28,22 26,18 26,15" />
+ <path d="M30,22 C32,22 34,18 34,15" />
+
+ {/* Middle branches (2) */}
+ <path d="M30,24 C26,24 23,18 22,15" />
+ <path d="M30,24 C34,24 37,18 38,15" />
+
+ {/* Outer branches (2) */}
+ <path d="M30,26 C24,26 20,18 18,15" />
+ <path d="M30,26 C36,26 40,18 42,15" />
+
+ {/* Flames (small circles at the top of each branch) */}
+ <circle cx="18" cy="14" r="1" fill="#222" stroke="none" />
+ <circle cx="22" cy="14" r="1" fill="#222" stroke="none" />
+ <circle cx="26" cy="14" r="1" fill="#222" stroke="none" />
+ <circle cx="30" cy="13.5" r="1" fill="#222" stroke="none" />
+ <circle cx="34" cy="14" r="1" fill="#222" stroke="none" />
+ <circle cx="38" cy="14" r="1" fill="#222" stroke="none" />
+ <circle cx="42" cy="14" r="1" fill="#222" stroke="none" />
+ </g>
+ </svg>
+);
diff --git a/freemocap-ui/src/components/playback/PlaybackControls.tsx b/freemocap-ui/src/components/playback/PlaybackControls.tsx
new file mode 100644
index 00000000..e96e1381
--- /dev/null
+++ b/freemocap-ui/src/components/playback/PlaybackControls.tsx
@@ -0,0 +1,456 @@
+import React, { useMemo, useState } from 'react';
+import {
+ Box,
+ Checkbox,
+ Collapse,
+ FormControlLabel,
+ IconButton,
+ MenuItem,
+ Popover,
+ Select,
+ Slider,
+ ToggleButton,
+ ToggleButtonGroup,
+ Tooltip,
+ Typography,
+ useTheme,
+} from '@mui/material';
+import { ThemeProvider, createTheme } from '@mui/material/styles';
+import PlayArrowIcon from '@mui/icons-material/PlayArrow';
+import PauseIcon from '@mui/icons-material/Pause';
+import SkipPreviousIcon from '@mui/icons-material/SkipPrevious';
+import SkipNextIcon from '@mui/icons-material/SkipNext';
+import FirstPageIcon from '@mui/icons-material/FirstPage';
+import LastPageIcon from '@mui/icons-material/LastPage';
+import InfoOutlinedIcon from '@mui/icons-material/InfoOutlined';
+import RepeatIcon from '@mui/icons-material/Repeat';
+import SettingsIcon from '@mui/icons-material/Settings';
+import type { PlaybackSettings } from './SyncedVideoPlayer';
+import { useTranslation } from 'react-i18next';
+
+interface PlaybackControlsProps {
+ isPlaying: boolean;
+ currentTime: number;
+ duration: number;
+ playbackRate: number;
+ currentFrame: number;
+ totalFrames: number;
+ fps: number;
+ recordingFps?: number;
+ settings: PlaybackSettings;
+ onSettingsChange: (settings: PlaybackSettings) => void;
+ onPlayPause: () => void;
+ onSeekDrag: (frame: number) => void;
+ onSeekCommit: (frame: number) => void;
+ onFrameStep: (delta: number) => void;
+ onPlaybackRateChange: (rate: number) => void;
+ onSeekToStart: () => void;
+ onSeekToEnd: () => void;
+ isLooping: boolean;
+ onToggleLoop: () => void;
+}
+
+const PLAYBACK_RATES = [0.1, 0.25, 0.5, 1, 1.5, 2, 4, 8];
+
+function formatTime(seconds: number): string {
+ const mins = Math.floor(seconds / 60);
+ const secs = Math.floor(seconds % 60);
+ const ms = Math.floor((seconds % 1) * 100);
+ return `${mins}:${secs.toString().padStart(2, '0')}.${ms.toString().padStart(2, '0')}`;
+}
+
+export const PlaybackControls: React.FC<PlaybackControlsProps> = ({
+ isPlaying,
+ currentTime,
+ duration,
+ playbackRate,
+ currentFrame,
+ totalFrames,
+ fps,
+ recordingFps,
+ settings,
+ onSettingsChange,
+ onPlayPause,
+ onSeekDrag,
+ onSeekCommit,
+ onFrameStep,
+ onPlaybackRateChange,
+ onSeekToStart,
+ onSeekToEnd,
+ isLooping,
+ onToggleLoop,
+}) => {
+ const theme = useTheme();
+ const { t } = useTranslation();
+ const monoFont = '"JetBrains Mono", "Fira Code", "SF Mono", monospace';
+ const isDark = theme.palette.mode === 'dark';
+
+ // MUI Slider reads direction from the theme, not CSS.
+ // Force LTR so the playback slider never reverses in RTL locales.
+ const ltrTheme = useMemo(() => createTheme({ ...theme, direction: 'ltr' }), [theme]);
+
+ // Visible accent colors that work on dark backgrounds
+ const accentGreen = '#00ff88';
+ const accentBlue = '#29b6f6'; // info.main from theme
+ const sliderColor = isDark ? accentBlue : theme.palette.primary.main;
+ const playBtnColor = isDark ? '#4caf50' : theme.palette.primary.main;
+
+ // Settings popover
+ const [settingsAnchor, setSettingsAnchor] = useState<HTMLElement | null>(null);
+ const settingsOpen = Boolean(settingsAnchor);
+
+ // Sync info collapse
+ const [syncInfoOpen, setSyncInfoOpen] = useState(true);
+
+ const updateSetting = <K extends keyof PlaybackSettings>(key: K, value: PlaybackSettings[K]) => {
+ onSettingsChange({ ...settings, [key]: value });
+ };
+
+ return (
+ <Box
+ sx={{
+ display: 'flex',
+ flexDirection: 'column',
+ gap: 0.5,
+ px: 2,
+ py: 1,
+ backgroundColor: theme.palette.background.paper,
+ borderTop: `1px solid ${theme.palette.divider}`,
+ }}
+ >
+ {/* Frame-based slider */}
+ <Box sx={{ display: 'flex', alignItems: 'center', gap: 1.5 }}>
+ <Tooltip title={t("estimatedTime")} placement="top">
+ <Typography variant="caption" sx={{
+ fontFamily: monoFont, minWidth: 70, textAlign: 'right',
+ color: accentGreen, fontWeight: 600, fontSize: '0.8rem',
+ }}>
+ ~{formatTime(currentTime)}
+ </Typography>
+ </Tooltip>
+ <ThemeProvider theme={ltrTheme}>
+ <Slider
+ value={currentFrame}
+ min={0}
+ max={Math.max(totalFrames - 1, 1)}
+ step={1}
+ onChange={(_, value) => onSeekDrag(value as number)}
+ onChangeCommitted={(_, value) => onSeekCommit(value as number)}
+ sx={{
+ flex: 1,
+ color: sliderColor,
+ '& .MuiSlider-thumb': {
+ width: 14, height: 14,
+ transition: 'none',
+ backgroundColor: sliderColor,
+ '&:hover, &.Mui-focusVisible': {
+ boxShadow: `0 0 0 8px ${isDark ? 'rgba(41, 182, 246, 0.16)' : 'rgba(25, 118, 210, 0.16)'}`,
+ },
+ },
+ '& .MuiSlider-track': { transition: 'none', backgroundColor: sliderColor },
+ '& .MuiSlider-rail': { backgroundColor: isDark ? 'rgba(255,255,255,0.2)' : 'rgba(0,0,0,0.2)' },
+ }}
+ size="small"
+ />
+ </ThemeProvider>
+ <Tooltip title={t("estimatedDuration")} placement="top">
+ <Typography variant="caption" sx={{
+ fontFamily: monoFont, minWidth: 70,
+ color: theme.palette.text.secondary,
+ }}>
+ ~{formatTime(duration)}
+ </Typography>
+ </Tooltip>
+ </Box>
+
+ {/* Transport controls */}
+ <Box sx={{ display: 'flex', alignItems: 'center', justifyContent: 'center', gap: 0.5 }}>
+ {/* Left: frame info + recording stats */}
+ <Box sx={{ minWidth: 240, textAlign: 'right', mr: 2, display: 'flex', alignItems: 'center', gap: 1.5, justifyContent: 'flex-end' }}>
+ {/* Frame counter badge */}
+ <Typography
+ component="span"
+ sx={{
+ fontFamily: monoFont,
+ fontSize: '0.85rem',
+ fontWeight: 700,
+ color: accentGreen,
+ backgroundColor: 'rgba(0,255,136,0.08)',
+ px: 1, py: 0.25, borderRadius: 1,
+ border: '1px solid rgba(0,255,136,0.2)',
+ }}
+ >
+ Frame {currentFrame} / {totalFrames}
+ </Typography>
+
+ {/* Recording FPS badge — clearly labeled */}
+ {recordingFps != null && recordingFps > 0 && (
+ <Tooltip title={t("recordingCaptureFps")}>
+ <Typography
+ component="span"
+ sx={{
+ fontFamily: monoFont,
+ fontSize: '0.7rem',
+ color: isDark ? '#ffcc80' : theme.palette.warning.dark,
+ backgroundColor: isDark ? 'rgba(255,204,128,0.08)' : 'rgba(255,152,0,0.08)',
+ px: 0.75, py: 0.2, borderRadius: 1,
+ border: `1px solid ${isDark ? 'rgba(255,204,128,0.2)' : 'rgba(255,152,0,0.2)'}`,
+ whiteSpace: 'nowrap',
+ }}
+ >
+ rec: {recordingFps} fps
+ </Typography>
+ </Tooltip>
+ )}
+ </Box>
+
+ {/* Center: transport buttons — bright colors for visibility */}
+ <Tooltip title={t("jumpToStart")}>
+ <IconButton size="small" onClick={onSeekToStart}
+ sx={{ color: isDark ? '#b3b9c6' : undefined }}>
+ <FirstPageIcon />
+ </IconButton>
+ </Tooltip>
+
+ <Tooltip title={t("previousFrame")}>
+ <IconButton size="small" onClick={() => onFrameStep(-1)}
+ sx={{ color: isDark ? '#b3b9c6' : undefined }}>
+ <SkipPreviousIcon />
+ </IconButton>
+ </Tooltip>
+
+ <Tooltip title={isPlaying ? 'Pause (Space)' : 'Play (Space)'}>
+ <IconButton
+ onClick={onPlayPause}
+ sx={{
+ mx: 1,
+ color: playBtnColor,
+ border: `2px solid ${playBtnColor}`,
+ '&:hover': {
+ backgroundColor: `${playBtnColor}22`,
+ borderColor: playBtnColor,
+ },
+ }}
+ >
+ {isPlaying ? <PauseIcon fontSize="large" /> : <PlayArrowIcon fontSize="large" />}
+ </IconButton>
+ </Tooltip>
+
+ <Tooltip title={t("nextFrame")}>
+ <IconButton size="small" onClick={() => onFrameStep(1)}
+ sx={{ color: isDark ? '#b3b9c6' : undefined }}>
+ <SkipNextIcon />
+ </IconButton>
+ </Tooltip>
+
+ <Tooltip title={t("jumpToEnd")}>
+ <IconButton size="small" onClick={onSeekToEnd}
+ sx={{ color: isDark ? '#b3b9c6' : undefined }}>
+ <LastPageIcon />
+ </IconButton>
+ </Tooltip>
+
+ <Tooltip title={isLooping ? t("loopOn") : t("loopOff")}>
+ <IconButton
+ size="small"
+ onClick={onToggleLoop}
+ sx={{
+ color: isLooping
+ ? accentBlue
+ : (isDark ? '#b3b9c6' : undefined),
+ backgroundColor: isLooping
+ ? (isDark ? 'rgba(41, 182, 246, 0.15)' : 'rgba(25, 118, 210, 0.1)')
+ : undefined,
+ border: isLooping ? `1px solid ${accentBlue}` : '1px solid transparent',
+ '&:hover': {
+ backgroundColor: isLooping
+ ? (isDark ? 'rgba(41, 182, 246, 0.25)' : 'rgba(25, 118, 210, 0.2)')
+ : undefined,
+ },
+ }}
+ >
+ <RepeatIcon fontSize="small" />
+ </IconButton>
+ </Tooltip>
+
+ {/* Right: speed selector + settings */}
+ <Box sx={{ display: 'flex', alignItems: 'center', ml: 2, gap: 1 }}>
+ <Tooltip title={t("playbackSpeed")}>
+ <Box sx={{ display: 'flex', alignItems: 'center', gap: 0.5 }}>
+ <Typography variant="caption" sx={{ color: isDark ? '#b3b9c6' : 'text.secondary' }}>
+ Speed:
+ </Typography>
+ <Select
+ value={playbackRate}
+ onChange={(e) => onPlaybackRateChange(Number(e.target.value))}
+ size="small"
+ variant="outlined"
+ sx={{
+ minWidth: 70,
+ '& .MuiSelect-select': {
+ py: 0.25, fontSize: '0.8rem', fontFamily: monoFont,
+ color: isDark ? '#fff' : undefined,
+ },
+ '& .MuiOutlinedInput-notchedOutline': {
+ borderColor: isDark ? 'rgba(255,255,255,0.25)' : undefined,
+ },
+ '&:hover .MuiOutlinedInput-notchedOutline': {
+ borderColor: isDark ? 'rgba(255,255,255,0.5)' : undefined,
+ },
+ '& .MuiSvgIcon-root': {
+ color: isDark ? 'rgba(255,255,255,0.5)' : undefined,
+ },
+ }}
+ >
+ {PLAYBACK_RATES.map((rate) => (
+ <MenuItem key={rate} value={rate}>{rate}×</MenuItem>
+ ))}
+ </Select>
+ </Box>
+ </Tooltip>
+
+ {/* Sync info */}
+ <Tooltip title={t("syncInfo")}>
+ <IconButton
+ size="small"
+ onClick={() => setSyncInfoOpen((prev) => !prev)}
+ sx={{
+ color: syncInfoOpen
+ ? (isDark ? '#ffcc80' : theme.palette.warning.dark)
+ : (isDark ? 'rgba(255,255,255,0.3)' : theme.palette.text.disabled),
+ fontSize: '0.85rem',
+ }}
+ >
+ <InfoOutlinedIcon sx={{ fontSize: 16 }} />
+ </IconButton>
+ </Tooltip>
+
+ {/* Settings gear */}
+ <Tooltip title={t("playbackSettings")}>
+ <IconButton
+ size="small"
+ onClick={(e) => setSettingsAnchor(e.currentTarget)}
+ sx={{
+ color: settingsOpen
+ ? accentBlue
+ : (isDark ? '#b3b9c6' : theme.palette.text.secondary),
+ }}
+ >
+ <SettingsIcon fontSize="small" />
+ </IconButton>
+ </Tooltip>
+ </Box>
+ </Box>
+
+ {/* Settings popover */}
+ <Popover
+ open={settingsOpen}
+ anchorEl={settingsAnchor}
+ onClose={() => setSettingsAnchor(null)}
+ anchorOrigin={{ vertical: 'top', horizontal: 'right' }}
+ transformOrigin={{ vertical: 'bottom', horizontal: 'right' }}
+ slotProps={{
+ paper: {
+ sx: {
+ p: 2,
+ minWidth: 260,
+ backgroundColor: theme.palette.background.paper,
+ border: `1px solid ${theme.palette.divider}`,
+ },
+ },
+ }}
+ >
+ <Typography variant="subtitle2" sx={{ mb: 1.5, fontWeight: 600, color: theme.palette.text.primary }}>
+ Display Settings
+ </Typography>
+
+ <FormControlLabel
+ control={
+ <Checkbox
+ checked={settings.showOverlays}
+ onChange={(e) => updateSetting('showOverlays', e.target.checked)}
+ size="small"
+ sx={{
+ color: isDark ? 'rgba(255,255,255,0.5)' : undefined,
+ '&.Mui-checked': { color: accentBlue },
+ }}
+ />
+ }
+ label={
+ <Typography variant="body2" sx={{ color: theme.palette.text.primary }}>
+ Show frame overlays
+ </Typography>
+ }
+ sx={{ mb: 1.5, ml: 0 }}
+ />
+
+ <Typography variant="caption" sx={{ mb: 0.75, display: 'block', color: theme.palette.text.secondary }}>
+ Timestamp format
+ </Typography>
+ <ToggleButtonGroup
+ value={settings.timestampFormat}
+ exclusive
+ onChange={(_, val) => { if (val) updateSetting('timestampFormat', val); }}
+ size="small"
+ fullWidth
+ sx={{
+ '& .MuiToggleButton-root': {
+ fontSize: '0.75rem',
+ fontFamily: monoFont,
+ py: 0.5,
+ color: isDark ? '#b3b9c6' : theme.palette.text.secondary,
+ borderColor: isDark ? 'rgba(255,255,255,0.2)' : theme.palette.divider,
+ '&.Mui-selected': {
+ color: '#fff',
+ backgroundColor: isDark ? 'rgba(41,182,246,0.25)' : theme.palette.primary.main,
+ borderColor: accentBlue,
+ '&:hover': {
+ backgroundColor: isDark ? 'rgba(41,182,246,0.35)' : theme.palette.primary.dark,
+ },
+ },
+ },
+ }}
+ >
+ <ToggleButton value="seconds">1.234s</ToggleButton>
+ <ToggleButton value="timecode">HH:MM:SS:FF</ToggleButton>
+ </ToggleButtonGroup>
+ </Popover>
+
+ {/* Sync info panel */}
+ <Collapse in={syncInfoOpen}>
+ <Box
+ sx={{
+ px: 2,
+ py: 1,
+ mt: 0.5,
+ borderRadius: 1,
+ backgroundColor: isDark ? 'rgba(255, 204, 128, 0.06)' : 'rgba(255, 152, 0, 0.05)',
+ border: `1px solid ${isDark ? 'rgba(255, 204, 128, 0.15)' : 'rgba(255, 152, 0, 0.2)'}`,
+ }}
+ >
+ <Typography
+ variant="caption"
+ sx={{
+ display: 'block',
+ color: isDark ? '#ffcc80' : theme.palette.warning.dark,
+ fontWeight: 600,
+ mb: 0.5,
+ }}
+ >
+ {t("syncInfoTitle")}
+ </Typography>
+ {/*<Typography*/}
+ {/* variant="caption"*/}
+ {/* sx={{*/}
+ {/* display: 'block',*/}
+ {/* color: theme.palette.text.secondary,*/}
+ {/* lineHeight: 1.5,*/}
+ {/* }}*/}
+ {/*>*/}
+ {/* {t("syncInfoBody")}*/}
+ {/*</Typography>*/}
+ </Box>
+ </Collapse>
+ </Box>
+ );
+};
diff --git a/freemocap-ui/src/components/playback/RecordingBrowser.tsx b/freemocap-ui/src/components/playback/RecordingBrowser.tsx
new file mode 100644
index 00000000..892abd48
--- /dev/null
+++ b/freemocap-ui/src/components/playback/RecordingBrowser.tsx
@@ -0,0 +1,783 @@
+/**
+ * RecordingBrowser — lists available recording sessions from the server,
+ * with search filtering, multi-field sorting, and rich per-recording metadata.
+ *
+ * Standalone component: only depends on MUI + server URL helper.
+ */
+import React, { useCallback, useEffect, useMemo, useState } from 'react';
+import {
+ Box,
+ Button,
+ Chip,
+ CircularProgress,
+ IconButton,
+ InputAdornment,
+ List,
+ ListItemButton,
+ ListItemIcon,
+ ListItemText,
+ MenuItem,
+ Select,
+ type SelectChangeEvent,
+ TextField,
+ Tooltip,
+ Typography,
+ useTheme,
+} from '@mui/material';
+import FolderIcon from '@mui/icons-material/Folder';
+import PlayArrowIcon from '@mui/icons-material/PlayArrow';
+import RefreshIcon from '@mui/icons-material/Refresh';
+import VideocamIcon from '@mui/icons-material/Videocam';
+import StorageIcon from '@mui/icons-material/Storage';
+import AccessTimeIcon from '@mui/icons-material/AccessTime';
+import SearchIcon from '@mui/icons-material/Search';
+import SortIcon from '@mui/icons-material/Sort';
+import { serverUrls } from '@/services/server/server-helpers/server-urls';
+import { useTranslation } from 'react-i18next';
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+/** Shape returned by GET /freemocap/playback/recordings */
+interface RecordingEntry {
+ name: string;
+ path: string;
+ video_count: number;
+ total_size_bytes?: number;
+ created_timestamp?: string;
+ total_frames?: number;
+ duration_seconds?: number;
+ fps?: number;
+}
+
+/** Shape passed up to the parent when a recording is loaded */
+export interface LoadedVideo {
+ videoId: string;
+ filename: string;
+ streamUrl: string;
+ sizeBytes: number;
+}
+
+interface RecordingBrowserProps {
+ onRecordingLoaded: (videos: LoadedVideo[], recordingPath: string, recordingFps?: number) => void;
+ /** If set, automatically load this recording path on mount. */
+ initialLoadPath?: string | null;
+}
+
+type SortField = 'date' | 'name' | 'size' | 'cameras' | 'frames' | 'duration';
+type SortDirection = 'asc' | 'desc';
+
+// ---------------------------------------------------------------------------
+// Formatting helpers
+// ---------------------------------------------------------------------------
+
+function formatBytes(bytes: number): string {
+ if (bytes <= 0) return '0 B';
+ const k = 1024;
+ const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+ const i = Math.floor(Math.log(bytes) / Math.log(k));
+ return `${(bytes / Math.pow(k, i)).toFixed(i > 1 ? 1 : 0)} ${units[i]}`;
+}
+
+function formatDuration(seconds: number): string {
+ if (seconds < 60) return `${seconds.toFixed(1)}s`;
+ const m = Math.floor(seconds / 60);
+ const s = Math.floor(seconds % 60);
+ if (m >= 60) {
+ const h = Math.floor(m / 60);
+ const rm = m % 60;
+ return `${h}h ${rm}m ${s}s`;
+ }
+ return `${m}m ${s}s`;
+}
+
+/**
+ * Try to parse an ISO-like timestamp from a recording folder name.
+ * Handles patterns like:
+ * 2026-02-18_09-24-12_GMT-5
+ * 2026-02-18T09_24_12
+ * 2026-02-18
+ */
+function parseTimestampFromName(name: string): Date | null {
+ // Full datetime: 2026-02-18_09-24-12 or 2026-02-18T09:24:12
+ const fullMatch = name.match(
+ /(\d{4})-(\d{2})-(\d{2})[T_](\d{2})[_:\-](\d{2})[_:\-](\d{2})/
+ );
+ if (fullMatch) {
+ const [, y, mo, d, h, mi, s] = fullMatch;
+ return new Date(+y, +mo - 1, +d, +h, +mi, +s);
+ }
+ // Date only: 2026-02-18
+ const dateMatch = name.match(/(\d{4})-(\d{2})-(\d{2})/);
+ if (dateMatch) {
+ const [, y, mo, d] = dateMatch;
+ return new Date(+y, +mo - 1, +d);
+ }
+ return null;
+}
+
+function formatRelativeTime(date: Date): string {
+ const now = new Date();
+ const diffMs = now.getTime() - date.getTime();
+ const diffMin = Math.floor(diffMs / 60000);
+ if (diffMin < 1) return 'just now';
+ if (diffMin < 60) return `${diffMin}m ago`;
+ const diffHr = Math.floor(diffMin / 60);
+ if (diffHr < 24) return `${diffHr}h ago`;
+ const diffDays = Math.floor(diffHr / 24);
+ if (diffDays < 7) return `${diffDays}d ago`;
+ if (diffDays < 30) return `${Math.floor(diffDays / 7)}w ago`;
+ return date.toLocaleDateString(undefined, {
+ month: 'short',
+ day: 'numeric',
+ year: date.getFullYear() !== now.getFullYear() ? 'numeric' : undefined,
+ });
+}
+
+// ---------------------------------------------------------------------------
+// Sort helpers
+// ---------------------------------------------------------------------------
+
+function getSortValue(rec: RecordingEntry, field: SortField): number | string {
+ switch (field) {
+ case 'date': {
+ const d = parseTimestampFromName(rec.name);
+ return d ? d.getTime() : 0;
+ }
+ case 'name':
+ return rec.name.toLowerCase();
+ case 'size':
+ return rec.total_size_bytes ?? 0;
+ case 'cameras':
+ return rec.video_count;
+ case 'frames':
+ return rec.total_frames ?? 0;
+ case 'duration':
+ return rec.duration_seconds ?? 0;
+ }
+}
+
+function compareRecordings(
+ a: RecordingEntry,
+ b: RecordingEntry,
+ field: SortField,
+ direction: SortDirection,
+): number {
+ const va = getSortValue(a, field);
+ const vb = getSortValue(b, field);
+ let cmp: number;
+ if (typeof va === 'string' && typeof vb === 'string') {
+ cmp = va.localeCompare(vb);
+ } else {
+ cmp = (va as number) - (vb as number);
+ }
+ return direction === 'desc' ? -cmp : cmp;
+}
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+const MONO_FONT = '"JetBrains Mono", "Fira Code", "SF Mono", "Cascadia Code", monospace';
+const ACCENT_BLUE = '#29b6f6';
+const ACCENT_GREEN = '#00ff88';
+
+const SORT_OPTIONS: { value: SortField; labelKey: string }[] = [
+ { value: 'date', labelKey: 'date' },
+ { value: 'name', labelKey: 'name' },
+ { value: 'size', labelKey: 'size' },
+ { value: 'cameras', labelKey: 'cameras' },
+ { value: 'frames', labelKey: 'frames' },
+ { value: 'duration', labelKey: 'duration' },
+];
+
+// ---------------------------------------------------------------------------
+// Component
+// ---------------------------------------------------------------------------
+
+export const RecordingBrowser: React.FC<RecordingBrowserProps> = ({ onRecordingLoaded, initialLoadPath }) => {
+ const theme = useTheme();
+ const { t } = useTranslation();
+ const isDark = theme.palette.mode === 'dark';
+
+ // Data state
+ const [recordings, setRecordings] = useState<RecordingEntry[]>([]);
+ const [isLoadingList, setIsLoadingList] = useState(false);
+ const [isLoadingRecording, setIsLoadingRecording] = useState(false);
+ const [error, setError] = useState<string | null>(null);
+ const [loadingPath, setLoadingPath] = useState<string | null>(null);
+
+ // Manual path input
+ const [manualPath, setManualPath] = useState('');
+
+ // Filter / sort
+ const [filterText, setFilterText] = useState('');
+ const [sortField, setSortField] = useState<SortField>('date');
+ const [sortDir, setSortDir] = useState<SortDirection>('desc');
+
+ // -----------------------------------------------------------------------
+ // Fetch the list of recordings from the server
+ // -----------------------------------------------------------------------
+ const fetchRecordings = useCallback(async () => {
+ setIsLoadingList(true);
+ setError(null);
+ try {
+ const response = await fetch(serverUrls.endpoints.playbackRecordings);
+ if (!response.ok) {
+ throw new Error(`Failed to fetch recordings: ${response.statusText}`);
+ }
+ const data: RecordingEntry[] = await response.json();
+ setRecordings(data);
+ } catch (e) {
+ setError(e instanceof Error ? e.message : t('failedToFetch'));
+ } finally {
+ setIsLoadingList(false);
+ }
+ }, []);
+
+ useEffect(() => {
+ fetchRecordings();
+ }, [fetchRecordings]);
+
+ // -----------------------------------------------------------------------
+ // Apply filter + sort
+ // -----------------------------------------------------------------------
+ const filteredSorted = useMemo(() => {
+ let result = recordings;
+
+ // Text filter
+ if (filterText.trim()) {
+ const q = filterText.trim().toLowerCase();
+ result = result.filter((r) => r.name.toLowerCase().includes(q));
+ }
+
+ // Sort
+ return [...result].sort((a, b) => compareRecordings(a, b, sortField, sortDir));
+ }, [recordings, filterText, sortField, sortDir]);
+
+ // -----------------------------------------------------------------------
+ // Load a specific recording
+ // -----------------------------------------------------------------------
+ const loadRecording = useCallback(
+ async (recordingPath: string) => {
+ setIsLoadingRecording(true);
+ setLoadingPath(recordingPath);
+ setError(null);
+
+ try {
+ const response = await fetch(serverUrls.endpoints.playbackLoad, {
+ method: 'POST',
+ headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify({ recording_path: recordingPath }),
+ });
+
+ if (!response.ok) {
+ const detail = await response
+ .json()
+ .catch(() => ({ detail: response.statusText }));
+ throw new Error(detail.detail || response.statusText);
+ }
+
+ const data = await response.json();
+ const baseUrl = serverUrls.getHttpUrl();
+
+ const videos: LoadedVideo[] = data.videos.map(
+ (v: {
+ video_id: string;
+ filename: string;
+ stream_url: string;
+ size_bytes: number;
+ }) => ({
+ videoId: v.video_id,
+ filename: v.filename,
+ streamUrl: `${baseUrl}${v.stream_url}`,
+ sizeBytes: v.size_bytes,
+ }),
+ );
+
+ // Look up recording fps from our cached list
+ const rec = recordings.find((r) => r.path === recordingPath);
+ const recFps = rec?.fps ?? undefined;
+
+ onRecordingLoaded(videos, data.recording_path, recFps);
+ } catch (e) {
+ setError(e instanceof Error ? e.message : 'Failed to load recording');
+ } finally {
+ setIsLoadingRecording(false);
+ setLoadingPath(null);
+ }
+ },
+ [onRecordingLoaded, recordings],
+ );
+
+ // Auto-load a recording if initialLoadPath is provided
+ const [didAutoLoad, setDidAutoLoad] = useState(false);
+ useEffect(() => {
+ if (initialLoadPath && !didAutoLoad) {
+ setDidAutoLoad(true);
+ loadRecording(initialLoadPath);
+ }
+ }, [initialLoadPath, didAutoLoad, loadRecording]);
+
+ const handleLoadManualPath = useCallback(() => {
+ const trimmed = manualPath.trim();
+ if (trimmed) loadRecording(trimmed);
+ }, [manualPath, loadRecording]);
+
+ // -----------------------------------------------------------------------
+ // Sort controls
+ // -----------------------------------------------------------------------
+ const handleSortFieldChange = (e: SelectChangeEvent) => {
+ setSortField(e.target.value as SortField);
+ };
+
+ const toggleSortDir = () => {
+ setSortDir((d) => (d === 'desc' ? 'asc' : 'desc'));
+ };
+
+ // -----------------------------------------------------------------------
+ // Render
+ // -----------------------------------------------------------------------
+ return (
+ <Box
+ sx={{
+ display: 'flex',
+ flexDirection: 'column',
+ gap: 2,
+ p: 2,
+ height: '100%',
+ overflow: 'hidden',
+ }}
+ >
+ {/* ── Manual path input ── */}
+ <Box sx={{ display: 'flex', gap: 1, alignItems: 'flex-start' }}>
+ <TextField
+ fullWidth
+ size="small"
+ label={t("recordingFolderPath")}
+ placeholder="~/freemocap_data/recordings/2024-01-01..."
+ value={manualPath}
+ onChange={(e) => setManualPath(e.target.value)}
+ onKeyDown={(e) => {
+ if (e.key === 'Enter') handleLoadManualPath();
+ }}
+ disabled={isLoadingRecording}
+ sx={{ '& input': { fontFamily: MONO_FONT, fontSize: '0.85rem' } }}
+ />
+ <Button
+ variant="contained"
+ onClick={handleLoadManualPath}
+ disabled={!manualPath.trim() || isLoadingRecording}
+ startIcon={
+ isLoadingRecording && !loadingPath ? (
+ <CircularProgress size={16} />
+ ) : (
+ <PlayArrowIcon />
+ )
+ }
+ sx={{
+ whiteSpace: 'nowrap',
+ backgroundColor: isDark ? '#4caf50' : undefined,
+ color: isDark ? '#fff' : undefined,
+ '&:hover': { backgroundColor: isDark ? '#66bb6a' : undefined },
+ }}
+ >
+ {t('load')}
+ </Button>
+ </Box>
+
+ {/* ── Error ── */}
+ {error && (
+ <Typography color="error" variant="body2" sx={{ px: 1 }}>
+ {error}
+ </Typography>
+ )}
+
+ {/* ── Header bar: title, filter, sort, refresh ── */}
+ <Box
+ sx={{
+ display: 'flex',
+ alignItems: 'center',
+ justifyContent: 'space-between',
+ flexWrap: 'wrap',
+ gap: 1,
+ }}
+ >
+ {/* Left: title + count */}
+ <Box sx={{ display: 'flex', alignItems: 'center', gap: 1 }}>
+ <Typography
+ variant="subtitle2"
+ sx={{
+ color: theme.palette.text.primary,
+ fontWeight: 600,
+ }}
+ >
+ {t('recordings')}
+ </Typography>
+ {recordings.length > 0 && (
+ <Chip
+ label={
+ filterText
+ ? `${filteredSorted.length} / ${recordings.length}`
+ : String(recordings.length)
+ }
+ size="small"
+ variant="outlined"
+ sx={{
+ height: 20,
+ fontSize: '0.7rem',
+ borderColor: isDark ? 'rgba(255,255,255,0.2)' : undefined,
+ color: isDark ? '#b3b9c6' : undefined,
+ }}
+ />
+ )}
+ </Box>
+
+ {/* Right: filter + sort + refresh */}
+ <Box sx={{ display: 'flex', alignItems: 'center', gap: 1 }}>
+ {/* Search filter */}
+ <TextField
+ size="small"
+ placeholder={t("filter")}
+ value={filterText}
+ onChange={(e) => setFilterText(e.target.value)}
+ InputProps={{
+ startAdornment: (
+ <InputAdornment position="start">
+ <SearchIcon
+ sx={{
+ fontSize: 16,
+ color: isDark
+ ? 'rgba(255,255,255,0.4)'
+ : 'rgba(0,0,0,0.4)',
+ }}
+ />
+ </InputAdornment>
+ ),
+ }}
+ sx={{
+ width: 160,
+ '& input': { fontSize: '0.8rem', py: 0.5 },
+ }}
+ />
+
+ {/* Sort field dropdown */}
+ <Select
+ value={sortField}
+ onChange={handleSortFieldChange}
+ size="small"
+ variant="outlined"
+ sx={{
+ minWidth: 100,
+ '& .MuiSelect-select': {
+ py: 0.4,
+ fontSize: '0.75rem',
+ color: isDark ? '#b3b9c6' : undefined,
+ },
+ '& .MuiOutlinedInput-notchedOutline': {
+ borderColor: isDark
+ ? 'rgba(255,255,255,0.2)'
+ : undefined,
+ },
+ '& .MuiSvgIcon-root': {
+ color: isDark
+ ? 'rgba(255,255,255,0.4)'
+ : undefined,
+ },
+ }}
+ >
+ {SORT_OPTIONS.map((opt) => (
+ <MenuItem key={opt.value} value={opt.value}>
+ {t(opt.labelKey)}
+ </MenuItem>
+ ))}
+ </Select>
+
+ {/* Sort direction toggle */}
+ <Tooltip
+ title={`Sort ${sortDir === 'desc' ? 'newest first' : 'oldest first'} — click to toggle`}
+ >
+ <IconButton
+ size="small"
+ onClick={toggleSortDir}
+ sx={{
+ color: isDark ? '#b3b9c6' : theme.palette.text.secondary,
+ }}
+ >
+ <SortIcon
+ sx={{
+ fontSize: 18,
+ transform: sortDir === 'asc' ? 'scaleY(-1)' : 'none',
+ transition: 'transform 0.2s ease',
+ }}
+ />
+ </IconButton>
+ </Tooltip>
+
+ {/* Refresh */}
+ <Button
+ size="small"
+ startIcon={<RefreshIcon />}
+ onClick={fetchRecordings}
+ disabled={isLoadingList}
+ sx={{ color: isDark ? '#b3b9c6' : undefined }}
+ >
+ {t('refresh')}
+ </Button>
+ </Box>
+ </Box>
+
+ {/* ── Recording list ── */}
+ {isLoadingList ? (
+ <Box sx={{ display: 'flex', justifyContent: 'center', py: 4 }}>
+ <CircularProgress size={24} sx={{ color: ACCENT_BLUE }} />
+ </Box>
+ ) : filteredSorted.length === 0 ? (
+ <Typography
+ variant="body2"
+ color="text.secondary"
+ sx={{ textAlign: 'center', py: 4 }}
+ >
+ {recordings.length === 0
+ ? t('noRecordingsFound')
+ : 'No recordings match your filter.'}
+ </Typography>
+ ) : (
+ <List
+ dense
+ sx={{
+ flex: 1,
+ overflow: 'auto',
+ border: `1px solid ${theme.palette.divider}`,
+ borderRadius: 1,
+ '& .MuiListItemButton-root + .MuiListItemButton-root': {
+ borderTop: `1px solid ${theme.palette.divider}`,
+ },
+ }}
+ >
+ {filteredSorted.map((rec) => (
+ <RecordingRow
+ key={rec.path}
+ rec={rec}
+ isLoading={loadingPath === rec.path}
+ isAnyLoading={isLoadingRecording}
+ isDark={isDark}
+ onClick={() => loadRecording(rec.path)}
+ />
+ ))}
+ </List>
+ )}
+ </Box>
+ );
+};
+
+// ---------------------------------------------------------------------------
+// RecordingRow — a single recording in the list
+// ---------------------------------------------------------------------------
+
+interface RecordingRowProps {
+ rec: RecordingEntry;
+ isLoading: boolean;
+ isAnyLoading: boolean;
+ isDark: boolean;
+ onClick: () => void;
+}
+
+const RecordingRow: React.FC<RecordingRowProps> = React.memo(
+ ({ rec, isLoading, isAnyLoading, isDark, onClick }) => {
+ const theme = useTheme();
+ const parsedDate = parseTimestampFromName(rec.name);
+ const { t } = useTranslation();
+
+ return (
+ <ListItemButton
+ onClick={onClick}
+ disabled={isAnyLoading}
+ sx={{
+ py: 1.25,
+ px: 2,
+ opacity: isAnyLoading && !isLoading ? 0.5 : 1,
+ }}
+ >
+ {/* Folder icon or spinner */}
+ <ListItemIcon sx={{ minWidth: 36 }}>
+ {isLoading ? (
+ <CircularProgress size={20} sx={{ color: ACCENT_BLUE }} />
+ ) : (
+ <FolderIcon
+ fontSize="small"
+ sx={{
+ color: isDark
+ ? ACCENT_BLUE
+ : theme.palette.primary.main,
+ }}
+ />
+ )}
+ </ListItemIcon>
+
+ <ListItemText
+ disableTypography
+ primary={
+ <Typography
+ variant="body2"
+ sx={{
+ fontFamily: MONO_FONT,
+ fontWeight: 600,
+ fontSize: '0.85rem',
+ mb: 0.5,
+ color: theme.palette.text.primary,
+ }}
+ >
+ {rec.name}
+ </Typography>
+ }
+ secondary={
+ <Box
+ sx={{
+ display: 'flex',
+ flexWrap: 'wrap',
+ gap: 1.5,
+ alignItems: 'center',
+ }}
+ >
+ {/* Camera count */}
+ <StatBadge
+ icon={
+ <VideocamIcon
+ sx={{
+ fontSize: 14,
+ color: theme.palette.text.secondary,
+ }}
+ />
+ }
+ label={`${rec.video_count} cam${rec.video_count !== 1 ? 's' : ''}`}
+ tooltip="Camera streams"
+ />
+
+ {/* Size */}
+ {rec.total_size_bytes != null &&
+ rec.total_size_bytes > 0 && (
+ <StatBadge
+ icon={
+ <StorageIcon
+ sx={{
+ fontSize: 14,
+ color: theme.palette.text
+ .secondary,
+ }}
+ />
+ }
+ label={formatBytes(rec.total_size_bytes)}
+ tooltip="Total size on disk"
+ />
+ )}
+
+ {/* Duration */}
+ {rec.duration_seconds != null &&
+ rec.duration_seconds > 0 && (
+ <StatBadge
+ icon={
+ <AccessTimeIcon
+ sx={{
+ fontSize: 14,
+ color: theme.palette.text
+ .secondary,
+ }}
+ />
+ }
+ label={formatDuration(rec.duration_seconds)}
+ tooltip="Recording duration"
+ />
+ )}
+
+ {/* Frame count chip */}
+ {rec.total_frames != null && rec.total_frames > 0 && (
+ <Tooltip title={t("frameCountPerCamera")}>
+ <Chip
+ label={`${rec.total_frames.toLocaleString()} frames`}
+ size="small"
+ variant="outlined"
+ sx={{
+ height: 18,
+ fontSize: '0.65rem',
+ fontFamily: MONO_FONT,
+ '& .MuiChip-label': { px: 0.75 },
+ borderColor: isDark
+ ? `${ACCENT_GREEN}44`
+ : undefined,
+ color: isDark
+ ? ACCENT_GREEN
+ : undefined,
+ }}
+ />
+ </Tooltip>
+ )}
+
+ {/* FPS chip */}
+ {rec.fps != null && rec.fps > 0 && (
+ <Tooltip title={t("recordingCaptureFps")}>
+ <Chip
+ label={`${rec.fps} fps`}
+ size="small"
+ variant="outlined"
+ sx={{
+ height: 18,
+ fontSize: '0.65rem',
+ fontFamily: MONO_FONT,
+ '& .MuiChip-label': { px: 0.75 },
+ borderColor: isDark
+ ? `${ACCENT_BLUE}44`
+ : undefined,
+ color: isDark
+ ? ACCENT_BLUE
+ : theme.palette.info.main,
+ }}
+ />
+ </Tooltip>
+ )}
+
+ {/* Relative time */}
+ {parsedDate && (
+ <Tooltip title={parsedDate.toLocaleString()}>
+ <Typography
+ variant="caption"
+ sx={{
+ color: theme.palette.text.disabled,
+ fontStyle: 'italic',
+ }}
+ >
+ {formatRelativeTime(parsedDate)}
+ </Typography>
+ </Tooltip>
+ )}
+ </Box>
+ }
+ />
+ </ListItemButton>
+ );
+ },
+);
+
+RecordingRow.displayName = 'RecordingRow';
+
+// ---------------------------------------------------------------------------
+// StatBadge — tiny icon + label used in the secondary line
+// ---------------------------------------------------------------------------
+
+interface StatBadgeProps {
+ icon: React.ReactNode;
+ label: string;
+ tooltip: string;
+}
+
+const StatBadge: React.FC<StatBadgeProps> = ({ icon, label, tooltip }) => (
+ <Tooltip title={tooltip}>
+ <Box sx={{ display: 'flex', alignItems: 'center', gap: 0.5 }}>
+ {icon}
+ <Typography variant="caption" color="text.secondary">
+ {label}
+ </Typography>
+ </Box>
+ </Tooltip>
+);
diff --git a/freemocap-ui/src/components/playback/SyncedVideoPlayer.tsx b/freemocap-ui/src/components/playback/SyncedVideoPlayer.tsx
new file mode 100644
index 00000000..dad1a227
--- /dev/null
+++ b/freemocap-ui/src/components/playback/SyncedVideoPlayer.tsx
@@ -0,0 +1,758 @@
+import React, { useCallback, useEffect, useRef, useState, useMemo } from 'react';
+import { Box, Tooltip, Typography, useTheme } from '@mui/material';
+import ReactGridLayout, { noCompactor } from 'react-grid-layout';
+import type { Layout, LayoutItem } from 'react-grid-layout';
+import 'react-grid-layout/css/styles.css';
+import 'react-resizable/css/styles.css';
+import { PlaybackControls } from './PlaybackControls';
+import { useTranslation } from 'react-i18next';
+
+interface VideoEntry {
+ videoId: string;
+ filename: string;
+ streamUrl: string;
+}
+
+export interface PlaybackSettings {
+ showOverlays: boolean;
+ timestampFormat: 'timecode' | 'seconds';
+}
+
+interface SyncedVideoPlayerProps {
+ videos: VideoEntry[];
+ recordingFps?: number;
+ /** Per-camera frame timestamps in seconds from recording start, loaded from CSV files */
+ frameTimestamps?: Record<string, number[]> | null;
+ /** null = auto-optimize, number = manual column count */
+ manualColumns: number | null;
+ /** Increment to force layout reset */
+ resetKey: number;
+ /** Frame to seek to once all videos are ready (default 0) */
+ initialFrame?: number;
+ /** Called when the current frame changes (throttled to ~5Hz) */
+ onFrameChange?: (frame: number) => void;
+}
+
+function formatTimecode(frame: number, fps: number): string {
+ if (fps <= 0) return '00:00:00:00';
+ const totalSec = frame / fps;
+ const h = Math.floor(totalSec / 3600);
+ const m = Math.floor((totalSec % 3600) / 60);
+ const s = Math.floor(totalSec % 60);
+ const f = frame % Math.round(fps);
+ const pad = (n: number) => n.toString().padStart(2, '0');
+ return `${pad(h)}:${pad(m)}:${pad(s)}:${pad(f)}`;
+}
+
+function formatTimecodeFromSeconds(seconds: number, fps: number): string {
+ if (fps <= 0) return '00:00:00:00';
+ const h = Math.floor(seconds / 3600);
+ const m = Math.floor((seconds % 3600) / 60);
+ const s = Math.floor(seconds % 60);
+ const f = Math.floor((seconds % 1) * fps);
+ const pad = (n: number) => n.toString().padStart(2, '0');
+ return `${pad(h)}:${pad(m)}:${pad(s)}:${pad(f)}`;
+}
+
+function formatSeconds(frame: number, fps: number): string {
+ if (fps <= 0) return '0.000s';
+ return `${(frame / fps).toFixed(3)}s`;
+}
+
+/**
+ * Frame-locked multi-video player using a "leader" video element as the
+ * canonical time source. All other videos sync to the leader.
+ *
+ * SYNC STRATEGY:
+ * - The first video is the "leader" and drives canonical time via its
+ * native currentTime property, which naturally accounts for decode
+ * latency, buffering, and rate changes.
+ * - The rAF loop reads leader.currentTime to derive the frame number.
+ * - Follower videos are corrected ONLY when they drift beyond a generous
+ * tolerance (2 frames), avoiding micro-stutter from frequent seeks.
+ * - Overlays update via direct DOM manipulation (zero React re-renders).
+ * - React state for controls/slider updates at ~5Hz.
+ */
+export const SyncedVideoPlayer: React.FC<SyncedVideoPlayerProps> = ({ videos, recordingFps, frameTimestamps, manualColumns, resetKey, initialFrame = 0, onFrameChange }) => {
+ const theme = useTheme();
+ const { t } = useTranslation();
+ const videoRefs = useRef<Map<string, HTMLVideoElement>>(new Map());
+
+ // Direct DOM refs for overlays — updated WITHOUT React re-renders
+ const frameOverlayRefs = useRef<Map<string, HTMLElement>>(new Map());
+ const timeOverlayRefs = useRef<Map<string, HTMLElement>>(new Map());
+
+ // Playback refs (rAF loop reads these, never stale)
+ const isPlayingRef = useRef(false);
+ const currentFrameRef = useRef(0);
+ const totalFramesRef = useRef(0);
+ const fpsRef = useRef(recordingFps || 30);
+ const playbackRateRef = useRef(1);
+ const rafRef = useRef<number | null>(null);
+ const settingsRef = useRef<PlaybackSettings>({ showOverlays: true, timestampFormat: 'seconds' });
+ const frameTimestampsRef = useRef<Record<string, number[]> | null>(null);
+ const onFrameChangeRef = useRef(onFrameChange);
+ onFrameChangeRef.current = onFrameChange;
+ const didSeekInitialRef = useRef(false);
+
+ // Leader-based sync: first video is the time authority
+ const leaderIdRef = useRef<string | null>(null);
+
+ // Follower drift correction: generous tolerance to avoid stutter.
+ // Only correct followers that are more than 2 frames away from leader.
+ const FOLLOWER_DRIFT_TOLERANCE_FRAMES = 2;
+ // Check followers every N rAF ticks (~250ms at 60fps)
+ const FOLLOWER_CHECK_INTERVAL = 15;
+ const followerCheckCounter = useRef(0);
+
+ // Throttle React state updates to ~5Hz
+ const lastReactUpdateRef = useRef(0);
+ const REACT_UPDATE_INTERVAL_MS = 200;
+
+ // Slider drag state
+ const isDraggingRef = useRef(false);
+ const wasPlayingBeforeDragRef = useRef(false);
+
+ // React state — ONLY for controls/slider, NOT updated per-frame
+ const [isPlaying, setIsPlaying] = useState(false);
+ const [currentFrame, setCurrentFrame] = useState(0);
+ const [totalFrames, setTotalFrames] = useState(0);
+ const [duration, setDuration] = useState(0);
+ const [playbackRate, setPlaybackRate] = useState(1);
+ const [videosReady, setVideosReady] = useState(0);
+ const [settings, setSettings] = useState<PlaybackSettings>({
+ showOverlays: true,
+ timestampFormat: 'timecode',
+ });
+ const [isLooping, setIsLooping] = useState(false);
+ const isLoopingRef = useRef(false);
+
+ const fps = recordingFps || 30;
+ const allReady = videosReady >= videos.length && videos.length > 0;
+ const currentTime = fpsRef.current > 0 ? currentFrameRef.current / fpsRef.current : 0;
+
+ // -----------------------------------------------------------------------
+ // Grid layout (same auto-tiling as CameraViewsGrid)
+ // -----------------------------------------------------------------------
+ const GRID_COLS = 12;
+ const GRID_MARGIN: [number, number] = [2, 2];
+
+ const gridContainerRef = useRef<HTMLDivElement>(null);
+ const [gridWidth, setGridWidth] = useState<number>(800);
+ const [gridHeight, setGridHeight] = useState<number>(400);
+
+ useEffect(() => {
+ const el = gridContainerRef.current;
+ if (!el) return;
+ const measure = () => {
+ const rect = el.getBoundingClientRect();
+ setGridWidth(rect.width);
+ setGridHeight(rect.height);
+ };
+ measure();
+ const observer = new ResizeObserver(() => measure());
+ observer.observe(el);
+ return () => observer.disconnect();
+ }, []);
+
+ const computeTiling = (n: number, w: number, h: number) => {
+ if (n <= 1) return { cols: 1, rows: 1 };
+ let bestCols = 1;
+ let bestArea = 0;
+ for (let cols = 1; cols <= n; cols++) {
+ const rows = Math.ceil(n / cols);
+ const cellW = (w - GRID_MARGIN[0] * (cols - 1)) / cols;
+ const cellH = (h - GRID_MARGIN[1] * (rows - 1)) / rows;
+ if (cellW < 80 || cellH < 60) continue;
+ const area = n * cellW * cellH;
+ if (area > bestArea) { bestArea = area; bestCols = cols; }
+ }
+ return { cols: bestCols, rows: Math.ceil(n / bestCols) };
+ };
+
+ const prevTilingRef = useRef({ cols: 1, rows: 1 });
+ const tiling = useMemo(() => {
+ const candidate = manualColumns !== null
+ ? { cols: Math.max(1, Math.min(manualColumns, videos.length || 1)), rows: Math.ceil((videos.length || 1) / Math.max(1, Math.min(manualColumns, videos.length || 1))) }
+ : computeTiling(videos.length, gridWidth, gridHeight);
+ const prev = prevTilingRef.current;
+ if (candidate.cols === prev.cols && candidate.rows === prev.rows) return prev;
+ prevTilingRef.current = candidate;
+ return candidate;
+ }, [videos.length, gridWidth, gridHeight, manualColumns]);
+
+ const buildVideoLayout = (vids: VideoEntry[]): LayoutItem[] => {
+ if (vids.length === 0) return [];
+ const colSpan = Math.floor(GRID_COLS / tiling.cols);
+ return vids.map((v, i) => ({
+ i: v.videoId,
+ x: (i % tiling.cols) * colSpan,
+ y: Math.floor(i / tiling.cols),
+ w: colSpan,
+ h: 1,
+ minW: 1,
+ minH: 1,
+ }));
+ };
+
+ const [gridLayout, setGridLayout] = useState<LayoutItem[]>(() => buildVideoLayout(videos));
+
+ useEffect(() => {
+ setGridLayout(buildVideoLayout(videos));
+ }, [videos, tiling, resetKey]);
+
+ const gridLayoutBeforeDragRef = useRef<LayoutItem[]>(gridLayout);
+
+ const handleGridDragStart = useCallback(() => {
+ gridLayoutBeforeDragRef.current = gridLayout;
+ }, [gridLayout]);
+
+ const handleGridDragStop = useCallback((_newLayout: Layout, _oldItem: LayoutItem | null, newItem: LayoutItem | null) => {
+ if (!newItem) return;
+ const preDrag = gridLayoutBeforeDragRef.current;
+ const draggedBefore = preDrag.find((l) => l.i === newItem.i);
+ if (!draggedBefore) return;
+
+ const swapTarget = preDrag.find((l) => {
+ if (l.i === newItem.i) return false;
+ return newItem.x < l.x + l.w && newItem.x + newItem.w > l.x
+ && newItem.y < l.y + l.h && newItem.y + newItem.h > l.y;
+ });
+
+ if (swapTarget) {
+ setGridLayout(preDrag.map((l) => {
+ if (l.i === newItem.i) return { ...l, x: swapTarget.x, y: swapTarget.y };
+ if (l.i === swapTarget.i) return { ...l, x: draggedBefore.x, y: draggedBefore.y };
+ return l;
+ }));
+ } else {
+ const maxX = GRID_COLS - newItem.w;
+ const maxY = tiling.rows - newItem.h;
+ setGridLayout(preDrag.map((l) => {
+ if (l.i === newItem.i) {
+ return { ...l, x: Math.max(0, Math.min(newItem.x, maxX)), y: Math.max(0, Math.min(newItem.y, maxY)) };
+ }
+ return l;
+ }));
+ }
+ }, [tiling.rows]);
+
+ const handleGridLayoutChange = useCallback((_: Layout) => {}, []);
+ const handleGridResizeStop = useCallback((newLayout: Layout) => { setGridLayout([...newLayout]); }, []);
+
+ const gridRowHeight = useMemo(() => {
+ const totalMargin = (tiling.rows - 1) * GRID_MARGIN[1];
+ return Math.max(30, (gridHeight - totalMargin) / tiling.rows);
+ }, [gridHeight, tiling.rows]);
+
+ // Keep refs in sync with props/state
+ useEffect(() => { settingsRef.current = settings; }, [settings]);
+ useEffect(() => { isLoopingRef.current = isLooping; }, [isLooping]);
+ useEffect(() => { frameTimestampsRef.current = frameTimestamps ?? null; }, [frameTimestamps]);
+ useEffect(() => {
+ if (recordingFps && recordingFps > 0) fpsRef.current = recordingFps;
+ }, [recordingFps]);
+
+ // Elect leader whenever video list changes
+ useEffect(() => {
+ leaderIdRef.current = videos.length > 0 ? videos[0].videoId : null;
+ }, [videos]);
+
+ // -----------------------------------------------------------------------
+ // Direct DOM overlay updates — fast, no React involved
+ // -----------------------------------------------------------------------
+ const updateOverlays = useCallback((frame: number) => {
+ const s = settingsRef.current;
+ const ts = frameTimestampsRef.current;
+ const padLen = Math.max(String(totalFramesRef.current).length, 1);
+ const frameText = 'F' + String(frame).padStart(padLen, '0');
+
+ let timeText: string;
+ if (ts) {
+ const firstKey = Object.keys(ts)[0];
+ const camTs = firstKey ? ts[firstKey] : null;
+ if (camTs && frame < camTs.length) {
+ const realSec = camTs[frame];
+ timeText = s.timestampFormat === 'timecode'
+ ? formatTimecodeFromSeconds(realSec, fpsRef.current)
+ : `${realSec.toFixed(3)}s`;
+ } else {
+ timeText = '~' + (s.timestampFormat === 'timecode'
+ ? formatTimecode(frame, fpsRef.current)
+ : formatSeconds(frame, fpsRef.current));
+ }
+ } else {
+ timeText = '~' + (s.timestampFormat === 'timecode'
+ ? formatTimecode(frame, fpsRef.current)
+ : formatSeconds(frame, fpsRef.current));
+ }
+
+ frameOverlayRefs.current.forEach((el) => { el.textContent = frameText; });
+ timeOverlayRefs.current.forEach((el) => { el.textContent = timeText; });
+ }, []);
+
+ // -----------------------------------------------------------------------
+ // Ref registration
+ // -----------------------------------------------------------------------
+ const setVideoRef = useCallback((videoId: string, el: HTMLVideoElement | null) => {
+ if (el) videoRefs.current.set(videoId, el);
+ else videoRefs.current.delete(videoId);
+ }, []);
+
+ const setFrameOverlayRef = useCallback((videoId: string, el: HTMLElement | null) => {
+ if (el) frameOverlayRefs.current.set(videoId, el);
+ else frameOverlayRefs.current.delete(videoId);
+ }, []);
+
+ const setTimeOverlayRef = useCallback((videoId: string, el: HTMLElement | null) => {
+ if (el) timeOverlayRefs.current.set(videoId, el);
+ else timeOverlayRefs.current.delete(videoId);
+ }, []);
+
+ // -----------------------------------------------------------------------
+ // Seek all videos to a frame (used when PAUSED / stepping only)
+ // -----------------------------------------------------------------------
+ const seekAllToFrame = useCallback((frame: number) => {
+ const clamped = Math.max(0, Math.min(frame, totalFramesRef.current - 1));
+ const targetTime = fpsRef.current > 0 ? clamped / fpsRef.current : 0;
+ videoRefs.current.forEach((el) => { el.currentTime = targetTime; });
+ currentFrameRef.current = clamped;
+ setCurrentFrame(clamped);
+ onFrameChangeRef.current?.(clamped);
+ updateOverlays(clamped);
+ }, [updateOverlays]);
+
+ // -----------------------------------------------------------------------
+ // Native play/pause
+ // -----------------------------------------------------------------------
+ const playAllVideos = useCallback(() => {
+ const rate = playbackRateRef.current;
+ // Play leader first so it starts decoding immediately
+ const leaderId = leaderIdRef.current;
+ const leader = leaderId ? videoRefs.current.get(leaderId) : null;
+ if (leader) {
+ leader.playbackRate = rate;
+ leader.play().catch(() => {});
+ }
+ videoRefs.current.forEach((el, id) => {
+ if (id === leaderId) return;
+ el.playbackRate = rate;
+ el.play().catch(() => {});
+ });
+ }, []);
+
+ const pauseAllVideos = useCallback(() => {
+ videoRefs.current.forEach((el) => { el.pause(); });
+ }, []);
+
+ // -----------------------------------------------------------------------
+ // rAF playback loop — reads leader.currentTime as the time source.
+ //
+ // This eliminates the wall-clock-vs-decode-pipeline fight that causes
+ // stutter. The leader's currentTime naturally accounts for buffering,
+ // decode latency, and rate changes. We just read it and derive frames.
+ // -----------------------------------------------------------------------
+ const tick = useCallback((timestamp: DOMHighResTimeStamp) => {
+ if (!isPlayingRef.current) return;
+
+ const leaderId = leaderIdRef.current;
+ const leader = leaderId ? videoRefs.current.get(leaderId) : null;
+ if (!leader) {
+ rafRef.current = requestAnimationFrame(tick);
+ return;
+ }
+
+ const leaderTime = leader.currentTime;
+ const newFrame = leaderTime * fpsRef.current;
+
+ // End of video — loop back to start or stop
+ if (newFrame >= totalFramesRef.current) {
+ if (isLoopingRef.current) {
+ // Pause all videos, seek cleanly to frame 0, then restart playback.
+ // Seeking while videos are still playing causes the browser's decode
+ // pipeline to stall, producing choppy playback on subsequent loops.
+ pauseAllVideos();
+ const targetTime = 0;
+ videoRefs.current.forEach((el) => { el.currentTime = targetTime; });
+ currentFrameRef.current = 0;
+ followerCheckCounter.current = 0;
+ updateOverlays(0);
+ setCurrentFrame(0);
+ playAllVideos();
+ rafRef.current = requestAnimationFrame(tick);
+ return;
+ }
+ pauseAllVideos();
+ isPlayingRef.current = false;
+ const endFrame = totalFramesRef.current - 1;
+ currentFrameRef.current = endFrame;
+ updateOverlays(endFrame);
+ setIsPlaying(false);
+ setCurrentFrame(endFrame);
+ return;
+ }
+
+ const intFrame = Math.floor(newFrame);
+ const prevIntFrame = Math.floor(currentFrameRef.current);
+ currentFrameRef.current = newFrame;
+
+ // Update DOM overlays on frame change
+ if (intFrame !== prevIntFrame) {
+ updateOverlays(intFrame);
+ }
+
+ // Throttled React update for slider (~5Hz)
+ if (timestamp - lastReactUpdateRef.current >= REACT_UPDATE_INTERVAL_MS) {
+ lastReactUpdateRef.current = timestamp;
+ setCurrentFrame(intFrame);
+ onFrameChangeRef.current?.(intFrame);
+ }
+
+ // Periodic follower drift correction — only when drift exceeds tolerance.
+ // This is the key to smooth playback: let browser-native playback run
+ // undisturbed and only intervene when followers genuinely desync.
+ followerCheckCounter.current++;
+ if (followerCheckCounter.current >= FOLLOWER_CHECK_INTERVAL) {
+ followerCheckCounter.current = 0;
+ const toleranceSec = FOLLOWER_DRIFT_TOLERANCE_FRAMES / fpsRef.current;
+ const rate = playbackRateRef.current;
+ videoRefs.current.forEach((el, id) => {
+ if (id === leaderId) return;
+ if (Math.abs(el.currentTime - leaderTime) > toleranceSec) {
+ el.currentTime = leaderTime;
+ }
+ if (Math.abs(el.playbackRate - rate) > 0.01) {
+ el.playbackRate = rate;
+ }
+ });
+ }
+
+ rafRef.current = requestAnimationFrame(tick);
+ }, [pauseAllVideos, playAllVideos, updateOverlays]);
+
+ const startLoop = useCallback(() => {
+ followerCheckCounter.current = 0;
+ lastReactUpdateRef.current = 0;
+ rafRef.current = requestAnimationFrame(tick);
+ }, [tick]);
+
+ const stopLoop = useCallback(() => {
+ if (rafRef.current !== null) { cancelAnimationFrame(rafRef.current); rafRef.current = null; }
+ }, []);
+
+ useEffect(() => stopLoop, [stopLoop]);
+
+ // -----------------------------------------------------------------------
+ // Metadata
+ // -----------------------------------------------------------------------
+ const handleLoadedMetadata = useCallback((e: React.SyntheticEvent<HTMLVideoElement>) => {
+ const el = e.currentTarget;
+ if (el.duration && el.duration !== Infinity) {
+ const d = el.duration;
+ setDuration((prev) => Math.max(prev, d));
+ const frames = Math.floor(d * fpsRef.current);
+ if (totalFramesRef.current === 0 || frames < totalFramesRef.current) {
+ totalFramesRef.current = frames;
+ setTotalFrames(frames);
+ }
+ }
+ el.pause();
+ setVideosReady((prev) => prev + 1);
+ }, []);
+
+ // -----------------------------------------------------------------------
+ // Playback commands
+ // -----------------------------------------------------------------------
+ const handlePlayPause = useCallback(() => {
+ if (isPlayingRef.current) {
+ isPlayingRef.current = false;
+ stopLoop();
+ pauseAllVideos();
+ setIsPlaying(false);
+ // Snap all videos to leader's position on pause for perfect alignment
+ const leaderId = leaderIdRef.current;
+ const leader = leaderId ? videoRefs.current.get(leaderId) : null;
+ if (leader) {
+ const pauseFrame = Math.floor(leader.currentTime * fpsRef.current);
+ seekAllToFrame(pauseFrame);
+ }
+ } else {
+ if (Math.floor(currentFrameRef.current) >= totalFramesRef.current - 1) {
+ seekAllToFrame(0);
+ }
+ isPlayingRef.current = true;
+ setIsPlaying(true);
+ playAllVideos();
+ startLoop();
+ }
+ }, [seekAllToFrame, startLoop, stopLoop, playAllVideos, pauseAllVideos]);
+
+ // Slider DRAG — pause once, then scrub as user drags
+ const handleSeekDrag = useCallback((frame: number) => {
+ if (!isDraggingRef.current) {
+ isDraggingRef.current = true;
+ wasPlayingBeforeDragRef.current = isPlayingRef.current;
+ if (isPlayingRef.current) {
+ isPlayingRef.current = false;
+ stopLoop();
+ pauseAllVideos();
+ }
+ }
+ const clamped = Math.max(0, Math.min(frame, totalFramesRef.current - 1));
+ currentFrameRef.current = clamped;
+ updateOverlays(clamped);
+ setCurrentFrame(clamped);
+ const targetTime = fpsRef.current > 0 ? clamped / fpsRef.current : 0;
+ videoRefs.current.forEach((el) => { el.currentTime = targetTime; });
+ }, [stopLoop, pauseAllVideos, updateOverlays]);
+
+ // Slider COMMIT — final seek + resume if was playing
+ const handleSeekCommit = useCallback((frame: number) => {
+ const clamped = Math.max(0, Math.min(frame, totalFramesRef.current - 1));
+ seekAllToFrame(clamped);
+ if (wasPlayingBeforeDragRef.current) {
+ isPlayingRef.current = true;
+ setIsPlaying(true);
+ playAllVideos();
+ startLoop();
+ }
+ isDraggingRef.current = false;
+ wasPlayingBeforeDragRef.current = false;
+ }, [seekAllToFrame, playAllVideos, startLoop]);
+
+ const handleFrameStep = useCallback((delta: number) => {
+ if (isPlayingRef.current) { isPlayingRef.current = false; stopLoop(); pauseAllVideos(); setIsPlaying(false); }
+ seekAllToFrame(Math.floor(currentFrameRef.current) + delta);
+ }, [seekAllToFrame, stopLoop, pauseAllVideos]);
+
+ const handlePlaybackRateChange = useCallback((rate: number) => {
+ playbackRateRef.current = rate;
+ setPlaybackRate(rate);
+ videoRefs.current.forEach((el) => { el.playbackRate = rate; });
+ }, []);
+
+ const handleSeekToStart = useCallback(() => {
+ const wasPlaying = isPlayingRef.current;
+ if (wasPlaying) { isPlayingRef.current = false; stopLoop(); pauseAllVideos(); }
+ seekAllToFrame(0);
+ if (wasPlaying) { isPlayingRef.current = true; setIsPlaying(true); playAllVideos(); startLoop(); }
+ }, [seekAllToFrame, stopLoop, startLoop, playAllVideos, pauseAllVideos]);
+
+ const handleSeekToEnd = useCallback(() => {
+ if (isPlayingRef.current) { isPlayingRef.current = false; stopLoop(); pauseAllVideos(); setIsPlaying(false); }
+ seekAllToFrame(totalFramesRef.current - 1);
+ }, [seekAllToFrame, stopLoop, pauseAllVideos]);
+
+ const handleToggleLoop = useCallback(() => {
+ setIsLooping((prev) => !prev);
+ }, []);
+
+ // Seek to initialFrame once all videos are ready (e.g. restoring position after tab switch)
+ useEffect(() => {
+ if (allReady && !didSeekInitialRef.current && initialFrame > 0) {
+ didSeekInitialRef.current = true;
+ seekAllToFrame(initialFrame);
+ }
+ }, [allReady, initialFrame, seekAllToFrame]);
+
+ // -----------------------------------------------------------------------
+ // Keyboard
+ // -----------------------------------------------------------------------
+ useEffect(() => {
+ const handleKeyDown = (e: KeyboardEvent) => {
+ if (e.target instanceof HTMLInputElement || e.target instanceof HTMLTextAreaElement) return;
+ switch (e.key) {
+ case ' ': if (e.shiftKey) break; e.preventDefault(); handlePlayPause(); break;
+ case 'ArrowLeft': e.preventDefault(); handleFrameStep(e.shiftKey ? -10 : -1); break;
+ case 'ArrowRight': e.preventDefault(); handleFrameStep(e.shiftKey ? 10 : 1); break;
+ case 'Home': e.preventDefault(); handleSeekToStart(); break;
+ case 'End': e.preventDefault(); handleSeekToEnd(); break;
+ case 'l': case 'L': e.preventDefault(); handleToggleLoop(); break;
+ }
+ };
+ window.addEventListener('keydown', handleKeyDown);
+ return () => window.removeEventListener('keydown', handleKeyDown);
+ }, [handlePlayPause, handleFrameStep, handleSeekToStart, handleSeekToEnd, handleToggleLoop]);
+
+ // -----------------------------------------------------------------------
+ // Render
+ // -----------------------------------------------------------------------
+ if (videos.length === 0) {
+ return (
+ <Box sx={{ display: 'flex', alignItems: 'center', justifyContent: 'center', height: '100%', color: 'text.secondary' }}>
+ <Typography>{t("noVideosLoaded")}</Typography>
+ </Box>
+ );
+ }
+
+ const framePadLen = Math.max(String(totalFrames).length, 1);
+ const initialFrameText = 'F' + String(currentFrame).padStart(framePadLen, '0');
+
+ let initialTimeText: string;
+ let timestampsAreReal = false;
+ if (frameTimestamps) {
+ const firstKey = Object.keys(frameTimestamps)[0];
+ const camTs = firstKey ? frameTimestamps[firstKey] : null;
+ if (camTs && currentFrame < camTs.length) {
+ const realSec = camTs[currentFrame];
+ initialTimeText = settings.timestampFormat === 'timecode'
+ ? formatTimecodeFromSeconds(realSec, fps)
+ : `${realSec.toFixed(3)}s`;
+ timestampsAreReal = true;
+ } else {
+ initialTimeText = '~' + (settings.timestampFormat === 'timecode'
+ ? formatTimecode(currentFrame, fps)
+ : formatSeconds(currentFrame, fps));
+ }
+ } else {
+ initialTimeText = '~' + (settings.timestampFormat === 'timecode'
+ ? formatTimecode(currentFrame, fps)
+ : formatSeconds(currentFrame, fps));
+ }
+
+ return (
+ <Box sx={{ display: 'flex', flexDirection: 'column', height: '100%', width: '100%' }}>
+ {/* Video grid */}
+ <Box
+ ref={gridContainerRef}
+ sx={{
+ flex: 1,
+ position: 'relative',
+ overflow: 'hidden',
+ backgroundColor: '#0a0a0a',
+ minHeight: 0,
+ '& .react-grid-placeholder': {
+ backgroundColor: 'primary.main',
+ opacity: 0.15,
+ borderRadius: '4px',
+ },
+ '& .react-resizable-handle': {
+ zIndex: 10,
+ },
+ }}
+ >
+ <ReactGridLayout
+ width={gridWidth}
+ layout={gridLayout}
+ gridConfig={{
+ cols: GRID_COLS,
+ rowHeight: gridRowHeight,
+ margin: GRID_MARGIN,
+ containerPadding: [0, 0] as [number, number],
+ }}
+ dragConfig={{ enabled: true }}
+ resizeConfig={{ enabled: true }}
+ compactor={noCompactor}
+ onLayoutChange={handleGridLayoutChange}
+ onDragStart={handleGridDragStart}
+ onDragStop={handleGridDragStop}
+ onResizeStop={handleGridResizeStop}
+ >
+ {videos.map((video) => (
+ <div
+ key={video.videoId}
+ style={{
+ position: 'relative',
+ overflow: 'hidden',
+ backgroundColor: '#000',
+ borderRadius: '4px',
+ border: '1px solid rgba(255,255,255,0.15)',
+ }}
+ >
+ <video
+ ref={(el) => setVideoRef(video.videoId, el)}
+ src={video.streamUrl}
+ preload="auto"
+ muted
+ playsInline
+ style={{ width: '100%', height: '100%', objectFit: 'contain' }}
+ onLoadedMetadata={handleLoadedMetadata}
+ />
+
+ {settings.showOverlays && (
+ <>
+ {/* FRAME NUMBER — DOM ref, updated directly */}
+ <Box
+ ref={(el: HTMLElement | null) => setFrameOverlayRef(video.videoId, el)}
+ sx={{
+ position: 'absolute', top: 6, right: 6,
+ backgroundColor: 'rgba(0, 0, 0, 0.88)',
+ color: '#00ff88',
+ px: 1.25, py: 0.4, borderRadius: '4px',
+ fontSize: '14px', fontWeight: 700,
+ fontFamily: '"JetBrains Mono", "Fira Code", "SF Mono", "Cascadia Code", monospace',
+ letterSpacing: '0.5px', lineHeight: 1,
+ border: '1px solid rgba(0, 255, 136, 0.3)',
+ textShadow: '0 0 6px rgba(0, 255, 136, 0.4)',
+ minWidth: 60, textAlign: 'center',
+ userSelect: 'none', pointerEvents: 'none', zIndex: 10,
+ }}
+ >
+ {initialFrameText}
+ </Box>
+
+ {/* CAMERA ID — static */}
+ <Box sx={{
+ position: 'absolute', bottom: 6, left: 6,
+ backgroundColor: 'rgba(0, 0, 0, 0.75)',
+ color: '#ccc', px: 1, py: 0.25, borderRadius: '3px',
+ fontSize: '11px',
+ fontFamily: '"JetBrains Mono", "Fira Code", monospace',
+ userSelect: 'none', pointerEvents: 'none', zIndex: 10,
+ }}>
+ {video.videoId}
+ </Box>
+
+ {/* TIMECODE — DOM ref, updated directly */}
+ <Tooltip title={timestampsAreReal ? t("timestampFromRecording") : t("estimatedFromFrameNumber")} placement="top-end">
+ <Box
+ ref={(el: HTMLElement | null) => setTimeOverlayRef(video.videoId, el)}
+ sx={{
+ position: 'absolute', bottom: 6, right: 6,
+ backgroundColor: 'rgba(0, 0, 0, 0.75)',
+ color: '#aaa', px: 0.75, py: 0.25, borderRadius: '3px',
+ fontSize: '10px',
+ fontFamily: '"JetBrains Mono", "Fira Code", monospace',
+ userSelect: 'none', zIndex: 10,
+ }}
+ >
+ {initialTimeText}
+ </Box>
+ </Tooltip>
+ </>
+ )}
+ </div>
+ ))}
+ </ReactGridLayout>
+ </Box>
+
+ {!allReady && videos.length > 0 && (
+ <Box sx={{ textAlign: 'center', py: 0.5, backgroundColor: theme.palette.warning.dark, color: '#fff' }}>
+ <Typography variant="caption">{t("loadingVideos", { ready: videosReady, total: videos.length })}</Typography>
+ </Box>
+ )}
+
+ <PlaybackControls
+ isPlaying={isPlaying}
+ currentTime={currentTime}
+ duration={duration}
+ playbackRate={playbackRate}
+ currentFrame={currentFrame}
+ totalFrames={totalFrames}
+ fps={fps}
+ recordingFps={recordingFps}
+ settings={settings}
+ onSettingsChange={setSettings}
+ onPlayPause={handlePlayPause}
+ onSeekDrag={handleSeekDrag}
+ onSeekCommit={handleSeekCommit}
+ onFrameStep={handleFrameStep}
+ onPlaybackRateChange={handlePlaybackRateChange}
+ onSeekToStart={handleSeekToStart}
+ onSeekToEnd={handleSeekToEnd}
+ isLooping={isLooping}
+ onToggleLoop={handleToggleLoop}
+ />
+ </Box>
+ );
+};
diff --git a/freemocap-ui/src/components/playback/index.ts b/freemocap-ui/src/components/playback/index.ts
new file mode 100644
index 00000000..ece1bfab
--- /dev/null
+++ b/freemocap-ui/src/components/playback/index.ts
@@ -0,0 +1,5 @@
+export { PlaybackControls } from './PlaybackControls';
+export { SyncedVideoPlayer } from './SyncedVideoPlayer';
+export type { PlaybackSettings } from './SyncedVideoPlayer';
+export { RecordingBrowser } from './RecordingBrowser';
+export type { LoadedVideo } from './RecordingBrowser';
diff --git a/freemocap-ui/src/components/recording-info-panel/RecordingCompleteDialog.tsx b/freemocap-ui/src/components/recording-info-panel/RecordingCompleteDialog.tsx
new file mode 100644
index 00000000..0b03d9e7
--- /dev/null
+++ b/freemocap-ui/src/components/recording-info-panel/RecordingCompleteDialog.tsx
@@ -0,0 +1,164 @@
+import React from 'react';
+import {
+ Dialog,
+ DialogTitle,
+ DialogContent,
+ DialogActions,
+ Button,
+ Typography,
+ Table,
+ TableBody,
+ TableCell,
+ TableContainer,
+ TableHead,
+ TableRow,
+ IconButton,
+ Box,
+ Divider,
+} from '@mui/material';
+import ContentCopyIcon from '@mui/icons-material/ContentCopy';
+import FolderOpenIcon from '@mui/icons-material/FolderOpen';
+import PlayArrowIcon from '@mui/icons-material/PlayArrow';
+import { useNavigate } from 'react-router-dom';
+import { useAppDispatch, useAppSelector } from '@/store/hooks';
+import { recordingCompletionDismissed } from '@/store/slices/recording/recording-slice';
+import { useElectronIPC } from '@/services/electron-ipc/electron-ipc';
+import type { RecordingCompletionData, StatsSummary } from '@/store/slices/recording/recording-types';
+
+function formatStat(value: number, precision: number = 3): string {
+ return value.toFixed(precision);
+}
+
+interface TimingRow {
+ label: string;
+ stats: StatsSummary;
+}
+
+function TimingStatsTable({ data }: { data: RecordingCompletionData }) {
+ const rows: TimingRow[] = [
+ { label: 'Framerate / FPS (Hz)', stats: data.framerate_stats },
+ { label: 'Frame Duration (ms)', stats: data.frame_duration_stats },
+ { label: 'Inter-Camera Frame Grab Sync (ms)', stats: data.inter_camera_grab_range_ms_stats },
+ ];
+
+ return (
+ <TableContainer>
+ <Table size="small" sx={{ '& td, & th': { py: 0.5, px: 1, fontSize: '0.8rem' } }}>
+ <TableHead>
+ <TableRow>
+ <TableCell sx={{ fontWeight: 'bold' }}>Metric</TableCell>
+ <TableCell align="right" sx={{ fontWeight: 'bold' }}>Median</TableCell>
+ <TableCell align="right" sx={{ fontWeight: 'bold' }}>Mean</TableCell>
+ <TableCell align="right" sx={{ fontWeight: 'bold' }}>Std</TableCell>
+ <TableCell align="right" sx={{ fontWeight: 'bold' }}>Min</TableCell>
+ <TableCell align="right" sx={{ fontWeight: 'bold' }}>Max</TableCell>
+ </TableRow>
+ </TableHead>
+ <TableBody>
+ {rows.map((row) => (
+ <TableRow key={row.label}>
+ <TableCell>{row.label}</TableCell>
+ <TableCell align="right">{formatStat(row.stats.median)}</TableCell>
+ <TableCell align="right">{formatStat(row.stats.mean)}</TableCell>
+ <TableCell align="right">{formatStat(row.stats.std)}</TableCell>
+ <TableCell align="right">{formatStat(row.stats.min)}</TableCell>
+ <TableCell align="right">{formatStat(row.stats.max)}</TableCell>
+ </TableRow>
+ ))}
+ </TableBody>
+ </Table>
+ </TableContainer>
+ );
+}
+
+export const RecordingCompleteDialog: React.FC = () => {
+ const dispatch = useAppDispatch();
+ const navigate = useNavigate();
+ const { api } = useElectronIPC();
+ const completionData = useAppSelector((state) => state.recording.completionData);
+
+ if (!completionData) return null;
+
+ const handleClose = () => dispatch(recordingCompletionDismissed());
+
+ const handleCopyPath = () => {
+ navigator.clipboard.writeText(completionData.recording_path);
+ };
+
+ const handleOpenFolder = async () => {
+ try {
+ await api?.fileSystem.openFolder.mutate({ path: completionData.recording_path });
+ } catch (err) {
+ console.error('Failed to open recording folder:', err);
+ }
+ };
+
+ const handleOpenInPlayback = () => {
+ dispatch(recordingCompletionDismissed());
+ navigate('/playback', { state: { loadRecordingPath: completionData.recording_path } });
+ };
+
+ return (
+ <Dialog open onClose={handleClose} maxWidth="md" fullWidth>
+ <DialogTitle sx={{ pb: 1 }}>Recording Complete!</DialogTitle>
+ <DialogContent>
+ <Box sx={{ display: 'flex', alignItems: 'center', gap: 1, mb: 2 }}>
+ <Typography
+ variant="body2"
+ sx={{
+ fontFamily: 'monospace',
+ fontSize: '0.8rem',
+ bgcolor: 'action.hover',
+ px: 1,
+ py: 0.5,
+ borderRadius: 1,
+ flex: 1,
+ overflow: 'hidden',
+ textOverflow: 'ellipsis',
+ whiteSpace: 'nowrap',
+ }}
+ >
+ {completionData.recording_path}
+ </Typography>
+ <IconButton size="small" onClick={handleCopyPath} title="Copy path">
+ <ContentCopyIcon fontSize="small" />
+ </IconButton>
+ <IconButton size="small" onClick={handleOpenFolder} title="Open folder">
+ <FolderOpenIcon fontSize="small" />
+ </IconButton>
+ </Box>
+
+ <Typography variant="body2" sx={{ mb: 2, color: 'text.secondary' }}>
+ {completionData.number_of_cameras} camera{completionData.number_of_cameras !== 1 ? 's' : ''}
+ {' \u00B7 '}
+ {completionData.number_of_frames} frames
+ {' \u00B7 '}
+ {completionData.total_duration_sec}s
+ {' \u00B7 '}
+ {completionData.mean_framerate} Hz avg
+ </Typography>
+
+ <Divider sx={{ mb: 1.5 }} />
+
+ <Typography variant="subtitle2" sx={{ mb: 1 }}>
+ Frame Timing Statistics
+ </Typography>
+
+ <TimingStatsTable data={completionData} />
+ </DialogContent>
+ <DialogActions>
+ <Button
+ onClick={handleOpenInPlayback}
+ variant="outlined"
+ size="small"
+ startIcon={<PlayArrowIcon />}
+ >
+ Open in Playback
+ </Button>
+ <Button onClick={handleClose} variant="contained" size="small">
+ Close
+ </Button>
+ </DialogActions>
+ </Dialog>
+ );
+};
diff --git a/freemocap-ui/src/components/recording-info-panel/getTimestampString.ts b/freemocap-ui/src/components/recording-info-panel/getTimestampString.ts
new file mode 100644
index 00000000..f3b56d54
--- /dev/null
+++ b/freemocap-ui/src/components/recording-info-panel/getTimestampString.ts
@@ -0,0 +1,29 @@
+export const getTimestampString = (): string => {
+ const now = new Date();
+
+ const dateOptions: Intl.DateTimeFormatOptions = {
+ year: "numeric",
+ month: "2-digit",
+ day: "2-digit",
+ hour: "2-digit",
+ minute: "2-digit",
+ second: "2-digit",
+ hour12: false,
+ timeZoneName: "shortOffset",
+ };
+
+ const formatter = new Intl.DateTimeFormat("en-US", dateOptions);
+ const parts = formatter.formatToParts(now);
+
+ const partMap: Record<string, string> = {};
+ parts.forEach((part) => {
+ partMap[part.type] = part.value;
+ });
+
+ return `${partMap.year}-${partMap.month}-${partMap.day}_${
+ partMap.hour
+ }-${partMap.minute}-${partMap.second}_${partMap.timeZoneName.replace(
+ ":",
+ ""
+ )}`;
+};
diff --git a/freemocap-ui/src/components/recording-info-panel/recording-subcomponents/MicrophoneSelector.tsx b/freemocap-ui/src/components/recording-info-panel/recording-subcomponents/MicrophoneSelector.tsx
new file mode 100644
index 00000000..0065457b
--- /dev/null
+++ b/freemocap-ui/src/components/recording-info-panel/recording-subcomponents/MicrophoneSelector.tsx
@@ -0,0 +1,120 @@
+import React, {useEffect, useState} from "react";
+import { useTranslation } from "react-i18next";
+import {
+ Box,
+ FormControl,
+ IconButton,
+ MenuItem,
+ Select,
+ Tooltip,
+ Typography,
+} from "@mui/material";
+import {Mic, MicOff, Refresh} from "@mui/icons-material";
+import {serverUrls} from "@/services";
+
+type MicrophoneSelectorProps = {
+ selectedMicIndex: number;
+ onMicSelected: (micIndex: number) => void;
+ disabled: boolean;
+};
+
+type MicrophoneMap = Record<number, string>;
+
+export const MicrophoneSelector: React.FC<MicrophoneSelectorProps> = ({
+ selectedMicIndex,
+ onMicSelected,
+ disabled,
+}) => {
+ const [microphones, setMicrophones] = useState<MicrophoneMap>({});
+ const [loading, setLoading] = useState<boolean>(false);
+ const [error, setError] = useState<string | null>(null);
+ const { t } = useTranslation();
+
+ const detectMicrophones = async (): Promise<void> => {
+ setLoading(true);
+ setError(null);
+ try {
+ const response = await fetch(serverUrls.endpoints.detectMicrophones);
+ if (!response.ok) {
+ throw new Error(`Failed to detect microphones: ${response.statusText}`);
+ }
+ const data = await response.json();
+ setMicrophones(data.microphones ?? {});
+ } catch (e) {
+ const msg = e instanceof Error ? e.message : String(e);
+ setError(msg);
+ console.error("Microphone detection failed:", msg);
+ } finally {
+ setLoading(false);
+ }
+ };
+
+ // Detect on mount
+ useEffect(() => {
+ detectMicrophones();
+ }, []);
+
+ const micEntries = Object.entries(microphones).map(([id, name]) => ({
+ id: Number(id),
+ name: name as string,
+ }));
+
+ const isActive = selectedMicIndex >= 0;
+
+ return (
+ <Box sx={{display: "flex", alignItems: "center", gap: 0.5, minWidth: 0}}>
+ <Tooltip title={isActive ? t("audioRecordingEnabled") : t("noMicrophoneSelected")}>
+ {isActive ? (
+ <Mic sx={{fontSize: 16, color: "success.main", flexShrink: 0}}/>
+ ) : (
+ <MicOff sx={{fontSize: 16, color: "text.disabled", flexShrink: 0}}/>
+ )}
+ </Tooltip>
+
+ <FormControl size="small" sx={{minWidth: 120, flex: 1}} disabled={disabled || loading}>
+ <Select
+ value={selectedMicIndex}
+ onChange={(e) => onMicSelected(Number(e.target.value))}
+ displayEmpty
+ sx={{
+ fontSize: "0.75rem",
+ height: 28,
+ "& .MuiSelect-select": {py: 0.25},
+ }}
+ >
+ <MenuItem value={-1}>
+ <Typography variant="caption" color="text.secondary">
+ {t('noMicrophone')}
+ </Typography>
+ </MenuItem>
+ {micEntries.map(({id, name}) => (
+ <MenuItem key={id} value={id}>
+ <Typography variant="caption" noWrap>
+ {name}
+ </Typography>
+ </MenuItem>
+ ))}
+ </Select>
+ </FormControl>
+
+ <Tooltip title={t("refreshMicrophoneList")}>
+ <span>
+ <IconButton
+ size="small"
+ onClick={detectMicrophones}
+ disabled={disabled || loading}
+ sx={{p: 0.25, flexShrink: 0}}
+ >
+ <Refresh sx={{fontSize: 14}}/>
+ </IconButton>
+ </span>
+ </Tooltip>
+
+ {error && (
+ <Typography variant="caption" color="error" noWrap sx={{fontSize: "0.65rem"}}>
+ {error}
+ </Typography>
+ )}
+ </Box>
+ );
+};
diff --git a/freemocap-ui/src/components/ui-components/UpdateBanner.tsx b/freemocap-ui/src/components/ui-components/UpdateBanner.tsx
new file mode 100644
index 00000000..713dfba3
--- /dev/null
+++ b/freemocap-ui/src/components/ui-components/UpdateBanner.tsx
@@ -0,0 +1,55 @@
+import React from 'react';
+import { Alert, Box, Button, LinearProgress, Typography } from '@mui/material';
+import { useTranslation } from 'react-i18next';
+import { useAutoUpdate } from '@/hooks/useAutoUpdate';
+
+export const UpdateBanner: React.FC = () => {
+ const { t } = useTranslation();
+ const { status, version, progress, errorMessage, installUpdate } = useAutoUpdate();
+
+ if (status === 'idle' || status === 'checking' || status === 'up-to-date') {
+ return null;
+ }
+
+ if (status === 'error') {
+ return (
+ <Alert severity="error" sx={{ borderRadius: 0 }}>
+ {t('updateError')}: {errorMessage}
+ </Alert>
+ );
+ }
+
+ if (status === 'downloading') {
+ return (
+ <Box sx={{ px: 2, py: 1, bgcolor: 'info.main', color: 'info.contrastText' }}>
+ <Typography variant="body2" sx={{ mb: 0.5 }}>
+ {t('downloading')} {version && `v${version}`}
+ </Typography>
+ <LinearProgress variant="determinate" value={progress} sx={{ borderRadius: 1 }} />
+ </Box>
+ );
+ }
+
+ if (status === 'ready') {
+ return (
+ <Alert
+ severity="success"
+ sx={{ borderRadius: 0 }}
+ action={
+ <Button color="inherit" size="small" onClick={installUpdate}>
+ {t('restartToUpdate')}
+ </Button>
+ }
+ >
+ {t('downloadComplete')} — v{version}
+ </Alert>
+ );
+ }
+
+ // status === 'available'
+ return (
+ <Alert severity="info" sx={{ borderRadius: 0 }}>
+ {t('updateAvailableMessage', { version })}
+ </Alert>
+ );
+};
diff --git a/freemocap-ui/src/components/ui-components/VersionChip.tsx b/freemocap-ui/src/components/ui-components/VersionChip.tsx
new file mode 100644
index 00000000..76f39b76
--- /dev/null
+++ b/freemocap-ui/src/components/ui-components/VersionChip.tsx
@@ -0,0 +1,123 @@
+import React, { useEffect, useRef, useState } from 'react';
+import { Alert, Box, Chip, CircularProgress, IconButton, Snackbar, Tooltip } from '@mui/material';
+import type { AlertColor } from '@mui/material';
+import OpenInNewIcon from '@mui/icons-material/OpenInNew';
+import UpdateIcon from '@mui/icons-material/Update';
+import CheckCircleIcon from '@mui/icons-material/CheckCircle';
+import { useTranslation } from 'react-i18next';
+import { useAppVersion } from '@/hooks/useAppVersion';
+import { useAutoUpdate } from '@/hooks/useAutoUpdate';
+import { EXTERNAL_URLS } from '@/constants/external-urls';
+
+interface VersionChipProps {
+ /** compact = small inline style for footers; full = larger for settings */
+ variant?: 'compact' | 'full';
+}
+
+export const VersionChip: React.FC<VersionChipProps> = ({ variant = 'full' }) => {
+ const { t } = useTranslation();
+ const version = useAppVersion();
+ const { status, version: updateVersion, errorMessage, checkForUpdate } = useAutoUpdate();
+
+ const isChecking = status === 'checking';
+ const size = variant === 'compact' ? 'small' : 'medium';
+
+ // Snackbar feedback for update check results
+ const prevStatusRef = useRef(status);
+ const [snackbar, setSnackbar] = useState<{ open: boolean; severity: AlertColor; message: string }>({
+ open: false, severity: 'info', message: '',
+ });
+
+ // Brief success state on the chip itself
+ const [showSuccess, setShowSuccess] = useState(false);
+
+ useEffect(() => {
+ const prev = prevStatusRef.current;
+ prevStatusRef.current = status;
+
+ // Only react to transitions from 'checking' to a terminal state
+ if (prev !== 'checking') return;
+
+ if (status === 'up-to-date') {
+ setSnackbar({ open: true, severity: 'success', message: t('upToDate') });
+ setShowSuccess(true);
+ setTimeout(() => setShowSuccess(false), 3000);
+ } else if (status === 'available') {
+ setSnackbar({
+ open: true,
+ severity: 'info',
+ message: t('updateAvailableMessage', { version: updateVersion }),
+ });
+ } else if (status === 'error') {
+ setSnackbar({
+ open: true,
+ severity: 'error',
+ message: errorMessage ? `${t('updateError')}: ${errorMessage}` : t('updateError'),
+ });
+ }
+ }, [status, updateVersion, errorMessage, t]);
+
+ if (!version) return null;
+
+ const chipIcon = isChecking
+ ? <CircularProgress size={14} color="inherit" />
+ : showSuccess
+ ? <CheckCircleIcon sx={{ fontSize: variant === 'compact' ? 14 : 18, color: 'success.main' }} />
+ : <UpdateIcon sx={{ fontSize: variant === 'compact' ? 14 : 18 }} />;
+
+ return (
+ <>
+ <Box sx={{ display: 'inline-flex', alignItems: 'center', gap: 0.5 }}>
+ <Tooltip title={t('checkForUpdates')} arrow>
+ <Chip
+ icon={chipIcon}
+ label={`v${version}`}
+ size={size}
+ variant="outlined"
+ onClick={checkForUpdate}
+ disabled={isChecking}
+ color={showSuccess ? 'success' : 'default'}
+ sx={{
+ cursor: 'pointer',
+ fontFamily: 'monospace',
+ fontSize: variant === 'compact' ? 10 : 12,
+ height: variant === 'compact' ? 22 : undefined,
+ transition: 'all 0.3s ease',
+ '& .MuiChip-icon': {
+ marginLeft: variant === 'compact' ? '4px' : undefined,
+ },
+ }}
+ />
+ </Tooltip>
+ <Tooltip title="GitHub Releases" arrow>
+ <IconButton
+ size="small"
+ onClick={() => window.open(EXTERNAL_URLS.GITHUB_RELEASES, '_blank')}
+ sx={{
+ padding: variant === 'compact' ? '2px' : '4px',
+ opacity: 0.6,
+ '&:hover': { opacity: 1 },
+ }}
+ >
+ <OpenInNewIcon sx={{ fontSize: variant === 'compact' ? 13 : 16 }} />
+ </IconButton>
+ </Tooltip>
+ </Box>
+ <Snackbar
+ open={snackbar.open}
+ autoHideDuration={4000}
+ onClose={() => setSnackbar(prev => ({ ...prev, open: false }))}
+ anchorOrigin={{ vertical: 'bottom', horizontal: 'center' }}
+ >
+ <Alert
+ onClose={() => setSnackbar(prev => ({ ...prev, open: false }))}
+ severity={snackbar.severity}
+ variant="filled"
+ sx={{ width: '100%' }}
+ >
+ {snackbar.message}
+ </Alert>
+ </Snackbar>
+ </>
+ );
+};
diff --git a/freemocap-ui/src/constants/external-urls.ts b/freemocap-ui/src/constants/external-urls.ts
new file mode 100644
index 00000000..4e11f7b2
--- /dev/null
+++ b/freemocap-ui/src/constants/external-urls.ts
@@ -0,0 +1,11 @@
+export const EXTERNAL_URLS = {
+ DOCS: 'https://docs.freemocap.org/freemocap',
+ ROADMAP: 'https://docs.freemocap.org/freemocap/roadmap',
+ GITHUB_REPO: 'https://github.com/freemocap/freemocap',
+ GITHUB_RELEASES: 'https://github.com/freemocap/freemocap/releases',
+ GITHUB_ISSUES: 'https://github.com/freemocap/freemocap/issues/new',
+ GITHUB_ORG: 'https://github.com/freemocap/',
+ FREEMOCAP_ORG: 'https://freemocap.org',
+ TRANSLATION_LOCALES: 'https://github.com/freemocap/freemocap/blob/development/freemocap-ui/src/i18n/locales',
+ TRANSLATING_GUIDE: 'https://github.com/freemocap/freemocap/blob/development/TRANSLATING.md',
+} as const;
diff --git a/freemocap-ui/src/hooks/AutoUpdateContext.tsx b/freemocap-ui/src/hooks/AutoUpdateContext.tsx
new file mode 100644
index 00000000..3d2f8fea
--- /dev/null
+++ b/freemocap-ui/src/hooks/AutoUpdateContext.tsx
@@ -0,0 +1,95 @@
+import React, { createContext, useCallback, useEffect, useState } from 'react';
+import { useElectronIPC } from '@/services';
+
+export type UpdateStatus =
+ | 'idle'
+ | 'checking'
+ | 'available'
+ | 'downloading'
+ | 'ready'
+ | 'error'
+ | 'up-to-date';
+
+export interface AutoUpdateState {
+ status: UpdateStatus;
+ version: string | null;
+ progress: number;
+ errorMessage: string | null;
+ checkForUpdate: () => void;
+ installUpdate: () => void;
+}
+
+export const AutoUpdateContext = createContext<AutoUpdateState | null>(null);
+
+export const AutoUpdateProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => {
+ const { isElectron, api } = useElectronIPC();
+ const [status, setStatus] = useState<UpdateStatus>('idle');
+ const [version, setVersion] = useState<string | null>(null);
+ const [progress, setProgress] = useState(0);
+ const [errorMessage, setErrorMessage] = useState<string | null>(null);
+
+ const checkForUpdate = useCallback(async () => {
+ if (!isElectron || !api) return;
+
+ setStatus('checking');
+ setErrorMessage(null);
+ try {
+ const result = await api.app.checkForUpdate.mutate();
+ if (result.available) {
+ setStatus('available');
+ setVersion(result.version ?? null);
+ } else {
+ setStatus('up-to-date');
+ }
+ } catch (err) {
+ setStatus('error');
+ setErrorMessage(err instanceof Error ? err.message : String(err));
+ }
+ }, [isElectron, api]);
+
+ const installUpdate = useCallback(() => {
+ if (!isElectron || !api) return;
+ api.app.installUpdate.mutate();
+ }, [isElectron, api]);
+
+ // Listen for IPC update events from the main process (UpdateHandler)
+ useEffect(() => {
+ if (!isElectron || !window.electronAPI) return;
+
+ const cleanups = [
+ window.electronAPI.onUpdateAvailable((info) => {
+ setStatus('available');
+ setVersion(info.version);
+ }),
+ window.electronAPI.onDownloadProgress((prog) => {
+ setStatus('downloading');
+ setProgress(prog.percent);
+ }),
+ window.electronAPI.onUpdateDownloaded((info) => {
+ setStatus('ready');
+ setVersion(info.version);
+ }),
+ window.electronAPI.onUpdateError((error) => {
+ setStatus('error');
+ setErrorMessage(error.message);
+ }),
+ ];
+
+ return () => {
+ cleanups.forEach((cleanup) => cleanup());
+ };
+ }, [isElectron]);
+
+ // Listen for menu-triggered check-for-updates
+ useEffect(() => {
+ const handler = () => checkForUpdate();
+ window.addEventListener('check-for-updates', handler);
+ return () => window.removeEventListener('check-for-updates', handler);
+ }, [checkForUpdate]);
+
+ return (
+ <AutoUpdateContext.Provider value={{ status, version, progress, errorMessage, checkForUpdate, installUpdate }}>
+ {children}
+ </AutoUpdateContext.Provider>
+ );
+};
diff --git a/freemocap-ui/src/hooks/useAppUrls.ts b/freemocap-ui/src/hooks/useAppUrls.ts
new file mode 100644
index 00000000..e11345d0
--- /dev/null
+++ b/freemocap-ui/src/hooks/useAppUrls.ts
@@ -0,0 +1,50 @@
+export interface DefaultUrlConfig {
+ host: string;
+ port: number;
+}
+
+// Default URL configuration
+const defaultUrlConfig: DefaultUrlConfig = {
+ host: 'localhost',
+ port: 8006,
+};
+
+
+// Get the base HTTP URL
+const getBaseHttpUrl = () => {
+ const {host, port} = defaultUrlConfig;
+ return `http://${host}:${port}`;
+};
+
+// Get a specific API URL
+const getApiUrl = (path: string) => {
+ return `${getBaseHttpUrl()}${path}`;
+};
+
+// Get WebSocket URL
+const getWebSocketUrl = () => {
+ const {host, port} = defaultUrlConfig;
+ return `ws://${host}:${port}/freemocap/websocket/connect`;
+};
+
+// Get all HTTP endpoint URLs
+const getHttpEndpointUrls = () => {
+ return {
+ health: getApiUrl('/health'),
+ shutdown: getApiUrl('/shutdown'),
+ detectCameras: getApiUrl('/freemocap/camera/detect'),
+ createGroup: getApiUrl('/freemocap/camera/group/apply'),
+ closeAll: getApiUrl('/freemocap/camera/group/close/all'),
+ updateConfigs: getApiUrl('/freemocap/camera/update'),
+ startRecording: getApiUrl('/freemocap/camera/group/all/record/start'),
+ stopRecording: getApiUrl('/freemocap/camera/group/all/record/stop'),
+ pauseUnpauseCameras: getApiUrl('/freemocap/camera/group/all/pause_unpause'),
+ };
+};
+
+export const useAppUrls = {
+ getBaseHttpUrl,
+ getApiUrl,
+ getWebSocketUrl,
+ getHttpEndpointUrls,
+};
diff --git a/freemocap-ui/src/hooks/useAppVersion.ts b/freemocap-ui/src/hooks/useAppVersion.ts
new file mode 100644
index 00000000..b169911e
--- /dev/null
+++ b/freemocap-ui/src/hooks/useAppVersion.ts
@@ -0,0 +1,19 @@
+import { useEffect, useState } from 'react';
+import { useElectronIPC } from '@/services';
+
+export function useAppVersion(): string | null {
+ const [version, setVersion] = useState<string | null>(null);
+ const { isElectron, api } = useElectronIPC();
+
+ useEffect(() => {
+ if (!isElectron || !api) return;
+
+ api.app.getVersion.query().then((v) => {
+ setVersion(v);
+ }).catch((err) => {
+ console.error('Failed to get app version:', err);
+ });
+ }, [isElectron, api]);
+
+ return version;
+}
diff --git a/freemocap-ui/src/hooks/useAutoUpdate.ts b/freemocap-ui/src/hooks/useAutoUpdate.ts
new file mode 100644
index 00000000..b67ee065
--- /dev/null
+++ b/freemocap-ui/src/hooks/useAutoUpdate.ts
@@ -0,0 +1,10 @@
+import { useContext } from 'react';
+import { AutoUpdateContext } from './AutoUpdateContext';
+
+export function useAutoUpdate() {
+ const ctx = useContext(AutoUpdateContext);
+ if (!ctx) {
+ throw new Error('useAutoUpdate must be used within an AutoUpdateProvider');
+ }
+ return ctx;
+}
diff --git a/freemocap-ui/src/hooks/useKeyboardShortcuts.ts b/freemocap-ui/src/hooks/useKeyboardShortcuts.ts
new file mode 100644
index 00000000..940c596e
--- /dev/null
+++ b/freemocap-ui/src/hooks/useKeyboardShortcuts.ts
@@ -0,0 +1,44 @@
+// src/hooks/useKeyboardShortcuts.ts
+import { useEffect } from "react";
+import { useAppDispatch } from "@/store";
+import { localeToggled } from "@/store/slices/settings";
+import { pauseUnpauseCameras } from "@/store/slices/cameras";
+
+/**
+ * Registers global keyboard shortcuts that should be active app-wide.
+ *
+ * Ctrl+Shift+L — toggle between the current locale and the previous one
+ * Shift+Space — pause / unpause camera streaming
+ */
+export function useKeyboardShortcuts(): void {
+ const dispatch = useAppDispatch();
+
+ useEffect(() => {
+ const handleKeyDown = (e: KeyboardEvent): void => {
+ // Ignore keystrokes aimed at text inputs
+ if (
+ e.target instanceof HTMLInputElement ||
+ e.target instanceof HTMLTextAreaElement
+ ) {
+ return;
+ }
+
+ // Ctrl+Shift+L (or Cmd+Shift+L on macOS) — toggle language
+ if ((e.ctrlKey || e.metaKey) && e.shiftKey && e.key.toLowerCase() === "l") {
+ e.preventDefault();
+ dispatch(localeToggled());
+ return;
+ }
+
+ // Shift+Space — pause / unpause camera streaming
+ if (e.shiftKey && e.key === " ") {
+ e.preventDefault();
+ dispatch(pauseUnpauseCameras());
+ return;
+ }
+ };
+
+ window.addEventListener("keydown", handleKeyDown);
+ return () => window.removeEventListener("keydown", handleKeyDown);
+ }, [dispatch]);
+}
diff --git a/freemocap-ui/src/hooks/useMenuActions.ts b/freemocap-ui/src/hooks/useMenuActions.ts
new file mode 100644
index 00000000..a64f7135
--- /dev/null
+++ b/freemocap-ui/src/hooks/useMenuActions.ts
@@ -0,0 +1,174 @@
+// src/hooks/useMenuActions.ts
+import { useEffect } from 'react';
+import { useNavigate } from 'react-router-dom';
+import { useTranslation } from 'react-i18next';
+import { useAppDispatch, useAppSelector } from '@/store';
+import { themeModeToggled } from '@/store/slices/theme';
+import { detectCameras, camerasConnectOrUpdate, closeCameras, pauseUnpauseCameras } from '@/store/slices/cameras';
+import { stopRecording } from '@/store/slices/recording';
+import { selectVideoLoadFolder } from '@/store/slices/videos';
+import { localeChanged, selectLocale, localeToggled } from '@/store/slices/settings';
+import { isElectron } from '@/services/electron-ipc/electron-ipc';
+import { SUPPORTED_LOCALES } from '@/i18n';
+
+import type { SupportedLocale } from '@/i18n';
+import type { MenuAction } from '../../electron/main/services/menu-builder';
+
+// i18n keys that the menu builder needs for translated labels
+const MENU_LABEL_KEYS = [
+ 'menuFile',
+ 'menuView',
+ 'menuCamera',
+ 'menuRecording',
+ 'menuHelp',
+ 'menuDetectCameras',
+ 'menuConnectCameras',
+ 'menuCloseAllCameras',
+ 'menuOpenRecordingFolder',
+ 'menuToggleSidebar',
+ 'menuToggleTheme',
+ 'menuToggleFullScreen',
+ 'menuPauseUnpause',
+ 'menuConnectApplySettings',
+ 'menuCloseAll',
+ 'menuDocumentation',
+ 'menuGitHubRepository',
+ 'menuReportIssue',
+ 'menuAbout',
+ 'menuCheckForUpdates',
+ 'menuPlayback',
+ 'home',
+ 'cameras',
+ 'settings',
+ 'startRecording',
+ 'stopRecording',
+ 'language',
+] as const;
+
+// Build the locale entries array from the SUPPORTED_LOCALES config (once)
+const LOCALE_ENTRIES = Object.entries(SUPPORTED_LOCALES).map(([code, { label }]) => ({
+ code,
+ label,
+}));
+
+interface UseMenuActionsParams {
+ onToggleSidebar: () => void;
+}
+
+export function useMenuActions({ onToggleSidebar }: UseMenuActionsParams): void {
+ const dispatch = useAppDispatch();
+ const navigate = useNavigate();
+ const { t, i18n } = useTranslation();
+
+ const isRecording = useAppSelector((state) => state.recording.isRecording);
+ const currentLocale = useAppSelector(selectLocale);
+
+ // Send translated menu labels + locale list to the main process whenever the language changes
+ useEffect(() => {
+ if (!isElectron() || !window.electronAPI?.sendMenuLabels) return;
+
+ const labels: Record<string, string> = {};
+ for (const key of MENU_LABEL_KEYS) {
+ labels[key] = t(key);
+ }
+ window.electronAPI.sendMenuLabels({
+ labels,
+ locales: LOCALE_ENTRIES,
+ currentLocale,
+ });
+ }, [t, i18n.language, currentLocale]);
+
+ // Listen for menu actions dispatched from the native menu
+ useEffect(() => {
+ if (!isElectron() || !window.electronAPI?.onMenuAction) return;
+
+ const cleanup = window.electronAPI.onMenuAction((action: string) => {
+ // Handle locale change actions (dynamic pattern: "change-locale:xx")
+ if (action.startsWith('change-locale:')) {
+ const localeCode = action.slice('change-locale:'.length);
+ if (localeCode in SUPPORTED_LOCALES) {
+ dispatch(localeChanged(localeCode as SupportedLocale));
+ }
+ return;
+ }
+
+ const menuAction = action as MenuAction;
+
+ switch (menuAction) {
+ // Navigation
+ case 'navigate-home':
+ navigate('/');
+ break;
+ case 'navigate-cameras':
+ navigate('/cameras');
+ break;
+ case 'navigate-playback':
+ navigate('/playback');
+ break;
+ case 'navigate-settings':
+ navigate('/settings');
+ break;
+
+ // View
+ case 'toggle-theme':
+ dispatch(themeModeToggled());
+ break;
+ case 'toggle-sidebar':
+ onToggleSidebar();
+ break;
+ case 'toggle-fullscreen': {
+ if (document.fullscreenElement) {
+ document.exitFullscreen();
+ } else {
+ document.documentElement.requestFullscreen();
+ }
+ break;
+ }
+
+ // Camera actions
+ case 'detect-cameras':
+ dispatch(detectCameras());
+ break;
+ case 'connect-cameras':
+ dispatch(camerasConnectOrUpdate());
+ break;
+ case 'close-cameras':
+ dispatch(closeCameras());
+ break;
+ case 'pause-unpause-cameras':
+ dispatch(pauseUnpauseCameras());
+ break;
+
+ // Locale toggle
+ case 'toggle-locale':
+ dispatch(localeToggled());
+ break;
+
+ // Recording actions
+ case 'start-recording':
+ if (!isRecording) {
+ navigate('/cameras');
+ }
+ break;
+ case 'stop-recording':
+ if (isRecording) {
+ dispatch(stopRecording());
+ }
+ break;
+
+ // Updates
+ case 'check-for-updates':
+ window.dispatchEvent(new CustomEvent('check-for-updates'));
+ break;
+
+ // File actions
+ case 'open-recording-folder':
+ dispatch(selectVideoLoadFolder());
+ navigate('/playback');
+ break;
+ }
+ });
+
+ return cleanup;
+ }, [dispatch, navigate, isRecording, onToggleSidebar]);
+}
diff --git a/freemocap-ui/src/pages/PlaybackPage.tsx b/freemocap-ui/src/pages/PlaybackPage.tsx
new file mode 100644
index 00000000..5be591b2
--- /dev/null
+++ b/freemocap-ui/src/pages/PlaybackPage.tsx
@@ -0,0 +1,297 @@
+import React, { useCallback, useEffect, useState } from 'react';
+import { Box, Chip, IconButton, Tooltip, Typography, useTheme } from '@mui/material';
+import ArrowBackIcon from '@mui/icons-material/ArrowBack';
+import VideocamIcon from '@mui/icons-material/Videocam';
+import StorageIcon from '@mui/icons-material/Storage';
+import FolderOpenIcon from '@mui/icons-material/FolderOpen';
+import { Footer } from '@/components/ui-components/Footer';
+import ErrorBoundary from '@/components/common/ErrorBoundary';
+import { RecordingBrowser, LoadedVideo } from '@/components/playback/RecordingBrowser';
+import { SyncedVideoPlayer } from '@/components/playback/SyncedVideoPlayer';
+import { CamerasViewSettingsOverlay } from '@/components/camera-view-settings-overlay/CamerasViewSettingsOverlay';
+import { useElectronIPC } from '@/services';
+import { serverUrls } from '@/services/server/server-helpers/server-urls';
+import { useTranslation } from 'react-i18next';
+import { useLocation } from 'react-router-dom';
+
+// Module-level cache so playback state survives tab switches
+let cachedPlaybackState: {
+ loadedVideos: LoadedVideo[];
+ recordingPath: string | null;
+ recordingFps: number | undefined;
+ frameTimestamps: Record<string, number[]> | null;
+ currentFrame: number;
+} = {
+ loadedVideos: [],
+ recordingPath: null,
+ recordingFps: undefined,
+ frameTimestamps: null,
+ currentFrame: 0,
+};
+
+const PlaybackPage: React.FC = () => {
+ const theme = useTheme();
+ const { t } = useTranslation();
+ const { api } = useElectronIPC();
+ const location = useLocation();
+ const isDark = theme.palette.mode === 'dark';
+ const locationState = location.state as { loadRecordingPath?: string } | null;
+ const initialLoadPath = locationState?.loadRecordingPath ?? null;
+
+ // If navigating here with a new recording path, clear cached state so RecordingBrowser shows and auto-loads
+ const initState = (initialLoadPath && initialLoadPath !== cachedPlaybackState.recordingPath)
+ ? { loadedVideos: [] as LoadedVideo[], recordingPath: null, recordingFps: undefined, frameTimestamps: null, currentFrame: 0 }
+ : cachedPlaybackState;
+
+ const [loadedVideos, setLoadedVideos] = useState<LoadedVideo[]>(initState.loadedVideos);
+ const [recordingPath, setRecordingPath] = useState<string | null>(initState.recordingPath);
+ const [recordingFps, setRecordingFps] = useState<number | undefined>(initState.recordingFps);
+ const [frameTimestamps, setFrameTimestamps] = useState<Record<string, number[]> | null>(initState.frameTimestamps);
+ const [manualColumns, setManualColumns] = useState<number | null>(null);
+ const [resetKey, setResetKey] = useState<number>(0);
+
+ const handleRecordingLoaded = useCallback((videos: LoadedVideo[], path: string, fps?: number) => {
+ setLoadedVideos(videos);
+ setRecordingPath(path);
+ setRecordingFps(fps);
+ setFrameTimestamps(null);
+ cachedPlaybackState = { loadedVideos: videos, recordingPath: path, recordingFps: fps, frameTimestamps: null, currentFrame: 0 };
+ }, []);
+
+ // After a recording is loaded, fetch real timestamps from the server
+ useEffect(() => {
+ if (loadedVideos.length === 0) return;
+
+ const fetchTimestamps = async () => {
+ try {
+ const response = await fetch(serverUrls.endpoints.playbackAllTimestamps);
+ if (!response.ok) return;
+ const data = await response.json();
+ if (data.timestamps && Object.keys(data.timestamps).length > 0) {
+ setFrameTimestamps(data.timestamps);
+ cachedPlaybackState.frameTimestamps = data.timestamps;
+ }
+ } catch {
+ // Timestamps not available — SyncedVideoPlayer will use approximation
+ }
+ };
+ fetchTimestamps();
+ }, [loadedVideos]);
+
+ const handleBack = useCallback(() => {
+ setLoadedVideos([]);
+ setRecordingPath(null);
+ setRecordingFps(undefined);
+ setFrameTimestamps(null);
+ cachedPlaybackState = { loadedVideos: [], recordingPath: null, recordingFps: undefined, frameTimestamps: null, currentFrame: 0 };
+ }, []);
+
+ const handleOpenFolder = useCallback(async () => {
+ if (!recordingPath) return;
+ try {
+ await api?.fileSystem.openFolder.mutate({ path: recordingPath });
+ } catch (err) {
+ console.error('Failed to open recording folder:', err);
+ throw err;
+ }
+ }, [recordingPath, api]);
+
+ const handleSettingsChange = useCallback((settings: { columns: number | null }) => {
+ setManualColumns(settings.columns);
+ }, []);
+
+ const handleResetLayout = useCallback(() => {
+ setResetKey((v) => v + 1);
+ }, []);
+
+ const handleFrameChange = useCallback((frame: number) => {
+ cachedPlaybackState.currentFrame = frame;
+ }, []);
+
+ const hasVideos = loadedVideos.length > 0;
+ const totalSize = loadedVideos.reduce((sum, v) => sum + v.sizeBytes, 0);
+ const monoFont = '"JetBrains Mono", "Fira Code", "SF Mono", monospace';
+
+ // Extract recording name from path
+ const recordingName = recordingPath ? recordingPath.split(/[\\/]/).pop() || recordingPath : '';
+
+ return (
+ <Box
+ sx={{
+ flex: 1,
+ display: 'flex',
+ flexDirection: 'column',
+ height: '100%',
+ backgroundColor: theme.palette.mode === 'dark'
+ ? theme.palette.background.default
+ : theme.palette.background.paper,
+ borderStyle: 'solid',
+ borderWidth: '1px',
+ borderColor: theme.palette.divider,
+ }}
+ >
+ <Box sx={{ flex: 1, display: 'flex', flexDirection: 'column', overflow: 'hidden' }}>
+ <ErrorBoundary>
+ {hasVideos ? (
+ <Box sx={{ display: 'flex', flexDirection: 'column', height: '100%', position: 'relative' }}>
+ {/* Settings overlay for grid columns */}
+ <CamerasViewSettingsOverlay
+ onSettingsChange={handleSettingsChange}
+ onResetLayout={handleResetLayout}
+ />
+
+ {/* Recording header bar */}
+ <Box
+ sx={{
+ display: 'flex',
+ alignItems: 'center',
+ gap: 1.5,
+ px: 1.5,
+ py: 0.75,
+ borderBottom: `1px solid ${theme.palette.divider}`,
+ backgroundColor: isDark ? 'rgba(255,255,255,0.03)' : 'rgba(0,0,0,0.02)',
+ minHeight: 40,
+ flexWrap: 'wrap',
+ }}
+ >
+ <Tooltip title={t('backToRecordings')}>
+ <IconButton size="small" onClick={handleBack}
+ sx={{ color: isDark ? '#b3b9c6' : undefined }}>
+ <ArrowBackIcon fontSize="small" />
+ </IconButton>
+ </Tooltip>
+
+ {/* Recording name */}
+ <Typography
+ variant="body2"
+ sx={{
+ fontFamily: monoFont,
+ fontWeight: 600,
+ color: theme.palette.text.primary,
+ overflow: 'hidden',
+ textOverflow: 'ellipsis',
+ whiteSpace: 'nowrap',
+ }}
+ >
+ {recordingName}
+ </Typography>
+
+ {/* Open Folder button */}
+ <Tooltip title={t('openFolder')}>
+ <IconButton
+ size="small"
+ onClick={handleOpenFolder}
+ sx={{
+ color: isDark ? '#ffcc80' : theme.palette.warning.dark,
+ border: `1px solid ${isDark ? 'rgba(255,204,128,0.3)' : theme.palette.warning.light}`,
+ borderRadius: '6px',
+ px: 1,
+ gap: 0.5,
+ fontSize: '0.75rem',
+ fontFamily: monoFont,
+ '&:hover': {
+ backgroundColor: isDark ? 'rgba(255,204,128,0.1)' : 'rgba(255,152,0,0.08)',
+ },
+ }}
+ >
+ <FolderOpenIcon sx={{ fontSize: 16 }} />
+ </IconButton>
+ </Tooltip>
+
+ {/* Spacer */}
+ <Box sx={{ flex: 1 }} />
+
+ {/* Stats chips */}
+ <Tooltip title={t('cameraStreams')}>
+ <Chip
+ icon={<VideocamIcon sx={{ fontSize: '14px !important' }} />}
+ label={t('cameraCount', { count: loadedVideos.length })}
+ size="small"
+ variant="outlined"
+ sx={{
+ fontFamily: monoFont,
+ fontSize: '0.75rem',
+ height: 24,
+ borderColor: isDark ? 'rgba(41,182,246,0.3)' : undefined,
+ color: isDark ? '#29b6f6' : theme.palette.info.main,
+ '& .MuiChip-icon': { color: 'inherit' },
+ }}
+ />
+ </Tooltip>
+
+ {totalSize > 0 && (
+ <Tooltip title={t('totalRecordingSize')}>
+ <Chip
+ icon={<StorageIcon sx={{ fontSize: '14px !important' }} />}
+ label={formatBytes(totalSize)}
+ size="small"
+ variant="outlined"
+ sx={{
+ fontFamily: monoFont,
+ fontSize: '0.75rem',
+ height: 24,
+ borderColor: isDark ? 'rgba(255,255,255,0.15)' : undefined,
+ color: isDark ? '#b3b9c6' : theme.palette.text.secondary,
+ '& .MuiChip-icon': { color: 'inherit' },
+ }}
+ />
+ </Tooltip>
+ )}
+
+ {recordingFps != null && recordingFps > 0 && (
+ <Tooltip title={t('recordingCaptureFps')}>
+ <Chip
+ label={`rec: ${recordingFps} fps`}
+ size="small"
+ variant="outlined"
+ sx={{
+ fontFamily: monoFont,
+ fontSize: '0.75rem',
+ height: 24,
+ borderColor: isDark ? 'rgba(255,204,128,0.3)' : undefined,
+ color: isDark ? '#ffcc80' : theme.palette.warning.dark,
+ }}
+ />
+ </Tooltip>
+ )}
+ </Box>
+
+ {/* Player */}
+ <Box sx={{ flex: 1, minHeight: 0 }}>
+ <SyncedVideoPlayer
+ videos={loadedVideos.map((v) => ({
+ videoId: v.videoId,
+ filename: v.filename,
+ streamUrl: v.streamUrl,
+ }))}
+ recordingFps={recordingFps}
+ frameTimestamps={frameTimestamps}
+ manualColumns={manualColumns}
+ resetKey={resetKey}
+ initialFrame={initState.currentFrame}
+ onFrameChange={handleFrameChange}
+ />
+ </Box>
+ </Box>
+ ) : (
+ <RecordingBrowser onRecordingLoaded={handleRecordingLoaded} initialLoadPath={initialLoadPath} />
+ )}
+ </ErrorBoundary>
+ </Box>
+
+ <Box component="footer" sx={{ p: 0.5 }}>
+ <Footer />
+ </Box>
+ </Box>
+ );
+};
+
+function formatBytes(bytes: number): string {
+ if (bytes === 0) return '0 B';
+ const k = 1024;
+ const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+ const i = Math.floor(Math.log(bytes) / Math.log(k));
+ return `${(bytes / Math.pow(k, i)).toFixed(i > 1 ? 1 : 0)} ${units[i]}`;
+}
+
+export default PlaybackPage;
diff --git a/freemocap-ui/src/services/server/server-helpers/frame-processor/frame-decode.worker.ts b/freemocap-ui/src/services/server/server-helpers/frame-processor/frame-decode.worker.ts
new file mode 100644
index 00000000..56fbafa8
--- /dev/null
+++ b/freemocap-ui/src/services/server/server-helpers/frame-processor/frame-decode.worker.ts
@@ -0,0 +1,209 @@
+// src/services/server/server-helpers/frame-processor/frame-decode.worker.ts
+//
+// Inline Web Worker that performs binary frame parsing and JPEG→ImageBitmap
+// decoding off the main thread. All Blob allocations and createImageBitmap
+// async work happen here, so their GC pressure never affects the UI.
+//
+// IMPORTANT: The binary protocol constants below are duplicated from
+// binary-protocol.ts because Web Workers cannot use ES module imports or
+// Vite path aliases. If the protocol changes, update BOTH files.
+
+export const frameDecodeWorkerCode = `
+// ─── Binary protocol constants (mirrored from binary-protocol.ts) ───
+
+const MESSAGE_TYPE_PAYLOAD_HEADER = 0;
+const MESSAGE_TYPE_FRAME_METADATA = 1;
+const MESSAGE_TYPE_PAYLOAD_FOOTER = 2;
+
+const PAYLOAD_HEADER_SIZE = 24;
+const FRAME_HEADER_SIZE = 56;
+const PAYLOAD_FOOTER_SIZE = 24;
+
+// Payload header field offsets
+const PH_MESSAGE_TYPE = 0;
+const PH_FRAME_NUMBER = 8;
+const PH_NUM_CAMERAS = 16;
+
+// Frame header field offsets
+const FH_MESSAGE_TYPE = 0;
+const FH_FRAME_NUMBER = 8;
+const FH_CAMERA_ID_OFFSET = 16;
+const FH_CAMERA_ID_SIZE = 16;
+const FH_CAMERA_INDEX = 32;
+const FH_IMAGE_WIDTH = 36;
+const FH_IMAGE_HEIGHT = 40;
+const FH_COLOR_CHANNELS = 44;
+const FH_JPEG_LENGTH = 48;
+
+// Footer field offsets
+const FT_MESSAGE_TYPE = 0;
+const FT_FRAME_NUMBER = 8;
+const FT_NUM_CAMERAS = 16;
+
+const BITMAP_OPTIONS = {
+ premultiplyAlpha: 'none',
+ colorSpaceConversion: 'none',
+ resizeQuality: 'pixelated',
+};
+
+const textDecoder = new TextDecoder();
+
+// ─── Parsing helpers ───
+
+function parseAsciiField(view, baseOffset, fieldOffset, size) {
+ const offset = baseOffset + fieldOffset;
+ let length = 0;
+ while (length < size && view.getUint8(offset + length) !== 0) {
+ length++;
+ }
+ if (length === 0) return '';
+ const bytes = new Uint8Array(view.buffer, view.byteOffset + offset, length);
+ return textDecoder.decode(bytes);
+}
+
+// ─── Main decode function ───
+
+async function decodePayload(data) {
+ const view = new DataView(data);
+
+ if (data.byteLength < PAYLOAD_HEADER_SIZE) {
+ throw new Error('Payload too small: ' + data.byteLength + ' bytes');
+ }
+
+ const messageType = view.getUint8(PH_MESSAGE_TYPE);
+ if (messageType !== MESSAGE_TYPE_PAYLOAD_HEADER) {
+ throw new Error('Invalid payload header: expected ' + MESSAGE_TYPE_PAYLOAD_HEADER + ', got ' + messageType);
+ }
+
+ const frameNumber = Number(view.getBigInt64(PH_FRAME_NUMBER, true));
+ const numCameras = view.getInt32(PH_NUM_CAMERAS, true);
+
+ if (numCameras <= 0) {
+ throw new Error('Invalid camera count: ' + numCameras);
+ }
+
+ const frameMetadata = new Array(numCameras);
+ let currentOffset = PAYLOAD_HEADER_SIZE;
+ let validFrameCount = 0;
+
+ for (let i = 0; i < numCameras; i++) {
+ if (currentOffset + FRAME_HEADER_SIZE > data.byteLength) break;
+
+ const fhType = view.getUint8(currentOffset + FH_MESSAGE_TYPE);
+ if (fhType !== MESSAGE_TYPE_FRAME_METADATA) break;
+
+ const frameNum = Number(view.getBigInt64(currentOffset + FH_FRAME_NUMBER, true));
+ const cameraId = parseAsciiField(view, currentOffset, FH_CAMERA_ID_OFFSET, FH_CAMERA_ID_SIZE);
+ const cameraIndex = view.getInt32(currentOffset + FH_CAMERA_INDEX, true);
+ const width = view.getInt32(currentOffset + FH_IMAGE_WIDTH, true);
+ const height = view.getInt32(currentOffset + FH_IMAGE_HEIGHT, true);
+ const colorChannels = view.getInt32(currentOffset + FH_COLOR_CHANNELS, true);
+ const jpegLength = view.getInt32(currentOffset + FH_JPEG_LENGTH, true);
+
+ if (jpegLength <= 0) break;
+
+ const jpegStart = currentOffset + FRAME_HEADER_SIZE;
+ if (jpegStart + jpegLength > data.byteLength) break;
+
+ frameMetadata[validFrameCount] = {
+ cameraId,
+ cameraIndex,
+ frameNumber: frameNum,
+ width,
+ height,
+ colorChannels,
+ jpegStart,
+ jpegLength,
+ };
+
+ validFrameCount++;
+ currentOffset += FRAME_HEADER_SIZE + jpegLength;
+ }
+
+ if (validFrameCount === 0) {
+ throw new Error('No valid frames found in payload');
+ }
+
+ // Optional footer validation
+ if (currentOffset + PAYLOAD_FOOTER_SIZE <= data.byteLength) {
+ const ftType = view.getUint8(currentOffset + FT_MESSAGE_TYPE);
+ if (ftType === MESSAGE_TYPE_PAYLOAD_FOOTER) {
+ const ftFrameNum = Number(view.getBigInt64(currentOffset + FT_FRAME_NUMBER, true));
+ const ftNumCameras = view.getInt32(currentOffset + FT_NUM_CAMERAS, true);
+ if (ftFrameNum !== frameNumber || ftNumCameras !== numCameras) {
+ console.warn(
+ 'Footer mismatch: header(frame=' + frameNumber + ', cameras=' + numCameras + ') ' +
+ 'footer(frame=' + ftFrameNum + ', cameras=' + ftNumCameras + ')'
+ );
+ }
+ }
+ }
+
+ frameMetadata.length = validFrameCount;
+
+ // Decode JPEGs sequentially so only one Blob's backing store exists
+ // at a time. Blob data lives in the browser's blob subsystem (outside
+ // the V8 heap) and relies on Blink GC to free it. In a Worker with no
+ // idle time, parallel Blob creation causes backing stores to accumulate
+ // faster than GC can reclaim them, producing a slowly rising memory
+ // floor. Sequential decode with explicit nulling keeps peak blob memory
+ // at one JPEG instead of N, and gives the browser a clear release signal.
+ const frames = new Array(validFrameCount);
+ for (let i = 0; i < validFrameCount; i++) {
+ const meta = frameMetadata[i];
+ const jpegData = new Uint8Array(data, meta.jpegStart, meta.jpegLength);
+ let blob = new Blob([jpegData], { type: 'image/jpeg' });
+ const bitmap = await createImageBitmap(blob, BITMAP_OPTIONS);
+ blob = null;
+ frames[i] = {
+ cameraId: meta.cameraId,
+ cameraIndex: meta.cameraIndex,
+ frameNumber: meta.frameNumber,
+ width: meta.width,
+ height: meta.height,
+ colorChannels: meta.colorChannels,
+ bitmap: bitmap,
+ };
+ }
+
+ return frames;
+}
+
+// ─── Worker message handler ───
+
+self.onmessage = async (e) => {
+ const { type, payload, requestId } = e.data;
+
+ if (type === 'decode') {
+ try {
+ const frames = await decodePayload(payload);
+
+ // Build transferable list of all ImageBitmaps
+ const transferList = frames.map((f) => f.bitmap);
+
+ // Separate bitmaps from metadata for structured cloning
+ const frameData = frames.map((f) => ({
+ cameraId: f.cameraId,
+ cameraIndex: f.cameraIndex,
+ frameNumber: f.frameNumber,
+ width: f.width,
+ height: f.height,
+ colorChannels: f.colorChannels,
+ }));
+
+ const bitmaps = frames.map((f) => f.bitmap);
+
+ self.postMessage(
+ { type: 'result', requestId, frameData, bitmaps },
+ transferList
+ );
+ } catch (error) {
+ self.postMessage({
+ type: 'error',
+ requestId,
+ message: error instanceof Error ? error.message : String(error),
+ });
+ }
+ }
+};
+`;
diff --git a/freemocap-ui/src/services/server/server-helpers/framerate-store.ts b/freemocap-ui/src/services/server/server-helpers/framerate-store.ts
new file mode 100644
index 00000000..03099874
--- /dev/null
+++ b/freemocap-ui/src/services/server/server-helpers/framerate-store.ts
@@ -0,0 +1,243 @@
+// src/services/server/server-helpers/framerate-store.ts
+
+const MAX_DURATION_HISTORY = 1000;
+
+/** Matches the shape sent by the Python backend's CurrentFramerate.model_dump() */
+export type DetailedFramerate = {
+ mean_frame_duration_ms: number;
+ mean_frames_per_second: number;
+ frame_duration_max: number;
+ frame_duration_min: number;
+ frame_duration_mean: number;
+ frame_duration_stddev: number;
+ frame_duration_median: number;
+ frame_duration_coefficient_of_variation: number;
+ calculation_window_size: number;
+ framerate_source: string;
+};
+
+/** A single data point with the real timestamp of when it was recorded. */
+export type TimestampedSample = {
+ timestamp: number;
+ value: number;
+};
+
+/** Snapshot of all framerate data, returned by getSnapshot(). */
+export type FramerateSnapshot = {
+ currentBackendFramerate: DetailedFramerate | null;
+ currentFrontendFramerate: DetailedFramerate | null;
+ aggregateBackendFramerate: DetailedFramerate | null;
+ aggregateFrontendFramerate: DetailedFramerate | null;
+ recentFrontendDurations: TimestampedSample[];
+ recentBackendDurations: TimestampedSample[];
+};
+
+/**
+ * Fixed-capacity ring buffer for timestamped numeric samples.
+ * O(1) push. toArray() reuses its output array when possible to reduce GC pressure.
+ */
+class TimestampedRingBuffer {
+ private readonly timestamps: Float64Array;
+ private readonly values: Float64Array;
+ private writeIndex: number = 0;
+ private count: number = 0;
+
+ /** Cached array from the last toArray() call — reused if count hasn't changed. */
+ private _cachedArray: TimestampedSample[] | null = null;
+ private _cachedVersion: number = 0;
+ private _version: number = 0;
+
+ constructor(capacity: number) {
+ this.timestamps = new Float64Array(capacity);
+ this.values = new Float64Array(capacity);
+ }
+
+ push(timestamp: number, value: number): void {
+ this.timestamps[this.writeIndex] = timestamp;
+ this.values[this.writeIndex] = value;
+ this.writeIndex = (this.writeIndex + 1) % this.timestamps.length;
+ if (this.count < this.timestamps.length) {
+ this.count++;
+ }
+ this._version++;
+ }
+
+ /** Return contents in chronological order (oldest → newest). */
+ toArray(): TimestampedSample[] {
+ // Return cached array if no writes since last call
+ if (this._cachedArray !== null && this._cachedVersion === this._version) {
+ return this._cachedArray;
+ }
+
+ const result = new Array<TimestampedSample>(this.count);
+ if (this.count < this.timestamps.length) {
+ for (let i = 0; i < this.count; i++) {
+ result[i] = {timestamp: this.timestamps[i], value: this.values[i]};
+ }
+ } else {
+ for (let i = 0; i < this.count; i++) {
+ const idx = (this.writeIndex + i) % this.timestamps.length;
+ result[i] = {timestamp: this.timestamps[idx], value: this.values[idx]};
+ }
+ }
+
+ this._cachedArray = result;
+ this._cachedVersion = this._version;
+ return result;
+ }
+
+ /** Copy current values into a Float64Array in chronological order (for stats computation). */
+ valuesToFloat64Array(): Float64Array {
+ const result = new Float64Array(this.count);
+ this.copyValuesInto(result);
+ return result;
+ }
+
+ /** Copy current values in chronological order into the provided array.
+ * The target must have at least `count` elements. */
+ copyValuesInto(target: Float64Array): void {
+ if (this.count < this.values.length) {
+ for (let i = 0; i < this.count; i++) {
+ target[i] = this.values[i];
+ }
+ } else {
+ for (let i = 0; i < this.count; i++) {
+ target[i] = this.values[(this.writeIndex + i) % this.values.length];
+ }
+ }
+ }
+
+ getCount(): number {
+ return this.count;
+ }
+
+ clear(): void {
+ this.writeIndex = 0;
+ this.count = 0;
+ this._cachedArray = null;
+ this._version++;
+ }
+}
+
+/**
+ * Computes statistics over the current contents of a ring buffer.
+ * All stats reflect only the windowed data (last MAX_DURATION_HISTORY samples),
+ * not all-time accumulations.
+ */
+class WindowedStats {
+ private _buffer: TimestampedRingBuffer;
+ /** Reusable typed array to avoid allocating a fresh one on every snapshot. */
+ private _valuesBuf: Float64Array;
+
+ constructor(buffer: TimestampedRingBuffer, capacity: number) {
+ this._buffer = buffer;
+ this._valuesBuf = new Float64Array(capacity);
+ }
+
+ /** Compute stats from the ring buffer's current window. */
+ computeAggregate(source: string): DetailedFramerate | null {
+ const count = this._buffer.getCount();
+ if (count === 0) return null;
+
+ // Reuse the pre-allocated buffer, only reallocating if capacity grew
+ if (this._valuesBuf.length < count) {
+ this._valuesBuf = new Float64Array(count);
+ }
+ const values = this._valuesBuf.subarray(0, count);
+ this._buffer.copyValuesInto(values);
+
+ let sum = 0;
+ let min = Infinity;
+ let max = -Infinity;
+ for (let i = 0; i < values.length; i++) {
+ const v = values[i];
+ sum += v;
+ if (v < min) min = v;
+ if (v > max) max = v;
+ }
+
+ const mean = sum / count;
+
+ let m2 = 0;
+ for (let i = 0; i < values.length; i++) {
+ const d = values[i] - mean;
+ m2 += d * d;
+ }
+ const variance = count > 1 ? m2 / count : 0;
+ const stddev = Math.sqrt(variance);
+ const cv = mean > 0 ? stddev / mean : 0;
+
+ // Sort for median
+ values.sort();
+ const median = count % 2 === 0
+ ? (values[count / 2 - 1] + values[count / 2]) / 2
+ : values[Math.floor(count / 2)];
+
+ return {
+ mean_frame_duration_ms: mean,
+ mean_frames_per_second: mean > 0 ? 1000 / mean : 0,
+ frame_duration_mean: mean,
+ frame_duration_median: median,
+ frame_duration_min: min,
+ frame_duration_max: max,
+ frame_duration_stddev: stddev,
+ frame_duration_coefficient_of_variation: cv,
+ calculation_window_size: count,
+ framerate_source: source,
+ };
+ }
+}
+
+/**
+ * Mutable store for streaming framerate telemetry.
+ * Lives in a ref — no Redux, no immutable copies, no re-renders on every update.
+ * Components poll via getSnapshot() on their own schedule.
+ *
+ * Aggregate statistics are computed from the windowed ring buffer on each snapshot (~4Hz).
+ */
+export class FramerateStore {
+ currentBackendFramerate: DetailedFramerate | null = null;
+ currentFrontendFramerate: DetailedFramerate | null = null;
+
+ private _recentFrontendDurations = new TimestampedRingBuffer(MAX_DURATION_HISTORY);
+ private _recentBackendDurations = new TimestampedRingBuffer(MAX_DURATION_HISTORY);
+ private _frontendStats = new WindowedStats(this._recentFrontendDurations, MAX_DURATION_HISTORY);
+ private _backendStats = new WindowedStats(this._recentBackendDurations, MAX_DURATION_HISTORY);
+
+ updateBackend(data: DetailedFramerate): void {
+ this.currentBackendFramerate = data;
+ if (data.mean_frame_duration_ms > 0) {
+ this._recentBackendDurations.push(Date.now(), data.mean_frame_duration_ms);
+ }
+ }
+
+ updateFrontend(data: DetailedFramerate): void {
+ this.currentFrontendFramerate = data;
+ if (data.mean_frame_duration_ms > 0) {
+ this._recentFrontendDurations.push(Date.now(), data.mean_frame_duration_ms);
+ }
+ }
+
+ /** Returns a snapshot for React components to read during render. */
+ getSnapshot(): FramerateSnapshot {
+ return {
+ currentBackendFramerate: this.currentBackendFramerate,
+ currentFrontendFramerate: this.currentFrontendFramerate,
+ aggregateBackendFramerate: this._backendStats.computeAggregate(
+ this.currentBackendFramerate?.framerate_source ?? "Server",
+ ),
+ aggregateFrontendFramerate: this._frontendStats.computeAggregate(
+ this.currentFrontendFramerate?.framerate_source ?? "Display",
+ ),
+ recentFrontendDurations: this._recentFrontendDurations.toArray(),
+ recentBackendDurations: this._recentBackendDurations.toArray(),
+ };
+ }
+
+ clear(): void {
+ this.currentBackendFramerate = null;
+ this.currentFrontendFramerate = null;
+ this._recentFrontendDurations.clear();
+ this._recentBackendDurations.clear();
+ }
+}
diff --git a/freemocap-ui/src/services/server/server-helpers/log-store.ts b/freemocap-ui/src/services/server/server-helpers/log-store.ts
new file mode 100644
index 00000000..7dad53a6
--- /dev/null
+++ b/freemocap-ui/src/services/server/server-helpers/log-store.ts
@@ -0,0 +1,124 @@
+// src/services/server/server-helpers/log-store.ts
+
+import { z } from 'zod';
+
+export const LogRecordSchema = z.object({
+ name: z.string(),
+ msg: z.string().nullable().default(""),
+ args: z.array(z.any()),
+ levelname: z.string(),
+ levelno: z.number(),
+ pathname: z.string(),
+ filename: z.string(),
+ module: z.string(),
+ exc_info: z.string().nullable(),
+ exc_text: z.string().nullable(),
+ stack_info: z.string().nullable(),
+ lineno: z.number(),
+ funcName: z.string(),
+ created: z.number(),
+ msecs: z.number(),
+ relativeCreated: z.number(),
+ thread: z.number(),
+ threadName: z.string(),
+ processName: z.string(),
+ process: z.number(),
+ delta_t: z.string(),
+ message: z.string(),
+ asctime: z.string(),
+ formatted_message: z.string(),
+ type: z.string(),
+});
+
+export type LogRecord = z.infer<typeof LogRecordSchema>;
+
+const MAX_ENTRIES = 1000;
+
+export type LogSnapshot = {
+ entries: LogRecord[];
+ hasErrors: boolean;
+ countsByLevel: Record<string, number>;
+ version: number;
+};
+
+/**
+ * Mutable store for streaming log records from the backend.
+ * Lives in a ref — no Redux, no immutable copies, no re-renders on every message.
+ * Components poll via getSnapshot() on their own schedule (typically ~500ms).
+ *
+ * Uses a version counter to avoid copying the entries array when nothing has
+ * changed since the last snapshot. The snapshot's entries array is only
+ * reallocated when new logs have arrived.
+ */
+export class LogStore {
+ private entries: LogRecord[] = [];
+ private countsByLevel: Record<string, number> = {};
+ private hasErrors: boolean = false;
+
+ /** Incremented on every mutation (add / clear). */
+ private version: number = 0;
+
+ /** Version at which the last snapshot was taken. */
+ private lastSnapshotVersion: number = -1;
+
+ /** Cached snapshot entries — reused when version hasn't changed. */
+ private cachedEntries: LogRecord[] = [];
+ private cachedCountsByLevel: Record<string, number> = {};
+
+ add(record: LogRecord): void {
+ this.entries.push(record);
+ this.version++;
+
+ // Update counts
+ const level = record.levelname;
+ this.countsByLevel[level] = (this.countsByLevel[level] || 0) + 1;
+
+ // Track error state
+ if (level === 'ERROR' || level === 'CRITICAL') {
+ this.hasErrors = true;
+ }
+
+ // Trim to capacity
+ if (this.entries.length > MAX_ENTRIES) {
+ const removed = this.entries.splice(0, this.entries.length - MAX_ENTRIES);
+ for (const r of removed) {
+ this.countsByLevel[r.levelname]--;
+ if (this.countsByLevel[r.levelname] <= 0) {
+ delete this.countsByLevel[r.levelname];
+ }
+ }
+ this.hasErrors = (this.countsByLevel['ERROR'] ?? 0) > 0
+ || (this.countsByLevel['CRITICAL'] ?? 0) > 0;
+ }
+ }
+
+ /**
+ * Returns a snapshot for React components to read during render.
+ * Only copies the entries array when new logs have arrived since the
+ * last call, avoiding the per-poll GC pressure of unconditional .slice().
+ */
+ getSnapshot(): LogSnapshot {
+ if (this.version !== this.lastSnapshotVersion) {
+ this.cachedEntries = this.entries.slice();
+ this.cachedCountsByLevel = { ...this.countsByLevel };
+ this.lastSnapshotVersion = this.version;
+ }
+
+ return {
+ entries: this.cachedEntries,
+ hasErrors: this.hasErrors,
+ countsByLevel: this.cachedCountsByLevel,
+ version: this.version,
+ };
+ }
+
+ clear(): void {
+ this.entries = [];
+ this.countsByLevel = {};
+ this.hasErrors = false;
+ this.version++;
+ this.cachedEntries = [];
+ this.cachedCountsByLevel = {};
+ this.lastSnapshotVersion = this.version;
+ }
+}
diff --git a/freemocap-ui/src/services/server/server-helpers/server-urls.ts b/freemocap-ui/src/services/server/server-helpers/server-urls.ts
new file mode 100644
index 00000000..21ec6813
--- /dev/null
+++ b/freemocap-ui/src/services/server/server-helpers/server-urls.ts
@@ -0,0 +1,73 @@
+export const DEFAULT_HOST = 'localhost';
+export const DEFAULT_PORT = 53117;
+export const WS_PATH = '/freemocap/websocket/connect';
+
+class ServerUrls {
+ private host: string = DEFAULT_HOST;
+ private port: number = DEFAULT_PORT;
+
+ getHost(): string {
+ return this.host;
+ }
+
+ getPort(): number {
+ return this.port;
+ }
+
+ setHost(host: string): void {
+ this.host = host;
+ }
+
+ setPort(port: number): void {
+ this.port = port;
+ }
+
+ /**
+ * Get HTTP base URL
+ */
+ getHttpUrl(): string {
+ return `http://${this.host}:${this.port}`;
+ }
+
+ /**
+ * Get WebSocket base URL
+ */
+ getWebSocketUrl(): string {
+ return `ws://${this.host}:${this.port}${WS_PATH}`;
+ }
+ get endpoints() {
+ const baseUrl = this.getHttpUrl();
+
+ return {
+ // Server management
+ health: `${baseUrl}/health`,
+ shutdown: `${baseUrl}/shutdown`,
+
+ // Camera endpoints
+ detectCameras: `${baseUrl}/freemocap/camera/detect`,
+ camerasConnectOrUpdate: `${baseUrl}/freemocap/camera/group/apply`,
+ closeAll: `${baseUrl}/freemocap/camera/group/close/all`,
+ updateConfigs: `${baseUrl}/freemocap/camera/update`,
+ pauseUnpauseCameras: `${baseUrl}/freemocap/camera/group/all/pause_unpause`,
+ detectMicrophones: `${baseUrl}/freemocap/camera/microphone/detect`,
+
+ // Recording endpoints
+ startRecording: `${baseUrl}/freemocap/camera/group/all/record/start`,
+ stopRecording: `${baseUrl}/freemocap/camera/group/all/record/stop`,
+
+ // Playback endpoints
+ playbackRecordings: `${baseUrl}/freemocap/playback/recordings`,
+ playbackLoad: `${baseUrl}/freemocap/playback/load`,
+ playbackVideos: `${baseUrl}/freemocap/playback/videos`,
+ playbackVideoStream: (videoId: string) => `${baseUrl}/freemocap/playback/video/${videoId}`,
+ playbackTimestamps: (videoId: string) => `${baseUrl}/freemocap/playback/timestamps/${videoId}`,
+ playbackAllTimestamps: `${baseUrl}/freemocap/playback/timestamps`,
+
+ // WebSocket
+ websocket: this.getWebSocketUrl(),
+ };
+ }
+}
+
+// Export singleton instance
+export const serverUrls = new ServerUrls();
diff --git a/freemocap-ui/src/store/slices/cameras/camera-settings-storage.ts b/freemocap-ui/src/store/slices/cameras/camera-settings-storage.ts
new file mode 100644
index 00000000..6de530b6
--- /dev/null
+++ b/freemocap-ui/src/store/slices/cameras/camera-settings-storage.ts
@@ -0,0 +1,48 @@
+import { CameraConfig, extractConfigSettings } from './cameras-types';
+
+const STORAGE_KEY = 'freemocap-camera-settings';
+
+// What we persist per camera: the user-tunable settings + selection state
+export interface PersistedCameraSettings {
+ selected: boolean;
+ desiredConfig: Partial<CameraConfig>;
+}
+
+export type PersistedCameraSettingsMap = Record<string, PersistedCameraSettings>;
+
+export function loadPersistedCameraSettings(): PersistedCameraSettingsMap {
+ const raw = localStorage.getItem(STORAGE_KEY);
+ if (raw === null) {
+ return {};
+ }
+ try {
+ const parsed: unknown = JSON.parse(raw);
+ if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+ throw new Error(`Expected object in localStorage key "${STORAGE_KEY}", got ${typeof parsed}`);
+ }
+ return parsed as PersistedCameraSettingsMap;
+ } catch (e) {
+ // Corrupted data — nuke it and start fresh
+ localStorage.removeItem(STORAGE_KEY);
+ throw new Error(`Failed to parse persisted camera settings, cleared storage: ${e}`);
+ }
+}
+
+export function savePersistedCameraSettings(settings: PersistedCameraSettingsMap): void {
+ localStorage.setItem(STORAGE_KEY, JSON.stringify(settings));
+}
+
+export function clearPersistedCameraSettings(): void {
+ localStorage.removeItem(STORAGE_KEY);
+}
+
+// Build a settings entry from a desired config + selection state
+export function buildPersistedEntry(
+ desiredConfig: CameraConfig,
+ selected: boolean,
+): PersistedCameraSettings {
+ return {
+ selected,
+ desiredConfig: extractConfigSettings(desiredConfig),
+ };
+}