diff --git a/SentryDeck.Tests/MainWindowViewModelTests.Clips.cs b/SentryDeck.Tests/MainWindowViewModelTests.Clips.cs
index 98e9a63..d0ee1cd 100644
--- a/SentryDeck.Tests/MainWindowViewModelTests.Clips.cs
+++ b/SentryDeck.Tests/MainWindowViewModelTests.Clips.cs
@@ -14,9 +14,9 @@ public async Task FilteredClips_OrderNewestFirst()
         var clips = TestClips.Create(3); // timestamps increase with index
         var vm = new MainWindowViewModel(() => null!, clipLoader: _ => clips);
 
-        await vm.LoadClipsAsync(new[] { "root" });
+        await vm.Library.LoadClipsAsync(new[] { "root" });
 
-        vm.FilteredClips.Select(c => c.Name).ShouldBe(new[] { "Clip 2", "Clip 1", "Clip 0" });
+        vm.Library.FilteredClips.Select(c => c.Name).ShouldBe(new[] { "Clip 2", "Clip 1", "Clip 0" });
     }
 
     [Fact]
@@ -24,11 +24,11 @@ public async Task FilteredClips_FiltersByNameCaseInsensitively()
     {
         var clips = TestClips.Create(3);
         var vm = new MainWindowViewModel(() => null!, clipLoader: _ => clips);
-        await vm.LoadClipsAsync(new[] { "root" });
+        await vm.Library.LoadClipsAsync(new[] { "root" });
 
-        vm.FilterText = "clip 1";
+        vm.Library.FilterText = "clip 1";
 
-        vm.FilteredClips.Single().Name.ShouldBe("Clip 1");
+        vm.Library.FilteredClips.Single().Name.ShouldBe("Clip 1");
     }
 
     [Fact]
@@ -37,11 +37,11 @@ public async Task FilteredClips_FiltersByPath()
         // TestClips share a folder path but have distinct names, so a path-only match keeps them all.
         var clips = TestClips.Create(2);
         var vm = new MainWindowViewModel(() => null!, clipLoader: _ => clips);
-        await vm.LoadClipsAsync(new[] { "root" });
+        await vm.Library.LoadClipsAsync(new[] { "root" });
 
-        vm.FilterText = clips[0].FullPath;
+        vm.Library.FilterText = clips[0].FullPath;
 
-        vm.FilteredClips.Count.ShouldBe(2);
+        vm.Library.FilteredClips.Count.ShouldBe(2);
     }
 
     [Fact]
@@ -53,11 +53,11 @@ public async Task FilteredClips_FiltersByCity()
             ClipWithEvent("B", "user_interaction_honk", "San Antonio"),
         };
         var vm = new MainWindowViewModel(() => null!, clipLoader: _ => clips);
-        await vm.LoadClipsAsync(new[] { "root" });
+        await vm.Library.LoadClipsAsync(new[] { "root" });
 
-        vm.FilterText = "hutto";
+        vm.Library.FilterText = "hutto";
 
-        vm.FilteredClips.Single().Name.ShouldBe("A");
+        vm.Library.FilteredClips.Single().Name.ShouldBe("A");
     }
 
     [Fact]
@@ -69,11 +69,11 @@ public async Task FilteredClips_FiltersByFriendlyReason()
             ClipWithEvent("Saver", "user_interaction_dashcam_launcher_action_tapped", "X"),
         };
         var vm = new MainWindowViewModel(() => null!, clipLoader: _ => clips);
-        await vm.LoadClipsAsync(new[] { "root" });
+        await vm.Library.LoadClipsAsync(new[] { "root" });
 
-        vm.FilterText = "saved";
+        vm.Library.FilterText = "saved";
 
-        vm.FilteredClips.Single().Name.ShouldBe("Saver");
+        vm.Library.FilteredClips.Single().Name.ShouldBe("Saver");
     }
 
     [Fact]
@@ -81,26 +81,26 @@ public async Task ClipCount_ReflectsFilteredCount()
     {
         var clips = TestClips.Create(3);
         var vm = new MainWindowViewModel(() => null!, clipLoader: _ => clips);
-        await vm.LoadClipsAsync(new[] { "root" });
+        await vm.Library.LoadClipsAsync(new[] { "root" });
 
-        vm.ClipCount.ShouldBe(3);
+        vm.Library.ClipCount.ShouldBe(3);
 
-        vm.FilterText = "Clip 1";
+        vm.Library.FilterText = "Clip 1";
 
-        vm.ClipCount.ShouldBe(1);
+        vm.Library.ClipCount.ShouldBe(1);
     }
 
     [Fact]
     public void ClearFilter_ResetsFilterTextAndFlag()
     {
         var vm = CreateViewModel();
-        vm.FilterText = "abc";
-        vm.HasFilterText.ShouldBeTrue();
+        vm.Library.FilterText = "abc";
+        vm.Library.HasFilterText.ShouldBeTrue();
 
-        vm.ClearFilterCommand.Execute(null);
+        vm.Library.ClearFilterCommand.Execute(null);
 
-        vm.FilterText.ShouldBe(string.Empty);
-        vm.HasFilterText.ShouldBeFalse();
+        vm.Library.FilterText.ShouldBe(string.Empty);
+        vm.Library.HasFilterText.ShouldBeFalse();
     }
 
     [Fact]
@@ -108,22 +108,22 @@ public async Task TypingInSearch_DoesNotRebindTheListPerKeystroke()
     {
         var clips = TestClips.Create(3);
         var vm = new MainWindowViewModel(() => null!, clipLoader: _ => clips);
-        await vm.LoadClipsAsync(["root"]);
+        await vm.Library.LoadClipsAsync(["root"]);
 
         var changed = new List<string>();
-        vm.PropertyChanged += (_, e) => changed.Add(e.PropertyName);
+        vm.Library.PropertyChanged += (_, e) => changed.Add(e.PropertyName);
 
-        vm.FilterText = "C";
-        vm.FilterText = "Cl";
-        vm.FilterText = "Cli";
+        vm.Library.FilterText = "C";
+        vm.Library.FilterText = "Cl";
+        vm.Library.FilterText = "Cli";
 
         // The list rebind is deferred to a debounce timer (which never ticks in tests) so the ListBox doesn't rebuild and replay its fade on every keystroke.
         // Wiring FilteredClips/ClipCount straight onto FilterText would look harmless and quietly undo that.
-        changed.ShouldNotContain(nameof(MainWindowViewModel.FilteredClips));
-        changed.ShouldNotContain(nameof(MainWindowViewModel.ClipCount));
+        changed.ShouldNotContain(nameof(ClipLibraryViewModel.FilteredClips));
+        changed.ShouldNotContain(nameof(ClipLibraryViewModel.ClipCount));
 
         // The clear affordance is the one part that stays immediate.
-        changed.ShouldContain(nameof(MainWindowViewModel.HasFilterText));
+        changed.ShouldContain(nameof(ClipLibraryViewModel.HasFilterText));
     }
 
     [Fact]
@@ -133,8 +133,8 @@ public void ShowOnMap_DisabledWithoutCoordinates()
         var noLocation = ClipWithEvent("A", "user_interaction_honk", "Hutto");
         var withLocation = ClipWithEvent("B", "user_interaction_honk", "Hutto", 30.5m, -97.5m);
 
-        vm.ShowOnMapCommand.CanExecute(noLocation).ShouldBeFalse();
-        vm.ShowOnMapCommand.CanExecute(withLocation).ShouldBeTrue();
+        vm.Library.ShowOnMapCommand.CanExecute(noLocation).ShouldBeFalse();
+        vm.Library.ShowOnMapCommand.CanExecute(withLocation).ShouldBeTrue();
     }
 
     // --- Scanning: what the sidebar and the overlay show when there is nothing to scan, or a root can't be read.
@@ -145,15 +145,15 @@ public async Task LoadClips_WithNoRoots_ShowsDismissibleEmptyState()
     {
         var vm = CreateViewModel();
 
-        await vm.LoadClipsAsync([]);
+        await vm.Library.LoadClipsAsync([]);
 
         // First run with no USB drive attached: a friendly prompt the user can dismiss to reach the rest of the app, not a scary error they're stuck behind.
-        vm.ErrorTitle.ShouldBe("No dashcam footage yet");
-        vm.IsEmptyState.ShouldBeTrue();
-        vm.CanDismissError.ShouldBeTrue();
-        vm.ShowErrorOverlay.ShouldBeTrue();
+        vm.Error.Title.ShouldBe("No dashcam footage yet");
+        vm.Error.IsEmptyState.ShouldBeTrue();
+        vm.Error.CanDismiss.ShouldBeTrue();
+        vm.Error.IsVisible.ShouldBeTrue();
         vm.ShowStatusOverlay.ShouldBeTrue();
-        vm.ClipCount.ShouldBe(0);
+        vm.Library.ClipCount.ShouldBe(0);
     }
 
     [Fact]
@@ -161,13 +161,13 @@ public async Task LoadClips_AccessDenied_ShowsAccessDeniedError()
     {
         var vm = new MainWindowViewModel(() => null!, clipLoader: _ => throw new UnauthorizedAccessException("denied"));
 
-        await vm.LoadClipsAsync([@"D:\TeslaCam"]);
+        await vm.Library.LoadClipsAsync([@"D:\TeslaCam"]);
 
         // A permissions problem gets its own title and remedy; it isn't the empty state.
-        vm.ErrorTitle.ShouldBe("Access Denied");
-        vm.ErrorDetails.ShouldContain(@"D:\TeslaCam");
-        vm.ShowErrorOverlay.ShouldBeTrue();
-        vm.IsEmptyState.ShouldBeFalse();
+        vm.Error.Title.ShouldBe("Access Denied");
+        vm.Error.Details.ShouldContain(@"D:\TeslaCam");
+        vm.Error.IsVisible.ShouldBeTrue();
+        vm.Error.IsEmptyState.ShouldBeFalse();
     }
 
     [Fact]
@@ -175,12 +175,12 @@ public async Task LoadClips_LoaderThrows_ShowsGenericLoadError()
     {
         var vm = new MainWindowViewModel(() => null!, clipLoader: _ => throw new IOException("the drive was removed"));
 
-        await vm.LoadClipsAsync([@"E:\TeslaCam"]);
+        await vm.Library.LoadClipsAsync([@"E:\TeslaCam"]);
 
         // Both halves matter for a bug report: which folder failed, and what the failure was.
-        vm.ErrorTitle.ShouldBe("Error Loading Clips");
-        vm.ErrorDetails.ShouldContain(@"E:\TeslaCam");
-        vm.ErrorDetails.ShouldContain("the drive was removed");
+        vm.Error.Title.ShouldBe("Error Loading Clips");
+        vm.Error.Details.ShouldContain(@"E:\TeslaCam");
+        vm.Error.Details.ShouldContain("the drive was removed");
     }
 
     [Fact]
@@ -199,12 +199,12 @@ public async Task LoadClips_OneRootFails_KeepsClipsFromTheHealthyRoot()
                 return clips;
             });
 
-        await vm.LoadClipsAsync(["bad", "good"]);
+        await vm.Library.LoadClipsAsync(["bad", "good"]);
 
         // Scanning is per-root: one unreadable drive reports itself but must not cost the user the library on the drive that is still plugged in.
-        vm.ClipCount.ShouldBe(2);
-        vm.ShowErrorOverlay.ShouldBeTrue();
-        vm.ErrorTitle.ShouldBe("Error Loading Clips");
+        vm.Library.ClipCount.ShouldBe(2);
+        vm.Error.IsVisible.ShouldBeTrue();
+        vm.Error.Title.ShouldBe("Error Loading Clips");
     }
 
     // --- Delete to Recycle Bin: the injectable confirm/recycle delegates keep this off the shell ---
@@ -222,7 +222,7 @@ private static List<CamClip> ClipsWithDistinctPaths(int count) =>
     private static async Task<MainWindowViewModel> LoadedViewModelAsync(IReadOnlyList<CamClip> clips)
     {
         var vm = new MainWindowViewModel(() => null!, clipLoader: _ => clips);
-        await vm.LoadClipsAsync(new[] { "root" });
+        await vm.Library.LoadClipsAsync(new[] { "root" });
         return vm;
     }
 
@@ -231,8 +231,8 @@ public void DeleteClipCommand_CanExecute_RequiresAClip()
     {
         var vm = CreateViewModel();
 
-        vm.DeleteClipCommand.CanExecute(null).ShouldBeFalse();
-        vm.DeleteClipCommand.CanExecute(TestClips.Create(1)[0]).ShouldBeTrue();
+        vm.Library.DeleteClipCommand.CanExecute(null).ShouldBeFalse();
+        vm.Library.DeleteClipCommand.CanExecute(TestClips.Create(1)[0]).ShouldBeTrue();
     }
 
     [Fact]
@@ -241,15 +241,15 @@ public async Task DeleteClip_Confirmed_RecyclesFolder_AndRemovesFromList()
         var clips = ClipsWithDistinctPaths(3);
         var vm = await LoadedViewModelAsync(clips);
         string recycledPath = null;
-        vm.ConfirmDeleteClip = _ => true;
-        vm.RecycleClipFolder = path => recycledPath = path;
+        vm.Library.ConfirmDeleteClip = _ => true;
+        vm.Library.RecycleClipFolder = path => recycledPath = path;
 
-        var target = vm.FilteredClips.Single(clip => clip.Name == "Clip 1");
-        await vm.DeleteClipCommand.ExecuteAsync(target);
+        var target = vm.Library.FilteredClips.Single(clip => clip.Name == "Clip 1");
+        await vm.Library.DeleteClipCommand.ExecuteAsync(target);
 
         recycledPath.ShouldBe(target.FullPath);
-        vm.FilteredClips.ShouldNotContain(target);
-        vm.ClipCount.ShouldBe(2);
+        vm.Library.FilteredClips.ShouldNotContain(target);
+        vm.Library.ClipCount.ShouldBe(2);
     }
 
     [Fact]
@@ -258,15 +258,15 @@ public async Task DeleteClip_Cancelled_KeepsClip_AndDoesNotRecycle()
         var clips = ClipsWithDistinctPaths(2);
         var vm = await LoadedViewModelAsync(clips);
         var recycleCalls = 0;
-        vm.ConfirmDeleteClip = _ => false;
-        vm.RecycleClipFolder = _ => recycleCalls++;
+        vm.Library.ConfirmDeleteClip = _ => false;
+        vm.Library.RecycleClipFolder = _ => recycleCalls++;
 
-        var target = vm.FilteredClips[0];
-        await vm.DeleteClipCommand.ExecuteAsync(target);
+        var target = vm.Library.FilteredClips[0];
+        await vm.Library.DeleteClipCommand.ExecuteAsync(target);
 
         recycleCalls.ShouldBe(0);
-        vm.ClipCount.ShouldBe(2);
-        vm.FilteredClips.ShouldContain(target);
+        vm.Library.ClipCount.ShouldBe(2);
+        vm.Library.FilteredClips.ShouldContain(target);
     }
 
     [Fact]
@@ -274,18 +274,18 @@ public async Task DeleteClip_TheSelectedClip_ClearsSelectionAndNowPlaying()
     {
         var clips = ClipsWithDistinctPaths(2);
         var vm = await LoadedViewModelAsync(clips);
-        vm.ConfirmDeleteClip = _ => true;
-        vm.RecycleClipFolder = _ => { };
+        vm.Library.ConfirmDeleteClip = _ => true;
+        vm.Library.RecycleClipFolder = _ => { };
 
-        var target = vm.FilteredClips[0];
-        vm.SelectedClip = target; // sets NowPlayingClip too (see OnSelectedClipChanged)
-        vm.NowPlayingClip.ShouldBe(target);
+        var target = vm.Library.FilteredClips[0];
+        vm.Library.SelectedClip = target; // sets NowPlayingClip too (see OnSelectedClipChanged)
+        vm.Playback.NowPlayingClip.ShouldBe(target);
 
-        await vm.DeleteClipCommand.ExecuteAsync(target);
+        await vm.Library.DeleteClipCommand.ExecuteAsync(target);
 
-        vm.SelectedClip.ShouldBeNull();
-        vm.NowPlayingClip.ShouldBeNull();
-        vm.FilteredClips.ShouldNotContain(target);
+        vm.Library.SelectedClip.ShouldBeNull();
+        vm.Playback.NowPlayingClip.ShouldBeNull();
+        vm.Library.FilteredClips.ShouldNotContain(target);
     }
 
     [Fact]
@@ -293,18 +293,18 @@ public async Task DeleteClip_NotTheSelectedClip_LeavesSelectionIntact()
     {
         var clips = ClipsWithDistinctPaths(3);
         var vm = await LoadedViewModelAsync(clips);
-        vm.ConfirmDeleteClip = _ => true;
-        vm.RecycleClipFolder = _ => { };
+        vm.Library.ConfirmDeleteClip = _ => true;
+        vm.Library.RecycleClipFolder = _ => { };
 
-        var selected = vm.FilteredClips.Single(clip => clip.Name == "Clip 2");
-        var victim = vm.FilteredClips.Single(clip => clip.Name == "Clip 0");
-        vm.SelectedClip = selected;
+        var selected = vm.Library.FilteredClips.Single(clip => clip.Name == "Clip 2");
+        var victim = vm.Library.FilteredClips.Single(clip => clip.Name == "Clip 0");
+        vm.Library.SelectedClip = selected;
 
-        await vm.DeleteClipCommand.ExecuteAsync(victim);
+        await vm.Library.DeleteClipCommand.ExecuteAsync(victim);
 
-        vm.SelectedClip.ShouldBe(selected);
-        vm.FilteredClips.ShouldNotContain(victim);
-        vm.ClipCount.ShouldBe(2);
+        vm.Library.SelectedClip.ShouldBe(selected);
+        vm.Library.FilteredClips.ShouldNotContain(victim);
+        vm.Library.ClipCount.ShouldBe(2);
     }
 
     [Fact]
@@ -312,16 +312,16 @@ public async Task DeleteClip_WhenRecycleFails_ShowsError_AndKeepsClip()
     {
         var clips = ClipsWithDistinctPaths(2);
         var vm = await LoadedViewModelAsync(clips);
-        vm.ConfirmDeleteClip = _ => true;
-        vm.RecycleClipFolder = _ => throw new IOException("The file is in use.");
+        vm.Library.ConfirmDeleteClip = _ => true;
+        vm.Library.RecycleClipFolder = _ => throw new IOException("The file is in use.");
 
-        var target = vm.FilteredClips[0];
-        await vm.DeleteClipCommand.ExecuteAsync(target);
+        var target = vm.Library.FilteredClips[0];
+        await vm.Library.DeleteClipCommand.ExecuteAsync(target);
 
-        vm.ShowErrorOverlay.ShouldBeTrue();
-        vm.ErrorTitle.ShouldBe("Delete Failed");
-        vm.ClipCount.ShouldBe(2);
-        vm.FilteredClips.ShouldContain(target);
+        vm.Error.IsVisible.ShouldBeTrue();
+        vm.Error.Title.ShouldBe("Delete Failed");
+        vm.Library.ClipCount.ShouldBe(2);
+        vm.Library.FilteredClips.ShouldContain(target);
     }
 
     // --- Deleting the clip that is actually open: the point of the feature, and the only path that touches the player.
@@ -334,15 +334,15 @@ public async Task DeleteClip_TheOpenClip_StopsPlaybackBeforeRecycling()
         var (vm, _, front) = CreateViewModelWithOpenedClip(clipFiles.Clip, uiInvoker: action => action());
         var closesBeforeDelete = front.Count("close");
         var closesWhenRecycled = -1;
-        vm.ConfirmDeleteClip = _ => true;
-        vm.RecycleClipFolder = _ => closesWhenRecycled = front.Count("close");
-        vm.SeekPosition = 0.5;
+        vm.Library.ConfirmDeleteClip = _ => true;
+        vm.Library.RecycleClipFolder = _ => closesWhenRecycled = front.Count("close");
+        vm.Playback.SeekPosition = 0.5;
 
-        await vm.DeleteClipCommand.ExecuteAsync(clipFiles.Clip);
+        await vm.Library.DeleteClipCommand.ExecuteAsync(clipFiles.Clip);
 
         // Windows can't recycle a folder whose files are still locked, so playback must already be stopped when the shell operation runs -- not merely by the time delete returns.
         closesWhenRecycled.ShouldBeGreaterThan(closesBeforeDelete);
-        vm.SeekPosition.ShouldBe(0);
+        vm.Playback.SeekPosition.ShouldBe(0);
     }
 
     [Fact]
@@ -351,16 +351,16 @@ public async Task DeleteClip_TheOpenClip_RemovesItFromThePlayerPlaylist()
         using var clipFiles = TestClipFiles.Create(chunkCount: 1);
         var clip = clipFiles.Clip;
         var (vm, controller, _) = CreateViewModelWithOpenedClip(clip, uiInvoker: action => action());
-        vm.ConfirmDeleteClip = _ => true;
-        vm.RecycleClipFolder = _ => { };
-        vm.SelectedClip = clip; // sets NowPlayingClip too (see OnSelectedClipChanged)
+        vm.Library.ConfirmDeleteClip = _ => true;
+        vm.Library.RecycleClipFolder = _ => { };
+        vm.Library.SelectedClip = clip; // sets NowPlayingClip too (see OnSelectedClipChanged)
 
-        await vm.DeleteClipCommand.ExecuteAsync(clip);
+        await vm.Library.DeleteClipCommand.ExecuteAsync(clip);
 
         // Next/Previous walk the controller's playlist, so a deleted clip left behind in it would navigate straight back to a folder that no longer exists.
         controller.Playlist.Clips.ShouldNotContain(clip);
-        vm.NowPlayingClip.ShouldBeNull();
-        vm.SelectedClip.ShouldBeNull();
+        vm.Playback.NowPlayingClip.ShouldBeNull();
+        vm.Library.SelectedClip.ShouldBeNull();
     }
 
     [Fact]
@@ -368,10 +368,39 @@ public async Task FilteredClips_NoMatch_IsEmpty()
     {
         var clips = TestClips.Create(3);
         var vm = new MainWindowViewModel(() => null!, clipLoader: _ => clips);
-        await vm.LoadClipsAsync(new[] { "root" });
+        await vm.Library.LoadClipsAsync(new[] { "root" });
+
+        vm.Library.FilterText = "no-such-clip";
+
+        vm.Library.FilteredClips.ShouldBeEmpty();
+    }
+
+    [Fact]
+    public async Task LoadClipsAsync_WhileTheScanRuns_ShowsTheLoadingOverlay()
+    {
+        // Loading is shared by the scan, the FFmpeg download, and clip loading; the overlay has to follow the scan even though playback isn't loading anything.
+        using var scanGate = new ManualResetEventSlim();
+        var vm = new MainWindowViewModel(() => null!, clipLoader: _ =>
+        {
+            scanGate.Wait();
+            return TestClips.Create(2);
+        });
+        var changed = new List<string>();
+        vm.PropertyChanged += (_, e) => changed.Add(e.PropertyName);
+
+        var load = vm.Library.LoadClipsAsync(["root"]);
+
+        vm.IsLoading.ShouldBeTrue();
+        vm.ShowStatusOverlay.ShouldBeTrue();
+        vm.HasNoClipSelected.ShouldBeFalse();
+        changed.ShouldContain(nameof(MainWindowViewModel.IsLoading));
+        changed.ShouldContain(nameof(MainWindowViewModel.ShowStatusOverlay));
 
-        vm.FilterText = "no-such-clip";
+        scanGate.Set();
+        await load;
 
-        vm.FilteredClips.ShouldBeEmpty();
+        vm.IsLoading.ShouldBeFalse();
+        vm.HasNoClipSelected.ShouldBeTrue();
+        vm.Library.ClipCount.ShouldBe(2);
     }
 }
diff --git a/SentryDeck.Tests/MainWindowViewModelTests.Keyboard.cs b/SentryDeck.Tests/MainWindowViewModelTests.Keyboard.cs
index 482a5ec..4200209 100644
--- a/SentryDeck.Tests/MainWindowViewModelTests.Keyboard.cs
+++ b/SentryDeck.Tests/MainWindowViewModelTests.Keyboard.cs
@@ -105,12 +105,12 @@ public void StopCommand_ClearsNowPlayingClip()
         using var clipFiles = TestClipFiles.Create(chunkCount: 1);
         var (vm, _, front) = CreateViewModelWithOpenedClip(clipFiles.Clip);
         var closesAfterOpen = front.Count("close");
-        vm.SelectedClip = clipFiles.Clip; // sets NowPlayingClip too (see OnSelectedClipChanged)
+        vm.Library.SelectedClip = clipFiles.Clip; // sets NowPlayingClip too (see OnSelectedClipChanged)
 
-        RunPinnedToTestThread(() => vm.StopCommand.ExecuteAsync(null));
+        RunPinnedToTestThread(() => vm.Playback.StopCommand.ExecuteAsync(null));
 
         // Stop is the only thing that takes the now-playing badge off the clip list; leaving it set would mark a clip as playing with nothing loaded.
-        vm.NowPlayingClip.ShouldBeNull();
+        vm.Playback.NowPlayingClip.ShouldBeNull();
         front.Count("close").ShouldBeGreaterThan(closesAfterOpen);
     }
 
@@ -127,12 +127,12 @@ public async Task DeselectingWhileSelectionLoadIsYielding_ClearsTheLoadingOverla
             backgroundYield: () => yieldGate.Task);
         vm.InitializePlayer();
 
-        vm.SelectedClip = ClipWithChunks(1);
+        vm.Library.SelectedClip = ClipWithChunks(1);
         vm.IsLoading.ShouldBeTrue();
 
         // Clear the selection before the yield resumes (Ctrl+click deselect, or a search filter dropping the clip).
         // The superseded load must not leave IsLoading stuck true forever.
-        vm.SelectedClip = null;
+        vm.Library.SelectedClip = null;
         yieldGate.SetResult();
 
         await Wait.UntilAsync(() => !vm.IsLoading);
@@ -153,17 +153,17 @@ public async Task SupersededSelection_DoesNotClearTheNewerLoadsLoadingState()
 
         var superseded = ClipWithCameras(SixCameras);
         var winner = ClipWithCamerasAndEventCamera(eventCamera: 7, SixCameras);
-        vm.SelectedClip = superseded;
-        vm.SelectedClip = winner;
+        vm.Library.SelectedClip = superseded;
+        vm.Library.SelectedClip = winner;
 
         yieldGate.SetResult();
 
         // The winner's load resumes and auto-focuses the rear camera.
         // The superseded load is dropped on its way out, and the loading state it finds is no longer its own to clear -- doing so would strand the newer clip's open with no progress indication at all.
-        await Wait.UntilAsync(() => vm.SelectedCameraView == CameraNames.Back);
+        await Wait.UntilAsync(() => vm.Cameras.SelectedCameraView == CameraNames.Back);
         vm.IsLoading.ShouldBeTrue();
-        vm.NowPlayingClip.ShouldBe(winner);
-        vm.SelectedClip.ShouldBe(winner);
+        vm.Playback.NowPlayingClip.ShouldBe(winner);
+        vm.Library.SelectedClip.ShouldBe(winner);
     }
 
     [Fact]
@@ -172,12 +172,12 @@ public void OpenFolderAndRefresh_AreDisabledWhileClipsAreScanning()
         // Both commands funnel into LoadClipsAsync, which has no re-entrancy protection: a second load started mid-scan would interleave with the first and merge both roots' clips.
         var vm = CreateViewModel();
 
-        vm.OpenFolderCommand.CanExecute(null).ShouldBeTrue();
-        vm.RefreshClipsCommand.CanExecute(null).ShouldBeTrue();
+        vm.Library.OpenFolderCommand.CanExecute(null).ShouldBeTrue();
+        vm.Library.RefreshClipsCommand.CanExecute(null).ShouldBeTrue();
 
-        vm.IsLoadingClips = true;
+        vm.Library.IsLoadingClips = true;
 
-        vm.OpenFolderCommand.CanExecute(null).ShouldBeFalse();
-        vm.RefreshClipsCommand.CanExecute(null).ShouldBeFalse();
+        vm.Library.OpenFolderCommand.CanExecute(null).ShouldBeFalse();
+        vm.Library.RefreshClipsCommand.CanExecute(null).ShouldBeFalse();
     }
 }
diff --git a/SentryDeck.Tests/MainWindowViewModelTests.Markers.cs b/SentryDeck.Tests/MainWindowViewModelTests.Markers.cs
index 3c13c52..6e96087 100644
--- a/SentryDeck.Tests/MainWindowViewModelTests.Markers.cs
+++ b/SentryDeck.Tests/MainWindowViewModelTests.Markers.cs
@@ -14,11 +14,11 @@ public void EventMarker_NearClipEnd_MapsToHighFraction()
         var vm = CreateViewModel();
 
         // 10 one-minute chunks (600s modeled); event at 9m30s in -> 0.95.
-        vm.SelectedClip = ClipWithChunksAndEvent(10, TimeSpan.FromSeconds(570));
+        vm.Library.SelectedClip = ClipWithChunksAndEvent(10, TimeSpan.FromSeconds(570));
 
-        vm.HasEventMarker.ShouldBeTrue();
-        vm.EventMarkerPosition.ShouldBe(0.95, 0.0001);
-        vm.EventMarkerTooltip.ShouldStartWith("Honk · ");
+        vm.Playback.HasEventMarker.ShouldBeTrue();
+        vm.Playback.EventMarkerPosition.ShouldBe(0.95, 0.0001);
+        vm.Playback.EventMarkerTooltip.ShouldStartWith("Honk · ");
     }
 
     [Fact]
@@ -26,11 +26,11 @@ public void EventMarker_AbsentWithoutEvent()
     {
         var vm = CreateViewModel();
 
-        vm.SelectedClip = ClipWithChunks(3);
+        vm.Library.SelectedClip = ClipWithChunks(3);
 
-        vm.HasEventMarker.ShouldBeFalse();
-        vm.EventMarkerPosition.ShouldBe(0);
-        vm.EventMarkerTooltip.ShouldBeEmpty();
+        vm.Playback.HasEventMarker.ShouldBeFalse();
+        vm.Playback.EventMarkerPosition.ShouldBe(0);
+        vm.Playback.EventMarkerTooltip.ShouldBeEmpty();
     }
 
     [Fact]
@@ -40,9 +40,9 @@ public void EventMarker_AbsentWhenEventTimestampIsDefault()
         var chunks = ClipWithChunks(3).Chunks;
         var camEvent = new CamEvent { Reason = "user_interaction_honk" }; // Timestamp == default
 
-        vm.SelectedClip = new CamClip(System.IO.Path.GetTempPath(), "Default TS", new DateTime(2025, 1, 1, 12, 0, 0), chunks, camEvent);
+        vm.Library.SelectedClip = new CamClip(System.IO.Path.GetTempPath(), "Default TS", new DateTime(2025, 1, 1, 12, 0, 0), chunks, camEvent);
 
-        vm.HasEventMarker.ShouldBeFalse();
+        vm.Playback.HasEventMarker.ShouldBeFalse();
     }
 
     [Fact]
@@ -51,10 +51,10 @@ public void EventMarker_AtTheVeryStart_ShowsAtFractionZero()
         var vm = CreateViewModel();
 
         // Event fired on the first recorded frame (timestamp == first chunk's timestamp): fraction is exactly 0, which is a real position, not clock skew.
-        vm.SelectedClip = ClipWithChunksAndEvent(10, TimeSpan.Zero);
+        vm.Library.SelectedClip = ClipWithChunksAndEvent(10, TimeSpan.Zero);
 
-        vm.HasEventMarker.ShouldBeTrue();
-        vm.EventMarkerPosition.ShouldBe(0);
+        vm.Playback.HasEventMarker.ShouldBeTrue();
+        vm.Playback.EventMarkerPosition.ShouldBe(0);
     }
 
     [Fact]
@@ -63,9 +63,9 @@ public void EventMarker_AbsentWhenEventBeforeClipStart()
         var vm = CreateViewModel();
 
         // Clock skew: event five minutes before the first chunk -> fraction <= 0, no marker.
-        vm.SelectedClip = ClipWithChunksAndEvent(10, TimeSpan.FromMinutes(-5));
+        vm.Library.SelectedClip = ClipWithChunksAndEvent(10, TimeSpan.FromMinutes(-5));
 
-        vm.HasEventMarker.ShouldBeFalse();
+        vm.Playback.HasEventMarker.ShouldBeFalse();
     }
 
     [Fact]
@@ -74,9 +74,9 @@ public void EventMarker_AbsentWhenEventBeyondModeledDuration()
         var vm = CreateViewModel();
 
         // 3 chunks = 180s modeled; an event at 200s is past the estimated end (fraction > 1).
-        vm.SelectedClip = ClipWithChunksAndEvent(3, TimeSpan.FromSeconds(200));
+        vm.Library.SelectedClip = ClipWithChunksAndEvent(3, TimeSpan.FromSeconds(200));
 
-        vm.HasEventMarker.ShouldBeFalse();
+        vm.Playback.HasEventMarker.ShouldBeFalse();
     }
 
     [Fact]
@@ -85,11 +85,11 @@ public void EventMarker_AbsentWhenNoChunks_NoDivideByZero()
         var vm = CreateViewModel();
         var camEvent = new CamEvent { Reason = "user_interaction_honk", Timestamp = new DateTime(2025, 1, 1, 12, 5, 0) };
 
-        vm.SelectedClip = new CamClip(System.IO.Path.GetTempPath(), "No Chunks", new DateTime(2025, 1, 1, 12, 0, 0), [], camEvent);
+        vm.Library.SelectedClip = new CamClip(System.IO.Path.GetTempPath(), "No Chunks", new DateTime(2025, 1, 1, 12, 0, 0), [], camEvent);
 
-        vm.HasEventMarker.ShouldBeFalse();
-        vm.EventMarkerPosition.ShouldBe(0);
-        vm.ChunkBoundaries.ShouldBeEmpty();
+        vm.Playback.HasEventMarker.ShouldBeFalse();
+        vm.Playback.EventMarkerPosition.ShouldBe(0);
+        vm.Playback.ChunkBoundaries.ShouldBeEmpty();
     }
 
     [Fact]
@@ -97,11 +97,11 @@ public void ChunkBoundaries_AreInteriorFractions()
     {
         var vm = CreateViewModel();
 
-        vm.SelectedClip = ClipWithChunks(3);
+        vm.Library.SelectedClip = ClipWithChunks(3);
 
-        vm.ChunkBoundaries.Count.ShouldBe(2);
-        vm.ChunkBoundaries[0].ShouldBe(1.0 / 3, 0.0001);
-        vm.ChunkBoundaries[1].ShouldBe(2.0 / 3, 0.0001);
+        vm.Playback.ChunkBoundaries.Count.ShouldBe(2);
+        vm.Playback.ChunkBoundaries[0].ShouldBe(1.0 / 3, 0.0001);
+        vm.Playback.ChunkBoundaries[1].ShouldBe(2.0 / 3, 0.0001);
     }
 
     [Fact]
@@ -109,9 +109,9 @@ public void ChunkBoundaries_EmptyForSingleChunk()
     {
         var vm = CreateViewModel();
 
-        vm.SelectedClip = ClipWithChunks(1);
+        vm.Library.SelectedClip = ClipWithChunks(1);
 
-        vm.ChunkBoundaries.ShouldBeEmpty();
+        vm.Playback.ChunkBoundaries.ShouldBeEmpty();
     }
 
     // --- Gap-aware markers: once the controller has actually opened the clip's media, event/gap positions come from the real ClipMediaSource (probed durations + wall-clock mapping) rather than the uniform-chunk-length estimate used before the media opens. ---
@@ -122,9 +122,9 @@ public void GapPositions_EmptyBeforeMediaOpens()
         // No controller at all: RecomputeSelectedClipTimeline can only fall back to the estimate, which carries no gap information.
         var vm = CreateViewModel();
 
-        vm.SelectedClip = ClipWithChunksAndEvent(3, TimeSpan.FromSeconds(90));
+        vm.Library.SelectedClip = ClipWithChunksAndEvent(3, TimeSpan.FromSeconds(90));
 
-        vm.GapPositions.ShouldBeEmpty();
+        vm.Playback.GapPositions.ShouldBeEmpty();
     }
 
     [Fact]
@@ -137,10 +137,10 @@ public void GapPositions_ReflectAGapOnceMediaSourceIsOpen()
         var clip = new CamClip(clipFiles.Clip.FullPath, clipFiles.Clip.Name, clipFiles.Clip.Timestamp, chunks, camEvent: null);
 
         var (vm, _, _) = CreateViewModelWithOpenedClip(clip);
-        vm.SelectedClip = clip;
+        vm.Library.SelectedClip = clip;
 
         // Two included chunks of 60s each = 120s total; the single gap sits at media time 60s.
-        vm.GapPositions.ShouldBe([60.0 / 120], 0.0001);
+        vm.Playback.GapPositions.ShouldBe([60.0 / 120], 0.0001);
     }
 
     [Fact]
@@ -155,38 +155,38 @@ public void EventMarker_AfterAGap_UsesGapCorrectedFraction_NotLinearTime()
         var clip = new CamClip(clipFiles.Clip.FullPath, clipFiles.Clip.Name, clipFiles.Clip.Timestamp, chunks, camEvent);
 
         var (vm, _, _) = CreateViewModelWithOpenedClip(clip);
-        vm.SelectedClip = clip;
+        vm.Library.SelectedClip = clip;
 
-        vm.HasEventMarker.ShouldBeTrue();
-        vm.EventMarkerPosition.ShouldBe(70.0 / 120, 0.0001);
+        vm.Playback.HasEventMarker.ShouldBeTrue();
+        vm.Playback.EventMarkerPosition.ShouldBe(70.0 / 120, 0.0001);
 
         // Sanity check that this genuinely differs from what the naive linear/estimated model (ignoring the gap) would have produced, so the test would fail if gap-awareness regressed.
