From 22c302e9f842a7b7448dc57e98b93bcb9f2d1c8d Mon Sep 17 00:00:00 2001
From: styu12 <styu12@naver.com>
Date: Mon, 13 Apr 2026 14:54:23 -0700
Subject: [PATCH 01/18] docs(plan): OpenCV to PyAV migration plan

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 .../2026-04-13-opencv-to-pyav-migration.md    | 1468 +++++++++++++++++
 1 file changed, 1468 insertions(+)
 create mode 100644 docs/plans/2026-04-13-opencv-to-pyav-migration.md

diff --git a/docs/plans/2026-04-13-opencv-to-pyav-migration.md b/docs/plans/2026-04-13-opencv-to-pyav-migration.md
new file mode 100644
index 0000000..bee9be2
--- /dev/null
+++ b/docs/plans/2026-04-13-opencv-to-pyav-migration.md
@@ -0,0 +1,1468 @@
+# OpenCV → PyAV Migration Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Replace OpenCV (`cv2`) with PyAV (`av`) across syncfield-python's video capture / encoding paths so the SDK gains UVC format negotiation (e.g. 720p request), hardware-accelerated H.264 encoding (VideoToolbox on macOS), and a lighter runtime footprint — while preserving every existing Stream SPI contract (`prepare → connect → start_recording → stop_recording → disconnect`, legacy `start/stop`, `latest_frame`, `FinalizationReport`) and the host-monotonic timestamping policy (`time.monotonic_ns()` immediately after the frame is read).
+
+**Architecture:** Introduce a shared internal `VideoEncoder` module that wraps PyAV's output container / H.264 encoder (auto-selecting `h264_videotoolbox` on macOS, falling back to `libx264`). `UVCWebcamStream` replaces `cv2.VideoCapture` with a PyAV input container (`avfoundation` / `v4l2` / `dshow`) and uses the shared encoder for MP4 output. `OakCameraStream` keeps its DepthAI capture path and only swaps `cv2.VideoWriter` for the shared encoder. The viewer's MJPEG endpoint swaps `cv2.imencode` for Pillow. Frames remain in numpy BGR so the existing `latest_frame` contract and viewer both stay untouched at the boundary. Timestamps stay `time.monotonic_ns()` — PTS is intentionally **not** adopted (see `docs/` conversation history for the rationale).
+
+**Tech Stack:**
+- `av` (PyAV ≥ 12.0) — video I/O, demux, encode
+- `Pillow` (PIL ≥ 10.0) — single-frame JPEG encoding in the viewer
+- `numpy` — frame buffers (already a transitive dep)
+- `depthai` — unchanged for OAK capture
+- `pytest` — unit tests with `sys.modules` mocking for `av` and `PIL`
+
+---
+
+## File Structure
+
+**New files:**
+- `src/syncfield/adapters/_video_encoder.py` — shared PyAV H.264 MP4 writer used by UVC and OAK. One responsibility: "accept BGR numpy frames at a fixed rate, produce a playable MP4."
+- `tests/unit/adapters/test_video_encoder.py` — unit tests for the encoder module using a fake `av` module.
+
+**Modified files:**
+- `src/syncfield/adapters/uvc_webcam.py` — swap `cv2.VideoCapture` for PyAV input container; swap writer for `VideoEncoder`; drop the `cv2` import.
+- `src/syncfield/adapters/oak_camera.py` — swap `cv2.VideoWriter` for `VideoEncoder`; drop the `cv2` import. DepthAI capture path is unchanged.
+- `src/syncfield/viewer/server.py` — swap `cv2.imencode(".jpg", …)` for `PIL.Image.save(…, format="JPEG")`; drop the `cv2` import.
+- `src/syncfield/types.py` — add optional `jitter_p95_ns` / `jitter_p99_ns` fields to `FinalizationReport` (both default `None` so unchanged for non-video streams).
+- `tests/unit/adapters/test_uvc_webcam.py` — replace `mock_cv2` fixture with `mock_av` fixture.
+- `tests/unit/adapters/test_oak_camera.py` — replace the writer-related `cv2` mocks with `mock_av` fixture. DepthAI mock unchanged.
+- `tests/unit/viewer/test_cluster_endpoints.py` — update any `cv2.imencode` mock to `PIL.Image` (only if present).
+- `pyproject.toml` — remove `opencv-python`, add `av` and `Pillow` to the relevant extras.
+
+**Rationale for the split:** UVC and OAK both need an "MP4 writer that accepts numpy BGR frames and is hardware-accelerated on macOS." Duplicating that across two adapters would invite divergence. A single `VideoEncoder` with a clear interface (`open(path, width, height, fps) → encoder`; `encoder.write(frame_bgr)`; `encoder.close() → None`) isolates the PyAV detail and makes both adapters one-liners at the write site. The module lives under `adapters/` (not a top-level `video/`) because nothing outside adapter internals should depend on it.
+
+---
+
+## Task 0: Create the worktree and verify baseline
+
+**Files:**
+- Read: `pyproject.toml` (verify baseline test pass)
+
+- [ ] **Step 1: Create an isolated worktree for the migration**
+
+```bash
+cd /Users/jerry/Documents/syncfield-python
+git worktree add ../syncfield-python-pyav -b feat/pyav-migration
+cd ../syncfield-python-pyav
+```
+
+- [ ] **Step 2: Verify the baseline test suite passes on `main`**
+
+```bash
+uv sync --all-extras
+uv run pytest tests/unit -x -q
+```
+
+Expected: all tests pass. Record the pass count (it's the floor we must preserve).
+
+- [ ] **Step 3: Commit the worktree marker (no file changes)**
+
+Skip — the worktree exists on the branch with no changes yet.
+
+---
+
+## Task 1: Add `av` and `Pillow` dependencies
+
+**Files:**
+- Modify: `pyproject.toml` (extras `uvc`, `oak`, `viewer`)
+
+- [ ] **Step 1: Inspect the current extras**
+
+Run: `grep -n -A2 '^\[project.optional-dependencies\]' pyproject.toml`
+
+Expected to see (roughly):
+```
+uvc = ["opencv-python>=4.5"]
+oak = ["depthai>=3.0.0"]
+viewer = ["opencv-python>=4.8.0", ...]
+```
+
+- [ ] **Step 2: Modify extras — replace `opencv-python` with `av` + `Pillow`**
+
+Exact edits in `pyproject.toml`:
+
+```toml
+[project.optional-dependencies]
+uvc = ["av>=12.0.0"]
+oak = ["depthai>=3.0.0", "av>=12.0.0"]
+viewer = [
+    "av>=12.0.0",
+    "Pillow>=10.0.0",
+    # ...keep the other viewer deps (fastapi, uvicorn, etc.) exactly as they were
+]
+```
+
+Also update `all = [...]` to union these (no `opencv-python` anywhere).
+
+- [ ] **Step 3: Resolve and install**
+
+```bash
+uv sync --all-extras
+```
+
+Expected: `opencv-python` is gone from `uv.lock`; `av` and `Pillow` are added.
+
+- [ ] **Step 4: Verify `av` imports and an encoder exists**
+
+```bash
+uv run python -c "import av; c = av.codec.Codec('h264', 'w'); print(c.name, c.long_name)"
+```
+
+Expected: `h264 ...` printed without error.
+
+- [ ] **Step 5: Verify VideoToolbox is available on macOS (informational)**
+
+```bash
+uv run python -c "import av; print(av.codec.Codec('h264_videotoolbox', 'w').name)"
+```
+
+On Apple Silicon: prints `h264_videotoolbox`. On other platforms: raises — expected, we fall back to `libx264`.
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add pyproject.toml uv.lock
+git commit -m "build: replace opencv-python with av + Pillow in extras"
+```
+
+---
+
+## Task 2: Introduce `VideoEncoder` — interface + failing test
+
+**Files:**
+- Create: `src/syncfield/adapters/_video_encoder.py`
+- Create: `tests/unit/adapters/test_video_encoder.py`
+
+- [ ] **Step 1: Write the failing contract test**
+
+Create `tests/unit/adapters/test_video_encoder.py`:
+
+```python
+"""Unit tests for VideoEncoder — the shared PyAV MP4 writer.
+
+The real ``av`` module is replaced with a fake in ``conftest.py`` style so
+these tests do not depend on a working FFmpeg build. We only assert that:
+
+* The encoder opens an output container with the right path and format.
+* It adds one video stream with the requested width, height, fps, pixel
+  format and a usable codec (h264_videotoolbox on mac, libx264 elsewhere).
+* ``write(frame)`` encodes and muxes one packet per call.
+* ``close()`` flushes the encoder and closes the container exactly once.
+* Double ``close()`` is idempotent (no double-flush, no exception).
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from types import SimpleNamespace
+from unittest.mock import MagicMock
+
+import numpy as np
+import pytest
+
+
+@pytest.fixture
+def fake_av(monkeypatch: pytest.MonkeyPatch) -> SimpleNamespace:
+    """Install a fake ``av`` module that records every interaction."""
+    container = MagicMock(name="OutputContainer")
+    stream = MagicMock(name="VideoStream")
+    stream.width = 0
+    stream.height = 0
+    stream.pix_fmt = "yuv420p"
+    container.add_stream.return_value = stream
+
+    # ``encode`` returns a list of packets; we fake one packet per call.
+    packet = MagicMock(name="Packet")
+    stream.encode.return_value = [packet]
+
+    av = SimpleNamespace()
+    av.open = MagicMock(name="av.open", return_value=container)
+
+    # ``av.VideoFrame.from_ndarray`` returns a fake frame carrying the array.
+    def _from_ndarray(arr: np.ndarray, format: str) -> MagicMock:
+        frame = MagicMock(name="VideoFrame")
+        frame.to_ndarray = lambda format="bgr24": arr
+        frame._source_format = format
+        return frame
+
+    video_frame = SimpleNamespace(from_ndarray=MagicMock(side_effect=_from_ndarray))
+    av.VideoFrame = video_frame
+
+    # ``av.codec.Codec`` returns an object if the codec exists, raises if not.
+    def _codec(name: str, mode: str) -> SimpleNamespace:
+        if name in {"h264_videotoolbox", "libx264"}:
+            return SimpleNamespace(name=name)
+        raise ValueError(f"unknown codec {name}")
+
+    av.codec = SimpleNamespace(Codec=MagicMock(side_effect=_codec))
+
+    monkeypatch.setitem(sys.modules, "av", av)
+    return SimpleNamespace(av=av, container=container, stream=stream, packet=packet)
+
+
+def test_open_creates_output_container(tmp_path: Path, fake_av: SimpleNamespace) -> None:
+    from syncfield.adapters._video_encoder import VideoEncoder
+
+    out = tmp_path / "clip.mp4"
+    enc = VideoEncoder.open(out, width=1280, height=720, fps=30.0)
+
+    fake_av.av.open.assert_called_once()
+    args, kwargs = fake_av.av.open.call_args
+    assert args[0] == str(out)
+    assert kwargs.get("mode") == "w"
+
+    fake_av.container.add_stream.assert_called_once()
+    stream_args, stream_kwargs = fake_av.container.add_stream.call_args
+    # codec preference: h264_videotoolbox (macOS) or libx264 (fallback)
+    assert stream_args[0] in {"h264_videotoolbox", "libx264"}
+    assert stream_kwargs.get("rate") == 30
+    assert fake_av.stream.width == 1280
+    assert fake_av.stream.height == 720
+
+    enc.close()
+
+
+def test_write_encodes_and_muxes_one_frame(tmp_path: Path, fake_av: SimpleNamespace) -> None:
+    from syncfield.adapters._video_encoder import VideoEncoder
+
+    enc = VideoEncoder.open(tmp_path / "clip.mp4", width=64, height=48, fps=30.0)
+    frame = np.zeros((48, 64, 3), dtype=np.uint8)
+
+    enc.write(frame)
+
+    fake_av.av.VideoFrame.from_ndarray.assert_called_once()
+    fake_av.stream.encode.assert_called()
+    fake_av.container.mux.assert_called_with(fake_av.packet)
+
+    enc.close()
+
+
+def test_close_is_idempotent(tmp_path: Path, fake_av: SimpleNamespace) -> None:
+    from syncfield.adapters._video_encoder import VideoEncoder
+
+    enc = VideoEncoder.open(tmp_path / "clip.mp4", width=64, height=48, fps=30.0)
+    enc.close()
+    enc.close()  # should not raise, should not double-close
+
+    assert fake_av.container.close.call_count == 1
+```
+
+- [ ] **Step 2: Run — expect failure (module missing)**
+
+```bash
+uv run pytest tests/unit/adapters/test_video_encoder.py -v
+```
+
+Expected: `ModuleNotFoundError: No module named 'syncfield.adapters._video_encoder'`.
+
+- [ ] **Step 3: Implement `VideoEncoder`**
+
+Create `src/syncfield/adapters/_video_encoder.py`:
+
+```python
+"""VideoEncoder — shared PyAV-based MP4 writer for video adapters.
+
+Used by :class:`~syncfield.adapters.uvc_webcam.UVCWebcamStream` and
+:class:`~syncfield.adapters.oak_camera.OakCameraStream`. The interface is
+deliberately narrow: open with geometry, write BGR numpy frames, close.
+
+The encoder auto-selects the best available H.264 encoder:
+* ``h264_videotoolbox`` on macOS (hardware, near-zero CPU)
+* ``libx264`` everywhere else (software, widely available)
+
+All frames are assumed to be BGR24 (numpy ``uint8``, shape
+``(height, width, 3)``) to match the rest of the SDK's convention.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import numpy as np
+
+try:
+    import av  # type: ignore[import-not-found]
+except ImportError as exc:  # pragma: no cover - exercised via sys.modules patch
+    raise ImportError(
+        "syncfield video adapters require PyAV. "
+        "Install with `pip install syncfield[uvc]` (or [oak], [viewer])."
+    ) from exc
+
+
+def _pick_h264_encoder() -> str:
+    """Return the best H.264 encoder name available in this FFmpeg build."""
+    for candidate in ("h264_videotoolbox", "libx264"):
+        try:
+            av.codec.Codec(candidate, "w")
+        except Exception:  # noqa: BLE001 - PyAV raises generic errors here
+            continue
+        return candidate
+    raise RuntimeError(
+        "No H.264 encoder found in PyAV. Reinstall `av` with libx264 support."
+    )
+
+
+class VideoEncoder:
+    """Thin wrapper around an ``av`` output container + H.264 stream."""
+
+    def __init__(
+        self,
+        container: "av.container.OutputContainer",
+        stream: "av.video.stream.VideoStream",
+    ) -> None:
+        self._container = container
+        self._stream = stream
+        self._closed = False
+
+    @classmethod
+    def open(
+        cls,
+        path: str | Path,
+        *,
+        width: int,
+        height: int,
+        fps: float,
+        codec: Optional[str] = None,
+        pixel_format: str = "yuv420p",
+    ) -> "VideoEncoder":
+        """Open ``path`` for writing and configure the H.264 stream."""
+        chosen_codec = codec or _pick_h264_encoder()
+        container = av.open(str(path), mode="w")
+        stream = container.add_stream(chosen_codec, rate=int(round(fps)))
+        stream.width = int(width)
+        stream.height = int(height)
+        stream.pix_fmt = pixel_format
+        return cls(container, stream)
+
+    def write(self, frame_bgr: np.ndarray) -> None:
+        """Encode and mux a single BGR frame.
+
+        Must not be called after :meth:`close`. Callers that interleave
+        writes with other hot-path work should keep the frame buffer
+        alive until this call returns.
+        """
+        if self._closed:
+            raise RuntimeError("VideoEncoder.write called after close")
+        video_frame = av.VideoFrame.from_ndarray(frame_bgr, format="bgr24")
+        for packet in self._stream.encode(video_frame):
+            self._container.mux(packet)
+
+    def close(self) -> None:
+        """Flush the encoder and close the container. Idempotent."""
+        if self._closed:
+            return
+        self._closed = True
+        # Flush: passing None drains any remaining packets in the encoder.
+        try:
+            for packet in self._stream.encode(None):
+                self._container.mux(packet)
+        finally:
+            self._container.close()
+```
+
+- [ ] **Step 4: Run the test — expect pass**
+
+```bash
+uv run pytest tests/unit/adapters/test_video_encoder.py -v
+```
+
+Expected: 3 passed.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/syncfield/adapters/_video_encoder.py tests/unit/adapters/test_video_encoder.py
+git commit -m "feat(adapters): add VideoEncoder shared PyAV MP4 writer"
+```
+
+---
+
+## Task 3: Build `_open_capture` platform helper — UVC input via PyAV
+
+**Files:**
+- Modify: `src/syncfield/adapters/_video_encoder.py` — add a sibling helper for input-side platform dispatch (keeping video I/O internals in one module).
+- Modify: `tests/unit/adapters/test_video_encoder.py` — add tests for the helper.
+
+Rationale: opening a UVC device with PyAV is platform-dependent (macOS uses `avfoundation`, Linux `v4l2`, Windows `dshow`). That logic is small but non-trivial; keeping it next to the encoder keeps the "video I/O primitives" in one place.
+
+- [ ] **Step 1: Add failing tests for `open_uvc_input`**
+
+Append to `tests/unit/adapters/test_video_encoder.py`:
+
+```python
+def test_open_uvc_input_macos(monkeypatch: pytest.MonkeyPatch, fake_av: SimpleNamespace) -> None:
+    from syncfield.adapters import _video_encoder
+
+    monkeypatch.setattr(_video_encoder.sys, "platform", "darwin")
+    input_container = MagicMock(name="InputContainer")
+    fake_av.av.open.return_value = input_container
+
+    result = _video_encoder.open_uvc_input(
+        device_index=0, width=1280, height=720, fps=30.0
+    )
+
+    args, kwargs = fake_av.av.open.call_args
+    assert args[0] == "0:none"  # avfoundation URL: "<video>:<audio>"
+    assert kwargs.get("format") == "avfoundation"
+    assert kwargs.get("options", {}).get("video_size") == "1280x720"
+    assert kwargs.get("options", {}).get("framerate") == "30"
+    assert result is input_container
+
+
+def test_open_uvc_input_linux(monkeypatch: pytest.MonkeyPatch, fake_av: SimpleNamespace) -> None:
+    from syncfield.adapters import _video_encoder
+
+    monkeypatch.setattr(_video_encoder.sys, "platform", "linux")
+    fake_av.av.open.return_value = MagicMock(name="InputContainer")
+
+    _video_encoder.open_uvc_input(
+        device_index=2, width=1280, height=720, fps=30.0
+    )
+
+    args, kwargs = fake_av.av.open.call_args
+    assert args[0] == "/dev/video2"
+    assert kwargs.get("format") == "v4l2"
+
+
+def test_open_uvc_input_windows(monkeypatch: pytest.MonkeyPatch, fake_av: SimpleNamespace) -> None:
+    from syncfield.adapters import _video_encoder
+
+    monkeypatch.setattr(_video_encoder.sys, "platform", "win32")
+    fake_av.av.open.return_value = MagicMock(name="InputContainer")
+
+    _video_encoder.open_uvc_input(
+        device_index=0, width=1280, height=720, fps=30.0,
+        device_name="Logitech BRIO",
+    )
+
+    args, kwargs = fake_av.av.open.call_args
+    assert args[0] == "video=Logitech BRIO"
+    assert kwargs.get("format") == "dshow"
+```
+
+- [ ] **Step 2: Run — expect failure**
+
+```bash
+uv run pytest tests/unit/adapters/test_video_encoder.py -v -k open_uvc_input
+```
+
+Expected: `AttributeError: module 'syncfield.adapters._video_encoder' has no attribute 'open_uvc_input'`.
+
+- [ ] **Step 3: Implement `open_uvc_input` + expose `sys`**
+
+Edit `src/syncfield/adapters/_video_encoder.py` — add at the top (after `import numpy as np`):
+
+```python
+import sys
+```
+
+Then add, after the `VideoEncoder` class:
+
+```python
+def open_uvc_input(
+    *,
+    device_index: int,
+    width: int,
+    height: int,
+    fps: float,
+    device_name: Optional[str] = None,
+    pixel_format: str = "mjpeg",
+) -> "av.container.InputContainer":
+    """Open a UVC webcam as a PyAV input container.
+
+    Platform dispatch:
+
+    * macOS — ``avfoundation`` with URL ``"<video>:<audio>"``. We pass
+      ``"<index>:none"`` so no audio input is opened.
+    * Linux — ``v4l2`` with URL ``/dev/video<N>``.
+    * Windows — ``dshow`` with URL ``video=<device_name>``. The caller
+      must supply ``device_name`` (DirectShow has no index URL).
+
+    The returned container yields packets via ``.demux()`` which the
+    caller decodes frame-by-frame.
+    """
+    options = {
+        "video_size": f"{int(width)}x{int(height)}",
+        "framerate": str(int(round(fps))),
+        "pixel_format": pixel_format,
+    }
+
+    if sys.platform == "darwin":
+        url = f"{int(device_index)}:none"
+        fmt = "avfoundation"
+    elif sys.platform.startswith("linux"):
+        url = f"/dev/video{int(device_index)}"
+        fmt = "v4l2"
+    elif sys.platform.startswith("win"):
+        if not device_name:
+            raise ValueError(
+                "Windows UVC input requires `device_name` "
+                "(DirectShow has no device-index URL)."
+            )
+        url = f"video={device_name}"
+        fmt = "dshow"
+    else:
+        raise RuntimeError(f"Unsupported platform for UVC input: {sys.platform}")
+
+    return av.open(url, format=fmt, options=options)
+```
+
+- [ ] **Step 4: Run — expect pass**
+
+```bash
+uv run pytest tests/unit/adapters/test_video_encoder.py -v
+```
+
+Expected: 6 passed (3 VideoEncoder + 3 platform dispatch).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/syncfield/adapters/_video_encoder.py tests/unit/adapters/test_video_encoder.py
+git commit -m "feat(adapters): add open_uvc_input platform dispatch helper"
+```
+
+---
+
+## Task 4: Migrate `UVCWebcamStream` — capture + write via PyAV
+
+**Files:**
+- Modify: `src/syncfield/adapters/uvc_webcam.py` (entire body)
+- Reference: `tests/unit/adapters/test_uvc_webcam.py` (will be updated in Task 5)
+
+Strategy: keep the public contract (constructor args, properties, lifecycle) **exactly** the same. Only the internal implementation changes.
+
+- [ ] **Step 1: Rewrite `uvc_webcam.py`**
+
+Replace the entire file with:
+
+```python
+"""UVCWebcamStream — PyAV-based adapter for UVC/USB webcams.
+
+Requires the optional ``uvc`` extra:
+
+    pip install syncfield[uvc]
+
+The adapter runs a background thread that decodes frames from a PyAV
+input container, timestamps each decoded frame with
+``time.monotonic_ns()`` **before** any further processing, and publishes
+them to :attr:`latest_frame` for the viewer to preview. The **same
+thread** writes to an MP4 via :class:`~._video_encoder.VideoEncoder` and
+emits :class:`~syncfield.types.SampleEvent` — but only while the session
+is in :attr:`~syncfield.SessionState.RECORDING`.
+
+Lifecycle and public surface are identical to the OpenCV-based
+predecessor; only the internals changed.
+"""
+
+from __future__ import annotations
+
+import threading
+import time
+from pathlib import Path
+from typing import Any, Optional
+
+from syncfield.adapters._video_encoder import VideoEncoder, open_uvc_input
+from syncfield.clock import SessionClock
+from syncfield.stream import DeviceKey, StreamBase
+from syncfield.types import (
+    FinalizationReport,
+    SampleEvent,
+    StreamCapabilities,
+)
+
+
+class UVCWebcamStream(StreamBase):
+    """Captures video from a UVC webcam via PyAV.
+
+    Args:
+        id: Stream id (also the output file name, ``{id}.mp4``).
+        device_index: Platform device index (AVFoundation / V4L2 index,
+            or DirectShow fallback alongside ``device_name``).
+        output_dir: Directory for the resulting MP4 file.
+        width: Requested frame width. Defaults to 1280 (720p).
+        height: Requested frame height. Defaults to 720 (720p).
+        fps: Requested frame rate. Defaults to 30.0.
+        device_name: Required only on Windows (DirectShow). Ignored
+            on macOS / Linux.
+    """
+
+    _discovery_kind = "video"
+    _discovery_adapter_type = "uvc_webcam"
+
+    def __init__(
+        self,
+        id: str,
+        device_index: int,
+        output_dir: Path | str,
+        width: Optional[int] = 1280,
+        height: Optional[int] = 720,
+        fps: Optional[float] = 30.0,
+        device_name: Optional[str] = None,
+    ) -> None:
+        super().__init__(
+            id=id,
+            kind="video",
+            capabilities=StreamCapabilities(
+                provides_audio_track=False,
+                supports_precise_timestamps=True,
+                is_removable=True,
+                produces_file=True,
+            ),
+        )
+        self._device_index = device_index
+        self._device_name = device_name
+        self._output_dir = Path(output_dir)
+        self._width = int(width) if width else 1280
+        self._height = int(height) if height else 720
+        self._fps = float(fps) if fps else 30.0
+
+        self._input: Any = None
+        self._encoder: Optional[VideoEncoder] = None
+        self._file_path = self._output_dir / f"{id}.mp4"
+
+        self._thread: Optional[threading.Thread] = None
+        self._stop_event = threading.Event()
+        self._frame_count = 0
+        self._first_at: Optional[int] = None
+        self._last_at: Optional[int] = None
+
+        self._recording = False
+
+        self._frame_lock = threading.Lock()
+        self._latest_frame: Any = None
+
+    @property
+    def device_key(self) -> Optional[DeviceKey]:
+        return ("uvc_webcam", str(self._device_index))
+
+    # ------------------------------------------------------------------
+    # Stream SPI — 4-phase lifecycle
+    # ------------------------------------------------------------------
+
+    def prepare(self) -> None:
+        """Open the PyAV input container."""
+        if self._input is None:
+            self._input = open_uvc_input(
+                device_index=self._device_index,
+                width=self._width,
+                height=self._height,
+                fps=self._fps,
+                device_name=self._device_name,
+            )
+
+    def connect(self) -> None:
+        """Start the capture thread in preview-only mode."""
+        if self._thread is not None and self._thread.is_alive():
+            return
+        if self._input is None:
+            self.prepare()
+        self._recording = False
+        self._stop_event.clear()
+        self._thread = threading.Thread(
+            target=self._capture_loop, name=f"uvc-{self.id}", daemon=True
+        )
+        self._thread.start()
+
+    def start_recording(self, session_clock: SessionClock) -> None:
+        """Open the VideoEncoder and flip recording on."""
+        if self._thread is None or not self._thread.is_alive():
+            self.connect()
+        self._output_dir.mkdir(parents=True, exist_ok=True)
+        self._encoder = VideoEncoder.open(
+            self._file_path,
+            width=self._width,
+            height=self._height,
+            fps=self._fps,
+        )
+        self._recording = True
+
+    def stop_recording(self) -> FinalizationReport:
+        """Flip recording off, close the encoder, emit the report."""
+        self._recording = False
+        if self._encoder is not None:
+            self._encoder.close()
+            self._encoder = None
+        return FinalizationReport(
+            stream_id=self.id,
+            status="completed",
+            frame_count=self._frame_count,
+            file_path=self._file_path if self._frame_count > 0 else None,
+            first_sample_at_ns=self._first_at,
+            last_sample_at_ns=self._last_at,
+            health_events=list(self._collected_health),
+            error=None,
+        )
+
+    def disconnect(self) -> None:
+        """Stop the capture thread and release the input container."""
+        self._stop_event.set()
+        if self._thread is not None:
+            self._thread.join(timeout=2.0)
+            self._thread = None
+        self._release_av_resources()
+
+    # ------------------------------------------------------------------
+    # Legacy one-shot lifecycle
+    # ------------------------------------------------------------------
+
+    def start(self, session_clock: SessionClock) -> None:
+        if self._input is None:
+            self.prepare()
+        self._output_dir.mkdir(parents=True, exist_ok=True)
+        self._encoder = VideoEncoder.open(
+            self._file_path,
+            width=self._width,
+            height=self._height,
+            fps=self._fps,
+        )
+        self._recording = True
+        self._stop_event.clear()
+        self._thread = threading.Thread(
+            target=self._capture_loop, name=f"uvc-{self.id}", daemon=True
+        )
+        self._thread.start()
+
+    def stop(self) -> FinalizationReport:
+        report = self.stop_recording()
+        self.disconnect()
+        return report
+
+    # ------------------------------------------------------------------
+    # Capture loop
+    # ------------------------------------------------------------------
+
+    def _capture_loop(self) -> None:
+        """Background thread — decode frames in a tight loop.
+
+        Two phases, distinguished by the ``_recording`` flag:
+
+        * Preview — publish to ``latest_frame`` only.
+        * Recording — also encode to MP4 and emit SampleEvent.
+
+        The loop exits when ``_stop_event`` fires or the input
+        container is exhausted (device disconnect).
+        """
+        assert self._input is not None
+        try:
+            for frame in self._input.decode(video=0):
+                if self._stop_event.is_set():
+                    break
+
+                capture_ns = time.monotonic_ns()
+                frame_bgr = frame.to_ndarray(format="bgr24")
+
+                with self._frame_lock:
+                    self._latest_frame = frame_bgr
+
+                if self._recording:
+                    if self._first_at is None:
+                        self._first_at = capture_ns
+                    self._last_at = capture_ns
+                    self._frame_count += 1
+                    if self._encoder is not None:
+                        self._encoder.write(frame_bgr)
+                    self._emit_sample(
+                        SampleEvent(
+                            stream_id=self.id,
+                            frame_number=self._frame_count - 1,
+                            capture_ns=capture_ns,
+                        )
+                    )
+        except Exception:
+            # Device disconnect or decode error — exit the loop; the
+            # orchestrator observes the thread dying via disconnect().
+            return
+
+    # ------------------------------------------------------------------
+    # Live preview
+    # ------------------------------------------------------------------
+
+    @property
+    def latest_frame(self) -> Any:
+        """Return the most recently captured BGR frame, or ``None``."""
+        with self._frame_lock:
+            return self._latest_frame
+
+    def _release_av_resources(self) -> None:
+        if self._encoder is not None:
+            self._encoder.close()
+            self._encoder = None
+        if self._input is not None:
+            try:
+                self._input.close()
+            finally:
+                self._input = None
+
+    # ------------------------------------------------------------------
+    # Discovery — unchanged from the OpenCV version.
+    # ------------------------------------------------------------------
+
+    @classmethod
+    def discover(cls, *, timeout: float = 5.0) -> list:
+        # Keep the existing discovery body verbatim — it does not touch
+        # cv2 or av and only enumerates the system via ``system_profiler``
+        # / ``/dev/video*``. Paste the original implementation here.
+        raise NotImplementedError(
+            "Copy the discover() body from the pre-migration file verbatim"
+        )
+```
+
+> **Implementation note for the engineer:** The `discover` method's body does not depend on cv2 — copy lines 368–510 from the pre-migration `uvc_webcam.py` unchanged into the `discover` method here. The placeholder `raise` above is a reminder, not a design choice.
+
+- [ ] **Step 2: Copy the original `discover()` body verbatim**
+
+```bash
+git show main:src/syncfield/adapters/uvc_webcam.py | sed -n '368,510p'
+```
+
+Copy that body into the `discover` method, replacing the `raise NotImplementedError(...)` line.
+
+- [ ] **Step 3: Smoke check — import the module (tests will fail, that's Task 5)**
+
+```bash
+uv run python -c "from syncfield.adapters.uvc_webcam import UVCWebcamStream; print(UVCWebcamStream)"
+```
+
+Expected: prints the class. If it raises, fix import errors before moving on.
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add src/syncfield/adapters/uvc_webcam.py
+git commit -m "feat(adapters): migrate UVCWebcamStream to PyAV"
+```
+
+---
+
+## Task 5: Migrate UVC adapter tests
+
+**Files:**
+- Modify: `tests/unit/adapters/test_uvc_webcam.py` (replace `mock_cv2` with `mock_av`)
+
+- [ ] **Step 1: Inspect the existing test fixture**
+
+```bash
+sed -n '1,60p' tests/unit/adapters/test_uvc_webcam.py
+```
+
+Note the `mock_cv2` fixture shape — we'll replace it with `mock_av` while keeping every test's intent.
+
+- [ ] **Step 2: Replace the `mock_cv2` fixture with `mock_av`**
+
+Edit `tests/unit/adapters/test_uvc_webcam.py`:
+
+Replace the `mock_cv2` fixture with this fixture (keep any other fixtures unchanged):
+
+```python
+import sys
+from types import SimpleNamespace
+from unittest.mock import MagicMock
+
+import numpy as np
+import pytest
+
+
+@pytest.fixture
+def mock_av(monkeypatch: pytest.MonkeyPatch) -> SimpleNamespace:
+    """Fake the ``av`` module so UVC tests run without FFmpeg."""
+
+    # ---- Input side (capture) -------------------------------------
+    def _make_frame(i: int) -> MagicMock:
+        frame = MagicMock(name=f"Frame-{i}")
+        frame.to_ndarray = MagicMock(
+            return_value=np.full((48, 64, 3), i % 256, dtype=np.uint8)
+        )
+        return frame
+
+    input_container = MagicMock(name="InputContainer")
+    # Yield 3 frames then stop — tests that need more can override.
+    input_container.decode = MagicMock(
+        return_value=iter([_make_frame(i) for i in range(3)])
+    )
+
+    # ---- Output side (encoder) ------------------------------------
+    output_stream = MagicMock(name="VideoStream")
+    output_stream.encode = MagicMock(return_value=[MagicMock(name="Packet")])
+    output_container = MagicMock(name="OutputContainer")
+    output_container.add_stream = MagicMock(return_value=output_stream)
+
+    # ---- av.open dispatches on mode -------------------------------
+    def _av_open(url, *args, **kwargs):  # noqa: ANN001 - MagicMock signature
+        if kwargs.get("mode") == "w":
+            return output_container
+        return input_container
+
+    av = SimpleNamespace()
+    av.open = MagicMock(side_effect=_av_open)
+    av.VideoFrame = SimpleNamespace(
+        from_ndarray=MagicMock(return_value=MagicMock(name="OutFrame"))
+    )
+    av.codec = SimpleNamespace(
+        Codec=MagicMock(side_effect=lambda n, m: SimpleNamespace(name=n))
+    )
+
+    monkeypatch.setitem(sys.modules, "av", av)
+    return SimpleNamespace(
+        av=av,
+        input_container=input_container,
+        output_container=output_container,
+        output_stream=output_stream,
+        make_frame=_make_frame,
+    )
+```
+
+- [ ] **Step 3: Update every test that referenced `mock_cv2`**
+
+Find and replace at call sites:
+
+```bash
+grep -n 'mock_cv2' tests/unit/adapters/test_uvc_webcam.py
+```
+
+For each occurrence, rename the fixture parameter to `mock_av` and:
+
+- `mock_cv2.VideoCapture.return_value.read.return_value` → remove (use `mock_av.input_container.decode`)
+- `mock_cv2.VideoWriter` → remove (the writer is tested separately in `test_video_encoder.py`)
+- Assertions on `write()` calls should assert on `mock_av.output_stream.encode` instead
+- Assertions on frame counts should still use `FinalizationReport.frame_count` — that's unchanged
+
+Rewrite each test to verify:
+- `prepare()` calls `av.open(...)` once with the platform format
+- `connect()` spawns the capture thread and begins populating `latest_frame`
+- `start_recording()` opens the writer container (mode="w")
+- After N decoded frames + `stop_recording()`, the `FinalizationReport` has `frame_count == N` with the expected file path
+
+Example replacement for one test (the lifecycle happy path):
+
+```python
+def test_4phase_lifecycle_records_expected_frame_count(
+    mock_av: SimpleNamespace, tmp_path
+) -> None:
+    from syncfield.adapters.uvc_webcam import UVCWebcamStream
+    from syncfield.clock import SessionClock
+
+    # Drive 5 frames through the decode iterator
+    frames = [mock_av.make_frame(i) for i in range(5)]
+    mock_av.input_container.decode = MagicMock(return_value=iter(frames))
+
+    stream = UVCWebcamStream(
+        id="uvc0", device_index=0, output_dir=tmp_path, fps=30.0
+    )
+    stream.prepare()
+    stream.connect()
+    stream.start_recording(SessionClock())
+
+    # Let the capture thread drain the iterator.
+    import time as _t
+    _t.sleep(0.05)
+
+    report = stream.stop_recording()
+    stream.disconnect()
+
+    assert report.frame_count == 5
+    assert report.file_path == tmp_path / "uvc0.mp4"
+    assert mock_av.output_stream.encode.call_count >= 5
+```
+
+Repeat this pattern for the other lifecycle tests (legacy `start/stop`, preview without recording, stop_recording idempotency, etc.). Each replacement must preserve the original assertion's intent.
+
+- [ ] **Step 4: Run the UVC tests — expect all pass**
+
+```bash
+uv run pytest tests/unit/adapters/test_uvc_webcam.py -v
+```
+
+Expected: same number of passing tests as before the migration.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add tests/unit/adapters/test_uvc_webcam.py
+git commit -m "test(adapters): migrate UVC tests from mock_cv2 to mock_av"
+```
+
+---
+
+## Task 6: Migrate `OakCameraStream` — writer only
+
+**Files:**
+- Modify: `src/syncfield/adapters/oak_camera.py`
+
+The OAK adapter keeps DepthAI for capture. Only the `cv2.VideoWriter` usage is swapped for `VideoEncoder`.
+
+- [ ] **Step 1: Remove the cv2 import and import `VideoEncoder`**
+
+Edit `src/syncfield/adapters/oak_camera.py`:
+
+Delete the `cv2` try/except block (lines ~64–69 in the current file). Add near the other syncfield imports:
+
+```python
+from syncfield.adapters._video_encoder import VideoEncoder
+```
+
+Change the type hint for `_video_writer`:
+
+```python
+self._video_writer: Optional[VideoEncoder] = None
+```
+
+- [ ] **Step 2: Replace the `cv2.VideoWriter` construction in `start_recording`**
+
+Find the block around line 309–313 (`fourcc = cv2.VideoWriter_fourcc...`) and replace with:
+
+```python
+width, height = self._rgb_resolution
+self._video_writer = VideoEncoder.open(
+    self._mp4_path,
+    width=width,
+    height=height,
+    fps=float(self._rgb_fps),
+)
+```
+
+Apply the same replacement in the legacy `start()` method if it duplicates this construction.
+
+- [ ] **Step 3: Update the frame-write and release sites**
+
+Frame write site (inside `_drain_rgb_tick` or wherever `self._video_writer.write(frame)` currently lives): the call signature is the same (`self._video_writer.write(frame_bgr)`), so **no change is needed** at the write site — `VideoEncoder.write()` matches the OpenCV contract.
+
+Writer release site (`_release_writers`): replace `self._video_writer.release()` with `self._video_writer.close()`.
+
+```bash
+grep -n 'self._video_writer' src/syncfield/adapters/oak_camera.py
+```
+
+Verify every hit either stays the same (`.write(...)`) or is updated (`.release()` → `.close()`).
+
+- [ ] **Step 4: Smoke check imports**
+
+```bash
+uv run python -c "from syncfield.adapters.oak_camera import OakCameraStream; print(OakCameraStream)"
+```
+
+Expected: prints the class.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/syncfield/adapters/oak_camera.py
+git commit -m "refactor(adapters): swap cv2.VideoWriter for VideoEncoder in OAK"
+```
+
+---
+
+## Task 7: Migrate OAK adapter tests
+
+**Files:**
+- Modify: `tests/unit/adapters/test_oak_camera.py`
+
+- [ ] **Step 1: Merge `mock_av` into the OAK test file**
+
+Paste the `mock_av` fixture from `test_uvc_webcam.py` into `test_oak_camera.py` (or hoist both to `tests/unit/adapters/conftest.py` — prefer the conftest hoist for DRY).
+
+- [ ] **Step 2: Hoist both fixtures to `conftest.py`**
+
+Create or extend `tests/unit/adapters/conftest.py`:
+
+```python
+import sys
+from types import SimpleNamespace
+from unittest.mock import MagicMock
+
+import numpy as np
+import pytest
+
+
+@pytest.fixture
+def mock_av(monkeypatch: pytest.MonkeyPatch) -> SimpleNamespace:
+    """Shared ``av`` module mock for adapter tests."""
+    # (paste the body from Task 5 Step 2 here, verbatim)
+    ...
+```
+
+Remove the duplicated fixture from `test_uvc_webcam.py`.
+
+- [ ] **Step 3: Update the OAK `mock_cv2` fixture usage**
+
+In `test_oak_camera.py`, find every test that used `mock_cv2` for the `VideoWriter`. Replace the fixture parameter with `mock_av` and update assertions:
+
+- `mock_cv2.VideoWriter_fourcc.assert_called_with(*"mp4v")` → remove (fourcc is handled inside VideoEncoder, not the adapter's concern)
+- `mock_cv2.VideoWriter.assert_called_once_with(...)` → `mock_av.av.open.assert_called_with(..., mode="w")` (plus the geometry on the returned stream)
+
+The DepthAI mock (`mock_depthai`) is untouched.
+
+- [ ] **Step 4: Run the OAK tests**
+
+```bash
+uv run pytest tests/unit/adapters/test_oak_camera.py -v
+```
+
+Expected: same number of passing tests as pre-migration.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add tests/unit/adapters/conftest.py tests/unit/adapters/test_oak_camera.py tests/unit/adapters/test_uvc_webcam.py
+git commit -m "test(adapters): hoist mock_av fixture and migrate OAK tests"
+```
+
+---
+
+## Task 8: Migrate viewer MJPEG endpoint — Pillow
+
+**Files:**
+- Modify: `src/syncfield/viewer/server.py`
+- Modify: `tests/unit/viewer/test_cluster_endpoints.py` (if it mocks cv2)
+
+- [ ] **Step 1: Remove `cv2` import, add Pillow**
+
+In `src/syncfield/viewer/server.py`:
+
+```python
+# DELETE
+import cv2
+
+# ADD (near the other stdlib / third-party imports)
+import io
+from PIL import Image
+```
+
+- [ ] **Step 2: Replace the JPEG encode block**
+
+Find the `_mjpeg_generator` method (around lines 1645–1666). Replace the `cv2.imencode` block with:
+
+```python
+# BGR numpy → PIL Image (PIL expects RGB, so reverse the last axis)
+rgb = stream.latest_frame[:, :, ::-1]
+img = Image.fromarray(rgb)
+buf = io.BytesIO()
+img.save(buf, format="JPEG", quality=80)
+frame_bytes = buf.getvalue()
+```
+
+The `yield` block after this stays identical.
+
+- [ ] **Step 3: Update viewer tests if they mock `cv2.imencode`**
+
+```bash
+grep -n 'cv2\|imencode' tests/unit/viewer/test_cluster_endpoints.py
+```
+
+If any test patches `cv2.imencode`, replace with a patch on `PIL.Image.Image.save` or a fake frame that round-trips through real Pillow (Pillow has no native dep, so it's fine to use the real library in tests).
+
+- [ ] **Step 4: Run viewer tests**
+
+```bash
+uv run pytest tests/unit/viewer -v
+```
+
+Expected: same pass count as before.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add src/syncfield/viewer/server.py tests/unit/viewer/test_cluster_endpoints.py
+git commit -m "refactor(viewer): swap cv2.imencode for Pillow JPEG encoder"
+```
+
+---
+
+## Task 9: Verify OpenCV is fully gone
+
+**Files:**
+- No edits — verification only.
+
+- [ ] **Step 1: Grep the repo for any remaining `cv2`**
+
+Run: `grep -rn 'cv2\|opencv' src/ tests/ --include='*.py'`
+
+Expected: zero hits. If hits remain, fix them before continuing.
+
+- [ ] **Step 2: Grep `pyproject.toml`**
+
+Run: `grep -n 'opencv' pyproject.toml`
+
+Expected: zero hits.
+
+- [ ] **Step 3: Run the full unit test suite**
+
+```bash
+uv run pytest tests/unit -x -q
+```
+
+Expected: the pass count recorded in Task 0 Step 2.
+
+- [ ] **Step 4: Commit the cleanup marker (docs only if anything updated)**
+
+No changes expected — skip.
+
+---
+
+## Task 10: Add jitter metrics to `FinalizationReport`
+
+**Files:**
+- Modify: `src/syncfield/types.py`
+- Modify: `src/syncfield/adapters/uvc_webcam.py` (collect jitter in capture loop)
+- Modify: `src/syncfield/adapters/oak_camera.py` (collect jitter in capture loop)
+- Create: `tests/unit/test_finalization_jitter.py`
+
+Rationale: as decided in design discussion, we keep `time.monotonic_ns()` as the single timestamp source. To monitor whether that choice starts to hurt us (scale, CPU pressure), every video stream reports `jitter_p95_ns` and `jitter_p99_ns` in its FinalizationReport.
+
+- [ ] **Step 1: Add the failing test**
+
+Create `tests/unit/test_finalization_jitter.py`:
+
+```python
+from syncfield.types import FinalizationReport
+
+
+def test_finalization_report_accepts_jitter_fields() -> None:
+    report = FinalizationReport(
+        stream_id="uvc0",
+        status="completed",
+        frame_count=100,
+        file_path=None,
+        first_sample_at_ns=0,
+        last_sample_at_ns=3_000_000_000,
+        health_events=[],
+        error=None,
+        jitter_p95_ns=2_500_000,
+        jitter_p99_ns=4_000_000,
+    )
+    assert report.jitter_p95_ns == 2_500_000
+    assert report.jitter_p99_ns == 4_000_000
+
+
+def test_finalization_report_jitter_defaults_none() -> None:
+    report = FinalizationReport(
+        stream_id="ble0",
+        status="completed",
+        frame_count=0,
+        file_path=None,
+        first_sample_at_ns=None,
+        last_sample_at_ns=None,
+        health_events=[],
+        error=None,
+    )
+    assert report.jitter_p95_ns is None
+    assert report.jitter_p99_ns is None
+```
+
+- [ ] **Step 2: Run — expect failure**
+
+```bash
+uv run pytest tests/unit/test_finalization_jitter.py -v
+```
+
+Expected: `TypeError: unexpected keyword argument 'jitter_p95_ns'`.
+
+- [ ] **Step 3: Extend `FinalizationReport`**
+
+Edit `src/syncfield/types.py`:
+
+```python
+@dataclass
+class FinalizationReport:
+    stream_id: str
+    status: Literal["completed", "partial", "failed"]
+    frame_count: int
+    file_path: Path | None
+    first_sample_at_ns: int | None
+    last_sample_at_ns: int | None
+    health_events: list[HealthEvent]
+    error: str | None
+    jitter_p95_ns: int | None = None
+    jitter_p99_ns: int | None = None
+```
+
+- [ ] **Step 4: Run — expect pass**
+
+```bash
+uv run pytest tests/unit/test_finalization_jitter.py -v
+```
+
+Expected: 2 passed.
+
+- [ ] **Step 5: Plumb jitter collection into the UVC capture loop**
+
+In `src/syncfield/adapters/uvc_webcam.py`, add to `__init__`:
+
+```python
+self._prev_capture_ns: Optional[int] = None
+self._intervals_ns: list[int] = []
+```
+
+In `_capture_loop`, immediately after `capture_ns = time.monotonic_ns()`:
+
+```python
+if self._prev_capture_ns is not None:
+    self._intervals_ns.append(capture_ns - self._prev_capture_ns)
+self._prev_capture_ns = capture_ns
+```
+
+In `stop_recording`, compute percentiles before building the report:
+
+```python
+import statistics  # at the top of the file
+
+jitter_p95 = jitter_p99 = None
+if len(self._intervals_ns) >= 20:
+    sorted_iv = sorted(self._intervals_ns)
+    jitter_p95 = sorted_iv[int(len(sorted_iv) * 0.95)]
+    jitter_p99 = sorted_iv[int(len(sorted_iv) * 0.99)]
+
+return FinalizationReport(
+    stream_id=self.id,
+    status="completed",
+    frame_count=self._frame_count,
+    file_path=self._file_path if self._frame_count > 0 else None,
+    first_sample_at_ns=self._first_at,
+    last_sample_at_ns=self._last_at,
+    health_events=list(self._collected_health),
+    error=None,
+    jitter_p95_ns=jitter_p95,
+    jitter_p99_ns=jitter_p99,
+)
+```
+
+Also reset `self._intervals_ns = []` and `self._prev_capture_ns = None` at the start of `start_recording` so a second recording in the same session starts clean.
+
+- [ ] **Step 6: Apply the identical plumbing to OAK**
+
+Same four edits in `src/syncfield/adapters/oak_camera.py`:
+
+1. Init: `self._prev_capture_ns`, `self._intervals_ns`.
+2. Capture tick: append interval.
+3. `start_recording`: reset both.
+4. `stop_recording`: compute p95/p99, include in report.
+
+- [ ] **Step 7: Update UVC lifecycle test to assert jitter**
+
+In `tests/unit/adapters/test_uvc_webcam.py`, add one test:
+
+```python
+def test_jitter_reported_when_enough_frames(
+    mock_av, tmp_path
+) -> None:
+    from syncfield.adapters.uvc_webcam import UVCWebcamStream
+    from syncfield.clock import SessionClock
+    import time as _t
+
+    frames = [mock_av.make_frame(i) for i in range(30)]
+    mock_av.input_container.decode = MagicMock(return_value=iter(frames))
+
+    stream = UVCWebcamStream(
+        id="uvc0", device_index=0, output_dir=tmp_path, fps=30.0
+    )
+    stream.prepare()
+    stream.connect()
+    stream.start_recording(SessionClock())
+    _t.sleep(0.1)
+    report = stream.stop_recording()
+    stream.disconnect()
+
+    assert report.jitter_p95_ns is not None
+    assert report.jitter_p99_ns is not None
+    assert report.jitter_p99_ns >= report.jitter_p95_ns
+```
+
+- [ ] **Step 8: Run all tests**
+
+```bash
+uv run pytest tests/unit -x -q
+```
+
+Expected: all previously-passing tests pass + the 3 new jitter tests.
+
+- [ ] **Step 9: Commit**
+
+```bash
+git add src/syncfield/types.py src/syncfield/adapters/uvc_webcam.py \
+        src/syncfield/adapters/oak_camera.py tests/
+git commit -m "feat(metrics): report jitter p95/p99 in FinalizationReport"
+```
+
+---
+
+## Task 11: Hardware smoke test (documentation, not automated)
+
+**Files:**
+- Create: `docs/plans/2026-04-13-opencv-to-pyav-migration-hw-smoketest.md`
+
+- [ ] **Step 1: Write a smoke-test checklist for the hardware engineer**
+
+Create the file with this body:
+
+```markdown
+# PyAV Migration — Hardware Smoke Test
+
+Run on: MacBook M3/M4, Apple Silicon, macOS 14+.
+
+1. **UVC camera at 720p** — plug a FaceTime / Logitech / BRIO webcam:
+   ```bash
+   uv run python examples/iphone_mac_webcam/run.py --width 1280 --height 720 --fps 30
+   ```
+   Record for 30 s. Check: `{id}.mp4` plays in QuickTime, is ~720p, has 900 ± 5 frames.
+
+2. **VideoToolbox hardware encoder** — while recording:
+   ```bash
+   top -pid $(pgrep -f run.py)
+   ```
+   Python CPU should be < 30 % (was > 80 % on cv2 mp4v).
+
+3. **OAK camera with depth** — run `examples/mac_iphone_dual_oak/`:
+   ```bash
+   uv run python examples/mac_iphone_dual_oak/run.py --duration 30
+   ```
+   Check: RGB mp4 is valid; `.depth.bin` size ≈ `1280*800*2*frame_count` bytes.
+
+4. **Viewer MJPEG** — load the viewer in a browser, confirm thumbnails
+   update at ~30 fps per stream for the recording window.
+
+5. **Jitter report** — at session end, inspect
+   `session_manifest.json` or the stdout report for
+   `jitter_p95_ns` / `jitter_p99_ns`. On an idle M3 with 4 streams
+   expect p95 < 3 ms, p99 < 6 ms.
+```
+
+- [ ] **Step 2: Commit**
+
+```bash
+git add docs/plans/2026-04-13-opencv-to-pyav-migration-hw-smoketest.md
+git commit -m "docs: hardware smoke-test checklist for PyAV migration"
+```
+
+---
+
+## Self-Review Summary
+
+**Spec coverage:**
+- UVC adapter migration → Tasks 3, 4, 5.
+- OAK adapter migration (writer only) → Tasks 6, 7.
+- Viewer MJPEG migration → Task 8.
+- Remove `opencv-python` entirely → Tasks 1 and 9.
+- Preserve existing lifecycle and contract → every task's "keep public surface identical" note.
+- Jitter metric (decided in design chat) → Task 10.
+- Hardware validation → Task 11.
+
+**Placeholder scan:** one intentional placeholder in Task 4 Step 1 (the `discover` method body is a verbatim copy from the pre-migration file — Task 4 Step 2 tells the engineer exactly how to retrieve it). No generic "add error handling" or "TBD" elsewhere.
+
+**Type consistency:** `VideoEncoder.open(...)` / `VideoEncoder.write(...)` / `VideoEncoder.close()` and `open_uvc_input(...)` are used identically across Tasks 2, 3, 4, 6. `FinalizationReport.jitter_p95_ns` / `jitter_p99_ns` field names match across Task 10 definition, plumbing, and test sites.
+
+---
+
+## Execution Handoff
+
+Plan complete and saved to `docs/plans/2026-04-13-opencv-to-pyav-migration.md`.
+
+**Two execution options:**
+
+1. **Subagent-Driven (recommended)** — dispatch a fresh subagent per task, review between tasks, fast iteration.
+2. **Inline Execution** — execute tasks in this session using executing-plans, batch execution with checkpoints.
+
+Which approach do you want?

From 01ad140556caf833fe9af676ec6b9c120972745c Mon Sep 17 00:00:00 2001
From: styu12 <styu12@naver.com>
Date: Mon, 13 Apr 2026 15:02:23 -0700
Subject: [PATCH 02/18] build: replace opencv-python with av + Pillow in extras

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 pyproject.toml |  18 ++-
 uv.lock        | 399 +++++++++++++++++++++++++++++++++++++++++++++----
 2 files changed, 382 insertions(+), 35 deletions(-)

diff --git a/pyproject.toml b/pyproject.toml
index 022eb55..aaf1232 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -30,18 +30,19 @@ audio = [
     "sounddevice>=0.4.6",
     "numpy>=1.21",
 ]
-uvc = ["opencv-python>=4.5"]
+uvc = ["av>=12.0.0"]
 ble = ["bleak>=0.21"]
-# OakCameraStream uses depthai v3 for the pipeline and reuses the `uvc`
-# extra's opencv-python for the MP4 writer. Install `syncfield[oak,uvc]`
-# (or `syncfield[all]`) for the full OAK capture path.
-oak = ["depthai>=3.0.0"]
+# OakCameraStream uses depthai v3 for the pipeline and PyAV for the MP4
+# writer. Install `syncfield[oak]` for the full OAK capture path.
+oak = ["depthai>=3.0.0", "av>=12.0.0"]
 # The web viewer uses FastAPI + uvicorn and opens a browser tab.
-# opencv-python is needed for MJPEG encoding of video frames.
+# PyAV handles MJPEG encoding of video frames; Pillow is used for still
+# image conversions.
 viewer = [
     "fastapi>=0.104.0",
     "uvicorn[standard]>=0.24.0",
-    "opencv-python>=4.8.0",
+    "av>=12.0.0",
+    "Pillow>=10.0.0",
 ]
 # mDNS-based multi-host session rendezvous (syncfield.multihost). Required
 # only when you want a leader/follower session discovered automatically
@@ -55,7 +56,8 @@ multihost = [
 all = [
     "sounddevice>=0.4.6",
     "numpy>=1.21",
-    "opencv-python>=4.8.0",
+    "av>=12.0.0",
+    "Pillow>=10.0.0",
     "bleak>=0.21",
     "depthai>=3.0.0",
     "fastapi>=0.104.0",
diff --git a/uv.lock b/uv.lock
index 34ef60d..13d3129 100644
--- a/uv.lock
+++ b/uv.lock
@@ -69,6 +69,101 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/fe/ba/e2081de779ca30d473f21f5b30e0e737c438205440784c7dfc81efc2b029/async_timeout-5.0.1-py3-none-any.whl", hash = "sha256:39e3809566ff85354557ec2398b55e096c8364bacac9405a7a1fa429e77fe76c", size = 6233, upload-time = "2024-11-06T16:41:37.9Z" },
 ]
 
+[[package]]
+name = "av"
+version = "15.1.0"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version < '3.10'",
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e9/c3/83e6e73d1592bc54436eae0bc61704ae0cff0c3cfbde7b58af9ed67ebb49/av-15.1.0.tar.gz", hash = "sha256:39cda2dc810e11c1938f8cb5759c41d6b630550236b3365790e67a313660ec85", size = 3774192, upload-time = "2025-08-30T04:41:56.076Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3a/6a/91e3e68ae0d1b53b480ec69a96f2ae820fb007bc60e6b821741f31c7ba4e/av-15.1.0-cp310-cp310-macosx_13_0_arm64.whl", hash = "sha256:cf067b66cee2248220b29df33b60eb4840d9e7b9b75545d6b922f9c41d88c4ee", size = 21781685, upload-time = "2025-08-30T04:39:13.118Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/6d/afa951b9cb615c3bc6d95c4eed280c6cefb52c006f4e15e79043626fab39/av-15.1.0-cp310-cp310-macosx_13_0_x86_64.whl", hash = "sha256:26426163d96fc3bde9a015ba4d60da09ef848d9284fe79b4ca5e60965a008fc5", size = 26962481, upload-time = "2025-08-30T04:39:16.875Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/42/0c384884235c42c439cef28cbd129e4624ad60229119bf3c6c6020805119/av-15.1.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:92f524541ce74b8a12491d8934164a5c57e983da24826547c212f60123de400b", size = 37571839, upload-time = "2025-08-30T04:39:20.325Z" },
+    { url = "https://files.pythonhosted.org/packages/25/c0/5c967b0872fce1add80a8f50fa7ce11e3e3e5257c2b079263570bc854699/av-15.1.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:659f9d6145fb2c58e8b31907283b6ba876570f5dd6e7e890d74c09614c436c8e", size = 39070227, upload-time = "2025-08-30T04:39:24.079Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/81/e333056d49363c35a74b828ed5f87c96dfbcc1a506b49d79a31ac773b94d/av-15.1.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:07a8ae30c0cfc3132eff320a6b27d18a5e0dda36effd0ae28892888f4ee14729", size = 39619362, upload-time = "2025-08-30T04:39:27.7Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/ae/50cc2af1bf68452cbfec8d1b2554c18f6d167c8ba6d7ad7707797dfd1541/av-15.1.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:e33a76e38f03bb5de026b9f66ccf23dc01ddd2223221096992cb52ac22e62538", size = 40371627, upload-time = "2025-08-30T04:39:31.207Z" },
+    { url = "https://files.pythonhosted.org/packages/50/e6/381edf1779106dd31c9ef1ac9842f643af4465b8a87cbc278d3eaa76229a/av-15.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:aa4bf12bdce20edc2a3b13a2776c474c5ab63e1817d53793714504476eeba82e", size = 31340369, upload-time = "2025-08-30T04:39:34.774Z" },
+    { url = "https://files.pythonhosted.org/packages/47/58/4e44cf6939be7aba96a4abce024e1be11ba7539ecac74d09369b8c03aa05/av-15.1.0-cp311-cp311-macosx_13_0_arm64.whl", hash = "sha256:b785948762a8d45fc58fc24a20251496829ace1817e9a7a508a348d6de2182c3", size = 21767323, upload-time = "2025-08-30T04:39:37.989Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/f6/a946544cdb49f6d892d2761b1d61a8bc6ce912fe57ba06769bdc640c0a7f/av-15.1.0-cp311-cp311-macosx_13_0_x86_64.whl", hash = "sha256:9c7131494a3a318612b4ee4db98fe5bc50eb705f6b6536127c7ab776c524fd8b", size = 26946268, upload-time = "2025-08-30T04:39:40.601Z" },
+    { url = "https://files.pythonhosted.org/packages/70/7c/b33513c0af73d0033af59a98f035b521c5b93445a6af7e9efbf41a6e8383/av-15.1.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:2b9623ae848625c59213b610c8665817924f913580c7c5c91e0dc18936deb00d", size = 38062118, upload-time = "2025-08-30T04:39:43.928Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/95/31b7fb34f9fea7c7389240364194f4f56ad2d460095038cc720f50a90bb3/av-15.1.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:c8ef597087db560514617143532b1fafc4825ebb2dda9a22418f548b113a0cc7", size = 39571086, upload-time = "2025-08-30T04:39:47.109Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/b0/7b0b45474a4e90c35c11d0032947d8b3c7386872957ce29c6f12add69a74/av-15.1.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:08eac47a90ebae1e2bd5935f400dd515166019bab4ff5b03c4625fa6ac3a0a5e", size = 40112634, upload-time = "2025-08-30T04:39:50.981Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/04/038b94bc9a1ee10a451c867d4a2fc91e845f83bfc2dae9df25893abcb57f/av-15.1.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:d3f66ff200ea166e606cb3c5cb1bd2fc714effbec2e262a5d67ce60450c8234a", size = 40878695, upload-time = "2025-08-30T04:39:54.493Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/3d/9f8f96c0deeaaf648485a3dbd1699b2f0580f2ce8a36cb616c0138ba7615/av-15.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:57b99544d91121b8bea570e4ddf61700f679a6b677c1f37966bc1a22e1d4cd5c", size = 31335683, upload-time = "2025-08-30T04:39:57.861Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/58/de78b276d20db6ffcd4371283df771721a833ba525a3d57e753d00a9fe79/av-15.1.0-cp312-cp312-macosx_13_0_arm64.whl", hash = "sha256:40c5df37f4c354ab8190c6fd68dab7881d112f527906f64ca73da4c252a58cee", size = 21760991, upload-time = "2025-08-30T04:40:00.801Z" },
+    { url = "https://files.pythonhosted.org/packages/56/cc/45f85775304ae60b66976360d82ba5b152ad3fd91f9267d5020a51e9a828/av-15.1.0-cp312-cp312-macosx_13_0_x86_64.whl", hash = "sha256:af455ce65ada3d361f80c90c810d9bced4db5655ab9aa513024d6c71c5c476d5", size = 26953097, upload-time = "2025-08-30T04:40:03.998Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/f8/2d781e5e71d02fc829487e775ccb1185e72f95340d05f2e84eb57a11e093/av-15.1.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:86226d2474c80c3393fa07a9c366106029ae500716098b72b3ec3f67205524c3", size = 38319710, upload-time = "2025-08-30T04:40:07.701Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/13/37737ef2193e83862ccacff23580c39de251da456a1bf0459e762cca273c/av-15.1.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:11326f197e7001c4ca53a83b2dbc67fd39ddff8cdf62ce6be3b22d9f3f9338bd", size = 39915519, upload-time = "2025-08-30T04:40:11.066Z" },
+    { url = "https://files.pythonhosted.org/packages/26/e9/e8032c7b8f2a4129a03f63f896544f8b7cf068e2db2950326fa2400d5c47/av-15.1.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a631ea879cc553080ee62874f4284765c42ba08ee0279851a98a85e2ceb3cc8d", size = 40286166, upload-time = "2025-08-30T04:40:14.561Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/23/612c0fd809444d04b8387a2dfd942ccc77829507bd78a387ff65a9d98c24/av-15.1.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:8f383949b010c3e731c245f80351d19dc0c08f345e194fc46becb1cb279be3ff", size = 41150592, upload-time = "2025-08-30T04:40:17.951Z" },
+    { url = "https://files.pythonhosted.org/packages/15/74/6f8e38a3b0aea5f28e72813672ff45b64615f2c69e6a4a558718c95edb9f/av-15.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:d5921aa45f4c1f8c1a8d8185eb347e02aa4c3071278a2e2dd56368d54433d643", size = 31336093, upload-time = "2025-08-30T04:40:21.393Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/bc/78b2ffa8235eeffc29aa4a8cc47b02e660cfec32f601f39a00975fb06d0e/av-15.1.0-cp313-cp313-macosx_13_0_arm64.whl", hash = "sha256:2f77853c3119c59d1bff4214ccbe46e3133eccff85ed96adee51c68684443f4e", size = 21726244, upload-time = "2025-08-30T04:40:24.14Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/99/66d69453a2dce028e6e8ebea085d90e880aac03d3a3ab7d8ec16755ffd75/av-15.1.0-cp313-cp313-macosx_13_0_x86_64.whl", hash = "sha256:c0bc4471c156a0a1c70a607502434f477bc8dfe085eef905e55b4b0d66bcd3a5", size = 26918663, upload-time = "2025-08-30T04:40:27.557Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/51/1a7dfbeda71f2772bc46d758af0e7fab1cc8388ce4bc7f24aecbc4bfd764/av-15.1.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:37839d4fa1407f047af82560dfc0f94d8d6266071eff49e1cbe16c4483054621", size = 38041408, upload-time = "2025-08-30T04:40:30.811Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/97/2c4e0288ad4359b6064cb06ae79c2ff3a84ac73d27e91f2161b75fcd86fa/av-15.1.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:729179cd8622815e8b6f6854d13a806fe710576e08895c77e5e4ad254609de9a", size = 39642563, upload-time = "2025-08-30T04:40:34.617Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/94/2362502149e276d00957edabcc201a5f4d5109a8a7b4fd30793714a532f3/av-15.1.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4abdf085bfa4eec318efccff567831b361ea56c045cc38366811552e3127c665", size = 40022119, upload-time = "2025-08-30T04:40:37.703Z" },
+    { url = "https://files.pythonhosted.org/packages/df/58/1a0ce1b3835d9728da0a7a54aeffaa0a2b1a88405eaed9322efd55212a54/av-15.1.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f985661644879e4520d28a995fcb2afeb951bc15a1d51412eb8e5f36da85b6fe", size = 40885158, upload-time = "2025-08-30T04:40:40.952Z" },
+    { url = "https://files.pythonhosted.org/packages/30/e6/054bb64e424d90b77ed5fc6a7358e4013fb436154c998fc90a89a186313f/av-15.1.0-cp313-cp313-win_amd64.whl", hash = "sha256:7d7804a44c8048bb4b014a99353dd124663a12cd1d4613ba2bd3b457c3b1d539", size = 31312256, upload-time = "2025-08-30T04:40:44.224Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/8b/89eae6dca10d7d2b83c131025a31ccc750be78699ac0304439faa1d1df99/av-15.1.0-cp314-cp314-macosx_13_0_arm64.whl", hash = "sha256:5dd73c6447947edcb82e5fecf96e1f146aeda0f169c7ad4c54df4d9f66f63fde", size = 21730645, upload-time = "2025-08-30T04:40:47.259Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/f0/abffaf69405ed68041524be12a1e294faf396971d6a0e70eb00e93687df7/av-15.1.0-cp314-cp314-macosx_13_0_x86_64.whl", hash = "sha256:a81cd515934a5d51290aa66b059b7ed29c4a212e704f3c5e99e32877ff1c312c", size = 26913753, upload-time = "2025-08-30T04:40:50.445Z" },
+    { url = "https://files.pythonhosted.org/packages/37/9e/7af078bcfc3cd340c981ac5d613c090ab007023d2ac13b05acd52f22f069/av-15.1.0-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:57cc7a733a7e7d7a153682f35c9cf5d01e8269367b049c954779de36fc3d0b10", size = 38027048, upload-time = "2025-08-30T04:40:54.076Z" },
+    { url = "https://files.pythonhosted.org/packages/02/76/1f9dac11ad713e3619288993ea04e9c9cf4ec0f04e5ee81e83b8129dd8f3/av-15.1.0-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:a77b75bdb6899a64302ff923a5246e0747b3f0a3ecee7d61118db407a22c3f53", size = 39565396, upload-time = "2025-08-30T04:40:57.84Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/32/2188c46e2747247458ffc26b230c57dd28e61f65ff7b9e6223a411af5e98/av-15.1.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:d0a1154ce081f1720082a133cfe12356c59f62dad2b93a7a1844bf1dcd010d85", size = 40015050, upload-time = "2025-08-30T04:41:01.091Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/41/b57fbce9994580619d7574817ece0fe0e7b822cde2af57904549d0150b8d/av-15.1.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:8a7bf5a34dee15c86790414fa86a144e6d0dcc788bc83b565fdcbc080b4fbc90", size = 40821225, upload-time = "2025-08-30T04:41:04.349Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/36/e85cd1f0d3369c6764ad422882895d082f7ececb66d3df8aeae3234ef7a6/av-15.1.0-cp314-cp314-win_amd64.whl", hash = "sha256:e30c9a6fd9734784941384a2e25fad3c22881a7682f378914676aa7e795acdb7", size = 31311750, upload-time = "2025-08-30T04:41:07.744Z" },
+    { url = "https://files.pythonhosted.org/packages/80/d8/08a681758a4e49adfda409a6a35eff533f42654c6a6cfa102bc5cae1a728/av-15.1.0-cp314-cp314t-macosx_13_0_arm64.whl", hash = "sha256:60666833d7e65ebcfc48034a072de74349edbb62c9aaa3e6722fef31ca028eb6", size = 21828343, upload-time = "2025-08-30T04:41:10.81Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/52/29bec3fe68669b21f7d1ab5d94e21f597b8dfd37f50a3e3c9af6a8da925c/av-15.1.0-cp314-cp314t-macosx_13_0_x86_64.whl", hash = "sha256:53fbdae45aa2a49a22e864ff4f4017416ef62c060a172085d3247ba0a101104e", size = 27001666, upload-time = "2025-08-30T04:41:13.822Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/54/2c1d1faced66d708f5df328e800997cb47f90b500a214130c3a0f2ad601e/av-15.1.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:e6c51061667983dc801502aff9140bbc4f0e0d97f879586f17fb2f9a7e49c381", size = 39496753, upload-time = "2025-08-30T04:41:16.759Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/76/06ded5e52c4dcc2d9b5184c6da8de5ea77bd7ecb79a59a2b9700f1984949/av-15.1.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:2f80ec387f04aa34868662b11018b5f09654ae1530a61e24e92a142a24b10b62", size = 40784729, upload-time = "2025-08-30T04:41:20.491Z" },
+    { url = "https://files.pythonhosted.org/packages/52/ef/797b76f3b39c99a96e387f501bbc07dca340b27d3dda12862fe694066b63/av-15.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:4975e03177d37d8165c99c8d494175675ba8acb72458fb5d7e43f746a53e0374", size = 41284953, upload-time = "2025-08-30T04:41:23.949Z" },
+    { url = "https://files.pythonhosted.org/packages/31/47/e4656f00e62fd059ea5a40b492dea784f5aecfe1dfac10c0d7a0664ce200/av-15.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:8f78f3dad11780b4cdd024cdb92ce43cb170929297c00f2f4555c2b103f51e55", size = 41985340, upload-time = "2025-08-30T04:41:27.561Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/c9/15bb4fd7a1f39d70db35af2b9c20a0ae19e4220eb58a8b8446e903b98d72/av-15.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:9a20c5eba3ec49c2f4b281797021923fc68a86aeb66c5cda4fd0252fa8004951", size = 31487337, upload-time = "2025-08-30T04:41:30.591Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/0e/c7c9f14b5c19a8230e0538c2940cef6da2be08b5d05ce884a68a30f4573d/av-15.1.0-cp39-cp39-macosx_13_0_arm64.whl", hash = "sha256:315915f6fef9f9f4935153aed8a81df56690da20f4426ee5b9fa55b4dae4bc0b", size = 21795132, upload-time = "2025-08-30T04:41:33.37Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/f8/ab8d800eefcf3588f883b76dc0ba39c6f7bb6792d5d660a7d416626c909c/av-15.1.0-cp39-cp39-macosx_13_0_x86_64.whl", hash = "sha256:4a2a52a56cd8c6a8f0f005d29c3a0ebc1822d31b0d0f39990c4c8e3a69d6c96e", size = 26976225, upload-time = "2025-08-30T04:41:36.472Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/09/878ec186c3c306bf747351a8ad736d19a32e7a95fdcd6188bcbd1c1b2679/av-15.1.0-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:406fc29103865f17de0f684c5fb2e3d2e43e15c1fa65fcc488f65d20c7a7c7f3", size = 37575927, upload-time = "2025-08-30T04:41:39.597Z" },
+    { url = "https://files.pythonhosted.org/packages/05/da/bcc82726fca6554420b23c1c04449eb6545737e78bb908a8cdf1cdb1eb68/av-15.1.0-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:fe07cf7de162acc09d021e02154b1f760bca742c62609ec0ae586a6a1e0579ac", size = 39078913, upload-time = "2025-08-30T04:41:43.025Z" },
+    { url = "https://files.pythonhosted.org/packages/33/e0/0638db8e824297d1c6d3b3a1a3b28788d967eef9c357eee0f3f777894605/av-15.1.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:9a0c1840959e1742dcd7fa4f7e9b80eea298049542f233e98d6d7a9441ed292c", size = 39622862, upload-time = "2025-08-30T04:41:46.722Z" },
+    { url = "https://files.pythonhosted.org/packages/96/22/091a6076a80cf71c4c6f799c50ca10cbda1602b598f3f8c95f7be38aeb99/av-15.1.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:46875a57562a72d9b11b4b222628eaf7e5b1a723c4225c869c66d5704634c1d1", size = 40381672, upload-time = "2025-08-30T04:41:50.15Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/21/64bbe36d68f6908fc6cab1f4be85331bcedae6ff6eea2dc56663295efbad/av-15.1.0-cp39-cp39-win_amd64.whl", hash = "sha256:5f895315ecfe5821a4a3a178cbbe7f62e6a73ae1f726138bef5bb153b2885ed8", size = 31353295, upload-time = "2025-08-30T04:41:53.246Z" },
+]
+
+[[package]]
+name = "av"
+version = "17.0.0"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version >= '3.11'",
+    "python_full_version == '3.10.*'",
+]
+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/95/4d/ea1ac272eeea83014daca1783679a9e9f894e1e68e5eb4f717dd8813da2a/av-17.0.0-cp310-cp310-macosx_11_0_x86_64.whl", hash = "sha256:4b21bcff4144acae658c0efb011fa8668c7a9638384f3ae7f5add33f35b907c6", size = 23407827, upload-time = "2026-03-14T14:37:47.337Z" },
+    { url = "https://files.pythonhosted.org/packages/54/1a/e433766470c57c9c1c8558021de4d2466b3403ed629e48722d39d12baa6c/av-17.0.0-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:17cd518fc88dc449ce9dcfd0b40e9b3530266927375a743efc80d510adfb188b", size = 18829899, upload-time = "2026-03-14T14:37:50.493Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/25/95ad714f950c188495ffbfef235d06a332123d6f266026a534801ffc2171/av-17.0.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:9a8b7b63a92d8dc7cbe5000546e4684176124ddd49fdd9c12570e3aa6dadf11a", size = 35348062, upload-time = "2026-03-14T14:37:52.964Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/db/7f3f9e92f2ac8dba639ab01d69a33b723aa16b5e3e612dbfe667fbc02dcd/av-17.0.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:8706ce9b5d8d087d093b46a9781e7532c4a9e13874bca1da468be78efc56cecc", size = 37684503, upload-time = "2026-03-14T14:37:55.628Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/53/3b356b14ba72354688c8d9777cf67b707769b6e14b63aaeb0cddeeac8d32/av-17.0.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:3a074835ce807434451086993fedfb3b223dacedb2119ab9d7a72480f2d77f32", size = 36547601, upload-time = "2026-03-14T14:37:58.465Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/8d/f489cd6f9fe9c8b38dca00ecb39dc38836761767a4ec07dd95e62e124ac3/av-17.0.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f8ef8e8f1a0cbb2e0ad49266015e2277801a916e2186ac9451b493ff6dfdec27", size = 38815129, upload-time = "2026-03-14T14:38:01.277Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/bd/e42536234e37caffd1a054de1a0e6abca226c5686e9672726a8d95511422/av-17.0.0-cp310-cp310-win_amd64.whl", hash = "sha256:a795e153ff31a6430e974b4e6ad0d0fab695b78e3f17812293a0a34cd03ee6a9", size = 28984602, upload-time = "2026-03-14T14:38:03.632Z" },
+    { 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 = "bleak"
 version = "1.1.1"
@@ -381,6 +476,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/8a/0e/97c33bf5009bdbac74fd2beace167cab3f978feb69cc36f1ef79360d6c4e/exceptiongroup-1.3.1-py3-none-any.whl", hash = "sha256:a7a39a3bd276781e98394987d3a5701d0c4edffb633bb7a5144577f82c773598", size = 16740, upload-time = "2025-11-21T23:01:53.443Z" },
 ]
 
+[[package]]
+name = "execnet"
+version = "2.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/bf/89/780e11f9588d9e7128a3f87788354c7946a9cbb1401ad38a48c4db9a4f07/execnet-2.1.2.tar.gz", hash = "sha256:63d83bfdd9a23e35b9c6a3261412324f964c2ec8dcd8d3c6916ee9373e0befcd", size = 166622, upload-time = "2025-11-12T09:56:37.75Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ab/84/02fc1827e8cdded4aa65baef11296a9bbe595c474f0d6d758af082d849fd/execnet-2.1.2-py3-none-any.whl", hash = "sha256:67fba928dd5a544b783f6056f449e5e3931a5c378b128bc18501f7ea79e296ec", size = 40708, upload-time = "2025-11-12T09:56:36.333Z" },
+]
+
 [[package]]
 name = "fastapi"
 version = "0.128.8"
