diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2be475c..b059512 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,35 @@ are tagged `vMAJOR.MINOR.PATCH` and published as
 
 ## [Unreleased]
 
+## [0.1.47] - 2026-09-15
+
+### Added
+- ISO feed selection: choose routed outputs, remember choices, and create files
+  only when selected feeds deliver media. TCP accepts `source_uuids`; OSC uses
+  saved panel selections. Empty selections no longer record every source.
+
+### Fixed
+- Each participant ISO is one continuous 1920x1080/30 H.264 MP4 with AAC audio.
+  Incoming resolution changes are scaled with aspect ratio preserved, without
+  splitting files. Duplicate output routes share the same participant recording.
+- ISO audio uses dedicated isolated participant subscriptions, independently of
+  the OBS source's Mix/Isolated setting, without changing Audience audio routing.
+- Participant workers hold video and fill silence through gaps. Startup timing,
+  full-range color, planar chroma, and batched audio timestamps are preserved.
+- Tiles retains valid pending pixels when a shared-memory read is rejected,
+  preventing a path that could flash incorrect colors during resolution changes.
+
+### Validation
+- Windows plugin/engine build and 72 native regressions pass. Real MP4 fixtures
+  cover eight concurrent NVENC tracks, changing resolutions/audio formats, gaps,
+  color preservation and flash/tone sync within 20 ms.
+- Alternating-speaker tests through routing, shared memory and MP4 encoding
+  confirm silence in each participant's file while the other speaker talks.
+- These are synthetic media checks; a live Zoom soak of the final isolated-audio
+  build has not been completed. Existing mixed recordings are not repaired.
+- Windows installer and ZIP include both updated plugin and engine. The signed
+  macOS installer still requires a separate build on the maintainer's Mac.
+
 ## [0.1.46] - 2026-09-14
 
 ### Fixed
diff --git a/CLAUDE.md b/CLAUDE.md
index c2f85d7..0b3e4a1 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -227,21 +227,27 @@ Every one of these is documented at length where it lives; the list is the map.
   interval rather than zeroing on fire -- zeroing discards the remainder
   that pushed a tick over threshold, which at 60 fps lands every 7 frames
   (~117 ms, ~8.6 Hz) instead of the documented 10 Hz.