-        Math.Abs(vm.EventMarkerPosition - (130.0 / 180)).ShouldBeGreaterThan(0.01);
+        Math.Abs(vm.Playback.EventMarkerPosition - (130.0 / 180)).ShouldBeGreaterThan(0.01);
     }
 
     [Fact]
     public void ClearingSelection_ResetsEventMarkerAndChunks()
     {
         var vm = CreateViewModel();
-        vm.SelectedClip = ClipWithChunksAndEvent(10, TimeSpan.FromSeconds(570));
-        vm.HasEventMarker.ShouldBeTrue();
+        vm.Library.SelectedClip = ClipWithChunksAndEvent(10, TimeSpan.FromSeconds(570));
+        vm.Playback.HasEventMarker.ShouldBeTrue();
 
-        vm.SelectedClip = null;
+        vm.Library.SelectedClip = null;
 
-        vm.HasEventMarker.ShouldBeFalse();
-        vm.EventMarkerPosition.ShouldBe(0);
-        vm.ChunkBoundaries.ShouldBeEmpty();
+        vm.Playback.HasEventMarker.ShouldBeFalse();
+        vm.Playback.EventMarkerPosition.ShouldBe(0);
+        vm.Playback.ChunkBoundaries.ShouldBeEmpty();
     }
 
     [Fact]
     public void JumpToEvent_CanExecute_FollowsHasEventMarker()
     {
         var vm = CreateViewModel();
-        vm.JumpToEventCommand.CanExecute(null).ShouldBeFalse();
+        vm.Playback.JumpToEventCommand.CanExecute(null).ShouldBeFalse();
 
-        vm.SelectedClip = ClipWithChunksAndEvent(10, TimeSpan.FromSeconds(570));
+        vm.Library.SelectedClip = ClipWithChunksAndEvent(10, TimeSpan.FromSeconds(570));
 
-        vm.JumpToEventCommand.CanExecute(null).ShouldBeTrue();
+        vm.Playback.JumpToEventCommand.CanExecute(null).ShouldBeTrue();
     }
 
     [Fact]
@@ -201,7 +201,7 @@ public void EventShortcut_WithAnOpenedEventClip_SeeksThePlayersToTheEventMoment(
             clipFiles.Clip.Chunks,
             new CamEvent { Timestamp = clipFiles.Clip.Chunks[1].Timestamp.AddSeconds(30) });
         var (vm, controller, front) = CreateViewModelWithOpenedClip(clip);
-        vm.SelectedClip = clip;
+        vm.Library.SelectedClip = clip;
 
         var handled = vm.HandleKeyDown(Key.E, ModifierKeys.None);
         RunPinnedToTestThread(controller.WhenIdleAsync);
@@ -209,14 +209,14 @@ public void EventShortcut_WithAnOpenedEventClip_SeeksThePlayersToTheEventMoment(
         handled.ShouldBeTrue();
         front.Seeks[^1].Position.ShouldBe(TimeSpan.FromSeconds(90));
         controller.Position.ShouldBe(TimeSpan.FromSeconds(90));
-        vm.SeekPosition.ShouldBe(0.5, 0.0001);
+        vm.Playback.SeekPosition.ShouldBe(0.5, 0.0001);
     }
 
     [Fact]
     public async Task EventShortcut_Ignored_WhenNoMarker()
     {
         var vm = CreateViewModel();
-        vm.SelectedClip = ClipWithChunks(3); // no event
+        vm.Library.SelectedClip = ClipWithChunks(3); // no event
 
         var handled = await vm.HandleKeyDownAsync(Key.E, ModifierKeys.None);
 
@@ -228,12 +228,12 @@ public void SelectingClip_RaisesEventMarkerNotifications()
     {
         var vm = CreateViewModel();
         var changed = new List<string>();
-        vm.PropertyChanged += (_, e) => changed.Add(e.PropertyName);
+        vm.Playback.PropertyChanged += (_, e) => changed.Add(e.PropertyName);
 
-        vm.SelectedClip = ClipWithChunksAndEvent(5, TimeSpan.FromSeconds(250));
+        vm.Library.SelectedClip = ClipWithChunksAndEvent(5, TimeSpan.FromSeconds(250));
 
-        changed.ShouldContain(nameof(MainWindowViewModel.EventMarkerPosition));
-        changed.ShouldContain(nameof(MainWindowViewModel.HasEventMarker));
-        changed.ShouldContain(nameof(MainWindowViewModel.ChunkBoundaries));
+        changed.ShouldContain(nameof(PlaybackViewModel.EventMarkerPosition));
+        changed.ShouldContain(nameof(PlaybackViewModel.HasEventMarker));
+        changed.ShouldContain(nameof(PlaybackViewModel.ChunkBoundaries));
     }
 }
diff --git a/SentryDeck.Tests/MainWindowViewModelTests.Playback.cs b/SentryDeck.Tests/MainWindowViewModelTests.Playback.cs
index 6341f12..e0dc00b 100644
--- a/SentryDeck.Tests/MainWindowViewModelTests.Playback.cs
+++ b/SentryDeck.Tests/MainWindowViewModelTests.Playback.cs
@@ -14,24 +14,24 @@ public void SeekMath_PositionTextScalesByDuration()
         var vm = CreateViewModelWithController(out var controller, out _);
         controller.Duration = TimeSpan.FromMinutes(2);
 
-        vm.SeekPosition = 0.5;
+        vm.Playback.SeekPosition = 0.5;
 
-        vm.PositionText.ShouldBe("1:00");
-        vm.DurationText.ShouldBe("2:00");
+        vm.Playback.PositionText.ShouldBe("1:00");
+        vm.Playback.DurationText.ShouldBe("2:00");
     }
 
     [Fact]
     public void CanSeek_RequiresOpenMediaDurationAndNotLoading()
     {
         var vm = CreateViewModelWithController(out var controller, out _);
-        vm.CanSeek.ShouldBeFalse(); // no media open yet
+        vm.Playback.CanSeek.ShouldBeFalse(); // no media open yet
 
         controller.Duration = TimeSpan.FromMinutes(1);
         controller.IsMediaOpen = true;
-        vm.CanSeek.ShouldBeTrue();
+        vm.Playback.CanSeek.ShouldBeTrue();
 
-        vm.IsLoading = true;
-        vm.CanSeek.ShouldBeFalse();
+        vm.Playback.IsLoading = true;
+        vm.Playback.CanSeek.ShouldBeFalse();
     }
 
     [Fact]
@@ -42,7 +42,7 @@ public void ControllerPositionChange_UpdatesSeekPosition()
 
         controller.Position = TimeSpan.FromSeconds(30);
 
-        vm.SeekPosition.ShouldBe(0.25, 0.0001);
+        vm.Playback.SeekPosition.ShouldBe(0.25, 0.0001);
     }
 
     [Fact]
@@ -52,13 +52,13 @@ public async Task WhileScrubbing_ControllerPositionDoesNotMoveTheSlider()
         controller.Duration = TimeSpan.FromMinutes(2);
         controller.IsMediaOpen = true;
 
-        vm.BeginSeek();
+        vm.Playback.BeginSeek();
         controller.Position = TimeSpan.FromSeconds(60); // user is dragging: ignore controller updates
-        vm.SeekPosition.ShouldBe(0.0);
+        vm.Playback.SeekPosition.ShouldBe(0.0);
 
-        await vm.EndSeekAsync();
+        await vm.Playback.EndSeekAsync();
         controller.Position = TimeSpan.FromSeconds(30); // updates resume after the drag
-        vm.SeekPosition.ShouldBe(0.25, 0.0001);
+        vm.Playback.SeekPosition.ShouldBe(0.25, 0.0001);
     }
 
     // Synchronous (no async/await in the test body itself -- see RunPinnedToTestThread).
@@ -68,14 +68,14 @@ public void DragSequence_IssuesFastSeeks_ReleaseIssuesAccurateSeekAtReleasePosit
         using var clipFiles = TestClipFiles.Create(chunkCount: 1); // 60s clip (see TestClipFiles)
         var (vm, _, front) = CreateViewModelWithOpenedClip(clipFiles.Clip);
 
-        vm.BeginSeek();
+        vm.Playback.BeginSeek();
 
         // Simulate a drag: each slider value change while dragging should scrub-seek (fast/keyframe).
-        vm.SeekPosition = 0.2; // 12s of 60s
-        vm.OnSeekSliderValueChanged();
+        vm.Playback.SeekPosition = 0.2; // 12s of 60s
+        vm.Playback.OnSeekSliderValueChanged();
 
-        vm.SeekPosition = 0.5; // 30s
-        vm.OnSeekSliderValueChanged();
+        vm.Playback.SeekPosition = 0.5; // 30s
+        vm.Playback.OnSeekSliderValueChanged();
 
         front.Seeks.ShouldContain((TimeSpan.FromSeconds(12), false));
         front.Seeks.ShouldContain((TimeSpan.FromSeconds(30), false));
@@ -84,9 +84,9 @@ public void DragSequence_IssuesFastSeeks_ReleaseIssuesAccurateSeekAtReleasePosit
         front.Seeks.ShouldAllBe(seek => !seek.Accurate);
 
         // Release at 0.75 (45s): EndSeekAsync must issue exactly one ACCURATE seek at the release position.
-        vm.SeekPosition = 0.75;
+        vm.Playback.SeekPosition = 0.75;
 
-        RunPinnedToTestThread(vm.EndSeekAsync);
+        RunPinnedToTestThread(vm.Playback.EndSeekAsync);
 
         front.Seeks[^1].ShouldBe((TimeSpan.FromSeconds(45), true));
     }
@@ -98,28 +98,28 @@ public void StaleEndSeek_AfterANewDragStarted_DoesNotUnlockPositionSync()
         using var clipFiles = TestClipFiles.Create(chunkCount: 1); // 60s clip
         var (vm, _, front) = CreateViewModelWithOpenedClip(clipFiles.Clip);
 
-        vm.BeginSeek();
-        vm.SeekPosition = 0.5;
+        vm.Playback.BeginSeek();
+        vm.Playback.SeekPosition = 0.5;
 
         // While gesture #1's accurate release seek is executing, the user grabs the thumb again and starts a new drag.
         // Gesture #1's completion is then stale: it must NOT clear the active drag's seeking state, or the position sync would yank the thumb mid-drag.
         front.SeekCallback = () =>
         {
             front.SeekCallback = null;
-            vm.BeginSeek();
-            vm.SeekPosition = 0.25;
+            vm.Playback.BeginSeek();
+            vm.Playback.SeekPosition = 0.25;
         };
 
-        RunPinnedToTestThread(vm.EndSeekAsync);
+        RunPinnedToTestThread(vm.Playback.EndSeekAsync);
 
         // A controller position sync arriving during drag #2 must still be ignored.
         front.RaisePositionChanged(TimeSpan.FromSeconds(50));
-        vm.SeekPosition.ShouldBe(0.25);
+        vm.Playback.SeekPosition.ShouldBe(0.25);
 
         // The active gesture still ends normally and re-enables position sync.
-        RunPinnedToTestThread(vm.EndSeekAsync);
+        RunPinnedToTestThread(vm.Playback.EndSeekAsync);
         front.RaisePositionChanged(TimeSpan.FromSeconds(30));
-        vm.SeekPosition.ShouldBe(0.5, 0.0001);
+        vm.Playback.SeekPosition.ShouldBe(0.5, 0.0001);
     }
 
     [Fact]
@@ -132,7 +132,7 @@ public void PositionSync_WhenNotDragging_DoesNotTriggerScrubSeeks()
 
         // Playback position advances on its own (not a drag): SeekPosition updates via the controller -> UpdateSeekPositionFromController path, which does not go through OnSeekSliderValueChanged, so no scrub seek should ever be issued.
         controller.Position = TimeSpan.FromSeconds(10);
-        vm.OnSeekSliderValueChanged(); // the view raises ValueChanged for programmatic changes too
+        vm.Playback.OnSeekSliderValueChanged(); // the view raises ValueChanged for programmatic changes too
 
         front.Seeks.Count.ShouldBe(seeksBefore);
     }
@@ -147,8 +147,8 @@ public void ControllerLoadingAndPlaying_MirrorToViewModel()
 
         controller.IsLoading = false;
         controller.IsPlaying = true;
-        vm.IsPlaying.ShouldBeTrue();
-        vm.PlayPauseIcon.ShouldBe(""); // Pause
+        vm.Playback.IsPlaying.ShouldBeTrue();
+        vm.Playback.PlayPauseIcon.ShouldBe(""); // Pause
     }
 
     [Fact]
@@ -158,9 +158,9 @@ public void ControllerError_ShowsErrorOverlay()
 
         controller.ErrorMessage = "decode failed";
 
-        vm.ShowErrorOverlay.ShouldBeTrue();
-        vm.ErrorTitle.ShouldBe("Playback Error");
-        vm.ErrorDetails.ShouldBe("decode failed");
+        vm.Error.IsVisible.ShouldBeTrue();
+        vm.Error.Title.ShouldBe("Playback Error");
+        vm.Error.Details.ShouldBe("decode failed");
     }
 
     [Fact]
@@ -170,8 +170,8 @@ public void CanGoNextPrevious_ReflectControllerPlaylist()
         controller.LoadClips(TestClips.Create(3)); // set the playlist directly (synchronous, on the test thread)
 
         // Playlist loaded, nothing playing yet: can advance, can't go back.
-        vm.CanGoNext.ShouldBeTrue();
-        vm.CanGoPrevious.ShouldBeFalse();
+        vm.Playback.CanGoNext.ShouldBeTrue();
+        vm.Playback.CanGoPrevious.ShouldBeFalse();
     }
 
     [Fact]
@@ -180,13 +180,13 @@ public void SelectingClip_NotYetOpened_ShowsLoadingWithoutAnError()
         var clip = TestClips.Create(1)[0];
         var vm = CreateViewModelWithController(out _, out _);
 
-        vm.SelectedClip = clip;
+        vm.Library.SelectedClip = clip;
 
         // Selecting a clip runs OnSelectedClipChanged -> PlaySelectedClipAsync, which sets IsLoading=true (synchronously, before the awaited yield) and calls the controller.
         // The clip is intentionally NOT in the controller's playlist, so GoToClipAsync is a deterministic no-op; this verifies only that selection triggers the auto-play loading state.
         // Opening media is VideoPlayerController's own job.
         vm.IsLoading.ShouldBeTrue();
-        vm.ShowErrorOverlay.ShouldBeFalse();
+        vm.Error.IsVisible.ShouldBeFalse();
     }
 
     [Fact]
@@ -196,10 +196,10 @@ public void SelectingAnEventClip_AutoFocusesTheTriggeringCamera()
 
         // Camera id 7 is the rear camera.
         // As in SelectingClip_TriggersPlaybackLoading, the clip is deliberately not in the controller's playlist, so GoToClipAsync early-returns and the rest of the selection load runs inline on this thread.
-        vm.SelectedClip = ClipWithCamerasAndEventCamera(eventCamera: 7, SixCameras);
+        vm.Library.SelectedClip = ClipWithCamerasAndEventCamera(eventCamera: 7, SixCameras);
 
         // Opening an incident on the angle that triggered it is the whole point of the metadata.
-        vm.SelectedCameraView.ShouldBe(CameraNames.Back);
+        vm.Cameras.SelectedCameraView.ShouldBe(CameraNames.Back);
     }
 
     [Fact]
@@ -214,8 +214,8 @@ public void StopCommand_WhileASelectionIsWaitingToLoad_KeepsItFromPlaying()
         var vm = new MainWindowViewModel(() => controller, backgroundYield: () => loadGate.Task);
         vm.InitializePlayer();
 
-        vm.SelectedClip = clipFiles.Clip;
-        RunPinnedToTestThread(() => vm.StopCommand.ExecuteAsync(null));
+        vm.Library.SelectedClip = clipFiles.Clip;
+        RunPinnedToTestThread(() => vm.Playback.StopCommand.ExecuteAsync(null));
         loadGate.SetResult();
         RunPinnedToTestThread(controller.WhenIdleAsync);
 
@@ -223,4 +223,27 @@ public void StopCommand_WhileASelectionIsWaitingToLoad_KeepsItFromPlaying()
         controller.IsPlaying.ShouldBeFalse();
         vm.IsLoading.ShouldBeFalse();
     }
+
+    [Fact]
+    public void NextCommand_MovesTheListSelectionToTheNextClip()
+    {
+        // The player reports clip changes back to the clip list; without that the list would keep highlighting the clip it left.
+        using var first = TestClipFiles.Create(chunkCount: 1);
+        using var second = TestClipFiles.Create(chunkCount: 1);
+        var front = new FakeCameraPlayer();
+        var controller = BuildFourCameraController(front);
+        controller.LoadClips([first.Clip, second.Clip]);
+        var vm = new MainWindowViewModel(() => controller, backgroundYield: () => Task.CompletedTask, uiInvoker: action => action());
+        vm.InitializePlayer();
+        vm.Library.SelectedClip = first.Clip;
+        RunPinnedToTestThread(controller.WhenIdleAsync);
+
+        RunPinnedToTestThread(() => vm.Playback.NextCommand.ExecuteAsync(null));
+        RunPinnedToTestThread(controller.WhenIdleAsync);
+
+        vm.Library.SelectedClip.ShouldBe(second.Clip);
+        vm.Playback.NowPlayingClip.ShouldBe(second.Clip);
+        controller.CurrentClip.ShouldBe(second.Clip);
+        front.Count("open").ShouldBe(2);
+    }
 }
diff --git a/SentryDeck.Tests/MainWindowViewModelTests.Trimming.cs b/SentryDeck.Tests/MainWindowViewModelTests.Trimming.cs
index 59e1f55..1f54d01 100644
--- a/SentryDeck.Tests/MainWindowViewModelTests.Trimming.cs
+++ b/SentryDeck.Tests/MainWindowViewModelTests.Trimming.cs
@@ -15,19 +15,19 @@ public void MarkSelection_SetsFractions_AndCompletesTheRange()
         controller.Duration = TimeSpan.FromMinutes(1);
         controller.IsMediaOpen = true;
 
-        vm.SeekPosition = 0.3;
-        vm.MarkSelectionStartCommand.Execute(null);
+        vm.Playback.SeekPosition = 0.3;
+        vm.Trim.MarkSelectionStartCommand.Execute(null);
 
-        vm.HasSelectionStart.ShouldBeTrue();
-        vm.SelectionStartPosition.ShouldBe(0.3);
-        vm.HasSelection.ShouldBeFalse(); // no end yet
+        vm.Trim.HasSelectionStart.ShouldBeTrue();
+        vm.Trim.SelectionStartPosition.ShouldBe(0.3);
+        vm.Trim.HasSelection.ShouldBeFalse(); // no end yet
 
-        vm.SeekPosition = 0.7;
-        vm.MarkSelectionEndCommand.Execute(null);
+        vm.Playback.SeekPosition = 0.7;
+        vm.Trim.MarkSelectionEndCommand.Execute(null);
 
-        vm.HasSelection.ShouldBeTrue();
-        vm.SelectionEndPosition.ShouldBe(0.7);
-        vm.CanExportSelection.ShouldBeTrue();
+        vm.Trim.HasSelection.ShouldBeTrue();
+        vm.Trim.SelectionEndPosition.ShouldBe(0.7);
+        vm.Trim.CanExportSelection.ShouldBeTrue();
     }
 
     [Fact]
@@ -37,22 +37,22 @@ public void MarkSelection_InvertedOrder_ClearsTheOtherMark()
         controller.Duration = TimeSpan.FromMinutes(1);
         controller.IsMediaOpen = true;
 
-        vm.SeekPosition = 0.3;
-        vm.MarkSelectionStartCommand.Execute(null);
-        vm.SeekPosition = 0.7;
-        vm.MarkSelectionEndCommand.Execute(null);
+        vm.Playback.SeekPosition = 0.3;
+        vm.Trim.MarkSelectionStartCommand.Execute(null);
+        vm.Playback.SeekPosition = 0.7;
+        vm.Trim.MarkSelectionEndCommand.Execute(null);
 
         // A start at/past the end invalidates the end...
-        vm.SeekPosition = 0.9;
-        vm.MarkSelectionStartCommand.Execute(null);
-        vm.SelectionStartPosition.ShouldBe(0.9);
-        vm.HasSelectionEnd.ShouldBeFalse();
+        vm.Playback.SeekPosition = 0.9;
+        vm.Trim.MarkSelectionStartCommand.Execute(null);
+        vm.Trim.SelectionStartPosition.ShouldBe(0.9);
+        vm.Trim.HasSelectionEnd.ShouldBeFalse();
 
         // ...and an end at/before the start invalidates the start.
-        vm.SeekPosition = 0.1;
-        vm.MarkSelectionEndCommand.Execute(null);
-        vm.SelectionEndPosition.ShouldBe(0.1);
-        vm.HasSelectionStart.ShouldBeFalse();
+        vm.Playback.SeekPosition = 0.1;
+        vm.Trim.MarkSelectionEndCommand.Execute(null);
+        vm.Trim.SelectionEndPosition.ShouldBe(0.1);
+        vm.Trim.HasSelectionStart.ShouldBeFalse();
     }
 
     [Fact]
@@ -62,16 +62,16 @@ public void ClearSelection_RemovesBothMarks()
         controller.Duration = TimeSpan.FromMinutes(1);
         controller.IsMediaOpen = true;
 
-        vm.ClearSelectionCommand.CanExecute(null).ShouldBeFalse(); // nothing to clear yet
+        vm.Trim.ClearSelectionCommand.CanExecute(null).ShouldBeFalse(); // nothing to clear yet
 
-        vm.SeekPosition = 0.2;
-        vm.MarkSelectionStartCommand.Execute(null);
-        vm.HasAnySelectionMark.ShouldBeTrue();
+        vm.Playback.SeekPosition = 0.2;
+        vm.Trim.MarkSelectionStartCommand.Execute(null);
+        vm.Trim.HasAnySelectionMark.ShouldBeTrue();
 
-        vm.ClearSelectionCommand.Execute(null);
+        vm.Trim.ClearSelectionCommand.Execute(null);
 
-        vm.HasAnySelectionMark.ShouldBeFalse();
-        vm.HasSelection.ShouldBeFalse();
+        vm.Trim.HasAnySelectionMark.ShouldBeFalse();
+        vm.Trim.HasSelection.ShouldBeFalse();
     }
 
     [Fact]
@@ -81,12 +81,12 @@ public void Selection_ClearsWhenAnotherClipIsSelected()
         controller.Duration = TimeSpan.FromMinutes(1);
         controller.IsMediaOpen = true;
 
-        vm.SeekPosition = 0.2;
-        vm.MarkSelectionStartCommand.Execute(null);
+        vm.Playback.SeekPosition = 0.2;
+        vm.Trim.MarkSelectionStartCommand.Execute(null);
 
-        vm.SelectedClip = TestClips.Create(1)[0];
+        vm.Library.SelectedClip = TestClips.Create(1)[0];
 
-        vm.HasAnySelectionMark.ShouldBeFalse();
+        vm.Trim.HasAnySelectionMark.ShouldBeFalse();
     }
 
     [Fact]
@@ -95,20 +95,20 @@ public void TrimCommands_ReEnableWhenLoadingEndsLast()
         // Mirrors the real clip-open order: the controller reports Duration and IsMediaOpen while the view-model is still loading, so CanSeek only becomes true when IsLoading flips off.
         // Every CanSeek-gated command must be re-queried on that final transition: the Trim button shipped permanently disabled because it wasn't.
         var vm = CreateViewModelWithController(out var controller, out _);
-        vm.IsLoading = true;
+        vm.Playback.IsLoading = true;
         controller.Duration = TimeSpan.FromMinutes(1);
         controller.IsMediaOpen = true;
 
         var trimCanExecuteChanged = false;
-        vm.ToggleTrimmingCommand.CanExecuteChanged += (_, _) => trimCanExecuteChanged = true;
+        vm.Trim.ToggleTrimmingCommand.CanExecuteChanged += (_, _) => trimCanExecuteChanged = true;
 
-        vm.IsLoading = false;
+        vm.Playback.IsLoading = false;
 
-        vm.CanSeek.ShouldBeTrue();
+        vm.Playback.CanSeek.ShouldBeTrue();
         trimCanExecuteChanged.ShouldBeTrue();
-        vm.ToggleTrimmingCommand.CanExecute(null).ShouldBeTrue();
-        vm.MarkSelectionStartCommand.CanExecute(null).ShouldBeTrue();
-        vm.MarkSelectionEndCommand.CanExecute(null).ShouldBeTrue();
+        vm.Trim.ToggleTrimmingCommand.CanExecute(null).ShouldBeTrue();
+        vm.Trim.MarkSelectionStartCommand.CanExecute(null).ShouldBeTrue();
+        vm.Trim.MarkSelectionEndCommand.CanExecute(null).ShouldBeTrue();
     }
 
     [Fact]
@@ -118,12 +118,12 @@ public void MarkingAPoint_OpensTheTrimPanel()
         controller.Duration = TimeSpan.FromMinutes(1);
         controller.IsMediaOpen = true;
 
-        vm.IsTrimming.ShouldBeFalse();
+        vm.Trim.IsTrimming.ShouldBeFalse();
 
-        vm.SeekPosition = 0.3;
-        vm.MarkSelectionStartCommand.Execute(null);
+        vm.Playback.SeekPosition = 0.3;
+        vm.Trim.MarkSelectionStartCommand.Execute(null);
 
-        vm.IsTrimming.ShouldBeTrue();
+        vm.Trim.IsTrimming.ShouldBeTrue();
     }
 
     [Fact]
@@ -133,17 +133,17 @@ public void ToggleTrimming_OpensEmpty_AndClosingDiscardsTheMarks()
         controller.Duration = TimeSpan.FromMinutes(1);
         controller.IsMediaOpen = true;
 
-        vm.ToggleTrimmingCommand.Execute(null);
-        vm.IsTrimming.ShouldBeTrue();
-        vm.HasAnySelectionMark.ShouldBeFalse();
+        vm.Trim.ToggleTrimmingCommand.Execute(null);
+        vm.Trim.IsTrimming.ShouldBeTrue();
+        vm.Trim.HasAnySelectionMark.ShouldBeFalse();
 
-        vm.SeekPosition = 0.3;
-        vm.MarkSelectionStartCommand.Execute(null);
+        vm.Playback.SeekPosition = 0.3;
+        vm.Trim.MarkSelectionStartCommand.Execute(null);
 
-        vm.ToggleTrimmingCommand.Execute(null); // acts as cancel while open
+        vm.Trim.ToggleTrimmingCommand.Execute(null); // acts as cancel while open
 
-        vm.IsTrimming.ShouldBeFalse();
-        vm.HasAnySelectionMark.ShouldBeFalse();
+        vm.Trim.IsTrimming.ShouldBeFalse();
+        vm.Trim.HasAnySelectionMark.ShouldBeFalse();
     }
 
     [Fact]
@@ -153,15 +153,15 @@ public void CancelTrim_ClosesThePanelAndDiscardsTheMarks()
         controller.Duration = TimeSpan.FromMinutes(1);
         controller.IsMediaOpen = true;
 
-        vm.SeekPosition = 0.3;
-        vm.MarkSelectionStartCommand.Execute(null);
-        vm.SeekPosition = 0.7;
-        vm.MarkSelectionEndCommand.Execute(null);
+        vm.Playback.SeekPosition = 0.3;
+        vm.Trim.MarkSelectionStartCommand.Execute(null);
+        vm.Playback.SeekPosition = 0.7;
+        vm.Trim.MarkSelectionEndCommand.Execute(null);
 
-        vm.CancelTrimCommand.Execute(null);
+        vm.Trim.CancelTrimCommand.Execute(null);
 
-        vm.IsTrimming.ShouldBeFalse();
-        vm.HasAnySelectionMark.ShouldBeFalse();
+        vm.Trim.IsTrimming.ShouldBeFalse();
+        vm.Trim.HasAnySelectionMark.ShouldBeFalse();
     }
 
     [Fact]
@@ -171,10 +171,10 @@ public void TrimPanel_ClosesWhenAnotherClipIsSelected()
         controller.Duration = TimeSpan.FromMinutes(1);
         controller.IsMediaOpen = true;
 
-        vm.ToggleTrimmingCommand.Execute(null);
-        vm.SelectedClip = TestClips.Create(1)[0];
+        vm.Trim.ToggleTrimmingCommand.Execute(null);
+        vm.Library.SelectedClip = TestClips.Create(1)[0];
 
-        vm.IsTrimming.ShouldBeFalse();
+        vm.Trim.IsTrimming.ShouldBeFalse();
     }
 
     [Fact]
@@ -184,18 +184,18 @@ public void TrimHintText_WalksThroughStartEndExport()
         controller.Duration = TimeSpan.FromMinutes(2);
         controller.IsMediaOpen = true;
 
-        vm.TrimHintText.ShouldContain("set the start");
+        vm.Trim.TrimHintText.ShouldContain("set the start");
 
-        vm.SeekPosition = 0.25;
-        vm.MarkSelectionStartCommand.Execute(null);
-        vm.TrimHintText.ShouldContain("set the end");
+        vm.Playback.SeekPosition = 0.25;
+        vm.Trim.MarkSelectionStartCommand.Execute(null);
+        vm.Trim.TrimHintText.ShouldContain("set the end");
 
-        vm.SeekPosition = 0.75;
-        vm.MarkSelectionEndCommand.Execute(null);
+        vm.Playback.SeekPosition = 0.75;
+        vm.Trim.MarkSelectionEndCommand.Execute(null);
 
         // Half of a 2:00 clip is selected.
-        vm.SelectionDurationText.ShouldBe("1:00");
-        vm.TrimHintText.ShouldBe("1:00 selected — ready to export.");
+        vm.Trim.SelectionDurationText.ShouldBe("1:00");
+        vm.Trim.TrimHintText.ShouldBe("1:00 selected — ready to export.");
     }
 
     [Fact]
@@ -203,9 +203,9 @@ public void MarkSelection_RequiresSeekableMedia()
     {
         var vm = CreateViewModel();
 
-        vm.MarkSelectionStartCommand.CanExecute(null).ShouldBeFalse();
-        vm.MarkSelectionEndCommand.CanExecute(null).ShouldBeFalse();
-        vm.ExportSelectionCommand.CanExecute(null).ShouldBeFalse();
+        vm.Trim.MarkSelectionStartCommand.CanExecute(null).ShouldBeFalse();
+        vm.Trim.MarkSelectionEndCommand.CanExecute(null).ShouldBeFalse();
+        vm.Trim.ExportSelectionCommand.CanExecute(null).ShouldBeFalse();
     }
 
     // Synchronous/blocking for the same thread-affinity reason as the drag-sequence test above (see RunPinnedToTestThread): the fake exporter and save picker complete synchronously.
@@ -216,13 +216,13 @@ public void ExportSelection_SendsMediaTimeRangeAndActiveCameraToTheExporter()
         var exporter = new FakeClipExporter();
         var (vm, _, _) = CreateViewModelWithOpenedClip(clipFiles.Clip, exporter, _ => @"C:\out\clip.mp4");
 
-        vm.SelectCameraViewCommand.Execute(CameraNames.Back);
-        vm.SeekPosition = 0.25;
-        vm.MarkSelectionStartCommand.Execute(null);
-        vm.SeekPosition = 0.75;
-        vm.MarkSelectionEndCommand.Execute(null);
+        vm.Cameras.SelectCameraViewCommand.Execute(CameraNames.Back);
+        vm.Playback.SeekPosition = 0.25;
+        vm.Trim.MarkSelectionStartCommand.Execute(null);
+        vm.Playback.SeekPosition = 0.75;
+        vm.Trim.MarkSelectionEndCommand.Execute(null);
 
-        RunPinnedToTestThread(() => vm.ExportSelectionCommand.ExecuteAsync(null));
+        RunPinnedToTestThread(() => vm.Trim.ExportSelectionCommand.ExecuteAsync(null));
 
         var request = exporter.Requests.ShouldHaveSingleItem();
         request.Clip.ShouldBe(clipFiles.Clip);
@@ -230,7 +230,7 @@ public void ExportSelection_SendsMediaTimeRangeAndActiveCameraToTheExporter()
         request.Start.ShouldBe(TimeSpan.FromSeconds(15));
         request.End.ShouldBe(TimeSpan.FromSeconds(45));
         request.OutputPath.ShouldBe(@"C:\out\clip.mp4");
-        vm.IsExporting.ShouldBeFalse();
+        vm.Trim.IsExporting.ShouldBeFalse();
     }
 
     [Fact]
@@ -240,15 +240,15 @@ public void ExportSelection_SaveDialogCanceled_DoesNotExport()
         var exporter = new FakeClipExporter();
         var (vm, _, _) = CreateViewModelWithOpenedClip(clipFiles.Clip, exporter, _ => null);
 
-        vm.SeekPosition = 0.25;
-        vm.MarkSelectionStartCommand.Execute(null);
-        vm.SeekPosition = 0.75;
-        vm.MarkSelectionEndCommand.Execute(null);
+        vm.Playback.SeekPosition = 0.25;
+        vm.Trim.MarkSelectionStartCommand.Execute(null);
+        vm.Playback.SeekPosition = 0.75;
+        vm.Trim.MarkSelectionEndCommand.Execute(null);
 
-        RunPinnedToTestThread(() => vm.ExportSelectionCommand.ExecuteAsync(null));
+        RunPinnedToTestThread(() => vm.Trim.ExportSelectionCommand.ExecuteAsync(null));
 
         exporter.Requests.ShouldBeEmpty();
-        vm.ShowErrorOverlay.ShouldBeFalse();
+        vm.Error.IsVisible.ShouldBeFalse();
     }
 
     [Fact]
@@ -258,17 +258,17 @@ public void ExportSelection_ExporterFailure_ShowsErrorAndResetsBusyState()
         var exporter = new FakeClipExporter { ExceptionToThrow = new InvalidOperationException("ffmpeg exploded") };
         var (vm, _, _) = CreateViewModelWithOpenedClip(clipFiles.Clip, exporter, _ => @"C:\out\clip.mp4");
 
-        vm.SeekPosition = 0.25;
-        vm.MarkSelectionStartCommand.Execute(null);
-        vm.SeekPosition = 0.75;
-        vm.MarkSelectionEndCommand.Execute(null);
+        vm.Playback.SeekPosition = 0.25;
+        vm.Trim.MarkSelectionStartCommand.Execute(null);
+        vm.Playback.SeekPosition = 0.75;
+        vm.Trim.MarkSelectionEndCommand.Execute(null);
 
-        RunPinnedToTestThread(() => vm.ExportSelectionCommand.ExecuteAsync(null));
+        RunPinnedToTestThread(() => vm.Trim.ExportSelectionCommand.ExecuteAsync(null));
 
-        vm.ShowErrorOverlay.ShouldBeTrue();
-        vm.ErrorTitle.ShouldBe("Export Failed");
-        vm.ErrorDetails.ShouldContain("ffmpeg exploded");
-        vm.IsExporting.ShouldBeFalse();
+        vm.Error.IsVisible.ShouldBeTrue();
+        vm.Error.Title.ShouldBe("Export Failed");
+        vm.Error.Details.ShouldContain("ffmpeg exploded");
+        vm.Trim.IsExporting.ShouldBeFalse();
     }
 
     [Fact]
@@ -284,10 +284,10 @@ public async Task SaveEventClip_ExportsFrontCameraWindowAroundTheEvent()
             savePathPicker: _ => @"C:\out\event.mp4",
             exportMediaSourceBuilder: new FakeClipMediaSourceBuilder())
         {
-            RevealInExplorer = _ => { },
+            Trim = { RevealInExplorer = _ => { } },
         };
 
-        await vm.SaveEventClipCommand.ExecuteAsync(clip);
+        await vm.Trim.SaveEventClipCommand.ExecuteAsync(clip);
 
         var request = exporter.Requests.ShouldHaveSingleItem();
         request.Camera.ShouldBe(CameraNames.Front);
@@ -308,10 +308,10 @@ public async Task SaveEventClip_WindowIsClampedToTheClip()
             savePathPicker: _ => @"C:\out\event.mp4",
             exportMediaSourceBuilder: new FakeClipMediaSourceBuilder())
         {
-            RevealInExplorer = _ => { },
+            Trim = { RevealInExplorer = _ => { } },
         };
 
-        await vm.SaveEventClipCommand.ExecuteAsync(clip);
+        await vm.Trim.SaveEventClipCommand.ExecuteAsync(clip);
 
         var request = exporter.Requests.ShouldHaveSingleItem();
         request.Start.ShouldBe(TimeSpan.Zero);
@@ -331,15 +331,15 @@ public async Task SaveEventClip_BuilderThrows_ShowsErrorInsteadOfCrashing()
             savePathPicker: _ => @"C:\out\event.mp4",
             exportMediaSourceBuilder: new ThrowingClipMediaSourceBuilder(new IOException("drive gone")))
         {
-            RevealInExplorer = _ => { },
+            Trim = { RevealInExplorer = _ => { } },
         };
 
-        await vm.SaveEventClipCommand.ExecuteAsync(clip);
+        await vm.Trim.SaveEventClipCommand.ExecuteAsync(clip);
 
-        vm.ShowErrorOverlay.ShouldBeTrue();
-        vm.ErrorTitle.ShouldBe("Export Failed");
+        vm.Error.IsVisible.ShouldBeTrue();
+        vm.Error.Title.ShouldBe("Export Failed");
         exporter.Requests.ShouldBeEmpty();
-        vm.IsExporting.ShouldBeFalse();
+        vm.Trim.IsExporting.ShouldBeFalse();
     }
 
     private sealed class ThrowingClipMediaSourceBuilder(Exception exception) : IClipMediaSourceBuilder