@@ -753,26 +857,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/04/74/f4c001f4714c3ad9ce037e18cf2b9c64871a84951eaa0baf683a9ca9301c/numpy-2.4.4-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:f2cf083b324a467e1ab358c105f6cad5ea950f50524668a80c486ff1db24e119", size = 12509075, upload-time = "2026-03-29T13:21:57.644Z" },
 ]
 
-[[package]]
-name = "opencv-python"
-version = "4.13.0.92"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "numpy", version = "2.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" },
-    { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.10.*'" },
-    { name = "numpy", version = "2.4.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
-]
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/fc/6f/5a28fef4c4a382be06afe3938c64cc168223016fa520c5abaf37e8862aa5/opencv_python-4.13.0.92-cp37-abi3-macosx_13_0_arm64.whl", hash = "sha256:caf60c071ec391ba51ed00a4a920f996d0b64e3e46068aac1f646b5de0326a19", size = 46247052, upload-time = "2026-02-05T07:01:25.046Z" },
-    { url = "https://files.pythonhosted.org/packages/08/ac/6c98c44c650b8114a0fb901691351cfb3956d502e8e9b5cd27f4ee7fbf2f/opencv_python-4.13.0.92-cp37-abi3-macosx_14_0_x86_64.whl", hash = "sha256:5868a8c028a0b37561579bfb8ac1875babdc69546d236249fff296a8c010ccf9", size = 32568781, upload-time = "2026-02-05T07:01:41.379Z" },
-    { url = "https://files.pythonhosted.org/packages/3e/51/82fed528b45173bf629fa44effb76dff8bc9f4eeaee759038362dfa60237/opencv_python-4.13.0.92-cp37-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:0bc2596e68f972ca452d80f444bc404e08807d021fbba40df26b61b18e01838a", size = 47685527, upload-time = "2026-02-05T06:59:11.24Z" },
-    { url = "https://files.pythonhosted.org/packages/db/07/90b34a8e2cf9c50fe8ed25cac9011cde0676b4d9d9c973751ac7616223a2/opencv_python-4.13.0.92-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:402033cddf9d294693094de5ef532339f14ce821da3ad7df7c9f6e8316da32cf", size = 70460872, upload-time = "2026-02-05T06:59:19.162Z" },
-    { url = "https://files.pythonhosted.org/packages/02/6d/7a9cc719b3eaf4377b9c2e3edeb7ed3a81de41f96421510c0a169ca3cfd4/opencv_python-4.13.0.92-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:bccaabf9eb7f897ca61880ce2869dcd9b25b72129c28478e7f2a5e8dee945616", size = 46708208, upload-time = "2026-02-05T06:59:15.419Z" },
-    { url = "https://files.pythonhosted.org/packages/fd/55/b3b49a1b97aabcfbbd6c7326df9cb0b6fa0c0aefa8e89d500939e04aa229/opencv_python-4.13.0.92-cp37-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:620d602b8f7d8b8dab5f4b99c6eb353e78d3fb8b0f53db1bd258bb1aa001c1d5", size = 72927042, upload-time = "2026-02-05T06:59:23.389Z" },
-    { url = "https://files.pythonhosted.org/packages/fb/17/de5458312bcb07ddf434d7bfcb24bb52c59635ad58c6e7c751b48949b009/opencv_python-4.13.0.92-cp37-abi3-win32.whl", hash = "sha256:372fe164a3148ac1ca51e5f3ad0541a4a276452273f503441d718fab9c5e5f59", size = 30932638, upload-time = "2026-02-05T07:02:14.98Z" },
-    { url = "https://files.pythonhosted.org/packages/e9/a5/1be1516390333ff9be3a9cb648c9f33df79d5096e5884b5df71a588af463/opencv_python-4.13.0.92-cp37-abi3-win_amd64.whl", hash = "sha256:423d934c9fafb91aad38edf26efb46da91ffbc05f3f59c4b0c72e699720706f5", size = 40212062, upload-time = "2026-02-05T07:02:12.724Z" },
-]
-
 [[package]]
 name = "packaging"
 version = "26.0"