-- **ISO recording timing** (`src/iso-video-pacer.h`, `src/iso-audio-gap-fill.h`):
-  raw video has no per-frame timestamps and ffmpeg cannot be trusted to
-  invent correct ones from a byte stream — `-use_wallclock_as_timestamps`
-  is confirmed (via `ffprobe -show_frames`, 2026-08-21) to have **no
-  effect** on this project's ffmpeg build's rawvideo demuxer, despite
-  looking like the textbook fix. `record_video_frame()` is called 1:1 with
-  Zoom's real, fluctuating (10-60fps) per-source delivery, so it must pace
-  itself to a fixed cadence (duplicate to backfill a stall, drop to shed a
-  burst) BEFORE the pipe — see `iso_video_frames_due()`. Audio has the
-  mirror-image problem for a different reason: Zoom only calls back audio
-  for someone currently talking, so `record_audio_frame()` must backfill
-  silence across every gap (`iso_audio_silence_frames()`) or the WAV
-  shrinks by every silent stretch. Both anchor to the same
-  `os_gettime_ns()` clock so video and audio stay in sync with each other,
-  not just individually correct.
+- **ISO participant A/V recording** (`src/iso-track-writer.cpp`,
+  `src/iso-av-mux.h`): one writer per Zoom participant ID owns a continuous
+  1920x1080/30 H.264 + 48 kHz stereo AAC MP4 until Stop. Source UUIDs and input
+  dimensions MUST NOT key writer lifetime. Workers scale/letterbox and resample,
+  hold video/fill silence against the same monotonic clock, and mux timestamped
+  raw media to one FFmpeg pipe. The input is full-range BT.709; preserve its
+  colour metadata. B-frames are disabled to avoid fragmented-MP4 startup A/V
+  offset. Keep startup video history while workers catch up: shrinking the
+  input queue on the first tick loses early frames. Validate decoded flash/tone
+  timing with `tests/verify-iso-av.py`, not only frame counts or process success.
+  ISO capture is explicitly selected by output source UUID (`source_uuids` in
+  TCP, saved panel choices for OSC). No default-all fallback. Do not pre-open
+  writers from configured participant IDs: selected routes open on first real
+  media delivery, so offline/unrouted sources produce no blank files. The feed
+  checklist updates rows by UUID and retains operator selections across refresh.
+  Audio MUST come from `IsoAudioTap`, not ZoomSource's embedded PCM (which may
+  be the meeting mix labelled with the route's participant ID). Audio-only IPC
+  subscriptions carry `recording_only=true`: receive one-way audio but never
+  claim a participant out of Audience routing. Install plugin AND engine for
+  this change. Each tap owns a fresh SHM reader, checks per-slot attribution,
+  preserves first buffers, and uses the recording epoch to reject stale callbacks.
 - **Colour range is normalised, never re-declared** (`src/i420-range-expand.h`,
   applied in `engine/src/engine-video.cpp`'s `onRawDataFrameReceived`): the
   engine requests `VideoRawdataColorspace_BT709_F` and the plugin declares
@@ -1574,6 +1580,16 @@ Home, download, and plugin docs point to `/download/#macos`.
 
 ## Media failure presentation (2026-09-06 soak)
 
+Tiles SHM reads must use `read_candidate`, never the pending `frame` directly.
+`shm_read_i420_frame` copies before validating its final sequence and can return
+Invalid with a modified destination. If `has_frame` was already true, reading
+into that frame published rejected pixels with the previous size/generation,
+causing a possible one-frame color flash during resolution changes. Commit only
+successful even-sized reads by swapping buffers (`zoom-tile-frame-read.h`).
+`CoreVideoTileFrameRead` injects rejected resized reads; it fails with the old
+direct-write behavior. Live diagnostics log `Tiles kept last valid frame` on
+the first rejected read and every 300 thereafter.
+
 `MediaFailureState` tracks current source media failures, bounded
 by live source assignments. Eight tiles × three failed attempts retain all
 24 raw error diagnostics but emit one nonmodal episode notice. Dock polling
diff --git a/CMakeLists.txt b/CMakeLists.txt
index d56d371..79eb96f 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -285,6 +285,9 @@ if(COREVIDEO_BUILD_PLUGIN)
         src/zoom-diagnostics-dialog.cpp
         src/zoom-output-profile.cpp
         src/zoom-iso-recorder.cpp
+        src/iso-track-writer.cpp
+        src/iso-audio-tap.cpp
+        src/iso-audio-reader.cpp
         src/iso-ffmpeg-pipe.cpp
         src/zoom-iso-panel.cpp
         src/zoom-dock.cpp
@@ -317,7 +320,7 @@ if(COREVIDEO_BUILD_PLUGIN)
     if(WIN32)
         # winmm: talkback-cue.cpp's PlaySound(SND_MEMORY | SND_ASYNC) call --
         # see that file's header comment for why it was chosen over WASAPI.
-        target_link_libraries(obs-zoom-plugin PRIVATE crypt32 winmm)
+        target_link_libraries(obs-zoom-plugin PRIVATE crypt32 winmm d3d11 d3dcompiler)
         add_executable(CoreVideoOAuthCallback src/oauth-callback-helper.cpp)
         target_link_libraries(CoreVideoOAuthCallback PRIVATE ws2_32 shell32 ole32)
         install(TARGETS CoreVideoOAuthCallback
@@ -651,9 +654,37 @@ if(BUILD_TESTING)
     target_include_directories(CoreVideoIsoRecordingTest PRIVATE
         "${CMAKE_CURRENT_SOURCE_DIR}/src")
 
+    if(COREVIDEO_BUILD_PLUGIN AND WIN32)
+        add_executable(CoreVideoIsoTrackWriterTest tests/iso-track-writer-test.cpp
+            src/iso-track-writer.cpp src/iso-ffmpeg-pipe.cpp)
+        target_include_directories(CoreVideoIsoTrackWriterTest PRIVATE src)
+        target_link_libraries(CoreVideoIsoTrackWriterTest PRIVATE OBS::libobs)
+        add_executable(CoreVideoIsoIsolatedRecordingTest tests/iso-isolated-recording-test.cpp
+            src/iso-track-writer.cpp src/iso-ffmpeg-pipe.cpp src/iso-audio-reader.cpp)
+        target_include_directories(CoreVideoIsoIsolatedRecordingTest PRIVATE src)
+        target_link_libraries(CoreVideoIsoIsolatedRecordingTest PRIVATE OBS::libobs d3d11 d3dcompiler)
+        target_compile_definitions(CoreVideoIsoIsolatedRecordingTest PRIVATE NOMINMAX WIN32_LEAN_AND_MEAN)
+        if(WIN32)
+            target_compile_definitions(CoreVideoIsoTrackWriterTest PRIVATE NOMINMAX WIN32_LEAN_AND_MEAN)
+            target_link_libraries(CoreVideoIsoTrackWriterTest PRIVATE d3d11 d3dcompiler)
+        endif()
+    endif()
+
     add_executable(CoreVideoIsoEncoderPlanTest
         tests/iso-encoder-plan-test.cpp
     )
+    add_executable(CoreVideoIsoProviderPolicyTest tests/iso-provider-policy-test.cpp)
+    add_executable(CoreVideoIsoFeedSelectionTest tests/iso-feed-selection-test.cpp)
+    add_executable(CoreVideoIsoAudioRoutingTest tests/iso-audio-routing-test.cpp)
+    add_executable(CoreVideoIsoAudioReaderTest tests/iso-audio-reader-test.cpp src/iso-audio-reader.cpp)
+    target_include_directories(CoreVideoIsoAudioReaderTest PRIVATE src)
+    add_test(NAME CoreVideoIsoAudioReader COMMAND CoreVideoIsoAudioReaderTest)
+    target_include_directories(CoreVideoIsoAudioRoutingTest PRIVATE src)
+    add_test(NAME CoreVideoIsoAudioRouting COMMAND CoreVideoIsoAudioRoutingTest)
+    target_include_directories(CoreVideoIsoFeedSelectionTest PRIVATE src)
+    add_test(NAME CoreVideoIsoFeedSelection COMMAND CoreVideoIsoFeedSelectionTest)
+    target_include_directories(CoreVideoIsoProviderPolicyTest PRIVATE src)
+    add_test(NAME CoreVideoIsoProviderPolicy COMMAND CoreVideoIsoProviderPolicyTest)
     target_include_directories(CoreVideoIsoEncoderPlanTest PRIVATE
         "${CMAKE_CURRENT_SOURCE_DIR}/src"
     )
@@ -915,6 +946,9 @@ if(BUILD_TESTING)
     add_executable(CoreVideoTileTextureTest
         tests/tile-texture-test.cpp
     )
+    add_executable(CoreVideoTileFrameReadTest tests/tile-frame-read-test.cpp)
+    target_include_directories(CoreVideoTileFrameReadTest PRIVATE src)
+    add_test(NAME CoreVideoTileFrameRead COMMAND CoreVideoTileFrameReadTest)
     target_include_directories(CoreVideoTileTextureTest PRIVATE
         "${CMAKE_CURRENT_SOURCE_DIR}/src"
     )
diff --git a/docs/CORE_PLUGIN_FUNCTIONALITY.md b/docs/CORE_PLUGIN_FUNCTIONALITY.md
index 6444168..edf4b9b 100644
--- a/docs/CORE_PLUGIN_FUNCTIONALITY.md
+++ b/docs/CORE_PLUGIN_FUNCTIONALITY.md
@@ -580,15 +580,24 @@ There are no Companion actions for talkback yet.
 
 ## Auto ISO Recording
 
-![CoreVideo ISO recording flow](images/iso-recording-flow.svg)
-
-ISO recording is controlled by the OBS plugin, not the engine. When enabled,
+ISO recording is controlled by the OBS plugin.
 On macOS, configure and test a working FFmpeg executable in **Zoom ISO Recorder**
 first; the package does not bundle FFmpeg.
 
-CoreVideo records one video file and one PCM WAV audio file per active source
-segment. A new segment starts when the resolved participant or source resolution
-changes.
+CoreVideo records one continuous MP4 per Zoom participant ID during Record/Stop.
+Each file contains H.264 video at 1920x1080, 30 fps and AAC stereo audio at 48 kHz.
+ISO audio comes from a dedicated one-way subscription for that participant,
+independent of the OBS source's Mix/Isolated setting. Recording subscriptions
+do not remove participants from the Audience mix. A muted/silent participant
+has silence in their MP4; other speakers are never substituted.
+Choose feeds in the ISO Recorder before starting. Choices are remembered by
+source UUID; no feeds are selected by default. Unrouted and unselected feeds do
+not start recordings. A selected feed opens its file only when its first actual
+audio or video arrives, so an offline route does not produce an empty recording.
+Incoming video is scaled to fit with black bars when needed. Zoom resolution
+changes, duplicate OBS sources, camera gaps, and source reassignment do not
+restart that participant's encoder or create another file. A new Zoom ID after
+a rejoin is treated as a new participant; display names are not identity keys.
 
 Requirements:
 
@@ -612,11 +621,13 @@ dock. The panel provides:
   requested encoder, actual encoder, and fallback state.
 - **Also start/stop OBS program recording** toggle.
 - **Start ISO Recording** and **Stop ISO Recording** buttons.
+- **Feeds to record** checkboxes, preserved through routing refreshes and OBS
+  restarts. Selection is fixed for the recording run; stop to change it.
 - Live status showing idle/recording and active session count.
 - Active session table with source, participant, resolution, video frame count,
-  audio chunk count, current video/audio file paths, and FFmpeg error details.
+  audio chunk count, combined file path, and FFmpeg error details.
 - Recently completed sessions remain in the table after stop so operators can
-  confirm completed MP4/WAV outputs before opening the folder.
+  confirm completed MP4 outputs before opening the folder.
 
 The panel uses the same `ZoomIsoRecorder` backend as the TCP and OSC APIs. It
 persists the output folder, FFmpeg path, and program-recording toggle in OBS
@@ -626,9 +637,14 @@ less than 2 GB free and warns below 10 GB free.
 TCP start example:
 
 ```json
-{"cmd":"iso_recording_start","output_dir":"C:/Recordings/CoreVideo","ffmpeg_path":"ffmpeg","record_program":true}
+{"cmd":"iso_recording_start","output_dir":"C:/Recordings/CoreVideo","ffmpeg_path":"ffmpeg","record_program":true,"source_uuids":["OUTPUT_SOURCE_UUID"]}
 ```
 
+`source_uuids` selects routed CoreVideo output sources. Omitting it uses the
+feed choices saved in the ISO panel; an empty selection is an error. OSC start
+also uses those saved choices. Multiple selected feeds for one participant
+share a single participant MP4.
+
 TCP status example:
 
 ```json
@@ -651,33 +667,25 @@ OSC equivalents:
 
 Output files are written as:
 
-- `*.mp4` for encoded I420 video through FFmpeg using the selected H.264
-  encoder
-- `*.wav` for matching PCM audio
-- `*.ffmpeg.log` beside them, holding FFmpeg's own account of the session. Read
-  this first when a file is missing or truncated.
+- `*.mp4` containing H.264 video and AAC audio for one participant.
+- `*.mp4.ffmpeg.log` containing encoder diagnostics.
 
 ### Timing
 
-Both files are paced to real elapsed time against the same clock, so each is
-individually accurate and the two stay in sync with each other.
-
-That is not free, and it is worth knowing why. Raw video carries no per-frame
-timestamps, and Zoom's per-source delivery fluctuates between roughly 10 and
-60 fps with conditions outside CoreVideo's control - so frames are paced to a
-fixed cadence before they reach FFmpeg, duplicating the held frame to backfill a
-stall and dropping excess from a burst. Audio has the mirror-image problem for a
-different reason: Zoom only calls audio back for someone currently making sound,
-so silence is backfilled across every gap or the WAV shrinks by the total silent
-duration. Both were wrong before v0.1.42/v0.1.43 - a source averaging 15 fps
-recorded under a declared 30 fps finished in about half the real duration, and an
-over-eager first gap-fill briefly doubled every WAV. If you see either symptom,
-check your version first.
-
-The hardware encoder fallback chain is NVENC -> QSV -> AMF -> libx264, and it
-walks the whole chain: a source demoted off NVENC on a machine with no working
-QSV or AMF runtime now reaches libx264, the tier with no hardware dependency to
-fail on.
+A worker per participant uses a monotonic clock to emit 30 video frames and
+48,000 audio samples per second. It holds the last picture during video gaps
+(or black before the first frame) and inserts silence during audio gaps. Input
+resolution and audio format changes are conformed on the worker without
+restarting the output. Files start on first media delivery. Participants first
+encountered later have a `start_offset_ms` in status.
+
+Timestamped video and PCM audio travel over one internal Matroska pipe to
+FFmpeg, which writes a single fragmented MP4. There are no separate temporary
+media files and no merge step at Stop. Producer buffers and encoder queues are
+bounded. An encoder failure is reported on that participant; it does not start
+an automatic replacement file. Hardware availability is tested by encoding an
+actual frame before recording starts. Automatic placement uses working NVENC,
+QSV, AMF, then libx264, accounting for OBS's NVENC sessions.
 
 When `record_program` is true, CoreVideo also starts the normal OBS program
 recording and stops it when ISO recording stops, but only if CoreVideo started
diff --git a/docs/iso-feed-selection-validation-2026-09-14.md b/docs/iso-feed-selection-validation-2026-09-14.md
new file mode 100644
index 0000000..6b39baf
--- /dev/null
+++ b/docs/iso-feed-selection-validation-2026-09-14.md
@@ -0,0 +1,30 @@
+# ISO feed selection
+
+Development build: `v0.1.47-dev.3`. Includes participant A/V recording and the
+pending Tiles frame-handoff fix. Not installed while the operator is in a meeting.
+
+The ISO panel now lists output feeds with checkboxes, defaulting to none.
+Selections are stored by source UUID, survive live routing refreshes, and are
+locked for the recording run. Unrouted/unsupported entries cannot be newly
+selected; a saved choice is retained if its route temporarily disappears.
+Start requires at least one selected routed feed. Disk and encoder estimates
+count only selected feeds, deduplicating fixed participant routes.
+
+The recorder validates selection independently of the UI and filters both
+audio and video callbacks. Starting no longer pre-opens writers for configured
+participant IDs. Files open only on media delivery from a selected route.
+Once opened, normal gap handling and one-file-per-participant ownership remain.
+
+TCP `iso_recording_start` accepts `source_uuids`, an array of output UUIDs;
+omission uses saved panel choices, and explicit empty selection is rejected.
+OSC start uses saved choices. Neither API falls back to recording every source.
+Status exposes `selected_source_uuids`; the panel shows an armed/waiting state
+when recording is enabled but no selected feed has delivered media.
+
+Windows full build succeeded and all 70 CTest regressions passed. The new
+selection-policy regression covers selected/unselected, unrouted, unsupported,
+empty selection, and empty UUID cases. Live UI and recording acceptance remain
+pending the operator's meeting ending and installation: select two routed
+feeds, leave others unchecked, verify only selected participants create files,
+and confirm offline/unrouted feeds create none. Check saved choices after OBS
+restart and a routing refresh.
diff --git a/docs/iso-isolated-audio-validation-2026-09-15.md b/docs/iso-isolated-audio-validation-2026-09-15.md
new file mode 100644
index 0000000..b6af1cb
--- /dev/null
+++ b/docs/iso-isolated-audio-validation-2026-09-15.md
@@ -0,0 +1,36 @@
+# Dedicated ISO audio validation
+
+Build `v0.1.47-dev.4` includes the feed picker, Tiles handoff fix, and dedicated
+participant audio recording. Both plugin and ZoomObsEngine must be installed.
+
+Root cause: ZoomSource forwarded its embedded audio to the ISO writer. Sources
+configured as Mix received mixed PCM labelled with the configured participant
+ID by the engine. A participant ID alone therefore did not prove isolation.
+Decoded audio envelopes from the last show's participant files were strongly
+correlated (two pairs 0.9956 and 0.9467), consistent with this path.
+
+ISO now owns an audio-only subscription per recorded participant. Source PCM
+is never passed to the writer. The engine forces these subscriptions to receive
+only that participant's one-way audio and excludes them from the set of output
+routes that claim participants away from Audience audio. Per-slot attribution
+is validated again at the recorder's dedicated SHM reader.
+
+Validation completed:
+
+- Full Windows build and 72 CTest regressions passed.
+- Routing regression rejects mix and other participants while retaining normal
+  isolated, meeting-mix, and Audience behavior.
+- Real SHM reader regression retains first/coalesced buffers, does not duplicate
+  drained buffers, clears notifications, and rejects another participant ID.
+- End-to-end synthetic alternating speakers through the production routing
+  policy, real shared-memory reader, resampler, and FFmpeg MP4 writers passed.
+  Decoded one-second RMS for participant 1: 8490.78, 0, 8485.57, 0.
+  Participant 2: 0, 8482.77, 0, 8482.81. Non-speaking intervals were digital silence.
+  Both files decoded completely without errors.
+
+Reproduce: run `CoreVideoIsoIsolatedRecordingTest <ffmpeg>` in an empty directory,
+then `python tests/verify-iso-isolated.py <ffmpeg> <directory>` from the repo root.
+These are synthetic SDK-input tests, not a live Zoom meeting. Live acceptance
+still requires two people alternating speech and checking their respective MP4s.
+Existing mixed recordings are unchanged; this fix cannot recover original
+isolated stems that were never captured.
diff --git a/docs/iso-participant-av-validation-2026-09-14.md b/docs/iso-participant-av-validation-2026-09-14.md
new file mode 100644
index 0000000..790e7f2
--- /dev/null
+++ b/docs/iso-participant-av-validation-2026-09-14.md
@@ -0,0 +1,77 @@
+# Continuous participant ISO recording validation
+
+Development build: `v0.1.47-dev`. This change has not been installed into the
+running OBS instance or published as a release.
+
+## Change
+
+The previous recorder opened separate video MP4 and audio WAV files and keyed
+video lifetime to source/resolution changes. The replacement owns one writer
+per Zoom participant ID for the Record/Stop interval. Duplicate source UUIDs
+share that writer. Input size changes only reconfigure the scaler.
+
+Every participant MP4 contains 1920x1080/30 H.264 and 48 kHz stereo AAC.
+Aspect ratio is preserved with black bars. A worker per participant performs
+scaling, resampling and timestamped A/V transport over one FFmpeg stdin pipe.
+Video gaps hold the picture; audio gaps contain silence. A participant with no
+media callbacks still gets black video and silence. No merge step or automatic
+replacement segment is created. Diagnostic text logs remain beside the MP4.
+
+The Windows GPU scaler and aspect-fit geometry were adapted from CoreVideo
+Pro's `D3DIsoFrameConformer.h` and `IsoFrameConform.h`. This recorder uses planar
+I420 rather than Pro's NV12 output, and preserves the engine's full-range
+BT.709 pixels. Other platforms use the OBS video scaler.
+
+## Completed checks
+
+- Full Windows plugin/engine build succeeded; 68 CTest regressions passed.
+- Real worker fixtures: two simultaneous libx264 participant encoders and eight
+  simultaneous NVENC participant encoders on this RTX 4090 host. Each run also
+  had a silent/no-video libx264 writer and a deliberately invalid encoder process.
+- Every participant produced one MP4 with both tracks, 180 decoded video frames
+  over six seconds, fixed 1920x1080/30 video, stereo 48 kHz AAC, and no decode errors.
+- Inputs changed between 640x360, 1280x720, 1920x1080, and 640x480, followed by a
+  camera-off second and recovery. Decoded pixels verified pillarboxing, recovery
+  to full canvas, and separate U/V colors through scaling and native-size input.
+- Input audio changed from 32 kHz mono to 48 kHz stereo, with callbacks withheld
+  outside test tones. Clustered callback timestamps verified that PCM placement
+  never rewinds or overwrites a previously received batch.
+- Decoded flashes/tones stayed within 20 ms on both encoders; all six 100 ms
+  audio tones retained their duration. No late audio samples were reported.
+- No-input tracks decoded as continuous black and silent AAC. The failed encoder
+  reported an error without stopping the healthy recordings.
+- Provider-policy regression covers duplicate source suppression, monotonic
+  timestamps, alternate takeover after a gap, and source removal.
+
+Validation found and corrected startup history loss, fragmented MP4 startup
+offset with B-frames, input color metadata, planar chroma conversion, and audio
+rewinding on bunched arrival timestamps.
+
+## Reproduce
+
+Build `CoreVideoIsoTrackWriterTest` with the Windows plugin dependencies. Run
+from an empty directory, with OBS's runtime DLL directory on PATH:
+
+```powershell
+& $writerTest $ffmpeg h264_nvenc 8
+python tests/verify-iso-av.py $ffmpegBin $fixtureDirectory
+```
+
+Run the verifier from the repository root. Use `libx264 2` for the CPU fixture.
+The test refuses to overwrite existing MP4s. The verifier checks decoded media,
+not only FFmpeg exit status. Local final results are in `build-iso/av-burst-cpu`
+and `build-iso/av-burst-nvenc`; regression results are in `build-iso/av-ctest.log`.
+
+## Remaining release validation
+
+- Live Zoom soak, including repeated resolution changes, mute/camera toggles,
+  duplicate OBS sources, source reassignment/removal, Stop, and a new Record run.
+- Live lip-sync check, sustained resource usage at the intended participant
+  count, and playback/import in the production editor.
+- Hosted macOS/Linux builds and platform recording checks; local validation
+  above is Windows only.
+
+The exposed identity is Zoom's numeric participant ID. A rejoin that receives a
+new ID creates a new participant file; matching by display name would risk
+combining different people. Known fixed participants share the Record epoch;
+late participants expose their offset through `start_offset_ms` status.
diff --git a/docs/tiles-flash-validation-2026-09-14.md b/docs/tiles-flash-validation-2026-09-14.md
new file mode 100644
index 0000000..34cc6ac
--- /dev/null
+++ b/docs/tiles-flash-validation-2026-09-14.md
@@ -0,0 +1,34 @@
+# Tiles pending-frame handoff fix
+
+Build: `v0.1.47-dev.2`, including the previous participant A/V ISO changes.
+
+The reported symptom was brightness/color flashing inside faces, possibly at
+speaker changes. The existing color-range normalization is present in the
+installed engine and its logs show it operating. Speaker/roster updates do not
+reassign a tile when its participant list is unchanged.
+
+Code inspection found a definite failure path in the Tiles frame handoff:
+
+1. A valid frame is waiting for the render thread (`has_frame=true`).
+2. Another callback copies SHM pixels directly into that pending frame.
+3. The shared-memory sequence check rejects the new copy, or its dimensions
+   are unsuitable for I420. The callback returns without updating metadata.
+4. The render thread still sees the previous ready flag, dimensions and frame
+   generation, but the underlying pixels have been overwritten. On a resize,
+   even the Y/U/V plane offsets can now describe the wrong buffer.
+
+The fix reads into a separate reusable candidate buffer and commits pixels only
+after a successful read with even dimensions. Failed reads leave the pending
+valid picture untouched. It adds one retained input buffer per tile, no extra
+full-frame copy, and no changes to subscriptions or color conversion.
+
+Validation: `CoreVideoTileFrameRead` failed with direct writes to the pending
+buffer, then passed after transactional publication. It covers rejected resize,
+successful resize recovery, and 100 subsequent rejected reads. The full Windows
+build and all 69 CTest regressions passed.
+
+The exact connection to the observed live flashes still needs confirmation on
+the new build. The previous build did not log rejected Tiles reads. The new
+build logs `Tiles kept last valid frame` at the first rejection and each 300th
+rejection so a live test can correlate these events. Verify repeated speaker
+changes and resolution changes without visible brightness/color pops.
diff --git a/engine/src/engine-audio.cpp b/engine/src/engine-audio.cpp
index 6ba0c82..e5373e8 100644
--- a/engine/src/engine-audio.cpp
+++ b/engine/src/engine-audio.cpp
@@ -1,6 +1,7 @@
 #include "engine-audio.h"
 #include "engine-writer.h"
 #include "tile-clock-log.h"
+#include "../../src/iso-audio-routing.h"
 #if __has_include(<rawdata/zoom_rawdata_api.h>)
 #include <rawdata/zoom_rawdata_api.h>
 #else
@@ -15,9 +16,10 @@ bool EngineAudio::init(IpcFd e2p_fd,
                        const std::string &source_uuid,
                        uint32_t participant_id,
                        bool isolate_audio,
-                       bool audience_audio)
+                       bool audience_audio, bool recording_only)
 {
     // isolate wins if both are set — defensive, the plugin UI prevents this.
+    if (recording_only) isolate_audio = true;
     if (isolate_audio) audience_audio = false;
 
     m_e2p_fd = e2p_fd;
@@ -47,6 +49,7 @@ bool EngineAudio::init(IpcFd e2p_fd,
             it->second->isolate_audio = isolate_audio;
             it->second->audience_audio = audience_audio;
         }
+        m_targets.at(source_uuid)->recording_only = recording_only;
     }
 
     if (!m_raw_media_active) {
@@ -380,7 +383,8 @@ void EngineAudio::onMixedAudioRawDataReceived(AudioRawData *data)
     for (auto &entry : m_targets) {
         if (!entry.second) continue;
         // Skip isolate AND audience targets — both receive only one-way audio.
-        if (entry.second->isolate_audio || entry.second->audience_audio) continue;
+        if (!audio_receives_mix(entry.second->isolate_audio, entry.second->audience_audio,
+                                entry.second->recording_only)) continue;
         output_audio_frame(*entry.second, entry.first, data,
                            "audio_frame_received");
     }
@@ -397,9 +401,10 @@ void EngineAudio::onOneWayAudioRawDataReceived(AudioRawData *data, uint32_t user
     // determine whether this user is "claimed" by any isolate target.
     bool claimed_by_isolate = false;
     for (auto &entry : m_targets) {
-        if (!entry.second || !entry.second->isolate_audio) continue;
-        if (entry.second->participant_id != user_id) continue;
-        claimed_by_isolate = true;
+        if (!entry.second || !audio_receives_participant(entry.second->participant_id,user_id,
+                entry.second->isolate_audio,entry.second->recording_only)) continue;
+        if (audio_claims_audience(entry.second->isolate_audio,entry.second->recording_only))
+            claimed_by_isolate = true;
         output_audio_frame(*entry.second, entry.first, data,
                            "audio_one_way_frame_received");
     }
diff --git a/engine/src/engine-audio.h b/engine/src/engine-audio.h
index 92c8787..84292a5 100644
--- a/engine/src/engine-audio.h
+++ b/engine/src/engine-audio.h
@@ -34,7 +34,7 @@ class EngineAudio : public ZOOMSDK::IZoomSDKAudioRawDataDelegate {
               const std::string &source_uuid,
               uint32_t participant_id,
               bool isolate_audio,
-              bool audience_audio);
+              bool audience_audio, bool recording_only = false);
     bool retry_subscribe(const std::string &reason);
     void set_raw_media_active(bool active);
     void reset_subscription(const std::string &reason);
@@ -60,6 +60,7 @@ class EngineAudio : public ZOOMSDK::IZoomSDKAudioRawDataDelegate {
         uint32_t participant_id = 0;
         bool isolate_audio = false;
         bool audience_audio = false;
+        bool recording_only = false;
         ShmRegion shm;
         // The generation the CURRENT region was created under; part of the name
         // from gen 2 and published with every audio event. A record of what was
diff --git a/engine/src/main.cpp b/engine/src/main.cpp
index 0dd3dfd..505dae8 100644
--- a/engine/src/main.cpp
+++ b/engine/src/main.cpp
@@ -1996,7 +1996,8 @@ int main()
                 line.find(R"("audience_audio":true)") != std::string::npos;
             if (is_valid_source_uuid(uuid)) {
                 EngineAudio::instance().init(e2p, uuid, pid,
-                                             isolate_audio, audience_audio);
+                                             isolate_audio, audience_audio,
+                    line.find(R"("recording_only":true)") != std::string::npos);
             }
 
         } else if (command == IpcCommand::Subscribe) {
diff --git a/package-lock.json b/package-lock.json
index 9e117ba..2d5c5b1 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -41,9 +41,9 @@
       }
     },
     "node_modules/@cloudflare/workerd-darwin-64": {
-      "version": "1.20260903.1",
-      "resolved": "https://registry.npmjs.org/@cloudflare/workerd-darwin-64/-/workerd-darwin-64-1.20260903.1.tgz",
-      "integrity": "sha512-FG+4mGxAXhKiL/1temH42alevIkumtYXNidhTa//3yULpzux6APw5UNVocI/vCQ1yG1YOEZRfbVy8lyuipM9MQ==",
+      "version": "1.20260911.1",
+      "resolved": "https://registry.npmjs.org/@cloudflare/workerd-darwin-64/-/workerd-darwin-64-1.20260911.1.tgz",
+      "integrity": "sha512-785eaY1bkR1cm4Z/PCUeteZYmTMe6lre2zz63/GdGGimsoMsKxgl4brFPRukim8iv28EyD1XoCB/VPYF20BERA==",
       "cpu": [
         "x64"
       ],
@@ -58,9 +58,9 @@
       }
     },
     "node_modules/@cloudflare/workerd-darwin-arm64": {
-      "version": "1.20260903.1",
-      "resolved": "https://registry.npmjs.org/@cloudflare/workerd-darwin-arm64/-/workerd-darwin-arm64-1.20260903.1.tgz",
-      "integrity": "sha512-o241VefnjG8eG+kGap5CjgV4zOT5UaAmS3OR1VZCpNj7vkXGxvp9KftKvtQgcCsIqJKaKx+7Xd7xq0L1DjkfPQ==",
+      "version": "1.20260911.1",
+      "resolved": "https://registry.npmjs.org/@cloudflare/workerd-darwin-arm64/-/workerd-darwin-arm64-1.20260911.1.tgz",
+      "integrity": "sha512-WU4bFqEN0H7ndGWxoedegv95DmNVBtv0ncXcHG9nYFTUI78sxEb0qoT3U6Ga4hyBkzsJFBX/zvVBIGX3qKldGA==",
       "cpu": [
         "arm64"
       ],
@@ -75,9 +75,9 @@
       }
     },
     "node_modules/@cloudflare/workerd-linux-64": {
-      "version": "1.20260903.1",
-      "resolved": "https://registry.npmjs.org/@cloudflare/workerd-linux-64/-/workerd-linux-64-1.20260903.1.tgz",
-      "integrity": "sha512-/VEvvtQ/XKf6HlBbg6FbvpwcpfYUcx6Fv6RkASY8DyEmUyuJ8rc7Qxil83ClRFoBzz/GY0BV94UZ6F+wers/hg==",
+      "version": "1.20260911.1",
+      "resolved": "https://registry.npmjs.org/@cloudflare/workerd-linux-64/-/workerd-linux-64-1.20260911.1.tgz",
+      "integrity": "sha512-0Y2gy62oxQxWa38qinSPE6zNL5+JmumJtDY9AWW1HB8KHuATxN71o5MGzmVFfB8PwZsiHfUd2Sv7O22krCOrhw==",
       "cpu": [
         "x64"
       ],
@@ -92,9 +92,9 @@
       }
     },
     "node_modules/@cloudflare/workerd-linux-arm64": {
-      "version": "1.20260903.1",
-      "resolved": "https://registry.npmjs.org/@cloudflare/workerd-linux-arm64/-/workerd-linux-arm64-1.20260903.1.tgz",
-      "integrity": "sha512-OWhihGC6KoTXF4u2C1AonfpgXeM4/7p/1IXuALqXESmFUpLLP5gZhRzjSk/gWW+mrCZDfSrvnjifl+lRqselbA==",
+      "version": "1.20260911.1",
+      "resolved": "https://registry.npmjs.org/@cloudflare/workerd-linux-arm64/-/workerd-linux-arm64-1.20260911.1.tgz",
+      "integrity": "sha512-kttNPnx1r2lCqFUoMH62z7CqGV+j4QBbw5fdtaz4pzOrzBv0AWkNATt7onFUe+SwP8zhcepMtbm2F4kKzTf6VA==",
       "cpu": [
         "arm64"
       ],
@@ -109,9 +109,9 @@
       }
     },
     "node_modules/@cloudflare/workerd-windows-64": {
-      "version": "1.20260903.1",
-      "resolved": "https://registry.npmjs.org/@cloudflare/workerd-windows-64/-/workerd-windows-64-1.20260903.1.tgz",
-      "integrity": "sha512-soPMF9/aMHlHKK7M0vq5HrRRicPbnZO1F6ZZ7JWN8EltxWJU5L7CEq7CxjO878DzyPx7gYvqBFy3SVgdZKZjMQ==",
+      "version": "1.20260911.1",
+      "resolved": "https://registry.npmjs.org/@cloudflare/workerd-windows-64/-/workerd-windows-64-1.20260911.1.tgz",
+      "integrity": "sha512-5iO/YfoBDOgO3CrHdkiiVP8SL3O2jC+c6Ux3d378TSPKLhU5+CgHjtE/ZSodWQrzr4FzFRqdW8S7n5nbyD1MHQ==",
       "cpu": [
         "x64"
       ],
@@ -602,9 +602,9 @@
       }
     },
     "node_modules/@img/sharp-darwin-arm64": {
-      "version": "0.35.2",
-      "resolved": "https://registry.npmjs.org/@img/sharp-darwin-arm64/-/sharp-darwin-arm64-0.35.2.tgz",
-      "integrity": "sha512-eEieHsMksAW4IiO5NzauESRl2D2qz3J/kwUxUrSfV06A93eEaRfMpHXyUb1mAqrR7i8U9A0GRqE9pjn6u1Jjpg==",
+      "version": "0.35.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-darwin-arm64/-/sharp-darwin-arm64-0.35.4.tgz",
+      "integrity": "sha512-Uhfl4V4lhP2nbUVF9+hyH1+luj86f1gUFeo8ALYxFoULoU+G87D43BfeMP8XHsk9boxAnCY/bf2EHwhA7MuGsA==",
       "cpu": [
         "arm64"
       ],
@@ -621,13 +621,13 @@
         "url": "https://opencollective.com/libvips"
       },
       "optionalDependencies": {
-        "@img/sharp-libvips-darwin-arm64": "1.3.1"
+        "@img/sharp-libvips-darwin-arm64": "1.3.3"
       }
     },
     "node_modules/@img/sharp-darwin-x64": {
-      "version": "0.35.2",
-      "resolved": "https://registry.npmjs.org/@img/sharp-darwin-x64/-/sharp-darwin-x64-0.35.2.tgz",
-      "integrity": "sha512-BaktuGPCeHJMARpodR8jK4uKiZrPAy9WrfQW0sdI37clracq8Bp01AYS3SZgi5FS/y5twa9t4+LIuuxQjqRrWw==",
+      "version": "0.35.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-darwin-x64/-/sharp-darwin-x64-0.35.4.tgz",
+      "integrity": "sha512-hWniXY3bG5qKpkKrAwPe4y+VTPmf086YQAnkxWh7uA1YrlRouWGa0M0Mxj3ZjnXFkv7/TD1bTy9lGUK26vRvWw==",
       "cpu": [
         "x64"
       ],
@@ -644,13 +644,13 @@
         "url": "https://opencollective.com/libvips"
       },
       "optionalDependencies": {
-        "@img/sharp-libvips-darwin-x64": "1.3.1"
+        "@img/sharp-libvips-darwin-x64": "1.3.3"
       }
     },
     "node_modules/@img/sharp-freebsd-wasm32": {
-      "version": "0.35.2",
-      "resolved": "https://registry.npmjs.org/@img/sharp-freebsd-wasm32/-/sharp-freebsd-wasm32-0.35.2.tgz",
-      "integrity": "sha512-YoAxdnd8hPUkvLHd3bWY+YA8nw3xM/RyRopYucNsWHVSan8NLVM3X2volsfoRDcXdUJPg6tXahSd7HXPK7lRnw==",
+      "version": "0.35.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-freebsd-wasm32/-/sharp-freebsd-wasm32-0.35.4.tgz",
+      "integrity": "sha512-lIsKw/BU+kjB4eZjxrYrZmwOJYi3Ajrv66iAlBmUPyKc3HpnloevB1g3wxGD9P/5BbQ1brBGl65VRRrCvQDEqA==",
       "dev": true,
       "license": "Apache-2.0",
       "optional": true,
@@ -658,7 +658,7 @@
         "freebsd"
       ],
       "dependencies": {
-        "@img/sharp-wasm32": "0.35.2"
+        "@img/sharp-wasm32": "0.35.4"
       },
       "engines": {
         "node": ">=20.9.0"
@@ -668,9 +668,9 @@
       }
     },
     "node_modules/@img/sharp-libvips-darwin-arm64": {
-      "version": "1.3.1",
-      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-darwin-arm64/-/sharp-libvips-darwin-arm64-1.3.1.tgz",
-      "integrity": "sha512-4V/M3roRMTYjiwZY9IOVQOE8OyeCxFAkYmyZDrZl51uOKjibm3oeEJ4WAmLxutAfzFbC9jqUiPs2gbnGflH+7g==",
+      "version": "1.3.3",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-darwin-arm64/-/sharp-libvips-darwin-arm64-1.3.3.tgz",
+      "integrity": "sha512-suTBPTDGrI9WodccaDdwZItTSaBYASlBk1NSfElSHrUfzu3szG6lvIF58+WiFvnfzuK8ZBFS5zE00PxqxnRiPg==",
       "cpu": [
         "arm64"
       ],
@@ -685,9 +685,9 @@
       }
     },
     "node_modules/@img/sharp-libvips-darwin-x64": {
-      "version": "1.3.1",
-      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-darwin-x64/-/sharp-libvips-darwin-x64-1.3.1.tgz",
-      "integrity": "sha512-c0/DxItpJv2+dGhgycJBBgotdqruGYDvA79drdh0MD1dFpy7JzJ/PlXwi1H4rFf0eTy8tgbI91aHDnZIceY3jQ==",
+      "version": "1.3.3",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-darwin-x64/-/sharp-libvips-darwin-x64-1.3.3.tgz",
+      "integrity": "sha512-FVJZ5mITMobmXIz/hPDTw0EintTW5H3WfrxwLqEqjiIihlu+hVRyGrFQ60xl0Lxn7Bt3zdpevPaQi0HEzqz9fw==",
       "cpu": [
         "x64"
       ],
@@ -702,16 +702,13 @@
       }
     },
     "node_modules/@img/sharp-libvips-linux-arm": {
-      "version": "1.3.1",
-      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-arm/-/sharp-libvips-linux-arm-1.3.1.tgz",
-      "integrity": "sha512-aGGy9aWzXgHBG7HNyQPWorZthlp7+x6fDRoPAQbGO3ThcttuTyKIx3NuSHb6zb4gBNq6/yNn9f1cy9nFKS/Vmg==",
+      "version": "1.3.3",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-arm/-/sharp-libvips-linux-arm-1.3.3.tgz",
+      "integrity": "sha512-3rbU4vqXXc3hY/OiXdl52xZvT0F1yEngWfvqudtPJg/KkyiaQw2DRsFrNzpmLvfavbwOq3qXn36GP8obHRULQA==",
       "cpu": [
         "arm"
       ],
       "dev": true,
-      "libc": [
-        "glibc"
-      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -722,16 +719,13 @@
       }
     },
     "node_modules/@img/sharp-libvips-linux-arm64": {
-      "version": "1.3.1",
-      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-arm64/-/sharp-libvips-linux-arm64-1.3.1.tgz",
-      "integrity": "sha512-JznefmcK9j1JKPz8AkQDh89kjojubyfOasWBPKfzMIhPwsgDy9evpE/naJTXXXmghS1iFwR8u/kTwh/I2/+GCw==",
+      "version": "1.3.3",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-arm64/-/sharp-libvips-linux-arm64-1.3.3.tgz",
+      "integrity": "sha512-0DaL0A6Xu6sQSQFwe4iVCrKWU2cCTItnRsYsCdxAMm9NF6twAA9BKnoqy4hqz4+azQ0JHuA26qiUKsf1XJ/v5A==",
       "cpu": [
         "arm64"
       ],
       "dev": true,
-      "libc": [
-        "glibc"
-      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -742,16 +736,13 @@
       }
     },
     "node_modules/@img/sharp-libvips-linux-ppc64": {
-      "version": "1.3.1",
-      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-ppc64/-/sharp-libvips-linux-ppc64-1.3.1.tgz",
-      "integrity": "sha512-1EkwGNCZk6iWNCMWqrvdJ+r1j0PT1zIz60CNPhYnJlK/zyeWqlsPZIe+ocBVqPF8k/Ssee/NCk+tE9Ryrko6ng==",
+      "version": "1.3.3",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-ppc64/-/sharp-libvips-linux-ppc64-1.3.3.tgz",
+      "integrity": "sha512-cdn1OvUBwsXhbC0zSzJnNzf5MZ/mTrobawDvNXBTxe8VtqKAm0sRuEY2Evzovb/w9JMk4TvRxqt1mekSuJz64w==",
       "cpu": [
         "ppc64"
       ],
       "dev": true,
-      "libc": [
-        "glibc"
-      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -762,16 +753,13 @@
       }
     },
     "node_modules/@img/sharp-libvips-linux-riscv64": {
-      "version": "1.3.1",
-      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-riscv64/-/sharp-libvips-linux-riscv64-1.3.1.tgz",
-      "integrity": "sha512-Ilays+w2bXdnxzxtQdmXR62u8o8GYa3eL4+Gr+1KiE4xperMZUslRaVPJwwPkzlHEjGfXAfRVAa/7CYCtSqsBw==",
+      "version": "1.3.3",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-riscv64/-/sharp-libvips-linux-riscv64-1.3.3.tgz",
+      "integrity": "sha512-HjPVx7yKz+0lqdhDlTw1tt90wamBoxhiXpvl1XZpJLiHH4RCJ5yDTqH+VlYPv2fwFs89JFw4c1IexYOcQUi4IQ==",
       "cpu": [
         "riscv64"
       ],
       "dev": true,
-      "libc": [
-        "glibc"
-      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -782,16 +770,13 @@
       }
     },
     "node_modules/@img/sharp-libvips-linux-s390x": {
-      "version": "1.3.1",
-      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-s390x/-/sharp-libvips-linux-s390x-1.3.1.tgz",
-      "integrity": "sha512-VfBwVHQTbRoj4XlpA/KLZ7ltgMpz+4WSejFzQ+GnoImjo1PtEJ59QB2qR1xQEeRPYIkNrPIm2L4cICMvz4C2ew==",
+      "version": "1.3.3",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-s390x/-/sharp-libvips-linux-s390x-1.3.3.tgz",
+      "integrity": "sha512-neWLh+3yCNThxnfy3c4BbVBeGgt9aftno+XbT56iK28RgeDs3UOFWviLWlUu0bArYVYJaFDK+RRohbicUNCm8Q==",
       "cpu": [
         "s390x"
       ],
       "dev": true,
-      "libc": [
-        "glibc"
-      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -802,16 +787,13 @@
       }
     },
     "node_modules/@img/sharp-libvips-linux-x64": {
-      "version": "1.3.1",
-      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-x64/-/sharp-libvips-linux-x64-1.3.1.tgz",
-      "integrity": "sha512-+c8ukgwU62DS54nCAjw7keOfHUkmr0B5QHEdcOqRnodF/MNXJbVI8Eopoj4B/0H8Asr65I+A4Amrn7a85/md6A==",
+      "version": "1.3.3",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-x64/-/sharp-libvips-linux-x64-1.3.3.tgz",
+      "integrity": "sha512-4vKmvAst9nrowcqquKFAyZJUDolUaIp8uRiN0mWFguJ1IplC9/pitXtlnnlU4aa/eJw3J7i67V+pwUL+wZGdsA==",
       "cpu": [
         "x64"
       ],
       "dev": true,
-      "libc": [
-        "glibc"
-      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -822,16 +804,13 @@
       }
     },
     "node_modules/@img/sharp-libvips-linuxmusl-arm64": {
-      "version": "1.3.1",
-      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linuxmusl-arm64/-/sharp-libvips-linuxmusl-arm64-1.3.1.tgz",
-      "integrity": "sha512-qlKb/pwbkAi1WMsJrYHk7CuDrd12s27U2QnRhFYUoJNrRCmkosMTttuRFat/DDB3IlDm5qE1TJgZ4JDnHX8Ldw==",
+      "version": "1.3.3",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linuxmusl-arm64/-/sharp-libvips-linuxmusl-arm64-1.3.3.tgz",
+      "integrity": "sha512-Y9kQaLMuNoB0bPYOOdcZMaseNrFpPodIWWMrx+CZyydf2xn68j9WYc6sWWRrDwNkzCQjKYfc68L7jKjGlHMibw==",
       "cpu": [
         "arm64"
       ],
       "dev": true,
-      "libc": [
-        "musl"
-      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -842,16 +821,13 @@
       }
     },
     "node_modules/@img/sharp-libvips-linuxmusl-x64": {
-      "version": "1.3.1",
-      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linuxmusl-x64/-/sharp-libvips-linuxmusl-x64-1.3.1.tgz",
-      "integrity": "sha512-yO21HwoUVLN8Qa+/SBjQLMYwBWAVJjeGPNe+hc0OUeMeifEtJqu5a1c4HayE1nNpDih9y3/KkoltfkDodmKAlg==",
+      "version": "1.3.3",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linuxmusl-x64/-/sharp-libvips-linuxmusl-x64-1.3.3.tgz",
+      "integrity": "sha512-fj8Mv0HHfD1Rr+4I68+3agJynxDWtBFgicTbSOb9Bke6pIwzGcJ+RX/yHjmiEGFMCavY/dxvem7MyNaJF+wDiw==",
       "cpu": [
         "x64"
       ],
       "dev": true,
-      "libc": [
-        "musl"
-      ],
       "license": "LGPL-3.0-or-later",
       "optional": true,
       "os": [
@@ -862,16 +838,13 @@
       }
     },
     "node_modules/@img/sharp-linux-arm": {
-      "version": "0.35.2",
-      "resolved": "https://registry.npmjs.org/@img/sharp-linux-arm/-/sharp-linux-arm-0.35.2.tgz",
-      "integrity": "sha512-SE4kzF2mepn6z+6E7L6lsV8FzuLL6IPQdyX8ZiwROAG/G8td+hP/m7FsFPwidtrF19gvajuC9l6TxAVcsA4S7A==",
+      "version": "0.35.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linux-arm/-/sharp-linux-arm-0.35.4.tgz",
+      "integrity": "sha512-7OAS8gI0EReKGVN2HssHlM6umJgxF5VI3xN0p9FA91p/YO+ou5hiNghLdZ5BEHztwaaK5+bLKRf8x/o2L2nk9A==",
       "cpu": [
         "arm"
       ],
       "dev": true,
-      "libc": [
-        "glibc"
-      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -884,20 +857,17 @@
         "url": "https://opencollective.com/libvips"
       },
       "optionalDependencies": {
-        "@img/sharp-libvips-linux-arm": "1.3.1"
+        "@img/sharp-libvips-linux-arm": "1.3.3"
       }
     },
     "node_modules/@img/sharp-linux-arm64": {
-      "version": "0.35.2",
-      "resolved": "https://registry.npmjs.org/@img/sharp-linux-arm64/-/sharp-linux-arm64-0.35.2.tgz",
-      "integrity": "sha512-af12Pnd0ZGu2HfP8NayB0kk6eC/lrfbQE6HlR4jD+34wdJ1Vw9TF6TMn6ZvffT+WgqVsl0hRbmNvz2u/23VmwA==",
+      "version": "0.35.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linux-arm64/-/sharp-linux-arm64-0.35.4.tgz",
+      "integrity": "sha512-De4jpEnAU8Hd5oT0j1G3uL4ZvTuipVMn7YC6vPaJhy6/7EwEae0SVAoBrUMYQbkLGDm85taVWwuPc1a44LTzCQ==",
       "cpu": [
         "arm64"
       ],
       "dev": true,
-      "libc": [
-        "glibc"
-      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -910,20 +880,17 @@
         "url": "https://opencollective.com/libvips"
       },
       "optionalDependencies": {
-        "@img/sharp-libvips-linux-arm64": "1.3.1"
+        "@img/sharp-libvips-linux-arm64": "1.3.3"
       }
     },
     "node_modules/@img/sharp-linux-ppc64": {
-      "version": "0.35.2",
-      "resolved": "https://registry.npmjs.org/@img/sharp-linux-ppc64/-/sharp-linux-ppc64-0.35.2.tgz",
-      "integrity": "sha512-hYSBm7zcNtDCozCxQHYZJiu63b/bXsgRZuOxCIBZsStMM9Vap47iFHdbX4kCvQsblPB/k+clhELpdQJHQLSHvg==",
+      "version": "0.35.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linux-ppc64/-/sharp-linux-ppc64-0.35.4.tgz",
+      "integrity": "sha512-2oYZJeIl4kCcMGk4ouZVjnkCtFrpQFlNEtJ6GbxzhHQchwH0NH/qEb9ykmOl29dqwMq+JhFdZn+1ak2FKhI9fQ==",
       "cpu": [
         "ppc64"
       ],
       "dev": true,
-      "libc": [
-        "glibc"
-      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -936,20 +903,17 @@
         "url": "https://opencollective.com/libvips"
       },
       "optionalDependencies": {
-        "@img/sharp-libvips-linux-ppc64": "1.3.1"
+        "@img/sharp-libvips-linux-ppc64": "1.3.3"
       }
     },
     "node_modules/@img/sharp-linux-riscv64": {
-      "version": "0.35.2",
-      "resolved": "https://registry.npmjs.org/@img/sharp-linux-riscv64/-/sharp-linux-riscv64-0.35.2.tgz",
-      "integrity": "sha512-qQt0Kc13+Hoan/Awq/qMSQw3L+RI1NCRPgD5cUJ/1WSSmIoysLOc72jlRM3E0OHN9Yr313jgeQ2T+zW+F03QFA==",
+      "version": "0.35.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linux-riscv64/-/sharp-linux-riscv64-0.35.4.tgz",
+      "integrity": "sha512-cPbNChoRURAWdebDIHSenxRpgEdy7JkPydSnUxRm9VvKD7m0/xVaR/8Fzlu81pk5nHEvHH87UZUA7cTtwnbJSA==",
       "cpu": [
         "riscv64"
       ],
       "dev": true,
-      "libc": [
-        "glibc"
-      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -962,20 +926,17 @@
         "url": "https://opencollective.com/libvips"
       },
       "optionalDependencies": {
-        "@img/sharp-libvips-linux-riscv64": "1.3.1"
+        "@img/sharp-libvips-linux-riscv64": "1.3.3"
       }
     },
     "node_modules/@img/sharp-linux-s390x": {
-      "version": "0.35.2",
-      "resolved": "https://registry.npmjs.org/@img/sharp-linux-s390x/-/sharp-linux-s390x-0.35.2.tgz",
-      "integrity": "sha512-E4fLLfRPzDLlEeDaTzI98OFLcv++WL5ChLLMwPoVd0CIoZQqupBSNbOisPL5am9XsbQ9T84+iiMpUvbFtkunbA==",
+      "version": "0.35.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linux-s390x/-/sharp-linux-s390x-0.35.4.tgz",
+      "integrity": "sha512-RY0JFY8Fd6RonCBtHz+DvadaPkXDSI1AUn6yWL9TipqkZ1vY8w8evqdgyDFnkm4/K1ve1TvZiaePP5oSd4+WVQ==",
       "cpu": [
         "s390x"
       ],
       "dev": true,
-      "libc": [
-        "glibc"
-      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -988,20 +949,17 @@
         "url": "https://opencollective.com/libvips"
       },
       "optionalDependencies": {
-        "@img/sharp-libvips-linux-s390x": "1.3.1"
+        "@img/sharp-libvips-linux-s390x": "1.3.3"
       }
     },
     "node_modules/@img/sharp-linux-x64": {
-      "version": "0.35.2",
-      "resolved": "https://registry.npmjs.org/@img/sharp-linux-x64/-/sharp-linux-x64-0.35.2.tgz",
-      "integrity": "sha512-gi0zFJJRLswfCZmHtJdikXPOc5u7qamSOS3NHedLqLd4W8Q0NqjdBr6TTRIgsfFjqfTsHFgdfvJ9LwqSgcHiAA==",
+      "version": "0.35.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linux-x64/-/sharp-linux-x64-0.35.4.tgz",
+      "integrity": "sha512-9qvvEAuk8k89TfWUoX2htWjbAMX8p+NxCppjpcg5k6xMsjhBQPTsoIh36h9Qde4WRuGpJeYnOjdosDn/cnv+OA==",
       "cpu": [
         "x64"
       ],
       "dev": true,
-      "libc": [
-        "glibc"
-      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -1014,20 +972,17 @@
         "url": "https://opencollective.com/libvips"
       },
       "optionalDependencies": {
-        "@img/sharp-libvips-linux-x64": "1.3.1"
+        "@img/sharp-libvips-linux-x64": "1.3.3"
       }
     },
     "node_modules/@img/sharp-linuxmusl-arm64": {
-      "version": "0.35.2",
-      "resolved": "https://registry.npmjs.org/@img/sharp-linuxmusl-arm64/-/sharp-linuxmusl-arm64-0.35.2.tgz",
-      "integrity": "sha512-siWbOW1u6HFnFLrp0waKyW7VEf7jYvcDWdrXEFa8AkdAQgEvuu5Fz8/Y70w9EeqAdwDtfU012BhEHHaDqvQNzg==",
+      "version": "0.35.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linuxmusl-arm64/-/sharp-linuxmusl-arm64-0.35.4.tgz",
+      "integrity": "sha512-KB5jxpfWQTr0nc3xdHtWChdbifHrBGsd2SM62Eyxrl8afikm+f5qGBU75SJIZBT/S1MC8XyacdlXBMSWq6OURA==",
       "cpu": [
         "arm64"
       ],
       "dev": true,
-      "libc": [
-        "musl"
-      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -1040,20 +995,17 @@
         "url": "https://opencollective.com/libvips"
       },
       "optionalDependencies": {
-        "@img/sharp-libvips-linuxmusl-arm64": "1.3.1"
+        "@img/sharp-libvips-linuxmusl-arm64": "1.3.3"
       }
     },
     "node_modules/@img/sharp-linuxmusl-x64": {
-      "version": "0.35.2",
-      "resolved": "https://registry.npmjs.org/@img/sharp-linuxmusl-x64/-/sharp-linuxmusl-x64-0.35.2.tgz",
-      "integrity": "sha512-YBqMMcjDi4QGYiSn4vNOYBhmlC4z5AXqkOUUqI2e0AFA4urNv4ESgOgwNl3K+4etQhha0twXlzeF20bbULm9Yg==",
+      "version": "0.35.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linuxmusl-x64/-/sharp-linuxmusl-x64-0.35.4.tgz",
+      "integrity": "sha512-f+eZJZIQNEEd26RPSW+76chwOf1XtA2Y/O+5ocVyLliHkeih3e+jhLVBdNTd2rS3IbNXK8+ug93Vf5ZXtF5Lxg==",
       "cpu": [
         "x64"
       ],
       "dev": true,
-      "libc": [
-        "musl"
-      ],
       "license": "Apache-2.0",
       "optional": true,
       "os": [
@@ -1066,18 +1018,18 @@
         "url": "https://opencollective.com/libvips"
       },
       "optionalDependencies": {
-        "@img/sharp-libvips-linuxmusl-x64": "1.3.1"
+        "@img/sharp-libvips-linuxmusl-x64": "1.3.3"
       }
     },
     "node_modules/@img/sharp-wasm32": {
-      "version": "0.35.2",
-      "resolved": "https://registry.npmjs.org/@img/sharp-wasm32/-/sharp-wasm32-0.35.2.tgz",
-      "integrity": "sha512-Mrv4JQNYVQ94xH+jzZ9r+gowleN8mv2FTgKT+PI6bx5C0G8TdNYndu161pg2i7uoBwxy2ImPMHrJOM2LZef7Bw==",
+      "version": "0.35.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-wasm32/-/sharp-wasm32-0.35.4.tgz",
+      "integrity": "sha512-zQnl4Kwp7Q6NHsENtU2T/00Zi+w3AQNwz3+UaTyVBy2FpXrzXzGjndpK61onhZjRtRpQXxCTeqw19bVyXOh7jA==",
       "dev": true,
       "license": "Apache-2.0 AND LGPL-3.0-or-later AND MIT",
       "optional": true,
       "dependencies": {
-        "@emnapi/runtime": "^1.11.1"
+        "@emnapi/runtime": "^1.11.3"
       },
       "engines": {
         "node": ">=20.9.0"
@@ -1087,9 +1039,9 @@
       }
     },
     "node_modules/@img/sharp-webcontainers-wasm32": {
-      "version": "0.35.2",
-      "resolved": "https://registry.npmjs.org/@img/sharp-webcontainers-wasm32/-/sharp-webcontainers-wasm32-0.35.2.tgz",
-      "integrity": "sha512-QNV27pxs9wpApEiCfvHM1RDoP1w1+2KrUWWDPEhEwg+latvOrfuhWrHWZKwdSFwU6jh3myjw/yOCRsUIuOft3g==",
+      "version": "0.35.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-webcontainers-wasm32/-/sharp-webcontainers-wasm32-0.35.4.tgz",
+      "integrity": "sha512-ESfNkywmCfPNyaZjxooddJQiQ+l/nTpGEOGthxiLnIHXC/CmcBixnfwUleX9mCz9ovrUUvKMap/pm8RYbzfwaA==",
       "cpu": [
         "wasm32"
       ],
@@ -1097,7 +1049,7 @@
       "license": "Apache-2.0",
       "optional": true,
       "dependencies": {
-        "@img/sharp-wasm32": "0.35.2"
+        "@img/sharp-wasm32": "0.35.4"
       },
       "engines": {
         "node": ">=20.9.0"
@@ -1107,9 +1059,9 @@
       }
     },
     "node_modules/@img/sharp-win32-arm64": {
-      "version": "0.35.2",
-      "resolved": "https://registry.npmjs.org/@img/sharp-win32-arm64/-/sharp-win32-arm64-0.35.2.tgz",
-      "integrity": "sha512-BiVRYc/t6/Vl3e1hBx0hugG4oN9Pydf4fgMSpxTQJmwGUg/YoXTWHiFeRymHfCZzifxu4F4rpk/I67D0LQ20wQ==",
+      "version": "0.35.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-win32-arm64/-/sharp-win32-arm64-0.35.4.tgz",
+      "integrity": "sha512-iNdlBX9gLVvqe2I3uIJSIKTq6wckP/DYxZtcqxm09x5Gi24DnFBmPAWZmr60ZyYMG0xlzo6goG3670ar+RXvRw==",
       "cpu": [
         "arm64"
       ],
@@ -1127,9 +1079,9 @@
       }
     },
     "node_modules/@img/sharp-win32-ia32": {
-      "version": "0.35.2",
-      "resolved": "https://registry.npmjs.org/@img/sharp-win32-ia32/-/sharp-win32-ia32-0.35.2.tgz",
-      "integrity": "sha512-YYEhx9PImCC7T0tI8JDMi4DB9LwLCXCU5OWNYEXAxh5Q1ShKkyC6byxzoBJ3gEFDnH2lQckWuDe70G7mB2XJog==",
+      "version": "0.35.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-win32-ia32/-/sharp-win32-ia32-0.35.4.tgz",
+      "integrity": "sha512-kqRsbaa5CS6KHlpxnN7WhE6vAAugXyZButpRdvDWetlv6Qv4N9WTcrWzF7tXfB9T7MsoadqdI8hmwLq6UlLvtw==",
       "cpu": [
         "ia32"
       ],
@@ -1147,9 +1099,9 @@
       }
     },
     "node_modules/@img/sharp-win32-x64": {
-      "version": "0.35.2",
-      "resolved": "https://registry.npmjs.org/@img/sharp-win32-x64/-/sharp-win32-x64-0.35.2.tgz",
-      "integrity": "sha512-imoOyBcoM/iiUr4J6VPpCNjPnjvP/Gks95898yB8YqoGGYmHYbOyCuNv9FMhFgtaiHFGbHW8bxKqRV6VjtXThQ==",
+      "version": "0.35.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-win32-x64/-/sharp-win32-x64-0.35.4.tgz",
+      "integrity": "sha512-XtmnYhBcrORsJ4XJngyzr/EWP0hRZLAZRFaApdKuviyqF78+ylxh2y06ZmtULAMOnObJ3ucpN0AcwSWnMowTRg==",
       "cpu": [
         "x64"
       ],
@@ -1352,16 +1304,16 @@
       }
     },
     "node_modules/miniflare": {
-      "version": "5.20260903.0-alpha",
-      "resolved": "https://registry.npmjs.org/miniflare/-/miniflare-5.20260903.0-alpha.tgz",
-      "integrity": "sha512-VCZIFxOqFXeibRBJWwTlppqbv2lkeO10IX3QBRGK9j1QiMAfH/OSsCvbjp1MslBMhVZmy2VTRlVaVnsKnbDp6A==",
+      "version": "5.20260911.1-alpha",
+      "resolved": "https://registry.npmjs.org/miniflare/-/miniflare-5.20260911.1-alpha.tgz",
+      "integrity": "sha512-7IDj9monoYcCPrS8HfcTt90T3pDwKGvNEAR1Y061KbJhBd5JkStOwOpHMUDFBo9PEbjWVDxPICAnXGNNV2LNfQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "@cspotcode/source-map-support": "0.8.1",
-        "sharp": "0.35.2",
+        "sharp": "0.35.4",
         "undici": "7.29.0",
-        "workerd": "1.20260903.1",
+        "workerd": "1.20260911.1",
         "ws": "8.21.0",
         "youch": "4.1.0-beta.10"
       },
@@ -1397,15 +1349,15 @@
       }
     },
     "node_modules/sharp": {
-      "version": "0.35.2",
-      "resolved": "https://registry.npmjs.org/sharp/-/sharp-0.35.2.tgz",
-      "integrity": "sha512-FVtFjtBCMiJS6yb5CX7Sop45WFMpeGw6oRKuJnXYgf/f1ms/D7LE/ZUSNxnW7rZ/dbslQWYkoqFHGPaDBtaK4w==",
+      "version": "0.35.4",
+      "resolved": "https://registry.npmjs.org/sharp/-/sharp-0.35.4.tgz",
+      "integrity": "sha512-n++8XWcj+jCOr2IOl7h8LbKnGBDY4aPbmprMONBNFdn0ImXqpGVv5zliDs0V9HbmbCQLpbuo2ej9rAoOQTvMDA==",
       "dev": true,
       "license": "Apache-2.0",
       "dependencies": {
         "@img/colour": "^1.1.0",
         "detect-libc": "^2.1.2",
-        "semver": "^7.8.4"
+        "semver": "^7.8.5"
       },
       "engines": {
         "node": ">=20.9.0"
@@ -1414,31 +1366,36 @@
         "url": "https://opencollective.com/libvips"
       },
       "optionalDependencies": {
-        "@img/sharp-darwin-arm64": "0.35.2",
-        "@img/sharp-darwin-x64": "0.35.2",
-        "@img/sharp-freebsd-wasm32": "0.35.2",
-        "@img/sharp-libvips-darwin-arm64": "1.3.1",
-        "@img/sharp-libvips-darwin-x64": "1.3.1",
-        "@img/sharp-libvips-linux-arm": "1.3.1",
-        "@img/sharp-libvips-linux-arm64": "1.3.1",
-        "@img/sharp-libvips-linux-ppc64": "1.3.1",
-        "@img/sharp-libvips-linux-riscv64": "1.3.1",
-        "@img/sharp-libvips-linux-s390x": "1.3.1",
-        "@img/sharp-libvips-linux-x64": "1.3.1",
-        "@img/sharp-libvips-linuxmusl-arm64": "1.3.1",
-        "@img/sharp-libvips-linuxmusl-x64": "1.3.1",
-        "@img/sharp-linux-arm": "0.35.2",
-        "@img/sharp-linux-arm64": "0.35.2",
-        "@img/sharp-linux-ppc64": "0.35.2",
-        "@img/sharp-linux-riscv64": "0.35.2",
-        "@img/sharp-linux-s390x": "0.35.2",
-        "@img/sharp-linux-x64": "0.35.2",
-        "@img/sharp-linuxmusl-arm64": "0.35.2",
-        "@img/sharp-linuxmusl-x64": "0.35.2",
-        "@img/sharp-webcontainers-wasm32": "0.35.2",
-        "@img/sharp-win32-arm64": "0.35.2",
-        "@img/sharp-win32-ia32": "0.35.2",
-        "@img/sharp-win32-x64": "0.35.2"
+        "@img/sharp-darwin-arm64": "0.35.4",
+        "@img/sharp-darwin-x64": "0.35.4",
+        "@img/sharp-freebsd-wasm32": "0.35.4",
+        "@img/sharp-libvips-darwin-arm64": "1.3.3",
+        "@img/sharp-libvips-darwin-x64": "1.3.3",
+        "@img/sharp-libvips-linux-arm": "1.3.3",
+        "@img/sharp-libvips-linux-arm64": "1.3.3",
+        "@img/sharp-libvips-linux-ppc64": "1.3.3",
+        "@img/sharp-libvips-linux-riscv64": "1.3.3",
+        "@img/sharp-libvips-linux-s390x": "1.3.3",
+        "@img/sharp-libvips-linux-x64": "1.3.3",
+        "@img/sharp-libvips-linuxmusl-arm64": "1.3.3",
+        "@img/sharp-libvips-linuxmusl-x64": "1.3.3",
+        "@img/sharp-linux-arm": "0.35.4",
+        "@img/sharp-linux-arm64": "0.35.4",
+        "@img/sharp-linux-ppc64": "0.35.4",
+        "@img/sharp-linux-riscv64": "0.35.4",
+        "@img/sharp-linux-s390x": "0.35.4",
+        "@img/sharp-linux-x64": "0.35.4",
+        "@img/sharp-linuxmusl-arm64": "0.35.4",
+        "@img/sharp-linuxmusl-x64": "0.35.4",
+        "@img/sharp-webcontainers-wasm32": "0.35.4",
+        "@img/sharp-win32-arm64": "0.35.4",
+        "@img/sharp-win32-ia32": "0.35.4",
+        "@img/sharp-win32-x64": "0.35.4"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        }
       }
     },
     "node_modules/supports-color": {
@@ -1478,14 +1435,15 @@
       "integrity": "sha512-i7qRCmY42zmCwnYlh9H2SvLEypEFGye5iRmEMKjcGi7zk9UquigRjFtTLz0TYqr0ZGLZhaMHl/foy1bZR+Cwlw==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "pathe": "^2.0.3"
       }
     },
     "node_modules/workerd": {
-      "version": "1.20260903.1",
-      "resolved": "https://registry.npmjs.org/workerd/-/workerd-1.20260903.1.tgz",
-      "integrity": "sha512-xJzt2RnCy7ulOULmZy/4JLbEPg1uisp9lVoOUsEz+UVhDsTmrSQ0rBXZMGcXuhr2HCGKs89bg8nnbbzvBSX1Ig==",
+      "version": "1.20260911.1",
+      "resolved": "https://registry.npmjs.org/workerd/-/workerd-1.20260911.1.tgz",
+      "integrity": "sha512-vRr8QdBxueQOZJO1hRCI73EZlix87IAyBAcSyI3rA1VB+6oxjw3oaqzYnIV8C4IOPtUgihbdMAgzkb5GM4V7DQ==",
       "dev": true,
       "hasInstallScript": true,
       "license": "Apache-2.0",
@@ -1496,17 +1454,17 @@
         "node": ">=16"
       },
       "optionalDependencies": {
-        "@cloudflare/workerd-darwin-64": "1.20260903.1",
-        "@cloudflare/workerd-darwin-arm64": "1.20260903.1",
-        "@cloudflare/workerd-linux-64": "1.20260903.1",
-        "@cloudflare/workerd-linux-arm64": "1.20260903.1",
-        "@cloudflare/workerd-windows-64": "1.20260903.1"
+        "@cloudflare/workerd-darwin-64": "1.20260911.1",
+        "@cloudflare/workerd-darwin-arm64": "1.20260911.1",
+        "@cloudflare/workerd-linux-64": "1.20260911.1",
+        "@cloudflare/workerd-linux-arm64": "1.20260911.1",
+        "@cloudflare/workerd-windows-64": "1.20260911.1"
       }
     },
     "node_modules/wrangler": {
-      "version": "4.129.0",
-      "resolved": "https://registry.npmjs.org/wrangler/-/wrangler-4.129.0.tgz",
-      "integrity": "sha512-PGPvs9UPoFrwxT0VogpESSZGvZIctAuTK3wGsLLPHtHsSgS85kNdvtpa2d14UzG8gwLWD64XUGFPGG9tOXG9VQ==",
+      "version": "4.131.2",
+      "resolved": "https://registry.npmjs.org/wrangler/-/wrangler-4.131.2.tgz",
+      "integrity": "sha512-jmkGE7monbPKyYQr1FPQN+SARVhddqw2fhXOmTKCw4lroqlFGSS6rit/RTvPi/qzNLKrXxkS8DhWXasJnStplg==",
       "dev": true,
       "license": "MIT OR Apache-2.0",
       "dependencies": {
@@ -1514,10 +1472,10 @@
         "@cloudflare/unenv-preset": "2.16.1",
         "blake3-wasm": "2.1.5",
         "esbuild": "0.28.1",
-        "miniflare": "5.20260903.0-alpha",
+        "miniflare": "5.20260911.1-alpha",
         "path-to-regexp": "6.3.0",
         "unenv": "2.0.0-rc.24",
-        "workerd": "1.20260903.1"
+        "workerd": "1.20260911.1"
       },
       "bin": {
         "cf-wrangler": "bin/cf-wrangler.js",
@@ -1531,7 +1489,7 @@
         "fsevents": "2.3.3"
       },
       "peerDependencies": {
-        "@cloudflare/workers-types": "^5.20260903.1"
+        "@cloudflare/workers-types": "^5.20260911.1"
       },
       "peerDependenciesMeta": {
         "@cloudflare/workers-types": {
diff --git a/scripts/build-site.mjs b/scripts/build-site.mjs
index a23371e..998849e 100644
--- a/scripts/build-site.mjs
+++ b/scripts/build-site.mjs
@@ -784,7 +784,7 @@ function downloadPageContent() {
   </div>
 </section>
 ${fileRows}
-<p>v0.1.45 is the current Windows release and adds the Zoom Talkback dock and the panelist loudness readiness board over v0.1.44. Existing installs are offered it by the in-plugin update check.</p>
+<p>See the <a href="${RELEASES_LATEST}">Windows release notes</a> for the latest changes. Existing installs are offered new stable releases by the in-plugin update check.</p>
 <section id="macos">
 <h2>macOS &mdash; Apple Silicon beta v${MAC_VERSION}</h2>
 <p>Developer ID signed, notarized by Apple, and stapled. The macOS installer is built and notarized separately from the Windows release, so its version can trail Windows; it carries the same raw-media recovery, waiting-room and video-quality fixes and the panelist loudness readiness board.</p>
diff --git a/src/iso-audio-reader.cpp b/src/iso-audio-reader.cpp
new file mode 100644
index 0000000..18b6f77
--- /dev/null
+++ b/src/iso-audio-reader.cpp
@@ -0,0 +1,72 @@
+#include "iso-audio-reader.h"
+#include <algorithm>
+void IsoAudioReader::read(uint32_t bytes, uint32_t generation)
+{
+    // Copy and release the tap lock before calling the recorder: Stop acquires
+    // the recorder lock first, and a callback must never reverse that order.
+    struct Packet { std::vector<uint8_t> pcm; uint32_t rate; uint16_t channels; uint64_t ns; };
+    std::vector<Packet> packets;
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        if (m_closed || !m_error.empty() || !bytes || bytes > 1024*1024) return;
+        const auto base = IPC_SHM_PREFIX + m_uuid + "_audio";
+        const auto name = shm_region_name(base, generation);
+        if (m_generation != generation || m_region.size < shm_audio_region_bytes(bytes)) {
+            shm_region_destroy(m_region); m_started = false;
+        }
+        if (!m_region.ptr) {
+            if (!shm_region_open_readwrite(m_region, name, shm_audio_region_bytes(bytes))) return;
+            m_generation = generation;
+        }
+        auto *ring = static_cast<ShmAudioHeader *>(m_region.ptr);
+        if (ring->slot_count != kAudioRingSlots || !ring->slot_bytes || ring->slot_bytes > 1024*1024) {
+            m_error = "ISO audio ring format is invalid"; return;
+        }
+        const auto needed = shm_audio_region_bytes(ring->slot_bytes);
+        if (needed > m_region.size) {
+            shm_region_destroy(m_region);
+            if (!shm_region_open_readwrite(m_region, name, needed)) return;
+            ring = static_cast<ShmAudioHeader *>(m_region.ptr);
+        }
+        if (ring->slot_count != kAudioRingSlots || ring->slot_bytes > 1024*1024 ||
+            shm_audio_region_bytes(ring->slot_bytes) > m_region.size) {
+            m_error = "ISO audio ring resized beyond mapped bounds"; return;
+        }
+        if (!m_started) {
+            // This UUID is unique to the recording. Preserve its first buffers.
+            m_index = ring->write_index > kAudioRingSlots ? ring->write_index-kAudioRingSlots : 0;
+            m_started = true;
+        }
+        for (int pass=0; pass<16; ++pass) {
+            const auto end = ring->write_index;
+            if (end-m_index > kAudioRingSlots) {
+                m_error = "ISO isolated audio ring overrun"; audio_ring_reader_abandon(ring); break;
+            }
+            while (m_index != end) {
+                const auto index = m_index++;
+                const auto *slot = reinterpret_cast<const ShmAudioSlot *>(
+                    static_cast<const char *>(m_region.ptr)+shm_audio_slot_offset(*ring,index%kAudioRingSlots));
+                for (int attempt=0; attempt<3; ++attempt) {
+                    const auto seq = slot->sequence;
+                    std::atomic_thread_fence(std::memory_order_acquire);
+                    if (seq&1) continue;
+                    const auto len=slot->byte_len, participant=slot->participant_id;
+                    const auto rate=ring->sample_rate; const auto channels=ring->channels;
+                    if (!len || len>ring->slot_bytes) break;
+                    m_pcm.resize(len); std::memcpy(m_pcm.data(),slot+1,len);
+                    std::atomic_thread_fence(std::memory_order_acquire);
+                    if (slot->sequence!=seq || ring->write_index-index>kAudioRingSlots) continue;
+                    if (participant != m_participant) {
+                        m_error="ISO audio participant attribution mismatch"; break;
+                    }
+                    packets.push_back({m_pcm,rate,channels,m_now()});
+                    break;
+                }
+            }
+            if (audio_ring_reader_done(ring,m_index)) break;
+            if (pass==15) audio_ring_reader_abandon(ring);
+        }
+    }
+    for (const auto &packet:packets)
+        m_deliver(packet.pcm.data(),uint32_t(packet.pcm.size()),packet.rate,packet.channels,packet.ns);
+}
diff --git a/src/iso-audio-reader.h b/src/iso-audio-reader.h
new file mode 100644
index 0000000..c70a17a
--- /dev/null
+++ b/src/iso-audio-reader.h
@@ -0,0 +1,27 @@
+#pragma once
+#include "engine-ipc.h"
+#include <functional>
+#include <mutex>
+#include <vector>
+
+class IsoAudioReader {
+public:
+    using Deliver = std::function<void(const uint8_t *, uint32_t, uint32_t, uint16_t, uint64_t)>;
+    using Now = std::function<uint64_t()>;
+    IsoAudioReader(std::string uuid, uint32_t participant, Deliver deliver, Now now)
+        : m_uuid(std::move(uuid)), m_participant(participant), m_deliver(std::move(deliver)), m_now(std::move(now)) {}
+    ~IsoAudioReader() { shm_region_destroy(m_region); }
+    void read(uint32_t bytes, uint32_t generation);
+    std::string error() const { std::lock_guard<std::mutex> lock(m_mutex); return m_error; }
+protected:
+    std::string m_uuid;
+    uint32_t m_participant;
+    Deliver m_deliver;
+    mutable std::mutex m_mutex;
+    ShmRegion m_region{};
+    uint32_t m_generation = 0, m_index = 0;
+    bool m_started = false, m_closed = false;
+    std::vector<uint8_t> m_pcm;
+    std::string m_error;
+    Now m_now;
+};
diff --git a/src/iso-audio-routing.h b/src/iso-audio-routing.h
new file mode 100644
index 0000000..288c47c
--- /dev/null
+++ b/src/iso-audio-routing.h
@@ -0,0 +1,15 @@
+#pragma once
+#include <cstdint>
+
+inline bool audio_receives_mix(bool isolated, bool audience, bool recording)
+{
+    return !isolated && !audience && !recording;
+}
+inline bool audio_receives_participant(uint32_t target, uint32_t speaker, bool isolated, bool recording)
+{
+    return target != 0 && target == speaker && (isolated || recording);
+}
+inline bool audio_claims_audience(bool isolated, bool recording)
+{
+    return isolated && !recording;
+}
diff --git a/src/iso-audio-tap.cpp b/src/iso-audio-tap.cpp
new file mode 100644
index 0000000..42e7c3a
--- /dev/null
+++ b/src/iso-audio-tap.cpp
@@ -0,0 +1,37 @@
+#include "iso-audio-tap.h"
+#include "zoom-engine-client.h"
+#include <util/platform.h>
+#include <algorithm>
+
+IsoAudioTap::~IsoAudioTap() { stop(); }
+bool IsoAudioTap::start()
+{
+    const std::weak_ptr<IsoAudioTap> weak = shared_from_this();
+    ZoomEngineClient::instance().register_source(m_uuid, {
+        {}, [weak](uint32_t bytes, uint32_t, uint32_t gen) {
+            if (auto tap = weak.lock()) tap->read(bytes, gen);
+        }, [weak] {
+            if (auto tap = weak.lock()) {
+                std::lock_guard<std::mutex> lock(tap->m_mutex);
+                shm_region_destroy(tap->m_region);
+                tap->m_started = false;
+                tap->m_error = "ISO audio engine restarted; stop and restart ISO recording";
+            }
+        }});
+    if (ZoomEngineClient::instance().subscribe_audio(m_uuid, m_participant, true, false, true))
+        return true;
+    std::lock_guard<std::mutex> lock(m_mutex);
+    m_error = "ISO isolated audio subscription could not be sent";
+    return false;
+}
+void IsoAudioTap::stop()
+{
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        if (m_closed) return;
+        m_closed = true;
+        shm_region_destroy(m_region);
+    }
+    ZoomEngineClient::instance().unregister_source(m_uuid);
+    ZoomEngineClient::instance().unsubscribe(m_uuid);
+}
diff --git a/src/iso-audio-tap.h b/src/iso-audio-tap.h
new file mode 100644
index 0000000..7b1efe0
--- /dev/null
+++ b/src/iso-audio-tap.h
@@ -0,0 +1,11 @@
+#pragma once
+#include "iso-audio-reader.h"
+#include <memory>
+
+class IsoAudioTap : public IsoAudioReader, public std::enable_shared_from_this<IsoAudioTap> {
+public:
+    using IsoAudioReader::IsoAudioReader;
+    ~IsoAudioTap();
+    bool start();
+    void stop();
+};
diff --git a/src/iso-av-mux.h b/src/iso-av-mux.h
new file mode 100644
index 0000000..fdc34da
--- /dev/null
+++ b/src/iso-av-mux.h
@@ -0,0 +1,114 @@
+#pragma once
+
+// Streaming Matroska transport to FFmpeg over one pipe. One fixed I420 track
+// and one PCM S16LE stereo track, both on a microsecond clock. This is an
+// internal transport; FFmpeg writes the user's single H.264/AAC MP4.
+// Codec mapping: https://www.matroska.org/technical/codec_specs.html
+#include <cstdint>
+#include <cstring>
+#include <vector>
+
+namespace iso_av
+{
+using Bytes = std::vector<uint8_t>;
+inline void be(Bytes &out, uint64_t value, int count)
+{
+    for (int i = count - 1; i >= 0; --i)
+        out.push_back(uint8_t(value >> (i * 8)));
+}
+inline void element(Bytes &out, uint32_t id, const Bytes &value)
+{
+    int n = id > 0xffffff ? 4 : id > 0xffff ? 3 : id > 0xff ? 2 : 1;
+    be(out, id, n);
+    // Fixed eight-byte EBML size, valid for every element in this transport.
+    be(out, (uint64_t(1) << 56) | value.size(), 8);
+    out.insert(out.end(), value.begin(), value.end());
+}
+inline void number(Bytes &out, uint32_t id, uint64_t value)
+{
+    Bytes b;
+    be(b, value, 8);
+    element(out, id, b);
+}
+inline void string(Bytes &out, uint32_t id, const char *value)
+{
+    element(out, id, Bytes(value, value + std::strlen(value)));
+}
+inline Bytes header()
+{
+    Bytes out, ebml, info, tracks, video, audio, v, a;
+    number(ebml, 0x4286, 1);
+    number(ebml, 0x42f7, 1);
+    number(ebml, 0x42f2, 4);
+    number(ebml, 0x42f3, 8);
+    string(ebml, 0x4282, "matroska");
+    number(ebml, 0x4287, 4);
+    number(ebml, 0x4285, 2);
+    element(out, 0x1a45dfa3, ebml);
+    be(out, 0x18538067, 4);
+    be(out, 0x01ffffffffffffffULL, 8); // unknown segment size
+    number(info, 0x2ad7b1, 1000);      // one tick = one microsecond
+    string(info, 0x4d80, "CoreVideo");
+    string(info, 0x5741, "CoreVideo");
+    element(out, 0x1549a966, info);
+    number(video, 0xd7, 1);
+    number(video, 0x73c5, 1);
+    number(video, 0x83, 1);
+    string(video, 0x86, "V_MS/VFW/FOURCC");
+    Bytes bitmap(40, 0);
+    const auto le = [&](size_t at, uint32_t value) {
+        for (int i = 0; i < 4; ++i)
+            bitmap[at + i] = uint8_t(value >> (8 * i));
+    };
+    le(0, 40);
+    le(4, 1920);
+    le(8, 1080);
+    bitmap[12] = 1;
+    bitmap[14] = 12;
+    le(16, 0x30323449);
+    le(20, 1920 * 1080 * 3 / 2); // I420 BITMAPINFOHEADER
+    element(video, 0x63a2, bitmap);
+    number(video, 0x23e383, 33333333);
+    number(v, 0xb0, 1920);
+    number(v, 0xba, 1080);
+    // The engine normalizes Zoom pixels to full-range BT.709 before delivery.
+    Bytes colour;
+    number(colour, 0x55b1, 1);
+    number(colour, 0x55b9, 2);
+    number(colour, 0x55ba, 1);
+    number(colour, 0x55bb, 1);
+    element(v, 0x55b0, colour);
+    element(video, 0xe0, v);
+    element(tracks, 0xae, video);
+    number(audio, 0xd7, 2);
+    number(audio, 0x73c5, 2);
+    number(audio, 0x83, 2);
+    string(audio, 0x86, "A_PCM/INT/LIT");
+    double rate = 48000;
+    uint64_t bits;
+    std::memcpy(&bits, &rate, 8);
+    Bytes frequency;
+    be(frequency, bits, 8);
+    element(a, 0xb5, frequency);
+    number(a, 0x9f, 2);
+    number(a, 0x6264, 16);
+    element(audio, 0xe1, a);
+    element(tracks, 0xae, audio);
+    element(out, 0x1654ae6b, tracks);
+    return out;
+}
+inline Bytes frame(uint64_t index, const Bytes &video, const Bytes &audio)
+{
+    Bytes cluster, block;
+    number(cluster, 0xe7, index * 1000000ULL / 30);
+    block = {0x81, 0, 0, 0x80};
+    block.insert(block.end(), video.begin(), video.end());
+    element(cluster, 0xa3, block);
+    block = {0x82, 0, 0, 0x80};
+    block.insert(block.end(), audio.begin(), audio.end());
+    element(cluster, 0xa3, block);
+    Bytes out;
+    element(out, 0x1f43b675, cluster);
+    return out;
+}
+} // namespace iso_av
diff --git a/src/iso-d3d-conformer.h b/src/iso-d3d-conformer.h
new file mode 100644
index 0000000..018232d
--- /dev/null
+++ b/src/iso-d3d-conformer.h
@@ -0,0 +1,204 @@
+#pragma once
+
+#include "iso-frame-conform.h"
+#include <d3d11.h>
+#include <d3dcompiler.h>
+#include <string>
+#include <wrl/client.h>
+
+namespace corevideo::modules
+{
+
+// Adapted from CoreVideo Pro's D3DIsoFrameConformer. This transport needs planar
+// I420 (Pro's writer takes NV12), with full-range black. Owned by one ISO worker;
+// no immediate context is shared with the live compositor.
+class D3DIsoFrameConformer
+{
+  public:
+    explicit D3DIsoFrameConformer(bool warpForTest = false) : warpForTest_(warpForTest) {}
+    bool prepare(std::string &error) { return device_ || initialize(error); }
+
+    bool convert(const std::vector<uint8_t> &input, int sw, int sh, int dw, int dh,
+                 std::vector<uint8_t> &output, std::string &error)
+    {
+        if (sw < 2 || sh < 2 || dw < 2 || dh < 2 || sw > 8192 || sh > 8192 || dw > 8192 ||
+            dh > 8192 || ((sw | sh | dw | dh) & 1) || input.size() < size_t(sw) * sh * 3 / 2) {
+            error = "invalid I420 conformance dimensions or payload";
+            return false;
+        }
+        if (!device_ && !initialize(error))
+            return false;
+        const UINT inputBytes = UINT(size_t(sw) * sh * 3 / 2);
+        const UINT outputBytes = UINT(size_t(dw) * dh * 3 / 2);
+        if ((inputBytes + 3u) / 4u * 4u != inputCapacity_ ||
+            (outputBytes + 3u) / 4u * 4u != outputCapacity_) {
+            if (!allocate(inputBytes, outputBytes, error))
+                return false;
+        }
+        D3D11_MAPPED_SUBRESOURCE mapped{};
+        if (FAILED(context_->Map(input_.Get(), 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped))) {
+            error = "map ISO GPU upload";
+            return false;
+        }
+        std::memcpy(mapped.pData, input.data(), inputBytes);
+        if (inputCapacity_ > inputBytes)
+            std::memset(static_cast<uint8_t *>(mapped.pData) + inputBytes, 0,
+                        inputCapacity_ - inputBytes);
+        context_->Unmap(input_.Get(), 0);
+        const auto fit = isoFitRect(sw, sh, dw, dh);
+        const UINT groups = (outputCapacity_ / 4u + 255u) / 256u;
+        const UINT groupsX = std::min(groups, 65535u);
+        const UINT constants[12] = {UINT(sw),    UINT(sh),    UINT(dw),        UINT(dh),
+                                    UINT(fit.x), UINT(fit.y), UINT(fit.width), UINT(fit.height),
+                                    inputBytes,  outputBytes, groupsX * 256u,  0};
+        context_->UpdateSubresource(constants_.Get(), 0, nullptr, constants, 0, 0);
+        ID3D11ShaderResourceView *srv = inputView_.Get();
+        ID3D11UnorderedAccessView *uav = outputView_.Get();
+        ID3D11Buffer *cb = constants_.Get();
+        context_->CSSetShader(shader_.Get(), nullptr, 0);
+        context_->CSSetShaderResources(0, 1, &srv);
+        context_->CSSetUnorderedAccessViews(0, 1, &uav, nullptr);
+        context_->CSSetConstantBuffers(0, 1, &cb);
+        context_->Dispatch(groupsX, (groups + groupsX - 1) / groupsX, 1);
+        srv = nullptr;
+        uav = nullptr;
+        context_->CSSetShaderResources(0, 1, &srv);
+        context_->CSSetUnorderedAccessViews(0, 1, &uav, nullptr);
+        context_->CopyResource(readback_.Get(), output_.Get());
+        if (FAILED(context_->Map(readback_.Get(), 0, D3D11_MAP_READ, 0, &mapped))) {
+            error = "map ISO GPU readback";
+            return false;
+        }
+        output.resize(outputBytes);
+        std::memcpy(output.data(), mapped.pData, outputBytes);
+        context_->Unmap(readback_.Get(), 0);
+        return true;
+    }
+
+  private:
+    template <class T> using Ptr = Microsoft::WRL::ComPtr<T>;
+    bool initialize(std::string &error)
+    {
+        D3D_FEATURE_LEVEL level{};
+        const D3D_FEATURE_LEVEL requested[] = {D3D_FEATURE_LEVEL_11_0};
+        if (FAILED(D3D11CreateDevice(
+                nullptr, warpForTest_ ? D3D_DRIVER_TYPE_WARP : D3D_DRIVER_TYPE_HARDWARE, nullptr, 0,
+                requested, 1, D3D11_SDK_VERSION, &device_, &level, &context_))) {
+            error = "create ISO GPU conformance device";
+            return false;
+        }
+        // Four output bytes per invocation avoid sub-word UAV write races. All
+        // box bounds, rounding, chroma alignment, and bar levels match the oracle.
+        static constexpr char source[] = R"(
+ByteAddressBuffer src : register(t0);
+RWByteAddressBuffer dst : register(u0);
+cbuffer Parameters : register(b0) { uint4 dims; uint4 fit; uint4 sizes; };
+uint byteAt(uint i) { return (src.Load(i & ~3u) >> ((i & 3u) * 8u)) & 255u; }
+uint box(uint offset, uint pw, uint ph, uint x, uint y, uint rw, uint rh) {
+  uint x0=x*pw/rw, x1=min(pw,max(x0+1,(x+1)*pw/rw));
+  uint y0=y*ph/rh, y1=min(ph,max(y0+1,(y+1)*ph/rh));
+  uint total=0, count=(x1-x0)*(y1-y0);
+  for(uint sy=y0;sy<y1;++sy) for(uint sx=x0;sx<x1;++sx) total+=byteAt(offset+sy*pw+sx);
+  return (total+count/2)/count;
+}
+uint pixel(uint i) {
+  if(i>=sizes.y) return 0;
+  uint luma=dims.z*dims.w;
+  if(i<luma) {
+    uint x=i%dims.z,y=i/dims.z;
+    if(x<fit.x || x>=fit.x+fit.z || y<fit.y || y>=fit.y+fit.w) return 0;
+    return box(0,dims.x,dims.y,x-fit.x,y-fit.y,fit.z,fit.w);
+  }
+  uint cl=luma/4,j=i-luma,plane=j/cl,p=j%cl,x=p%(dims.z/2),y=p/(dims.z/2);
+  if(x<fit.x/2 || x>=(fit.x+fit.z)/2 || y<fit.y/2 || y>=(fit.y+fit.w)/2) return 128;
+  uint sl=dims.x*dims.y;
+  return box(sl+plane*(sl/4),dims.x/2,dims.y/2,x-fit.x/2,y-fit.y/2,fit.z/2,fit.w/2);
+}
+[numthreads(256,1,1)] void main(uint3 tid : SV_DispatchThreadID) {
+  uint at=(tid.x+tid.y*sizes.z)*4;
+  if(at>=sizes.y) return;
+  dst.Store(at,pixel(at)|(pixel(at+1)<<8)|(pixel(at+2)<<16)|(pixel(at+3)<<24));
+})";
+        Ptr<ID3DBlob> code, diagnostics;
+        const HRESULT compiled = D3DCompile(
+            source, sizeof(source) - 1, "IsoBoxConform", nullptr, nullptr, "main", "cs_5_0",
+            D3DCOMPILE_ENABLE_STRICTNESS | D3DCOMPILE_OPTIMIZATION_LEVEL3, 0, &code, &diagnostics);
+        if (FAILED(compiled) ||
+            FAILED(device_->CreateComputeShader(code->GetBufferPointer(), code->GetBufferSize(),
+                                                nullptr, &shader_))) {
+            error = "compile ISO GPU box filter";
+            device_.Reset();
+            context_.Reset();
+            return false;
+        }
+        D3D11_BUFFER_DESC desc{};
+        desc.ByteWidth = 48;
+        desc.Usage = D3D11_USAGE_DEFAULT;
+        desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
+        if (FAILED(device_->CreateBuffer(&desc, nullptr, &constants_))) {
+            error = "create ISO GPU constants";
+            device_.Reset();
+            context_.Reset();
+            return false;
+        }
+        return true;
+    }
+    bool allocate(UINT inBytes, UINT outBytes, std::string &error)
+    {
+        inputView_.Reset();
+        outputView_.Reset();
+        input_.Reset();
+        output_.Reset();
+        readback_.Reset();
+        inputCapacity_ = outputCapacity_ = 0;
+        D3D11_BUFFER_DESC desc{};
+        desc.ByteWidth = (inBytes + 3u) / 4u * 4u;
+        desc.Usage = D3D11_USAGE_DYNAMIC;
+        desc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
+        desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
+        desc.MiscFlags = D3D11_RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS;
+        HRESULT hr = device_->CreateBuffer(&desc, nullptr, &input_);
+        D3D11_SHADER_RESOURCE_VIEW_DESC srv{};
+        srv.Format = DXGI_FORMAT_R32_TYPELESS;
+        srv.ViewDimension = D3D11_SRV_DIMENSION_BUFFEREX;
+        srv.BufferEx.NumElements = desc.ByteWidth / 4;
+        srv.BufferEx.Flags = D3D11_BUFFEREX_SRV_FLAG_RAW;
+        if (SUCCEEDED(hr))
+            hr = device_->CreateShaderResourceView(input_.Get(), &srv, &inputView_);
+        desc.ByteWidth = (outBytes + 3u) / 4u * 4u;
+        desc.Usage = D3D11_USAGE_DEFAULT;
+        desc.BindFlags = D3D11_BIND_UNORDERED_ACCESS;
+        desc.CPUAccessFlags = 0;
+        if (SUCCEEDED(hr))
+            hr = device_->CreateBuffer(&desc, nullptr, &output_);
+        D3D11_UNORDERED_ACCESS_VIEW_DESC uav{};
+        uav.Format = DXGI_FORMAT_R32_TYPELESS;
+        uav.ViewDimension = D3D11_UAV_DIMENSION_BUFFER;
+        uav.Buffer.NumElements = desc.ByteWidth / 4;
+        uav.Buffer.Flags = D3D11_BUFFER_UAV_FLAG_RAW;
+        if (SUCCEEDED(hr))
+            hr = device_->CreateUnorderedAccessView(output_.Get(), &uav, &outputView_);
+        desc.Usage = D3D11_USAGE_STAGING;
+        desc.BindFlags = 0;
+        desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
+        desc.MiscFlags = 0;
+        if (SUCCEEDED(hr))
+            hr = device_->CreateBuffer(&desc, nullptr, &readback_);
+        if (FAILED(hr)) {
+            error = "allocate ISO GPU conformance buffers";
+            return false;
+        }
+        inputCapacity_ = (inBytes + 3u) / 4u * 4u;
+        outputCapacity_ = (outBytes + 3u) / 4u * 4u;
+        return true;
+    }
+    bool warpForTest_ = false;
+    UINT inputCapacity_ = 0, outputCapacity_ = 0;
+    Ptr<ID3D11Device> device_;
+    Ptr<ID3D11DeviceContext> context_;
+    Ptr<ID3D11ComputeShader> shader_;
+    Ptr<ID3D11Buffer> input_, output_, readback_, constants_;
+    Ptr<ID3D11ShaderResourceView> inputView_;
+    Ptr<ID3D11UnorderedAccessView> outputView_;
+};
+} // namespace corevideo::modules
diff --git a/src/iso-feed-selection.h b/src/iso-feed-selection.h
new file mode 100644
index 0000000..0601539
--- /dev/null
+++ b/src/iso-feed-selection.h
@@ -0,0 +1,11 @@
+#pragma once
+#include <algorithm>
+#include <string>
+#include <vector>
+
+inline bool iso_feed_selected(const std::vector<std::string> &selected,
+                              const std::string &uuid, bool routed, bool excluded)
+{
+    return routed && !excluded && !uuid.empty() &&
+           std::find(selected.begin(), selected.end(), uuid) != selected.end();
+}
diff --git a/src/iso-frame-conform.h b/src/iso-frame-conform.h
new file mode 100644
index 0000000..52e2ec8
--- /dev/null
+++ b/src/iso-frame-conform.h
@@ -0,0 +1,47 @@
+#pragma once
+
+// Aspect-fit geometry adapted from CoreVideo Pro IsoFrameConform.h.
+// ISO output is always 1920x1080; chroma-aligned bars preserve aspect ratio.
+#include <algorithm>
+#include <cstdint>
+#include <cstring>
+#include <vector>
+
+namespace corevideo::modules
+{
+
+struct IsoFitRect {
+    int x = 0;
+    int y = 0;
+    int width = 0;
+    int height = 0;
+};
+
+// Largest centred rect of the source's aspect that fits the destination, with
+// every edge EVEN: I420 and NV12 carry chroma at half resolution, so an odd
+// origin or extent splits a chroma sample across the letterbox edge and fringes
+// it. A degenerate input returns an empty rect rather than dividing by zero.
+[[nodiscard]] inline IsoFitRect isoFitRect(int srcW, int srcH, int dstW, int dstH)
+{
+    if (srcW <= 0 || srcH <= 0 || dstW <= 0 || dstH <= 0) {
+        return {};
+    }
+    const auto even = [](int value) { return value & ~1; };
+    // Compare aspects in integer cross-products: no float, no rounding drift.
+    const long long srcAspect = static_cast<long long>(srcW) * dstH;
+    const long long dstAspect = static_cast<long long>(dstW) * srcH;
+    int width = dstW;
+    int height = dstH;
+    if (srcAspect > dstAspect) {
+        // Source is wider: full width, bars top and bottom.
+        height = static_cast<int>((static_cast<long long>(dstW) * srcH + srcW / 2) / srcW);
+    } else if (srcAspect < dstAspect) {
+        // Source is taller: full height, bars left and right.
+        width = static_cast<int>((static_cast<long long>(dstH) * srcW + srcH / 2) / srcH);
+    }
+    width = std::max(2, std::min(even(width), even(dstW)));
+    height = std::max(2, std::min(even(height), even(dstH)));
+    return {even((dstW - width) / 2), even((dstH - height) / 2), width, height};
+}
+
+} // namespace corevideo::modules
diff --git a/src/iso-provider-policy.h b/src/iso-provider-policy.h
new file mode 100644
index 0000000..8c4a324
--- /dev/null
+++ b/src/iso-provider-policy.h
@@ -0,0 +1,17 @@
+#pragma once
+#include <cstdint>
+#include <string>
+
+// One provider per participant stream prevents duplicate OBS sources from
+// doubling audio. An alternate may take over after a 250 ms delivery gap.
+inline bool iso_take_provider(std::string &owner, uint64_t &last, const std::string &source,
+                              uint64_t now)
+{
+    if (now <= last)
+        return false;
+    if (!owner.empty() && owner != source && now - last < 250000000ULL)
+        return false;
+    owner = source;
+    last = now;
+    return true;
+}
diff --git a/src/iso-track-writer.cpp b/src/iso-track-writer.cpp
new file mode 100644
index 0000000..40a62ed
--- /dev/null
+++ b/src/iso-track-writer.cpp
@@ -0,0 +1,329 @@
+#include "iso-track-writer.h"
+#include "iso-av-mux.h"
+#include "iso-frame-conform.h"
+#ifdef _WIN32
+#include "iso-d3d-conformer.h"
+#else
+#include <media-io/video-scaler.h>
+#endif
+#include <algorithm>
+#include <chrono>
+#include <cstring>
+#include <stdexcept>
+#include <media-io/audio-resampler.h>
+
+IsoTrackWriter::IsoTrackWriter(Config config)
+    : m_config(std::move(config)), m_thread([this] { run(); })
+{
+}
+IsoTrackWriter::~IsoTrackWriter()
+{
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        m_abort = true;
+    }
+    m_cv.notify_all();
+    if (m_thread.joinable())
+        m_thread.join();
+}
+void IsoTrackWriter::fail(const std::string &error)
+{
+    std::lock_guard<std::mutex> lock(m_mutex);
+    if (m_status.error.empty())
+        m_status.error = error;
+}
+IsoTrackWriter::Status IsoTrackWriter::status() const
+{
+    std::lock_guard<std::mutex> lock(m_mutex);
+    return m_status;
+}
+void IsoTrackWriter::close(uint64_t end_ns)
+{
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        m_closing = true;
+        m_end_ns = end_ns;
+    }
+    m_cv.notify_all();
+}
+bool IsoTrackWriter::wait_finished(int timeout_ms)
+{
+    std::unique_lock<std::mutex> lock(m_mutex);
+    return m_cv.wait_for(lock, std::chrono::milliseconds(timeout_ms),
+                         [&] { return m_status.done; });
+}
+bool IsoTrackWriter::video(uint32_t w, uint32_t h, const uint8_t *y, const uint8_t *u,
+                           const uint8_t *v, uint32_t sy, uint32_t suv, uint64_t ns)
+{
+    if (!y || !u || !v || w < 2 || h < 2 || w > 4096 || h > 2160 || ((w | h) & 1) || sy < w ||
+        suv < w / 2)
+        return false;
+    Video frame{w, h, ns, std::vector<uint8_t>(size_t(w) * h * 3 / 2)};
+    auto *dst = frame.pixels.data();
+    for (uint32_t row = 0; row < h; ++row) {
+        std::memcpy(dst, y + size_t(row) * sy, w);
+        dst += w;
+    }
+    for (auto *plane : {u, v})
+        for (uint32_t row = 0; row < h / 2; ++row) {
+            std::memcpy(dst, plane + size_t(row) * suv, w / 2);
+            dst += w / 2;
+        }
+    std::lock_guard<std::mutex> lock(m_mutex);
+    if (m_closing || m_status.done || !m_status.error.empty())
+        return false;
+    // Coalesce delivery bursts; the independent output clock never loses time.
+    // Keep one second through GPU/encoder startup and delivery bursts. Shrinking
+    // this after the first output tick discards still-pending startup frames.
+    const size_t limit = 32;
+    while (m_video.size() >= limit) {
+        m_video.pop_front();
+        ++m_status.coalesced_video;
+    }
+    m_video.push_back(std::move(frame));
+    m_cv.notify_all();
+    return true;
+}
+bool IsoTrackWriter::audio(const uint8_t *pcm, uint32_t bytes, uint32_t rate, uint16_t channels,
+                           uint64_t ns)
+{
+    if (!pcm || !bytes || (channels != 1 && channels != 2) || rate < 8000 || rate > 192000 ||
+        bytes % (channels * 2) || bytes > rate * channels * 2 / 2)
+        return false;
+    std::lock_guard<std::mutex> lock(m_mutex);
+    if (m_closing || m_status.done || !m_status.error.empty())
+        return false;
+    if (m_audio.size() >= 256) {
+        m_status.error = "ISO audio input backlog exceeded its bound";
+        return false;
+    }
+    m_audio.push_back({rate, channels, ns, {pcm, pcm + bytes}});
+    m_cv.notify_all();
+    return true;
+}
+void IsoTrackWriter::run()
+{
+    IsoFfmpegPipe pipe;
+    audio_resampler_t *resampler = nullptr;
+#ifndef _WIN32
+    video_scaler_t *scaler = nullptr;
+#endif
+    try {
+        // One encoder process owns both streams for the participant's lifetime.
+        // Matroska carries explicit timestamps across the single stdin pipe.
+        std::vector<std::string> args = {
+            "-hide_banner", "-loglevel", "warning", "-n",   "-f",    "matroska", "-i",
+            "pipe:0",       "-map",      "0:v:0",   "-map", "0:a:0", "-c:v",     m_config.encoder};
+        if (m_config.encoder == "libx264")
+            args.insert(args.end(), {"-preset", "veryfast", "-crf", "18", "-threads", "2"});
+        else
+            args.insert(args.end(), {"-b:v", "12M", "-maxrate", "20M", "-bufsize", "24M"});
+        args.insert(args.end(), {"-r",           "30",
+                                 "-fps_mode",    "cfr",
+                                 "-g",           "60",
+                                 "-bf",          "0",
+                                 "-color_range", "pc",
+                                 "-colorspace",  "bt709",
+                                 "-c:a",         "aac",
+                                 "-b:a",         "192k",
+                                 "-ar",          "48000",
+                                 "-ac",          "2",
+                                 "-movflags",    "+frag_keyframe+empty_moov",
+                                 m_config.path});
+        std::string error;
+        if (!pipe.start(m_config.ffmpeg, args, m_config.log_path, IsoFfmpegPipe::kMaximumPixelBytes,
+                        &error))
+            throw std::runtime_error(error);
+        if (!pipe.try_queue(iso_av::header()))
+            throw std::runtime_error("ISO transport header rejected");
+        constexpr uint64_t latency = 150000000ULL;
+        constexpr size_t ringFrames = 48000 * 4;
+        std::vector<int16_t> ring(ringFrames * 2, 0);
+        uint64_t index = 0, audioEnd = 0;
+        uint32_t rate = 0;
+        uint16_t channels = 0;
+        std::vector<uint8_t> picture(1920 * 1080 * 3 / 2, 128);
+        std::fill_n(picture.data(), 1920 * 1080, 0);
+#ifdef _WIN32
+        corevideo::modules::D3DIsoFrameConformer conformer;
+#else
+        uint32_t oldW = 0, oldH = 0;
+#endif
+        for (;;) {
+            // Advance a fixed 30 Hz output clock, allowing input a short arrival window.
+            // A missing video frame retains the previous conformed picture.
+            Video newest{};
+            std::deque<Audio> audio;
+            const uint64_t tickNs = m_config.epoch_ns + index * 1000000000ULL / 30;
+            {
+                std::unique_lock<std::mutex> lock(m_mutex);
+                if (m_abort || !m_status.error.empty())
+                    break;
+                if (m_closing && tickNs >= m_end_ns)
+                    break;
+                if (!m_closing && m_config.now() < tickNs + latency) {
+                    m_cv.wait_for(lock, std::chrono::milliseconds(5));
+                    continue;
+                }
+                while (!m_video.empty() && m_video.front().ns <= tickNs) {
+                    newest = std::move(m_video.front());
+                    m_video.pop_front();
+                }
+                audio.swap(m_audio);
+            }
+            if (!newest.pixels.empty()) {
+                if (newest.w == 1920 && newest.h == 1080)
+                    picture = std::move(newest.pixels);
+                else {
+#ifdef _WIN32
+                    if (!conformer.convert(newest.pixels, newest.w, newest.h, 1920, 1080, picture,
+                                           error))
+                        throw std::runtime_error(error);
+#else
+                    const auto fit = corevideo::modules::isoFitRect(newest.w, newest.h, 1920, 1080);
+                    if (oldW != newest.w || oldH != newest.h) {
+                        video_scaler_destroy(scaler);
+                        scaler = nullptr;
+                        video_scale_info src{VIDEO_FORMAT_I420, newest.w, newest.h,
+                                             VIDEO_RANGE_FULL, VIDEO_CS_709};
+                        video_scale_info dst{VIDEO_FORMAT_I420, uint32_t(fit.width),
+                                             uint32_t(fit.height), VIDEO_RANGE_FULL, VIDEO_CS_709};
+                        if (video_scaler_create(&scaler, &dst, &src, VIDEO_SCALE_BILINEAR) !=
+                            VIDEO_SCALER_SUCCESS)
+                            throw std::runtime_error("ISO scaler initialization failed");
+                        oldW = newest.w;
+                        oldH = newest.h;
+                    }
+                    std::fill(picture.begin(), picture.end(), 128);
+                    std::fill_n(picture.data(), 1920 * 1080, 0);
+                    uint8_t *out[4] = {picture.data() + fit.y * 1920 + fit.x,
+                                       picture.data() + 1920 * 1080 + fit.y / 2 * 960 + fit.x / 2,
+                                       picture.data() + 1920 * 1080 * 5 / 4 + fit.y / 2 * 960 +
+                                           fit.x / 2,
+                                       nullptr};
+                    const uint8_t *in[4] = {
+                        newest.pixels.data(), newest.pixels.data() + newest.w * newest.h,
+                        newest.pixels.data() + newest.w * newest.h * 5 / 4, nullptr};
+                    uint32_t os[4] = {1920, 960, 960, 0},
+                             is[4] = {newest.w, newest.w / 2, newest.w / 2, 0};
+                    if (!video_scaler_scale(scaler, out, os, in, is))
+                        throw std::runtime_error("ISO scaling failed");
+#endif
+                }
+                std::lock_guard<std::mutex> lock(m_mutex);
+                m_status.input_width = newest.w;
+                m_status.input_height = newest.h;
+            }
+            const uint64_t emitted = index * 1600;
+            // Resample into a bounded stereo timeline; unfilled positions remain silent.
+            for (auto &packet : audio) {
+                if (packet.rate != rate || packet.channels != channels) {
+                    audio_resampler_destroy(resampler);
+                    resample_info src{packet.rate, AUDIO_FORMAT_16BIT,
+                                      packet.channels == 1 ? SPEAKERS_MONO : SPEAKERS_STEREO};
+                    resample_info dst{48000, AUDIO_FORMAT_16BIT, SPEAKERS_STEREO};
+                    resampler = audio_resampler_create(&dst, &src);
+                    if (!resampler)
+                        throw std::runtime_error("ISO audio resampler initialization failed");
+                    rate = packet.rate;
+                    channels = packet.channels;
+                }
+                uint8_t *out[MAX_AV_PLANES] = {};
+                const uint8_t *in[MAX_AV_PLANES] = {packet.pcm.data()};
+                uint32_t frames = 0;
+                uint64_t offset = 0;
+                if (!audio_resampler_resample(resampler, out, &frames, &offset, in,
+                                              uint32_t(packet.pcm.size() / (channels * 2))))
+                    throw std::runtime_error("ISO audio resampling failed");
+                const uint64_t ns = packet.ns > offset ? packet.ns - offset : 0;
+                const uint64_t target =
+                    ns > m_config.epoch_ns ? (ns - m_config.epoch_ns) * 48000 / 1000000000ULL : 0;
+                uint64_t begin = audioEnd;
+                // Arrival timestamps bunch together when the source drains an
+                // audio batch. Never rewind and overwrite already placed PCM.
+                if (target > begin + 960)
+                    begin = target;
+                auto *samples = reinterpret_cast<const int16_t *>(out[0]);
+                uint64_t late = 0;
+                for (uint32_t i = 0; i < frames; ++i) {
+                    const auto pos = begin + i;
+                    if (pos < emitted) {
+                        ++late;
+                        continue;
+                    }
+                    if (pos >= emitted + ringFrames)
+                        throw std::runtime_error("ISO audio timestamp exceeds bounded timeline");
+                    ring[(pos % ringFrames) * 2] = samples[i * 2];
+                    ring[(pos % ringFrames) * 2 + 1] = samples[i * 2 + 1];
+                }
+                audioEnd = begin + frames;
+                std::lock_guard<std::mutex> lock(m_mutex);
+                ++m_status.audio_packets;
+                m_status.late_audio_frames += late;
+            }
+            iso_av::Bytes pcm(1600 * 4);
+            for (size_t i = 0; i < 1600; ++i)
+                for (size_t c = 0; c < 2; ++c) {
+                    auto &sample = ring[((emitted + i) % ringFrames) * 2 + c];
+                    const uint16_t bits = uint16_t(sample);
+                    pcm[i * 4 + c * 2] = uint8_t(bits);
+                    pcm[i * 4 + c * 2 + 1] = uint8_t(bits >> 8);
+                    sample = 0;
+                }
+            auto batch = iso_av::frame(index, picture, pcm);
+            // Backpressure stays on this participant worker and has a finite timeout.
+            const auto queueStart = std::chrono::steady_clock::now();
+            while (!pipe.try_queue(std::move(batch))) {
+                if (!pipe.running() || pipe.queue_status().broken)
+                    throw std::runtime_error("ISO encoder stopped: " + pipe.log_tail(2048));
+                std::unique_lock<std::mutex> lock(m_mutex);
+                if (m_abort || !m_status.error.empty())
+                    throw std::runtime_error("ISO recording interrupted");
+                if (std::chrono::steady_clock::now() - queueStart > std::chrono::seconds(3))
+                    throw std::runtime_error("ISO encoder backlog exceeded three seconds");
+                m_cv.wait_for(lock, std::chrono::milliseconds(5));
+            }
+            ++index;
+            const auto queue = pipe.queue_status();
+            std::lock_guard<std::mutex> lock(m_mutex);
+            m_status.frames = index;
+            m_status.written_frames = queue.written_frames ? queue.written_frames - 1 : 0;
+            m_status.startup = queue.startup;
+            m_status.queued_frames = queue.frames;
+            m_status.peak_frames = queue.peak_frames;
+        }
+    } catch (const std::exception &e) {
+        fail(e.what());
+    } catch (...) {
+        fail("Unexpected ISO writer failure");
+    }
+    audio_resampler_destroy(resampler);
+#ifndef _WIN32
+    video_scaler_destroy(scaler);
+#endif
+    pipe.close_stdin();
+    // Let FFmpeg flush audio and finalize the file before reporting completion.
+    const auto deadline = std::chrono::steady_clock::now() + std::chrono::seconds(15);
+    while (!pipe.wait_finished(50)) {
+        bool abort;
+        {
+            std::lock_guard<std::mutex> lock(m_mutex);
+            abort = m_abort;
+        }
+        if (abort || std::chrono::steady_clock::now() > deadline) {
+            pipe.kill();
+            fail("ISO encoder finalization timed out or was cancelled");
+            break;
+        }
+    }
+    if (pipe.exit_code() != 0)
+        fail("ISO encoder failure: " + pipe.log_tail(2048));
+    {
+        std::lock_guard<std::mutex> lock(m_mutex);
+        m_status.done = true;
+        const auto queue = pipe.queue_status();
+        m_status.written_frames = queue.written_frames ? queue.written_frames - 1 : 0;
+        m_status.queued_frames = 0;
+    }
+    m_cv.notify_all();
+}
diff --git a/src/iso-track-writer.h b/src/iso-track-writer.h
new file mode 100644
index 0000000..19dc9f5
--- /dev/null
+++ b/src/iso-track-writer.h
@@ -0,0 +1,58 @@
+#pragma once
+#include "iso-ffmpeg-pipe.h"
+#include <condition_variable>
+#include <deque>
+#include <functional>
+#include <mutex>
+#include <thread>
+
+// One participant, one worker, one muxed MP4. Producers copy bounded inputs
+// only; GPU scaling, resampling, muxing and process I/O live on this worker.
+class IsoTrackWriter
+{
+  public:
+    struct Config {
+        std::string ffmpeg, encoder, path, log_path;
+        uint64_t epoch_ns = 0;
+        std::function<uint64_t()> now;
+    };
+    struct Status {
+        uint64_t frames = 0, written_frames = 0, audio_packets = 0, coalesced_video = 0, late_audio_frames = 0;
+        size_t queued_frames = 0, peak_frames = 0;
+        uint32_t input_width = 0, input_height = 0;
+        bool done = false, startup = true;
+        std::string error;
+    };
+    explicit IsoTrackWriter(Config config);
+    ~IsoTrackWriter();
+    bool video(uint32_t w, uint32_t h, const uint8_t *y, const uint8_t *u, const uint8_t *v,
+               uint32_t sy, uint32_t suv, uint64_t ns);
+    bool audio(const uint8_t *pcm, uint32_t bytes, uint32_t rate, uint16_t channels, uint64_t ns);
+    void close(uint64_t end_ns);
+    bool wait_finished(int timeout_ms);
+    Status status() const;
+
+  private:
+    struct Video {
+        uint32_t w, h;
+        uint64_t ns;
+        std::vector<uint8_t> pixels;
+    };
+    struct Audio {
+        uint32_t rate;
+        uint16_t channels;
+        uint64_t ns;
+        std::vector<uint8_t> pcm;
+    };
+    void run();
+    void fail(const std::string &error);
+    Config m_config;
+    mutable std::mutex m_mutex;
+    std::condition_variable m_cv;
+    std::deque<Video> m_video;
+    std::deque<Audio> m_audio;
+    Status m_status;
+    bool m_closing = false, m_abort = false;
+    uint64_t m_end_ns = 0;
+    std::thread m_thread;
+};
diff --git a/src/zoom-control-server.cpp b/src/zoom-control-server.cpp
index ac083be..24af19b 100644
--- a/src/zoom-control-server.cpp
+++ b/src/zoom-control-server.cpp
@@ -678,6 +678,21 @@ void ZoomControlServer::handle_line(QPointer<QTcpSocket> socket, const QByteArra
         cfg.video_encoder =
             req.value("video_encoder").toString("libx264").toStdString();
         cfg.record_program = req.value("record_program").toBool(true);
+        cfg.selected_source_uuids = ZoomPluginSettings::load().iso_selected_source_uuids;
+        if (req.contains("source_uuids")) {
+            if (!req.value("source_uuids").isArray()) {
+                write_response(socket, {{"ok", false}, {"error", "source_uuids must be an array"}});
+                return;
+            }
+            cfg.selected_source_uuids.clear();
+            for (const auto &value : req.value("source_uuids").toArray()) {
+                if (!value.isString() || value.toString().isEmpty()) {
+                    write_response(socket, {{"ok", false}, {"error", "source_uuids must contain nonempty strings"}});
+                    return;
+                }
+                cfg.selected_source_uuids.push_back(value.toString().toStdString());
+            }
+        }
         std::string error;
         const bool ok = ZoomIsoRecorder::instance().start(cfg, &error);
         for (const auto &o : ZoomOutputManager::instance().outputs())
diff --git a/src/zoom-engine-client.cpp b/src/zoom-engine-client.cpp
index ce78f19..8cefc31 100644
--- a/src/zoom-engine-client.cpp
+++ b/src/zoom-engine-client.cpp
@@ -1139,7 +1139,7 @@ void ZoomEngineClient::subscribe(const std::string &source_uuid,
 bool ZoomEngineClient::subscribe_audio(const std::string &source_uuid,
                                        uint32_t participant_id,
                                        bool isolate_audio,
-                                       bool audience_audio)
+                                       bool audience_audio, bool recording_only)
 {
     if (!m_running.load(std::memory_order_acquire) || source_uuid.empty())
         return false;
@@ -1147,6 +1147,7 @@ bool ZoomEngineClient::subscribe_audio(const std::string &source_uuid,
         R"(","participant_id":)" + std::to_string(participant_id) +
         R"(,"isolate_audio":)" + std::string(isolate_audio ? "true" : "false") +
         R"(,"audience_audio":)" + std::string(audience_audio ? "true" : "false") +
+        R"(,"recording_only":)" + std::string(recording_only ? "true" : "false") +
         "}");
 }
 
diff --git a/src/zoom-engine-client.h b/src/zoom-engine-client.h
index d5d9ec9..24bfcd4 100644
--- a/src/zoom-engine-client.h
+++ b/src/zoom-engine-client.h
@@ -257,7 +257,7 @@ class ZoomEngineClient {
     bool subscribe_audio(const std::string &source_uuid,
                          uint32_t participant_id,
                          bool isolate_audio,
-                         bool audience_audio);
+                         bool audience_audio, bool recording_only = false);
     void unsubscribe(const std::string &source_uuid);
 
     MeetingState state() const { return m_state.load(std::memory_order_acquire); }
diff --git a/src/zoom-iso-panel.cpp b/src/zoom-iso-panel.cpp
index 9bd59ad..d051d45 100644
--- a/src/zoom-iso-panel.cpp
+++ b/src/zoom-iso-panel.cpp
@@ -1,3 +1,4 @@
+#include <set>
 #include "zoom-iso-panel.h"
 #include "cv-style.h"
 #include "zoom-iso-recorder.h"
@@ -19,6 +20,7 @@
 #include <QJsonObject>
 #include <QLabel>
 #include <QLineEdit>
+#include <QListWidget>
 #include <QMessageBox>
 #include <QProcess>
 #include <QPushButton>
@@ -256,7 +258,7 @@ static bool is_hardware_encoder(const QString &encoder)
 
 static bool is_iso_eligible_output(const ZoomOutputInfo &output)
 {
-    if (output.assignment == AssignmentMode::ScreenShare)
+    if (output.audience_audio || output.assignment == AssignmentMode::ScreenShare)
         return false;
     if (output.assignment == AssignmentMode::ActiveSpeaker ||
         output.assignment == AssignmentMode::SpotlightIndex)
@@ -264,35 +266,25 @@ static bool is_iso_eligible_output(const ZoomOutputInfo &output)
     return output.participant_id != 0;
 }
 
-static qint64 estimated_output_bytes_per_second(const ZoomOutputInfo &output)
+static int iso_participant_count(const std::vector<ZoomOutputInfo> &outputs)
 {
-    const int requested_height = video_resolution_height(output.video_resolution);
-    const uint32_t observed_height = output.observed_height;
-    const int height = static_cast<int>(observed_height > 0
-        ? observed_height
-        : static_cast<uint32_t>(requested_height));
-    if (height >= 1000)
-        return 1100ll * 1024ll;
-    if (height >= 700)
-        return 700ll * 1024ll;
-    return 350ll * 1024ll;
+    std::set<uint32_t> participants;
+    int dynamic_outputs = 0;
+    for (const auto &output : outputs) {
+        if (!is_iso_eligible_output(output)) continue;
+        if (output.assignment == AssignmentMode::Participant)
+            participants.insert(output.participant_id);
+        else
+            ++dynamic_outputs;
+    }
+    return int(participants.size()) + dynamic_outputs;
 }
 
 static qint64 estimated_iso_bytes_per_second(
     const std::vector<ZoomOutputInfo> &outputs, bool record_program)
 {
-    qint64 bytes_per_second = 0;
-    // Accumulation is conditional (filtered by is_iso_eligible_output), so
-    // std::accumulate would need an equivalent-or-more-convoluted lambda
-    // here with no readability gain over the plain loop.
-    for (const auto &output : outputs) {
-        if (is_iso_eligible_output(output))
-            // cppcheck-suppress useStlAlgorithm
-            bytes_per_second += estimated_output_bytes_per_second(output);
-    }
-    if (record_program)
-        bytes_per_second += 1100ll * 1024ll;
-    return bytes_per_second;
+    // Every file is 1080p regardless of Zoom's current delivery resolution.
+    return (iso_participant_count(outputs) + (record_program ? 1 : 0)) * 1600ll * 1024ll;
 }
 
 ZoomIsoPanel::ZoomIsoPanel(QWidget *parent)
@@ -301,6 +293,8 @@ ZoomIsoPanel::ZoomIsoPanel(QWidget *parent)
     setMinimumWidth(560);
 
     const ZoomPluginSettings settings = ZoomPluginSettings::load();
+    for (const auto &uuid : settings.iso_selected_source_uuids)
+        m_selected_feeds.insert(QString::fromStdString(uuid));
 
     auto *layout = new QVBoxLayout(this);
     layout->setContentsMargins(8, 8, 8, 8);
@@ -375,6 +369,24 @@ ZoomIsoPanel::ZoomIsoPanel(QWidget *parent)
     });
     config_layout->addWidget(m_record_program);
 
+    config_layout->addWidget(new QLabel("Feeds to record:", config_group));
+    m_feeds = new QListWidget(config_group);
+    m_feeds->setMaximumHeight(145);
+    m_feeds->setAccessibleName("ISO feeds to record");
+    config_layout->addWidget(m_feeds);
+    auto *feed_hint = new QLabel("Choose routed feeds. Files start when media arrives. "
+        "Two feeds showing the same participant share one MP4.", config_group);
+    feed_hint->setWordWrap(true);
+    config_layout->addWidget(feed_hint);
+    connect(m_feeds, &QListWidget::itemChanged, this, [this](QListWidgetItem *item) {
+        const auto uuid = item->data(Qt::UserRole).toString();
+        if (item->checkState() == Qt::Checked) m_selected_feeds.insert(uuid);
+        else m_selected_feeds.remove(uuid);
+        persist_settings();
+        refresh_capacity_guidance();
+        refresh_status();
+    });
+
     auto *button_row = new QHBoxLayout;
     button_row->setSpacing(6);
     m_start_btn = new QPushButton("Start ISO Recording", config_group);
@@ -417,7 +429,7 @@ ZoomIsoPanel::ZoomIsoPanel(QWidget *parent)
     m_sessions->setColumnCount(11);
     m_sessions->setHorizontalHeaderLabels({
         "Source", "Participant", "Status", "Encoder", "Duration", "Resolution",
-        "Video Frames", "Audio Chunks", "Video Size", "Audio Size", "Files"
+        "Video Frames", "Audio Chunks", "File Size", "Audio", "File"
     });
     m_sessions->horizontalHeader()->setSectionResizeMode(0, QHeaderView::ResizeToContents);
     m_sessions->horizontalHeader()->setSectionResizeMode(1, QHeaderView::ResizeToContents);
@@ -509,6 +521,10 @@ void ZoomIsoPanel::test_ffmpeg()
 
 void ZoomIsoPanel::start_recording()
 {
+    if (selected_outputs().empty()) {
+        set_error("Select at least one routed feed to record.");
+        return;
+    }
     persist_settings();
     set_error(QString());
 
@@ -532,7 +548,7 @@ void ZoomIsoPanel::start_recording()
             if (choice != QMessageBox::Yes)
                 return;
         }
-        const auto outputs = ZoomOutputManager::instance().outputs();
+        const auto outputs = selected_outputs();
         const qint64 estimated_bytes_per_second =
             estimated_iso_bytes_per_second(outputs, m_record_program->isChecked());
         if (estimated_bytes_per_second > 0 &&
@@ -551,9 +567,8 @@ void ZoomIsoPanel::start_recording()
     }
 
     const QString encoder = m_video_encoder->currentData().toString();
-    const auto outputs = ZoomOutputManager::instance().outputs();
-    const int eligible_outputs = static_cast<int>(std::count_if(
-        outputs.begin(), outputs.end(), is_iso_eligible_output));
+    const auto outputs = selected_outputs();
+    const int eligible_outputs = iso_participant_count(outputs);
     const int encode_paths = eligible_outputs + (m_record_program->isChecked() ? 1 : 0);
     if (is_hardware_encoder(encoder) && encode_paths > 3) {
         const int choice = QMessageBox::warning(
@@ -576,6 +591,8 @@ void ZoomIsoPanel::start_recording()
     config.video_encoder =
         m_video_encoder->currentData().toString().toStdString();
     config.record_program = m_record_program->isChecked();
+    for (const auto &output : selected_outputs())
+        config.selected_source_uuids.push_back(output.source_uuid);
 
     std::string error;
     if (!ZoomIsoRecorder::instance().start(config, &error)) {
@@ -595,13 +612,61 @@ void ZoomIsoPanel::stop_recording()
     refresh_status();
 }
 
+std::vector<ZoomOutputInfo> ZoomIsoPanel::selected_outputs() const
+{
+    auto outputs = ZoomOutputManager::instance().outputs();
+    outputs.erase(std::remove_if(outputs.begin(), outputs.end(), [this](const auto &output) {
+        return !is_iso_eligible_output(output) ||
+            !m_selected_feeds.contains(QString::fromStdString(output.source_uuid));
+    }), outputs.end());
+    return outputs;
+}
+
+void ZoomIsoPanel::refresh_feeds()
+{
+    const auto outputs = ZoomOutputManager::instance().outputs();
+    const QSignalBlocker blocker(m_feeds);
+    const int scroll = m_feeds->verticalScrollBar()->value();
+    m_feeds->setUpdatesEnabled(false);
+    QSet<QString> present;
+    for (const auto &output : outputs) {
+        const auto uuid = QString::fromStdString(output.source_uuid);
+        present.insert(uuid);
+        QListWidgetItem *item = nullptr;
+        for (int row = 0; row < m_feeds->count(); ++row)
+            if (m_feeds->item(row)->data(Qt::UserRole).toString() == uuid)
+                item = m_feeds->item(row);
+        if (!item) {
+            item = new QListWidgetItem(m_feeds);
+            item->setData(Qt::UserRole, uuid);
+        }
+        const bool eligible = is_iso_eligible_output(output);
+        QString route = output.assignment == AssignmentMode::ActiveSpeaker ? "active speaker" :
+            output.assignment == AssignmentMode::SpotlightIndex ? "spotlight" :
+            QString("participant %1").arg(output.participant_id);
+        if (!eligible) route = "unrouted or unsupported";
+        const auto label = QString::fromStdString(output.display_name.empty() ? output.source_name : output.display_name);
+        item->setText(QString("%1 — %2").arg(label, route));
+        item->setFlags(Qt::ItemIsUserCheckable | Qt::ItemIsSelectable |
+                       (eligible ? Qt::ItemIsEnabled : Qt::NoItemFlags));
+        item->setCheckState(m_selected_feeds.contains(uuid) ? Qt::Checked : Qt::Unchecked);
+    }
+    for (int row = m_feeds->count()-1; row >= 0; --row)
+        if (!present.contains(m_feeds->item(row)->data(Qt::UserRole).toString()))
+            delete m_feeds->takeItem(row);
+    m_feeds->verticalScrollBar()->setValue(scroll);
+    m_feeds->setUpdatesEnabled(true);
+}
+
 void ZoomIsoPanel::refresh_status()
 {
+    refresh_feeds();
     const bool active = ZoomIsoRecorder::instance().active();
     const QJsonObject recorder = ZoomIsoRecorder::instance().status_overview();
     const QJsonArray sessions = ZoomIsoRecorder::instance().status_json();
 
-    m_start_btn->setEnabled(!active);
+    m_start_btn->setEnabled(!active && !recorder.value("finishing").toBool() && !selected_outputs().empty());
+    m_feeds->setEnabled(!active && !recorder.value("finishing").toBool());
     m_stop_btn->setEnabled(active);
     m_output_dir->setEnabled(!active);
     m_ffmpeg_path->setEnabled(!active);
@@ -614,6 +679,8 @@ void ZoomIsoPanel::refresh_status()
               .arg(recorder.value("session_count").toInt())
               .arg(recorder.value("session_count").toInt() == 1 ? "" : "s")
         : QStringLiteral("Idle");
+    if (active && sessions.isEmpty())
+        status_text = "Armed - waiting for media from selected feeds";
     const int completed_count = recorder.value("completed_session_count").toInt();
     if (completed_count > 0) {
         status_text += QString(" - %1 completed session%2 retained")
@@ -684,7 +751,7 @@ void ZoomIsoPanel::refresh_status()
             status = QString("Waiting for video (%1)")
                 .arg(age_text(static_cast<double>(elapsed_ms)));
         else if (!completed && audio_chunks == 0)
-            status += QString(" / no audio (%1)")
+            status += QString(" / silence: no audio received (%1)")
                 .arg(age_text(static_cast<double>(elapsed_ms)));
         if (frames_dropped > 0 &&
             session_health != QLatin1String("encoder_behind"))
@@ -722,7 +789,9 @@ void ZoomIsoPanel::refresh_status()
             tooltip += QString("\n\nFFmpeg output:\n%1").arg(ffmpeg_output);
         }
         status_item->setToolTip(tooltip);
-        if (completed)
+        if (!ffmpeg_error.isEmpty())
+            status_item->setForeground(QColor("#ef6b73"));
+        else if (completed)
             status_item->setForeground(QColor("#66d989"));
         else if (!ffmpeg_running || video_frames == 0)
             status_item->setForeground(QColor("#f0b429"));
@@ -739,11 +808,10 @@ void ZoomIsoPanel::refresh_status()
         m_sessions->setItem(row, 7, item(QString::number(audio_chunks)));
         m_sessions->setItem(row, 8, item(bytes_text(
             static_cast<qint64>(s.value("video_bytes").toDouble()))));
-        m_sessions->setItem(row, 9, item(bytes_text(
-            static_cast<qint64>(s.value("audio_bytes").toDouble()))));
-        auto *files = item(QString("%1\n%2")
-            .arg(s.value("video_path").toString(),
-                 s.value("audio_path").toString()));
+        m_sessions->setItem(row, 9, item(s.value("audio_muxed").toBool()
+            ? QStringLiteral("AAC in MP4")
+            : bytes_text(static_cast<qint64>(s.value("audio_bytes").toDouble()))));
+        auto *files = item(s.value("video_path").toString());
         files->setToolTip(files->text());
         m_sessions->setItem(row, 10, files);
     }
@@ -769,9 +837,8 @@ void ZoomIsoPanel::refresh_capacity_guidance()
         return;
 
     const QString encoder = m_video_encoder->currentData().toString();
-    const auto outputs = ZoomOutputManager::instance().outputs();
-    const int eligible_outputs = static_cast<int>(std::count_if(
-        outputs.begin(), outputs.end(), is_iso_eligible_output));
+    const auto outputs = selected_outputs();
+    const int eligible_outputs = iso_participant_count(outputs);
     const int encode_paths = eligible_outputs + (m_record_program->isChecked() ? 1 : 0);
     const qint64 estimated_bytes_per_second =
         estimated_iso_bytes_per_second(outputs, m_record_program->isChecked());
@@ -829,6 +896,9 @@ void ZoomIsoPanel::persist_settings() const
     settings.iso_video_encoder =
         m_video_encoder->currentData().toString().toStdString();
     settings.iso_record_program = m_record_program->isChecked();
+    settings.iso_selected_source_uuids.clear();
+    for (const auto &uuid : m_selected_feeds)
+        settings.iso_selected_source_uuids.push_back(uuid.toStdString());
     settings.save();
 }
 
diff --git a/src/zoom-iso-panel.h b/src/zoom-iso-panel.h
index 930af53..49fa62e 100644
--- a/src/zoom-iso-panel.h
+++ b/src/zoom-iso-panel.h
@@ -1,6 +1,12 @@
 #pragma once
 
 #include <QWidget>
+#include <QSet>
+#include <QString>
+#include <vector>
+
+struct ZoomOutputInfo;
+class QListWidget;
 
 class QCheckBox;
 class QComboBox;
@@ -25,6 +31,8 @@ class ZoomIsoPanel : public QWidget {
     void start_recording();
     void stop_recording();
     void refresh_status();
+    void refresh_feeds();
+    std::vector<ZoomOutputInfo> selected_outputs() const;
     void refresh_encoder_guidance();
     void refresh_capacity_guidance();
     void persist_settings() const;
@@ -34,6 +42,8 @@ class ZoomIsoPanel : public QWidget {
     QLineEdit *m_ffmpeg_path = nullptr;
     QComboBox *m_video_encoder = nullptr;
     QCheckBox *m_record_program = nullptr;
+    QListWidget *m_feeds = nullptr;
+    QSet<QString> m_selected_feeds;
     QPushButton *m_start_btn = nullptr;
     QPushButton *m_stop_btn = nullptr;
     QPushButton *m_test_btn = nullptr;
diff --git a/src/zoom-iso-recorder.cpp b/src/zoom-iso-recorder.cpp
index ad2bd59..e550b15 100644
--- a/src/zoom-iso-recorder.cpp
+++ b/src/zoom-iso-recorder.cpp
@@ -1,7 +1,7 @@
 #include "zoom-iso-recorder.h"
-#include "iso-audio-gap-fill.h"
 #include "iso-encoder-plan.h"
-#include "iso-video-pacer.h"
+#include "iso-provider-policy.h"
+#include "iso-feed-selection.h"
 #include <QDateTime>
 #include <QDir>
 #include <QElapsedTimer>
@@ -11,23 +11,20 @@
 #include <QStandardPaths>
 #include <QStorageInfo>
 #include <QStringList>
-#include <obs-frontend-api.h>
-#include <obs-module.h>
-#include <util/platform.h>
 #include <algorithm>
 #include <cerrno>
 #include <cstring>
+#include <obs-frontend-api.h>
+#include <obs-module.h>
 #include <set>
+#include <util/platform.h>
 
 static constexpr qint64 kIsoMinimumFreeBytes = 2ll * 1024ll * 1024ll * 1024ll;
 static constexpr qint64 kIsoWarningFreeBytes = 10ll * 1024ll * 1024ll * 1024ll;
-static constexpr int kFfmpegOutputTailChars = 2048;
-static constexpr size_t kMaxCompletedIsoSessions = 24;
 
 static QString default_iso_dir()
 {
-    const QString docs = QStandardPaths::writableLocation(
-        QStandardPaths::DocumentsLocation);
+    const QString docs = QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation);
     const QString base = docs.isEmpty() ? QDir::homePath() : docs;
     return QDir(base).absoluteFilePath("CoreVideo ISOs");
 }
@@ -35,26 +32,17 @@ static QString default_iso_dir()
 static QString sanitized(const std::string &value, const QString &fallback)
 {
     QString out = QString::fromStdString(value).trimmed();
-    if (out.isEmpty()) out = fallback;
+    if (out.isEmpty())
+        out = fallback;
     for (QChar &ch : out) {
         if (!ch.isLetterOrNumber() && ch != '-' && ch != '_' && ch != '.')
             ch = '_';
     }
-    while (out.contains("__")) out.replace("__", "_");
+    while (out.contains("__"))
+        out.replace("__", "_");
     return out.left(80);
 }
 
-static const char *assignment_label(AssignmentMode mode)
-{
-    switch (mode) {
-    case AssignmentMode::ActiveSpeaker: return "active_speaker";
-    case AssignmentMode::SpotlightIndex: return "spotlight";
-    case AssignmentMode::ScreenShare: return "screen_share";
-    case AssignmentMode::Participant:
-    default: return "participant";
-    }
-}
-
 static QString bytes_text(qint64 bytes)
 {
     const double gb = static_cast<double>(bytes) / (1024.0 * 1024.0 * 1024.0);
@@ -67,10 +55,8 @@ static QString bytes_text(qint64 bytes)
 static std::string normalized_video_encoder(const std::string &encoder);
 static int count_obs_nvenc_encoders();
 static bool is_hardware_encoder(const std::string &encoder);
-static bool ffmpeg_encoder_available(const QString &ffmpeg_path,
-                                     const std::string &encoder,
+static bool ffmpeg_encoder_available(const QString &ffmpeg_path, const std::string &encoder,
                                      std::string *error);
-static QStringList ffmpeg_video_encoder_args(const std::string &encoder);
 
 ZoomIsoRecorder &ZoomIsoRecorder::instance()
 {
@@ -78,100 +64,40 @@ ZoomIsoRecorder &ZoomIsoRecorder::instance()
     return inst;
 }
 
-ZoomIsoRecorder::~ZoomIsoRecorder()
-{
-    stop();
-}
-
-bool ZoomIsoRecorder::WavFile::open(const QString &path,
-                                    uint32_t rate,
-                                    uint16_t channel_count)
-{
-    close();
-#if defined(_WIN32)
-    file = _wfopen(reinterpret_cast<const wchar_t *>(path.utf16()), L"wb");
-#else
-    file = fopen(path.toUtf8().constData(), "wb");
-#endif
-    if (!file) return false;
-    sample_rate = rate;
-    channels = std::max<uint16_t>(channel_count, 1);
-    data_bytes = 0;
-
-    const uint16_t audio_format = 1;
-    const uint16_t bits_per_sample = 16;
-    const uint32_t byte_rate = sample_rate * channels * bits_per_sample / 8;
-    const uint16_t block_align = channels * bits_per_sample / 8;
-    const uint32_t riff_size = 36;
-    const uint32_t data_size = 0;
-
-    fwrite("RIFF", 1, 4, file);
-    fwrite(&riff_size, 4, 1, file);
-    fwrite("WAVEfmt ", 1, 8, file);
-    const uint32_t fmt_size = 16;
-    fwrite(&fmt_size, 4, 1, file);
-    fwrite(&audio_format, 2, 1, file);
-    fwrite(&channels, 2, 1, file);
-    fwrite(&sample_rate, 4, 1, file);
-    fwrite(&byte_rate, 4, 1, file);
-    fwrite(&block_align, 2, 1, file);
-    fwrite(&bits_per_sample, 2, 1, file);
-    fwrite("data", 1, 4, file);
-    fwrite(&data_size, 4, 1, file);
-    return true;
-}
+ZoomIsoRecorder::~ZoomIsoRecorder() { stop(); }
 
-bool ZoomIsoRecorder::WavFile::write(const uint8_t *pcm, uint32_t byte_len,
-                                     bool *out_disk_full)
+bool ZoomIsoRecorder::start(const ZoomIsoRecordConfig &config, std::string *error)
 {
-    if (out_disk_full) *out_disk_full = false;
-    if (!file || !pcm || byte_len == 0) return true;
-    errno = 0;
-    const size_t written = fwrite(pcm, 1, byte_len, file);
-    data_bytes += static_cast<uint32_t>(written);
-    if (written < byte_len) {
-        write_failed = true;
-        if (out_disk_full && (errno == ENOSPC || ferror(file)))
-            *out_disk_full = (errno == ENOSPC);
+    if (m_active.load() || m_stopping.load()) {
+        if (error)
+            *error = "ISO recording is already active or finishing.";
         return false;
     }
-    return true;
-}
-
-void ZoomIsoRecorder::WavFile::close()
-{
-    if (!file) return;
-    // Finalize the RIFF/data size fields on every close path (including
-    // when a write failed mid-stream) so the file stays valid and playable.
-    // data_bytes reflects the bytes actually written, so a truncated file
-    // still describes its real payload size.
-    const uint32_t riff_size = 36 + data_bytes;
-    if (fseek(file, 4, SEEK_SET) == 0)
-        fwrite(&riff_size, 4, 1, file);
-    if (fseek(file, 40, SEEK_SET) == 0)
-        fwrite(&data_bytes, 4, 1, file);
-    fclose(file);
-    file = nullptr;
-    data_bytes = 0;
-    write_failed = false;
-}
-
-bool ZoomIsoRecorder::start(const ZoomIsoRecordConfig &config,
-                            std::string *error)
-{
     ZoomIsoRecordConfig normalized = config;
+    if (normalized.selected_source_uuids.empty()) {
+        if (error) *error = "Select at least one feed in the ISO Recorder before starting.";
+        return false;
+    }
     if (normalized.output_dir.empty())
+    {
         normalized.output_dir = default_iso_dir().toStdString();
+    }
+    const auto outputs = ZoomOutputManager::instance().outputs();
+    if (!std::any_of(outputs.begin(), outputs.end(), [&](const auto &info) {
+        return iso_feed_selected(normalized.selected_source_uuids, info.source_uuid,
+            info.assignment != AssignmentMode::Participant || info.participant_id != 0,
+            info.audience_audio || info.assignment == AssignmentMode::ScreenShare);
+    })) {
+        if (error) *error = "None of the selected ISO feeds is currently routed. Assign a participant first.";
+        return false;
+    }
     if (normalized.ffmpeg_path.empty())
         normalized.ffmpeg_path = "ffmpeg";
-    const std::string requested_encoder =
-        normalized_video_encoder(normalized.video_encoder);
-    normalized.video_encoder =
-        requested_encoder;
+    const std::string requested_encoder = normalized_video_encoder(normalized.video_encoder);
+    normalized.video_encoder = requested_encoder;
     const QString ffmpegProgram = QString::fromStdString(normalized.ffmpeg_path);
     const QFileInfo ffmpegInfo(ffmpegProgram);
-    if ((ffmpegInfo.isRelative() &&
-         QStandardPaths::findExecutable(ffmpegProgram).isEmpty()) ||
+    if ((ffmpegInfo.isRelative() && QStandardPaths::findExecutable(ffmpegProgram).isEmpty()) ||
         (!ffmpegInfo.isRelative() && !ffmpegInfo.exists())) {
         if (error) {
             *error = "FFmpeg was not found on PATH. Set ffmpeg_path to a "
@@ -193,19 +119,16 @@ bool ZoomIsoRecorder::start(const ZoomIsoRecordConfig &config,
              "[obs-zoom-plugin] ISO encoder placement: automatic "
              "(nvenc=%d qsv=%d amf=%d, NVENC session limit %d, "
              "OBS NVENC encoders active %d)",
-             avail.nvenc, avail.qsv, avail.amf,
-             iso_nvenc_default_session_limit(), count_obs_nvenc_encoders());
-    } else if (!ffmpeg_encoder_available(ffmpegProgram,
-                                         normalized.video_encoder,
-                                         &encoder_error)) {
+             avail.nvenc, avail.qsv, avail.amf, iso_nvenc_default_session_limit(),
+             count_obs_nvenc_encoders());
+    } else if (!ffmpeg_encoder_available(ffmpegProgram, normalized.video_encoder, &encoder_error)) {
         if (is_hardware_encoder(normalized.video_encoder) &&
             ffmpeg_encoder_available(ffmpegProgram, "libx264", nullptr)) {
             status_warning = QString("Requested hardware encoder '%1' was not "
                                      "available in FFmpeg; falling back to CPU "
                                      "libx264 for this ISO run.")
                                  .arg(QString::fromStdString(normalized.video_encoder));
-            blog(LOG_WARNING, "[obs-zoom-plugin] %s",
-                 status_warning.toUtf8().constData());
+            blog(LOG_WARNING, "[obs-zoom-plugin] %s", status_warning.toUtf8().constData());
             normalized.video_encoder = "libx264";
         } else {
             if (error)
@@ -216,7 +139,8 @@ bool ZoomIsoRecorder::start(const ZoomIsoRecordConfig &config,
 
     QDir dir(QString::fromStdString(normalized.output_dir));
     if (!dir.exists() && !dir.mkpath(".")) {
-        if (error) *error = "Could not create ISO recording directory.";
+        if (error)
+            *error = "Could not create ISO recording directory.";
         return false;
     }
     const QStorageInfo storage(dir.absolutePath());
@@ -226,17 +150,16 @@ bool ZoomIsoRecorder::start(const ZoomIsoRecordConfig &config,
             if (error) {
                 *error = QString("Only %1 is free in the ISO output folder. "
                                  "Free at least %2 before starting ISO recording.")
-                             .arg(bytes_text(available),
-                                  bytes_text(kIsoMinimumFreeBytes))
+                             .arg(bytes_text(available), bytes_text(kIsoMinimumFreeBytes))
                              .toStdString();
             }
             return false;
         }
         if (available < kIsoWarningFreeBytes) {
-            blog(LOG_WARNING,
-                 "[obs-zoom-plugin] ISO recording starting with low disk space: available=%s dir=%s",
-                 bytes_text(available).toUtf8().constData(),
-                 normalized.output_dir.c_str());
+            blog(
+                LOG_WARNING,
+                "[obs-zoom-plugin] ISO recording starting with low disk space: available=%s dir=%s",
+                bytes_text(available).toUtf8().constData(), normalized.output_dir.c_str());
         }
     } else {
         blog(LOG_WARNING,
@@ -246,20 +169,22 @@ bool ZoomIsoRecorder::start(const ZoomIsoRecordConfig &config,
 
     {
         std::lock_guard<std::mutex> lock(m_mtx);
-        for (auto &entry : m_sessions)
-            begin_finishing_locked(std::move(entry.second));
         m_sessions.clear();
-        reap_finishing_locked();
         m_config = normalized;
         m_requested_video_encoder = requested_encoder;
         m_encoder_avail = avail;
         m_nvenc_session_limit = iso_nvenc_default_session_limit();
-        m_encoder_demotions.clear();
-        m_stopped_sources.clear();
         m_status_warning = status_warning;
         m_started_program_recording = false;
         m_completed_sessions.clear();
+        m_epoch_ns = os_gettime_ns();
         m_active.store(true, std::memory_order_release);
+        for (const auto &info : outputs) m_outputs[info.source_uuid] = info;
+        // Arm selected feeds only. A writer is opened on their first actual
+        // media callback, never merely because an OBS source exists.
+        for (const auto &info : outputs)
+            if (should_record(info, info.participant_id))
+                ensure_audio_locked(info, info.participant_id);
     }
 
     if (normalized.record_program && !obs_frontend_recording_active()) {
@@ -268,8 +193,7 @@ bool ZoomIsoRecorder::start(const ZoomIsoRecordConfig &config,
         m_started_program_recording = true;
     }
 
-    blog(LOG_INFO,
-         "[obs-zoom-plugin] ISO recording started: dir=%s ffmpeg=%s encoder=%s",
+    blog(LOG_INFO, "[obs-zoom-plugin] ISO recording started: dir=%s ffmpeg=%s encoder=%s",
          normalized.output_dir.c_str(), normalized.ffmpeg_path.c_str(),
          normalized.video_encoder.c_str());
     return true;
@@ -277,829 +201,284 @@ bool ZoomIsoRecorder::start(const ZoomIsoRecordConfig &config,
 
 void ZoomIsoRecorder::stop()
 {
-    if (!m_active.exchange(false, std::memory_order_acq_rel)) return;
-
-    // Take the sessions out and finish them WITHOUT holding m_mtx. The old
-    // close-in-place loop waited up to 5 s per session under the lock; with
-    // 8 sessions the engine-IPC dispatch thread (which needs m_mtx to write
-    // frames) blocked for ~40 s, the engine's pipe backed up until its
-    // heartbeat write stalled, and the plugin declared the engine dead and
-    // tore the meeting down (2026-08-08 incident).
-    std::vector<Session> finishing;
+    if (m_stopping.exchange(true))
+        return;
+    if (!m_active.exchange(false)) {
+        m_stopping = false;
+        return;
+    }
+    const uint64_t end_ns = os_gettime_ns();
+    std::unordered_map<uint32_t, Session> sessions;
+    std::unordered_map<uint32_t, std::shared_ptr<IsoAudioTap>> audio_taps;
     bool stop_program = false;
     {
         std::lock_guard<std::mutex> lock(m_mtx);
-        finishing.reserve(m_sessions.size() + m_finishing.size());
-        for (auto &entry : m_sessions)
-            finishing.push_back(std::move(entry.second));
-        m_sessions.clear();
-        for (auto &pending : m_finishing)
-            finishing.push_back(std::move(pending));
-        m_finishing.clear();
-        stop_program = m_started_program_recording &&
-                       obs_frontend_recording_active();
+        sessions.swap(m_sessions);
+        audio_taps.swap(m_audio_taps);
+        stop_program = m_started_program_recording && obs_frontend_recording_active();
         m_started_program_recording = false;
     }
     if (stop_program)
         obs_frontend_recording_stop();
-
-    // Phase 1: signal EOF to every encoder at once so they all finalize
-    // their MP4s in parallel instead of serially.
-    for (Session &session : finishing) {
-        session.wav.close();
-        if (session.ffmpeg) {
-            refresh_ffmpeg_status_locked(session);
-            session.ffmpeg->close_stdin();
-        }
-    }
-
-    // Phase 2: wait against one shared deadline; anything still running at
-    // the end gets terminated with an honest status (a killed FFmpeg leaves
-    // the MP4 without its final index).
+    for (auto &entry : audio_taps) entry.second->stop();
+    for (auto &entry : sessions)
+        entry.second.writer->close(end_ns);
     QElapsedTimer deadline;
     deadline.start();
-    constexpr qint64 kShutdownBudgetMs = 15000;
-    for (Session &session : finishing) {
-        if (!session.ffmpeg)
-            continue;
-        qint64 remaining = kShutdownBudgetMs - deadline.elapsed();
-        if (remaining < 100)
-            remaining = 100;
-        if (!session.ffmpeg->wait_finished(static_cast<int>(remaining))) {
-            mark_ffmpeg_failure_locked(
-                session,
-                QString("FFmpeg did not exit within the %1s shutdown budget "
-                        "and was terminated — the recording may be missing "
-                        "its final index (moov).")
-                    .arg(kShutdownBudgetMs / 1000));
-            session.ffmpeg->kill();
-            if (!session.ffmpeg->wait_finished(2000) &&
-                session.ffmpeg->running()) {
-                blog(LOG_WARNING,
-                     "[obs-zoom-plugin] ISO ffmpeg for %s did not exit after "
-                     "kill(); process may not be reaped (pid=%lld)",
-                     session.source_name.c_str(), session.ffmpeg->pid());
-            }
+    for (auto &entry : sessions) {
+        auto &session = entry.second;
+        session.writer->wait_finished(int(std::max<qint64>(0, 15000 - deadline.elapsed())));
+        QJsonObject completed = session_status_locked(session, true, end_ns);
+        const auto tap = audio_taps.find(entry.first);
+        if (tap != audio_taps.end() && !tap->second->error().empty()) {
+            completed["ffmpeg_error"] = QString::fromStdString(tap->second->error());
+            completed["session_health"] = "audio_error";
         }
-        refresh_ffmpeg_status_locked(session);
-        blog(LOG_INFO,
-             "[obs-zoom-plugin] ISO session closed: source=%s participant=%u frames=%u audio_chunks=%u",
-             session.source_name.c_str(), session.resolved_participant_id,
-             session.video_frames, session.audio_chunks);
-    }
-
-    {
-        std::lock_guard<std::mutex> lock(m_mtx);
-        for (Session &session : finishing) {
-            QJsonObject completed =
-                session_status_json_locked(session, true);
-            completed["completed_at"] =
-                QDateTime::currentDateTimeUtc().toString(Qt::ISODateWithMs);
-            m_completed_sessions.insert(m_completed_sessions.begin(),
-                                        completed);
+        if (!session.writer->status().done) {
+            completed["ffmpeg_error"] = "ISO finalization exceeded the shared shutdown deadline";
+            completed["session_health"] = "encoder_error";
         }
-        if (m_completed_sessions.size() > kMaxCompletedIsoSessions)
-            m_completed_sessions.resize(kMaxCompletedIsoSessions);
+        // Destruction cancels any hung worker/process outside the recorder lock.
+        session.writer.reset();
+        std::lock_guard<std::mutex> lock(m_mtx);
+        m_completed_sessions.push_back(completed);
     }
-    blog(LOG_INFO, "[obs-zoom-plugin] ISO recording stopped");
+    m_stopping = false;
+    blog(LOG_INFO,
+         "[obs-zoom-plugin] ISO recording stopped (one muxed 1080p file per participant)");
 }
 
-QJsonArray ZoomIsoRecorder::status_json()
+bool ZoomIsoRecorder::should_record(const ZoomOutputInfo &info, uint32_t participant) const
 {
-    QJsonArray arr;
-    std::lock_guard<std::mutex> lock(m_mtx);
-    reap_finishing_locked();
-    sweep_unresolved_locked();
-    for (auto &entry : m_sessions) {
-        arr.append(session_status_json_locked(entry.second, false));
-    }
-    for (auto &finishing : m_finishing)
-        arr.append(session_status_json_locked(finishing, false));
-    for (const QJsonObject &completed : m_completed_sessions)
-        arr.append(completed);
-    return arr;
+    return m_active.load() && participant && iso_feed_selected(
+        m_config.selected_source_uuids, info.source_uuid,
+        info.assignment != AssignmentMode::Participant || info.participant_id != 0,
+        info.audience_audio || info.assignment == AssignmentMode::ScreenShare);
 }
 
-QJsonObject ZoomIsoRecorder::status_overview()
+ZoomIsoRecorder::Session &ZoomIsoRecorder::ensure_session_locked(const ZoomOutputInfo &info,
+                                                                 uint32_t participant, uint64_t ns)
 {
-    QJsonObject obj;
-    std::lock_guard<std::mutex> lock(m_mtx);
-    obj["active"] = m_active.load(std::memory_order_acquire);
-    obj["output_dir"] = QString::fromStdString(m_config.output_dir);
-    obj["ffmpeg_path"] = QString::fromStdString(m_config.ffmpeg_path);
-    obj["requested_video_encoder"] =
-        QString::fromStdString(m_requested_video_encoder.empty()
-            ? m_config.video_encoder
-            : m_requested_video_encoder);
-    obj["video_encoder"] = QString::fromStdString(m_config.video_encoder);
-    obj["encoder_fallback"] =
-        !m_requested_video_encoder.empty() &&
-        m_requested_video_encoder != m_config.video_encoder;
-    obj["hardware_encoder"] = is_hardware_encoder(m_config.video_encoder);
-    obj["record_program"] = m_config.record_program;
-    obj["program_recording_started_by_corevideo"] = m_started_program_recording;
-    obj["session_count"] = static_cast<int>(m_sessions.size());
-    obj["completed_session_count"] = static_cast<int>(m_completed_sessions.size());
-    obj["warning"] = m_status_warning;
-
-    const QDir dir(QString::fromStdString(m_config.output_dir));
-    const QStorageInfo storage(dir.absolutePath());
-    if (storage.isValid() && storage.isReady()) {
-        obj["disk_available_bytes"] = static_cast<double>(storage.bytesAvailable());
-        obj["disk_warning"] = storage.bytesAvailable() < kIsoWarningFreeBytes;
-    } else {
-        obj["disk_available_bytes"] = -1.0;
-        obj["disk_warning"] = true;
-    }
-    return obj;
+    auto existing = m_sessions.find(participant);
+    if (existing != m_sessions.end())
+        return existing->second;
+    Session session;
+    session.info = info;
+    session.participant = participant;
+    // Known participants begin at Record. Late arrivals have an explicit offset
+    // rather than generating minutes of blank frames in a catch-up burst.
+    session.epoch_ns = ns - m_epoch_ns < 500000000ULL ? m_epoch_ns : ns;
+    const QString stamp = QDateTime::currentDateTimeUtc().toString("yyyyMMdd-HHmmss-zzz");
+    session.path = QDir(QString::fromStdString(m_config.output_dir))
+                       .absoluteFilePath(
+                           QString("%1_%2_participant_%3.mp4")
+                               .arg(stamp, sanitized(info.display_name.empty() ? info.source_name
+                                                                               : info.display_name,
+                                                     "participant"))
+                               .arg(participant));
+    int in_use = 0;
+    for (const auto &entry : m_sessions)
+        if (entry.second.encoder == "h264_nvenc")
+            ++in_use;
+    const int reserve = m_config.record_program && !obs_frontend_recording_active() ? 1 : 0;
+    session.encoder = iso_choose_session_encoder(
+        m_config.video_encoder,
+        m_nvenc_session_limit - count_obs_nvenc_encoders() - in_use - reserve, m_encoder_avail);
+    IsoTrackWriter::Config config;
+    config.ffmpeg = m_config.ffmpeg_path;
+    config.encoder = session.encoder;
+    config.path = session.path.toStdString();
+    config.log_path = config.path + ".ffmpeg.log";
+    config.epoch_ns = session.epoch_ns;
+    config.now = [] { return os_gettime_ns(); };
+    session.writer = std::make_unique<IsoTrackWriter>(std::move(config));
+    blog(LOG_INFO,
+         "[obs-zoom-plugin] ISO participant recording opened: participant=%u encoder=%s "
+         "output=1920x1080 audio=AAC file=%s",
+         participant, session.encoder.c_str(), session.path.toUtf8().constData());
+    return m_sessions.emplace(participant, std::move(session)).first->second;
 }
 
-void ZoomIsoRecorder::on_output_updated(const ZoomOutputInfo &info)
+void ZoomIsoRecorder::record_video_frame(const ZoomOutputInfo &info, uint32_t participant,
+                                         uint32_t w, uint32_t h, const uint8_t *y, const uint8_t *u,
+                                         const uint8_t *v, uint32_t sy, uint32_t suv, uint64_t ns)
 {
     std::lock_guard<std::mutex> lock(m_mtx);
-    if (info.source_uuid.empty()) return;
-    m_outputs[info.source_uuid] = info;
-    auto it = m_sessions.find(info.source_uuid);
-    if (it == m_sessions.end())
+    if (!should_record(info, participant))
         return;
-    if (should_record(info, info.participant_id)) {
-        it->second.unresolved_since_ns = 0;
-        return;
-    }
-    if (info.assignment == AssignmentMode::ScreenShare) {
-        // Assignment changed away from a recordable mode — final.
-        close_session_locked(info.source_uuid);
-        return;
-    }
-    // Unresolved participant: often transient (engine reconnect, camera
-    // toggle). Start the grace clock instead of finalizing the file;
-    // sweep_unresolved_locked() closes it if this persists.
-    if (it->second.unresolved_since_ns == 0)
-        it->second.unresolved_since_ns = os_gettime_ns();
+    ensure_audio_locked(info, participant);
+    auto &session = ensure_session_locked(info, participant, ns);
+    if (iso_take_provider(session.video_owner, session.video_ns, info.source_uuid, ns))
+        session.writer->video(w, h, y, u, v, sy, suv, ns);
 }
-
-void ZoomIsoRecorder::on_output_removed(const std::string &source_uuid)
+void ZoomIsoRecorder::record_audio_frame(const ZoomOutputInfo &info, uint32_t participant,
+                                         const uint8_t *pcm, uint32_t bytes, uint32_t rate,
+                                         uint16_t channels, uint64_t ns)
 {
     std::lock_guard<std::mutex> lock(m_mtx);
-    close_session_locked(source_uuid);
-    m_outputs.erase(source_uuid);
-}
-
-bool ZoomIsoRecorder::should_record(const ZoomOutputInfo &info,
-                                    uint32_t resolved_participant_id) const
-{
-    if (!m_active.load(std::memory_order_acquire)) return false;
-    if (info.source_uuid.empty()) return false;
-    if (info.assignment == AssignmentMode::ScreenShare) return false;
-    if (resolved_participant_id == 0 &&
-        info.assignment != AssignmentMode::ActiveSpeaker &&
-        info.assignment != AssignmentMode::SpotlightIndex)
-        return false;
-    return true;
-}
-
-ZoomIsoRecorder::Session &
-ZoomIsoRecorder::ensure_session_locked(const ZoomOutputInfo &info,
-                                       uint32_t resolved_participant_id,
-                                       uint32_t width,
-                                       uint32_t height,
-                                       uint64_t timestamp_ns)
-{
-    auto it = m_sessions.find(info.source_uuid);
-    const bool needs_new = it == m_sessions.end() ||
-        it->second.resolved_participant_id != resolved_participant_id ||
-        it->second.width != width ||
-        it->second.height != height;
-    if (!needs_new) return it->second;
-
-    if (it != m_sessions.end()) {
-        // Resolution or participant change: finalize the old segment
-        // without blocking (we are on the frame-dispatch thread).
-        begin_finishing_locked(std::move(it->second));
-        m_sessions.erase(it);
-    }
-
-    Session session;
-    session.source_uuid = info.source_uuid;
-    session.source_name = info.source_name;
-    session.display_name = info.display_name.empty()
-        ? info.source_name : info.display_name;
-    session.assignment = info.assignment;
-    session.configured_participant_id = info.participant_id;
-    session.resolved_participant_id = resolved_participant_id;
-    session.width = width;
-    session.height = height;
-    session.started_ns = timestamp_ns;
-    // Seeds the video pacer's schedule at the session's own start, the same
-    // instant started_ns records — see src/iso-video-pacer.h.
-    session.video_next_due_ns = timestamp_ns;
-
-    QDir root(QString::fromStdString(m_config.output_dir));
-    const QString stamp = QDateTime::currentDateTimeUtc()
-        .toString("yyyyMMdd-HHmmss-zzz");
-    const QString name = sanitized(session.display_name,
-        QStringLiteral("source"));
-    const QString participant =
-        resolved_participant_id == 0
-            ? QStringLiteral("unresolved")
-            : QString::number(resolved_participant_id);
-    const QString base = QString("%1_%2_%3_%4")
-        .arg(stamp, name, QString::fromLatin1(assignment_label(info.assignment)),
-             participant);
-    session.base_path = root.absoluteFilePath(base);
-    session.video_path = session.base_path + ".mp4";
-    session.audio_path = session.base_path + ".wav";
-    session.requested_video_encoder = m_requested_video_encoder.empty()
-        ? normalized_video_encoder(m_config.video_encoder)
-        : m_requested_video_encoder;
-    // Encoder placement: hardware sessions are a shared, finite budget
-    // (OBS's own outputs included), so each ISO session is placed
-    // individually — NVENC while the budget lasts, then QSV/AMF/x264.
-    // A session that already failed once on a hardware encoder was demoted
-    // and stays demoted for this run.
-    const auto demoted = m_encoder_demotions.find(session.source_uuid);
-    if (demoted != m_encoder_demotions.end()) {
-        session.video_encoder = demoted->second;
-    } else {
-        int nvenc_in_use_iso = 0;
-        for (const auto &other : m_sessions) {
-            if (other.second.video_encoder == "h264_nvenc" &&
-                other.second.ffmpeg && other.second.ffmpeg->running())
-                ++nvenc_in_use_iso;
-        }
-        const int remaining = m_nvenc_session_limit -
-                              count_obs_nvenc_encoders() - nvenc_in_use_iso;
-        session.video_encoder = iso_choose_session_encoder(
-            normalized_video_encoder(m_config.video_encoder), remaining,
-            m_encoder_avail);
-    }
-    session.encoder_fallback =
-        session.requested_video_encoder != session.video_encoder;
-
-    session.ffmpeg = std::make_unique<IsoFfmpegPipe>();
-    std::vector<std::string> args = {
-        "-hide_banner", "-loglevel", "warning", "-y",
-        "-f", "rawvideo",
-        "-pix_fmt", "yuv420p",
-        "-s", std::to_string(width) + "x" + std::to_string(height),
-        // record_video_frame() paces every call to kIsoVideoTargetFps
-        // BEFORE it reaches this pipe (see the call site below and
-        // src/iso-video-pacer.h) -- what ffmpeg receives is genuinely CFR,
-        // so a plain declared -r here is correct and sufficient. It was
-        // NOT always sufficient: an earlier version of this fix tried
-        // -use_wallclock_as_timestamps to let ffmpeg itself derive PTS from
-        // real per-frame arrival time, on the theory that Zoom's actual
-        // delivery rate fluctuates 10-60fps with network/encoder conditions
-        // outside our control (CLAUDE.md's "media events are prompts, not
-        // payloads" applies to video here too) and record_video_frame() was
-        // called 1:1 with that, never padded, so a declared-CFR -r 30 was
-        // silently wrong whenever the source's real average differed from
-        // 30 (measured live 2026-08-19: observed_fps 16-18 on every
-        // participant, meaning every ISO file from that verification
-        // session played back at roughly 1.7-1.9x speed and finished in
-        // ~55-60% of the real meeting's duration). That was a correct
-        // diagnosis but the wrong mechanism: probed directly against this
-        // exact ffmpeg build (8.1.1) with ffprobe -show_frames, the
-        // rawvideo demuxer does not honor -use_wallclock_as_timestamps at
-        // all -- every frame's pts_time came back as a pure
-        // frame_index/30, identical to the unpatched behavior, even when
-        // fed a deliberate 1.5s real-time gap. Pacing before the pipe
-        // avoids depending on that (undocumented, apparently silently
-        // ignored) demuxer behavior entirely: duplicate the held frame to
-        // fill a stall, drop excess frames on a burst, so ffmpeg is never
-        // asked to infer timing it cannot actually derive from a raw byte
-        // stream.
-        "-r", std::to_string(kIsoVideoTargetFps),
-        "-i", "pipe:0",
-        "-an",
-    };
-    for (const QString &a : ffmpeg_video_encoder_args(session.video_encoder))
-        args.push_back(a.toStdString());
-    // Fragmented MP4: the file is playable up to the last written
-    // fragment even if FFmpeg is killed or the machine loses power
-    // (+faststart wrote the index only during finalize — and rewrote
-    // the whole file, which made shutdown slow on synced folders and
-    // left killed recordings unplayable).
-    args.push_back("-movflags");
-    args.push_back("+frag_keyframe+empty_moov");
-    args.push_back(session.video_path.toStdString());
-
-    // Allow codec startup and normal delivery jitter without unbounded RAM.
-    // Repeated catch-up pictures share storage, but consume logical slots.
-    // 96 frames at 1080p = 285 MiB; larger formats hit the 288 MiB byte cap.
-    session.ffmpeg->configure_frame_limits(IsoFfmpegPipe::kSteadyFrames,
-                                           IsoFfmpegPipe::kStartupFrames);
-    const size_t frame_cap =
-        std::min<size_t>(static_cast<size_t>(width) * height * 3 / 2 *
-                            IsoFfmpegPipe::kStartupFrames,
-                         IsoFfmpegPipe::kMaximumPixelBytes);
-    std::string start_error;
-    if (!session.ffmpeg->start(
-            m_config.ffmpeg_path, args,
-            (session.base_path + ".ffmpeg.log").toStdString(),
-            frame_cap, &start_error)) {
-        session.ffmpeg_error = QString::fromStdString(start_error);
-        session.ffmpeg_error_logged = true;
-        blog(LOG_WARNING,
-             "[obs-zoom-plugin] ISO ffmpeg failed to start for %s: %s",
-             session.source_name.c_str(), start_error.c_str());
-    } else {
-        session.ffmpeg_started_ns = os_gettime_ns();
-    }
-
-    blog(LOG_INFO,
-         "[obs-zoom-plugin] ISO session started: source=%s participant=%u encoder=%s video=%s audio=%s",
-         session.source_name.c_str(), session.resolved_participant_id,
-         session.video_encoder.c_str(),
-         session.video_path.toUtf8().constData(),
-         session.audio_path.toUtf8().constData());
-
-    auto inserted = m_sessions.emplace(info.source_uuid, std::move(session));
-    return inserted.first->second;
-}
-
-void ZoomIsoRecorder::close_session_locked(const std::string &source_uuid)
-{
-    auto it = m_sessions.find(source_uuid);
-    if (it == m_sessions.end()) return;
-    begin_finishing_locked(std::move(it->second));
-    m_sessions.erase(it);
-}
-
-// Mid-recording closes must never wait on an encoder: they run on the
-// frame-dispatch thread, and a blocked dispatch thread starves the engine's
-// IPC pipe (the 2026-08-08 engine-"death" incidents). Signal EOF, park the
-// session, and let reap_finishing_locked() finalize it from status polls.
-void ZoomIsoRecorder::begin_finishing_locked(Session &&session)
+    if (!should_record(info, participant))
+        return;
+    // OBS source PCM may be the meeting mix. It can discover a route, but must
+    // never be written to a participant recording, even if labelled with its ID.
+    (void)pcm; (void)bytes; (void)rate; (void)channels; (void)ns;
+    ensure_audio_locked(info, participant);
+}
+void ZoomIsoRecorder::ensure_audio_locked(const ZoomOutputInfo &info, uint32_t participant)
+{
+    if (m_audio_taps.count(participant)) return;
+    const auto uuid = "iso_audio_" + std::to_string(m_epoch_ns) + "_" + std::to_string(participant);
+    const auto epoch = m_epoch_ns;
+    auto tap = std::make_shared<IsoAudioTap>(uuid,participant,
+        [this,info,participant,epoch](const uint8_t *pcm,uint32_t bytes,uint32_t rate,uint16_t channels,uint64_t ns) {
+            receive_isolated_audio(info,participant,epoch,pcm,bytes,rate,channels,ns);
+        }, [] { return os_gettime_ns(); });
+    m_audio_taps.emplace(participant,tap);
+    tap->start();
+}
+void ZoomIsoRecorder::receive_isolated_audio(const ZoomOutputInfo &info,uint32_t participant,
+    uint64_t epoch,const uint8_t *pcm,uint32_t bytes,uint32_t rate,uint16_t channels,uint64_t ns)
 {
-    session.wav.close();
-    if (session.ffmpeg) {
-        refresh_ffmpeg_status_locked(session);
-        session.ffmpeg->close_stdin();
+    std::lock_guard<std::mutex> lock(m_mtx);
+    if (!m_active.load() || epoch != m_epoch_ns || !m_audio_taps.count(participant)) return;
+    if (!m_sessions.count(participant)) {
+        const auto route = m_outputs.find(info.source_uuid);
+        if (route == m_outputs.end() || !should_record(route->second,participant) ||
+            (route->second.assignment == AssignmentMode::Participant &&
+             route->second.participant_id != participant)) return;
     }
-    session.finishing_since_ns = os_gettime_ns();
-    m_finishing.push_back(std::move(session));
+    auto &session=ensure_session_locked(info,participant,ns);
+    session.audio_ns=ns;
+    session.writer->audio(pcm,bytes,rate,channels,ns);
 }
-
-void ZoomIsoRecorder::reap_finishing_locked()
+void ZoomIsoRecorder::on_output_updated(const ZoomOutputInfo &info)
 {
-    constexpr uint64_t kFinishingKillNs = 15000000000ULL;
-    const uint64_t now_ns = os_gettime_ns();
-    for (auto it = m_finishing.begin(); it != m_finishing.end();) {
-        Session &session = *it;
-        bool done = true;
-        if (session.ffmpeg && session.ffmpeg->running()) {
-            const uint64_t age_ns =
-                now_ns >= session.finishing_since_ns
-                    ? now_ns - session.finishing_since_ns
-                    : 0;
-            if (age_ns > kFinishingKillNs) {
-                mark_ffmpeg_failure_locked(
-                    session,
-                    QStringLiteral(
-                        "FFmpeg did not exit within the shutdown budget "
-                        "and was terminated — the recording may be missing "
-                        "its final index (moov)."));
-                session.ffmpeg->kill();
-                session.ffmpeg->wait_finished(100);
-            }
-            done = !session.ffmpeg->running();
-        }
-        if (!done) {
-            ++it;
-            continue;
-        }
-        refresh_ffmpeg_status_locked(session);
-        blog(LOG_INFO,
-             "[obs-zoom-plugin] ISO session closed: source=%s participant=%u frames=%u audio_chunks=%u",
-             session.source_name.c_str(), session.resolved_participant_id,
-             session.video_frames, session.audio_chunks);
-        QJsonObject completed = session_status_json_locked(session, true);
-        completed["completed_at"] =
-            QDateTime::currentDateTimeUtc().toString(Qt::ISODateWithMs);
-        m_completed_sessions.insert(m_completed_sessions.begin(), completed);
-        if (m_completed_sessions.size() > kMaxCompletedIsoSessions)
-            m_completed_sessions.resize(kMaxCompletedIsoSessions);
-        it = m_finishing.erase(it);
-    }
+    std::lock_guard<std::mutex> lock(m_mtx);
+    m_outputs[info.source_uuid] = info;
+    if (should_record(info, info.participant_id)) ensure_audio_locked(info, info.participant_id);
 }
-
-// Closes sessions whose participant has stayed unresolved past the grace
-// window. Transient unresolves (engine reconnect, camera toggles) must NOT
-// finalize the file — that was fragmenting recordings into segments.
-void ZoomIsoRecorder::sweep_unresolved_locked()
+void ZoomIsoRecorder::on_output_removed(const std::string &source)
 {
-    constexpr uint64_t kUnresolvedGraceNs = 60000000000ULL;
-    const uint64_t now_ns = os_gettime_ns();
-    std::vector<std::string> to_close;
+    std::lock_guard<std::mutex> lock(m_mtx);
+    m_outputs.erase(source);
     for (auto &entry : m_sessions) {
-        Session &session = entry.second;
-        if (session.unresolved_since_ns == 0 ||
-            now_ns < session.unresolved_since_ns)
-            continue;
-        if (now_ns - session.unresolved_since_ns > kUnresolvedGraceNs)
-            to_close.push_back(entry.first);
-    }
-    for (const std::string &uuid : to_close) {
-        blog(LOG_INFO,
-             "[obs-zoom-plugin] ISO session %s unresolved for over 60s; "
-             "finalizing its recording",
-             uuid.c_str());
-        close_session_locked(uuid);
+        if (entry.second.video_owner == source)
+            entry.second.video_owner.clear();
+        if (entry.second.audio_owner == source)
+            entry.second.audio_owner.clear();
     }
+    // Keep the participant's file and clock alive until Record/Stop ends.
 }
-
-
-QJsonObject ZoomIsoRecorder::session_status_json_locked(Session &s,
-                                                        bool completed)
+QJsonObject ZoomIsoRecorder::session_status_locked(Session &session, bool completed,
+                                                   uint64_t end_ns)
 {
-    // Finalize an overload-stopped WAV from the status lane, not video dispatch.
-    if (s.media_stopped) s.wav.close();
-    refresh_ffmpeg_status_locked(s);
+    const auto status = session.writer->status();
+    if (!status.error.empty() && !session.error_logged) {
+        blog(LOG_ERROR, "[obs-zoom-plugin] ISO participant %u failed: %s", session.participant,
+             status.error.c_str());
+        session.error_logged = true;
+    }
+    const uint64_t now = end_ns ? end_ns : os_gettime_ns();
     QJsonObject obj;
+    obj["source_uuid"] = QString("participant_%1").arg(session.participant);
+    obj["source"] = QString::fromStdString(session.info.source_name);
+    obj["display_name"] = QString::fromStdString(
+        session.info.display_name.empty() ? session.info.source_name : session.info.display_name);
+    obj["resolved_participant_id"] = double(session.participant);
+    obj["configured_participant_id"] = double(session.participant);
+    obj["assignment"] = "participant";
+    obj["width"] = 1920;
+    obj["height"] = 1080;
+    obj["input_width"] = int(status.input_width);
+    obj["input_height"] = int(status.input_height);
+    obj["start_offset_ms"] = double((session.epoch_ns - m_epoch_ns) / 1000000);
+    obj["elapsed_ms"] = double((now - session.epoch_ns) / 1000000);
+    obj["last_video_age_ms"] = session.video_ns ? double((now - session.video_ns) / 1000000) : -1;
+    obj["last_audio_age_ms"] = session.audio_ns ? double((now - session.audio_ns) / 1000000) : -1;
+    obj["video_frames"] = double(status.frames);
+    obj["written_frames"] = double(status.written_frames);
+    obj["audio_chunks"] = double(status.audio_packets);
+    obj["audio_isolated"] = true;
+    obj["coalesced_video_frames"] = double(status.coalesced_video);
+    obj["late_audio_frames"] = double(status.late_audio_frames);
+    obj["video_frames_dropped"] = 0;
+    obj["queued_frames"] = double(status.queued_frames);
+    obj["queue_duration_ms"] = double(status.queued_frames) * 1000 / 30;
+    obj["peak_queued_frames"] = double(status.peak_frames);
+    obj["startup_buffering"] = status.startup;
+    obj["media_stopped"] = !status.error.empty();
+    obj["ffmpeg_error"] = QString::fromStdString(status.error);
+    const auto tap = m_audio_taps.find(session.participant);
+    if (tap != m_audio_taps.end() && !tap->second->error().empty())
+        obj["ffmpeg_error"] = QString::fromStdString(tap->second->error());
+    obj["ffmpeg_running"] = !status.done;
     obj["completed"] = completed;
-    obj["source_uuid"] = QString::fromStdString(s.source_uuid);
-    obj["source"] = QString::fromStdString(s.source_name);
-    obj["display_name"] = QString::fromStdString(s.display_name);
-    obj["assignment"] = assignment_label(s.assignment);
-    obj["configured_participant_id"] =
-        static_cast<double>(s.configured_participant_id);
-    obj["resolved_participant_id"] =
-        static_cast<double>(s.resolved_participant_id);
-    obj["width"] = static_cast<int>(s.width);
-    obj["height"] = static_cast<int>(s.height);
-    obj["video_frames"] = static_cast<int>(s.video_frames);
-    obj["video_frames_dropped"] =
-        static_cast<double>(s.video_frames_dropped);
-    if (s.ffmpeg) {
-        const auto queue = s.ffmpeg->queue_status();
-        obj["queued_frames"] = static_cast<double>(queue.frames);
-        obj["queued_bytes"] = static_cast<double>(queue.bytes);
-        obj["queue_duration_ms"] = static_cast<double>(queue.frames) * 1000 / kIsoVideoTargetFps;
-        obj["peak_queued_frames"] = static_cast<double>(queue.peak_frames);
-        obj["written_frames"] = static_cast<double>(queue.written_frames);
-        obj["startup_buffering"] = queue.startup;
-    }
-    obj["media_stopped"] = s.media_stopped;
-    obj["audio_chunks"] = static_cast<int>(s.audio_chunks);
-    const uint64_t now_ns = os_gettime_ns();
-    obj["elapsed_ms"] = s.started_ns > 0 && now_ns >= s.started_ns
-        ? static_cast<double>((now_ns - s.started_ns) / 1000000ULL)
-        : 0.0;
-    obj["last_video_age_ms"] = s.last_video_ns > 0 && now_ns >= s.last_video_ns
-        ? static_cast<double>((now_ns - s.last_video_ns) / 1000000ULL)
-        : -1.0;
-    obj["last_audio_age_ms"] = s.last_audio_ns > 0 && now_ns >= s.last_audio_ns
-        ? static_cast<double>((now_ns - s.last_audio_ns) / 1000000ULL)
-        : -1.0;
-    const bool ffmpeg_running =
-        !completed && s.ffmpeg && s.ffmpeg->running();
-    obj["ffmpeg_running"] = ffmpeg_running;
-    obj["ffmpeg_error"] = s.ffmpeg_error;
-    obj["disk_full"] = s.disk_full;
-    obj["ffmpeg_exit_code"] = s.ffmpeg_exit_code;
-    obj["ffmpeg_exit_status"] = s.ffmpeg_exit_status;
-    obj["ffmpeg_output_tail"] = s.ffmpeg_output_tail;
-    obj["requested_video_encoder"] =
-        QString::fromStdString(s.requested_video_encoder);
-    obj["video_encoder"] = QString::fromStdString(s.video_encoder);
-    obj["encoder_fallback"] = s.encoder_fallback;
-    const uint64_t health_now_ns = os_gettime_ns();
-    const bool dropping_recently = s.last_drop_ns > 0 &&
-        health_now_ns >= s.last_drop_ns &&
-        health_now_ns - s.last_drop_ns < 5000000000ULL;
-    QString session_health = QStringLiteral("recording");
-    if (s.disk_full) {
-        session_health = QStringLiteral("disk_full");
-    } else if (!s.ffmpeg_error.isEmpty()) {
-        session_health = QStringLiteral("encoder_error");
-    } else if (completed) {
-        session_health = QStringLiteral("completed");
-    } else if (!ffmpeg_running) {
-        session_health = QStringLiteral("encoder_stopped");
-    } else if (dropping_recently) {
-        session_health = QStringLiteral("encoder_behind");
-    } else if (s.video_frames == 0) {
-        session_health = QStringLiteral("waiting_for_video");
-    } else if (s.audio_chunks == 0) {
-        session_health = QStringLiteral("no_audio_yet");
-    }
-    obj["session_health"] = session_health;
-    obj["video_bytes"] = QFileInfo(s.video_path).exists()
-        ? static_cast<double>(QFileInfo(s.video_path).size())
-        : 0.0;
-    obj["audio_bytes"] = QFileInfo(s.audio_path).exists()
-        ? static_cast<double>(QFileInfo(s.audio_path).size())
-        : 0.0;
-    obj["video_path"] = s.video_path;
-    obj["audio_path"] = s.audio_path;
+    obj["video_encoder"] = QString::fromStdString(session.encoder);
+    obj["requested_video_encoder"] = QString::fromStdString(m_requested_video_encoder);
+    obj["encoder_fallback"] =
+        m_requested_video_encoder != "auto" && session.encoder != m_requested_video_encoder;
+    obj["session_health"] = !status.error.empty() ? "encoder_error"
+                            : completed           ? "completed"
+                                                  : "recording";
+    obj["video_path"] = session.path;
+    obj["audio_path"] = "";
+    obj["audio_muxed"] = true;
+    obj["video_bytes"] = double(QFileInfo(session.path).size());
+    obj["audio_bytes"] = 0;
     return obj;
 }
-
-void ZoomIsoRecorder::refresh_ffmpeg_status_locked(Session &session)
-{
-    if (!session.ffmpeg)
-        return;
-
-    // The child's stdout+stderr live in its sidecar log file; the tail is
-    // re-read whole rather than accumulated, so it stays available after
-    // any kind of exit (the merged-pipe readAll() was empty once the
-    // process was gone).
-    const std::string tail =
-        session.ffmpeg->log_tail(kFfmpegOutputTailChars);
-    if (!tail.empty())
-        session.ffmpeg_output_tail =
-            QString::fromUtf8(tail.data(),
-                              static_cast<int>(tail.size())).trimmed();
-
-    if (session.ffmpeg->running())
-        return;
-
-    session.ffmpeg_exit_code = session.ffmpeg->exit_code();
-    session.ffmpeg_exit_status = session.ffmpeg->crashed()
-        ? QStringLiteral("crashed")
-        : QStringLiteral("normal");
-
-    if (!session.ffmpeg_error.isEmpty())
-        return;
-
-    if (session.ffmpeg->crashed()) {
-        mark_ffmpeg_failure_locked(session, QStringLiteral("FFmpeg crashed."));
-    } else if (session.ffmpeg->exit_code() != 0) {
-        mark_ffmpeg_failure_locked(
-            session,
-            QString("FFmpeg exited with code %1.")
-                .arg(session.ffmpeg->exit_code()));
-    }
-}
-
-void ZoomIsoRecorder::mark_ffmpeg_failure_locked(Session &session,
-                                                const QString &message)
-{
-    if (session.ffmpeg_error.isEmpty())
-        session.ffmpeg_error = message;
-    if (!session.ffmpeg || session.ffmpeg_error_logged)
-        return;
-
-    blog(LOG_WARNING,
-         "[obs-zoom-plugin] ISO ffmpeg failure for %s: %s%s%s",
-         session.source_name.c_str(),
-         session.ffmpeg_error.toUtf8().constData(),
-         session.ffmpeg_output_tail.isEmpty() ? "" : " output=",
-         session.ffmpeg_output_tail.toUtf8().constData());
-    session.ffmpeg_error_logged = true;
-}
-
-void ZoomIsoRecorder::mark_disk_full_locked(Session &session)
-{
-    session.disk_full = true;
-    mark_ffmpeg_failure_locked(
-        session,
-        QStringLiteral("No space left on device - free disk space."));
-}
-
-void ZoomIsoRecorder::close_session_on_disk_full_locked(
-    const std::string &source_uuid)
-{
-    auto it = m_sessions.find(source_uuid);
-    if (it == m_sessions.end() || !it->second.disk_full)
-        return;
-    // Disk is full: stop this session cleanly so the partial files are
-    // finalized rather than left growing against a full volume.
-    close_session_locked(source_uuid);
-}
-
-
-void ZoomIsoRecorder::record_video_frame(const ZoomOutputInfo &info,
-                                         uint32_t resolved_participant_id,
-                                         uint32_t width,
-                                         uint32_t height,
-                                         const uint8_t *y,
-                                         const uint8_t *u,
-                                         const uint8_t *v,
-                                         uint32_t stride_y,
-                                         uint32_t stride_uv,
-                                         uint64_t timestamp_ns)
+QJsonArray ZoomIsoRecorder::status_json()
 {
-    if (!y || !u || !v || width == 0 || height == 0) return;
     std::lock_guard<std::mutex> lock(m_mtx);
-    if (!should_record(info, resolved_participant_id)) return;
-    if (m_stopped_sources.count(info.source_uuid)) return;
-    Session &session = ensure_session_locked(info, resolved_participant_id,
-                                             width, height, timestamp_ns);
-    session.unresolved_since_ns = 0; // frames flowing == resolved
-    if (!session.ffmpeg || !session.ffmpeg->running()) {
-        refresh_ffmpeg_status_locked(session);
-        // Startup-time death of a hardware encoder usually means the
-        // session-budget estimate was wrong for this GPU (driver caps
-        // vary). Demote this source one tier and recreate on the next
-        // frame instead of surfacing a dead "Encoder error" row.
-        //
-        // Deliberately NOT gated on "has this uuid ever been demoted
-        // before": that was the bug. iso_demote_encoder() is a CHAIN
-        // (nvenc -> qsv -> amf -> libx264), but the old guard let a uuid
-        // take exactly one hop for the rest of the run -- on a box with a
-        // real GPU but no working QSV or AMF runtime (live 2026-08-19:
-        // "Error creating a MFX session" / "DLL amfrt64.dll failed to
-        // open"), a source demoted nvenc->qsv failed qsv too, could not
-        // demote again, and sat at video_frames=2 permanently instead of
-        // ever reaching libx264 (CPU, no hardware dependency, the one
-        // tier guaranteed to work). `session.video_encoder != "libx264"`
-        // is the only guard the chain needs: it is what iso_demote_encoder
-        // eventually returns for every input, so re-arming this on every
-        // startup failure still terminates, in at most 3 hops.
-        const uint64_t now_ns = os_gettime_ns();
-        if (session.video_encoder != "libx264" &&
-            session.ffmpeg_started_ns != 0 &&
-            now_ns - session.ffmpeg_started_ns < 10000000000ULL) {
-            const std::string next =
-                iso_demote_encoder(session.video_encoder, m_encoder_avail);
-            blog(LOG_WARNING,
-                 "[obs-zoom-plugin] ISO encoder %s failed at startup for "
-                 "%s; retrying with %s",
-                 session.video_encoder.c_str(),
-                 session.source_name.c_str(), next.c_str());
-            const std::string uuid = session.source_uuid;
-            m_encoder_demotions[uuid] = next;
-            close_session_locked(uuid);
-            return;
-        }
-        if (session.ffmpeg_error.isEmpty())
-            mark_ffmpeg_failure_locked(
-                session, QStringLiteral("FFmpeg is not running."));
-        return;
-    }
-
-    // One contiguous I420 frame, then a single bounded queue attempt.
-    // Whole-frame granularity is load-bearing: a partially written frame
-    // would shift every following frame's bytes and shear the video. The
-    // pipe's writer thread does the blocking writes; a stalled encoder
-    // shows up here as try_queue() == false (drop), never as RAM growth or
-    // a wedge (the QProcess feed stalled after ~5 frames — see
-    // iso-ffmpeg-pipe.h).
-    const size_t frame_bytes =
-        static_cast<size_t>(width) * height * 3 / 2;
-    std::vector<uint8_t> frame(frame_bytes);
-    uint8_t *dst = frame.data();
-    for (uint32_t row = 0; row < height; ++row) {
-        std::memcpy(dst, y + row * stride_y, width);
-        dst += width;
-    }
-    for (uint32_t row = 0; row < height / 2; ++row) {
-        std::memcpy(dst, u + row * stride_uv, width / 2);
-        dst += width / 2;
-    }
-    for (uint32_t row = 0; row < height / 2; ++row) {
-        std::memcpy(dst, v + row * stride_uv, width / 2);
-        dst += width / 2;
-    }
-
-    // Commit the schedule only after the entire CFR batch is accepted.
-    // A rejected batch ends this track instead of compressing its timeline.
-    const auto submission = iso_video_submit(session.video_next_due_ns, timestamp_ns,
-        [&](uint32_t due) { return session.ffmpeg->try_queue(std::move(frame), due); });
-    if (!submission.frames) return;
-    if (!submission.accepted) {
-        session.video_frames_dropped += submission.frames;
-        session.last_drop_ns = timestamp_ns;
-        session.media_stopped = true;
-        m_stopped_sources.insert(info.source_uuid);
-        const QString warning = QStringLiteral("One or more ISO tracks stopped accepting media. Recording is incomplete; inspect the track errors before restarting.");
-        if (!m_status_warning.contains(warning)) {
-            if (!m_status_warning.isEmpty()) m_status_warning += " ";
-            m_status_warning += warning;
-        }
-        const auto queue = session.ffmpeg->queue_status();
-        mark_ffmpeg_failure_locked(session,
-            queue.broken
-                ? QStringLiteral("ISO input pipe failed; this track stopped accepting media.")
-                : QStringLiteral("ISO buffering limit exceeded; this track stopped accepting media to preserve timing. Reduce ISO load and restart recording."));
-        session.ffmpeg->close_stdin();
-        return;
-    }
-    session.video_frames += submission.frames;
-    session.last_video_ns = timestamp_ns;
+    QJsonArray result;
+    for (auto &entry : m_sessions)
+        result.append(session_status_locked(entry.second, false));
+    for (const auto &entry : m_completed_sessions)
+        result.append(entry);
+    return result;
 }
-
-void ZoomIsoRecorder::record_audio_frame(const ZoomOutputInfo &info,
-                                         uint32_t resolved_participant_id,
-                                         const uint8_t *pcm,
-                                         uint32_t byte_len,
-                                         uint32_t sample_rate,
-                                         uint16_t channels,
-                                         uint64_t timestamp_ns)
+QJsonObject ZoomIsoRecorder::status_overview()
 {
-    if (!pcm || byte_len == 0 || sample_rate == 0) return;
     std::lock_guard<std::mutex> lock(m_mtx);
-    if (!should_record(info, resolved_participant_id)) return;
-    auto it = m_sessions.find(info.source_uuid);
-    if (it == m_sessions.end() ||
-        it->second.resolved_participant_id != resolved_participant_id) {
-        return;
-    }
-    Session &session = it->second;
-    if (session.media_stopped) return;
-    if (!session.wav.file &&
-        !session.wav.open(session.audio_path, sample_rate, channels)) {
-        blog(LOG_WARNING,
-             "[obs-zoom-plugin] ISO WAV open failed: %s",
-             session.audio_path.toUtf8().constData());
-        return;
-    }
-    if (session.wav.sample_rate == sample_rate &&
-        session.wav.channels == std::max<uint16_t>(channels, 1)) {
-        // Zoom only calls back audio for a participant currently producing
-        // sound, so gaps here are ordinary and expected -- not lost data.
-        // Backfill silence for the gap BEFORE the real buffer, so the WAV's
-        // byte position keeps tracking wall-clock position instead of
-        // shrinking by every silent stretch (see src/iso-audio-gap-fill.h).
-        // `session.last_audio_ns == 0` means nothing has been written yet;
-        // session.started_ns (stamped from the first VIDEO frame in
-        // ensure_session_locked) is the right reference then, so a
-        // participant who stays quiet after their video starts gets that
-        // lead time as real silence instead of the file starting misaligned.
-        //
-        // session.last_audio_ns is a CONTENT-DRIVEN PLAYHEAD, not "the last
-        // call's arrival time" -- it advances by exactly how much audio was
-        // WRITTEN (silence + real), never snapped to timestamp_ns. Live
-        // bug (2026-08-21): an earlier version set it to timestamp_ns after
-        // every write, so ordinary per-call dispatch/IPC latency jitter --
-        // a 10ms buffer's callback landing, say, ~20ms after the previous
-        // one's arrival stamp even with zero real silence between them --
-        // read as a genuine 10ms gap on nearly every single buffer. Over a
-        // whole session that inserted almost as much bogus silence as real
-        // audio: measured live, a 152s video paired a 305s WAV, almost
-        // exactly 2x. Advancing by content duration instead (the same
-        // "never consult arrival except to anchor" doctrine
-        // src/audio-timeline.h already uses for the live OBS path) makes
-        // ordinary arrival jitter invisible: the playhead only falls behind
-        // real arrival time -- triggering a real backfill -- when audio
-        // actually stopped arriving, not merely when this call happened to
-        // land a few ms later than the last one.
-        const uint64_t audio_reference_ns =
-            session.last_audio_ns != 0 ? session.last_audio_ns
-                                       : session.started_ns;
-        const uint64_t silence_frames = iso_audio_silence_frames(
-            audio_reference_ns, timestamp_ns, sample_rate);
-        uint64_t playhead_ns = audio_reference_ns +
-            (silence_frames * 1'000'000'000ULL) / sample_rate;
-        if (silence_frames > 0) {
-            const uint16_t effective_channels =
-                std::max<uint16_t>(channels, 1);
-            const std::vector<uint8_t> silence(
-                static_cast<size_t>(silence_frames) * effective_channels *
-                    sizeof(int16_t),
-                0);
-            bool disk_full = false;
-            if (!session.wav.write(silence.data(),
-                                   static_cast<uint32_t>(silence.size()),
-                                   &disk_full)) {
-                if (disk_full) {
-                    mark_disk_full_locked(session);
-                } else if (session.ffmpeg_error.isEmpty()) {
-                    mark_ffmpeg_failure_locked(
-                        session, QStringLiteral("WAV write failed."));
-                }
-                const std::string source_uuid = session.source_uuid;
-                close_session_locked(source_uuid);
-                return;
-            }
+    QJsonObject obj;
+    obj["active"] = m_active.load();
+    obj["finishing"] = m_stopping.load();
+    QJsonArray selected_sources;
+    for (const auto &uuid : m_config.selected_source_uuids)
+        selected_sources.append(QString::fromStdString(uuid));
+    obj["selected_source_uuids"] = selected_sources;
+    obj["output_dir"] = QString::fromStdString(m_config.output_dir);
+    obj["session_count"] = int(m_sessions.size());
+    obj["completed_session_count"] = int(m_completed_sessions.size());
+    QString warning = m_status_warning;
+    for (const auto &entry : m_audio_taps) {
+        const auto error = entry.second->error();
+        if (!error.empty()) { warning = QString::fromStdString(error); break; }
+    }
+    for (const auto &entry : m_sessions)
+        if (!entry.second.writer->status().error.empty()) {
+            warning = "One or more participant recordings failed. Inspect the track errors.";
+            break;
         }
-        const uint32_t real_frames =
-            byte_len / (sizeof(int16_t) * std::max<uint16_t>(channels, 1));
-        playhead_ns += (static_cast<uint64_t>(real_frames) *
-                        1'000'000'000ULL) / sample_rate;
-
-        bool disk_full = false;
-        if (!session.wav.write(pcm, byte_len, &disk_full)) {
-            if (disk_full) {
-                mark_disk_full_locked(session);
-            } else if (session.ffmpeg_error.isEmpty()) {
-                mark_ffmpeg_failure_locked(
-                    session,
-                    QStringLiteral("WAV write failed."));
-            }
-            // Finalize and close the WAV so it stays valid/playable, and
-            // stop the rest of this session cleanly. Copy the key first:
-            // close_session_locked erases the Session (and its source_uuid).
-            const std::string source_uuid = session.source_uuid;
-            close_session_locked(source_uuid);
-            return;
+    for (const auto &entry : m_completed_sessions)
+        if (!entry.value("ffmpeg_error").toString().isEmpty()) {
+            warning = "One or more participant recordings failed. Inspect the track errors.";
+            break;
         }
-        ++session.audio_chunks;
-        // Content-driven playhead (see the comment above) -- NOT
-        // timestamp_ns. session.last_video_ns and last_drop_ns stay
-        // arrival-stamped on purpose; only this field is a virtual position
-        // rather than a clock reading.
-        session.last_audio_ns = playhead_ns;
-    }
+    obj["warning"] = warning;
+    obj["record_program"] = m_config.record_program;
+    obj["video_encoder"] = QString::fromStdString(m_config.video_encoder);
+    obj["requested_video_encoder"] = QString::fromStdString(m_requested_video_encoder);
+    obj["ffmpeg_path"] = QString::fromStdString(m_config.ffmpeg_path);
+    const QStorageInfo storage(QString::fromStdString(m_config.output_dir));
+    obj["disk_available_bytes"] = double(storage.bytesAvailable());
+    obj["disk_warning"] = storage.bytesAvailable() < kIsoWarningFreeBytes;
+    return obj;
 }
 
 static std::string normalized_video_encoder(const std::string &encoder)
 {
-    if (encoder == "auto" || encoder == "h264_nvenc" ||
-        encoder == "h264_qsv" || encoder == "h264_amf" ||
-        encoder == "libx264") {
+    if (encoder == "auto" || encoder == "h264_nvenc" || encoder == "h264_qsv" ||
+        encoder == "h264_amf" || encoder == "libx264") {
         return encoder;
     }
     return "auto";
@@ -1119,8 +498,7 @@ static int count_obs_nvenc_encoders()
             if (!obs_output_active(output))
                 return true;
             for (size_t i = 0; i < MAX_OUTPUT_VIDEO_ENCODERS; ++i) {
-                obs_encoder_t *enc =
-                    obs_output_get_video_encoder2(output, i);
+                obs_encoder_t *enc = obs_output_get_video_encoder2(output, i);
                 if (!enc)
                     continue;
                 const char *id = obs_encoder_get_id(enc);
@@ -1135,17 +513,17 @@ static int count_obs_nvenc_encoders()
 
 static bool is_hardware_encoder(const std::string &encoder)
 {
-    return encoder == "h264_nvenc" || encoder == "h264_qsv" ||
-        encoder == "h264_amf";
+    return encoder == "h264_nvenc" || encoder == "h264_qsv" || encoder == "h264_amf";
 }
 
-static bool ffmpeg_encoder_available(const QString &ffmpeg_path,
-                                     const std::string &encoder,
+static bool ffmpeg_encoder_available(const QString &ffmpeg_path, const std::string &encoder,
                                      std::string *error)
 {
     QProcess probe;
     probe.setProgram(ffmpeg_path);
-    probe.setArguments({"-hide_banner", "-encoders"});
+    probe.setArguments({"-hide_banner", "-loglevel", "error", "-f", "lavfi", "-i",
+                        "color=size=1920x1080:rate=30", "-frames:v", "1", "-an", "-c:v",
+                        QString::fromStdString(encoder), "-f", "null", "-"});
     probe.setProcessChannelMode(QProcess::MergedChannels);
     probe.start(QIODevice::ReadOnly);
     if (!probe.waitForStarted(2000)) {
@@ -1155,34 +533,19 @@ static bool ffmpeg_encoder_available(const QString &ffmpeg_path,
         }
         return false;
     }
-    if (!probe.waitForFinished(5000))
+    if (!probe.waitForFinished(10000)) {
         probe.kill();
+        probe.waitForFinished(2000);
+        if (error)
+            *error = "Encoder startup probe timed out: " + encoder;
+        return false;
+    }
 
-    const QString encoders = QString::fromUtf8(probe.readAll());
-    if (encoders.contains(QString::fromStdString(encoder)))
+    if (probe.exitStatus() == QProcess::NormalExit && probe.exitCode() == 0)
         return true;
 
     if (error) {
-        *error = "FFmpeg encoder '" + encoder +
-                 "' is not available in the selected ffmpeg build.";
+        *error = "FFmpeg encoder '" + encoder + "' is not available in the selected ffmpeg build.";
     }
     return false;
 }
-
-static QStringList ffmpeg_video_encoder_args(const std::string &encoder)
-{
-    if (encoder == "libx264") {
-        return {
-            "-c:v", "libx264",
-            "-preset", "veryfast",
-            "-crf", "18",
-        };
-    }
-
-    return {
-        "-c:v", QString::fromStdString(encoder),
-        "-b:v", "12M",
-        "-maxrate", "20M",
-        "-bufsize", "24M",
-    };
-}
diff --git a/src/zoom-iso-recorder.h b/src/zoom-iso-recorder.h
index c6e151e..0dd1737 100644
--- a/src/zoom-iso-recorder.h
+++ b/src/zoom-iso-recorder.h
@@ -1,9 +1,10 @@
 #pragma once
 
+#include "iso-encoder-plan.h"
+#include "iso-track-writer.h"
+#include "iso-audio-tap.h"
 #include "zoom-output-manager.h"
 #include "zoom-types.h"
-#include "iso-encoder-plan.h"
-#include "iso-ffmpeg-pipe.h"
 #include <QJsonArray>
 #include <QJsonObject>
 #include <QString>
@@ -22,10 +23,12 @@ struct ZoomIsoRecordConfig {
     std::string ffmpeg_path = "ffmpeg";
     std::string video_encoder = "libx264";
     bool record_program = true;
+    std::vector<std::string> selected_source_uuids;
 };
 
-class ZoomIsoRecorder {
-public:
+class ZoomIsoRecorder
+{
+  public:
     static ZoomIsoRecorder &instance();
 
     bool start(const ZoomIsoRecordConfig &config, std::string *error = nullptr);
@@ -37,122 +40,44 @@ class ZoomIsoRecorder {
     void on_output_updated(const ZoomOutputInfo &info);
     void on_output_removed(const std::string &source_uuid);
 
-    void record_video_frame(const ZoomOutputInfo &info,
-                            uint32_t resolved_participant_id,
-                            uint32_t width,
-                            uint32_t height,
-                            const uint8_t *y,
-                            const uint8_t *u,
-                            const uint8_t *v,
-                            uint32_t stride_y,
-                            uint32_t stride_uv,
-                            uint64_t timestamp_ns);
-    void record_audio_frame(const ZoomOutputInfo &info,
-                            uint32_t resolved_participant_id,
-                            const uint8_t *pcm,
-                            uint32_t byte_len,
-                            uint32_t sample_rate,
-                            uint16_t channels,
+    void record_video_frame(const ZoomOutputInfo &info, uint32_t resolved_participant_id,
+                            uint32_t width, uint32_t height, const uint8_t *y, const uint8_t *u,
+                            const uint8_t *v, uint32_t stride_y, uint32_t stride_uv,
                             uint64_t timestamp_ns);
+    void record_audio_frame(const ZoomOutputInfo &info, uint32_t resolved_participant_id,
+                            const uint8_t *pcm, uint32_t byte_len, uint32_t sample_rate,
+                            uint16_t channels, uint64_t timestamp_ns);
 
-private:
+  private:
     ZoomIsoRecorder() = default;
     ~ZoomIsoRecorder();
 
-    struct WavFile {
-        bool open(const QString &path, uint32_t sample_rate, uint16_t channels);
-        // Returns false if a write failed; sets out_disk_full when the
-        // failure was caused by the disk being full (ENOSPC).
-        bool write(const uint8_t *pcm, uint32_t byte_len, bool *out_disk_full);
-        void close();
-        FILE *file = nullptr;
-        uint32_t data_bytes = 0;
-        uint32_t sample_rate = 0;
-        uint16_t channels = 0;
-        bool write_failed = false;
-    };
-
     struct Session {
-        std::string source_uuid;
-        std::string source_name;
-        std::string display_name;
-        AssignmentMode assignment = AssignmentMode::Participant;
-        uint32_t configured_participant_id = 0;
-        uint32_t resolved_participant_id = 0;
-        uint32_t width = 0;
-        uint32_t height = 0;
-        uint32_t video_frames = 0;
-        uint64_t video_frames_dropped = 0;
-        uint64_t last_drop_ns = 0;
-        bool media_stopped = false;
-        uint64_t ffmpeg_started_ns = 0;
-        uint64_t finishing_since_ns = 0;
-        uint64_t unresolved_since_ns = 0;
-        uint32_t audio_chunks = 0;
-        uint64_t started_ns = 0;
-        uint64_t last_video_ns = 0;
-        uint64_t last_audio_ns = 0;
-        // The video pacer's schedule (src/iso-video-pacer.h): the next
-        // frame slot this session has not yet filled. Seeded to started_ns.
-        uint64_t video_next_due_ns = 0;
-        QString base_path;
-        QString video_path;
-        QString audio_path;
-        QString ffmpeg_error;
-        QString ffmpeg_output_tail;
-        int ffmpeg_exit_code = -1;
-        QString ffmpeg_exit_status;
-        bool ffmpeg_error_logged = false;
-        bool disk_full = false;
-        std::string requested_video_encoder;
-        std::string video_encoder;
-        bool encoder_fallback = false;
-        // Raw-pipe process feed — QProcess is banned here: its Windows stdin
-        // chaining needs the owner thread's Qt event loop, and every caller
-        // of record_video_frame() is a plain std::thread (measured live
-        // 2026-08-18: exactly 5 frames per session, then a permanent
-        // backlog). See iso-ffmpeg-pipe.h.
-        std::unique_ptr<IsoFfmpegPipe> ffmpeg;
-        WavFile wav;
+        ZoomOutputInfo info;
+        uint32_t participant = 0;
+        std::string video_owner, audio_owner, encoder;
+        uint64_t video_ns = 0, audio_ns = 0, epoch_ns = 0;
+        QString path;
+        bool error_logged = false;
+        std::unique_ptr<IsoTrackWriter> writer;
     };
-
-    Session &ensure_session_locked(const ZoomOutputInfo &info,
-                                   uint32_t resolved_participant_id,
-                                   uint32_t width,
-                                   uint32_t height,
-                                   uint64_t timestamp_ns);
-    void close_session_locked(const std::string &source_uuid);
-    // Non-blocking close for mid-recording paths (frame-dispatch thread must
-    // never wait on an encoder): signals EOF and parks the session on
-    // m_finishing; reap_finishing_locked() finalizes it from status polls.
-    void begin_finishing_locked(Session &&session);
-    void reap_finishing_locked();
-    void sweep_unresolved_locked();
-    QJsonObject session_status_json_locked(Session &session, bool completed);
-    void refresh_ffmpeg_status_locked(Session &session);
-    void mark_ffmpeg_failure_locked(Session &session, const QString &message);
-    void mark_disk_full_locked(Session &session);
-    // If the session was flagged disk-full, close it cleanly (finalizing the
-    // WAV header and reaping FFmpeg). No-op otherwise. Note: this may
-    // invalidate any Session reference for source_uuid.
-    void close_session_on_disk_full_locked(const std::string &source_uuid);
-    bool should_record(const ZoomOutputInfo &info,
-                       uint32_t resolved_participant_id) const;
-
+    Session &ensure_session_locked(const ZoomOutputInfo &info, uint32_t participant, uint64_t ns);
+    void ensure_audio_locked(const ZoomOutputInfo &info, uint32_t participant);
+    void receive_isolated_audio(const ZoomOutputInfo &info, uint32_t participant,
+        uint64_t epoch, const uint8_t *pcm, uint32_t bytes, uint32_t rate, uint16_t channels, uint64_t ns);
+    QJsonObject session_status_locked(Session &session, bool completed, uint64_t end_ns = 0);
+    bool should_record(const ZoomOutputInfo &info, uint32_t participant) const;
     IsoEncoderAvailability m_encoder_avail;
     int m_nvenc_session_limit = 8;
-    // source_uuid -> encoder to use after a startup failure demoted it.
-    std::unordered_map<std::string, std::string> m_encoder_demotions;
-    std::unordered_set<std::string> m_stopped_sources;
-
     mutable std::mutex m_mtx;
-    std::atomic<bool> m_active{false};
+    std::atomic<bool> m_active{false}, m_stopping{false};
     bool m_started_program_recording = false;
+    uint64_t m_epoch_ns = 0;
     ZoomIsoRecordConfig m_config;
     std::string m_requested_video_encoder;
     QString m_status_warning;
     std::unordered_map<std::string, ZoomOutputInfo> m_outputs;
-    std::unordered_map<std::string, Session> m_sessions;
-    std::vector<Session> m_finishing;
+    std::unordered_map<uint32_t, Session> m_sessions;
+    std::unordered_map<uint32_t, std::shared_ptr<IsoAudioTap>> m_audio_taps;
     std::vector<QJsonObject> m_completed_sessions;
 };
diff --git a/src/zoom-osc-server.cpp b/src/zoom-osc-server.cpp
index c993196..3dba72e 100644
--- a/src/zoom-osc-server.cpp
+++ b/src/zoom-osc-server.cpp
@@ -578,6 +578,7 @@ void ZoomOscServer::dispatch(const QString &address,
         cfg.ffmpeg_path = settings.iso_ffmpeg_path;
         cfg.video_encoder = settings.iso_video_encoder;
         cfg.record_program = settings.iso_record_program;
+        cfg.selected_source_uuids = settings.iso_selected_source_uuids;
         if (!args.empty() && args[0].type == OscArg::String)
             cfg.output_dir = args[0].s;
         if (args.size() >= 2 && args[1].type == OscArg::String)
diff --git a/src/zoom-settings.cpp b/src/zoom-settings.cpp
index de416e7..17b1068 100644
--- a/src/zoom-settings.cpp
+++ b/src/zoom-settings.cpp
@@ -4,6 +4,7 @@
 #include <QByteArray>
 #include <QDateTime>
 #include <QJsonDocument>
+#include <QJsonArray>
 #include <QJsonObject>
 #include <QMessageAuthenticationCode>
 #include <obs-frontend-api.h>
@@ -398,6 +399,10 @@ ZoomPluginSettings ZoomPluginSettings::load()
     const char *iso_ffmpeg_path = config_get_string(cfg, SECTION, "IsoFfmpegPath");
     const char *iso_video_encoder = config_get_string(cfg, SECTION, "IsoVideoEncoder");
     s.iso_output_dir = iso_output_dir ? iso_output_dir : "";
+    const char *iso_sources = config_get_string(cfg, SECTION, "IsoSelectedSources");
+    for (const auto &value : QJsonDocument::fromJson(iso_sources ? QByteArray(iso_sources) : QByteArray()).array())
+        if (value.isString() && !value.toString().isEmpty())
+            s.iso_selected_source_uuids.push_back(value.toString().toStdString());
     if (iso_ffmpeg_path && *iso_ffmpeg_path)
         s.iso_ffmpeg_path = iso_ffmpeg_path;
     if (iso_video_encoder && *iso_video_encoder)
@@ -563,6 +568,11 @@ void ZoomPluginSettings::save() const
     config_set_string(cfg, SECTION, "IsoFfmpegPath",          iso_ffmpeg_path.c_str());
     config_set_string(cfg, SECTION, "IsoVideoEncoder",        iso_video_encoder.c_str());
     config_set_int   (cfg, SECTION, "IsoRecordProgram",       iso_record_program ? 1 : 0);
+    QJsonArray iso_sources;
+    for (const auto &uuid : iso_selected_source_uuids)
+        iso_sources.append(QString::fromStdString(uuid));
+    config_set_string(cfg, SECTION, "IsoSelectedSources",
+                      QJsonDocument(iso_sources).toJson(QJsonDocument::Compact).constData());
     config_set_string(cfg, SECTION, "TalkbackSource",        talkback_source.c_str());
     config_set_int   (cfg, SECTION, "TalkbackLatch",         talkback_latch ? 1 : 0);
     config_set_int   (cfg, SECTION, "TalkbackProbeExpanded", talkback_probe_expanded ? 1 : 0);
diff --git a/src/zoom-settings.h b/src/zoom-settings.h
index 9c58c4e..6e934a2 100644
--- a/src/zoom-settings.h
+++ b/src/zoom-settings.h
@@ -3,6 +3,7 @@
 #include "zoom-reconnect.h"
 #include <cstdint>
 #include <string>
+#include <vector>
 
 struct ZoomPluginSettings {
     std::string         sdk_key, sdk_secret, jwt_token;
@@ -46,6 +47,7 @@ struct ZoomPluginSettings {
     std::string         iso_ffmpeg_path = "ffmpeg";
     std::string         iso_video_encoder = "auto";
     bool                iso_record_program = true;
+    std::vector<std::string> iso_selected_source_uuids;
 
     // Talkback dock (Milestone 7). The OBS audio source the director talks
     // through, stored BY NAME because that is what TalkbackTap::open() and
diff --git a/src/zoom-supersource.cpp b/src/zoom-supersource.cpp
index 7fe93ed..958622e 100644
--- a/src/zoom-supersource.cpp
+++ b/src/zoom-supersource.cpp
@@ -12,6 +12,7 @@
 #include "zoom-tile-shape.h"
 #include "zoom-tile-slot.h"
 #include "zoom-tile-texture.h"
+#include "zoom-tile-frame-read.h"
 #include "zoom-tiles-audio.h"
 #include "zoom-tiles-background.h"
 #include "zoom-tiles-effect.h"
@@ -171,6 +172,8 @@ struct TileFeed {
     // keeps a frozen frame forever (see shm_read_i420_frame in engine-ipc.h).
     uint32_t shm_gen = 0;
     std::vector<uint8_t> frame;  // I420: y_len, then U and V of y_len/4 each
+    std::vector<uint8_t> read_candidate; // uncommitted SHM copy; may be torn on failure
+    uint64_t rejected_reads = 0;
     uint32_t width = 0;
     uint32_t height = 0;
     uint64_t frame_epoch = 0;
@@ -430,13 +433,23 @@ static void tile_feed_on_frame(const TileFeedPtr &feed, uint32_t event_width,
     uint32_t w = 0;
     uint32_t h = 0;
     uint32_t y_len = 0;
-    const ShmFrameRead status =
-        shm_read_i420_frame(feed->shm, IPC_SHM_PREFIX + feed->uuid,
-                            event_width, event_height, event_shm_gen,
-                            feed->shm_gen, feed->frame, w, h, y_len);
-    if (status != ShmFrameRead::Ok) return;
-    // Odd dimensions have no valid I420 chroma layout to sample.
-    if ((w & 1u) || (h & 1u)) return;
+    ShmFrameRead status = ShmFrameRead::Invalid;
+    // A rejected seqlock read may already have overwritten its destination.
+    // Never use the pending draw frame as that destination: its ready flag,
+    // dimensions and generation would still describe the previous good pixels.
+    // This is particularly visible as a color flash during a resolution change.
+    if (!tile_read_frame(feed->frame, feed->read_candidate, [&](auto &candidate) {
+        status = shm_read_i420_frame(feed->shm, IPC_SHM_PREFIX + feed->uuid,
+                                    event_width, event_height, event_shm_gen,
+                                    feed->shm_gen, candidate, w, h, y_len);
+        return status == ShmFrameRead::Ok && !(w & 1u) && !(h & 1u);
+    })) {
+        if (++feed->rejected_reads == 1 || feed->rejected_reads % 300 == 0)
+            blog(LOG_INFO, "[obs-zoom-plugin] Tiles kept last valid frame: uuid=%s rejected=%llu read_status=%d event=%ux%u generation=%u",
+                 feed->uuid.c_str(), static_cast<unsigned long long>(feed->rejected_reads),
+                 static_cast<int>(status), event_width, event_height, event_shm_gen);
+        return;
+    }
 
     ZoomEngineClient::instance().acknowledge_media_delivery(feed->uuid, event_participant_id, delivery_ticket);
     feed->last_frame_ns = os_gettime_ns();
diff --git a/src/zoom-tile-frame-read.h b/src/zoom-tile-frame-read.h
new file mode 100644
index 0000000..e5f3882
--- /dev/null
+++ b/src/zoom-tile-frame-read.h
@@ -0,0 +1,15 @@
+#pragma once
+
+#include <cstdint>
+#include <vector>
+
+// The reader may modify its destination even when its seqlock check fails.
+// A pending frame must remain byte-identical until another valid frame arrives.
+template<class Reader>
+bool tile_read_frame(std::vector<uint8_t> &pending,
+                     std::vector<uint8_t> &candidate, Reader &&read)
+{
+    if (!read(candidate)) return false;
+    pending.swap(candidate);
+    return true;
+}
diff --git a/tests/iso-audio-reader-test.cpp b/tests/iso-audio-reader-test.cpp
new file mode 100644
index 0000000..8330009
--- /dev/null
+++ b/tests/iso-audio-reader-test.cpp
@@ -0,0 +1,38 @@
+#include "iso-audio-reader.h"
+#include <chrono>
+#include <iostream>
+
+int main()
+{
+    const auto uuid="iso_reader_test_"+std::to_string(std::chrono::steady_clock::now().time_since_epoch().count());
+    ShmRegion writer{};
+    const auto base=IPC_SHM_PREFIX+uuid+"_audio";
+    if (!shm_region_create(writer,shm_region_name(base,1),shm_audio_region_bytes(8))) return 1;
+    auto *ring=static_cast<ShmAudioHeader *>(writer.ptr);
+    std::memset(writer.ptr,0,writer.size);
+    ring->slot_count=kAudioRingSlots; ring->slot_bytes=8; ring->sample_rate=48000; ring->channels=1;
+    int delivered=0; bool correct=true;
+    {
+        IsoAudioReader reader(uuid,42,[&](const uint8_t *pcm,uint32_t bytes,uint32_t rate,uint16_t ch,uint64_t ns) {
+            ++delivered;
+            correct &= bytes==8 && rate==48000 && ch==1 && ns==123 && pcm[0]==uint8_t(delivered);
+        }, [] {return 123ULL;});
+        auto publish=[&](uint32_t id,uint8_t value) {
+            auto *slot=reinterpret_cast<ShmAudioSlot *>(static_cast<char *>(writer.ptr)+
+                shm_audio_slot_offset(*ring,ring->write_index%kAudioRingSlots));
+            slot->sequence=1; slot->participant_id=id; slot->byte_len=8;
+            std::memset(slot+1,value,8); slot->sequence=2; ++ring->write_index; ring->notify=1;
+        };
+        // Coalesced first wakeup must retain all initial buffers, not skip them.
+        publish(42,1); publish(42,2); reader.read(8,1);
+        if(delivered!=2 || !correct || ring->notify!=0 || !reader.error().empty()) return 2;
+        reader.read(8,1); if(delivered!=2) return 3;
+        publish(42,3); reader.read(8,1);
+        if(delivered!=3 || !correct) return 4;
+        // Even valid PCM with another attribution is never handed to the writer.
+        publish(43,4); reader.read(8,1);
+        if(delivered!=3 || reader.error().empty()) return 5;
+    }
+    shm_region_destroy(writer);
+    std::cout << "Isolated reader preserves first/batched audio and rejects other participants\n";
+}
diff --git a/tests/iso-audio-routing-test.cpp b/tests/iso-audio-routing-test.cpp
new file mode 100644
index 0000000..db4b1fd
--- /dev/null
+++ b/tests/iso-audio-routing-test.cpp
@@ -0,0 +1,27 @@
+#include "iso-audio-routing.h"
+#include <array>
+#include <iostream>
+
+int main()
+{
+    std::array<int,2> iso{}, normal{};
+    int mix=0, audience=0;
+    // Alternating, distinguishable participants, plus a meeting-mix callback.
+    for (uint32_t speaker : {1u,2u,1u,2u}) {
+        mix += 10; // OBS Mix must continue to receive the full meeting.
+        bool claimed=false;
+        for (uint32_t target=1; target<=2; ++target) {
+            if (audio_receives_mix(true,false,true)) iso[target-1] += 1000;
+            if (audio_receives_participant(target,speaker,true,true)) iso[target-1] += int(speaker);
+            claimed |= audio_claims_audience(true,true);
+        }
+        if (!claimed) ++audience;
+        if (audio_receives_participant(1,speaker,true,false)) normal[0] += int(speaker);
+    }
+    if (iso != std::array<int,2>{2,4} || audience!=4 || mix!=40 || normal[0]!=2 ||
+        !audio_receives_mix(false,false,false) || audio_receives_mix(false,true,false) ||
+        !audio_claims_audience(true,false) || audio_receives_participant(0,0,true,true)) {
+        std::cerr << "Isolated recording leaked mix/another speaker or changed audience routing\n";
+        return 1;
+    }
+}
diff --git a/tests/iso-feed-selection-test.cpp b/tests/iso-feed-selection-test.cpp
new file mode 100644
index 0000000..3c079ec
--- /dev/null
+++ b/tests/iso-feed-selection-test.cpp
@@ -0,0 +1,17 @@
+#include "iso-feed-selection.h"
+#include <iostream>
+
+int main()
+{
+    const std::vector<std::string> selected{"camera-a", "camera-b"};
+    if (!iso_feed_selected(selected, "camera-a", true, false) ||
+        !iso_feed_selected(selected, "camera-b", true, false) ||
+        iso_feed_selected(selected, "camera-c", true, false) ||
+        iso_feed_selected(selected, "camera-a", false, false) ||
+        iso_feed_selected(selected, "camera-a", true, true) ||
+        iso_feed_selected({}, "camera-a", true, false) ||
+        iso_feed_selected(selected, "", true, false)) {
+        std::cerr << "ISO selection allowed an unselected, unrouted or unsupported feed\n";
+        return 1;
+    }
+}
diff --git a/tests/iso-isolated-recording-test.cpp b/tests/iso-isolated-recording-test.cpp
new file mode 100644
index 0000000..574aca7
--- /dev/null
+++ b/tests/iso-isolated-recording-test.cpp
@@ -0,0 +1,61 @@
+#include "iso-audio-reader.h"
+#include "iso-audio-routing.h"
+#include "iso-track-writer.h"
+#include <util/platform.h>
+#include <array>
+#include <chrono>
+#include <cmath>
+#include <memory>
+#include <thread>
+
+int main(int argc,char **argv)
+{
+    if(argc!=2) return 2;
+    const auto epoch=os_gettime_ns();
+    std::array<ShmRegion,2> regions{};
+    std::array<std::unique_ptr<IsoTrackWriter>,2> writers;
+    std::array<std::unique_ptr<IsoAudioReader>,2> readers;
+    for(int i=0;i<2;++i) {
+        IsoTrackWriter::Config config;
+        config.ffmpeg=argv[1]; config.encoder="libx264";
+        config.path="isolated-"+std::to_string(i+1)+".mp4"; config.log_path=config.path+".log";
+        config.epoch_ns=epoch; config.now=[] {return os_gettime_ns();};
+        writers[i]=std::make_unique<IsoTrackWriter>(config);
+        const auto uuid="isolated_test_"+std::to_string(epoch)+"_"+std::to_string(i);
+        if(!shm_region_create(regions[i],shm_region_name(IPC_SHM_PREFIX+uuid+"_audio",1),shm_audio_region_bytes(960))) return 3;
+        std::memset(regions[i].ptr,0,regions[i].size);
+        auto *ring=static_cast<ShmAudioHeader *>(regions[i].ptr);
+        ring->slot_count=kAudioRingSlots; ring->slot_bytes=960; ring->sample_rate=48000; ring->channels=1;
+        readers[i]=std::make_unique<IsoAudioReader>(uuid,i+1,[&,i](auto pcm,auto bytes,auto rate,auto channels,auto ns) {
+            writers[i]->audio(pcm,bytes,rate,channels,ns);
+        }, [] {return os_gettime_ns();});
+    }
+    const auto begin=std::chrono::steady_clock::now();
+    std::vector<uint8_t> image(1920*1080*3/2,128);
+    std::array<int16_t,480> audio{};
+    for(int packet=0;packet<400;++packet) {
+        std::this_thread::sleep_until(begin+std::chrono::milliseconds(packet*10));
+        const uint32_t speaker=uint32_t((packet/100)%2+1);
+        const double frequency=speaker==1?500:1500;
+        for(int j=0;j<480;++j) audio[j]=int16_t(12000*std::sin(2*3.141592653589793*frequency*j/48000));
+        for(int i=0;i<2;++i) {
+            // The production engine policy must never pass the mixed callback.
+            if(audio_receives_mix(true,false,true)) return 4;
+            if(audio_receives_participant(i+1,speaker,true,true)) {
+                auto *ring=static_cast<ShmAudioHeader *>(regions[i].ptr);
+                auto *slot=reinterpret_cast<ShmAudioSlot *>(static_cast<char *>(regions[i].ptr)+
+                    shm_audio_slot_offset(*ring,ring->write_index%kAudioRingSlots));
+                slot->sequence=1; slot->participant_id=speaker; slot->byte_len=960;
+                std::memcpy(slot+1,audio.data(),960); slot->sequence=2; ++ring->write_index; ring->notify=1;
+                readers[i]->read(960,1);
+            }
+            if(packet%3==0) writers[i]->video(1920,1080,image.data(),image.data()+1920*1080,
+                image.data()+1920*1080*5/4,1920,960,epoch+uint64_t(packet)*10000000);
+        }
+    }
+    for(auto &writer:writers) writer->close(epoch+4000000000ULL);
+    for(int i=0;i<2;++i) {
+        if(!writers[i]->wait_finished(15000) || !writers[i]->status().error.empty() || !readers[i]->error().empty()) return 5;
+        readers[i].reset(); shm_region_destroy(regions[i]);
+    }
+}
diff --git a/tests/iso-provider-policy-test.cpp b/tests/iso-provider-policy-test.cpp
new file mode 100644
index 0000000..d6a2fdf
--- /dev/null
+++ b/tests/iso-provider-policy-test.cpp
@@ -0,0 +1,28 @@
+#include "iso-provider-policy.h"
+#include <iostream>
+
+int main()
+{
+    std::string owner;
+    uint64_t last = 0;
+    const auto require = [](bool value) {
+        if (!value)
+            throw "provider policy regression";
+    };
+    try {
+        require(iso_take_provider(owner, last, "camera-a", 1000000000));
+        require(!iso_take_provider(owner, last, "camera-b", 1010000000));
+        require(last == 1000000000 && owner == "camera-a");
+        require(iso_take_provider(owner, last, "camera-a", 1020000000));
+        require(!iso_take_provider(owner, last, "camera-a", 1020000000));
+        require(!iso_take_provider(owner, last, "camera-a", 1010000000));
+        require(iso_take_provider(owner, last, "camera-b", 1270000000));
+        require(owner == "camera-b");
+        require(!iso_take_provider(owner, last, "camera-a", 1280000000));
+        owner.clear(); // Source removed: permit immediate alternate delivery.
+        require(iso_take_provider(owner, last, "camera-a", 1290000000));
+    } catch (const char *error) {
+        std::cerr << error << '\n';
+        return 1;
+    }
+}
diff --git a/tests/iso-track-writer-test.cpp b/tests/iso-track-writer-test.cpp
new file mode 100644
index 0000000..b5148ea
--- /dev/null
+++ b/tests/iso-track-writer-test.cpp
@@ -0,0 +1,95 @@
+// Real worker integration test. Run in an empty folder with FFmpeg on argv[1].
+#include "iso-track-writer.h"
+#include <algorithm>
+#include <chrono>
+#include <cmath>
+#include <iostream>
+#include <memory>
+#include <thread>
+#include <util/platform.h>
+
+int main(int argc, char **argv)
+{
+    if (argc < 2)
+        return 2;
+    const int tracks = argc > 3 ? std::stoi(argv[3]) : 2;
+    if (tracks < 1 || tracks > 8)
+        return 2;
+    const auto epoch = os_gettime_ns();
+    IsoTrackWriter::Config silentConfig;
+    silentConfig.ffmpeg = argv[1];
+    silentConfig.encoder = "libx264";
+    silentConfig.path = "silent.mp4";
+    silentConfig.log_path = "silent.mp4.log";
+    silentConfig.epoch_ns = epoch;
+    silentConfig.now = [] { return os_gettime_ns(); };
+    IsoTrackWriter silent(silentConfig);
+    auto brokenConfig = silentConfig;
+    brokenConfig.ffmpeg = "nonexistent-corevideo-test-encoder";
+    brokenConfig.path = "broken.mp4";
+    brokenConfig.log_path = "broken.mp4.log";
+    IsoTrackWriter broken(brokenConfig);
+    std::vector<std::unique_ptr<IsoTrackWriter>> writers;
+    for (int i = 0; i < tracks; ++i) {
+        IsoTrackWriter::Config c;
+        c.ffmpeg = argv[1];
+        c.encoder = argc > 2 ? argv[2] : "libx264";
+        c.path = "participant-" + std::to_string(i) + ".mp4";
+        c.log_path = c.path + ".log";
+        c.epoch_ns = epoch;
+        c.now = [] { return os_gettime_ns(); };
+        writers.push_back(std::make_unique<IsoTrackWriter>(c));
+    }
+    const auto begin = std::chrono::steady_clock::now();
+    for (int packet = 0; packet < 600; ++packet) {
+        std::this_thread::sleep_until(begin + std::chrono::milliseconds(packet * 10));
+        const uint64_t ns = epoch + uint64_t(packet) * 10000000;
+        const int second = packet / 100;
+        uint32_t w = second == 1 ? 1280 : second == 2 ? 1920 : 640;
+        uint32_t h = second == 1 ? 720 : second == 2 ? 1080 : second == 3 ? 480 : 360;
+        const bool flash = packet % 100 >= 20 && packet % 100 < 30;
+        std::vector<uint8_t> pixels(size_t(w) * h * 3 / 2, 128);
+        std::fill_n(pixels.data(), size_t(w) * h, flash ? 235 : 32);
+        std::fill_n(pixels.data() + size_t(w) * h, size_t(w) * h / 4, 90);
+        std::fill_n(pixels.data() + size_t(w) * h * 5 / 4, size_t(w) * h / 4, 180);
+        const uint32_t rate = second < 3 ? 32000 : 48000;
+        const uint16_t channels = second < 3 ? 1 : 2;
+        std::vector<int16_t> audio(size_t(rate / 100) * channels);
+        for (uint32_t frame = 0; frame < rate / 100; ++frame) {
+            const auto sample = int16_t(
+                flash ? std::sin(double(frame) * 2 * 3.141592653589793 * 1000 / rate) * 16000 : 0);
+            for (uint16_t c = 0; c < channels; ++c)
+                audio[frame * channels + c] = sample;
+        }
+        for (auto &writer : writers) {
+            // Send variable-rate video; withhold a whole second for camera-off.
+            if (packet % 3 == 0 && second != 4)
+                writer->video(w, h, pixels.data(), pixels.data() + w * h,
+                              pixels.data() + w * h * 5 / 4, w, w / 2, ns);
+            // Audio callback silence is withheld too; output must still contain silence.
+            if (flash)
+                writer->audio(reinterpret_cast<const uint8_t *>(audio.data()),
+                              uint32_t(audio.size() * 2), rate, channels,
+                              epoch + uint64_t(packet / 10) * 100000000ULL +
+                                  uint64_t(packet % 10) * 1000ULL);
+        }
+    }
+    for (auto &writer : writers)
+        writer->close(epoch + 6000000000ULL);
+    silent.close(epoch + 6000000000ULL);
+    int failures = 0;
+    for (auto &writer : writers) {
+        if (!writer->wait_finished(15000))
+            ++failures;
+        const auto s = writer->status();
+        std::cout << "frames=" << s.frames << " peak=" << s.peak_frames
+                  << " late_audio=" << s.late_audio_frames << " error=" << s.error << '\n';
+        if (s.frames != 180 || !s.error.empty())
+            ++failures;
+    }
+    if (!silent.wait_finished(15000) || silent.status().frames != 180 || !silent.status().error.empty())
+        ++failures;
+    if (!broken.wait_finished(1000) || broken.status().error.empty())
+        ++failures;
+    return failures ? 1 : 0;
+}
diff --git a/tests/tile-frame-read-test.cpp b/tests/tile-frame-read-test.cpp
new file mode 100644
index 0000000..2b58f84
--- /dev/null
+++ b/tests/tile-frame-read-test.cpp
@@ -0,0 +1,37 @@
+#include "zoom-tile-frame-read.h"
+#include <iostream>
+
+int main()
+{
+    // A good 4x4 I420 frame is pending when a resize event arrives before draw.
+    const std::vector<uint8_t> good(24, 80);
+    std::vector<uint8_t> pending = good, candidate;
+    const bool accepted = tile_read_frame(pending, candidate, [](auto &destination) {
+        // Exactly the SHM reader contract: copy first, reject when the sequence
+        // changed under the copy. The old ready flag and dimensions stay valid.
+        destination.assign(6, 235);
+        return false;
+    });
+    if (accepted || pending != good) {
+        std::cerr << "Rejected resized read corrupted a pending frame\n";
+        return 1;
+    }
+    if (!tile_read_frame(pending, candidate, [](auto &destination) {
+        destination.assign(6, 120);
+        return true;
+    }) || pending != std::vector<uint8_t>(6, 120)) {
+        std::cerr << "Valid resized frame was not published\n";
+        return 1;
+    }
+    const auto resized = pending;
+    for (int i = 0; i < 100; ++i) {
+        if (tile_read_frame(pending, candidate, [i](auto &destination) {
+            destination.assign(24, uint8_t(i));
+            return false;
+        }) || pending != resized) {
+            std::cerr << "Repeated rejected read replaced the held picture\n";
+            return 1;
+        }
+    }
+    std::cout << "Tile pending pixels survive failed reads and resize recovery\n";
+}
diff --git a/tests/verify-iso-av.py b/tests/verify-iso-av.py
new file mode 100644
index 0000000..2eaa65d
--- /dev/null
+++ b/tests/verify-iso-av.py
@@ -0,0 +1,56 @@
+"""Decode the six-second IsoTrackWriter fixture and check actual media timing.
+
+Usage: python tests/verify-iso-av.py <ffmpeg-bin-directory> <fixture-directory>
+"""
+import array
+import json
+from pathlib import Path
+import subprocess
+import sys
+
+bin_dir, fixture = map(Path, sys.argv[1:])
+ffmpeg, probe = str(bin_dir / "ffmpeg"), str(bin_dir / "ffprobe")
+files = sorted(fixture.glob("*.mp4"))
+assert files, "No participant files"
+assert not list(fixture.glob("*.wav")), "Unexpected separate audio files"
+for file in files:
+    info = json.loads(subprocess.check_output([
+        probe, "-v", "error", "-count_frames", "-show_streams", "-of", "json", str(file)]))
+    streams = info["streams"]
+    assert len(streams) == 2, streams
+    video = next(s for s in streams if s["codec_type"] == "video")
+    audio = next(s for s in streams if s["codec_type"] == "audio")
+    assert (video["codec_name"], video["width"], video["height"], video["r_frame_rate"], int(video["nb_read_frames"])) == ("h264", 1920, 1080, "30/1", 180), video
+    assert (audio["codec_name"], audio["sample_rate"], audio["channels"]) == ("aac", "48000", 2), audio
+    assert video.get("color_range") == "pc" and video.get("color_space") == "bt709", video
+    subprocess.run([ffmpeg, "-v", "error", "-xerror", "-i", str(file), "-f", "null", "-"], check=True)
+    # Decode centre luma without resampling the frame cadence; retain stream PTS origin.
+    pixels = subprocess.check_output([ffmpeg, "-v", "error", "-i", str(file), "-an", "-vf", "crop=2:2:960:540,format=gray", "-fps_mode", "passthrough", "-f", "rawvideo", "-"])
+    bright = [pixels[i] > 180 for i in range(0, len(pixels), 4)]
+    pcm = array.array("h", subprocess.check_output([ffmpeg, "-v", "error", "-i", str(file), "-vn", "-ac", "1", "-ar", "48000", "-f", "s16le", "-"]))
+    if sys.byteorder != "little":
+        pcm.byteswap()
+    loud = [max(map(abs, pcm[i:i+480]), default=0) > 4000 for i in range(0, len(pcm), 480)]
+    if file.stem == "silent":
+        assert not any(bright) and max(map(abs, pcm), default=0) == 0, "No-input track must be black and silent"
+        print(f"{file.name}: continuous 1080p video and silent AAC with no input callbacks")
+        continue
+    chroma = subprocess.check_output([ffmpeg, "-v", "error", "-i", str(file), "-an", "-vf", "crop=2:2:960:540", "-pix_fmt", "yuvj420p", "-fps_mode", "passthrough", "-f", "rawvideo", "-"])
+    for frame in (15, 45, 75, 105, 135, 165):
+        u, v = chroma[frame*6+4:frame*6+6]
+        assert abs(u-90) <= 4 and abs(v-180) <= 4, (file, frame, u, v)
+    vt = [float(video["start_time"]) + i/30 for i, value in enumerate(bright) if value and (i == 0 or not bright[i-1])]
+    at = [float(audio["start_time"]) + i/100 for i, value in enumerate(loud) if value and (i == 0 or not loud[i-1])]
+    assert len(vt) == 5 and len(at) == 6, (vt, at)
+    offsets = [min(abs(v-a) for a in at) for v in vt]
+    assert max(offsets) <= .040, (file, vt, at, offsets)
+    # Bunched callback timestamps must not rewind/overwrite a 100 ms tone.
+    ends = [i for i, value in enumerate(loud) if not value and i > 0 and loud[i-1]]
+    starts = [i for i, value in enumerate(loud) if value and (i == 0 or not loud[i-1])]
+    assert len(ends) == len(starts) and all(8 <= e-s <= 12 for s, e in zip(starts, ends)), (starts, ends)
+    # Camera-off second must hold the last dark picture; audio continues independently.
+    assert not any(bright[120:150]), "Unexpected flash during camera gap"
+    # 4:3 input must have black bars, and changing back to 16:9 must fill the canvas.
+    edges = subprocess.check_output([ffmpeg, "-v", "error", "-i", str(file), "-an", "-vf", "crop=2:2:0:540,format=gray", "-fps_mode", "passthrough", "-f", "rawvideo", "-"])
+    assert edges[100*4] < 20 and edges[160*4] > 20, "Incorrect aspect-ratio conformance"
+    print(f"{file.name}: 180 frames, H264/AAC 1080p30, full decode passed, max flash/tone offset {max(offsets)*1000:.1f} ms")
diff --git a/tests/verify-iso-isolated.py b/tests/verify-iso-isolated.py
new file mode 100644
index 0000000..5b303cf
--- /dev/null
+++ b/tests/verify-iso-isolated.py
@@ -0,0 +1,24 @@
+"""Check decoded alternating-speaker files from IsoIsolatedRecordingTest."""
+import array
+from pathlib import Path
+import math
+import subprocess
+import sys
+
+ffmpeg, folder = sys.argv[1], Path(sys.argv[2])
+for participant in (1, 2):
+    file = folder / f"isolated-{participant}.mp4"
+    samples = array.array("h", subprocess.check_output([
+        ffmpeg, "-v", "error", "-xerror", "-i", str(file), "-vn", "-ac", "1", "-ar", "48000", "-f", "s16le", "-"]))
+    if sys.byteorder != "little":
+        samples.byteswap()
+    levels = []
+    for second in range(4):
+        chunk = samples[int((second+.25)*48000):int((second+.75)*48000)]
+        assert len(chunk) == 24000
+        rms = math.sqrt(sum(x*x for x in chunk)/len(chunk))
+        speaking = second % 2 + 1 == participant
+        assert (rms > 5000 if speaking else rms < 10), (participant, second, rms)
+        levels.append(round(rms, 2))
+    subprocess.run([ffmpeg, "-v", "error", "-xerror", "-i", str(file), "-f", "null", "-"], check=True)
+    print(f"Participant {participant}: decoded one-second RMS {levels}; other speaker silent")