@@ -352,44 +352,44 @@ public void SaveEventClip_RequiresAnEventMoment()
     {
         var vm = CreateViewModel();
 
-        vm.SaveEventClipCommand.CanExecute(ClipWithChunks(1)).ShouldBeFalse(); // no event
-        vm.SaveEventClipCommand.CanExecute(ClipWithEvent("clip", "sentry_aware_object_detection", "Bellevue")).ShouldBeFalse(); // event without timestamp
-        vm.SaveEventClipCommand.CanExecute(ClipWithChunksAndEvent(1, TimeSpan.FromSeconds(10))).ShouldBeTrue();
+        vm.Trim.SaveEventClipCommand.CanExecute(ClipWithChunks(1)).ShouldBeFalse(); // no event
+        vm.Trim.SaveEventClipCommand.CanExecute(ClipWithEvent("clip", "sentry_aware_object_detection", "Bellevue")).ShouldBeFalse(); // event without timestamp
+        vm.Trim.SaveEventClipCommand.CanExecute(ClipWithChunksAndEvent(1, TimeSpan.FromSeconds(10))).ShouldBeTrue();
     }
 
     [Fact]
     public void SpeedStepper_WalksTheLadder_AndClampsAtTheEnds()
     {
         var vm = CreateViewModel();
-        vm.PlaybackSpeed.ShouldBe(1.0);
+        vm.Playback.PlaybackSpeed.ShouldBe(1.0);
 
-        vm.IncreaseSpeedCommand.Execute(null);
-        vm.PlaybackSpeed.ShouldBe(1.25);
+        vm.Playback.IncreaseSpeedCommand.Execute(null);
+        vm.Playback.PlaybackSpeed.ShouldBe(1.25);
 
         // Run the ladder up: it must stop at the top step (Flyleaf's 16x clamp).
         for (var i = 0; i < 20; i++)
-            vm.IncreaseSpeedCommand.Execute(null);
-        vm.PlaybackSpeed.ShouldBe(16.0);
-        vm.CanIncreaseSpeed.ShouldBeFalse();
-        vm.IncreaseSpeedCommand.CanExecute(null).ShouldBeFalse();
+            vm.Playback.IncreaseSpeedCommand.Execute(null);
+        vm.Playback.PlaybackSpeed.ShouldBe(16.0);
+        vm.Playback.CanIncreaseSpeed.ShouldBeFalse();
+        vm.Playback.IncreaseSpeedCommand.CanExecute(null).ShouldBeFalse();
 
         // And back down to the bottom step.
         for (var i = 0; i < 20; i++)
-            vm.DecreaseSpeedCommand.Execute(null);
-        vm.PlaybackSpeed.ShouldBe(0.25);
-        vm.CanDecreaseSpeed.ShouldBeFalse();
-        vm.DecreaseSpeedCommand.CanExecute(null).ShouldBeFalse();
+            vm.Playback.DecreaseSpeedCommand.Execute(null);
+        vm.Playback.PlaybackSpeed.ShouldBe(0.25);
+        vm.Playback.CanDecreaseSpeed.ShouldBeFalse();
+        vm.Playback.DecreaseSpeedCommand.CanExecute(null).ShouldBeFalse();
     }
 
     [Fact]
     public void ResetSpeed_ReturnsToRealtime()
     {
         var vm = CreateViewModel();
-        vm.PlaybackSpeed = 8.0;
+        vm.Playback.PlaybackSpeed = 8.0;
 
-        vm.ResetSpeedCommand.Execute(null);
+        vm.Playback.ResetSpeedCommand.Execute(null);
 
-        vm.PlaybackSpeed.ShouldBe(1.0);
+        vm.Playback.PlaybackSpeed.ShouldBe(1.0);
     }
 
     [Theory]
@@ -401,9 +401,9 @@ public void PlaybackSpeedText_FormatsCompactly(double speed, string expected)
     {
         var vm = CreateViewModel();
 
-        vm.PlaybackSpeed = speed;
+        vm.Playback.PlaybackSpeed = speed;
 
-        vm.PlaybackSpeedText.ShouldBe(expected);
+        vm.Playback.PlaybackSpeedText.ShouldBe(expected);
     }
 
     [Fact]
@@ -412,11 +412,11 @@ public async Task SpeedShortcuts_StepTheLadder()
         var vm = CreateViewModel();
 
         (await vm.HandleKeyDownAsync(Key.OemPeriod, ModifierKeys.Shift)).ShouldBeTrue();
-        vm.PlaybackSpeed.ShouldBe(1.25);
+        vm.Playback.PlaybackSpeed.ShouldBe(1.25);
 
         (await vm.HandleKeyDownAsync(Key.OemComma, ModifierKeys.Shift)).ShouldBeTrue();
         (await vm.HandleKeyDownAsync(Key.OemComma, ModifierKeys.Shift)).ShouldBeTrue();
-        vm.PlaybackSpeed.ShouldBe(0.75);
+        vm.Playback.PlaybackSpeed.ShouldBe(0.75);
     }
 
     [Fact]
@@ -428,7 +428,7 @@ public async Task SpeedShortcuts_DoNotActBehindAboutPage()
         var handled = await vm.HandleKeyDownAsync(Key.OemPeriod, ModifierKeys.Shift);
 
         handled.ShouldBeFalse();
-        vm.PlaybackSpeed.ShouldBe(1.0);
+        vm.Playback.PlaybackSpeed.ShouldBe(1.0);
     }
 
     [Fact]
@@ -436,8 +436,30 @@ public void ChangingSpeed_FlowsToTheController()
     {
         var vm = CreateViewModelWithController(out var controller, out _);
 
-        vm.PlaybackSpeed = 4.0;
+        vm.Playback.PlaybackSpeed = 4.0;
 
         controller.PlaybackSpeed.ShouldBe(4.0);
     }
+
+    [Fact]
+    public void TrimMarks_WhenRecoveryRebuildsTheClipsMedia_AreDropped()
+    {
+        // Recovery from a corrupt chunk excludes footage and shrinks the timeline, so fractions marked against the old timeline would point at different moments.
+        using var clipFiles = TestClipFiles.Create(chunkCount: 3);
+        var (vm, controller, front) = CreateViewModelWithOpenedClip(clipFiles.Clip, uiInvoker: action => action());
+        RunPinnedToTestThread(controller.PauseAsync);
+        vm.Playback.SeekPosition = 0.2;
+        vm.Trim.MarkSelectionStartCommand.Execute(null);
+        vm.Playback.SeekPosition = 0.4;
+        vm.Trim.MarkSelectionEndCommand.Execute(null);
+        vm.Trim.HasSelection.ShouldBeTrue();
+
+        // Ending 90s into 180s of footage makes recovery exclude the middle chunk and reopen a 120s timeline.
+        front.RaisePositionChanged(TimeSpan.FromSeconds(90));
+        front.RaiseEnded();
+        RunPinnedToTestThread(controller.WhenIdleAsync);
+
+        controller.Duration.ShouldBe(TimeSpan.FromMinutes(2));
+        vm.Trim.HasAnySelectionMark.ShouldBeFalse();
+    }
 }
diff --git a/SentryDeck.Tests/MainWindowViewModelTests.cs b/SentryDeck.Tests/MainWindowViewModelTests.cs
index 30bd128..5bdca20 100644
--- a/SentryDeck.Tests/MainWindowViewModelTests.cs
+++ b/SentryDeck.Tests/MainWindowViewModelTests.cs
@@ -131,7 +131,7 @@ private VideoPlayerController BuildFourCameraController(FakeCameraPlayer front)
             savePathPicker: savePathPicker,
             uiInvoker: uiInvoker)
         {
-            RevealInExplorer = _ => { },
+            Trim = { RevealInExplorer = _ => { } },
         };
         vm.InitializePlayer();
         return (vm, built, front);
@@ -162,10 +162,10 @@ public void NewViewModel_DefaultsToFrontCamera_AndEmptyOverlay()
     {
         var vm = CreateViewModel();
 
-        vm.SelectedCameraView.ShouldBe(CameraNames.Front);
-        vm.IsGridViewSelected.ShouldBeFalse();
-        vm.IsSingleCameraViewSelected.ShouldBeTrue();
-        vm.CameraViewOptions.Single(option => option.ViewId == CameraNames.Front).IsSelected.ShouldBeTrue();
+        vm.Cameras.SelectedCameraView.ShouldBe(CameraNames.Front);
+        vm.Cameras.IsGridViewSelected.ShouldBeFalse();
+        vm.Cameras.IsSingleCameraViewSelected.ShouldBeTrue();
+        vm.Cameras.CameraViewOptions.Single(option => option.ViewId == CameraNames.Front).IsSelected.ShouldBeTrue();
         vm.ShowMainContent.ShouldBeTrue();
         vm.ShowAboutPage.ShouldBeFalse();
 
@@ -173,7 +173,7 @@ public void NewViewModel_DefaultsToFrontCamera_AndEmptyOverlay()
         vm.HasNoClipSelected.ShouldBeTrue();
         vm.ShowStatusOverlay.ShouldBeTrue();
         vm.ShowVideoHosts.ShouldBeFalse();
-        vm.PlayPauseIcon.ShouldBe(""); // Segoe Fluent Icons PlaySolid
+        vm.Playback.PlayPauseIcon.ShouldBe(""); // Segoe Fluent Icons PlaySolid
     }
 
     [Theory]