@@ -782,6 +866,224 @@ 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 = "pillow"
+version = "11.3.0"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version < '3.10'",
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f3/0d/d0d6dea55cd152ce3d6767bb38a8fc10e33796ba4ba210cbab9354b6d238/pillow-11.3.0.tar.gz", hash = "sha256:3828ee7586cd0b2091b6209e5ad53e20d0649bbe87164a459d0676e035e8f523", size = 47113069, upload-time = "2025-07-01T09:16:30.666Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4c/5d/45a3553a253ac8763f3561371432a90bdbe6000fbdcf1397ffe502aa206c/pillow-11.3.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:1b9c17fd4ace828b3003dfd1e30bff24863e0eb59b535e8f80194d9cc7ecf860", size = 5316554, upload-time = "2025-07-01T09:13:39.342Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/c8/67c12ab069ef586a25a4a79ced553586748fad100c77c0ce59bb4983ac98/pillow-11.3.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:65dc69160114cdd0ca0f35cb434633c75e8e7fad4cf855177a05bf38678f73ad", size = 4686548, upload-time = "2025-07-01T09:13:41.835Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/bd/6741ebd56263390b382ae4c5de02979af7f8bd9807346d068700dd6d5cf9/pillow-11.3.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7107195ddc914f656c7fc8e4a5e1c25f32e9236ea3ea860f257b0436011fddd0", size = 5859742, upload-time = "2025-07-03T13:09:47.439Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/0b/c412a9e27e1e6a829e6ab6c2dca52dd563efbedf4c9c6aa453d9a9b77359/pillow-11.3.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:cc3e831b563b3114baac7ec2ee86819eb03caa1a2cef0b481a5675b59c4fe23b", size = 7633087, upload-time = "2025-07-03T13:09:51.796Z" },
+    { url = "https://files.pythonhosted.org/packages/59/9d/9b7076aaf30f5dd17e5e5589b2d2f5a5d7e30ff67a171eb686e4eecc2adf/pillow-11.3.0-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f1f182ebd2303acf8c380a54f615ec883322593320a9b00438eb842c1f37ae50", size = 5963350, upload-time = "2025-07-01T09:13:43.865Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/16/1a6bf01fb622fb9cf5c91683823f073f053005c849b1f52ed613afcf8dae/pillow-11.3.0-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4445fa62e15936a028672fd48c4c11a66d641d2c05726c7ec1f8ba6a572036ae", size = 6631840, upload-time = "2025-07-01T09:13:46.161Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/e6/6ff7077077eb47fde78739e7d570bdcd7c10495666b6afcd23ab56b19a43/pillow-11.3.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:71f511f6b3b91dd543282477be45a033e4845a40278fa8dcdbfdb07109bf18f9", size = 6074005, upload-time = "2025-07-01T09:13:47.829Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/3a/b13f36832ea6d279a697231658199e0a03cd87ef12048016bdcc84131601/pillow-11.3.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:040a5b691b0713e1f6cbe222e0f4f74cd233421e105850ae3b3c0ceda520f42e", size = 6708372, upload-time = "2025-07-01T09:13:52.145Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/e4/61b2e1a7528740efbc70b3d581f33937e38e98ef3d50b05007267a55bcb2/pillow-11.3.0-cp310-cp310-win32.whl", hash = "sha256:89bd777bc6624fe4115e9fac3352c79ed60f3bb18651420635f26e643e3dd1f6", size = 6277090, upload-time = "2025-07-01T09:13:53.915Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/d3/60c781c83a785d6afbd6a326ed4d759d141de43aa7365725cbcd65ce5e54/pillow-11.3.0-cp310-cp310-win_amd64.whl", hash = "sha256:19d2ff547c75b8e3ff46f4d9ef969a06c30ab2d4263a9e287733aa8b2429ce8f", size = 6985988, upload-time = "2025-07-01T09:13:55.699Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/28/4f4a0203165eefb3763939c6789ba31013a2e90adffb456610f30f613850/pillow-11.3.0-cp310-cp310-win_arm64.whl", hash = "sha256:819931d25e57b513242859ce1876c58c59dc31587847bf74cfe06b2e0cb22d2f", size = 2422899, upload-time = "2025-07-01T09:13:57.497Z" },
+    { url = "https://files.pythonhosted.org/packages/db/26/77f8ed17ca4ffd60e1dcd220a6ec6d71210ba398cfa33a13a1cd614c5613/pillow-11.3.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:1cd110edf822773368b396281a2293aeb91c90a2db00d78ea43e7e861631b722", size = 5316531, upload-time = "2025-07-01T09:13:59.203Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/39/ee475903197ce709322a17a866892efb560f57900d9af2e55f86db51b0a5/pillow-11.3.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:9c412fddd1b77a75aa904615ebaa6001f169b26fd467b4be93aded278266b288", size = 4686560, upload-time = "2025-07-01T09:14:01.101Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/90/442068a160fd179938ba55ec8c97050a612426fae5ec0a764e345839f76d/pillow-11.3.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7d1aa4de119a0ecac0a34a9c8bde33f34022e2e8f99104e47a3ca392fd60e37d", size = 5870978, upload-time = "2025-07-03T13:09:55.638Z" },
+    { url = "https://files.pythonhosted.org/packages/13/92/dcdd147ab02daf405387f0218dcf792dc6dd5b14d2573d40b4caeef01059/pillow-11.3.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:91da1d88226663594e3f6b4b8c3c8d85bd504117d043740a8e0ec449087cc494", size = 7641168, upload-time = "2025-07-03T13:10:00.37Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/db/839d6ba7fd38b51af641aa904e2960e7a5644d60ec754c046b7d2aee00e5/pillow-11.3.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:643f189248837533073c405ec2f0bb250ba54598cf80e8c1e043381a60632f58", size = 5973053, upload-time = "2025-07-01T09:14:04.491Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/2f/d7675ecae6c43e9f12aa8d58b6012683b20b6edfbdac7abcb4e6af7a3784/pillow-11.3.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:106064daa23a745510dabce1d84f29137a37224831d88eb4ce94bb187b1d7e5f", size = 6640273, upload-time = "2025-07-01T09:14:06.235Z" },
+    { url = "https://files.pythonhosted.org/packages/45/ad/931694675ede172e15b2ff03c8144a0ddaea1d87adb72bb07655eaffb654/pillow-11.3.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:cd8ff254faf15591e724dc7c4ddb6bf4793efcbe13802a4ae3e863cd300b493e", size = 6082043, upload-time = "2025-07-01T09:14:07.978Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/04/ba8f2b11fc80d2dd462d7abec16351b45ec99cbbaea4387648a44190351a/pillow-11.3.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:932c754c2d51ad2b2271fd01c3d121daaa35e27efae2a616f77bf164bc0b3e94", size = 6715516, upload-time = "2025-07-01T09:14:10.233Z" },
+    { url = "https://files.pythonhosted.org/packages/48/59/8cd06d7f3944cc7d892e8533c56b0acb68399f640786313275faec1e3b6f/pillow-11.3.0-cp311-cp311-win32.whl", hash = "sha256:b4b8f3efc8d530a1544e5962bd6b403d5f7fe8b9e08227c6b255f98ad82b4ba0", size = 6274768, upload-time = "2025-07-01T09:14:11.921Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/cc/29c0f5d64ab8eae20f3232da8f8571660aa0ab4b8f1331da5c2f5f9a938e/pillow-11.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:1a992e86b0dd7aeb1f053cd506508c0999d710a8f07b4c791c63843fc6a807ac", size = 6986055, upload-time = "2025-07-01T09:14:13.623Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/df/90bd886fabd544c25addd63e5ca6932c86f2b701d5da6c7839387a076b4a/pillow-11.3.0-cp311-cp311-win_arm64.whl", hash = "sha256:30807c931ff7c095620fe04448e2c2fc673fcbb1ffe2a7da3fb39613489b1ddd", size = 2423079, upload-time = "2025-07-01T09:14:15.268Z" },
+    { url = "https://files.pythonhosted.org/packages/40/fe/1bc9b3ee13f68487a99ac9529968035cca2f0a51ec36892060edcc51d06a/pillow-11.3.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:fdae223722da47b024b867c1ea0be64e0df702c5e0a60e27daad39bf960dd1e4", size = 5278800, upload-time = "2025-07-01T09:14:17.648Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/32/7e2ac19b5713657384cec55f89065fb306b06af008cfd87e572035b27119/pillow-11.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:921bd305b10e82b4d1f5e802b6850677f965d8394203d182f078873851dada69", size = 4686296, upload-time = "2025-07-01T09:14:19.828Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/1e/b9e12bbe6e4c2220effebc09ea0923a07a6da1e1f1bfbc8d7d29a01ce32b/pillow-11.3.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:eb76541cba2f958032d79d143b98a3a6b3ea87f0959bbe256c0b5e416599fd5d", size = 5871726, upload-time = "2025-07-03T13:10:04.448Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/33/e9200d2bd7ba00dc3ddb78df1198a6e80d7669cce6c2bdbeb2530a74ec58/pillow-11.3.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:67172f2944ebba3d4a7b54f2e95c786a3a50c21b88456329314caaa28cda70f6", size = 7644652, upload-time = "2025-07-03T13:10:10.391Z" },
+    { url = "https://files.pythonhosted.org/packages/41/f1/6f2427a26fc683e00d985bc391bdd76d8dd4e92fac33d841127eb8fb2313/pillow-11.3.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:97f07ed9f56a3b9b5f49d3661dc9607484e85c67e27f3e8be2c7d28ca032fec7", size = 5977787, upload-time = "2025-07-01T09:14:21.63Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/c9/06dd4a38974e24f932ff5f98ea3c546ce3f8c995d3f0985f8e5ba48bba19/pillow-11.3.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:676b2815362456b5b3216b4fd5bd89d362100dc6f4945154ff172e206a22c024", size = 6645236, upload-time = "2025-07-01T09:14:23.321Z" },
+    { url = "https://files.pythonhosted.org/packages/40/e7/848f69fb79843b3d91241bad658e9c14f39a32f71a301bcd1d139416d1be/pillow-11.3.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3e184b2f26ff146363dd07bde8b711833d7b0202e27d13540bfe2e35a323a809", size = 6086950, upload-time = "2025-07-01T09:14:25.237Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/1a/7cff92e695a2a29ac1958c2a0fe4c0b2393b60aac13b04a4fe2735cad52d/pillow-11.3.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:6be31e3fc9a621e071bc17bb7de63b85cbe0bfae91bb0363c893cbe67247780d", size = 6723358, upload-time = "2025-07-01T09:14:27.053Z" },
+    { url = "https://files.pythonhosted.org/packages/26/7d/73699ad77895f69edff76b0f332acc3d497f22f5d75e5360f78cbcaff248/pillow-11.3.0-cp312-cp312-win32.whl", hash = "sha256:7b161756381f0918e05e7cb8a371fff367e807770f8fe92ecb20d905d0e1c149", size = 6275079, upload-time = "2025-07-01T09:14:30.104Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/ce/e7dfc873bdd9828f3b6e5c2bbb74e47a98ec23cc5c74fc4e54462f0d9204/pillow-11.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:a6444696fce635783440b7f7a9fc24b3ad10a9ea3f0ab66c5905be1c19ccf17d", size = 6986324, upload-time = "2025-07-01T09:14:31.899Z" },
+    { url = "https://files.pythonhosted.org/packages/16/8f/b13447d1bf0b1f7467ce7d86f6e6edf66c0ad7cf44cf5c87a37f9bed9936/pillow-11.3.0-cp312-cp312-win_arm64.whl", hash = "sha256:2aceea54f957dd4448264f9bf40875da0415c83eb85f55069d89c0ed436e3542", size = 2423067, upload-time = "2025-07-01T09:14:33.709Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/93/0952f2ed8db3a5a4c7a11f91965d6184ebc8cd7cbb7941a260d5f018cd2d/pillow-11.3.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:1c627742b539bba4309df89171356fcb3cc5a9178355b2727d1b74a6cf155fbd", size = 2128328, upload-time = "2025-07-01T09:14:35.276Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/e8/100c3d114b1a0bf4042f27e0f87d2f25e857e838034e98ca98fe7b8c0a9c/pillow-11.3.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:30b7c02f3899d10f13d7a48163c8969e4e653f8b43416d23d13d1bbfdc93b9f8", size = 2170652, upload-time = "2025-07-01T09:14:37.203Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/86/3f758a28a6e381758545f7cdb4942e1cb79abd271bea932998fc0db93cb6/pillow-11.3.0-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:7859a4cc7c9295f5838015d8cc0a9c215b77e43d07a25e460f35cf516df8626f", size = 2227443, upload-time = "2025-07-01T09:14:39.344Z" },
+    { url = "https://files.pythonhosted.org/packages/01/f4/91d5b3ffa718df2f53b0dc109877993e511f4fd055d7e9508682e8aba092/pillow-11.3.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:ec1ee50470b0d050984394423d96325b744d55c701a439d2bd66089bff963d3c", size = 5278474, upload-time = "2025-07-01T09:14:41.843Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/0e/37d7d3eca6c879fbd9dba21268427dffda1ab00d4eb05b32923d4fbe3b12/pillow-11.3.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7db51d222548ccfd274e4572fdbf3e810a5e66b00608862f947b163e613b67dd", size = 4686038, upload-time = "2025-07-01T09:14:44.008Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/b0/3426e5c7f6565e752d81221af9d3676fdbb4f352317ceafd42899aaf5d8a/pillow-11.3.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:2d6fcc902a24ac74495df63faad1884282239265c6839a0a6416d33faedfae7e", size = 5864407, upload-time = "2025-07-03T13:10:15.628Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/c1/c6c423134229f2a221ee53f838d4be9d82bab86f7e2f8e75e47b6bf6cd77/pillow-11.3.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f0f5d8f4a08090c6d6d578351a2b91acf519a54986c055af27e7a93feae6d3f1", size = 7639094, upload-time = "2025-07-03T13:10:21.857Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/c9/09e6746630fe6372c67c648ff9deae52a2bc20897d51fa293571977ceb5d/pillow-11.3.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c37d8ba9411d6003bba9e518db0db0c58a680ab9fe5179f040b0463644bc9805", size = 5973503, upload-time = "2025-07-01T09:14:45.698Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/1c/a2a29649c0b1983d3ef57ee87a66487fdeb45132df66ab30dd37f7dbe162/pillow-11.3.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:13f87d581e71d9189ab21fe0efb5a23e9f28552d5be6979e84001d3b8505abe8", size = 6642574, upload-time = "2025-07-01T09:14:47.415Z" },
+    { url = "https://files.pythonhosted.org/packages/36/de/d5cc31cc4b055b6c6fd990e3e7f0f8aaf36229a2698501bcb0cdf67c7146/pillow-11.3.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:023f6d2d11784a465f09fd09a34b150ea4672e85fb3d05931d89f373ab14abb2", size = 6084060, upload-time = "2025-07-01T09:14:49.636Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/ea/502d938cbaeec836ac28a9b730193716f0114c41325db428e6b280513f09/pillow-11.3.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:45dfc51ac5975b938e9809451c51734124e73b04d0f0ac621649821a63852e7b", size = 6721407, upload-time = "2025-07-01T09:14:51.962Z" },
+    { url = "https://files.pythonhosted.org/packages/45/9c/9c5e2a73f125f6cbc59cc7087c8f2d649a7ae453f83bd0362ff7c9e2aee2/pillow-11.3.0-cp313-cp313-win32.whl", hash = "sha256:a4d336baed65d50d37b88ca5b60c0fa9d81e3a87d4a7930d3880d1624d5b31f3", size = 6273841, upload-time = "2025-07-01T09:14:54.142Z" },
+    { url = "https://files.pythonhosted.org/packages/23/85/397c73524e0cd212067e0c969aa245b01d50183439550d24d9f55781b776/pillow-11.3.0-cp313-cp313-win_amd64.whl", hash = "sha256:0bce5c4fd0921f99d2e858dc4d4d64193407e1b99478bc5cacecba2311abde51", size = 6978450, upload-time = "2025-07-01T09:14:56.436Z" },
+    { url = "https://files.pythonhosted.org/packages/17/d2/622f4547f69cd173955194b78e4d19ca4935a1b0f03a302d655c9f6aae65/pillow-11.3.0-cp313-cp313-win_arm64.whl", hash = "sha256:1904e1264881f682f02b7f8167935cce37bc97db457f8e7849dc3a6a52b99580", size = 2423055, upload-time = "2025-07-01T09:14:58.072Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/80/a8a2ac21dda2e82480852978416cfacd439a4b490a501a288ecf4fe2532d/pillow-11.3.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:4c834a3921375c48ee6b9624061076bc0a32a60b5532b322cc0ea64e639dd50e", size = 5281110, upload-time = "2025-07-01T09:14:59.79Z" },
+    { url = "https://files.pythonhosted.org/packages/44/d6/b79754ca790f315918732e18f82a8146d33bcd7f4494380457ea89eb883d/pillow-11.3.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:5e05688ccef30ea69b9317a9ead994b93975104a677a36a8ed8106be9260aa6d", size = 4689547, upload-time = "2025-07-01T09:15:01.648Z" },
+    { url = "https://files.pythonhosted.org/packages/49/20/716b8717d331150cb00f7fdd78169c01e8e0c219732a78b0e59b6bdb2fd6/pillow-11.3.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:1019b04af07fc0163e2810167918cb5add8d74674b6267616021ab558dc98ced", size = 5901554, upload-time = "2025-07-03T13:10:27.018Z" },
+    { url = "https://files.pythonhosted.org/packages/74/cf/a9f3a2514a65bb071075063a96f0a5cf949c2f2fce683c15ccc83b1c1cab/pillow-11.3.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f944255db153ebb2b19c51fe85dd99ef0ce494123f21b9db4877ffdfc5590c7c", size = 7669132, upload-time = "2025-07-03T13:10:33.01Z" },
+    { url = "https://files.pythonhosted.org/packages/98/3c/da78805cbdbee9cb43efe8261dd7cc0b4b93f2ac79b676c03159e9db2187/pillow-11.3.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1f85acb69adf2aaee8b7da124efebbdb959a104db34d3a2cb0f3793dbae422a8", size = 6005001, upload-time = "2025-07-01T09:15:03.365Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/fa/ce044b91faecf30e635321351bba32bab5a7e034c60187fe9698191aef4f/pillow-11.3.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:05f6ecbeff5005399bb48d198f098a9b4b6bdf27b8487c7f38ca16eeb070cd59", size = 6668814, upload-time = "2025-07-01T09:15:05.655Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/51/90f9291406d09bf93686434f9183aba27b831c10c87746ff49f127ee80cb/pillow-11.3.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:a7bc6e6fd0395bc052f16b1a8670859964dbd7003bd0af2ff08342eb6e442cfe", size = 6113124, upload-time = "2025-07-01T09:15:07.358Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/5a/6fec59b1dfb619234f7636d4157d11fb4e196caeee220232a8d2ec48488d/pillow-11.3.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:83e1b0161c9d148125083a35c1c5a89db5b7054834fd4387499e06552035236c", size = 6747186, upload-time = "2025-07-01T09:15:09.317Z" },
+    { url = "https://files.pythonhosted.org/packages/49/6b/00187a044f98255225f172de653941e61da37104a9ea60e4f6887717e2b5/pillow-11.3.0-cp313-cp313t-win32.whl", hash = "sha256:2a3117c06b8fb646639dce83694f2f9eac405472713fcb1ae887469c0d4f6788", size = 6277546, upload-time = "2025-07-01T09:15:11.311Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/5c/6caaba7e261c0d75bab23be79f1d06b5ad2a2ae49f028ccec801b0e853d6/pillow-11.3.0-cp313-cp313t-win_amd64.whl", hash = "sha256:857844335c95bea93fb39e0fa2726b4d9d758850b34075a7e3ff4f4fa3aa3b31", size = 6985102, upload-time = "2025-07-01T09:15:13.164Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/7e/b623008460c09a0cb38263c93b828c666493caee2eb34ff67f778b87e58c/pillow-11.3.0-cp313-cp313t-win_arm64.whl", hash = "sha256:8797edc41f3e8536ae4b10897ee2f637235c94f27404cac7297f7b607dd0716e", size = 2424803, upload-time = "2025-07-01T09:15:15.695Z" },
+    { url = "https://files.pythonhosted.org/packages/73/f4/04905af42837292ed86cb1b1dabe03dce1edc008ef14c473c5c7e1443c5d/pillow-11.3.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:d9da3df5f9ea2a89b81bb6087177fb1f4d1c7146d583a3fe5c672c0d94e55e12", size = 5278520, upload-time = "2025-07-01T09:15:17.429Z" },
+    { url = "https://files.pythonhosted.org/packages/41/b0/33d79e377a336247df6348a54e6d2a2b85d644ca202555e3faa0cf811ecc/pillow-11.3.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:0b275ff9b04df7b640c59ec5a3cb113eefd3795a8df80bac69646ef699c6981a", size = 4686116, upload-time = "2025-07-01T09:15:19.423Z" },
+    { url = "https://files.pythonhosted.org/packages/49/2d/ed8bc0ab219ae8768f529597d9509d184fe8a6c4741a6864fea334d25f3f/pillow-11.3.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:0743841cabd3dba6a83f38a92672cccbd69af56e3e91777b0ee7f4dba4385632", size = 5864597, upload-time = "2025-07-03T13:10:38.404Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/3d/b932bb4225c80b58dfadaca9d42d08d0b7064d2d1791b6a237f87f661834/pillow-11.3.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2465a69cf967b8b49ee1b96d76718cd98c4e925414ead59fdf75cf0fd07df673", size = 7638246, upload-time = "2025-07-03T13:10:44.987Z" },
+    { url = "https://files.pythonhosted.org/packages/09/b5/0487044b7c096f1b48f0d7ad416472c02e0e4bf6919541b111efd3cae690/pillow-11.3.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:41742638139424703b4d01665b807c6468e23e699e8e90cffefe291c5832b027", size = 5973336, upload-time = "2025-07-01T09:15:21.237Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/2d/524f9318f6cbfcc79fbc004801ea6b607ec3f843977652fdee4857a7568b/pillow-11.3.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:93efb0b4de7e340d99057415c749175e24c8864302369e05914682ba642e5d77", size = 6642699, upload-time = "2025-07-01T09:15:23.186Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/d2/a9a4f280c6aefedce1e8f615baaa5474e0701d86dd6f1dede66726462bbd/pillow-11.3.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7966e38dcd0fa11ca390aed7c6f20454443581d758242023cf36fcb319b1a874", size = 6083789, upload-time = "2025-07-01T09:15:25.1Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/54/86b0cd9dbb683a9d5e960b66c7379e821a19be4ac5810e2e5a715c09a0c0/pillow-11.3.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:98a9afa7b9007c67ed84c57c9e0ad86a6000da96eaa638e4f8abe5b65ff83f0a", size = 6720386, upload-time = "2025-07-01T09:15:27.378Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/95/88efcaf384c3588e24259c4203b909cbe3e3c2d887af9e938c2022c9dd48/pillow-11.3.0-cp314-cp314-win32.whl", hash = "sha256:02a723e6bf909e7cea0dac1b0e0310be9d7650cd66222a5f1c571455c0a45214", size = 6370911, upload-time = "2025-07-01T09:15:29.294Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/cc/934e5820850ec5eb107e7b1a72dd278140731c669f396110ebc326f2a503/pillow-11.3.0-cp314-cp314-win_amd64.whl", hash = "sha256:a418486160228f64dd9e9efcd132679b7a02a5f22c982c78b6fc7dab3fefb635", size = 7117383, upload-time = "2025-07-01T09:15:31.128Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/e9/9c0a616a71da2a5d163aa37405e8aced9a906d574b4a214bede134e731bc/pillow-11.3.0-cp314-cp314-win_arm64.whl", hash = "sha256:155658efb5e044669c08896c0c44231c5e9abcaadbc5cd3648df2f7c0b96b9a6", size = 2511385, upload-time = "2025-07-01T09:15:33.328Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/33/c88376898aff369658b225262cd4f2659b13e8178e7534df9e6e1fa289f6/pillow-11.3.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:59a03cdf019efbfeeed910bf79c7c93255c3d54bc45898ac2a4140071b02b4ae", size = 5281129, upload-time = "2025-07-01T09:15:35.194Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/70/d376247fb36f1844b42910911c83a02d5544ebd2a8bad9efcc0f707ea774/pillow-11.3.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:f8a5827f84d973d8636e9dc5764af4f0cf2318d26744b3d902931701b0d46653", size = 4689580, upload-time = "2025-07-01T09:15:37.114Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/1c/537e930496149fbac69efd2fc4329035bbe2e5475b4165439e3be9cb183b/pillow-11.3.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ee92f2fd10f4adc4b43d07ec5e779932b4eb3dbfbc34790ada5a6669bc095aa6", size = 5902860, upload-time = "2025-07-03T13:10:50.248Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/57/80f53264954dcefeebcf9dae6e3eb1daea1b488f0be8b8fef12f79a3eb10/pillow-11.3.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c96d333dcf42d01f47b37e0979b6bd73ec91eae18614864622d9b87bbd5bbf36", size = 7670694, upload-time = "2025-07-03T13:10:56.432Z" },
+    { url = "https://files.pythonhosted.org/packages/70/ff/4727d3b71a8578b4587d9c276e90efad2d6fe0335fd76742a6da08132e8c/pillow-11.3.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4c96f993ab8c98460cd0c001447bff6194403e8b1d7e149ade5f00594918128b", size = 6005888, upload-time = "2025-07-01T09:15:39.436Z" },
+    { url = "https://files.pythonhosted.org/packages/05/ae/716592277934f85d3be51d7256f3636672d7b1abfafdc42cf3f8cbd4b4c8/pillow-11.3.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:41342b64afeba938edb034d122b2dda5db2139b9a4af999729ba8818e0056477", size = 6670330, upload-time = "2025-07-01T09:15:41.269Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/bb/7fe6cddcc8827b01b1a9766f5fdeb7418680744f9082035bdbabecf1d57f/pillow-11.3.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:068d9c39a2d1b358eb9f245ce7ab1b5c3246c7c8c7d9ba58cfa5b43146c06e50", size = 6114089, upload-time = "2025-07-01T09:15:43.13Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/f5/06bfaa444c8e80f1a8e4bff98da9c83b37b5be3b1deaa43d27a0db37ef84/pillow-11.3.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:a1bc6ba083b145187f648b667e05a2534ecc4b9f2784c2cbe3089e44868f2b9b", size = 6748206, upload-time = "2025-07-01T09:15:44.937Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/77/bc6f92a3e8e6e46c0ca78abfffec0037845800ea38c73483760362804c41/pillow-11.3.0-cp314-cp314t-win32.whl", hash = "sha256:118ca10c0d60b06d006be10a501fd6bbdfef559251ed31b794668ed569c87e12", size = 6377370, upload-time = "2025-07-01T09:15:46.673Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/82/3a721f7d69dca802befb8af08b7c79ebcab461007ce1c18bd91a5d5896f9/pillow-11.3.0-cp314-cp314t-win_amd64.whl", hash = "sha256:8924748b688aa210d79883357d102cd64690e56b923a186f35a82cbc10f997db", size = 7121500, upload-time = "2025-07-01T09:15:48.512Z" },
+    { url = "https://files.pythonhosted.org/packages/89/c7/5572fa4a3f45740eaab6ae86fcdf7195b55beac1371ac8c619d880cfe948/pillow-11.3.0-cp314-cp314t-win_arm64.whl", hash = "sha256:79ea0d14d3ebad43ec77ad5272e6ff9bba5b679ef73375ea760261207fa8e0aa", size = 2512835, upload-time = "2025-07-01T09:15:50.399Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/8e/9c089f01677d1264ab8648352dcb7773f37da6ad002542760c80107da816/pillow-11.3.0-cp39-cp39-macosx_10_10_x86_64.whl", hash = "sha256:48d254f8a4c776de343051023eb61ffe818299eeac478da55227d96e241de53f", size = 5316478, upload-time = "2025-07-01T09:15:52.209Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/a9/5749930caf674695867eb56a581e78eb5f524b7583ff10b01b6e5048acb3/pillow-11.3.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:7aee118e30a4cf54fdd873bd3a29de51e29105ab11f9aad8c32123f58c8f8081", size = 4686522, upload-time = "2025-07-01T09:15:54.162Z" },
+    { url = "https://files.pythonhosted.org/packages/43/46/0b85b763eb292b691030795f9f6bb6fcaf8948c39413c81696a01c3577f7/pillow-11.3.0-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:23cff760a9049c502721bdb743a7cb3e03365fafcdfc2ef9784610714166e5a4", size = 5853376, upload-time = "2025-07-03T13:11:01.066Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/c6/1a230ec0067243cbd60bc2dad5dc3ab46a8a41e21c15f5c9b52b26873069/pillow-11.3.0-cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:6359a3bc43f57d5b375d1ad54a0074318a0844d11b76abccf478c37c986d3cfc", size = 7626020, upload-time = "2025-07-03T13:11:06.479Z" },
+    { url = "https://files.pythonhosted.org/packages/63/dd/f296c27ffba447bfad76c6a0c44c1ea97a90cb9472b9304c94a732e8dbfb/pillow-11.3.0-cp39-cp39-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:092c80c76635f5ecb10f3f83d76716165c96f5229addbd1ec2bdbbda7d496e06", size = 5956732, upload-time = "2025-07-01T09:15:56.111Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/a0/98a3630f0b57f77bae67716562513d3032ae70414fcaf02750279c389a9e/pillow-11.3.0-cp39-cp39-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cadc9e0ea0a2431124cde7e1697106471fc4c1da01530e679b2391c37d3fbb3a", size = 6624404, upload-time = "2025-07-01T09:15:58.245Z" },
+    { url = "https://files.pythonhosted.org/packages/de/e6/83dfba5646a290edd9a21964da07674409e410579c341fc5b8f7abd81620/pillow-11.3.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:6a418691000f2a418c9135a7cf0d797c1bb7d9a485e61fe8e7722845b95ef978", size = 6067760, upload-time = "2025-07-01T09:16:00.003Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/41/15ab268fe6ee9a2bc7391e2bbb20a98d3974304ab1a406a992dcb297a370/pillow-11.3.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:97afb3a00b65cc0804d1c7abddbf090a81eaac02768af58cbdcaaa0a931e0b6d", size = 6700534, upload-time = "2025-07-01T09:16:02.29Z" },
+    { url = "https://files.pythonhosted.org/packages/64/79/6d4f638b288300bed727ff29f2a3cb63db054b33518a95f27724915e3fbc/pillow-11.3.0-cp39-cp39-win32.whl", hash = "sha256:ea944117a7974ae78059fcc1800e5d3295172bb97035c0c1d9345fca1419da71", size = 6277091, upload-time = "2025-07-01T09:16:04.4Z" },
+    { url = "https://files.pythonhosted.org/packages/46/05/4106422f45a05716fd34ed21763f8ec182e8ea00af6e9cb05b93a247361a/pillow-11.3.0-cp39-cp39-win_amd64.whl", hash = "sha256:e5c5858ad8ec655450a7c7df532e9842cf8df7cc349df7225c60d5d348c8aada", size = 6986091, upload-time = "2025-07-01T09:16:06.342Z" },
+    { url = "https://files.pythonhosted.org/packages/63/c6/287fd55c2c12761d0591549d48885187579b7c257bef0c6660755b0b59ae/pillow-11.3.0-cp39-cp39-win_arm64.whl", hash = "sha256:6abdbfd3aea42be05702a8dd98832329c167ee84400a1d1f61ab11437f1717eb", size = 2422632, upload-time = "2025-07-01T09:16:08.142Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/8b/209bd6b62ce8367f47e68a218bffac88888fdf2c9fcf1ecadc6c3ec1ebc7/pillow-11.3.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:3cee80663f29e3843b68199b9d6f4f54bd1d4a6b59bdd91bceefc51238bcb967", size = 5270556, upload-time = "2025-07-01T09:16:09.961Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/e6/231a0b76070c2cfd9e260a7a5b504fb72da0a95279410fa7afd99d9751d6/pillow-11.3.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:b5f56c3f344f2ccaf0dd875d3e180f631dc60a51b314295a3e681fe8cf851fbe", size = 4654625, upload-time = "2025-07-01T09:16:11.913Z" },
+    { url = "https://files.pythonhosted.org/packages/13/f4/10cf94fda33cb12765f2397fc285fa6d8eb9c29de7f3185165b702fc7386/pillow-11.3.0-pp310-pypy310_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:e67d793d180c9df62f1f40aee3accca4829d3794c95098887edc18af4b8b780c", size = 4874207, upload-time = "2025-07-03T13:11:10.201Z" },
+    { url = "https://files.pythonhosted.org/packages/72/c9/583821097dc691880c92892e8e2d41fe0a5a3d6021f4963371d2f6d57250/pillow-11.3.0-pp310-pypy310_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d000f46e2917c705e9fb93a3606ee4a819d1e3aa7a9b442f6444f07e77cf5e25", size = 6583939, upload-time = "2025-07-03T13:11:15.68Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/8e/5c9d410f9217b12320efc7c413e72693f48468979a013ad17fd690397b9a/pillow-11.3.0-pp310-pypy310_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:527b37216b6ac3a12d7838dc3bd75208ec57c1c6d11ef01902266a5a0c14fc27", size = 4957166, upload-time = "2025-07-01T09:16:13.74Z" },
+    { url = "https://files.pythonhosted.org/packages/62/bb/78347dbe13219991877ffb3a91bf09da8317fbfcd4b5f9140aeae020ad71/pillow-11.3.0-pp310-pypy310_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:be5463ac478b623b9dd3937afd7fb7ab3d79dd290a28e2b6df292dc75063eb8a", size = 5581482, upload-time = "2025-07-01T09:16:16.107Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/28/1000353d5e61498aaeaaf7f1e4b49ddb05f2c6575f9d4f9f914a3538b6e1/pillow-11.3.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:8dc70ca24c110503e16918a658b869019126ecfe03109b754c402daff12b3d9f", size = 6984596, upload-time = "2025-07-01T09:16:18.07Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/e3/6fa84033758276fb31da12e5fb66ad747ae83b93c67af17f8c6ff4cc8f34/pillow-11.3.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:7c8ec7a017ad1bd562f93dbd8505763e688d388cde6e4a010ae1486916e713e6", size = 5270566, upload-time = "2025-07-01T09:16:19.801Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/ee/e8d2e1ab4892970b561e1ba96cbd59c0d28cf66737fc44abb2aec3795a4e/pillow-11.3.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:9ab6ae226de48019caa8074894544af5b53a117ccb9d3b3dcb2871464c829438", size = 4654618, upload-time = "2025-07-01T09:16:21.818Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/6d/17f80f4e1f0761f02160fc433abd4109fa1548dcfdca46cfdadaf9efa565/pillow-11.3.0-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:fe27fb049cdcca11f11a7bfda64043c37b30e6b91f10cb5bab275806c32f6ab3", size = 4874248, upload-time = "2025-07-03T13:11:20.738Z" },
+    { url = "https://files.pythonhosted.org/packages/de/5f/c22340acd61cef960130585bbe2120e2fd8434c214802f07e8c03596b17e/pillow-11.3.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:465b9e8844e3c3519a983d58b80be3f668e2a7a5db97f2784e7079fbc9f9822c", size = 6583963, upload-time = "2025-07-03T13:11:26.283Z" },
+    { url = "https://files.pythonhosted.org/packages/31/5e/03966aedfbfcbb4d5f8aa042452d3361f325b963ebbadddac05b122e47dd/pillow-11.3.0-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5418b53c0d59b3824d05e029669efa023bbef0f3e92e75ec8428f3799487f361", size = 4957170, upload-time = "2025-07-01T09:16:23.762Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/2d/e082982aacc927fc2cab48e1e731bdb1643a1406acace8bed0900a61464e/pillow-11.3.0-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:504b6f59505f08ae014f724b6207ff6222662aab5cc9542577fb084ed0676ac7", size = 5581505, upload-time = "2025-07-01T09:16:25.593Z" },
+    { url = "https://files.pythonhosted.org/packages/34/e7/ae39f538fd6844e982063c3a5e4598b8ced43b9633baa3a85ef33af8c05c/pillow-11.3.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:c84d689db21a1c397d001aa08241044aa2069e7587b398c8cc63020390b1c1b8", size = 6984598, upload-time = "2025-07-01T09:16:27.732Z" },
+]
+
+[[package]]
+name = "pillow"
+version = "12.2.0"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version >= '3.11'",
+    "python_full_version == '3.10.*'",
+]
+sdist = { url = "https://files.pythonhosted.org/packages/8c/21/c2bcdd5906101a30244eaffc1b6e6ce71a31bd0742a01eb89e660ebfac2d/pillow-12.2.0.tar.gz", hash = "sha256:a830b1a40919539d07806aa58e1b114df53ddd43213d9c8b75847eee6c0182b5", size = 46987819, upload-time = "2026-04-01T14:46:17.687Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3a/aa/d0b28e1c811cd4d5f5c2bfe2e022292bd255ae5744a3b9ac7d6c8f72dd75/pillow-12.2.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:a4e8f36e677d3336f35089648c8955c51c6d386a13cf6ee9c189c5f5bd713a9f", size = 5354355, upload-time = "2026-04-01T14:42:15.402Z" },
+    { url = "https://files.pythonhosted.org/packages/27/8e/1d5b39b8ae2bd7650d0c7b6abb9602d16043ead9ebbfef4bc4047454da2a/pillow-12.2.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:2e589959f10d9824d39b350472b92f0ce3b443c0a3442ebf41c40cb8361c5b97", size = 4695871, upload-time = "2026-04-01T14:42:18.234Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/c5/dcb7a6ca6b7d3be41a76958e90018d56c8462166b3ef223150360850c8da/pillow-12.2.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:a52edc8bfff4429aaabdf4d9ee0daadbbf8562364f940937b941f87a4290f5ff", size = 6269734, upload-time = "2026-04-01T14:42:20.608Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/f1/aa1bb13b2f4eba914e9637893c73f2af8e48d7d4023b9d3750d4c5eb2d0c/pillow-12.2.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:975385f4776fafde056abb318f612ef6285b10a1f12b8570f3647ad0d74b48ec", size = 8076080, upload-time = "2026-04-01T14:42:23.095Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/2a/8c79d6a53169937784604a8ae8d77e45888c41537f7f6f65ed1f407fe66d/pillow-12.2.0-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bd9c0c7a0c681a347b3194c500cb1e6ca9cab053ea4d82a5cf45b6b754560136", size = 6382236, upload-time = "2026-04-01T14:42:25.82Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/42/bbcb6051030e1e421d103ce7a8ecadf837aa2f39b8f82ef1a8d37c3d4ebc/pillow-12.2.0-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:88d387ff40b3ff7c274947ed3125dedf5262ec6919d83946753b5f3d7c67ea4c", size = 7070220, upload-time = "2026-04-01T14:42:28.68Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/e1/c2a7d6dd8cfa6b231227da096fd2d58754bab3603b9d73bf609d3c18b64f/pillow-12.2.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:51c4167c34b0d8ba05b547a3bb23578d0ba17b80a5593f93bd8ecb123dd336a3", size = 6493124, upload-time = "2026-04-01T14:42:31.579Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/41/7c8617da5d32e1d2f026e509484fdb6f3ad7efaef1749a0c1928adbb099e/pillow-12.2.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:34c0d99ecccea270c04882cb3b86e7b57296079c9a4aff88cb3b33563d95afaa", size = 7194324, upload-time = "2026-04-01T14:42:34.615Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/de/a777627e19fd6d62f84070ee1521adde5eeda4855b5cf60fe0b149118bca/pillow-12.2.0-cp310-cp310-win32.whl", hash = "sha256:b85f66ae9eb53e860a873b858b789217ba505e5e405a24b85c0464822fe88032", size = 6376363, upload-time = "2026-04-01T14:42:37.19Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/34/fc4cb5204896465842767b96d250c08410f01f2f28afc43b257de842eed5/pillow-12.2.0-cp310-cp310-win_amd64.whl", hash = "sha256:673aa32138f3e7531ccdbca7b3901dba9b70940a19ccecc6a37c77d5fdeb05b5", size = 7083523, upload-time = "2026-04-01T14:42:39.62Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/a0/32852d36bc7709f14dc3f64f929a275e958ad8c19a6deba9610d458e28b3/pillow-12.2.0-cp310-cp310-win_arm64.whl", hash = "sha256:3e080565d8d7c671db5802eedfb438e5565ffa40115216eabb8cd52d0ecce024", size = 2463318, upload-time = "2026-04-01T14:42:42.063Z" },
+    { url = "https://files.pythonhosted.org/packages/68/e1/748f5663efe6edcfc4e74b2b93edfb9b8b99b67f21a854c3ae416500a2d9/pillow-12.2.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:8be29e59487a79f173507c30ddf57e733a357f67881430449bb32614075a40ab", size = 5354347, upload-time = "2026-04-01T14:42:44.255Z" },
+    { url = "https://files.pythonhosted.org/packages/47/a1/d5ff69e747374c33a3b53b9f98cca7889fce1fd03d79cdc4e1bccc6c5a87/pillow-12.2.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:71cde9a1e1551df7d34a25462fc60325e8a11a82cc2e2f54578e5e9a1e153d65", size = 4695873, upload-time = "2026-04-01T14:42:46.452Z" },
+    { url = "https://files.pythonhosted.org/packages/df/21/e3fbdf54408a973c7f7f89a23b2cb97a7ef30c61ab4142af31eee6aebc88/pillow-12.2.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f490f9368b6fc026f021db16d7ec2fbf7d89e2edb42e8ec09d2c60505f5729c7", size = 6280168, upload-time = "2026-04-01T14:42:49.228Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/f1/00b7278c7dd52b17ad4329153748f87b6756ec195ff786c2bdf12518337d/pillow-12.2.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8bd7903a5f2a4545f6fd5935c90058b89d30045568985a71c79f5fd6edf9b91e", size = 8088188, upload-time = "2026-04-01T14:42:51.735Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/cf/220a5994ef1b10e70e85748b75649d77d506499352be135a4989c957b701/pillow-12.2.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3997232e10d2920a68d25191392e3a4487d8183039e1c74c2297f00ed1c50705", size = 6394401, upload-time = "2026-04-01T14:42:54.343Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/bd/e51a61b1054f09437acfbc2ff9106c30d1eb76bc1453d428399946781253/pillow-12.2.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e74473c875d78b8e9d5da2a70f7099549f9eb37ded4e2f6a463e60125bccd176", size = 7079655, upload-time = "2026-04-01T14:42:56.954Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/3d/45132c57d5fb4b5744567c3817026480ac7fc3ce5d4c47902bc0e7f6f853/pillow-12.2.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:56a3f9c60a13133a98ecff6197af34d7824de9b7b38c3654861a725c970c197b", size = 6503105, upload-time = "2026-04-01T14:42:59.847Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/2e/9df2fc1e82097b1df3dce58dc43286aa01068e918c07574711fcc53e6fb4/pillow-12.2.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:90e6f81de50ad6b534cab6e5aef77ff6e37722b2f5d908686f4a5c9eba17a909", size = 7203402, upload-time = "2026-04-01T14:43:02.664Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/2e/2941e42858ebb67e50ae741473de81c2984e6eff7b397017623c676e2e8d/pillow-12.2.0-cp311-cp311-win32.whl", hash = "sha256:8c984051042858021a54926eb597d6ee3012393ce9c181814115df4c60b9a808", size = 6378149, upload-time = "2026-04-01T14:43:05.274Z" },
+    { url = "https://files.pythonhosted.org/packages/69/42/836b6f3cd7f3e5fa10a1f1a5420447c17966044c8fbf589cc0452d5502db/pillow-12.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:6e6b2a0c538fc200b38ff9eb6628228b77908c319a005815f2dde585a0664b60", size = 7082626, upload-time = "2026-04-01T14:43:08.557Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/88/549194b5d6f1f494b485e493edc6693c0a16f4ada488e5bd974ed1f42fad/pillow-12.2.0-cp311-cp311-win_arm64.whl", hash = "sha256:9a8a34cc89c67a65ea7437ce257cea81a9dad65b29805f3ecee8c8fe8ff25ffe", size = 2463531, upload-time = "2026-04-01T14:43:10.743Z" },
+    { url = "https://files.pythonhosted.org/packages/58/be/7482c8a5ebebbc6470b3eb791812fff7d5e0216c2be3827b30b8bb6603ed/pillow-12.2.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2d192a155bbcec180f8564f693e6fd9bccff5a7af9b32e2e4bf8c9c69dbad6b5", size = 5308279, upload-time = "2026-04-01T14:43:13.246Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/95/0a351b9289c2b5cbde0bacd4a83ebc44023e835490a727b2a3bd60ddc0f4/pillow-12.2.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f3f40b3c5a968281fd507d519e444c35f0ff171237f4fdde090dd60699458421", size = 4695490, upload-time = "2026-04-01T14:43:15.584Z" },
+    { url = "https://files.pythonhosted.org/packages/de/af/4e8e6869cbed569d43c416fad3dc4ecb944cb5d9492defaed89ddd6fe871/pillow-12.2.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:03e7e372d5240cc23e9f07deca4d775c0817bffc641b01e9c3af208dbd300987", size = 6284462, upload-time = "2026-04-01T14:43:18.268Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/9e/c05e19657fd57841e476be1ab46c4d501bffbadbafdc31a6d665f8b737b6/pillow-12.2.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b86024e52a1b269467a802258c25521e6d742349d760728092e1bc2d135b4d76", size = 8094744, upload-time = "2026-04-01T14:43:20.716Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/54/1789c455ed10176066b6e7e6da1b01e50e36f94ba584dc68d9eebfe9156d/pillow-12.2.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7371b48c4fa448d20d2714c9a1f775a81155050d383333e0a6c15b1123dda005", size = 6398371, upload-time = "2026-04-01T14:43:23.443Z" },
+    { url = "https://files.pythonhosted.org/packages/43/e3/fdc657359e919462369869f1c9f0e973f353f9a9ee295a39b1fea8ee1a77/pillow-12.2.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:62f5409336adb0663b7caa0da5c7d9e7bdbaae9ce761d34669420c2a801b2780", size = 7087215, upload-time = "2026-04-01T14:43:26.758Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/f8/2f6825e441d5b1959d2ca5adec984210f1ec086435b0ed5f52c19b3b8a6e/pillow-12.2.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:01afa7cf67f74f09523699b4e88c73fb55c13346d212a59a2db1f86b0a63e8c5", size = 6509783, upload-time = "2026-04-01T14:43:29.56Z" },
+    { url = "https://files.pythonhosted.org/packages/67/f9/029a27095ad20f854f9dba026b3ea6428548316e057e6fc3545409e86651/pillow-12.2.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fc3d34d4a8fbec3e88a79b92e5465e0f9b842b628675850d860b8bd300b159f5", size = 7212112, upload-time = "2026-04-01T14:43:32.091Z" },
+    { url = "https://files.pythonhosted.org/packages/be/42/025cfe05d1be22dbfdb4f264fe9de1ccda83f66e4fc3aac94748e784af04/pillow-12.2.0-cp312-cp312-win32.whl", hash = "sha256:58f62cc0f00fd29e64b29f4fd923ffdb3859c9f9e6105bfc37ba1d08994e8940", size = 6378489, upload-time = "2026-04-01T14:43:34.601Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/7b/25a221d2c761c6a8ae21bfa3874988ff2583e19cf8a27bf2fee358df7942/pillow-12.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:7f84204dee22a783350679a0333981df803dac21a0190d706a50475e361c93f5", size = 7084129, upload-time = "2026-04-01T14:43:37.213Z" },
+    { url = "https://files.pythonhosted.org/packages/10/e1/542a474affab20fd4a0f1836cb234e8493519da6b76899e30bcc5d990b8b/pillow-12.2.0-cp312-cp312-win_arm64.whl", hash = "sha256:af73337013e0b3b46f175e79492d96845b16126ddf79c438d7ea7ff27783a414", size = 2463612, upload-time = "2026-04-01T14:43:39.421Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/01/53d10cf0dbad820a8db274d259a37ba50b88b24768ddccec07355382d5ad/pillow-12.2.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:8297651f5b5679c19968abefd6bb84d95fe30ef712eb1b2d9b2d31ca61267f4c", size = 4100837, upload-time = "2026-04-01T14:43:41.506Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/98/f3a6657ecb698c937f6c76ee564882945f29b79bad496abcba0e84659ec5/pillow-12.2.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:50d8520da2a6ce0af445fa6d648c4273c3eeefbc32d7ce049f22e8b5c3daecc2", size = 4176528, upload-time = "2026-04-01T14:43:43.773Z" },
+    { url = "https://files.pythonhosted.org/packages/69/bc/8986948f05e3ea490b8442ea1c1d4d990b24a7e43d8a51b2c7d8b1dced36/pillow-12.2.0-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:766cef22385fa1091258ad7e6216792b156dc16d8d3fa607e7545b2b72061f1c", size = 3640401, upload-time = "2026-04-01T14:43:45.87Z" },
+    { url = "https://files.pythonhosted.org/packages/34/46/6c717baadcd62bc8ed51d238d521ab651eaa74838291bda1f86fe1f864c9/pillow-12.2.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5d2fd0fa6b5d9d1de415060363433f28da8b1526c1c129020435e186794b3795", size = 5308094, upload-time = "2026-04-01T14:43:48.438Z" },
+    { url = "https://files.pythonhosted.org/packages/71/43/905a14a8b17fdb1ccb58d282454490662d2cb89a6bfec26af6d3520da5ec/pillow-12.2.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:56b25336f502b6ed02e889f4ece894a72612fe885889a6e8c4c80239ff6e5f5f", size = 4695402, upload-time = "2026-04-01T14:43:51.292Z" },
+    { url = "https://files.pythonhosted.org/packages/73/dd/42107efcb777b16fa0393317eac58f5b5cf30e8392e266e76e51cff28c3d/pillow-12.2.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f1c943e96e85df3d3478f7b691f229887e143f81fedab9b20205349ab04d73ed", size = 6280005, upload-time = "2026-04-01T14:43:54.242Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/68/b93e09e5e8549019e61acf49f65b1a8530765a7f812c77a7461bca7e4494/pillow-12.2.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:03f6fab9219220f041c74aeaa2939ff0062bd5c364ba9ce037197f4c6d498cd9", size = 8090669, upload-time = "2026-04-01T14:43:57.335Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/6e/3ccb54ce8ec4ddd1accd2d89004308b7b0b21c4ac3d20fa70af4760a4330/pillow-12.2.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5cdfebd752ec52bf5bb4e35d9c64b40826bc5b40a13df7c3cda20a2c03a0f5ed", size = 6395194, upload-time = "2026-04-01T14:43:59.864Z" },
+    { url = "https://files.pythonhosted.org/packages/67/ee/21d4e8536afd1a328f01b359b4d3997b291ffd35a237c877b331c1c3b71c/pillow-12.2.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:eedf4b74eda2b5a4b2b2fb4c006d6295df3bf29e459e198c90ea48e130dc75c3", size = 7082423, upload-time = "2026-04-01T14:44:02.74Z" },
+    { url = "https://files.pythonhosted.org/packages/78/5f/e9f86ab0146464e8c133fe85df987ed9e77e08b29d8d35f9f9f4d6f917ba/pillow-12.2.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:00a2865911330191c0b818c59103b58a5e697cae67042366970a6b6f1b20b7f9", size = 6505667, upload-time = "2026-04-01T14:44:05.381Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/1e/409007f56a2fdce61584fd3acbc2bbc259857d555196cedcadc68c015c82/pillow-12.2.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1e1757442ed87f4912397c6d35a0db6a7b52592156014706f17658ff58bbf795", size = 7208580, upload-time = "2026-04-01T14:44:08.39Z" },
+    { url = "https://files.pythonhosted.org/packages/23/c4/7349421080b12fb35414607b8871e9534546c128a11965fd4a7002ccfbee/pillow-12.2.0-cp313-cp313-win32.whl", hash = "sha256:144748b3af2d1b358d41286056d0003f47cb339b8c43a9ea42f5fea4d8c66b6e", size = 6375896, upload-time = "2026-04-01T14:44:11.197Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/82/8a3739a5e470b3c6cbb1d21d315800d8e16bff503d1f16b03a4ec3212786/pillow-12.2.0-cp313-cp313-win_amd64.whl", hash = "sha256:390ede346628ccc626e5730107cde16c42d3836b89662a115a921f28440e6a3b", size = 7081266, upload-time = "2026-04-01T14:44:13.947Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/25/f968f618a062574294592f668218f8af564830ccebdd1fa6200f598e65c5/pillow-12.2.0-cp313-cp313-win_arm64.whl", hash = "sha256:8023abc91fba39036dbce14a7d6535632f99c0b857807cbbbf21ecc9f4717f06", size = 2463508, upload-time = "2026-04-01T14:44:16.312Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/a4/b342930964e3cb4dce5038ae34b0eab4653334995336cd486c5a8c25a00c/pillow-12.2.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:042db20a421b9bafecc4b84a8b6e444686bd9d836c7fd24542db3e7df7baad9b", size = 5309927, upload-time = "2026-04-01T14:44:18.89Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/de/23198e0a65a9cf06123f5435a5d95cea62a635697f8f03d134d3f3a96151/pillow-12.2.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:dd025009355c926a84a612fecf58bb315a3f6814b17ead51a8e48d3823d9087f", size = 4698624, upload-time = "2026-04-01T14:44:21.115Z" },
+    { url = "https://files.pythonhosted.org/packages/01/a6/1265e977f17d93ea37aa28aa81bad4fa597933879fac2520d24e021c8da3/pillow-12.2.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:88ddbc66737e277852913bd1e07c150cc7bb124539f94c4e2df5344494e0a612", size = 6321252, upload-time = "2026-04-01T14:44:23.663Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/83/5982eb4a285967baa70340320be9f88e57665a387e3a53a7f0db8231a0cd/pillow-12.2.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d362d1878f00c142b7e1a16e6e5e780f02be8195123f164edf7eddd911eefe7c", size = 8126550, upload-time = "2026-04-01T14:44:26.772Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/48/6ffc514adce69f6050d0753b1a18fd920fce8cac87620d5a31231b04bfc5/pillow-12.2.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2c727a6d53cb0018aadd8018c2b938376af27914a68a492f59dfcaca650d5eea", size = 6433114, upload-time = "2026-04-01T14:44:29.615Z" },
+    { url = "https://files.pythonhosted.org/packages/36/a3/f9a77144231fb8d40ee27107b4463e205fa4677e2ca2548e14da5cf18dce/pillow-12.2.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:efd8c21c98c5cc60653bcb311bef2ce0401642b7ce9d09e03a7da87c878289d4", size = 7115667, upload-time = "2026-04-01T14:44:32.773Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/fc/ac4ee3041e7d5a565e1c4fd72a113f03b6394cc72ab7089d27608f8aaccb/pillow-12.2.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9f08483a632889536b8139663db60f6724bfcb443c96f1b18855860d7d5c0fd4", size = 6538966, upload-time = "2026-04-01T14:44:35.252Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/a8/27fb307055087f3668f6d0a8ccb636e7431d56ed0750e07a60547b1e083e/pillow-12.2.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:dac8d77255a37e81a2efcbd1fc05f1c15ee82200e6c240d7e127e25e365c39ea", size = 7238241, upload-time = "2026-04-01T14:44:37.875Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/4b/926ab182c07fccae9fcb120043464e1ff1564775ec8864f21a0ebce6ac25/pillow-12.2.0-cp313-cp313t-win32.whl", hash = "sha256:ee3120ae9dff32f121610bb08e4313be87e03efeadfc6c0d18f89127e24d0c24", size = 6379592, upload-time = "2026-04-01T14:44:40.336Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/c4/f9e476451a098181b30050cc4c9a3556b64c02cf6497ea421ac047e89e4b/pillow-12.2.0-cp313-cp313t-win_amd64.whl", hash = "sha256:325ca0528c6788d2a6c3d40e3568639398137346c3d6e66bb61db96b96511c98", size = 7085542, upload-time = "2026-04-01T14:44:43.251Z" },
+    { url = "https://files.pythonhosted.org/packages/00/a4/285f12aeacbe2d6dc36c407dfbbe9e96d4a80b0fb710a337f6d2ad978c75/pillow-12.2.0-cp313-cp313t-win_arm64.whl", hash = "sha256:2e5a76d03a6c6dcef67edabda7a52494afa4035021a79c8558e14af25313d453", size = 2465765, upload-time = "2026-04-01T14:44:45.996Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/98/4595daa2365416a86cb0d495248a393dfc84e96d62ad080c8546256cb9c0/pillow-12.2.0-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:3adc9215e8be0448ed6e814966ecf3d9952f0ea40eb14e89a102b87f450660d8", size = 4100848, upload-time = "2026-04-01T14:44:48.48Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/79/40184d464cf89f6663e18dfcf7ca21aae2491fff1a16127681bf1fa9b8cf/pillow-12.2.0-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:6a9adfc6d24b10f89588096364cc726174118c62130c817c2837c60cf08a392b", size = 4176515, upload-time = "2026-04-01T14:44:51.353Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/63/703f86fd4c422a9cf722833670f4f71418fb116b2853ff7da722ea43f184/pillow-12.2.0-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:6a6e67ea2e6feda684ed370f9a1c52e7a243631c025ba42149a2cc5934dec295", size = 3640159, upload-time = "2026-04-01T14:44:53.588Z" },
+    { url = "https://files.pythonhosted.org/packages/71/e0/fb22f797187d0be2270f83500aab851536101b254bfa1eae10795709d283/pillow-12.2.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:2bb4a8d594eacdfc59d9e5ad972aa8afdd48d584ffd5f13a937a664c3e7db0ed", size = 5312185, upload-time = "2026-04-01T14:44:56.039Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/8c/1a9e46228571de18f8e28f16fabdfc20212a5d019f3e3303452b3f0a580d/pillow-12.2.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:80b2da48193b2f33ed0c32c38140f9d3186583ce7d516526d462645fd98660ae", size = 4695386, upload-time = "2026-04-01T14:44:58.663Z" },
+    { url = "https://files.pythonhosted.org/packages/70/62/98f6b7f0c88b9addd0e87c217ded307b36be024d4ff8869a812b241d1345/pillow-12.2.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:22db17c68434de69d8ecfc2fe821569195c0c373b25cccb9cbdacf2c6e53c601", size = 6280384, upload-time = "2026-04-01T14:45:01.5Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/03/688747d2e91cfbe0e64f316cd2e8005698f76ada3130d0194664174fa5de/pillow-12.2.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7b14cc0106cd9aecda615dd6903840a058b4700fcb817687d0ee4fc8b6e389be", size = 8091599, upload-time = "2026-04-01T14:45:04.5Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/35/577e22b936fcdd66537329b33af0b4ccfefaeabd8aec04b266528cddb33c/pillow-12.2.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8cbeb542b2ebc6fcdacabf8aca8c1a97c9b3ad3927d46b8723f9d4f033288a0f", size = 6396021, upload-time = "2026-04-01T14:45:07.117Z" },
+    { url = "https://files.pythonhosted.org/packages/11/8d/d2532ad2a603ca2b93ad9f5135732124e57811d0168155852f37fbce2458/pillow-12.2.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4bfd07bc812fbd20395212969e41931001fd59eb55a60658b0e5710872e95286", size = 7083360, upload-time = "2026-04-01T14:45:09.763Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/26/d325f9f56c7e039034897e7380e9cc202b1e368bfd04d4cbe6a441f02885/pillow-12.2.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:9aba9a17b623ef750a4d11b742cbafffeb48a869821252b30ee21b5e91392c50", size = 6507628, upload-time = "2026-04-01T14:45:12.378Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/f7/769d5632ffb0988f1c5e7660b3e731e30f7f8ec4318e94d0a5d674eb65a4/pillow-12.2.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:deede7c263feb25dba4e82ea23058a235dcc2fe1f6021025dc71f2b618e26104", size = 7209321, upload-time = "2026-04-01T14:45:15.122Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/7a/c253e3c645cd47f1aceea6a8bacdba9991bf45bb7dfe927f7c893e89c93c/pillow-12.2.0-cp314-cp314-win32.whl", hash = "sha256:632ff19b2778e43162304d50da0181ce24ac5bb8180122cbe1bf4673428328c7", size = 6479723, upload-time = "2026-04-01T14:45:17.797Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/8b/601e6566b957ca50e28725cb6c355c59c2c8609751efbecd980db44e0349/pillow-12.2.0-cp314-cp314-win_amd64.whl", hash = "sha256:4e6c62e9d237e9b65fac06857d511e90d8461a32adcc1b9065ea0c0fa3a28150", size = 7217400, upload-time = "2026-04-01T14:45:20.529Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/94/220e46c73065c3e2951bb91c11a1fb636c8c9ad427ac3ce7d7f3359b9b2f/pillow-12.2.0-cp314-cp314-win_arm64.whl", hash = "sha256:b1c1fbd8a5a1af3412a0810d060a78b5136ec0836c8a4ef9aa11807f2a22f4e1", size = 2554835, upload-time = "2026-04-01T14:45:23.162Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/ab/1b426a3974cb0e7da5c29ccff4807871d48110933a57207b5a676cccc155/pillow-12.2.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:57850958fe9c751670e49b2cecf6294acc99e562531f4bd317fa5ddee2068463", size = 5314225, upload-time = "2026-04-01T14:45:25.637Z" },
+    { url = "https://files.pythonhosted.org/packages/19/1e/dce46f371be2438eecfee2a1960ee2a243bbe5e961890146d2dee1ff0f12/pillow-12.2.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:d5d38f1411c0ed9f97bcb49b7bd59b6b7c314e0e27420e34d99d844b9ce3b6f3", size = 4698541, upload-time = "2026-04-01T14:45:28.355Z" },
+    { url = "https://files.pythonhosted.org/packages/55/c3/7fbecf70adb3a0c33b77a300dc52e424dc22ad8cdc06557a2e49523b703d/pillow-12.2.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5c0a9f29ca8e79f09de89293f82fc9b0270bb4af1d58bc98f540cc4aedf03166", size = 6322251, upload-time = "2026-04-01T14:45:30.924Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/3c/7fbc17cfb7e4fe0ef1642e0abc17fc6c94c9f7a16be41498e12e2ba60408/pillow-12.2.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1610dd6c61621ae1cf811bef44d77e149ce3f7b95afe66a4512f8c59f25d9ebe", size = 8127807, upload-time = "2026-04-01T14:45:33.908Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/c3/a8ae14d6defd2e448493ff512fae903b1e9bd40b72efb6ec55ce0048c8ce/pillow-12.2.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0a34329707af4f73cf1782a36cd2289c0368880654a2c11f027bcee9052d35dd", size = 6433935, upload-time = "2026-04-01T14:45:36.623Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/32/2880fb3a074847ac159d8f902cb43278a61e85f681661e7419e6596803ed/pillow-12.2.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8e9c4f5b3c546fa3458a29ab22646c1c6c787ea8f5ef51300e5a60300736905e", size = 7116720, upload-time = "2026-04-01T14:45:39.258Z" },
+    { url = "https://files.pythonhosted.org/packages/46/87/495cc9c30e0129501643f24d320076f4cc54f718341df18cc70ec94c44e1/pillow-12.2.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:fb043ee2f06b41473269765c2feae53fc2e2fbf96e5e22ca94fb5ad677856f06", size = 6540498, upload-time = "2026-04-01T14:45:41.879Z" },
+    { url = "https://files.pythonhosted.org/packages/18/53/773f5edca692009d883a72211b60fdaf8871cbef075eaa9d577f0a2f989e/pillow-12.2.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f278f034eb75b4e8a13a54a876cc4a5ab39173d2cdd93a638e1b467fc545ac43", size = 7239413, upload-time = "2026-04-01T14:45:44.705Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/e4/4b64a97d71b2a83158134abbb2f5bd3f8a2ea691361282f010998f339ec7/pillow-12.2.0-cp314-cp314t-win32.whl", hash = "sha256:6bb77b2dcb06b20f9f4b4a8454caa581cd4dd0643a08bacf821216a16d9c8354", size = 6482084, upload-time = "2026-04-01T14:45:47.568Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/13/306d275efd3a3453f72114b7431c877d10b1154014c1ebbedd067770d629/pillow-12.2.0-cp314-cp314t-win_amd64.whl", hash = "sha256:6562ace0d3fb5f20ed7290f1f929cae41b25ae29528f2af1722966a0a02e2aa1", size = 7225152, upload-time = "2026-04-01T14:45:50.032Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/6e/cf826fae916b8658848d7b9f38d88da6396895c676e8086fc0988073aaf8/pillow-12.2.0-cp314-cp314t-win_arm64.whl", hash = "sha256:aa88ccfe4e32d362816319ed727a004423aab09c5cea43c01a4b435643fa34eb", size = 2556579, upload-time = "2026-04-01T14:45:52.529Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/b7/2437044fb910f499610356d1352e3423753c98e34f915252aafecc64889f/pillow-12.2.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:0538bd5e05efec03ae613fd89c4ce0368ecd2ba239cc25b9f9be7ed426b0af1f", size = 5273969, upload-time = "2026-04-01T14:45:55.538Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/f4/8316e31de11b780f4ac08ef3654a75555e624a98db1056ecb2122d008d5a/pillow-12.2.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:394167b21da716608eac917c60aa9b969421b5dcbbe02ae7f013e7b85811c69d", size = 4659674, upload-time = "2026-04-01T14:45:58.093Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/37/664fca7201f8bb2aa1d20e2c3d5564a62e6ae5111741966c8319ca802361/pillow-12.2.0-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5d04bfa02cc2d23b497d1e90a0f927070043f6cbf303e738300532379a4b4e0f", size = 5288479, upload-time = "2026-04-01T14:46:01.141Z" },
+    { url = "https://files.pythonhosted.org/packages/49/62/5b0ed78fce87346be7a5cfcfaaad91f6a1f98c26f86bdbafa2066c647ef6/pillow-12.2.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0c838a5125cee37e68edec915651521191cef1e6aa336b855f495766e77a366e", size = 7032230, upload-time = "2026-04-01T14:46:03.874Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/28/ec0fc38107fc32536908034e990c47914c57cd7c5a3ece4d8d8f7ffd7e27/pillow-12.2.0-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4a6c9fa44005fa37a91ebfc95d081e8079757d2e904b27103f4f5fa6f0bf78c0", size = 5355404, upload-time = "2026-04-01T14:46:06.33Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/8b/51b0eddcfa2180d60e41f06bd6d0a62202b20b59c68f5a132e615b75aecf/pillow-12.2.0-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:25373b66e0dd5905ed63fa3cae13c82fbddf3079f2c8bf15c6fb6a35586324c1", size = 6002215, upload-time = "2026-04-01T14:46:08.83Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/60/5382c03e1970de634027cee8e1b7d39776b778b81812aaf45b694dfe9e28/pillow-12.2.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:bfa9c230d2fe991bed5318a5f119bd6780cda2915cca595393649fc118ab895e", size = 7080946, upload-time = "2026-04-01T14:46:11.734Z" },
+]
+
 [[package]]
 name = "pluggy"
 version = "1.6.0"
