diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index ce4199c6..9f1ee15e 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -2,19 +2,19 @@ name: CI
 
 on:
   push:
-    branches: [v2]
+    branches: [v2, v2.1]
   pull_request:
-    branches: [v2]
+    branches: [v2, v2.1]
 
 jobs:
   lint:
     name: Lint
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v4
+        uses: astral-sh/setup-uv@v7
         with:
           version: "latest"
 
@@ -36,27 +36,34 @@ jobs:
   test:
     name: Test (Python ${{ matrix.python-version }})
     runs-on: ubuntu-latest
+    env:
+      QT_QPA_PLATFORM: offscreen
     strategy:
       fail-fast: false
       matrix:
         python-version: ["3.12"]
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v4
+        uses: astral-sh/setup-uv@v7
         with:
           version: "latest"
 
       - name: Set up Python ${{ matrix.python-version }}
         run: uv python install ${{ matrix.python-version }}
 
+      - name: Install Qt runtime dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libegl1
+
       - name: Install dependencies
         run: uv sync --all-extras
 
       - name: Run tests
-        run: uv run pytest tests/ -v --tb=short
+        run: make test
 
   all-checks-pass:
     name: All Checks Pass
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
new file mode 100644
index 00000000..19d61966
--- /dev/null
+++ b/.github/workflows/release.yml
@@ -0,0 +1,123 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - "v*"
+
+permissions:
+  contents: write
+
+jobs:
+  ensure-release:
+    name: Ensure Release + Notes
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v5
+
+      - name: Prepare release notes
+        run: |
+          cat > RELEASE_NOTES.md <<'EOF'
+          ## TRDrop v2.1.0-beta.3 Release Notes
+
+          ### Major updates
+          - Improved FPS/frametime overlay readability across 1/2/3/4-video layouts.
+          - Fixed multi-video frametime placement so each frametime plot stays within its own video region and no longer overlaps or gets hidden behind the framerate plot.
+          - Fixed frametime plot rendering so the history curve is visible instead of appearing as an empty chart box.
+          - Tuned dense 3/4-video layouts by reducing frametime axis label size and making framerate axes/curves thicker for clearer readability.
+          - Enabled frametime overlay by default and enabled profile generation by default in the main UI/default preset.
+          - Aligned the default test path with CI by excluding GUI-marked tests from `make test` and adding a separate `make test-gui` target.
+          - Improved headless Linux CI stability for PyQt-based tests by adding the required Qt/EGL runtime setup.
+
+          ### macOS usage (ZIP-only in this release)
+          1. Download and extract `TRDrop-macos-universal.zip`.
+          2. In Terminal, run:
+             `chmod +x TRDrop-macos-universal`
+          3. Start the app:
+             `./TRDrop-macos-universal`
+          4. If blocked by Gatekeeper, right-click → Open, or allow it in Privacy & Security.
+
+          ---
+
+          ## TRDrop v2.1.0-beta.3 更新说明
+
+          ### 主要功能更新
+          - 优化了 1/2/3/4 视频布局下 FPS/frametime 图表的可读性。
+          - 修复多视频场景下 frametime 图表位置错误的问题，确保每个 frametime 图都显示在各自视频区域内，不再与 framerate 图重叠或被遮挡。
+          - 修复 frametime 图表“只有框没有曲线”的问题，历史曲线现在可以正常显示。
+          - 针对 3/4 视频密集布局，缩小了 frametime 坐标数字，并加粗了 framerate 坐标线和曲线，显示更清晰。
+          - 主界面与默认预设现在默认开启 frametime 图表，并默认勾选 profile 生成功能。
+          - 让默认测试路径与 CI 保持一致：`make test` 默认排除 GUI 测试，并新增 `make test-gui` 用于单独运行 GUI 测试。
+          - 为无头 Linux 环境下的 PyQt 测试补充了 Qt/EGL 运行依赖，提升 CI 稳定性。
+
+          ### macOS 使用说明（本次仅提供 ZIP 包）
+          1. 下载 `TRDrop-macos-universal.zip` 并解压。
+          2. 终端进入解压目录后执行：
+             `chmod +x TRDrop-macos-universal`
+          3. 启动：
+             `./TRDrop-macos-universal`
+          4. 若被 Gatekeeper 拦截：右键应用选择“打开”，或在「系统设置 → 隐私与安全性」点击“仍要打开”。
+          EOF
+
+      - name: Create or update GitHub release (official gh CLI)
+        env:
+          GH_TOKEN: ${{ github.token }}
+          TAG: ${{ github.ref_name }}
+        run: |
+          if gh release view "$TAG" --repo "$GITHUB_REPOSITORY" >/dev/null 2>&1; then
+            gh release edit "$TAG" --repo "$GITHUB_REPOSITORY" --title "$TAG" --notes-file RELEASE_NOTES.md
+          else
+            gh release create "$TAG" --repo "$GITHUB_REPOSITORY" --title "$TAG" --notes-file RELEASE_NOTES.md
+          fi
+
+  build-and-upload:
+    name: Build (${{ matrix.os }})
+    needs: ensure-release
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [windows-latest, macos-latest]
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v5
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+        with:
+          version: "latest"
+
+      - name: Set up Python
+        run: uv python install 3.12
+
+      - name: Install dependencies
+        run: uv sync --all-extras
+
+      - name: Build with PyInstaller spec
+        run: uv run pyinstaller trdrop.spec --noconfirm --clean
+
+      - name: Prepare artifact (Windows)
+        if: runner.os == 'Windows'
+        shell: pwsh
+        run: |
+          New-Item -ItemType Directory -Force -Path out | Out-Null
+          Copy-Item dist/TRDrop.exe out/TRDrop-windows-x64.exe
+
+      - name: Prepare artifact (macOS)
+        if: runner.os == 'macOS'
+        shell: bash
+        run: |
+          mkdir -p out
+          cp dist/TRDrop TRDrop-macos-universal
+          chmod +x TRDrop-macos-universal
+          zip -9 out/TRDrop-macos-universal.zip TRDrop-macos-universal
+
+      - name: Upload build outputs to release (official gh CLI)
+        shell: bash
+        env:
+          GH_TOKEN: ${{ github.token }}
+          TAG: ${{ github.ref_name }}
+        run: |
+          gh release upload "$TAG" out/* --repo "$GITHUB_REPOSITORY" --clobber
diff --git a/.gitignore b/.gitignore
index 03adb83b..7ca150df 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,6 +1,7 @@
 __pycache__/
 *.py[cod]
 *.so
+*.exe
 .venv/
 *.egg-info/
 dist/
@@ -20,3 +21,24 @@ examples/*.csv
 
 # macOS
 .DS_Store
+*.mp4
+*.csv
+
+# User preset (use trdrop_preset.example.yaml as template)
+trdrop_preset.yaml
+
+# AI and planning files
+trdrop_profile.summary.txt
+implementation_plan.md
+task.md
+walkthrough.md
+diff.txt
+head_version.py
+.cursorrules
+.claude/
+
+# transient icon conversion workspace
+a.iconset/
+*.iconset/
+
+!uv.lock
diff --git a/HDR_PLAN.md b/HDR_PLAN.md
new file mode 100644
index 00000000..dfcd4c90
--- /dev/null
+++ b/HDR_PLAN.md
@@ -0,0 +1,68 @@
+# TRDrop HDR 支持方案 (HDR_PLAN.md)
+
+当前 TRDrop 导入 HDR 视频输出泛白、呈灰色的问题，主要是因为视频为 10-bit BT.2020 广色域与 PQ/HLG 伽马曲线，而 TRDrop 整个底层管线在强行按 8-bit BT.709 线性读取与合成。
+
+要实现对 HDR 视频的支持，以下是两套完整的技术评估与改造方案：
+
+---
+
+## 方案 A: HDR 转 SDR 映射（Tonemapping）—— 推荐 ✅
+
+此方案投入产出比最高，不会破坏现有核心逻辑。只在视频“入口处”做一层滤镜拦截，将 HDR 色调映射（Tone Map）回通用的标准 8-bit SDR。
+
+### 1. 适用场景
+* 快速修复“灰屏”问题。
+* 生成的测定视频只需要在普通的手机、显示器、B站上观看，不需要炫技展示原版 HDR 高光。
+* 追求代码修改最小化、性能影响最小化。
+
+### 2. 需要改动的代码
+**文件位置**: `src/trdrop/video/reader.py`
+**改动内容**:
+* 在 PyAV 获取解码帧之前，引入 `av.filter.Graph` 构建一个 FFmpeg 的滤镜网络。
+* 动态检测输入视频的像素格式（如 `yuv420p10le`）。
+* 如果是 HDR 视频，则令其穿过类似 `zscale=t=linear:npl=100,format=gbrpf32le,zscale=p=bt709,tonemap=tonemap=hable:desat=0,zscale=t=bt709:m=bt709:r=tv,format=rgb24` （针对 PQ）的滤镜管道。
+* 输出端直接吐出处理好的 `rgb24` 帧数据，喂给下游。
+
+### 3. 后续影响
+* **分析引擎 (`engine`)**: 无需改动，继续用 8-bit `np.uint8`。
+* **合成器 (`compositor/OSD`)**: 无需改动，原本的 (255,255,255) 就是 SDR 体系下的纯白。
+* **导出端 (`export`)**: 无需改动，继续输出 8-bit SDR 的 `yuv420p`。
+
+---
+
+## 方案 B: 全链路原生 HDR 透传处理（极高难度）
+
+真正的专业极客向方案，保持原视频的 10-bit 甚至 12-bit 高光动态范围不变，将测评数据（FPS、Frametime、图表）直接在由 `0-65535` 重构出来的广色域空间中绘制进去。
+
+### 1. 适用场景
+* 想将最终生成的评测视频放在顶级的 HDR 电视或 OLED 显示器上展示。
+* 保留画质原汁原味的高保真追求。
+
+### 2. 大面积的底层重构
+要达成全链路 HDR，以下四个模块全部需要重写：
+
+#### ⚙️ 第一关：入水管道升维 (`reader.py`)
+* 获取数据流时不能再强制转化为 `format="rgb24"`（8-bit）。
+* 必须将其提取为 `rgb48le`（16-bit packed RGB）或是完整的 10-bit `gbrp10le` 平面源。
+* NumPy 的数据结构全面升级为 `dtype=np.uint16`。
+* 必须**提取并保存**原视频的 HDR 静态/动态元数据 (Mastering Display Color Volume, Content Light Level - MaxCLL/MaxFALL)。
+
+#### 🔬 第二关：特征对比算法升级 (`analysis`)
+* SSIM、MSE 差异比对、Template Matching 等 OpenCV 计算虽然支持 `uint16` 矩阵，但之前基于 `0-255` 取值范围所设定的 `duplicate_threshold`（重复帧阈值）等全部会失效，必须建立两套阈值系统去分别适配 SDR 和 HDR 视频。
+
+#### 🎨 第三关：色彩管理与画布重绘 (`compositor`)
+* **痛点**：这是最麻烦的地方，必须手动调配 HDR 色彩锚点。
+* 以前你在画布上画一条绿线或写白字，给的颜色是 `(0, 255, 0)` 或 `(255, 255, 255)`。
+* 现在画布变成了一张巨大无比的网 (`0-65535`)，且它遵从并不是人眼线性的 PQ/HLG 曲线。
+* 如果你在 PQ 伽马下给一条白线 `(65535, 65535, 65535)`，这根线在屏幕上会放射出极为刺眼的 `10,000 Nits` 光芒。
+* 如果你维持给 `(255, 255, 255)`，那么这根线对应的大概只有 `0.02 Nits`，几乎是**纯黑**的。
+* **改法**：必须依据 PQ Transfer 查表，将 OSD 的 UI 亮度锁定在 “Paper White”（常规漫反射白，约 200 nits）级别，推算出对应的 16-bit 色值（大概是 `~38000` 左右），用这个特调过的色彩常量进行 `cv2.putText` 或曲线绘制。
+
+#### 📦 第四关：打包与元数据回填 (`export`)
+* 输出部分的代码 `streaming_video.py` 必须将格式切换为 `yuv420p10le` 开始 10-bit 编码压制。
+* 仅仅压制还不够，必须向新容器（Container）和流（Stream）中重新注入刚才第一关提取的 HDR Metadata（Color primaries: BT.2020，Color trc: SMPTE 2084，Color space: BT.2020nc）以及相关的 SEI 信息。如果不加这一步，即便视频有了高动态，所有的播放引擎依旧只会把它当成普通的 SDR 画面来强制暗化映射（继续灰蒙蒙）。
+
+---
+
+### 推荐落实步骤
+如果你要着手改善工具，**强烈建议从方案 A 开始做起**，几行 PyAV 黑魔法就能搞定入城口的格式化转换；不仅开发极快，还能保证分析算法不会出现断崖式的兼容错误。当你真的有了全链路 C++ 级别重构的耐心，再考虑开启方案 B。
diff --git a/Makefile b/Makefile
index 67a2ea37..f411eb2c 100644
--- a/Makefile
+++ b/Makefile
@@ -1,4 +1,4 @@
-.PHONY: lint test check testvideos clean-testvideos benchmark examples clean-examples clean
+.PHONY: lint test test-gui check testvideos clean-testvideos benchmark examples clean-examples clean
 
 lint:
 	uv run isort --check-only src tests
@@ -6,7 +6,10 @@ lint:
 	uv run basedpyright src tests
 
 test:
-	uv run pytest tests/ --verbose --ignore=tests/benchmarks/
+	uv run pytest tests/ --verbose -m "not gui" --ignore=tests/benchmarks/
+
+test-gui:
+	uv run pytest tests/ --verbose -m "gui"
 
 test-all:
 	uv run pytest tests/ --verbose
diff --git a/README.md b/README.md
index 826a44f8..36bd731a 100644
--- a/README.md
+++ b/README.md
@@ -2,6 +2,8 @@
 
 Video framerate, frametime, and screen tearing analysis tool for capture card footage.
 
+Supports up to 4 videos side-by-side comparison. Automatically detects HDR (PQ/HLG) content and tonemaps to SDR for correct output.
+
 ## Setup
 
 ```bash
@@ -9,17 +11,95 @@ uv sync              # runtime only
 uv sync --all-extras # with dev tools
 ```
 
-## Lint & Test
+## Run
 
 ```bash
-make check  # run all
-make lint   # isort, flake8, basedpyright
-make test   # pytest
+uv run trdrop
 ```
 
-## Run
+## Usage
+
+### Quick Start
+
+1. Launch the app, you will see an empty window with a control bar at the top
+2. Click **"+"** or drag video files into the window (up to 4 videos)
+3. *(Optional)* Click **"Video..."** to set the output video path, click **"CSV..."** to set the metrics export path
+4. Click **"Start"** to begin processing
+5. Wait for the progress bar to reach 100%, or click **"Pause"** to inspect individual frames
+
+### Control Bar
+
+From left to right:
+
+| Control | Description |
+|---------|-------------|
+| State Indicator | Colored circle showing engine state (gray=idle, blue=ready, green=processing, orange=paused, purple=complete, red=error) |
+| **"+"** | Add video files (MP4, MKV, AVI, MOV, WebM). Supports multiple selection. Max 4 videos |
+| **"-"** | Remove the last loaded video |
+| Video Count | Shows number of loaded videos (0-4) |
+| **"CSV..."** | Set CSV export path. Exports frame-by-frame metrics (fps, frametime, duplicate detection per frame) |
+| **"Video..."** | Set video export path. Exports composited video with overlays as MP4 |
+| **"Config..."** | Load or save a YAML preset file for overlay configuration (see [Preset Configuration](#preset-configuration)) |
+| **"Profile"** | Enable performance profiling. Generates `trdrop_profile.csv` and summary on completion |
+| **"Start"** | Begin processing (enabled when videos are loaded) |
+| **"Pause"** / **"Resume"** | Pause or resume processing |
+| **"Reset"** | Clear everything and return to idle state |
+| Seek Spinbox + **"Seek"** | Jump to a specific frame (enabled when paused or completed) |
+
+### Menu Bar
+
+- **File > Add Video...** (Ctrl+O / Cmd+O) — Same as "+" button
+- **File > Quit** (Ctrl+Q / Cmd+Q) — Exit the application
+- **Help > About** — Version info
+
+### Drag and Drop
+
+Drag video files directly into the window to load them. Supported formats: MP4, MKV, AVI, MOV, WebM.
+
+### Workflow
+
+1. **Load videos** — Use "+" button, menu, or drag-and-drop
+2. **Configure exports** — Set CSV and/or video output paths (optional, but at least one is needed for output)
+3. **Load preset** — Click "Config..." to load a YAML preset for overlay style customization (optional)
+4. **Start processing** — The preview area shows composited frames in real-time with FPS overlay
+5. **Inspect frames** — Pause processing, enter a frame number, and click "Seek" to view that frame's metrics
+6. **View results** — After completion, check the exported video and/or CSV file
+
+### Outputs
+
+- **Video (.mp4)** — Composited video with all loaded videos arranged in a grid, FPS/frametime text overlays, and optional FPS plot
+- **CSV (.csv)** — One row per frame per video, columns include: frame_index, is_duplicate, diff_ratio, windowed_fps, smoothed_fps, frametime_ms, etc.
+
+## Preset Configuration
+
+TRDrop uses YAML preset files to control overlay appearance. Click **"Config..."** in the control bar:
+
+- **"Yes"** — Load an existing YAML preset
+- **"No"** — Save the default preset as a template to edit
+
+See `trdrop_preset.example.yaml` for a fully commented example with all available parameters.
+
+### Key Concepts
+
+- **Coordinates** are normalized 0.0–1.0 (0.5 = center of the frame)
+- **Reference** can be `global` (relative to entire output frame) or `video:N` (relative to video N's region)
+- **Colors** are RGBA arrays `[R, G, B, A]` with values 0–255
+
+## HDR Support
+
+TRDrop automatically detects HDR video content (PQ/HLG transfer curves, BT.2020 color primaries) and applies tonemapping to SDR for correct display and export. This includes:
+
+- PQ EOTF (Perceptual Quantizer) decoding
+- BT.2020 to BT.709 color gamut mapping
+- Reinhard tonemapping
+- BT.709 gamma encoding
+
+No configuration needed — HDR detection and conversion happen automatically.
+
+## Lint & Test
 
 ```bash
-uv run trdrop
-uv run python examples/pyav/01_read_video_info.py <video>
+make check  # run all
+make lint   # isort, flake8, basedpyright
+make test   # pytest
 ```
diff --git a/README_CN.md b/README_CN.md
new file mode 100644
index 00000000..5de469ff
--- /dev/null
+++ b/README_CN.md
@@ -0,0 +1,105 @@
+# TRDrop v2
+
+视频帧率、帧时间与画面撕裂分析工具，适用于采集卡录制的视频素材。
+
+支持最多 4 个视频并排对比分析。自动检测 HDR（PQ/HLG）内容并转换为 SDR 以确保输出画面颜色正确。
+
+## 环境配置
+
+```bash
+uv sync              # 仅安装运行时依赖
+uv sync --all-extras # 安装开发工具
+```
+
+## 启动
+
+```bash
+uv run trdrop
+```
+
+## 使用说明
+
+### 快速上手
+
+1. 启动应用，你会看到一个带有顶部控制栏的空白窗口
+2. 点击 **"+"** 或拖拽视频文件到窗口中（最多 4 个视频）
+3. *（可选）* 点击 **"Video..."** 设置输出视频路径，点击 **"CSV..."** 设置指标导出路径
+4. 点击 **"Start"** 开始处理
+5. 等待进度条到 100%，或点击 **"Pause"** 暂停后逐帧检查
+
+### 控制栏
+
+从左到右依次为：
+
+| 控件 | 说明 |
+|------|------|
+| 状态指示器 | 彩色圆点显示引擎状态（灰色=空闲，蓝色=就绪，绿色=处理中，橙色=暂停，紫色=完成，红色=错误） |
+| **"+"** | 添加视频文件（支持 MP4、MKV、AVI、MOV、WebM），可多选，最多 4 个 |
+| **"-"** | 移除最后一个已加载的视频 |
+| 视频计数 | 显示当前已加载的视频数量（0-4） |
+| **"CSV..."** | 设置 CSV 导出路径。导出逐帧指标（帧率、帧时间、重复帧检测等） |
+| **"Video..."** | 设置视频导出路径。导出带叠加层的合成视频（MP4） |
+| **"Config..."** | 加载或保存 YAML 预设文件，用于自定义叠加层样式（见[预设配置](#预设配置)） |
+| **"Profile"** | 启用性能分析。处理完成后生成 `trdrop_profile.csv` 和摘要报告 |
+| **"Start"** | 开始处理（加载视频后可用） |
+| **"Pause"** / **"Resume"** | 暂停或恢复处理 |
+| **"Reset"** | 清除所有内容，回到空闲状态 |
+| Seek 输入框 + **"Seek"** | 跳转到指定帧（暂停或完成状态下可用） |
+
+### 菜单栏
+
+- **File > Add Video...** (Ctrl+O / Cmd+O) — 同 "+" 按钮
+- **File > Quit** (Ctrl+Q / Cmd+Q) — 退出应用
+- **Help > About** — 版本信息
+
+### 拖放导入
+
+直接将视频文件拖拽到窗口中即可加载。支持格式：MP4、MKV、AVI、MOV、WebM。
+
+### 工作流程
+
+1. **加载视频** — 使用 "+" 按钮、菜单或拖放
+2. **配置导出** — 设置 CSV 和/或视频输出路径（可选，但至少设置一个才有输出）
+3. **加载预设** — 点击 "Config..." 加载 YAML 预设文件来自定义叠加层样式（可选）
+4. **开始处理** — 预览区域实时显示带 FPS 叠加层的合成画面
+5. **检查帧** — 暂停处理，输入帧号，点击 "Seek" 查看该帧的指标数据
+6. **查看结果** — 处理完成后，查看导出的视频和/或 CSV 文件
+
+### 输出内容
+
+- **视频 (.mp4)** — 合成视频，包含所有已加载视频的网格排列、FPS/帧时间文字叠加层以及可选的 FPS 曲线图
+- **CSV (.csv)** — 每帧每视频一行，字段包括：frame_index、is_duplicate、diff_ratio、windowed_fps、smoothed_fps、frametime_ms 等
+
+## 预设配置
+
+TRDrop 使用 YAML 预设文件控制叠加层的外观。点击控制栏中的 **"Config..."**：
+
+- **"Yes"** — 加载已有的 YAML 预设文件
+- **"No"** — 将默认预设保存为模板供编辑
+
+完整参数说明和注释请参见 `trdrop_preset.example.yaml`。
+
+### 核心概念
+
+- **坐标** 使用 0.0–1.0 归一化表示（0.5 = 画面中心）
+- **参考系** 可以是 `global`（相对于整个输出画面）或 `video:N`（相对于第 N 个视频的区域）
+- **颜色** 使用 RGBA 数组 `[R, G, B, A]`，取值范围 0–255
+
+## HDR 支持
+
+TRDrop 自动检测 HDR 视频内容（PQ/HLG 传输曲线、BT.2020 色彩空间）并进行 SDR 色调映射，确保显示和导出颜色正确。处理流程包括：
+
+- PQ EOTF（感知量化器）解码
+- BT.2020 到 BT.709 色域映射
+- Reinhard 色调映射
+- BT.709 伽马编码
+
+无需任何配置——HDR 检测和转换全自动完成。
+
+## 代码检查与测试
+
+```bash
+make check  # 全部运行
+make lint   # isort, flake8, basedpyright
+make test   # pytest
+```
diff --git a/make_mac_icon.py b/make_mac_icon.py
new file mode 100644
index 00000000..10717aab
--- /dev/null
+++ b/make_mac_icon.py
@@ -0,0 +1,46 @@
+import sys
+from PyQt6.QtWidgets import QApplication
+from PyQt6.QtGui import QIcon, QPainter, QPainterPath, QImage, QPixmap
+from PyQt6.QtCore import Qt, QSize
+
+def main():
+    app = QApplication(sys.argv)
+    
+    icon_path = "trdrop_logo_new.png"
+    img = QImage(icon_path)
+    
+    if img.isNull():
+        print(f"Failed to load {icon_path}.")
+        return
+        
+    pix = QPixmap.fromImage(img)
+    
+    w, h = pix.width(), pix.height()
+    if w < 512:
+        pix = pix.scaled(512, 512, Qt.AspectRatioMode.KeepAspectRatio, Qt.TransformationMode.SmoothTransformation)
+        w, h = 512, 512
+
+    pad = int(w * 0.1)
+    inner_w = w - 2 * pad
+    inner_pix = pix.scaled(inner_w, inner_w, Qt.AspectRatioMode.KeepAspectRatio, Qt.TransformationMode.SmoothTransformation)
+    
+    canvas = QImage(w, h, QImage.Format.Format_ARGB32_Premultiplied)
+    canvas.fill(Qt.GlobalColor.transparent)
+    
+    painter = QPainter(canvas)
+    painter.setRenderHint(QPainter.RenderHint.Antialiasing)
+    painter.setRenderHint(QPainter.RenderHint.SmoothPixmapTransform)
+    
+    path = QPainterPath()
+    radius = inner_w * 0.225
+    path.addRoundedRect(float(pad), float(pad), float(inner_w), float(inner_w), radius, radius)
+    
+    painter.setClipPath(path)
+    painter.drawPixmap(pad, pad, inner_pix)
+    painter.end()
+    
+    canvas.save("trdrop_mac.png")
+    print("trdrop_mac.png created successfully.")
+
+if __name__ == "__main__":
+    main()
diff --git a/pyproject.toml b/pyproject.toml
index a6c3f677..b3bcd38a 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
 [project]
 name = "trdrop"
-version = "2.0.0-dev"
+version = "2.1.0-beta.4"
 description = "Video framerate and frametime analysis tool"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -40,3 +40,8 @@ testpaths = ["tests"]
 markers = [
     "gui: marks tests as GUI/interactive engine tests (deselect with '-m \"not gui\"')",
 ]
+
+[dependency-groups]
+dev = [
+    "pyinstaller>=6.19.0",
+]
diff --git a/rthook_av.py b/rthook_av.py
new file mode 100644
index 00000000..f2d1c732
--- /dev/null
+++ b/rthook_av.py
@@ -0,0 +1,36 @@
+"""PyInstaller runtime hook: pre-load FFmpeg DLLs for av._core."""
+import ctypes
+import glob
+import os
+import sys
+
+if hasattr(sys, "_MEIPASS"):
+    av_libs = os.path.join(sys._MEIPASS, "av.libs")
+    if os.path.isdir(av_libs):
+        os.add_dll_directory(av_libs)
+        os.environ["PATH"] = av_libs + os.pathsep + os.environ.get("PATH", "")
+
+        # Load in dependency order: support libs -> avutil -> sw* -> avcodec -> rest
+        _load_order = [
+            "libgcc_s_seh-*.dll",
+            "libwinpthread-*.dll",
+            "libstdc++-*.dll",
+            "zlib1-*.dll",
+            "lib*.dll",
+            "avutil-*.dll",
+            "swresample-*.dll",
+            "swscale-*.dll",
+            "avcodec-*.dll",
+            "avformat-*.dll",
+            "avfilter-*.dll",
+            "avdevice-*.dll",
+        ]
+        _loaded = set()
+        for pattern in _load_order:
+            for dll_path in glob.glob(os.path.join(av_libs, pattern)):
+                if dll_path not in _loaded:
+                    _loaded.add(dll_path)
+                    try:
+                        ctypes.CDLL(dll_path)
+                    except OSError:
+                        pass
diff --git a/src/trdrop/__init__.py b/src/trdrop/__init__.py
index 439990e1..05832709 100644
--- a/src/trdrop/__init__.py
+++ b/src/trdrop/__init__.py
@@ -2,5 +2,5 @@
 
 from __future__ import annotations
 
-__version__ = "2.0.0-dev"
+__version__ = "2.1.0-beta.4"
 __engine_version__ = "0.6"  # Engine optimization version for benchmark tracking
diff --git a/src/trdrop/compositor/overlay/plot.py b/src/trdrop/compositor/overlay/plot.py
index f112ee24..51db3f45 100644
--- a/src/trdrop/compositor/overlay/plot.py
+++ b/src/trdrop/compositor/overlay/plot.py
@@ -13,6 +13,12 @@
 from trdrop.utils.ringbuffer import RingBuffer
 
 
+def _font_px(font: QFont) -> int:
+    """Get font size in pixels, whether set via pixelSize or pointSize."""
+    ps = font.pixelSize()
+    return ps if ps > 0 else max(1, font.pointSize())
+
+
 def _format_fps_label(value: float) -> str:
     """Format FPS value for display, using K suffix for thousands."""
     if value >= 1000:
@@ -136,16 +142,13 @@ def _draw_background(self, painter: QPainter, bounds: QRect) -> None:
         painter.fillRect(bounds, self._style.background_color)
 
     def _draw_axes(self, painter: QPainter, bounds: QRect) -> None:
-        """Draw X and Y axes with shadow."""
+        """Draw a full rectangular plot frame."""
         pen = QPen(self._style.axis_color)
-        pen.setWidth(2)
+        pen.setWidth(max(2, self._style.line_width - 1))
         pen.setJoinStyle(Qt.PenJoinStyle.MiterJoin)
         painter.setPen(pen)
-
-        # Y axis (left edge)
-        painter.drawLine(bounds.left(), bounds.top(), bounds.left(), bounds.bottom())
-        # X axis (bottom edge)
-        painter.drawLine(bounds.left(), bounds.bottom(), bounds.right(), bounds.bottom())
+        painter.setBrush(Qt.BrushStyle.NoBrush)
+        painter.drawRect(bounds.adjusted(0, 0, -1, -1))
 
     def _draw_grid(self, painter: QPainter, bounds: QRect) -> None:
         """Draw horizontal grid lines."""
@@ -153,7 +156,7 @@ def _draw_grid(self, painter: QPainter, bounds: QRect) -> None:
             return
 
         pen = QPen(self._style.grid_color)
-        pen.setWidth(1)
+        pen.setWidth(max(1, self._style.line_width - 2))
         painter.setPen(pen)
 
         segments = self._style.grid_segments
@@ -169,16 +172,32 @@ def _draw_text_with_shadow(
         pos: QPoint,
         text: str,
     ) -> None:
-        """Draw text with shadow for contrast."""
-        offset = self._style.shadow_offset
+        """Draw text with black outline for contrast (like DF-style overlays)."""
+        painter.save()
 
-        # Shadow
-        painter.setPen(self._style.shadow_color)
-        painter.drawText(pos.x() + offset, pos.y() + offset, text)
+        font = painter.font()
+        font.setBold(True)
+        painter.setFont(font)
+
+        # Build text path for outline
+        path = QPainterPath()
+        path.addText(QPointF(pos.x(), pos.y()), font, text)
+
+        # Draw black outline
+        outline_width = max(2.0, _font_px(font) / 8.0)
+        outline_pen = QPen(self._style.shadow_color)
+        outline_pen.setWidthF(outline_width)
+        outline_pen.setJoinStyle(Qt.PenJoinStyle.RoundJoin)
+        painter.setPen(outline_pen)
+        painter.setBrush(Qt.BrushStyle.NoBrush)
+        painter.drawPath(path)
 
-        # Main text
-        painter.setPen(self._style.text_color)
-        painter.drawText(pos.x(), pos.y(), text)
+        # Fill with text color
+        painter.setPen(Qt.PenStyle.NoPen)
+        painter.setBrush(self._style.text_color)
+        painter.drawPath(path)
+
+        painter.restore()
 
     def _draw_labels(
         self,
@@ -209,8 +228,19 @@ def _draw_labels(
             label = _format_fps_label(value)
 
             # Draw to the right of the anchor position
-            text_x = anchor_x + 5
-            text_y = y + 4
+            font_size = _font_px(self._style.font)
+            pad_x = max(8, font_size // 2)
+            pad_y = font_size // 3
+            from PyQt6.QtGui import QFontMetrics
+            metrics = QFontMetrics(self._style.font)
+            text_width = metrics.horizontalAdvance(label)
+            text_x = self._fit_text_x(
+                bounds,
+                text_width,
+                anchor_x + pad_x,
+                padding=pad_x,
+            )
+            text_y = y + pad_y
             self._draw_text_with_shadow(painter, QPoint(text_x, text_y), label)
 
     def _draw_title(
@@ -241,11 +271,32 @@ def _draw_title(
         # Use (width - 1) for Qt rect semantics
         plot_width = bounds.width() - 1
         anchor_x = bounds.left() + int(plot_width * time_anchor)
-        x = anchor_x - text_width  # Right-align to anchor
-        y = bounds.top() - 8  # Small gap above plot
+        font_size = _font_px(title_font)
+        x = self._fit_text_x(
+            bounds,
+            text_width,
+            anchor_x - text_width,
+            padding=max(8, font_size // 2),
+        )
+        y = bounds.top() - max(8, font_size // 2)  # Gap scales with font
 
         self._draw_text_with_shadow(painter, QPoint(x, y), self._title)
 
+    def _fit_text_x(
+        self,
+        bounds: QRect,
+        text_width: int,
+        desired_x: int,
+        *,
+        padding: int = 0,
+    ) -> int:
+        """Clamp text X position so the full string stays within bounds."""
+        min_x = bounds.left() + padding
+        max_x = bounds.right() - text_width - padding
+        if max_x < min_x:
+            return min_x
+        return max(min_x, min(desired_x, max_x))
+
 
 class FrameratePlot(Plot):
     """Plot for framerate history (0 to max_fps).
@@ -389,7 +440,7 @@ def _build_framerate_cache(
     def _draw_center_line(self, painter: QPainter, bounds: QRect) -> None:
         """Draw horizontal center line at half max FPS."""
         pen = QPen(self._style.grid_color)
-        pen.setWidth(1)
+        pen.setWidth(max(1, self._style.line_width - 2))
         painter.setPen(pen)
 
         center_y = bounds.top() + bounds.height() // 2
@@ -402,7 +453,7 @@ def _draw_anchor_line(self, painter: QPainter, bounds: QRect) -> None:
             return
 
         pen = QPen(self._style.line_color)
-        pen.setWidth(1)
+        pen.setWidth(max(1, self._style.line_width - 2))
         pen.setStyle(Qt.PenStyle.DashLine)
         painter.setPen(pen)
 
@@ -790,8 +841,19 @@ def _draw_labels_fractional(
                 label = f"{value:.2f}"
 
             # Draw to the RIGHT of plot area (same as FrameratePlot)
-            text_x = bounds.right() + 5
-            text_y = y + 4
+            font_size = _font_px(self._style.font)
+            pad_x = max(8, font_size // 2)
+            pad_y = font_size // 3
+            from PyQt6.QtGui import QFontMetrics
+            metrics = QFontMetrics(self._style.font)
+            text_width = metrics.horizontalAdvance(label)
+            text_x = self._fit_text_x(
+                bounds,
+                text_width,
+                bounds.right() - text_width - pad_x,
+                padding=pad_x,
+            )
+            text_y = y + pad_y
             self._draw_text_with_shadow(painter, QPoint(text_x, text_y), label)
 
     def _draw_title_with_value(
@@ -824,8 +886,14 @@ def _draw_title_with_value(
         # Use (width - 1) for Qt rect semantics
         plot_width = bounds.width() - 1
         anchor_x = bounds.left() + int(plot_width * self._time_anchor)
-        x = anchor_x - text_width
-        y = bounds.top() - 8
+        font_size = _font_px(title_font)
+        x = self._fit_text_x(
+            bounds,
+            text_width,
+            anchor_x - text_width,
+            padding=max(8, font_size // 2),
+        )
+        y = bounds.top() - max(8, font_size // 2)
 
         self._draw_text_with_shadow(painter, QPoint(x, y), title_text)
 
diff --git a/src/trdrop/compositor/simple.py b/src/trdrop/compositor/simple.py
index 1314c65f..f90506ac 100644
--- a/src/trdrop/compositor/simple.py
+++ b/src/trdrop/compositor/simple.py
@@ -7,8 +7,8 @@
 from dataclasses import dataclass
 
 import numpy as np
-from PyQt6.QtCore import QPoint, QRect
-from PyQt6.QtGui import QColor, QFont, QImage, QPainter
+from PyQt6.QtCore import QPoint, QPointF, QRect, Qt
+from PyQt6.QtGui import QColor, QFont, QImage, QPainter, QPainterPath, QPen
 
 from trdrop.compositor.base import Compositor
 from trdrop.compositor.overlay.colors import get_video_color
@@ -292,6 +292,7 @@ def __init__(
         frametime_plots: list[FrametimePlot] | None = None,
         framerate_combined: bool = True,
         frametime_combined: bool = False,
+        video_names: list[str] | None = None,
     ) -> None:
         if video_count != len(video_fps):
             raise ValueError(
@@ -364,10 +365,60 @@ def __init__(
             self._fps_texts = self._create_fps_texts_from_config()
         if framerate_plots is None and config is not None:
             self._framerate_plots = self._create_framerate_plots_from_config()
+            self._framerate_combined = True
         if frametime_plots is None and config is not None:
             self._frametime_plots = self._create_frametime_plots_from_config()
+            self._frametime_combined = self._video_count == 1
 
         self._frame_index = 0
+        self._video_names = video_names or []
+
+    @staticmethod
+    def _make_pixel_font(family: str, pixel_size: int) -> QFont:
+        """Create a QFont with pixel size (DPI-independent)."""
+        font = QFont(family)
+        font.setPixelSize(pixel_size)
+        return font
+
+    def _plot_font_px(self, relative_size: float) -> int:
+        """Scale plot fonts against the full output frame for stable readability."""
+        return max(10, int(relative_size * self._output_height))
+
+    @staticmethod
+    def _frametime_label_size(relative_size: float, video_count: int) -> float:
+        """Reduce frametime label size in dense 3/4-up layouts to avoid clipping."""
+        if video_count < 3:
+            return relative_size
+        reduced_size = max(relative_size * 0.72, 0.011)
+        return min(relative_size, reduced_size)
+
+    def _make_plot_style(
+        self,
+        *,
+        line_color: QColor,
+        background_color: QColor,
+        grid_color: QColor,
+        label_size: float,
+        line_width: float,
+        show_grid: bool,
+        title_size: float | None = None,
+    ) -> OverlayPlotStyle:
+        """Build a plot style tuned for HUD-like overlays."""
+        font_px = self._plot_font_px(label_size)
+        title_base_px = self._plot_font_px(title_size) if title_size is not None else font_px
+        title_px = max(title_base_px + 2, int(title_base_px * 1.18))
+        return OverlayPlotStyle(
+            line_color=line_color,
+            background_color=background_color,
+            axis_color=QColor(255, 255, 255, 224),
+            grid_color=grid_color,
+            text_color=QColor(255, 255, 255, 245),
+            shadow_color=QColor(0, 0, 0, 235),
+            font=self._make_pixel_font(self._config.rendering.font_family, font_px),
+            title_font=self._make_pixel_font(self._config.rendering.font_family, title_px),
+            line_width=max(2, int(line_width)),
+            show_grid=show_grid,
+        )
 
     def _create_fps_texts_from_config(self) -> list[FPSText]:
         """Create FPS text overlays from config."""
@@ -385,7 +436,8 @@ def _create_fps_texts_from_config(self) -> list[FPSText]:
                 font_size_px = int(
                     video_cfg.fps_text.font_size * self._output_height
                 )
-                font = QFont(video_cfg.fps_text.font_family, font_size_px)
+                font = QFont(video_cfg.fps_text.font_family)
+                font.setPixelSize(font_size_px)
                 font.setWeight(QFont.Weight.Bold)
 
                 style = TextStyle(
@@ -410,28 +462,30 @@ def _create_framerate_plots_from_config(self) -> list[FrameratePlot]:
         gr, gg, gb, ga = cfg.grid_color
         grid_color = QColor(gr, gg, gb, ga)
 
-        # Use first video's color as line color for combined plot
-        line_color = get_video_color(0)
-
-        style = OverlayPlotStyle(
-            line_color=line_color,
-            background_color=bg_color,
-            axis_color=QColor(236, 236, 236),
-            grid_color=grid_color,
-            text_color=QColor(255, 255, 255),
-            shadow_color=QColor(0, 0, 0),
-            font=QFont(self._config.rendering.font_family, 12),
-            line_width=int(cfg.line_width),
-            show_grid=cfg.show_grid,
-        )
-
-        # Create single combined plot
-        return [FrameratePlot(
-            style,
-            max_fps=max(self._video_fps),
-            show_center_line=True,
-            auto_scale=True,
-        )]
+        plot_count = 1
+        plots: list[FrameratePlot] = []
+        for i in range(plot_count):
+            style = self._make_plot_style(
+                line_color=get_video_color(i),
+                background_color=bg_color,
+                grid_color=grid_color,
+                label_size=cfg.label_font_size,
+                line_width=cfg.line_width + 1.0,
+                show_grid=cfg.show_grid,
+            )
+            plots.append(
+                FrameratePlot(
+                    style,
+                    max_fps=max(self._video_fps),
+                    title="FRAME-RATE (FPS)",
+                    show_center_line=False,
+                    auto_scale=True,
+                    time_anchor=1.0,
+                    show_time_indicator=False,
+                    show_start_marker=False,
+                )
+            )
+        return plots
 
     def _create_frametime_plots_from_config(self) -> list[FrametimePlot]:
         """Create frametime plot overlays from config."""
@@ -446,26 +500,32 @@ def _create_frametime_plots_from_config(self) -> list[FrametimePlot]:
         gr, gg, gb, ga = cfg.grid_color
         grid_color = QColor(gr, gg, gb, ga)
 
-        line_color = get_video_color(0)
-
-        style = OverlayPlotStyle(
-            line_color=line_color,
-            background_color=bg_color,
-            axis_color=QColor(236, 236, 236),
-            grid_color=grid_color,
-            text_color=QColor(255, 255, 255),
-            shadow_color=QColor(0, 0, 0),
-            font=QFont(self._config.rendering.font_family, 12),
-            line_width=int(cfg.line_width),
-            show_grid=cfg.show_grid,
-        )
-
-        return [FrametimePlot(
-            style,
-            max_ms=50.0,
-            auto_scale=True,
-            show_current_value=True,
-        )]
+        plot_count = 1 if self._video_count == 1 else self._video_count
+        plots: list[FrametimePlot] = []
+        label_size = self._frametime_label_size(cfg.label_font_size, self._video_count)
+        for i in range(plot_count):
+            style = self._make_plot_style(
+                line_color=get_video_color(i),
+                background_color=bg_color,
+                grid_color=grid_color,
+                label_size=label_size,
+                line_width=cfg.line_width,
+                show_grid=cfg.show_grid,
+                title_size=cfg.label_font_size,
+            )
+            plots.append(
+                FrametimePlot(
+                    style,
+                    max_ms=50.0,
+                    title="FRAME-TIME (MS)",
+                    auto_scale=True,
+                    time_anchor=1.0,
+                    show_current_value=False,
+                    show_time_indicator=False,
+                    show_start_marker=False,
+                )
+            )
+        return plots
 
     @property
     def layout(self) -> FrameLayout:
@@ -721,6 +781,10 @@ def _draw_overlays(self, video_metrics: list[VideoMetrics]) -> None:
                             "overlay_fps_text", (time.perf_counter() - t0) * 1000
                         )
 
+            # Draw video file names in top-right of each video region
+            if self._video_names:
+                self._draw_video_names(painter)
+
             # Draw framerate plot(s)
             if self._framerate_plots:
                 t0 = time.perf_counter()
@@ -746,19 +810,133 @@ def _draw_overlays(self, video_metrics: list[VideoMetrics]) -> None:
         finally:
             painter.end()
 
+    def _draw_video_names(self, painter: QPainter) -> None:
+        """Draw file names in the top-right corner of each video region."""
+        painter.save()
+
+        font_size = max(10, int(self._output_height * 0.018))
+        font = QFont(self._config.rendering.font_family)
+        font.setPixelSize(font_size)
+        font.setBold(True)
+        painter.setFont(font)
+
+        from PyQt6.QtGui import QFontMetrics
+        fm = QFontMetrics(font)
+        padding = font_size // 2
+
+        for i, name in enumerate(self._video_names):
+            if i >= self._video_count:
+                break
+            region = self._layout.get_region(i)
+            # Region pixel bounds
+            rx = int(region.x * self._output_width)
+            ry = int(region.y * self._output_height)
+            rw = int(region.width * self._output_width)
+
+            text_w = fm.horizontalAdvance(name)
+            x = rx + rw - text_w - padding
+            y = ry + fm.ascent() + padding
+
+            color = get_video_color(i)
+
+            # Black outline
+            path = QPainterPath()
+            path.addText(QPointF(x, y), font, name)
+            outline_pen = QPen(QColor(0, 0, 0, 200))
+            outline_pen.setWidthF(max(2.0, font_size / 8.0))
+            outline_pen.setJoinStyle(Qt.PenJoinStyle.RoundJoin)
+            painter.setPen(outline_pen)
+            painter.setBrush(Qt.BrushStyle.NoBrush)
+            painter.drawPath(path)
+
+            # Fill with video color
+            painter.setPen(Qt.PenStyle.NoPen)
+            painter.setBrush(color)
+            painter.drawPath(path)
+
+        painter.restore()
+
+    def _video_pixel_bounds(self, index: int) -> tuple[int, int, int, int]:
+        """Return pixel bounds for a video region."""
+        region = self._layout.get_region(index)
+        video_px = int(region.x * self._output_width)
+        video_py = int(region.y * self._output_height)
+        video_pw = int(region.width * self._output_width)
+        video_ph = int(region.height * self._output_height)
+        return video_px, video_py, video_pw, video_ph
+
+    def _framerate_plot_bounds(self, index: int) -> QRect:
+        """Compute per-video framerate plot bounds."""
+        video_px, video_py, video_pw, video_ph = self._video_pixel_bounds(index)
+
+        side_margin = max(12, int(video_pw * 0.03))
+        bottom_margin = max(14, int(video_ph * 0.035))
+        plot_w = max(120, video_pw - (side_margin * 2))
+        plot_h = max(72, min(int(video_ph * 0.18), 180))
+        plot_x = video_px + side_margin
+        plot_y = video_py + video_ph - plot_h - bottom_margin
+
+        return QRect(plot_x, plot_y, plot_w, plot_h)
+
+    def _combined_framerate_plot_bounds(self) -> QRect:
+        """Compute global framerate plot bounds from config."""
+        cfg = self._config.rendering.fps_plot
+        px, py = cfg.position.to_pixels(self._layout)
+        pw, ph = cfg.size.to_pixels(self._layout)
+        return QRect(px, py, pw, ph)
+
+    def _combined_frametime_strip_bounds(self, index: int) -> QRect:
+        """Compute frametime box bounds in a row above the combined framerate plot."""
+        fr_bounds = self._combined_framerate_plot_bounds()
+
+        gap = max(12, int(self._output_height * 0.014))
+        plot_h = max(64, min(int(self._output_height * 0.095), 108))
+        slot_w = max(160, fr_bounds.width() // self._video_count)
+        max_fit_w = max(150, slot_w - gap)
+        preferred_w = min(320, int(fr_bounds.width() * 0.16))
+        plot_w = min(preferred_w, max_fit_w)
+        slot_x = fr_bounds.left() + index * slot_w
+        plot_x = slot_x + max(0, (slot_w - plot_w) // 2)
+        plot_y = max(12, fr_bounds.top() - gap - plot_h)
+
+        return QRect(plot_x, plot_y, plot_w, plot_h)
+
+    def _frametime_plot_bounds(self, index: int) -> QRect:
+        """Compute per-video frametime plot bounds as a compact box at lower-left."""
+        video_px, video_py, video_pw, video_ph = self._video_pixel_bounds(index)
+        video_bounds = QRect(video_px, video_py, video_pw, video_ph)
+        fr_bounds = self._framerate_plot_bounds(index)
+
+        left_margin = max(12, int(video_pw * 0.03))
+        gap = max(10, int(video_ph * 0.028))
+        top_margin = max(10, int(video_ph * 0.02))
+        plot_w = max(160, min(int(video_pw * 0.32), 380))
+        plot_h = max(84, min(int(video_ph * 0.15), 132))
+        plot_x = video_px + left_margin
+
+        obstruction_top = fr_bounds.top()
+        if self._framerate_combined and self._framerate_plots:
+            combined_fr_bounds = self._combined_framerate_plot_bounds()
+            if combined_fr_bounds.intersects(video_bounds):
+                obstruction_top = min(obstruction_top, combined_fr_bounds.top())
+                gap = max(gap, max(12, int(self._output_height * 0.02)))
+
+        plot_y = obstruction_top - gap - plot_h
+
+        min_y = video_py + top_margin
+        if plot_y < min_y:
+            plot_y = min_y
+
+        max_w = max(120, video_pw - (left_margin * 2))
+        return QRect(plot_x, plot_y, min(plot_w, max_w), plot_h)
+
     def _draw_framerate_combined(self, painter: QPainter) -> None:
         """Draw a single combined framerate plot with all video series."""
         if not self._framerate_plots:
             return
 
         plot = self._framerate_plots[0]
-        cfg = self._config.rendering.fps_plot
-
-        # Get position and size from config (converts to pixels)
-        px, py = cfg.position.to_pixels(self._layout)
-        pw, ph = cfg.size.to_pixels(self._layout)
-
-        bounds = QRect(px, py, pw, ph)
+        bounds = self._combined_framerate_plot_bounds()
 
         # Build series list with distinct colors per video
         series_list = [
@@ -780,23 +958,8 @@ def _draw_framerate_separate(self, painter: QPainter) -> None:
             if i >= len(self._framerate_plots):
                 break
 
-            # Get region from layout
-            region = self._layout.get_region(i)
             is_last = (i == self._video_count - 1)
-
-            # Place plot within video region
-            # Use 90% width, 20% height, at bottom of region
-            video_px = int(region.x * self._output_width)
-            video_py = int(region.y * self._output_height)
-            video_pw = int(region.width * self._output_width)
-            video_ph = int(region.height * self._output_height)
-
-            plot_w = int(video_pw * 0.9)
-            plot_h = int(video_ph * 0.20)
-            plot_x = video_px + int(video_pw * 0.05)
-            plot_y = video_py + video_ph - plot_h - int(video_ph * 0.05)
-
-            bounds = QRect(plot_x, plot_y, plot_w, plot_h)
+            bounds = self._framerate_plot_bounds(i)
             self._framerate_plots[i].draw(
                 painter, bounds, state.fps_history,
                 override_show_title=is_last,
@@ -848,23 +1011,7 @@ def _draw_frametime_separate(
             if i >= len(self._frametime_plots):
                 break
 
-            # Get region from layout
-            region = self._layout.get_region(i)
-
-            # Place plot within video region
-            video_px = int(region.x * self._output_width)
-            video_py = int(region.y * self._output_height)
-            video_pw = int(region.width * self._output_width)
-            video_ph = int(region.height * self._output_height)
-
-            ft_plot_w = min(int(video_pw * 0.25), 320)
-            ft_plot_h = min(int(video_ph * 0.10), 80)
-            ft_plot_x = video_px + int(video_pw * 0.05)
-            # Position above the framerate plot area
-            framerate_top = video_py + video_ph - int(video_ph * 0.20) - int(video_ph * 0.05)
-            ft_plot_y = framerate_top - ft_plot_h - int(video_ph * 0.06)
-
-            ft_bounds = QRect(ft_plot_x, ft_plot_y, ft_plot_w, ft_plot_h)
+            ft_bounds = self._frametime_plot_bounds(i)
             self._frametime_plots[i].draw(
                 painter,
                 ft_bounds,
@@ -873,6 +1020,18 @@ def _draw_frametime_separate(
                 override_show_title=True,
             )
 
+    def snapshot_video_states(self) -> tuple[VideoStateSnapshot, ...]:
+        """Return immutable snapshots of per-video state.
+
+        Useful for interactive engine seek buffers.
+        """
+        return tuple(state.snapshot() for state in self._video_states)
+
+    def restore_video_states(self, snapshots: tuple[VideoStateSnapshot, ...]) -> None:
+        """Restore per-video state from snapshots (inverse of snapshot)."""
+        for i, snap in enumerate(snapshots):
+            self._video_states[i].restore(snap)
+
     def reset(self) -> None:
         for state in self._video_states:
             state.reset()
diff --git a/src/trdrop/config/types.py b/src/trdrop/config/types.py
index e650855a..c76e07d1 100644
--- a/src/trdrop/config/types.py
+++ b/src/trdrop/config/types.py
@@ -242,11 +242,11 @@ class FpsTextConfig:
     """Configuration for FPS text overlay."""
 
     position: Position = field(
-        default_factory=lambda: Position(0.05, 0.05, GlobalRef())
+        default_factory=lambda: Position(0.03, 0.08, GlobalRef())
     )
     anchor: Anchor = Anchor.TOP_LEFT
     visible: bool = True
-    font_size: float = 0.03  # Relative to reference frame height
+    font_size: float = 0.035  # Relative to reference frame height
     font_family: str = "monospace"
     color: tuple[int, int, int, int] = (255, 255, 255, 230)  # RGBA
     shadow: bool = True
@@ -258,11 +258,11 @@ class FrametimeTextConfig:
     """Configuration for frametime text overlay."""
 
     position: Position = field(
-        default_factory=lambda: Position(0.05, 0.10, GlobalRef())
+        default_factory=lambda: Position(0.03, 0.11, GlobalRef())
     )
     anchor: Anchor = Anchor.TOP_LEFT
-    visible: bool = True
-    font_size: float = 0.025
+    visible: bool = False
+    font_size: float = 0.04
     font_family: str = "monospace"
     color: tuple[int, int, int, int] = (255, 255, 255, 230)
     shadow: bool = True
@@ -282,16 +282,17 @@ class FpsPlotConfig:
     """Configuration for FPS plot overlay (global, spans all videos)."""
 
     position: Position = field(
-        default_factory=lambda: Position(0.05, 0.85, GlobalRef())
+        default_factory=lambda: Position(0.025, 0.83, GlobalRef())
     )
     size: Size = field(
-        default_factory=lambda: Size(0.9, 0.12, GlobalRef())
+        default_factory=lambda: Size(0.955, 0.15, GlobalRef())
     )
     visible: bool = True
-    style: PlotStyle = PlotStyle.FILLED
-    background_color: tuple[int, int, int, int] = (0, 0, 0, 128)
-    grid_color: tuple[int, int, int, int] = (128, 128, 128, 64)
-    line_width: float = 2.0
+    style: PlotStyle = PlotStyle.LINE
+    background_color: tuple[int, int, int, int] = (0, 0, 0, 24)
+    grid_color: tuple[int, int, int, int] = (255, 255, 255, 108)
+    line_width: float = 4.0
+    label_font_size: float = 0.018  # Relative to output height
     show_grid: bool = True
 
 
@@ -300,16 +301,17 @@ class FrametimePlotConfig:
     """Configuration for frametime plot overlay (global)."""
 
     position: Position = field(
-        default_factory=lambda: Position(0.05, 0.70, GlobalRef())
+        default_factory=lambda: Position(0.025, 0.69, GlobalRef())
     )
     size: Size = field(
-        default_factory=lambda: Size(0.9, 0.12, GlobalRef())
+        default_factory=lambda: Size(0.18, 0.10, GlobalRef())
     )
-    visible: bool = False  # Off by default
+    visible: bool = True
     style: PlotStyle = PlotStyle.LINE
-    background_color: tuple[int, int, int, int] = (0, 0, 0, 128)
-    grid_color: tuple[int, int, int, int] = (128, 128, 128, 64)
-    line_width: float = 2.0
+    background_color: tuple[int, int, int, int] = (0, 0, 0, 18)
+    grid_color: tuple[int, int, int, int] = (255, 255, 255, 108)
+    line_width: float = 3.0
+    label_font_size: float = 0.016  # Relative to output height
     show_grid: bool = True
 
 
@@ -335,19 +337,15 @@ class VideoOverlayConfig:
 
     def update_refs(self, video_index: int, layout: FrameLayout) -> VideoOverlayConfig:
         """
-        Return a copy with all positions converted to reference this video.
+        Return a copy with all positions set to reference the given video.
 
-        Args:
-            video_index: The video index to reference
-            layout: Frame layout for coordinate translation
-
-        Returns:
-            New VideoOverlayConfig with updated references
+        Keeps the same local coordinates but changes the reference frame
+        so the overlay appears in the correct video region.
         """
         ref = VideoRef(video_index)
         return VideoOverlayConfig(
             fps_text=FpsTextConfig(
-                position=self.fps_text.position.with_ref(ref, layout),
+                position=Position(self.fps_text.position.x, self.fps_text.position.y, ref),
                 anchor=self.fps_text.anchor,
                 visible=self.fps_text.visible,
                 font_size=self.fps_text.font_size,
@@ -357,7 +355,9 @@ def update_refs(self, video_index: int, layout: FrameLayout) -> VideoOverlayConf
                 shadow_color=self.fps_text.shadow_color,
             ),
             frametime_text=FrametimeTextConfig(
-                position=self.frametime_text.position.with_ref(ref, layout),
+                position=Position(
+                    self.frametime_text.position.x, self.frametime_text.position.y, ref
+                ),
                 anchor=self.frametime_text.anchor,
                 visible=self.frametime_text.visible,
                 font_size=self.frametime_text.font_size,
@@ -433,7 +433,7 @@ class ExportConfig:
     resolution: tuple[int, int] = (1920, 1080)
     codec: VideoCodec = VideoCodec.H264
     bitrate: str = "auto"  # "auto" or specific like "10M"
-    fps: float | None = None  # None = use source fps
+    fps: float | None = 60  # Output fps; None or outside 10-120 = use source fps
 
 
 # =============================================================================
diff --git a/src/trdrop/engine/interactive.py b/src/trdrop/engine/interactive.py
index 50a633fd..39a8ad28 100644
--- a/src/trdrop/engine/interactive.py
+++ b/src/trdrop/engine/interactive.py
@@ -7,6 +7,7 @@
 
 import logging
 import threading
+import time
 from dataclasses import dataclass
 from pathlib import Path
 
@@ -15,11 +16,14 @@
 
 from trdrop.analysis.duplicate import DuplicateDetector
 from trdrop.compositor.simple import SimpleCompositor, _VideoState
+from trdrop.compositor.types import CompositorOutput
+from trdrop.config import PresetConfig
 from trdrop.engine.buffer import ProcessingBuffer
 from trdrop.engine.protocol import EngineState, SeekResult
 from trdrop.export.streaming_csv import StreamingCSVExporter
 from trdrop.export.streaming_video import StreamingVideoExporter
 from trdrop.source.sequential import SequentialFrameSource
+from trdrop.types.frames import FramePair, FrameView
 from trdrop.types.metrics import FrameMetrics
 from trdrop.video.reader import PyAVReader
 
@@ -65,6 +69,7 @@ class InteractiveEngine(QObject):
     state_changed = pyqtSignal(EngineState)
     progress = pyqtSignal(int, int)  # current_frame, total_frames
     error = pyqtSignal(str)
+    frame_ready = pyqtSignal(object)  # np.ndarray (composited RGB frame)
 
     def __init__(self, parent: QObject | None = None) -> None:
         super().__init__(parent)
@@ -82,6 +87,7 @@ def __init__(self, parent: QObject | None = None) -> None:
         self._analyzer = DuplicateDetector()
         self._compositor: SimpleCompositor | None = None
         self._buffer: ProcessingBuffer | None = None
+        self._last_output_frame: np.ndarray | None = None
 
         # Export (optional)
         self._video_exporter: StreamingVideoExporter | None = None
@@ -96,6 +102,7 @@ def __init__(self, parent: QObject | None = None) -> None:
         # Frame tracking
         self._total_frames = 0
         self._current_frame = 0
+        self._last_frame_emit_time = 0.0
 
     # === Properties ===
 
@@ -123,6 +130,7 @@ def load(
         video_paths: list[Path | str],
         output_video: Path | str | None = None,
         output_csv: Path | str | None = None,
+        config: PresetConfig | None = None,
     ) -> LoadResult:
         """Load videos and configure exports.
 
@@ -130,6 +138,7 @@ def load(
             video_paths: 1-4 video file paths
             output_video: Optional output video path
             output_csv: Optional output CSV path
+            config: Optional overlay preset config (default: PresetConfig())
 
         Returns:
             LoadResult with video information
@@ -161,7 +170,8 @@ def load(
 
         # Determine total frames (minimum across all videos)
         frame_counts = [r.total_frames for r in self._readers]
-        self._total_frames = min(frame_counts) - 1  # -1 because we need pairs
+        min_frames = min(frame_counts)
+        self._total_frames = max(0, min_frames - 1)  # -1 because we need pairs, 0 if unknown
 
         if len(set(frame_counts)) > 1:
             logger.warning(
@@ -171,20 +181,41 @@ def load(
                 self._total_frames,
             )
 
-        # Initialize video states for compositor
+        # Initialize video states for seek/restore
         self._video_states = [
-            _VideoState(window_size=60, container_fps=r.fps)
+            _VideoState(window_size=round(r.fps), container_fps=r.fps)
             for r in self._readers
         ]
 
+        # Initialize compositor output
+        video_names = [p.stem for p in paths]
+        self._compositor = SimpleCompositor(
+            video_count=len(paths),
+            video_fps=[r.fps for r in self._readers],
+            output_width=self._readers[0].width,
+            output_height=self._readers[0].height,
+            config=config if config is not None else PresetConfig(),
+            video_names=video_names,
+        )
+        self._last_output_frame = None
+
+        # Fix analyzer threshold to match config
+        cfg = config if config is not None else PresetConfig()
+        self._analyzer = DuplicateDetector(duplicate_threshold=cfg.processing.duplicate_threshold)
+
         # Initialize buffer
         self._buffer = ProcessingBuffer(video_count=len(paths))
 
         # Setup exporters if requested
         if output_video:
+            # Determine output fps: use config if valid, else source fps
+            cfg = config if config is not None else PresetConfig()
+            output_fps = self._readers[0].fps
+            if cfg.export.fps is not None and 10 <= cfg.export.fps <= 120:
+                output_fps = cfg.export.fps
             self._video_exporter = StreamingVideoExporter(
                 Path(output_video),
-                fps=self._readers[0].fps,
+                fps=output_fps,
             )
 
         if output_csv:
@@ -220,6 +251,9 @@ def start(self) -> None:
         if self._csv_exporter:
             self._csv_exporter.open()
 
+        from trdrop.profiling import get_profiler
+        get_profiler().start_run()
+
         # Start processing thread
         self._processing_thread = threading.Thread(
             target=self._processing_loop,
@@ -311,6 +345,28 @@ def seek(self, frame_idx: int) -> SeekResult:
         fps_histories = tuple(list(s.fps_history) for s in self._video_states)
         frametime_histories = tuple(list(s.frametime_history) for s in self._video_states)
 
+        # Render composited frame through compositor if available
+        composited_frame: np.ndarray | None = None
+        if self._compositor is not None:
+            # Save current compositor state
+            saved_states = self._compositor.snapshot_video_states()
+            # Restore compositor to the seek frame's state
+            self._compositor.restore_video_states(snapshot.video_states)
+            # Build FramePairs from raw arrays
+            pairs: list[FramePair] = []
+            for i in range(len(frames)):
+                prev_view = FrameView(
+                    _data=prev_frames[i], index=max(0, frame_idx - 1), pts=0,
+                )
+                curr_view = FrameView(
+                    _data=frames[i], index=frame_idx, pts=0,
+                )
+                pairs.append(FramePair(prev=prev_view, curr=curr_view))
+            output = self._compositor.process(pairs, list(snapshot.metrics))
+            composited_frame = output.frame.copy()
+            # Restore compositor to previous state
+            self._compositor.restore_video_states(saved_states)
+
         return SeekResult(
             frame_idx=frame_idx,
             frames=tuple(frames),
@@ -320,6 +376,7 @@ def seek(self, frame_idx: int) -> SeekResult:
             frametime_values=tuple(s.smoothed_frametime() for s in self._video_states),
             fps_histories=fps_histories,
             frametime_histories=frametime_histories,
+            composited_frame=composited_frame,
         )
 
     def reset(self) -> None:
@@ -362,6 +419,8 @@ def reset(self) -> None:
         self._total_frames = 0
         self._current_frame = 0
         self._error_message = None
+        self._last_output_frame = None
+        self._last_frame_emit_time = 0.0
 
         # Reset events
         self._pause_event.set()
@@ -377,12 +436,38 @@ def _set_state(self, new_state: EngineState) -> None:
             self._state = new_state
             self.state_changed.emit(new_state)
 
+    def set_duplicate_threshold(self, threshold: float) -> None:
+        """Update duplicate threshold for analysis."""
+        self._analyzer = DuplicateDetector(duplicate_threshold=threshold)
+
+    def _export_output(self, output: CompositorOutput) -> None:
+        """Export compositor output to configured exporters."""
+        if self._video_exporter is not None:
+            self._video_exporter.write_frame(output)
+        if self._csv_exporter is not None:
+            self._csv_exporter.write_frame(output)
+
     def _processing_loop(self) -> None:
         """Main processing loop (runs in background thread)."""
+        from concurrent.futures import Future, ThreadPoolExecutor
         try:
+            import itertools
             source_iters = [iter(s) for s in self._sources]
+            from trdrop.profiling import get_profiler
+            profiler = get_profiler()
+
+            pool = ThreadPoolExecutor(max_workers=1)
+            export_future: Future[None] | None = None
+
+            # Process until StopIteration if total_frames is 0/unknown,
+            # otherwise use range.
+            frame_iterator = (
+                range(self._total_frames)
+                if self._total_frames > 0
+                else itertools.count()
+            )
 
-            for frame_idx in range(self._total_frames):
+            for frame_idx in frame_iterator:
                 # Check for stop
                 if self._stop_event.is_set():
                     break
@@ -392,6 +477,9 @@ def _processing_loop(self) -> None:
                 if self._stop_event.is_set():
                     break
 
+                profiler.start_frame(frame_idx)
+                t0_read = time.perf_counter()
+
                 # Read frame pairs from all sources
                 pairs = []
                 for it in source_iters:
@@ -404,9 +492,13 @@ def _processing_loop(self) -> None:
                 if len(pairs) != len(self._sources):
                     break  # Source exhausted
 
+                profiler.add_timing("read_total", (time.perf_counter() - t0_read) * 1000)
+                profiler.mark_timestamp("read_end")
+                t0_analysis = time.perf_counter()
+
                 # Analyze each video
                 metrics_list: list[FrameMetrics] = []
-                for i, pair in enumerate(pairs):
+                for pair in pairs:
                     result = self._analyzer.map(pair)
                     metrics = FrameMetrics(
                         frame_index=frame_idx,
@@ -415,8 +507,38 @@ def _processing_loop(self) -> None:
                     )
                     metrics_list.append(metrics)
 
-                    # Update video state (is_duplicate is always set by DuplicateDetector)
-                    self._video_states[i].update(result.is_duplicate or False)
+                profiler.add_timing("analysis_total", (time.perf_counter() - t0_analysis) * 1000)
+                profiler.mark_timestamp("analysis_end")
+
+                # Build composited output (also computes aggregated metrics)
+                video_snapshots = tuple(s.snapshot() for s in self._video_states)
+                if self._compositor is not None:
+                    # Wait for previous export to finish to protect compositor buffer
+                    if export_future is not None:
+                        export_future.result()
+
+                    t0_comp = time.perf_counter()
+                    output = self._compositor.process(pairs, metrics_list)
+                    profiler.add_timing("compositor_total", (time.perf_counter() - t0_comp) * 1000)
+                    profiler.mark_timestamp("compositor_end")
+                    self._last_output_frame = output.frame.copy()
+
+                    current_profile = getattr(profiler, 'current_frame', None)
+
+                    def _do_export(out, prof):
+                        self._export_output(out)
+                        if prof is not None:
+                            prof.export_end_ts = time.perf_counter()
+
+                    export_future = pool.submit(_do_export, output, current_profile)
+
+                    video_snapshots = self._compositor.snapshot_video_states()
+
+                    # Emit frame for live preview (~30fps throttle)
+                    now = time.monotonic()
+                    if now - self._last_frame_emit_time >= 0.033:
+                        self.frame_ready.emit(self._last_output_frame)
+                        self._last_frame_emit_time = now
 
                 # Release frame pairs to allow buffer reuse
                 for pair in pairs:
@@ -424,20 +546,23 @@ def _processing_loop(self) -> None:
 
                 # Store snapshot
                 if self._buffer is not None:
-                    video_snapshots = tuple(s.snapshot() for s in self._video_states)
                     self._buffer.append(
                         frame_idx=frame_idx,
                         metrics=tuple(metrics_list),
                         video_states=video_snapshots,
                     )
 
-                # Export if configured
-                # TODO: Integrate compositor for video export
-
                 # Update progress
                 self._current_frame = frame_idx
                 self.progress.emit(frame_idx + 1, self._total_frames)
 
+                profiler.end_frame()
+
+            # Wait for last export
+            if export_future is not None:
+                export_future.result()
+            pool.shutdown(wait=True)
+
             # Processing complete
             if not self._stop_event.is_set():
                 self._set_state(EngineState.COMPLETED)
@@ -461,3 +586,6 @@ def _processing_loop(self) -> None:
                     self._csv_exporter.close()
                 except Exception:
                     pass
+
+            from trdrop.profiling import get_profiler
+            get_profiler().end_run()
diff --git a/src/trdrop/engine/protocol.py b/src/trdrop/engine/protocol.py
index 47d71f72..09be3613 100644
--- a/src/trdrop/engine/protocol.py
+++ b/src/trdrop/engine/protocol.py
@@ -68,6 +68,9 @@ class SeekResult:
     fps_histories: tuple[list[float], ...]        # FPS history per video
     frametime_histories: tuple[list[float], ...]  # Frametime history per video
 
+    # Composited frame with overlays (from compositor)
+    composited_frame: np.ndarray | None = None
+
 
 # Callback types for GUI integration
 OnStateChange = Callable[[EngineState], None]
diff --git a/src/trdrop/export/__init__.py b/src/trdrop/export/__init__.py
index dc232d1b..9c23046b 100644
--- a/src/trdrop/export/__init__.py
+++ b/src/trdrop/export/__init__.py
@@ -8,7 +8,7 @@
 from trdrop.export.streaming_csv import StreamingCSVExporter
 from trdrop.export.streaming_video import (
     StreamingVideoExporter,
-    get_best_h264_encoder,
+    get_best_encoder,
     is_hardware_encoder,
 )
 
@@ -18,7 +18,7 @@
     "StreamingVideoExporter",
     "export_csv",
     "export_json",
-    "get_best_h264_encoder",
+    "get_best_encoder",
     "import_json",
     "is_hardware_encoder",
 ]
diff --git a/src/trdrop/export/streaming_video.py b/src/trdrop/export/streaming_video.py
index 308e7ee4..a038c5d9 100644
--- a/src/trdrop/export/streaming_video.py
+++ b/src/trdrop/export/streaming_video.py
@@ -13,7 +13,15 @@
 from trdrop.profiling import get_profiler
 
 # Hardware encoder preference order (fastest/best quality first)
-_HW_ENCODER_PRIORITY = [
+_HW_HEVC_PRIORITY = [
+    "hevc_videotoolbox",  # macOS (Apple Silicon / Intel GPU)
+    "hevc_nvenc",         # NVIDIA (Windows/Linux)
+    "hevc_amf",           # AMD (Windows)
+    "hevc_qsv",           # Intel QuickSync (Windows/Linux)
+    "hevc_vaapi",         # Linux VAAPI
+]
+
+_HW_H264_PRIORITY = [
     "h264_videotoolbox",  # macOS (Apple Silicon / Intel GPU)
     "h264_nvenc",         # NVIDIA (Windows/Linux)
     "h264_amf",           # AMD (Windows)
@@ -21,24 +29,59 @@
     "h264_vaapi",         # Linux VAAPI
 ]
 
-_SOFTWARE_ENCODER = "libx264"
+_HW_ALL = set(_HW_HEVC_PRIORITY + _HW_H264_PRIORITY)
+
+_SOFTWARE_HEVC = "libx265"
+_SOFTWARE_H264 = "libx264"
+
+
+_OPEN_ENCODER_CACHE: dict[str, bool] = {}
+
+
+def _can_open_encoder(name: str) -> bool:
+    """Test if an encoder can actually be constructed and opened on this hardware."""
+    if name in _OPEN_ENCODER_CACHE:
+        return _OPEN_ENCODER_CACHE[name]
 
+    try:
+        codec = av.Codec(name, "w")
+        if not codec:
+            _OPEN_ENCODER_CACHE[name] = False
+            return False
+        ctx = codec.create()
+        # Encoders require valid stream parameters to open successfully
+        ctx.width = 256  # type: ignore[reportAttributeAccessIssue]
+        ctx.height = 256  # type: ignore[reportAttributeAccessIssue]
+        ctx.pix_fmt = "yuv420p"  # type: ignore[reportAttributeAccessIssue]
+        ctx.time_base = Fraction(1, 30)
+        ctx.open()
+        _OPEN_ENCODER_CACHE[name] = True
+        return True
+    except Exception:
+        _OPEN_ENCODER_CACHE[name] = False
+        return False
 
-def get_best_h264_encoder() -> str:
-    """Return best available h264 encoder.
 
-    Tries hardware encoders in order of preference, falls back to libx264.
+def get_best_encoder() -> str:
+    """Return best available encoder, preferring HEVC over H264.
+
+    Tries HEVC hardware → H264 hardware → libx265 → libx264.
     """
     available = set(av.codecs_available)
-    for enc in _HW_ENCODER_PRIORITY:
-        if enc in available:
+    for enc in _HW_HEVC_PRIORITY:
+        if enc in available and _can_open_encoder(enc):
+            return enc
+    for enc in _HW_H264_PRIORITY:
+        if enc in available and _can_open_encoder(enc):
             return enc
-    return _SOFTWARE_ENCODER
+    if _SOFTWARE_HEVC in available and _can_open_encoder(_SOFTWARE_HEVC):
+        return _SOFTWARE_HEVC
+    return _SOFTWARE_H264
 
 
 def is_hardware_encoder(codec: str) -> bool:
     """Check if codec is a hardware encoder."""
-    return codec in _HW_ENCODER_PRIORITY
+    return codec in _HW_ALL
 
 
 class StreamingVideoExporter(StreamingExporter):
@@ -79,7 +122,7 @@ def __init__(
 
         # Resolve "auto" to best available encoder
         if codec == "auto":
-            self._codec = get_best_h264_encoder()
+            self._codec = get_best_encoder()
         else:
             self._codec = codec
 
@@ -114,12 +157,23 @@ def write_frame(self, output: CompositorOutput) -> None:
             stream.height = height
             stream.pix_fmt = self._pix_fmt
 
+            # Mark output as BT.709 SDR so players don't misinterpret tonemapped content
+            stream.codec_context.color_primaries = 1   # BT.709
+            stream.codec_context.color_trc = 1         # BT.709
+            stream.codec_context.colorspace = 1        # BT.709
+
             # Set encoder options (different for HW vs SW encoders)
             if self._is_hw:
                 # Hardware encoders use quality-based settings
                 stream.options = {"q:v": str(self._quality)}  # type: ignore[assignment]
+            elif self._codec == "libx265":
+                stream.options = {  # type: ignore[assignment]
+                    "crf": str(self._crf),
+                    "preset": self._preset,
+                    "x265-params": "log-level=error",
+                }
             else:
-                # Software encoder (libx264) uses CRF and preset
+                # libx264
                 stream.options = {  # type: ignore[assignment]
                     "crf": str(self._crf),
                     "preset": self._preset,
diff --git a/src/trdrop/gui/app.py b/src/trdrop/gui/app.py
index ec96edb9..aaa8465b 100644
--- a/src/trdrop/gui/app.py
+++ b/src/trdrop/gui/app.py
@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import ctypes
 import sys
 
 from PyQt6.QtWidgets import QApplication
@@ -21,6 +22,17 @@ def __init__(self, args: list[str] | None = None) -> None:
         self._app.setApplicationVersion("2.0.0")
         self._app.setOrganizationName("TRDrop")
 
+        # Set AppUserModelID so Windows treats this as a separate app in taskbar
+        if sys.platform == "win32":
+            my_app_id = "TheAutomatic.TRDrop.v2"
+            ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(my_app_id)
+
+        from trdrop.utils.frozen import icon_path
+        _icon = icon_path()
+        if _icon is not None:
+            from PyQt6.QtGui import QIcon
+            self._app.setWindowIcon(QIcon(str(_icon)))
+
         self._window = MainWindow()
 
     def run(self) -> int:
diff --git a/src/trdrop/gui/main_window.py b/src/trdrop/gui/main_window.py
index 018eefe5..eb58cf18 100644
--- a/src/trdrop/gui/main_window.py
+++ b/src/trdrop/gui/main_window.py
@@ -2,11 +2,23 @@
 
 from __future__ import annotations
 
+import time
 from pathlib import Path
 
+import numpy as np
 from PyQt6.QtCore import Qt
-from PyQt6.QtGui import QAction, QDragEnterEvent, QDropEvent, QKeySequence
+from PyQt6.QtGui import (
+    QDragEnterEvent,
+    QDropEvent,
+    QIcon,
+    QImage,
+    QKeySequence,
+    QPixmap,
+    QShortcut,
+)
 from PyQt6.QtWidgets import (
+    QCheckBox,
+    QDoubleSpinBox,
     QFileDialog,
     QFrame,
     QHBoxLayout,
@@ -15,12 +27,113 @@
     QMessageBox,
     QPushButton,
     QSpinBox,
+    QStackedWidget,
     QVBoxLayout,
     QWidget,
 )
 
+from trdrop.config import PresetConfig, load_preset, save_preset
 from trdrop.engine import EngineState, InteractiveEngine
 from trdrop.gui.widgets.state_indicator import StateIndicator
+from trdrop.profiling.profiler import reset_profiler
+
+FLUENT_STYLE = """
+QMainWindow {
+    background-color: #f3f3f3;
+}
+QFrame#sidebar, QFrame#bottom_bar {
+    background-color: #f8f8f8;
+    border-radius: 8px;
+    border: 1px solid #e0e0e0;
+}
+QLabel {
+    color: #1c1c1c;
+    font-size: 13px;
+    font-family: "-apple-system", "BlinkMacSystemFont", "Segoe UI Variable Text", "Segoe UI",
+                 "PingFang SC", "Microsoft YaHei UI", "Microsoft YaHei",
+                 "Source Han Sans SC", "Noto Sans SC", sans-serif;
+}
+QPushButton {
+    background-color: #ffffff;
+    border: 1px solid #d1d1d1;
+    border-radius: 6px;
+    padding: 6px 14px;
+    color: #1c1c1c;
+    font-size: 13px;
+    font-family: "-apple-system", "BlinkMacSystemFont", "Segoe UI Variable Text", "Segoe UI",
+                 "PingFang SC", "Microsoft YaHei UI", "Microsoft YaHei",
+                 "Source Han Sans SC", "Noto Sans SC", sans-serif;
+}
+QPushButton:hover {
+    background-color: #f5f5f5;
+}
+QPushButton:pressed {
+    background-color: #ebebeb;
+    color: #666666;
+}
+QPushButton:disabled {
+    background-color: #f9f9f9;
+    color: #a0a0a0;
+    border: 1px solid #e0e0e0;
+}
+QPushButton#primary_btn {
+    background-color: #0060df;
+    color: white;
+    border: 1px solid #0050ba;
+    font-weight: bold;
+}
+QPushButton#primary_btn:hover {
+    background-color: #0050ba;
+}
+QPushButton#primary_btn:pressed {
+    background-color: #004095;
+    color: #e0e0e0;
+}
+QPushButton#primary_btn:disabled {
+    background-color: #8cb6f5;
+    border: 1px solid #8cb6f5;
+    color: #ffffff;
+}
+QSpinBox, QDoubleSpinBox, QLineEdit {
+    font-family: "-apple-system", "BlinkMacSystemFont", "Segoe UI Variable Text", "Segoe UI",
+                 "PingFang SC", "Microsoft YaHei UI", "Microsoft YaHei",
+                 "Source Han Sans SC", "Noto Sans SC", sans-serif;
+    min-height: 24px;
+    background-color: #ffffff;
+    color: #1c1c1c;
+    border: 1px solid #d1d1d1;
+    border-radius: 4px;
+    padding: 2px 4px;
+}
+QSpinBox::up-button, QDoubleSpinBox::up-button {
+    subcontrol-origin: border;
+    subcontrol-position: top right;
+    width: 20px;
+}
+QSpinBox::down-button, QDoubleSpinBox::down-button {
+    subcontrol-origin: border;
+    subcontrol-position: bottom right;
+    width: 20px;
+}
+QPushButton#profile_label {
+    background-color: transparent;
+    border: none;
+    padding: 0px;
+    text-align: left;
+    color: #1c1c1c;
+}
+QPushButton#profile_label:hover {
+    background-color: transparent;
+}
+QPushButton#profile_label:pressed {
+    background-color: transparent;
+    color: #666666;
+}
+QPushButton#profile_label:disabled {
+    background-color: transparent;
+    color: #a0a0a0;
+}
+"""
 
 
 class MainWindow(QMainWindow):
@@ -28,195 +141,491 @@ class MainWindow(QMainWindow):
 
     def __init__(self) -> None:
         super().__init__()
+        self._lang = "en"
+        self._ignore_frames = False
 
         # Engine
         self._engine = InteractiveEngine(self)
+
+        # Icon
+        from trdrop.utils.frozen import icon_path
+        _icon = icon_path()
+        if _icon is not None:
+            self.setWindowIcon(QIcon(str(_icon)))
+
         self._engine.state_changed.connect(self._on_state_changed)
         self._engine.progress.connect(self._on_progress)
         self._engine.error.connect(self._on_error)
+        self._engine.frame_ready.connect(self._on_frame_ready)
 
         # Video paths (before loading into engine)
         self._pending_videos: list[Path] = []
 
+        # Optional export paths
+        self._output_csv_path: Path | None = None
+        self._output_video_path: Path | None = None
+        self._processing_start_time: float | None = None
+        self._preset_config: PresetConfig = PresetConfig()
+
         self._setup_ui()
-        self._setup_menu()
+        self._setup_shortcuts()
         self._update_controls()
+        self._retranslate_ui()
 
         self.setAcceptDrops(True)
 
+    # ================================================================
+    # UI Setup
+    # ================================================================
+
     def _setup_ui(self) -> None:
         """Setup the main UI layout."""
-        self.setWindowTitle("TRDrop v2")
-        self.setMinimumSize(600, 400)
-        self.resize(800, 500)
+        self.setWindowTitle("TRDrop v2.1.0-beta.4")
+        self.setMinimumSize(850, 600)
+        self.resize(1100, 750)
+        self.setStyleSheet(FLUENT_STYLE)
+
+        # Hide the default empty menu bar
+        mb = self.menuBar()
+        if mb is not None:
+            mb.setVisible(False)
 
         # Central widget
         central = QWidget()
         self.setCentralWidget(central)
-        layout = QVBoxLayout(central)
-        layout.setSpacing(0)
-        layout.setContentsMargins(0, 0, 0, 0)
-
-        # Control bar (below menu)
-        self._control_bar = self._create_control_bar()
-        layout.addWidget(self._control_bar)
-
-        # Separator line
-        separator = QFrame()
-        separator.setFrameShape(QFrame.Shape.HLine)
-        separator.setFrameShadow(QFrame.Shadow.Sunken)
-        layout.addWidget(separator)
-
-        # Main content area
-        content = QWidget()
-        content_layout = QVBoxLayout(content)
-        content_layout.setContentsMargins(16, 16, 16, 16)
-
-        # Video list display
+        main_layout = QHBoxLayout(central)
+        main_layout.setSpacing(20)
+        main_layout.setContentsMargins(16, 16, 16, 16)
+
+        # 1. Left Sidebar
+        self._sidebar = self._create_sidebar()
+        main_layout.addWidget(self._sidebar)
+
+        # 2. Right Content Area (Status + Preview + Bottom Control Bar)
+        right_container = QWidget()
+        right_layout = QVBoxLayout(right_container)
+        right_layout.setSpacing(10)
+        right_layout.setContentsMargins(0, 0, 0, 0)
+
+        # Top Status Row
+        status_row = QHBoxLayout()
+        status_row.setContentsMargins(4, 8, 4, 4)
+        self._state_indicator = StateIndicator()
+        self._state_indicator.set_translator(self._t)
+        status_row.addWidget(self._state_indicator)
+
+        status_row.addStretch()
+
+        self._progress_label = QLabel("")
+        self._progress_label.setStyleSheet("font-size: 13px; color: #555; font-weight: 500;")
+        status_row.addWidget(self._progress_label)
+        right_layout.addLayout(status_row)
+
+        # Stacked widget: page 0 = text placeholder, page 1 = preview
+        self._content_stack = QStackedWidget()
+        self._content_stack.setStyleSheet(
+            "background-color: #000000; border-radius: 8px;"
+        )
+
+        # Page 0: Video list text
         self._video_list_label = QLabel(
             "No videos loaded.\nDrag and drop video files or use + to add."
         )
         self._video_list_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
-        self._video_list_label.setStyleSheet("color: #888; font-size: 14px;")
-        content_layout.addWidget(self._video_list_label, stretch=1)
+        self._video_list_label.setStyleSheet(
+            "font-size: 15px; color: #666666; "
+            "background-color: #ffffff; border-radius: 8px;"
+        )
+        self._content_stack.addWidget(self._video_list_label)
 
-        # Progress display
-        self._progress_label = QLabel("")
-        self._progress_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
-        self._progress_label.setStyleSheet("font-size: 13px;")
-        content_layout.addWidget(self._progress_label)
+        # Page 1: Preview display
+        self._preview_label = QLabel()
+        self._preview_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        self._preview_label.setStyleSheet(
+            "background-color: #000000; border-radius: 8px;"
+        )
+        self._preview_label.setMinimumSize(480, 270)
+        self._content_stack.addWidget(self._preview_label)
 
-        layout.addWidget(content, stretch=1)
+        right_layout.addWidget(self._content_stack, stretch=1)
 
-    def _create_control_bar(self) -> QWidget:
-        """Create the control bar with state, video controls, and seek."""
-        bar = QWidget()
-        bar.setStyleSheet("background-color: #f5f5f5;")
-        layout = QHBoxLayout(bar)
-        layout.setContentsMargins(8, 6, 8, 6)
-        layout.setSpacing(12)
+        # Bottom Control Bar
+        self._bottom_bar = self._create_bottom_bar()
+        right_layout.addWidget(self._bottom_bar)
 
-        # State indicator
-        self._state_indicator = StateIndicator()
-        layout.addWidget(self._state_indicator)
+        main_layout.addWidget(right_container, stretch=1)
 
-        # Separator
-        layout.addWidget(self._create_separator())
+    def _create_sidebar(self) -> QFrame:
+        """Create the left sidebar with video input and settings."""
+        sidebar = QFrame()
+        sidebar.setObjectName("sidebar")
+        sidebar.setFixedWidth(280)
 
-        # Video controls
-        video_label = QLabel("Videos:")
-        video_label.setStyleSheet("font-size: 12px; color: #666;")
-        layout.addWidget(video_label)
+        layout = QVBoxLayout(sidebar)
+        layout.setContentsMargins(16, 20, 16, 20)
+        layout.setSpacing(20)
 
-        self._add_btn = QPushButton("+")
-        self._add_btn.setFixedSize(28, 28)
+        # --- Section: Videos ---
+        video_sec = QVBoxLayout()
+        video_sec.setSpacing(10)
+        self._v_title = QLabel("Input Videos")
+        self._v_title.setStyleSheet("font-weight: bold; font-size: 14px;")
+        video_sec.addWidget(self._v_title)
+
+        btn_layout = QHBoxLayout()
+        self._add_btn = QPushButton("+ Add Video")
         self._add_btn.setToolTip("Add video")
         self._add_btn.clicked.connect(self._on_add_video)
-        layout.addWidget(self._add_btn)
+        btn_layout.addWidget(self._add_btn)
 
-        self._remove_btn = QPushButton("-")
-        self._remove_btn.setFixedSize(28, 28)
+        self._remove_btn = QPushButton("- Remove")
         self._remove_btn.setToolTip("Remove last video")
         self._remove_btn.clicked.connect(self._on_remove_video)
-        layout.addWidget(self._remove_btn)
+        btn_layout.addWidget(self._remove_btn)
+        video_sec.addLayout(btn_layout)
+
+        layout.addLayout(video_sec)
+        layout.addWidget(self._create_separator(horizontal=True))
+
+        # --- Section: Parameters ---
+        param_sec = QVBoxLayout()
+        param_sec.setSpacing(10)
+        self._p_title = QLabel("Parameters")
+        self._p_title.setStyleSheet("font-weight: bold; font-size: 14px;")
+        param_sec.addWidget(self._p_title)
+
+        thresh_layout = QHBoxLayout()
+        self._thresh_label = QLabel("Duplicate Threshold:")
+        thresh_layout.addWidget(self._thresh_label)
+        self._thresh_spinbox = QDoubleSpinBox()
+        self._thresh_spinbox.setRange(0.001, 0.100)
+        self._thresh_spinbox.setSingleStep(0.005)
+        self._thresh_spinbox.setDecimals(3)
+        self._thresh_spinbox.setValue(
+            self._preset_config.processing.duplicate_threshold
+        )
+        self._thresh_spinbox.setToolTip(
+            "Duplicate Threshold (e.g. 0.02 = 2% pixels changed)"
+        )
+        self._thresh_spinbox.valueChanged.connect(self._on_thresh_changed)
+        thresh_layout.addWidget(self._thresh_spinbox)
+        param_sec.addLayout(thresh_layout)
+
+        cb_layout = QHBoxLayout()
+        cb_layout.setContentsMargins(0, 0, 0, 0)
+        cb_layout.setSpacing(6)
+
+        self._profile_cb = QCheckBox()
+        self._profile_cb.setChecked(True)
+        self._profile_cb.setToolTip(
+            "Generate profiling CSV and summary on completion"
+        )
 
-        self._video_count_label = QLabel("0")
-        self._video_count_label.setStyleSheet("font-weight: bold; min-width: 20px;")
-        layout.addWidget(self._video_count_label)
+        self._profile_label = QPushButton("Generate Profile")
+        self._profile_label.setObjectName("profile_label")
+        self._profile_label.setToolTip(
+            "Generate profiling CSV and summary on completion"
+        )
+        self._profile_label.setCursor(Qt.CursorShape.PointingHandCursor)
+        self._profile_label.clicked.connect(self._profile_cb.toggle)
 
-        # Separator
-        layout.addWidget(self._create_separator())
+        cb_layout.addWidget(self._profile_cb)
+        cb_layout.addWidget(self._profile_label)
+        cb_layout.addStretch()
 
-        # Processing controls
-        self._start_btn = QPushButton("Start")
+        param_sec.addLayout(cb_layout)
+
+        frametime_layout = QHBoxLayout()
+        frametime_layout.setContentsMargins(0, 0, 0, 0)
+        frametime_layout.setSpacing(6)
+
+        self._frametime_cb = QCheckBox()
+        self._frametime_cb.setChecked(
+            self._preset_config.rendering.frametime_plot.visible
+        )
+        self._frametime_cb.setToolTip(
+            "Show frametime plot overlay in preview/exported video"
+        )
+        self._frametime_cb.toggled.connect(self._on_frametime_toggled)
+
+        self._frametime_label = QPushButton("Generate Frametime")
+        self._frametime_label.setObjectName("profile_label")
+        self._frametime_label.setToolTip(
+            "Show frametime plot overlay in preview/exported video"
+        )
+        self._frametime_label.setCursor(Qt.CursorShape.PointingHandCursor)
+        self._frametime_label.clicked.connect(self._frametime_cb.toggle)
+
+        frametime_layout.addWidget(self._frametime_cb)
+        frametime_layout.addWidget(self._frametime_label)
+        frametime_layout.addStretch()
+
+        param_sec.addLayout(frametime_layout)
+
+        layout.addLayout(param_sec)
+        layout.addWidget(self._create_separator(horizontal=True))
+
+        # --- Section: Exports & Config ---
+        export_sec = QVBoxLayout()
+        export_sec.setSpacing(10)
+        self._e_title = QLabel("Exports & Config")
+        self._e_title.setStyleSheet("font-weight: bold; font-size: 14px;")
+        export_sec.addWidget(self._e_title)
+
+        self._csv_btn = QPushButton("📄 Select CSV Output")
+        self._csv_btn.setToolTip("Choose CSV export path")
+        self._csv_btn.clicked.connect(self._on_pick_csv)
+        export_sec.addWidget(self._csv_btn)
+
+        self._video_btn = QPushButton("🎥 Select Video Output")
+        self._video_btn.setToolTip("Choose video export path")
+        self._video_btn.clicked.connect(self._on_pick_video_export)
+        export_sec.addWidget(self._video_btn)
+
+        self._config_btn = QPushButton("⚙️ Preset Config (.yaml)")
+        self._config_btn.setToolTip("Load or save overlay preset (YAML)")
+        self._config_btn.clicked.connect(self._on_config)
+        export_sec.addWidget(self._config_btn)
+
+        layout.addLayout(export_sec)
+
+        layout.addStretch()
+
+        # Bottom row: About + Language toggle
+        bottom_row = QHBoxLayout()
+        bottom_row.setSpacing(8)
+
+        self._about_btn = QPushButton("ℹ️ About TRDrop")
+        self._about_btn.setStyleSheet(
+            "background-color: transparent; border: none; "
+            "color: #888888; font-size: 12px; text-align: left;"
+        )
+        self._about_btn.setCursor(Qt.CursorShape.PointingHandCursor)
+        self._about_btn.clicked.connect(self._on_about)
+        bottom_row.addWidget(self._about_btn)
+
+        bottom_row.addStretch()
+
+        self._lang_btn = QPushButton("🌐")
+        self._lang_btn.setFixedSize(32, 32)
+        self._lang_btn.setStyleSheet(
+            "background-color: transparent; border: none; "
+            "font-size: 18px; padding: 0px;"
+        )
+        self._lang_btn.setCursor(Qt.CursorShape.PointingHandCursor)
+        self._lang_btn.setToolTip("Switch language / 切换语言")
+        self._lang_btn.clicked.connect(self._toggle_language)
+        bottom_row.addWidget(self._lang_btn)
+
+        layout.addLayout(bottom_row)
+
+        return sidebar
+
+    def _create_bottom_bar(self) -> QFrame:
+        """Create the bottom bar with execution controls."""
+        bar = QFrame()
+        bar.setObjectName("bottom_bar")
+        bar.setFixedHeight(80)
+
+        layout = QHBoxLayout(bar)
+        layout.setContentsMargins(20, 10, 20, 10)
+        layout.setSpacing(24)
+
+        # Center: Playback controls
+        center_layout = QHBoxLayout()
+        center_layout.setSpacing(16)
+        center_layout.setAlignment(Qt.AlignmentFlag.AlignCenter)
+
+        self._start_btn = QPushButton("▶ Start")
+        self._start_btn.setObjectName("primary_btn")
+        self._start_btn.setFixedHeight(42)
+        self._start_btn.setFixedWidth(110)
         self._start_btn.setToolTip("Start processing")
         self._start_btn.clicked.connect(self._on_start)
-        layout.addWidget(self._start_btn)
+        center_layout.addWidget(self._start_btn)
 
-        self._pause_btn = QPushButton("Pause")
+        self._pause_btn = QPushButton("⏸ Pause")
+        self._pause_btn.setFixedHeight(42)
+        self._pause_btn.setFixedWidth(110)
         self._pause_btn.setToolTip("Pause processing")
         self._pause_btn.clicked.connect(self._on_pause)
-        layout.addWidget(self._pause_btn)
+        center_layout.addWidget(self._pause_btn)
 
-        self._reset_btn = QPushButton("Reset")
+        self._reset_btn = QPushButton("⏹ Reset")
+        self._reset_btn.setFixedHeight(42)
+        self._reset_btn.setFixedWidth(110)
         self._reset_btn.setToolTip("Reset engine")
         self._reset_btn.clicked.connect(self._on_reset)
-        layout.addWidget(self._reset_btn)
+        center_layout.addWidget(self._reset_btn)
 
-        # Separator
-        layout.addWidget(self._create_separator())
+        layout.addStretch(1)
+        layout.addLayout(center_layout)
+        layout.addStretch(1)
 
-        # Seek controls
-        seek_label = QLabel("Seek:")
-        seek_label.setStyleSheet("font-size: 12px; color: #666;")
-        layout.addWidget(seek_label)
+        # Right: Seek controls
+        right_layout = QHBoxLayout()
+        right_layout.setSpacing(8)
+        right_layout.setAlignment(
+            Qt.AlignmentFlag.AlignRight | Qt.AlignmentFlag.AlignVCenter
+        )
+
+        self._seek_label_title = QLabel("Seek Frame:")
+        right_layout.addWidget(self._seek_label_title)
 
         self._seek_spinbox = QSpinBox()
         self._seek_spinbox.setMinimum(0)
         self._seek_spinbox.setMaximum(0)
         self._seek_spinbox.setFixedWidth(80)
-        layout.addWidget(self._seek_spinbox)
+        right_layout.addWidget(self._seek_spinbox)
 
-        self._seek_btn = QPushButton("Seek")
+        self._seek_btn = QPushButton("Go")
+        self._seek_btn.setFixedWidth(60)
         self._seek_btn.setToolTip("Seek to frame")
         self._seek_btn.clicked.connect(self._on_seek)
-        layout.addWidget(self._seek_btn)
+        right_layout.addWidget(self._seek_btn)
 
-        layout.addStretch()
+        layout.addLayout(right_layout, stretch=1)
 
         return bar
 
-    def _create_separator(self) -> QFrame:
-        """Create a vertical separator line."""
+    def _create_separator(self, horizontal: bool = False) -> QFrame:
+        """Create a separator line."""
         sep = QFrame()
-        sep.setFrameShape(QFrame.Shape.VLine)
-        sep.setFrameShadow(QFrame.Shadow.Sunken)
+        if horizontal:
+            sep.setFrameShape(QFrame.Shape.HLine)
+            sep.setFixedHeight(1)
+            sep.setStyleSheet("background-color: #d1d1d1; border: none;")
+        else:
+            sep.setFrameShape(QFrame.Shape.VLine)
+            sep.setFixedWidth(1)
+            sep.setStyleSheet("background-color: #d1d1d1; border: none;")
         return sep
 
-    def _setup_menu(self) -> None:
-        """Setup menu bar."""
-        menubar = self.menuBar()
-        assert menubar is not None
+    def _setup_shortcuts(self) -> None:
+        """Setup keyboard shortcuts (replacing removed menu bar)."""
+        sc_open = QShortcut(QKeySequence.StandardKey.Open, self)
+        sc_open.activated.connect(self._on_add_video)
 
-        # File menu
-        file_menu = menubar.addMenu("&File")
-        assert file_menu is not None
+        sc_quit = QShortcut(QKeySequence.StandardKey.Quit, self)
+        sc_quit.activated.connect(self.close)
 
-        open_action = QAction("&Add Video...", self)
-        open_action.setShortcut(QKeySequence.StandardKey.Open)
-        open_action.triggered.connect(self._on_add_video)
-        file_menu.addAction(open_action)
+    # ================================================================
+    # Localization
+    # ================================================================
 
-        file_menu.addSeparator()
+    def _t(self, en_text: str, zh_text: str) -> str:
+        """Return text based on current language."""
+        return zh_text if self._lang == "zh" else en_text
 
-        quit_action = QAction("&Quit", self)
-        quit_action.setShortcut(QKeySequence.StandardKey.Quit)
-        quit_action.triggered.connect(self.close)
-        file_menu.addAction(quit_action)
+    def _toggle_language(self) -> None:
+        """Toggle between English and Chinese."""
+        self._lang = "zh" if self._lang == "en" else "en"
+        self._retranslate_ui()
 
-        # Help menu
-        help_menu = menubar.addMenu("&Help")
-        assert help_menu is not None
+    def _retranslate_ui(self) -> None:
+        """Update all translatable text based on current language."""
+        if not self._pending_videos:
+            self._video_list_label.setText(
+                self._t(
+                    "No videos loaded.\nDrag and drop video files or use + to add.",
+                    "尚未加载视频。\n拖入视频文件或点击 + 添加。",
+                )
+            )
 
-        about_action = QAction("&About", self)
-        about_action.triggered.connect(self._on_about)
-        help_menu.addAction(about_action)
+        self._v_title.setText(self._t("Input Videos", "视频源"))
+        self._add_btn.setText(self._t("+ Add Video", "+ 添加视频"))
+        self._add_btn.setToolTip(self._t("Add video", "添加视频文件"))
+        self._remove_btn.setText(self._t("- Remove", "- 移除视频"))
+        self._remove_btn.setToolTip(
+            self._t("Remove last video", "移除最后一个视频")
+        )
+        self._p_title.setText(self._t("Parameters", "分析参数"))
+        # lang_btn is icon-only, no text to update
+        self._thresh_label.setText(
+            self._t("Duplicate Threshold:", "重复帧阈值:")
+        )
+        self._profile_label.setText(
+            self._t("Generate Profile", "生成性能报告")
+        )
+        self._frametime_label.setText(
+            self._t("Generate Frametime", "生成 Frametime 图")
+        )
+        self._e_title.setText(
+            self._t("Exports & Config", "导出与预设")
+        )
+        self._about_btn.setText(
+            self._t("ℹ️ About TRDrop", "ℹ️ 关于 TRDrop")
+        )
+
+        if self._output_csv_path:
+            n = self._output_csv_path.name
+            self._csv_btn.setText(
+                self._t(f"📄 CSV✓ ({n})", f"📄 CSV已选 ({n})")
+            )
+        else:
+            self._csv_btn.setText(
+                self._t("📄 Select CSV Output", "📄 选择 CSV 导出路径")
+            )
+
+        if self._output_video_path:
+            n = self._output_video_path.name
+            self._video_btn.setText(
+                self._t(f"🎥 Video✓ ({n})", f"🎥 视频已选 ({n})")
+            )
+        else:
+            self._video_btn.setText(
+                self._t("🎥 Select Video Output", "🎥 选择视频导出路径")
+            )
+
+        self._config_btn.setText(
+            self._t("⚙️ Preset Config (.yaml)", "⚙️ 预设配置 (.yaml)")
+        )
+
+        self._start_btn.setText(self._t("▶ Start", "▶ 开始"))
+        state = self._engine.state
+        if state == EngineState.PAUSED:
+            self._pause_btn.setText(self._t("▶ Resume", "▶ 继续"))
+        else:
+            self._pause_btn.setText(self._t("⏸ Pause", "⏸ 暂停"))
+        self._reset_btn.setText(self._t("⏹ Reset", "⏹ 重置"))
+
+        self._seek_label_title.setText(
+            self._t("Seek Frame:", "跳转到帧:")
+        )
+        self._seek_btn.setText(self._t("Go", "跳转"))
+
+        self._state_indicator.retranslate()
+        self._update_video_list()
+
+    # ================================================================
+    # State Management
+    # ================================================================
 
     def _update_controls(self) -> None:
         """Update control states based on engine state."""
         state = self._engine.state
         video_count = len(self._pending_videos)
 
-        # Video controls
-        can_modify_videos = state == EngineState.IDLE
+        # Video/export controls
+        can_modify_videos = state in (EngineState.IDLE, EngineState.READY)
         self._add_btn.setEnabled(can_modify_videos and video_count < 4)
         self._remove_btn.setEnabled(can_modify_videos and video_count > 0)
-        self._video_count_label.setText(str(video_count))
+        self._csv_btn.setEnabled(can_modify_videos)
+        self._video_btn.setEnabled(can_modify_videos)
+        self._config_btn.setEnabled(can_modify_videos)
+        self._profile_cb.setEnabled(can_modify_videos)
+        self._profile_label.setEnabled(can_modify_videos)
+        self._frametime_cb.setEnabled(can_modify_videos)
+        self._frametime_label.setEnabled(can_modify_videos)
 
         # Processing controls
         self._start_btn.setEnabled(state == EngineState.READY)
         self._pause_btn.setEnabled(state == EngineState.PROCESSING)
-        self._pause_btn.setText("Resume" if state == EngineState.PAUSED else "Pause")
+        self._pause_btn.setText(
+            self._t("▶ Resume", "▶ 继续")
+            if state == EngineState.PAUSED
+            else self._t("⏸ Pause", "⏸ 暂停")
+        )
         if state == EngineState.PAUSED:
             self._pause_btn.setEnabled(True)
         self._reset_btn.setEnabled(state != EngineState.IDLE)
@@ -226,7 +635,9 @@ def _update_controls(self) -> None:
         self._seek_spinbox.setEnabled(can_seek)
         self._seek_btn.setEnabled(can_seek)
         if can_seek:
-            self._seek_spinbox.setMaximum(max(0, self._engine.processed_frames - 1))
+            self._seek_spinbox.setMaximum(
+                max(0, self._engine.processed_frames - 1)
+            )
 
         # Update video list display
         self._update_video_list()
@@ -235,30 +646,59 @@ def _update_video_list(self) -> None:
         """Update the video list display."""
         if not self._pending_videos:
             self._video_list_label.setText(
-                "No videos loaded.\nDrag and drop video files or use + to add."
+                self._t(
+                    "No videos loaded.\nDrag and drop video files or use + to add.",
+                    "尚未加载视频。\n拖入视频文件或点击 + 添加。",
+                )
             )
-            self._video_list_label.setStyleSheet("color: #888; font-size: 14px;")
+            self._video_list_label.setEnabled(False)
         else:
-            lines = ["Loaded videos:"]
+            lines = [self._t("Loaded videos:", "已加载:")]
             for i, path in enumerate(self._pending_videos, 1):
                 lines.append(f"  {i}. {path.name}")
             self._video_list_label.setText("\n".join(lines))
-            self._video_list_label.setStyleSheet("color: #333; font-size: 13px;")
+            self._video_list_label.setEnabled(True)
 
-    # === Event Handlers ===
+    # ================================================================
+    # Event Handlers
+    # ================================================================
 
     def _on_state_changed(self, state: EngineState) -> None:
         """Handle engine state change."""
         self._state_indicator.set_state(state)
         self._update_controls()
+        # Switch to text view when idle
+        if state == EngineState.IDLE:
+            self._content_stack.setCurrentIndex(0)
 
     def _on_progress(self, current: int, total: int) -> None:
         """Handle processing progress update."""
         pct = (current / total * 100) if total > 0 else 0
-        self._progress_label.setText(f"Processing: {current}/{total} frames ({pct:.1f}%)")
+        # Calculate ETA
+        eta_text = ""
+        if self._processing_start_time is not None and current > 0:
+            elapsed = time.time() - self._processing_start_time
+            rate = current / elapsed  # frames per second
+            remaining = (total - current) / rate if rate > 0 else 0
+            if remaining < 60:
+                eta_text = f" | ETA: {remaining:.0f}s"
+            elif remaining < 3600:
+                eta_text = f" | ETA: {remaining / 60:.1f}min"
+            else:
+                eta_text = f" | ETA: {remaining / 3600:.1f}h"
+            eta_text += f" ({rate:.0f} fps)"
+        self._progress_label.setText(
+            self._t(
+                f"Processing: {current}/{total} ({pct:.1f}%){eta_text}",
+                f"处理进度: {current}/{total} ({pct:.1f}%){eta_text}",
+            )
+        )
         self._state_indicator.set_state(
             EngineState.PROCESSING,
-            f"Processing {current}/{total}"
+            self._t(
+                f"Processing {current}/{total}",
+                f"处理中 {current}/{total}",
+            ),
         )
 
     def _on_error(self, message: str) -> None:
@@ -266,25 +706,57 @@ def _on_error(self, message: str) -> None:
         QMessageBox.critical(self, "Processing Error", message)
         self._state_indicator.set_state(EngineState.ERROR, message)
 
+    def _on_frame_ready(self, frame: object) -> None:
+        """Handle live preview frame from processing thread."""
+        if self._ignore_frames:
+            return
+        if not isinstance(frame, np.ndarray):
+            return
+        self._show_frame(frame)
+
+    def _show_frame(self, frame: np.ndarray) -> None:
+        """Display a composited frame in the preview area."""
+        h, w = frame.shape[:2]
+        bytes_per_line = 3 * w
+        image = QImage(
+            frame.tobytes(), w, h, bytes_per_line,
+            QImage.Format.Format_RGB888,
+        )
+        pixmap = QPixmap.fromImage(image)
+        # Scale to fit preview label while preserving aspect ratio
+        label_size = self._preview_label.size()
+        scaled = pixmap.scaled(
+            label_size, Qt.AspectRatioMode.KeepAspectRatio,
+            Qt.TransformationMode.SmoothTransformation,
+        )
+        self._preview_label.setPixmap(scaled)
+        self._content_stack.setCurrentIndex(1)
+
     def _on_add_video(self) -> None:
-        """Add a video file."""
+        """Add video file(s)."""
         if len(self._pending_videos) >= 4:
-            QMessageBox.warning(self, "Limit Reached", "Maximum 4 videos supported.")
+            QMessageBox.warning(
+                self, "Limit Reached", "Maximum 4 videos supported."
+            )
             return
 
-        path, _ = QFileDialog.getOpenFileName(
+        paths, _ = QFileDialog.getOpenFileNames(
             self,
-            "Add Video",
+            "Add Video(s)",
             "",
             "Video Files (*.mp4 *.mkv *.avi *.mov *.webm);;All Files (*)",
         )
-        if path:
+        for path in paths:
+            if len(self._pending_videos) >= 4:
+                break
             self._add_video(Path(path))
 
     def _add_video(self, path: Path) -> None:
         """Add a video to the pending list."""
         if not path.exists():
-            QMessageBox.warning(self, "File Not Found", f"File not found: {path}")
+            QMessageBox.warning(
+                self, "File Not Found", f"File not found: {path}"
+            )
             return
 
         if len(self._pending_videos) >= 4:
@@ -293,14 +765,22 @@ def _add_video(self, path: Path) -> None:
         self._pending_videos.append(path)
         self._update_controls()
 
-        # If we have videos and engine is IDLE, load them
-        if self._engine.state == EngineState.IDLE and self._pending_videos:
+        # Load/reload engine with current video list
+        if self._pending_videos:
+            if self._engine.state != EngineState.IDLE:
+                self._engine.reset()
             self._load_videos()
 
     def _on_remove_video(self) -> None:
         """Remove the last video."""
-        if self._pending_videos and self._engine.state == EngineState.IDLE:
+        if self._pending_videos and self._engine.state in (
+            EngineState.IDLE, EngineState.READY
+        ):
             self._pending_videos.pop()
+
+            if self._engine.state != EngineState.IDLE:
+                self._engine.reset()
+
             self._update_controls()
 
             # Reload if we still have videos
@@ -313,19 +793,155 @@ def _load_videos(self) -> None:
             return
 
         try:
-            result = self._engine.load(list(self._pending_videos))
+            result = self._engine.load(
+                list(self._pending_videos),
+                output_video=self._output_video_path,
+                output_csv=self._output_csv_path,
+                config=self._preset_config,
+            )
             self._seek_spinbox.setMaximum(result.total_frames - 1)
             self._progress_label.setText(
-                f"Loaded {result.video_count} video(s), {result.total_frames} frames"
+                self._t(
+                    f"Loaded {result.video_count} video(s), "
+                    f"{result.total_frames} frames",
+                    f"成功加载 {result.video_count} 个视频, "
+                    f"共 {result.total_frames} 帧",
+                )
             )
         except Exception as e:
             QMessageBox.critical(self, "Load Error", str(e))
             self._pending_videos.clear()
             self._update_controls()
 
+    def _on_pick_csv(self) -> None:
+        """Pick CSV export path (optional)."""
+        path, _ = QFileDialog.getSaveFileName(
+            self,
+            "Choose CSV Export Path",
+            "trdrop_metrics.csv",
+            "CSV Files (*.csv)",
+        )
+        if path:
+            p = Path(path)
+            if p.suffix.lower() != ".csv":
+                p = p.with_suffix(".csv")
+            self._output_csv_path = p
+            self._retranslate_ui()
+            self._csv_btn.setToolTip(str(p))
+            # Reload engine if videos already loaded
+            if self._pending_videos and self._engine.state != EngineState.IDLE:
+                self._engine.reset()
+                self._load_videos()
+
+    def _on_pick_video_export(self) -> None:
+        """Pick video export path (optional)."""
+        path, _ = QFileDialog.getSaveFileName(
+            self,
+            "Choose Video Export Path",
+            "trdrop_output.mp4",
+            "Video Files (*.mp4)",
+        )
+        if path:
+            p = Path(path)
+            if p.suffix.lower() != ".mp4":
+                p = p.with_suffix(".mp4")
+            self._output_video_path = p
+            self._retranslate_ui()
+            self._video_btn.setToolTip(str(p))
+            # Reload engine if videos already loaded
+            if self._pending_videos and self._engine.state != EngineState.IDLE:
+                self._engine.reset()
+                self._load_videos()
+
+    def _on_config(self) -> None:
+        """Load or save overlay config preset."""
+        choice = QMessageBox.question(
+            self,
+            "Config Preset",
+            "Load an existing preset?\n\n"
+            "Yes = Load YAML preset\n"
+            "No = Save default preset as template",
+            QMessageBox.StandardButton.Yes
+            | QMessageBox.StandardButton.No
+            | QMessageBox.StandardButton.Cancel,
+        )
+        if choice == QMessageBox.StandardButton.Yes:
+            path, _ = QFileDialog.getOpenFileName(
+                self, "Load Config Preset", "",
+                "YAML Files (*.yaml *.yml)",
+            )
+            if path:
+                try:
+                    self._preset_config = load_preset(path)
+                    self._thresh_spinbox.blockSignals(True)
+                    self._thresh_spinbox.setValue(
+                        self._preset_config.processing.duplicate_threshold
+                    )
+                    self._thresh_spinbox.blockSignals(False)
+                    self._frametime_cb.blockSignals(True)
+                    self._frametime_cb.setChecked(
+                        self._preset_config.rendering.frametime_plot.visible
+                    )
+                    self._frametime_cb.blockSignals(False)
+                    self._engine.set_duplicate_threshold(
+                        self._preset_config.processing.duplicate_threshold
+                    )
+                    self._retranslate_ui()
+                    self._config_btn.setToolTip(str(path))
+                    # Reload engine if videos already loaded
+                    if (
+                        self._pending_videos
+                        and self._engine.state != EngineState.IDLE
+                    ):
+                        self._engine.reset()
+                        self._load_videos()
+                except Exception as e:
+                    QMessageBox.critical(self, "Config Error", str(e))
+        elif choice == QMessageBox.StandardButton.No:
+            path, _ = QFileDialog.getSaveFileName(
+                self,
+                "Save Default Config",
+                "trdrop_preset.yaml",
+                "YAML Files (*.yaml)",
+            )
+            if path:
+                try:
+                    save_preset(self._preset_config, path)
+                    QMessageBox.information(
+                        self,
+                        "Config Saved",
+                        f"Default preset saved to:\n{path}\n\n"
+                        "Edit this file to customize overlays, "
+                        "then load it back.",
+                    )
+                except Exception as e:
+                    QMessageBox.critical(self, "Save Error", str(e))
+
+    def _on_thresh_changed(self, value: float) -> None:
+        """Update duplicate threshold in config and engine."""
+        self._preset_config.processing.duplicate_threshold = value
+        self._engine.set_duplicate_threshold(value)
+
+    def _on_frametime_toggled(self, checked: bool) -> None:
+        """Update frametime plot visibility in config and loaded engine."""
+        self._preset_config.rendering.frametime_plot.visible = checked
+
+        if self._pending_videos and self._engine.state != EngineState.IDLE:
+            self._engine.reset()
+            self._load_videos()
+
     def _on_start(self) -> None:
         """Start processing."""
         try:
+            import os
+            if self._profile_cb.isChecked():
+                os.environ["TRDROP_PROFILE"] = "1"
+            else:
+                os.environ["TRDROP_PROFILE"] = ""
+            reset_profiler()
+
+            self._ignore_frames = False
+            self._processing_start_time = time.time()
             self._engine.start()
         except Exception as e:
             QMessageBox.critical(self, "Start Error", str(e))
@@ -342,9 +958,27 @@ def _on_pause(self) -> None:
 
     def _on_reset(self) -> None:
         """Reset the engine."""
+        self._ignore_frames = True
         self._engine.reset()
         self._pending_videos.clear()
+        self._output_csv_path = None
+        self._output_video_path = None
+        self._processing_start_time = None
+        self._preset_config = PresetConfig()
+        self._thresh_spinbox.blockSignals(True)
+        self._thresh_spinbox.setValue(
+            self._preset_config.processing.duplicate_threshold
+        )
+        self._thresh_spinbox.blockSignals(False)
+        self._frametime_cb.blockSignals(True)
+        self._frametime_cb.setChecked(
+            self._preset_config.rendering.frametime_plot.visible
+        )
+        self._frametime_cb.blockSignals(False)
+        self._retranslate_ui()
         self._progress_label.setText("")
+        self._preview_label.clear()
+        self._content_stack.setCurrentIndex(0)
         self._update_controls()
 
     def _on_seek(self) -> None:
@@ -352,6 +986,10 @@ def _on_seek(self) -> None:
         frame_idx = self._seek_spinbox.value()
         try:
             result = self._engine.seek(frame_idx)
+            # Display composited frame if available
+            if result.composited_frame is not None:
+                self._show_frame(result.composited_frame)
+
             # Display seek result info
             metrics_info = []
             for i, m in enumerate(result.metrics):
@@ -361,8 +999,12 @@ def _on_seek(self) -> None:
             fps_info = [f"{fps:.1f}" for fps in result.fps_values]
 
             self._progress_label.setText(
-                f"Frame {frame_idx}: {', '.join(metrics_info)} | "
-                f"FPS: {', '.join(fps_info)}"
+                self._t(
+                    f"Frame {frame_idx}: {', '.join(metrics_info)} | "
+                    f"FPS: {', '.join(fps_info)}",
+                    f"第 {frame_idx} 帧: {', '.join(metrics_info)} | "
+                    f"帧率: {', '.join(fps_info)}",
+                )
             )
         except Exception as e:
             QMessageBox.warning(self, "Seek Error", str(e))
@@ -372,12 +1014,14 @@ def _on_about(self) -> None:
         QMessageBox.about(
             self,
             "About TRDrop",
-            "TRDrop v2.0.0\n\n"
+            "TRDrop v2.1.0-beta.4\n\n"
             "Video framerate and frametime analysis tool.\n\n"
             "Drop video files to analyze their real framerate.",
         )
 
-    # === Drag and Drop ===
+    # ================================================================
+    # Drag and Drop
+    # ================================================================
 
     def dragEnterEvent(self, a0: QDragEnterEvent | None) -> None:
         """Accept video file drops."""
diff --git a/src/trdrop/gui/widgets/state_indicator.py b/src/trdrop/gui/widgets/state_indicator.py
index a254500f..c169d746 100644
--- a/src/trdrop/gui/widgets/state_indicator.py
+++ b/src/trdrop/gui/widgets/state_indicator.py
@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+from typing import Callable
+
 from PyQt6.QtCore import Qt
 from PyQt6.QtGui import QColor, QPainter, QPaintEvent
 from PyQt6.QtWidgets import QHBoxLayout, QLabel, QWidget
@@ -18,7 +20,7 @@
     EngineState.ERROR: QColor(255, 59, 48),        # Red
 }
 
-STATE_MESSAGES: dict[EngineState, str] = {
+STATE_MESSAGES_EN: dict[EngineState, str] = {
     EngineState.IDLE: "No videos loaded",
     EngineState.READY: "Ready to process",
     EngineState.PROCESSING: "Processing...",
@@ -27,6 +29,15 @@
     EngineState.ERROR: "Error",
 }
 
+STATE_MESSAGES_ZH: dict[EngineState, str] = {
+    EngineState.IDLE: "尚未加载视频",
+    EngineState.READY: "就绪",
+    EngineState.PROCESSING: "处理中...",
+    EngineState.PAUSED: "已暂停",
+    EngineState.COMPLETED: "已完成",
+    EngineState.ERROR: "出错",
+}
+
 
 class StateCircle(QWidget):
     """A small colored circle indicating state."""
@@ -56,6 +67,7 @@ class StateIndicator(QWidget):
     def __init__(self, parent: QWidget | None = None) -> None:
         super().__init__(parent)
         self._state = EngineState.IDLE
+        self._translator: Callable[[str, str], str] | None = None
 
         layout = QHBoxLayout(self)
         layout.setContentsMargins(8, 4, 8, 4)
@@ -64,12 +76,21 @@ def __init__(self, parent: QWidget | None = None) -> None:
         self._circle = StateCircle()
         layout.addWidget(self._circle)
 
-        self._label = QLabel(STATE_MESSAGES[EngineState.IDLE])
+        self._label = QLabel(STATE_MESSAGES_EN[EngineState.IDLE])
         self._label.setStyleSheet("font-size: 12px;")
         layout.addWidget(self._label)
 
         layout.addStretch()
 
+    def set_translator(self, t: Callable[[str, str], str]) -> None:
+        """Set translation function for bilingual support."""
+        self._translator = t
+
+    def _tr(self, en: str, zh: str) -> str:
+        if self._translator is not None:
+            return self._translator(en, zh)
+        return en
+
     @property
     def state(self) -> EngineState:
         """Current displayed state."""
@@ -88,4 +109,12 @@ def set_state(self, state: EngineState, message: str | None = None) -> None:
         if message is not None:
             self._label.setText(message)
         else:
-            self._label.setText(STATE_MESSAGES.get(state, str(state)))
+            en = STATE_MESSAGES_EN.get(state, str(state))
+            zh = STATE_MESSAGES_ZH.get(state, en)
+            self._label.setText(self._tr(en, zh))
+
+    def retranslate(self) -> None:
+        """Re-apply translation to current default state message."""
+        en = STATE_MESSAGES_EN.get(self._state, str(self._state))
+        zh = STATE_MESSAGES_ZH.get(self._state, en)
+        self._label.setText(self._tr(en, zh))
diff --git a/src/trdrop/gui/widgets/video_viewport.py b/src/trdrop/gui/widgets/video_viewport.py
index 16aefd16..fbd1d87e 100644
--- a/src/trdrop/gui/widgets/video_viewport.py
+++ b/src/trdrop/gui/widgets/video_viewport.py
@@ -27,7 +27,7 @@ def _setup_ui(self) -> None:
         # Video display area (placeholder for now)
         self._display = QLabel()
         self._display.setAlignment(Qt.AlignmentFlag.AlignCenter)
-        self._display.setStyleSheet("background-color: #1a1a1a; color: #666;")
+        self._display.setStyleSheet("background-color: palette(base);")
         self._display.setText(f"Video {self._video_index + 1}")
         self._display.setMinimumSize(320, 180)
         layout.addWidget(self._display, stretch=1)
@@ -35,7 +35,7 @@ def _setup_ui(self) -> None:
         # Info label
         self._info = QLabel()
         self._info.setAlignment(Qt.AlignmentFlag.AlignCenter)
-        self._info.setStyleSheet("color: #888; font-size: 11px;")
+        self._info.setStyleSheet("font-size: 11px;")
         self._update_info()
         layout.addWidget(self._info)
 
diff --git a/src/trdrop/utils/frozen.py b/src/trdrop/utils/frozen.py
new file mode 100644
index 00000000..12af0585
--- /dev/null
+++ b/src/trdrop/utils/frozen.py
@@ -0,0 +1,26 @@
+"""Helpers for PyInstaller frozen builds."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+
+def is_frozen() -> bool:
+    """Return True when running inside a PyInstaller bundle."""
+    return getattr(sys, "frozen", False) and hasattr(sys, "_MEIPASS")
+
+
+def bundle_dir() -> Path:
+    """Return the bundle directory (PyInstaller _MEIPASS or source tree root)."""
+    if is_frozen():
+        return Path(sys._MEIPASS)  # type: ignore[attr-defined]
+    # Development: project root is 4 levels up from this file
+    return Path(__file__).resolve().parent.parent.parent.parent
+
+
+def icon_path() -> Path | None:
+    """Return the app icon path, or None if not found."""
+    icon_name = "trdrop_mac.png" if sys.platform == "darwin" else "trdrop.ico"
+    p = bundle_dir() / icon_name
+    return p if p.exists() else None
diff --git a/src/trdrop/video/reader.py b/src/trdrop/video/reader.py
index 049c1182..4c915ff8 100644
--- a/src/trdrop/video/reader.py
+++ b/src/trdrop/video/reader.py
@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import logging
 import time
 from pathlib import Path
 from typing import Any, Iterator
@@ -11,6 +12,99 @@
 from trdrop.interfaces.video import VideoReader
 from trdrop.profiling import get_profiler
 
+logger = logging.getLogger(__name__)
+
+
+def _build_pq_tonemap_lut3d() -> np.ndarray:
+    """Build a 256×256×256×3 LUT for full HDR→SDR conversion.
+
+    Pipeline: PQ EOTF → BT.2020→BT.709 gamut mapping → Reinhard tonemap → BT.709 OETF.
+    """
+    # PQ EOTF constants (SMPTE ST 2084)
+    m1 = 0.1593017578125
+    m2 = 78.84375
+    c1 = 0.8359375
+    c2 = 18.8515625
+    c3 = 18.6875
+
+    # BT.2020 → BT.709 color matrix (ITU-R BT.2087)
+    M = np.array([
+        [1.6605, -0.5877, -0.0728],
+        [-0.1246, 1.1329, -0.0083],
+        [-0.0182, -0.1006, 1.1187],
+    ], dtype=np.float64)
+
+    idx = np.arange(256, dtype=np.float64) / 255.0
+    r, g, b = np.meshgrid(idx, idx, idx, indexing="ij")
+    rgb = np.stack([r, g, b], axis=-1)  # (256, 256, 256, 3)
+
+    # PQ EOTF: normalized PQ signal → linear light (0–10000 nits)
+    t = np.power(np.maximum(rgb, 1e-10), 1.0 / m2)
+    linear = 10000.0 * np.power(
+        np.maximum(t - c1, 0.0) / (c2 - c3 * t + 1e-10),
+        1.0 / m1,
+    )
+
+    # BT.2020 → BT.709 gamut mapping in linear light
+    lin709 = np.einsum("ij,...j->...i", M, linear)
+    lin709 = np.maximum(lin709, 0.0)
+
+    # Extended Reinhard tonemap, normalized to SDR reference white (100 nits)
+    v = lin709 / 100.0
+    Lw = 10000.0 / 100.0
+    mapped = v * (1.0 + v / (Lw * Lw)) / (1.0 + v)
+    mapped = np.clip(mapped, 0.0, 1.0)
+
+    # BT.709 OETF
+    sdr = np.where(
+        mapped < 0.018,
+        mapped * 4.5,
+        1.099 * np.power(np.maximum(mapped, 1e-10), 0.45) - 0.099,
+    )
+    return np.clip(sdr * 255.0, 0, 255).astype(np.uint8)
+
+
+def _get_lut3d_applier():
+    """Return a fast 3D LUT apply function (numba-accelerated if available)."""
+    try:
+        import numba
+
+        @numba.njit(parallel=True)
+        def _apply(img, lut):
+            h, w = img.shape[0], img.shape[1]
+            out = np.empty_like(img)
+            for y in numba.prange(h):
+                for x in range(w):
+                    r = img[y, x, 0]
+                    g = img[y, x, 1]
+                    b = img[y, x, 2]
+                    out[y, x, 0] = lut[r, g, b, 0]
+                    out[y, x, 1] = lut[r, g, b, 1]
+                    out[y, x, 2] = lut[r, g, b, 2]
+            return out
+
+        return _apply
+    except ImportError:
+        def _apply(img, lut):
+            return lut[img[..., 0], img[..., 1], img[..., 2]]
+        return _apply
+
+
+# Lazy-initialized globals (built on first HDR video encounter)
+_pq_lut3d: np.ndarray | None = None
+_apply_lut3d = _get_lut3d_applier()
+
+
+def _ensure_pq_lut3d() -> np.ndarray:
+    global _pq_lut3d
+    if _pq_lut3d is None:
+        logger.info("Building HDR→SDR 3D LUT (48MB, one-time cost)...")
+        _pq_lut3d = _build_pq_tonemap_lut3d()
+        # Warm up numba JIT with a tiny array
+        tiny = np.zeros((1, 1, 3), dtype=np.uint8)
+        _apply_lut3d(tiny, _pq_lut3d)
+    return _pq_lut3d
+
 
 class PyAVReader(VideoReader):
     """Video reader using PyAV (libav/ffmpeg bindings)."""
@@ -21,6 +115,7 @@ def __init__(self, path: str | Path) -> None:
         self._path = Path(path)
         self._container: Any = av.open(str(path))
         self._stream: Any = self._container.streams.video[0]
+        self._stream.thread_type = "AUTO"
 
         self._fps = float(self._stream.average_rate or self._stream.base_rate or 30)
         self._width: int = self._stream.width
@@ -28,6 +123,7 @@ def __init__(self, path: str | Path) -> None:
         self._total_frames: int = self._stream.frames or self._estimate_frames()
 
         self._frame_iter: Iterator[Any] | None = None
+        self._hdr_tonemap = False
         self._current_frame = -1
 
     def _estimate_frames(self) -> int:
@@ -67,6 +163,31 @@ def read(self, out: np.ndarray) -> bool:
 
         if self._frame_iter is None:
             self._frame_iter = self._container.decode(video=0)
+            self._hdr_tonemap = False
+
+            # Detect HDR via color transfer characteristic (integer enum from FFmpeg)
+            # AVCOL_TRC_SMPTE2084 (PQ) = 16, AVCOL_TRC_ARIB_STD_B67 (HLG) = 18
+            _TRC_PQ = 16
+            _TRC_HLG = 18
+            _PRIM_BT2020 = 9  # AVCOL_PRI_BT2020
+            trc_val = getattr(self._stream.codec_context, "color_trc", None)
+            prim_val = getattr(self._stream.codec_context, "color_primaries", None)
+            pix_fmt = getattr(self._stream.codec_context, "pix_fmt", "") or ""
+            is_hdr = (
+                trc_val in (_TRC_PQ, _TRC_HLG)
+                or prim_val == _PRIM_BT2020
+                or "10le" in pix_fmt
+                or "12le" in pix_fmt
+            )
+
+            if is_hdr:
+                _ensure_pq_lut3d()
+                self._hdr_tonemap = True
+                logger.info(
+                    "HDR detected (trc=%s, pix_fmt=%s). Tonemapping to SDR enabled.",
+                    trc_val,
+                    pix_fmt
+                )
 
         assert self._frame_iter is not None
         profiler = get_profiler()
@@ -74,9 +195,14 @@ def read(self, out: np.ndarray) -> bool:
             # Time the decode operation
             t0 = time.perf_counter()
             frame = next(self._frame_iter)
+
             self._current_frame += 1
             # Copy frame data to output buffer
             arr = frame.to_ndarray(format="rgb24")
+
+            if self._hdr_tonemap:
+                arr = _apply_lut3d(arr, _pq_lut3d)
+
             np.copyto(out, arr)
             t1 = time.perf_counter()
             profiler.add_timing("read_decode", (t1 - t0) * 1000)
diff --git a/tests/benchmarks/test_benchmark.py b/tests/benchmarks/test_benchmark.py
index 4029b55e..b3db969f 100644
--- a/tests/benchmarks/test_benchmark.py
+++ b/tests/benchmarks/test_benchmark.py
@@ -23,7 +23,7 @@
 from trdrop.export import (
     StreamingCSVExporter,
     StreamingVideoExporter,
-    get_best_h264_encoder,
+    get_best_encoder,
     is_hardware_encoder,
 )
 from trdrop.profiling.profiler import OverlapStats, Profiler, get_profiler, reset_profiler
@@ -186,7 +186,7 @@ class TestBenchmark:
     def test_benchmark(self, qapp, tmp_path):
         """Consolidated benchmark: scaling + async comparison."""
         # Get encoder info
-        encoder = get_best_h264_encoder()
+        encoder = get_best_encoder()
         hw_tag = "HW" if is_hardware_encoder(encoder) else "SW"
 
         print("\n")
diff --git a/tests/test_config_integration.py b/tests/test_config_integration.py
index 9ba8d1f6..75aeaa6c 100644
--- a/tests/test_config_integration.py
+++ b/tests/test_config_integration.py
@@ -97,6 +97,54 @@ def test_compositor_uses_config_layout_mode(self, qapp, test_video):
 
         reader.close()
 
+    def test_plot_font_sizes_are_tuned_for_dense_four_up_layouts(self, qapp, test_video):
+        """Verify 4-up keeps framerate text stable while shrinking frametime labels."""
+        reader = PyAVReader(test_video)
+
+        config = PresetConfig()
+        config.rendering.fps_plot.visible = True
+        config.rendering.frametime_plot.visible = True
+
+        single = SimpleCompositor(
+            video_count=1,
+            video_fps=[reader.fps],
+            output_width=1920,
+            output_height=1080,
+            config=config,
+        )
+        four_up = SimpleCompositor(
+            video_count=4,
+            video_fps=[reader.fps] * 4,
+            output_width=1920,
+            output_height=1080,
+            config=config,
+        )
+
+        assert single._framerate_plots is not None
+        assert four_up._framerate_plots is not None
+        assert single._frametime_plots is not None
+        assert four_up._frametime_plots is not None
+
+        assert single._framerate_plots[0]._style.font.pixelSize() == \
+            four_up._framerate_plots[0]._style.font.pixelSize()
+        assert single._framerate_plots[0]._style.title_font is not None
+        assert four_up._framerate_plots[0]._style.title_font is not None
+        assert single._framerate_plots[0]._style.title_font.pixelSize() == \
+            four_up._framerate_plots[0]._style.title_font.pixelSize()
+        assert single._framerate_plots[0]._style.line_width == 5
+        assert four_up._framerate_plots[0]._style.line_width == 5
+
+        assert single._frametime_plots[0]._style.font.pixelSize() > \
+            four_up._frametime_plots[0]._style.font.pixelSize()
+        assert single._frametime_plots[0]._style.title_font is not None
+        assert four_up._frametime_plots[0]._style.title_font is not None
+        assert single._frametime_plots[0]._style.title_font.pixelSize() == \
+            four_up._frametime_plots[0]._style.title_font.pixelSize()
+        assert single._frametime_plots[0]._time_anchor == 1.0
+        assert four_up._frametime_plots[0]._time_anchor == 1.0
+
+        reader.close()
+
     def test_compositor_uses_config_grid_layout(self, qapp, test_video):
         """Verify compositor respects GRID layout from config."""
         reader = PyAVReader(test_video)
@@ -560,3 +608,36 @@ def test_fps_plot_position_from_config(self, qapp, test_video):
             "Default config should render plot at bottom"
 
         source.close()
+
+    def test_multi_video_frametime_bounds_avoid_combined_framerate(
+        self, qapp, test_video
+    ):
+        """Verify separate frametime plots avoid the combined framerate plot."""
+        reader = PyAVReader(test_video)
+
+        for video_count in (2, 3, 4):
+            config = PresetConfig()
+            config.rendering.fps_plot.visible = True
+            config.rendering.frametime_plot.visible = True
+
+            compositor = SimpleCompositor(
+                video_count=video_count,
+                video_fps=[reader.fps] * video_count,
+                output_width=1920,
+                output_height=1080,
+                config=config,
+            )
+
+            combined_fr_bounds = compositor._combined_framerate_plot_bounds()
+
+            for i in range(video_count):
+                bounds = compositor._frametime_plot_bounds(i)
+                video_px, video_py, video_pw, video_ph = compositor._video_pixel_bounds(i)
+
+                assert bounds.left() >= video_px
+                assert bounds.right() <= video_px + video_pw
+                assert bounds.top() >= video_py
+                assert bounds.bottom() <= video_py + video_ph
+                assert not bounds.intersects(combined_fr_bounds)
+
+        reader.close()
diff --git a/tests/test_main_window.py b/tests/test_main_window.py
new file mode 100644
index 00000000..d70da78d
--- /dev/null
+++ b/tests/test_main_window.py
@@ -0,0 +1,54 @@
+"""Tests for MainWindow GUI parameter wiring."""
+
+from __future__ import annotations
+
+import sys
+
+import pytest
+from PyQt6.QtWidgets import QApplication
+
+from trdrop.gui.main_window import MainWindow
+
+pytestmark = pytest.mark.gui
+
+
+@pytest.fixture
+def qapp() -> QApplication:
+    """Create or reuse QApplication for widget tests."""
+    app = QApplication.instance()
+    if app is None:
+        app = QApplication(sys.argv)
+    assert isinstance(app, QApplication)
+    return app
+
+
+def test_frametime_checkbox_defaults_to_visible(qapp: QApplication) -> None:
+    """Frametime checkbox mirrors the default preset."""
+    window = MainWindow()
+
+    assert window._frametime_cb.isChecked() is True
+    assert window._preset_config.rendering.frametime_plot.visible is True
+
+    window.close()
+
+
+def test_profile_checkbox_defaults_to_visible(qapp: QApplication) -> None:
+    """Profile checkbox defaults to enabled."""
+    window = MainWindow()
+
+    assert window._profile_cb.isChecked() is True
+
+    window.close()
+
+
+def test_frametime_checkbox_updates_preset(qapp: QApplication) -> None:
+    """Toggling frametime checkbox updates preset config."""
+    window = MainWindow()
+
+    window._frametime_cb.setChecked(True)
+    assert window._preset_config.rendering.frametime_plot.visible is True
+
+    window._frametime_cb.setChecked(False)
+    assert window._preset_config.rendering.frametime_plot.visible is False
+
+    window.close()
diff --git a/tests/test_overlay_rendering.py b/tests/test_overlay_rendering.py
index 2cdaa33c..013051d6 100644
--- a/tests/test_overlay_rendering.py
+++ b/tests/test_overlay_rendering.py
@@ -211,6 +211,26 @@ def test_plot_region_has_content(self, qapp, test_video, plot_style, text_style)
         print(f"Frametime plot region: {ft_bright} bright pixels")
         assert ft_bright > 500
 
+    def test_frametime_bounds_match_framerate_layout(self, qapp, test_video, plot_style):
+        """Frametime plot should stay compact at lower-left and sit above framerate."""
+        compositor = SimpleCompositor(
+            video_count=1,
+            video_fps=[test_video.fps],
+            output_width=1280,
+            output_height=720,
+            framerate_plots=[FrameratePlot(plot_style, max_fps=60.0)],
+            frametime_plots=[FrametimePlot(plot_style, max_ms=50.0)],
+        )
+
+        fr_bounds = compositor._framerate_plot_bounds(0)
+        ft_bounds = compositor._frametime_plot_bounds(0)
+
+        assert ft_bounds.width() < fr_bounds.width() // 2
+        assert ft_bounds.height() <= fr_bounds.height()
+        assert ft_bounds.left() == fr_bounds.left()
+        assert ft_bounds.bottom() < fr_bounds.top()
+        assert ft_bounds.top() >= 0
+
     def test_framerate_plot_modifies_output(self, qapp, test_video, plot_style, text_style):
         """Verify framerate plot actually draws pixels."""
         analyzer = DuplicateDetector()
diff --git a/trdrop.icns b/trdrop.icns
new file mode 100644
index 00000000..c4a4e5c8
Binary files /dev/null and b/trdrop.icns differ
diff --git a/trdrop.ico b/trdrop.ico
new file mode 100644
index 00000000..b29a4e79
Binary files /dev/null and b/trdrop.ico differ
diff --git a/trdrop.spec b/trdrop.spec
new file mode 100644
index 00000000..bc0e94e3
--- /dev/null
+++ b/trdrop.spec
@@ -0,0 +1,122 @@
+# -*- mode: python ; coding: utf-8 -*-
+"""PyInstaller spec for TRDrop single-file EXE."""
+
+import platform
+from PyInstaller.utils.hooks import collect_submodules, collect_data_files
+
+# Only collect numba runtime submodules, skip tests/cuda tests
+_numba_runtime = [
+    m for m in collect_submodules("numba")
+    if not m.startswith("numba.tests.")
+    and not m.startswith("numba.cuda.tests.")
+]
+
+hiddenimports = (
+    _numba_runtime
+    + collect_submodules("av")
+    + [
+        "PyQt6.sip",
+    ]
+)
+
+# numba needs its bundled data, but skip test data
+datas = [
+    (src, dst) for src, dst in collect_data_files("numba")
+    if "tests" not in src
+]
+
+a = Analysis(
+    ["src/trdrop/main.py"],
+    pathex=[],
+    hiddenimports=hiddenimports,
+    datas=datas + [
+        ("trdrop.ico", "."),
+        ("trdrop_mac.png", "."),
+    ],
+    hookspath=[],
+    runtime_hooks=["rthook_av.py"],
+    excludes=[
+        "numba.tests",
+        "numba.cuda.tests",
+        # Unused PyQt6 modules -- only QtCore/QtGui/QtWidgets are used
+        "PyQt6.QtPdf",
+        "PyQt6.QtSvg",
+        "PyQt6.QtNetwork",
+        "PyQt6.QtOpenGL",
+        "PyQt6.QtDBus",
+        "PyQt6.QtQml",
+        "PyQt6.QtQuick",
+        "PyQt6.QtBluetooth",
+        "PyQt6.QtMultimedia",
+        "PyQt6.QtWebEngine",
+        "PyQt6.QtWebSockets",
+        "PyQt6.QtPositioning",
+        "PyQt6.QtSensors",
+        "PyQt6.QtSerialPort",
+        "PyQt6.QtSql",
+        "PyQt6.QtTest",
+        "PyQt6.QtXml",
+    ],
+)
+
+# --- Strip unnecessary Qt/native binaries ---
+_exclude_binaries = {
+    # Qt software OpenGL fallback (7.3 MB) - all modern Windows have GPU drivers
+    "opengl32sw.dll",
+    # Qt PDF module (2.7 MB) - not used
+    "Qt6Pdf.dll",
+    # Qt Network (not used)
+    "Qt6Network.dll",
+    # Qt SVG (not used)
+    "Qt6Svg.dll",
+}
+
+# av.libs encoders: can't exclude any -- avcodec links against all of them
+_exclude_prefixes = ()
+
+# Qt plugins not needed for this app
+_exclude_qt_plugins = {
+    "qtuiotouchplugin.dll",   # touch input
+    "qsvgicon.dll",           # SVG icon engine
+    "qpdf.dll",               # PDF image format
+    "qsvg.dll",               # SVG image format
+    "qtga.dll",               # TGA image format
+    "qwbmp.dll",              # WBMP image format
+    "qwebp.dll",              # WebP image format
+    "qtiff.dll",              # TIFF image format
+    "qicns.dll",              # Apple ICNS format
+    "qminimal.dll",           # headless platform
+    "qoffscreen.dll",         # offscreen platform
+}
+
+# Qt translation files (~1 MB)
+a.binaries = [
+    b for b in a.binaries
+    if b[0].split("\\")[-1] not in _exclude_binaries
+    and b[0].split("/")[-1] not in _exclude_binaries
+    and b[0].split("\\")[-1] not in _exclude_qt_plugins
+    and b[0].split("/")[-1] not in _exclude_qt_plugins
+    and not b[0].endswith(".qm")
+    and not any(b[0].split("\\")[-1].startswith(p) or b[0].split("/")[-1].startswith(p) for p in _exclude_prefixes)
+]
+
+a.datas = [
+    d for d in a.datas
+    if not d[0].endswith(".qm")
+]
+
+pyz = PYZ(a.pure)
+
+_icon_file = "trdrop.ico" if platform.system() == "Windows" else "trdrop.icns"
+
+exe = EXE(
+    pyz,
+    a.scripts,
+    a.binaries,
+    a.datas,
+    [],
+    name="TRDrop",
+    icon=_icon_file,
+    console=False,
+    windowed=True,
+)
diff --git a/trdrop_logo_new.png b/trdrop_logo_new.png
new file mode 100644
index 00000000..f30a899e
Binary files /dev/null and b/trdrop_logo_new.png differ
diff --git a/trdrop_mac.png b/trdrop_mac.png
new file mode 100644
index 00000000..b6d7d1fa
Binary files /dev/null and b/trdrop_mac.png differ
diff --git a/trdrop_preset.example.yaml b/trdrop_preset.example.yaml
new file mode 100644
index 00000000..14936f76
--- /dev/null
+++ b/trdrop_preset.example.yaml
@@ -0,0 +1,237 @@
+# ============================================================================
+# TRDrop v2 Preset Configuration
+# ============================================================================
+# This file controls overlay appearance, layout, and export settings.
+# Load it in TRDrop via Config... button, or pass it via command line.
+#
+# Coordinates are normalized 0.0-1.0 (e.g., 0.5 = center).
+# Colors are RGBA arrays [Red, Green, Blue, Alpha], each 0-255.
+# "ref" can be "global" (entire output frame) or "video:N" (video N's region).
+
+# ----------------------------------------------------------------------------
+# Processing parameters
+# ----------------------------------------------------------------------------
+processing:
+  # Threshold for duplicate frame detection (0.0-1.0).
+  # Lower = more sensitive. Frames with diff_ratio below this are marked as duplicates.
+  # 0.02 works well for most capture card footage.
+  duplicate_threshold: 0.02
+
+  # Sliding window size for FPS calculation (in frames).
+  # Larger = smoother FPS reading but slower to react to changes.
+  # 60 means FPS is averaged over the last 60 frames.
+  window_size: 60
+
+# ----------------------------------------------------------------------------
+# Rendering / overlay configuration
+# ----------------------------------------------------------------------------
+rendering:
+
+  # --- Video layout ---
+  layout:
+    # How multiple videos are arranged:
+    #   grid       — automatic grid (1=full, 2=side-by-side, 3-4=2x2)
+    #   horizontal — all videos in a single row
+    #   vertical   — all videos in a single column
+    #   single     — only show first video
+    mode: grid
+
+    # Gap between videos (0.0-1.0, fraction of output size). 0 = no gap.
+    spacing: 0.0
+
+  # --- FPS plot (shown across the bottom of the output) ---
+  fps_plot:
+    position:
+      x: 0.025       # left edge
+      y: 0.83        # vertical position (0=top, 1=bottom)
+      ref: global    # relative to entire output frame
+    size:
+      width: 0.955   # 95.5% of output width
+      height: 0.15   # 15% of output height
+      ref: global
+    visible: true    # set to false to hide the FPS plot
+
+    # Plot drawing style: "filled" (area chart), "line" (line chart), or "bar"
+    style: line
+
+    # Subtle background behind the plot [R, G, B, A]
+    background_color: [0, 0, 0, 24]
+
+    # Grid line color [R, G, B, A]
+    grid_color: [255, 255, 255, 108]
+
+    # Line thickness in pixels
+    line_width: 4.0
+
+    # Font size for axis labels and FPS values (fraction of output height)
+    label_font_size: 0.018
+
+    # Show horizontal grid lines at target FPS intervals
+    show_grid: true
+
+  # --- Frametime plot ---
+  frametime_plot:
+    position:
+      x: 0.025
+      y: 0.69
+      ref: global
+    size:
+      width: 0.18
+      height: 0.10
+      ref: global
+    visible: true
+
+    style: line
+    background_color: [0, 0, 0, 18]
+    grid_color: [255, 255, 255, 108]
+    line_width: 3.0
+    label_font_size: 0.016
+    show_grid: true
+
+  # Font used for all text overlays
+  font_family: monospace
+
+  # Colors for each video's plot line and text [R, G, B, A].
+  # Up to 4 colors for up to 4 videos.
+  video_colors:
+    - [52, 199, 89, 230]    # Video 1 — green
+    - [0, 122, 255, 230]    # Video 2 — blue
+    - [255, 149, 0, 230]    # Video 3 — orange
+    - [255, 59, 48, 230]    # Video 4 — red
+
+# ----------------------------------------------------------------------------
+# Per-video overlay settings
+# ----------------------------------------------------------------------------
+# Configure text overlays for each video slot (0-3).
+# Only define slots you want to customize; others use defaults.
+videos:
+  0:
+    # --- FPS text overlay ---
+    fps_text:
+      position:
+        x: 0.03       # 3% from left edge of this video's region
+        y: 0.08       # 8% from top
+        ref: video:0   # relative to video 0's region
+      anchor: top_left  # text anchor point: top_left, top_center, top_right, etc.
+      visible: true
+      # Font size as fraction of video height (0.035 = 3.5% of video height)
+      font_size: 0.035
+      font_family: monospace
+      color: [255, 255, 255, 230]       # white, slightly transparent
+      shadow: true                       # drop shadow for readability
+      shadow_color: [0, 0, 0, 180]      # dark shadow
+
+    # --- Frametime text overlay (hidden by default) ---
+    frametime_text:
+      position:
+        x: 0.03
+        y: 0.11
+        ref: video:0
+      anchor: top_left
+      visible: false    # set to true to show frametime text
+      font_size: 0.04
+      font_family: monospace
+      color: [255, 255, 255, 230]
+      shadow: true
+      shadow_color: [0, 0, 0, 180]
+
+    # Whether this video's overlays are shown at all
+    visible: true
+
+  1:
+    fps_text:
+      position:
+        x: 0.03
+        y: 0.08
+        ref: video:1
+      anchor: top_left
+      visible: true
+      font_size: 0.035
+      font_family: monospace
+      color: [255, 255, 255, 230]
+      shadow: true
+      shadow_color: [0, 0, 0, 180]
+    frametime_text:
+      position:
+        x: 0.03
+        y: 0.11
+        ref: video:1
+      anchor: top_left
+      visible: false
+      font_size: 0.04
+      font_family: monospace
+      color: [255, 255, 255, 230]
+      shadow: true
+      shadow_color: [0, 0, 0, 180]
+    visible: true
+
+  2:
+    fps_text:
+      position:
+        x: 0.03
+        y: 0.08
+        ref: video:2
+      anchor: top_left
+      visible: true
+      font_size: 0.035
+      font_family: monospace
+      color: [255, 255, 255, 230]
+      shadow: true
+      shadow_color: [0, 0, 0, 180]
+    frametime_text:
+      position:
+        x: 0.03
+        y: 0.11
+        ref: video:2
+      anchor: top_left
+      visible: false
+      font_size: 0.04
+      font_family: monospace
+      color: [255, 255, 255, 230]
+      shadow: true
+      shadow_color: [0, 0, 0, 180]
+    visible: true
+
+  3:
+    fps_text:
+      position:
+        x: 0.03
+        y: 0.08
+        ref: video:3
+      anchor: top_left
+      visible: true
+      font_size: 0.035
+      font_family: monospace
+      color: [255, 255, 255, 230]
+      shadow: true
+      shadow_color: [0, 0, 0, 180]
+    frametime_text:
+      position:
+        x: 0.03
+        y: 0.11
+        ref: video:3
+      anchor: top_left
+      visible: false
+      font_size: 0.04
+      font_family: monospace
+      color: [255, 255, 255, 230]
+      shadow: true
+      shadow_color: [0, 0, 0, 180]
+    visible: true
+
+# ----------------------------------------------------------------------------
+# Export settings
+# ----------------------------------------------------------------------------
+export:
+  # Output resolution [width, height] in pixels
+  resolution: [1920, 1080]
+
+  # Video codec: h264, h265, vp9, prores
+  # "auto" picks the best available (prefers hardware encoding)
+  codec: h264
+
+  # Bitrate: "auto" for codec default, or specify like "10M", "5000k"
+  bitrate: auto
+
+  # Output framerate. null = use source video FPS. Range: 10-120.
+  fps: 60
diff --git a/uv.lock b/uv.lock
new file mode 100644
index 00000000..c91b3adb
--- /dev/null
+++ b/uv.lock
@@ -0,0 +1,541 @@
+version = 1
+revision = 3
+requires-python = ">=3.11"
+
+[[package]]
+name = "altgraph"
+version = "0.17.5"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7e/f8/97fdf103f38fed6792a1601dbc16cc8aac56e7459a9fff08c812d8ae177a/altgraph-0.17.5.tar.gz", hash = "sha256:c87b395dd12fabde9c99573a9749d67da8d29ef9de0125c7f536699b4a9bc9e7", size = 48428, upload-time = "2025-11-21T20:35:50.583Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a9/ba/000a1996d4308bc65120167c21241a3b205464a2e0b58deda26ae8ac21d1/altgraph-0.17.5-py2.py3-none-any.whl", hash = "sha256:f3a22400bce1b0c701683820ac4f3b159cd301acab067c51c653e06961600597", size = 21228, upload-time = "2025-11-21T20:35:49.444Z" },
+]
+
+[[package]]
+name = "av"
+version = "17.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b2/eb/abca886df3a091bc406feb5ff71b4c4f426beaae6b71b9697264ce8c7211/av-17.0.0.tar.gz", hash = "sha256:c53685df73775a8763c375c7b2d62a6cb149d992a26a4b098204da42ade8c3df", size = 4410769, upload-time = "2026-03-14T14:38:45.868Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b1/fb/55e3b5b5d1fc61466292f26fbcbabafa2642f378dc48875f8f554591e1a4/av-17.0.0-cp311-abi3-macosx_11_0_x86_64.whl", hash = "sha256:ed4013fac77c309a4a68141dcf6148f1821bb1073a36d4289379762a6372f711", size = 23238424, upload-time = "2026-03-14T14:38:05.856Z" },
+    { url = "https://files.pythonhosted.org/packages/52/03/9ace1acc08bc9ae38c14bf3a4b1360e995e4d999d1d33c2cbd7c9e77582a/av-17.0.0-cp311-abi3-macosx_14_0_arm64.whl", hash = "sha256:e44b6c83e9f3be9f79ee87d0b77a27cea9a9cd67bd630362c86b7e56a748dfbb", size = 18709043, upload-time = "2026-03-14T14:38:08.288Z" },
+    { url = "https://files.pythonhosted.org/packages/00/c0/637721f3cd5bb8bd16105a1a08efd781fc12f449931bdb3a4d0cfd63fa55/av-17.0.0-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:b440da6ac47da0629d509316f24bcd858f33158dbdd0f1b7293d71e99beb26de", size = 34018780, upload-time = "2026-03-14T14:38:10.45Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/59/d19bc3257dd985d55337d7f0414c019414b97e16cd3690ebf9941a847543/av-17.0.0-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:1060cba85f97f4a337311169d92c0b5e143452cfa5ca0e65fa499d7955e8592e", size = 36358757, upload-time = "2026-03-14T14:38:13.092Z" },
+    { url = "https://files.pythonhosted.org/packages/52/6c/a1f4f2677bae6f2ade7a8a18e90ebdcf70690c9b1c4e40e118aa30fa313f/av-17.0.0-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:deda202e6021cfc7ba3e816897760ec5431309d59a4da1f75df3c0e9413d71e7", size = 35195281, upload-time = "2026-03-14T14:38:15.789Z" },
+    { url = "https://files.pythonhosted.org/packages/90/ea/52b0fc6f69432c7bf3f5fbe6f707113650aa40a1a05b9096ffc2bba4f77d/av-17.0.0-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:ffaf266a1a9c2148072de0a4b5ae98061465178d2cfaa69ee089761149342974", size = 37444817, upload-time = "2026-03-14T14:38:18.563Z" },
+    { url = "https://files.pythonhosted.org/packages/34/ad/d2172966282cb8f146c13b6be7416efefde74186460c5e1708ddfc13dba6/av-17.0.0-cp311-abi3-win_amd64.whl", hash = "sha256:45a35a40b2875bf2f98de7c952d74d960f92f319734e6d28e03b4c62a49e6f49", size = 28888553, upload-time = "2026-03-14T14:38:21.223Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/bb/c5a4c4172c514d631fb506e6366b503576b8c7f29809cf42aca73e28ff01/av-17.0.0-cp311-abi3-win_arm64.whl", hash = "sha256:3d32e9b5c5bbcb872a0b6917b352a1db8a42142237826c9b49a36d5dbd9e9c26", size = 21916910, upload-time = "2026-03-14T14:38:23.706Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/8e/c40ac08e63f79387c59f6ecc38f47d4c942b549130eee579ec1a91f6a291/av-17.0.0-cp314-cp314t-macosx_11_0_x86_64.whl", hash = "sha256:d13250fb4b4522e9a6bec32da082556d5f257110ea223758151375748d9bbe25", size = 23483029, upload-time = "2026-03-14T14:38:25.758Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/fb/b4419494bfc249163ec393c613966d66db7e95c76da3345711cd115a79df/av-17.0.0-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:dbb56aa3b7ae72451d1bf6e9d37c7d83d39b97af712f73583ff419fbf08fc237", size = 18920446, upload-time = "2026-03-14T14:38:27.905Z" },
+    { url = "https://files.pythonhosted.org/packages/30/62/c2306d91602ddad2c56106f21dcb334fd51d5ea2e952f7fa025bb8aa39fc/av-17.0.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:a213ac9e83b7ab12c2e9f277a09cac8e9d85cf0883efdab7a87a60e2e4e48879", size = 37477266, upload-time = "2026-03-14T14:38:30.404Z" },
+    { url = "https://files.pythonhosted.org/packages/28/cd/c8510a9607886785c0b3ca019d503e888c3757529be42a7287fe2bfa92d5/av-17.0.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:e15c88bb0921f9435bcc5a27a0863dba571a80ad5e1389c4fcf2073833bb4a74", size = 39572988, upload-time = "2026-03-14T14:38:32.984Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/2d/207d9361e25b5abec9be335bbab4df6b6b838e2214be4b374f4cfb285427/av-17.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:096cfd1e9fc896506726c7c42aaf9b370e78c2f257cde4d6ddb6c889bfcc49ec", size = 38399591, upload-time = "2026-03-14T14:38:35.465Z" },
+    { url = "https://files.pythonhosted.org/packages/73/ca/307740c6aa2980966bf11383ffcb04bacc5b13f3d268ab4cfb274ad6f793/av-17.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:3649ab3d2c7f58049ded1a36e100c0d8fd529cf258f41dd88678ba824034d8c9", size = 40590681, upload-time = "2026-03-14T14:38:38.269Z" },
+    { url = "https://files.pythonhosted.org/packages/35/f2/6fdb26d0651adf409864cb2a0d60da107e467d3d1aabc94b234ead54324a/av-17.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:e5002271ab2135b551d980c2db8f3299d452e3b9d3633f24f6bb57fffe91cd10", size = 29216337, upload-time = "2026-03-14T14:38:40.83Z" },
+    { url = "https://files.pythonhosted.org/packages/41/0a/0896b829a39b5669a2d811e1a79598de661693685cd62b31f11d0c18e65b/av-17.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:dba98603fc4665b4f750de86fbaf6c0cfaece970671a9b529e0e3d1711e8367e", size = 22071058, upload-time = "2026-03-14T14:38:43.663Z" },
+]
+
+[[package]]
+name = "basedpyright"
+version = "1.38.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "nodejs-wheel-binaries" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/0f/58/7abba2c743571a42b2548f07aee556ebc1e4d0bc2b277aeba1ee6c83b0af/basedpyright-1.38.3.tar.gz", hash = "sha256:9725419786afbfad8a9539527f162da02d462afad440b0412fdb3f3cdf179b90", size = 25277430, upload-time = "2026-03-17T13:10:41.526Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2c/e3/3ebb5c23bd3abb5fc2053b8a06a889aa5c1cf8cff738c78cb6c1957e90cd/basedpyright-1.38.3-py3-none-any.whl", hash = "sha256:1f15c2e489c67d6c5e896c24b6a63251195c04223a55e4568b8f8e8ed49ca830", size = 12313363, upload-time = "2026-03-17T13:10:47.344Z" },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "flake8"
+version = "7.3.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mccabe" },
+    { name = "pycodestyle" },
+    { name = "pyflakes" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/9b/af/fbfe3c4b5a657d79e5c47a2827a362f9e1b763336a52f926126aa6dc7123/flake8-7.3.0.tar.gz", hash = "sha256:fe044858146b9fc69b551a4b490d69cf960fcb78ad1edcb84e7fbb1b4a8e3872", size = 48326, upload-time = "2025-06-20T19:31:35.838Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9f/56/13ab06b4f93ca7cac71078fbe37fcea175d3216f31f85c3168a6bbd0bb9a/flake8-7.3.0-py2.py3-none-any.whl", hash = "sha256:b9696257b9ce8beb888cdbe31cf885c90d31928fe202be0889a7cdafad32f01e", size = 57922, upload-time = "2025-06-20T19:31:34.425Z" },
+]
+
+[[package]]
+name = "iniconfig"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
+]
+
+[[package]]
+name = "isort"
+version = "8.0.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ef/7c/ec4ab396d31b3b395e2e999c8f46dec78c5e29209fac49d1f4dace04041d/isort-8.0.1.tar.gz", hash = "sha256:171ac4ff559cdc060bcfff550bc8404a486fee0caab245679c2abe7cb253c78d", size = 769592, upload-time = "2026-02-28T10:08:20.685Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3e/95/c7c34aa53c16353c56d0b802fba48d5f5caa2cdee7958acbcb795c830416/isort-8.0.1-py3-none-any.whl", hash = "sha256:28b89bc70f751b559aeca209e6120393d43fbe2490de0559662be7a9787e3d75", size = 89733, upload-time = "2026-02-28T10:08:19.466Z" },
+]
+
+[[package]]
+name = "llvmlite"
+version = "0.46.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/74/cd/08ae687ba099c7e3d21fe2ea536500563ef1943c5105bf6ab4ee3829f68e/llvmlite-0.46.0.tar.gz", hash = "sha256:227c9fd6d09dce2783c18b754b7cd9d9b3b3515210c46acc2d3c5badd9870ceb", size = 193456, upload-time = "2025-12-08T18:15:36.295Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7a/a1/2ad4b2367915faeebe8447f0a057861f646dbf5fbbb3561db42c65659cf3/llvmlite-0.46.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:82f3d39b16f19aa1a56d5fe625883a6ab600d5cc9ea8906cca70ce94cabba067", size = 37232766, upload-time = "2025-12-08T18:14:48.836Z" },
+    { url = "https://files.pythonhosted.org/packages/12/b5/99cf8772fdd846c07da4fd70f07812a3c8fd17ea2409522c946bb0f2b277/llvmlite-0.46.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a3df43900119803bbc52720e758c76f316a9a0f34612a886862dfe0a5591a17e", size = 56275175, upload-time = "2025-12-08T18:14:51.604Z" },
+    { url = "https://files.pythonhosted.org/packages/38/f2/ed806f9c003563732da156139c45d970ee435bd0bfa5ed8de87ba972b452/llvmlite-0.46.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:de183fefc8022d21b0aa37fc3e90410bc3524aed8617f0ff76732fc6c3af5361", size = 55128630, upload-time = "2025-12-08T18:14:55.107Z" },
+    { url = "https://files.pythonhosted.org/packages/19/0c/8f5a37a65fc9b7b17408508145edd5f86263ad69c19d3574e818f533a0eb/llvmlite-0.46.0-cp311-cp311-win_amd64.whl", hash = "sha256:e8b10bc585c58bdffec9e0c309bb7d51be1f2f15e169a4b4d42f2389e431eb93", size = 38138652, upload-time = "2025-12-08T18:14:58.171Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/f8/4db016a5e547d4e054ff2f3b99203d63a497465f81ab78ec8eb2ff7b2304/llvmlite-0.46.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6b9588ad4c63b4f0175a3984b85494f0c927c6b001e3a246a3a7fb3920d9a137", size = 37232767, upload-time = "2025-12-08T18:15:00.737Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/85/4890a7c14b4fa54400945cb52ac3cd88545bbdb973c440f98ca41591cdc5/llvmlite-0.46.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3535bd2bb6a2d7ae4012681ac228e5132cdb75fefb1bcb24e33f2f3e0c865ed4", size = 56275176, upload-time = "2025-12-08T18:15:03.936Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/07/3d31d39c1a1a08cd5337e78299fca77e6aebc07c059fbd0033e3edfab45c/llvmlite-0.46.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4cbfd366e60ff87ea6cc62f50bc4cd800ebb13ed4c149466f50cf2163a473d1e", size = 55128630, upload-time = "2025-12-08T18:15:07.196Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/6b/d139535d7590a1bba1ceb68751bef22fadaa5b815bbdf0e858e3875726b2/llvmlite-0.46.0-cp312-cp312-win_amd64.whl", hash = "sha256:398b39db462c39563a97b912d4f2866cd37cba60537975a09679b28fbbc0fb38", size = 38138940, upload-time = "2025-12-08T18:15:10.162Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/ff/3eba7eb0aed4b6fca37125387cd417e8c458e750621fce56d2c541f67fa8/llvmlite-0.46.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:30b60892d034bc560e0ec6654737aaa74e5ca327bd8114d82136aa071d611172", size = 37232767, upload-time = "2025-12-08T18:15:13.22Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/54/737755c0a91558364b9200702c3c9c15d70ed63f9b98a2c32f1c2aa1f3ba/llvmlite-0.46.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:6cc19b051753368a9c9f31dc041299059ee91aceec81bd57b0e385e5d5bf1a54", size = 56275176, upload-time = "2025-12-08T18:15:16.339Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/91/14f32e1d70905c1c0aa4e6609ab5d705c3183116ca02ac6df2091868413a/llvmlite-0.46.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bca185892908f9ede48c0acd547fe4dc1bafefb8a4967d47db6cf664f9332d12", size = 55128629, upload-time = "2025-12-08T18:15:19.493Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/a7/d526ae86708cea531935ae777b6dbcabe7db52718e6401e0fb9c5edea80e/llvmlite-0.46.0-cp313-cp313-win_amd64.whl", hash = "sha256:67438fd30e12349ebb054d86a5a1a57fd5e87d264d2451bcfafbbbaa25b82a35", size = 38138941, upload-time = "2025-12-08T18:15:22.536Z" },
+    { url = "https://files.pythonhosted.org/packages/95/ae/af0ffb724814cc2ea64445acad05f71cff5f799bb7efb22e47ee99340dbc/llvmlite-0.46.0-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:d252edfb9f4ac1fcf20652258e3f102b26b03eef738dc8a6ffdab7d7d341d547", size = 37232768, upload-time = "2025-12-08T18:15:25.055Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/19/5018e5352019be753b7b07f7759cdabb69ca5779fea2494be8839270df4c/llvmlite-0.46.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:379fdd1c59badeff8982cb47e4694a6143bec3bb49aa10a466e095410522064d", size = 56275173, upload-time = "2025-12-08T18:15:28.109Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/c9/d57877759d707e84c082163c543853245f91b70c804115a5010532890f18/llvmlite-0.46.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2e8cbfff7f6db0fa2c771ad24154e2a7e457c2444d7673e6de06b8b698c3b269", size = 55128628, upload-time = "2025-12-08T18:15:31.098Z" },
+    { url = "https://files.pythonhosted.org/packages/30/a8/e61a8c2b3cc7a597073d9cde1fcbb567e9d827f1db30c93cf80422eac70d/llvmlite-0.46.0-cp314-cp314-win_amd64.whl", hash = "sha256:7821eda3ec1f18050f981819756631d60b6d7ab1a6cf806d9efefbe3f4082d61", size = 39153056, upload-time = "2025-12-08T18:15:33.938Z" },
+]
+
+[[package]]
+name = "macholib"
+version = "1.16.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "altgraph" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/10/2f/97589876ea967487978071c9042518d28b958d87b17dceb7cdc1d881f963/macholib-1.16.4.tar.gz", hash = "sha256:f408c93ab2e995cd2c46e34fe328b130404be143469e41bc366c807448979362", size = 59427, upload-time = "2025-11-22T08:28:38.373Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c7/d1/a9f36f8ecdf0fb7c9b1e78c8d7af12b8c8754e74851ac7b94a8305540fc7/macholib-1.16.4-py2.py3-none-any.whl", hash = "sha256:da1a3fa8266e30f0ce7e97c6a54eefaae8edd1e5f86f3eb8b95457cae90265ea", size = 38117, upload-time = "2025-11-22T08:28:36.939Z" },
+]
+
+[[package]]
+name = "mccabe"
+version = "0.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e7/ff/0ffefdcac38932a54d2b5eed4e0ba8a408f215002cd178ad1df0f2806ff8/mccabe-0.7.0.tar.gz", hash = "sha256:348e0240c33b60bbdf4e523192ef919f28cb2c3d7d5c7794f74009290f236325", size = 9658, upload-time = "2022-01-24T01:14:51.113Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/27/1a/1f68f9ba0c207934b35b86a8ca3aad8395a3d6dd7921c0686e23853ff5a9/mccabe-0.7.0-py2.py3-none-any.whl", hash = "sha256:6c2d30ab6be0e4a46919781807b4f0d834ebdd6c6e3dca0bda5a15f863427b6e", size = 7350, upload-time = "2022-01-24T01:14:49.62Z" },
+]
+
+[[package]]
+name = "nodejs-wheel-binaries"
+version = "24.14.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/71/05/c75c0940b1ebf82975d14f37176679b6f3229eae8b47b6a70d1e1dae0723/nodejs_wheel_binaries-24.14.0.tar.gz", hash = "sha256:c87b515e44b0e4a523017d8c59f26ccbd05b54fe593338582825d4b51fc91e1c", size = 8057, upload-time = "2026-02-27T02:57:30.931Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/58/8c/b057c2db3551a6fe04e93dd14e33d810ac8907891534ffcc7a051b253858/nodejs_wheel_binaries-24.14.0-py2.py3-none-macosx_13_0_arm64.whl", hash = "sha256:59bb78b8eb08c3e32186da1ef913f1c806b5473d8bd0bb4492702092747b674a", size = 54798488, upload-time = "2026-02-27T02:56:56.831Z" },
+    { url = "https://files.pythonhosted.org/packages/30/88/7e1b29c067b6625c97c81eb8b0ef37cf5ad5b62bb81e23f4bde804910ec9/nodejs_wheel_binaries-24.14.0-py2.py3-none-macosx_13_0_x86_64.whl", hash = "sha256:348fa061b57625de7250d608e2d9b7c4bc170544da7e328325343860eadd59e5", size = 54972803, upload-time = "2026-02-27T02:57:01.696Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/e0/a83f0ff12faca2a56366462e572e38ac6f5cb361877bb29e289138eb7f24/nodejs_wheel_binaries-24.14.0-py2.py3-none-manylinux_2_28_aarch64.whl", hash = "sha256:222dbf516ccc877afcad4e4789a81b4ee93daaa9f0ad97c464417d9597f49449", size = 59340859, upload-time = "2026-02-27T02:57:06.125Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/9f/06fad4ae8a723ae7096b5311eba67ad8b4df5f359c0a68e366750b7fef78/nodejs_wheel_binaries-24.14.0-py2.py3-none-manylinux_2_28_x86_64.whl", hash = "sha256:b35d6fcccfe4fb0a409392d237fbc67796bac0d357b996bc12d057a1531a238b", size = 59838751, upload-time = "2026-02-27T02:57:10.449Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/72/4916dadc7307c3e9bcfa43b4b6f88237932d502c66f89eb2d90fb07810db/nodejs_wheel_binaries-24.14.0-py2.py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:519507fb74f3f2b296ab1e9f00dcc211f36bbfb93c60229e72dcdee9dafd301a", size = 61340534, upload-time = "2026-02-27T02:57:15.309Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/df/a8ba881ee5d04b04e0d93abc8ce501ff7292813583e97f9789eb3fc0472a/nodejs_wheel_binaries-24.14.0-py2.py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:68c93c52ff06d704bcb5ed160b4ba04ab1b291d238aaf996b03a5396e0e9a7ed", size = 61922394, upload-time = "2026-02-27T02:57:20.24Z" },
+    { url = "https://files.pythonhosted.org/packages/60/8c/b8c5f61201c72a0c7dc694b459941f89a6defda85deff258a9940a4e2efc/nodejs_wheel_binaries-24.14.0-py2.py3-none-win_amd64.whl", hash = "sha256:60b83c4e98b0c7d836ac9ccb67dcb36e343691cbe62cd325799ff9ed936286f3", size = 41218783, upload-time = "2026-02-27T02:57:24.175Z" },
+    { url = "https://files.pythonhosted.org/packages/91/23/1f904bc9cbd8eece393e20840c08ba3ac03440090c3a4e95168fa6d2709f/nodejs_wheel_binaries-24.14.0-py2.py3-none-win_arm64.whl", hash = "sha256:78a9bd1d6b11baf1433f9fb84962ff8aa71c87d48b6434f98224bc49a2253a6e", size = 38926103, upload-time = "2026-02-27T02:57:27.458Z" },
+]
+
+[[package]]
+name = "numba"
+version = "0.64.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "llvmlite" },
+    { name = "numpy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/23/c9/a0fb41787d01d621046138da30f6c2100d80857bf34b3390dd68040f27a3/numba-0.64.0.tar.gz", hash = "sha256:95e7300af648baa3308127b1955b52ce6d11889d16e8cfe637b4f85d2fca52b1", size = 2765679, upload-time = "2026-02-18T18:41:20.974Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/89/a3/1a4286a1c16136c8896d8e2090d950e79b3ec626d3a8dc9620f6234d5a38/numba-0.64.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:766156ee4b8afeeb2b2e23c81307c5d19031f18d5ce76ae2c5fb1429e72fa92b", size = 2682938, upload-time = "2026-02-18T18:40:52.897Z" },
+    { url = "https://files.pythonhosted.org/packages/19/16/aa6e3ba3cd45435c117d1101b278b646444ed05b7c712af631b91353f573/numba-0.64.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d17071b4ffc9d39b75d8e6c101a36f0c81b646123859898c9799cb31807c8f78", size = 3747376, upload-time = "2026-02-18T18:40:54.925Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/f1/dd2f25e18d75fdf897f730b78c5a7b00cc4450f2405564dbebfaf359f21f/numba-0.64.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4ead5630434133bac87fa67526eacb264535e4e9a2d5ec780e0b4fc381a7d275", size = 3453292, upload-time = "2026-02-18T18:40:56.818Z" },
+    { url = "https://files.pythonhosted.org/packages/31/29/e09d5630578a50a2b3fa154990b6b839cf95327aa0709e2d50d0b6816cd1/numba-0.64.0-cp311-cp311-win_amd64.whl", hash = "sha256:f2b1fd93e7aaac07d6fbaed059c00679f591f2423885c206d8c1b55d65ca3f2d", size = 2749824, upload-time = "2026-02-18T18:40:58.392Z" },
+    { url = "https://files.pythonhosted.org/packages/70/a6/9fc52cb4f0d5e6d8b5f4d81615bc01012e3cf24e1052a60f17a68deb8092/numba-0.64.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:69440a8e8bc1a81028446f06b363e28635aa67bd51b1e498023f03b812e0ce68", size = 2683418, upload-time = "2026-02-18T18:40:59.886Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/89/1a74ea99b180b7a5587b0301ed1b183a2937c4b4b67f7994689b5d36fc34/numba-0.64.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f13721011f693ba558b8dd4e4db7f2640462bba1b855bdc804be45bbeb55031a", size = 3804087, upload-time = "2026-02-18T18:41:01.699Z" },
+    { url = "https://files.pythonhosted.org/packages/91/e1/583c647404b15f807410510fec1eb9b80cb8474165940b7749f026f21cbc/numba-0.64.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e0b180b1133f2b5d8b3f09d96b6d7a9e51a7da5dda3c09e998b5bcfac85d222c", size = 3504309, upload-time = "2026-02-18T18:41:03.252Z" },
+    { url = "https://files.pythonhosted.org/packages/85/23/0fce5789b8a5035e7ace21216a468143f3144e02013252116616c58339aa/numba-0.64.0-cp312-cp312-win_amd64.whl", hash = "sha256:e63dc94023b47894849b8b106db28ccb98b49d5498b98878fac1a38f83ac007a", size = 2752740, upload-time = "2026-02-18T18:41:05.097Z" },
+    { url = "https://files.pythonhosted.org/packages/52/80/2734de90f9300a6e2503b35ee50d9599926b90cbb7ac54f9e40074cd07f1/numba-0.64.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:3bab2c872194dcd985f1153b70782ec0fbbe348fffef340264eacd3a76d59fd6", size = 2683392, upload-time = "2026-02-18T18:41:06.563Z" },
+    { url = "https://files.pythonhosted.org/packages/42/e8/14b5853ebefd5b37723ef365c5318a30ce0702d39057eaa8d7d76392859d/numba-0.64.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:703a246c60832cad231d2e73c1182f25bf3cc8b699759ec8fe58a2dbc689a70c", size = 3812245, upload-time = "2026-02-18T18:41:07.963Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/a2/f60dc6c96d19b7185144265a5fbf01c14993d37ff4cd324b09d0212aa7ce/numba-0.64.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7e2e49a7900ee971d32af7609adc0cfe6aa7477c6f6cccdf6d8138538cf7756f", size = 3511328, upload-time = "2026-02-18T18:41:09.504Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/2a/fe7003ea7e7237ee7014f8eaeeb7b0d228a2db22572ca85bab2648cf52cb/numba-0.64.0-cp313-cp313-win_amd64.whl", hash = "sha256:396f43c3f77e78d7ec84cdfc6b04969c78f8f169351b3c4db814b97e7acf4245", size = 2752668, upload-time = "2026-02-18T18:41:11.455Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/8a/77d26afe0988c592dd97cb8d4e80bfb3dfc7dbdacfca7d74a7c5c81dd8c2/numba-0.64.0-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:f565d55eaeff382cbc86c63c8c610347453af3d1e7afb2b6569aac1c9b5c93ce", size = 2683590, upload-time = "2026-02-18T18:41:12.897Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/4b/600b8b7cdbc7f9cebee9ea3d13bb70052a79baf28944024ffcb59f0712e3/numba-0.64.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:9b55169b18892c783f85e9ad9e6f5297a6d12967e4414e6b71361086025ff0bb", size = 3781163, upload-time = "2026-02-18T18:41:15.377Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/73/53f2d32bfa45b7175e9944f6b816d8c32840178c3eee9325033db5bf838e/numba-0.64.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:196bcafa02c9dd1707e068434f6d5cedde0feb787e3432f7f1f0e993cc336c4c", size = 3481172, upload-time = "2026-02-18T18:41:17.281Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/00/aebd2f7f1e11e38814bb96e95a27580817a7b340608d3ac085fdbab83174/numba-0.64.0-cp314-cp314-win_amd64.whl", hash = "sha256:213e9acbe7f1c05090592e79020315c1749dd52517b90e94c517dca3f014d4a1", size = 2754700, upload-time = "2026-02-18T18:41:19.277Z" },
+]
+
+[[package]]
+name = "numpy"
+version = "2.4.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/10/8b/c265f4823726ab832de836cdd184d0986dcf94480f81e8739692a7ac7af2/numpy-2.4.3.tar.gz", hash = "sha256:483a201202b73495f00dbc83796c6ae63137a9bdade074f7648b3e32613412dd", size = 20727743, upload-time = "2026-03-09T07:58:53.426Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f9/51/5093a2df15c4dc19da3f79d1021e891f5dcf1d9d1db6ba38891d5590f3fe/numpy-2.4.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:33b3bf58ee84b172c067f56aeadc7ee9ab6de69c5e800ab5b10295d54c581adb", size = 16957183, upload-time = "2026-03-09T07:55:57.774Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/7c/c061f3de0630941073d2598dc271ac2f6cbcf5c83c74a5870fea07488333/numpy-2.4.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:8ba7b51e71c05aa1f9bc3641463cd82308eab40ce0d5c7e1fd4038cbf9938147", size = 14968734, upload-time = "2026-03-09T07:56:00.494Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/27/d26c85cbcd86b26e4f125b0668e7a7c0542d19dd7d23ee12e87b550e95b5/numpy-2.4.3-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:a1988292870c7cb9d0ebb4cc96b4d447513a9644801de54606dc7aabf2b7d920", size = 5475288, upload-time = "2026-03-09T07:56:02.857Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/09/3c4abbc1dcd8010bf1a611d174c7aa689fc505585ec806111b4406f6f1b1/numpy-2.4.3-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:23b46bb6d8ecb68b58c09944483c135ae5f0e9b8d8858ece5e4ead783771d2a9", size = 6805253, upload-time = "2026-03-09T07:56:04.53Z" },
+    { url = "https://files.pythonhosted.org/packages/21/bc/e7aa3f6817e40c3f517d407742337cbb8e6fc4b83ce0b55ab780c829243b/numpy-2.4.3-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a016db5c5dba78fa8fe9f5d80d6708f9c42ab087a739803c0ac83a43d686a470", size = 15969479, upload-time = "2026-03-09T07:56:06.638Z" },
+    { url = "https://files.pythonhosted.org/packages/78/51/9f5d7a41f0b51649ddf2f2320595e15e122a40610b233d51928dd6c92353/numpy-2.4.3-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:715de7f82e192e8cae5a507a347d97ad17598f8e026152ca97233e3666daaa71", size = 16901035, upload-time = "2026-03-09T07:56:09.405Z" },
+    { url = "https://files.pythonhosted.org/packages/64/6e/b221dd847d7181bc5ee4857bfb026182ef69499f9305eb1371cbb1aea626/numpy-2.4.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:2ddb7919366ee468342b91dea2352824c25b55814a987847b6c52003a7c97f15", size = 17325657, upload-time = "2026-03-09T07:56:12.067Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/b8/8f3fd2da596e1063964b758b5e3c970aed1949a05200d7e3d46a9d46d643/numpy-2.4.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a315e5234d88067f2d97e1f2ef670a7569df445d55400f1e33d117418d008d52", size = 18635512, upload-time = "2026-03-09T07:56:14.629Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/24/2993b775c37e39d2f8ab4125b44337ab0b2ba106c100980b7c274a22bee7/numpy-2.4.3-cp311-cp311-win32.whl", hash = "sha256:2b3f8d2c4589b1a2028d2a770b0fc4d1f332fb5e01521f4de3199a896d158ddd", size = 6238100, upload-time = "2026-03-09T07:56:17.243Z" },
+    { url = "https://files.pythonhosted.org/packages/76/1d/edccf27adedb754db7c4511d5eac8b83f004ae948fe2d3509e8b78097d4c/numpy-2.4.3-cp311-cp311-win_amd64.whl", hash = "sha256:77e76d932c49a75617c6d13464e41203cd410956614d0a0e999b25e9e8d27eec", size = 12609816, upload-time = "2026-03-09T07:56:19.089Z" },
+    { url = "https://files.pythonhosted.org/packages/92/82/190b99153480076c8dce85f4cfe7d53ea84444145ffa54cb58dcd460d66b/numpy-2.4.3-cp311-cp311-win_arm64.whl", hash = "sha256:eb610595dd91560905c132c709412b512135a60f1851ccbd2c959e136431ff67", size = 10485757, upload-time = "2026-03-09T07:56:21.753Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/ed/6388632536f9788cea23a3a1b629f25b43eaacd7d7377e5d6bc7b9deb69b/numpy-2.4.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:61b0cbabbb6126c8df63b9a3a0c4b1f44ebca5e12ff6997b80fcf267fb3150ef", size = 16669628, upload-time = "2026-03-09T07:56:24.252Z" },
+    { url = "https://files.pythonhosted.org/packages/74/1b/ee2abfc68e1ce728b2958b6ba831d65c62e1b13ce3017c13943f8f9b5b2e/numpy-2.4.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7395e69ff32526710748f92cd8c9849b361830968ea3e24a676f272653e8983e", size = 14696872, upload-time = "2026-03-09T07:56:26.991Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/d1/780400e915ff5638166f11ca9dc2c5815189f3d7cf6f8759a1685e586413/numpy-2.4.3-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:abdce0f71dcb4a00e4e77f3faf05e4616ceccfe72ccaa07f47ee79cda3b7b0f4", size = 5203489, upload-time = "2026-03-09T07:56:29.414Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/bb/baffa907e9da4cc34a6e556d6d90e032f6d7a75ea47968ea92b4858826c4/numpy-2.4.3-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:48da3a4ee1336454b07497ff7ec83903efa5505792c4e6d9bf83d99dc07a1e18", size = 6550814, upload-time = "2026-03-09T07:56:32.225Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/12/8c9f0c6c95f76aeb20fc4a699c33e9f827fa0d0f857747c73bb7b17af945/numpy-2.4.3-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:32e3bef222ad6b052280311d1d60db8e259e4947052c3ae7dd6817451fc8a4c5", size = 15666601, upload-time = "2026-03-09T07:56:34.461Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/79/cc665495e4d57d0aa6fbcc0aa57aa82671dfc78fbf95fe733ed86d98f52a/numpy-2.4.3-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e7dd01a46700b1967487141a66ac1a3cf0dd8ebf1f08db37d46389401512ca97", size = 16621358, upload-time = "2026-03-09T07:56:36.852Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/40/b4ecb7224af1065c3539f5ecfff879d090de09608ad1008f02c05c770cb3/numpy-2.4.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:76f0f283506c28b12bba319c0fab98217e9f9b54e6160e9c79e9f7348ba32e9c", size = 17016135, upload-time = "2026-03-09T07:56:39.337Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/b1/6a88e888052eed951afed7a142dcdf3b149a030ca59b4c71eef085858e43/numpy-2.4.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:737f630a337364665aba3b5a77e56a68cc42d350edd010c345d65a3efa3addcc", size = 18345816, upload-time = "2026-03-09T07:56:42.31Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/8f/103a60c5f8c3d7fc678c19cd7b2476110da689ccb80bc18050efbaeae183/numpy-2.4.3-cp312-cp312-win32.whl", hash = "sha256:26952e18d82a1dbbc2f008d402021baa8d6fc8e84347a2072a25e08b46d698b9", size = 5960132, upload-time = "2026-03-09T07:56:44.851Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/7c/f5ee1bf6ed888494978046a809df2882aad35d414b622893322df7286879/numpy-2.4.3-cp312-cp312-win_amd64.whl", hash = "sha256:65f3c2455188f09678355f5cae1f959a06b778bc66d535da07bf2ef20cd319d5", size = 12316144, upload-time = "2026-03-09T07:56:47.057Z" },
+    { url = "https://files.pythonhosted.org/packages/71/46/8d1cb3f7a00f2fb6394140e7e6623696e54c6318a9d9691bb4904672cf42/numpy-2.4.3-cp312-cp312-win_arm64.whl", hash = "sha256:2abad5c7fef172b3377502bde47892439bae394a71bc329f31df0fd829b41a9e", size = 10220364, upload-time = "2026-03-09T07:56:49.849Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/d0/1fe47a98ce0df229238b77611340aff92d52691bcbc10583303181abf7fc/numpy-2.4.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:b346845443716c8e542d54112966383b448f4a3ba5c66409771b8c0889485dd3", size = 16665297, upload-time = "2026-03-09T07:56:52.296Z" },
+    { url = "https://files.pythonhosted.org/packages/27/d9/4e7c3f0e68dfa91f21c6fb6cf839bc829ec920688b1ce7ec722b1a6202fb/numpy-2.4.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2629289168f4897a3c4e23dc98d6f1731f0fc0fe52fb9db19f974041e4cc12b9", size = 14691853, upload-time = "2026-03-09T07:56:54.992Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/66/bd096b13a87549683812b53ab211e6d413497f84e794fb3c39191948da97/numpy-2.4.3-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:bb2e3cf95854233799013779216c57e153c1ee67a0bf92138acca0e429aefaee", size = 5198435, upload-time = "2026-03-09T07:56:57.184Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/2f/687722910b5a5601de2135c891108f51dfc873d8e43c8ed9f4ebb440b4a2/numpy-2.4.3-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:7f3408ff897f8ab07a07fbe2823d7aee6ff644c097cc1f90382511fe982f647f", size = 6546347, upload-time = "2026-03-09T07:56:59.531Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/ec/7971c4e98d86c564750393fab8d7d83d0a9432a9d78bb8a163a6dc59967a/numpy-2.4.3-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:decb0eb8a53c3b009b0962378065589685d66b23467ef5dac16cbe818afde27f", size = 15664626, upload-time = "2026-03-09T07:57:01.385Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/eb/7daecbea84ec935b7fc732e18f532073064a3816f0932a40a17f3349185f/numpy-2.4.3-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d5f51900414fc9204a0e0da158ba2ac52b75656e7dce7e77fb9f84bfa343b4cc", size = 16608916, upload-time = "2026-03-09T07:57:04.008Z" },
+    { url = "https://files.pythonhosted.org/packages/df/58/2a2b4a817ffd7472dca4421d9f0776898b364154e30c95f42195041dc03b/numpy-2.4.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:6bd06731541f89cdc01b261ba2c9e037f1543df7472517836b78dfb15bd6e476", size = 17015824, upload-time = "2026-03-09T07:57:06.347Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/ca/627a828d44e78a418c55f82dd4caea8ea4a8ef24e5144d9e71016e52fb40/numpy-2.4.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:22654fe6be0e5206f553a9250762c653d3698e46686eee53b399ab90da59bd92", size = 18334581, upload-time = "2026-03-09T07:57:09.114Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/c0/76f93962fc79955fcba30a429b62304332345f22d4daec1cb33653425643/numpy-2.4.3-cp313-cp313-win32.whl", hash = "sha256:d71e379452a2f670ccb689ec801b1218cd3983e253105d6e83780967e899d687", size = 5958618, upload-time = "2026-03-09T07:57:11.432Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/3c/88af0040119209b9b5cb59485fa48b76f372c73068dbf9254784b975ac53/numpy-2.4.3-cp313-cp313-win_amd64.whl", hash = "sha256:0a60e17a14d640f49146cb38e3f105f571318db7826d9b6fef7e4dce758faecd", size = 12312824, upload-time = "2026-03-09T07:57:13.586Z" },
+    { url = "https://files.pythonhosted.org/packages/58/ce/3d07743aced3d173f877c3ef6a454c2174ba42b584ab0b7e6d99374f51ed/numpy-2.4.3-cp313-cp313-win_arm64.whl", hash = "sha256:c9619741e9da2059cd9c3f206110b97583c7152c1dc9f8aafd4beb450ac1c89d", size = 10221218, upload-time = "2026-03-09T07:57:16.183Z" },
+    { url = "https://files.pythonhosted.org/packages/62/09/d96b02a91d09e9d97862f4fc8bfebf5400f567d8eb1fe4b0cc4795679c15/numpy-2.4.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:7aa4e54f6469300ebca1d9eb80acd5253cdfa36f2c03d79a35883687da430875", size = 14819570, upload-time = "2026-03-09T07:57:18.564Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/ca/0b1aba3905fdfa3373d523b2b15b19029f4f3031c87f4066bd9d20ef6c6b/numpy-2.4.3-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:d1b90d840b25874cf5cd20c219af10bac3667db3876d9a495609273ebe679070", size = 5326113, upload-time = "2026-03-09T07:57:21.052Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/63/406e0fd32fcaeb94180fd6a4c41e55736d676c54346b7efbce548b94a914/numpy-2.4.3-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:a749547700de0a20a6718293396ec237bb38218049cfce788e08fcb716e8cf73", size = 6646370, upload-time = "2026-03-09T07:57:22.804Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/d0/10f7dc157d4b37af92720a196be6f54f889e90dcd30dce9dc657ed92c257/numpy-2.4.3-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:94f3c4a151a2e529adf49c1d54f0f57ff8f9b233ee4d44af623a81553ab86368", size = 15723499, upload-time = "2026-03-09T07:57:24.693Z" },
+    { url = "https://files.pythonhosted.org/packages/66/f1/d1c2bf1161396629701bc284d958dc1efa3a5a542aab83cf11ee6eb4cba5/numpy-2.4.3-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:22c31dc07025123aedf7f2db9e91783df13f1776dc52c6b22c620870dc0fab22", size = 16657164, upload-time = "2026-03-09T07:57:27.676Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/be/cca19230b740af199ac47331a21c71e7a3d0ba59661350483c1600d28c37/numpy-2.4.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:148d59127ac95979d6f07e4d460f934ebdd6eed641db9c0db6c73026f2b2101a", size = 17081544, upload-time = "2026-03-09T07:57:30.664Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/c5/9602b0cbb703a0936fb40f8a95407e8171935b15846de2f0776e08af04c7/numpy-2.4.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:a97cbf7e905c435865c2d939af3d93f99d18eaaa3cabe4256f4304fb51604349", size = 18380290, upload-time = "2026-03-09T07:57:33.763Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/81/9f24708953cd30be9ee36ec4778f4b112b45165812f2ada4cc5ea1c1f254/numpy-2.4.3-cp313-cp313t-win32.whl", hash = "sha256:be3b8487d725a77acccc9924f65fd8bce9af7fac8c9820df1049424a2115af6c", size = 6082814, upload-time = "2026-03-09T07:57:36.491Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/9e/52f6eaa13e1a799f0ab79066c17f7016a4a8ae0c1aefa58c82b4dab690b4/numpy-2.4.3-cp313-cp313t-win_amd64.whl", hash = "sha256:1ec84fd7c8e652b0f4aaaf2e6e9cc8eaa9b1b80a537e06b2e3a2fb176eedcb26", size = 12452673, upload-time = "2026-03-09T07:57:38.281Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/04/b8cece6ead0b30c9fbd99bb835ad7ea0112ac5f39f069788c5558e3b1ab2/numpy-2.4.3-cp313-cp313t-win_arm64.whl", hash = "sha256:120df8c0a81ebbf5b9020c91439fccd85f5e018a927a39f624845be194a2be02", size = 10290907, upload-time = "2026-03-09T07:57:40.747Z" },
+    { url = "https://files.pythonhosted.org/packages/70/ae/3936f79adebf8caf81bd7a599b90a561334a658be4dcc7b6329ebf4ee8de/numpy-2.4.3-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:5884ce5c7acfae1e4e1b6fde43797d10aa506074d25b531b4f54bde33c0c31d4", size = 16664563, upload-time = "2026-03-09T07:57:43.817Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/62/760f2b55866b496bb1fa7da2a6db076bef908110e568b02fcfc1422e2a3a/numpy-2.4.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:297837823f5bc572c5f9379b0c9f3a3365f08492cbdc33bcc3af174372ebb168", size = 14702161, upload-time = "2026-03-09T07:57:46.169Z" },
+    { url = "https://files.pythonhosted.org/packages/32/af/a7a39464e2c0a21526fb4fb76e346fb172ebc92f6d1c7a07c2c139cc17b1/numpy-2.4.3-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:a111698b4a3f8dcbe54c64a7708f049355abd603e619013c346553c1fd4ca90b", size = 5208738, upload-time = "2026-03-09T07:57:48.506Z" },
+    { url = "https://files.pythonhosted.org/packages/29/8c/2a0cf86a59558fa078d83805589c2de490f29ed4fb336c14313a161d358a/numpy-2.4.3-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:4bd4741a6a676770e0e97fe9ab2e51de01183df3dcbcec591d26d331a40de950", size = 6543618, upload-time = "2026-03-09T07:57:50.591Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/b8/612ce010c0728b1c363fa4ea3aa4c22fe1c5da1de008486f8c2f5cb92fae/numpy-2.4.3-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:54f29b877279d51e210e0c80709ee14ccbbad647810e8f3d375561c45ef613dd", size = 15680676, upload-time = "2026-03-09T07:57:52.34Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/7e/4f120ecc54ba26ddf3dc348eeb9eb063f421de65c05fc961941798feea18/numpy-2.4.3-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:679f2a834bae9020f81534671c56fd0cc76dd7e5182f57131478e23d0dc59e24", size = 16613492, upload-time = "2026-03-09T07:57:54.91Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/86/1b6020db73be330c4b45d5c6ee4295d59cfeef0e3ea323959d053e5a6909/numpy-2.4.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:d84f0f881cb2225c2dfd7f78a10a5645d487a496c6668d6cc39f0f114164f3d0", size = 17031789, upload-time = "2026-03-09T07:57:57.641Z" },
+    { url = "https://files.pythonhosted.org/packages/07/3a/3b90463bf41ebc21d1b7e06079f03070334374208c0f9a1f05e4ae8455e7/numpy-2.4.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:d213c7e6e8d211888cc359bab7199670a00f5b82c0978b9d1c75baf1eddbeac0", size = 18339941, upload-time = "2026-03-09T07:58:00.577Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/74/6d736c4cd962259fd8bae9be27363eb4883a2f9069763747347544c2a487/numpy-2.4.3-cp314-cp314-win32.whl", hash = "sha256:52077feedeff7c76ed7c9f1a0428558e50825347b7545bbb8523da2cd55c547a", size = 6007503, upload-time = "2026-03-09T07:58:03.331Z" },
+    { url = "https://files.pythonhosted.org/packages/48/39/c56ef87af669364356bb011922ef0734fc49dad51964568634c72a009488/numpy-2.4.3-cp314-cp314-win_amd64.whl", hash = "sha256:0448e7f9caefb34b4b7dd2b77f21e8906e5d6f0365ad525f9f4f530b13df2afc", size = 12444915, upload-time = "2026-03-09T07:58:06.353Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/1f/ab8528e38d295fd349310807496fabb7cf9fe2e1f70b97bc20a483ea9d4a/numpy-2.4.3-cp314-cp314-win_arm64.whl", hash = "sha256:b44fd60341c4d9783039598efadd03617fa28d041fc37d22b62d08f2027fa0e7", size = 10494875, upload-time = "2026-03-09T07:58:08.734Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/ef/b7c35e4d5ef141b836658ab21a66d1a573e15b335b1d111d31f26c8ef80f/numpy-2.4.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0a195f4216be9305a73c0e91c9b026a35f2161237cf1c6de9b681637772ea657", size = 14822225, upload-time = "2026-03-09T07:58:11.034Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/8d/7730fa9278cf6648639946cc816e7cc89f0d891602584697923375f801ed/numpy-2.4.3-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:cd32fbacb9fd1bf041bf8e89e4576b6f00b895f06d00914820ae06a616bdfef7", size = 5328769, upload-time = "2026-03-09T07:58:13.67Z" },
+    { url = "https://files.pythonhosted.org/packages/47/01/d2a137317c958b074d338807c1b6a383406cdf8b8e53b075d804cc3d211d/numpy-2.4.3-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:2e03c05abaee1f672e9d67bc858f300b5ccba1c21397211e8d77d98350972093", size = 6649461, upload-time = "2026-03-09T07:58:15.912Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/34/812ce12bc0f00272a4b0ec0d713cd237cb390666eb6206323d1cc9cedbb2/numpy-2.4.3-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7d1ce23cce91fcea443320a9d0ece9b9305d4368875bab09538f7a5b4131938a", size = 15725809, upload-time = "2026-03-09T07:58:17.787Z" },
+    { url = "https://files.pythonhosted.org/packages/25/c0/2aed473a4823e905e765fee3dc2cbf504bd3e68ccb1150fbdabd5c39f527/numpy-2.4.3-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c59020932feb24ed49ffd03704fbab89f22aa9c0d4b180ff45542fe8918f5611", size = 16655242, upload-time = "2026-03-09T07:58:20.476Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/c8/7e052b2fc87aa0e86de23f20e2c42bd261c624748aa8efd2c78f7bb8d8c6/numpy-2.4.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:9684823a78a6cd6ad7511fc5e25b07947d1d5b5e2812c93fe99d7d4195130720", size = 17080660, upload-time = "2026-03-09T07:58:23.067Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/3d/0876746044db2adcb11549f214d104f2e1be00f07a67edbb4e2812094847/numpy-2.4.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:0200b25c687033316fb39f0ff4e3e690e8957a2c3c8d22499891ec58c37a3eb5", size = 18380384, upload-time = "2026-03-09T07:58:25.839Z" },
+    { url = "https://files.pythonhosted.org/packages/07/12/8160bea39da3335737b10308df4f484235fd297f556745f13092aa039d3b/numpy-2.4.3-cp314-cp314t-win32.whl", hash = "sha256:5e10da9e93247e554bb1d22f8edc51847ddd7dde52d85ce31024c1b4312bfba0", size = 6154547, upload-time = "2026-03-09T07:58:28.289Z" },
+    { url = "https://files.pythonhosted.org/packages/42/f3/76534f61f80d74cc9cdf2e570d3d4eeb92c2280a27c39b0aaf471eda7b48/numpy-2.4.3-cp314-cp314t-win_amd64.whl", hash = "sha256:45f003dbdffb997a03da2d1d0cb41fbd24a87507fb41605c0420a3db5bd4667b", size = 12633645, upload-time = "2026-03-09T07:58:30.384Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/b6/7c0d4334c15983cec7f92a69e8ce9b1e6f31857e5ee3a413ac424e6bd63d/numpy-2.4.3-cp314-cp314t-win_arm64.whl", hash = "sha256:4d382735cecd7bcf090172489a525cd7d4087bc331f7df9f60ddc9a296cf208e", size = 10565454, upload-time = "2026-03-09T07:58:33.031Z" },
+    { url = "https://files.pythonhosted.org/packages/64/e4/4dab9fb43c83719c29241c535d9e07be73bea4bc0c6686c5816d8e1b6689/numpy-2.4.3-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:c6b124bfcafb9e8d3ed09130dbee44848c20b3e758b6bbf006e641778927c028", size = 16834892, upload-time = "2026-03-09T07:58:35.334Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/29/f8b6d4af90fed3dfda84ebc0df06c9833d38880c79ce954e5b661758aa31/numpy-2.4.3-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:76dbb9d4e43c16cf9aa711fcd8de1e2eeb27539dcefb60a1d5e9f12fae1d1ed8", size = 14893070, upload-time = "2026-03-09T07:58:37.7Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/04/a19b3c91dbec0a49269407f15d5753673a09832daed40c45e8150e6fa558/numpy-2.4.3-pp311-pypy311_pp73-macosx_14_0_arm64.whl", hash = "sha256:29363fbfa6f8ee855d7569c96ce524845e3d726d6c19b29eceec7dd555dab152", size = 5399609, upload-time = "2026-03-09T07:58:39.853Z" },
+    { url = "https://files.pythonhosted.org/packages/79/34/4d73603f5420eab89ea8a67097b31364bf7c30f811d4dd84b1659c7476d9/numpy-2.4.3-pp311-pypy311_pp73-macosx_14_0_x86_64.whl", hash = "sha256:bc71942c789ef415a37f0d4eab90341425a00d538cd0642445d30b41023d3395", size = 6714355, upload-time = "2026-03-09T07:58:42.365Z" },
+    { url = "https://files.pythonhosted.org/packages/58/ad/1100d7229bb248394939a12a8074d485b655e8ed44207d328fdd7fcebc7b/numpy-2.4.3-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7e58765ad74dcebd3ef0208a5078fba32dc8ec3578fe84a604432950cd043d79", size = 15800434, upload-time = "2026-03-09T07:58:44.837Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/fd/16d710c085d28ba4feaf29ac60c936c9d662e390344f94a6beaa2ac9899b/numpy-2.4.3-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8e236dbda4e1d319d681afcbb136c0c4a8e0f1a5c58ceec2adebb547357fe857", size = 16729409, upload-time = "2026-03-09T07:58:47.972Z" },
+    { url = "https://files.pythonhosted.org/packages/57/a7/b35835e278c18b85206834b3aa3abe68e77a98769c59233d1f6300284781/numpy-2.4.3-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:4b42639cdde6d24e732ff823a3fa5b701d8acad89c4142bc1d0bd6dc85200ba5", size = 12504685, upload-time = "2026-03-09T07:58:50.525Z" },
+]
+
+[[package]]
+name = "packaging"
+version = "26.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/65/ee/299d360cdc32edc7d2cf530f3accf79c4fca01e96ffc950d8a52213bd8e4/packaging-26.0.tar.gz", hash = "sha256:00243ae351a257117b6a241061796684b084ed1c516a08c48a3f7e147a9d80b4", size = 143416, upload-time = "2026-01-21T20:50:39.064Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b7/b9/c538f279a4e237a006a2c98387d081e9eb060d203d8ed34467cc0f0b9b53/packaging-26.0-py3-none-any.whl", hash = "sha256:b36f1fef9334a5588b4166f8bcd26a14e521f2b55e6b9de3aaa80d3ff7a37529", size = 74366, upload-time = "2026-01-21T20:50:37.788Z" },
+]
+
+[[package]]
+name = "pefile"
+version = "2024.8.26"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/03/4f/2750f7f6f025a1507cd3b7218691671eecfd0bbebebe8b39aa0fe1d360b8/pefile-2024.8.26.tar.gz", hash = "sha256:3ff6c5d8b43e8c37bb6e6dd5085658d658a7a0bdcd20b6a07b1fcfc1c4e9d632", size = 76008, upload-time = "2024-08-26T20:58:38.155Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/16/12b82f791c7f50ddec566873d5bdd245baa1491bac11d15ffb98aecc8f8b/pefile-2024.8.26-py3-none-any.whl", hash = "sha256:76f8b485dcd3b1bb8166f1128d395fa3d87af26360c2358fb75b80019b957c6f", size = 74766, upload-time = "2024-08-26T21:01:02.632Z" },
+]
+
+[[package]]
+name = "pluggy"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
+]
+
+[[package]]
+name = "pycodestyle"
+version = "2.14.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/11/e0/abfd2a0d2efe47670df87f3e3a0e2edda42f055053c85361f19c0e2c1ca8/pycodestyle-2.14.0.tar.gz", hash = "sha256:c4b5b517d278089ff9d0abdec919cd97262a3367449ea1c8b49b91529167b783", size = 39472, upload-time = "2025-06-20T18:49:48.75Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d7/27/a58ddaf8c588a3ef080db9d0b7e0b97215cee3a45df74f3a94dbbf5c893a/pycodestyle-2.14.0-py2.py3-none-any.whl", hash = "sha256:dd6bf7cb4ee77f8e016f9c8e74a35ddd9f67e1d5fd4184d86c3b98e07099f42d", size = 31594, upload-time = "2025-06-20T18:49:47.491Z" },
+]
+
+[[package]]
+name = "pyflakes"
+version = "3.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/45/dc/fd034dc20b4b264b3d015808458391acbf9df40b1e54750ef175d39180b1/pyflakes-3.4.0.tar.gz", hash = "sha256:b24f96fafb7d2ab0ec5075b7350b3d2d2218eab42003821c06344973d3ea2f58", size = 64669, upload-time = "2025-06-20T18:45:27.834Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c2/2f/81d580a0fb83baeb066698975cb14a618bdbed7720678566f1b046a95fe8/pyflakes-3.4.0-py2.py3-none-any.whl", hash = "sha256:f742a7dbd0d9cb9ea41e9a24a918996e8170c799fa528688d40dd582c8265f4f", size = 63551, upload-time = "2025-06-20T18:45:26.937Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.19.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631, upload-time = "2025-06-21T13:39:12.283Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" },
+]
+
+[[package]]
+name = "pyinstaller"
+version = "6.19.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "altgraph" },
+    { name = "macholib", marker = "sys_platform == 'darwin'" },
+    { name = "packaging" },
+    { name = "pefile", marker = "sys_platform == 'win32'" },
+    { name = "pyinstaller-hooks-contrib" },
+    { name = "pywin32-ctypes", marker = "sys_platform == 'win32'" },
+    { name = "setuptools" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c8/63/fd62472b6371d89dc138d40c36d87a50dc2de18a035803bbdc376b4ffac4/pyinstaller-6.19.0.tar.gz", hash = "sha256:ec73aeb8bd9b7f2f1240d328a4542e90b3c6e6fbc106014778431c616592a865", size = 4036072, upload-time = "2026-02-14T18:06:28.718Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e3/eb/23374721fecfa72677e79800921cb6aceefa6ba48574dc404f3f6c6c3be7/pyinstaller-6.19.0-py3-none-macosx_10_13_universal2.whl", hash = "sha256:4190e76b74f0c4b5c5f11ac360928cd2e36ec8e3194d437bf6b8648c7bc0c134", size = 1040563, upload-time = "2026-02-14T18:05:22.436Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/7e/dfd724b0b533f5aaec0ee5df406fe2319987ed6964480a706f85478b12ea/pyinstaller-6.19.0-py3-none-manylinux2014_aarch64.whl", hash = "sha256:8bd68abd812d8a6ba33b9f1810e91fee0f325969733721b78151f0065319ca11", size = 735477, upload-time = "2026-02-14T18:05:27.143Z" },
+    { url = "https://files.pythonhosted.org/packages/88/c9/ee3a4101c31f26344e66896c73c1fd6ed8282bf871473365b7f8674af406/pyinstaller-6.19.0-py3-none-manylinux2014_i686.whl", hash = "sha256:1ec54ef967996ca61dacba676227e2b23219878ccce5ee9d6f3aada7b8ed8abf", size = 747143, upload-time = "2026-02-14T18:05:31.488Z" },
+    { url = "https://files.pythonhosted.org/packages/da/0a/fc77e9f861be8cf300ac37155f59cc92aff99b29f2ddd78546f563a5b5a6/pyinstaller-6.19.0-py3-none-manylinux2014_ppc64le.whl", hash = "sha256:4ab2bb52e58448e14ddf9450601bdedd66800465043501c1d8f1cab87b60b122", size = 744849, upload-time = "2026-02-14T18:05:35.492Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/e3/6872e020ee758afe0b821663858492c10745608b07150e5e2c824a5b3e1c/pyinstaller-6.19.0-py3-none-manylinux2014_s390x.whl", hash = "sha256:da6d5c6391ccefe73554b9fa29b86001c8e378e0f20c2a4004f836ba537eff63", size = 741590, upload-time = "2026-02-14T18:05:39.59Z" },
+    { url = "https://files.pythonhosted.org/packages/53/60/b8db5f1a4b0fb228175f2ea0aa33f949adcc097fbe981cc524f9faf85777/pyinstaller-6.19.0-py3-none-manylinux2014_x86_64.whl", hash = "sha256:a0fc5f6b3c55aa54353f0c74ffa59b1115433c1850c6f655d62b461a2ed6cbbe", size = 741448, upload-time = "2026-02-14T18:05:45.636Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/4d/63b0600f2694e9141b83129fbc1c488ec84d5a0770b1448ec154dcd0fee9/pyinstaller-6.19.0-py3-none-musllinux_1_1_aarch64.whl", hash = "sha256:e649ba6bd1b0b89b210ad92adb5fbdc8a42dd2c5ca4f72ef3a0bfec83a424b83", size = 740613, upload-time = "2026-02-14T18:05:49.726Z" },
+    { url = "https://files.pythonhosted.org/packages/01/d4/e812ad36178093a0e9fd4b8127577748dd85b0cb71de912229dca21fd741/pyinstaller-6.19.0-py3-none-musllinux_1_1_x86_64.whl", hash = "sha256:481a909c8e60c8692fc60fcb1344d984b44b943f8bc9682f2fcdae305ad297e6", size = 740350, upload-time = "2026-02-14T18:05:54.093Z" },
+    { url = "https://files.pythonhosted.org/packages/52/03/b2c2ee41fb8e10fd2a45d21f5ec2ef25852cfb978dbf762972eed59e3d63/pyinstaller-6.19.0-py3-none-win32.whl", hash = "sha256:3c5c251054fe4cfaa04c34a363dcfbf811545438cb7198304cd444756bc2edd2", size = 1324317, upload-time = "2026-02-14T18:06:00.085Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/d3/6d5e62b8270e2b53a6065e281b3a7785079b00e9019c8019952828dd1669/pyinstaller-6.19.0-py3-none-win_amd64.whl", hash = "sha256:b5bb6536c6560330d364d91522250f254b107cf69129d9cbcd0e6727c570be33", size = 1384894, upload-time = "2026-02-14T18:06:06.425Z" },
+    { url = "https://files.pythonhosted.org/packages/81/65/458cd523308a101a22fd2742893405030cc24994cc74b1b767cecf137160/pyinstaller-6.19.0-py3-none-win_arm64.whl", hash = "sha256:c2d5a539b0bfe6159d5522c8c70e1c0e487f22c2badae0f97d45246223b798ea", size = 1325374, upload-time = "2026-02-14T18:06:12.804Z" },
+]
+
+[[package]]
+name = "pyinstaller-hooks-contrib"
+version = "2026.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "packaging" },
+    { name = "setuptools" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/80/17/716326f6ba18d0663f7995ae369c23e50efebc22fbb054e9710a45688f61/pyinstaller_hooks_contrib-2026.3.tar.gz", hash = "sha256:800d3a198a49a6cd0de2d7fb795005fdca7a0222ed9cb47c0691abd1c27b9310", size = 172323, upload-time = "2026-03-09T22:44:06.345Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ed/19/781352446af28755f16ce52b2d97f7a6f2d7974ac34c00ca5cd8c40c9098/pyinstaller_hooks_contrib-2026.3-py3-none-any.whl", hash = "sha256:5ecd1068ad262afecadf07556279d2be52ca93a88b049fae17f1a2eb2969254a", size = 454625, upload-time = "2026-03-09T22:44:04.717Z" },
+]
+
+[[package]]
+name = "pyqt6"
+version = "6.10.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pyqt6-qt6" },
+    { name = "pyqt6-sip" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/96/03/e756f52e8b0d7bb5527baf8c46d59af0746391943bdb8655acba22ee4168/pyqt6-6.10.2.tar.gz", hash = "sha256:6c0db5d8cbb9a3e7e2b5b51d0ff3f283121fa27b864db6d2f35b663c9be5cc83", size = 1085573, upload-time = "2026-01-08T16:40:00.244Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fb/3f/f073a980969aa485ef288eb2e3b94c223ba9c7ac9941543f19b51659b98d/pyqt6-6.10.2-cp39-abi3-macosx_10_14_universal2.whl", hash = "sha256:37ae7c1183fe4dd0c6aefd2006a35731245de1cb6f817bb9e414a3e4848dfd6d", size = 60244482, upload-time = "2026-01-08T16:38:50.837Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/3e/9a015651ec71cea2e2f960c37edeb21623ba96a74956c0827def837f7c6b/pyqt6-6.10.2-cp39-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:78e1b3d5763e4cbc84485aef600e0aba5e1932fd263b716f92cd1a40dfa5e924", size = 37899440, upload-time = "2026-01-08T16:39:09.027Z" },
+    { url = "https://files.pythonhosted.org/packages/51/74/a88fec2b99700270ca5d7dc7d650236a4990ed6fc88e055ca0fc8a339ee3/pyqt6-6.10.2-cp39-abi3-manylinux_2_39_aarch64.whl", hash = "sha256:bbc3af541bbecd27301bfe69fe445aa1611a9b490bd3de77306b12df632f7ec6", size = 40748467, upload-time = "2026-01-08T16:39:29.551Z" },
+    { url = "https://files.pythonhosted.org/packages/75/34/be7a55529607b21db00a49ca53cb07c3092d2a5a95ea19bb95cfa0346904/pyqt6-6.10.2-cp39-abi3-win_amd64.whl", hash = "sha256:bd328cb70bc382c48861cd5f0a11b2b8ae6f5692d5a2d6679ba52785dced327b", size = 26015391, upload-time = "2026-01-08T16:39:42.946Z" },
+    { url = "https://files.pythonhosted.org/packages/af/de/d9c88f976602b7884fec4ad54a4575d48e23e4f390e5357ea83917358846/pyqt6-6.10.2-cp39-abi3-win_arm64.whl", hash = "sha256:7901ba1df024b7ee9fdacfb2b7661aeb3749ae8b0bef65428077de3e0450eabb", size = 26208415, upload-time = "2026-01-08T16:39:57.751Z" },
+]
+
+[[package]]
+name = "pyqt6-qt6"
+version = "6.10.2"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9a/eb/f04d547d8ed9f20c7b246db4ef5d93b49cab4692009a10652ed0a8b9d2aa/pyqt6_qt6-6.10.2-py3-none-macosx_10_14_x86_64.whl", hash = "sha256:5761cfccc721da2311c3f1213577f0ff1df07bbbbe3fa3a209a256b82cf057e3", size = 68688870, upload-time = "2026-01-29T12:26:48.619Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/c8/d99e65ab01c2402fb6bc4f77abef7244f7d5fb2f2e6d5b0abdf71bb2e4fc/pyqt6_qt6-6.10.2-py3-none-macosx_11_0_arm64.whl", hash = "sha256:6dda853a8db1b8d1a2ddbbe76cc6c3aa86614cad14056bd3c0435d8feea73b2d", size = 62512013, upload-time = "2026-01-29T12:27:24.642Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/fe/01fd9b9d2ca139ef61582f2e2da249fa169229144294c1bb27db59ad8420/pyqt6_qt6-6.10.2-py3-none-manylinux_2_34_x86_64.whl", hash = "sha256:19c10b5f0806e9f9bac2c9759bd5d7d19a78967f330fd60a2db409177fa76e49", size = 84028760, upload-time = "2026-01-29T12:28:03.267Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/20/a0d027ebb267d3afaf319d94efe1ff4d667004ee83b96701329a4d11fb95/pyqt6_qt6-6.10.2-py3-none-manylinux_2_39_aarch64.whl", hash = "sha256:2e60d616861ca4565cd295418d605975aa2dc407ba4b94c1586a70c92e9cb052", size = 83063975, upload-time = "2026-01-29T12:28:48.928Z" },
+    { url = "https://files.pythonhosted.org/packages/06/8e/595f215876d507417cc8565e05519916d3b0b76baedea6a1e4e5105633fc/pyqt6_qt6-6.10.2-py3-none-win_amd64.whl", hash = "sha256:c4b7f7d66cc58bddf1bc1ca28dfcf7a45f58cfcb11d81d13a0510409dd4957ac", size = 78433821, upload-time = "2026-01-29T12:29:35.493Z" },
+    { url = "https://files.pythonhosted.org/packages/50/5f/2196e2b536217b87cb3d2ce13ef8f7607d08b02f1990a4bd84a88d293a3c/pyqt6_qt6-6.10.2-py3-none-win_arm64.whl", hash = "sha256:7164a6f0c1335358a3026df9865c8f75395b01f60f0dcd2f66c029ec16fc83d2", size = 58354426, upload-time = "2026-01-29T12:30:02.95Z" },
+]
+
+[[package]]
+name = "pyqt6-sip"
+version = "13.11.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/90/24/a753e1af94b9ae5b2da63d4598457308da3cdbf0838c959381db086ccc86/pyqt6_sip-13.11.1.tar.gz", hash = "sha256:869c5b48afe38e55b1ee0dd72182b0886e968cc509b98023ff50010b013ce1be", size = 92574, upload-time = "2026-03-09T13:01:35.418Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/46/fa/049879f61888462099dcbab495ad16df770cca2432330cca0767ab8e87cb/pyqt6_sip-13.11.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:c0ec2128c174db352bec1c8d23a437e970e8d5a78ac50315d8dfc671fcf7a7da", size = 111056, upload-time = "2026-03-09T13:01:07.998Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/0d/6ee861c53f3f7e6c5dd34a441d17aad1dfb3d50ce1f1a024cc9194ac3db3/pyqt6_sip-13.11.1-cp311-cp311-manylinux1_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:6aa6c15ad3a9bb86e69119baff77b4ac17c47e55ee567abff616a4652051a6cc", size = 289930, upload-time = "2026-03-09T13:01:11.122Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/39/c975733d7204a594e6ae51d3a810aad539d09718aa3ceeb0dd28cb3276bd/pyqt6_sip-13.11.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0ee652b272373c4f9287625ef32ad4ec1f0755c24928dc958a870b7a928b288c", size = 315827, upload-time = "2026-03-09T13:01:09.48Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/d6/c40e8ae38a6e2bce9e837b64688f55746bfdad1aa557eb733fb5e90edd7c/pyqt6_sip-13.11.1-cp311-cp311-win_amd64.whl", hash = "sha256:98db8ed37cf08130e1ee74b8ff47a6bfb8c3cdfe826310597a630a50e47feedc", size = 54029, upload-time = "2026-03-09T13:01:12.261Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/63/ec8c21ef9edffb55af42c637325d72eca4ea90a73ab714aaa1429c757e85/pyqt6_sip-13.11.1-cp311-cp311-win_arm64.whl", hash = "sha256:3af7a49dce4c35c5464309232c81cc1da5ec6074f46d2957831ee4031b8eefa6", size = 48458, upload-time = "2026-03-09T13:01:13.689Z" },
+    { url = "https://files.pythonhosted.org/packages/46/27/47598e701d284497216bf97bf8b6a69f5e61412e716c232ff2b7e6cb2100/pyqt6_sip-13.11.1-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:ba9d362dd1e54b43bc2594f8841e1e39d24789716d28f08e5c9282af9fca342c", size = 112564, upload-time = "2026-03-09T13:01:14.628Z" },
+    { url = "https://files.pythonhosted.org/packages/95/cb/116f9b328636765f3bce97d9e10ec041c54bbe92beb0617edb86c2b615c1/pyqt6_sip-13.11.1-cp312-cp312-manylinux1_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:0df15849946cea969d3ff2b24b76149262b6044aea2c5403e4f70c24c973a4c8", size = 299564, upload-time = "2026-03-09T13:01:17.292Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/be/fe2321285e8f683e705d199dbb458131f1850dc5966155a19c40100c85bb/pyqt6_sip-13.11.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c52b2b27fc77d9447a8dc1c6de1aaccc22d41e48697aafb2f2f20b8984bb02a5", size = 321210, upload-time = "2026-03-09T13:01:15.904Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/9b/7d4b10f9cba1b6f581dfb4860b9d11898da55a5ed3b8a6e7a1bf9f7084d0/pyqt6_sip-13.11.1-cp312-cp312-win_amd64.whl", hash = "sha256:1d1c67179c1924b28e3d7f04585639e7a7c0946f62390efc6ccf2a6206e595d3", size = 53351, upload-time = "2026-03-09T13:01:19.327Z" },
+    { url = "https://files.pythonhosted.org/packages/06/72/6c4e6f21cafa4bed40d2b0c1563525b0d8bfcb5734493696f4cfd043b45f/pyqt6_sip-13.11.1-cp312-cp312-win_arm64.whl", hash = "sha256:d83543125fe9fdb153e7e446c3b4d056d80ab5953644660633ab3f80e7784194", size = 48746, upload-time = "2026-03-09T13:01:20.248Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/0b/dc76c463c203e630b2c6417d4d5e337e919a265ac1c10127ef413551f5de/pyqt6_sip-13.11.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:0c6d097aae7df312519e2b36e001bd796f6a2ce060ab8b9ed793daa8f407fe2e", size = 112552, upload-time = "2026-03-09T13:01:21.493Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/e3/65b605759859d38231ce7544065d4c61f891eb7766c351318e2a0b08a473/pyqt6_sip-13.11.1-cp313-cp313-manylinux1_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:a72f4ebdab16a8a484019ff593de90d8013d3286b678c6ba1c0bdb117f4fcb13", size = 299932, upload-time = "2026-03-09T13:01:24.912Z" },
+    { url = "https://files.pythonhosted.org/packages/60/f7/c10d2dd5bf503a1de83bd163467bd323f12af016866c2814743b5b1efe1c/pyqt6_sip-13.11.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b68e442efc4275651bf63f2c43713e242924fd948909e31cf8f20d783ca505e9", size = 321497, upload-time = "2026-03-09T13:01:22.724Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/1f/e7e5ad77a76c00db5c8c1b9960f2b0672ec1978b971bb3509858cd7a9458/pyqt6_sip-13.11.1-cp313-cp313-win_amd64.whl", hash = "sha256:ca24bfd4d5d8274e338433df9ac41930650088c00018d3313c6bd8de21772a02", size = 53371, upload-time = "2026-03-09T13:01:26.286Z" },
+    { url = "https://files.pythonhosted.org/packages/36/ef/a7acaf44980aed6fe26f1320e265db528fecb6a47ac67829c7cd011e9821/pyqt6_sip-13.11.1-cp313-cp313-win_arm64.whl", hash = "sha256:f532144c43f2fddcccf2e25df50cdb4a744edb4ce4ba5ed2d0f2cef825197f2f", size = 48745, upload-time = "2026-03-09T13:01:27.212Z" },
+    { url = "https://files.pythonhosted.org/packages/20/1d/62c633faedef5bb3b8c7486a72e8a6466adaa2a14efcfccf85bb23426748/pyqt6_sip-13.11.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:cb931c1af45294bbe8039c5cfda184e3023f5dc766fc884964010eedd8fd85db", size = 112678, upload-time = "2026-03-09T13:01:28.15Z" },
+    { url = "https://files.pythonhosted.org/packages/03/72/5a3d9ffef0caa7e1bc7a35d6300f6099bfccd1d8a485b4320ba20013a2d9/pyqt6_sip-13.11.1-cp314-cp314-manylinux1_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:353d613129316e9f7eda6bbe821deb7b7ffa14483499189171fd8a246873f9ac", size = 299560, upload-time = "2026-03-09T13:01:32.134Z" },
+    { url = "https://files.pythonhosted.org/packages/98/f4/886f901f1e04da717a11e180ba19a9c7fc62da170966d57206006f173bda/pyqt6_sip-13.11.1-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fcadd68e09ee24cdda8f8bfcba52e59c9b297055d2c450f0eb89afa61a8dc31a", size = 321846, upload-time = "2026-03-09T13:01:29.817Z" },
+    { url = "https://files.pythonhosted.org/packages/96/f2/b68fd566f7f86dbb53d933489e70487cabaea0e0161690e4899653bbc7fb/pyqt6_sip-13.11.1-cp314-cp314-win_amd64.whl", hash = "sha256:581e287bf42587593b88b30d9db06ed0fccbf40f345a5bd3ec3f00a5692e2430", size = 55055, upload-time = "2026-03-09T13:01:33.467Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/42/efb7ced69f7d1d31eb8f19b2d778aeb182be7e070569d02b9057ac478e3e/pyqt6_sip-13.11.1-cp314-cp314-win_arm64.whl", hash = "sha256:42b62530a9b6a9c6e29c2941b8ab78258652da0aeae4eb1fc9a0631d19a7a7b2", size = 49597, upload-time = "2026-03-09T13:01:34.49Z" },
+]
+
+[[package]]
+name = "pytest"
+version = "9.0.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d1/db/7ef3487e0fb0049ddb5ce41d3a49c235bf9ad299b6a25d5780a89f19230f/pytest-9.0.2.tar.gz", hash = "sha256:75186651a92bd89611d1d9fc20f0b4345fd827c41ccd5c299a868a05d70edf11", size = 1568901, upload-time = "2025-12-06T21:30:51.014Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3b/ab/b3226f0bd7cdcf710fbede2b3548584366da3b19b5021e74f5bde2a8fa3f/pytest-9.0.2-py3-none-any.whl", hash = "sha256:711ffd45bf766d5264d487b917733b453d917afd2b0ad65223959f59089f875b", size = 374801, upload-time = "2025-12-06T21:30:49.154Z" },
+]
+
+[[package]]
+name = "pywin32-ctypes"
+version = "0.2.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/85/9f/01a1a99704853cb63f253eea009390c88e7131c67e66a0a02099a8c917cb/pywin32-ctypes-0.2.3.tar.gz", hash = "sha256:d162dc04946d704503b2edc4d55f3dba5c1d539ead017afa00142c38b9885755", size = 29471, upload-time = "2024-08-14T10:15:34.626Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/de/3d/8161f7711c017e01ac9f008dfddd9410dff3674334c233bde66e7ba65bbf/pywin32_ctypes-0.2.3-py3-none-any.whl", hash = "sha256:8a1513379d709975552d202d942d9837758905c8d01eb82b8bcc30918929e7b8", size = 30756, upload-time = "2024-08-14T10:15:33.187Z" },
+]
+
+[[package]]
+name = "pyyaml"
+version = "6.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6d/16/a95b6757765b7b031c9374925bb718d55e0a9ba8a1b6a12d25962ea44347/pyyaml-6.0.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e", size = 185826, upload-time = "2025-09-25T21:31:58.655Z" },
+    { url = "https://files.pythonhosted.org/packages/16/19/13de8e4377ed53079ee996e1ab0a9c33ec2faf808a4647b7b4c0d46dd239/pyyaml-6.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824", size = 175577, upload-time = "2025-09-25T21:32:00.088Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/62/d2eb46264d4b157dae1275b573017abec435397aa59cbcdab6fc978a8af4/pyyaml-6.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c", size = 775556, upload-time = "2025-09-25T21:32:01.31Z" },
+    { url = "https://files.pythonhosted.org/packages/10/cb/16c3f2cf3266edd25aaa00d6c4350381c8b012ed6f5276675b9eba8d9ff4/pyyaml-6.0.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00", size = 882114, upload-time = "2025-09-25T21:32:03.376Z" },
+    { url = "https://files.pythonhosted.org/packages/71/60/917329f640924b18ff085ab889a11c763e0b573da888e8404ff486657602/pyyaml-6.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d", size = 806638, upload-time = "2025-09-25T21:32:04.553Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/6f/529b0f316a9fd167281a6c3826b5583e6192dba792dd55e3203d3f8e655a/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a", size = 767463, upload-time = "2025-09-25T21:32:06.152Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/6a/b627b4e0c1dd03718543519ffb2f1deea4a1e6d42fbab8021936a4d22589/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4", size = 794986, upload-time = "2025-09-25T21:32:07.367Z" },
+    { url = "https://files.pythonhosted.org/packages/45/91/47a6e1c42d9ee337c4839208f30d9f09caa9f720ec7582917b264defc875/pyyaml-6.0.3-cp311-cp311-win32.whl", hash = "sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b", size = 142543, upload-time = "2025-09-25T21:32:08.95Z" },
+    { url = "https://files.pythonhosted.org/packages/da/e3/ea007450a105ae919a72393cb06f122f288ef60bba2dc64b26e2646fa315/pyyaml-6.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf", size = 158763, upload-time = "2025-09-25T21:32:09.96Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" },
+    { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" },
+    { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" },
+    { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" },
+    { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" },
+    { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" },
+    { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" },
+    { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" },
+    { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" },
+    { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" },
+    { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" },
+    { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" },
+    { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" },
+    { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" },
+    { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" },
+    { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" },
+    { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" },
+    { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" },
+]
+
+[[package]]
+name = "setuptools"
+version = "82.0.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/4f/db/cfac1baf10650ab4d1c111714410d2fbb77ac5a616db26775db562c8fab2/setuptools-82.0.1.tar.gz", hash = "sha256:7d872682c5d01cfde07da7bccc7b65469d3dca203318515ada1de5eda35efbf9", size = 1152316, upload-time = "2026-03-09T12:47:17.221Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9d/76/f789f7a86709c6b087c5a2f52f911838cad707cc613162401badc665acfe/setuptools-82.0.1-py3-none-any.whl", hash = "sha256:a59e362652f08dcd477c78bb6e7bd9d80a7995bc73ce773050228a348ce2e5bb", size = 1006223, upload-time = "2026-03-09T12:47:15.026Z" },
+]
+
+[[package]]
+name = "trdrop"
+version = "2.1.0"
+source = { editable = "." }
+dependencies = [
+    { name = "av" },
+    { name = "numba" },
+    { name = "numpy" },
+    { name = "pyqt6" },
+    { name = "pyyaml" },
+]
+
+[package.optional-dependencies]
+dev = [
+    { name = "basedpyright" },
+    { name = "flake8" },
+    { name = "isort" },
+    { name = "pytest" },
+]
+
+[package.dev-dependencies]
+dev = [
+    { name = "pyinstaller" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "av", specifier = ">=14.0.0" },
+    { name = "basedpyright", marker = "extra == 'dev'", specifier = ">=1.18.0" },
+    { name = "flake8", marker = "extra == 'dev'", specifier = ">=7.0.0" },
+    { name = "isort", marker = "extra == 'dev'", specifier = ">=5.13.0" },
+    { name = "numba", specifier = ">=0.63.1" },
+    { name = "numpy", specifier = ">=1.26.0" },
+    { name = "pyqt6", specifier = ">=6.6.0" },
+    { name = "pytest", marker = "extra == 'dev'", specifier = ">=8.0.0" },
+    { name = "pyyaml", specifier = ">=6.0.3" },
+]
+provides-extras = ["dev"]
+
+[package.metadata.requires-dev]
+dev = [{ name = "pyinstaller", specifier = ">=6.19.0" }]