@@ -187,13 +187,13 @@ public void SelectCameraView_SetsSelectedViewAndLabel(string cameraView, string
     {
         var vm = CreateViewModel();
 
-        vm.SelectCameraViewCommand.Execute(cameraView);
+        vm.Cameras.SelectCameraViewCommand.Execute(cameraView);
 
         var expectedView = expectedLabel == "Front"
             ? CameraNames.Front
             : cameraView;
-        vm.SelectedCameraView.ShouldBe(expectedView);
-        vm.ActiveCameraLabel.ShouldBe(expectedLabel);
+        vm.Cameras.SelectedCameraView.ShouldBe(expectedView);
+        vm.Cameras.ActiveCameraLabel.ShouldBe(expectedLabel);
     }
 
     [Fact]
@@ -201,15 +201,15 @@ public void NewViewModel_OffersGridPlusClassicFourCameras()
     {
         var vm = CreateViewModel();
 
-        vm.CameraViewOptions.Select(option => option.ViewId).ShouldBe(
+        vm.Cameras.CameraViewOptions.Select(option => option.ViewId).ShouldBe(
             [
-                MainWindowViewModel.GridCameraView,
+                CameraViewsViewModel.GridCameraView,
                 CameraNames.Front,
                 CameraNames.Back,
                 CameraNames.LeftRepeater,
                 CameraNames.RightRepeater,
             ]);
-        vm.CameraViewOptions.Select(option => option.ShortcutNumber).ShouldBe([1, 2, 3, 4, 5]);
+        vm.Cameras.CameraViewOptions.Select(option => option.ShortcutNumber).ShouldBe([1, 2, 3, 4, 5]);
     }
 
     [Fact]
@@ -217,10 +217,10 @@ public void SelectCameraView_Grid_SetsGridFlags()
     {
         var vm = CreateViewModel();
 
-        vm.SelectCameraViewCommand.Execute("grid");
+        vm.Cameras.SelectCameraViewCommand.Execute("grid");
 
-        vm.IsGridViewSelected.ShouldBeTrue();
-        vm.IsSingleCameraViewSelected.ShouldBeFalse();
+        vm.Cameras.IsGridViewSelected.ShouldBeTrue();
+        vm.Cameras.IsSingleCameraViewSelected.ShouldBeFalse();
     }
 
     [Fact]
@@ -228,12 +228,12 @@ public void SelectCameraView_Rear_SetsSingleViewFlags_AndMarksItsTile()
     {
         var vm = CreateViewModel();
 
-        vm.SelectCameraViewCommand.Execute(CameraNames.Back);
+        vm.Cameras.SelectCameraViewCommand.Execute(CameraNames.Back);
 
-        vm.SelectedCameraView.ShouldBe(CameraNames.Back);
-        vm.IsGridViewSelected.ShouldBeFalse();
-        vm.IsSingleCameraViewSelected.ShouldBeTrue();
-        vm.CameraViewOptions.Single(option => option.IsSelected).ViewId.ShouldBe(CameraNames.Back);
+        vm.Cameras.SelectedCameraView.ShouldBe(CameraNames.Back);
+        vm.Cameras.IsGridViewSelected.ShouldBeFalse();
+        vm.Cameras.IsSingleCameraViewSelected.ShouldBeTrue();
+        vm.Cameras.CameraViewOptions.Single(option => option.IsSelected).ViewId.ShouldBe(CameraNames.Back);
     }
 
     [Fact]
@@ -241,11 +241,11 @@ public void SixCameraClip_OffersPillarTiles_InCanonicalOrder()
     {
         var vm = CreateViewModel();
 
-        vm.SelectedClip = ClipWithCameras(SixCameras);
+        vm.Library.SelectedClip = ClipWithCameras(SixCameras);
 
-        vm.CameraViewOptions.Select(option => option.ViewId).ShouldBe(
+        vm.Cameras.CameraViewOptions.Select(option => option.ViewId).ShouldBe(
             [
-                MainWindowViewModel.GridCameraView,
+                CameraViewsViewModel.GridCameraView,
                 CameraNames.Front,
                 CameraNames.Back,
                 CameraNames.LeftRepeater,
@@ -253,12 +253,12 @@ public void SixCameraClip_OffersPillarTiles_InCanonicalOrder()
                 CameraNames.LeftPillar,
                 CameraNames.RightPillar,
             ]);
-        vm.CameraViewOptions.Select(option => option.ShortcutNumber).ShouldBe([1, 2, 3, 4, 5, 6, 7]);
-        vm.CameraViewOptions.Last().Label.ShouldBe("Right Pillar");
+        vm.Cameras.CameraViewOptions.Select(option => option.ShortcutNumber).ShouldBe([1, 2, 3, 4, 5, 6, 7]);
+        vm.Cameras.CameraViewOptions.Last().Label.ShouldBe("Right Pillar");
 
-        vm.SelectCameraViewCommand.Execute(CameraNames.LeftPillar);
-        vm.SelectedCameraView.ShouldBe(CameraNames.LeftPillar);
-        vm.ActiveCameraLabel.ShouldBe("Left Pillar");
+        vm.Cameras.SelectCameraViewCommand.Execute(CameraNames.LeftPillar);
+        vm.Cameras.SelectedCameraView.ShouldBe(CameraNames.LeftPillar);
+        vm.Cameras.ActiveCameraLabel.ShouldBe("Left Pillar");
     }
 
     [Fact]
@@ -266,38 +266,38 @@ public void FourCameraClip_DoesNotOfferPillarTiles_AndPillarSelectionFallsBackTo
     {
         var vm = CreateViewModel();
 
-        vm.SelectedClip = ClipWithCameras(CameraNames.Front, CameraNames.Back, CameraNames.LeftRepeater, CameraNames.RightRepeater);
+        vm.Library.SelectedClip = ClipWithCameras(CameraNames.Front, CameraNames.Back, CameraNames.LeftRepeater, CameraNames.RightRepeater);
 
-        vm.CameraViewOptions.Count.ShouldBe(5);
-        vm.CameraViewOptions.ShouldAllBe(option => option.ViewId != CameraNames.LeftPillar);
+        vm.Cameras.CameraViewOptions.Count.ShouldBe(5);
+        vm.Cameras.CameraViewOptions.ShouldAllBe(option => option.ViewId != CameraNames.LeftPillar);
 
-        vm.SelectCameraViewCommand.Execute(CameraNames.LeftPillar);
-        vm.SelectedCameraView.ShouldBe(CameraNames.Front);
+        vm.Cameras.SelectCameraViewCommand.Execute(CameraNames.LeftPillar);
+        vm.Cameras.SelectedCameraView.ShouldBe(CameraNames.Front);
     }
 
     [Fact]
     public void SwitchingToClipWithoutTheWatchedCamera_FallsBackToFront()
     {
         var vm = CreateViewModel();
-        vm.SelectedClip = ClipWithCameras(SixCameras);
-        vm.SelectCameraViewCommand.Execute(CameraNames.RightPillar);
+        vm.Library.SelectedClip = ClipWithCameras(SixCameras);
+        vm.Cameras.SelectCameraViewCommand.Execute(CameraNames.RightPillar);
 
-        vm.SelectedClip = ClipWithCameras(CameraNames.Front, CameraNames.Back, CameraNames.LeftRepeater, CameraNames.RightRepeater);
+        vm.Library.SelectedClip = ClipWithCameras(CameraNames.Front, CameraNames.Back, CameraNames.LeftRepeater, CameraNames.RightRepeater);
 
-        vm.SelectedCameraView.ShouldBe(CameraNames.Front);
+        vm.Cameras.SelectedCameraView.ShouldBe(CameraNames.Front);
     }
 
     [Fact]
     public void SwitchingClips_KeepsTheWatchedCamera_WhenTheNewClipHasIt()
     {
         var vm = CreateViewModel();
-        vm.SelectedClip = ClipWithCameras(SixCameras);
-        vm.SelectCameraViewCommand.Execute(CameraNames.LeftPillar);
+        vm.Library.SelectedClip = ClipWithCameras(SixCameras);
+        vm.Cameras.SelectCameraViewCommand.Execute(CameraNames.LeftPillar);
 
-        vm.SelectedClip = ClipWithCameras(SixCameras);
+        vm.Library.SelectedClip = ClipWithCameras(SixCameras);
 
-        vm.SelectedCameraView.ShouldBe(CameraNames.LeftPillar);
-        vm.CameraViewOptions.Single(option => option.IsSelected).ViewId.ShouldBe(CameraNames.LeftPillar);
+        vm.Cameras.SelectedCameraView.ShouldBe(CameraNames.LeftPillar);
+        vm.Cameras.CameraViewOptions.Single(option => option.IsSelected).ViewId.ShouldBe(CameraNames.LeftPillar);
     }
 
     [Theory]
@@ -312,35 +312,35 @@ public void SwitchingClips_KeepsTheWatchedCamera_WhenTheNewClipHasIt()
     public void CameraIdToView_MapsDocumentedEventCameraIds(int cameraId, string expectedView)
     {
         var vm = CreateViewModel();
-        vm.SelectedClip = ClipWithCameras(SixCameras);
+        vm.Library.SelectedClip = ClipWithCameras(SixCameras);
 
-        vm.CameraIdToView(cameraId).ShouldBe(expectedView);
+        vm.Cameras.CameraIdToView(cameraId).ShouldBe(expectedView);
     }
 
     [Fact]
     public void CameraIdToView_FallsBackToFront_WhenTheClipLacksThatCamera()
     {
         var vm = CreateViewModel();
-        vm.SelectedClip = ClipWithCameras(CameraNames.Front, CameraNames.Back, CameraNames.LeftRepeater, CameraNames.RightRepeater);
+        vm.Library.SelectedClip = ClipWithCameras(CameraNames.Front, CameraNames.Back, CameraNames.LeftRepeater, CameraNames.RightRepeater);
 
-        vm.CameraIdToView(5).ShouldBe(CameraNames.Front);
-        vm.CameraIdToView(7).ShouldBe(CameraNames.Back);
+        vm.Cameras.CameraIdToView(5).ShouldBe(CameraNames.Front);
+        vm.Cameras.CameraIdToView(7).ShouldBe(CameraNames.Back);
     }
 
     [Fact]
     public async Task NumberKeys_SelectTilesByStripPosition_IncludingPillars()
     {
         var vm = CreateViewModel();
-        vm.SelectedClip = ClipWithCameras(SixCameras);
+        vm.Library.SelectedClip = ClipWithCameras(SixCameras);
 
         (await vm.HandleKeyDownAsync(Key.D6, ModifierKeys.None)).ShouldBeTrue();
-        vm.SelectedCameraView.ShouldBe(CameraNames.LeftPillar);
+        vm.Cameras.SelectedCameraView.ShouldBe(CameraNames.LeftPillar);
 
         (await vm.HandleKeyDownAsync(Key.NumPad7, ModifierKeys.None)).ShouldBeTrue();
-        vm.SelectedCameraView.ShouldBe(CameraNames.RightPillar);
+        vm.Cameras.SelectedCameraView.ShouldBe(CameraNames.RightPillar);
 
         (await vm.HandleKeyDownAsync(Key.D1, ModifierKeys.None)).ShouldBeTrue();
-        vm.SelectedCameraView.ShouldBe(MainWindowViewModel.GridCameraView);
+        vm.Cameras.SelectedCameraView.ShouldBe(CameraViewsViewModel.GridCameraView);
     }
 
     [Fact]
@@ -349,7 +349,7 @@ public async Task NumberKeys_BeyondTheStrip_AreNotHandled()
         var vm = CreateViewModel(); // classic strip: 5 tiles, so 6 has no target
 
         (await vm.HandleKeyDownAsync(Key.D6, ModifierKeys.None)).ShouldBeFalse();
-        vm.SelectedCameraView.ShouldBe(CameraNames.Front);
+        vm.Cameras.SelectedCameraView.ShouldBe(CameraNames.Front);
     }
 
     [Fact]
@@ -358,11 +358,11 @@ public void SelectCameraView_RaisesPropertyChangedForSelectedCameraView()
         // The view re-parents the Flyleaf hosts when SelectedCameraView changes, so this notification is part of the view/view-model contract.
         var vm = CreateViewModel();
         var changed = new List<string>();
-        vm.PropertyChanged += (_, e) => changed.Add(e.PropertyName);
+        vm.Cameras.PropertyChanged += (_, e) => changed.Add(e.PropertyName);
 
-        vm.SelectCameraViewCommand.Execute("grid");
+        vm.Cameras.SelectCameraViewCommand.Execute("grid");
 
-        changed.ShouldContain(nameof(MainWindowViewModel.SelectedCameraView));
+        changed.ShouldContain(nameof(CameraViewsViewModel.SelectedCameraView));
     }
 
     [Fact]
@@ -384,11 +384,10 @@ public void Loading_ShowsStatusOverlay_AndHidesVideo()
     {
         var vm = CreateViewModel();
 
-        vm.IsLoading = true;
+        vm.Playback.IsLoading = true;
 
         vm.ShowStatusOverlay.ShouldBeTrue();
         vm.ShowVideoHosts.ShouldBeFalse();
-        vm.IsIndeterminateProgress.ShouldBeTrue();
     }
 
     [Fact]
@@ -396,7 +395,7 @@ public void Error_ShowsStatusOverlay_AndReportsError()
     {
         var vm = CreateViewModel();
 
-        vm.ShowErrorOverlay = true;
+        vm.Error.IsVisible = true;
 
         vm.HasError.ShouldBeTrue();
         vm.ShowStatusOverlay.ShouldBeTrue();
@@ -409,7 +408,7 @@ public void SelectingClip_HidesOverlay_AndShowsVideo()
     {
         var vm = CreateViewModel();
 
-        vm.SelectedClip = TestClips.Create(1)[0];
+        vm.Library.SelectedClip = TestClips.Create(1)[0];
 
         vm.HasNoClipSelected.ShouldBeFalse();
         vm.ShowStatusOverlay.ShouldBeFalse();
@@ -420,33 +419,33 @@ public void SelectingClip_HidesOverlay_AndShowsVideo()
     public void CanPlayPause_RequiresClipOrPlayback_AndNotLoading()
     {
         var vm = CreateViewModel();
-        vm.CanPlayPause.ShouldBeFalse();
+        vm.Playback.CanPlayPause.ShouldBeFalse();
 
-        vm.SelectedClip = TestClips.Create(1)[0];
-        vm.CanPlayPause.ShouldBeTrue();
+        vm.Library.SelectedClip = TestClips.Create(1)[0];
+        vm.Playback.CanPlayPause.ShouldBeTrue();
 
-        vm.IsLoading = true;
-        vm.CanPlayPause.ShouldBeFalse();
+        vm.Playback.IsLoading = true;
+        vm.Playback.CanPlayPause.ShouldBeFalse();
 
         // Even with no selected clip, an in-flight playback keeps the toggle live.
-        vm.IsLoading = false;
-        vm.SelectedClip = null;
-        vm.IsPlaying = true;
-        vm.CanPlayPause.ShouldBeTrue();
+        vm.Playback.IsLoading = false;
+        vm.Library.SelectedClip = null;
+        vm.Playback.IsPlaying = true;
+        vm.Playback.CanPlayPause.ShouldBeTrue();
     }
 
     [Fact]
     public void CanStop_WhenPlayingOrLoading()
     {
         var vm = CreateViewModel();
-        vm.CanStop.ShouldBeFalse();
+        vm.Playback.CanStop.ShouldBeFalse();
 
-        vm.IsPlaying = true;
-        vm.CanStop.ShouldBeTrue();
+        vm.Playback.IsPlaying = true;
+        vm.Playback.CanStop.ShouldBeTrue();
 
-        vm.IsPlaying = false;
-        vm.IsLoading = true;
-        vm.CanStop.ShouldBeTrue();
+        vm.Playback.IsPlaying = false;
+        vm.Playback.IsLoading = true;
+        vm.Playback.CanStop.ShouldBeTrue();
     }
 
     [Theory]
@@ -456,27 +455,9 @@ public void PlayPauseIcon_ReflectsPlaybackState(bool isPlaying, string expectedI
     {
         var vm = CreateViewModel();
 
-        vm.IsPlaying = isPlaying;
+        vm.Playback.IsPlaying = isPlaying;
 
-        vm.PlayPauseIcon.ShouldBe(expectedIcon);
-    }
-
-    [Fact]
-    public void LoadingStatusText_ShowsRenderProgressWhileRendering()
-    {
-        var vm = CreateViewModel();
-        vm.IsLoading = true;
-
-        vm.LoadingStatusText.ShouldBe("Loading...");
-        vm.IsIndeterminateProgress.ShouldBeTrue();
-
-        vm.IsRendering = true;
-        vm.RenderProgress = 0.5;
-
-        vm.RenderProgressPercent.ShouldBe(50);
-        vm.LoadingStatusText.ShouldBe("Rendering... 50%");
-        // A determinate render progress bar replaces the indeterminate spinner.
-        vm.IsIndeterminateProgress.ShouldBeFalse();
+        vm.Playback.PlayPauseIcon.ShouldBe(expectedIcon);
     }
 
     [Fact]
@@ -484,12 +465,12 @@ public void UpdateBadge_DefaultsToUpToDate()
     {
         var vm = CreateViewModel();
 
-        vm.IsUpdateAvailable.ShouldBeFalse();
-        vm.HasUpdateBadge.ShouldBeFalse();
-        vm.UpdateStatusTitle.ShouldBe("You're up to date");
-        vm.UpdateStatusDetails.ShouldBe("No newer release was found.");
-        vm.LatestVersionText.ShouldBe("Unknown");
-        vm.LatestReleaseUrl.ShouldBe(UpdateService.ReleasesPageUrl);
+        vm.About.IsUpdateAvailable.ShouldBeFalse();
+        vm.About.HasUpdateBadge.ShouldBeFalse();
+        vm.About.UpdateStatusTitle.ShouldBe("You're up to date");
+        vm.About.UpdateStatusDetails.ShouldBe("No newer release was found.");
+        vm.About.LatestVersionText.ShouldBe("Unknown");
+        vm.About.LatestReleaseUrl.ShouldBe(UpdateService.ReleasesPageUrl);
     }
 
     [Fact]
@@ -497,14 +478,14 @@ public void UpdateBadge_ReflectsAvailableRelease()
     {
         var vm = CreateViewModel();
 
-        vm.LatestRelease = new UpdateRelease(new Version(1, 4, 2), "v1.4.2", "https://example.com/releases/1.4.2");
-        vm.IsUpdateAvailable = true;
+        vm.About.LatestRelease = new UpdateRelease(new Version(1, 4, 2), "v1.4.2", "https://example.com/releases/1.4.2");
+        vm.About.IsUpdateAvailable = true;
 
-        vm.HasUpdateBadge.ShouldBeTrue();
-        vm.UpdateStatusTitle.ShouldBe("Update available");
-        vm.LatestVersionText.ShouldBe("1.4.2");
-        vm.UpdateStatusDetails.ShouldBe("Version 1.4.2 is available.");
-        vm.LatestReleaseUrl.ShouldBe("https://example.com/releases/1.4.2");
+        vm.About.HasUpdateBadge.ShouldBeTrue();
+        vm.About.UpdateStatusTitle.ShouldBe("Update available");
+        vm.About.LatestVersionText.ShouldBe("1.4.2");
+        vm.About.UpdateStatusDetails.ShouldBe("Version 1.4.2 is available.");
+        vm.About.LatestReleaseUrl.ShouldBe("https://example.com/releases/1.4.2");
     }
 
     [Theory]
@@ -533,13 +514,13 @@ public async Task AboutPage_SwallowsPlayerShortcuts(Key key, ModifierKeys modifi
     {
         var vm = CreateViewModel();
         vm.ShowAboutPage = true;
-        var cameraViewBefore = vm.SelectedCameraView;
+        var cameraViewBefore = vm.Cameras.SelectedCameraView;
 
         var handled = await vm.HandleKeyDownAsync(key, modifiers);
 
         handled.ShouldBeFalse();
-        vm.SelectedCameraView.ShouldBe(cameraViewBefore); // no camera switch behind the About page
-        vm.IsTrimming.ShouldBeFalse();
+        vm.Cameras.SelectedCameraView.ShouldBe(cameraViewBefore); // no camera switch behind the About page
+        vm.Trim.IsTrimming.ShouldBeFalse();
         vm.ShowAboutPage.ShouldBeTrue(); // the page stays open
     }
 
@@ -560,18 +541,18 @@ public async Task UnhandledKeys_WithoutPlayer_ReturnFalse(Key key, ModifierKeys
     public void DismissError_ClearsErrorState()
     {
         var vm = CreateViewModel();
-        vm.ShowErrorOverlay = true;
-        vm.ShowFFmpegDownloadButton = true;
-        vm.CanDismissError = false;
-        vm.ErrorTitle = "Boom";
-        vm.ErrorDetails = "Something went wrong";
-
-        vm.DismissErrorCommand.Execute(null);
-
-        vm.ShowErrorOverlay.ShouldBeFalse();
-        vm.ShowFFmpegDownloadButton.ShouldBeFalse();
-        vm.CanDismissError.ShouldBeTrue();
-        vm.ErrorTitle.ShouldBeNull();
-        vm.ErrorDetails.ShouldBeNull();
+        vm.Error.IsVisible = true;
+        vm.Error.ShowFFmpegDownloadButton = true;
+        vm.Error.CanDismiss = false;
+        vm.Error.Title = "Boom";
+        vm.Error.Details = "Something went wrong";
+
+        vm.Error.DismissCommand.Execute(null);
+
+        vm.Error.IsVisible.ShouldBeFalse();
+        vm.Error.ShowFFmpegDownloadButton.ShouldBeFalse();
+        vm.Error.CanDismiss.ShouldBeTrue();
+        vm.Error.Title.ShouldBeNull();
+        vm.Error.Details.ShouldBeNull();
     }
 }
diff --git a/SentryDeck/CameraViewOption.cs b/SentryDeck/CameraViewOption.cs
index 6fab8e9..0e06087 100644
--- a/SentryDeck/CameraViewOption.cs
+++ b/SentryDeck/CameraViewOption.cs
@@ -16,7 +16,7 @@ public CameraViewOption(string viewId, string label, int shortcutNumber, bool is
     }
 
     /// <summary>
-    /// <see cref="MainWindowViewModel.GridCameraView"/> or a canonical <see cref="CameraNames"/> name.
+    /// <see cref="CameraViewsViewModel.GridCameraView"/> or a canonical <see cref="CameraNames"/> name.
     /// </summary>
     public string ViewId { get; }
 
diff --git a/SentryDeck/MainWindow.xaml b/SentryDeck/MainWindow.xaml
index d36c960..bdfdbdb 100644
--- a/SentryDeck/MainWindow.xaml
+++ b/SentryDeck/MainWindow.xaml
@@ -75,10 +75,10 @@
                                     CornerRadius="2"
                                     IsHitTestVisible="False"
                                     Opacity="0.3"
-                                    Visibility="{Binding Data.HasSelection, Converter={local:BoolToVisibilityConverter}, Source={StaticResource VmProxy}}">
+                                    Visibility="{Binding Data.Trim.HasSelection, Converter={local:BoolToVisibilityConverter}, Source={StaticResource VmProxy}}">
                                 <Border.Margin>
                                     <MultiBinding Converter="{local:SeekOffsetConverter}">
-                                        <Binding Path="Data.SelectionStartPosition"
+                                        <Binding Path="Data.Trim.SelectionStartPosition"
                                                  Source="{StaticResource VmProxy}" />
                                         <Binding ElementName="SeekRail"
                                                  Path="ActualWidth" />
@@ -86,9 +86,9 @@
                                 </Border.Margin>
                                 <Border.Width>
                                     <MultiBinding Converter="{local:SelectionWidthConverter}">
-                                        <Binding Path="Data.SelectionStartPosition"
+                                        <Binding Path="Data.Trim.SelectionStartPosition"
                                                  Source="{StaticResource VmProxy}" />
-                                        <Binding Path="Data.SelectionEndPosition"
+                                        <Binding Path="Data.Trim.SelectionEndPosition"
                                                  Source="{StaticResource VmProxy}" />
                                         <Binding ElementName="SeekRail"
                                                  Path="ActualWidth" />
@@ -104,10 +104,10 @@
                                        IsHitTestVisible="False"
                                        RadiusX="1"
                                        RadiusY="1"
-                                       Visibility="{Binding Data.HasSelectionStart, Converter={local:BoolToVisibilityConverter}, Source={StaticResource VmProxy}}">
+                                       Visibility="{Binding Data.Trim.HasSelectionStart, Converter={local:BoolToVisibilityConverter}, Source={StaticResource VmProxy}}">
                                 <Rectangle.Margin>
                                     <MultiBinding Converter="{local:SeekOffsetConverter}">
-                                        <Binding Path="Data.SelectionStartPosition"
+                                        <Binding Path="Data.Trim.SelectionStartPosition"
                                                  Source="{StaticResource VmProxy}" />
                                         <Binding ElementName="SeekRail"
                                                  Path="ActualWidth" />
@@ -123,10 +123,10 @@
                                        IsHitTestVisible="False"
                                        RadiusX="1"
                                        RadiusY="1"
-                                       Visibility="{Binding Data.HasSelectionEnd, Converter={local:BoolToVisibilityConverter}, Source={StaticResource VmProxy}}">
+                                       Visibility="{Binding Data.Trim.HasSelectionEnd, Converter={local:BoolToVisibilityConverter}, Source={StaticResource VmProxy}}">
                                 <Rectangle.Margin>
                                     <MultiBinding Converter="{local:SeekOffsetConverter}">
-                                        <Binding Path="Data.SelectionEndPosition"
+                                        <Binding Path="Data.Trim.SelectionEndPosition"
                                                  Source="{StaticResource VmProxy}" />
                                         <Binding ElementName="SeekRail"
                                                  Path="ActualWidth" />
@@ -141,7 +141,7 @@
                             -->
                             <ItemsControl Focusable="False"
                                           IsHitTestVisible="False"
-                                          ItemsSource="{Binding Data.ChunkBoundaries, Source={StaticResource VmProxy}}">
+                                          ItemsSource="{Binding Data.Playback.ChunkBoundaries, Source={StaticResource VmProxy}}">
                                 <ItemsControl.ItemsPanel>
                                     <ItemsPanelTemplate>
                                         <Grid />
@@ -177,7 +177,7 @@
                             -->
                             <ItemsControl Focusable="False"
                                           IsHitTestVisible="False"
-                                          ItemsSource="{Binding Data.GapPositions, Source={StaticResource VmProxy}}">
+                                          ItemsSource="{Binding Data.Playback.GapPositions, Source={StaticResource VmProxy}}">
                                 <ItemsControl.ItemsPanel>
                                     <ItemsPanelTemplate>
                                         <Grid />
@@ -210,26 +210,26 @@
                                     VerticalAlignment="Center"
                                     CornerRadius="1.5"
                                     IsHitTestVisible="False"
-                                    ToolTip="{Binding Data.EventMarkerTooltip, Source={StaticResource VmProxy}}"
-                                    Visibility="{Binding Data.HasEventMarker, Converter={local:BoolToVisibilityConverter}, Source={StaticResource VmProxy}}">
+                                    ToolTip="{Binding Data.Playback.EventMarkerTooltip, Source={StaticResource VmProxy}}"
+                                    Visibility="{Binding Data.Playback.HasEventMarker, Converter={local:BoolToVisibilityConverter}, Source={StaticResource VmProxy}}">
                                 <Border.Style>
                                     <!--  Reason color via DynamicResource (keyed by ReasonKey) so the marker re-colors on a live OS theme switch.  -->
                                     <Style TargetType="Border">
                                         <Setter Property="Background" Value="{DynamicResource TextFillColorTertiaryBrush}" />
                                         <Style.Triggers>
-                                            <DataTrigger Binding="{Binding Data.SelectedClip.Event, Converter={local:ReasonKeyConverter}, Source={StaticResource VmProxy}}"
+                                            <DataTrigger Binding="{Binding Data.Library.SelectedClip.Event, Converter={local:ReasonKeyConverter}, Source={StaticResource VmProxy}}"
                                                          Value="sentry">
                                                 <Setter Property="Background" Value="{DynamicResource SystemFillColorAttentionBrush}" />
                                             </DataTrigger>
-                                            <DataTrigger Binding="{Binding Data.SelectedClip.Event, Converter={local:ReasonKeyConverter}, Source={StaticResource VmProxy}}"
+                                            <DataTrigger Binding="{Binding Data.Library.SelectedClip.Event, Converter={local:ReasonKeyConverter}, Source={StaticResource VmProxy}}"
                                                          Value="honk">
                                                 <Setter Property="Background" Value="{DynamicResource SystemFillColorCautionBrush}" />
                                             </DataTrigger>
-                                            <DataTrigger Binding="{Binding Data.SelectedClip.Event, Converter={local:ReasonKeyConverter}, Source={StaticResource VmProxy}}"
+                                            <DataTrigger Binding="{Binding Data.Library.SelectedClip.Event, Converter={local:ReasonKeyConverter}, Source={StaticResource VmProxy}}"
                                                          Value="alert">
                                                 <Setter Property="Background" Value="{DynamicResource SystemFillColorCriticalBrush}" />
                                             </DataTrigger>
-                                            <DataTrigger Binding="{Binding Data.SelectedClip.Event, Converter={local:ReasonKeyConverter}, Source={StaticResource VmProxy}}"
+                                            <DataTrigger Binding="{Binding Data.Library.SelectedClip.Event, Converter={local:ReasonKeyConverter}, Source={StaticResource VmProxy}}"
                                                          Value="saved">
                                                 <Setter Property="Background" Value="{DynamicResource AccentFillColorDefaultBrush}" />
                                             </DataTrigger>
@@ -238,7 +238,7 @@
                                 </Border.Style>
                                 <Border.Margin>
                                     <MultiBinding Converter="{local:SeekOffsetConverter}">
-                                        <Binding Path="Data.EventMarkerPosition"
+                                        <Binding Path="Data.Playback.EventMarkerPosition"
                                                  Source="{StaticResource VmProxy}" />
                                         <Binding ElementName="SeekRail"
                                                  Path="ActualWidth" />
@@ -480,7 +480,7 @@
 
         <!--  Day-grouped clip view; grouping lives in XAML via the shared VmProxy above.  -->
         <CollectionViewSource x:Key="GroupedClips"
-                              Source="{Binding Data.FilteredClips, Source={StaticResource VmProxy}}">
+                              Source="{Binding Data.Library.FilteredClips, Source={StaticResource VmProxy}}">
             <CollectionViewSource.GroupDescriptions>
                 <PropertyGroupDescription Converter="{local:DateOnlyConverter}"
                                           PropertyName="Timestamp" />
@@ -490,14 +490,14 @@
         <!--  Shared clip context menu (Tag on the item = the view-model).  -->
         <ContextMenu x:Key="ClipContextMenu">
             <MenuItem Header="Open clip folder"
-                      Command="{Binding PlacementTarget.Tag.OpenClipFolderCommand, RelativeSource={RelativeSource AncestorType=ContextMenu}}"
+                      Command="{Binding PlacementTarget.Tag.Library.OpenClipFolderCommand, RelativeSource={RelativeSource AncestorType=ContextMenu}}"
                       CommandParameter="{Binding PlacementTarget.DataContext, RelativeSource={RelativeSource AncestorType=ContextMenu}}">
                 <MenuItem.Icon>
                     <TextBlock Text="&#xE8B7;" Style="{StaticResource AppGlyph}" />
                 </MenuItem.Icon>
             </MenuItem>
             <MenuItem Header="Show on map"
-                      Command="{Binding PlacementTarget.Tag.ShowOnMapCommand, RelativeSource={RelativeSource AncestorType=ContextMenu}}"
+                      Command="{Binding PlacementTarget.Tag.Library.ShowOnMapCommand, RelativeSource={RelativeSource AncestorType=ContextMenu}}"
                       CommandParameter="{Binding PlacementTarget.DataContext, RelativeSource={RelativeSource AncestorType=ContextMenu}}">
                 <MenuItem.Icon>
                     <TextBlock Text="&#xECAF;" Style="{StaticResource AppGlyph}" />
@@ -505,7 +505,7 @@
             </MenuItem>
             <!--  ±30s of front-camera footage around the event moment, stream-copied (no re-encode).  -->
             <MenuItem Header="Save event clip…"
-                      Command="{Binding PlacementTarget.Tag.SaveEventClipCommand, RelativeSource={RelativeSource AncestorType=ContextMenu}}"
+                      Command="{Binding PlacementTarget.Tag.Trim.SaveEventClipCommand, RelativeSource={RelativeSource AncestorType=ContextMenu}}"
                       CommandParameter="{Binding PlacementTarget.DataContext, RelativeSource={RelativeSource AncestorType=ContextMenu}}">
                 <MenuItem.Icon>
                     <TextBlock Text="&#xE792;" Style="{StaticResource AppGlyph}" />
@@ -513,21 +513,21 @@
             </MenuItem>
             <Separator />
             <MenuItem Header="Copy clip name"
-                      Command="{Binding PlacementTarget.Tag.CopyClipNameCommand, RelativeSource={RelativeSource AncestorType=ContextMenu}}"
+                      Command="{Binding PlacementTarget.Tag.Library.CopyClipNameCommand, RelativeSource={RelativeSource AncestorType=ContextMenu}}"
                       CommandParameter="{Binding PlacementTarget.DataContext, RelativeSource={RelativeSource AncestorType=ContextMenu}}">
                 <MenuItem.Icon>
                     <TextBlock Text="&#xE8C8;" Style="{StaticResource AppGlyph}" />
                 </MenuItem.Icon>
             </MenuItem>
             <MenuItem Header="Copy timestamp"
-                      Command="{Binding PlacementTarget.Tag.CopyTimestampCommand, RelativeSource={RelativeSource AncestorType=ContextMenu}}"
+                      Command="{Binding PlacementTarget.Tag.Library.CopyTimestampCommand, RelativeSource={RelativeSource AncestorType=ContextMenu}}"
                       CommandParameter="{Binding PlacementTarget.DataContext, RelativeSource={RelativeSource AncestorType=ContextMenu}}">
                 <MenuItem.Icon>
                     <TextBlock Text="&#xE8C8;" Style="{StaticResource AppGlyph}" />
                 </MenuItem.Icon>
             </MenuItem>
             <MenuItem Header="Copy folder path"
-                      Command="{Binding PlacementTarget.Tag.CopyClipPathCommand, RelativeSource={RelativeSource AncestorType=ContextMenu}}"
+                      Command="{Binding PlacementTarget.Tag.Library.CopyClipPathCommand, RelativeSource={RelativeSource AncestorType=ContextMenu}}"
                       CommandParameter="{Binding PlacementTarget.DataContext, RelativeSource={RelativeSource AncestorType=ContextMenu}}">
                 <MenuItem.Icon>
                     <TextBlock Text="&#xE8C8;" Style="{StaticResource AppGlyph}" />
@@ -536,7 +536,7 @@
             <Separator />
             <!--  Moves the whole clip folder to the Windows Recycle Bin (recoverable) so the timeline can be tidied in place.  -->
             <MenuItem Header="Delete to Recycle Bin"
-                      Command="{Binding PlacementTarget.Tag.DeleteClipCommand, RelativeSource={RelativeSource AncestorType=ContextMenu}}"
+                      Command="{Binding PlacementTarget.Tag.Library.DeleteClipCommand, RelativeSource={RelativeSource AncestorType=ContextMenu}}"
                       CommandParameter="{Binding PlacementTarget.DataContext, RelativeSource={RelativeSource AncestorType=ContextMenu}}">
                 <MenuItem.Icon>
                     <TextBlock Text="&#xE74D;" Style="{StaticResource AppGlyph}" />
@@ -607,7 +607,7 @@
 
                         <Grid Grid.Column="1">
                             <TextBox x:Name="SearchBox"
-                                     Text="{Binding FilterText, UpdateSourceTrigger=PropertyChanged}"
+                                     Text="{Binding Library.FilterText, UpdateSourceTrigger=PropertyChanged}"
                                      Padding="10,8,8,8"
                                      VerticalContentAlignment="Center"
                                      FontSize="14"
@@ -625,7 +625,7 @@
                                     <Style TargetType="TextBlock">
                                         <Setter Property="Visibility" Value="Hidden" />
                                         <Style.Triggers>
-                                            <DataTrigger Binding="{Binding FilterText}"
+                                            <DataTrigger Binding="{Binding Library.FilterText}"
                                                          Value="">
                                                 <Setter Property="Visibility" Value="Visible" />
                                             </DataTrigger>
@@ -649,7 +649,7 @@
                          PreviewMouseLeftButtonUp="ClipListBox_PreviewMouseLeftButtonUp"
                          PreviewMouseRightButtonDown="ClipListBox_PreviewMouseRightButtonDown"
                          ScrollViewer.HorizontalScrollBarVisibility="Disabled"
-                         SelectedItem="{Binding SelectedClip, Mode=TwoWay}"
+                         SelectedItem="{Binding Library.SelectedClip, Mode=TwoWay}"
                          VirtualizingPanel.IsVirtualizingWhenGrouping="True"
                          VirtualizingPanel.VirtualizationMode="Recycling">
                     <ListBox.GroupStyle>
@@ -768,7 +768,7 @@
                                             <Border.Visibility>
                                                 <MultiBinding Converter="{local:NowPlayingConverter}">
                                                     <Binding />
-                                                    <Binding Path="Data.NowPlayingClip"
+                                                    <Binding Path="Data.Playback.NowPlayingClip"
                                                              Source="{StaticResource VmProxy}" />
                                                 </MultiBinding>
                                             </Border.Visibility>
@@ -862,9 +862,9 @@
                             <Style.Triggers>
                                 <MultiDataTrigger>
                                     <MultiDataTrigger.Conditions>
-                                        <Condition Binding="{Binding ClipCount}" Value="0" />
-                                        <Condition Binding="{Binding IsLoadingClips}" Value="False" />
-                                        <Condition Binding="{Binding HasFilterText}" Value="True" />
+                                        <Condition Binding="{Binding Library.ClipCount}" Value="0" />
+                                        <Condition Binding="{Binding Library.IsLoadingClips}" Value="False" />
+                                        <Condition Binding="{Binding Library.HasFilterText}" Value="True" />
                                     </MultiDataTrigger.Conditions>
                                     <Setter Property="Visibility" Value="Visible" />
                                 </MultiDataTrigger>
@@ -893,7 +893,7 @@
                              Background="Transparent"
                              BorderThickness="0"
                              IsIndeterminate="True"
-                             Visibility="{Binding IsLoadingClips, Converter={local:BoolToVisibilityConverter}}" />
+                             Visibility="{Binding Library.IsLoadingClips, Converter={local:BoolToVisibilityConverter}}" />
 
                 <!--  Utility action bar (single row, divided from the list)  -->
                 <Border Grid.Row="2"
@@ -910,7 +910,7 @@
                         </Grid.ColumnDefinitions>
 
                         <Button Grid.Column="0"
-                                Command="{Binding OpenFolderCommand}"
+                                Command="{Binding Library.OpenFolderCommand}"
                                 HorizontalContentAlignment="Left"
                                 AutomationProperties.Name="Select folder"
                                 Style="{StaticResource PressScaleButton}">
@@ -924,7 +924,7 @@
                         </Button>
 
                         <Button Grid.Column="2"
-                                Command="{Binding RefreshClipsCommand}"
+                                Command="{Binding Library.RefreshClipsCommand}"
                                 AutomationProperties.Name="Rescan folder"
                                 Style="{StaticResource SubtleIconButton}"
                                 ToolTip="Rescan the current folder for clips">
@@ -949,7 +949,7 @@
                                     CornerRadius="4"
                                     IsHitTestVisible="False"
                                     ToolTip="Update available"
-                                    Visibility="{Binding HasUpdateBadge, Converter={local:BoolToVisibilityConverter}}" />
+                                    Visibility="{Binding About.HasUpdateBadge, Converter={local:BoolToVisibilityConverter}}" />
                         </Grid>
                     </Grid>
                 </Border>
@@ -1010,7 +1010,7 @@
                                 CornerRadius="6"
                                 Focusable="True">
                             <Grid>
-                                <Grid Visibility="{Binding IsGridViewSelected, Converter={local:BoolToVisibilityConverter}}">
+                                <Grid Visibility="{Binding Cameras.IsGridViewSelected, Converter={local:BoolToVisibilityConverter}}">
                                     <Grid.RowDefinitions>
                                         <RowDefinition Height="*" />
                                         <RowDefinition Height="*" />
@@ -1101,7 +1101,7 @@
                                     </Border>
                                 </Grid>
 
-                                <Grid Visibility="{Binding IsSingleCameraViewSelected, Converter={local:BoolToVisibilityConverter}}">
+                                <Grid Visibility="{Binding Cameras.IsSingleCameraViewSelected, Converter={local:BoolToVisibilityConverter}}">
                                     <ContentControl x:Name="PrimaryCameraHostSlot" />
                                     <Border Margin="14"
                                             Padding="10,4"
@@ -1109,7 +1109,7 @@
                                             VerticalAlignment="Top"
                                             Background="#A0000000"
                                             CornerRadius="4">
-                                        <TextBlock Text="{Binding ActiveCameraLabel}"
+                                        <TextBlock Text="{Binding Cameras.ActiveCameraLabel}"
                                                    FontSize="13"
                                                    FontWeight="SemiBold"
                                                    Foreground="White" />
@@ -1127,7 +1127,7 @@
                                 CornerRadius="8">
                             <!--  One tile per view the current clip offers: the grid plus each recorded camera (four on HW3, six on HW4/AI4).
                                   Camera tiles carry a preview slot that registers itself with the code-behind (CameraTileSlot_Loaded), which re-parents each camera's Flyleaf host into it.  -->
-                            <ItemsControl ItemsSource="{Binding CameraViewOptions}">
+                            <ItemsControl ItemsSource="{Binding Cameras.CameraViewOptions}">
                                 <ItemsControl.ItemsPanel>
                                     <ItemsPanelTemplate>
                                         <UniformGrid Rows="1" />
@@ -1135,7 +1135,7 @@
                                 </ItemsControl.ItemsPanel>
                                 <ItemsControl.ItemTemplate>
                                     <DataTemplate DataType="{x:Type local:CameraViewOption}">
-                                        <RadioButton Command="{Binding DataContext.SelectCameraViewCommand, RelativeSource={RelativeSource AncestorType=ItemsControl}}"
+                                        <RadioButton Command="{Binding DataContext.Cameras.SelectCameraViewCommand, RelativeSource={RelativeSource AncestorType=ItemsControl}}"
                                                      CommandParameter="{Binding ViewId}"
                                                      AutomationProperties.Name="{Binding AutomationName}"
                                                      GroupName="CameraViewMode"
@@ -1236,20 +1236,18 @@
 
                             <!--  Loading / rendering status  -->
                             <StackPanel Visibility="{Binding IsLoading, Converter={local:BoolToVisibilityConverter}}">
-                                <TextBlock Text="{Binding LoadingStatusText}"
+                                <TextBlock Text="Loading..."
                                            Margin="0,0,0,16"
                                            HorizontalAlignment="Center"
                                            Foreground="{DynamicResource TextFillColorPrimaryBrush}"
                                            Style="{StaticResource AppSubtitle}" />
                                 <ProgressBar Width="300"
                                              Height="6"
-                                             IsIndeterminate="{Binding IsIndeterminateProgress}"
-                                             Maximum="100"
-                                             Value="{Binding RenderProgressPercent, Mode=OneWay}" />
+                                             IsIndeterminate="True" />
                             </StackPanel>
 
                             <!--  Error / first-run empty state  -->
-                            <StackPanel Visibility="{Binding ShowErrorOverlay, Converter={local:BoolToVisibilityConverter}}">
+                            <StackPanel Visibility="{Binding Error.IsVisible, Converter={local:BoolToVisibilityConverter}}">
                                 <Border Width="64"
                                         Height="64"
                                         Margin="0,0,0,16"
@@ -1259,7 +1257,7 @@
                                         <Style TargetType="Border">
                                             <Setter Property="Background" Value="{DynamicResource SystemFillColorCriticalBackgroundBrush}" />
                                             <Style.Triggers>
-                                                <DataTrigger Binding="{Binding IsEmptyState}"
+                                                <DataTrigger Binding="{Binding Error.IsEmptyState}"
                                                              Value="True">
                                                     <Setter Property="Background" Value="{DynamicResource SubtleFillColorSecondaryBrush}" />
                                                 </DataTrigger>
@@ -1273,7 +1271,7 @@
                                                 <Setter Property="Text" Value="&#xE783;" />
                                                 <Setter Property="Foreground" Value="{DynamicResource SystemFillColorCriticalBrush}" />
                                                 <Style.Triggers>
-                                                    <DataTrigger Binding="{Binding IsEmptyState}"
+                                                    <DataTrigger Binding="{Binding Error.IsEmptyState}"
                                                                  Value="True">
                                                         <Setter Property="Text" Value="&#xE8B7;" />
                                                         <Setter Property="Foreground" Value="{DynamicResource TextFillColorSecondaryBrush}" />
@@ -1283,7 +1281,7 @@
                                         </TextBlock.Style>
                                     </TextBlock>
                                 </Border>
-                                <TextBlock Text="{Binding ErrorTitle}"
+                                <TextBlock Text="{Binding Error.Title}"
                                            Margin="0,0,0,8"
                                            HorizontalAlignment="Center"
                                            TextAlignment="Center">
@@ -1292,7 +1290,7 @@
                                                BasedOn="{StaticResource AppSubtitle}">
                                             <Setter Property="Foreground" Value="{DynamicResource SystemFillColorCriticalBrush}" />
                                             <Style.Triggers>
-                                                <DataTrigger Binding="{Binding IsEmptyState}"
+                                                <DataTrigger Binding="{Binding Error.IsEmptyState}"
                                                              Value="True">
                                                     <Setter Property="Foreground" Value="{DynamicResource TextFillColorPrimaryBrush}" />
                                                 </DataTrigger>
@@ -1300,7 +1298,7 @@
                                         </Style>
                                     </TextBlock.Style>
                                 </TextBlock>
-                                <TextBlock Text="{Binding ErrorDetails}"
+                                <TextBlock Text="{Binding Error.Details}"
                                            MaxWidth="380"
                                            HorizontalAlignment="Center"
                                            Foreground="{DynamicResource TextFillColorSecondaryBrush}"
@@ -1308,26 +1306,26 @@
                                            TextAlignment="Center"
                                            TextWrapping="Wrap" />
                                 <Button Content="Select folder"
-                                        Command="{Binding OpenFolderCommand}"
+                                        Command="{Binding Library.OpenFolderCommand}"
                                         Margin="0,20,0,0"
                                         Padding="24,8"
                                         HorizontalAlignment="Center"
                                         Style="{StaticResource AccentButtonStyle}"
-                                        Visibility="{Binding IsEmptyState, Converter={local:BoolToVisibilityConverter}}" />
+                                        Visibility="{Binding Error.IsEmptyState, Converter={local:BoolToVisibilityConverter}}" />
                                 <Button Content="Download FFmpeg"
                                         Command="{Binding DownloadFFmpegCommand}"
                                         Margin="0,20,0,0"
                                         Padding="24,8"
                                         HorizontalAlignment="Center"
                                         Style="{StaticResource AccentButtonStyle}"
-                                        Visibility="{Binding ShowFFmpegDownloadButton, Converter={local:BoolToVisibilityConverter}}" />
+                                        Visibility="{Binding Error.ShowFFmpegDownloadButton, Converter={local:BoolToVisibilityConverter}}" />
                                 <Button Content="Dismiss"
-                                        Command="{Binding DismissErrorCommand}"
+                                        Command="{Binding Error.DismissCommand}"
                                         Margin="0,12,0,0"
                                         Padding="24,8"
                                         HorizontalAlignment="Center"
                                         Style="{StaticResource DefaultButtonStyle}"
-                                        Visibility="{Binding CanDismissError, Converter={local:BoolToVisibilityConverter}}" />
+                                        Visibility="{Binding Error.CanDismiss, Converter={local:BoolToVisibilityConverter}}" />
                             </StackPanel>
                         </StackPanel>
                     </Border>
@@ -1343,7 +1341,7 @@
                             Background="{DynamicResource LayerFillColorDefaultBrush}"
                             BorderBrush="{DynamicResource DividerStrokeColorDefaultBrush}"
                             BorderThickness="0,1,0,1"
-                            Visibility="{Binding IsTrimming, Converter={local:BoolToVisibilityConverter}}">
+                            Visibility="{Binding Trim.IsTrimming, Converter={local:BoolToVisibilityConverter}}">
                         <Grid>
                             <Grid.ColumnDefinitions>
                                 <ColumnDefinition Width="Auto" />
@@ -1369,7 +1367,7 @@
                             </StackPanel>
 
                             <Button Grid.Column="1"
-                                    Command="{Binding MarkSelectionStartCommand}"
+                                    Command="{Binding Trim.MarkSelectionStartCommand}"
                                     VerticalAlignment="Center"
                                     AutomationProperties.Name="Set start"
                                     Style="{StaticResource DefaultButtonStyle}"
@@ -1386,7 +1384,7 @@
                             </Button>
 
                             <Button Grid.Column="2"
-                                    Command="{Binding MarkSelectionEndCommand}"
+                                    Command="{Binding Trim.MarkSelectionEndCommand}"
                                     Margin="8,0,0,0"
                                     VerticalAlignment="Center"
                                     AutomationProperties.Name="Set end"
@@ -1405,14 +1403,14 @@
 
                             <!--  Live guidance: which step is next, then the selected length.  -->
                             <TextBlock Grid.Column="3"
-                                       Text="{Binding TrimHintText}"
+                                       Text="{Binding Trim.TrimHintText}"
                                        Margin="16,0"
                                        VerticalAlignment="Center"
                                        Foreground="{DynamicResource TextFillColorSecondaryBrush}"
                                        TextTrimming="CharacterEllipsis" />
 
                             <Button Grid.Column="4"
-                                    Command="{Binding ExportSelectionCommand}"
+                                    Command="{Binding Trim.ExportSelectionCommand}"
                                     VerticalAlignment="Center"
                                     AutomationProperties.Name="Export trimmed clip"
                                     Style="{StaticResource AccentButtonStyle}"
@@ -1427,7 +1425,7 @@
 
                             <Button Grid.Column="5"
                                     Content="Cancel"
-                                    Command="{Binding CancelTrimCommand}"
+                                    Command="{Binding Trim.CancelTrimCommand}"
                                     Margin="8,0,0,0"
                                     VerticalAlignment="Center"
                                     AutomationProperties.Name="Cancel trim"
@@ -1452,21 +1450,21 @@
                         <StackPanel Grid.Column="0"
                                     VerticalAlignment="Center"
                                     Orientation="Horizontal">
-                            <Button Command="{Binding PreviousCommand}"
+                            <Button Command="{Binding Playback.PreviousCommand}"
                                     VerticalAlignment="Center"
                                     AutomationProperties.Name="Previous clip"
-                                    IsEnabled="{Binding CanGoPrevious}"
+                                    IsEnabled="{Binding Playback.CanGoPrevious}"
                                     Style="{StaticResource SubtleIconButton}"
                                     ToolTip="Previous clip (Ctrl+Left)">
                                 <TextBlock Text="&#xE892;"
                                            Style="{StaticResource AppGlyph}" />
                             </Button>
 
-                            <Button Command="{Binding StepFrameBackwardCommand}"
+                            <Button Command="{Binding Playback.StepFrameBackwardCommand}"
                                     Margin="10,0,0,0"
                                     VerticalAlignment="Center"
                                     AutomationProperties.Name="Previous frame"
-                                    IsEnabled="{Binding CanSeek}"
+                                    IsEnabled="{Binding Playback.CanSeek}"
                                     Style="{StaticResource SubtleIconButton}"
                                     ToolTip="Previous frame (,)">
                                 <TextBlock Text="&#xE76B;"
@@ -1474,8 +1472,8 @@
                             </Button>
 
                             <Button x:Name="PlayPauseButton"
-                                    Content="{Binding PlayPauseIcon}"
-                                    Command="{Binding PlayPauseCommand}"
+                                    Content="{Binding Playback.PlayPauseIcon}"
+                                    Command="{Binding Playback.PlayPauseCommand}"
                                     Width="56"
                                     Height="40"
                                     Margin="10,0"
@@ -1483,36 +1481,36 @@
                                     FontFamily="{DynamicResource SymbolThemeFontFamily}"
                                     FontSize="20"
                                     AutomationProperties.Name="Play or pause"
-                                    IsEnabled="{Binding CanPlayPause}"
+                                    IsEnabled="{Binding Playback.CanPlayPause}"
                                     Style="{StaticResource AccentButtonStyle}"
                                     ToolTip="Play/Pause (Space)" />
 
-                            <Button Command="{Binding StepFrameForwardCommand}"
+                            <Button Command="{Binding Playback.StepFrameForwardCommand}"
                                     Margin="0,0,10,0"
                                     VerticalAlignment="Center"
                                     AutomationProperties.Name="Next frame"
-                                    IsEnabled="{Binding CanSeek}"
+                                    IsEnabled="{Binding Playback.CanSeek}"
                                     Style="{StaticResource SubtleIconButton}"
                                     ToolTip="Next frame (.)">
                                 <TextBlock Text="&#xE76C;"
                                            Style="{StaticResource AppGlyph}" />
                             </Button>
 
-                            <Button Command="{Binding NextCommand}"
+                            <Button Command="{Binding Playback.NextCommand}"
                                     VerticalAlignment="Center"
                                     AutomationProperties.Name="Next clip"
-                                    IsEnabled="{Binding CanGoNext}"
+                                    IsEnabled="{Binding Playback.CanGoNext}"
                                     Style="{StaticResource SubtleIconButton}"
                                     ToolTip="Next clip (Ctrl+Right)">
                                 <TextBlock Text="&#xE893;"
                                            Style="{StaticResource AppGlyph}" />
                             </Button>
 
-                            <Button Command="{Binding StopCommand}"
+                            <Button Command="{Binding Playback.StopCommand}"
                                     Margin="10,0,0,0"
                                     VerticalAlignment="Center"
                                     AutomationProperties.Name="Stop"
-                                    IsEnabled="{Binding CanStop}"
+                                    IsEnabled="{Binding Playback.CanStop}"
                                     Style="{StaticResource SubtleIconButton}"
                                     ToolTip="Stop">
                                 <TextBlock Text="&#xE71A;"
@@ -1535,11 +1533,11 @@
                                        Fill="{DynamicResource DividerStrokeColorDefaultBrush}" />
 
                             <!--  Jump straight to the moment the incident happened  -->
-                            <Button Command="{Binding JumpToEventCommand}"
+                            <Button Command="{Binding Playback.JumpToEventCommand}"
                                     Margin="10,0,0,0"
                                     VerticalAlignment="Center"
                                     AutomationProperties.Name="Jump to event"
-                                    IsEnabled="{Binding HasEventMarker}"
+                                    IsEnabled="{Binding Playback.HasEventMarker}"
                                     Style="{StaticResource SubtleIconButton}"
                                     ToolTip="Jump to the moment the event fired (E)">
                                 <StackPanel Orientation="Horizontal">
@@ -1551,7 +1549,7 @@
                             </Button>
 
                             <!--  Opens the trim panel (above this bar) for cutting a shareable MP4.  -->
-                            <Button Command="{Binding ToggleTrimmingCommand}"
+                            <Button Command="{Binding Trim.ToggleTrimmingCommand}"
                                     Margin="6,0,0,0"
                                     VerticalAlignment="Center"
                                     AutomationProperties.Name="Trim clip"
@@ -1572,25 +1570,25 @@
                                 Margin="16,0"
                                 VerticalAlignment="Center"
                                 AutomationProperties.Name="Seek"
-                                IsEnabled="{Binding CanSeek}"
+                                IsEnabled="{Binding Playback.CanSeek}"
                                 Maximum="1"
                                 Minimum="0"
                                 PreviewMouseDown="SeekSlider_PreviewMouseDown"
                                 PreviewMouseUp="SeekSlider_PreviewMouseUp"
                                 Style="{StaticResource SeekSlider}"
                                 ValueChanged="SeekSlider_ValueChanged"
-                                Value="{Binding SeekPosition, Mode=TwoWay}" />
+                                Value="{Binding Playback.SeekPosition, Mode=TwoWay}" />
 
                         <!--  Time readout  -->
                         <TextBlock Grid.Column="3"
                                    VerticalAlignment="Center"
                                    FontFamily="Consolas"
                                    FontSize="13">
-                            <Run Text="{Binding PositionText, Mode=OneWay}"
+                            <Run Text="{Binding Playback.PositionText, Mode=OneWay}"
                                  Foreground="{DynamicResource TextFillColorPrimaryBrush}" />
                             <Run Text=" / "
                                  Foreground="{DynamicResource TextFillColorTertiaryBrush}" />
-                            <Run Text="{Binding DurationText, Mode=OneWay}"
+                            <Run Text="{Binding Playback.DurationText, Mode=OneWay}"
                                  Foreground="{DynamicResource TextFillColorSecondaryBrush}" />
                         </TextBlock>
 
@@ -1600,7 +1598,7 @@
                                     Margin="16,0,0,0"
                                     VerticalAlignment="Center"
                                     Orientation="Horizontal">
-                            <Button Command="{Binding DecreaseSpeedCommand}"
+                            <Button Command="{Binding Playback.DecreaseSpeedCommand}"
                                     AutomationProperties.Name="Slower"
                                     Style="{StaticResource SubtleIconButton}"
                                     ToolTip="Slower (Shift+,)">
@@ -1609,7 +1607,7 @@
                                            Style="{StaticResource AppGlyph}" />
                             </Button>
                             <Button MinWidth="72"
-                                    Command="{Binding ResetSpeedCommand}"
+                                    Command="{Binding Playback.ResetSpeedCommand}"
                                     AutomationProperties.Name="Playback speed"
                                     Style="{StaticResource SubtleIconButton}"
                                     ToolTip="Playback speed — click to reset to 1x">
@@ -1618,11 +1616,11 @@
                                                FontSize="15"
                                                Foreground="{DynamicResource TextFillColorSecondaryBrush}"
                                                Style="{StaticResource AppGlyphInButton}" />
-                                    <TextBlock Text="{Binding PlaybackSpeedText}"
+                                    <TextBlock Text="{Binding Playback.PlaybackSpeedText}"
                                                VerticalAlignment="Center" />
                                 </StackPanel>
                             </Button>
-                            <Button Command="{Binding IncreaseSpeedCommand}"
+                            <Button Command="{Binding Playback.IncreaseSpeedCommand}"
                                     AutomationProperties.Name="Faster"
                                     Style="{StaticResource SubtleIconButton}"
                                     ToolTip="Faster (Shift+.)">
@@ -1694,7 +1692,7 @@
                                     <TextBlock Margin="0,2,0,0"
                                                Foreground="{DynamicResource TextFillColorSecondaryBrush}">
                                         <Run Text="Version" />
-                                        <Run Text="{Binding FileVersion, Mode=OneWay}" />
+                                        <Run Text="{Binding About.FileVersion, Mode=OneWay}" />
                                     </TextBlock>
                                 </StackPanel>
                             </StackPanel>
@@ -1927,18 +1925,18 @@
                                             VerticalAlignment="Top"
                                             Background="{DynamicResource AccentFillColorDefaultBrush}"
                                             CornerRadius="6"
-                                            Visibility="{Binding HasUpdateBadge, Converter={local:BoolToVisibilityConverter}}" />
+                                            Visibility="{Binding About.HasUpdateBadge, Converter={local:BoolToVisibilityConverter}}" />
                                     <StackPanel Grid.Column="2">
-                                        <TextBlock Text="{Binding UpdateStatusTitle}"
+                                        <TextBlock Text="{Binding About.UpdateStatusTitle}"
                                                    FontWeight="SemiBold"
                                                    Foreground="{DynamicResource TextControlForeground}"
                                                    TextWrapping="Wrap" />
                                         <TextBlock Margin="0,4,0,0"
                                                    Foreground="{DynamicResource TextControlForeground}"
                                                    TextWrapping="Wrap">
-                                            <Run Text="{Binding UpdateStatusDetails, Mode=OneWay}" />
+                                            <Run Text="{Binding About.UpdateStatusDetails, Mode=OneWay}" />
                                             <Run Text=" " />
-                                            <Hyperlink NavigateUri="{Binding LatestReleaseUrl}"
+                                            <Hyperlink NavigateUri="{Binding About.LatestReleaseUrl}"
                                                        RequestNavigate="Hyperlink_RequestNavigate">
                                                 Learn more
                                             </Hyperlink>
@@ -1965,7 +1963,7 @@
                                                TextAlignment="Right" />
                                     <TextBlock Grid.Row="0"
                                                Grid.Column="2"
-                                               Text="{Binding FileVersion}"
+                                               Text="{Binding About.FileVersion}"
                                                Foreground="{DynamicResource TextControlForeground}" />
                                     <TextBlock Grid.Row="1"
                                                Grid.Column="0"
@@ -1975,7 +1973,7 @@
                                                TextAlignment="Right" />
                                     <TextBlock Grid.Row="1"
                                                Grid.Column="2"
-                                               Text="{Binding RuntimeDescription}"
+                                               Text="{Binding About.RuntimeDescription}"
                                                Foreground="{DynamicResource TextControlForeground}" />
                                     <TextBlock Grid.Row="2"
                                                Grid.Column="0"
@@ -1985,7 +1983,7 @@
                                                TextAlignment="Right" />
                                     <TextBlock Grid.Row="2"
                                                Grid.Column="2"
-                                               Text="{Binding OsDescription}"
+                                               Text="{Binding About.OsDescription}"
                                                Foreground="{DynamicResource TextControlForeground}" />
                                     <TextBlock Grid.Row="3"
                                                Grid.Column="0"
@@ -1995,7 +1993,7 @@
                                                TextAlignment="Right" />
                                     <TextBlock Grid.Row="3"
                                                Grid.Column="2"
-                                               Text="{Binding ExecutablePath}"
+                                               Text="{Binding About.ExecutablePath}"
                                                Foreground="{DynamicResource TextControlForeground}"
                                                TextWrapping="Wrap" />
                                 </Grid>
diff --git a/SentryDeck/MainWindow.xaml.cs b/SentryDeck/MainWindow.xaml.cs
index 6c8efb5..a120af9 100644
--- a/SentryDeck/MainWindow.xaml.cs
+++ b/SentryDeck/MainWindow.xaml.cs
@@ -44,7 +44,7 @@ public MainWindow()
         _viewModel = new MainWindowViewModel(
             () => VideoPlayerController.Create([.. _cameraHosts.Select(pair => (pair.Key, pair.Value))]));
         _viewModel.SearchBoxFocusRequested += OnSearchBoxFocusRequested;
-        _viewModel.PropertyChanged += ViewModelOnPropertyChanged;
+        _viewModel.Cameras.PropertyChanged += CamerasOnPropertyChanged;
 
         DataContext = _viewModel;
 
@@ -162,26 +162,26 @@ private void ClipListBox_PreviewMouseLeftButtonUp(object sender, MouseButtonEven
 
     private void SeekSlider_PreviewMouseDown(object sender, MouseButtonEventArgs e)
     {
-        _viewModel.BeginSeek();
+        _viewModel.Playback.BeginSeek();
     }
 
     private async void SeekSlider_PreviewMouseUp(object sender, MouseButtonEventArgs e)
     {
-        await _viewModel.EndSeekAsync();
+        await _viewModel.Playback.EndSeekAsync();
     }
 
     // Fires for both thumb-drag and click-then-drag (WPF raises ValueChanged on every Value mutation, whether from dragging the Thumb or from IsMoveToPointEnabled's click-to-position), and also for the one-off value jump a plain click makes.
     // PreviewMouseDown has already called BeginSeek by the time this fires, so even a plain click issues one keyframe scrub seek here, which is harmless since the accurate mouse-up seek runs behind the same serialized lock and lands last.
     private void SeekSlider_ValueChanged(object sender, RoutedPropertyChangedEventArgs<double> e)
     {
-        _viewModel.OnSeekSliderValueChanged();
+        _viewModel.Playback.OnSeekSliderValueChanged();
     }
 
-    private void ViewModelOnPropertyChanged(object sender, PropertyChangedEventArgs e)
+    private void CamerasOnPropertyChanged(object sender, PropertyChangedEventArgs e)
     {
         // Re-parent the hosts when the enlarged view changes, and when a new clip swaps in a different camera set (the freshly generated tiles also self-register via CameraTileSlot_Loaded, which covers containers that don't exist yet at this moment).
-        if (e.PropertyName is nameof(MainWindowViewModel.SelectedCameraView)
-            or nameof(MainWindowViewModel.CameraViewOptions))
+        if (e.PropertyName is nameof(CameraViewsViewModel.SelectedCameraView)
+            or nameof(CameraViewsViewModel.CameraViewOptions))
         {
             UpdateCameraHostLayout();
         }
@@ -204,7 +204,7 @@ private void HookCameraClick(FlyleafHost host, string cameraView)
                     MouseLeftButtonUpEvent,
                     new MouseButtonEventHandler((_, e) =>
                     {
-                        _viewModel.SelectCameraViewCommand.Execute(cameraView);
+                        _viewModel.Cameras.SelectCameraViewCommand.Execute(cameraView);
 
                         // The click moved Win32 focus to the native Flyleaf surface, which never routes keys back into WPF, so every keyboard shortcut would go dead.
                         // Pull it back onto the video container, a neutral focusable element that consumes no shortcut keys (see its remarks in the XAML).
@@ -235,7 +235,7 @@ private void UpdateCameraHostLayout()
 
         var placed = new HashSet<FlyleafHost>();
 
-        foreach (var (host, slot) in GetCameraHostLayout(_viewModel.SelectedCameraView))
+        foreach (var (host, slot) in GetCameraHostLayout(_viewModel.Cameras.SelectedCameraView))
         {
             MoveHostToSlot(host, slot);
             placed.Add(host);
@@ -257,7 +257,7 @@ private void UpdateCameraHostLayout()
 
     private IEnumerable<(FlyleafHost Host, ContentControl Slot)> GetCameraHostLayout(string view)
     {
-        if (view == MainWindowViewModel.GridCameraView)
+        if (view == CameraViewsViewModel.GridCameraView)
         {
             // The grid stays the classic four-camera 2x2 for now; pillar cameras are reachable through their single-camera views.
             yield return (FrontFlyleafHost, GridFrontHostSlot);
@@ -275,7 +275,7 @@ private void UpdateCameraHostLayout()
         yield return (primaryHost, PrimaryCameraHostSlot);
 
         // Every other camera of this clip previews inside its own selector tile; the enlarged camera's tile stays empty behind its "this is the main view" icon.
-        foreach (var option in _viewModel.CameraViewOptions)
+        foreach (var option in _viewModel.Cameras.CameraViewOptions)
         {
             if (option.IsCamera
                 && option.ViewId != view
diff --git a/SentryDeck/MainWindowViewModel.cs b/SentryDeck/MainWindowViewModel.cs
index 2195a39..fb94bd4 100644
--- a/SentryDeck/MainWindowViewModel.cs
+++ b/SentryDeck/MainWindowViewModel.cs
@@ -1,73 +1,36 @@
 using System.ComponentModel;
-using System.Diagnostics;
-using System.Globalization;
-using System.IO;
-using System.Reflection;
-using System.Runtime.InteropServices;
-using System.Windows;
 using System.Windows.Input;
 using System.Windows.Threading;
 using CommunityToolkit.Mvvm.ComponentModel;
 using CommunityToolkit.Mvvm.Input;
-using Microsoft.VisualBasic.FileIO;
-using Microsoft.Win32;
 using Serilog;
 
 namespace SentryDeck;
 
 /// <summary>
-/// View-model for the main window: clip browsing, playback orchestration, update checks, FFmpeg prompts, and shell actions.
-/// Holds no references to WPF controls; the view supplies the playback controller (via <see cref="MainWindowViewModel(Func{VideoPlayerController})"/>) and reacts to <see cref="SearchBoxFocusRequested"/> and <see cref="SelectedCameraView"/> changes.
+/// View-model for the main window.
+/// It composes one view-model per feature (<see cref="Library"/>, <see cref="Playback"/>, <see cref="Trim"/>, <see cref="Cameras"/>, <see cref="Error"/>, <see cref="About"/>), wires them to each other, and owns what spans them: startup, the overlay covering the video area, the About page, and keyboard shortcuts.
+/// Holds no references to WPF controls; the view supplies the playback controller (via <see cref="MainWindowViewModel(Func{VideoPlayerController})"/>) and reacts to <see cref="SearchBoxFocusRequested"/> and <see cref="CameraViewsViewModel.SelectedCameraView"/> changes.
 /// </summary>
 public partial class MainWindowViewModel : ObservableObject
 {
-    /// <summary>
-    /// The multi-camera grid pseudo-view.
-    /// Every other view id is a canonical camera name from <see cref="CameraNames"/>, so the selected view maps 1:1 onto the clip's camera files.
-    /// </summary>
-    public const string GridCameraView = "grid";
-
-    // The classic four-camera set (HW3 and earlier) shown before any clip is opened, so the selector strip doesn't start empty.
-    private static readonly string[] DefaultCameras =
-    [
-        CameraNames.Front,
-        CameraNames.Back,
-        CameraNames.LeftRepeater,
-        CameraNames.RightRepeater,
-    ];
-
-    private readonly List<CamClip> _allClips = [];
     private readonly FlyleafRuntime _flyleafRuntime = new();
-    private readonly UpdateService _updateService = new();
-    private readonly Func<VideoPlayerController> _playerControllerFactory;
-    private readonly Func<string, IReadOnlyList<CamClip>> _clipLoader;
-    private readonly Func<Task> _backgroundYield;
     private readonly Dispatcher _dispatcher;
-    private readonly Action<Action> _uiInvoker;
-    private readonly DispatcherTimer _filterDebounceTimer;
-    private readonly IClipExporter _clipExporter;
-    private readonly Func<string, string> _savePathPicker;
-    private readonly IClipMediaSourceBuilder _exportMediaSourceBuilder;
-    private VideoPlayerController _playerController;
-    private CancellationTokenSource _selectionCts;
-    private readonly SeekScrubCoalescer _scrubCoalescer;
-    private bool _isSeeking;
-
-    // Identifies the current seek gesture.
-    // EndSeekAsync's slow tail (the accurate seek can queue behind in-flight scrubs) may complete after the user has already started a NEW drag; only the completion belonging to the latest gesture may clear _isSeeking, or the position sync would yank the thumb out from under the active drag.
-    private int _seekGeneration;
     private bool _isInitialized;
-
-    // The source of dashcam roots: auto-discovery by default, or the user's last picked folders.
-    // Refresh re-evaluates it to rescan for newly added clips (and, for auto-discovery, newly connected drives).
-    private Func<IEnumerable<string>> _rootSource = CamStorage.FindCommonRoots;
-
-    /// <param name="playerControllerFactory">Creates the playback controller (the view supplies one bound to its Flyleaf hosts).</param> <param name="clipLoader">Maps a dashcam root to its clips.
-    /// Defaults to scanning the filesystem; overridable for tests.</param> <param name="backgroundYield">Yields to the UI before a clip loads so the window stays responsive.
-    /// Overridable for tests.</param> <param name="clipExporter">Exports trimmed clip ranges.
-    /// Defaults to the FFmpeg-backed exporter; overridable for tests.</param> <param name="savePathPicker">Maps a suggested file name to the chosen save path (null = canceled).
-    /// Defaults to a save dialog; overridable for tests.</param> <param name="exportMediaSourceBuilder">Builds a media source for exporting a clip that isn't currently open.
-    /// Overridable for tests.</param> <param name="uiInvoker">Runs an action on the UI thread.
+    private bool _isDownloadingFFmpeg;
+
+    /// <param name="playerControllerFactory">Creates the playback controller (the view supplies one bound to its Flyleaf hosts).</param>
+    /// <param name="clipLoader">Maps a dashcam root to its clips.
+    /// Defaults to scanning the filesystem; overridable for tests.</param>
+    /// <param name="backgroundYield">Yields to the UI before a clip loads so the window stays responsive.
+    /// Overridable for tests.</param>
+    /// <param name="clipExporter">Exports trimmed clip ranges.
+    /// Defaults to the FFmpeg-backed exporter; overridable for tests.</param>
+    /// <param name="savePathPicker">Maps a suggested file name to the chosen save path (null = canceled).
+    /// Defaults to a save dialog; overridable for tests.</param>
+    /// <param name="exportMediaSourceBuilder">Builds a media source for exporting a clip that isn't currently open.
+    /// Overridable for tests.</param>
+    /// <param name="uiInvoker">Runs an action on the UI thread.
     /// Defaults to the dispatcher hop; overridable for tests, which have no pumped message loop to service it.</param>
     public MainWindowViewModel(
         Func<VideoPlayerController> playerControllerFactory,
@@ -78,24 +41,41 @@ public MainWindowViewModel(
         IClipMediaSourceBuilder exportMediaSourceBuilder = null,
         Action<Action> uiInvoker = null)
     {
-        _playerControllerFactory = playerControllerFactory;
-        _clipLoader = clipLoader ?? (root => CamStorage.Map(root).Clips);
-        _backgroundYield = backgroundYield ?? (async () => await Dispatcher.Yield(DispatcherPriority.Background));
-        _clipExporter = clipExporter ?? new ClipExporter(PackageManager.FindFFmpegDirectory);
-        _savePathPicker = savePathPicker ?? PickSavePathWithDialog;
-        _exportMediaSourceBuilder = exportMediaSourceBuilder ?? new FfconcatMediaSourceBuilder();
         _dispatcher = Dispatcher.CurrentDispatcher;
-        _uiInvoker = uiInvoker ?? InvokeOnDispatcher;
-        _scrubCoalescer = new SeekScrubCoalescer(ScrubToAsync);
 
-        // Coalesces the expensive clip-list regroup/rebind so fast typing in search stays smooth; the getters stay live, so only the (debounced) change notification is deferred.
-        _filterDebounceTimer = new DispatcherTimer(DispatcherPriority.Background, _dispatcher)
-        {
-            Interval = TimeSpan.FromMilliseconds(150),
+        Playback = new PlaybackViewModel(
+            playerControllerFactory,
+            backgroundYield ?? (async () => await Dispatcher.Yield(DispatcherPriority.Background)),
+            uiInvoker ?? InvokeOnDispatcher,
+            Error,
+            Cameras);
+        Library = new ClipLibraryViewModel(
+            clipLoader ?? (root => CamStorage.Map(root).Clips),
+            Playback,
+            Error,
+            _dispatcher);
+        Trim = new TrimViewModel(
+            Playback,
+            Cameras,
+            Error,
+            clipExporter ?? new ClipExporter(PackageManager.FindFFmpegDirectory),
+            savePathPicker,
+            exportMediaSourceBuilder ?? new FfconcatMediaSourceBuilder());
+
+        Error.PropertyChanged += (_, e) =>
+        {
+            if (e.PropertyName == nameof(ErrorOverlayViewModel.IsVisible))
+            {
+                OnPropertyChanged(nameof(ShowStatusOverlay));
+                OnPropertyChanged(nameof(ShowVideoHosts));
+                OnPropertyChanged(nameof(HasNoClipSelected));
+                OnPropertyChanged(nameof(HasError));
+            }
         };
-        _filterDebounceTimer.Tick += OnFilterDebounceTick;
 
-        SyncCameraViewSelection();
+        Playback.PropertyChanged += OnPlaybackPropertyChanged;
+        Playback.CurrentClipChanged += (_, clip) => Library.SelectedClip = clip;
+        Library.PropertyChanged += OnLibraryPropertyChanged;
     }
 
     /// <summary>
@@ -103,422 +83,56 @@ public MainWindowViewModel(
     /// </summary>
     public event EventHandler SearchBoxFocusRequested;
 
-    public bool ShowMainContent => !ShowAboutPage;
-
-    public Version CurrentVersion => Assembly.GetExecutingAssembly().GetName().Version ?? new Version(0, 0, 0);
-
-    public string FileVersion => FormatVersion(CurrentVersion);
-
-    public string RuntimeDescription => $"{RuntimeInformation.FrameworkDescription} ({RuntimeInformation.ProcessArchitecture})";
-
-    public string OsDescription => RuntimeInformation.OSDescription;
-
-    public string ExecutablePath => Environment.ProcessPath;
-
-    public bool HasUpdateBadge => IsUpdateAvailable;
-
-    public string LatestVersionText => LatestRelease is null ? "Unknown" : FormatVersion(LatestRelease.Version);
-
-    public string LatestReleaseUrl => LatestRelease?.ReleaseUrl ?? UpdateService.ReleasesPageUrl;
-
-    public string ReleasesPageUrl => UpdateService.ReleasesPageUrl;
-
-    public string UpdateStatusTitle => IsUpdateAvailable
-        ? "Update available"
-        : "You're up to date";
-
-    public string UpdateStatusDetails => IsUpdateAvailable
-        ? $"Version {LatestVersionText} is available."
-        : "No newer release was found.";
-
     /// <summary>
-    /// Ladder the speed stepper walks: fine increments around 1x, doubling above.
-    /// Flyleaf clamps Player.Speed to [0.125, 16], so 16x is the hard ceiling.
+    /// The notice over the video area; every feature reports errors through it.
     /// </summary>
-    public static IReadOnlyList<double> PlaybackSpeedSteps { get; } =
-    [
-        0.25,
-        0.5,
-        0.75,
-        1.0,
-        1.25,
-        1.5,
-        2.0,
-        4.0,
-        8.0,
-        16.0,
-    ];
-
-    /// <summary>Speed readout shown on the stepper, e.g. "1x" or "0.25x".</summary>
-    public string PlaybackSpeedText => $"{PlaybackSpeed:0.##}x";
-
-    public bool CanIncreaseSpeed => PlaybackSpeed < PlaybackSpeedSteps[^1];
-
-    public bool CanDecreaseSpeed => PlaybackSpeed > PlaybackSpeedSteps[0];
-
-    public IReadOnlyList<CamClip> FilteredClips => _allClips
-        .Where(MatchesFilter)
-        .OrderByDescending(c => c.Timestamp)
-        .ThenBy(c => c.Name)
-        .ToList();
-
-    /// <summary>Number of clips currently shown (drives the sidebar count).</summary>
-    public int ClipCount => FilteredClips.Count;
-
-    /// <summary>True when the search box has text (drives the clear button).</summary>
-    public bool HasFilterText => !string.IsNullOrEmpty(FilterText);
-
-    // Matches the clip name, path, event city, and friendly event reason (e.g. "sentry", "honk", "saved").
-    private bool MatchesFilter(CamClip clip)
-    {
-        if (string.IsNullOrWhiteSpace(FilterText))
-        {
-            return true;
-        }
-
-        var term = FilterText;
-        return clip.Name.Contains(term, StringComparison.CurrentCultureIgnoreCase)
-            || clip.FullPath.Contains(term, StringComparison.CurrentCultureIgnoreCase)
-            || (clip.Event?.City?.Contains(term, StringComparison.CurrentCultureIgnoreCase) ?? false)
-            || ClipDisplay.ReasonLabel(clip.Event).Contains(term, StringComparison.CurrentCultureIgnoreCase);
-    }
-
-    // Restart the debounce on each keystroke; the list is rebound once typing settles.
-    partial void OnFilterTextChanged(string value)
-    {
-        _filterDebounceTimer.Stop();
-        _filterDebounceTimer.Start();
-    }
-
-    private void OnFilterDebounceTick(object sender, EventArgs e)
-    {
-        _filterDebounceTimer.Stop();
-        OnPropertyChanged(nameof(FilteredClips));
-        OnPropertyChanged(nameof(ClipCount));
-    }
-
-    public string PositionText
-    {
-        get
-        {
-            var duration = _playerController?.Duration ?? TimeSpan.Zero;
-            var position = TimeSpan.FromSeconds(SeekPosition * duration.TotalSeconds);
-            return FormatTimeSpan(position);
-        }
-    }
-
-    public string DurationText => FormatTimeSpan(_playerController?.Duration ?? TimeSpan.Zero);
-
-    public bool CanSeek => _playerController?.IsMediaOpen == true && !IsLoading && _playerController.Duration > TimeSpan.Zero;
-
-    public bool CanPlayPause => (SelectedClip is not null || IsPlaying) && !IsLoading;
-
-    public bool CanStop => IsPlaying || IsLoading;
-
-    public bool CanGoNext => _playerController?.CanGoNext == true;
-
-    public bool CanGoPrevious => _playerController?.CanGoPrevious == true;
-
-    // Segoe Fluent Icons: Pause (E769) / PlaySolid (F5B0).
-    // Rendered with SymbolThemeFontFamily.
-    public string PlayPauseIcon => IsPlaying ? "" : "";
-
-    // The full-screen overlay only covers the no-video states (scanning with no clip, error, empty); as a WPF sibling it can't draw over the Flyleaf video surface anyway.
-    // While a selected clip loads, the hosts stay visible and simply show black until the first frame decodes, with no loading screen flashing mid-playback.
-    public bool ShowStatusOverlay => (IsLoading && SelectedClip is null) || ShowErrorOverlay || HasNoClipSelected;
-
-    public bool ShowVideoHosts => SelectedClip is not null && !ShowErrorOverlay;
-
-    public bool HasError => ShowErrorOverlay;
-
-    public bool HasNoClipSelected => SelectedClip is null && !IsLoading && !ShowErrorOverlay;
-
-    public bool IsIndeterminateProgress => IsLoading && !IsRendering;
-
-    public bool IsGridViewSelected => SelectedCameraView == GridCameraView;
-
-    public bool IsSingleCameraViewSelected => !IsGridViewSelected;
-
-    public string ActiveCameraLabel => SelectedCameraView == GridCameraView ? "Grid" : CameraLabel(SelectedCameraView);
+    public ErrorOverlayViewModel Error { get; } = new();
 
     /// <summary>
-    /// Friendly tile label for a camera.
-    /// The classic four keep their short historical names; the HW4/AI4 B-pillars are spelled out to distinguish them from the repeaters.
+    /// Version, environment, and update details for the About and help page.
     /// </summary>
-    private static string CameraLabel(string camera) => camera switch
-    {
-        CameraNames.Front => "Front",
-        CameraNames.Back => "Rear",
-        CameraNames.LeftRepeater => "Left",
-        CameraNames.RightRepeater => "Right",
-        CameraNames.LeftPillar => "Left Pillar",
-        CameraNames.RightPillar => "Right Pillar",
-        _ => CameraNames.DisplayName(camera),
-    };
-
-    public string LoadingStatusText => IsRendering
-        ? $"Rendering... {RenderProgressPercent}%"
-        : "Loading...";
-
-    public int RenderProgressPercent => (int)(RenderProgress * 100);
-
-    // --- Seek-bar overlays for the selected clip (event moment + chunk seams + gaps) ---
-    // Recomputed whenever the selection changes or the controller opens/replaces its media source; plain fields (not ObservableProperty) because they're derived, not independently settable.
-    private double? _eventPosition;
-    private IReadOnlyList<double> _chunkBoundaries = [];
-    private IReadOnlyList<double> _gapPositions = [];
-
-    /// <summary>The event moment as a 0..1 fraction of the clip timeline (0 when none; pair with <see cref="HasEventMarker"/>).</summary>
-    public double EventMarkerPosition => _eventPosition ?? 0d;
-
-    /// <summary>True when the selected clip has a locatable event moment to mark on the seek bar and jump to.</summary>
-    public bool HasEventMarker => _eventPosition.HasValue;
-
-    /// <summary>Friendly reason + time for the event marker tooltip, e.g. "Honk · 3:53 PM".</summary>
-    public string EventMarkerTooltip => SelectedClip?.Event is { } camEvent && HasEventMarker
-        ? $"{ClipDisplay.ReasonLabel(camEvent)} · {camEvent.Timestamp:t}"
-        : string.Empty;
-
-    /// <summary>Interior chunk-boundary fractions (i/Count for i in 1..Count-1); empty for fewer than two chunks.</summary>
-    public IReadOnlyList<double> ChunkBoundaries => _chunkBoundaries;
+    public AboutViewModel About { get; } = new();
 
     /// <summary>
-    /// Fractional seek-bar positions where the opened clip's media time skips over a wall-clock gap (deleted/corrupt/excluded chunks, or a Sentry idle period).
-    /// Empty until the selected clip's media source has actually been built and opened by the controller.
+    /// The enlarged camera (or grid) and the strip of cameras the current clip recorded.
     /// </summary>
-    public IReadOnlyList<double> GapPositions => _gapPositions;
-
-    // --- Export selection (in/out marks on the seek bar, as 0..1 fractions like SeekPosition) ---
-    // Plain fields + an explicit notify helper (not ObservableProperty) because the pair changes together under shared invariants (start < end) and several derived properties hang off both.
-    private double? _selectionStart;
-    private double? _selectionEnd;
-
-    /// <summary>How much footage to keep on each side of the event moment in "Save event clip".</summary>
-    public static readonly TimeSpan EventClipPadding = TimeSpan.FromSeconds(30);
-
-    /// <summary>The selection start as a 0..1 fraction of the clip timeline (0 when unset; pair with <see cref="HasSelectionStart"/>).</summary>
-    public double SelectionStartPosition => _selectionStart ?? 0d;
-
-    /// <summary>The selection end as a 0..1 fraction of the clip timeline (0 when unset; pair with <see cref="HasSelectionEnd"/>).</summary>
-    public double SelectionEndPosition => _selectionEnd ?? 0d;
-
-    public bool HasSelectionStart => _selectionStart.HasValue;
-
-    public bool HasSelectionEnd => _selectionEnd.HasValue;
-
-    /// <summary>True when both marks are set (a complete, exportable range).</summary>
-    public bool HasSelection => _selectionStart.HasValue && _selectionEnd.HasValue;
-
-    public bool CanExportSelection => HasSelection && !IsExporting && CanSeek;
+    public CameraViewsViewModel Cameras { get; } = new();
 
     /// <summary>
-    /// True while the trim panel is open.
-    /// Opens explicitly (the Trim button) or implicitly (marking a point via I/O); closing it always discards the marks, so the panel and the selection can't drift apart.
+    /// The player: loading the selected clip, transport, the seek bar and its markers, and speed.
     /// </summary>
-    [ObservableProperty]
-    private bool _isTrimming;
+    public PlaybackViewModel Playback { get; }
 
     /// <summary>
-    /// One-line guidance for the trim panel: walks the user through start → end → export, and shows the selected length once the range is complete.
+    /// The clip list: scanning, search, the selected clip, and per-clip actions.
     /// </summary>
-    public string TrimHintText
-    {
-        get
-        {
-            if (HasSelection)
-            {
-                return $"{SelectionDurationText} selected — ready to export.";
-            }
-
-            if (HasSelectionStart)
-            {
-                return "Now play or scrub ahead to the end of your cut, then set the end.";
-            }
-
-            if (HasSelectionEnd)
-            {
-                return "Now play or scrub back to where your cut should begin, then set the start.";
-            }
-
-            return "Play or scrub to where your cut should begin, then set the start.";
-        }
-    }
-
-    /// <summary>Length of the marked range, e.g. "0:42" (empty until both marks are set).</summary>
-    public string SelectionDurationText
-    {
-        get
-        {
-            if (_selectionStart is not { } start || _selectionEnd is not { } end)
-            {
-                return string.Empty;
-            }
-
-            var duration = _playerController?.Duration ?? TimeSpan.Zero;
-            return FormatTimeSpan(TimeSpan.FromSeconds((end - start) * duration.TotalSeconds));
-        }
-    }
-
-    [ObservableProperty]
-    [NotifyPropertyChangedFor(nameof(CanExportSelection))]
-    [NotifyCanExecuteChangedFor(nameof(ExportSelectionCommand))]
-    [NotifyCanExecuteChangedFor(nameof(SaveEventClipCommand))]
-    private bool _isExporting;
-
-    // FilteredClips/ClipCount are refreshed on a short debounce (see OnFilterTextChanged) rather than per keystroke; HasFilterText stays immediate so the search box's clear affordance is responsive.
-    [ObservableProperty]
-    [NotifyPropertyChangedFor(nameof(HasFilterText))]
-    private string _filterText = string.Empty;
-
-    [ObservableProperty]
-    [NotifyPropertyChangedFor(nameof(HasNoClipSelected))]
-    [NotifyPropertyChangedFor(nameof(ShowStatusOverlay))]
-    [NotifyPropertyChangedFor(nameof(ShowVideoHosts))]
-    [NotifyPropertyChangedFor(nameof(CanPlayPause))]
-    private CamClip _selectedClip;
-
-    // The clip actually loaded in the player (drives the now-playing marker in the list).
-    // Distinct from SelectedClip so a marker can persist even when selection is elsewhere.
-    [ObservableProperty]
-    private CamClip _nowPlayingClip;
-
-    [ObservableProperty]
-    private string _errorTitle;
-
-    [ObservableProperty]
-    private string _errorDetails;
-
-    [ObservableProperty]
-    [NotifyPropertyChangedFor(nameof(ShowStatusOverlay))]
-    [NotifyPropertyChangedFor(nameof(ShowVideoHosts))]
-    [NotifyPropertyChangedFor(nameof(HasNoClipSelected))]
-    [NotifyPropertyChangedFor(nameof(HasError))]
-    private bool _showErrorOverlay;
-
-    [ObservableProperty]
-    private bool _canDismissError = true;
-
-    // True when the overlay is a friendly first-run/empty prompt rather than a genuine error.
-    [ObservableProperty]
-    private bool _isEmptyState;
-
-    [ObservableProperty]
-    private bool _showFFmpegDownloadButton;
-
-    [ObservableProperty]
-    [NotifyPropertyChangedFor(nameof(ShowMainContent))]
-    private bool _showAboutPage;
-
-    [ObservableProperty]
-    [NotifyPropertyChangedFor(nameof(CanPlayPause))]
-    [NotifyPropertyChangedFor(nameof(CanStop))]
-    [NotifyPropertyChangedFor(nameof(LoadingStatusText))]
-    [NotifyPropertyChangedFor(nameof(IsIndeterminateProgress))]
-    [NotifyPropertyChangedFor(nameof(ShowStatusOverlay))]
-    [NotifyPropertyChangedFor(nameof(ShowVideoHosts))]
-    [NotifyPropertyChangedFor(nameof(HasNoClipSelected))]
-    [NotifyPropertyChangedFor(nameof(CanSeek))]
-    [NotifyPropertyChangedFor(nameof(CanExportSelection))]
-    [NotifyCanExecuteChangedFor(nameof(StepFrameBackwardCommand))]
-    [NotifyCanExecuteChangedFor(nameof(StepFrameForwardCommand))]
-    [NotifyCanExecuteChangedFor(nameof(MarkSelectionStartCommand))]
-    [NotifyCanExecuteChangedFor(nameof(MarkSelectionEndCommand))]
-    [NotifyCanExecuteChangedFor(nameof(ToggleTrimmingCommand))]
-    [NotifyCanExecuteChangedFor(nameof(ExportSelectionCommand))]
-    private bool _isLoading;
-
-    [ObservableProperty]
-    [NotifyPropertyChangedFor(nameof(LoadingStatusText))]
-    [NotifyPropertyChangedFor(nameof(IsIndeterminateProgress))]
-    private bool _isRendering;
-
-    // True while the clip list is being (re)scanned from disk; drives the sidebar loading indicator.
-    [ObservableProperty]
-    [NotifyCanExecuteChangedFor(nameof(RefreshClipsCommand))]
-    [NotifyCanExecuteChangedFor(nameof(OpenFolderCommand))]
-    private bool _isLoadingClips;
-
-    [ObservableProperty]
-    [NotifyPropertyChangedFor(nameof(RenderProgressPercent))]
-    [NotifyPropertyChangedFor(nameof(LoadingStatusText))]
-    private double _renderProgress;
-
-    [ObservableProperty]
-    [NotifyPropertyChangedFor(nameof(PositionText))]
-    private double _seekPosition;
-
-    [ObservableProperty]
-    [NotifyPropertyChangedFor(nameof(PlayPauseIcon))]
-    [NotifyPropertyChangedFor(nameof(CanPlayPause))]
-    [NotifyPropertyChangedFor(nameof(CanStop))]
-    private bool _isPlaying;
-
-    [ObservableProperty]
-    [NotifyPropertyChangedFor(nameof(PlaybackSpeedText))]
-    [NotifyPropertyChangedFor(nameof(CanIncreaseSpeed))]
-    [NotifyPropertyChangedFor(nameof(CanDecreaseSpeed))]
-    [NotifyCanExecuteChangedFor(nameof(IncreaseSpeedCommand))]
-    [NotifyCanExecuteChangedFor(nameof(DecreaseSpeedCommand))]
-    private double _playbackSpeed = 1.0;
-
-    [ObservableProperty]
-    [NotifyPropertyChangedFor(nameof(IsGridViewSelected))]
-    [NotifyPropertyChangedFor(nameof(IsSingleCameraViewSelected))]
-    [NotifyPropertyChangedFor(nameof(ActiveCameraLabel))]
-    private string _selectedCameraView = CameraNames.Front;
+    public ClipLibraryViewModel Library { get; }
 
     /// <summary>
-    /// The selectable views for the current clip: the grid plus one tile per camera the clip actually recorded, in <see cref="CameraNames.All"/> order.
-    /// The view re-parents its Flyleaf hosts into the tiles when this changes.
+    /// The trim panel's in/out marks, and exporting a range or an event clip.
     /// </summary>
-    [ObservableProperty]
-    private IReadOnlyList<CameraViewOption> _cameraViewOptions = BuildCameraViewOptions(null);
+    public TrimViewModel Trim { get; }
 
-    private static IReadOnlyList<CameraViewOption> BuildCameraViewOptions(CamClip clip)
-    {
-        // Only recognized cameras get a tile: each needs a dedicated Flyleaf host wired in the view, so an unknown future suffix is ingested and played in the engine but not shown.
-        var cameras = clip is null
-            ? DefaultCameras
-            : CameraNames.All.Where(camera => clip.Chunks.Any(chunk => chunk.Files.ContainsKey(camera))).ToArray();
-
-        // Metadata-only clips (no camera files at all) keep the classic strip rather than none.
-        if (cameras.Length == 0)
-        {
-            cameras = DefaultCameras;
-        }
+    public bool ShowMainContent => !ShowAboutPage;
 
-        var options = new List<CameraViewOption>(cameras.Length + 1)
-        {
-            new(GridCameraView, "Grid", shortcutNumber: 1, isGrid: true),
-        };
-        options.AddRange(cameras.Select((camera, index) => new CameraViewOption(camera, CameraLabel(camera), index + 2)));
-        return options;
-    }
+    /// <summary>
+    /// True while anything blocks the video pane: a clip scan, the FFmpeg download, or the selected clip loading.
+    /// </summary>
+    public bool IsLoading => Library.IsLoadingClips || _isDownloadingFFmpeg || Playback.IsLoading;
 
-    private bool IsAvailableView(string view) =>
-        view is not null && CameraViewOptions.Any(option => option.ViewId == view);
+    // The full-screen overlay only covers the no-video states (scanning with no clip, error, empty); as a WPF sibling it can't draw over the Flyleaf video surface anyway.
+    // While a selected clip loads, the hosts stay visible and simply show black until the first frame decodes, with no loading screen flashing mid-playback.
+    public bool ShowStatusOverlay => (IsLoading && Library.SelectedClip is null) || Error.IsVisible || HasNoClipSelected;
 
-    partial void OnSelectedCameraViewChanged(string value) => SyncCameraViewSelection();
+    public bool ShowVideoHosts => Library.SelectedClip is not null && !Error.IsVisible;
 
-    private void SyncCameraViewSelection()
-    {
-        foreach (var option in CameraViewOptions)
-        {
-            option.IsSelected = option.ViewId == SelectedCameraView;
-        }
-    }
+    public bool HasError => Error.IsVisible;
 
-    [ObservableProperty]
-    [NotifyPropertyChangedFor(nameof(HasUpdateBadge))]
-    [NotifyPropertyChangedFor(nameof(UpdateStatusTitle))]
-    [NotifyPropertyChangedFor(nameof(UpdateStatusDetails))]
-    private bool _isUpdateAvailable;
+    public bool HasNoClipSelected => Library.SelectedClip is null && !IsLoading && !Error.IsVisible;
 
     [ObservableProperty]
-    [NotifyPropertyChangedFor(nameof(LatestVersionText))]
-    [NotifyPropertyChangedFor(nameof(LatestReleaseUrl))]
-    [NotifyPropertyChangedFor(nameof(UpdateStatusDetails))]
-    private UpdateRelease _latestRelease;
+    [NotifyPropertyChangedFor(nameof(ShowMainContent))]
+    private bool _showAboutPage;
 
     public async Task InitializeAsync()
     {
@@ -531,13 +145,13 @@ public async Task InitializeAsync()
 #if DEBUG
         Log.Debug("Skipping update check in debug build");
 #else
-        _ = UpdateLatestReleaseAsync();
+        _ = About.CheckForUpdatesAsync();
 #endif
 
         if (_flyleafRuntime.TryStart())
         {
             InitializePlayer();
-            await LoadClipsAsync(_rootSource());
+            await Library.ReloadAsync();
         }
         else
         {
@@ -547,537 +161,67 @@ public async Task InitializeAsync()
 
     public void Shutdown()
     {
-        _filterDebounceTimer.Stop();
-        _selectionCts?.Cancel();
-        _selectionCts?.Dispose();
-        _selectionCts = null;
-
-        var controller = _playerController;
-        _playerController = null;
-
-        if (controller is null)
-            return;
-
-        controller.PropertyChanged -= PlayerControllerOnPropertyChanged;
-        controller.Dispose();
-    }
-
-    public void InitializePlayer()
-    {
-        if (_playerController is not null)
-            return;
-
-        _playerController = _playerControllerFactory();
-        _playerController.PropertyChanged += PlayerControllerOnPropertyChanged;
-        _playerController.PlaybackSpeed = PlaybackSpeed;
+        Library.Shutdown();
+        Playback.Shutdown();
     }
 
-    public async Task LoadClipsAsync(IEnumerable<string> roots, TimeSpan minimumLoadingDuration = default)
-    {
-        ClearError();
-        _allClips.Clear();
-        SelectedClip = null;
-        IsLoading = true;
-        IsLoadingClips = true;
-
-        // Clear the list right away so a (re)scan visibly empties it and shows the loading bar before refilling.
-        OnPropertyChanged(nameof(FilteredClips));
-        OnPropertyChanged(nameof(ClipCount));
-        RefreshClipState();
-
-        var stopwatch = Stopwatch.StartNew();
-
-        try
-        {
-            // Scan the disk off the UI thread; the continuation resumes on it via the WPF SynchronizationContext, so all view-model state below is mutated on the UI thread.
-            var result = await Task.Run(() => ScanRoots(roots));
-
-            if (!result.HadRoots)
-            {
-                ShowError(
-                    "No dashcam footage yet",
-                    "Point Sentry Deck at your TeslaCam folder to get started. Recorded USB drives are found automatically.",
-                    canDismiss: true,
-                    isEmptyState: true);
-            }
-            else
-            {
-                _allClips.AddRange(result.Clips);
-                foreach (var error in result.Errors)
-                {
-                    ShowError(error.Title, error.Details);
-                }
-            }
-
-            _playerController?.LoadClips(_allClips);
-
-            // Hold the loading state briefly so a fast rescan still reads as a deliberate refresh (clear -> loading -> refill) instead of an imperceptible flicker.
-            var remaining = minimumLoadingDuration - stopwatch.Elapsed;
-            if (remaining > TimeSpan.Zero)
-            {
-                await Task.Delay(remaining);
-            }
-        }
-        finally
-        {
-            IsLoading = false;
-            IsLoadingClips = false;
-            OnPropertyChanged(nameof(FilteredClips));
-            OnPropertyChanged(nameof(ClipCount));
-            RefreshClipState();
-        }
-    }
-
-    private ScanResult ScanRoots(IEnumerable<string> roots)
-    {
-        var rootList = roots?.Where(root => !string.IsNullOrWhiteSpace(root)).ToList() ?? [];
-        if (rootList.Count == 0)
-        {
-            Log.Information("No dashcam roots found");
-            return new ScanResult([], [], HadRoots: false);
-        }
-
-        Log.Information("Loading dashcam clips. RootCount={RootCount}; Roots={Roots}", rootList.Count, rootList);
-        var totalStopwatch = Stopwatch.StartNew();
-        var clips = new List<CamClip>();
-        var errors = new List<ClipLoadError>();
-
-        foreach (var root in rootList)
-        {
-            var rootStopwatch = Stopwatch.StartNew();
-            Log.Debug("Scanning dashcam root. Root={Root}", root);
-
-            try
-            {
-                var rootClips = _clipLoader(root);
-                clips.AddRange(rootClips);
-                Log.Information(
-                    "Scanned dashcam root. Root={Root}; ClipCount={ClipCount}; ElapsedMs={ElapsedMs}",
-                    root,
-                    rootClips.Count,
-                    rootStopwatch.ElapsedMilliseconds);
-            }
-            catch (UnauthorizedAccessException ex)
-            {
-                Log.Error(ex, "Access denied while loading dashcam root. Root={Root}", root);
-                errors.Add(new ClipLoadError("Access Denied", $"Cannot access folder: {root}\n\nCheck that you have permission to read this location."));
-            }
-            catch (Exception ex)
-            {
-                Log.Error(ex, "Failed to load dashcam root. Root={Root}", root);
-                errors.Add(new ClipLoadError("Error Loading Clips", $"Failed to load clips from:\n{root}\n\nError: {ex.Message}"));
-            }
-        }
-
-        Log.Information(
-            "Finished loading dashcam clips. ClipCount={ClipCount}; RootCount={RootCount}; FailedRootCount={FailedRootCount}; ElapsedMs={ElapsedMs}",
-            clips.Count,
-            rootList.Count,
-            errors.Count,
-            totalStopwatch.ElapsedMilliseconds);
-        return new ScanResult(clips, errors, HadRoots: true);
-    }
-
-    private sealed record ScanResult(IReadOnlyList<CamClip> Clips, IReadOnlyList<ClipLoadError> Errors, bool HadRoots);
-
-    private sealed record ClipLoadError(string Title, string Details);
-
-    private void RefreshClipState()
-    {
-        // FilteredClips is intentionally NOT raised here: this runs on every clip change, and re-notifying the unchanged list rebuilds the ListBox and retriggers its fade (flicker).
-        // The list is notified explicitly only when it actually changes (load + FilterText).
-        OnPropertyChanged(nameof(HasNoClipSelected));
-        OnPropertyChanged(nameof(ShowStatusOverlay));
-        OnPropertyChanged(nameof(ShowVideoHosts));
-        OnPropertyChanged(nameof(CanPlayPause));
-        OnPropertyChanged(nameof(CanGoNext));
-        OnPropertyChanged(nameof(CanGoPrevious));
-    }
-
-    // Gated like Refresh: LoadClipsAsync has no re-entrancy protection, so picking a folder while a scan is still running would interleave two loads and merge both roots into one clip list.
-    [RelayCommand(CanExecute = nameof(CanRefreshClips))]
-    private async Task OpenFolderAsync()
-    {
-        Log.Debug("Opening folder picker");
-
-        var dialog = new OpenFolderDialog
-        {
-            Multiselect = true,
-            Title = "Select a folder containing Tesla dashcam footage (TeslaCam folder)",
-        };
-
-        if (dialog.ShowDialog() == true)
-        {
-            var folders = dialog.FolderNames;
-            Log.Information(
-                "User selected dashcam folders. FolderCount={FolderCount}; Folders={Folders}",
-                folders.Length,
-                folders);
-
-            if (_playerController is not null)
-            {
-                await _playerController.StopAsync();
-            }
-
-            _rootSource = () => folders;
-            await LoadClipsAsync(folders);
-        }
-        else
-        {
-            Log.Debug("Folder picker canceled");
-        }
-    }
-
-    [RelayCommand(CanExecute = nameof(CanRefreshClips))]
-    private async Task RefreshClipsAsync()
-    {
-        Log.Debug("Refreshing clips");
-
-        if (_playerController is not null)
-        {
-            await _playerController.StopAsync();
-        }
-
-        await LoadClipsAsync(_rootSource(), TimeSpan.FromMilliseconds(400));
-    }
-
-    private bool CanRefreshClips => !IsLoadingClips;
-
-    [RelayCommand]
-    private async Task PlayPauseAsync()
-    {
-        if (_playerController is not null)
-        {
-            await _playerController.TogglePlayPauseAsync();
-        }
-    }
-
-    [RelayCommand]
-    private async Task StopAsync()
-    {
-        if (_playerController is null)
-            return;
-
-        // A selection that is still waiting to load would otherwise start playing right after the stop.
-        _selectionCts?.Cancel();
-
-        await _playerController.StopAsync();
-        IsLoading = false;
-        SeekPosition = 0;
-        NowPlayingClip = null;
-    }
-
-    [RelayCommand(CanExecute = nameof(CanSeek))]
-    private async Task StepFrameBackwardAsync()
-    {
-        if (_playerController is not null)
-        {
-            await _playerController.StepFrameAsync(forward: false);
-        }
-    }
-
-    [RelayCommand(CanExecute = nameof(CanSeek))]
-    private async Task StepFrameForwardAsync()
-    {
-        if (_playerController is not null)
-        {
-            await _playerController.StepFrameAsync(forward: true);
-        }
-    }
-
-    [RelayCommand(CanExecute = nameof(HasEventMarker))]
-    private async Task JumpToEventAsync()
-    {
-        if (!HasEventMarker)
-            return;
-
-        Log.Debug("Jumping to event moment. Position={EventMarkerPosition}", EventMarkerPosition);
-        SeekPosition = EventMarkerPosition;
-        await SeekToCurrentPositionAsync();
-    }
+    public void InitializePlayer() => Playback.InitializePlayer();
 
     /// <summary>
-    /// Marks the selection start at the current playhead.
-    /// A mark that would invert the range (start at or past the existing end) clears the other mark instead of silently swapping.
+    /// True for the shortcuts that focus the clip search box (Ctrl+F, F3, or F6).
+    /// Shared with the view's tunneling PreviewKeyDown so it works regardless of which control currently has focus.
     /// </summary>
-    [RelayCommand(CanExecute = nameof(CanSeek))]
-    private void MarkSelectionStart()
-    {
-        IsTrimming = true;
-        _selectionStart = SeekPosition;
-        if (_selectionEnd is { } end && end <= SeekPosition)
-        {
-            _selectionEnd = null;
-        }
-
-        NotifySelectionChanged();
-    }
-
-    /// <summary>Marks the selection end at the current playhead (see <see cref="MarkSelectionStart"/> for the invariant).</summary>
-    [RelayCommand(CanExecute = nameof(CanSeek))]
-    private void MarkSelectionEnd()
-    {
-        IsTrimming = true;
-        _selectionEnd = SeekPosition;
-        if (_selectionStart is { } start && start >= SeekPosition)
-        {
-            _selectionStart = null;
-        }
-
-        NotifySelectionChanged();
-    }
-
-    [RelayCommand(CanExecute = nameof(HasAnySelectionMark))]
-    private void ClearSelection()
-    {
-        _selectionStart = null;
-        _selectionEnd = null;
-        NotifySelectionChanged();
-    }
-
-    /// <summary>The control-bar Trim button: opens the trim panel, or cancels an open one.</summary>
-    [RelayCommand(CanExecute = nameof(CanSeek))]
-    private void ToggleTrimming()
-    {
-        if (IsTrimming)
-        {
-            CancelTrim();
-        }
-        else
-        {
-            IsTrimming = true;
-        }
-    }
-
-    /// <summary>Closes the trim panel and discards any marks.</summary>
-    [RelayCommand]
-    private void CancelTrim()
-    {
-        IsTrimming = false;
-        if (HasAnySelectionMark)
-        {
-            ClearSelection();
-        }
-    }
-
-    /// <summary>True when either mark is set (drives the clear affordance).</summary>
-    public bool HasAnySelectionMark => _selectionStart.HasValue || _selectionEnd.HasValue;
-
-    // Everything downstream of CanSeek: the mark/export commands gate on it alongside the frame-step commands.
-    private void NotifyCanSeekChanged()
-    {
-        OnPropertyChanged(nameof(CanSeek));
-        OnPropertyChanged(nameof(CanExportSelection));
-        OnPropertyChanged(nameof(SelectionDurationText)); // scales with Duration
-        OnPropertyChanged(nameof(TrimHintText));
-        StepFrameBackwardCommand.NotifyCanExecuteChanged();
-        StepFrameForwardCommand.NotifyCanExecuteChanged();
-        MarkSelectionStartCommand.NotifyCanExecuteChanged();
-        MarkSelectionEndCommand.NotifyCanExecuteChanged();
-        ToggleTrimmingCommand.NotifyCanExecuteChanged();
-        ExportSelectionCommand.NotifyCanExecuteChanged();
-    }
-
-    private void NotifySelectionChanged()
-    {
-        OnPropertyChanged(nameof(SelectionStartPosition));
-        OnPropertyChanged(nameof(SelectionEndPosition));
-        OnPropertyChanged(nameof(HasSelectionStart));
-        OnPropertyChanged(nameof(HasSelectionEnd));
-        OnPropertyChanged(nameof(HasSelection));
-        OnPropertyChanged(nameof(HasAnySelectionMark));
-        OnPropertyChanged(nameof(CanExportSelection));
-        OnPropertyChanged(nameof(TrimHintText));
-        OnPropertyChanged(nameof(SelectionDurationText));
-        ClearSelectionCommand.NotifyCanExecuteChanged();
-        ExportSelectionCommand.NotifyCanExecuteChanged();
-    }
+    public static bool IsSearchFocusShortcut(Key key, ModifierKeys modifiers) =>
+        (key == Key.F && modifiers == ModifierKeys.Control) ||
+        ((key == Key.F3 || key == Key.F6) && modifiers == ModifierKeys.None);
 
-    [RelayCommand(CanExecute = nameof(CanExportSelection))]
-    private async Task ExportSelectionAsync()
+    /// <summary>Leaves the About page if shown and asks the view to focus the search box.</summary>
+    public void RequestSearchFocus()
     {
-        var clip = _playerController?.CurrentClip;
-        var mediaSource = _playerController?.OpenedMediaSource;
-        if (clip is null || mediaSource is null || mediaSource.Duration <= TimeSpan.Zero
-            || _selectionStart is not { } startFraction || _selectionEnd is not { } endFraction)
-        {
-            return;
-        }
-
-        var start = TimeSpan.FromSeconds(startFraction * mediaSource.Duration.TotalSeconds);
-        var end = TimeSpan.FromSeconds(endFraction * mediaSource.Duration.TotalSeconds);
-        var camera = ActiveExportCameraName;
-        var defaultFileName = $"{clip.Name} {CameraNames.DisplayName(camera)} {FormatTimeSpanForFileName(start)}-{FormatTimeSpanForFileName(end)}.mp4";
-
-        await ExportAsync(clip, mediaSource, camera, start, end, defaultFileName);
+        ShowAboutPage = false;
+        SearchBoxFocusRequested?.Invoke(this, EventArgs.Empty);
     }
 
     /// <summary>
-    /// Exports the front-camera footage around the clip's event moment (±<see cref="EventClipPadding"/>) in one step, with no in/out marks needed.
-    /// Works from the clip list context menu even when the clip isn't the one currently playing (its media source is built on demand).
+    /// Handles an app-wide shortcut and reports synchronously whether the key was one.
+    /// The view calls this from a tunneling key handler and must mark the key handled before any await, or a focused button would also act on it (Space clicks whatever button was last clicked).
     /// </summary>
-    [RelayCommand(CanExecute = nameof(CanSaveEventClip))]
-    private async Task SaveEventClipAsync(CamClip clip)
-    {
-        if (clip?.Event is null || clip.Event.Timestamp == default || IsExporting)
-        {
-            return;
-        }
-
-        ClipMediaSource mediaSource;
-        try
-        {
-            mediaSource = _playerController?.CurrentClip == clip ? _playerController.OpenedMediaSource : null;
-
-            // Building an unopened clip's source does real IO (probe every chunk, write ffconcat files) and can throw (drive unplugged, temp write fails).
-            // Unlike ExportSelectionAsync, nothing downstream caught it, so the fault escaped to the dispatcher; surface a normal "Export Failed" dialog instead.
-            mediaSource ??= await Task.Run(() => _exportMediaSourceBuilder.Build(clip));
-        }
-        catch (Exception ex)
-        {
-            Log.Error(ex, "Failed to build media source for event clip. ClipName={ClipName}; ClipPath={ClipPath}", clip.Name, clip.FullPath);
-            ShowError("Export Failed", $"Could not export clip: {clip.Name}\n\nError: {ex.Message}");
-            return;
-        }
-
-        var eventTime = mediaSource.Duration > TimeSpan.Zero ? mediaSource.ToMediaTime(clip.Event.Timestamp) : null;
-        if (eventTime is null)
-        {
-            ShowError("Export Failed", "The event moment isn't within this clip's saved footage.");
-            return;
-        }
-
-        var start = eventTime.Value - EventClipPadding;
-        if (start < TimeSpan.Zero)
-        {
-            start = TimeSpan.Zero;
-        }
-
-        var end = eventTime.Value + EventClipPadding;
-        if (end > mediaSource.Duration)
-        {
-            end = mediaSource.Duration;
-        }
-
-        await ExportAsync(clip, mediaSource, CameraNames.Front, start, end, $"{clip.Name} event.mp4");
-    }
-
-    private bool CanSaveEventClip(CamClip clip) =>
-        clip?.Event is not null && clip.Event.Timestamp != default && !IsExporting;
-
-    private async Task ExportAsync(CamClip clip, ClipMediaSource mediaSource, string camera, TimeSpan start, TimeSpan end, string defaultFileName)
+    public bool HandleKeyDown(Key key, ModifierKeys modifiers)
     {
-        var outputPath = _savePathPicker(SanitizeFileName(defaultFileName));
-        if (string.IsNullOrEmpty(outputPath))
-        {
-            return;
-        }
-
-        IsExporting = true;
-
-        try
-        {
-            Log.Information(
-                "Exporting clip range. Clip={ClipName}; Camera={Camera}; Start={Start}; End={End}; Output={Output}",
-                clip.Name,
-                camera,
-                start,
-                end,
-                outputPath);
-            await _clipExporter.ExportAsync(new ClipExportRequest(clip, mediaSource, camera, start, end, outputPath));
-            RevealInExplorer(outputPath);
-        }
-        catch (OperationCanceledException)
-        {
-        }
-        catch (Exception ex)
-        {
-            Log.Error(ex, "Export failed. Clip={ClipName}; Camera={Camera}; Output={Output}", clip.Name, camera, outputPath);
-            ShowError("Export Failed", $"Could not export clip: {clip.Name}\n\nError: {ex.Message}");
-        }
-        finally
+        var action = ResolveKeyAction(key, modifiers);
+        if (action is null)
         {
-            IsExporting = false;
+            return false;
         }
-    }
-
-    // The currently enlarged camera; grid view exports the front (primary) angle.
-    private string ActiveExportCameraName => SelectedCameraView == GridCameraView ? CameraNames.Front : SelectedCameraView;
 
-    private static string PickSavePathWithDialog(string defaultFileName)
-    {
-        var dialog = new SaveFileDialog
-        {
-            Title = "Export clip",
-            FileName = defaultFileName,
-            DefaultExt = ".mp4",
-            Filter = "MP4 video|*.mp4",
-        };
-
-        return dialog.ShowDialog() == true ? dialog.FileName : null;
+        _ = RunKeyActionAsync(action, key);
+        return true;
     }
 
-    /// <summary>Points Explorer at the exported file so it's immediately ready to share.
-    /// Overridable for tests.</summary>
-    internal Action<string> RevealInExplorer { get; set; } = path =>
-        Process.Start(new ProcessStartInfo("explorer.exe", $"/select,\"{path}\"") { UseShellExecute = true });
-
-    /// <summary>
-    /// Asks the user to confirm sending a clip to the Recycle Bin.
-    /// Returns true to proceed.
-    /// Overridable for tests; defaults to a yes/no message box.
-    /// </summary>
-    internal Func<CamClip, bool> ConfirmDeleteClip { get; set; } = clip =>
-        MessageBox.Show(
-            $"Move this clip to the Recycle Bin?\n\n{clip.Name}\n{clip.FullPath}",
-            "Delete clip",
-            MessageBoxButton.YesNo,
-            MessageBoxImage.Warning) == MessageBoxResult.Yes;
-
-    /// <summary>
-    /// Sends a clip folder to the Windows Recycle Bin (recoverable).
-    /// Overridable for tests; defaults to the shell recycle operation, which surfaces its own error dialog if a file is in use.
-    /// </summary>
-    internal Action<string> RecycleClipFolder { get; set; } = path =>
-        FileSystem.DeleteDirectory(path, UIOption.OnlyErrorDialogs, RecycleOption.SendToRecycleBin);
-
-    private static string FormatTimeSpanForFileName(TimeSpan ts) => FormatTimeSpan(ts).Replace(':', '.');
-
-    private static string SanitizeFileName(string name)
+    /// <summary>Awaitable form of <see cref="HandleKeyDown"/> for callers (tests) that need the shortcut's work to have finished.</summary>
+    public async Task<bool> HandleKeyDownAsync(Key key, ModifierKeys modifiers)
     {
-        foreach (var invalid in Path.GetInvalidFileNameChars())
+        var action = ResolveKeyAction(key, modifiers);
+        if (action is null)
         {
-            name = name.Replace(invalid, '_');
+            return false;
         }
 
-        return name;
-    }
-
-    [RelayCommand]
-    private async Task PreviousAsync()
-    {
-        if (_playerController is null)
-            return;
-
-        await _playerController.PreviousAsync();
-        SelectedClip = _playerController.CurrentClip;
+        await action();
+        return true;
     }
 
     [RelayCommand]
-    private async Task NextAsync()
+    private void ToggleAbout()
     {
-        if (_playerController is null)
-            return;
-
-        await _playerController.NextAsync();
-        SelectedClip = _playerController.CurrentClip;
+        ShowAboutPage = !ShowAboutPage;
     }
 
     [RelayCommand]
     private async Task DownloadFFmpegAsync()
     {
-        IsLoading = true;
-        ClearError();
+        SetDownloadingFFmpeg(true);
+        Error.Clear();
 
         try
         {
@@ -1086,7 +230,7 @@ private async Task DownloadFFmpegAsync()
             if (_flyleafRuntime.TryStart())
             {
                 InitializePlayer();
-                await LoadClipsAsync(_rootSource());
+                await Library.ReloadAsync();
             }
             else
             {
@@ -1096,114 +240,26 @@ private async Task DownloadFFmpegAsync()
         catch (Exception ex)
         {
             Log.Error(ex, "Failed to download FFmpeg");
-            ShowError("Download Failed", $"Failed to download FFmpeg: {ex.Message}");
-            ShowFFmpegDownloadButton = true;
-        }
-        finally
-        {
-            IsLoading = false;
-        }
-    }
-
-    private async Task PlaySelectedClipAsync(CamClip clip, CancellationToken cancellationToken)
-    {
-        if (clip is null || _playerController is null)
-            return;
-
-        ClearError();
-        IsLoading = true;
-        await _backgroundYield();
-
-        // A newer selection superseded this one while we yielded, so drop it and let the latest win and the selection doesn't rubber-band backwards as earlier, slower loads complete.
-        if (cancellationToken.IsCancellationRequested || !ReferenceEquals(clip, SelectedClip))
-        {
-            // A newer selection's own load owns IsLoading now, but if the selection was cleared outright (deselect, or a filter dropping the clip), no load is in flight and nothing else ever resets the flag, leaving a permanent "Loading…" overlay over the video pane.
-            if (SelectedClip is null)
-            {
-                IsLoading = false;
-            }
-
-            return;
-        }
-
-        try
-        {
-            await _playerController.GoToClipAsync(clip);
-
-            if (cancellationToken.IsCancellationRequested)
-                return;
-
-            // Auto-focus the camera that triggered the event (Full metadata mode).
-            if (clip.Event is not null)
-            {
-                SelectedCameraView = CameraIdToView(clip.Event.Camera);
-            }
-        }
-        catch (Exception ex)
-        {
-            if (cancellationToken.IsCancellationRequested)
-            {
-                // Same stuck-overlay guard as the pre-load early-return above.
-                if (SelectedClip is null)
-                {
-                    IsLoading = false;
-                }
-
-                return;
-            }
-
-            IsLoading = false;
-            Log.Error(
-                ex,
-                "Failed to play selected clip. ClipName={ClipName}; ClipPath={ClipPath}",
-                clip.Name,
-                clip.FullPath);
-            ShowError("Playback Failed", $"Could not play clip: {clip.Name}\n\nError: {ex.Message}");
-        }
-    }
-
-    /// <summary>
-    /// True for the shortcuts that focus the clip search box (Ctrl+F, F3, or F6).
-    /// Shared with the view's tunneling PreviewKeyDown so it works regardless of which control currently has focus.
-    /// </summary>
-    public static bool IsSearchFocusShortcut(Key key, ModifierKeys modifiers) =>
-        (key == Key.F && modifiers == ModifierKeys.Control) ||
-        ((key == Key.F3 || key == Key.F6) && modifiers == ModifierKeys.None);
-
-    /// <summary>Leaves the About page if shown and asks the view to focus the search box.</summary>
-    public void RequestSearchFocus()
-    {
-        ShowAboutPage = false;
-        SearchBoxFocusRequested?.Invoke(this, EventArgs.Empty);
-    }
-
-    /// <summary>
-    /// Handles an app-wide shortcut and reports synchronously whether the key was one.
-    /// The view calls this from a tunneling key handler and must mark the key handled before any await, or a focused button would also act on it (Space clicks whatever button was last clicked).
-    /// </summary>
-    public bool HandleKeyDown(Key key, ModifierKeys modifiers)
-    {
-        var action = ResolveKeyAction(key, modifiers);
-        if (action is null)
+            Error.Show("Download Failed", $"Failed to download FFmpeg: {ex.Message}");
+            Error.ShowFFmpegDownloadButton = true;
+        }
+        finally
         {
-            return false;
+            SetDownloadingFFmpeg(false);
         }
-
-        _ = RunKeyActionAsync(action, key);
-        return true;
     }
 
-    /// <summary>Awaitable form of <see cref="HandleKeyDown"/> for callers (tests) that need the shortcut's work to have finished.</summary>
-    public async Task<bool> HandleKeyDownAsync(Key key, ModifierKeys modifiers)
+    private void SetDownloadingFFmpeg(bool value)
     {
-        var action = ResolveKeyAction(key, modifiers);
-        if (action is null)
-        {
-            return false;
-        }
+        _isDownloadingFFmpeg = value;
+        NotifyLoadingChanged();
+    }
 
-        await action();
-        return true;
+    private void ShowFFmpegMissingError()
+    {
+        Log.Debug("Showing FFmpeg missing prompt");
+        Error.ShowFFmpegDownloadButton = true;
+        Error.Show("FFmpeg Required", "FFmpeg is required to play clips. This will download about 80MB.", canDismiss: false);
     }
 
     private static async Task RunKeyActionAsync(Func<Task> action, Key key)
@@ -1250,36 +306,36 @@ private Func<Task> ResolveKeyAction(Key key, ModifierKeys modifiers)
                 _ => 0,
             };
 
-            var numberedOption = CameraViewOptions.FirstOrDefault(option => option.ShortcutNumber == shortcutNumber);
+            var numberedOption = Cameras.CameraViewOptions.FirstOrDefault(option => option.ShortcutNumber == shortcutNumber);
             if (numberedOption is not null)
             {
-                return Run(() => SelectCameraView(numberedOption.ViewId));
+                return Run(() => Cameras.SelectCameraViewCommand.Execute(numberedOption.ViewId));
             }
 
-            if (key == Key.E && HasEventMarker)
+            if (key == Key.E && Playback.HasEventMarker)
             {
-                return JumpToEventAsync;
+                return () => Playback.JumpToEventCommand.ExecuteAsync(null);
             }
 
-            if (key == Key.I && CanSeek)
+            if (key == Key.I && Playback.CanSeek)
             {
-                return Run(MarkSelectionStart);
+                return Run(() => Trim.MarkSelectionStartCommand.Execute(null));
             }
 
-            if (key == Key.O && CanSeek)
+            if (key == Key.O && Playback.CanSeek)
             {
-                return Run(MarkSelectionEnd);
+                return Run(() => Trim.MarkSelectionEndCommand.Execute(null));
             }
 
-            if (key == Key.Escape && IsTrimming)
+            if (key == Key.Escape && Trim.IsTrimming)
             {
-                return Run(CancelTrim);
+                return Run(() => Trim.CancelTrimCommand.Execute(null));
             }
         }
 
-        if (key == Key.E && modifiers == ModifierKeys.Control && CanExportSelection)
+        if (key == Key.E && modifiers == ModifierKeys.Control && Trim.CanExportSelection)
         {
-            return ExportSelectionAsync;
+            return () => Trim.ExportSelectionCommand.ExecuteAsync(null);
         }
 
         // Shift+, / Shift+. (i.e. < / >) step the playback speed, YouTube-style.
@@ -1288,30 +344,29 @@ private Func<Task> ResolveKeyAction(Key key, ModifierKeys modifiers)
         {
             if (key == Key.OemComma)
             {
-                return Run(DecreaseSpeed);
+                return Run(() => Playback.DecreaseSpeedCommand.Execute(null));
             }
 
             if (key == Key.OemPeriod)
             {
-                return Run(IncreaseSpeed);
+                return Run(() => Playback.IncreaseSpeedCommand.Execute(null));
             }
         }
 
-        var controller = _playerController;
-        if (controller is null)
+        if (!Playback.HasPlayer)
         {
             return null;
         }
 
         return key switch
         {
-            Key.Space => controller.TogglePlayPauseAsync,
-            Key.OemComma when modifiers == ModifierKeys.None && CanSeek => () => controller.StepFrameAsync(forward: false),
-            Key.OemPeriod when modifiers == ModifierKeys.None && CanSeek => () => controller.StepFrameAsync(forward: true),
-            Key.Left when modifiers == ModifierKeys.Control => CanGoPrevious ? PreviousAsync : Run(() => { }),
-            Key.Right when modifiers == ModifierKeys.Control => CanGoNext ? NextAsync : Run(() => { }),
-            Key.Left => () => SeekRelativeAsync(TimeSpan.FromSeconds(-5)),
-            Key.Right => () => SeekRelativeAsync(TimeSpan.FromSeconds(5)),
+            Key.Space => Playback.TogglePlayPauseAsync,
+            Key.OemComma when modifiers == ModifierKeys.None && Playback.CanSeek => () => Playback.StepFrameAsync(forward: false),
+            Key.OemPeriod when modifiers == ModifierKeys.None && Playback.CanSeek => () => Playback.StepFrameAsync(forward: true),
+            Key.Left when modifiers == ModifierKeys.Control => Playback.CanGoPrevious ? () => Playback.PreviousCommand.ExecuteAsync(null) : Run(() => { }),
+            Key.Right when modifiers == ModifierKeys.Control => Playback.CanGoNext ? () => Playback.NextCommand.ExecuteAsync(null) : Run(() => { }),
+            Key.Left => () => Playback.SeekRelativeAsync(TimeSpan.FromSeconds(-5)),
+            Key.Right => () => Playback.SeekRelativeAsync(TimeSpan.FromSeconds(5)),
             _ => null,
         };
 
@@ -1322,481 +377,49 @@ static Func<Task> Run(Action action) => () =>
         };
     }
 
-    private Task SeekRelativeAsync(TimeSpan offset)
-    {
-        if (_playerController is not { } controller || !CanSeek)
-        {
-            return Task.CompletedTask;
-        }
-
-        return controller.SeekByAsync(offset);
-    }
-
-    public void BeginSeek()
-    {
-        if (CanSeek)
-        {
-            _seekGeneration++;
-            _isSeeking = true;
-            _scrubCoalescer.Reset();
-
-            // Holds playback paused for the gesture, so each scrub is one cheap paused seek and the release resumes every camera together.
-            // The controller serializes this ahead of the first scrub seek, so it needs no await here.
-            _ = _playerController.BeginScrubAsync();
-        }
-    }
-
-    public async Task EndSeekAsync()
-    {
-        var generation = _seekGeneration;
-
-        if (_playerController is null || !CanSeek)
-        {
-            _isSeeking = false;
-            return;
-        }
-
-        // The gesture is over: drop any scrub value still queued in the coalescer.
-        // When the in-flight scrub completes it would otherwise re-issue that value as a keyframe seek AFTER the accurate seek below (both queue on the controller's serialized-operation lock in that order), leaving the playhead on a keyframe instead of the release point.
-        _scrubCoalescer.CancelPending();
-
-        // _isSeeking stays true until the release seek completes, so the position sync can't pull the thumb back while a scrub seek winds down.
-        // The release seek queues behind any in-flight scrub on the controller's serialized-operation lock, so it always lands last.
-        await _playerController.EndScrubAsync(CurrentSeekTargetPosition());
-
-        // Only the latest gesture's completion may end the seeking state: if the user has already grabbed the thumb again, this completion is stale and their new drag owns the flag.
-        if (generation == _seekGeneration)
-        {
-            _isSeeking = false;
-        }
-    }
-
-    /// <summary>
-    /// Called on every seek-bar value change.
-    /// While a seek gesture is active (<see cref="_isSeeking"/>, set by <see cref="BeginSeek"/> on mouse-down for clicks and drags alike), each value feeds the scrub coalescer so the video follows the thumb in near-real-time.
-    /// A plain click therefore issues one scrub seek too; the accurate seek from <see cref="EndSeekAsync"/> runs behind the same serialized lock and always lands last.
-    /// Value changes from playback position sync arrive with <see cref="_isSeeking"/> false and are ignored.
-    /// </summary>
-    public void OnSeekSliderValueChanged()
-    {
-        if (!_isSeeking)
-            return;
-
-        OnPropertyChanged(nameof(PositionText));
-
-        if (CanSeek)
-        {
-            _scrubCoalescer.OnDragValueChanged(CurrentSeekTargetPosition());
-        }
-    }
-
-    private async Task SeekToCurrentPositionAsync()
-    {
-        if (_playerController is null)
-            return;
-
-        var duration = _playerController.Duration;
-        if (duration.TotalSeconds > 0)
-        {
-            await _playerController.SeekAsync(CurrentSeekTargetPosition());
-        }
-    }
-
-    private Task ScrubToAsync(TimeSpan position) =>
-        _playerController?.ScrubSeekAsync(position) ?? Task.CompletedTask;
-
-    private TimeSpan CurrentSeekTargetPosition()
-    {
-        var duration = _playerController?.Duration ?? TimeSpan.Zero;
-        return TimeSpan.FromSeconds(SeekPosition * duration.TotalSeconds);
-    }
-
-    // Derives the seek-bar overlays for the selected clip: the event moment, the interior chunk-boundary ticks, and gap ticks (mapped onto the 0..1 seek axis).
-    // Nulls out cleanly when the selection is cleared or the clip has no usable event metadata.
-    //
-    // Prefers the controller's actually-opened ClipMediaSource when it belongs to this clip: that source has real probed durations and gap-aware wall-clock mapping (see ClipMediaSource.ToMediaTime), so its positions match what's actually playing.
-    // Selecting a clip is synchronous but opening its media is not, so immediately after selection (or for a clip that never opens, e.g. in tests with no controller) there is no opened source yet; a ClipTimeline estimate (uniform assumed chunk length) is used as a same-frame placeholder so the markers don't flash empty, and is superseded once OpenedMediaSource changes.
-    private void RecomputeSelectedClipTimeline()
-    {
-        var clip = SelectedClip;
-        if (clip is null)
-        {
-            _eventPosition = null;
-            _chunkBoundaries = [];
-            _gapPositions = [];
-            return;
-        }
-
-        var mediaSource = _playerController?.CurrentClip == clip ? _playerController?.OpenedMediaSource : null;
-
-        if (mediaSource is not null && mediaSource.Duration > TimeSpan.Zero)
-        {
-            RecomputeFromMediaSource(clip, mediaSource);
-        }
-        else
-        {
-            RecomputeFromEstimatedTimeline(clip);
-        }
-    }
-
-    private void RecomputeFromMediaSource(CamClip clip, ClipMediaSource mediaSource)
-    {
-        var durationSeconds = mediaSource.Duration.TotalSeconds;
-
-        _chunkBoundaries = mediaSource.ChunkStarts.Count < 2
-            ? []
-            : mediaSource.ChunkStarts.Skip(1).Select(start => start.TotalSeconds / durationSeconds).ToList();
-
-        _gapPositions = mediaSource.GapPositions
-            .Select(position => position.TotalSeconds / durationSeconds)
-            .ToList();
-
-        var camEvent = clip.Event;
-        if (camEvent is null || camEvent.Timestamp == default)
-        {
-            _eventPosition = null;
-            return;
-        }
-
-        // Fraction 0 is a real position: an event that fired on the first recorded frame (or one snapped forward to the start of the footage) still deserves its marker.
-        var mediaTime = mediaSource.ToMediaTime(camEvent.Timestamp);
-        var fraction = mediaTime?.TotalSeconds / durationSeconds;
-        _eventPosition = fraction is >= 0 and <= 1 ? fraction : null;
-    }
-
-    // Fallback used before the selected clip's media has actually been opened (or when it never will be, e.g. no controller in tests): the legacy uniform-chunk-length estimate.
-    // Carries no gap information, since gaps can only be known once the builder has probed real durations.
-    private void RecomputeFromEstimatedTimeline(CamClip clip)
-    {
-        var timeline = new ClipTimeline(clip.Chunks);
-        _chunkBoundaries = timeline.Count < 2
-            ? []
-            : Enumerable.Range(1, timeline.Count - 1).Select(i => (double)i / timeline.Count).ToList();
-        _gapPositions = [];
-
-        var camEvent = clip.Event;
-        if (camEvent is null || camEvent.Timestamp == default || clip.Chunks.Count == 0 || timeline.Duration <= TimeSpan.Zero)
-        {
-            _eventPosition = null;
-            return;
-        }
-
-        // The event landing at or after the start and no later than the modeled end is markable (exactly 0 = the event fired on the first recorded frame); clock skew (fraction < 0) or an event past the estimate (> 1) yields no marker.
-        var fraction = (camEvent.Timestamp - clip.Chunks[0].Timestamp).TotalSeconds / timeline.Duration.TotalSeconds;
-        _eventPosition = fraction is >= 0 and <= 1 ? fraction : null;
-    }
-
-    private void UpdateSeekPositionFromController()
+    private void OnLibraryPropertyChanged(object sender, PropertyChangedEventArgs e)
     {
-        if (_playerController is null || _isSeeking)
-            return;
-
-        var duration = _playerController.Duration;
-        SeekPosition = duration.TotalSeconds > 0
-            ? Math.Clamp(_playerController.Position.TotalSeconds / duration.TotalSeconds, 0, 1)
-            : 0;
-    }
-
-    private void PlayerControllerOnPropertyChanged(object sender, PropertyChangedEventArgs e)
-    {
-        if (string.IsNullOrWhiteSpace(e.PropertyName))
-            return;
-
-        RunOnUiThread(() => HandlePlayerControllerPropertyChanged(e.PropertyName));
-    }
-
-    private void HandlePlayerControllerPropertyChanged(string propertyName)
-    {
-        if (_playerController is null)
-            return;
-
-        switch (propertyName)
+        switch (e.PropertyName)
         {
-            case nameof(VideoPlayerController.IsLoading):
-                IsLoading = _playerController.IsLoading;
-                break;
-
-            case nameof(VideoPlayerController.IsPlaying):
-                IsPlaying = _playerController.IsPlaying;
-                break;
-
-            case nameof(VideoPlayerController.Duration):
-                UpdateSeekPositionFromController();
-                OnPropertyChanged(nameof(DurationText));
-                OnPropertyChanged(nameof(PositionText));
-                NotifyCanSeekChanged();
+            case nameof(ClipLibraryViewModel.SelectedClip):
+                OnSelectedClipChanged(Library.SelectedClip);
+                OnPropertyChanged(nameof(HasNoClipSelected));
+                OnPropertyChanged(nameof(ShowStatusOverlay));
+                OnPropertyChanged(nameof(ShowVideoHosts));
                 break;
 
-            case nameof(VideoPlayerController.Position):
-                UpdateSeekPositionFromController();
+            case nameof(ClipLibraryViewModel.IsLoadingClips):
+                NotifyLoadingChanged();
                 break;
-
-            case nameof(VideoPlayerController.OpenedMediaSource):
-                // The controller finished (re)building the media source for the selected clip (or one under recovery from a corrupt chunk) -- refresh the gap-aware overlays now that real probed durations/timestamps are available.
-                // A rebuild can reshape the timeline (chunks excluded during recovery), so in/out fractions marked against the old timeline no longer point at the same footage.
-                if (HasAnySelectionMark)
-                {
-                    ClearSelection();
-                }
-
-                RecomputeSelectedClipTimeline();
-                OnPropertyChanged(nameof(EventMarkerPosition));
-                OnPropertyChanged(nameof(HasEventMarker));
-                OnPropertyChanged(nameof(EventMarkerTooltip));
-                OnPropertyChanged(nameof(ChunkBoundaries));
-                OnPropertyChanged(nameof(GapPositions));
-                JumpToEventCommand.NotifyCanExecuteChanged();
-                break;
-
-            case nameof(VideoPlayerController.ErrorMessage):
-                if (_playerController.ErrorMessage is not null)
-                {
-                    ShowError("Playback Error", _playerController.ErrorMessage);
-                }
-
-                break;
-
-            case nameof(VideoPlayerController.CurrentClip):
-                SelectedClip = _playerController.CurrentClip;
-                NowPlayingClip = _playerController.CurrentClip;
-                RefreshClipState();
-                break;
-
-            case nameof(VideoPlayerController.IsMediaOpen):
-                NotifyCanSeekChanged();
-                break;
-        }
-    }
-
-    internal static string FormatTimeSpan(TimeSpan ts)
-    {
-        return ts.TotalHours >= 1
-            ? ts.ToString(@"h\:mm\:ss")
-            : ts.ToString(@"m\:ss");
-    }
-
-    private static string FormatVersion(Version version)
-    {
-        if (version is null)
-        {
-            return "Unknown";
-        }
-
-        if (version.Revision >= 0)
-        {
-            return version.ToString(4);
-        }
-
-        return version.Build >= 0
-            ? version.ToString(3)
-            : version.ToString(2);
-    }
-
-    private void ShowError(string title, string details, bool canDismiss = true, bool isEmptyState = false)
-    {
-        ErrorTitle = title;
-        ErrorDetails = details;
-        CanDismissError = canDismiss;
-        IsEmptyState = isEmptyState;
-        ShowErrorOverlay = true;
-    }
-
-    private void ClearError()
-    {
-        ShowErrorOverlay = false;
-        ShowFFmpegDownloadButton = false;
-        CanDismissError = true;
-        IsEmptyState = false;
-        ErrorTitle = null;
-        ErrorDetails = null;
-    }
-
-    [RelayCommand]
-    private void DismissError()
-    {
-        ClearError();
-    }
-
-    private void ShowFFmpegMissingError()
-    {
-        Log.Debug("Showing FFmpeg missing prompt");
-        ShowFFmpegDownloadButton = true;
-        ShowError("FFmpeg Required", "FFmpeg is required to play clips. This will download about 80MB.", canDismiss: false);
-    }
-
-    [RelayCommand]
-    private void ToggleAbout()
-    {
-        ShowAboutPage = !ShowAboutPage;
-    }
-
-    [RelayCommand]
-    private void ClearFilter()
-    {
-        FilterText = string.Empty;
-    }
-
-    [RelayCommand]
-    private void SelectCameraView(string cameraView)
-    {
-        // Unknown views and cameras the current clip didn't record fall back to the front (primary) angle, which every playable clip has.
-        SelectedCameraView = IsAvailableView(cameraView) ? cameraView : CameraNames.Front;
-    }
-
-    // Maps a Tesla event.json camera id to the camera view to auto-focus.
-    // Ids follow the community-documented map (0 front, 3/4 repeaters, 5/6 B-pillars, 7 rear; 1/2/8 are the non-recorded fisheye/narrow/cabin).
-    // Unknown ids and cameras this clip didn't record fall back to the front (primary) angle.
-    internal string CameraIdToView(int cameraId)
-    {
-        var camera = cameraId switch
-        {
-            3 => CameraNames.LeftRepeater,
-            4 => CameraNames.RightRepeater,
-            5 => CameraNames.LeftPillar,
-            6 => CameraNames.RightPillar,
-            7 => CameraNames.Back,
-            _ => CameraNames.Front,
-        };
-
-        return IsAvailableView(camera) ? camera : CameraNames.Front;
-    }
-
-    private async Task UpdateLatestReleaseAsync()
-    {
-        var result = await _updateService.CheckForUpdateAsync(CurrentVersion);
-        LatestRelease = result.LatestRelease;
-        IsUpdateAvailable = result.IsUpdateAvailable;
-
-        Log.Information(
-            "Checked for updates. CurrentVersion={CurrentVersion}; LatestVersion={LatestVersion}; IsUpdateAvailable={IsUpdateAvailable}",
-            FormatVersion(CurrentVersion),
-            LatestVersionText,
-            IsUpdateAvailable);
-    }
-
-    private static bool CanUseClip(CamClip clip)
-    {
-        return clip is not null;
-    }
-
-    [RelayCommand(CanExecute = nameof(CanUseClip))]
-    private void OpenClipFolder(CamClip clip)
-    {
-        if (clip is null)
-        {
-            return;
-        }
-
-        if (!Directory.Exists(clip.FullPath))
-        {
-            ShowError("Clip Folder Not Found", $"Could not find folder:\n{clip.FullPath}");
-            return;
-        }
-
-        Process.Start(new ProcessStartInfo(clip.FullPath)
-        {
-            UseShellExecute = true,
-        });
-    }
-
-    [RelayCommand(CanExecute = nameof(CanUseClip))]
-    private void CopyClipPath(CamClip clip)
-    {
-        if (clip is not null)
-        {
-            Clipboard.SetText(clip.FullPath);
-        }
-    }
-
-    [RelayCommand(CanExecute = nameof(CanUseClip))]
-    private void CopyClipName(CamClip clip)
-    {
-        if (clip is not null)
-        {
-            Clipboard.SetText(clip.Name);
         }
     }
 
-    [RelayCommand(CanExecute = nameof(CanUseClip))]
-    private void CopyTimestamp(CamClip clip)
+    private void OnPlaybackPropertyChanged(object sender, PropertyChangedEventArgs e)
     {
-        if (clip is not null)
+        if (e.PropertyName == nameof(PlaybackViewModel.IsLoading))
         {
-            // Invariant (24-hour, culture-stable) so the copied value matches the clip name and is paste-searchable, unlike the ambiguous AM/PM current-culture rendering.
-            Clipboard.SetText(clip.Timestamp.ToString(CultureInfo.InvariantCulture));
+            NotifyLoadingChanged();
         }
     }
 
-    /// <summary>
-    /// Sends the clip's folder to the Recycle Bin so the timeline can be tidied without leaving the app.
-    /// Confirms first, then, if the clip is the one currently open, stops playback so Flyleaf releases its file handles before the shell tries to recycle the (otherwise locked) folder.
-    /// </summary>
-    [RelayCommand(CanExecute = nameof(CanUseClip))]
-    private async Task DeleteClipAsync(CamClip clip)
+    private void OnSelectedClipChanged(CamClip value)
     {
-        if (clip is null || !ConfirmDeleteClip(clip))
-        {
-            return;
-        }
-
-        // Flyleaf keeps the current clip's camera files open; Windows can't recycle a folder whose files are still locked, so stop and close the players before deleting it.
-        var isCurrent = ReferenceEquals(SelectedClip, clip)
-            || ReferenceEquals(NowPlayingClip, clip)
-            || _playerController?.CurrentClip == clip;
-        if (isCurrent && _playerController is not null)
-        {
-            await _playerController.StopAsync();
-            SeekPosition = 0;
-        }
-
-        try
-        {
-            Log.Information("Deleting clip to Recycle Bin. ClipName={ClipName}; ClipPath={ClipPath}", clip.Name, clip.FullPath);
-            await Task.Run(() => RecycleClipFolder(clip.FullPath));
-        }
-        catch (Exception ex)
-        {
-            Log.Error(ex, "Failed to delete clip. ClipName={ClipName}; ClipPath={ClipPath}", clip.Name, clip.FullPath);
-            ShowError("Delete Failed", $"Could not delete clip: {clip.Name}\n\nError: {ex.Message}");
-            return;
-        }
-
-        // Drop it from the sidebar list and keep the player's Next/Previous playlist in sync.
-        _allClips.Remove(clip);
-        _playerController?.RemoveClip(clip);
-
-        if (ReferenceEquals(NowPlayingClip, clip))
-        {
-            NowPlayingClip = null;
-        }
+        Cameras.ShowCamerasOf(value);
 
-        if (ReferenceEquals(SelectedClip, clip))
-        {
-            SelectedClip = null;
-        }
+        // In/out marks are fractions of the previous clip's timeline; they mean nothing on the new one, and a trim panel guiding a cut of the old clip would now be lying.
+        Trim.CancelTrimCommand.Execute(null);
 
-        OnPropertyChanged(nameof(FilteredClips));
-        OnPropertyChanged(nameof(ClipCount));
-        RefreshClipState();
+        Playback.Select(value);
     }
 
-    [RelayCommand(CanExecute = nameof(CanShowOnMap))]
-    private void ShowOnMap(CamClip clip)
+    private void NotifyLoadingChanged()
     {
-        if (clip?.Event is null || !ClipDisplay.HasLocation(clip.Event))
-        {
-            return;
-        }
-
-        var lat = clip.Event.EstLat.ToString(CultureInfo.InvariantCulture);
-        var lon = clip.Event.EstLon.ToString(CultureInfo.InvariantCulture);
-        Process.Start(new ProcessStartInfo($"https://www.google.com/maps?q={lat},{lon}") { UseShellExecute = true });
+        OnPropertyChanged(nameof(IsLoading));
+        OnPropertyChanged(nameof(ShowStatusOverlay));
+        OnPropertyChanged(nameof(ShowVideoHosts));
+        OnPropertyChanged(nameof(HasNoClipSelected));
     }
 
-    private static bool CanShowOnMap(CamClip clip) => clip?.Event is not null && ClipDisplay.HasLocation(clip.Event);
-
-    private void RunOnUiThread(Action action) => _uiInvoker(action);
-
     private void InvokeOnDispatcher(Action action)
     {
         if (_dispatcher.CheckAccess())
@@ -1808,70 +431,4 @@ private void InvokeOnDispatcher(Action action)
         // Never block the caller: a synchronous hop from a background thread while the UI thread waits on that thread is a deadlock.
         _dispatcher.BeginInvoke(action);
     }
-
-    partial void OnSelectedClipChanged(CamClip value)
-    {
-        // Rebuild the camera tiles from what this clip actually recorded (four on HW3, six on HW4/AI4).
-        // If the previously watched camera doesn't exist here, fall back to the front.
-        CameraViewOptions = BuildCameraViewOptions(value);
-        if (IsAvailableView(SelectedCameraView))
-        {
-            // Same view id as before, but the option objects are new, so re-mark the selected one.
-            SyncCameraViewSelection();
-        }
-        else
-        {
-            SelectedCameraView = CameraNames.Front;
-        }
-
-        // In/out marks are fractions of the previous clip's timeline; they mean nothing on the new one, and a trim panel guiding a cut of the old clip would now be lying.
-        CancelTrim();
-
-        RecomputeSelectedClipTimeline();
-        OnPropertyChanged(nameof(EventMarkerPosition));
-        OnPropertyChanged(nameof(HasEventMarker));
-        OnPropertyChanged(nameof(EventMarkerTooltip));
-        OnPropertyChanged(nameof(ChunkBoundaries));
-        OnPropertyChanged(nameof(GapPositions));
-        JumpToEventCommand.NotifyCanExecuteChanged();
-
-        // Cancel any in-flight selection load so quickly arrowing through the list doesn't open every clip in turn (which would also drag the selection backwards until the queue drained).
-        _selectionCts?.Cancel();
-        _selectionCts?.Dispose();
-        _selectionCts = null;
-
-        if (value is not null)
-        {
-            _selectionCts = new CancellationTokenSource();
-
-            // Show the now-playing badge on the newly clicked clip right away, instead of only once its media finishes opening.
-            NowPlayingClip = value;
-
-            Log.Debug(
-                "Selected clip changed. ClipName={ClipName}; ClipPath={ClipPath}",
-                value.Name,
-                value.FullPath);
-            _ = PlaySelectedClipAsync(value, _selectionCts.Token);
-        }
-    }
-
-    partial void OnPlaybackSpeedChanged(double value)
-    {
-        if (_playerController is not null)
-        {
-            Log.Information("Playback speed changed. Speed={PlaybackSpeed}", value);
-            _playerController.PlaybackSpeed = value;
-        }
-    }
-
-    [RelayCommand(CanExecute = nameof(CanIncreaseSpeed))]
-    private void IncreaseSpeed() =>
-        PlaybackSpeed = PlaybackSpeedSteps.FirstOrDefault(step => step > PlaybackSpeed, PlaybackSpeedSteps[^1]);
-
-    [RelayCommand(CanExecute = nameof(CanDecreaseSpeed))]
-    private void DecreaseSpeed() =>
-        PlaybackSpeed = PlaybackSpeedSteps.LastOrDefault(step => step < PlaybackSpeed, PlaybackSpeedSteps[0]);
-
-    [RelayCommand]
-    private void ResetSpeed() => PlaybackSpeed = 1.0;
 }
diff --git a/SentryDeck/ViewModels/AboutViewModel.cs b/SentryDeck/ViewModels/AboutViewModel.cs
new file mode 100644
index 0000000..336d471
--- /dev/null
+++ b/SentryDeck/ViewModels/AboutViewModel.cs
@@ -0,0 +1,82 @@
+using System.Reflection;
+using System.Runtime.InteropServices;
+using CommunityToolkit.Mvvm.ComponentModel;
+using Serilog;
+
+namespace SentryDeck;
+
+/// <summary>
+/// What the About and help page shows: this build's version and environment, and whether a newer release is out.
+/// </summary>
+public sealed partial class AboutViewModel : ObservableObject
+{
+    private readonly UpdateService _updateService = new();
+
+    public Version CurrentVersion => Assembly.GetExecutingAssembly().GetName().Version ?? new Version(0, 0, 0);
+
+    public string FileVersion => FormatVersion(CurrentVersion);
+
+    public string RuntimeDescription => $"{RuntimeInformation.FrameworkDescription} ({RuntimeInformation.ProcessArchitecture})";
+
+    public string OsDescription => RuntimeInformation.OSDescription;
+
+    public string ExecutablePath => Environment.ProcessPath;
+
+    public bool HasUpdateBadge => IsUpdateAvailable;
+
+    public string LatestVersionText => LatestRelease is null ? "Unknown" : FormatVersion(LatestRelease.Version);
+
+    public string LatestReleaseUrl => LatestRelease?.ReleaseUrl ?? UpdateService.ReleasesPageUrl;
+
+    public string ReleasesPageUrl => UpdateService.ReleasesPageUrl;
+
+    public string UpdateStatusTitle => IsUpdateAvailable
+        ? "Update available"
+        : "You're up to date";
+
+    public string UpdateStatusDetails => IsUpdateAvailable
+        ? $"Version {LatestVersionText} is available."
+        : "No newer release was found.";
+
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(HasUpdateBadge))]
+    [NotifyPropertyChangedFor(nameof(UpdateStatusTitle))]
+    [NotifyPropertyChangedFor(nameof(UpdateStatusDetails))]
+    private bool _isUpdateAvailable;
+
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(LatestVersionText))]
+    [NotifyPropertyChangedFor(nameof(LatestReleaseUrl))]
+    [NotifyPropertyChangedFor(nameof(UpdateStatusDetails))]
+    private UpdateRelease _latestRelease;
+
+    public async Task CheckForUpdatesAsync()
+    {
+        var result = await _updateService.CheckForUpdateAsync(CurrentVersion);
+        LatestRelease = result.LatestRelease;
+        IsUpdateAvailable = result.IsUpdateAvailable;
+
+        Log.Information(
+            "Checked for updates. CurrentVersion={CurrentVersion}; LatestVersion={LatestVersion}; IsUpdateAvailable={IsUpdateAvailable}",
+            FormatVersion(CurrentVersion),
+            LatestVersionText,
+            IsUpdateAvailable);
+    }
+
+    private static string FormatVersion(Version version)
+    {
+        if (version is null)
+        {
+            return "Unknown";
+        }
+
+        if (version.Revision >= 0)
+        {
+            return version.ToString(4);
+        }
+
+        return version.Build >= 0
+            ? version.ToString(3)
+            : version.ToString(2);
+    }
+}
diff --git a/SentryDeck/ViewModels/CameraViewsViewModel.cs b/SentryDeck/ViewModels/CameraViewsViewModel.cs
new file mode 100644
index 0000000..c18bc48
--- /dev/null
+++ b/SentryDeck/ViewModels/CameraViewsViewModel.cs
@@ -0,0 +1,147 @@
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+
+namespace SentryDeck;
+
+/// <summary>
+/// Which camera is enlarged (or the grid), and the selector strip of cameras the current clip recorded.
+/// The view re-parents its Flyleaf hosts whenever <see cref="SelectedCameraView"/> or <see cref="CameraViewOptions"/> changes.
+/// </summary>
+public sealed partial class CameraViewsViewModel : ObservableObject
+{
+    /// <summary>
+    /// The multi-camera grid pseudo-view.
+    /// Every other view id is a canonical camera name from <see cref="CameraNames"/>, so the selected view maps 1:1 onto the clip's camera files.
+    /// </summary>
+    public const string GridCameraView = "grid";
+
+    // The classic four-camera set (HW3 and earlier) shown before any clip is opened, so the selector strip doesn't start empty.
+    private static readonly string[] DefaultCameras =
+    [
+        CameraNames.Front,
+        CameraNames.Back,
+        CameraNames.LeftRepeater,
+        CameraNames.RightRepeater,
+    ];
+
+    public CameraViewsViewModel()
+    {
+        SyncCameraViewSelection();
+    }
+
+    public bool IsGridViewSelected => SelectedCameraView == GridCameraView;
+
+    public bool IsSingleCameraViewSelected => !IsGridViewSelected;
+
+    public string ActiveCameraLabel => SelectedCameraView == GridCameraView ? "Grid" : CameraLabel(SelectedCameraView);
+
+    /// <summary>
+    /// The camera an export of what's on screen should use: the enlarged camera, or the front (primary) angle for the grid.
+    /// </summary>
+    public string ExportCamera => SelectedCameraView == GridCameraView ? CameraNames.Front : SelectedCameraView;
+
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(IsGridViewSelected))]
+    [NotifyPropertyChangedFor(nameof(IsSingleCameraViewSelected))]
+    [NotifyPropertyChangedFor(nameof(ActiveCameraLabel))]
+    [NotifyPropertyChangedFor(nameof(ExportCamera))]
+    private string _selectedCameraView = CameraNames.Front;
+
+    /// <summary>
+    /// The selectable views for the current clip: the grid plus one tile per camera the clip actually recorded, in <see cref="CameraNames.All"/> order.
+    /// </summary>
+    [ObservableProperty]
+    private IReadOnlyList<CameraViewOption> _cameraViewOptions = BuildCameraViewOptions(null);
+
+    /// <summary>
+    /// Rebuilds the camera tiles from what <paramref name="clip"/> actually recorded (four on HW3, six on HW4/AI4).
+    /// If the previously watched camera doesn't exist there, the view falls back to the front.
+    /// </summary>
+    public void ShowCamerasOf(CamClip clip)
+    {
+        CameraViewOptions = BuildCameraViewOptions(clip);
+        if (IsAvailableView(SelectedCameraView))
+        {
+            // Same view id as before, but the option objects are new, so re-mark the selected one.
+            SyncCameraViewSelection();
+        }
+        else
+        {
+            SelectedCameraView = CameraNames.Front;
+        }
+    }
+
+    // Maps a Tesla event.json camera id to the camera view to auto-focus.
+    // Ids follow the community-documented map (0 front, 3/4 repeaters, 5/6 B-pillars, 7 rear; 1/2/8 are the non-recorded fisheye/narrow/cabin).
+    // Unknown ids and cameras this clip didn't record fall back to the front (primary) angle.
+    internal string CameraIdToView(int cameraId)
+    {
+        var camera = cameraId switch
+        {
+            3 => CameraNames.LeftRepeater,
+            4 => CameraNames.RightRepeater,
+            5 => CameraNames.LeftPillar,
+            6 => CameraNames.RightPillar,
+            7 => CameraNames.Back,
+            _ => CameraNames.Front,
+        };
+
+        return IsAvailableView(camera) ? camera : CameraNames.Front;
+    }
+
+    [RelayCommand]
+    private void SelectCameraView(string cameraView)
+    {
+        // Unknown views and cameras the current clip didn't record fall back to the front (primary) angle, which every playable clip has.
+        SelectedCameraView = IsAvailableView(cameraView) ? cameraView : CameraNames.Front;
+    }
+
+    /// <summary>
+    /// Friendly tile label for a camera.
+    /// The classic four keep their short historical names; the HW4/AI4 B-pillars are spelled out to distinguish them from the repeaters.
+    /// </summary>
+    private static string CameraLabel(string camera) => camera switch
+    {
+        CameraNames.Front => "Front",
+        CameraNames.Back => "Rear",
+        CameraNames.LeftRepeater => "Left",
+        CameraNames.RightRepeater => "Right",
+        CameraNames.LeftPillar => "Left Pillar",
+        CameraNames.RightPillar => "Right Pillar",
+        _ => CameraNames.DisplayName(camera),
+    };
+
+    private static IReadOnlyList<CameraViewOption> BuildCameraViewOptions(CamClip clip)
+    {
+        // Only recognized cameras get a tile: each needs a dedicated Flyleaf host wired in the view, so an unknown future suffix is ingested and played in the engine but not shown.
+        var cameras = clip is null
+            ? DefaultCameras
+            : CameraNames.All.Where(camera => clip.Chunks.Any(chunk => chunk.Files.ContainsKey(camera))).ToArray();
+
+        // Metadata-only clips (no camera files at all) keep the classic strip rather than none.
+        if (cameras.Length == 0)
+        {
+            cameras = DefaultCameras;
+        }
+
+        var options = new List<CameraViewOption>(cameras.Length + 1)
+        {
+            new(GridCameraView, "Grid", shortcutNumber: 1, isGrid: true),
+        };
+        options.AddRange(cameras.Select((camera, index) => new CameraViewOption(camera, CameraLabel(camera), index + 2)));
+        return options;
+    }
+
+    private bool IsAvailableView(string view) =>
+        view is not null && CameraViewOptions.Any(option => option.ViewId == view);
+
+    partial void OnSelectedCameraViewChanged(string value) => SyncCameraViewSelection();
+
+    private void SyncCameraViewSelection()
+    {
+        foreach (var option in CameraViewOptions)
+        {
+            option.IsSelected = option.ViewId == SelectedCameraView;
+        }
+    }
+}
diff --git a/SentryDeck/ViewModels/ClipLibraryViewModel.cs b/SentryDeck/ViewModels/ClipLibraryViewModel.cs
new file mode 100644
index 0000000..325e19d
--- /dev/null
+++ b/SentryDeck/ViewModels/ClipLibraryViewModel.cs
@@ -0,0 +1,403 @@
+using System.Diagnostics;
+using System.Globalization;
+using System.IO;
+using System.Windows;
+using System.Windows.Threading;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using Microsoft.VisualBasic.FileIO;
+using Microsoft.Win32;
+using Serilog;
+
+namespace SentryDeck;
+
+/// <summary>
+/// The clip list: scanning dashcam folders, searching, the selected clip, and the per-clip actions in its context menu.
+/// </summary>
+public sealed partial class ClipLibraryViewModel : ObservableObject
+{
+    private readonly List<CamClip> _allClips = [];
+    private readonly Func<string, IReadOnlyList<CamClip>> _clipLoader;
+    private readonly PlaybackViewModel _playback;
+    private readonly ErrorOverlayViewModel _error;
+    private readonly DispatcherTimer _filterDebounceTimer;
+
+    // The source of dashcam roots: auto-discovery by default, or the user's last picked folders.
+    // Refresh re-evaluates it to rescan for newly added clips (and, for auto-discovery, newly connected drives).
+    private Func<IEnumerable<string>> _rootSource = CamStorage.FindCommonRoots;
+
+    /// <param name="clipLoader">Maps a dashcam root to its clips.</param>
+    /// <param name="playback">The player, which is stopped before a rescan or a delete and follows the clip list's playlist.</param>
+    /// <param name="error">Where scan and delete failures are reported.</param>
+    /// <param name="dispatcher">Runs the search debounce.</param>
+    public ClipLibraryViewModel(
+        Func<string, IReadOnlyList<CamClip>> clipLoader,
+        PlaybackViewModel playback,
+        ErrorOverlayViewModel error,
+        Dispatcher dispatcher)
+    {
+        _clipLoader = clipLoader;
+        _playback = playback;
+        _error = error;
+
+        // Coalesces the expensive clip-list regroup/rebind so fast typing in search stays smooth; the getters stay live, so only the (debounced) change notification is deferred.
+        _filterDebounceTimer = new DispatcherTimer(DispatcherPriority.Background, dispatcher)
+        {
+            Interval = TimeSpan.FromMilliseconds(150),
+        };
+        _filterDebounceTimer.Tick += OnFilterDebounceTick;
+    }
+
+    public IReadOnlyList<CamClip> FilteredClips => _allClips
+        .Where(MatchesFilter)
+        .OrderByDescending(c => c.Timestamp)
+        .ThenBy(c => c.Name)
+        .ToList();
+
+    /// <summary>Number of clips currently shown (drives the sidebar count).</summary>
+    public int ClipCount => FilteredClips.Count;
+
+    /// <summary>True when the search box has text (drives the clear button).</summary>
+    public bool HasFilterText => !string.IsNullOrEmpty(FilterText);
+
+    // FilteredClips/ClipCount are refreshed on a short debounce (see OnFilterTextChanged) rather than per keystroke; HasFilterText stays immediate so the search box's clear affordance is responsive.
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(HasFilterText))]
+    private string _filterText = string.Empty;
+
+    [ObservableProperty]
+    private CamClip _selectedClip;
+
+    // True while the clip list is being (re)scanned from disk; drives the sidebar loading indicator.
+    [ObservableProperty]
+    [NotifyCanExecuteChangedFor(nameof(RefreshClipsCommand))]
+    [NotifyCanExecuteChangedFor(nameof(OpenFolderCommand))]
+    private bool _isLoadingClips;
+
+    /// <summary>
+    /// Asks the user to confirm sending a clip to the Recycle Bin.
+    /// Returns true to proceed.
+    /// Overridable for tests; defaults to a yes/no message box.
+    /// </summary>
+    internal Func<CamClip, bool> ConfirmDeleteClip { get; set; } = clip =>
+        MessageBox.Show(
+            $"Move this clip to the Recycle Bin?\n\n{clip.Name}\n{clip.FullPath}",
+            "Delete clip",
+            MessageBoxButton.YesNo,
+            MessageBoxImage.Warning) == MessageBoxResult.Yes;
+
+    /// <summary>
+    /// Sends a clip folder to the Windows Recycle Bin (recoverable).
+    /// Overridable for tests; defaults to the shell recycle operation, which surfaces its own error dialog if a file is in use.
+    /// </summary>
+    internal Action<string> RecycleClipFolder { get; set; } = path =>
+        FileSystem.DeleteDirectory(path, UIOption.OnlyErrorDialogs, RecycleOption.SendToRecycleBin);
+
+    /// <summary>Rescans the current source of dashcam roots (auto-discovered drives, or the folders the user picked).</summary>
+    public Task ReloadAsync(TimeSpan minimumLoadingDuration = default) => LoadClipsAsync(_rootSource(), minimumLoadingDuration);
+
+    public async Task LoadClipsAsync(IEnumerable<string> roots, TimeSpan minimumLoadingDuration = default)
+    {
+        _error.Clear();
+        _allClips.Clear();
+        SelectedClip = null;
+        IsLoadingClips = true;
+
+        // Clear the list right away so a (re)scan visibly empties it and shows the loading bar before refilling.
+        OnPropertyChanged(nameof(FilteredClips));
+        OnPropertyChanged(nameof(ClipCount));
+
+        var stopwatch = Stopwatch.StartNew();
+
+        try
+        {
+            // Scan the disk off the UI thread; the continuation resumes on it via the WPF SynchronizationContext, so all view-model state below is mutated on the UI thread.
+            var result = await Task.Run(() => ScanRoots(roots));
+
+            if (!result.HadRoots)
+            {
+                _error.Show(
+                    "No dashcam footage yet",
+                    "Point Sentry Deck at your TeslaCam folder to get started. Recorded USB drives are found automatically.",
+                    canDismiss: true,
+                    isEmptyState: true);
+            }
+            else
+            {
+                _allClips.AddRange(result.Clips);
+                foreach (var error in result.Errors)
+                {
+                    _error.Show(error.Title, error.Details);
+                }
+            }
+
+            _playback.SetPlaylist(_allClips);
+
+            // Hold the loading state briefly so a fast rescan still reads as a deliberate refresh (clear -> loading -> refill) instead of an imperceptible flicker.
+            var remaining = minimumLoadingDuration - stopwatch.Elapsed;
+            if (remaining > TimeSpan.Zero)
+            {
+                await Task.Delay(remaining);
+            }
+        }
+        finally
+        {
+            IsLoadingClips = false;
+            OnPropertyChanged(nameof(FilteredClips));
+            OnPropertyChanged(nameof(ClipCount));
+        }
+    }
+
+    public void Shutdown() => _filterDebounceTimer.Stop();
+
+    // Matches the clip name, path, event city, and friendly event reason (e.g. "sentry", "honk", "saved").
+    private bool MatchesFilter(CamClip clip)
+    {
+        if (string.IsNullOrWhiteSpace(FilterText))
+        {
+            return true;
+        }
+
+        var term = FilterText;
+        return clip.Name.Contains(term, StringComparison.CurrentCultureIgnoreCase)
+            || clip.FullPath.Contains(term, StringComparison.CurrentCultureIgnoreCase)
+            || (clip.Event?.City?.Contains(term, StringComparison.CurrentCultureIgnoreCase) ?? false)
+            || ClipDisplay.ReasonLabel(clip.Event).Contains(term, StringComparison.CurrentCultureIgnoreCase);
+    }
+
+    // Restart the debounce on each keystroke; the list is rebound once typing settles.
+    partial void OnFilterTextChanged(string value)
+    {
+        _filterDebounceTimer.Stop();
+        _filterDebounceTimer.Start();
+    }
+
+    private void OnFilterDebounceTick(object sender, EventArgs e)
+    {
+        _filterDebounceTimer.Stop();
+        OnPropertyChanged(nameof(FilteredClips));
+        OnPropertyChanged(nameof(ClipCount));
+    }
+
+    private ScanResult ScanRoots(IEnumerable<string> roots)
+    {
+        var rootList = roots?.Where(root => !string.IsNullOrWhiteSpace(root)).ToList() ?? [];
+        if (rootList.Count == 0)
+        {
+            Log.Information("No dashcam roots found");
+            return new ScanResult([], [], HadRoots: false);
+        }
+
+        Log.Information("Loading dashcam clips. RootCount={RootCount}; Roots={Roots}", rootList.Count, rootList);
+        var totalStopwatch = Stopwatch.StartNew();
+        var clips = new List<CamClip>();
+        var errors = new List<ClipLoadError>();
+
+        foreach (var root in rootList)
+        {
+            var rootStopwatch = Stopwatch.StartNew();
+            Log.Debug("Scanning dashcam root. Root={Root}", root);
+
+            try
+            {
+                var rootClips = _clipLoader(root);
+                clips.AddRange(rootClips);
+                Log.Information(
+                    "Scanned dashcam root. Root={Root}; ClipCount={ClipCount}; ElapsedMs={ElapsedMs}",
+                    root,
+                    rootClips.Count,
+                    rootStopwatch.ElapsedMilliseconds);
+            }
+            catch (UnauthorizedAccessException ex)
+            {
+                Log.Error(ex, "Access denied while loading dashcam root. Root={Root}", root);
+                errors.Add(new ClipLoadError("Access Denied", $"Cannot access folder: {root}\n\nCheck that you have permission to read this location."));
+            }
+            catch (Exception ex)
+            {
+                Log.Error(ex, "Failed to load dashcam root. Root={Root}", root);
+                errors.Add(new ClipLoadError("Error Loading Clips", $"Failed to load clips from:\n{root}\n\nError: {ex.Message}"));
+            }
+        }
+
+        Log.Information(
+            "Finished loading dashcam clips. ClipCount={ClipCount}; RootCount={RootCount}; FailedRootCount={FailedRootCount}; ElapsedMs={ElapsedMs}",
+            clips.Count,
+            rootList.Count,
+            errors.Count,
+            totalStopwatch.ElapsedMilliseconds);
+        return new ScanResult(clips, errors, HadRoots: true);
+    }
+
+    private sealed record ScanResult(IReadOnlyList<CamClip> Clips, IReadOnlyList<ClipLoadError> Errors, bool HadRoots);
+
+    private sealed record ClipLoadError(string Title, string Details);
+
+    // Gated like Refresh: LoadClipsAsync has no re-entrancy protection, so picking a folder while a scan is still running would interleave two loads and merge both roots into one clip list.
+    [RelayCommand(CanExecute = nameof(CanRefreshClips))]
+    private async Task OpenFolderAsync()
+    {
+        Log.Debug("Opening folder picker");
+
+        var dialog = new OpenFolderDialog
+        {
+            Multiselect = true,
+            Title = "Select a folder containing Tesla dashcam footage (TeslaCam folder)",
+        };
+
+        if (dialog.ShowDialog() == true)
+        {
+            var folders = dialog.FolderNames;
+            Log.Information(
+                "User selected dashcam folders. FolderCount={FolderCount}; Folders={Folders}",
+                folders.Length,
+                folders);
+
+            await _playback.StopPlayerAsync();
+
+            _rootSource = () => folders;
+            await LoadClipsAsync(folders);
+        }
+        else
+        {
+            Log.Debug("Folder picker canceled");
+        }
+    }
+
+    [RelayCommand(CanExecute = nameof(CanRefreshClips))]
+    private async Task RefreshClipsAsync()
+    {
+        Log.Debug("Refreshing clips");
+
+        await _playback.StopPlayerAsync();
+        await ReloadAsync(TimeSpan.FromMilliseconds(400));
+    }
+
+    private bool CanRefreshClips => !IsLoadingClips;
+
+    [RelayCommand]
+    private void ClearFilter()
+    {
+        FilterText = string.Empty;
+    }
+
+    private static bool CanUseClip(CamClip clip)
+    {
+        return clip is not null;
+    }
+
+    [RelayCommand(CanExecute = nameof(CanUseClip))]
+    private void OpenClipFolder(CamClip clip)
+    {
+        if (clip is null)
+        {
+            return;
+        }
+
+        if (!Directory.Exists(clip.FullPath))
+        {
+            _error.Show("Clip Folder Not Found", $"Could not find folder:\n{clip.FullPath}");
+            return;
+        }
+
+        Process.Start(new ProcessStartInfo(clip.FullPath)
+        {
+            UseShellExecute = true,
+        });
+    }
+
+    [RelayCommand(CanExecute = nameof(CanUseClip))]
+    private void CopyClipPath(CamClip clip)
+    {
+        if (clip is not null)
+        {
+            Clipboard.SetText(clip.FullPath);
+        }
+    }
+
+    [RelayCommand(CanExecute = nameof(CanUseClip))]
+    private void CopyClipName(CamClip clip)
+    {
+        if (clip is not null)
+        {
+            Clipboard.SetText(clip.Name);
+        }
+    }
+
+    [RelayCommand(CanExecute = nameof(CanUseClip))]
+    private void CopyTimestamp(CamClip clip)
+    {
+        if (clip is not null)
+        {
+            // Invariant (24-hour, culture-stable) so the copied value matches the clip name and is paste-searchable, unlike the ambiguous AM/PM current-culture rendering.
+            Clipboard.SetText(clip.Timestamp.ToString(CultureInfo.InvariantCulture));
+        }
+    }
+
+    /// <summary>
+    /// Sends the clip's folder to the Recycle Bin so the timeline can be tidied without leaving the app.
+    /// Confirms first, then, if the clip is the one currently open, stops playback so Flyleaf releases its file handles before the shell tries to recycle the (otherwise locked) folder.
+    /// </summary>
+    [RelayCommand(CanExecute = nameof(CanUseClip))]
+    private async Task DeleteClipAsync(CamClip clip)
+    {
+        if (clip is null || !ConfirmDeleteClip(clip))
+        {
+            return;
+        }
+
+        // Flyleaf keeps the current clip's camera files open; Windows can't recycle a folder whose files are still locked, so stop and close the players before deleting it.
+        var isCurrent = ReferenceEquals(SelectedClip, clip)
+            || ReferenceEquals(_playback.NowPlayingClip, clip)
+            || _playback.CurrentClip == clip;
+        if (isCurrent && _playback.HasPlayer)
+        {
+            await _playback.StopPlayerAsync();
+            _playback.SeekPosition = 0;
+        }
+
+        try
+        {
+            Log.Information("Deleting clip to Recycle Bin. ClipName={ClipName}; ClipPath={ClipPath}", clip.Name, clip.FullPath);
+            await Task.Run(() => RecycleClipFolder(clip.FullPath));
+        }
+        catch (Exception ex)
+        {
+            Log.Error(ex, "Failed to delete clip. ClipName={ClipName}; ClipPath={ClipPath}", clip.Name, clip.FullPath);
+            _error.Show("Delete Failed", $"Could not delete clip: {clip.Name}\n\nError: {ex.Message}");
+            return;
+        }
+
+        // Drop it from the sidebar list and keep the player's Next/Previous playlist in sync.
+        _allClips.Remove(clip);
+        _playback.RemoveFromPlaylist(clip);
+
+        if (ReferenceEquals(_playback.NowPlayingClip, clip))
+        {
+            _playback.NowPlayingClip = null;
+        }
+
+        if (ReferenceEquals(SelectedClip, clip))
+        {
+            SelectedClip = null;
+        }
+
+        OnPropertyChanged(nameof(FilteredClips));
+        OnPropertyChanged(nameof(ClipCount));
+    }
+
+    [RelayCommand(CanExecute = nameof(CanShowOnMap))]
+    private void ShowOnMap(CamClip clip)
+    {
+        if (clip?.Event is null || !ClipDisplay.HasLocation(clip.Event))
+        {
+            return;
+        }
+
+        var lat = clip.Event.EstLat.ToString(CultureInfo.InvariantCulture);
+        var lon = clip.Event.EstLon.ToString(CultureInfo.InvariantCulture);
+        Process.Start(new ProcessStartInfo($"https://www.google.com/maps?q={lat},{lon}") { UseShellExecute = true });
+    }
+
+    private static bool CanShowOnMap(CamClip clip) => clip?.Event is not null && ClipDisplay.HasLocation(clip.Event);
+}
diff --git a/SentryDeck/ViewModels/ErrorOverlayViewModel.cs b/SentryDeck/ViewModels/ErrorOverlayViewModel.cs
new file mode 100644
index 0000000..1157f04
--- /dev/null
+++ b/SentryDeck/ViewModels/ErrorOverlayViewModel.cs
@@ -0,0 +1,52 @@
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+
+namespace SentryDeck;
+
+/// <summary>
+/// The notice that covers the video area: a genuine error, or the friendly prompt shown when there is no footage yet.
+/// Every feature reports through the one instance the main window owns, so a newer notice replaces the one on screen.
+/// </summary>
+public sealed partial class ErrorOverlayViewModel : ObservableObject
+{
+    [ObservableProperty]
+    private string _title;
+
+    [ObservableProperty]
+    private string _details;
+
+    [ObservableProperty]
+    private bool _isVisible;
+
+    [ObservableProperty]
+    private bool _canDismiss = true;
+
+    // True when the notice is a friendly first-run/empty prompt rather than a genuine error.
+    [ObservableProperty]
+    private bool _isEmptyState;
+
+    [ObservableProperty]
+    private bool _showFFmpegDownloadButton;
+
+    public void Show(string title, string details, bool canDismiss = true, bool isEmptyState = false)
+    {
+        Title = title;
+        Details = details;
+        CanDismiss = canDismiss;
+        IsEmptyState = isEmptyState;
+        IsVisible = true;
+    }
+
+    public void Clear()
+    {
+        IsVisible = false;
+        ShowFFmpegDownloadButton = false;
+        CanDismiss = true;
+        IsEmptyState = false;
+        Title = null;
+        Details = null;
+    }
+
+    [RelayCommand]
+    private void Dismiss() => Clear();
+}
diff --git a/SentryDeck/ViewModels/PlaybackViewModel.cs b/SentryDeck/ViewModels/PlaybackViewModel.cs
new file mode 100644
index 0000000..115dc24
--- /dev/null
+++ b/SentryDeck/ViewModels/PlaybackViewModel.cs
@@ -0,0 +1,644 @@
+using System.ComponentModel;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using Serilog;
+
+namespace SentryDeck;
+
+/// <summary>
+/// Everything about the clip in the player: loading it when it is selected, the transport controls, the seek bar and its markers, and playback speed.
+/// Wraps the <see cref="VideoPlayerController"/> the view supplies; sibling view-models reach the player only through the members here.
+/// </summary>
+public sealed partial class PlaybackViewModel : ObservableObject
+{
+    private readonly Func<VideoPlayerController> _playerControllerFactory;
+    private readonly Func<Task> _backgroundYield;
+    private readonly Action<Action> _uiInvoker;
+    private readonly ErrorOverlayViewModel _error;
+    private readonly CameraViewsViewModel _cameras;
+    private readonly SeekScrubCoalescer _scrubCoalescer;
+    private VideoPlayerController _playerController;
+    private CancellationTokenSource _selectionCts;
+    private bool _isSeeking;
+
+    // Identifies the current seek gesture.
+    // EndSeekAsync's slow tail (the accurate seek can queue behind in-flight scrubs) may complete after the user has already started a NEW drag; only the completion belonging to the latest gesture may clear _isSeeking, or the position sync would yank the thumb out from under the active drag.
+    private int _seekGeneration;
+
+    // --- Seek-bar overlays for the selected clip (event moment + chunk seams + gaps) ---
+    // Recomputed whenever the selection changes or the controller opens/replaces its media source; plain fields (not ObservableProperty) because they're derived, not independently settable.
+    private double? _eventPosition;
+    private IReadOnlyList<double> _chunkBoundaries = [];
+    private IReadOnlyList<double> _gapPositions = [];
+
+    /// <param name="playerControllerFactory">Creates the playback controller (the view supplies one bound to its Flyleaf hosts).</param>
+    /// <param name="backgroundYield">Yields to the UI before a clip loads so the window stays responsive.</param>
+    /// <param name="uiInvoker">Runs an action on the UI thread.</param>
+    /// <param name="error">Where playback failures are reported.</param>
+    /// <param name="cameras">Refocused on the camera that triggered an event clip once it opens.</param>
+    public PlaybackViewModel(
+        Func<VideoPlayerController> playerControllerFactory,
+        Func<Task> backgroundYield,
+        Action<Action> uiInvoker,
+        ErrorOverlayViewModel error,
+        CameraViewsViewModel cameras)
+    {
+        _playerControllerFactory = playerControllerFactory;
+        _backgroundYield = backgroundYield;
+        _uiInvoker = uiInvoker;
+        _error = error;
+        _cameras = cameras;
+        _scrubCoalescer = new SeekScrubCoalescer(ScrubToAsync);
+    }
+
+    /// <summary>
+    /// Raised when the player moves to another clip on its own or through Next/Previous, so the clip list can follow.
+    /// </summary>
+    public event EventHandler<CamClip> CurrentClipChanged;
+
+    /// <summary>
+    /// Ladder the speed stepper walks: fine increments around 1x, doubling above.
+    /// Flyleaf clamps Player.Speed to [0.125, 16], so 16x is the hard ceiling.
+    /// </summary>
+    public static IReadOnlyList<double> PlaybackSpeedSteps { get; } =
+    [
+        0.25,
+        0.5,
+        0.75,
+        1.0,
+        1.25,
+        1.5,
+        2.0,
+        4.0,
+        8.0,
+        16.0,
+    ];
+
+    /// <summary>The clip the user selected, which this view-model loads into the player.</summary>
+    public CamClip SelectedClip { get; private set; }
+
+    /// <summary>The clip the player has open, or null when nothing is open.</summary>
+    public CamClip CurrentClip => _playerController?.CurrentClip;
+
+    /// <summary>The media source backing the open clip, or null when nothing is open.</summary>
+    public ClipMediaSource OpenedMediaSource => _playerController?.OpenedMediaSource;
+
+    public TimeSpan Duration => _playerController?.Duration ?? TimeSpan.Zero;
+
+    /// <summary>False until the view's Flyleaf-backed controller has been created (FFmpeg missing, or not initialized yet).</summary>
+    public bool HasPlayer => _playerController is not null;
+
+    /// <summary>Speed readout shown on the stepper, e.g. "1x" or "0.25x".</summary>
+    public string PlaybackSpeedText => $"{PlaybackSpeed:0.##}x";
+
+    public bool CanIncreaseSpeed => PlaybackSpeed < PlaybackSpeedSteps[^1];
+
+    public bool CanDecreaseSpeed => PlaybackSpeed > PlaybackSpeedSteps[0];
+
+    public string PositionText => FormatTimeSpan(SeekTargetPosition());
+
+    public string DurationText => FormatTimeSpan(Duration);
+
+    public bool CanSeek => _playerController?.IsMediaOpen == true && !IsLoading && _playerController.Duration > TimeSpan.Zero;
+
+    public bool CanPlayPause => (SelectedClip is not null || IsPlaying) && !IsLoading;
+
+    public bool CanStop => IsPlaying || IsLoading;
+
+    public bool CanGoNext => _playerController?.CanGoNext == true;
+
+    public bool CanGoPrevious => _playerController?.CanGoPrevious == true;
+
+    // Segoe Fluent Icons: Pause (E769) / PlaySolid (F5B0).
+    // Rendered with SymbolThemeFontFamily.
+    public string PlayPauseIcon => IsPlaying ? "" : "";
+
+    /// <summary>The event moment as a 0..1 fraction of the clip timeline (0 when none; pair with <see cref="HasEventMarker"/>).</summary>
+    public double EventMarkerPosition => _eventPosition ?? 0d;
+
+    /// <summary>True when the selected clip has a locatable event moment to mark on the seek bar and jump to.</summary>
+    public bool HasEventMarker => _eventPosition.HasValue;
+
+    /// <summary>Friendly reason + time for the event marker tooltip, e.g. "Honk · 3:53 PM".</summary>
+    public string EventMarkerTooltip => SelectedClip?.Event is { } camEvent && HasEventMarker
+        ? $"{ClipDisplay.ReasonLabel(camEvent)} · {camEvent.Timestamp:t}"
+        : string.Empty;
+
+    /// <summary>Interior chunk-boundary fractions (i/Count for i in 1..Count-1); empty for fewer than two chunks.</summary>
+    public IReadOnlyList<double> ChunkBoundaries => _chunkBoundaries;
+
+    /// <summary>
+    /// Fractional seek-bar positions where the opened clip's media time skips over a wall-clock gap (deleted/corrupt/excluded chunks, or a Sentry idle period).
+    /// Empty until the selected clip's media source has actually been built and opened by the controller.
+    /// </summary>
+    public IReadOnlyList<double> GapPositions => _gapPositions;
+
+    /// <summary>True while the selected clip is loading into the player.</summary>
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(CanPlayPause))]
+    [NotifyPropertyChangedFor(nameof(CanStop))]
+    [NotifyPropertyChangedFor(nameof(CanSeek))]
+    [NotifyCanExecuteChangedFor(nameof(StepFrameBackwardCommand))]
+    [NotifyCanExecuteChangedFor(nameof(StepFrameForwardCommand))]
+    private bool _isLoading;
+
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(PositionText))]
+    private double _seekPosition;
+
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(PlayPauseIcon))]
+    [NotifyPropertyChangedFor(nameof(CanPlayPause))]
+    [NotifyPropertyChangedFor(nameof(CanStop))]
+    private bool _isPlaying;
+
+    // The clip actually loaded in the player (drives the now-playing marker in the list).
+    // Distinct from the selection so a marker can persist even when selection is elsewhere.
+    [ObservableProperty]
+    private CamClip _nowPlayingClip;
+
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(PlaybackSpeedText))]
+    [NotifyPropertyChangedFor(nameof(CanIncreaseSpeed))]
+    [NotifyPropertyChangedFor(nameof(CanDecreaseSpeed))]
+    [NotifyCanExecuteChangedFor(nameof(IncreaseSpeedCommand))]
+    [NotifyCanExecuteChangedFor(nameof(DecreaseSpeedCommand))]
+    private double _playbackSpeed = 1.0;
+
+    public void InitializePlayer()
+    {
+        if (_playerController is not null)
+            return;
+
+        _playerController = _playerControllerFactory();
+        _playerController.PropertyChanged += PlayerControllerOnPropertyChanged;
+        _playerController.PlaybackSpeed = PlaybackSpeed;
+    }
+
+    public void Shutdown()
+    {
+        _selectionCts?.Cancel();
+        _selectionCts?.Dispose();
+        _selectionCts = null;
+
+        var controller = _playerController;
+        _playerController = null;
+
+        if (controller is null)
+            return;
+
+        controller.PropertyChanged -= PlayerControllerOnPropertyChanged;
+        controller.Dispose();
+    }
+
+    /// <summary>
+    /// Loads <paramref name="clip"/> into the player, or clears the player's selection when it is null.
+    /// A newer selection cancels an older one that is still waiting to load, so quickly arrowing through the list doesn't open every clip in turn.
+    /// </summary>
+    public void Select(CamClip clip)
+    {
+        SelectedClip = clip;
+        OnPropertyChanged(nameof(SelectedClip));
+        OnPropertyChanged(nameof(CanPlayPause));
+
+        RecomputeSelectedClipTimeline();
+        NotifyMarkersChanged();
+
+        _selectionCts?.Cancel();
+        _selectionCts?.Dispose();
+        _selectionCts = null;
+
+        if (clip is not null)
+        {
+            _selectionCts = new CancellationTokenSource();
+
+            // Show the now-playing badge on the newly clicked clip right away, instead of only once its media finishes opening.
+            NowPlayingClip = clip;
+
+            Log.Debug(
+                "Selected clip changed. ClipName={ClipName}; ClipPath={ClipPath}",
+                clip.Name,
+                clip.FullPath);
+            _ = PlaySelectedClipAsync(clip, _selectionCts.Token);
+        }
+    }
+
+    /// <summary>Replaces the player's playlist, which Next and Previous walk.</summary>
+    public void SetPlaylist(IEnumerable<CamClip> clips)
+    {
+        _playerController?.LoadClips(clips);
+        NotifyNavigationChanged();
+    }
+
+    /// <summary>Drops a deleted clip from the player's playlist so Next and Previous skip it.</summary>
+    public void RemoveFromPlaylist(CamClip clip)
+    {
+        _playerController?.RemoveClip(clip);
+        NotifyNavigationChanged();
+    }
+
+    /// <summary>Closes whatever the player has open, releasing its file handles.</summary>
+    public Task StopPlayerAsync() => _playerController?.StopAsync() ?? Task.CompletedTask;
+
+    public Task TogglePlayPauseAsync() => _playerController?.TogglePlayPauseAsync() ?? Task.CompletedTask;
+
+    public Task StepFrameAsync(bool forward) => _playerController?.StepFrameAsync(forward) ?? Task.CompletedTask;
+
+    public Task SeekRelativeAsync(TimeSpan offset)
+    {
+        if (_playerController is not { } controller || !CanSeek)
+        {
+            return Task.CompletedTask;
+        }
+
+        return controller.SeekByAsync(offset);
+    }
+
+    public void BeginSeek()
+    {
+        if (CanSeek)
+        {
+            _seekGeneration++;
+            _isSeeking = true;
+            _scrubCoalescer.Reset();
+
+            // Holds playback paused for the gesture, so each scrub is one cheap paused seek and the release resumes every camera together.
+            // The controller serializes this ahead of the first scrub seek, so it needs no await here.
+            _ = _playerController.BeginScrubAsync();
+        }
+    }
+
+    public async Task EndSeekAsync()
+    {
+        var generation = _seekGeneration;
+
+        if (_playerController is null || !CanSeek)
+        {
+            _isSeeking = false;
+            return;
+        }
+
+        // The gesture is over: drop any scrub value still queued in the coalescer.
+        // When the in-flight scrub completes it would otherwise re-issue that value as a keyframe seek AFTER the accurate seek below (both queue on the controller's serialized-operation lock in that order), leaving the playhead on a keyframe instead of the release point.
+        _scrubCoalescer.CancelPending();
+
+        // _isSeeking stays true until the release seek completes, so the position sync can't pull the thumb back while a scrub seek winds down.
+        // The release seek queues behind any in-flight scrub on the controller's serialized-operation lock, so it always lands last.
+        await _playerController.EndScrubAsync(SeekTargetPosition());
+
+        // Only the latest gesture's completion may end the seeking state: if the user has already grabbed the thumb again, this completion is stale and their new drag owns the flag.
+        if (generation == _seekGeneration)
+        {
+            _isSeeking = false;
+        }
+    }
+
+    /// <summary>
+    /// Called on every seek-bar value change.
+    /// While a seek gesture is active (<see cref="_isSeeking"/>, set by <see cref="BeginSeek"/> on mouse-down for clicks and drags alike), each value feeds the scrub coalescer so the video follows the thumb in near-real-time.
+    /// A plain click therefore issues one scrub seek too; the accurate seek from <see cref="EndSeekAsync"/> runs behind the same serialized lock and always lands last.
+    /// Value changes from playback position sync arrive with <see cref="_isSeeking"/> false and are ignored.
+    /// </summary>
+    public void OnSeekSliderValueChanged()
+    {
+        if (!_isSeeking)
+            return;
+
+        OnPropertyChanged(nameof(PositionText));
+
+        if (CanSeek)
+        {
+            _scrubCoalescer.OnDragValueChanged(SeekTargetPosition());
+        }
+    }
+
+    internal static string FormatTimeSpan(TimeSpan ts)
+    {
+        return ts.TotalHours >= 1
+            ? ts.ToString(@"h\:mm\:ss")
+            : ts.ToString(@"m\:ss");
+    }
+
+    [RelayCommand]
+    private Task PlayPauseAsync() => TogglePlayPauseAsync();
+
+    [RelayCommand]
+    private async Task StopAsync()
+    {
+        if (_playerController is null)
+            return;
+
+        // A selection that is still waiting to load would otherwise start playing right after the stop.
+        _selectionCts?.Cancel();
+
+        await _playerController.StopAsync();
+        IsLoading = false;
+        SeekPosition = 0;
+        NowPlayingClip = null;
+    }
+
+    [RelayCommand(CanExecute = nameof(CanSeek))]
+    private Task StepFrameBackwardAsync() => StepFrameAsync(forward: false);
+
+    [RelayCommand(CanExecute = nameof(CanSeek))]
+    private Task StepFrameForwardAsync() => StepFrameAsync(forward: true);
+
+    [RelayCommand(CanExecute = nameof(HasEventMarker))]
+    private async Task JumpToEventAsync()
+    {
+        if (!HasEventMarker)
+            return;
+
+        Log.Debug("Jumping to event moment. Position={EventMarkerPosition}", EventMarkerPosition);
+        SeekPosition = EventMarkerPosition;
+        await SeekToCurrentPositionAsync();
+    }
+
+    [RelayCommand]
+    private async Task PreviousAsync()
+    {
+        if (_playerController is null)
+            return;
+
+        await _playerController.PreviousAsync();
+        CurrentClipChanged?.Invoke(this, _playerController.CurrentClip);
+    }
+
+    [RelayCommand]
+    private async Task NextAsync()
+    {
+        if (_playerController is null)
+            return;
+
+        await _playerController.NextAsync();
+        CurrentClipChanged?.Invoke(this, _playerController.CurrentClip);
+    }
+
+    [RelayCommand(CanExecute = nameof(CanIncreaseSpeed))]
+    private void IncreaseSpeed() =>
+        PlaybackSpeed = PlaybackSpeedSteps.FirstOrDefault(step => step > PlaybackSpeed, PlaybackSpeedSteps[^1]);
+
+    [RelayCommand(CanExecute = nameof(CanDecreaseSpeed))]
+    private void DecreaseSpeed() =>
+        PlaybackSpeed = PlaybackSpeedSteps.LastOrDefault(step => step < PlaybackSpeed, PlaybackSpeedSteps[0]);
+
+    [RelayCommand]
+    private void ResetSpeed() => PlaybackSpeed = 1.0;
+
+    partial void OnPlaybackSpeedChanged(double value)
+    {
+        if (_playerController is not null)
+        {
+            Log.Information("Playback speed changed. Speed={PlaybackSpeed}", value);
+            _playerController.PlaybackSpeed = value;
+        }
+    }
+
+    private async Task PlaySelectedClipAsync(CamClip clip, CancellationToken cancellationToken)
+    {
+        if (clip is null || _playerController is null)
+            return;
+
+        _error.Clear();
+        IsLoading = true;
+        await _backgroundYield();
+
+        // A newer selection superseded this one while we yielded, so drop it and let the latest win and the selection doesn't rubber-band backwards as earlier, slower loads complete.
+        if (cancellationToken.IsCancellationRequested || !ReferenceEquals(clip, SelectedClip))
+        {
+            // A newer selection's own load owns IsLoading now, but if the selection was cleared outright (deselect, or a filter dropping the clip), no load is in flight and nothing else ever resets the flag, leaving a permanent "Loading…" overlay over the video pane.
+            if (SelectedClip is null)
+            {
+                IsLoading = false;
+            }
+
+            return;
+        }
+
+        try
+        {
+            await _playerController.GoToClipAsync(clip);
+
+            if (cancellationToken.IsCancellationRequested)
+                return;
+
+            // Auto-focus the camera that triggered the event (Full metadata mode).
+            if (clip.Event is not null)
+            {
+                _cameras.SelectedCameraView = _cameras.CameraIdToView(clip.Event.Camera);
+            }
+        }
+        catch (Exception ex)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                // Same stuck-overlay guard as the pre-load early-return above.
+                if (SelectedClip is null)
+                {
+                    IsLoading = false;
+                }
+
+                return;
+            }
+
+            IsLoading = false;
+            Log.Error(
+                ex,
+                "Failed to play selected clip. ClipName={ClipName}; ClipPath={ClipPath}",
+                clip.Name,
+                clip.FullPath);
+            _error.Show("Playback Failed", $"Could not play clip: {clip.Name}\n\nError: {ex.Message}");
+        }
+    }
+
+    private async Task SeekToCurrentPositionAsync()
+    {
+        if (_playerController is null)
+            return;
+
+        var duration = _playerController.Duration;
+        if (duration.TotalSeconds > 0)
+        {
+            await _playerController.SeekAsync(SeekTargetPosition());
+        }
+    }
+
+    private Task ScrubToAsync(TimeSpan position) =>
+        _playerController?.ScrubSeekAsync(position) ?? Task.CompletedTask;
+
+    private TimeSpan SeekTargetPosition() => TimeSpan.FromSeconds(SeekPosition * Duration.TotalSeconds);
+
+    // Derives the seek-bar overlays for the selected clip: the event moment, the interior chunk-boundary ticks, and gap ticks (mapped onto the 0..1 seek axis).
+    // Nulls out cleanly when the selection is cleared or the clip has no usable event metadata.
+    //
+    // Prefers the controller's actually-opened ClipMediaSource when it belongs to this clip: that source has real probed durations and gap-aware wall-clock mapping (see ClipMediaSource.ToMediaTime), so its positions match what's actually playing.
+    // Selecting a clip is synchronous but opening its media is not, so immediately after selection (or for a clip that never opens, e.g. in tests with no controller) there is no opened source yet; a ClipTimeline estimate (uniform assumed chunk length) is used as a same-frame placeholder so the markers don't flash empty, and is superseded once OpenedMediaSource changes.
+    private void RecomputeSelectedClipTimeline()
+    {
+        var clip = SelectedClip;
+        if (clip is null)
+        {
+            _eventPosition = null;
+            _chunkBoundaries = [];
+            _gapPositions = [];
+            return;
+        }
+
+        var mediaSource = _playerController?.CurrentClip == clip ? _playerController?.OpenedMediaSource : null;
+
+        if (mediaSource is not null && mediaSource.Duration > TimeSpan.Zero)
+        {
+            RecomputeFromMediaSource(clip, mediaSource);
+        }
+        else
+        {
+            RecomputeFromEstimatedTimeline(clip);
+        }
+    }
+
+    private void RecomputeFromMediaSource(CamClip clip, ClipMediaSource mediaSource)
+    {
+        var durationSeconds = mediaSource.Duration.TotalSeconds;
+
+        _chunkBoundaries = mediaSource.ChunkStarts.Count < 2
+            ? []
+            : mediaSource.ChunkStarts.Skip(1).Select(start => start.TotalSeconds / durationSeconds).ToList();
+
+        _gapPositions = mediaSource.GapPositions
+            .Select(position => position.TotalSeconds / durationSeconds)
+            .ToList();
+
+        var camEvent = clip.Event;
+        if (camEvent is null || camEvent.Timestamp == default)
+        {
+            _eventPosition = null;
+            return;
+        }
+
+        // Fraction 0 is a real position: an event that fired on the first recorded frame (or one snapped forward to the start of the footage) still deserves its marker.
+        var mediaTime = mediaSource.ToMediaTime(camEvent.Timestamp);
+        var fraction = mediaTime?.TotalSeconds / durationSeconds;
+        _eventPosition = fraction is >= 0 and <= 1 ? fraction : null;
+    }
+
+    // Fallback used before the selected clip's media has actually been opened (or when it never will be, e.g. no controller in tests): the legacy uniform-chunk-length estimate.
+    // Carries no gap information, since gaps can only be known once the builder has probed real durations.
+    private void RecomputeFromEstimatedTimeline(CamClip clip)
+    {
+        var timeline = new ClipTimeline(clip.Chunks);
+        _chunkBoundaries = timeline.Count < 2
+            ? []
+            : Enumerable.Range(1, timeline.Count - 1).Select(i => (double)i / timeline.Count).ToList();
+        _gapPositions = [];
+
+        var camEvent = clip.Event;
+        if (camEvent is null || camEvent.Timestamp == default || clip.Chunks.Count == 0 || timeline.Duration <= TimeSpan.Zero)
+        {
+            _eventPosition = null;
+            return;
+        }
+
+        // The event landing at or after the start and no later than the modeled end is markable (exactly 0 = the event fired on the first recorded frame); clock skew (fraction < 0) or an event past the estimate (> 1) yields no marker.
+        var fraction = (camEvent.Timestamp - clip.Chunks[0].Timestamp).TotalSeconds / timeline.Duration.TotalSeconds;
+        _eventPosition = fraction is >= 0 and <= 1 ? fraction : null;
+    }
+
+    private void NotifyMarkersChanged()
+    {
+        OnPropertyChanged(nameof(EventMarkerPosition));
+        OnPropertyChanged(nameof(HasEventMarker));
+        OnPropertyChanged(nameof(EventMarkerTooltip));
+        OnPropertyChanged(nameof(ChunkBoundaries));
+        OnPropertyChanged(nameof(GapPositions));
+        JumpToEventCommand.NotifyCanExecuteChanged();
+    }
+
+    // Sibling view-models gate on CanSeek (the trim marks and export), so it is re-announced whenever anything it reads changes, even if its value didn't.
+    private void NotifyCanSeekChanged()
+    {
+        OnPropertyChanged(nameof(CanSeek));
+        StepFrameBackwardCommand.NotifyCanExecuteChanged();
+        StepFrameForwardCommand.NotifyCanExecuteChanged();
+    }
+
+    private void NotifyNavigationChanged()
+    {
+        OnPropertyChanged(nameof(CanPlayPause));
+        OnPropertyChanged(nameof(CanGoNext));
+        OnPropertyChanged(nameof(CanGoPrevious));
+    }
+
+    private void UpdateSeekPositionFromController()
+    {
+        if (_playerController is null || _isSeeking)
+            return;
+
+        var duration = _playerController.Duration;
+        SeekPosition = duration.TotalSeconds > 0
+            ? Math.Clamp(_playerController.Position.TotalSeconds / duration.TotalSeconds, 0, 1)
+            : 0;
+    }
+
+    private void PlayerControllerOnPropertyChanged(object sender, PropertyChangedEventArgs e)
+    {
+        if (string.IsNullOrWhiteSpace(e.PropertyName))
+            return;
+
+        _uiInvoker(() => HandlePlayerControllerPropertyChanged(e.PropertyName));
+    }
+
+    private void HandlePlayerControllerPropertyChanged(string propertyName)
+    {
+        if (_playerController is null)
+            return;
+
+        switch (propertyName)
+        {
+            case nameof(VideoPlayerController.IsLoading):
+                IsLoading = _playerController.IsLoading;
+                break;
+
+            case nameof(VideoPlayerController.IsPlaying):
+                IsPlaying = _playerController.IsPlaying;
+                break;
+
+            case nameof(VideoPlayerController.Duration):
+                UpdateSeekPositionFromController();
+                OnPropertyChanged(nameof(Duration));
+                OnPropertyChanged(nameof(DurationText));
+                OnPropertyChanged(nameof(PositionText));
+                NotifyCanSeekChanged();
+                break;
+
+            case nameof(VideoPlayerController.Position):
+                UpdateSeekPositionFromController();
+                break;
+
+            case nameof(VideoPlayerController.OpenedMediaSource):
+                // The controller finished (re)building the media source for the selected clip (or one under recovery from a corrupt chunk).
+                // Siblings that hold positions against the old timeline hear about it first; then the gap-aware overlays are refreshed now that real probed durations/timestamps are available.
+                OnPropertyChanged(nameof(OpenedMediaSource));
+                RecomputeSelectedClipTimeline();
+                NotifyMarkersChanged();
+                break;
+
+            case nameof(VideoPlayerController.ErrorMessage):
+                if (_playerController.ErrorMessage is not null)
+                {
+                    _error.Show("Playback Error", _playerController.ErrorMessage);
+                }
+
+                break;
+
+            case nameof(VideoPlayerController.CurrentClip):
+                CurrentClipChanged?.Invoke(this, _playerController.CurrentClip);
+                NowPlayingClip = _playerController.CurrentClip;
+                NotifyNavigationChanged();
+                break;
+
+            case nameof(VideoPlayerController.IsMediaOpen):
+                NotifyCanSeekChanged();
+                break;
+        }
+    }
+}
diff --git a/SentryDeck/ViewModels/TrimViewModel.cs b/SentryDeck/ViewModels/TrimViewModel.cs
new file mode 100644
index 0000000..2259714
--- /dev/null
+++ b/SentryDeck/ViewModels/TrimViewModel.cs
@@ -0,0 +1,372 @@
+using System.ComponentModel;
+using System.Diagnostics;
+using System.IO;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using Microsoft.Win32;
+using Serilog;
+
+namespace SentryDeck;
+
+/// <summary>
+/// Cutting a clip down to share it: the trim panel's in/out marks on the seek bar, and exporting either the marked range or the footage around an event.
+/// </summary>
+public sealed partial class TrimViewModel : ObservableObject
+{
+    /// <summary>How much footage to keep on each side of the event moment in "Save event clip".</summary>
+    public static readonly TimeSpan EventClipPadding = TimeSpan.FromSeconds(30);
+
+    private readonly PlaybackViewModel _playback;
+    private readonly CameraViewsViewModel _cameras;
+    private readonly ErrorOverlayViewModel _error;
+    private readonly IClipExporter _clipExporter;
+    private readonly Func<string, string> _savePathPicker;
+    private readonly IClipMediaSourceBuilder _exportMediaSourceBuilder;
+
+    // --- Export selection (in/out marks on the seek bar, as 0..1 fractions like SeekPosition) ---
+    // Plain fields + an explicit notify helper (not ObservableProperty) because the pair changes together under shared invariants (start < end) and several derived properties hang off both.
+    private double? _selectionStart;
+    private double? _selectionEnd;
+
+    /// <param name="playback">Supplies the playhead the marks are set at, and the open clip an export reads from.</param>
+    /// <param name="cameras">Decides which camera a range export uses.</param>
+    /// <param name="error">Where export failures are reported.</param>
+    /// <param name="clipExporter">Exports trimmed clip ranges.</param>
+    /// <param name="savePathPicker">Maps a suggested file name to the chosen save path (null = canceled).</param>
+    /// <param name="exportMediaSourceBuilder">Builds a media source for exporting a clip that isn't currently open.</param>
+    public TrimViewModel(
+        PlaybackViewModel playback,
+        CameraViewsViewModel cameras,
+        ErrorOverlayViewModel error,
+        IClipExporter clipExporter,
+        Func<string, string> savePathPicker,
+        IClipMediaSourceBuilder exportMediaSourceBuilder)
+    {
+        _playback = playback;
+        _cameras = cameras;
+        _error = error;
+        _clipExporter = clipExporter;
+        _savePathPicker = savePathPicker ?? PickSavePathWithDialog;
+        _exportMediaSourceBuilder = exportMediaSourceBuilder;
+
+        _playback.PropertyChanged += OnPlaybackPropertyChanged;
+    }
+
+    /// <summary>The selection start as a 0..1 fraction of the clip timeline (0 when unset; pair with <see cref="HasSelectionStart"/>).</summary>
+    public double SelectionStartPosition => _selectionStart ?? 0d;
+
+    /// <summary>The selection end as a 0..1 fraction of the clip timeline (0 when unset; pair with <see cref="HasSelectionEnd"/>).</summary>
+    public double SelectionEndPosition => _selectionEnd ?? 0d;
+
+    public bool HasSelectionStart => _selectionStart.HasValue;
+
+    public bool HasSelectionEnd => _selectionEnd.HasValue;
+
+    /// <summary>True when both marks are set (a complete, exportable range).</summary>
+    public bool HasSelection => _selectionStart.HasValue && _selectionEnd.HasValue;
+
+    /// <summary>True when either mark is set (drives the clear affordance).</summary>
+    public bool HasAnySelectionMark => _selectionStart.HasValue || _selectionEnd.HasValue;
+
+    public bool CanExportSelection => HasSelection && !IsExporting && CanSeek;
+
+    /// <summary>
+    /// One-line guidance for the trim panel: walks the user through start → end → export, and shows the selected length once the range is complete.
+    /// </summary>
+    public string TrimHintText
+    {
+        get
+        {
+            if (HasSelection)
+            {
+                return $"{SelectionDurationText} selected — ready to export.";
+            }
+
+            if (HasSelectionStart)
+            {
+                return "Now play or scrub ahead to the end of your cut, then set the end.";
+            }
+
+            if (HasSelectionEnd)
+            {
+                return "Now play or scrub back to where your cut should begin, then set the start.";
+            }
+
+            return "Play or scrub to where your cut should begin, then set the start.";
+        }
+    }
+
+    /// <summary>Length of the marked range, e.g. "0:42" (empty until both marks are set).</summary>
+    public string SelectionDurationText
+    {
+        get
+        {
+            if (_selectionStart is not { } start || _selectionEnd is not { } end)
+            {
+                return string.Empty;
+            }
+
+            var duration = _playback.Duration;
+            return PlaybackViewModel.FormatTimeSpan(TimeSpan.FromSeconds((end - start) * duration.TotalSeconds));
+        }
+    }
+
+    /// <summary>
+    /// True while the trim panel is open.
+    /// Opens explicitly (the Trim button) or implicitly (marking a point via I/O); closing it always discards the marks, so the panel and the selection can't drift apart.
+    /// </summary>
+    [ObservableProperty]
+    private bool _isTrimming;
+
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(CanExportSelection))]
+    [NotifyCanExecuteChangedFor(nameof(ExportSelectionCommand))]
+    [NotifyCanExecuteChangedFor(nameof(SaveEventClipCommand))]
+    private bool _isExporting;
+
+    /// <summary>Points Explorer at the exported file so it's immediately ready to share.
+    /// Overridable for tests.</summary>
+    internal Action<string> RevealInExplorer { get; set; } = path =>
+        Process.Start(new ProcessStartInfo("explorer.exe", $"/select,\"{path}\"") { UseShellExecute = true });
+
+    // The marks and the trim panel need a seekable player.
+    private bool CanSeek => _playback.CanSeek;
+
+    /// <summary>
+    /// Marks the selection start at the current playhead.
+    /// A mark that would invert the range (start at or past the existing end) clears the other mark instead of silently swapping.
+    /// </summary>
+    [RelayCommand(CanExecute = nameof(CanSeek))]
+    private void MarkSelectionStart()
+    {
+        IsTrimming = true;
+        _selectionStart = _playback.SeekPosition;
+        if (_selectionEnd is { } end && end <= _playback.SeekPosition)
+        {
+            _selectionEnd = null;
+        }
+
+        NotifySelectionChanged();
+    }
+
+    /// <summary>Marks the selection end at the current playhead (see <see cref="MarkSelectionStart"/> for the invariant).</summary>
+    [RelayCommand(CanExecute = nameof(CanSeek))]
+    private void MarkSelectionEnd()
+    {
+        IsTrimming = true;
+        _selectionEnd = _playback.SeekPosition;
+        if (_selectionStart is { } start && start >= _playback.SeekPosition)
+        {
+            _selectionStart = null;
+        }
+
+        NotifySelectionChanged();
+    }
+
+    [RelayCommand(CanExecute = nameof(HasAnySelectionMark))]
+    private void ClearSelection()
+    {
+        _selectionStart = null;
+        _selectionEnd = null;
+        NotifySelectionChanged();
+    }
+
+    /// <summary>The control-bar Trim button: opens the trim panel, or cancels an open one.</summary>
+    [RelayCommand(CanExecute = nameof(CanSeek))]
+    private void ToggleTrimming()
+    {
+        if (IsTrimming)
+        {
+            CancelTrim();
+        }
+        else
+        {
+            IsTrimming = true;
+        }
+    }
+
+    /// <summary>Closes the trim panel and discards any marks.</summary>
+    [RelayCommand]
+    private void CancelTrim()
+    {
+        IsTrimming = false;
+        if (HasAnySelectionMark)
+        {
+            ClearSelection();
+        }
+    }
+
+    [RelayCommand(CanExecute = nameof(CanExportSelection))]
+    private async Task ExportSelectionAsync()
+    {
+        var clip = _playback.CurrentClip;
+        var mediaSource = _playback.OpenedMediaSource;
+        if (clip is null || mediaSource is null || mediaSource.Duration <= TimeSpan.Zero
+            || _selectionStart is not { } startFraction || _selectionEnd is not { } endFraction)
+        {
+            return;
+        }
+
+        var start = TimeSpan.FromSeconds(startFraction * mediaSource.Duration.TotalSeconds);
+        var end = TimeSpan.FromSeconds(endFraction * mediaSource.Duration.TotalSeconds);
+        var camera = _cameras.ExportCamera;
+        var defaultFileName = $"{clip.Name} {CameraNames.DisplayName(camera)} {FormatTimeSpanForFileName(start)}-{FormatTimeSpanForFileName(end)}.mp4";
+
+        await ExportAsync(clip, mediaSource, camera, start, end, defaultFileName);
+    }
+
+    /// <summary>
+    /// Exports the front-camera footage around the clip's event moment (±<see cref="EventClipPadding"/>) in one step, with no in/out marks needed.
+    /// Works from the clip list context menu even when the clip isn't the one currently playing (its media source is built on demand).
+    /// </summary>
+    [RelayCommand(CanExecute = nameof(CanSaveEventClip))]
+    private async Task SaveEventClipAsync(CamClip clip)
+    {
+        if (clip?.Event is null || clip.Event.Timestamp == default || IsExporting)
+        {
+            return;
+        }
+
+        ClipMediaSource mediaSource;
+        try
+        {
+            mediaSource = _playback.CurrentClip == clip ? _playback.OpenedMediaSource : null;
+
+            // Building an unopened clip's source does real IO (probe every chunk, write ffconcat files) and can throw (drive unplugged, temp write fails).
+            // Unlike ExportSelectionAsync, nothing downstream caught it, so the fault escaped to the dispatcher; surface a normal "Export Failed" dialog instead.
+            mediaSource ??= await Task.Run(() => _exportMediaSourceBuilder.Build(clip));
+        }
+        catch (Exception ex)
+        {
+            Log.Error(ex, "Failed to build media source for event clip. ClipName={ClipName}; ClipPath={ClipPath}", clip.Name, clip.FullPath);
+            _error.Show("Export Failed", $"Could not export clip: {clip.Name}\n\nError: {ex.Message}");
+            return;
+        }
+
+        var eventTime = mediaSource.Duration > TimeSpan.Zero ? mediaSource.ToMediaTime(clip.Event.Timestamp) : null;
+        if (eventTime is null)
+        {
+            _error.Show("Export Failed", "The event moment isn't within this clip's saved footage.");
+            return;
+        }
+
+        var start = eventTime.Value - EventClipPadding;
+        if (start < TimeSpan.Zero)
+        {
+            start = TimeSpan.Zero;
+        }
+
+        var end = eventTime.Value + EventClipPadding;
+        if (end > mediaSource.Duration)
+        {
+            end = mediaSource.Duration;
+        }
+
+        await ExportAsync(clip, mediaSource, CameraNames.Front, start, end, $"{clip.Name} event.mp4");
+    }
+
+    private bool CanSaveEventClip(CamClip clip) =>
+        clip?.Event is not null && clip.Event.Timestamp != default && !IsExporting;
+
+    private async Task ExportAsync(CamClip clip, ClipMediaSource mediaSource, string camera, TimeSpan start, TimeSpan end, string defaultFileName)
+    {
+        var outputPath = _savePathPicker(SanitizeFileName(defaultFileName));
+        if (string.IsNullOrEmpty(outputPath))
+        {
+            return;
+        }
+
+        IsExporting = true;
+
+        try
+        {
+            Log.Information(
+                "Exporting clip range. Clip={ClipName}; Camera={Camera}; Start={Start}; End={End}; Output={Output}",
+                clip.Name,
+                camera,
+                start,
+                end,
+                outputPath);
+            await _clipExporter.ExportAsync(new ClipExportRequest(clip, mediaSource, camera, start, end, outputPath));
+            RevealInExplorer(outputPath);
+        }
+        catch (OperationCanceledException)
+        {
+        }
+        catch (Exception ex)
+        {
+            Log.Error(ex, "Export failed. Clip={ClipName}; Camera={Camera}; Output={Output}", clip.Name, camera, outputPath);
+            _error.Show("Export Failed", $"Could not export clip: {clip.Name}\n\nError: {ex.Message}");
+        }
+        finally
+        {
+            IsExporting = false;
+        }
+    }
+
+    private static string PickSavePathWithDialog(string defaultFileName)
+    {
+        var dialog = new SaveFileDialog
+        {
+            Title = "Export clip",
+            FileName = defaultFileName,
+            DefaultExt = ".mp4",
+            Filter = "MP4 video|*.mp4",
+        };
+
+        return dialog.ShowDialog() == true ? dialog.FileName : null;
+    }
+
+    private static string FormatTimeSpanForFileName(TimeSpan ts) => PlaybackViewModel.FormatTimeSpan(ts).Replace(':', '.');
+
+    private static string SanitizeFileName(string name)
+    {
+        foreach (var invalid in Path.GetInvalidFileNameChars())
+        {
+            name = name.Replace(invalid, '_');
+        }
+
+        return name;
+    }
+
+    private void OnPlaybackPropertyChanged(object sender, PropertyChangedEventArgs e)
+    {
+        switch (e.PropertyName)
+        {
+            case nameof(PlaybackViewModel.CanSeek):
+                // Everything downstream of CanSeek: the mark/export commands gate on it, and the selected length scales with the clip's duration.
+                OnPropertyChanged(nameof(CanExportSelection));
+                OnPropertyChanged(nameof(SelectionDurationText));
+                OnPropertyChanged(nameof(TrimHintText));
+                MarkSelectionStartCommand.NotifyCanExecuteChanged();
+                MarkSelectionEndCommand.NotifyCanExecuteChanged();
+                ToggleTrimmingCommand.NotifyCanExecuteChanged();
+                ExportSelectionCommand.NotifyCanExecuteChanged();
+                break;
+
+            case nameof(PlaybackViewModel.OpenedMediaSource):
+                // A rebuild can reshape the timeline (chunks excluded during recovery), so in/out fractions marked against the old timeline no longer point at the same footage.
+                if (HasAnySelectionMark)
+                {
+                    ClearSelection();
+                }
+
+                break;
+        }
+    }
+
+    private void NotifySelectionChanged()
+    {
+        OnPropertyChanged(nameof(SelectionStartPosition));
+        OnPropertyChanged(nameof(SelectionEndPosition));
+        OnPropertyChanged(nameof(HasSelectionStart));
+        OnPropertyChanged(nameof(HasSelectionEnd));
+        OnPropertyChanged(nameof(HasSelection));
+        OnPropertyChanged(nameof(HasAnySelectionMark));
+        OnPropertyChanged(nameof(CanExportSelection));
+        OnPropertyChanged(nameof(TrimHintText));
+        OnPropertyChanged(nameof(SelectionDurationText));
+        ClearSelectionCommand.NotifyCanExecuteChanged();
+        ExportSelectionCommand.NotifyCanExecuteChanged();
+    }
+}