@@ -1201,6 +1503,33 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/5a/cc/06253936f4a7fa2e0f48dfe6d851d9c56df896a9ab09ac019d70b760619c/pytest_mock-3.15.1-py3-none-any.whl", hash = "sha256:0a25e2eb88fe5168d535041d09a4529a188176ae608a6d249ee65abc0949630d", size = 10095, upload-time = "2025-09-16T16:37:25.734Z" },
 ]
 
+[[package]]
+name = "pytest-timeout"
+version = "2.4.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pytest", version = "8.4.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" },
+    { name = "pytest", version = "9.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ac/82/4c9ecabab13363e72d880f2fb504c5f750433b2b6f16e99f4ec21ada284c/pytest_timeout-2.4.0.tar.gz", hash = "sha256:7e68e90b01f9eff71332b25001f85c75495fc4e3a836701876183c4bcfd0540a", size = 17973, upload-time = "2025-05-05T19:44:34.99Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fa/b6/3127540ecdf1464a00e5a01ee60a1b09175f6913f0644ac748494d9c4b21/pytest_timeout-2.4.0-py3-none-any.whl", hash = "sha256:c42667e5cdadb151aeb5b26d114aff6bdf5a907f176a007a30b940d3d865b5c2", size = 14382, upload-time = "2025-05-05T19:44:33.502Z" },
+]
+
+[[package]]
+name = "pytest-xdist"
+version = "3.8.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "execnet" },
+    { name = "pytest", version = "8.4.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" },
+    { name = "pytest", version = "9.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/78/b4/439b179d1ff526791eb921115fca8e44e596a13efeda518b9d845a619450/pytest_xdist-3.8.0.tar.gz", hash = "sha256:7e578125ec9bc6050861aa93f2d59f1d8d085595d6551c2c90b6f4fad8d3a9f1", size = 88069, upload-time = "2025-07-01T13:30:59.346Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ca/31/d4e37e9e550c2b92a9cbc2e4d0b7420a27224968580b5a447f420847c975/pytest_xdist-3.8.0-py3-none-any.whl", hash = "sha256:202ca578cfeb7370784a8c33d6d05bc6e13b4f25b5053c30a152269fd10f0b88", size = 46396, upload-time = "2025-07-01T13:30:56.632Z" },
+]
+
 [[package]]
 name = "python-dotenv"
 version = "1.2.1"
@@ -1350,11 +1679,13 @@ wheels = [
 
 [[package]]
 name = "syncfield"
-version = "0.3.6"
+version = "0.3.10"
 source = { editable = "." }
 
 [package.optional-dependencies]
 all = [
+    { name = "av", version = "15.1.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" },
+    { name = "av", version = "17.0.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" },
     { name = "bleak", version = "1.1.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" },
     { name = "bleak", version = "3.0.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" },
     { name = "depthai" },
@@ -1364,7 +1695,8 @@ all = [
     { name = "numpy", version = "2.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" },
     { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.10.*'" },
     { name = "numpy", version = "2.4.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
-    { name = "opencv-python" },
+    { name = "pillow", version = "11.3.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" },
+    { name = "pillow", version = "12.2.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" },
     { name = "sounddevice" },
     { name = "uvicorn", version = "0.39.0", source = { registry = "https://pypi.org/simple" }, extra = ["standard"], marker = "python_full_version < '3.10'" },
     { name = "uvicorn", version = "0.44.0", source = { registry = "https://pypi.org/simple" }, extra = ["standard"], marker = "python_full_version >= '3.10'" },
@@ -1389,15 +1721,21 @@ multihost = [
     { name = "zeroconf" },
 ]
 oak = [
+    { name = "av", version = "15.1.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" },
+    { name = "av", version = "17.0.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" },
     { name = "depthai" },
 ]
 uvc = [
-    { name = "opencv-python" },
+    { name = "av", version = "15.1.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" },
+    { name = "av", version = "17.0.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" },
 ]
 viewer = [
+    { name = "av", version = "15.1.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" },
+    { name = "av", version = "17.0.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" },
     { name = "fastapi", version = "0.128.8", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" },
     { name = "fastapi", version = "0.135.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" },
-    { name = "opencv-python" },
+    { name = "pillow", version = "11.3.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" },
+    { name = "pillow", version = "12.2.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" },
     { name = "uvicorn", version = "0.39.0", source = { registry = "https://pypi.org/simple" }, extra = ["standard"], marker = "python_full_version < '3.10'" },
     { name = "uvicorn", version = "0.44.0", source = { registry = "https://pypi.org/simple" }, extra = ["standard"], marker = "python_full_version >= '3.10'" },
 ]
@@ -1407,10 +1745,16 @@ dev = [
     { name = "pytest", version = "8.4.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" },
     { name = "pytest", version = "9.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" },
     { name = "pytest-mock" },
+    { name = "pytest-timeout" },
+    { name = "pytest-xdist" },
 ]
 
 [package.metadata]
 requires-dist = [
+    { name = "av", marker = "extra == 'all'", specifier = ">=12.0.0" },
+    { name = "av", marker = "extra == 'oak'", specifier = ">=12.0.0" },
+    { name = "av", marker = "extra == 'uvc'", specifier = ">=12.0.0" },
+    { name = "av", marker = "extra == 'viewer'", specifier = ">=12.0.0" },
     { name = "bleak", marker = "extra == 'all'", specifier = ">=0.21" },
     { name = "bleak", marker = "extra == 'ble'", specifier = ">=0.21" },
     { name = "depthai", marker = "extra == 'all'", specifier = ">=3.0.0" },
@@ -1422,9 +1766,8 @@ requires-dist = [
     { name = "httpx", marker = "extra == 'multihost'", specifier = ">=0.25.0" },
     { name = "numpy", marker = "extra == 'all'", specifier = ">=1.21" },
     { name = "numpy", marker = "extra == 'audio'", specifier = ">=1.21" },
-    { name = "opencv-python", marker = "extra == 'all'", specifier = ">=4.8.0" },
-    { name = "opencv-python", marker = "extra == 'uvc'", specifier = ">=4.5" },
-    { name = "opencv-python", marker = "extra == 'viewer'", specifier = ">=4.8.0" },
+    { name = "pillow", marker = "extra == 'all'", specifier = ">=10.0.0" },
+    { name = "pillow", marker = "extra == 'viewer'", specifier = ">=10.0.0" },
     { name = "sounddevice", marker = "extra == 'all'", specifier = ">=0.4.6" },
     { name = "sounddevice", marker = "extra == 'audio'", specifier = ">=0.4.6" },
     { name = "uvicorn", extras = ["standard"], marker = "extra == 'all'", specifier = ">=0.24.0" },
@@ -1439,6 +1782,8 @@ provides-extras = ["audio", "uvc", "ble", "oak", "viewer", "multihost", "all"]
 dev = [
     { name = "pytest", specifier = ">=8.4.2" },
     { name = "pytest-mock", specifier = ">=3.12.0" },
+    { name = "pytest-timeout", specifier = ">=2.4.0" },
+    { name = "pytest-xdist", specifier = ">=3.6.0" },
 ]
 
 [[package]]

From db98584b8c8705292726c1917d9fbaf51e4a1228 Mon Sep 17 00:00:00 2001
From: styu12 <styu12@naver.com>
Date: Mon, 13 Apr 2026 15:12:55 -0700
Subject: [PATCH 03/18] feat(adapters): add VideoEncoder shared PyAV MP4 writer

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 src/syncfield/adapters/_video_encoder.py  |  99 ++++++++++++++++++
 tests/unit/adapters/test_video_encoder.py | 117 ++++++++++++++++++++++
 2 files changed, 216 insertions(+)
 create mode 100644 src/syncfield/adapters/_video_encoder.py
 create mode 100644 tests/unit/adapters/test_video_encoder.py

diff --git a/src/syncfield/adapters/_video_encoder.py b/src/syncfield/adapters/_video_encoder.py
new file mode 100644
index 0000000..f15e8f3
--- /dev/null
+++ b/src/syncfield/adapters/_video_encoder.py
@@ -0,0 +1,99 @@
+"""VideoEncoder — shared PyAV-based MP4 writer for video adapters.
+
+Used by :class:`~syncfield.adapters.uvc_webcam.UVCWebcamStream` and
+:class:`~syncfield.adapters.oak_camera.OakCameraStream`. The interface is
+deliberately narrow: open with geometry, write BGR numpy frames, close.
+
+The encoder auto-selects the best available H.264 encoder:
+
+* ``h264_videotoolbox`` on macOS (hardware, near-zero CPU)
+* ``libx264`` everywhere else (software, widely available)
+
+All frames are assumed to be BGR24 (numpy ``uint8``, shape
+``(height, width, 3)``) to match the rest of the SDK's convention.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import numpy as np
+
+try:
+    import av  # type: ignore[import-not-found]
+except ImportError as exc:  # pragma: no cover - exercised via sys.modules patch
+    raise ImportError(
+        "syncfield video adapters require PyAV. "
+        "Install with `pip install syncfield[uvc]` (or [oak], [viewer])."
+    ) from exc
+
+
+def _pick_h264_encoder() -> str:
+    """Return the best H.264 encoder name available in this FFmpeg build."""
+    for candidate in ("h264_videotoolbox", "libx264"):
+        try:
+            av.codec.Codec(candidate, "w")
+        except Exception:  # noqa: BLE001 - PyAV raises generic errors here
+            continue
+        return candidate
+    raise RuntimeError(
+        "No H.264 encoder found in PyAV. Reinstall `av` with libx264 support."
+    )
+
+
+class VideoEncoder:
+    """Thin wrapper around an ``av`` output container + H.264 stream."""
+
+    def __init__(
+        self,
+        container: "av.container.OutputContainer",
+        stream: "av.video.stream.VideoStream",
+    ) -> None:
+        self._container = container
+        self._stream = stream
+        self._closed = False
+
+    @classmethod
+    def open(
+        cls,
+        path: str | Path,
+        *,
+        width: int,
+        height: int,
+        fps: float,
+        codec: Optional[str] = None,
+        pixel_format: str = "yuv420p",
+    ) -> "VideoEncoder":
+        """Open ``path`` for writing and configure the H.264 stream."""
+        chosen_codec = codec or _pick_h264_encoder()
+        container = av.open(str(path), mode="w")
+        stream = container.add_stream(chosen_codec, rate=int(round(fps)))
+        stream.width = int(width)
+        stream.height = int(height)
+        stream.pix_fmt = pixel_format
+        return cls(container, stream)
+
+    def write(self, frame_bgr: np.ndarray) -> None:
+        """Encode and mux a single BGR frame.
+
+        Must not be called after :meth:`close`. Callers that interleave
+        writes with other hot-path work should keep the frame buffer
+        alive until this call returns.
+        """
+        if self._closed:
+            raise RuntimeError("VideoEncoder.write called after close")
+        video_frame = av.VideoFrame.from_ndarray(frame_bgr, format="bgr24")
+        for packet in self._stream.encode(video_frame):
+            self._container.mux(packet)
+
+    def close(self) -> None:
+        """Flush the encoder and close the container. Idempotent."""
+        if self._closed:
+            return
+        self._closed = True
+        try:
+            for packet in self._stream.encode(None):
+                self._container.mux(packet)
+        finally:
+            self._container.close()
diff --git a/tests/unit/adapters/test_video_encoder.py b/tests/unit/adapters/test_video_encoder.py
new file mode 100644
index 0000000..26dff05
--- /dev/null
+++ b/tests/unit/adapters/test_video_encoder.py
@@ -0,0 +1,117 @@
+"""Unit tests for VideoEncoder — the shared PyAV MP4 writer.
+
+The real ``av`` module is replaced with a fake so these tests do not
+depend on a working FFmpeg build. We only assert that:
+
+* The encoder opens an output container with the right path and format.
+* It adds one video stream with the requested width, height, fps, pixel
+  format and a usable codec (h264_videotoolbox on mac, libx264 elsewhere).
+* ``write(frame)`` encodes and muxes one packet per call.
+* ``close()`` flushes the encoder and closes the container exactly once.
+* Double ``close()`` is idempotent (no double-flush, no exception).
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from types import SimpleNamespace
+from unittest.mock import MagicMock
+
+import numpy as np
+import pytest
+
+
+@pytest.fixture
+def fake_av(monkeypatch: pytest.MonkeyPatch) -> SimpleNamespace:
+    """Install a fake ``av`` module that records every interaction."""
+    container = MagicMock(name="OutputContainer")
+    stream = MagicMock(name="VideoStream")
+    stream.width = 0
+    stream.height = 0
+    stream.pix_fmt = "yuv420p"
+    container.add_stream.return_value = stream
+
+    packet = MagicMock(name="Packet")
+    stream.encode.return_value = [packet]
+
+    av = SimpleNamespace()
+    av.open = MagicMock(name="av.open", return_value=container)
+
+    def _from_ndarray(arr: np.ndarray, format: str) -> MagicMock:
+        frame = MagicMock(name="VideoFrame")
+        frame.to_ndarray = lambda format="bgr24": arr
+        frame._source_format = format
+        return frame
+
+    video_frame = SimpleNamespace(from_ndarray=MagicMock(side_effect=_from_ndarray))
+    av.VideoFrame = video_frame
+
+    def _codec(name: str, mode: str) -> SimpleNamespace:
+        if name in {"h264_videotoolbox", "libx264"}:
+            return SimpleNamespace(name=name)
+        raise ValueError(f"unknown codec {name}")
+
+    av.codec = SimpleNamespace(Codec=MagicMock(side_effect=_codec))
+
+    # Remove any cached import of the module under test so it picks up
+    # the fake ``av`` when re-imported.
+    sys.modules.pop("syncfield.adapters._video_encoder", None)
+    monkeypatch.setitem(sys.modules, "av", av)
+    return SimpleNamespace(av=av, container=container, stream=stream, packet=packet)
+
+
+def test_open_creates_output_container(tmp_path: Path, fake_av: SimpleNamespace) -> None:
+    from syncfield.adapters._video_encoder import VideoEncoder
+
+    out = tmp_path / "clip.mp4"
+    enc = VideoEncoder.open(out, width=1280, height=720, fps=30.0)
+
+    fake_av.av.open.assert_called_once()
+    args, kwargs = fake_av.av.open.call_args
+    assert args[0] == str(out)
+    assert kwargs.get("mode") == "w"
+
+    fake_av.container.add_stream.assert_called_once()
+    stream_args, stream_kwargs = fake_av.container.add_stream.call_args
+    assert stream_args[0] in {"h264_videotoolbox", "libx264"}
+    assert stream_kwargs.get("rate") == 30
+    assert fake_av.stream.width == 1280
+    assert fake_av.stream.height == 720
+
+    enc.close()
+
+
+def test_write_encodes_and_muxes_one_frame(tmp_path: Path, fake_av: SimpleNamespace) -> None:
+    from syncfield.adapters._video_encoder import VideoEncoder
+
+    enc = VideoEncoder.open(tmp_path / "clip.mp4", width=64, height=48, fps=30.0)
+    frame = np.zeros((48, 64, 3), dtype=np.uint8)
+
+    enc.write(frame)
+
+    fake_av.av.VideoFrame.from_ndarray.assert_called_once()
+    fake_av.stream.encode.assert_called()
+    fake_av.container.mux.assert_called_with(fake_av.packet)
+
+    enc.close()
+
+
+def test_close_is_idempotent(tmp_path: Path, fake_av: SimpleNamespace) -> None:
+    from syncfield.adapters._video_encoder import VideoEncoder
+
+    enc = VideoEncoder.open(tmp_path / "clip.mp4", width=64, height=48, fps=30.0)
+    enc.close()
+    enc.close()  # should not raise, should not double-close
+
+    assert fake_av.container.close.call_count == 1
+
+
+def test_write_after_close_raises(tmp_path: Path, fake_av: SimpleNamespace) -> None:
+    from syncfield.adapters._video_encoder import VideoEncoder
+
+    enc = VideoEncoder.open(tmp_path / "clip.mp4", width=64, height=48, fps=30.0)
+    enc.close()
+    frame = np.zeros((48, 64, 3), dtype=np.uint8)
+    with pytest.raises(RuntimeError):
+        enc.write(frame)

From 7c534c1243fa1aa72b9e5d7280d5e77bbb1d3f62 Mon Sep 17 00:00:00 2001
From: styu12 <styu12@naver.com>
Date: Mon, 13 Apr 2026 15:16:54 -0700
Subject: [PATCH 04/18] fix(adapters): harden VideoEncoder close() and tighten
 fake_av fixture

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 src/syncfield/adapters/_video_encoder.py  | 20 ++++++++++++---
 tests/unit/adapters/test_video_encoder.py | 31 +++++++++++++++++++++--
 2 files changed, 45 insertions(+), 6 deletions(-)

diff --git a/src/syncfield/adapters/_video_encoder.py b/src/syncfield/adapters/_video_encoder.py
index f15e8f3..fa52d23 100644
--- a/src/syncfield/adapters/_video_encoder.py
+++ b/src/syncfield/adapters/_video_encoder.py
@@ -63,7 +63,6 @@ def open(
         height: int,
         fps: float,
         codec: Optional[str] = None,
-        pixel_format: str = "yuv420p",
     ) -> "VideoEncoder":
         """Open ``path`` for writing and configure the H.264 stream."""
         chosen_codec = codec or _pick_h264_encoder()
@@ -71,7 +70,7 @@ def open(
         stream = container.add_stream(chosen_codec, rate=int(round(fps)))
         stream.width = int(width)
         stream.height = int(height)
-        stream.pix_fmt = pixel_format
+        stream.pix_fmt = "yuv420p"
         return cls(container, stream)
 
     def write(self, frame_bgr: np.ndarray) -> None:
@@ -88,12 +87,25 @@ def write(self, frame_bgr: np.ndarray) -> None:
             self._container.mux(packet)
 
     def close(self) -> None:
-        """Flush the encoder and close the container. Idempotent."""
+        """Flush the encoder and close the container. Idempotent.
+
+        May raise if the final flush fails. A second ``close()`` is always
+        a no-op. The underlying container is closed even if the flush
+        raises, so resources are not leaked.
+        """
         if self._closed:
             return
         self._closed = True
+        flush_error: Optional[BaseException] = None
         try:
             for packet in self._stream.encode(None):
                 self._container.mux(packet)
-        finally:
+        except BaseException as exc:  # noqa: BLE001 - propagate after cleanup
+            flush_error = exc
+        # Always close the container, even if flush raised.
+        try:
             self._container.close()
+        except Exception:  # noqa: BLE001 - trailer write failure is unrecoverable
+            pass
+        if flush_error is not None:
+            raise flush_error
diff --git a/tests/unit/adapters/test_video_encoder.py b/tests/unit/adapters/test_video_encoder.py
index 26dff05..fac7324 100644
--- a/tests/unit/adapters/test_video_encoder.py
+++ b/tests/unit/adapters/test_video_encoder.py
@@ -33,7 +33,9 @@ def fake_av(monkeypatch: pytest.MonkeyPatch) -> SimpleNamespace:
     container.add_stream.return_value = stream
 
     packet = MagicMock(name="Packet")
-    stream.encode.return_value = [packet]
+    stream.encode = MagicMock(
+        side_effect=lambda frame: [packet] if frame is not None else []
+    )
 
     av = SimpleNamespace()
     av.open = MagicMock(name="av.open", return_value=container)
@@ -92,7 +94,7 @@ def test_write_encodes_and_muxes_one_frame(tmp_path: Path, fake_av: SimpleNamesp
 
     fake_av.av.VideoFrame.from_ndarray.assert_called_once()
     fake_av.stream.encode.assert_called()
-    fake_av.container.mux.assert_called_with(fake_av.packet)
+    fake_av.container.mux.assert_called_once_with(fake_av.packet)
 
     enc.close()
 
@@ -115,3 +117,28 @@ def test_write_after_close_raises(tmp_path: Path, fake_av: SimpleNamespace) -> N
     frame = np.zeros((48, 64, 3), dtype=np.uint8)
     with pytest.raises(RuntimeError):
         enc.write(frame)
+
+
+def test_close_propagates_flush_error_but_closes_container(
+    tmp_path: Path, fake_av: SimpleNamespace
+) -> None:
+    """If the flush raises, close() still closes the container and re-raises."""
+    from syncfield.adapters._video_encoder import VideoEncoder
+
+    enc = VideoEncoder.open(tmp_path / "clip.mp4", width=64, height=48, fps=30.0)
+
+    # Make the flush (encode(None)) raise.
+    fake_av.stream.encode = MagicMock(
+        side_effect=lambda frame: (_ for _ in ()).throw(RuntimeError("flush failed"))
+        if frame is None
+        else [fake_av.packet]
+    )
+
+    with pytest.raises(RuntimeError, match="flush failed"):
+        enc.close()
+
+    # Container was still closed even though flush raised.
+    fake_av.container.close.assert_called_once()
+    # Second close() is a no-op.
+    enc.close()
+    fake_av.container.close.assert_called_once()

From 47908286f4abe4c3b8f4baa2131348f0e442340d Mon Sep 17 00:00:00 2001
From: styu12 <styu12@naver.com>
Date: Mon, 13 Apr 2026 15:21:08 -0700
Subject: [PATCH 05/18] feat(adapters): add open_uvc_input platform dispatch
 helper

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 src/syncfield/adapters/_video_encoder.py  | 49 ++++++++++++
 tests/unit/adapters/test_video_encoder.py | 93 ++++++++++++++++++++++-
 2 files changed, 141 insertions(+), 1 deletion(-)

diff --git a/src/syncfield/adapters/_video_encoder.py b/src/syncfield/adapters/_video_encoder.py
index fa52d23..1bdd41c 100644
--- a/src/syncfield/adapters/_video_encoder.py
+++ b/src/syncfield/adapters/_video_encoder.py
@@ -15,6 +15,7 @@
 
 from __future__ import annotations
 
+import sys
 from pathlib import Path
 from typing import Optional
 
@@ -109,3 +110,51 @@ def close(self) -> None:
             pass
         if flush_error is not None:
             raise flush_error
+
+
+def open_uvc_input(
+    *,
+    device_index: int,
+    width: int,
+    height: int,
+    fps: float,
+    device_name: Optional[str] = None,
+    pixel_format: str = "mjpeg",
+) -> "av.container.InputContainer":
+    """Open a UVC webcam as a PyAV input container.
+
+    Platform dispatch:
+
+    * macOS — ``avfoundation`` with URL ``"<video>:<audio>"``. We pass
+      ``"<index>:none"`` so no audio input is opened.
+    * Linux — ``v4l2`` with URL ``/dev/video<N>``.
+    * Windows — ``dshow`` with URL ``video=<device_name>``. The caller
+      must supply ``device_name`` (DirectShow has no index URL).
+
+    The returned container yields packets via ``.demux()`` which the
+    caller decodes frame-by-frame.
+    """
+    options = {
+        "video_size": f"{int(width)}x{int(height)}",
+        "framerate": str(int(round(fps))),
+        "pixel_format": pixel_format,
+    }
+
+    if sys.platform == "darwin":
+        url = f"{int(device_index)}:none"
+        fmt = "avfoundation"
+    elif sys.platform.startswith("linux"):
+        url = f"/dev/video{int(device_index)}"
+        fmt = "v4l2"
+    elif sys.platform.startswith("win"):
+        if not device_name:
+            raise ValueError(
+                "Windows UVC input requires `device_name` "
+                "(DirectShow has no device-index URL)."
+            )
+        url = f"video={device_name}"
+        fmt = "dshow"
+    else:
+        raise RuntimeError(f"Unsupported platform for UVC input: {sys.platform}")
+
+    return av.open(url, format=fmt, options=options)
diff --git a/tests/unit/adapters/test_video_encoder.py b/tests/unit/adapters/test_video_encoder.py
index fac7324..904f610 100644
--- a/tests/unit/adapters/test_video_encoder.py
+++ b/tests/unit/adapters/test_video_encoder.py
@@ -57,8 +57,14 @@ def _codec(name: str, mode: str) -> SimpleNamespace:
     av.codec = SimpleNamespace(Codec=MagicMock(side_effect=_codec))
 
     # Remove any cached import of the module under test so it picks up
-    # the fake ``av`` when re-imported.
+    # the fake ``av`` when re-imported. Also drop the attribute on the
+    # parent package, otherwise ``from syncfield.adapters import
+    # _video_encoder`` would resolve via the cached parent attribute and
+    # skip the reload.
     sys.modules.pop("syncfield.adapters._video_encoder", None)
+    parent = sys.modules.get("syncfield.adapters")
+    if parent is not None and hasattr(parent, "_video_encoder"):
+        monkeypatch.delattr(parent, "_video_encoder", raising=False)
     monkeypatch.setitem(sys.modules, "av", av)
     return SimpleNamespace(av=av, container=container, stream=stream, packet=packet)
 
@@ -142,3 +148,88 @@ def test_close_propagates_flush_error_but_closes_container(
     # Second close() is a no-op.
     enc.close()
     fake_av.container.close.assert_called_once()
+
+
+def test_open_uvc_input_macos(
+    monkeypatch: pytest.MonkeyPatch, fake_av: SimpleNamespace
+) -> None:
+    from syncfield.adapters import _video_encoder
+
+    monkeypatch.setattr(_video_encoder.sys, "platform", "darwin")
+    input_container = MagicMock(name="InputContainer")
+    fake_av.av.open.return_value = input_container
+
+    result = _video_encoder.open_uvc_input(
+        device_index=0, width=1280, height=720, fps=30.0
+    )
+
+    args, kwargs = fake_av.av.open.call_args
+    assert args[0] == "0:none"
+    assert kwargs.get("format") == "avfoundation"
+    assert kwargs.get("options", {}).get("video_size") == "1280x720"
+    assert kwargs.get("options", {}).get("framerate") == "30"
+    assert result is input_container
+
+
+def test_open_uvc_input_linux(
+    monkeypatch: pytest.MonkeyPatch, fake_av: SimpleNamespace
+) -> None:
+    from syncfield.adapters import _video_encoder
+
+    monkeypatch.setattr(_video_encoder.sys, "platform", "linux")
+    fake_av.av.open.return_value = MagicMock(name="InputContainer")
+
+    _video_encoder.open_uvc_input(
+        device_index=2, width=1280, height=720, fps=30.0
+    )
+
+    args, kwargs = fake_av.av.open.call_args
+    assert args[0] == "/dev/video2"
+    assert kwargs.get("format") == "v4l2"
+
+
+def test_open_uvc_input_windows(
+    monkeypatch: pytest.MonkeyPatch, fake_av: SimpleNamespace
+) -> None:
+    from syncfield.adapters import _video_encoder
+
+    monkeypatch.setattr(_video_encoder.sys, "platform", "win32")
+    fake_av.av.open.return_value = MagicMock(name="InputContainer")
+
+    _video_encoder.open_uvc_input(
+        device_index=0,
+        width=1280,
+        height=720,
+        fps=30.0,
+        device_name="Logitech BRIO",
+    )
+
+    args, kwargs = fake_av.av.open.call_args
+    assert args[0] == "video=Logitech BRIO"
+    assert kwargs.get("format") == "dshow"
+
+
+def test_open_uvc_input_windows_requires_device_name(
+    monkeypatch: pytest.MonkeyPatch, fake_av: SimpleNamespace
+) -> None:
+    from syncfield.adapters import _video_encoder
+
+    monkeypatch.setattr(_video_encoder.sys, "platform", "win32")
+
+    with pytest.raises(ValueError, match="device_name"):
+        _video_encoder.open_uvc_input(
+            device_index=0, width=1280, height=720, fps=30.0
+        )
+
+
+def test_open_uvc_input_unsupported_platform(
+    monkeypatch: pytest.MonkeyPatch, fake_av: SimpleNamespace
+) -> None:
+    from syncfield.adapters import _video_encoder
+
+    monkeypatch.setattr(_video_encoder.sys, "platform", "freebsd13")
+
+    with pytest.raises(RuntimeError, match="Unsupported platform"):
+        _video_encoder.open_uvc_input(
+            device_index=0, width=1280, height=720, fps=30.0
+        )

From 4ffdd562bfdf572546bb6176c08985f05fdd47e2 Mon Sep 17 00:00:00 2001
From: styu12 <styu12@naver.com>
Date: Mon, 13 Apr 2026 15:26:25 -0700
Subject: [PATCH 06/18] feat(adapters): migrate UVCWebcamStream to PyAV

- Replace cv2.VideoCapture with open_uvc_input() platform dispatch
- Replace cv2.VideoWriter with shared VideoEncoder
- Default resolution 1280x720@30 (enables request at UVC level)
- Timestamp strategy unchanged (time.monotonic_ns after decode)
- Discover helpers preserved verbatim
- Existing UVC tests now fail; Task 5 migrates them

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 src/syncfield/adapters/uvc_webcam.py | 360 ++++++++++-----------------
 1 file changed, 127 insertions(+), 233 deletions(-)

diff --git a/src/syncfield/adapters/uvc_webcam.py b/src/syncfield/adapters/uvc_webcam.py
index b9d6490..1d8c9eb 100644
--- a/src/syncfield/adapters/uvc_webcam.py
+++ b/src/syncfield/adapters/uvc_webcam.py
@@ -1,38 +1,34 @@
-"""UVCWebcamStream — OpenCV-based reference adapter for UVC/USB webcams.
+"""UVCWebcamStream — PyAV-based adapter for UVC/USB webcams.
 
 Requires the optional ``uvc`` extra:
 
     pip install syncfield[uvc]
 
-The adapter runs a background thread that reads frames in a tight loop,
-timestamps each read with ``time.monotonic_ns()`` **before** any further
-processing, and publishes them to :attr:`latest_frame` for the viewer
-to preview. The **same thread** writes to an MP4 via ``cv2.VideoWriter``
-and emits :class:`~syncfield.types.SampleEvent` — but only while the
-session is in :attr:`~syncfield.SessionState.RECORDING`. In the
-:attr:`~syncfield.SessionState.CONNECTED` live-preview phase the loop
-keeps feeding ``latest_frame`` so the viewer card shows a live
-thumbnail, without touching the filesystem.
+The adapter runs a background thread that decodes frames from a PyAV
+input container, timestamps each decoded frame with
+``time.monotonic_ns()`` **before** any further processing, and publishes
+them to :attr:`latest_frame` for the viewer to preview. The **same
+thread** writes to an MP4 via :class:`~._video_encoder.VideoEncoder` and
+emits :class:`~syncfield.types.SampleEvent` — but only while the session
+is in :attr:`~syncfield.SessionState.RECORDING`.
 
 Lifecycle
 ---------
 
 This adapter implements the 4-phase :class:`~syncfield.Stream` SPI:
 
-* ``prepare()``   — create the output directory and open ``cv2.VideoCapture``.
+* ``prepare()``   — open the PyAV input container.
 * ``connect()``   — start the capture thread in preview-only mode;
   ``latest_frame`` begins updating immediately.
-* ``start_recording()`` — open the ``VideoWriter`` and flip the
+* ``start_recording()`` — open the :class:`VideoEncoder` and flip the
   ``_recording`` flag so the loop starts writing and emitting samples.
-* ``stop_recording()`` — flip ``_recording`` off and close the writer;
+* ``stop_recording()`` — flip ``_recording`` off and close the encoder;
   the capture thread keeps running so preview continues.
-* ``disconnect()`` — stop the capture thread and release the
-  ``VideoCapture`` handle.
+* ``disconnect()`` — stop the capture thread and release the input
+  container.
 
 Legacy ``start()`` / ``stop()`` are still supported for one-shot code
-paths (tests, scripts that don't use the viewer): they simply call
-``connect() + start_recording()`` and ``stop_recording() + disconnect()``
-respectively.
+paths (tests, scripts that don't use the viewer).
 """
 
 from __future__ import annotations
@@ -42,14 +38,7 @@
 from pathlib import Path
 from typing import Any, Optional
 
-try:
-    import cv2  # type: ignore[import-not-found]
-except ImportError as exc:  # pragma: no cover - exercised via sys.modules patch
-    raise ImportError(
-        "UVCWebcamStream requires opencv-python. "
-        "Install with `pip install syncfield[uvc]`."
-    ) from exc
-
+from syncfield.adapters._video_encoder import VideoEncoder, open_uvc_input
 from syncfield.clock import SessionClock
 from syncfield.stream import DeviceKey, StreamBase
 from syncfield.types import (
@@ -60,15 +49,18 @@
 
 
 class UVCWebcamStream(StreamBase):
-    """Captures video from a UVC webcam via OpenCV.
+    """Captures video from a UVC webcam via PyAV.
 
     Args:
         id: Stream id (also used as the output file name, ``{id}.mp4``).
-        device_index: OpenCV device index passed to ``cv2.VideoCapture``.
+        device_index: Platform device index (AVFoundation / V4L2 index,
+            or DirectShow fallback alongside ``device_name``).
         output_dir: Directory for the resulting MP4 file.
-        width: Desired frame width (or ``None`` to use the device default).
-        height: Desired frame height (or ``None`` to use the device default).
-        fps: Desired frame rate (or ``None`` to use the device default).
+        width: Desired frame width (defaults to 1280 — 720p).
+        height: Desired frame height (defaults to 720 — 720p).
+        fps: Desired frame rate (defaults to 30.0).
+        device_name: Required only on Windows (DirectShow). Ignored on
+            macOS / Linux — see :func:`~syncfield.adapters._video_encoder.open_uvc_input`.
     """
 
     # Class-level hints for ``syncfield.discovery``.
@@ -80,54 +72,52 @@ def __init__(
         id: str,
         device_index: int,
         output_dir: Path | str,
-        width: Optional[int] = None,
-        height: Optional[int] = None,
-        fps: Optional[float] = None,
+        width: Optional[int] = 1280,
+        height: Optional[int] = 720,
+        fps: Optional[float] = 30.0,
+        device_name: Optional[str] = None,
     ) -> None:
         super().__init__(
             id=id,
             kind="video",
             capabilities=StreamCapabilities(
-                provides_audio_track=False,  # OpenCV webcams have no audio path
+                provides_audio_track=False,
                 supports_precise_timestamps=True,
                 is_removable=True,
                 produces_file=True,
             ),
         )
         self._device_index = device_index
+        self._device_name = device_name
         self._output_dir = Path(output_dir)
-        self._width = width
-        self._height = height
-        self._fps = fps
+        self._width = int(width) if width else 1280
+        self._height = int(height) if height else 720
+        self._fps = float(fps) if fps else 30.0
 
-        self._capture: Any = None
-        self._writer: Any = None
+        self._input: Any = None
+        self._encoder: Optional[VideoEncoder] = None
         self._file_path = self._output_dir / f"{id}.mp4"
+
         self._thread: Optional[threading.Thread] = None
         self._stop_event = threading.Event()
         self._frame_count = 0
         self._first_at: Optional[int] = None
         self._last_at: Optional[int] = None
 
-        # True while the capture loop is writing frames to the MP4
-        # writer and emitting ``SampleEvent``s. ``connect()`` leaves
-        # this False so the preview phase stays write-free;
-        # ``start_recording()`` flips it True; ``stop_recording()``
-        # flips it False again while the thread keeps running.
+        # True while the capture loop is writing frames and emitting
+        # SampleEvents. ``connect()`` leaves this False so the preview
+        # phase stays write-free; ``start_recording()`` flips it True.
         self._recording = False
 
-        # Live preview support — the viewer reads ``latest_frame`` to render
-        # the stream card thumbnail. ``_frame_lock`` protects handoff between
-        # the capture thread and the reader; the frame itself is a plain
-        # reference so no copy is made in the hot path.
+        # Live preview support — the viewer reads ``latest_frame`` for
+        # the stream card thumbnail. ``_frame_lock`` protects the
+        # reference handoff between the capture thread and readers.
         self._frame_lock = threading.Lock()
         self._latest_frame: Any = None
 
     @property
     def device_key(self) -> Optional[DeviceKey]:
-        """``("uvc_webcam", str(device_index))`` — the OpenCV index is
-        the stable hardware id on macOS / Linux / Windows.
-        """
+        """``("uvc_webcam", str(device_index))`` — stable hardware id."""
         return ("uvc_webcam", str(self._device_index))
 
     # ------------------------------------------------------------------
@@ -135,40 +125,21 @@ def device_key(self) -> Optional[DeviceKey]:
     # ------------------------------------------------------------------
 
     def prepare(self) -> None:
-        """Open ``cv2.VideoCapture``.
-
-        Called once by the orchestrator before ``connect()``. The
-        device handle stays open from here until ``disconnect()``.
-        Output directory is created later in ``start_recording()``.
-        """
-        if self._capture is None:
-            self._capture = cv2.VideoCapture(self._device_index)
-        if not self._capture.isOpened():
-            raise RuntimeError(
-                f"cv2.VideoCapture({self._device_index}) failed to open"
+        """Open the PyAV input container (the camera device)."""
+        if self._input is None:
+            self._input = open_uvc_input(
+                device_index=self._device_index,
+                width=self._width,
+                height=self._height,
+                fps=self._fps,
+                device_name=self._device_name,
             )
 
     def connect(self) -> None:
-        """Start the capture thread in preview-only mode.
-
-        After this call the background thread reads frames as fast as
-        the device allows and publishes each one to
-        :attr:`latest_frame` so the viewer's stream card shows a live
-        thumbnail. **No file is written and no SampleEvents are
-        emitted** until ``start_recording()`` flips the
-        ``_recording`` flag.
-
-        Idempotent: calling ``connect()`` on an already-connected
-        stream is a no-op so the legacy ``start()`` wrapper can call
-        it unconditionally without risking a second thread.
-        """
+        """Start the capture thread in preview-only mode."""
         if self._thread is not None and self._thread.is_alive():
             return
-        # prepare() is the documented step that opens the capture,
-        # but legacy scripts that jump straight to start() route
-        # through connect() too — so open the device here if nobody
-        # already did.
-        if self._capture is None or not self._capture.isOpened():
+        if self._input is None:
             self.prepare()
         self._recording = False
         self._stop_event.clear()
@@ -178,38 +149,24 @@ def connect(self) -> None:
         self._thread.start()
 
     def start_recording(self, session_clock: SessionClock) -> None:
-        """Open the ``VideoWriter`` and flip recording on.
-
-        The capture thread is already running from ``connect()``,
-        so this is effectively a flag flip plus one ``cv2.VideoWriter``
-        construction. The first frame written after this call lands
-        at ``frame_count == 1``.
-
-        If the caller skipped ``connect()`` (legacy ``start()`` path),
-        the thread is started first so the writer always has a
-        feeder thread to back it.
-        """
+        """Open the VideoEncoder and flip recording on."""
         if self._thread is None or not self._thread.is_alive():
             self.connect()
         self._output_dir.mkdir(parents=True, exist_ok=True)
-        width, height, fps = self._resolve_frame_geometry()
-        fourcc = cv2.VideoWriter_fourcc(*"mp4v")
-        self._writer = cv2.VideoWriter(
-            str(self._file_path), fourcc, fps, (width, height)
+        self._encoder = VideoEncoder.open(
+            self._file_path,
+            width=self._width,
+            height=self._height,
+            fps=self._fps,
         )
         self._recording = True
 
     def stop_recording(self) -> FinalizationReport:
-        """Flip recording off, close the writer, emit the report.
-
-        The capture thread **keeps running** after this call so the
-        viewer preview stays live and the user can start a new
-        recording on the same session without re-opening hardware.
-        """
+        """Flip recording off, close the encoder, emit the report."""
         self._recording = False
-        if self._writer is not None:
-            self._writer.release()
-            self._writer = None
+        if self._encoder is not None:
+            self._encoder.close()
+            self._encoder = None
         return FinalizationReport(
             stream_id=self.id,
             status="completed",
@@ -222,45 +179,28 @@ def stop_recording(self) -> FinalizationReport:
         )
 
     def disconnect(self) -> None:
-        """Stop the capture thread and release the device handle.
-
-        Called by the orchestrator when the session returns to
-        ``IDLE``. After this call the adapter holds no OS resources.
-        Idempotent — calling it twice is safe.
-        """
+        """Stop the capture thread and release the input container."""
         self._stop_event.set()
         if self._thread is not None:
             self._thread.join(timeout=2.0)
             self._thread = None
-        self._release_cv2_resources()
+        self._release_av_resources()
 
     # ------------------------------------------------------------------
     # Legacy one-shot lifecycle
     # ------------------------------------------------------------------
 
     def start(self, session_clock: SessionClock) -> None:
-        """Legacy one-shot start — open writer and start recording immediately.
-
-        Exists so 0.1-era scripts that call ``prepare() → start() →
-        stop()`` keep working without changes. The flag and writer
-        are set up **before** the capture thread spawns so the very
-        first frame off ``read()`` lands in both the file and the
-        emitted :class:`SampleEvent` — no preview phase.
-
-        New callers (the viewer, the 4-phase orchestrator path)
-        should use :meth:`connect` and :meth:`start_recording`
-        directly to get live preview before the first Record click.
-        """
-        if self._capture is None or not self._capture.isOpened():
+        """Legacy one-shot start — open encoder and start recording."""
+        if self._input is None:
             self.prepare()
-        width, height, fps = self._resolve_frame_geometry()
-        fourcc = cv2.VideoWriter_fourcc(*"mp4v")
-        self._writer = cv2.VideoWriter(
-            str(self._file_path), fourcc, fps, (width, height)
+        self._output_dir.mkdir(parents=True, exist_ok=True)
+        self._encoder = VideoEncoder.open(
+            self._file_path,
+            width=self._width,
+            height=self._height,
+            fps=self._fps,
         )
-        # Flip the recording flag BEFORE spawning the thread so the
-        # loop records from frame 1 instead of racing through a
-        # preview phase the caller never asked for.
         self._recording = True
         self._stop_event.clear()
         self._thread = threading.Thread(
@@ -269,73 +209,56 @@ def start(self, session_clock: SessionClock) -> None:
         self._thread.start()
 
     def stop(self) -> FinalizationReport:
-        """Legacy one-shot stop — stop_recording + disconnect in one call."""
+        """Legacy one-shot stop — stop_recording + disconnect."""
         report = self.stop_recording()
         self.disconnect()
         return report
 
     # ------------------------------------------------------------------
-    # Helpers
+    # Capture loop
     # ------------------------------------------------------------------
 
-    def _resolve_frame_geometry(self) -> tuple[int, int, float]:
-        """Pick width, height, fps — constructor overrides beat device defaults."""
-        width = self._width or int(
-            self._capture.get(cv2.CAP_PROP_FRAME_WIDTH) or 640
-        )
-        height = self._height or int(
-            self._capture.get(cv2.CAP_PROP_FRAME_HEIGHT) or 480
-        )
-        fps = self._fps or self._capture.get(cv2.CAP_PROP_FPS) or 30.0
-        return width, height, fps
-
     def _capture_loop(self) -> None:
-        """Background thread body — read frames in a tight loop.
-
-        Two phases, distinguished by the ``_recording`` flag:
-
-        * **Preview** (``_recording == False``) — publish every frame
-          to ``latest_frame`` so the viewer card stays live, but do
-          **not** write to the file, update frame counters, or emit
-          ``SampleEvent``. The capture runs continuously from the
-          moment ``connect()`` spawned this thread.
-        * **Recording** (``_recording == True``) — same preview
-          publish, plus append the frame to the ``VideoWriter``,
-          advance ``_frame_count``, and emit ``SampleEvent``. The
-          capture timestamp is sampled immediately after ``read()``
-          so the jitter between the physical frame and the recorded
-          monotonic time stays as small as possible.
-
-        The loop exits when ``_stop_event`` fires (from
-        ``disconnect()``) or when ``read()`` returns a falsy result
-        (hardware disconnect / device busy).
+        """Background thread — decode frames in a tight loop.
+
+        Two phases, distinguished by ``_recording`` flag:
+
+        * Preview — publish to ``latest_frame`` only.
+        * Recording — also encode to MP4 and emit SampleEvent.
+
+        The loop exits when ``_stop_event`` fires or the input container
+        is exhausted (device disconnect).
         """
-        assert self._capture is not None
-        while not self._stop_event.is_set():
-            ok, frame = self._capture.read()
-            capture_ns = time.monotonic_ns()
-            if not ok or frame is None:
-                break
-
-            # Always publish for live preview — the viewer reads this
-            # in both CONNECTED and RECORDING states.
-            with self._frame_lock:
-                self._latest_frame = frame
-
-            if self._recording:
-                if self._first_at is None:
-                    self._first_at = capture_ns
-                self._last_at = capture_ns
-                self._frame_count += 1
-                if self._writer is not None:
-                    self._writer.write(frame)
-                self._emit_sample(
-                    SampleEvent(
-                        stream_id=self.id,
-                        frame_number=self._frame_count - 1,
-                        capture_ns=capture_ns,
+        assert self._input is not None
+        try:
+            for frame in self._input.decode(video=0):
+                if self._stop_event.is_set():
+                    break
+
+                capture_ns = time.monotonic_ns()
+                frame_bgr = frame.to_ndarray(format="bgr24")
+
+                with self._frame_lock:
+                    self._latest_frame = frame_bgr
+
+                if self._recording:
+                    if self._first_at is None:
+                        self._first_at = capture_ns
+                    self._last_at = capture_ns
+                    self._frame_count += 1
+                    if self._encoder is not None:
+                        self._encoder.write(frame_bgr)
+                    self._emit_sample(
+                        SampleEvent(
+                            stream_id=self.id,
+                            frame_number=self._frame_count - 1,
+                            capture_ns=capture_ns,
+                        )
                     )
-                )
+        except Exception:
+            # Device disconnect or decode error — exit the loop; the
+            # orchestrator observes the thread dying via disconnect().
+            return
 
     # ------------------------------------------------------------------
     # Live preview
@@ -343,23 +266,19 @@ def _capture_loop(self) -> None:
 
     @property
     def latest_frame(self) -> Any:
-        """Return the most recently captured BGR frame, or ``None``.
-
-        Thread-safe: the frame reference is published under a lock by the
-        capture thread. Readers that mutate the returned array should
-        ``.copy()`` it first — in practice the viewer uploads it as a
-        texture immediately and never mutates it in place.
-        """
+        """Return the most recently captured BGR frame, or ``None``."""
         with self._frame_lock:
             return self._latest_frame
 
-    def _release_cv2_resources(self) -> None:
-        if self._writer is not None:
-            self._writer.release()
-            self._writer = None
-        if self._capture is not None:
-            self._capture.release()
-            self._capture = None
+    def _release_av_resources(self) -> None:
+        if self._encoder is not None:
+            self._encoder.close()
+            self._encoder = None
+        if self._input is not None:
+            try:
+                self._input.close()
+            finally:
+                self._input = None
 
     # ------------------------------------------------------------------
     # Discovery
@@ -369,24 +288,13 @@ def _release_cv2_resources(self) -> None:
     def discover(cls, *, timeout: float = 5.0) -> list:
         """Enumerate attached UVC webcams.
 
-        Uses the platform-native enumeration tool when available so the
-        discovery pass is fast and avoids triggering the camera permission
-        dialog (which ``cv2.VideoCapture`` does on macOS even for a probe):
+        Uses the platform-native enumeration tool so the discovery pass
+        is fast and avoids triggering the camera permission dialog:
 
         - macOS: ``system_profiler SPCameraDataType -json``
         - Linux: ``/dev/video*`` inspection
         - Other / fallback: nothing returned — use explicit
-          ``UVCWebcamStream(device_index=...)`` construction
-
-        Each returned device's ``construct_kwargs`` carries the OpenCV
-        ``device_index`` that matches its position in the native listing.
-        On some platforms that mapping is not perfectly stable — if the
-        resulting stream fails to open, users fall back to explicit
-        construction.
-
-        Returns:
-            List of :class:`~syncfield.discovery.DiscoveredDevice`. Empty
-            on unsupported platforms or if the probe raises.
+          ``UVCWebcamStream(device_index=...)`` construction.
         """
         from syncfield.discovery import DiscoveredDevice
 
@@ -421,14 +329,7 @@ def discover(cls, *, timeout: float = 5.0) -> list:
 
 
 def _discover_uvc_macos() -> list[dict]:
-    """macOS enumeration via ``system_profiler SPCameraDataType``.
-
-    The tool is free to execute, doesn't prompt for camera permissions,
-    and gives us the human-readable name that shows up in System Settings.
-    We map its array position to the OpenCV device_index — on almost all
-    MacBooks this mapping is stable (built-in at 0, Continuity Camera at
-    1, external at 2, ...).
-    """
+    """macOS enumeration via ``system_profiler SPCameraDataType``."""
     import json
     import subprocess
 
@@ -464,12 +365,7 @@ def _discover_uvc_macos() -> list[dict]:
 
 
 def _discover_uvc_linux() -> list[dict]:
-    """Linux enumeration via ``/dev/video*`` + optional name lookup.
-
-    Reads ``/sys/class/video4linux/videoN/name`` for each ``/dev/videoN``
-    — that's what ``v4l2-ctl --list-devices`` uses internally. No
-    subprocess needed.
-    """
+    """Linux enumeration via ``/dev/video*`` + optional name lookup."""
     import re
     from pathlib import Path as _Path
 
@@ -488,8 +384,6 @@ def _discover_uvc_linux() -> list[dict]:
             continue
         index = int(match.group(1))
 
-        # Try to read the human-readable name via sysfs. Falls back to
-        # the device path when sysfs isn't available.
         sysfs_name = _Path(f"/sys/class/video4linux/{device_file.name}/name")
         if sysfs_name.exists():
             try:

From 2e0ec16c93f47a0212f66eb08de5698fcc102627 Mon Sep 17 00:00:00 2001
From: styu12 <styu12@naver.com>
Date: Mon, 13 Apr 2026 15:29:05 -0700
Subject: [PATCH 07/18] fix(adapters): capture monotonic_ns before stop-event
 check in UVC loop

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 src/syncfield/adapters/uvc_webcam.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/syncfield/adapters/uvc_webcam.py b/src/syncfield/adapters/uvc_webcam.py
index 1d8c9eb..ce0af2f 100644
--- a/src/syncfield/adapters/uvc_webcam.py
+++ b/src/syncfield/adapters/uvc_webcam.py
@@ -232,10 +232,10 @@ def _capture_loop(self) -> None:
         assert self._input is not None
         try:
             for frame in self._input.decode(video=0):
+                capture_ns = time.monotonic_ns()
                 if self._stop_event.is_set():
                     break
 
-                capture_ns = time.monotonic_ns()
                 frame_bgr = frame.to_ndarray(format="bgr24")
 
                 with self._frame_lock:

From e2894d76870a19a4dcd54606082a357e77cd0a39 Mon Sep 17 00:00:00 2001
From: styu12 <styu12@naver.com>
Date: Mon, 13 Apr 2026 15:35:38 -0700
Subject: [PATCH 08/18] fix(adapters): emit health on UVC loop exit and reset
 counters per recording

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 src/syncfield/adapters/uvc_webcam.py | 24 +++++++++++++++++++++---
 1 file changed, 21 insertions(+), 3 deletions(-)

diff --git a/src/syncfield/adapters/uvc_webcam.py b/src/syncfield/adapters/uvc_webcam.py
index ce0af2f..c979f5c 100644
--- a/src/syncfield/adapters/uvc_webcam.py
+++ b/src/syncfield/adapters/uvc_webcam.py
@@ -43,6 +43,8 @@
 from syncfield.stream import DeviceKey, StreamBase
 from syncfield.types import (
     FinalizationReport,
+    HealthEvent,
+    HealthEventKind,
     SampleEvent,
     StreamCapabilities,
 )
@@ -153,6 +155,11 @@ def start_recording(self, session_clock: SessionClock) -> None:
         if self._thread is None or not self._thread.is_alive():
             self.connect()
         self._output_dir.mkdir(parents=True, exist_ok=True)
+        # Reset per-recording counters so a second recording in the
+        # same session starts clean.
+        self._frame_count = 0
+        self._first_at = None
+        self._last_at = None
         self._encoder = VideoEncoder.open(
             self._file_path,
             width=self._width,
@@ -195,6 +202,9 @@ def start(self, session_clock: SessionClock) -> None:
         if self._input is None:
             self.prepare()
         self._output_dir.mkdir(parents=True, exist_ok=True)
+        self._frame_count = 0
+        self._first_at = None
+        self._last_at = None
         self._encoder = VideoEncoder.open(
             self._file_path,
             width=self._width,
@@ -255,9 +265,17 @@ def _capture_loop(self) -> None:
                             capture_ns=capture_ns,
                         )
                     )
-        except Exception:
-            # Device disconnect or decode error — exit the loop; the
-            # orchestrator observes the thread dying via disconnect().
+        except Exception as exc:  # noqa: BLE001 - PyAV surfaces diverse errors here
+            # Device disconnect or decode error — emit a health event so the
+            # orchestrator sees a first-class signal, then exit the thread.
+            self._emit_health(
+                HealthEvent(
+                    stream_id=self.id,
+                    kind=HealthEventKind.ERROR,
+                    at_ns=time.monotonic_ns(),
+                    detail=f"capture loop ended: {exc!r}",
+                )
+            )
             return
 
     # ------------------------------------------------------------------

From 3a7d0f7aa0acb99552e554851f7fcc225780f38e Mon Sep 17 00:00:00 2001
From: styu12 <styu12@naver.com>
Date: Mon, 13 Apr 2026 15:39:44 -0700
Subject: [PATCH 09/18] test(adapters): migrate UVC tests from mock_cv2 to
 mock_av

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 tests/unit/adapters/test_uvc_webcam.py | 219 ++++++++++++++++---------
 1 file changed, 144 insertions(+), 75 deletions(-)

diff --git a/tests/unit/adapters/test_uvc_webcam.py b/tests/unit/adapters/test_uvc_webcam.py
index d456d4b..f82d2e4 100644
--- a/tests/unit/adapters/test_uvc_webcam.py
+++ b/tests/unit/adapters/test_uvc_webcam.py
@@ -1,12 +1,14 @@
-"""Unit tests for UVCWebcamStream using a mocked cv2 module."""
+"""Unit tests for UVCWebcamStream using a mocked PyAV module."""
 
 from __future__ import annotations
 
 import importlib
 import sys
 import time
+from types import SimpleNamespace
 from unittest.mock import MagicMock
 
+import numpy as np
 import pytest
 
 from syncfield.clock import SessionClock
@@ -17,90 +19,168 @@ def _clock() -> SessionClock:
     return SessionClock(sync_point=SyncPoint.create_now("h"))
 
 
-def _build_fake_cv2(frame_budget: int = 3) -> MagicMock:
-    """Return a MagicMock that looks enough like cv2 for the adapter."""
-    fake = MagicMock()
-    cap = MagicMock()
-    counter = {"n": 0}
-
-    def fake_read():
-        counter["n"] += 1
-        if counter["n"] <= frame_budget:
-            return True, MagicMock(shape=(480, 640, 3))
-        return False, None
-
-    cap.read.side_effect = fake_read
-    cap.isOpened.return_value = True
-
-    def fake_get(prop):
-        if prop == fake.CAP_PROP_FPS:
-            return 30.0
-        if prop == fake.CAP_PROP_FRAME_WIDTH:
-            return 640
-        if prop == fake.CAP_PROP_FRAME_HEIGHT:
-            return 480
-        return 0.0
-
-    cap.get.side_effect = fake_get
-    fake.VideoCapture.return_value = cap
-    fake.CAP_PROP_FPS = "CAP_PROP_FPS"
-    fake.CAP_PROP_FRAME_WIDTH = "CAP_PROP_FRAME_WIDTH"
-    fake.CAP_PROP_FRAME_HEIGHT = "CAP_PROP_FRAME_HEIGHT"
-    fake.VideoWriter_fourcc = lambda *args: 0
-    fake.VideoWriter.return_value = MagicMock()
-    return fake
+def _make_frame(i: int) -> MagicMock:
+    """Build a fake PyAV VideoFrame whose ``to_ndarray`` returns BGR24."""
+    frame = MagicMock(name=f"Frame-{i}")
+    frame.to_ndarray = MagicMock(
+        return_value=np.full((48, 64, 3), i % 256, dtype=np.uint8)
+    )
+    return frame
+
+
+def _build_fake_av(
+    frame_budget: int = 3, pace_seconds: float = 0.0
+) -> tuple[SimpleNamespace, MagicMock, MagicMock]:
+    """Build a fake ``av`` module and return (av, input_container, output_stream).
+
+    The input container's ``decode(video=0)`` yields ``frame_budget`` fake
+    frames then stops. When ``pace_seconds`` is > 0 the generator sleeps
+    between frames so the background capture thread doesn't exhaust the
+    iterator faster than the test can interact with the stream. The
+    output container's ``add_stream`` returns a stream whose ``encode``
+    yields one packet per call (empty list on flush with ``None``).
+    """
+
+    def _frame_gen():
+        for i in range(frame_budget):
+            if pace_seconds > 0:
+                time.sleep(pace_seconds)
+            yield _make_frame(i)
+
+    input_container = MagicMock(name="InputContainer")
+    input_container.decode = MagicMock(return_value=_frame_gen())
+
+    output_stream = MagicMock(name="VideoStream")
+    packet = MagicMock(name="Packet")
+    output_stream.encode = MagicMock(
+        side_effect=lambda frame: [packet] if frame is not None else []
+    )
+    output_container = MagicMock(name="OutputContainer")
+    output_container.add_stream = MagicMock(return_value=output_stream)
+
+    def _av_open(url, *args, **kwargs):  # noqa: ANN001 - MagicMock signature
+        if kwargs.get("mode") == "w":
+            return output_container
+        return input_container
+
+    av = SimpleNamespace()
+    av.open = MagicMock(side_effect=_av_open)
+    av.VideoFrame = SimpleNamespace(
+        from_ndarray=MagicMock(return_value=MagicMock(name="OutFrame"))
+    )
+    av.codec = SimpleNamespace(
+        Codec=MagicMock(side_effect=lambda n, m: SimpleNamespace(name=n))
+    )
+    return av, input_container, output_stream
+
+
+@pytest.fixture
+def mock_av(monkeypatch):
+    """Patch ``sys.modules['av']`` with a fake and force-reimport the encoder."""
+    av, input_container, output_stream = _build_fake_av(frame_budget=3)
+    monkeypatch.setitem(sys.modules, "av", av)
+    # Clear cached imports so the adapter and encoder bind to the fake av.
+    sys.modules.pop("syncfield.adapters._video_encoder", None)
+    sys.modules.pop("syncfield.adapters.uvc_webcam", None)
+    # Drop parent-package cached attribute so ``from syncfield.adapters import _video_encoder`` reloads.
+    import syncfield.adapters as _adapters_pkg
+    monkeypatch.delattr(_adapters_pkg, "_video_encoder", raising=False)
+    monkeypatch.delattr(_adapters_pkg, "uvc_webcam", raising=False)
+
+    importlib.import_module("syncfield.adapters._video_encoder")
+    importlib.import_module("syncfield.adapters.uvc_webcam")
+    yield SimpleNamespace(
+        av=av,
+        input_container=input_container,
+        output_stream=output_stream,
+    )
+    sys.modules.pop("syncfield.adapters.uvc_webcam", None)
+    sys.modules.pop("syncfield.adapters._video_encoder", None)
 
 
 @pytest.fixture
-def mock_cv2(monkeypatch):
-    fake = _build_fake_cv2()
-    monkeypatch.setitem(sys.modules, "cv2", fake)
-    # Force re-import so the adapter binds to the fake module
+def mock_av_generous(monkeypatch):
+    """Same as ``mock_av`` but yields effectively unlimited frames so the
+    capture thread can run through both preview and recording phases
+    without exhausting the mocked ``decode()`` iterator.
+    """
+    # Pace the generator so the background thread doesn't exhaust the
+    # iterator during the test's ``time.sleep(...)`` windows — without
+    # pacing, 10_000 MagicMock frames complete in microseconds and the
+    # capture thread exits before ``start_recording()`` is called.
+    av, input_container, output_stream = _build_fake_av(
+        frame_budget=10_000, pace_seconds=0.001
+    )
+    monkeypatch.setitem(sys.modules, "av", av)
+    sys.modules.pop("syncfield.adapters._video_encoder", None)
     sys.modules.pop("syncfield.adapters.uvc_webcam", None)
+    import syncfield.adapters as _adapters_pkg
+    monkeypatch.delattr(_adapters_pkg, "_video_encoder", raising=False)
+    monkeypatch.delattr(_adapters_pkg, "uvc_webcam", raising=False)
+    importlib.import_module("syncfield.adapters._video_encoder")
     importlib.import_module("syncfield.adapters.uvc_webcam")
-    yield fake
+    yield SimpleNamespace(
+        av=av,
+        input_container=input_container,
+        output_stream=output_stream,
+    )
     sys.modules.pop("syncfield.adapters.uvc_webcam", None)
+    sys.modules.pop("syncfield.adapters._video_encoder", None)
+
+
+# ---------------------------------------------------------------------------
+# Basic SPI coverage
+# ---------------------------------------------------------------------------
 
 
-def test_capabilities(mock_cv2, tmp_path):
+def test_capabilities(mock_av, tmp_path):
     from syncfield.adapters.uvc_webcam import UVCWebcamStream
+
     stream = UVCWebcamStream("cam", device_index=0, output_dir=tmp_path)
     assert stream.capabilities.produces_file is True
     assert stream.capabilities.provides_audio_track is False
     assert stream.kind == "video"
 
 
-def test_prepare_opens_device(mock_cv2, tmp_path):
+def test_prepare_opens_pyav_input(mock_av, tmp_path):
     from syncfield.adapters.uvc_webcam import UVCWebcamStream
+
     stream = UVCWebcamStream("cam", device_index=0, output_dir=tmp_path)
     stream.prepare()
-    mock_cv2.VideoCapture.assert_called_once_with(0)
-
 
-def test_prepare_raises_when_device_fails_to_open(mock_cv2, tmp_path):
-    mock_cv2.VideoCapture.return_value.isOpened.return_value = False
-    from syncfield.adapters.uvc_webcam import UVCWebcamStream
-    stream = UVCWebcamStream("cam", device_index=0, output_dir=tmp_path)
-    with pytest.raises(RuntimeError, match="VideoCapture"):
-        stream.prepare()
+    # av.open was called with the input URL (macOS or Linux depending on
+    # the runner), NOT with mode="w".
+    input_calls = [
+        c for c in mock_av.av.open.call_args_list
+        if c.kwargs.get("mode") != "w"
+    ]
+    assert len(input_calls) == 1
 
 
-def test_start_stop_produces_file_path_in_report(mock_cv2, tmp_path):
+def test_start_stop_produces_file_path_in_report(mock_av, tmp_path):
     from syncfield.adapters.uvc_webcam import UVCWebcamStream
+
     stream = UVCWebcamStream("cam", device_index=0, output_dir=tmp_path)
     stream.prepare()
     stream.start(_clock())
-    # Let the background thread read the mocked frames
-    time.sleep(0.1)
+    time.sleep(0.1)  # let the background thread drain the decode iterator
     report = stream.stop()
     assert report.status == "completed"
     assert report.file_path is not None
     assert report.frame_count >= 1
 
 
-def test_cv2_missing_raises_clear_install_hint(monkeypatch):
-    monkeypatch.setitem(sys.modules, "cv2", None)
+def test_av_missing_raises_clear_install_hint(monkeypatch):
+    """If PyAV is not installed, importing the video-encoder module
+    (and transitively the UVC adapter) raises a hint mentioning the
+    ``syncfield[uvc]`` extra.
+    """
+    monkeypatch.setitem(sys.modules, "av", None)
+    sys.modules.pop("syncfield.adapters._video_encoder", None)
     sys.modules.pop("syncfield.adapters.uvc_webcam", None)
+    import syncfield.adapters as _adapters_pkg
+    monkeypatch.delattr(_adapters_pkg, "_video_encoder", raising=False)
+    monkeypatch.delattr(_adapters_pkg, "uvc_webcam", raising=False)
     with pytest.raises(ImportError, match=r"syncfield\[uvc\]"):
         importlib.import_module("syncfield.adapters.uvc_webcam")
 
@@ -110,31 +190,19 @@ def test_cv2_missing_raises_clear_install_hint(monkeypatch):
 # ---------------------------------------------------------------------------
 
 
-@pytest.fixture
-def mock_cv2_generous(monkeypatch):
-    """Like ``mock_cv2`` but with a large frame budget so the capture
-    thread can run through a preview phase AND a recording phase
-    without exhausting the mocked ``read()`` side-effect.
-    """
-    fake = _build_fake_cv2(frame_budget=10_000)
-    monkeypatch.setitem(sys.modules, "cv2", fake)
-    sys.modules.pop("syncfield.adapters.uvc_webcam", None)
-    importlib.import_module("syncfield.adapters.uvc_webcam")
-    yield fake
-    sys.modules.pop("syncfield.adapters.uvc_webcam", None)
-
-
 class TestFourPhaseLifecycle:
     """UVCWebcamStream must support live preview in CONNECTED state.
 
     The 4-phase lifecycle is what the viewer uses: ``connect()`` runs
     the capture thread in preview-only mode so ``latest_frame``
     populates before the user clicks Record; ``start_recording()``
-    then flips the recording flag and opens the writer without
+    then flips the recording flag and opens the encoder without
     respawning the thread.
     """
 
-    def test_connect_starts_preview_without_writing(self, mock_cv2_generous, tmp_path):
+    def test_connect_starts_preview_without_writing(
+        self, mock_av_generous, tmp_path
+    ):
         from syncfield.adapters.uvc_webcam import UVCWebcamStream
 
         stream = UVCWebcamStream("cam", device_index=0, output_dir=tmp_path)
@@ -142,8 +210,8 @@ def test_connect_starts_preview_without_writing(self, mock_cv2_generous, tmp_pat
         stream.connect()
         time.sleep(0.1)  # let the thread read a few mocked frames
         try:
-            # Writer was never constructed — preview phase doesn't write.
-            assert stream._writer is None  # noqa: SLF001
+            # Encoder was never constructed — preview phase doesn't write.
+            assert stream._encoder is None  # noqa: SLF001
             # No SampleEvent emissions, no advanced frame counter.
             assert stream._frame_count == 0  # noqa: SLF001
             # But latest_frame IS populated so the viewer card can
@@ -152,7 +220,7 @@ def test_connect_starts_preview_without_writing(self, mock_cv2_generous, tmp_pat
         finally:
             stream.disconnect()
 
-    def test_start_recording_flips_to_writing(self, mock_cv2_generous, tmp_path):
+    def test_start_recording_flips_to_writing(self, mock_av_generous, tmp_path):
         from syncfield.adapters.uvc_webcam import UVCWebcamStream
 
         stream = UVCWebcamStream("cam", device_index=0, output_dir=tmp_path)
@@ -173,10 +241,12 @@ def test_start_recording_flips_to_writing(self, mock_cv2_generous, tmp_path):
             # is still alive so the preview continues.
             assert stream._thread is not None  # noqa: SLF001
             assert stream._thread.is_alive()  # noqa: SLF001
+            # Encoder stream was actually called to encode at least once.
+            assert mock_av_generous.output_stream.encode.called
         finally:
             stream.disconnect()
 
-    def test_disconnect_stops_capture_thread(self, mock_cv2_generous, tmp_path):
+    def test_disconnect_stops_capture_thread(self, mock_av_generous, tmp_path):
         from syncfield.adapters.uvc_webcam import UVCWebcamStream
 
         stream = UVCWebcamStream("cam", device_index=0, output_dir=tmp_path)
@@ -184,10 +254,9 @@ def test_disconnect_stops_capture_thread(self, mock_cv2_generous, tmp_path):
         stream.connect()
         time.sleep(0.05)
         stream.disconnect()
-        # Thread handle is cleared and the OS thread has joined.
         assert stream._thread is None  # noqa: SLF001
 
-    def test_connect_is_idempotent(self, mock_cv2_generous, tmp_path):
+    def test_connect_is_idempotent(self, mock_av_generous, tmp_path):
         """Calling connect() twice must not spawn a second thread."""
         from syncfield.adapters.uvc_webcam import UVCWebcamStream
 

From ee109db3f4039cbfeae73463c5334dbf6d0465f7 Mon Sep 17 00:00:00 2001
From: styu12 <styu12@naver.com>
Date: Mon, 13 Apr 2026 15:49:29 -0700
Subject: [PATCH 10/18] test(adapters): DRY mock_av fixtures and tighten
 frame_count assertion

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 tests/unit/adapters/test_uvc_webcam.py | 81 +++++++++++++-------------
 1 file changed, 41 insertions(+), 40 deletions(-)

diff --git a/tests/unit/adapters/test_uvc_webcam.py b/tests/unit/adapters/test_uvc_webcam.py
index f82d2e4..5d24dbd 100644
--- a/tests/unit/adapters/test_uvc_webcam.py
+++ b/tests/unit/adapters/test_uvc_webcam.py
@@ -74,58 +74,56 @@ def _av_open(url, *args, **kwargs):  # noqa: ANN001 - MagicMock signature
     return av, input_container, output_stream
 
 
-@pytest.fixture
-def mock_av(monkeypatch):
-    """Patch ``sys.modules['av']`` with a fake and force-reimport the encoder."""
-    av, input_container, output_stream = _build_fake_av(frame_budget=3)
+def _install_fake_av(
+    monkeypatch, *, frame_budget: int, pace_seconds: float
+) -> SimpleNamespace:
+    """Install a fake ``av`` module, clear cached imports, and return the handle."""
+    av, input_container, output_stream = _build_fake_av(
+        frame_budget=frame_budget, pace_seconds=pace_seconds
+    )
     monkeypatch.setitem(sys.modules, "av", av)
-    # Clear cached imports so the adapter and encoder bind to the fake av.
-    sys.modules.pop("syncfield.adapters._video_encoder", None)
-    sys.modules.pop("syncfield.adapters.uvc_webcam", None)
-    # Drop parent-package cached attribute so ``from syncfield.adapters import _video_encoder`` reloads.
+    for mod in ("syncfield.adapters._video_encoder", "syncfield.adapters.uvc_webcam"):
+        sys.modules.pop(mod, None)
     import syncfield.adapters as _adapters_pkg
-    monkeypatch.delattr(_adapters_pkg, "_video_encoder", raising=False)
-    monkeypatch.delattr(_adapters_pkg, "uvc_webcam", raising=False)
-
+    for attr in ("_video_encoder", "uvc_webcam"):
+        monkeypatch.delattr(_adapters_pkg, attr, raising=False)
     importlib.import_module("syncfield.adapters._video_encoder")
     importlib.import_module("syncfield.adapters.uvc_webcam")
-    yield SimpleNamespace(
+    return SimpleNamespace(
         av=av,
         input_container=input_container,
         output_stream=output_stream,
     )
-    sys.modules.pop("syncfield.adapters.uvc_webcam", None)
-    sys.modules.pop("syncfield.adapters._video_encoder", None)
+
+
+def _evict_adapter_imports() -> None:
+    """Teardown helper — pop both adapter modules so the next test rebinds."""
+    for mod in ("syncfield.adapters.uvc_webcam", "syncfield.adapters._video_encoder"):
+        sys.modules.pop(mod, None)
+
+
+@pytest.fixture
+def mock_av(monkeypatch):
+    handle = _install_fake_av(monkeypatch, frame_budget=3, pace_seconds=0.0)
+    yield handle
+    _evict_adapter_imports()
 
 
 @pytest.fixture
 def mock_av_generous(monkeypatch):
-    """Same as ``mock_av`` but yields effectively unlimited frames so the
-    capture thread can run through both preview and recording phases
-    without exhausting the mocked ``decode()`` iterator.
+    """Like ``mock_av`` but paces the decode iterator (1 ms/frame) so the
+    capture thread stays alive across ``time.sleep()`` windows in the
+    4-phase lifecycle tests.
+
+    TODO(test-harness): ``pace_seconds`` is a pragmatic wall-clock
+    workaround. A deterministic ``threading.Event``-driven pump would
+    remove the wall-clock dependency entirely. Deferred because the
+    current pacing is stable and the OAK tests (Task 7) can inherit
+    the same pattern safely — revisit if CI flakes appear.
     """
-    # Pace the generator so the background thread doesn't exhaust the
-    # iterator during the test's ``time.sleep(...)`` windows — without
-    # pacing, 10_000 MagicMock frames complete in microseconds and the
-    # capture thread exits before ``start_recording()`` is called.
-    av, input_container, output_stream = _build_fake_av(
-        frame_budget=10_000, pace_seconds=0.001
-    )
-    monkeypatch.setitem(sys.modules, "av", av)
-    sys.modules.pop("syncfield.adapters._video_encoder", None)
-    sys.modules.pop("syncfield.adapters.uvc_webcam", None)
-    import syncfield.adapters as _adapters_pkg
-    monkeypatch.delattr(_adapters_pkg, "_video_encoder", raising=False)
-    monkeypatch.delattr(_adapters_pkg, "uvc_webcam", raising=False)
-    importlib.import_module("syncfield.adapters._video_encoder")
-    importlib.import_module("syncfield.adapters.uvc_webcam")
-    yield SimpleNamespace(
-        av=av,
-        input_container=input_container,
-        output_stream=output_stream,
-    )
-    sys.modules.pop("syncfield.adapters.uvc_webcam", None)
-    sys.modules.pop("syncfield.adapters._video_encoder", None)
+    handle = _install_fake_av(monkeypatch, frame_budget=10_000, pace_seconds=0.001)
+    yield handle
+    _evict_adapter_imports()
 
 
 # ---------------------------------------------------------------------------
@@ -235,7 +233,10 @@ def test_start_recording_flips_to_writing(self, mock_av_generous, tmp_path):
         report = stream.stop_recording()
         try:
             assert frames_before == 0  # preview didn't advance the counter
-            assert report.frame_count >= 1  # recording did
+            # With pace_seconds=0.001 and 0.1s recording window we expect roughly
+            # ~100 frames. Assert a lower bound that's meaningful (>5) but a loose
+            # upper bound that tolerates CI jitter.
+            assert 5 <= report.frame_count <= 10_000
             assert report.file_path is not None
             # Stream stays connected after stop_recording — the thread
             # is still alive so the preview continues.

From 6ca6ea52eeafd573ebd76329247006c838433f32 Mon Sep 17 00:00:00 2001
From: styu12 <styu12@naver.com>
Date: Mon, 13 Apr 2026 15:52:14 -0700
Subject: [PATCH 11/18] refactor(adapters): swap cv2.VideoWriter for
 VideoEncoder in OAK

- Remove cv2 import block
- Use shared VideoEncoder.open() instead of cv2.VideoWriter
- Reset per-recording counters on start_recording (same as UVC)
- .release() -> .close() in _release_writers
- DepthAI capture path and depth .bin write unchanged
- OAK tests now fail on cv2 mock; Task 7 migrates them

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 src/syncfield/adapters/oak_camera.py | 41 +++++++++++++++-------------
 1 file changed, 22 insertions(+), 19 deletions(-)

diff --git a/src/syncfield/adapters/oak_camera.py b/src/syncfield/adapters/oak_camera.py
index d9269a7..c598435 100644
--- a/src/syncfield/adapters/oak_camera.py
+++ b/src/syncfield/adapters/oak_camera.py
@@ -2,15 +2,15 @@
 
 Supports OAK-1, OAK-D, OAK-D Lite, OAK-D S2 and related devices through the
 DepthAI v3 pipeline API. The adapter captures RGB frames to an MP4 file via
-``cv2.VideoWriter`` and, when ``depth_enabled=True``, also writes a raw uint16
-depth stream (little-endian, millimeters) to a sibling ``.depth.bin`` file.
+the shared :class:`~syncfield.adapters._video_encoder.VideoEncoder` (PyAV)
+and, when ``depth_enabled=True``, also writes a raw uint16 depth stream
+(little-endian, millimeters) to a sibling ``.depth.bin`` file.
 
-Requires two optional extras:
+Requires the ``oak`` optional extra:
 
     pip install syncfield[oak]     # depthai
-    pip install syncfield[uvc]     # opencv-python for the MP4 writer
 
-Both extras are available together via ``syncfield[all]``.
+The ``VideoEncoder`` dependency (PyAV) ships with the base package.
 
 Lifecycle
 ---------
@@ -60,13 +60,7 @@
         "Install with `pip install syncfield[oak]`."
     ) from exc
 
-try:
-    import cv2  # type: ignore[import-not-found]
-except ImportError as exc:  # pragma: no cover - exercised via sys.modules patch
-    raise ImportError(
-        "OakCameraStream also requires opencv-python for the MP4 writer. "
-        "Install with `pip install syncfield[uvc]`."
-    ) from exc
+from syncfield.adapters._video_encoder import VideoEncoder
 
 from syncfield.clock import SessionClock
 from syncfield.stream import StreamBase
@@ -146,7 +140,7 @@ def __init__(
         # Recording state.
         self._mp4_path = self._output_dir / f"{id}.mp4"
         self._depth_path = self._output_dir / f"{id}.depth.bin"
-        self._video_writer: Any = None
+        self._video_writer: Optional[VideoEncoder] = None
         self._depth_file: Any = None
         self._thread: Optional[threading.Thread] = None
         self._stop_event = threading.Event()
@@ -294,7 +288,7 @@ def start_recording(self, session_clock: SessionClock) -> None:
         """Open output files and flip the recording flag.
 
         The capture thread is already running from :meth:`connect`, so
-        this is a :class:`cv2.VideoWriter` construction plus a boolean
+        this is a :class:`VideoEncoder` construction plus a boolean
         flip — fast enough to run atomically across every stream in
         the orchestrator's start phase.
 
@@ -306,10 +300,19 @@ def start_recording(self, session_clock: SessionClock) -> None:
             self.connect()
         self._output_dir.mkdir(parents=True, exist_ok=True)
 
+        # Reset per-recording counters so a second recording in the same
+        # session starts clean.
+        self._frame_count = 0
+        self._depth_frame_count = 0
+        self._first_at = None
+        self._last_at = None
+
         width, height = self._rgb_resolution
-        fourcc = cv2.VideoWriter_fourcc(*"mp4v")
-        self._video_writer = cv2.VideoWriter(
-            str(self._mp4_path), fourcc, float(self._rgb_fps), (width, height)
+        self._video_writer = VideoEncoder.open(
+            self._mp4_path,
+            width=width,
+            height=height,
+            fps=float(self._rgb_fps),
         )
         if self._depth_enabled:
             self._depth_file = open(self._depth_path, "wb")
@@ -425,7 +428,7 @@ def _capture_loop(self) -> None:
           ``SampleEvent``. The capture runs continuously from the
           moment :meth:`connect` spawned this thread.
         * **Recording** (``_recording == True``) — same preview
-          publish, plus write to the ``VideoWriter``, advance
+          publish, plus write to the ``VideoEncoder``, advance
           ``_frame_count``, drain a depth tick, and emit
           ``SampleEvent``. The capture timestamp is sampled
           *immediately* after ``queue.get()`` so the jitter between
@@ -497,7 +500,7 @@ def _drain_depth_tick(self) -> None:
     def _release_writers(self) -> None:
         if self._video_writer is not None:
             try:
-                self._video_writer.release()
+                self._video_writer.close()
             except Exception:
                 pass
             self._video_writer = None

From 70713158a9036411d306c212e5b1f2614a0d11a0 Mon Sep 17 00:00:00 2001
From: styu12 <styu12@naver.com>
Date: Mon, 13 Apr 2026 15:58:35 -0700
Subject: [PATCH 12/18] test(adapters): hoist mock_av to conftest and migrate
 OAK tests

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 tests/unit/adapters/conftest.py        | 132 +++++++++++++++++++++++++
 tests/unit/adapters/test_oak_camera.py |  65 +++++++-----
 tests/unit/adapters/test_uvc_webcam.py | 110 ---------------------
 3 files changed, 173 insertions(+), 134 deletions(-)
 create mode 100644 tests/unit/adapters/conftest.py

diff --git a/tests/unit/adapters/conftest.py b/tests/unit/adapters/conftest.py
new file mode 100644
index 0000000..9785b83
--- /dev/null
+++ b/tests/unit/adapters/conftest.py
@@ -0,0 +1,132 @@
+"""Shared fixtures for adapter tests.
+
+Hoisted from ``test_uvc_webcam.py`` so both UVC and OAK tests can
+patch ``av`` with the same fake module.
+"""
+
+from __future__ import annotations
+
+import importlib
+import sys
+import time
+from types import SimpleNamespace
+from unittest.mock import MagicMock
+
+import numpy as np
+import pytest
+
+
+def _make_frame(i: int) -> MagicMock:
+    """Build a fake PyAV VideoFrame whose ``to_ndarray`` returns BGR24."""
+    frame = MagicMock(name=f"Frame-{i}")
+    frame.to_ndarray = MagicMock(
+        return_value=np.full((48, 64, 3), i % 256, dtype=np.uint8)
+    )
+    return frame
+
+
+def _build_fake_av(
+    *, frame_budget: int, pace_seconds: float
+) -> tuple[SimpleNamespace, MagicMock, MagicMock]:
+    """Build a fake ``av`` module.
+
+    Returns ``(av, input_container, output_stream)``. The input container's
+    ``decode(video=0)`` yields ``frame_budget`` fake frames, optionally
+    paced by ``pace_seconds`` between yields so the capture thread stays
+    alive across ``time.sleep()`` windows in lifecycle tests.
+    """
+    def _paced_frames():
+        for i in range(frame_budget):
+            if pace_seconds > 0:
+                time.sleep(pace_seconds)
+            yield _make_frame(i)
+
+    input_container = MagicMock(name="InputContainer")
+    input_container.decode = MagicMock(return_value=_paced_frames())
+
+    output_stream = MagicMock(name="VideoStream")
+    packet = MagicMock(name="Packet")
+    output_stream.encode = MagicMock(
+        side_effect=lambda frame: [packet] if frame is not None else []
+    )
+    output_container = MagicMock(name="OutputContainer")
+    output_container.add_stream = MagicMock(return_value=output_stream)
+
+    def _av_open(url, *args, **kwargs):  # noqa: ANN001 - MagicMock signature
+        if kwargs.get("mode") == "w":
+            return output_container
+        return input_container
+
+    av = SimpleNamespace()
+    av.open = MagicMock(side_effect=_av_open)
+    av.VideoFrame = SimpleNamespace(
+        from_ndarray=MagicMock(return_value=MagicMock(name="OutFrame"))
+    )
+    av.codec = SimpleNamespace(
+        Codec=MagicMock(side_effect=lambda n, m: SimpleNamespace(name=n))
+    )
+    return av, input_container, output_stream
+
+
+# Modules that cache ``av`` at import time. When we swap a fake ``av``
+# into ``sys.modules`` we must also force these to reload.
+_AV_DEPENDENT_MODULES = (
+    "syncfield.adapters._video_encoder",
+    "syncfield.adapters.uvc_webcam",
+    "syncfield.adapters.oak_camera",
+)
+
+
+def _install_fake_av(
+    monkeypatch, *, frame_budget: int, pace_seconds: float
+) -> SimpleNamespace:
+    """Install a fake ``av`` module, evict cached imports, reimport adapters."""
+    av, input_container, output_stream = _build_fake_av(
+        frame_budget=frame_budget, pace_seconds=pace_seconds
+    )
+    monkeypatch.setitem(sys.modules, "av", av)
+    for mod in _AV_DEPENDENT_MODULES:
+        sys.modules.pop(mod, None)
+    import syncfield.adapters as _adapters_pkg
+    # Remove parent-package attribute cache so the next ``from syncfield.adapters
+    # import _video_encoder`` re-resolves and binds to the fake ``av``.
+    for attr in ("_video_encoder", "uvc_webcam", "oak_camera"):
+        monkeypatch.delattr(_adapters_pkg, attr, raising=False)
+    importlib.import_module("syncfield.adapters._video_encoder")
+    return SimpleNamespace(
+        av=av,
+        input_container=input_container,
+        output_stream=output_stream,
+    )
+
+
+def _evict_av_dependent_imports() -> None:
+    for mod in _AV_DEPENDENT_MODULES:
+        sys.modules.pop(mod, None)
+
+
+@pytest.fixture
+def mock_av(monkeypatch):
+    """Plain fake ``av`` — short decode budget, no pacing.
+
+    Suitable for tests that don't rely on the capture thread staying
+    alive across a ``time.sleep()`` window.
+    """
+    handle = _install_fake_av(monkeypatch, frame_budget=3, pace_seconds=0.0)
+    yield handle
+    _evict_av_dependent_imports()
+
+
+@pytest.fixture
+def mock_av_generous(monkeypatch):
+    """Paced fake ``av`` — 10k frame budget + 1 ms between yields.
+
+    TODO(test-harness): ``pace_seconds`` is a pragmatic wall-clock
+    workaround. A deterministic ``threading.Event``-driven pump would
+    eliminate the wall-clock dependency. Revisit if CI flakes appear.
+    """
+    handle = _install_fake_av(
+        monkeypatch, frame_budget=10_000, pace_seconds=0.001
+    )
+    yield handle
+    _evict_av_dependent_imports()
diff --git a/tests/unit/adapters/test_oak_camera.py b/tests/unit/adapters/test_oak_camera.py
index ca05528..4fc5f6b 100644
--- a/tests/unit/adapters/test_oak_camera.py
+++ b/tests/unit/adapters/test_oak_camera.py
@@ -7,6 +7,7 @@
 import time
 from unittest.mock import MagicMock
 
+import numpy as np
 import pytest
 
 from syncfield.clock import SessionClock
@@ -36,10 +37,11 @@ def _build_fake_depthai() -> MagicMock:
     # --- Fake frame object with numpy-shaped data ------------------------
     class _FakeFrame:
         def __init__(self) -> None:
-            self._cv_frame = MagicMock()
-            self._cv_frame.shape = (1080, 1920, 3)
+            # Real BGR ndarray so the real VideoEncoder.write() path
+            # (via av.VideoFrame.from_ndarray) accepts it cleanly.
+            self._cv_frame = np.zeros((1080, 1920, 3), dtype=np.uint8)
 
-        def getCvFrame(self) -> MagicMock:
+        def getCvFrame(self) -> np.ndarray:
             return self._cv_frame
 
     # --- Fake output queue: unlimited stream of frames ------------------
@@ -86,22 +88,21 @@ def fake_get(timeout: float = 0.1) -> _FakeFrame:
 
 @pytest.fixture
 def mock_depthai(monkeypatch):
+    """Patch ``sys.modules['depthai']`` with a fake pipeline.
+
+    OAK tests that exercise the recording path must also inject
+    ``mock_av_generous`` (from ``conftest.py``) so the shared
+    ``VideoEncoder`` sees a fake ``av`` module.
+    """
     fake = _build_fake_depthai()
     monkeypatch.setitem(sys.modules, "depthai", fake)
-    # Also mock cv2 since the adapter uses it for the VideoWriter
-    fake_cv2 = MagicMock()
-    fake_cv2.VideoWriter_fourcc = lambda *args: 0
-    fake_cv2.VideoWriter.return_value = MagicMock()
-    monkeypatch.setitem(sys.modules, "cv2", fake_cv2)
-    # Force re-import so the adapter binds to the fake modules
     sys.modules.pop("syncfield.adapters.oak_camera", None)
-    importlib.import_module("syncfield.adapters.oak_camera")
-    yield fake, fake_cv2
+    yield fake
     sys.modules.pop("syncfield.adapters.oak_camera", None)
 
 
 class TestCapabilities:
-    def test_capabilities(self, mock_depthai, tmp_path):
+    def test_capabilities(self, mock_depthai, mock_av_generous, tmp_path):
         from syncfield.adapters.oak_camera import OakCameraStream
 
         stream = OakCameraStream("oak", output_dir=tmp_path)
@@ -120,8 +121,10 @@ class TestLifecycle:
     is pressed. These tests pin that split down.
     """
 
-    def test_connect_builds_and_starts_pipeline(self, mock_depthai, tmp_path):
-        fake, _ = mock_depthai
+    def test_connect_builds_and_starts_pipeline(
+        self, mock_depthai, mock_av_generous, tmp_path
+    ):
+        fake = mock_depthai
         from syncfield.adapters.oak_camera import OakCameraStream
 
         stream = OakCameraStream("oak", output_dir=tmp_path)
@@ -140,8 +143,10 @@ def test_connect_builds_and_starts_pipeline(self, mock_depthai, tmp_path):
         finally:
             stream.disconnect()
 
-    def test_connect_raises_when_no_devices(self, mock_depthai, tmp_path):
-        fake, _ = mock_depthai
+    def test_connect_raises_when_no_devices(
+        self, mock_depthai, mock_av_generous, tmp_path
+    ):
+        fake = mock_depthai
         fake.Device.getAllAvailableDevices.return_value = []
         from syncfield.adapters.oak_camera import OakCameraStream
 
@@ -150,7 +155,9 @@ def test_connect_raises_when_no_devices(self, mock_depthai, tmp_path):
         with pytest.raises(RuntimeError, match="No OAK devices"):
             stream.connect()
 
-    def test_full_lifecycle_produces_file_path(self, mock_depthai, tmp_path):
+    def test_full_lifecycle_produces_file_path(
+        self, mock_depthai, mock_av_generous, tmp_path
+    ):
         from syncfield.adapters.oak_camera import OakCameraStream
 
         stream = OakCameraStream("oak", output_dir=tmp_path)
@@ -166,8 +173,10 @@ def test_full_lifecycle_produces_file_path(self, mock_depthai, tmp_path):
         assert report.file_path is not None
         assert report.frame_count >= 1
 
-    def test_disconnect_releases_pipeline(self, mock_depthai, tmp_path):
-        fake, _ = mock_depthai
+    def test_disconnect_releases_pipeline(
+        self, mock_depthai, mock_av_generous, tmp_path
+    ):
+        fake = mock_depthai
         from syncfield.adapters.oak_camera import OakCameraStream
 
         stream = OakCameraStream("oak", output_dir=tmp_path)
@@ -179,7 +188,9 @@ def test_disconnect_releases_pipeline(self, mock_depthai, tmp_path):
         pipeline = fake.Pipeline.return_value
         assert pipeline.stop.called
 
-    def test_legacy_start_stop_still_works(self, mock_depthai, tmp_path):
+    def test_legacy_start_stop_still_works(
+        self, mock_depthai, mock_av_generous, tmp_path
+    ):
         """Old 0.1-era ``prepare() → start() → stop()`` path stays valid."""
         from syncfield.adapters.oak_camera import OakCameraStream
 
@@ -195,9 +206,11 @@ def test_legacy_start_stop_still_works(self, mock_depthai, tmp_path):
 
 
 class TestDepthOption:
-    def test_depth_enabled_declares_depth_output(self, mock_depthai, tmp_path):
+    def test_depth_enabled_declares_depth_output(
+        self, mock_depthai, mock_av_generous, tmp_path
+    ):
         """When depth_enabled=True the pipeline builds a StereoDepth node."""
-        fake, _ = mock_depthai
+        fake = mock_depthai
         from syncfield.adapters.oak_camera import OakCameraStream
 
         stream = OakCameraStream(
@@ -214,9 +227,11 @@ def test_depth_enabled_declares_depth_output(self, mock_depthai, tmp_path):
         finally:
             stream.disconnect()
 
-    def test_depth_disabled_by_default(self, mock_depthai, tmp_path):
+    def test_depth_disabled_by_default(
+        self, mock_depthai, mock_av_generous, tmp_path
+    ):
         """Default config builds only the RGB camera node."""
-        fake, _ = mock_depthai
+        fake = mock_depthai
         from syncfield.adapters.oak_camera import OakCameraStream
 
         stream = OakCameraStream("oak", output_dir=tmp_path)
@@ -233,5 +248,7 @@ class TestImportGuard:
     def test_depthai_missing_raises_clear_install_hint(self, monkeypatch):
         monkeypatch.setitem(sys.modules, "depthai", None)
         sys.modules.pop("syncfield.adapters.oak_camera", None)
+        import syncfield.adapters as _pkg
+        monkeypatch.delattr(_pkg, "oak_camera", raising=False)
         with pytest.raises(ImportError, match=r"syncfield\[oak\]"):
             importlib.import_module("syncfield.adapters.oak_camera")
diff --git a/tests/unit/adapters/test_uvc_webcam.py b/tests/unit/adapters/test_uvc_webcam.py
index 5d24dbd..20f6ab1 100644
--- a/tests/unit/adapters/test_uvc_webcam.py
+++ b/tests/unit/adapters/test_uvc_webcam.py
@@ -5,10 +5,7 @@
 import importlib
 import sys
 import time
-from types import SimpleNamespace
-from unittest.mock import MagicMock
 
-import numpy as np
 import pytest
 
 from syncfield.clock import SessionClock
@@ -19,113 +16,6 @@ def _clock() -> SessionClock:
     return SessionClock(sync_point=SyncPoint.create_now("h"))
 
 
-def _make_frame(i: int) -> MagicMock:
-    """Build a fake PyAV VideoFrame whose ``to_ndarray`` returns BGR24."""
-    frame = MagicMock(name=f"Frame-{i}")
-    frame.to_ndarray = MagicMock(
-        return_value=np.full((48, 64, 3), i % 256, dtype=np.uint8)
-    )
-    return frame
-
-
-def _build_fake_av(
-    frame_budget: int = 3, pace_seconds: float = 0.0
-) -> tuple[SimpleNamespace, MagicMock, MagicMock]:
-    """Build a fake ``av`` module and return (av, input_container, output_stream).
-
-    The input container's ``decode(video=0)`` yields ``frame_budget`` fake
-    frames then stops. When ``pace_seconds`` is > 0 the generator sleeps
-    between frames so the background capture thread doesn't exhaust the
-    iterator faster than the test can interact with the stream. The
-    output container's ``add_stream`` returns a stream whose ``encode``
-    yields one packet per call (empty list on flush with ``None``).
-    """
-
-    def _frame_gen():
-        for i in range(frame_budget):
-            if pace_seconds > 0:
-                time.sleep(pace_seconds)
-            yield _make_frame(i)
-
-    input_container = MagicMock(name="InputContainer")
-    input_container.decode = MagicMock(return_value=_frame_gen())
-
-    output_stream = MagicMock(name="VideoStream")
-    packet = MagicMock(name="Packet")
-    output_stream.encode = MagicMock(
-        side_effect=lambda frame: [packet] if frame is not None else []
-    )
-    output_container = MagicMock(name="OutputContainer")
-    output_container.add_stream = MagicMock(return_value=output_stream)
-
-    def _av_open(url, *args, **kwargs):  # noqa: ANN001 - MagicMock signature
-        if kwargs.get("mode") == "w":
-            return output_container
-        return input_container
-
-    av = SimpleNamespace()
-    av.open = MagicMock(side_effect=_av_open)
-    av.VideoFrame = SimpleNamespace(
-        from_ndarray=MagicMock(return_value=MagicMock(name="OutFrame"))
-    )
-    av.codec = SimpleNamespace(
-        Codec=MagicMock(side_effect=lambda n, m: SimpleNamespace(name=n))
-    )
-    return av, input_container, output_stream
-
-
-def _install_fake_av(
-    monkeypatch, *, frame_budget: int, pace_seconds: float
-) -> SimpleNamespace:
-    """Install a fake ``av`` module, clear cached imports, and return the handle."""
-    av, input_container, output_stream = _build_fake_av(
-        frame_budget=frame_budget, pace_seconds=pace_seconds
-    )
-    monkeypatch.setitem(sys.modules, "av", av)
-    for mod in ("syncfield.adapters._video_encoder", "syncfield.adapters.uvc_webcam"):
-        sys.modules.pop(mod, None)
-    import syncfield.adapters as _adapters_pkg
-    for attr in ("_video_encoder", "uvc_webcam"):
-        monkeypatch.delattr(_adapters_pkg, attr, raising=False)
-    importlib.import_module("syncfield.adapters._video_encoder")
-    importlib.import_module("syncfield.adapters.uvc_webcam")
-    return SimpleNamespace(
-        av=av,
-        input_container=input_container,
-        output_stream=output_stream,
-    )
-
-
-def _evict_adapter_imports() -> None:
-    """Teardown helper — pop both adapter modules so the next test rebinds."""
-    for mod in ("syncfield.adapters.uvc_webcam", "syncfield.adapters._video_encoder"):
-        sys.modules.pop(mod, None)
-
-
-@pytest.fixture
-def mock_av(monkeypatch):
-    handle = _install_fake_av(monkeypatch, frame_budget=3, pace_seconds=0.0)
-    yield handle
-    _evict_adapter_imports()
-
-
-@pytest.fixture
-def mock_av_generous(monkeypatch):
-    """Like ``mock_av`` but paces the decode iterator (1 ms/frame) so the
-    capture thread stays alive across ``time.sleep()`` windows in the
-    4-phase lifecycle tests.
-
-    TODO(test-harness): ``pace_seconds`` is a pragmatic wall-clock
-    workaround. A deterministic ``threading.Event``-driven pump would
-    remove the wall-clock dependency entirely. Deferred because the
-    current pacing is stable and the OAK tests (Task 7) can inherit
-    the same pattern safely — revisit if CI flakes appear.
-    """
-    handle = _install_fake_av(monkeypatch, frame_budget=10_000, pace_seconds=0.001)
-    yield handle
-    _evict_adapter_imports()
-
-
 # ---------------------------------------------------------------------------
 # Basic SPI coverage
 # ---------------------------------------------------------------------------

From 9960a51d311422a172dffddd3fde0b9b081a1d84 Mon Sep 17 00:00:00 2001
From: styu12 <styu12@naver.com>
Date: Mon, 13 Apr 2026 16:02:06 -0700
Subject: [PATCH 13/18] refactor(viewer): swap cv2.imencode for Pillow JPEG
 encoder

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 src/syncfield/viewer/server.py              | 14 +++++----
 tests/unit/viewer/test_cluster_endpoints.py | 32 ++++++---------------
 2 files changed, 17 insertions(+), 29 deletions(-)

diff --git a/src/syncfield/viewer/server.py b/src/syncfield/viewer/server.py
index 2e2ba52..8a0cab2 100644
--- a/src/syncfield/viewer/server.py
+++ b/src/syncfield/viewer/server.py
@@ -20,13 +20,14 @@
 
 import asyncio
 import dataclasses
+import io
 import json
 import logging
 import time
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Set
 
-import cv2
+from PIL import Image
 from fastapi import FastAPI, HTTPException, Request, WebSocket, WebSocketDisconnect
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import HTMLResponse, JSONResponse
@@ -1650,11 +1651,12 @@ async def _mjpeg_generator(self, stream_id: str):
                 stream = snapshot.streams.get(stream_id)
                 if stream is not None and stream.latest_frame is not None:
                     try:
-                        _, jpeg = cv2.imencode(
-                            ".jpg", stream.latest_frame,
-                            [cv2.IMWRITE_JPEG_QUALITY, 80],
-                        )
-                        frame_bytes = jpeg.tobytes()
+                        # BGR numpy → PIL Image (PIL expects RGB, so reverse the last axis).
+                        rgb = stream.latest_frame[:, :, ::-1]
+                        img = Image.fromarray(rgb)
+                        buf = io.BytesIO()
+                        img.save(buf, format="JPEG", quality=80)
+                        frame_bytes = buf.getvalue()
                         yield (
                             b"--frame\r\n"
                             b"Content-Type: image/jpeg\r\n"
diff --git a/tests/unit/viewer/test_cluster_endpoints.py b/tests/unit/viewer/test_cluster_endpoints.py
index 61a0eaf..c6df302 100644
--- a/tests/unit/viewer/test_cluster_endpoints.py
+++ b/tests/unit/viewer/test_cluster_endpoints.py
@@ -1,10 +1,9 @@
 """Tests for the multi-host cluster endpoints on the viewer server.
 
-The viewer's ``server.py`` imports ``cv2`` at module load time for
-MJPEG encoding — a dependency that isn't declared for the unit-test
-extra (it ships with the ``viewer`` optional extra). To keep these
-tests environment-agnostic we pre-register a stub ``cv2`` module in
-``sys.modules`` before importing the server, then dispatch the
+The viewer's ``server.py`` imports ``PIL`` at module load time for
+MJPEG encoding — a dependency that ships with the ``viewer`` optional
+extra. Since ``Pillow`` is widely available and present in the dev
+install, the real module is used; no stub is needed. We dispatch the
 cluster endpoints through FastAPI's :class:`TestClient` against a
 fake orchestrator. The test covers the acceptance criteria:
 
@@ -23,29 +22,16 @@
 
 from __future__ import annotations
 
-import sys
-import types
 from typing import Any, Dict, List, Optional
 
 import pytest
 
-# ---------------------------------------------------------------------------
-# cv2 stub must land in sys.modules BEFORE syncfield.viewer.server imports it.
-# ---------------------------------------------------------------------------
-
-if "cv2" not in sys.modules:
-    _cv2 = types.ModuleType("cv2")
-    _cv2.imencode = lambda *a, **kw: (True, b"")  # type: ignore[attr-defined]
-    _cv2.IMWRITE_JPEG_QUALITY = 1  # type: ignore[attr-defined]
-    sys.modules["cv2"] = _cv2
-
-
-from fastapi.testclient import TestClient  # noqa: E402
+from fastapi.testclient import TestClient
 
-from syncfield.multihost.types import SessionAnnouncement  # noqa: E402
-from syncfield.roles import FollowerRole, LeaderRole  # noqa: E402
-from syncfield.types import SessionState  # noqa: E402
-from syncfield.viewer.server import ViewerServer  # noqa: E402
+from syncfield.multihost.types import SessionAnnouncement
+from syncfield.roles import FollowerRole, LeaderRole
+from syncfield.types import SessionState
+from syncfield.viewer.server import ViewerServer
 
 
 # ---------------------------------------------------------------------------

From c27eb2fbd8ffb01893d18581712c988a92e6aafd Mon Sep 17 00:00:00 2001
From: styu12 <styu12@naver.com>
Date: Mon, 13 Apr 2026 16:05:56 -0700
Subject: [PATCH 14/18] chore: remove residual cv2/opencv references from
 docstrings and tests

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 src/syncfield/adapters/__init__.py            |  4 +--
 src/syncfield/discovery/types.py              |  2 +-
 src/syncfield/viewer/__init__.py              |  2 +-
 .../unit/adapters/test_discover_oak_camera.py |  4 ---
 .../unit/adapters/test_discover_uvc_webcam.py | 30 +++++--------------
 5 files changed, 12 insertions(+), 30 deletions(-)

diff --git a/src/syncfield/adapters/__init__.py b/src/syncfield/adapters/__init__.py
index dccd8ef..5b9ffeb 100644
--- a/src/syncfield/adapters/__init__.py
+++ b/src/syncfield/adapters/__init__.py
@@ -9,10 +9,10 @@
 Adapter                    Requires                               Install
 =========================  =====================================  =============================
 ``JSONLFileStream``        —                                      ``syncfield``
-``UVCWebcamStream``        ``opencv-python``                      ``syncfield[uvc]``
+``UVCWebcamStream``        ``av``                                 ``syncfield[uvc]``
 ``BLEImuGenericStream``    ``bleak``                              ``syncfield[ble]``
 ``OgloTactileStream``      ``bleak``                              ``syncfield[ble]``
-``OakCameraStream``        ``depthai`` + ``opencv-python``        ``syncfield[oak,uvc]``
+``OakCameraStream``        ``depthai`` + ``av``                   ``syncfield[oak]``
 =========================  =====================================  =============================
 
 Users who need a specific optional adapter can always import it directly
diff --git a/src/syncfield/discovery/types.py b/src/syncfield/discovery/types.py
index eccbf76..01846ab 100644
--- a/src/syncfield/discovery/types.py
+++ b/src/syncfield/discovery/types.py
@@ -49,7 +49,7 @@ class reference so :meth:`construct` needs no string → class
             speed, BLE address tail). Rendered in a muted color below the
             name in UIs.
         device_id: Stable identifier for this specific device —
-            ``cv2`` index, OAK serial, BLE MAC. Used for cache keys and
+            UVC device index, OAK serial, BLE MAC. Used for cache keys and
             user-facing copy like "already added".
         construct_kwargs: Keyword arguments for
             ``adapter_cls(**construct_kwargs, **caller_kwargs)``. Contains
diff --git a/src/syncfield/viewer/__init__.py b/src/syncfield/viewer/__init__.py
index 6443956..456a62b 100644
--- a/src/syncfield/viewer/__init__.py
+++ b/src/syncfield/viewer/__init__.py
@@ -26,7 +26,7 @@
 
     pip install 'syncfield[viewer]'
 
-which installs ``fastapi``, ``uvicorn``, and ``opencv-python``.
+which installs ``fastapi``, ``uvicorn``, ``av``, and ``Pillow``.
 """
 
 from __future__ import annotations
diff --git a/tests/unit/adapters/test_discover_oak_camera.py b/tests/unit/adapters/test_discover_oak_camera.py
index 4a37615..4d3f2f1 100644
--- a/tests/unit/adapters/test_discover_oak_camera.py
+++ b/tests/unit/adapters/test_discover_oak_camera.py
@@ -23,10 +23,6 @@ def mock_depthai(monkeypatch):
     fake.Device.getAllAvailableDevices.return_value = []
     monkeypatch.setitem(sys.modules, "depthai", fake)
 
-    fake_cv2 = MagicMock()
-    fake_cv2.VideoWriter_fourcc = lambda *a: 0
-    monkeypatch.setitem(sys.modules, "cv2", fake_cv2)
-
     sys.modules.pop("syncfield.adapters.oak_camera", None)
     importlib.import_module("syncfield.adapters.oak_camera")
     yield fake
diff --git a/tests/unit/adapters/test_discover_uvc_webcam.py b/tests/unit/adapters/test_discover_uvc_webcam.py
index 0ceb0fe..427eb29 100644
--- a/tests/unit/adapters/test_discover_uvc_webcam.py
+++ b/tests/unit/adapters/test_discover_uvc_webcam.py
@@ -7,7 +7,6 @@
 
 from __future__ import annotations
 
-import importlib
 import json
 import sys
 from pathlib import Path
@@ -16,21 +15,8 @@
 import pytest
 
 
-@pytest.fixture
-def mock_cv2(monkeypatch):
-    """Install a fake ``cv2`` so uvc_webcam.py imports cleanly."""
-    fake = MagicMock()
-    fake.VideoCapture.return_value = MagicMock(isOpened=lambda: True)
-    fake.VideoWriter_fourcc = lambda *a: 0
-    monkeypatch.setitem(sys.modules, "cv2", fake)
-    sys.modules.pop("syncfield.adapters.uvc_webcam", None)
-    importlib.import_module("syncfield.adapters.uvc_webcam")
-    yield fake
-    sys.modules.pop("syncfield.adapters.uvc_webcam", None)
-
-
 class TestMacosBranch:
-    def test_parses_system_profiler_output(self, mock_cv2):
+    def test_parses_system_profiler_output(self):
         from syncfield.adapters import uvc_webcam
         from syncfield.adapters.uvc_webcam import UVCWebcamStream
 
@@ -63,7 +49,7 @@ def test_parses_system_profiler_output(self, mock_cv2):
         assert devices[1].display_name == "Logitech Brio"
         assert devices[1].construct_kwargs == {"device_index": 1}
 
-    def test_missing_system_profiler_returns_empty(self, mock_cv2):
+    def test_missing_system_profiler_returns_empty(self):
         from syncfield.adapters.uvc_webcam import UVCWebcamStream
 
         with patch.object(sys, "platform", "darwin"), patch(
@@ -71,7 +57,7 @@ def test_missing_system_profiler_returns_empty(self, mock_cv2):
         ):
             assert UVCWebcamStream.discover() == []
 
-    def test_system_profiler_failure_returns_empty(self, mock_cv2):
+    def test_system_profiler_failure_returns_empty(self):
         from syncfield.adapters.uvc_webcam import UVCWebcamStream
 
         with patch.object(sys, "platform", "darwin"), patch(
@@ -80,7 +66,7 @@ def test_system_profiler_failure_returns_empty(self, mock_cv2):
         ):
             assert UVCWebcamStream.discover() == []
 
-    def test_malformed_json_returns_empty(self, mock_cv2):
+    def test_malformed_json_returns_empty(self):
         from syncfield.adapters.uvc_webcam import UVCWebcamStream
 
         with patch.object(sys, "platform", "darwin"), patch(
@@ -91,7 +77,7 @@ def test_malformed_json_returns_empty(self, mock_cv2):
 
 
 class TestLinuxBranch:
-    def test_enumerates_dev_video(self, mock_cv2, tmp_path):
+    def test_enumerates_dev_video(self, tmp_path):
         from syncfield.adapters import uvc_webcam
         from syncfield.adapters.uvc_webcam import UVCWebcamStream
 
@@ -146,7 +132,7 @@ def __new__(cls, *args, **kwargs):
         assert devices[0].display_name == "Integrated Camera"
         assert devices[0].construct_kwargs == {"device_index": 0}
 
-    def test_linux_without_dev_returns_empty(self, mock_cv2):
+    def test_linux_without_dev_returns_empty(self):
         from syncfield.adapters import uvc_webcam
 
         with patch.object(sys, "platform", "linux"), patch.object(
@@ -156,7 +142,7 @@ def test_linux_without_dev_returns_empty(self, mock_cv2):
 
 
 class TestFallbackBranch:
-    def test_unsupported_platform_returns_empty(self, mock_cv2):
+    def test_unsupported_platform_returns_empty(self):
         from syncfield.adapters.uvc_webcam import UVCWebcamStream
 
         with patch.object(sys, "platform", "win32"):
@@ -164,7 +150,7 @@ def test_unsupported_platform_returns_empty(self, mock_cv2):
 
 
 class TestClassAttributes:
-    def test_registry_hints_present(self, mock_cv2):
+    def test_registry_hints_present(self):
         from syncfield.adapters.uvc_webcam import UVCWebcamStream
 
         assert UVCWebcamStream._discovery_kind == "video"

From 179cc238f93deb37ef51ee2ea6fb2b6b73441201 Mon Sep 17 00:00:00 2001
From: styu12 <styu12@naver.com>
Date: Mon, 13 Apr 2026 16:07:11 -0700
Subject: [PATCH 15/18] docs(examples): update README references from cv2 to
 PyAV

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 examples/iphone_mac_webcam/README.md   | 8 ++++----
 examples/mac_iphone_dual_oak/README.md | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/examples/iphone_mac_webcam/README.md b/examples/iphone_mac_webcam/README.md
index 179aa57..dfb00e4 100644
--- a/examples/iphone_mac_webcam/README.md
+++ b/examples/iphone_mac_webcam/README.md
@@ -115,8 +115,8 @@ The `*.timestamps.jsonl` files plus `sync_point.json` are what the SyncField syn
 │  │ id = "mac_webcam"    │      │ id = "iphone"        │     │
 │  │ device_index = 0     │      │ device_index = 1     │     │
 │  │                      │      │                      │     │
-│  │ cv2.VideoCapture     │      │ cv2.VideoCapture     │     │
-│  │   → MP4 writer       │      │   → MP4 writer       │     │
+│  │ PyAV (avfoundation)  │      │ PyAV (avfoundation)  │     │
+│  │   → VideoEncoder     │      │   → VideoEncoder     │     │
 │  │   → timestamps JSONL │      │   → timestamps JSONL │     │
 │  │   → latest_frame     │      │   → latest_frame     │     │
 │  └──────────┬───────────┘      └──────────┬───────────┘     │
@@ -140,10 +140,10 @@ The orchestrator is configured with `SyncToneConfig.default()` (chirp enabled),
 | Symptom | Likely cause | Fix |
 |---|---|---|
 | Viewer opens but both previews are black | Wrong device indices | Run `python record.py --probe` and pass the correct indices |
-| `cv2.VideoCapture(1)` fails | iPhone not connected to Continuity Camera | Wake the iPhone, hold it near the Mac, check System Settings |
+| `av.open(…)` fails on iPhone index | iPhone not connected to Continuity Camera | Wake the iPhone, hold it near the Mac, check System Settings |
 | iPhone video is 720p instead of 1080p | macOS picked a lower-res stream profile | Try different `--width`/`--height` values; some iPhones cap Continuity at 1280×720 |
 | `ImportError: syncfield.viewer requires the 'viewer' extra` | Missing dev dep | `pip install "syncfield[viewer]"` |
-| `ImportError: UVCWebcamStream requires opencv-python` | Missing UVC extra | `pip install "syncfield[uvc]"` |
+| `ImportError: syncfield video adapters require PyAV` | Missing UVC extra | `pip install "syncfield[uvc]"` |
 | Recording stops after a few seconds | Continuity Camera dropped | Plug the iPhone into power; keep it awake; minimize Bluetooth contention |
 | Frame rate lower than requested | USB bandwidth contention | Lower `--fps`, or plug the webcam into a dedicated USB bus |
 
diff --git a/examples/mac_iphone_dual_oak/README.md b/examples/mac_iphone_dual_oak/README.md
index dd4cf2c..90dd341 100644
--- a/examples/mac_iphone_dual_oak/README.md
+++ b/examples/mac_iphone_dual_oak/README.md
@@ -199,7 +199,7 @@ They're **not** stable across a physical Myriad-X firmware reflash, which is rar
 | `RuntimeError: X_LINK_ALREADY_OPEN` | Device still held by a previous session | Wait ~10 s for the OAK to recycle, or replug |
 | Both previews freeze after ~1 s | Turned depth on for both OAKs on one bus | Run RGB-only (drop the `--*-depth` flags) or move one OAK to a separate bus |
 | `ImportError: depthai` | Missing OAK extra | `pip install "syncfield[oak]"` |
-| `ImportError: cv2` | Missing UVC extra | `pip install "syncfield[uvc]"` |
+| `ImportError: av` | Missing UVC extra | `pip install "syncfield[uvc]"` |
 | iPhone card stays blank | Continuity Camera dropped | Wake the iPhone, plug it into power, check System Settings → AirPlay & Handoff |
 | Health table shows `drop` events | USB bandwidth saturated | Lower resolution / FPS on one OAK, or split across USB buses |
 

From 06685f4b9744d8de87310f43e78591a647bb09ea Mon Sep 17 00:00:00 2001
From: styu12 <styu12@naver.com>
Date: Mon, 13 Apr 2026 16:10:59 -0700
Subject: [PATCH 16/18] feat(metrics): report jitter p95/p99 in
 FinalizationReport

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 src/syncfield/adapters/_video_encoder.py | 17 +++++++++++
 src/syncfield/adapters/oak_camera.py     | 15 +++++++++-
 src/syncfield/adapters/uvc_webcam.py     | 21 +++++++++++++-
 src/syncfield/types.py                   |  2 ++
 tests/unit/adapters/test_uvc_webcam.py   | 25 ++++++++++++++++
 tests/unit/test_finalization_jitter.py   | 37 ++++++++++++++++++++++++
 6 files changed, 115 insertions(+), 2 deletions(-)
 create mode 100644 tests/unit/test_finalization_jitter.py

diff --git a/src/syncfield/adapters/_video_encoder.py b/src/syncfield/adapters/_video_encoder.py
index 1bdd41c..df8b4f6 100644
--- a/src/syncfield/adapters/_video_encoder.py
+++ b/src/syncfield/adapters/_video_encoder.py
@@ -158,3 +158,20 @@ def open_uvc_input(
         raise RuntimeError(f"Unsupported platform for UVC input: {sys.platform}")
 
     return av.open(url, format=fmt, options=options)
+
+
+def compute_jitter_percentiles(
+    intervals_ns: list[int],
+) -> tuple[Optional[int], Optional[int]]:
+    """Return (p95, p99) of inter-frame intervals, or (None, None) if <20 samples.
+
+    At very small sample sizes percentile estimates are noisy and not
+    usefully actionable — better to leave them null than to emit a
+    misleading number.
+    """
+    if len(intervals_ns) < 20:
+        return None, None
+    sorted_iv = sorted(intervals_ns)
+    p95_idx = min(len(sorted_iv) - 1, int(len(sorted_iv) * 0.95))
+    p99_idx = min(len(sorted_iv) - 1, int(len(sorted_iv) * 0.99))
+    return sorted_iv[p95_idx], sorted_iv[p99_idx]
diff --git a/src/syncfield/adapters/oak_camera.py b/src/syncfield/adapters/oak_camera.py
index c598435..86823e1 100644
--- a/src/syncfield/adapters/oak_camera.py
+++ b/src/syncfield/adapters/oak_camera.py
@@ -60,7 +60,7 @@
         "Install with `pip install syncfield[oak]`."
     ) from exc
 
-from syncfield.adapters._video_encoder import VideoEncoder
+from syncfield.adapters._video_encoder import VideoEncoder, compute_jitter_percentiles
 
 from syncfield.clock import SessionClock
 from syncfield.stream import StreamBase
@@ -149,6 +149,11 @@ def __init__(
         self._first_at: Optional[int] = None
         self._last_at: Optional[int] = None
 
+        # Jitter collection: inter-frame intervals (ns) over the current
+        # recording window. Reset in start_recording().
+        self._prev_capture_ns: Optional[int] = None
+        self._intervals_ns: list[int] = []
+
         # True while the capture loop should write frames to disk and
         # emit ``SampleEvent``. ``connect()`` leaves this False so the
         # CONNECTED preview phase never touches the filesystem;
@@ -306,6 +311,8 @@ def start_recording(self, session_clock: SessionClock) -> None:
         self._depth_frame_count = 0
         self._first_at = None
         self._last_at = None
+        self._prev_capture_ns = None
+        self._intervals_ns = []
 
         width, height = self._rgb_resolution
         self._video_writer = VideoEncoder.open(
@@ -331,6 +338,7 @@ def stop_recording(self) -> FinalizationReport:
         self._recording = False
         self._release_writers()
 
+        jitter_p95, jitter_p99 = compute_jitter_percentiles(self._intervals_ns)
         return FinalizationReport(
             stream_id=self.id,
             status="completed",
@@ -340,6 +348,8 @@ def stop_recording(self) -> FinalizationReport:
             last_sample_at_ns=self._last_at,
             health_events=list(self._collected_health),
             error=None,
+            jitter_p95_ns=jitter_p95,
+            jitter_p99_ns=jitter_p99,
         )
 
     def disconnect(self) -> None:
@@ -443,6 +453,9 @@ def _capture_loop(self) -> None:
             capture_ns = time.monotonic_ns()
             if rgb_msg is None:
                 continue
+            if self._prev_capture_ns is not None:
+                self._intervals_ns.append(capture_ns - self._prev_capture_ns)
+            self._prev_capture_ns = capture_ns
 
             frame = rgb_msg.getCvFrame()
 
diff --git a/src/syncfield/adapters/uvc_webcam.py b/src/syncfield/adapters/uvc_webcam.py
index c979f5c..93487f2 100644
--- a/src/syncfield/adapters/uvc_webcam.py
+++ b/src/syncfield/adapters/uvc_webcam.py
@@ -38,7 +38,11 @@
 from pathlib import Path
 from typing import Any, Optional
 
-from syncfield.adapters._video_encoder import VideoEncoder, open_uvc_input
+from syncfield.adapters._video_encoder import (
+    VideoEncoder,
+    compute_jitter_percentiles,
+    open_uvc_input,
+)
 from syncfield.clock import SessionClock
 from syncfield.stream import DeviceKey, StreamBase
 from syncfield.types import (
@@ -106,6 +110,11 @@ def __init__(
         self._first_at: Optional[int] = None
         self._last_at: Optional[int] = None
 
+        # Jitter collection: inter-frame intervals (ns) over the current
+        # recording window. Reset in start_recording() / start().
+        self._prev_capture_ns: Optional[int] = None
+        self._intervals_ns: list[int] = []
+
         # True while the capture loop is writing frames and emitting
         # SampleEvents. ``connect()`` leaves this False so the preview
         # phase stays write-free; ``start_recording()`` flips it True.
@@ -160,6 +169,8 @@ def start_recording(self, session_clock: SessionClock) -> None:
         self._frame_count = 0
         self._first_at = None
         self._last_at = None
+        self._prev_capture_ns = None
+        self._intervals_ns = []
         self._encoder = VideoEncoder.open(
             self._file_path,
             width=self._width,
@@ -174,6 +185,7 @@ def stop_recording(self) -> FinalizationReport:
         if self._encoder is not None:
             self._encoder.close()
             self._encoder = None
+        jitter_p95, jitter_p99 = compute_jitter_percentiles(self._intervals_ns)
         return FinalizationReport(
             stream_id=self.id,
             status="completed",
@@ -183,6 +195,8 @@ def stop_recording(self) -> FinalizationReport:
             last_sample_at_ns=self._last_at,
             health_events=list(self._collected_health),
             error=None,
+            jitter_p95_ns=jitter_p95,
+            jitter_p99_ns=jitter_p99,
         )
 
     def disconnect(self) -> None:
@@ -205,6 +219,8 @@ def start(self, session_clock: SessionClock) -> None:
         self._frame_count = 0
         self._first_at = None
         self._last_at = None
+        self._prev_capture_ns = None
+        self._intervals_ns = []
         self._encoder = VideoEncoder.open(
             self._file_path,
             width=self._width,
@@ -243,6 +259,9 @@ def _capture_loop(self) -> None:
         try:
             for frame in self._input.decode(video=0):
                 capture_ns = time.monotonic_ns()
+                if self._prev_capture_ns is not None:
+                    self._intervals_ns.append(capture_ns - self._prev_capture_ns)
+                self._prev_capture_ns = capture_ns
                 if self._stop_event.is_set():
                     break
 
diff --git a/src/syncfield/types.py b/src/syncfield/types.py
index c062e6f..e836d49 100644
--- a/src/syncfield/types.py
+++ b/src/syncfield/types.py
@@ -297,6 +297,8 @@ class FinalizationReport:
     last_sample_at_ns: int | None
     health_events: list[HealthEvent]
     error: str | None
+    jitter_p95_ns: int | None = None
+    jitter_p99_ns: int | None = None
 
 
 @dataclass(frozen=True)
diff --git a/tests/unit/adapters/test_uvc_webcam.py b/tests/unit/adapters/test_uvc_webcam.py
index 20f6ab1..494eda7 100644
--- a/tests/unit/adapters/test_uvc_webcam.py
+++ b/tests/unit/adapters/test_uvc_webcam.py
@@ -160,3 +160,28 @@ def test_connect_is_idempotent(self, mock_av_generous, tmp_path):
             assert stream._thread is first_thread  # noqa: SLF001
         finally:
             stream.disconnect()
+
+    def test_jitter_reported_when_enough_frames(
+        self, mock_av_generous, tmp_path
+    ):
+        """After recording 20+ frames, jitter p95/p99 are populated."""
+        from syncfield.adapters.uvc_webcam import UVCWebcamStream
+
+        stream = UVCWebcamStream(
+            "cam", device_index=0, output_dir=tmp_path, fps=30.0
+        )
+        stream.prepare()
+        stream.connect()
+        stream.start_recording(_clock())
+        # Need enough recorded frames for the >=20 sample threshold.
+        # mock_av_generous paces at 1ms/frame, so 100ms should yield ~90.
+        time.sleep(0.15)
+        report = stream.stop_recording()
+        stream.disconnect()
+
+        assert report.jitter_p95_ns is not None
+        assert report.jitter_p99_ns is not None
+        assert report.jitter_p99_ns >= report.jitter_p95_ns
+        # Sanity: jitter should be on the order of pace_seconds (1ms = 1_000_000 ns)
+        # — allow generous bounds for CI load.
+        assert 0 < report.jitter_p95_ns < 100_000_000  # < 100ms
diff --git a/tests/unit/test_finalization_jitter.py b/tests/unit/test_finalization_jitter.py
new file mode 100644
index 0000000..99e32ed
--- /dev/null
+++ b/tests/unit/test_finalization_jitter.py
@@ -0,0 +1,37 @@
+"""Unit tests for FinalizationReport jitter fields."""
+
+from __future__ import annotations
+
+from syncfield.types import FinalizationReport
+
+
+def test_finalization_report_accepts_jitter_fields() -> None:
+    report = FinalizationReport(
+        stream_id="uvc0",
+        status="completed",
+        frame_count=100,
+        file_path=None,
+        first_sample_at_ns=0,
+        last_sample_at_ns=3_000_000_000,
+        health_events=[],
+        error=None,
+        jitter_p95_ns=2_500_000,
+        jitter_p99_ns=4_000_000,
+    )
+    assert report.jitter_p95_ns == 2_500_000
+    assert report.jitter_p99_ns == 4_000_000
+
+
+def test_finalization_report_jitter_defaults_none() -> None:
+    report = FinalizationReport(
+        stream_id="ble0",
+        status="completed",
+        frame_count=0,
+        file_path=None,
+        first_sample_at_ns=None,
+        last_sample_at_ns=None,
+        health_events=[],
+        error=None,
+    )
+    assert report.jitter_p95_ns is None
+    assert report.jitter_p99_ns is None

From 0362c4526b603c153ddd746753e742f32b51e177 Mon Sep 17 00:00:00 2001
From: styu12 <styu12@naver.com>
Date: Mon, 13 Apr 2026 16:12:42 -0700
Subject: [PATCH 17/18] docs: hardware smoke-test checklist for PyAV migration

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 ...3-opencv-to-pyav-migration-hw-smoketest.md | 118 ++++++++++++++++++
 1 file changed, 118 insertions(+)
 create mode 100644 docs/plans/2026-04-13-opencv-to-pyav-migration-hw-smoketest.md

diff --git a/docs/plans/2026-04-13-opencv-to-pyav-migration-hw-smoketest.md b/docs/plans/2026-04-13-opencv-to-pyav-migration-hw-smoketest.md
new file mode 100644
index 0000000..2439c7c
--- /dev/null
+++ b/docs/plans/2026-04-13-opencv-to-pyav-migration-hw-smoketest.md
@@ -0,0 +1,118 @@
+# PyAV Migration — Hardware Smoke Test
+
+Manual verification checklist for `feat/pyav-migration`. Run on a MacBook M3/M4 (Apple Silicon, macOS 14+) with real cameras attached.
+
+## 0. Prep
+
+```bash
+cd /Users/jerry/Documents/syncfield-python-pyav   # or wherever the worktree lives
+uv sync --all-extras
+uv run python -c "import av; print(av.codec.Codec('h264_videotoolbox', 'w').name)"
+```
+
+Expected last line: `h264_videotoolbox`. If it raises, VideoToolbox isn't visible to PyAV on this machine — the software encoder (`libx264`) will still work but the CPU savings below won't apply.
+
+## 1. UVC webcam at 720p
+
+Plug a FaceTime / Logitech / BRIO webcam. Run the example:
+
+```bash
+uv run python examples/iphone_mac_webcam/record.py --width 1280 --height 720 --fps 30 --duration 30
+```
+
+**Verify:**
+- The resulting `{id}.mp4` plays in QuickTime.
+- Resolution reported by `ffprobe -v error -select_streams v:0 -show_entries stream=width,height -of csv=p=0 {id}.mp4` is `1280,720`.
+- Frame count: roughly 900 ± 5 (30 fps × 30 s).
+- The session's `FinalizationReport` in the stdout summary shows `jitter_p95_ns` and `jitter_p99_ns` as non-null integers.
+
+## 2. VideoToolbox hardware encoder (CPU check)
+
+Re-run the 30-second capture from §1 while watching CPU usage:
+
+```bash
+# In another terminal:
+top -pid $(pgrep -f record.py)
+```
+
+**Expected:**
+- Python process CPU < 30 % throughout the recording (was > 80 % on the cv2 `mp4v` software encoder).
+- No fan ramp. No thermal throttling.
+
+If CPU is still > 80 %, PyAV fell back to `libx264` — double-check §0's VideoToolbox probe.
+
+## 3. Multi-stream capacity
+
+Run the multi-stream example (iPhone + Mac webcam simultaneously):
+
+```bash
+uv run python examples/iphone_mac_webcam/record.py --duration 30
+```
+
+**Expected:**
+- Both streams record without frame drops.
+- Each `FinalizationReport.frame_count` ≈ 900 ± 5.
+- Aggregate CPU remains reasonable (< 60 % for two 720p30 streams on M3 Pro).
+- Per-stream `jitter_p95_ns` is typically < 3 ms on an idle host; `jitter_p99_ns` < 6 ms. Log these numbers — they're the new baseline.
+
+## 4. OAK camera + depth
+
+With an OAK-D or OAK-D-Lite plugged in:
+
+```bash
+uv run python examples/mac_iphone_dual_oak/record.py --duration 30
+```
+
+**Verify:**
+- RGB `{id}.mp4` is valid and plays in QuickTime.
+- `{id}.depth.bin` size ≈ `depth_width × depth_height × 2 × frame_count` bytes (e.g., `640 × 400 × 2 × 900 ≈ 461 MB`).
+- No warnings about missing `cv2` or `opencv-python` anywhere in stdout.
+
+## 5. Viewer MJPEG preview
+
+Start the viewer example and open the browser tab:
+
+```bash
+uv run python examples/iphone_mac_webcam/run.py
+# Visit http://localhost:8000 in Safari / Chrome
+```
+
+**Verify:**
+- Each stream card shows a live thumbnail updating at ~30 fps.
+- Click Record → Stop → Record again. Second recording produces a fresh `FinalizationReport` with `frame_count` starting from 0 (confirms the counter-reset fix from Task 4 is working).
+- No cv2 errors anywhere in the server logs.
+
+## 6. Device disconnect produces a health event
+
+Start a recording, then unplug the webcam mid-session. Check the session log:
+
+```bash
+grep -i 'capture loop ended' logs/session_*.log
+```
+
+**Expected:** one `HealthEvent` entry with `kind="error"` and a `detail` like `"capture loop ended: ..."`. (This is the observability fix from Task 4 — silent disconnects are now a first-class signal.)
+
+## 7. Jitter report sanity
+
+Inspect the `FinalizationReport` JSON (or Python-repr in the CLI output) for any 30-second recording:
+
+```python
+{
+  "stream_id": "uvc_ego",
+  "status": "completed",
+  "frame_count": 900,
+  ...
+  "jitter_p95_ns": 2_734_112,    # ~2.7 ms
+  "jitter_p99_ns": 5_891_440     # ~5.9 ms
+}
+```
+
+**Expected on an idle M3 with 4 active streams:**
+- `jitter_p95_ns < 3_000_000` (3 ms)
+- `jitter_p99_ns < 6_000_000` (6 ms)
+
+If either metric is consistently higher, that's the signal described in the design discussion — time to revisit multi-process capture or the PTS-based timestamp path.
+
+## Sign-off
+
+All seven sections must pass before `feat/pyav-migration` merges to `main`. Capture the jitter p95/p99 numbers from §3 and §7 in the PR description — they become the ongoing baseline for the sync infrastructure.

From 94a33a2e15d61a2b0ba4b1cd93770a12b3df73b7 Mon Sep 17 00:00:00 2001
From: styu12 <styu12@naver.com>
Date: Mon, 13 Apr 2026 16:23:43 -0700
Subject: [PATCH 18/18] fix(adapters): gate jitter collection on _recording
 flag

Prevents two issues:
- Preview-phase intervals no longer poison p95/p99 on short recordings
- Capture thread no longer mutates _intervals_ns while stop_recording
  is iterating it via sorted() in compute_jitter_percentiles

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
---
 src/syncfield/adapters/oak_camera.py |  8 +++++---
 src/syncfield/adapters/uvc_webcam.py | 10 +++++++---
 src/syncfield/types.py               |  6 ++++++
 3 files changed, 18 insertions(+), 6 deletions(-)

diff --git a/src/syncfield/adapters/oak_camera.py b/src/syncfield/adapters/oak_camera.py
index 86823e1..45da8b4 100644
--- a/src/syncfield/adapters/oak_camera.py
+++ b/src/syncfield/adapters/oak_camera.py
@@ -453,9 +453,11 @@ def _capture_loop(self) -> None:
             capture_ns = time.monotonic_ns()
             if rgb_msg is None:
                 continue
-            if self._prev_capture_ns is not None:
-                self._intervals_ns.append(capture_ns - self._prev_capture_ns)
-            self._prev_capture_ns = capture_ns
+            # Recording-window-only jitter collection (see UVC adapter for rationale).
+            if self._recording:
+                if self._prev_capture_ns is not None:
+                    self._intervals_ns.append(capture_ns - self._prev_capture_ns)
+                self._prev_capture_ns = capture_ns
 
             frame = rgb_msg.getCvFrame()
 
diff --git a/src/syncfield/adapters/uvc_webcam.py b/src/syncfield/adapters/uvc_webcam.py
index 93487f2..06ea2dd 100644
--- a/src/syncfield/adapters/uvc_webcam.py
+++ b/src/syncfield/adapters/uvc_webcam.py
@@ -259,9 +259,13 @@ def _capture_loop(self) -> None:
         try:
             for frame in self._input.decode(video=0):
                 capture_ns = time.monotonic_ns()
-                if self._prev_capture_ns is not None:
-                    self._intervals_ns.append(capture_ns - self._prev_capture_ns)
-                self._prev_capture_ns = capture_ns
+                # Jitter collection runs only during the recording window so preview
+                # intervals don't pollute the report and so the capture thread never
+                # mutates the list while stop_recording() is reading it.
+                if self._recording:
+                    if self._prev_capture_ns is not None:
+                        self._intervals_ns.append(capture_ns - self._prev_capture_ns)
+                    self._prev_capture_ns = capture_ns
                 if self._stop_event.is_set():
                     break
 
diff --git a/src/syncfield/types.py b/src/syncfield/types.py
index e836d49..1e9b924 100644
--- a/src/syncfield/types.py
+++ b/src/syncfield/types.py
@@ -287,6 +287,12 @@ class FinalizationReport:
         last_sample_at_ns: Monotonic ns of last sample, or None if empty.
         health_events: Health events observed during recording.
         error: Error message if status is ``"failed"``.
+        jitter_p95_ns: 95th-percentile inter-frame interval (ns) during
+            the recording window. None if fewer than 20 samples were
+            collected, or for non-video streams.
+        jitter_p99_ns: 99th-percentile inter-frame interval (ns) during
+            the recording window. None if fewer than 20 samples were
+            collected.
     """
 
     stream_id: str