diff --git a/Directory.Packages.props b/Directory.Packages.props
index f3926d7da..6e5b9fb9a 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -8,6 +8,7 @@
   <ItemGroup>
     <PackageVersion Include="Microsoft.Maui.Controls" Version="$(MauiVersion)" />
     <PackageVersion Include="Microsoft.Maui.Controls.Compatibility" Version="$(MauiVersion)" />
+    <PackageVersion Include="Microsoft.AspNetCore.Components.Web" Version="10.0.0" />
     <PackageVersion Include="Microsoft.AspNetCore.Components.WebView.Maui" Version="$(MauiVersion)" />
     <!-- Pinned to the version transitively resolved through Microsoft.Maui.Controls (per
              dotnet list package, include-transitive) so the ExplorerExtension companion exe and
@@ -30,6 +31,7 @@
          (dotnet/efcore PR 38402, milestone 11.0-preview6). Tracked by:
          https://github.com/microsoft/EventLogExpert/issues/604 -->
     <PackageVersion Include="SQLitePCLRaw.lib.e_sqlite3" Version="3.53.3" />
+    <PackageVersion Include="Fluxor" Version="6.10.0" />
     <PackageVersion Include="Fluxor.Blazor.Web" Version="6.10.0" />
     <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="18.8.1" />
     <PackageVersion Include="NSubstitute" Version="6.0.0" />
diff --git a/docs/Performance.md b/docs/Performance.md
index 69eac399a..976e32bb0 100644
--- a/docs/Performance.md
+++ b/docs/Performance.md
@@ -60,12 +60,11 @@ newest rows stay as a bounded array-of-structs tail that seals into a new chunk
 target size, giving amortized O(1) append. Repeated strings fold into an interned pool and
 `EventData` field-name sequences into a shared schema table, and `Append` returns a new snapshot
 that reference-shares the prior chunks, pool, and schema table, so a published snapshot is safe to
-read while the next ingest builds. Each log exposes an `EventColumnView` that sorts its rows into a
-display order and reads fields straight through the store's reader with no event objects rehydrated;
-`CombinedColumnView` merges several such views with a K-way, column-direct cursor walk that compares
-head-to-head off each row's own reader, plus a periodic checkpoint index (stride 64) so a positional
-read seeks in log(rows) rather than walking from the start, with per-read offset scratch
-stack-allocated up to a capped K.
+read while the next ingest builds. The ordered-view engine maintains the display order
+incrementally in an `OrderedViewSnapshot` and reads fields straight through the store's reader with no
+event objects rehydrated; `OrderedColumnView` presents a single log and `CombinedOrderedColumnView`
+presents several, addressing each row to its owning reader over the pre-merged global order rather than
+re-running a K-way merge per read.
 
 ### P6 - Viewport virtualization and render-buffer reuse
 
@@ -109,7 +108,7 @@ filtering.
 | Read | Reverse read, newest bookmark, tuned `EvtNext` batch | `EventLogReader` |
 | Marshalling | Non-boxing packed `EventProperty` | `EventProperty`, `NativeMethods.Evt` |
 | Resolve | `ProcessorCount - 1` priority-gated parallelism | `OpenLogEffects` |
-| Store | Chunked columnar snapshot + K-way combined view | `EventColumnStore`, `EventColumnView`, `CombinedColumnView` |
+| Store | Chunked columnar snapshot + incrementally-ordered view engine | `EventColumnStore`, `OrderedColumnView`, `CombinedOrderedColumnView` |
 | Viewport | `Virtualize` + one-slice-per-window provider | `LogTablePane` |
 | Render | Per-thread grow-only render buffer, skip-probe | `NativeMethods.Evt` |
 | Filter memory | Retained structured `EventData` / `UserData` fields | `ResolvedEvent`, `UserDataValueExtractor` |
diff --git a/src/EventLogExpert.DatabaseTools/Common/Operations/OperationBase.cs b/src/EventLogExpert.DatabaseTools/Common/Operations/OperationBase.cs
index c9c814e26..509f1dfb3 100644
--- a/src/EventLogExpert.DatabaseTools/Common/Operations/OperationBase.cs
+++ b/src/EventLogExpert.DatabaseTools/Common/Operations/OperationBase.cs
@@ -15,13 +15,13 @@ namespace EventLogExpert.DatabaseTools.Common.Operations;
 
 internal abstract class OperationBase
 {
+    protected static readonly TimeSpan DefaultFilterRegexTimeout = TimeSpan.FromSeconds(5);
     private static readonly string[] s_databaseFileSuffixes = ["", "-wal", "-shm"];
 
     private string _providerDetailFormat = "{0, -14} {1, 8} {2, 8} {3, 8} {4, 8} {5, 8} {6, 8}";
 
     public string? FailureSummary { get; private set; }
 
-    // Clearing SQLite pools releases Windows file handles before deleting the partial database.
     protected static async Task CleanupPartialDatabaseAsync(
         ITraceLogger logger,
         ProviderDbContext? dbContext,
@@ -54,7 +54,8 @@ protected static async Task CleanupPartialDatabaseAsync(
         }
     }
 
-    // Recompile infinite-timeout regexes so hostile patterns cannot hang the operation.
+    protected static Regex? EnsureBoundedTimeout(Regex? regex) => EnsureBoundedTimeout(regex, DefaultFilterRegexTimeout);
+
     protected static Regex? EnsureBoundedTimeout(Regex? regex, TimeSpan defaultTimeout)
     {
         if (regex is null) { return null; }
@@ -77,7 +78,6 @@ protected static async IAsyncEnumerable<ProviderDetails> LoadLocalProvidersAsync
         IReadOnlySet<string>? excludeProviderNames = null,
         [EnumeratorCancellation] CancellationToken cancellationToken = default)
     {
-        // Async iterator bridge: synchronous provider reads share an IAsyncEnumerable consumer path.
         await Task.CompletedTask;
 
         foreach (var providerName in GetLocalProviderNames(regex))
diff --git a/src/EventLogExpert.DatabaseTools/CreateDatabase/CreateDatabaseOperation.cs b/src/EventLogExpert.DatabaseTools/CreateDatabase/CreateDatabaseOperation.cs
index 97246e27d..90d636aa3 100644
--- a/src/EventLogExpert.DatabaseTools/CreateDatabase/CreateDatabaseOperation.cs
+++ b/src/EventLogExpert.DatabaseTools/CreateDatabase/CreateDatabaseOperation.cs
@@ -7,7 +7,6 @@
 using EventLogExpert.Eventing.OfflineImaging.VirtualDisk;
 using EventLogExpert.Eventing.OfflineImaging.Wim;
 using EventLogExpert.Eventing.OfflineImaging.Workspace;
-using EventLogExpert.Eventing.ProviderMetadata;
 using EventLogExpert.Logging.Abstractions;
 using EventLogExpert.Provider.Database.Context;
 using EventLogExpert.Provider.Database.Hashing;
@@ -21,12 +20,9 @@ internal sealed class CreateDatabaseOperation(CreateDatabaseRequest request) : O
 {
     private const int BatchSize = 100;
 
-    // SQLite at rest may include main, WAL, and SHM files; overwrite backup/restore must move all three together.
     private static readonly string[] s_databaseFileSuffixes = ["", "-wal", "-shm"];
 
-    // Set only after every sidecar backup moves; restore must not delete unmoved originals after a torn backup.
     private bool _overwriteBackupCompleted;
-
     private bool _overwriteBackupTaken;
 
     internal enum CreateDatabaseMode { Local, FileSource, OfflineImage }
@@ -43,7 +39,6 @@ public async Task<DatabaseToolsOutcome> ExecuteAsync(
             return DatabaseToolsOutcome.Failed;
         }
 
-        // Any stale .bak sidecar may be the sole surviving copy after an interrupted overwrite and must block retry.
         foreach (var suffix in s_databaseFileSuffixes)
         {
             var backupPath = request.TargetPath + suffix + ".bak";
@@ -69,7 +64,6 @@ public async Task<DatabaseToolsOutcome> ExecuteAsync(
             return DatabaseToolsOutcome.Failed;
         }
 
-        // Fail fast on destination ACL/CFA denial before expensive scan or extraction work begins.
         string targetDirectory = Path.GetDirectoryName(Path.GetFullPath(request.TargetPath)) ?? request.TargetPath;
         string? targetBlocked = OfflineScratch.ProbeWritable(targetDirectory);
 
@@ -98,7 +92,7 @@ public async Task<DatabaseToolsOutcome> ExecuteAsync(
             logger.Information($"{FormatSkippedProvidersMessage(excludeProviderNames.Count, request.SkipProvidersInFile)}");
         }
 
-        var filterRegex = EnsureBoundedTimeout(request.FilterRegex, TimeSpan.FromSeconds(5));
+        var filterRegex = EnsureBoundedTimeout(request.FilterRegex);
 
         var outcome = await CreateCoreAsync();
 
@@ -120,7 +114,6 @@ async Task<DatabaseToolsOutcome> CreateCoreAsync()
         var firstByIdentity = new Dictionary<ProviderIdentity, ProviderDetails>();
 #endif
 
-        // Create DbContext only after the first provider so failed scans leave no empty database.
         ProviderDbContext? dbContext = null;
         OfflineWimImage? wimImage = null;
         OfflineIsoImage? isoImage = null;
@@ -133,7 +126,6 @@ async Task<DatabaseToolsOutcome> CreateCoreAsync()
             string? effectiveOfflineImagePath = request.OfflineImagePath;
             OfflineImageKind? kind = mode == CreateDatabaseMode.OfflineImage ? ResolveImageKind(request) : null;
 
-            // WIM apply ignores cooperative cancellation on denied writes, so probe scratch ACLs before native extraction.
             if (kind is OfflineImageKind.Wim or OfflineImageKind.Iso)
             {
                 string? scratchBlocked = OfflineScratch.ProbeWritable(OfflineScratch.Root);
@@ -191,7 +183,6 @@ async Task<DatabaseToolsOutcome> CreateCoreAsync()
                 effectiveOfflineImagePath = wimImage!.ExtractedRoot;
             }
 
-            // Offline providers already carry image provenance; only local builds read host provenance.
             IAsyncEnumerable<ProviderDetails> providersToAdd;
             SourceOsProvenance? sourceOsProvenance;
 
@@ -335,13 +326,11 @@ async Task<DatabaseToolsOutcome> CreateCoreAsync()
         {
             if (dbContext is not null) { await dbContext.DisposeAsync(); }
 
-            // Dispose extracted WIM after SaveChanges because persisted rows may still read from it.
             wimImage?.Dispose();
             isoImage?.Dispose();
             vhdxImage?.Dispose();
         }
 
-        // Never delete target files after a torn overwrite backup; they may be unmoved originals.
         async Task CleanupPartialUnlessUnmovedOriginalAsync()
         {
             if (_overwriteBackupTaken && !_overwriteBackupCompleted) { return; }
@@ -350,12 +339,10 @@ async Task CleanupPartialUnlessUnmovedOriginalAsync()
         }
         }
 
-        // Back up the old database before the writable context opens or creates target files.
         ProviderDbContext GetOrCreateContext()
         {
             if (request.Overwrite && !_overwriteBackupTaken && File.Exists(request.TargetPath))
             {
-                // Set before moving so a torn backup still enters restore.
                 _overwriteBackupTaken = true;
                 TakeOverwriteBackup();
                 _overwriteBackupCompleted = true;
@@ -383,10 +370,8 @@ internal static CreateDatabaseMode SelectMode(CreateDatabaseRequest request) =>
 
     internal static bool ValidateOfflineImageRequest(CreateDatabaseRequest request, ITraceLogger logger)
     {
-        // Kind-ambiguous validation errors are attributed to the Offline root; each resolved kind uses its fine category.
         ITraceLogger offlineLogger = logger.ForCategory(LogCategories.Offline);
 
-        // Reject orphan WIM options so the command cannot silently fall back to local providers.
         if (string.IsNullOrWhiteSpace(request.OfflineImagePath))
         {
             if (request.ImageKind is not null)
@@ -487,7 +472,6 @@ internal static bool ValidateOfflineImageRequest(CreateDatabaseRequest request,
                     return false;
                 }
 
-                // Validator cannot mount ISO just to list choices; extraction reports bad indices after mount.
                 if (request.WimIndex is null)
                 {
                     isoLogger.Error(
@@ -693,7 +677,6 @@ private async Task FlushHeaderAndBufferAsync(
         buffer.Clear();
     }
 
-    // Clear pools and remove aborted-build sidecars before restoring backups.
     private void RestoreOverwriteBackups(ITraceLogger logger)
     {
         var mainBackup = request.TargetPath + ".bak";
@@ -702,14 +685,12 @@ private void RestoreOverwriteBackups(ITraceLogger logger)
         {
             SqliteConnection.ClearAllPools();
 
-            // Only delete files after a complete backup; otherwise they may be unmoved originals.
             if (_overwriteBackupCompleted)
             {
                 foreach (var suffix in s_databaseFileSuffixes)
                 {
                     var newFile = request.TargetPath + suffix;
 
-                    // Never delete the main file unless its snapshot exists to take its place.
                     if (suffix.Length == 0 && !File.Exists(mainBackup)) { continue; }
 
                     if (File.Exists(newFile)) { File.Delete(newFile); }
@@ -731,7 +712,6 @@ private void RestoreOverwriteBackups(ITraceLogger logger)
         }
     }
 
-    // Stale-backup preflight guarantees every .bak move targets a free path.
     private void TakeOverwriteBackup()
     {
         foreach (var suffix in s_databaseFileSuffixes)
@@ -815,7 +795,6 @@ private static bool ModelsEquivalent<TModel, TIdentity>(
         Func<TModel, TModel, bool> areEquivalent)
         where TIdentity : notnull
     {
-        // Compare distinct identities both ways because the hash drops exact duplicate rows.
         var firstByIdentity = new Dictionary<TIdentity, TModel>(first.Count);
 
         foreach (TModel model in first) { firstByIdentity[identityOf(model)] = model; }
diff --git a/src/EventLogExpert.DatabaseTools/ShowProviders/ShowProvidersOperation.cs b/src/EventLogExpert.DatabaseTools/ShowProviders/ShowProvidersOperation.cs
index 1a7517257..5ade4c5fb 100644
--- a/src/EventLogExpert.DatabaseTools/ShowProviders/ShowProvidersOperation.cs
+++ b/src/EventLogExpert.DatabaseTools/ShowProviders/ShowProvidersOperation.cs
@@ -8,10 +8,6 @@
 
 namespace EventLogExpert.DatabaseTools.ShowProviders;
 
-/// <summary>
-///     Lists provider details from either local providers (<see cref="ShowProvidersRequest.SourcePath" /> = null) or
-///     a specified source (.db / .evtx / folder). Streams output as each provider is resolved.
-/// </summary>
 internal sealed class ShowProvidersOperation(ShowProvidersRequest request) : OperationBase, IDatabaseToolsOperation
 {
     private const int HeaderBatchSize = 100;
@@ -21,8 +17,7 @@ public async Task<DatabaseToolsOutcome> ExecuteAsync(
         IProgress<DatabaseToolsProgress>? progress,
         CancellationToken cancellationToken)
     {
-        // Defensive recompile if input has Regex.InfiniteMatchTimeout (otherwise catch below is dead).
-        var filterRegex = EnsureBoundedTimeout(request.FilterRegex, TimeSpan.FromSeconds(5));
+        var filterRegex = EnsureBoundedTimeout(request.FilterRegex);
 
         // Buffer first batch to size the column widths (mirrors CreateDatabaseOperation). Lives outside
         // the try so the cancellation arm can flush partial output the user has been waiting on.
diff --git a/src/EventLogExpert.ElevationHelper/ProgramEntry.cs b/src/EventLogExpert.ElevationHelper/ProgramEntry.cs
index b20af83a9..577fcce89 100644
--- a/src/EventLogExpert.ElevationHelper/ProgramEntry.cs
+++ b/src/EventLogExpert.ElevationHelper/ProgramEntry.cs
@@ -16,10 +16,12 @@ namespace EventLogExpert.ElevationHelper;
 internal static class ProgramEntry
 {
     private const int CancelWatchdogExitCode = 12;
-    // High-IL helper must kill itself if native code ignores cooperative cancellation; the medium-IL host cannot.
-    private static readonly TimeSpan s_selfTerminateWatchdog = TimeSpan.FromSeconds(8);
+    private const int PipeConnectTimeoutMilliseconds = 10_000;
 
-    // Startup orphan cleanup must not block the control reader from receiving cancellation.
+    private static readonly TimeSpan s_controlReaderDrainTimeout = TimeSpan.FromSeconds(1);
+    private static readonly TimeSpan s_requestReadTimeout = TimeSpan.FromSeconds(10);
+    private static readonly TimeSpan s_selfTerminateWatchdog = TimeSpan.FromSeconds(8);
+    private static readonly TimeSpan s_selfTerminateWriteTimeout = TimeSpan.FromSeconds(2);
     private static readonly TimeSpan s_startupReconcileTimeout = TimeSpan.FromSeconds(30);
 
     public static async Task<int> MainAsync(string[] args)
@@ -55,7 +57,7 @@ private static async Task<int> RunOperationModeAsync(IpcMessageReader reader, Ip
 
         try
         {
-            using var requestCts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
+            using var requestCts = new CancellationTokenSource(s_requestReadTimeout);
             request = await reader.ReadRequestAsync(requestCts.Token);
         }
         catch (OperationCanceledException)
@@ -80,7 +82,6 @@ private static async Task<int> RunOperationModeAsync(IpcMessageReader reader, Ip
 
         using var operationCts = new CancellationTokenSource();
 
-        // Armed on CancelMessage and cancelled on completion so only an ignored cooperative cancel self-terminates.
         using var watchdogCts = new CancellationTokenSource();
 
         var controlReaderTask = Task.Run(async () =>
@@ -104,7 +105,6 @@ private static async Task<int> RunOperationModeAsync(IpcMessageReader reader, Ip
                     {
                         operationCts.Cancel();
 
-                        // If the operation does not unwind, self-terminate so the host observes pipe EOF promptly.
                         try { await Task.Delay(s_selfTerminateWatchdog, watchdogCts.Token); }
                         catch (OperationCanceledException) { return; }
 
@@ -121,7 +121,6 @@ private static async Task<int> RunOperationModeAsync(IpcMessageReader reader, Ip
             }
         });
 
-        // Run orphan cleanup off the main flow so a wedged delete cannot block cancellation handling.
         var reconcileTask = Task.Run(() =>
         {
             try { OfflineMaintenance.ReconcileOrphans(logger: null); }
@@ -141,7 +140,7 @@ private static async Task<int> RunOperationModeAsync(IpcMessageReader reader, Ip
         {
             watchdogCts.Cancel();
             operationCts.Cancel();
-            try { await controlReaderTask.WaitAsync(TimeSpan.FromSeconds(1)); } catch { /* Best-effort control-reader drain. */ }
+            try { await controlReaderTask.WaitAsync(s_controlReaderDrainTimeout); } catch { /* Best-effort control-reader drain. */ }
 
             await TryWriteTerminalAsync(writer,
                 new FatalMessage(ex.GetType().FullName ?? ex.GetType().Name, ex.Message, ex.StackTrace ?? string.Empty));
@@ -152,7 +151,7 @@ await TryWriteTerminalAsync(writer,
         watchdogCts.Cancel();
         operationCts.Cancel();
 
-        try { await controlReaderTask.WaitAsync(TimeSpan.FromSeconds(1)); } catch { /* Best-effort control-reader drain. */ }
+        try { await controlReaderTask.WaitAsync(s_controlReaderDrainTimeout); } catch { /* Best-effort control-reader drain. */ }
 
         await TryWriteTerminalAsync(writer,
             new ResultMessage(result.Outcome, result.FailureSummary, (long)result.Duration.TotalMilliseconds));
@@ -166,12 +165,11 @@ private static async Task<int> RunPipeModeAsync(string pipeName, bool probe)
             ".",
             pipeName,
             PipeDirection.InOut,
-            // Omit client-side CurrentUserOnly: elevated and medium-IL same-user tokens have different SIDs; server DACL plus PID verification authenticates.
             PipeOptions.Asynchronous);
 
         try
         {
-            await pipe.ConnectAsync(timeout: 10_000);
+            await pipe.ConnectAsync(timeout: PipeConnectTimeoutMilliseconds);
         }
         catch (TimeoutException)
         {
@@ -208,7 +206,6 @@ await writer.WriteAsync(
         }
     }
 
-    // Last-resort self-termination leaves orphaned mounts for next elevated-launch reconciliation.
     private static async Task SelfTerminateAfterUnresponsiveCancelAsync(IpcMessageWriter writer, long elapsedMs)
     {
         try
@@ -216,7 +213,7 @@ private static async Task SelfTerminateAfterUnresponsiveCancelAsync(IpcMessageWr
             await TryWriteTerminalAsync(writer, new ResultMessage(
                 DatabaseToolsOutcome.Cancelled,
                 "Cancelled; the elevated helper self-terminated after a native operation ignored cancellation.",
-                elapsedMs)).WaitAsync(TimeSpan.FromSeconds(2));
+                elapsedMs)).WaitAsync(s_selfTerminateWriteTimeout);
         }
         catch { /* Pipe EOF on exit is the guaranteed host signal. */ }
 
diff --git a/src/EventLogExpert.EventDbTool/EventLogExpert.EventDbTool.csproj b/src/EventLogExpert.EventDbTool/EventLogExpert.EventDbTool.csproj
index 612e18d68..236a95f8b 100644
--- a/src/EventLogExpert.EventDbTool/EventLogExpert.EventDbTool.csproj
+++ b/src/EventLogExpert.EventDbTool/EventLogExpert.EventDbTool.csproj
@@ -3,7 +3,6 @@
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <RuntimeIdentifiers>win-x64</RuntimeIdentifiers>
-    <PlatformTarget>x64</PlatformTarget>
     <AssemblyName>eventdbtool</AssemblyName>
   </PropertyGroup>
 
diff --git a/src/EventLogExpert.Filtering/Compilation/FilterService.cs b/src/EventLogExpert.Filtering/Compilation/FilterService.cs
index 783576d47..802af9bc4 100644
--- a/src/EventLogExpert.Filtering/Compilation/FilterService.cs
+++ b/src/EventLogExpert.Filtering/Compilation/FilterService.cs
@@ -13,7 +13,6 @@ namespace EventLogExpert.Filtering.Compilation;
 
 public sealed class FilterService : IFilterService
 {
-    /// <summary>Outer parallelism only kicks in when the combined work justifies the scheduling overhead.</summary>
     private const int OuterParallelTotalEventThreshold = 10_000;
 
     public static byte[] ClassifyHighlightWinners(
@@ -49,6 +48,22 @@ public static byte[] ClassifyHighlightWinners(
         return winners;
     }
 
+    public static Func<IEventColumnReader, EventLocator, bool> CompileSurvivorPredicate(Filter filter)
+    {
+        if (!filter.IsFilteringEnabled) { return static (_, _) => true; }
+
+        var compiledFilters = CompileColumnFilters(filter.Filters);
+
+        var dateFilter = filter.DateFilter;
+        var dateEnabled = dateFilter?.IsEnabled is true;
+        var after = dateFilter?.After;
+        var before = dateFilter?.Before;
+
+        return (reader, locator) =>
+            MatchesCompiledFilters(reader, locator, compiledFilters) &&
+            (!dateEnabled || MatchesDateRange(reader, locator, after, before));
+    }
+
     public static IReadOnlyList<int> GetSurvivingOrder(IEventColumnReader reader, Filter filter)
     {
         ArgumentNullException.ThrowIfNull(reader);
@@ -91,8 +106,6 @@ public IReadOnlyDictionary<EventLogId, IReadOnlyList<ResolvedEvent>> FilterActiv
         IReadOnlyList<(EventLogId Id, IReadOnlyList<ResolvedEvent> Events)> logs,
         Filter filter)
     {
-        // Single log, no filters, or trivial total work: sequential per-log (inner PLINQ still
-        // engages for >=10k events on a single large log).
         if (logs.Count <= 1 ||
             !filter.IsFilteringEnabled ||
             !ShouldParallelizeAcrossLogs(logs))
@@ -100,8 +113,6 @@ public IReadOnlyDictionary<EventLogId, IReadOnlyList<ResolvedEvent>> FilterActiv
             return BuildSequentialResult(logs, filter);
         }
 
-        // Multi-log heavy work: parallelize across logs, sequential within each log to avoid
-        // oversubscribing the thread pool.
         var results = new IReadOnlyList<ResolvedEvent>[logs.Count];
 
         try
@@ -123,7 +134,6 @@ public IReadOnlyDictionary<EventLogId, IReadOnlyList<ResolvedEvent>> FilterActiv
 
         for (var index = 0; index < logs.Count; index++)
         {
-            // Add() (not the indexer) preserves duplicate-key failure parity with the sequential path.
             filtered.Add(logs[index].Id, results[index]);
         }
 
@@ -139,7 +149,6 @@ public IReadOnlyList<ResolvedEvent> GetFilteredEvents(
             return events as IReadOnlyList<ResolvedEvent> ?? [.. events];
         }
 
-        // PLINQ scheduling overhead exceeds the benefit below this threshold.
         if (events is IReadOnlyCollection<ResolvedEvent> { Count: < 10_000 } collection)
         {
             return FilterEventsSequential(collection, filter);
@@ -159,8 +168,6 @@ public IReadOnlyList<ResolvedEvent> GetFilteredEvents(
 
         foreach (var savedFilter in filters)
         {
-            // A null AoS Compiled is skipped without touching the isEmpty/isFiltered decision. Skipping at compile time
-            // is equivalent to the row oracle's per-event `continue` before the exclude/include arms.
             if (savedFilter.Compiled is null) { continue; }
 
             if (!FilterCompiler.TryCompileColumn(savedFilter.ComparisonText, out var columnCompiled, out var error))
@@ -225,7 +232,6 @@ private static bool MatchesCompiledFilters(
 
             if (isExcluded)
             {
-                // Exclude hides only on a decisive Match; Unknown and NoMatch keep the row visible.
                 if (match == FilterMatch.Match) { return false; }
 
                 continue;
@@ -233,7 +239,6 @@ private static bool MatchesCompiledFilters(
 
             isEmpty = false;
 
-            // Include keeps the row on a Match OR an Unknown; only a decisive NoMatch fails to satisfy it.
             if (match != FilterMatch.NoMatch) { isFiltered = true; }
         }
 
@@ -248,7 +253,6 @@ private static bool MatchesDateRange(
     {
         reader.GetField(locator, EventFieldId.TimeCreated).TryGetDateTime(out var timeCreated);
 
-        // Lifted nullable comparison mirrors the row oracle: a null After or Before makes the arm false.
         return timeCreated >= after && timeCreated <= before;
     }
 
@@ -259,7 +263,6 @@ private static bool ShouldParallelizeAcrossLogs(
 
         foreach (var data in logs)
         {
-            // If we can't cheaply size a log, assume the work is non-trivial and opt in to parallelism.
             if (data.Events is not IReadOnlyCollection<ResolvedEvent> collection)
             {
                 return true;
diff --git a/src/EventLogExpert.Filtering/Evaluation/DateFilter.cs b/src/EventLogExpert.Filtering/Evaluation/DateFilter.cs
index c4079a5e7..c597359ae 100644
--- a/src/EventLogExpert.Filtering/Evaluation/DateFilter.cs
+++ b/src/EventLogExpert.Filtering/Evaluation/DateFilter.cs
@@ -5,9 +5,9 @@ namespace EventLogExpert.Filtering.Evaluation;
 
 public sealed record DateFilter
 {
-    public DateTime? After { get; set; }
+    public DateTime? After { get; init; }
 
-    public DateTime? Before { get; set; }
+    public DateTime? Before { get; init; }
 
-    public bool IsEnabled { get; set; } = true;
+    public bool IsEnabled { get; init; } = true;
 }
diff --git a/src/EventLogExpert.Logging/Routing/LogRoutingPolicy.cs b/src/EventLogExpert.Logging/Routing/LogRoutingPolicy.cs
index 913103d39..d9cad427c 100644
--- a/src/EventLogExpert.Logging/Routing/LogRoutingPolicy.cs
+++ b/src/EventLogExpert.Logging/Routing/LogRoutingPolicy.cs
@@ -22,10 +22,6 @@ public LogRoutingPolicy(LoggingOptions options, LogLevel globalBaseline)
         _globalBaseline = globalBaseline;
     }
 
-    // The file sink writes a category at its configured throttle where one is set (channel-authoritative); every other
-    // category follows the live global baseline, so raising the global level never un-floors a configured throttle.
-    // Precedence returns on the first matching tier: runtime overrides (troubleshooting toggles) beat shipped
-    // throttles, which beat the global baseline.
     public LogLevel FileMinimumFor(string category)
     {
         if (string.IsNullOrEmpty(category)) { return _globalBaseline; }
@@ -35,12 +31,6 @@ public LogLevel FileMinimumFor(string category)
         return TryMatchLongestPrefix(_fileOverrides, category, out LogLevel fileLevel) ? fileLevel : _globalBaseline;
     }
 
-    // Runtime per-category override (e.g. the verbose-resolution troubleshooting toggle): raise or reset a category
-    // live without touching the shipped throttles or the global baseline. The read-modify-write runs under _writeLock
-    // so concurrent writers cannot lose updates; readers take a single lock-free volatile snapshot. Because
-    // FileMinimumFor returns on the first matching tier, a broad runtime prefix (e.g. "Resolution") shadows a narrower
-    // shipped override ("Resolution.Sub") regardless of specificity - intended for the toggle, and harmless today
-    // because no shipped "Resolution.*" override exists.
     public void SetCategoryOverride(string category, LogLevel? level)
     {
         ArgumentException.ThrowIfNullOrEmpty(category);
@@ -59,7 +49,7 @@ public void SetCategoryOverride(string category, LogLevel? level)
         }
     }
 
-    public LogLevel UiMinimumFor(bool verbose) => verbose ? LogLevel.Trace : LogLevel.Information;
+    public LogLevel UIMinimumFor(bool verbose) => verbose ? LogLevel.Trace : LogLevel.Information;
 
     public void UpdateGlobalBaseline(LogLevel level) => _globalBaseline = level;
 
@@ -72,8 +62,6 @@ private static IReadOnlyList<CategoryOverride> BuildOverrides(LoggingOptions opt
             .OrderByDescending(static entry => entry.Prefix.Length)];
     }
 
-    // Segment-boundary match: "Offline" covers "Offline.Wim" but not "OfflineExtras". Overrides are pre-sorted
-    // longest-first, so the first match is the most specific.
     private static bool IsSegmentPrefix(string prefix, string category)
     {
         if (!category.StartsWith(prefix, StringComparison.Ordinal)) { return false; }
diff --git a/src/EventLogExpert.Logging/Sinks/UiStreamingSink.cs b/src/EventLogExpert.Logging/Sinks/UIStreamingSink.cs
similarity index 90%
rename from src/EventLogExpert.Logging/Sinks/UiStreamingSink.cs
rename to src/EventLogExpert.Logging/Sinks/UIStreamingSink.cs
index e9bf93666..714f2f9a4 100644
--- a/src/EventLogExpert.Logging/Sinks/UiStreamingSink.cs
+++ b/src/EventLogExpert.Logging/Sinks/UIStreamingSink.cs
@@ -6,7 +6,7 @@
 
 namespace EventLogExpert.Logging.Sinks;
 
-public sealed class UiStreamingSink(IProgress<LogRecord> progress, LogLevel minimumLevel) : ILogSink
+public sealed class UIStreamingSink(IProgress<LogRecord> progress, LogLevel minimumLevel) : ILogSink
 {
     private readonly IProgress<LogRecord> _progress = progress ?? throw new ArgumentNullException(nameof(progress));
 
diff --git a/src/EventLogExpert.Runtime/Alerts/AlertPresentation.cs b/src/EventLogExpert.Runtime/Alerts/AlertPresentation.cs
index 35a8729ee..8b5614052 100644
--- a/src/EventLogExpert.Runtime/Alerts/AlertPresentation.cs
+++ b/src/EventLogExpert.Runtime/Alerts/AlertPresentation.cs
@@ -5,28 +5,13 @@
 
 namespace EventLogExpert.Runtime.Alerts;
 
-/// <summary>
-///     Controls how an <see cref="IAlertDialogService.ShowAlert(string,string,string,AlertPresentation)" /> request
-///     is surfaced to the user.
-/// </summary>
 public enum AlertPresentation
 {
-    /// <summary>
-    ///     Default. Use the existing <see cref="AlertDialogService" /> routing: render inline in the active modal host if
-    ///     one is registered, otherwise open a standalone alert popup.
-    /// </summary>
     Auto,
 
-    /// <summary>
-    ///     Route to <see cref="IInfoBannerService.ReportInfoBanner" /> with <see cref="BannerSeverity.Warning" /> severity.
-    ///     Only valid for one-button overloads (the banner has no accept/cancel pair); using it on a two-button overload
-    ///     throws.
-    /// </summary>
     Banner,
 
-    /// <summary>Require an active inline alert host. Throws <see cref="InvalidOperationException" /> if none is registered.</summary>
     InlineOnly,
 
-    /// <summary>Always open a standalone popup, even if an inline host is registered.</summary>
     PopupOnly,
 }
diff --git a/src/EventLogExpert.Runtime/Alerts/IInlineAlertHost.cs b/src/EventLogExpert.Runtime/Alerts/IInlineAlertHost.cs
deleted file mode 100644
index cf3357c21..000000000
--- a/src/EventLogExpert.Runtime/Alerts/IInlineAlertHost.cs
+++ /dev/null
@@ -1,14 +0,0 @@
-// // Copyright (c) Microsoft Corporation.
-// // Licensed under the MIT License.
-
-namespace EventLogExpert.Runtime.Alerts;
-
-/// <summary>
-///     Implemented by an active modal so alerts can be routed as inline banners instead of opening a separate alert
-///     modal (which would cancel the active one).
-/// </summary>
-public interface IInlineAlertHost
-{
-    /// <summary>Show <paramref name="request" /> inline. Replaces any prior pending inline alert (its task is canceled).</summary>
-    Task<InlineAlertResult> ShowInlineAlertAsync(InlineAlertRequest request, CancellationToken cancellationToken);
-}
diff --git a/src/EventLogExpert.Runtime/Alerts/InlineAlertRequest.cs b/src/EventLogExpert.Runtime/Alerts/InlineAlertRequest.cs
deleted file mode 100644
index 97196ac95..000000000
--- a/src/EventLogExpert.Runtime/Alerts/InlineAlertRequest.cs
+++ /dev/null
@@ -1,22 +0,0 @@
-// // Copyright (c) Microsoft Corporation.
-// // Licensed under the MIT License.
-
-namespace EventLogExpert.Runtime.Alerts;
-
-public sealed record InlineAlertRequest(
-    string Title,
-    string Message,
-    string? AcceptLabel,
-    string CancelLabel,
-    bool IsPrompt,
-    string? PromptInitialValue)
-{
-    public Func<string, string?>? Validate { get; init; }
-
-    /// <summary>
-    ///     Optional third button rendered between Accept and Cancel. When the user clicks it the result is
-    ///     <see cref="InlineAlertResult.SecondaryChosen" /> = true (Accepted stays false). Escape/Cancel remain a plain
-    ///     dismissal (both flags false), so a secondary action is never triggered by dismissing the alert.
-    /// </summary>
-    public string? SecondaryActionLabel { get; init; }
-}
diff --git a/src/EventLogExpert.Runtime/Alerts/InlineAlertResult.cs b/src/EventLogExpert.Runtime/Alerts/InlineAlertResult.cs
deleted file mode 100644
index f8dcd261f..000000000
--- a/src/EventLogExpert.Runtime/Alerts/InlineAlertResult.cs
+++ /dev/null
@@ -1,14 +0,0 @@
-// // Copyright (c) Microsoft Corporation.
-// // Licensed under the MIT License.
-
-namespace EventLogExpert.Runtime.Alerts;
-
-/// <summary>Result of an inline alert. <see cref="PromptValue" /> is non-null only for prompt requests.</summary>
-public sealed record InlineAlertResult(bool Accepted, string? PromptValue)
-{
-    /// <summary>
-    ///     True when the user clicked the optional <see cref="InlineAlertRequest.SecondaryActionLabel" /> button.
-    ///     Mutually exclusive with <see cref="Accepted" />; both false means the alert was cancelled/dismissed.
-    /// </summary>
-    public bool SecondaryChosen { get; init; }
-}
diff --git a/src/EventLogExpert.Runtime/Common/Clipboard/EventCopyFormatter.cs b/src/EventLogExpert.Runtime/Common/Clipboard/EventCopyFormatter.cs
new file mode 100644
index 000000000..b38730fab
--- /dev/null
+++ b/src/EventLogExpert.Runtime/Common/Clipboard/EventCopyFormatter.cs
@@ -0,0 +1,288 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.Events;
+using EventLogExpert.Eventing.Resolvers;
+using EventLogExpert.Runtime.Common.Display;
+using EventLogExpert.Runtime.EventLog;
+using EventLogExpert.Runtime.LogTable;
+using System.Collections.Immutable;
+using System.Text;
+using System.Xml;
+using System.Xml.Linq;
+
+namespace EventLogExpert.Runtime.Common.Clipboard;
+
+internal sealed class EventCopyFormatter(IEventDetailResolver detailResolver, IEventXmlResolver xmlResolver)
+    : IEventCopyFormatter
+{
+    private readonly IEventDetailResolver _detailResolver = detailResolver;
+    private readonly IEventXmlResolver _xmlResolver = xmlResolver;
+
+    public async Task<string> FormatAsync(EventCopyRequest request, CancellationToken cancellationToken = default)
+    {
+        ArgumentNullException.ThrowIfNull(request);
+
+        var events = ResolveSelection(request.Selection);
+        var selected = ResolveEntry(request.Focus);
+
+        EventCopyFormat format = request.Format;
+
+        if (format == EventCopyFormat.Markdown)
+        {
+            IReadOnlyList<ResolvedEvent> markdownEvents =
+                events.Count == 0 ? (selected is null ? [] : [selected]) : events;
+
+            return markdownEvents.Count == 0 ? string.Empty : BuildMarkdownTable(markdownEvents, request);
+        }
+
+        bool needsXml = format is EventCopyFormat.Xml or EventCopyFormat.Full;
+
+        if (events.Count == 0)
+        {
+            if (selected is null) { return string.Empty; }
+
+            string xml = needsXml ? await _xmlResolver.GetXmlAsync(selected, cancellationToken).ConfigureAwait(false) : string.Empty;
+
+            return FormatEventForCopy(format, selected, xml, request);
+        }
+
+        if (events.Count == 1)
+        {
+            string xml = needsXml ? await _xmlResolver.GetXmlAsync(events[0], cancellationToken).ConfigureAwait(false) : string.Empty;
+
+            return FormatEventForCopy(format, events[0], xml, request);
+        }
+
+        string[] xmlByIndex;
+
+        if (needsXml)
+        {
+            int maxConcurrency = Math.Max(2, Math.Min(events.Count, Environment.ProcessorCount));
+            using var resolverLock = new SemaphoreSlim(maxConcurrency, maxConcurrency);
+
+            var resolveTasks = new Task<string>[events.Count];
+
+            for (int i = 0; i < events.Count; i++)
+            {
+                var evt = events[i];
+
+                resolveTasks[i] = ResolveXmlAsync(evt, resolverLock, cancellationToken);
+            }
+
+            xmlByIndex = await Task.WhenAll(resolveTasks).ConfigureAwait(false);
+        }
+        else
+        {
+            xmlByIndex = [];
+        }
+
+        StringBuilder stringToCopy = new();
+
+        for (int i = 0; i < events.Count; i++)
+        {
+            string xml = needsXml ? xmlByIndex[i] : string.Empty;
+
+            AppendFormattedEvent(stringToCopy, format, events[i], xml, request);
+            stringToCopy.AppendLine();
+        }
+
+        return stringToCopy.ToString();
+    }
+
+    private static void AppendFormattedEvent(
+        StringBuilder builder,
+        EventCopyFormat format,
+        ResolvedEvent @event,
+        string xml,
+        EventCopyRequest request)
+    {
+        switch (format)
+        {
+            case EventCopyFormat.Default:
+                foreach ((ColumnName column, _) in request.EnabledColumns.Where(x => x.Value))
+                {
+                    switch (column)
+                    {
+                        case ColumnName.RecordId:
+                            builder.Append($"\"{@event.RecordId}\" ");
+                            break;
+                        case ColumnName.Level:
+                            builder.Append($"\"{@event.Level}\" ");
+                            break;
+                        case ColumnName.DateAndTime:
+                            builder.Append($"\"{@event.TimeCreated.ConvertTimeZone(request.TimeZone)}\" ");
+                            break;
+                        case ColumnName.ActivityId:
+                            builder.Append($"\"{@event.ActivityId}\" ");
+                            break;
+                        case ColumnName.Log:
+                            builder.Append($"\"{OwningLogDisplay.ShortName(@event.OwningLog)}\" ");
+                            break;
+                        case ColumnName.ComputerName:
+                            builder.Append($"\"{@event.ComputerName}\" ");
+                            break;
+                        case ColumnName.Source:
+                            builder.Append($"\"{@event.Source}\" ");
+                            break;
+                        case ColumnName.EventId:
+                            builder.Append($"\"{@event.Id}\" ");
+                            break;
+                        case ColumnName.TaskCategory:
+                            builder.Append($"\"{@event.TaskCategory}\" ");
+                            break;
+                        case ColumnName.Keywords:
+                            builder.Append($"\"{@event.KeywordsDisplayName}\" ");
+                            break;
+                        case ColumnName.ProcessId:
+                            builder.Append($"\"{@event.ProcessId}\" ");
+                            break;
+                        case ColumnName.ThreadId:
+                            builder.Append($"\"{@event.ThreadId}\" ");
+                            break;
+                        case ColumnName.User:
+                            builder.Append($"\"{@event.UserId}\" ");
+                            break;
+                    }
+                }
+
+                builder.Append($"\"{@event.Description}\"");
+                break;
+            case EventCopyFormat.Simple:
+                builder.Append($"\"{@event.Level}\" ");
+                builder.Append($"\"{@event.TimeCreated.ConvertTimeZone(request.TimeZone)}\" ");
+                builder.Append($"\"{@event.Source}\" ");
+                builder.Append($"\"{@event.Id}\" ");
+                builder.Append($"\"{@event.Description}\"");
+                break;
+            case EventCopyFormat.Xml:
+                if (!string.IsNullOrEmpty(xml)) { builder.Append(FormatXmlForCopy(xml)); }
+
+                break;
+            case EventCopyFormat.Full:
+            default:
+                builder.AppendLine($"Log Name: {@event.LogName}");
+                builder.AppendLine($"Source: {@event.Source}");
+                builder.AppendLine($"Date: {@event.TimeCreated.ConvertTimeZone(request.TimeZone)}");
+                builder.AppendLine($"Event ID: {@event.Id}");
+                builder.AppendLine($"Task Category: {@event.TaskCategory}");
+                builder.AppendLine($"Level: {@event.Level}");
+                builder.AppendLine($"Keywords: {@event.KeywordsDisplayName}");
+                builder.AppendLine($"User: {@event.UserId}");
+                builder.AppendLine($"Computer: {@event.ComputerName}");
+                builder.AppendLine("Description:");
+                builder.AppendLine(@event.Description);
+                builder.AppendLine("Event Xml:");
+
+                if (!string.IsNullOrEmpty(xml))
+                {
+                    builder.AppendLine(FormatXmlForCopy(xml));
+                }
+
+                break;
+        }
+    }
+
+    private static string BuildMarkdownTable(IReadOnlyList<ResolvedEvent> events, EventCopyRequest request)
+    {
+        var enabled = request.EnabledColumns;
+        var order = request.ColumnOrder;
+        var columns = (order.IsEmpty
+                ? enabled.Where(column => column.Value).Select(column => column.Key).OrderBy(column => column)
+                : order.Where(column => enabled.TryGetValue(column, out bool isEnabled) && isEnabled))
+            .ToList();
+
+        StringBuilder builder = new();
+
+        builder.Append("| ");
+        foreach (var column in columns) { builder.Append(EscapeMarkdownCell(column.ToFullString())).Append(" | "); }
+
+        builder.AppendLine("Description |");
+
+        builder.Append('|');
+        for (int separator = 0; separator <= columns.Count; separator++) { builder.Append(" --- |"); }
+
+        builder.AppendLine();
+
+        foreach (var @event in events)
+        {
+            builder.Append("| ");
+            foreach (var column in columns) { builder.Append(EscapeMarkdownCell(GetColumnText(column, @event, request.TimeZone))).Append(" | "); }
+
+            builder.Append(EscapeMarkdownCell(@event.Description)).AppendLine(" |");
+        }
+
+        return builder.ToString().TrimEnd();
+    }
+
+    private static string EscapeMarkdownCell(string? value) =>
+        (value ?? string.Empty)
+            .Replace("\\", "\\\\", StringComparison.Ordinal)
+            .Replace("\r", " ", StringComparison.Ordinal)
+            .Replace("\n", " ", StringComparison.Ordinal)
+            .Replace("|", "\\|", StringComparison.Ordinal);
+
+    private static string FormatEventForCopy(EventCopyFormat format, ResolvedEvent @event, string xml, EventCopyRequest request)
+    {
+        if (format == EventCopyFormat.Xml)
+        {
+            return string.IsNullOrEmpty(xml) ? string.Empty : FormatXmlForCopy(xml);
+        }
+
+        StringBuilder builder = new();
+
+        AppendFormattedEvent(builder, format, @event, xml, request);
+
+        return builder.ToString();
+    }
+
+    private static string FormatXmlForCopy(string xml)
+    {
+        try
+        {
+            return XElement.Parse(xml).ToString();
+        }
+        catch (XmlException)
+        {
+            return xml;
+        }
+    }
+
+    private static string GetColumnText(ColumnName column, ResolvedEvent @event, TimeZoneInfo timeZone) =>
+        EventTableColumnFormatter.GetCellText(@event, column, timeZone);
+
+    private ResolvedEvent? ResolveEntry(SelectionEntry? entry)
+    {
+        if (entry?.CurrentHandle is not { } handle) { return null; }
+
+        return _detailResolver.TryResolve(handle, out var detail) ? detail : null;
+    }
+
+    private IReadOnlyList<ResolvedEvent> ResolveSelection(ImmutableList<SelectionEntry> selection)
+    {
+        if (selection.Count == 0) { return []; }
+
+        var resolved = new List<ResolvedEvent>(selection.Count);
+
+        foreach (var entry in selection)
+        {
+            if (ResolveEntry(entry) is { } detail) { resolved.Add(detail); }
+        }
+
+        return resolved;
+    }
+
+    private async Task<string> ResolveXmlAsync(ResolvedEvent evt, SemaphoreSlim resolverLock, CancellationToken cancellationToken)
+    {
+        await resolverLock.WaitAsync(cancellationToken).ConfigureAwait(false);
+
+        try
+        {
+            return await _xmlResolver.GetXmlAsync(evt, cancellationToken).ConfigureAwait(false);
+        }
+        finally
+        {
+            resolverLock.Release();
+        }
+    }
+}
diff --git a/src/EventLogExpert.Runtime/Common/Clipboard/EventCopyRequest.cs b/src/EventLogExpert.Runtime/Common/Clipboard/EventCopyRequest.cs
new file mode 100644
index 000000000..7f7c2233b
--- /dev/null
+++ b/src/EventLogExpert.Runtime/Common/Clipboard/EventCopyRequest.cs
@@ -0,0 +1,16 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Runtime.EventLog;
+using EventLogExpert.Runtime.LogTable;
+using System.Collections.Immutable;
+
+namespace EventLogExpert.Runtime.Common.Clipboard;
+
+public sealed record EventCopyRequest(
+    ImmutableList<SelectionEntry> Selection,
+    SelectionEntry? Focus,
+    ImmutableDictionary<ColumnName, bool> EnabledColumns,
+    ImmutableList<ColumnName> ColumnOrder,
+    EventCopyFormat Format,
+    TimeZoneInfo TimeZone);
diff --git a/src/EventLogExpert.Runtime/Common/Clipboard/IEventCopyFormatter.cs b/src/EventLogExpert.Runtime/Common/Clipboard/IEventCopyFormatter.cs
new file mode 100644
index 000000000..98f1d7e12
--- /dev/null
+++ b/src/EventLogExpert.Runtime/Common/Clipboard/IEventCopyFormatter.cs
@@ -0,0 +1,9 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+namespace EventLogExpert.Runtime.Common.Clipboard;
+
+public interface IEventCopyFormatter
+{
+    Task<string> FormatAsync(EventCopyRequest request, CancellationToken cancellationToken = default);
+}
diff --git a/src/EventLogExpert.Runtime/Common/Sources/IChangeNotifier.cs b/src/EventLogExpert.Runtime/Common/Sources/IChangeNotifier.cs
new file mode 100644
index 000000000..c3a37d1ad
--- /dev/null
+++ b/src/EventLogExpert.Runtime/Common/Sources/IChangeNotifier.cs
@@ -0,0 +1,9 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+namespace EventLogExpert.Runtime.Common.Sources;
+
+public interface IChangeNotifier
+{
+    event Action Changed;
+}
diff --git a/src/EventLogExpert.Runtime/Common/Sources/ObservableStateSourceBase.cs b/src/EventLogExpert.Runtime/Common/Sources/ObservableStateSourceBase.cs
new file mode 100644
index 000000000..681980cc5
--- /dev/null
+++ b/src/EventLogExpert.Runtime/Common/Sources/ObservableStateSourceBase.cs
@@ -0,0 +1,95 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Logging.Abstractions;
+using Fluxor;
+
+namespace EventLogExpert.Runtime.Common.Sources;
+
+internal abstract class ObservableStateSourceBase<TState, TProjection> : IChangeNotifier, IDisposable
+{
+    private static readonly Func<TProjection, TProjection, bool> s_defaultEquals =
+        static (next, current) => EqualityComparer<TProjection>.Default.Equals(next, current);
+
+    private readonly Lock _gate = new();
+    private readonly ITraceLogger _logger;
+    private readonly Func<TState, TProjection> _project;
+    private readonly Func<TProjection, TProjection, bool> _projectionEquals;
+    private readonly IState<TState> _state;
+
+    private TProjection _current;
+    private bool _disposed;
+
+    protected ObservableStateSourceBase(
+        IState<TState> state,
+        ITraceLogger logger,
+        Func<TState, TProjection> project,
+        Func<TProjection, TProjection, bool>? projectionEquals = null)
+    {
+        ArgumentNullException.ThrowIfNull(state);
+        ArgumentNullException.ThrowIfNull(logger);
+        ArgumentNullException.ThrowIfNull(project);
+
+        _state = state;
+        _logger = logger;
+        _project = project;
+        _projectionEquals = projectionEquals ?? s_defaultEquals;
+
+        _current = _project(state.Value);
+        _state.StateChanged += OnStateChanged;
+
+        lock (_gate) { _current = _project(_state.Value); }
+    }
+
+    public event Action? Changed;
+
+    protected TProjection CurrentProjection
+    {
+        get { lock (_gate) { return _current; } }
+    }
+
+    public void Dispose()
+    {
+        lock (_gate)
+        {
+            if (_disposed) { return; }
+
+            _disposed = true;
+        }
+
+        _state.StateChanged -= OnStateChanged;
+    }
+
+    private void OnStateChanged(object? sender, EventArgs e)
+    {
+        var next = _project(_state.Value);
+
+        lock (_gate)
+        {
+            if (_disposed || _projectionEquals(next, _current)) { return; }
+
+            _current = next;
+        }
+
+        RaiseChanged();
+    }
+
+    private void RaiseChanged()
+    {
+        var handlers = Changed;
+
+        if (handlers is null) { return; }
+
+        foreach (var handler in handlers.GetInvocationList().Cast<Action>())
+        {
+            try
+            {
+                handler();
+            }
+            catch (Exception fault)
+            {
+                _logger.Trace($"{GetType().Name}: a subscriber threw and was isolated: {fault}");
+            }
+        }
+    }
+}
diff --git a/src/EventLogExpert.Runtime/DatabaseTools/Elevation/ElevatedDatabaseToolsRunner.cs b/src/EventLogExpert.Runtime/DatabaseTools/Elevation/ElevatedDatabaseToolsRunner.cs
index cc93103cc..787383f83 100644
--- a/src/EventLogExpert.Runtime/DatabaseTools/Elevation/ElevatedDatabaseToolsRunner.cs
+++ b/src/EventLogExpert.Runtime/DatabaseTools/Elevation/ElevatedDatabaseToolsRunner.cs
@@ -18,11 +18,13 @@
 
 namespace EventLogExpert.Runtime.DatabaseTools.Elevation;
 
-// Duplex named-pipe buffers permit concurrent drain reads and request/cancel writes.
 internal sealed class ElevatedDatabaseToolsRunner : IElevatedDatabaseToolsRunner
 {
     private const int ChannelCapacity = 1024;
 
+    private static readonly TimeSpan s_defaultCancellationGrace = TimeSpan.FromSeconds(30);
+    private static readonly TimeSpan s_defaultExitGrace = TimeSpan.FromSeconds(5);
+    private static readonly TimeSpan s_defaultHelloTimeout = TimeSpan.FromSeconds(10);
     private static readonly UTF8Encoding s_utf8NoBom = new(encoderShouldEmitUTF8Identifier: false);
 
     private readonly TimeSpan _cancellationGrace;
@@ -32,7 +34,7 @@ internal sealed class ElevatedDatabaseToolsRunner : IElevatedDatabaseToolsRunner
     private readonly ITraceLogger _traceLogger;
 
     public ElevatedDatabaseToolsRunner(IElevatedHelperProcessHost host, ITraceLogger traceLogger)
-        : this(host, traceLogger, TimeSpan.FromSeconds(10), TimeSpan.FromSeconds(30), TimeSpan.FromSeconds(5)) { }
+        : this(host, traceLogger, s_defaultHelloTimeout, s_defaultCancellationGrace, s_defaultExitGrace) { }
 
     internal ElevatedDatabaseToolsRunner(
         IElevatedHelperProcessHost host,
@@ -518,7 +520,6 @@ private async Task<DatabaseToolsResult> RunAsync(
 
             killState.CancelGraceTimer();
 
-            // Join the kill-timer so its disposition write happens-before the TranslateOutcome read.
             try { await killState.KillTaskOrCompleted.WaitAsync(_exitGrace); }
             catch (TimeoutException)
             {
@@ -605,7 +606,6 @@ private async Task<DatabaseToolsResult> RunAsync(
                     catch { /* best effort */ }
                 }
 
-                // Dispose pipe before force-kill so the helper can exit cooperatively.
                 try { await ((IAsyncDisposable)process.Pipe).DisposeAsync(); }
                 catch { /* best effort */ }
 
diff --git a/src/EventLogExpert.Runtime/DebugLog/OperationLogProgressFactory.cs b/src/EventLogExpert.Runtime/DebugLog/OperationLogProgressFactory.cs
index 02bf8b3cc..0c095f816 100644
--- a/src/EventLogExpert.Runtime/DebugLog/OperationLogProgressFactory.cs
+++ b/src/EventLogExpert.Runtime/DebugLog/OperationLogProgressFactory.cs
@@ -15,7 +15,7 @@ public IProgress<LogRecord> Create(IProgress<LogRecord> uiProgress, string categ
         ArgumentNullException.ThrowIfNull(uiProgress);
         ArgumentException.ThrowIfNullOrEmpty(category);
 
-        List<ILogSink> sinks = [new UiStreamingSink(uiProgress, routingPolicy.UiMinimumFor(verbose)), fileSink];
+        List<ILogSink> sinks = [new UIStreamingSink(uiProgress, routingPolicy.UIMinimumFor(verbose)), fileSink];
 
         return new BroadcastLogProgress(sinks, category);
     }
diff --git a/src/EventLogExpert.Runtime/DependencyInjection/RuntimeServiceCollectionExtensions.cs b/src/EventLogExpert.Runtime/DependencyInjection/RuntimeServiceCollectionExtensions.cs
index c9cc52ff2..353a1520d 100644
--- a/src/EventLogExpert.Runtime/DependencyInjection/RuntimeServiceCollectionExtensions.cs
+++ b/src/EventLogExpert.Runtime/DependencyInjection/RuntimeServiceCollectionExtensions.cs
@@ -3,6 +3,7 @@
 
 using EventLogExpert.DatabaseTools.DependencyInjection;
 using EventLogExpert.Eventing.Readers;
+using EventLogExpert.Eventing.Resolvers;
 using EventLogExpert.Eventing.Writers;
 using EventLogExpert.Logging.Abstractions;
 using EventLogExpert.Logging.Configuration;
@@ -13,6 +14,7 @@
 using EventLogExpert.Runtime.Announcement;
 using EventLogExpert.Runtime.Banner;
 using EventLogExpert.Runtime.Common.AppTitle;
+using EventLogExpert.Runtime.Common.Clipboard;
 using EventLogExpert.Runtime.Common.Files;
 using EventLogExpert.Runtime.Common.Versioning;
 using EventLogExpert.Runtime.Database;
@@ -26,11 +28,11 @@
 using EventLogExpert.Runtime.FilterPane;
 using EventLogExpert.Runtime.Histogram;
 using EventLogExpert.Runtime.LogTable;
-using EventLogExpert.Runtime.Menu;
-using EventLogExpert.Runtime.Modal;
+using EventLogExpert.Runtime.LogTable.OrderedView;
 using EventLogExpert.Runtime.Scenarios;
 using EventLogExpert.Runtime.Scenarios.Favorites;
 using EventLogExpert.Runtime.Settings;
+using EventLogExpert.Runtime.StatusBar;
 using EventLogExpert.Runtime.Update;
 using EventLogExpert.Runtime.Update.Deployment;
 using EventLogExpert.Scenarios.Catalog;
@@ -72,8 +74,8 @@ private static void AddDatabaseServices(IServiceCollection services)
             ActivatorUtilities.CreateInstance<DatabaseRecoveryService>(sp, CategoryLogger(sp, LogCategories.Database)));
 
         services.AddSingleton<DatabaseService>();
-        services.AddSingleton<IDatabaseService>(static sp => sp.GetRequiredService<DatabaseService>());
-        services.AddSingleton<IActiveDatabases>(static sp => sp.GetRequiredService<DatabaseService>());
+        services.Forward<IDatabaseService, DatabaseService>();
+        services.Forward<IActiveDatabases, DatabaseService>();
 
         services.AddSingleton<IDatabaseOperationCoordinator>(static sp =>
             ActivatorUtilities.CreateInstance<DatabaseOperationCoordinator>(sp, CategoryLogger(sp, LogCategories.Database)));
@@ -90,13 +92,6 @@ private static ITraceLogger CategoryLogger(IServiceProvider serviceProvider, str
 
     extension(IServiceCollection services)
     {
-        /// <summary>
-        ///     Helper-friendly subset of <see cref="AddEventLogRuntime" />. Registers ONLY
-        ///     <see cref="IDatabaseToolsService" /> and its operation factory dependency. Used by the packaged elevation helper
-        ///     which needs to run DatabaseTools operations but must NOT pull in the rest of the runtime (Fluxor, banner services,
-        ///     settings, etc.) - those would require host services (file pickers, modal coordinators) that don't exist in a
-        ///     console helper.
-        /// </summary>
         public IServiceCollection AddDatabaseToolsRuntime()
         {
             ArgumentNullException.ThrowIfNull(services);
@@ -107,12 +102,6 @@ public IServiceCollection AddDatabaseToolsRuntime()
             return services;
         }
 
-        /// <summary>
-        ///     Registers <see cref="IElevatedDatabaseToolsRunner" /> backed by the in-Runtime
-        ///     <see cref="ElevatedDatabaseToolsRunner" /> implementation. Callers MUST also register
-        ///     <see cref="IElevatedHelperProcessHost" /> separately (the production implementation lives in the MAUI head's
-        ///     adapter layer; tests substitute scripted fakes).
-        /// </summary>
         public IServiceCollection AddElevatedDatabaseToolsRunner()
         {
             ArgumentNullException.ThrowIfNull(services);
@@ -125,39 +114,6 @@ public IServiceCollection AddElevatedDatabaseToolsRunner()
             return services;
         }
 
-        /// <summary>
-        ///     Registers the runtime tier's services. Callers MUST also register:
-        ///     <list type="bullet">
-        ///         <item>
-        ///             <c>AddFluxor(...)</c> - effect classes and state selectors depend on <c>IDispatcher</c>,
-        ///             <c>IState&lt;T&gt;</c>, etc.
-        ///         </item>
-        ///         <item><c>AddEventLogFiltering()</c> - effect classes depend on <c>IFilterService</c>.</item>
-        ///         <item>
-        ///             <c>AddEventLogProviderDatabase()</c> - database sub-services depend on
-        ///             <c>IProviderDatabaseMaintenance</c>.
-        ///         </item>
-        ///         <item>
-        ///             <c>IFilePickerService</c> - <c>DatabaseOperationCoordinator</c> depends on it for Import. Host registers
-        ///             a concrete implementation (e.g., <c>MauiFilePickerService</c>).
-        ///         </item>
-        ///         <item>
-        ///             <c>IFilterLibraryStore</c> - <c>FilterLibrary</c> effects depend on it. Register the default
-        ///             SQLite-backed store via <c>services.AddFilterLibrarySqliteStore(<i>dbPath</i>)</c>, or supply a custom
-        ///             implementation.
-        ///         </item>
-        ///         <item>
-        ///             <c>IScenarioFavoriteStore</c> - the scenario favorites effects depend on it. Register the default
-        ///             SQLite-backed store via <c>services.AddScenarioFavoriteSqliteStore(<i>dbPath</i>)</c>, or supply a custom
-        ///             implementation.
-        ///         </item>
-        ///         <item>
-        ///             <c>IMenuActionService</c> - the scenario launch service depends on it to open a scenario's channels. The
-        ///             host registers the concrete implementation (e.g., <c>MauiMenuActionService</c>).
-        ///         </item>
-        ///     </list>
-        ///     Omitting any of these produces a DI resolution failure when the dependent services are first activated.
-        /// </summary>
         public IServiceCollection AddEventLogRuntime()
         {
             ArgumentNullException.ThrowIfNull(services);
@@ -165,7 +121,7 @@ public IServiceCollection AddEventLogRuntime()
             AddDatabaseServices(services);
             AddExportServices(services);
 
-            // Command facades.
+            // Commands
             services.AddSingleton<IEventLogCommands, EventLogCommands>();
             services.AddSingleton<IFilterLensCommands, FilterLensCommands>();
             services.AddSingleton<IFilterLibraryCommands, FilterLibraryCommands>();
@@ -174,43 +130,75 @@ public IServiceCollection AddEventLogRuntime()
             services.AddSingleton<ILogTableCommands, LogTableCommands>();
             services.AddSingleton<IScenarioFavoriteCommands, ScenarioFavoriteCommands>();
 
-            // Query facades.
+            // Queries
             services.AddSingleton<IEventLogQueries, EventLogQueries>();
+            services.AddSingleton<ILogTableQueries, LogTableQueries>();
+            services.AddSingleton<IFilterPaneQueries, FilterPaneQueries>();
 
-            // Shared coordination state for EventLog effects classes.
+            // Coordinators and concurrency
             services.AddSingleton<LogCloseCoordinator>();
             services.AddSingleton<EventLogConcurrencyState>();
-            services.AddSingleton<PartialLoadCoordinator>();
+            services.AddSingleton<XmlReloadCoordinator>();
+            services.AddSingleton<LiveTailIngestCoordinator>();
+            services.AddSingleton<FilteredLogPresenceCoordinator>();
             services.AddSingleton<IEventLogReaderFactory, EventLogReaderFactory>();
 
-            // UI capabilities.
+            // Ordered-view engine
+            services.AddSingleton<OrderedViewWriter>(static _ => new OrderedViewWriter());
+            services.AddSingleton<ViewRequestIssuer>();
+            services.AddSingleton<OrderedViewDispatchBridge>();
+            services.AddSingleton<IOrderedViewSource, OrderedViewSource>();
+
+            // Read-model sources
+            services.AddSingleton<IFilterLensSource, FilterLensSource>();
+            services.AddSingleton<IOpenLogsPresenceSource, OpenLogsPresenceSource>();
+            services.AddSingleton<IHistogramVisibilitySource, HistogramVisibilitySource>();
+            services.AddSingleton<IFilterAppliedSource, FilterAppliedSource>();
+            services.AddSingleton<IEventFocusSource, EventFocusSource>();
+            services.AddSingleton<IActiveEventLogSource, ActiveEventLogSource>();
+            services.AddSingleton<IEventSelectionSource, EventSelectionSource>();
+            services.AddSingleton<IRevealFocusSource, RevealFocusSource>();
+            services.AddSingleton<IHistogramDimensionRequestSource, HistogramDimensionRequestSource>();
+            services.AddSingleton<IActiveFiltersSource, ActiveFiltersSource>();
+            services.AddSingleton<IFilteredDateRangeSource, FilteredDateRangeSource>();
+            services.AddSingleton<ILoadedLogNamesSource, LoadedLogNamesSource>();
+            services.AddSingleton<ILibraryEntriesSource, LibraryEntriesSource>();
+            services.AddSingleton<ILibraryLoadStatusSource, LibraryLoadStatusSource>();
+            services.AddSingleton<IScenarioFavoritesSource, ScenarioFavoritesSource>();
+            services.AddSingleton<ILogTabBarSource, LogTabBarSource>();
+            services.AddSingleton<IStatusBarSource, StatusBarSource>();
+
+            // Change notifiers (concrete raises; interface subscribes; one shared instance)
+            services.AddSingleton<GroupCollapseNotifier>();
+            services.Forward<IGroupCollapseNotifier, GroupCollapseNotifier>();
+            services.AddSingleton<TagBulkUpdateFailedNotifier>();
+            services.Forward<ITagBulkUpdateFailedNotifier, TagBulkUpdateFailedNotifier>();
+            services.AddSingleton<ClearAllFiltersNotifier>();
+            services.Forward<IClearAllFiltersNotifier, ClearAllFiltersNotifier>();
+            services.AddSingleton<SetFilterDateRangeSucceededNotifier>();
+            services.Forward<ISetFilterDateRangeSucceededNotifier, SetFilterDateRangeSucceededNotifier>();
+
+            // Indicators, resolvers, formatters, and selectors
+            services.AddSingleton<DisplayIndicatorGate>();
+            services.AddSingleton<IEventDetailResolver, EventDetailResolver>();
+            services.AddSingleton<IEventXmlResolver, EventXmlResolver>();
+            services.AddSingleton<IEventCopyFormatter, EventCopyFormatter>();
             services.AddSingleton<IHighlightSelector, HighlightSelector>();
             services.AddSingleton<ILogTableColumnDefaultsProvider, ColumnDefaults>();
-            services.AddSingleton<DatabaseCoordinationEffects>();
-            services.AddSingleton<ILogReloadCoordinator>(static sp => sp.GetRequiredService<DatabaseCoordinationEffects>());
+            services.AddSingleton<ILogReloadCoordinator, DatabaseCoordinationEffects>();
 
-            // Application services.
+            // Application shell: title, banners, and announcements
             services.AddSingleton<IAppTitleService, AppTitleService>();
-
-            // BannerService is the shared backing store for the 5 banner facets.
-            // Registered once as the concrete type, then each facet interface resolves
-            // back to the same singleton instance. This preserves cross-facet state
-            // invariants (single lock, single backing store) while letting consumers
-            // depend only on the narrow interface they need.
             services.AddSingleton<BannerService>();
-            services.AddSingleton<IAttentionBannerService>(static sp => sp.GetRequiredService<BannerService>());
-            services.AddSingleton<IProgressBannerService>(static sp => sp.GetRequiredService<BannerService>());
-            services.AddSingleton<ICriticalErrorService>(static sp => sp.GetRequiredService<BannerService>());
-            services.AddSingleton<IErrorBannerService>(static sp => sp.GetRequiredService<BannerService>());
-            services.AddSingleton<IInfoBannerService>(static sp => sp.GetRequiredService<BannerService>());
-
-            // Export progress is a standalone banner facet with no database coupling, so it is a
-            // separate singleton from BannerService. The UI BannerCycleStateService consumes it as a
-            // 7th source; the head menu driver brackets a streaming export with Begin/End.
+            services.Forward<IAttentionBannerService, BannerService>();
+            services.Forward<IProgressBannerService, BannerService>();
+            services.Forward<ICriticalErrorService, BannerService>();
+            services.Forward<IErrorBannerService, BannerService>();
+            services.Forward<IInfoBannerService, BannerService>();
             services.AddSingleton<IExportProgressBannerService, ExportProgressBannerService>();
-
             services.AddSingleton<IAnnouncementService, AnnouncementService>();
 
+            // Logging
             services.Configure<LoggingOptions>(LoggingOptions.ApplyShippedDefaults);
             services.AddSingleton(static sp =>
             {
@@ -219,9 +207,6 @@ public IServiceCollection AddEventLogRuntime()
                     sp.GetRequiredService<IOptions<LoggingOptions>>().Value,
                     settings.LogLevel);
 
-                // Seed the initial verbose-resolution override at construction (mirrors the LogLevel baseline seeding
-                // above) so a persisted-ON toggle is in effect the moment the singleton is visible - before the eager
-                // DebugLogHost resolve. DebugLogHost then bridges only subsequent toggles.
                 if (settings.VerboseResolution)
                 {
                     policy.SetCategoryOverride(LogCategories.Resolution, LogLevel.Trace);
@@ -236,14 +221,11 @@ public IServiceCollection AddEventLogRuntime()
             services.AddSingleton<IDebugLogReader>(static sp => new DebugLogFileReader(
                 sp.GetRequiredService<FileLocationOptions>(),
                 sp.GetRequiredService<FileLogSink>()));
-            // Owns the settings->routing-baseline bridge + the unhandled-exception hook. Nothing depends on it, so the
-            // MAUI head force-resolves it at startup; it depends on FileLogSink so it is disposed (hooks detached) first.
             services.AddSingleton<DebugLogHost>();
             services.AddSingleton<ILogSourceFactory>(static sp =>
             {
                 List<ILogSink> sinks = [sp.GetRequiredService<FileLogSink>()];
 #if DEBUG
-                // Debug builds also mirror to the console so logs surface in the F12 / debug window; Release is file-only.
                 sinks.Add(new ConsoleSink());
 #endif
                 return new LogSourceFactory(sinks);
@@ -254,12 +236,9 @@ public IServiceCollection AddEventLogRuntime()
                 sp.GetRequiredService<ILogSourceFactory>().ForCategory(LogCategories.EventLog));
             services.AddSingleton<IOperationLogProgressFactory, OperationLogProgressFactory>();
             services.AddSingleton<ILogWatcherService, LogWatcherService>();
-            services.AddSingleton<IMenuService, MenuService>();
-            services.AddSingleton<IModalCoordinator, ModalCoordinator>();
-            services.AddSingleton<IModalService, ModalService>();
             services.AddSingleton<ISettingsService, SettingsService>();
 
-            // Update + deployment services.
+            // Update and deployment
             services.AddSingleton<ICurrentVersionProvider, CurrentVersionProvider>();
             services.AddSingleton<IDeploymentService, DeploymentService>();
             services.AddSingleton<IGitHubService, GitHubService>();
@@ -267,12 +246,11 @@ public IServiceCollection AddEventLogRuntime()
             services.AddSingleton<IPackageVersionProvider, PackageVersionProvider>();
             services.AddSingleton<IUpdateService, UpdateService>();
 
-            // DatabaseTools service (CLI-equivalent operations exposed to the UI).
+            // Database tools
             services.AddDatabaseToolsServices();
             services.TryAddSingleton<IDatabaseToolsService, DatabaseToolsService>();
 
-            // Built-in scenarios: the immutable embedded catalog + presence/query/launch services. The registry
-            // aggregates every registered IScenarioSource (PR1 ships only the built-in source).
+            // Scenarios and channels
             services.AddSingleton<IScenarioSource, BuiltInScenarioSource>();
             services.AddSingleton<BuiltInScenarioRegistry>();
             services.AddSingleton<IChannelConfigReader>(static sp =>
@@ -280,8 +258,8 @@ public IServiceCollection AddEventLogRuntime()
             services.AddSingleton<IChannelConfigWriter>(static sp =>
                 new ChannelConfigWriter(CategoryLogger(sp, LogCategories.EventLog)));
             services.AddSingleton<ChannelPresenceProbe>();
-            services.AddSingleton<IChannelPresenceProbe>(static sp => sp.GetRequiredService<ChannelPresenceProbe>());
-            services.AddSingleton<IChannelReadinessService>(static sp => sp.GetRequiredService<ChannelPresenceProbe>());
+            services.Forward<IChannelPresenceProbe, ChannelPresenceProbe>();
+            services.Forward<IChannelReadinessService, ChannelPresenceProbe>();
             services.AddSingleton<IChannelEnableService, ChannelEnableService>();
             services.AddSingleton<IEvtxChannelReader, EvtxChannelReader>();
             services.AddSingleton<IScenarioQueryService, ScenarioQueryService>();
diff --git a/src/EventLogExpert.Runtime/DependencyInjection/ServiceCollectionForwardingExtensions.cs b/src/EventLogExpert.Runtime/DependencyInjection/ServiceCollectionForwardingExtensions.cs
new file mode 100644
index 000000000..d942e35df
--- /dev/null
+++ b/src/EventLogExpert.Runtime/DependencyInjection/ServiceCollectionForwardingExtensions.cs
@@ -0,0 +1,23 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+namespace Microsoft.Extensions.DependencyInjection;
+
+public static class ServiceCollectionForwardingExtensions
+{
+    /// <summary>
+    ///     Registers <typeparamref name="TService" /> so it resolves to the single shared
+    ///     <typeparamref name="TImplementation" /> singleton instead of constructing a second instance. Register the concrete
+    ///     <typeparamref name="TImplementation" /> separately, then forward every additional interface to it.
+    /// </summary>
+    public static IServiceCollection Forward<TService, TImplementation>(this IServiceCollection services)
+        where TService : class
+        where TImplementation : class, TService
+    {
+        ArgumentNullException.ThrowIfNull(services);
+
+        services.AddSingleton<TService>(static sp => sp.GetRequiredService<TImplementation>());
+
+        return services;
+    }
+}
diff --git a/src/EventLogExpert.Runtime/EventLog/EventFocusSource.cs b/src/EventLogExpert.Runtime/EventLog/EventFocusSource.cs
new file mode 100644
index 000000000..aa4b915ad
--- /dev/null
+++ b/src/EventLogExpert.Runtime/EventLog/EventFocusSource.cs
@@ -0,0 +1,18 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Logging.Abstractions;
+using EventLogExpert.Runtime.Common.Sources;
+using Fluxor;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace EventLogExpert.Runtime.EventLog;
+
+internal sealed class EventFocusSource(
+    IState<EventLogState> state,
+    [FromKeyedServices(LogCategories.EventLog)] ITraceLogger logger)
+    : ObservableStateSourceBase<EventLogState, SelectionEntry?>(state, logger, static state => state.Focus),
+        IEventFocusSource
+{
+    public SelectionEntry? Current => CurrentProjection;
+}
diff --git a/src/EventLogExpert.Runtime/EventLog/EventLogCommands.cs b/src/EventLogExpert.Runtime/EventLog/EventLogCommands.cs
index a0df32f58..729ea0e5d 100644
--- a/src/EventLogExpert.Runtime/EventLog/EventLogCommands.cs
+++ b/src/EventLogExpert.Runtime/EventLog/EventLogCommands.cs
@@ -3,6 +3,7 @@
 
 using EventLogExpert.Eventing.Common.Channels;
 using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
 using Fluxor;
 
 namespace EventLogExpert.Runtime.EventLog;
@@ -13,14 +14,14 @@ internal sealed class EventLogCommands(IDispatcher dispatcher) : IEventLogComman
 
     public void CloseAllLogs() => _dispatcher.Dispatch(new CloseAllLogsAction());
 
-    // Emits the user-close discriminator alongside the close so lens lifecycle (and any other user-close-only subscriber)
-    // can distinguish a genuine tab close from a filter-driven reload, which dispatches CloseLogAction directly.
     public void CloseLog(EventLogId logId, string logName)
     {
         _dispatcher.Dispatch(new CloseLogAction(logId, logName));
         _dispatcher.Dispatch(new LogClosedByUserAction(logId, logName));
     }
 
+    public void ConsumeRevealFocus(EventLocator target) => _dispatcher.Dispatch(new RevealFocusConsumedAction(target));
+
     public void LoadNewEvents() => _dispatcher.Dispatch(new LoadNewEventsAction());
 
     public void OpenLog(string logName, LogPathType logPathType, CancellationToken token = default) =>
diff --git a/src/EventLogExpert.Runtime/EventLog/EventLogConcurrencyState.cs b/src/EventLogExpert.Runtime/EventLog/EventLogConcurrencyState.cs
index 938e8ab31..8a477cccc 100644
--- a/src/EventLogExpert.Runtime/EventLog/EventLogConcurrencyState.cs
+++ b/src/EventLogExpert.Runtime/EventLog/EventLogConcurrencyState.cs
@@ -11,18 +11,13 @@ internal sealed class EventLogConcurrencyState
     private readonly ConcurrentDictionary<EventLogId, byte> _logsLoadedWithXml = new();
 
     private long _closeAllToken;
-    private long _filterToken;
 
     public void ClearAllLoadedWithXml() => _logsLoadedWithXml.Clear();
 
     public void ClearLoadedWithXml(EventLogId logId) => _logsLoadedWithXml.TryRemove(logId, out _);
 
-    public long GetCurrentFilterToken() => Interlocked.Read(ref _filterToken);
-
     public long GetCurrentReloadToken() => Interlocked.Read(ref _closeAllToken);
 
-    public long InvalidateInFlightFilters() => Interlocked.Increment(ref _filterToken);
-
     public void InvalidateInFlightReloads() => Interlocked.Increment(ref _closeAllToken);
 
     public bool IsLoadedWithXml(EventLogId logId) => _logsLoadedWithXml.ContainsKey(logId);
diff --git a/src/EventLogExpert.Runtime/EventLog/EventLogQueries.cs b/src/EventLogExpert.Runtime/EventLog/EventLogQueries.cs
index d38866fd2..52701fced 100644
--- a/src/EventLogExpert.Runtime/EventLog/EventLogQueries.cs
+++ b/src/EventLogExpert.Runtime/EventLog/EventLogQueries.cs
@@ -65,6 +65,8 @@ public ImmutableArray<string> GetUserDataFieldValues(string fieldName)
         return EventPropertyValuesCache.GetUserDataFieldValues(byLog, EnumerateAll(byLog), fieldName);
     }
 
+    public bool IsContinuouslyUpdating() => _eventLogState.Value.ContinuouslyUpdate;
+
     private static IEnumerable<ResolvedEvent> EnumerateAll(
         ImmutableDictionary<EventLogId, EventColumnStore> byLog)
     {
diff --git a/src/EventLogExpert.Runtime/EventLog/EventLogState.cs b/src/EventLogExpert.Runtime/EventLog/EventLogState.cs
index b6b050448..59d790f5a 100644
--- a/src/EventLogExpert.Runtime/EventLog/EventLogState.cs
+++ b/src/EventLogExpert.Runtime/EventLog/EventLogState.cs
@@ -11,7 +11,6 @@ namespace EventLogExpert.Runtime.EventLog;
 [FeatureState]
 public sealed record EventLogState
 {
-    /// <summary>The maximum number of new events we will hold in the state before we turn off the watcher.</summary>
     public static int MaxNewEvents => 1000;
 
     internal ImmutableDictionary<string, OpenLogInfo> OpenLogs { get; init; } =
@@ -38,4 +37,6 @@ public sealed record EventLogState
     public SelectionEntry? Focus { get; init; }
 
     public ImmutableList<SelectionEntry> Selection { get; init; } = [];
+
+    public EventLocator? PendingRevealFocus { get; init; }
 }
diff --git a/src/EventLogExpert.Runtime/EventLog/EventSelectionSource.cs b/src/EventLogExpert.Runtime/EventLog/EventSelectionSource.cs
new file mode 100644
index 000000000..896d0c8d3
--- /dev/null
+++ b/src/EventLogExpert.Runtime/EventLog/EventSelectionSource.cs
@@ -0,0 +1,23 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Logging.Abstractions;
+using EventLogExpert.Runtime.Common.Sources;
+using Fluxor;
+using Microsoft.Extensions.DependencyInjection;
+using System.Collections.Immutable;
+
+namespace EventLogExpert.Runtime.EventLog;
+
+internal sealed class EventSelectionSource(
+    IState<EventLogState> state,
+    [FromKeyedServices(LogCategories.EventLog)] ITraceLogger logger)
+    : ObservableStateSourceBase<EventLogState, ImmutableList<SelectionEntry>>(
+            state,
+            logger,
+            static state => state.Selection,
+            static (next, current) => ReferenceEquals(next, current)),
+        IEventSelectionSource
+{
+    public ImmutableList<SelectionEntry> Current => CurrentProjection;
+}
diff --git a/src/EventLogExpert.Runtime/EventLog/FilterAppliedSource.cs b/src/EventLogExpert.Runtime/EventLog/FilterAppliedSource.cs
new file mode 100644
index 000000000..2a459202c
--- /dev/null
+++ b/src/EventLogExpert.Runtime/EventLog/FilterAppliedSource.cs
@@ -0,0 +1,18 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Logging.Abstractions;
+using EventLogExpert.Runtime.Common.Sources;
+using Fluxor;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace EventLogExpert.Runtime.EventLog;
+
+internal sealed class FilterAppliedSource(
+    IState<EventLogState> state,
+    [FromKeyedServices(LogCategories.EventLog)] ITraceLogger logger)
+    : ObservableStateSourceBase<EventLogState, bool>(state, logger, static state => state.AppliedFilter.IsFilteringEnabled),
+        IFilterAppliedSource
+{
+    public bool IsFilteringEnabled => CurrentProjection;
+}
diff --git a/src/EventLogExpert.Runtime/EventLog/FilteringEffects.cs b/src/EventLogExpert.Runtime/EventLog/FilteringEffects.cs
index d86242db3..7a67ba9d7 100644
--- a/src/EventLogExpert.Runtime/EventLog/FilteringEffects.cs
+++ b/src/EventLogExpert.Runtime/EventLog/FilteringEffects.cs
@@ -1,58 +1,30 @@
 // // Copyright (c) Microsoft Corporation.
 // // Licensed under the MIT License.
 
-using EventLogExpert.Eventing.Common.Channels;
-using EventLogExpert.Eventing.Common.EventLogs;
-using EventLogExpert.Eventing.Common.Events;
-using EventLogExpert.Filtering.Evaluation;
-using EventLogExpert.Logging.Abstractions;
-using EventLogExpert.Runtime.FilterProgress;
-using EventLogExpert.Runtime.Histogram;
-using EventLogExpert.Runtime.LogTable;
 using Fluxor;
-using Microsoft.Extensions.DependencyInjection;
-using System.Collections.Immutable;
 using IDispatcher = Fluxor.IDispatcher;
 
 namespace EventLogExpert.Runtime.EventLog;
 
 internal sealed class FilteringEffects(
     IState<EventLogState> eventLogState,
-    IState<RawEventStoreState> rawEventStore,
-    IState<LogTableState> logTableState,
-    [FromKeyedServices(LogCategories.EventLog)] ITraceLogger logger,
-    LogCloseCoordinator closeCoordinator,
-    EventLogConcurrencyState concurrencyState,
-    TimeSpan? convergenceDelay = null)
+    LiveTailIngestCoordinator liveTailCoordinator,
+    XmlReloadCoordinator xmlReloadCoordinator)
 {
-    private readonly LogCloseCoordinator _closeCoordinator = closeCoordinator;
-    private readonly EventLogConcurrencyState _concurrencyState = concurrencyState;
-    private readonly TimeSpan _convergenceDelay = convergenceDelay ?? TimeSpan.FromMilliseconds(250);
     private readonly IState<EventLogState> _eventLogState = eventLogState;
-    private readonly IState<LogTableState> _logTableState = logTableState;
-    private readonly ITraceLogger _logger = logger;
-    private readonly IState<RawEventStoreState> _rawEventStore = rawEventStore;
+    private readonly LiveTailIngestCoordinator _liveTailCoordinator = liveTailCoordinator;
+    private readonly XmlReloadCoordinator _xmlReloadCoordinator = xmlReloadCoordinator;
 
     [EffectMethod]
     public Task HandleAddEvent(AddEventAction action, IDispatcher dispatcher)
     {
-        // The non-live-tail buffering is handled atomically by ReduceAddEvent; this effect only drives the
-        // continuously-update live tail (ingest the new event, rebuild its display).
         if (!_eventLogState.Value.ContinuouslyUpdate ||
             !_eventLogState.Value.OpenLogs.TryGetValue(action.NewEvent.OwningLog, out var owningLog))
         {
             return Task.CompletedTask;
         }
 
-        var newEventsByLog = new Dictionary<EventLogId, IReadOnlyList<ResolvedEvent>>
-        {
-            [owningLog.Id] = [action.NewEvent]
-        };
-
-        // Ingest before the rebuild: the filter-gated build runs in the continuation so it reads the post-ingest store
-        // (inlining here would lag the tail by one event). Live tail owns no buffer.
-        dispatcher.Dispatch(new IngestRawEventsAction(newEventsByLog, RawIngestMode.Prepend));
-        dispatcher.Dispatch(new RebuildDisplayViewsAction(newEventsByLog, BufferEntriesToConsume: null));
+        _liveTailCoordinator.Enqueue(owningLog.Id, action.NewEvent);
 
         return Task.CompletedTask;
     }
@@ -60,111 +32,11 @@ public Task HandleAddEvent(AddEventAction action, IDispatcher dispatcher)
     [EffectMethod]
     public async Task HandleApplyFilter(ApplyFilterAction action, IDispatcher dispatcher)
     {
-        long reloadTokenAtStart = _concurrencyState.GetCurrentReloadToken();
-
-        bool newRequiresXml = action.Filter.RequiresXml;
-
-        // Reopen only logs missing the XML the new filter needs; UserData filters resolve from stored fields and never force a reload.
-        var logsNeedingReload = newRequiresXml && !_eventLogState.Value.OpenLogs.IsEmpty
-            ? _eventLogState.Value.OpenLogs
-                .Where(kvp => !_concurrencyState.IsLoadedWithXml(kvp.Value.Id))
-                .Select(kvp => (kvp.Value.Id, Name: kvp.Key, kvp.Value.Type))
-                .ToList()
-            : [];
-
-        long filterToken = _concurrencyState.InvalidateInFlightFilters();
+        PendingXmlReload pendingReload = _xmlReloadCoordinator.Resolve(action.Filter);
 
-        if (logsNeedingReload.Count > 0)
+        if (pendingReload.IsNeeded)
         {
-            dispatcher.Dispatch(new SetFilterProgressAction(false));
-
-            await ReloadLogsWithXmlAsync(logsNeedingReload, reloadTokenAtStart, dispatcher);
-
-            return;
-        }
-
-        await ApplyFilterAndPublishAsync(action.Filter, filterToken, dispatcher);
-    }
-
-    [EffectMethod]
-    public async Task HandleConvergeFilter(ConvergeFilterAction action, IDispatcher dispatcher)
-    {
-        long filterToken = action.OriginToken;
-
-        if (_concurrencyState.GetCurrentFilterToken() != filterToken) { return; }
-
-        var filter = _eventLogState.Value.AppliedFilter;
-        var logTable = _logTableState.Value;
-        var context = logTable.SortContext;
-        var version = logTable.DisplayListVersion;
-
-        var targets = ResidualOpenStale(action.StaleIds);
-
-        if (targets.Length == 0)
-        {
-            if (_concurrencyState.GetCurrentFilterToken() == filterToken)
-            {
-                dispatcher.Dispatch(new SetFilterProgressAction(false));
-            }
-
-            return;
-        }
-
-        bool convergenceScheduled = false;
-
-        try
-        {
-            var snapshot = SnapshotEventsForLogs(targets);
-            var sorted = await Task.Run(() => FilterAndSort(snapshot, filter, context));
-
-            if (_concurrencyState.GetCurrentFilterToken() != filterToken) { return; }
-
-            var capturedByLog = snapshot.ToDictionary(pair => pair.Id, pair => pair.ContentVersion);
-            var nowRaw = _rawEventStore.Value.ByLog;
-            var fresh = new Dictionary<EventLogId, EventColumnView>(sorted.Count);
-            var residual = new List<EventLogId>();
-
-            foreach (var logId in targets)
-            {
-                // M1 race guard: an unchanged ContentVersion means no rebuild slipped in since the snapshot, so the built view still matches the live store.
-                if (sorted.TryGetValue(logId, out var view) &&
-                    capturedByLog.TryGetValue(logId, out var capturedVersion) &&
-                    nowRaw.TryGetValue(logId, out var now) &&
-                    now.ContentVersion == capturedVersion)
-                {
-                    fresh[logId] = view;
-                }
-                else
-                {
-                    residual.Add(logId);
-                }
-            }
-
-            if (fresh.Count > 0)
-            {
-                dispatcher.Dispatch(new DisplayReadyAction { Views = fresh, Version = version });
-            }
-
-            var stillStale = ResidualOpenStale(residual);
-
-            if (stillStale.Length > 0)
-            {
-                convergenceScheduled = true;
-
-                await Task.Delay(_convergenceDelay);
-
-                if (_concurrencyState.GetCurrentFilterToken() == filterToken)
-                {
-                    dispatcher.Dispatch(new ConvergeFilterAction(stillStale, filterToken));
-                }
-            }
-        }
-        finally
-        {
-            if (!convergenceScheduled && _concurrencyState.GetCurrentFilterToken() == filterToken)
-            {
-                dispatcher.Dispatch(new SetFilterProgressAction(false));
-            }
+            await _xmlReloadCoordinator.ReloadAsync(pendingReload, dispatcher);
         }
     }
 
@@ -175,317 +47,11 @@ public Task HandleSetContinuouslyUpdate(SetContinuouslyUpdateAction action, IDis
         {
             LogReloadEffects.ProcessNewEventBuffer(_eventLogState.Value, dispatcher);
         }
-
-        return Task.CompletedTask;
-    }
-
-    [EffectMethod]
-    public async Task HandleSetGroupBy(SetGroupByAction action, IDispatcher dispatcher) =>
-        await RepublishForSortAsync(dispatcher);
-
-    [EffectMethod]
-    public async Task HandleSetHistogramVisible(SetHistogramVisibleAction action, IDispatcher dispatcher)
-    {
-        // Timeline visibility only changes the default order of a single log with no explicit sort or grouping; every other
-        // view keeps its order, so skip the rebuild. This predicate matches the reducer's conditional DisplayListVersion bump.
-        var logTable = _logTableState.Value;
-
-        if (logTable.PerLogEvents.Count != 1 || logTable.RequestedOrderBy is not null || logTable.RequestedGroupBy is not null)
-        {
-            return;
-        }
-
-        await RepublishForSortAsync(dispatcher);
-    }
-
-    [EffectMethod]
-    public async Task HandleSetOrderBy(SetOrderByAction action, IDispatcher dispatcher) =>
-        await RepublishForSortAsync(dispatcher);
-
-    [EffectMethod(typeof(ToggleGroupSortingAction))]
-    public async Task HandleToggleGroupSorting(IDispatcher dispatcher)
-    {
-        if (_logTableState.Value.RequestedGroupBy is null) { return; }
-
-        await RepublishForSortAsync(dispatcher);
-    }
-
-    [EffectMethod(typeof(ToggleSortingAction))]
-    public async Task HandleToggleSorting(IDispatcher dispatcher) =>
-        await RepublishForSortAsync(dispatcher);
-
-    [EffectMethod(typeof(UpdateTableAction))]
-    public async Task HandleUpdateTable(IDispatcher dispatcher)
-    {
-        // A reopen settles under the live sort and drops the in-flight rebuild; republish if a sort is still pending.
-        if (!_logTableState.Value.HasPendingSortChange) { return; }
-
-        await RepublishForSortAsync(dispatcher);
-    }
-
-    private static Dictionary<EventLogId, EventColumnView> FilterAndSort(
-        IReadOnlyList<(EventLogId Id, EventColumnStore Store, long ContentVersion)> snapshot,
-        Filter filter,
-        SortContext context)
-    {
-        var views = new Dictionary<EventLogId, EventColumnView>(snapshot.Count);
-
-        foreach (var (logId, store, _) in snapshot)
+        else
         {
-            views[logId] = DisplayViewBuilder.Build(store, logId, filter, context);
+            _liveTailCoordinator.Flush();
         }
 
-        return views;
-    }
-
-    private async Task ApplyFilterAndPublishAsync(Filter filter, long filterToken, IDispatcher dispatcher)
-    {
-        var snapshot = SnapshotOpenLogEvents();
-        var logTable = _logTableState.Value;
-        var capturedContext = logTable.SortContext;
-        var version = logTable.DisplayListVersion;
-
-        dispatcher.Dispatch(new SetFilterProgressAction(true));
-
-        bool convergenceScheduled = false;
-
-        try
-        {
-            var sortedActiveLogs = await Task.Run(() => FilterAndSort(snapshot, filter, capturedContext));
-
-            if (_concurrencyState.GetCurrentFilterToken() != filterToken) { return; }
-
-            var snapshotById = snapshot.ToDictionary(pair => pair.Id, pair => pair.ContentVersion);
-            var currentRaw = _rawEventStore.Value.ByLog;
-            var fresh = new Dictionary<EventLogId, EventColumnView>(sortedActiveLogs.Count);
-            var staleIds = new List<EventLogId>();
-
-            foreach (var (logId, view) in sortedActiveLogs)
-            {
-                if (!snapshotById.TryGetValue(logId, out var snapshotVersion)) { continue; }
-
-                if (currentRaw.TryGetValue(logId, out var current) &&
-                    current.ContentVersion == snapshotVersion)
-                {
-                    fresh[logId] = view;
-                }
-                else
-                {
-                    staleIds.Add(logId);
-                }
-            }
-
-            if (staleIds.Count > 0)
-            {
-                var pass2Snapshot = SnapshotEventsForLogs(staleIds);
-                var refilteredSorted = await Task.Run(() => FilterAndSort(pass2Snapshot, filter, capturedContext));
-
-                if (_concurrencyState.GetCurrentFilterToken() != filterToken) { return; }
-
-                var pass2CapturedById = pass2Snapshot.ToDictionary(pair => pair.Id, pair => pair.ContentVersion);
-                var nowRaw = _rawEventStore.Value.ByLog;
-
-                foreach (var (logId, view) in refilteredSorted)
-                {
-                    if (!pass2CapturedById.TryGetValue(logId, out var pass2Version)) { continue; }
-
-                    if (nowRaw.TryGetValue(logId, out var now) &&
-                        now.ContentVersion == pass2Version)
-                    {
-                        fresh[logId] = view;
-                    }
-                }
-            }
-
-            dispatcher.Dispatch(new DisplayReadyAction { Views = fresh, Version = version });
-
-            var residualStale = ResidualOpenStale(staleIds.Where(id => !fresh.ContainsKey(id)));
-
-            if (residualStale.Length > 0)
-            {
-                convergenceScheduled = true;
-
-                await Task.Delay(_convergenceDelay);
-
-                if (_concurrencyState.GetCurrentFilterToken() == filterToken)
-                {
-                    dispatcher.Dispatch(new ConvergeFilterAction(residualStale, filterToken));
-                }
-            }
-        }
-        finally
-        {
-            if (!convergenceScheduled && _concurrencyState.GetCurrentFilterToken() == filterToken)
-            {
-                dispatcher.Dispatch(new SetFilterProgressAction(false));
-            }
-        }
-    }
-
-    private async Task ReloadLogsWithXmlAsync(
-        List<(EventLogId Id, string Name, LogPathType Type)> logsNeedingReload,
-        long reloadToken,
-        IDispatcher dispatcher)
-    {
-        var reloadNames = logsNeedingReload.Select(t => t.Name).ToHashSet(StringComparer.Ordinal);
-
-        var selectionByLog = _eventLogState.Value.Selection
-            .Where(entry => entry.ReloadKey is { } key && reloadNames.Contains(key.OwningLog))
-            .GroupBy(entry => entry.ReloadKey!.Value.OwningLog)
-            .ToDictionary(
-                group => group.Key,
-                IReadOnlySet<long> (group) => group.Select(entry => entry.ReloadKey!.Value.RecordId).ToHashSet());
-
-        var focus = _eventLogState.Value.Focus;
-        long? selectedRecordId = focus?.ReloadKey?.RecordId;
-        string? selectedLogName = focus?.ReloadKey?.OwningLog;
-
-        if (selectedRecordId.HasValue &&
-            !string.IsNullOrEmpty(selectedLogName) &&
-            reloadNames.Contains(selectedLogName) &&
-            !selectionByLog.ContainsKey(selectedLogName))
-        {
-            selectionByLog[selectedLogName] = new HashSet<long>();
-        }
-
-        await _closeCoordinator.AcquireCoordinatorLockAsync();
-
-        try
-        {
-            var closeWaiters = new List<(EventLogId Id, string Name, Task Task)>(logsNeedingReload.Count);
-
-            foreach (var (id, name, _) in logsNeedingReload)
-            {
-                var tcs = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
-                _closeCoordinator.RegisterCloseCompletion(id, tcs);
-                closeWaiters.Add((id, name, tcs.Task));
-            }
-
-            foreach (var (id, name, _) in logsNeedingReload)
-            {
-                dispatcher.Dispatch(new CloseLogAction(id, name));
-            }
-
-            var timedOutLogs = new HashSet<string>(StringComparer.Ordinal);
-
-            foreach (var (id, name, task) in closeWaiters)
-            {
-                try
-                {
-                    await task.WaitAsync(LogCloseCoordinator.LogCloseTimeout);
-                }
-                catch (TimeoutException)
-                {
-                    _closeCoordinator.RemoveStrandedCompletion(id);
-                    timedOutLogs.Add(name);
-
-                    _logger.Trace(
-                        $"{nameof(HandleApplyFilter)}: close for log '{name}' did not complete within {LogCloseCoordinator.LogCloseTimeout}; selection will not be restored to avoid race with the delayed close wiping the entry.");
-                }
-            }
-
-            foreach (var (name, ids) in selectionByLog)
-            {
-                if (timedOutLogs.Contains(name)) { continue; }
-
-                long? selectedIdForLog = string.Equals(name, selectedLogName, StringComparison.Ordinal) ?
-                    selectedRecordId : null;
-
-                _closeCoordinator.WritePendingRestore(name, new PendingSelectionRestore(ids, selectedIdForLog));
-            }
-
-            if (_concurrencyState.GetCurrentReloadToken() != reloadToken)
-            {
-                foreach (var (_, name, _) in logsNeedingReload)
-                {
-                    _closeCoordinator.ClearPendingRestore(name);
-                }
-
-                _logger.Trace(
-                    $"{nameof(HandleApplyFilter)}: reload superseded by CloseAll; skipping reopen of {logsNeedingReload.Count} log(s) and clearing pending selection restore.");
-
-                return;
-            }
-
-            var reopenedSoFar = new List<(EventLogId Id, string Name)>(logsNeedingReload.Count);
-
-            foreach (var (id, name, type) in logsNeedingReload)
-            {
-                if (_concurrencyState.GetCurrentReloadToken() != reloadToken)
-                {
-                    foreach (var (reopenedId, reopenedName) in reopenedSoFar)
-                    {
-                        dispatcher.Dispatch(new CloseLogAction(reopenedId, reopenedName));
-                    }
-
-                    foreach (var (_, restoreName, _) in logsNeedingReload)
-                    {
-                        _closeCoordinator.ClearPendingRestore(restoreName);
-                    }
-
-                    _logger.Trace(
-                        $"{nameof(HandleApplyFilter)}: reload superseded by CloseAll mid-reopen; dispatched CloseLog for {reopenedSoFar.Count} just-reopened log(s) and cleared pending selection restore.");
-
-                    return;
-                }
-
-                dispatcher.Dispatch(new OpenLogAction(name, type));
-                reopenedSoFar.Add((id, name));
-            }
-        }
-        finally
-        {
-            _closeCoordinator.ReleaseCoordinatorLock();
-        }
-    }
-
-    private Task RepublishForSortAsync(IDispatcher dispatcher) =>
-        ApplyFilterAndPublishAsync(
-            _eventLogState.Value.AppliedFilter,
-            _concurrencyState.InvalidateInFlightFilters(),
-            dispatcher);
-
-    private ImmutableArray<EventLogId> ResidualOpenStale(IEnumerable<EventLogId> candidateStaleIds)
-    {
-        var openIds = new HashSet<EventLogId>();
-
-        foreach (var info in _eventLogState.Value.OpenLogs.Values) { openIds.Add(info.Id); }
-
-        var raw = _rawEventStore.Value.ByLog;
-
-        return [.. candidateStaleIds.Distinct().Where(id => openIds.Contains(id) && raw.ContainsKey(id))];
-    }
-
-    private List<(EventLogId Id, EventColumnStore Store, long ContentVersion)> SnapshotEventsForLogs(
-        IReadOnlyList<EventLogId> logIds)
-    {
-        var raw = _rawEventStore.Value.ByLog;
-        var snapshot = new List<(EventLogId Id, EventColumnStore Store, long ContentVersion)>();
-
-        foreach (var logId in logIds)
-        {
-            if (raw.TryGetValue(logId, out var store))
-            {
-                snapshot.Add((logId, store, store.ContentVersion));
-            }
-        }
-
-        return snapshot;
-    }
-
-    private List<(EventLogId Id, EventColumnStore Store, long ContentVersion)> SnapshotOpenLogEvents()
-    {
-        var raw = _rawEventStore.Value.ByLog;
-        var snapshot = new List<(EventLogId Id, EventColumnStore Store, long ContentVersion)>();
-
-        foreach (var info in _eventLogState.Value.OpenLogs.Values)
-        {
-            if (raw.TryGetValue(info.Id, out var store))
-            {
-                snapshot.Add((info.Id, store, store.ContentVersion));
-            }
-        }
-
-        return snapshot;
+        return Task.CompletedTask;
     }
 }
diff --git a/src/EventLogExpert.Runtime/EventLog/IEventFocusSource.cs b/src/EventLogExpert.Runtime/EventLog/IEventFocusSource.cs
new file mode 100644
index 000000000..fcc36cdcf
--- /dev/null
+++ b/src/EventLogExpert.Runtime/EventLog/IEventFocusSource.cs
@@ -0,0 +1,11 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Runtime.Common.Sources;
+
+namespace EventLogExpert.Runtime.EventLog;
+
+public interface IEventFocusSource : IChangeNotifier
+{
+    SelectionEntry? Current { get; }
+}
diff --git a/src/EventLogExpert.Runtime/EventLog/IEventLogCommands.cs b/src/EventLogExpert.Runtime/EventLog/IEventLogCommands.cs
index b258264d7..05f7a1bfc 100644
--- a/src/EventLogExpert.Runtime/EventLog/IEventLogCommands.cs
+++ b/src/EventLogExpert.Runtime/EventLog/IEventLogCommands.cs
@@ -3,6 +3,7 @@
 
 using EventLogExpert.Eventing.Common.Channels;
 using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
 
 namespace EventLogExpert.Runtime.EventLog;
 
@@ -12,6 +13,8 @@ public interface IEventLogCommands
 
     void CloseLog(EventLogId logId, string logName);
 
+    void ConsumeRevealFocus(EventLocator target);
+
     void LoadNewEvents();
 
     void OpenLog(string logName, LogPathType logPathType, CancellationToken token = default);
diff --git a/src/EventLogExpert.Runtime/EventLog/IEventLogQueries.cs b/src/EventLogExpert.Runtime/EventLog/IEventLogQueries.cs
index cb48ad87e..c3dedea32 100644
--- a/src/EventLogExpert.Runtime/EventLog/IEventLogQueries.cs
+++ b/src/EventLogExpert.Runtime/EventLog/IEventLogQueries.cs
@@ -8,46 +8,19 @@ namespace EventLogExpert.Runtime.EventLog;
 
 public interface IEventLogQueries
 {
-    /// <summary>
-    ///     Returns the distinct names of the currently open Channel logs (excludes File logs). Used by scenario authoring
-    ///     export to record which channels the filter rows were captured against.
-    /// </summary>
     IReadOnlyList<string> GetChannelNames();
 
-    /// <summary>
-    ///     Returns the distinct, sorted &lt;EventData&gt; field names present across all open raw events (used to
-    ///     populate the Basic editor's EventData field-name picker).
-    /// </summary>
     ImmutableArray<string> GetEventDataFieldNames();
 
-    /// <summary>
-    ///     Returns the distinct, sorted values of the named EventData <paramref name="fieldName" /> across all open raw
-    ///     events (used to populate the value picker for an EventData filter row).
-    /// </summary>
     ImmutableArray<string> GetEventDataFieldValues(string fieldName);
 
-    /// <summary>
-    ///     Returns the UTC date range covering all events across the active logs, with bounds rounded outward to the
-    ///     hour, falling back to <paramref name="fallbackUtcNow" /> when no log has events.
-    /// </summary>
     (DateTime After, DateTime Before) GetEventDateRange(DateTime fallbackUtcNow);
 
-    /// <summary>
-    ///     Returns the distinct, sorted set of values present across all open raw events for the given
-    ///     <paramref name="property" /> (used to populate filter value pickers). Empty for properties that are not derived
-    ///     from event data.
-    /// </summary>
     ImmutableArray<string> GetPropertyValues(EventProperty property);
 
-    /// <summary>
-    ///     Distinct, sorted structured &lt;UserData&gt; field paths (storage keys) across all open raw events, for the
-    ///     Basic editor's UserData field-name picker.
-    /// </summary>
     ImmutableArray<string> GetUserDataFieldNames();
 
-    /// <summary>
-    ///     Distinct, sorted values of the structured UserData field <paramref name="fieldName" /> (a storage key) across
-    ///     all open raw events, for the value picker of a UserData filter row.
-    /// </summary>
     ImmutableArray<string> GetUserDataFieldValues(string fieldName);
+
+    bool IsContinuouslyUpdating();
 }
diff --git a/src/EventLogExpert.Runtime/EventLog/IEventSelectionSource.cs b/src/EventLogExpert.Runtime/EventLog/IEventSelectionSource.cs
new file mode 100644
index 000000000..996bda748
--- /dev/null
+++ b/src/EventLogExpert.Runtime/EventLog/IEventSelectionSource.cs
@@ -0,0 +1,12 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Runtime.Common.Sources;
+using System.Collections.Immutable;
+
+namespace EventLogExpert.Runtime.EventLog;
+
+public interface IEventSelectionSource : IChangeNotifier
+{
+    ImmutableList<SelectionEntry> Current { get; }
+}
diff --git a/src/EventLogExpert.Runtime/EventLog/IFilterAppliedSource.cs b/src/EventLogExpert.Runtime/EventLog/IFilterAppliedSource.cs
new file mode 100644
index 000000000..a74c20dce
--- /dev/null
+++ b/src/EventLogExpert.Runtime/EventLog/IFilterAppliedSource.cs
@@ -0,0 +1,11 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Runtime.Common.Sources;
+
+namespace EventLogExpert.Runtime.EventLog;
+
+public interface IFilterAppliedSource : IChangeNotifier
+{
+    bool IsFilteringEnabled { get; }
+}
diff --git a/src/EventLogExpert.Runtime/EventLog/ConvergeFilterAction.cs b/src/EventLogExpert.Runtime/EventLog/ILoadedLogNamesSource.cs
similarity index 51%
rename from src/EventLogExpert.Runtime/EventLog/ConvergeFilterAction.cs
rename to src/EventLogExpert.Runtime/EventLog/ILoadedLogNamesSource.cs
index 7d8a32024..c118d5eef 100644
--- a/src/EventLogExpert.Runtime/EventLog/ConvergeFilterAction.cs
+++ b/src/EventLogExpert.Runtime/EventLog/ILoadedLogNamesSource.cs
@@ -1,9 +1,12 @@
 // // Copyright (c) Microsoft Corporation.
 // // Licensed under the MIT License.
 
-using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Runtime.Common.Sources;
 using System.Collections.Immutable;
 
 namespace EventLogExpert.Runtime.EventLog;
 
-internal sealed record ConvergeFilterAction(ImmutableArray<EventLogId> StaleIds, long OriginToken);
+public interface ILoadedLogNamesSource : IChangeNotifier
+{
+    ImmutableHashSet<string> Current { get; }
+}
diff --git a/src/EventLogExpert.Runtime/EventLog/IOpenLogsPresenceSource.cs b/src/EventLogExpert.Runtime/EventLog/IOpenLogsPresenceSource.cs
new file mode 100644
index 000000000..6633d0e14
--- /dev/null
+++ b/src/EventLogExpert.Runtime/EventLog/IOpenLogsPresenceSource.cs
@@ -0,0 +1,11 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Runtime.Common.Sources;
+
+namespace EventLogExpert.Runtime.EventLog;
+
+public interface IOpenLogsPresenceSource : IChangeNotifier
+{
+    bool HasOpenLogs { get; }
+}
diff --git a/src/EventLogExpert.Runtime/EventLog/IRevealFocusSource.cs b/src/EventLogExpert.Runtime/EventLog/IRevealFocusSource.cs
new file mode 100644
index 000000000..69c716768
--- /dev/null
+++ b/src/EventLogExpert.Runtime/EventLog/IRevealFocusSource.cs
@@ -0,0 +1,12 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.Events;
+using EventLogExpert.Runtime.Common.Sources;
+
+namespace EventLogExpert.Runtime.EventLog;
+
+public interface IRevealFocusSource : IChangeNotifier
+{
+    EventLocator? Current { get; }
+}
diff --git a/src/EventLogExpert.Runtime/EventLog/LiveTailIngestCoordinator.cs b/src/EventLogExpert.Runtime/EventLog/LiveTailIngestCoordinator.cs
new file mode 100644
index 000000000..97d5a0551
--- /dev/null
+++ b/src/EventLogExpert.Runtime/EventLog/LiveTailIngestCoordinator.cs
@@ -0,0 +1,115 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
+using EventLogExpert.Runtime.LogTable;
+using System.Diagnostics;
+using IDispatcher = Fluxor.IDispatcher;
+
+namespace EventLogExpert.Runtime.EventLog;
+
+internal sealed class LiveTailIngestCoordinator : IDisposable
+{
+    private const int MaxPendingPerLog = 1000;
+
+    private static readonly TimeSpan s_maxBatchAge = TimeSpan.FromMilliseconds(16);
+
+    private readonly IDispatcher _dispatcher;
+    private readonly Lock _emissionGate = new();
+    private readonly Lock _gate = new();
+    private readonly TimeSpan _maxBatchAge;
+    private readonly Dictionary<EventLogId, List<ResolvedEvent>> _pending = [];
+    private readonly Timer _timer;
+
+    private bool _disposed;
+
+    private long _lastFlushTimestamp;
+
+    public LiveTailIngestCoordinator(IDispatcher dispatcher, TimeSpan? maxBatchAge = null)
+    {
+        ArgumentNullException.ThrowIfNull(dispatcher);
+
+        _dispatcher = dispatcher;
+        _maxBatchAge = maxBatchAge ?? s_maxBatchAge;
+
+        TimeSpan period = _maxBatchAge == Timeout.InfiniteTimeSpan ? Timeout.InfiniteTimeSpan : _maxBatchAge;
+
+        _timer = new Timer(_ => Flush(), null, period, period);
+    }
+
+    public void Discard(EventLogId logId)
+    {
+        lock (_gate) { _pending.Remove(logId); }
+    }
+
+    public void DiscardAll()
+    {
+        lock (_gate) { _pending.Clear(); }
+    }
+
+    public void Dispose()
+    {
+        lock (_gate)
+        {
+            if (_disposed) { return; }
+
+            _disposed = true;
+
+            _pending.Clear();
+        }
+
+        _timer.Dispose();
+    }
+
+    public void Enqueue(EventLogId logId, ResolvedEvent newEvent)
+    {
+        ArgumentNullException.ThrowIfNull(newEvent);
+
+        bool flushNow;
+
+        lock (_gate)
+        {
+            if (_disposed) { return; }
+
+            if (!_pending.TryGetValue(logId, out List<ResolvedEvent>? batch))
+            {
+                batch = [];
+                _pending[logId] = batch;
+            }
+
+            batch.Add(newEvent);
+
+            bool idle = _lastFlushTimestamp == 0
+                || Stopwatch.GetElapsedTime(_lastFlushTimestamp) >= _maxBatchAge;
+
+            flushNow = batch.Count >= MaxPendingPerLog || (idle && _pending.Count == 1 && batch.Count == 1);
+        }
+
+        if (flushNow) { Flush(); }
+    }
+
+    public void Flush()
+    {
+        Dictionary<EventLogId, IReadOnlyList<ResolvedEvent>> batches;
+
+        lock (_gate)
+        {
+            if (_disposed || _pending.Count == 0) { return; }
+
+            batches = new Dictionary<EventLogId, IReadOnlyList<ResolvedEvent>>(_pending.Count);
+
+            foreach ((EventLogId logId, List<ResolvedEvent> batch) in _pending) { batches[logId] = batch.AsReadOnly(); }
+
+            _pending.Clear();
+            _lastFlushTimestamp = Stopwatch.GetTimestamp();
+        }
+
+        lock (_emissionGate)
+        {
+            if (Volatile.Read(ref _disposed)) { return; }
+
+            _dispatcher.Dispatch(new IngestRawEventsAction(batches, RawIngestMode.Prepend));
+        }
+    }
+}
diff --git a/src/EventLogExpert.Runtime/EventLog/LoadedLogNamesSource.cs b/src/EventLogExpert.Runtime/EventLog/LoadedLogNamesSource.cs
new file mode 100644
index 000000000..3a049db0b
--- /dev/null
+++ b/src/EventLogExpert.Runtime/EventLog/LoadedLogNamesSource.cs
@@ -0,0 +1,23 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Logging.Abstractions;
+using EventLogExpert.Runtime.Common.Sources;
+using Fluxor;
+using Microsoft.Extensions.DependencyInjection;
+using System.Collections.Immutable;
+
+namespace EventLogExpert.Runtime.EventLog;
+
+internal sealed class LoadedLogNamesSource(
+    IState<EventLogState> state,
+    [FromKeyedServices(LogCategories.EventLog)] ITraceLogger logger)
+    : ObservableStateSourceBase<EventLogState, ImmutableHashSet<string>>(
+            state,
+            logger,
+            static state => state.LoadedLogNames,
+            static (next, current) => ReferenceEquals(next, current)),
+        ILoadedLogNamesSource
+{
+    public ImmutableHashSet<string> Current => CurrentProjection;
+}
diff --git a/src/EventLogExpert.Runtime/EventLog/LogReloadEffects.cs b/src/EventLogExpert.Runtime/EventLog/LogReloadEffects.cs
index 9b16a4a1a..ecb3467ef 100644
--- a/src/EventLogExpert.Runtime/EventLog/LogReloadEffects.cs
+++ b/src/EventLogExpert.Runtime/EventLog/LogReloadEffects.cs
@@ -3,7 +3,6 @@
 
 using EventLogExpert.Eventing.Common.EventLogs;
 using EventLogExpert.Eventing.Common.Events;
-using EventLogExpert.Filtering.Compilation;
 using EventLogExpert.Runtime.LogTable;
 using Fluxor;
 using IDispatcher = Fluxor.IDispatcher;
@@ -12,37 +11,21 @@ namespace EventLogExpert.Runtime.EventLog;
 
 internal sealed class LogReloadEffects(
     IState<EventLogState> eventLogState,
-    IState<LogTableState> logTableState,
     IState<RawEventStoreState> rawEventStore,
-    IFilterService filterService,
-    LogCloseCoordinator closeCoordinator,
-    PartialLoadCoordinator coordinator)
+    LogCloseCoordinator closeCoordinator)
 {
     private readonly LogCloseCoordinator _closeCoordinator = closeCoordinator;
-    private readonly PartialLoadCoordinator _coordinator = coordinator;
     private readonly IState<EventLogState> _eventLogState = eventLogState;
-    private readonly IFilterService _filterService = filterService;
-    private readonly IState<LogTableState> _logTableState = logTableState;
     private readonly IState<RawEventStoreState> _rawEventStore = rawEventStore;
 
     [EffectMethod]
     public Task HandleLoadEvents(LoadEventsAction action, IDispatcher dispatcher)
     {
-        var version = _logTableState.Value.DisplayListVersion;
-
-        _coordinator.MarkFinalized(action.LogData.Id);
-
-        // The raw-store reducer runs synchronously before this effect, so the store already holds the finalized build.
         if (!_rawEventStore.Value.ByLog.TryGetValue(action.LogData.Id, out var store))
         {
             return Task.CompletedTask;
         }
 
-        var view = DisplayViewBuilder.Build(
-            store, action.LogData.Id, _eventLogState.Value.AppliedFilter, _logTableState.Value.SortContext);
-
-        dispatcher.Dispatch(new UpdateTableAction(action.LogData.Id) { View = view, Version = version });
-
         if (!_closeCoordinator.TryConsumePendingRestore(action.LogData.Name, out var pending) ||
             pending is null ||
             (pending.SelectedIds.Count <= 0 && !pending.SelectedId.HasValue))
@@ -55,18 +38,6 @@ pending is null ||
         return Task.CompletedTask;
     }
 
-    [EffectMethod]
-    public Task HandleLoadEventsPartial(LoadEventsPartialAction action, IDispatcher dispatcher)
-    {
-        // The raw-store reducer already appended this partial's events, so the coordinator only marks the log dirty and
-        // rebuilds the view at flush time.
-        var version = _logTableState.Value.DisplayListVersion;
-
-        _coordinator.Enqueue(action.LogData.Id, version);
-
-        return Task.CompletedTask;
-    }
-
     [EffectMethod(typeof(LoadNewEventsAction))]
     public Task HandleLoadNewEvents(IDispatcher dispatcher)
     {
@@ -75,43 +46,6 @@ public Task HandleLoadNewEvents(IDispatcher dispatcher)
         return Task.CompletedTask;
     }
 
-    [EffectMethod]
-    public Task HandleRebuildDisplayViews(RebuildDisplayViewsAction action, IDispatcher dispatcher)
-    {
-        // Continuation of the IngestRawEventsAction dispatched just before it, so these reads see the post-ingest store. Do
-        // not inline back into the producer effect: a same-effect read would see the stale pre-ingest store (the fixed bug).
-        var raw = _rawEventStore.Value.ByLog;
-        var filter = _eventLogState.Value.AppliedFilter;
-        var context = _logTableState.Value.SortContext;
-        var viewsByLog = new Dictionary<EventLogId, EventColumnView>(action.NewEventsByLog.Count);
-
-        foreach (var (logId, newEvents) in action.NewEventsByLog)
-        {
-            // Existence check before filter work: skip a log a concurrent close dropped without filtering it, and rebuild
-            // only when a new event survives the filter so a fully hidden batch doesn't churn the view.
-            if (raw.TryGetValue(logId, out var store) &&
-                _filterService.GetFilteredEvents(newEvents, filter).Count > 0)
-            {
-                viewsByLog[logId] = DisplayViewBuilder.Build(store, logId, filter, context);
-            }
-        }
-
-        if (viewsByLog.Count > 0)
-        {
-            dispatcher.Dispatch(new AppendTableEventsBatchAction { ViewsByLog = viewsByLog });
-        }
-
-        // Consume only after a successful rebuild (unreachable if it threw above), so a build failure preserves the count.
-        // Consuming the captured snapshot - not a blanket clear - keeps a mid-flush event; skip the dispatch when nothing
-        // was captured (an all-filtered rebuild still consumes its non-empty snapshot).
-        if (action.BufferEntriesToConsume is { Count: > 0 } bufferEntriesToConsume)
-        {
-            dispatcher.Dispatch(new NewEventBufferConsumedAction(bufferEntriesToConsume));
-        }
-
-        return Task.CompletedTask;
-    }
-
     internal static void ProcessNewEventBuffer(EventLogState state, IDispatcher dispatcher)
     {
         var grouped = new Dictionary<EventLogId, List<ResolvedEvent>>();
@@ -138,9 +72,10 @@ internal static void ProcessNewEventBuffer(EventLogState state, IDispatcher disp
             dispatcher.Dispatch(new IngestRawEventsAction(rawByLog, RawIngestMode.Prepend));
         }
 
-        // Continuation runs after the ingest, so it reads the post-ingest store and consumes exactly this snapshot by
-        // identity. Atomic reducer buffering (ReduceAddEvent) keeps an event buffered concurrently with the flush alive.
-        dispatcher.Dispatch(new RebuildDisplayViewsAction(rawByLog, BufferEntriesToConsume: state.NewEventBuffer));
+        if (state.NewEventBuffer.Count > 0)
+        {
+            dispatcher.Dispatch(new NewEventBufferConsumedAction(state.NewEventBuffer));
+        }
     }
 
     private static void RestoreSelection(
@@ -176,5 +111,7 @@ private static void RestoreSelection(
 
         SelectionEntry? focused = focusEntry ?? (restored.Count > 0 ? restored[^1] : null);
         dispatcher.Dispatch(new SetSelectedEventsAction(restored, focused));
+
+        dispatcher.Dispatch(new RequestRevealFocusAction(focused!.Value.OriginHandle));
     }
 }
diff --git a/src/EventLogExpert.Runtime/EventLog/OpenLogAction.cs b/src/EventLogExpert.Runtime/EventLog/OpenLogAction.cs
index de0fd9348..e5f2f6d68 100644
--- a/src/EventLogExpert.Runtime/EventLog/OpenLogAction.cs
+++ b/src/EventLogExpert.Runtime/EventLog/OpenLogAction.cs
@@ -2,7 +2,8 @@
 // // Licensed under the MIT License.
 
 using EventLogExpert.Eventing.Common.Channels;
+using EventLogExpert.Eventing.Common.EventLogs;
 
 namespace EventLogExpert.Runtime.EventLog;
 
-internal sealed record OpenLogAction(string LogName, LogPathType LogPathType, CancellationToken Token = default);
+internal sealed record OpenLogAction(string LogName, LogPathType LogPathType, CancellationToken Token = default, EventLogId? PreassignedId = null);
diff --git a/src/EventLogExpert.Runtime/EventLog/OpenLogEffects.cs b/src/EventLogExpert.Runtime/EventLog/OpenLogEffects.cs
index 162996eff..494ae22b7 100644
--- a/src/EventLogExpert.Runtime/EventLog/OpenLogEffects.cs
+++ b/src/EventLogExpert.Runtime/EventLog/OpenLogEffects.cs
@@ -35,30 +35,29 @@ internal sealed class OpenLogEffects(
     ICriticalErrorService criticalErrorService,
     LogCloseCoordinator closeCoordinator,
     EventLogConcurrencyState concurrencyState,
-    PartialLoadCoordinator coordinator,
+    LiveTailIngestCoordinator liveTailCoordinator,
     IEventLogReaderFactory readerFactory)
 {
-    // Eager first paint fires at a screenful so the newest rows render in ~1s instead of waiting for the 3s partial timer.
     private const int EagerFirstPaintThreshold = 200;
 
-    // EvtNext batch: benchmarked Win11 throughput sweet spot; 512 regresses.
     private const int ReadBatchSize = 256;
 
     private static readonly int s_maxGlobalConcurrency = ConcurrencyLimits.MaxBackgroundIoParallelism;
+    private static readonly TimeSpan s_partialDispatchInterval = TimeSpan.FromSeconds(3);
     private static readonly PrioritySemaphore s_resolutionGate = new(s_maxGlobalConcurrency);
 
     private readonly LogCloseCoordinator _closeCoordinator = closeCoordinator;
     private readonly EventLogConcurrencyState _concurrencyState = concurrencyState;
-    private readonly PartialLoadCoordinator _coordinator = coordinator;
     private readonly ICriticalErrorService _criticalErrorService = criticalErrorService;
     private readonly IDatabaseService _databaseService = databaseService;
     private readonly IState<EventLogState> _eventLogState = eventLogState;
     private readonly Lock _globalCtsLock = new();
     private readonly ITraceLogger _lifecycleLogger = logger.ForCategory(LogCategories.EventLogLifecycle);
+    private readonly LiveTailIngestCoordinator _liveTailCoordinator = liveTailCoordinator;
     private readonly ConcurrentDictionary<EventLogId, CancellationTokenSource> _logCts = new();
-    private readonly ITraceLogger _logger = logger;
     private readonly ConcurrentDictionary<EventLogId, TaskCompletionSource> _logLoadCompletions = new();
     private readonly ILogWatcherService _logWatcherService = logWatcherService;
+    private readonly ITraceLogger _logger = logger;
     private readonly IEventLogReaderFactory _readerFactory = readerFactory;
     private readonly IEventResolverCache _resolverCache = resolverCache;
     private readonly IServiceScopeFactory _serviceScopeFactory = serviceScopeFactory;
@@ -72,9 +71,8 @@ public async Task HandleCloseAll(IDispatcher dispatcher)
     {
         _lifecycleLogger.Debug($"Close-all requested ({_eventLogState.Value.OpenLogs.Count} active logs).");
 
-        _coordinator.DiscardAll();
+        _liveTailCoordinator.DiscardAll();
 
-        _concurrencyState.InvalidateInFlightFilters();
         _concurrencyState.InvalidateInFlightReloads();
 
         CancelAllLoads();
@@ -92,7 +90,7 @@ public async Task HandleCloseLog(CloseLogAction action, IDispatcher dispatcher)
     {
         _lifecycleLogger.Debug($"Close requested for '{action.LogName}' (id: {action.LogId}).");
 
-        _coordinator.Discard(action.LogId);
+        _liveTailCoordinator.Discard(action.LogId);
 
         try
         {
@@ -114,12 +112,14 @@ public async Task HandleCloseLog(CloseLogAction action, IDispatcher dispatcher)
                 }
             }
 
-            await _logWatcherService.RemoveLogAsync(action.LogName);
+            if (!(_eventLogState.Value.OpenLogs.TryGetValue(action.LogName, out var activeLog) && activeLog.Id != action.LogId))
+            {
+                await _logWatcherService.RemoveLogAsync(action.LogName);
+                _closeCoordinator.ClearPendingRestore(action.LogName);
+                _xmlResolver.ClearXmlCacheForLog(action.LogName);
+            }
 
             _concurrencyState.ClearLoadedWithXml(action.LogId);
-            _closeCoordinator.ClearPendingRestore(action.LogName);
-
-            _xmlResolver.ClearXmlCacheForLog(action.LogName);
 
             dispatcher.Dispatch(new LogTable.CloseLogAction(action.LogId));
 
@@ -154,6 +154,13 @@ public async Task HandleOpenLog(OpenLogAction action, IDispatcher dispatcher)
 
         var logData = new EventLogData(action.LogName, openInfo.Type) { Id = openInfo.Id };
 
+        if (action.PreassignedId is { } preassignedId && openInfo.Id != preassignedId)
+        {
+            _logger.Trace($"Open '{action.LogName}': correlated reopen superseded by a same-name open (expected {preassignedId}, found {openInfo.Id}); skipping load.");
+
+            return;
+        }
+
         CancellationTokenSource perLoadCts;
 
         using (_globalCtsLock.EnterScope())
@@ -330,7 +337,7 @@ private async Task LoadLogAsync(
             },
             null,
             TimeSpan.Zero,
-            TimeSpan.FromSeconds(3));
+            s_partialDispatchInterval);
 
         bool renderXml = _eventLogState.Value.AppliedFilter.RequiresXml;
 
@@ -381,8 +388,6 @@ await Parallel.ForEachAsync(
                 {
                     EventRecord[] batch = item.Batch;
 
-                    // Classify by ADMITTED (not completed) events so a slow-resolving load still demotes to Bulk after
-                    // its first screenful instead of monopolizing the high-priority lane.
                     var priority = Volatile.Read(ref highAdmitted) < EagerFirstPaintThreshold ?
                         ResolutionPriority.FirstScreenful :
                         ResolutionPriority.Bulk;
@@ -435,8 +440,6 @@ await Parallel.ForEachAsync(
                                 nextDrainSeq++;
                             }
 
-                            // Dispatch the first screenful immediately instead of waiting for the 3s timer (the read is
-                            // reversed, so these are the newest events).
                             if (events.Count >= EagerFirstPaintThreshold && Interlocked.Exchange(ref eagerFired, 1) == 0)
                             {
                                 dispatchEager = true;
@@ -500,12 +503,8 @@ await Parallel.ForEachAsync(
             return;
         }
 
-        // Stop the timer before dispatching so no stale LoadEventsPartialAction fires after the final LoadEventsAction.
         await timer.DisposeAsync();
 
-        // Dispatch the finalized list in physical read order (the order partials were appended) so the finalization
-        // Build keeps every physical Index stable; re-sorting would strand partial-era EventLocators (the selection and
-        // highlight-cache keys) on a different physical row.
         token.ThrowIfCancellationRequested();
 
         if (!_eventLogState.Value.OpenLogs.TryGetValue(logData.Name, out var activeLog)
diff --git a/src/EventLogExpert.Runtime/EventLog/OpenLogsPresenceSource.cs b/src/EventLogExpert.Runtime/EventLog/OpenLogsPresenceSource.cs
new file mode 100644
index 000000000..d93be8e04
--- /dev/null
+++ b/src/EventLogExpert.Runtime/EventLog/OpenLogsPresenceSource.cs
@@ -0,0 +1,18 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Logging.Abstractions;
+using EventLogExpert.Runtime.Common.Sources;
+using Fluxor;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace EventLogExpert.Runtime.EventLog;
+
+internal sealed class OpenLogsPresenceSource(
+    IState<EventLogState> state,
+    [FromKeyedServices(LogCategories.EventLog)] ITraceLogger logger)
+    : ObservableStateSourceBase<EventLogState, bool>(state, logger, static state => state.OpenLogCount > 0),
+        IOpenLogsPresenceSource
+{
+    public bool HasOpenLogs => CurrentProjection;
+}
diff --git a/src/EventLogExpert.Runtime/EventLog/PartialLoadCoordinator.cs b/src/EventLogExpert.Runtime/EventLog/PartialLoadCoordinator.cs
deleted file mode 100644
index 880fac0c7..000000000
--- a/src/EventLogExpert.Runtime/EventLog/PartialLoadCoordinator.cs
+++ /dev/null
@@ -1,146 +0,0 @@
-// // Copyright (c) Microsoft Corporation.
-// // Licensed under the MIT License.
-
-using EventLogExpert.Eventing.Common.EventLogs;
-using EventLogExpert.Runtime.LogTable;
-using Fluxor;
-using IDispatcher = Fluxor.IDispatcher;
-
-namespace EventLogExpert.Runtime.EventLog;
-
-internal sealed class PartialLoadCoordinator : IDisposable
-{
-    private static readonly TimeSpan s_flushWindow = TimeSpan.FromMilliseconds(1000);
-
-    private readonly HashSet<EventLogId> _dirty = [];
-    private readonly IDispatcher _dispatcher;
-    private readonly IState<EventLogState> _eventLogState;
-    private readonly HashSet<EventLogId> _finalized = [];
-    private readonly Lock _gate = new();
-    private readonly IState<LogTableState> _logTableState;
-    private readonly IState<RawEventStoreState> _rawEventStore;
-    private readonly HashSet<EventLogId> _seen = [];
-    private readonly Timer _timer;
-    private readonly Dictionary<EventLogId, int> _versions = [];
-
-    private bool _disposed;
-
-    public PartialLoadCoordinator(
-        IDispatcher dispatcher,
-        IState<RawEventStoreState> rawEventStore,
-        IState<EventLogState> eventLogState,
-        IState<LogTableState> logTableState)
-        : this(dispatcher, rawEventStore, eventLogState, logTableState, s_flushWindow) { }
-
-    internal PartialLoadCoordinator(
-        IDispatcher dispatcher,
-        IState<RawEventStoreState> rawEventStore,
-        IState<EventLogState> eventLogState,
-        IState<LogTableState> logTableState,
-        TimeSpan flushInterval)
-    {
-        _dispatcher = dispatcher;
-        _rawEventStore = rawEventStore;
-        _eventLogState = eventLogState;
-        _logTableState = logTableState;
-        _timer = new Timer(_ => Flush(), null, flushInterval, flushInterval);
-    }
-
-    public void Discard(EventLogId logId)
-    {
-        lock (_gate)
-        {
-            _dirty.Remove(logId);
-            _versions.Remove(logId);
-            _finalized.Remove(logId);
-            _seen.Remove(logId);
-        }
-    }
-
-    public void DiscardAll()
-    {
-        lock (_gate)
-        {
-            _dirty.Clear();
-            _versions.Clear();
-            _finalized.Clear();
-            _seen.Clear();
-        }
-    }
-
-    public void Dispose()
-    {
-        lock (_gate)
-        {
-            _disposed = true;
-            _dirty.Clear();
-            _versions.Clear();
-            _finalized.Clear();
-            _seen.Clear();
-        }
-
-        _timer.Dispose();
-    }
-
-    public void Enqueue(EventLogId logId, int version)
-    {
-        lock (_gate)
-        {
-            // A straggler partial delta can arrive after the final LoadEvents (effects are fire-and-forget); dropping finalized logs prevents rebuilding a view the finalize already published.
-            if (_disposed || _finalized.Contains(logId)) { return; }
-
-            _dirty.Add(logId);
-
-            // Use Math.Min so a buffer straddling a filter change adopts the older version, forcing a safe re-sort at finalize.
-            _versions[logId] = _versions.TryGetValue(logId, out var existingVersion)
-                ? Math.Min(existingVersion, version)
-                : version;
-
-            if (_seen.Add(logId)) { FlushLocked(); }
-        }
-    }
-
-    public void MarkFinalized(EventLogId logId)
-    {
-        lock (_gate)
-        {
-            _finalized.Add(logId);
-            _dirty.Remove(logId);
-            _versions.Remove(logId);
-        }
-    }
-
-    internal void Flush()
-    {
-        lock (_gate) { FlushLocked(); }
-    }
-
-    private void FlushLocked()
-    {
-        if (_disposed || _dirty.Count == 0) { return; }
-
-        var raw = _rawEventStore.Value.ByLog;
-        var filter = _eventLogState.Value.AppliedFilter;
-        var context = _logTableState.Value.SortContext;
-
-        var viewsByLog = new Dictionary<EventLogId, EventColumnView>(_dirty.Count);
-        var versionByLog = new Dictionary<EventLogId, int>(_dirty.Count);
-
-        foreach (var logId in _dirty)
-        {
-            if (!raw.TryGetValue(logId, out var store)) { continue; }
-
-            viewsByLog[logId] = DisplayViewBuilder.Build(store, logId, filter, context);
-
-            if (_versions.TryGetValue(logId, out var version)) { versionByLog[logId] = version; }
-        }
-
-        _dirty.Clear();
-        _versions.Clear();
-
-        if (viewsByLog.Count == 0) { return; }
-
-        // Dispatch under the lock so batches and the final UpdateTable keep FIFO order in Fluxor's queue.
-        _dispatcher.Dispatch(new AppendTableEventsBatchAction { ViewsByLog = viewsByLog, VersionByLog = versionByLog });
-    }
-}
diff --git a/src/EventLogExpert.Runtime/EventLog/RebuildDisplayViewsAction.cs b/src/EventLogExpert.Runtime/EventLog/RebuildDisplayViewsAction.cs
deleted file mode 100644
index 9b929e3ff..000000000
--- a/src/EventLogExpert.Runtime/EventLog/RebuildDisplayViewsAction.cs
+++ /dev/null
@@ -1,14 +0,0 @@
-// // Copyright (c) Microsoft Corporation.
-// // Licensed under the MIT License.
-
-using EventLogExpert.Eventing.Common.EventLogs;
-using EventLogExpert.Eventing.Common.Events;
-
-namespace EventLogExpert.Runtime.EventLog;
-
-// Effect-only continuation dispatched after IngestRawEventsAction so the rebuild reads the post-ingest store.
-// BufferEntriesToConsume is the flush's captured buffer snapshot to remove on a successful rebuild; null on the
-// live-tail path (no buffer to consume).
-internal sealed record RebuildDisplayViewsAction(
-    IReadOnlyDictionary<EventLogId, IReadOnlyList<ResolvedEvent>> NewEventsByLog,
-    IReadOnlyList<ResolvedEvent>? BufferEntriesToConsume);
diff --git a/src/EventLogExpert.Runtime/EventLog/Reducers.cs b/src/EventLogExpert.Runtime/EventLog/Reducers.cs
index 58d1d59c5..16af064bf 100644
--- a/src/EventLogExpert.Runtime/EventLog/Reducers.cs
+++ b/src/EventLogExpert.Runtime/EventLog/Reducers.cs
@@ -21,9 +21,6 @@ internal sealed class Reducers
     [ReducerMethod]
     public static EventLogState ReduceAddEvent(EventLogState state, AddEventAction action)
     {
-        // Buffer additively in the reducer so concurrent adds and the flush's consume compose against current state (a
-        // stale whole-buffer effect write could clobber them). Continuously-update buffers nothing; HandleAddEvent drives
-        // the live tail.
         if (state.ContinuouslyUpdate || !state.OpenLogs.ContainsKey(action.NewEvent.OwningLog))
         {
             return state;
@@ -59,6 +56,7 @@ state with
             LoadedLogNames = RecomputeLoadedLogNames(s_emptyNamesByLog, state.LoadedLogNames),
             Focus = null,
             Selection = [],
+            PendingRevealFocus = null,
             NewEventBuffer = [],
             NewEventBufferIsFull = false
         };
@@ -66,21 +64,28 @@ state with
     [ReducerMethod]
     public static EventLogState ReduceCloseLog(EventLogState state, CloseLogAction action)
     {
+        if (state.OpenLogs.TryGetValue(action.LogName, out var closingLog) && closingLog.Id != action.LogId)
+        {
+            return state;
+        }
+
         var newEventBuffer = state.NewEventBuffer
             .Where(e => e.OwningLog != action.LogName)
             .ToList();
 
-        // Drop selections belonging to the closed log; otherwise a reload (close then reopen) leaves stale-generation
-        // handles that block the highlight refresh when the restored entries arrive.
         var newSelection = state.Selection
             .RemoveAll(entry => entry.OriginHandle.LogId == action.LogId);
 
-        // Clear focus when it belongs to the closed log; otherwise it would address a defunct generation after the reopen.
         var newFocus =
             state.Focus is { } focus && focus.OriginHandle.LogId == action.LogId
                 ? null
                 : state.Focus;
 
+        var newPendingRevealFocus =
+            state.PendingRevealFocus is { } reveal && reveal.LogId == action.LogId
+                ? null
+                : state.PendingRevealFocus;
+
         var newNamesByLog = state.NamesByLog.Remove(action.LogName);
 
         return state with
@@ -91,7 +96,8 @@ public static EventLogState ReduceCloseLog(EventLogState state, CloseLogAction a
             NewEventBuffer = newEventBuffer,
             NewEventBufferIsFull = newEventBuffer.Count >= EventLogState.MaxNewEvents,
             Focus = newFocus,
-            Selection = newSelection
+            Selection = newSelection,
+            PendingRevealFocus = newPendingRevealFocus
         };
     }
 
@@ -154,8 +160,6 @@ public static EventLogState ReduceNewEventBufferConsumed(EventLogState state, Ne
     {
         if (action.ConsumedEvents.Count == 0) { return state; }
 
-        // Remove only the captured entries by reference identity, so an event a watcher buffered during the flush
-        // (prepended after the snapshot) survives. Mirrors ReduceCloseLog's filtered removal + IsFull recompute.
         var consumed = new HashSet<object>(action.ConsumedEvents, ReferenceEqualityComparer.Instance);
         var remaining = state.NewEventBuffer.Where(bufferedEvent => !consumed.Contains(bufferedEvent)).ToList();
 
@@ -169,11 +173,9 @@ public static EventLogState ReduceNewEventBufferConsumed(EventLogState state, Ne
     [ReducerMethod]
     public static EventLogState ReduceOpenLog(EventLogState state, OpenLogAction action)
     {
-        // Idempotent: re-opening an already-active log is a no-op, so callers need not coordinate to avoid
-        // ImmutableDictionary.Add throwing.
         if (state.OpenLogs.ContainsKey(action.LogName)) { return state; }
 
-        var openLogId = EventLogId.Create();
+        var openLogId = action.PreassignedId ?? EventLogId.Create();
 
         var perLogNames = action.LogPathType == LogPathType.Channel
             ? s_emptyNames.Add(action.LogName)
@@ -189,14 +191,23 @@ public static EventLogState ReduceOpenLog(EventLogState state, OpenLogAction act
         };
     }
 
+    [ReducerMethod]
+    public static EventLogState ReduceRequestRevealFocus(EventLogState state, RequestRevealFocusAction action) =>
+        state.PendingRevealFocus == action.Target ? state : state with { PendingRevealFocus = action.Target };
+
+    [ReducerMethod]
+    public static EventLogState ReduceRevealFocusConsumed(EventLogState state, RevealFocusConsumedAction action)
+    {
+        if (state.PendingRevealFocus != action.Target) { return state; }
+
+        return state with { PendingRevealFocus = null };
+    }
+
     [ReducerMethod]
     public static EventLogState ReduceSelectEvent(EventLogState state, SelectEventAction action)
     {
-        // OriginHandle value equality is the selection identity: a stale (prior-generation) handle is distinct from the
-        // fresh one, matching reference-identity semantics without holding event object references.
         bool alreadySelected = ContainsByOriginHandle(state.Selection, action.Selection);
 
-        // Focus always tracks the affected row (Explorer-style focus), independent of whether the row ends up selected.
         if (!alreadySelected)
         {
             return state with
@@ -229,8 +240,6 @@ public static EventLogState ReduceSelectEvent(EventLogState state, SelectEventAc
     [ReducerMethod]
     public static EventLogState ReduceSelectEvents(EventLogState state, SelectEventsAction action)
     {
-        // OriginHandle-identity dedupe only: blocks the same handle twice but lets distinct-generation handles (a stale
-        // entry and a freshly restored one) coexist, so a stale selection isn't collapsed with the fresh copy.
         var existing = new HashSet<EventLocator>();
 
         foreach (var entry in state.Selection) { existing.Add(entry.OriginHandle); }
@@ -246,8 +255,6 @@ public static EventLogState ReduceSelectEvents(EventLogState state, SelectEvents
 
         var newSelection = state.Selection.AddRange(entriesToAdd);
 
-        // Preserve focus when it survives the merge (matched by OriginHandle); otherwise focus the last incoming entry
-        // so the restore path leaves something focused.
         SelectionEntry newFocus = entriesToAdd[^1];
 
         if (state.Focus is not { } priorFocus)
@@ -277,8 +284,6 @@ public static EventLogState ReduceSetContinuouslyUpdate(
     [ReducerMethod]
     public static EventLogState ReduceSetSelectedEvents(EventLogState state, SetSelectedEventsAction action)
     {
-        // Order-preserving distinct by OriginHandle; the caller orders entries by the current sort, and the reducer
-        // honors that order.
         var seen = new HashSet<EventLocator>();
         var builder = ImmutableList.CreateBuilder<SelectionEntry>();
 
@@ -292,8 +297,6 @@ public static EventLogState ReduceSetSelectedEvents(EventLogState state, SetSele
 
         var newSelection = builder.ToImmutable();
 
-        // Avoid a new state reference when nothing changed; SelectionEntry is a value type, so identity uses OriginHandle
-        // value equality, not ReferenceEquals.
         bool selectionUnchanged = SelectionsEqualByOriginHandle(state.Selection, newSelection);
         bool focusUnchanged = FocusEqualsByOriginHandle(state.Focus, action.Focus);
 
diff --git a/src/EventLogExpert.Runtime/EventLog/RequestRevealFocusAction.cs b/src/EventLogExpert.Runtime/EventLog/RequestRevealFocusAction.cs
new file mode 100644
index 000000000..7c830c538
--- /dev/null
+++ b/src/EventLogExpert.Runtime/EventLog/RequestRevealFocusAction.cs
@@ -0,0 +1,8 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.Events;
+
+namespace EventLogExpert.Runtime.EventLog;
+
+internal sealed record RequestRevealFocusAction(EventLocator Target);
diff --git a/src/EventLogExpert.Runtime/EventLog/RevealFocusConsumedAction.cs b/src/EventLogExpert.Runtime/EventLog/RevealFocusConsumedAction.cs
new file mode 100644
index 000000000..bc2eca839
--- /dev/null
+++ b/src/EventLogExpert.Runtime/EventLog/RevealFocusConsumedAction.cs
@@ -0,0 +1,8 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.Events;
+
+namespace EventLogExpert.Runtime.EventLog;
+
+internal sealed record RevealFocusConsumedAction(EventLocator Target);
diff --git a/src/EventLogExpert.Runtime/EventLog/RevealFocusSource.cs b/src/EventLogExpert.Runtime/EventLog/RevealFocusSource.cs
new file mode 100644
index 000000000..580b5cc46
--- /dev/null
+++ b/src/EventLogExpert.Runtime/EventLog/RevealFocusSource.cs
@@ -0,0 +1,19 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.Events;
+using EventLogExpert.Logging.Abstractions;
+using EventLogExpert.Runtime.Common.Sources;
+using Fluxor;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace EventLogExpert.Runtime.EventLog;
+
+internal sealed class RevealFocusSource(
+    IState<EventLogState> state,
+    [FromKeyedServices(LogCategories.EventLog)] ITraceLogger logger)
+    : ObservableStateSourceBase<EventLogState, EventLocator?>(state, logger, static state => state.PendingRevealFocus),
+        IRevealFocusSource
+{
+    public EventLocator? Current => CurrentProjection;
+}
diff --git a/src/EventLogExpert.Runtime/EventLog/XmlReloadCoordinator.cs b/src/EventLogExpert.Runtime/EventLog/XmlReloadCoordinator.cs
new file mode 100644
index 000000000..7977b7a6b
--- /dev/null
+++ b/src/EventLogExpert.Runtime/EventLog/XmlReloadCoordinator.cs
@@ -0,0 +1,175 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.Channels;
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Filtering.Evaluation;
+using EventLogExpert.Logging.Abstractions;
+using Fluxor;
+using Microsoft.Extensions.DependencyInjection;
+using IDispatcher = Fluxor.IDispatcher;
+
+namespace EventLogExpert.Runtime.EventLog;
+
+internal sealed class XmlReloadCoordinator(
+    IState<EventLogState> eventLogState,
+    LogCloseCoordinator closeCoordinator,
+    EventLogConcurrencyState concurrencyState,
+    [FromKeyedServices(LogCategories.EventLog)] ITraceLogger logger)
+{
+    private readonly LogCloseCoordinator _closeCoordinator = closeCoordinator;
+    private readonly EventLogConcurrencyState _concurrencyState = concurrencyState;
+    private readonly IState<EventLogState> _eventLogState = eventLogState;
+    private readonly ITraceLogger _logger = logger;
+
+    public async Task ReloadAsync(PendingXmlReload pending, IDispatcher dispatcher)
+    {
+        ArgumentNullException.ThrowIfNull(pending);
+        ArgumentNullException.ThrowIfNull(dispatcher);
+
+        var logsNeedingReload = pending.Logs;
+        long reloadToken = pending.ReloadToken;
+        var reloadNames = logsNeedingReload.Select(log => log.Name).ToHashSet(StringComparer.Ordinal);
+
+        var selectionByLog = _eventLogState.Value.Selection
+            .Where(entry => entry.ReloadKey is { } key && reloadNames.Contains(key.OwningLog))
+            .GroupBy(entry => entry.ReloadKey!.Value.OwningLog)
+            .ToDictionary(
+                group => group.Key,
+                IReadOnlySet<long> (group) => group.Select(entry => entry.ReloadKey!.Value.RecordId).ToHashSet());
+
+        var focus = _eventLogState.Value.Focus;
+        long? selectedRecordId = focus?.ReloadKey?.RecordId;
+        string? selectedLogName = focus?.ReloadKey?.OwningLog;
+
+        if (selectedRecordId.HasValue &&
+            !string.IsNullOrEmpty(selectedLogName) &&
+            reloadNames.Contains(selectedLogName) &&
+            !selectionByLog.ContainsKey(selectedLogName))
+        {
+            selectionByLog[selectedLogName] = new HashSet<long>();
+        }
+
+        await _closeCoordinator.AcquireCoordinatorLockAsync();
+
+        try
+        {
+            var closeWaiters = new List<(EventLogId Id, string Name, Task Task)>(logsNeedingReload.Count);
+
+            foreach (var (id, name, _) in logsNeedingReload)
+            {
+                var tcs = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+                _closeCoordinator.RegisterCloseCompletion(id, tcs);
+                closeWaiters.Add((id, name, tcs.Task));
+            }
+
+            foreach (var (id, name, _) in logsNeedingReload)
+            {
+                dispatcher.Dispatch(new CloseLogAction(id, name));
+            }
+
+            var timedOutLogs = new HashSet<string>(StringComparer.Ordinal);
+
+            foreach (var (id, name, task) in closeWaiters)
+            {
+                try
+                {
+                    await task.WaitAsync(LogCloseCoordinator.LogCloseTimeout);
+                }
+                catch (TimeoutException)
+                {
+                    _closeCoordinator.RemoveStrandedCompletion(id);
+                    timedOutLogs.Add(name);
+
+                    _logger.Trace(
+                        $"{nameof(ReloadAsync)}: close for log '{name}' did not complete within {LogCloseCoordinator.LogCloseTimeout}; selection will not be restored to avoid race with the delayed close wiping the entry.");
+                }
+            }
+
+            foreach (var (name, ids) in selectionByLog)
+            {
+                if (timedOutLogs.Contains(name)) { continue; }
+
+                long? selectedIdForLog = string.Equals(name, selectedLogName, StringComparison.Ordinal) ?
+                    selectedRecordId : null;
+
+                _closeCoordinator.WritePendingRestore(name, new PendingSelectionRestore(ids, selectedIdForLog));
+            }
+
+            if (_concurrencyState.GetCurrentReloadToken() != reloadToken)
+            {
+                foreach (var (_, name, _) in logsNeedingReload)
+                {
+                    _closeCoordinator.ClearPendingRestore(name);
+                }
+
+                _logger.Trace(
+                    $"{nameof(ReloadAsync)}: reload superseded by CloseAll; skipping reopen of {logsNeedingReload.Count} log(s) and clearing pending selection restore.");
+
+                return;
+            }
+
+            var reopenedSoFar = new List<(EventLogId Id, string Name)>(logsNeedingReload.Count);
+
+            void AbortReopenAsSuperseded(string when)
+            {
+                foreach (var (reopenedId, reopenedName) in reopenedSoFar)
+                {
+                    dispatcher.Dispatch(new CloseLogAction(reopenedId, reopenedName));
+                }
+
+                foreach (var (_, restoreName, _) in logsNeedingReload)
+                {
+                    _closeCoordinator.ClearPendingRestore(restoreName);
+                }
+
+                _logger.Trace(
+                    $"{nameof(ReloadAsync)}: reload superseded by CloseAll {when}; dispatched CloseLog for {reopenedSoFar.Count} reopened log(s) and cleared pending selection restore.");
+            }
+
+            foreach (var (_, name, type) in logsNeedingReload)
+            {
+                if (_concurrencyState.GetCurrentReloadToken() != reloadToken)
+                {
+                    AbortReopenAsSuperseded("mid-reopen");
+
+                    return;
+                }
+
+                var reopenedId = EventLogId.Create();
+
+                dispatcher.Dispatch(new OpenLogAction(name, type, PreassignedId: reopenedId));
+                reopenedSoFar.Add((reopenedId, name));
+            }
+
+            if (_concurrencyState.GetCurrentReloadToken() != reloadToken)
+            {
+                AbortReopenAsSuperseded("after reopen");
+            }
+        }
+        finally
+        {
+            _closeCoordinator.ReleaseCoordinatorLock();
+        }
+    }
+
+    public PendingXmlReload Resolve(Filter filter)
+    {
+        long reloadToken = _concurrencyState.GetCurrentReloadToken();
+
+        var logs = filter.RequiresXml && !_eventLogState.Value.OpenLogs.IsEmpty ?
+            _eventLogState.Value.OpenLogs
+                .Where(entry => !_concurrencyState.IsLoadedWithXml(entry.Value.Id))
+                .Select(entry => (entry.Value.Id, Name: entry.Key, entry.Value.Type))
+                .ToList() : [];
+
+        return new PendingXmlReload(logs, reloadToken);
+    }
+}
+
+internal sealed record PendingXmlReload(
+    List<(EventLogId Id, string Name, LogPathType Type)> Logs,
+    long ReloadToken)
+{
+    public bool IsNeeded => Logs.Count > 0;
+}
diff --git a/src/EventLogExpert.Runtime/EventLogExpert.Runtime.csproj b/src/EventLogExpert.Runtime/EventLogExpert.Runtime.csproj
index 7cdd3cb49..e339a2047 100644
--- a/src/EventLogExpert.Runtime/EventLogExpert.Runtime.csproj
+++ b/src/EventLogExpert.Runtime/EventLogExpert.Runtime.csproj
@@ -6,7 +6,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Fluxor.Blazor.Web" />
+    <PackageReference Include="Fluxor" />
     <PackageReference Include="Microsoft.Data.Sqlite" />
   </ItemGroup>
 
diff --git a/src/EventLogExpert.Runtime/Export/EventExportCoordinator.cs b/src/EventLogExpert.Runtime/Export/EventExportCoordinator.cs
new file mode 100644
index 000000000..ffa1b7fd8
--- /dev/null
+++ b/src/EventLogExpert.Runtime/Export/EventExportCoordinator.cs
@@ -0,0 +1,153 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Logging.Abstractions;
+using EventLogExpert.Runtime.Alerts;
+using EventLogExpert.Runtime.Banner;
+using EventLogExpert.Runtime.Common.Files;
+using EventLogExpert.Runtime.LogTable;
+using EventLogExpert.Runtime.Settings;
+using Fluxor;
+using System.Globalization;
+
+namespace EventLogExpert.Runtime.Export;
+
+public sealed class EventExportCoordinator(
+    IState<LogTableState> logTableState,
+    IEventTableExporter eventTableExporter,
+    IFileSaveService fileSaveService,
+    IExportProgressBannerService exportProgress,
+    IAlertDialogService dialogService,
+    ISettingsService settings,
+    ILogTableColumnDefaultsProvider columnDefaults,
+    ITraceLogger traceLogger)
+{
+    private readonly ILogTableColumnDefaultsProvider _columnDefaults = columnDefaults;
+    private readonly IAlertDialogService _dialogService = dialogService;
+    private readonly IEventTableExporter _eventTableExporter = eventTableExporter;
+    private readonly IExportProgressBannerService _exportProgress = exportProgress;
+    private readonly IFileSaveService _fileSaveService = fileSaveService;
+    private readonly IState<LogTableState> _logTableState = logTableState;
+    private readonly ISettingsService _settings = settings;
+    private readonly ITraceLogger _traceLogger = traceLogger;
+
+    private int _exportInFlight;
+
+    public async Task ExportEventsAsync(ExportFormat format)
+    {
+        var state = _logTableState.Value;
+        var events = state.GetActiveDisplayedEvents();
+
+        if (events.Count == 0)
+        {
+            string reason = state.PresentationState switch
+            {
+                PresentationState.Faulted => "These events cannot be exported because the view could not be prepared.",
+                PresentationState.Updating =>
+                    "These events are still being prepared. Please try again once they have finished loading.",
+                _ => "There are no events to export."
+            };
+
+            await _dialogService.ShowAlert("Export events", reason, "Ok", AlertPresentation.Banner);
+
+            return;
+        }
+
+        var columns = state.GetOrderedEnabledColumns(_columnDefaults);
+
+        if (columns.Count == 0)
+        {
+            await _dialogService.ShowAlert(
+                "Export events", "There are no visible columns to export.", "Ok", AlertPresentation.Banner);
+
+            return;
+        }
+
+        var timeZone = _settings.TimeZoneInfo;
+        bool isCsv = format == ExportFormat.Csv;
+        var fileTypes = isCsv ? FileSaveFileTypes.Csv : FileSaveFileTypes.Json;
+        string extension = isCsv ? ".csv" : ".json";
+        string suggestedFileName =
+            $"events-{DateTime.Now.ToString("yyyyMMdd-HHmmss", CultureInfo.InvariantCulture)}{extension}";
+
+        if (Interlocked.CompareExchange(ref _exportInFlight, 1, 0) != 0)
+        {
+            await _dialogService.ShowAlert(
+                "Export events", "An export is already in progress.", "Ok", AlertPresentation.Banner);
+
+            return;
+        }
+
+        CancellationTokenSource cancellation = new();
+        string? savedPath = null;
+        Exception? failure = null;
+        bool canceled = false;
+
+        try
+        {
+            savedPath = await _fileSaveService.SaveStreamingAsync(
+                suggestedFileName,
+                fileTypes,
+                async (stream, _) =>
+                {
+                    _exportProgress.Begin(
+                        "Exporting events...",
+                        () =>
+                        {
+                            try { cancellation.Cancel(); }
+                            catch (ObjectDisposedException) { /* Teardown disposed the CTS; a late Cancel is a no-op. */ }
+                        });
+
+                    await _eventTableExporter.ExportAsync(
+                        stream, format, events, columns, timeZone, includeDescription: true, cancellation.Token);
+                },
+                CancellationToken.None);
+        }
+        catch (OperationCanceledException) when (cancellation.IsCancellationRequested)
+        {
+            canceled = true;
+        }
+        catch (Exception ex)
+        {
+            failure = ex;
+        }
+        finally
+        {
+            try
+            {
+                _exportProgress.End();
+            }
+            finally
+            {
+                cancellation.Dispose();
+                Interlocked.Exchange(ref _exportInFlight, 0);
+            }
+        }
+
+        if (canceled)
+        {
+            await _dialogService.ShowAlert(
+                "Export canceled", "The export was canceled.", "Ok", AlertPresentation.Banner);
+
+            return;
+        }
+
+        if (failure is not null)
+        {
+            _traceLogger.Error($"Failed to export events: {failure}");
+
+            await _dialogService.ShowAlert("Export failed", failure.Message, "Ok", AlertPresentation.Banner);
+
+            return;
+        }
+
+        if (savedPath is not null)
+        {
+            await _dialogService.ShowAlert(
+                "Export complete",
+                $"Exported {events.Count:N0} {(events.Count == 1 ? "event" : "events")} to {savedPath}.",
+                "Ok",
+                AlertPresentation.Banner);
+        }
+    }
+}
diff --git a/src/EventLogExpert.Runtime/Export/EventTableExporter.cs b/src/EventLogExpert.Runtime/Export/EventTableExporter.cs
index fc913b39e..5062a96df 100644
--- a/src/EventLogExpert.Runtime/Export/EventTableExporter.cs
+++ b/src/EventLogExpert.Runtime/Export/EventTableExporter.cs
@@ -53,12 +53,8 @@ private static string NeutralizeCsvFormula(string value)
     {
         if (value.Length == 0) { return value; }
 
-        // A leading TAB or CR is itself a CSV-injection vector; neutralize it directly (it is whitespace,
-        // so the scan below would otherwise skip past it).
         if (value[0] is '\t' or '\r') { return "'" + value; }
 
-        // Spreadsheet apps trim leading whitespace before evaluating a cell, so a value like " =SUM(A1)"
-        // is still a formula. Neutralize when the first non-whitespace character is a formula trigger.
         foreach (char character in value)
         {
             if (char.IsWhiteSpace(character)) { continue; }
@@ -77,15 +73,12 @@ private static string NeutralizeCsvFormula(string value)
         bool includeDescription,
         [EnumeratorCancellation] CancellationToken cancellationToken)
     {
-        // This await only satisfies the async-iterator contract; the projection itself is synchronous over the view's
-        // on-demand rehydrate.
         await Task.CompletedTask.ConfigureAwait(false);
 
         bool neutralizeCsvFormula = format == ExportFormat.Csv;
         int cellCount = columns.Count + (includeDescription ? 1 : 0);
 
-        // Enumerate, never index: EnumerateDetail is an O(n) single-cursor rehydrate, so indexed access would be O(n^2).
-        foreach (ResolvedEvent @event in events.EnumerateDetail())
+        foreach (ResolvedEvent @event in events.EnumerateDetailLean())
         {
             cancellationToken.ThrowIfCancellationRequested();
 
@@ -99,9 +92,10 @@ private static string NeutralizeCsvFormula(string value)
 
             if (includeDescription)
             {
-                cells[columns.Count] = neutralizeCsvFormula
-                    ? NeutralizeCsvFormula(@event.Description)
-                    : @event.Description;
+                cells[columns.Count] =
+                    neutralizeCsvFormula ?
+                        NeutralizeCsvFormula(@event.Description) :
+                        @event.Description;
             }
 
             yield return cells;
diff --git a/src/EventLogExpert.Runtime/FilterLenses/FilterLensCommands.cs b/src/EventLogExpert.Runtime/FilterLenses/FilterLensCommands.cs
index 0e0568ba2..39e16bfe8 100644
--- a/src/EventLogExpert.Runtime/FilterLenses/FilterLensCommands.cs
+++ b/src/EventLogExpert.Runtime/FilterLenses/FilterLensCommands.cs
@@ -11,7 +11,7 @@ internal sealed class FilterLensCommands(IDispatcher dispatcher) : IFilterLensCo
 
     public void ClearLenses() => _dispatcher.Dispatch(new ClearFilterLensesAction());
 
-    public void RemoveLens(FilterLens lens) => _dispatcher.Dispatch(new RemoveFilterLensAction(lens));
+    public void RemoveLens(FilterLensId id) => _dispatcher.Dispatch(new RemoveFilterLensAction(id));
 
     public void ShowEventsNearTime(DateTime timeCreated, TimeSpan radius, TimeZoneInfo displayZone, string? originLog = null) =>
         PushLens(FilterLensFactory.ForTimeWindow(timeCreated, radius, displayZone, originLog));
diff --git a/src/EventLogExpert.Runtime/FilterLenses/FilterLensFactory.cs b/src/EventLogExpert.Runtime/FilterLenses/FilterLensFactory.cs
index 94568a897..01fe3051a 100644
--- a/src/EventLogExpert.Runtime/FilterLenses/FilterLensFactory.cs
+++ b/src/EventLogExpert.Runtime/FilterLenses/FilterLensFactory.cs
@@ -11,18 +11,11 @@ namespace EventLogExpert.Runtime.FilterLenses;
 
 internal static class FilterLensFactory
 {
-    /// <summary>
-    ///     Builds a lens that keeps only rows whose ActivityId equals <paramref name="activityId" />. An optional
-    ///     <paramref name="label" /> overrides the default chip text - used by the parent-activity jump, which is an
-    ///     ActivityId-equality narrowing surfaced to the user under a different name.
-    /// </summary>
+    private static readonly TimeSpan s_maxTimeWindowRadius = TimeSpan.FromHours(1);
+
     public static FilterLens? ForActivityId(Guid activityId, string? originLog = null, string? label = null) =>
         BuildEqualityLens(EventProperty.ActivityId, activityId, label ?? $"Activity ID = {activityId}", originLog);
 
-    /// <summary>
-    ///     Builds a lens that keeps only rows whose RelatedActivityId equals <paramref name="relatedActivityId" />,
-    ///     grouping events that share the same parent/correlation activity.
-    /// </summary>
     public static FilterLens? ForRelatedActivityId(Guid relatedActivityId, string? originLog = null) =>
         BuildEqualityLens(
             EventProperty.RelatedActivityId,
@@ -30,10 +23,6 @@ internal static class FilterLensFactory
             $"Related Activity ID = {relatedActivityId}",
             originLog);
 
-    /// <summary>
-    ///     Builds a lens keeping rows whose TimeCreated is in the inclusive UTC range [startUtc, endUtc]; endpoints are
-    ///     normalized so a right-to-left brush stays a valid non-empty window.
-    /// </summary>
     public static FilterLens ForTimeRange(
         DateTime startUtc,
         DateTime endUtc,
@@ -46,7 +35,6 @@ public static FilterLens ForTimeRange(
 
         return new FilterLens
         {
-            // Include each endpoint's date when the window spans more than one displayed day, so a midnight-straddling or multi-day range isn't a bare, ambiguous "23:55:00 - 00:05:00".
             Label = afterLocal.Date == beforeLocal.Date
                 ? $"{afterLocal:T} - {beforeLocal:T}"
                 : $"{afterLocal:d} {afterLocal:T} - {beforeLocal:d} {beforeLocal:T}",
@@ -56,20 +44,6 @@ public static FilterLens ForTimeRange(
         };
     }
 
-    /// <summary>
-    ///     Builds a transient time-window lens centered on <paramref name="timeCreatedUtc" /> (the source event's UTC
-    ///     timestamp): the effective view is narrowed to the inclusive range [timeCreatedUtc - radius, timeCreatedUtc +
-    ///     radius], so the source event itself always survives. Bounds are clamped to the <see cref="DateTime" /> range
-    ///     because boundary arithmetic throws on overflow - a degenerate near-min/near-max timestamp must not crash the menu
-    ///     handler. The chip label renders the anchor's time of day in <paramref name="displayZone" /> (the grid's display
-    ///     zone) as a compact marker; it is not the grid's full date+time rendering. <paramref name="radius" /> must be within
-    ///     (0, 1 hour] and a whole number of seconds (validated); the suffix renders it to its largest whole unit (for example
-    ///     90s stays "90s").
-    /// </summary>
-    /// <exception cref="ArgumentOutOfRangeException">
-    ///     <paramref name="radius" /> is not within (0, 1 hour], or is not a whole
-    ///     number of seconds.
-    /// </exception>
     public static FilterLens ForTimeWindow(
         DateTime timeCreatedUtc,
         TimeSpan radius,
@@ -77,7 +51,7 @@ public static FilterLens ForTimeWindow(
         string? originLog = null)
     {
         ArgumentOutOfRangeException.ThrowIfLessThanOrEqual(radius, TimeSpan.Zero);
-        ArgumentOutOfRangeException.ThrowIfGreaterThan(radius, TimeSpan.FromHours(1));
+        ArgumentOutOfRangeException.ThrowIfGreaterThan(radius, s_maxTimeWindowRadius);
 
         if (radius.Ticks % TimeSpan.TicksPerSecond != 0)
         {
@@ -96,14 +70,6 @@ public static FilterLens ForTimeWindow(
         };
     }
 
-    /// <summary>
-    ///     Encodes a nullable-Guid equality narrowing (keep only rows where the field equals <paramref name="value" />)
-    ///     as an <em>exclude-of-complement</em>: because the base's include filters are OR-combined an appended include would
-    ///     broaden, so the complement (<c>field != value</c>, <see cref="SavedFilter.IsExcluded" />) is excluded to AND-narrow
-    ///     to exactly <c>field == value</c>. <c>NotEqual</c> on a nullable-Guid column is total (a decisive Match for an
-    ///     absent value), so the exclude hides absent-field rows rather than leaking them. Returns <see langword="null" />
-    ///     only if the criterion fails to format or compile.
-    /// </summary>
     private static FilterLens? BuildEqualityLens(EventProperty property, Guid value, string label, string? originLog)
     {
         if (!TryFormatNotEqual(property, value.ToString(), out var comparisonText))
@@ -128,11 +94,6 @@ public static FilterLens ForTimeWindow(
         };
     }
 
-    /// <summary>
-    ///     Formats the window radius as a compact chip suffix (for example "30s", "5m", "1h") using the largest whole
-    ///     unit that represents it exactly. Callers are validated to whole-second radii, so every valid radius renders
-    ///     losslessly.
-    /// </summary>
     private static string FormatRadius(TimeSpan radius) => radius switch
     {
         { Minutes: 0, Seconds: 0, Milliseconds: 0 } => $"{radius.TotalHours:0}h",
diff --git a/src/EventLogExpert.Runtime/FilterLenses/FilterLensSource.cs b/src/EventLogExpert.Runtime/FilterLenses/FilterLensSource.cs
new file mode 100644
index 000000000..6663f18dd
--- /dev/null
+++ b/src/EventLogExpert.Runtime/FilterLenses/FilterLensSource.cs
@@ -0,0 +1,23 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Logging.Abstractions;
+using EventLogExpert.Runtime.Common.Sources;
+using Fluxor;
+using Microsoft.Extensions.DependencyInjection;
+using System.Collections.Immutable;
+
+namespace EventLogExpert.Runtime.FilterLenses;
+
+internal sealed class FilterLensSource(
+    IState<FilterLensState> state,
+    [FromKeyedServices(LogCategories.EventLog)] ITraceLogger logger)
+    : ObservableStateSourceBase<FilterLensState, ImmutableList<FilterLensSummary>>(
+            state,
+            logger,
+            static state => [.. state.Lenses.Select(lens => new FilterLensSummary(lens.Id, lens.Label))],
+            static (next, current) => next.SequenceEqual(current)),
+        IFilterLensSource
+{
+    public ImmutableList<FilterLensSummary> Lenses => CurrentProjection;
+}
diff --git a/src/EventLogExpert.Runtime/FilterLenses/FilterLensSummary.cs b/src/EventLogExpert.Runtime/FilterLenses/FilterLensSummary.cs
new file mode 100644
index 000000000..64c56417b
--- /dev/null
+++ b/src/EventLogExpert.Runtime/FilterLenses/FilterLensSummary.cs
@@ -0,0 +1,6 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+namespace EventLogExpert.Runtime.FilterLenses;
+
+public sealed record FilterLensSummary(FilterLensId Id, string Label);
diff --git a/src/EventLogExpert.Runtime/FilterLenses/IFilterLensCommands.cs b/src/EventLogExpert.Runtime/FilterLenses/IFilterLensCommands.cs
index bc3517d90..665098ca9 100644
--- a/src/EventLogExpert.Runtime/FilterLenses/IFilterLensCommands.cs
+++ b/src/EventLogExpert.Runtime/FilterLenses/IFilterLensCommands.cs
@@ -9,42 +9,15 @@ public interface IFilterLensCommands
 {
     void ClearLenses();
 
-    void RemoveLens(FilterLens lens);
-
-    /// <summary>
-    ///     Pushes a transient time-window lens centered on <paramref name="timeCreated" /> (the source event's UTC
-    ///     timestamp), narrowing the view to events no more than <paramref name="radius" /> before or after it. The window is
-    ///     inclusive, so the source event always stays in view. <paramref name="displayZone" /> renders the chip's anchor time
-    ///     in the grid's display zone; <paramref name="originLog" /> is the source event's
-    ///     <see cref="ResolvedEvent.OwningLog" /> so the lens auto-clears when that log is closed.
-    /// </summary>
+    void RemoveLens(FilterLensId id);
+
     void ShowEventsNearTime(DateTime timeCreated, TimeSpan radius, TimeZoneInfo displayZone, string? originLog = null);
 
-    /// <summary>
-    ///     Pushes a lens narrowing the view to the parent activity's events - those whose ActivityId equals the source
-    ///     event's <paramref name="relatedActivityId" />. A null id is a no-op. <paramref name="originLog" /> is the source
-    ///     event's <see cref="ResolvedEvent.OwningLog" /> so the lens auto-clears when that log is closed.
-    /// </summary>
     void ShowParentActivity(Guid? relatedActivityId, string? originLog = null);
 
-    /// <summary>
-    ///     Pushes a "Show Related by Activity ID" lens narrowing the view to events sharing
-    ///     <paramref name="activityId" />. A null id is a no-op, so callers may pass an event's nullable ActivityId directly.
-    ///     <paramref name="originLog" /> is the source event's <see cref="ResolvedEvent.OwningLog" /> so the lens auto-clears
-    ///     when that log is closed.
-    /// </summary>
     void ShowRelatedByActivityId(Guid? activityId, string? originLog = null);
 
-    /// <summary>
-    ///     Pushes a lens narrowing the view to events that share <paramref name="relatedActivityId" /> (siblings of the
-    ///     same parent/correlation activity). A null id is a no-op. <paramref name="originLog" /> is the source event's
-    ///     <see cref="ResolvedEvent.OwningLog" /> so the lens auto-clears when that log is closed.
-    /// </summary>
     void ShowRelatedByRelatedActivityId(Guid? relatedActivityId, string? originLog = null);
 
-    /// <summary>
-    ///     Pushes a reversible lens narrowing the view to the inclusive UTC range [startUtc, endUtc] (histogram brush);
-    ///     originLog auto-clears the lens when that log closes (null for a combined view).
-    /// </summary>
     void ShowTimeRange(DateTime startUtc, DateTime endUtc, TimeZoneInfo displayZone, string? originLog = null);
 }
diff --git a/src/EventLogExpert.Runtime/FilterLenses/IFilterLensSource.cs b/src/EventLogExpert.Runtime/FilterLenses/IFilterLensSource.cs
new file mode 100644
index 000000000..af5629d1c
--- /dev/null
+++ b/src/EventLogExpert.Runtime/FilterLenses/IFilterLensSource.cs
@@ -0,0 +1,12 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Runtime.Common.Sources;
+using System.Collections.Immutable;
+
+namespace EventLogExpert.Runtime.FilterLenses;
+
+public interface IFilterLensSource : IChangeNotifier
+{
+    ImmutableList<FilterLensSummary> Lenses { get; }
+}
diff --git a/src/EventLogExpert.Runtime/FilterLenses/Reducers.cs b/src/EventLogExpert.Runtime/FilterLenses/Reducers.cs
index 844d86133..84745f2c6 100644
--- a/src/EventLogExpert.Runtime/FilterLenses/Reducers.cs
+++ b/src/EventLogExpert.Runtime/FilterLenses/Reducers.cs
@@ -18,7 +18,7 @@ public static FilterLensState ReducePush(FilterLensState state, PushFilterLensAc
     [ReducerMethod]
     public static FilterLensState ReduceRemove(FilterLensState state, RemoveFilterLensAction action)
     {
-        var updated = state.Lenses.RemoveAll(lens => lens.Id == action.Lens.Id);
+        var updated = state.Lenses.RemoveAll(lens => lens.Id == action.Id);
 
         return updated.Count == state.Lenses.Count ? state : state with { Lenses = updated };
     }
diff --git a/src/EventLogExpert.Runtime/FilterLenses/RemoveFilterLensAction.cs b/src/EventLogExpert.Runtime/FilterLenses/RemoveFilterLensAction.cs
index da06ac90a..be2c85a9f 100644
--- a/src/EventLogExpert.Runtime/FilterLenses/RemoveFilterLensAction.cs
+++ b/src/EventLogExpert.Runtime/FilterLenses/RemoveFilterLensAction.cs
@@ -3,4 +3,4 @@
 
 namespace EventLogExpert.Runtime.FilterLenses;
 
-internal sealed record RemoveFilterLensAction(FilterLens Lens);
+internal sealed record RemoveFilterLensAction(FilterLensId Id);
diff --git a/src/EventLogExpert.Runtime/FilterLibrary/Effects.cs b/src/EventLogExpert.Runtime/FilterLibrary/Effects.cs
index a96d2bcfc..f6354544c 100644
--- a/src/EventLogExpert.Runtime/FilterLibrary/Effects.cs
+++ b/src/EventLogExpert.Runtime/FilterLibrary/Effects.cs
@@ -17,7 +17,8 @@ internal sealed class Effects(
     ILegacyFilterMigrator legacyMigrator,
     IBackslashNameMigrator backslashMigrator,
     IAnnouncementService announcementService,
-    ITraceLogger logger)
+    ITraceLogger logger,
+    TagBulkUpdateFailedNotifier tagBulkUpdateFailedNotifier)
 {
     private const int MaxAutoTrackedRecents = 50;
 
@@ -163,16 +164,8 @@ public async Task HandleLoadLibrary(IDispatcher dispatcher)
 
             if (legacyMigrator.ShouldRunMigration())
             {
-                // AddRange-throws → keep returning currently-loaded entries + return without marking complete
-                // (retries next launch). Post-AddRange LoadAll-throws → in-memory fallback + MarkMigrationCompleted
-                // as on the happy path.
                 var migrationResult = legacyMigrator.BuildEntriesFromLegacy();
 
-                // Dedup against the already-loaded entries before AddRange - the per-section flag check in
-                // BuildEntriesFromLegacy short-circuits already-completed sections, but on the bitmask-not-advanced
-                // path (e.g., MarkMigrationCompleted SetString throws after a successful AddRange) the next launch
-                // would re-read the still-present legacy keys and produce content-duplicate rows because migration
-                // entries are Origin=UserSaved and the store's partial UNIQUE INDEX only covers AutoTracked rows.
                 var entriesToAdd = DedupMigrationEntriesAgainstExisting(migrationResult.Entries, entries);
 
                 if (entriesToAdd.Count > 0)
@@ -202,7 +195,6 @@ public async Task HandleLoadLibrary(IDispatcher dispatcher)
                     logger.Information($"Migrated {entriesToAdd.Count} legacy entries to filter library (deduped from {migrationResult.Entries.Count}).");
                 }
 
-                // Not wrapped: a SetString failure surfaces via the outer catch (LoadLibraryFailure). On the next
                 // launch ShouldRunMigration returns true again, BuildEntriesFromLegacy re-emits the same entries,
                 // and DedupMigrationEntriesAgainstExisting filters them out against the now-non-empty store -
                 // so the SetString-throws path is idempotent rather than duplicating.
@@ -485,8 +477,6 @@ public Task HandleSaveFilterSet(SaveFilterSetAction action, IDispatcher dispatch
         {
             Name = action.Name,
             CreatedUtc = DateTimeOffset.UtcNow,
-            // Regenerate FilterIds so Razor `@key=filter.Id` diffing stays correct when the
-            // same pane filters are saved into multiple filter sets.
             Filters = [.. action.Filters.Select(f => f with { Id = FilterId.Create(), IsEnabled = false })],
             Origin = LibraryEntryOrigin.UserSaved,
         };
@@ -545,6 +535,14 @@ public Task HandleSetIsFavorite(SetIsFavoriteAction action, IDispatcher dispatch
         return PersistAndDispatchAsync(action.EntryId, e => ApplyFavoriteToggle(e, setIsFavorite, unfavoriteTimestamp), dispatcher);
     }
 
+    [EffectMethod(typeof(TagBulkUpdateFailedAction))]
+    public Task HandleTagBulkUpdateFailed(IDispatcher dispatcher)
+    {
+        tagBulkUpdateFailedNotifier.Raise();
+
+        return Task.CompletedTask;
+    }
+
     [EffectMethod]
     public async Task HandleUpdateLibraryEntry(UpdateLibraryEntryAction action, IDispatcher dispatcher)
     {
@@ -580,7 +578,6 @@ private static LibraryEntry ApplyFavoriteToggle(LibraryEntry entry, bool isFavor
     {
         if (isFavorite)
         {
-            // Favoriting: mutex (LastUsedUtc=null) + promotion (Origin=UserSaved). Symmetric for filter + filter set.
             return entry switch
             {
                 LibraryEntrySavedFilter f => f with
@@ -599,7 +596,6 @@ private static LibraryEntry ApplyFavoriteToggle(LibraryEntry entry, bool isFavor
             };
         }
 
-        // Unfavoriting: filters drop to Recents (matches legacy FilterCache UX); filter sets stay out of Recents.
         return entry switch
         {
             LibraryEntrySavedFilter f => f with
@@ -924,7 +920,6 @@ private async Task PruneFromSnapshot(ImmutableList<LibraryEntry> snapshot, IDisp
 
         if (autoTrackedRecents.Count <= MaxAutoTrackedRecents) { return; }
 
-        // CreatedUtc tie-break keeps prune deterministic when entries share LastUsedUtc.
         var toDelete = autoTrackedRecents
             .OrderBy(e => e.LastUsedUtc!.Value)
             .ThenBy(e => e.CreatedUtc)
@@ -933,8 +928,6 @@ private async Task PruneFromSnapshot(ImmutableList<LibraryEntry> snapshot, IDisp
 
         foreach (var entry in toDelete)
         {
-            // SQL guard no-ops the delete if a concurrent SetIsFavorite/SaveEntry promoted the row
-            // (Origin=UserSaved or IsFavorite=true) after the snapshot was projected.
             bool deleted;
 
             try { deleted = await store.TryDeleteAutoTrackedIfNotFavoriteAsync(entry.Id).ConfigureAwait(false); }
diff --git a/src/EventLogExpert.Runtime/FilterLibrary/ILibraryEntriesSource.cs b/src/EventLogExpert.Runtime/FilterLibrary/ILibraryEntriesSource.cs
new file mode 100644
index 000000000..f3a0a4100
--- /dev/null
+++ b/src/EventLogExpert.Runtime/FilterLibrary/ILibraryEntriesSource.cs
@@ -0,0 +1,12 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Runtime.Common.Sources;
+using System.Collections.Immutable;
+
+namespace EventLogExpert.Runtime.FilterLibrary;
+
+public interface ILibraryEntriesSource : IChangeNotifier
+{
+    ImmutableList<LibraryEntry> Current { get; }
+}
diff --git a/src/EventLogExpert.Runtime/FilterLibrary/ILibraryLoadStatusSource.cs b/src/EventLogExpert.Runtime/FilterLibrary/ILibraryLoadStatusSource.cs
new file mode 100644
index 000000000..86256e34b
--- /dev/null
+++ b/src/EventLogExpert.Runtime/FilterLibrary/ILibraryLoadStatusSource.cs
@@ -0,0 +1,13 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Runtime.Common.Sources;
+
+namespace EventLogExpert.Runtime.FilterLibrary;
+
+public readonly record struct LibraryLoadStatus(bool IsLoaded, bool LoadError);
+
+public interface ILibraryLoadStatusSource : IChangeNotifier
+{
+    LibraryLoadStatus Current { get; }
+}
diff --git a/src/EventLogExpert.Runtime/FilterLibrary/ITagBulkUpdateFailedNotifier.cs b/src/EventLogExpert.Runtime/FilterLibrary/ITagBulkUpdateFailedNotifier.cs
new file mode 100644
index 000000000..5eefd8179
--- /dev/null
+++ b/src/EventLogExpert.Runtime/FilterLibrary/ITagBulkUpdateFailedNotifier.cs
@@ -0,0 +1,9 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+namespace EventLogExpert.Runtime.FilterLibrary;
+
+public interface ITagBulkUpdateFailedNotifier
+{
+    event Action Failed;
+}
diff --git a/src/EventLogExpert.Runtime/FilterLibrary/LibraryEntriesSource.cs b/src/EventLogExpert.Runtime/FilterLibrary/LibraryEntriesSource.cs
new file mode 100644
index 000000000..af6957af9
--- /dev/null
+++ b/src/EventLogExpert.Runtime/FilterLibrary/LibraryEntriesSource.cs
@@ -0,0 +1,23 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Logging.Abstractions;
+using EventLogExpert.Runtime.Common.Sources;
+using Fluxor;
+using Microsoft.Extensions.DependencyInjection;
+using System.Collections.Immutable;
+
+namespace EventLogExpert.Runtime.FilterLibrary;
+
+internal sealed class LibraryEntriesSource(
+    IState<FilterLibraryState> state,
+    [FromKeyedServices(LogCategories.EventLog)] ITraceLogger logger)
+    : ObservableStateSourceBase<FilterLibraryState, ImmutableList<LibraryEntry>>(
+            state,
+            logger,
+            static state => state.Entries,
+            static (next, current) => ReferenceEquals(next, current)),
+        ILibraryEntriesSource
+{
+    public ImmutableList<LibraryEntry> Current => CurrentProjection;
+}
diff --git a/src/EventLogExpert.Runtime/FilterLibrary/LibraryLoadStatusSource.cs b/src/EventLogExpert.Runtime/FilterLibrary/LibraryLoadStatusSource.cs
new file mode 100644
index 000000000..417e42c2b
--- /dev/null
+++ b/src/EventLogExpert.Runtime/FilterLibrary/LibraryLoadStatusSource.cs
@@ -0,0 +1,20 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Logging.Abstractions;
+using EventLogExpert.Runtime.Common.Sources;
+using Fluxor;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace EventLogExpert.Runtime.FilterLibrary;
+
+internal sealed class LibraryLoadStatusSource(
+    IState<FilterLibraryState> state,
+    [FromKeyedServices(LogCategories.EventLog)] ITraceLogger logger)
+    : ObservableStateSourceBase<FilterLibraryState, LibraryLoadStatus>(state,
+            logger,
+            static state => new LibraryLoadStatus(state.IsLoaded, state.LoadError)),
+        ILibraryLoadStatusSource
+{
+    public LibraryLoadStatus Current => CurrentProjection;
+}
diff --git a/src/EventLogExpert.Runtime/FilterLibrary/TagBulkUpdateFailedNotifier.cs b/src/EventLogExpert.Runtime/FilterLibrary/TagBulkUpdateFailedNotifier.cs
new file mode 100644
index 000000000..cec53d27a
--- /dev/null
+++ b/src/EventLogExpert.Runtime/FilterLibrary/TagBulkUpdateFailedNotifier.cs
@@ -0,0 +1,40 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Logging.Abstractions;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace EventLogExpert.Runtime.FilterLibrary;
+
+internal sealed class TagBulkUpdateFailedNotifier : ITagBulkUpdateFailedNotifier
+{
+    private readonly ITraceLogger _logger;
+
+    public TagBulkUpdateFailedNotifier([FromKeyedServices(LogCategories.EventLog)] ITraceLogger logger)
+    {
+        ArgumentNullException.ThrowIfNull(logger);
+
+        _logger = logger;
+    }
+
+    public event Action? Failed;
+
+    public void Raise()
+    {
+        var handlers = Failed;
+
+        if (handlers is null) { return; }
+
+        foreach (var handler in handlers.GetInvocationList().Cast<Action>())
+        {
+            try
+            {
+                handler();
+            }
+            catch (Exception fault)
+            {
+                _logger.Trace($"{nameof(TagBulkUpdateFailedNotifier)}: a subscriber threw and was isolated: {fault}");
+            }
+        }
+    }
+}
diff --git a/src/EventLogExpert.Runtime/FilterPane/ActiveFiltersSource.cs b/src/EventLogExpert.Runtime/FilterPane/ActiveFiltersSource.cs
new file mode 100644
index 000000000..d9013abc1
--- /dev/null
+++ b/src/EventLogExpert.Runtime/FilterPane/ActiveFiltersSource.cs
@@ -0,0 +1,24 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Filtering.Persistence;
+using EventLogExpert.Logging.Abstractions;
+using EventLogExpert.Runtime.Common.Sources;
+using Fluxor;
+using Microsoft.Extensions.DependencyInjection;
+using System.Collections.Immutable;
+
+namespace EventLogExpert.Runtime.FilterPane;
+
+internal sealed class ActiveFiltersSource(
+    IState<FilterPaneState> state,
+    [FromKeyedServices(LogCategories.EventLog)] ITraceLogger logger)
+    : ObservableStateSourceBase<FilterPaneState, ImmutableList<SavedFilter>>(
+            state,
+            logger,
+            static state => state.Filters,
+            static (next, current) => ReferenceEquals(next, current)),
+        IActiveFiltersSource
+{
+    public ImmutableList<SavedFilter> Current => CurrentProjection;
+}
diff --git a/src/EventLogExpert.Runtime/FilterPane/ClearAllFiltersNotifier.cs b/src/EventLogExpert.Runtime/FilterPane/ClearAllFiltersNotifier.cs
new file mode 100644
index 000000000..53aefaf4f
--- /dev/null
+++ b/src/EventLogExpert.Runtime/FilterPane/ClearAllFiltersNotifier.cs
@@ -0,0 +1,40 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Logging.Abstractions;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace EventLogExpert.Runtime.FilterPane;
+
+internal sealed class ClearAllFiltersNotifier : IClearAllFiltersNotifier
+{
+    private readonly ITraceLogger _logger;
+
+    public ClearAllFiltersNotifier([FromKeyedServices(LogCategories.EventLog)] ITraceLogger logger)
+    {
+        ArgumentNullException.ThrowIfNull(logger);
+
+        _logger = logger;
+    }
+
+    public event Action? Requested;
+
+    public void Raise()
+    {
+        var handlers = Requested;
+
+        if (handlers is null) { return; }
+
+        foreach (var handler in handlers.GetInvocationList().Cast<Action>())
+        {
+            try
+            {
+                handler();
+            }
+            catch (Exception fault)
+            {
+                _logger.Trace($"{nameof(ClearAllFiltersNotifier)}: a subscriber threw and was isolated: {fault}");
+            }
+        }
+    }
+}
diff --git a/src/EventLogExpert.Runtime/FilterPane/Effects.cs b/src/EventLogExpert.Runtime/FilterPane/Effects.cs
index 051c95b4d..ad43d4267 100644
--- a/src/EventLogExpert.Runtime/FilterPane/Effects.cs
+++ b/src/EventLogExpert.Runtime/FilterPane/Effects.cs
@@ -14,20 +14,26 @@ namespace EventLogExpert.Runtime.FilterPane;
 internal sealed class Effects
 {
     private readonly IStateSelection<EventLogState, Filter> _appliedFilter;
+    private readonly ClearAllFiltersNotifier _clearAllFiltersNotifier;
     private readonly IState<FilterPaneState> _filterPaneState;
     private readonly IState<FilterLensState> _lensState;
     private readonly IState<RawEventStoreState> _rawEventStore;
+    private readonly SetFilterDateRangeSucceededNotifier _setFilterDateRangeSucceededNotifier;
 
     public Effects(
         IStateSelection<EventLogState, Filter> appliedFilter,
         IState<RawEventStoreState> rawEventStore,
         IState<FilterPaneState> filterPaneState,
-        IState<FilterLensState> lensState)
+        IState<FilterLensState> lensState,
+        ClearAllFiltersNotifier clearAllFiltersNotifier,
+        SetFilterDateRangeSucceededNotifier setFilterDateRangeSucceededNotifier)
     {
         _appliedFilter = appliedFilter;
         _rawEventStore = rawEventStore;
         _filterPaneState = filterPaneState;
         _lensState = lensState;
+        _clearAllFiltersNotifier = clearAllFiltersNotifier;
+        _setFilterDateRangeSucceededNotifier = setFilterDateRangeSucceededNotifier;
 
         _appliedFilter.Select(static s => s.AppliedFilter);
     }
@@ -51,6 +57,7 @@ public Task HandleAddFilter(AddFilterAction action, IDispatcher dispatcher)
     public Task HandleClearAllFilters(IDispatcher dispatcher)
     {
         UpdateEventTableFilters(_filterPaneState.Value, dispatcher);
+        _clearAllFiltersNotifier.Raise();
         return Task.CompletedTask;
     }
 
@@ -131,6 +138,7 @@ public Task HandleSetFilterDateRange(SetFilterDateRangeAction action, IDispatche
     public Task HandleSetFilterDateRangeSuccess(IDispatcher dispatcher)
     {
         UpdateEventTableFilters(_filterPaneState.Value, dispatcher);
+        _setFilterDateRangeSucceededNotifier.Raise();
 
         return Task.CompletedTask;
     }
@@ -177,9 +185,6 @@ public Task HandleToggleIsEnabled(IDispatcher dispatcher)
 
     private void UpdateEventTableFilters(FilterPaneState filterPaneState, IDispatcher dispatcher)
     {
-        // Build the effective filter by layering any active transient lenses onto the base through the single shared
-        // EffectiveFilterBuilder, so the FilterPane apply path and the FilterLens push/pop path can never diverge.
-        // FilterPaneFilterBuilder handles both the enabled and the excluded-only (pane-disabled) branch, so lenses narrow in both.
         var candidate = EffectiveFilterBuilder.Build(
             FilterPaneFilterBuilder.Build(filterPaneState),
             _lensState.Value.Lenses);
diff --git a/src/EventLogExpert.Runtime/FilterPane/FilterPaneQueries.cs b/src/EventLogExpert.Runtime/FilterPane/FilterPaneQueries.cs
new file mode 100644
index 000000000..f04a4f349
--- /dev/null
+++ b/src/EventLogExpert.Runtime/FilterPane/FilterPaneQueries.cs
@@ -0,0 +1,13 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using Fluxor;
+
+namespace EventLogExpert.Runtime.FilterPane;
+
+internal sealed class FilterPaneQueries(IState<FilterPaneState> filterPaneState) : IFilterPaneQueries
+{
+    private readonly IState<FilterPaneState> _filterPaneState = filterPaneState;
+
+    public bool IsEnabled() => _filterPaneState.Value.IsEnabled;
+}
diff --git a/src/EventLogExpert.Runtime/FilterPane/FilteredDateRangeSource.cs b/src/EventLogExpert.Runtime/FilterPane/FilteredDateRangeSource.cs
new file mode 100644
index 000000000..a253626a3
--- /dev/null
+++ b/src/EventLogExpert.Runtime/FilterPane/FilteredDateRangeSource.cs
@@ -0,0 +1,19 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Filtering.Evaluation;
+using EventLogExpert.Logging.Abstractions;
+using EventLogExpert.Runtime.Common.Sources;
+using Fluxor;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace EventLogExpert.Runtime.FilterPane;
+
+internal sealed class FilteredDateRangeSource(
+    IState<FilterPaneState> state,
+    [FromKeyedServices(LogCategories.EventLog)] ITraceLogger logger)
+    : ObservableStateSourceBase<FilterPaneState, DateFilter?>(state, logger, static state => state.FilteredDateRange),
+        IFilteredDateRangeSource
+{
+    public DateFilter? Current => CurrentProjection;
+}
diff --git a/src/EventLogExpert.Runtime/FilterPane/IActiveFiltersSource.cs b/src/EventLogExpert.Runtime/FilterPane/IActiveFiltersSource.cs
new file mode 100644
index 000000000..06d944184
--- /dev/null
+++ b/src/EventLogExpert.Runtime/FilterPane/IActiveFiltersSource.cs
@@ -0,0 +1,13 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Filtering.Persistence;
+using EventLogExpert.Runtime.Common.Sources;
+using System.Collections.Immutable;
+
+namespace EventLogExpert.Runtime.FilterPane;
+
+public interface IActiveFiltersSource : IChangeNotifier
+{
+    ImmutableList<SavedFilter> Current { get; }
+}
diff --git a/src/EventLogExpert.Runtime/FilterPane/IClearAllFiltersNotifier.cs b/src/EventLogExpert.Runtime/FilterPane/IClearAllFiltersNotifier.cs
new file mode 100644
index 000000000..266b12386
--- /dev/null
+++ b/src/EventLogExpert.Runtime/FilterPane/IClearAllFiltersNotifier.cs
@@ -0,0 +1,9 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+namespace EventLogExpert.Runtime.FilterPane;
+
+public interface IClearAllFiltersNotifier
+{
+    event Action Requested;
+}
diff --git a/src/EventLogExpert.Runtime/FilterPane/IFilterPaneQueries.cs b/src/EventLogExpert.Runtime/FilterPane/IFilterPaneQueries.cs
new file mode 100644
index 000000000..5792ea45b
--- /dev/null
+++ b/src/EventLogExpert.Runtime/FilterPane/IFilterPaneQueries.cs
@@ -0,0 +1,9 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+namespace EventLogExpert.Runtime.FilterPane;
+
+public interface IFilterPaneQueries
+{
+    bool IsEnabled();
+}
diff --git a/src/EventLogExpert.Runtime/FilterPane/IFilteredDateRangeSource.cs b/src/EventLogExpert.Runtime/FilterPane/IFilteredDateRangeSource.cs
new file mode 100644
index 000000000..9798f119f
--- /dev/null
+++ b/src/EventLogExpert.Runtime/FilterPane/IFilteredDateRangeSource.cs
@@ -0,0 +1,12 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Filtering.Evaluation;
+using EventLogExpert.Runtime.Common.Sources;
+
+namespace EventLogExpert.Runtime.FilterPane;
+
+public interface IFilteredDateRangeSource : IChangeNotifier
+{
+    DateFilter? Current { get; }
+}
diff --git a/src/EventLogExpert.Runtime/FilterPane/ISetFilterDateRangeSucceededNotifier.cs b/src/EventLogExpert.Runtime/FilterPane/ISetFilterDateRangeSucceededNotifier.cs
new file mode 100644
index 000000000..57bcde9ce
--- /dev/null
+++ b/src/EventLogExpert.Runtime/FilterPane/ISetFilterDateRangeSucceededNotifier.cs
@@ -0,0 +1,9 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+namespace EventLogExpert.Runtime.FilterPane;
+
+public interface ISetFilterDateRangeSucceededNotifier
+{
+    event Action Succeeded;
+}
diff --git a/src/EventLogExpert.Runtime/FilterPane/SetFilterDateRangeSucceededNotifier.cs b/src/EventLogExpert.Runtime/FilterPane/SetFilterDateRangeSucceededNotifier.cs
new file mode 100644
index 000000000..dd0833718
--- /dev/null
+++ b/src/EventLogExpert.Runtime/FilterPane/SetFilterDateRangeSucceededNotifier.cs
@@ -0,0 +1,40 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Logging.Abstractions;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace EventLogExpert.Runtime.FilterPane;
+
+internal sealed class SetFilterDateRangeSucceededNotifier : ISetFilterDateRangeSucceededNotifier
+{
+    private readonly ITraceLogger _logger;
+
+    public SetFilterDateRangeSucceededNotifier([FromKeyedServices(LogCategories.EventLog)] ITraceLogger logger)
+    {
+        ArgumentNullException.ThrowIfNull(logger);
+
+        _logger = logger;
+    }
+
+    public event Action? Succeeded;
+
+    public void Raise()
+    {
+        var handlers = Succeeded;
+
+        if (handlers is null) { return; }
+
+        foreach (var handler in handlers.GetInvocationList().Cast<Action>())
+        {
+            try
+            {
+                handler();
+            }
+            catch (Exception fault)
+            {
+                _logger.Trace($"{nameof(SetFilterDateRangeSucceededNotifier)}: a subscriber threw and was isolated: {fault}");
+            }
+        }
+    }
+}
diff --git a/src/EventLogExpert.Runtime/FilterProgress/FilterProgressState.cs b/src/EventLogExpert.Runtime/FilterProgress/FilterProgressState.cs
deleted file mode 100644
index 29364c949..000000000
--- a/src/EventLogExpert.Runtime/FilterProgress/FilterProgressState.cs
+++ /dev/null
@@ -1,12 +0,0 @@
-// // Copyright (c) Microsoft Corporation.
-// // Licensed under the MIT License.
-
-using Fluxor;
-
-namespace EventLogExpert.Runtime.FilterProgress;
-
-[FeatureState]
-public sealed record FilterProgressState
-{
-    public bool IsLoading { get; init; }
-}
diff --git a/src/EventLogExpert.Runtime/FilterProgress/Reducers.cs b/src/EventLogExpert.Runtime/FilterProgress/Reducers.cs
deleted file mode 100644
index 57424182a..000000000
--- a/src/EventLogExpert.Runtime/FilterProgress/Reducers.cs
+++ /dev/null
@@ -1,23 +0,0 @@
-// // Copyright (c) Microsoft Corporation.
-// // Licensed under the MIT License.
-
-using EventLogExpert.Runtime.EventLog;
-using Fluxor;
-
-namespace EventLogExpert.Runtime.FilterProgress;
-
-internal sealed class Reducers
-{
-    [ReducerMethod(typeof(CloseAllLogsAction))]
-    public static FilterProgressState ReduceCloseAll(FilterProgressState state) =>
-        state.IsLoading ? new FilterProgressState() : state;
-
-    [ReducerMethod]
-    public static FilterProgressState ReduceSetFilterProgress(
-        FilterProgressState state,
-        SetFilterProgressAction action) =>
-        state.IsLoading == action.IsLoading ? state : new FilterProgressState
-        {
-            IsLoading = action.IsLoading
-        };
-}
diff --git a/src/EventLogExpert.Runtime/FilterProgress/SetFilterProgressAction.cs b/src/EventLogExpert.Runtime/FilterProgress/SetFilterProgressAction.cs
deleted file mode 100644
index d3e32da56..000000000
--- a/src/EventLogExpert.Runtime/FilterProgress/SetFilterProgressAction.cs
+++ /dev/null
@@ -1,6 +0,0 @@
-// // Copyright (c) Microsoft Corporation.
-// // Licensed under the MIT License.
-
-namespace EventLogExpert.Runtime.FilterProgress;
-
-internal sealed record SetFilterProgressAction(bool IsLoading);
diff --git a/src/EventLogExpert.Runtime/Histogram/HistogramDimensionRequestSource.cs b/src/EventLogExpert.Runtime/Histogram/HistogramDimensionRequestSource.cs
new file mode 100644
index 000000000..ca8882193
--- /dev/null
+++ b/src/EventLogExpert.Runtime/Histogram/HistogramDimensionRequestSource.cs
@@ -0,0 +1,20 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Logging.Abstractions;
+using EventLogExpert.Runtime.Common.Sources;
+using Fluxor;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace EventLogExpert.Runtime.Histogram;
+
+internal sealed class HistogramDimensionRequestSource(
+    IState<HistogramState> state,
+    [FromKeyedServices(LogCategories.EventLog)] ITraceLogger logger)
+    : ObservableStateSourceBase<HistogramState, HistogramDimensionRequest?>(state,
+            logger,
+            static state => state.DimensionRequest),
+        IHistogramDimensionRequestSource
+{
+    public HistogramDimensionRequest? Current => CurrentProjection;
+}
diff --git a/src/EventLogExpert.Runtime/Histogram/HistogramVisibilitySource.cs b/src/EventLogExpert.Runtime/Histogram/HistogramVisibilitySource.cs
new file mode 100644
index 000000000..ff520cdcc
--- /dev/null
+++ b/src/EventLogExpert.Runtime/Histogram/HistogramVisibilitySource.cs
@@ -0,0 +1,18 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Logging.Abstractions;
+using EventLogExpert.Runtime.Common.Sources;
+using Fluxor;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace EventLogExpert.Runtime.Histogram;
+
+internal sealed class HistogramVisibilitySource(
+    IState<HistogramState> state,
+    [FromKeyedServices(LogCategories.EventLog)] ITraceLogger logger)
+    : ObservableStateSourceBase<HistogramState, bool>(state, logger, static state => state.IsVisible),
+        IHistogramVisibilitySource
+{
+    public bool IsVisible => CurrentProjection;
+}
diff --git a/src/EventLogExpert.Runtime/Histogram/IHistogramDimensionRequestSource.cs b/src/EventLogExpert.Runtime/Histogram/IHistogramDimensionRequestSource.cs
new file mode 100644
index 000000000..44f026f5a
--- /dev/null
+++ b/src/EventLogExpert.Runtime/Histogram/IHistogramDimensionRequestSource.cs
@@ -0,0 +1,11 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Runtime.Common.Sources;
+
+namespace EventLogExpert.Runtime.Histogram;
+
+public interface IHistogramDimensionRequestSource : IChangeNotifier
+{
+    HistogramDimensionRequest? Current { get; }
+}
diff --git a/src/EventLogExpert.Runtime/Histogram/IHistogramVisibilitySource.cs b/src/EventLogExpert.Runtime/Histogram/IHistogramVisibilitySource.cs
new file mode 100644
index 000000000..7b5b657c7
--- /dev/null
+++ b/src/EventLogExpert.Runtime/Histogram/IHistogramVisibilitySource.cs
@@ -0,0 +1,11 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Runtime.Common.Sources;
+
+namespace EventLogExpert.Runtime.Histogram;
+
+public interface IHistogramVisibilitySource : IChangeNotifier
+{
+    bool IsVisible { get; }
+}
diff --git a/src/EventLogExpert.Runtime/LogTable/ActiveEventLogSource.cs b/src/EventLogExpert.Runtime/LogTable/ActiveEventLogSource.cs
new file mode 100644
index 000000000..d23d0d30b
--- /dev/null
+++ b/src/EventLogExpert.Runtime/LogTable/ActiveEventLogSource.cs
@@ -0,0 +1,19 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Logging.Abstractions;
+using EventLogExpert.Runtime.Common.Sources;
+using Fluxor;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace EventLogExpert.Runtime.LogTable;
+
+internal sealed class ActiveEventLogSource(
+    IState<LogTableState> state,
+    [FromKeyedServices(LogCategories.EventLog)] ITraceLogger logger)
+    : ObservableStateSourceBase<LogTableState, EventLogId?>(state, logger, static state => state.ActiveEventLogId),
+        IActiveEventLogSource
+{
+    public EventLogId? Current => CurrentProjection;
+}
diff --git a/src/EventLogExpert.Runtime/LogTable/AppendTableEventsBatchAction.cs b/src/EventLogExpert.Runtime/LogTable/AppendTableEventsBatchAction.cs
deleted file mode 100644
index 736a44581..000000000
--- a/src/EventLogExpert.Runtime/LogTable/AppendTableEventsBatchAction.cs
+++ /dev/null
@@ -1,16 +0,0 @@
-// // Copyright (c) Microsoft Corporation.
-// // Licensed under the MIT License.
-
-using EventLogExpert.Eventing.Common.EventLogs;
-using System.Collections.Immutable;
-
-namespace EventLogExpert.Runtime.LogTable;
-
-public sealed record AppendTableEventsBatchAction
-{
-    internal IReadOnlyDictionary<EventLogId, EventColumnView> ViewsByLog { get; init; } =
-        ImmutableDictionary<EventLogId, EventColumnView>.Empty;
-
-    internal IReadOnlyDictionary<EventLogId, int> VersionByLog { get; init; } =
-        ImmutableDictionary<EventLogId, int>.Empty;
-}
diff --git a/src/EventLogExpert.Runtime/LogTable/ResolvedEventOrdering.ColumnDirectSort.cs b/src/EventLogExpert.Runtime/LogTable/ColumnDirectSort.cs
similarity index 73%
rename from src/EventLogExpert.Runtime/LogTable/ResolvedEventOrdering.ColumnDirectSort.cs
rename to src/EventLogExpert.Runtime/LogTable/ColumnDirectSort.cs
index dd09128d9..dcd55d8b6 100644
--- a/src/EventLogExpert.Runtime/LogTable/ResolvedEventOrdering.ColumnDirectSort.cs
+++ b/src/EventLogExpert.Runtime/LogTable/ColumnDirectSort.cs
@@ -5,7 +5,7 @@
 
 namespace EventLogExpert.Runtime.LogTable;
 
-internal static partial class ResolvedEventOrdering
+internal static class ColumnDirectSort
 {
     internal static int[] SortColumnDirect(
         IEventColumnReader reader,
@@ -13,28 +13,24 @@ internal static int[] SortColumnDirect(
         ColumnName? orderBy,
         bool isDescending,
         ColumnName? groupBy,
-        bool isGroupDescending)
+        bool isGroupDescending,
+        CancellationToken cancellationToken = default)
     {
         ArgumentNullException.ThrowIfNull(reader);
 
-        int[] result = survivors.ToArray();
+        int[] result = [.. survivors];
 
         if (result.Length < 2) { return result; }
 
-        var keys = ColumnDirectKeys.Materialize(reader, orderBy, groupBy);
+        var keys = ColumnDirectKeys.Materialize(reader, orderBy, groupBy, cancellationToken);
         Comparison<int> comparison = keys.BuildComparison(orderBy, isDescending, groupBy, isGroupDescending);
+        cancellationToken.ThrowIfCancellationRequested();
         Array.Sort(result, comparison);
+        cancellationToken.ThrowIfCancellationRequested();
 
         return result;
     }
 
-    /// <summary>
-    ///     The flat, physical-row-indexed columns the sort chain reads: numeric columns as value + present flags, the
-    ///     ActivityId column as Guid + present flags, and string columns as a precomputed ordinal rank per row (pooled columns
-    ///     share one ranking scoped to the distinct pool indices those columns actually use; Keywords is dense-ranked from its
-    ///     joined text). OwningLog and RecordId are always materialized because every tie-break chain reads them; DateAndTime
-    ///     is materialized only when the selected chain reads it.
-    /// </summary>
     private sealed class ColumnDirectKeys
     {
         private static readonly int s_columnCount = Enum.GetValues<ColumnName>().Length;
@@ -65,25 +61,21 @@ private ColumnDirectKeys(int count)
 
         private int Count { get; }
 
-        internal static ColumnDirectKeys Materialize(IEventColumnReader reader, ColumnName? orderBy, ColumnName? groupBy)
+        internal static ColumnDirectKeys Materialize(
+            IEventColumnReader reader, ColumnName? orderBy, ColumnName? groupBy, CancellationToken cancellationToken)
         {
             var keys = new ColumnDirectKeys(reader.Count);
 
-            // RecordId and OwningLog feed every chain's tie-break, so always materialize them. DateAndTime is read only by
-            // the ungrouped default chain, an explicit DateAndTime order, or a grouped chain's within-fallback, so skip its
-            // column copy for an ungrouped sort with an explicit non-DateAndTime order.
-            keys.MaterializeColumn(reader, ColumnName.RecordId);
-            keys.MaterializeOwningLog(reader);
+            keys.MaterializeColumn(reader, ColumnName.RecordId, cancellationToken);
+            keys.MaterializeOwningLog(reader, cancellationToken);
 
-            if (groupBy is not null || orderBy is null) { keys.MaterializeColumn(reader, ColumnName.DateAndTime); }
+            if (groupBy is not null || orderBy is null) { keys.MaterializeColumn(reader, ColumnName.DateAndTime, cancellationToken); }
 
-            if (orderBy is { } orderColumn) { keys.MaterializeColumn(reader, orderColumn); }
+            if (orderBy is { } orderColumn) { keys.MaterializeColumn(reader, orderColumn, cancellationToken); }
 
-            if (groupBy is { } groupColumn) { keys.MaterializeColumn(reader, groupColumn); }
+            if (groupBy is { } groupColumn) { keys.MaterializeColumn(reader, groupColumn, cancellationToken); }
 
-            // Rank OwningLog and any pooled order/group column over ONLY the distinct pool indices they use, so the ordinal
-            // string sort costs O(used distinct) rather than O(whole pool).
-            keys.RankPooledColumns(reader);
+            keys.RankPooledColumns(reader, cancellationToken);
 
             return keys;
         }
@@ -104,22 +96,26 @@ internal Comparison<int> BuildComparison(
 
             if (orderBy is null)
             {
-                return isDescending
-                    ? (a, b) => WithIndexTieBreak(DefaultChain(b, a), a, b)
-                    : (a, b) => WithIndexTieBreak(DefaultChain(a, b), a, b);
+                return isDescending ?
+                    (a, b) => WithIndexTieBreak(DefaultChain(b, a), a, b) :
+                    (a, b) => WithIndexTieBreak(DefaultChain(a, b), a, b);
             }
 
             ColumnName orderColumn = orderBy.Value;
 
-            return isDescending
-                ? (a, b) => WithIndexTieBreak(OrderedChain(b, a, orderColumn), a, b)
-                : (a, b) => WithIndexTieBreak(OrderedChain(a, b, orderColumn), a, b);
+            return isDescending ?
+                (a, b) => WithIndexTieBreak(OrderedChain(b, a, orderColumn), a, b) :
+                (a, b) => WithIndexTieBreak(OrderedChain(a, b, orderColumn), a, b);
         }
 
-        private static void CollectUsedPoolIndices(int[] rawPoolIndices, bool[] seen, List<int> used)
+        private static void CollectUsedPoolIndices(int[] rawPoolIndices, bool[] seen, List<int> used, CancellationToken cancellationToken)
         {
+            int scanned = 0;
+
             foreach (int poolIndex in rawPoolIndices)
             {
+                if ((scanned++ & 8191) == 0) { cancellationToken.ThrowIfCancellationRequested(); }
+
                 if (poolIndex >= 0 && !seen[poolIndex])
                 {
                     seen[poolIndex] = true;
@@ -130,20 +126,29 @@ private static void CollectUsedPoolIndices(int[] rawPoolIndices, bool[] seen, Li
 
         private static int CompareRank(int[] rank, int a, int b) => rank[a].CompareTo(rank[b]);
 
-        private static int[] DenseRank(string[] values, int[] rankByPosition)
+        private static int[] DenseRank(string[] values, int[] rankByPosition, CancellationToken cancellationToken)
         {
             int length = values.Length;
             var order = new int[length];
 
-            for (int index = 0; index < length; index++) { order[index] = index; }
+            for (int index = 0; index < length; index++)
+            {
+                if ((index & 8191) == 0) { cancellationToken.ThrowIfCancellationRequested(); }
+
+                order[index] = index;
+            }
 
+            cancellationToken.ThrowIfCancellationRequested();
             Array.Sort(order, (x, y) => string.Compare(values[x], values[y], StringComparison.Ordinal));
+            cancellationToken.ThrowIfCancellationRequested();
 
             int rank = 0;
             rankByPosition[order[0]] = 0;
 
             for (int position = 1; position < length; position++)
             {
+                if ((position & 8191) == 0) { cancellationToken.ThrowIfCancellationRequested(); }
+
                 if (!string.Equals(values[order[position]], values[order[position - 1]], StringComparison.Ordinal))
                 {
                     rank++;
@@ -155,8 +160,6 @@ private static int[] DenseRank(string[] values, int[] rankByPosition)
             return order;
         }
 
-        // The final deterministic tie-break: physical index ascending, applied after the whole chain and never swapped,
-        // so both a descending chain and its ascending index tie-break agree on a strict total order.
         private static int WithIndexTieBreak(int chain, int a, int b) => chain != 0 ? chain : a.CompareTo(b);
 
         private int CompareColumn(ColumnName column, int a, int b) => column switch
@@ -182,7 +185,6 @@ private int CompareNumeric(ColumnName column, int a, int b)
         {
             bool[] has = _numericHas[(int)column]!;
 
-            // Absent sorts first, reproducing Nullable.Compare's null-low ordering (always-present columns fill true).
             if (!has[a] || !has[b]) { return has[a] == has[b] ? 0 : (has[a] ? 1 : -1); }
 
             long[] values = _numericValues[(int)column]!;
@@ -230,8 +232,10 @@ private int GroupedChain(
             return isDescending ? -Math.Sign(within) : within;
         }
 
-        private void MaterializeColumn(IEventColumnReader reader, ColumnName column)
+        private void MaterializeColumn(IEventColumnReader reader, ColumnName column, CancellationToken cancellationToken)
         {
+            cancellationToken.ThrowIfCancellationRequested();
+
             switch (column)
             {
                 case ColumnName.RecordId:
@@ -245,7 +249,7 @@ private void MaterializeColumn(IEventColumnReader reader, ColumnName column)
                     MaterializeGuid(reader, column);
                     break;
                 case ColumnName.Keywords:
-                    MaterializeKeywords(reader);
+                    MaterializeKeywords(reader, cancellationToken);
                     break;
                 default:
                     MaterializePooled(reader, column);
@@ -264,20 +268,21 @@ private void MaterializeGuid(IEventColumnReader reader, ColumnName column)
             _guidHas[(int)column] = has;
         }
 
-        private void MaterializeKeywords(IEventColumnReader reader)
+        private void MaterializeKeywords(IEventColumnReader reader, CancellationToken cancellationToken)
         {
             if (_stringRank[(int)ColumnName.Keywords] is not null) { return; }
 
-            // Keywords is a joined string, not a single pooled column, so fall back to per-row text then dense-rank it.
             var values = new string[Count];
 
             for (int index = 0; index < Count; index++)
             {
+                if ((index & 8191) == 0) { cancellationToken.ThrowIfCancellationRequested(); }
+
                 values[index] = reader.GetField(reader.LocatorAt(index), EventFieldId.KeywordsDisplay).AsString();
             }
 
             var rankByRow = new int[Count];
-            DenseRank(values, rankByRow);
+            DenseRank(values, rankByRow, cancellationToken);
             _stringRank[(int)ColumnName.Keywords] = rankByRow;
         }
 
@@ -292,8 +297,11 @@ private void MaterializeNumeric(IEventColumnReader reader, ColumnName column)
             _numericHas[(int)column] = has;
         }
 
-        private void MaterializeOwningLog(IEventColumnReader reader) =>
+        private void MaterializeOwningLog(IEventColumnReader reader, CancellationToken cancellationToken)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
             reader.CopyPoolIndexColumn(EventFieldId.OwningLog, _owningLogRank);
+        }
 
         private void MaterializePooled(IEventColumnReader reader, ColumnName column)
         {
@@ -302,7 +310,6 @@ private void MaterializePooled(IEventColumnReader reader, ColumnName column)
             var poolIndices = new int[Count];
             reader.CopyPoolIndexColumn(ColumnFieldMap.ToFieldId(column), poolIndices);
 
-            // Store the raw pool indices; RankPooledColumns converts them to ranks once the used-index set is known.
             _stringRank[(int)column] = poolIndices;
             _pooledColumns.Add((int)column);
         }
@@ -310,56 +317,63 @@ private void MaterializePooled(IEventColumnReader reader, ColumnName column)
         private int OrderedChain(int a, int b, ColumnName orderColumn) =>
             WithTieBreak(CompareColumn(orderColumn, a, b), a, b);
 
-        private void RankFromPoolIndices(int[] poolIndices, int[] rankByRow)
+        private void RankFromPoolIndices(int[] poolIndices, int[] rankByRow, CancellationToken cancellationToken)
         {
             for (int index = 0; index < poolIndices.Length; index++)
             {
+                if ((index & 8191) == 0) { cancellationToken.ThrowIfCancellationRequested(); }
+
                 int poolIndex = poolIndices[index];
                 rankByRow[index] = poolIndex < 0 ? _nullRank : _rankByPoolIndex[poolIndex];
             }
         }
 
-        private void RankPooledColumns(IEventColumnReader reader)
+        private void RankPooledColumns(IEventColumnReader reader, CancellationToken cancellationToken)
         {
             IReadOnlyList<string?> pool = reader.Pool;
             int poolCount = pool.Count;
             _rankByPoolIndex = poolCount == 0 ? [] : new int[poolCount];
 
-            // Gather only the distinct pool indices the touched pooled columns actually use (OwningLog plus any pooled
-            // order/group column), so the ordinal sort below runs over that small set instead of the whole pool.
             var seen = new bool[poolCount];
             var used = new List<int>();
-            CollectUsedPoolIndices(_owningLogRank, seen, used);
+            CollectUsedPoolIndices(_owningLogRank, seen, used, cancellationToken);
 
-            foreach (int columnIndex in _pooledColumns) { CollectUsedPoolIndices(_stringRank[columnIndex]!, seen, used); }
+            foreach (int columnIndex in _pooledColumns) { CollectUsedPoolIndices(_stringRank[columnIndex]!, seen, used, cancellationToken); }
 
             if (used.Count == 0)
             {
-                // Every touched pooled value is absent, so the rows tie on it; a null reads as the empty string.
                 _nullRank = -1;
             }
             else
             {
                 var usedStrings = new string[used.Count];
 
-                for (int index = 0; index < used.Count; index++) { usedStrings[index] = pool[used[index]] ?? string.Empty; }
+                for (int index = 0; index < used.Count; index++)
+                {
+                    if ((index & 8191) == 0) { cancellationToken.ThrowIfCancellationRequested(); }
+
+                    usedStrings[index] = pool[used[index]] ?? string.Empty;
+                }
 
                 var rankByPosition = new int[used.Count];
-                int[] order = DenseRank(usedStrings, rankByPosition);
+                int[] order = DenseRank(usedStrings, rankByPosition, cancellationToken);
+
+                for (int index = 0; index < used.Count; index++)
+                {
+                    if ((index & 8191) == 0) { cancellationToken.ThrowIfCancellationRequested(); }
 
-                for (int index = 0; index < used.Count; index++) { _rankByPoolIndex[used[index]] = rankByPosition[index]; }
+                    _rankByPoolIndex[used[index]] = rankByPosition[index];
+                }
 
-                // Absent (-1) reads as "". It shares rank 0 when "" is among the used values (the ordinal minimum);
-                // otherwise it sorts below every present value.
                 _nullRank = usedStrings[order[0]].Length == 0 ? 0 : -1;
             }
 
-            RankFromPoolIndices(_owningLogRank, _owningLogRank);
+            RankFromPoolIndices(_owningLogRank, _owningLogRank, cancellationToken);
 
             foreach (int columnIndex in _pooledColumns)
             {
                 int[] columnRanks = _stringRank[columnIndex]!;
-                RankFromPoolIndices(columnRanks, columnRanks);
+                RankFromPoolIndices(columnRanks, columnRanks, cancellationToken);
             }
         }
 
diff --git a/src/EventLogExpert.Runtime/LogTable/DisplayIndicatorGate.cs b/src/EventLogExpert.Runtime/LogTable/DisplayIndicatorGate.cs
new file mode 100644
index 000000000..6cf3bfb98
--- /dev/null
+++ b/src/EventLogExpert.Runtime/LogTable/DisplayIndicatorGate.cs
@@ -0,0 +1,142 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+namespace EventLogExpert.Runtime.LogTable;
+
+public sealed class DisplayIndicatorGate : IDisposable
+{
+    private const int ActiveIndicatorHistory = 16;
+    public static readonly TimeSpan OnsetDelay = TimeSpan.FromMilliseconds(200);
+    private readonly List<ActiveIndicator> _activeIndicators = [];
+
+    private readonly Func<TimeSpan, CancellationToken, Task> _delay;
+    private readonly Lock _gate = new();
+    private readonly IOrderedViewSource _source;
+
+    private bool _disposed;
+    private long _generation;
+    private CancellationTokenSource? _onset;
+
+    public DisplayIndicatorGate(IOrderedViewSource source, Func<TimeSpan, CancellationToken, Task>? delay = null)
+    {
+        _source = source;
+        _delay = delay ?? Task.Delay;
+
+        _source.Updated += Observe;
+
+        Observe(_source.Current);
+    }
+
+    public event Action? OnsetElapsed;
+
+    public void Dispose()
+    {
+        CancellationTokenSource? onset;
+
+        lock (_gate)
+        {
+            if (_disposed) { return; }
+
+            _disposed = true;
+            onset = _onset;
+            _onset = null;
+        }
+
+        _source.Updated -= Observe;
+
+        onset?.Cancel();
+        onset?.Dispose();
+    }
+
+    public bool IsFiredFor(DisplayIndicatorKind kind, long paintedRevision)
+    {
+        if (kind == DisplayIndicatorKind.None) { return false; }
+
+        lock (_gate)
+        {
+            foreach (var indicator in _activeIndicators)
+            {
+                if (indicator.Kind == kind && indicator.ArmedRevision <= paintedRevision) { return indicator.Fired; }
+            }
+
+            return false;
+        }
+    }
+
+    private void Observe(OrderedViewPresentation presentation)
+    {
+        CancellationTokenSource? superseded;
+        ActiveIndicator armed;
+        CancellationToken onsetToken;
+
+        lock (_gate)
+        {
+            if (_disposed) { return; }
+
+            var kind = presentation.IndicatorKind;
+
+            if (_activeIndicators.Count > 0 && _activeIndicators[0].Kind == kind) { return; }
+
+            superseded = _onset;
+            _onset = null;
+
+            armed = new ActiveIndicator(kind, ++_generation, presentation.Revision);
+
+            _activeIndicators.Insert(0, armed);
+
+            if (_activeIndicators.Count > ActiveIndicatorHistory) { _activeIndicators.RemoveAt(_activeIndicators.Count - 1); }
+
+            if (kind == DisplayIndicatorKind.None)
+            {
+                superseded?.Cancel();
+                superseded?.Dispose();
+
+                return;
+            }
+
+            _onset = new CancellationTokenSource();
+            onsetToken = _onset.Token;
+        }
+
+        superseded?.Cancel();
+        superseded?.Dispose();
+
+        _ = RunOnsetAsync(armed, onsetToken);
+    }
+
+    private async Task RunOnsetAsync(ActiveIndicator indicator, CancellationToken token)
+    {
+        try
+        {
+            await _delay(OnsetDelay, token).ConfigureAwait(false);
+        }
+        catch (OperationCanceledException) { return; }
+        catch (ObjectDisposedException)
+        {
+            /* The onset CTS was disposed by a concurrent Dispose()/supersede; treat as cancelled. */
+            return;
+        }
+
+        lock (_gate)
+        {
+            if (_disposed) { return; }
+
+            if (_activeIndicators.Count == 0 || _activeIndicators[0].Generation != indicator.Generation) { return; }
+
+            indicator.Fired = true;
+        }
+
+        OnsetElapsed?.Invoke();
+    }
+
+    private sealed class ActiveIndicator(DisplayIndicatorKind kind, long generation, long armedRevision)
+    {
+        public long ArmedRevision { get; } = armedRevision;
+
+        public bool Fired { get; set; }
+
+        public long Generation { get; } = generation;
+
+        public DisplayIndicatorKind Kind { get; } = kind;
+    }
+}
diff --git a/src/EventLogExpert.Runtime/LogTable/ToggleLoadingAction.cs b/src/EventLogExpert.Runtime/LogTable/DisplayIndicatorKind.cs
similarity index 54%
rename from src/EventLogExpert.Runtime/LogTable/ToggleLoadingAction.cs
rename to src/EventLogExpert.Runtime/LogTable/DisplayIndicatorKind.cs
index 68987d47f..f83a5528f 100644
--- a/src/EventLogExpert.Runtime/LogTable/ToggleLoadingAction.cs
+++ b/src/EventLogExpert.Runtime/LogTable/DisplayIndicatorKind.cs
@@ -1,8 +1,15 @@
 // // Copyright (c) Microsoft Corporation.
 // // Licensed under the MIT License.
 
-using EventLogExpert.Eventing.Common.EventLogs;
-
 namespace EventLogExpert.Runtime.LogTable;
 
-public sealed record ToggleLoadingAction(EventLogId LogId);
+public enum DisplayIndicatorKind
+{
+    None,
+
+    EmptyPending,
+
+    ReorderPending,
+
+    Fault
+}
diff --git a/src/EventLogExpert.Runtime/LogTable/DisplayIndicatorState.cs b/src/EventLogExpert.Runtime/LogTable/DisplayIndicatorState.cs
new file mode 100644
index 000000000..44715a557
--- /dev/null
+++ b/src/EventLogExpert.Runtime/LogTable/DisplayIndicatorState.cs
@@ -0,0 +1,131 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+namespace EventLogExpert.Runtime.LogTable;
+
+public sealed class DisplayIndicatorState : IDisposable
+{
+    public static readonly TimeSpan MinimumVisible = TimeSpan.FromMilliseconds(300);
+
+    private readonly Func<TimeSpan, CancellationToken, Task> _delay;
+    private readonly DisplayIndicatorGate _gate;
+    private readonly Action _requestRender;
+    private readonly Lock _sync = new();
+
+    private bool _disposed;
+    private CancellationTokenSource? _floor;
+    private long _floorGeneration;
+    private bool _floorHolding;
+    private bool _spinnerOnScreen;
+
+    public DisplayIndicatorState(
+        DisplayIndicatorGate gate,
+        Action requestRender,
+        Func<TimeSpan, CancellationToken, Task>? delay = null)
+    {
+        _gate = gate;
+        _requestRender = requestRender;
+        _delay = delay ?? Task.Delay;
+
+        _gate.OnsetElapsed += OnGateOnsetElapsed;
+    }
+
+    public void Dispose()
+    {
+        CancellationTokenSource? floor;
+
+        lock (_sync)
+        {
+            if (_disposed) { return; }
+
+            _disposed = true;
+            floor = _floor;
+            _floor = null;
+        }
+
+        _gate.OnsetElapsed -= OnGateOnsetElapsed;
+
+        floor?.Cancel();
+        floor?.Dispose();
+    }
+
+    private void OnGateOnsetElapsed() => _requestRender();
+
+    public void RecordPaint(DisplayedIndicator painted)
+    {
+        CancellationTokenSource? superseded = null;
+        CancellationToken floorToken = default;
+        long generation = 0;
+        bool startFloor = false;
+
+        lock (_sync)
+        {
+            if (_disposed) { return; }
+
+            if (painted.Spinner)
+            {
+                if (_spinnerOnScreen) { return; }
+
+                _spinnerOnScreen = true;
+                _floorHolding = true;
+                superseded = _floor;
+                _floor = new CancellationTokenSource();
+                floorToken = _floor.Token;
+                generation = ++_floorGeneration;
+                startFloor = true;
+            }
+            else
+            {
+                _spinnerOnScreen = false;
+                _floorHolding = false;
+                superseded = _floor;
+                _floor = null;
+            }
+        }
+
+        superseded?.Cancel();
+        superseded?.Dispose();
+
+        if (startFloor) { _ = RunFloorAsync(generation, floorToken); }
+    }
+
+    public DisplayedIndicator Resolve(
+        DisplayIndicatorKind paintedKind,
+        long paintedRevision,
+        bool surfaceStillCatchingUp = false)
+    {
+        if (_gate.IsFiredFor(paintedKind, paintedRevision))
+        {
+            return new DisplayedIndicator(paintedKind, true);
+        }
+
+        bool stillOwed = paintedKind != DisplayIndicatorKind.None;
+
+        lock (_sync)
+        {
+            if (!_spinnerOnScreen) { return DisplayedIndicator.Nothing; }
+
+            return stillOwed || surfaceStillCatchingUp || _floorHolding ?
+                DisplayedIndicator.GenericSpinner :
+                DisplayedIndicator.Nothing;
+        }
+    }
+
+    private async Task RunFloorAsync(long generation, CancellationToken token)
+    {
+        try
+        {
+            await _delay(MinimumVisible, token).ConfigureAwait(false);
+        }
+        catch (OperationCanceledException) { return; }
+
+        lock (_sync)
+        {
+            if (_disposed || _floorGeneration != generation || !_floorHolding) { return; }
+
+            _floorHolding = false;
+        }
+
+        _requestRender();
+    }
+}
diff --git a/src/EventLogExpert.Runtime/LogTable/DisplayOrdering.cs b/src/EventLogExpert.Runtime/LogTable/DisplayOrdering.cs
new file mode 100644
index 000000000..439c6e6c5
--- /dev/null
+++ b/src/EventLogExpert.Runtime/LogTable/DisplayOrdering.cs
@@ -0,0 +1,10 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+namespace EventLogExpert.Runtime.LogTable;
+
+public readonly record struct DisplayOrdering(
+    ColumnName? OrderBy,
+    bool IsDescending,
+    ColumnName? GroupBy,
+    bool IsGroupDescending);
diff --git a/src/EventLogExpert.Runtime/LogTable/DisplayReadyAction.cs b/src/EventLogExpert.Runtime/LogTable/DisplayReadyAction.cs
deleted file mode 100644
index 595057dec..000000000
--- a/src/EventLogExpert.Runtime/LogTable/DisplayReadyAction.cs
+++ /dev/null
@@ -1,15 +0,0 @@
-// // Copyright (c) Microsoft Corporation.
-// // Licensed under the MIT License.
-
-using EventLogExpert.Eventing.Common.EventLogs;
-using System.Collections.Immutable;
-
-namespace EventLogExpert.Runtime.LogTable;
-
-public sealed record DisplayReadyAction
-{
-    internal IReadOnlyDictionary<EventLogId, EventColumnView> Views { get; init; } =
-        ImmutableDictionary<EventLogId, EventColumnView>.Empty;
-
-    internal int Version { get; init; }
-}
diff --git a/src/EventLogExpert.Runtime/LogTable/DisplayViewBuilder.cs b/src/EventLogExpert.Runtime/LogTable/DisplayViewBuilder.cs
deleted file mode 100644
index 03079d8c9..000000000
--- a/src/EventLogExpert.Runtime/LogTable/DisplayViewBuilder.cs
+++ /dev/null
@@ -1,27 +0,0 @@
-// // Copyright (c) Microsoft Corporation.
-// // Licensed under the MIT License.
-
-using EventLogExpert.Eventing.Common.EventLogs;
-using EventLogExpert.Eventing.Common.Events;
-using EventLogExpert.Filtering.Compilation;
-using EventLogExpert.Filtering.Evaluation;
-
-namespace EventLogExpert.Runtime.LogTable;
-
-internal static class DisplayViewBuilder
-{
-    internal static EventColumnView Build(
-        EventColumnStore store,
-        EventLogId logId,
-        Filter filter,
-        SortContext context)
-    {
-        ArgumentNullException.ThrowIfNull(store);
-
-        var reader = store.CreateReader(logId);
-        var survivors = FilterService.GetSurvivingOrder(reader, filter);
-        int[] order = survivors as int[] ?? [.. survivors];
-
-        return EventColumnView.Create(reader, order, context);
-    }
-}
diff --git a/src/EventLogExpert.Runtime/LogTable/DisplayedIndicator.cs b/src/EventLogExpert.Runtime/LogTable/DisplayedIndicator.cs
new file mode 100644
index 000000000..5ce372d6e
--- /dev/null
+++ b/src/EventLogExpert.Runtime/LogTable/DisplayedIndicator.cs
@@ -0,0 +1,11 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+namespace EventLogExpert.Runtime.LogTable;
+
+public readonly record struct DisplayedIndicator(DisplayIndicatorKind Sentence, bool Spinner)
+{
+    public static DisplayedIndicator Nothing { get; } = new(DisplayIndicatorKind.None, false);
+
+    public static DisplayedIndicator GenericSpinner { get; } = new(DisplayIndicatorKind.None, true);
+}
diff --git a/src/EventLogExpert.Runtime/LogTable/Effects.cs b/src/EventLogExpert.Runtime/LogTable/Effects.cs
index c1e62b3a0..b5f542550 100644
--- a/src/EventLogExpert.Runtime/LogTable/Effects.cs
+++ b/src/EventLogExpert.Runtime/LogTable/Effects.cs
@@ -10,10 +10,12 @@ internal sealed class Effects(
     ILogTablePreferencesProvider preferencesProvider,
     IState<LogTableState> logTableState,
     ILogTableColumnDefaultsProvider columnDefaults,
-    IColumnResetMigrator columnResetMigrator)
+    IColumnResetMigrator columnResetMigrator,
+    GroupCollapseNotifier groupCollapseNotifier)
 {
     private readonly ILogTableColumnDefaultsProvider _columnDefaults = columnDefaults;
     private readonly IColumnResetMigrator _columnResetMigrator = columnResetMigrator;
+    private readonly GroupCollapseNotifier _groupCollapseNotifier = groupCollapseNotifier;
     private readonly IState<LogTableState> _logTableState = logTableState;
     private readonly ILogTablePreferencesProvider _preferencesProvider = preferencesProvider;
 
@@ -41,7 +43,6 @@ public Task HandleLoadColumns(IDispatcher dispatcher)
     [EffectMethod]
     public Task HandleReorderColumn(ReorderColumnAction action, IDispatcher dispatcher)
     {
-        // Read from post-reducer state to avoid race conditions with rapid reorder actions
         _preferencesProvider.ColumnOrderPreference = _logTableState.Value.ColumnOrder;
 
         return Task.CompletedTask;
@@ -68,10 +69,17 @@ public Task HandleResetColumnDefaults(IDispatcher dispatcher)
         return Task.CompletedTask;
     }
 
+    [EffectMethod(typeof(SetAllGroupsCollapsedAction))]
+    public Task HandleSetAllGroupsCollapsed(IDispatcher dispatcher)
+    {
+        _groupCollapseNotifier.Raise();
+
+        return Task.CompletedTask;
+    }
+
     [EffectMethod]
     public Task HandleSetColumnWidth(SetColumnWidthAction action, IDispatcher dispatcher)
     {
-        // Read from post-reducer state to avoid race conditions
         _preferencesProvider.ColumnWidthsPreference = new Dictionary<ColumnName, int>(_logTableState.Value.ColumnWidths);
 
         return Task.CompletedTask;
@@ -110,7 +118,6 @@ private ImmutableList<ColumnName> BuildOrder()
             return _columnDefaults.ColumnOrder;
         }
 
-        // Start with saved order, then append any new columns not in saved order
         var allColumns = Enum.GetValues<ColumnName>().ToHashSet();
         var ordered = savedOrder.Where(allColumns.Contains).ToList();
         var missing = _columnDefaults.ColumnOrder.Where(c => !ordered.Contains(c));
diff --git a/src/EventLogExpert.Runtime/LogTable/EmptyColumnView.cs b/src/EventLogExpert.Runtime/LogTable/EmptyColumnView.cs
new file mode 100644
index 000000000..0e6733569
--- /dev/null
+++ b/src/EventLogExpert.Runtime/LogTable/EmptyColumnView.cs
@@ -0,0 +1,213 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.Events;
+using EventLogExpert.Filtering.Persistence;
+using System.Diagnostics.CodeAnalysis;
+
+namespace EventLogExpert.Runtime.LogTable;
+
+internal sealed class EmptyColumnView : IEventColumnView
+{
+    private static readonly DisplayRow[] s_noRows = [];
+
+    public int Count => 0;
+
+    internal static EmptyColumnView Instance { get; } = new();
+
+    public void BucketTimeTicksByEventData(
+        long minTicks,
+        long bucketSpanTicks,
+        int bucketCount,
+        string fieldName,
+        long[] targetCodes,
+        int[] slotCounts,
+        CancellationToken cancellationToken) { }
+
+    public void BucketTimeTicksByEventDataHResult(
+        long minTicks,
+        long bucketSpanTicks,
+        int bucketCount,
+        string fieldName,
+        IReadOnlyCollection<string> eligibleProviders,
+        IReadOnlyList<string> userDataErrorCodePaths,
+        long[] targetCodes,
+        int[] slotCounts,
+        CancellationToken cancellationToken) { }
+
+    public void BucketTimeTicksByEventDataHResultWithTie(
+        byte[] highlightWinners,
+        uint[] slotColorMask,
+        long minTicks,
+        long bucketSpanTicks,
+        int bucketCount,
+        string fieldName,
+        IReadOnlyCollection<string> eligibleProviders,
+        IReadOnlyList<string> userDataErrorCodePaths,
+        long[] targetCodes,
+        int[] slotCounts,
+        CancellationToken cancellationToken) { }
+
+    public void BucketTimeTicksByEventDataString(
+        long minTicks,
+        long bucketSpanTicks,
+        int bucketCount,
+        string[] candidateFields,
+        IReadOnlyDictionary<string, int> rawValueToSlot,
+        int slotCount,
+        int[] slotCounts,
+        CancellationToken cancellationToken) { }
+
+    public void BucketTimeTicksByEventDataStringWithTie(
+        byte[] highlightWinners,
+        uint[] slotColorMask,
+        long minTicks,
+        long bucketSpanTicks,
+        int bucketCount,
+        string[] candidateFields,
+        IReadOnlyDictionary<string, int> rawValueToSlot,
+        int slotCount,
+        int[] slotCounts,
+        CancellationToken cancellationToken) { }
+
+    public void BucketTimeTicksByEventDataWithTie(
+        byte[] highlightWinners,
+        uint[] slotColorMask,
+        long minTicks,
+        long bucketSpanTicks,
+        int bucketCount,
+        string fieldName,
+        long[] targetCodes,
+        int[] slotCounts,
+        CancellationToken cancellationToken) { }
+
+    public void BucketTimeTicksByEventId(
+        long minTicks,
+        long bucketSpanTicks,
+        int bucketCount,
+        int[] targetIds,
+        int[] slotCounts,
+        CancellationToken cancellationToken) { }
+
+    public void BucketTimeTicksByEventIdWithTie(
+        byte[] highlightWinners,
+        uint[] slotColorMask,
+        long minTicks,
+        long bucketSpanTicks,
+        int bucketCount,
+        int[] targetIds,
+        int[] slotCounts,
+        CancellationToken cancellationToken) { }
+
+    public void BucketTimeTicksByField(
+        long minTicks,
+        long bucketSpanTicks,
+        int bucketCount,
+        EventFieldId field,
+        string[] targetValues,
+        int[] slotCounts,
+        CancellationToken cancellationToken) { }
+
+    public void BucketTimeTicksByFieldWithTie(
+        byte[] highlightWinners,
+        uint[] slotColorMask,
+        long minTicks,
+        long bucketSpanTicks,
+        int bucketCount,
+        EventFieldId field,
+        string[] targetValues,
+        int[] slotCounts,
+        CancellationToken cancellationToken) { }
+
+    public void BucketTimeTicksBySeverity(
+        long minTicks,
+        long bucketSpanTicks,
+        int bucketCount,
+        int[] slotCounts,
+        CancellationToken cancellationToken) { }
+
+    public void BucketTimeTicksBySeverityWithTie(
+        byte[] highlightWinners,
+        uint[] slotColorMask,
+        long minTicks,
+        long bucketSpanTicks,
+        int bucketCount,
+        int[] slotCounts,
+        CancellationToken cancellationToken) { }
+
+    public void CountEventDataHResults(
+        string fieldName,
+        IReadOnlyCollection<string> eligibleProviders,
+        IReadOnlyList<string> userDataErrorCodePaths,
+        IDictionary<long, int> counts,
+        CancellationToken cancellationToken) { }
+
+    public void CountEventDataStringValues(
+        string[] candidateFields,
+        IDictionary<string, int> counts,
+        CancellationToken cancellationToken) { }
+
+    public void CountEventDataValues(
+        string fieldName,
+        IDictionary<long, int> counts,
+        CancellationToken cancellationToken) { }
+
+    public void CountEventIds(IDictionary<int, int> counts, CancellationToken cancellationToken) { }
+
+    public void CountFieldValues(EventFieldId field, IDictionary<string, int> counts, CancellationToken cancellationToken) { }
+
+    public byte[] EnsureHighlightWinners(
+        IReadOnlyList<SavedFilter> orderedColoredFilters,
+        int planKey,
+        CancellationToken cancellationToken) => new byte[1];
+
+    public IEnumerable<ResolvedEvent> EnumerateDetail() => [];
+
+    public IEnumerable<ResolvedEvent> EnumerateDetailLean() => [];
+
+    public ResolvedEvent GetDetail(EventLocator locator) => throw NotAMember(locator);
+
+    public ResolvedEvent GetDetailLean(EventLocator locator) => throw NotAMember(locator);
+
+    public string GroupKeyAt(EventLocator locator, ColumnName column) => throw NotAMember(locator);
+
+    public EventLocator LocatorAt(int index) => throw new ArgumentOutOfRangeException(nameof(index));
+
+    public int Rank(EventLocator locator) => -1;
+
+    public EventLocator? ResolveByKey(ValueKey key) => null;
+
+    public IReadOnlyList<DisplayRow> Slice(int start, int count)
+    {
+        if (start < 0) { throw new ArgumentOutOfRangeException(nameof(start)); }
+
+        if (count < 0) { throw new ArgumentOutOfRangeException(nameof(count)); }
+
+        return s_noRows;
+    }
+
+    public bool TryGetDetail(EventLocator locator, [NotNullWhen(true)] out ResolvedEvent? detail)
+    {
+        detail = null;
+
+        return false;
+    }
+
+    public bool TryGetTimeTicks(EventLocator locator, out long ticks)
+    {
+        ticks = 0;
+
+        return false;
+    }
+
+    public bool TryGetTimeTicksRange(out long minTicks, out long maxTicks, CancellationToken cancellationToken)
+    {
+        minTicks = 0;
+        maxTicks = 0;
+
+        return false;
+    }
+
+    private static KeyNotFoundException NotAMember(EventLocator locator) =>
+        new($"Locator log id '{locator.LogId}' is not a member of this combined view.");
+}
diff --git a/src/EventLogExpert.Runtime/LogTable/EventDetailResolver.cs b/src/EventLogExpert.Runtime/LogTable/EventDetailResolver.cs
new file mode 100644
index 000000000..fa9084959
--- /dev/null
+++ b/src/EventLogExpert.Runtime/LogTable/EventDetailResolver.cs
@@ -0,0 +1,30 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.Events;
+using Fluxor;
+using System.Diagnostics.CodeAnalysis;
+
+namespace EventLogExpert.Runtime.LogTable;
+
+internal sealed class EventDetailResolver(IState<RawEventStoreState> rawEventStore) : IEventDetailResolver
+{
+    private readonly IState<RawEventStoreState> _rawEventStore = rawEventStore;
+
+    public bool TryResolve(EventLocator locator, [NotNullWhen(true)] out ResolvedEvent? detail)
+    {
+        detail = null;
+
+        if (!_rawEventStore.Value.ByLog.TryGetValue(locator.LogId, out var store)) { return false; }
+
+        var reader = store.CreateReader(locator.LogId);
+
+        if (locator.Generation != reader.Generation) { return false; }
+
+        if (locator.Index < 0 || locator.Index >= reader.Count) { return false; }
+
+        detail = reader.GetDetail(locator);
+
+        return true;
+    }
+}
diff --git a/src/EventLogExpert.Runtime/LogTable/FilteredLogPresenceCoordinator.cs b/src/EventLogExpert.Runtime/LogTable/FilteredLogPresenceCoordinator.cs
new file mode 100644
index 000000000..ed71d9eea
--- /dev/null
+++ b/src/EventLogExpert.Runtime/LogTable/FilteredLogPresenceCoordinator.cs
@@ -0,0 +1,324 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
+using EventLogExpert.Filtering.Compilation;
+using EventLogExpert.Filtering.Evaluation;
+using EventLogExpert.Runtime.EventLog;
+using Fluxor;
+using System.Collections.Immutable;
+using IDispatcher = Fluxor.IDispatcher;
+
+namespace EventLogExpert.Runtime.LogTable;
+
+internal sealed class FilteredLogPresenceCoordinator : IDisposable
+{
+    private readonly EventLogConcurrencyState _concurrencyState;
+    private readonly HashSet<EventLogId> _dirty = [];
+    private readonly IDispatcher _dispatcher;
+    private readonly IState<EventLogState> _eventLogState;
+    private readonly Lock _gate = new();
+    private readonly IState<FilteredLogPresenceState> _presenceState;
+    private readonly IState<RawEventStoreState> _rawEventStore;
+
+    private readonly bool _scanInline;
+
+    internal Action? OnBatchDrainedForTest { get; set; }
+
+    private readonly Dictionary<EventLogId, ScanPosition> _scanPositions = [];
+
+    private bool _disposed;
+    private long _filterVersion;
+    private bool _scanRunning;
+
+    public FilteredLogPresenceCoordinator(
+        IDispatcher dispatcher,
+        IState<EventLogState> eventLogState,
+        IState<RawEventStoreState> rawEventStore,
+        IState<FilteredLogPresenceState> presenceState,
+        EventLogConcurrencyState concurrencyState)
+        : this(dispatcher, eventLogState, rawEventStore, presenceState, concurrencyState, scanInline: false) { }
+
+    internal FilteredLogPresenceCoordinator(
+        IDispatcher dispatcher,
+        IState<EventLogState> eventLogState,
+        IState<RawEventStoreState> rawEventStore,
+        IState<FilteredLogPresenceState> presenceState,
+        EventLogConcurrencyState concurrencyState,
+        bool scanInline)
+    {
+        ArgumentNullException.ThrowIfNull(dispatcher);
+        ArgumentNullException.ThrowIfNull(eventLogState);
+        ArgumentNullException.ThrowIfNull(rawEventStore);
+        ArgumentNullException.ThrowIfNull(presenceState);
+        ArgumentNullException.ThrowIfNull(concurrencyState);
+
+        _dispatcher = dispatcher;
+        _eventLogState = eventLogState;
+        _rawEventStore = rawEventStore;
+        _presenceState = presenceState;
+        _concurrencyState = concurrencyState;
+        _scanInline = scanInline;
+    }
+
+    public void Discard(EventLogId logId)
+    {
+        lock (_gate)
+        {
+            _dirty.Remove(logId);
+            _scanPositions.Remove(logId);
+        }
+
+        ScheduleScan();
+    }
+
+    public void DiscardAll()
+    {
+        lock (_gate)
+        {
+            _dirty.Clear();
+            _scanPositions.Clear();
+        }
+    }
+
+    public void Dispose()
+    {
+        lock (_gate)
+        {
+            if (_disposed) { return; }
+
+            _disposed = true;
+            _dirty.Clear();
+            _scanPositions.Clear();
+        }
+    }
+
+    public void MarkAppended(IEnumerable<EventLogId> logIds)
+    {
+        ArgumentNullException.ThrowIfNull(logIds);
+
+        lock (_gate)
+        {
+            if (_disposed) { return; }
+
+            foreach (var logId in logIds) { _dirty.Add(logId); }
+        }
+
+        ScheduleScan();
+    }
+
+    public void MarkFilterChanged()
+    {
+        ImmutableArray<EventLogId> openLogs = [.. _eventLogState.Value.OpenLogs.Values.Select(log => log.Id)];
+        long filterVersion;
+
+        lock (_gate)
+        {
+            if (_disposed) { return; }
+
+            filterVersion = ++_filterVersion;
+            _scanPositions.Clear();
+            _dirty.Clear();
+        }
+
+        _dispatcher.Dispatch(new FilteredPresenceInvalidatedAction(filterVersion, openLogs));
+
+        lock (_gate)
+        {
+            if (_disposed) { return; }
+
+            foreach (var logId in openLogs) { _dirty.Add(logId); }
+        }
+
+        ScheduleScan();
+    }
+
+    public void MarkRebuilt(EventLogId logId)
+    {
+        lock (_gate)
+        {
+            if (_disposed) { return; }
+
+            _scanPositions.Remove(logId);
+            _dirty.Add(logId);
+        }
+
+        ScheduleScan();
+    }
+
+    private static bool ScanFrom(
+        EventColumnStore store,
+        EventLogId logId,
+        int start,
+        Func<IEventColumnReader, EventLocator, bool> survives)
+    {
+        var reader = store.CreateReader(logId);
+        int count = reader.Count;
+
+        for (int index = start; index < count; index++)
+        {
+            if (survives(reader, reader.LocatorAt(index))) { return true; }
+        }
+
+        return false;
+    }
+
+    private ImmutableArray<KeyValuePair<EventLogId, FilteredLogPresence>> Evaluate(EventLogId[] batch, long filterVersion)
+    {
+        var eventLogState = _eventLogState.Value;
+        Filter filter = eventLogState.AppliedFilter;
+
+        if (XmlDeferralActive(eventLogState))
+        {
+            lock (_gate)
+            {
+                if (!_disposed) { foreach (var logId in batch) { _dirty.Add(logId); } }
+            }
+
+            return [];
+        }
+
+        var openIds = eventLogState.OpenLogs.Values.Select(log => log.Id).ToHashSet();
+        var stores = _rawEventStore.Value.ByLog;
+        var presenceSnapshot = _presenceState.Value;
+        var known = presenceSnapshot.ByLog;
+        bool knownReflectsCurrentFilter = presenceSnapshot.FilterVersion == filterVersion;
+        var results = ImmutableArray.CreateBuilder<KeyValuePair<EventLogId, FilteredLogPresence>>(batch.Length);
+
+        Func<IEventColumnReader, EventLocator, bool>? survives = null;
+
+        foreach (var logId in batch)
+        {
+            lock (_gate)
+            {
+                if (_disposed || filterVersion != _filterVersion) { return []; }
+            }
+
+            if (!openIds.Contains(logId) || !stores.TryGetValue(logId, out var store)) { continue; }
+
+            if (store.Count <= 0)
+            {
+                results.Add(new(logId, FilteredLogPresence.NoSurvivor));
+
+                continue;
+            }
+
+            if (!filter.IsFilteringEnabled)
+            {
+                results.Add(new(logId, FilteredLogPresence.HasSurvivor));
+
+                continue;
+            }
+
+            if (knownReflectsCurrentFilter && known.TryGetValue(logId, out var current) && current == FilteredLogPresence.HasSurvivor) { continue; }
+
+            int start = ResumePoint(logId, store);
+
+            survives ??= FilterService.CompileSurvivorPredicate(filter);
+
+            bool found = ScanFrom(store, logId, start, survives);
+
+            results.Add(new(logId, found ? FilteredLogPresence.HasSurvivor : FilteredLogPresence.NoSurvivor));
+
+            lock (_gate)
+            {
+                if (_disposed || filterVersion != _filterVersion) { return []; }
+
+                if (found) { _scanPositions.Remove(logId); }
+                else { _scanPositions[logId] = new ScanPosition(store.Count, store.Generation); }
+            }
+        }
+
+        return results.ToImmutable();
+    }
+
+    private int ResumePoint(EventLogId logId, EventColumnStore store)
+    {
+        lock (_gate)
+        {
+            if (!_scanPositions.TryGetValue(logId, out var scanPosition)) { return 0; }
+
+            if (scanPosition.Generation != store.Generation || store.Count < scanPosition.ScannedCount)
+            {
+                _scanPositions.Remove(logId);
+
+                return 0;
+            }
+
+            return scanPosition.ScannedCount;
+        }
+    }
+
+    private void RunScanLoop()
+    {
+        while (true)
+        {
+            EventLogId[] batch;
+            long filterVersion;
+
+            lock (_gate)
+            {
+                if (_disposed || _dirty.Count <= 0)
+                {
+                    _scanRunning = false;
+
+                    return;
+                }
+
+                if (XmlDeferralActive(_eventLogState.Value))
+                {
+                    _scanRunning = false;
+
+                    return;
+                }
+
+                batch = [.. _dirty];
+                filterVersion = _filterVersion;
+                _dirty.Clear();
+            }
+
+            OnBatchDrainedForTest?.Invoke();
+
+            try
+            {
+                var verdicts = Evaluate(batch, filterVersion);
+
+                if (verdicts.Length > 0) { _dispatcher.Dispatch(new FilteredPresenceUpdatedAction(filterVersion, verdicts)); }
+            }
+            catch (Exception)
+            {
+                // A faulty survivor predicate or a dispatch failure must not escape this fire-and-forget scan
+                // loop: escaping would leave _scanRunning stuck true and silently wedge every later presence
+                // scan. Drop this batch; a later filter change or append re-dirties the logs and retries.
+            }
+        }
+    }
+
+    private bool XmlDeferralActive(EventLogState eventLogState) =>
+        eventLogState.AppliedFilter.RequiresXml &&
+        eventLogState.OpenLogs.Values.Any(log => !_concurrencyState.IsLoadedWithXml(log.Id));
+
+    private void ScheduleScan()
+    {
+        lock (_gate)
+        {
+            if (_disposed || _scanRunning || _dirty.Count <= 0) { return; }
+
+            if (XmlDeferralActive(_eventLogState.Value)) { return; }
+
+            _scanRunning = true;
+        }
+
+        if (_scanInline)
+        {
+            RunScanLoop();
+
+            return;
+        }
+
+        _ = Task.Run(RunScanLoop);
+    }
+
+    private readonly record struct ScanPosition(int ScannedCount, int Generation);
+}
diff --git a/src/EventLogExpert.Runtime/LogTable/FilteredLogPresenceEffects.cs b/src/EventLogExpert.Runtime/LogTable/FilteredLogPresenceEffects.cs
new file mode 100644
index 000000000..5f6c4b3b5
--- /dev/null
+++ b/src/EventLogExpert.Runtime/LogTable/FilteredLogPresenceEffects.cs
@@ -0,0 +1,68 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Runtime.EventLog;
+using Fluxor;
+using CloseAllLogsAction = EventLogExpert.Runtime.EventLog.CloseAllLogsAction;
+
+namespace EventLogExpert.Runtime.LogTable;
+
+internal sealed class FilteredLogPresenceEffects(FilteredLogPresenceCoordinator coordinator)
+{
+    private readonly FilteredLogPresenceCoordinator _coordinator = coordinator;
+
+    [EffectMethod(typeof(ApplyFilterAction))]
+    public Task HandleApplyFilter(IDispatcher dispatcher)
+    {
+        _coordinator.MarkFilterChanged();
+
+        return Task.CompletedTask;
+    }
+
+    [EffectMethod(typeof(CloseAllLogsAction))]
+    public Task HandleCloseAll(IDispatcher dispatcher)
+    {
+        _coordinator.DiscardAll();
+
+        return Task.CompletedTask;
+    }
+
+    [EffectMethod]
+    public Task HandleCloseLog(CloseLogAction action, IDispatcher dispatcher)
+    {
+        _coordinator.Discard(action.LogId);
+
+        return Task.CompletedTask;
+    }
+
+    [EffectMethod]
+    public Task HandleIngestRawEvents(IngestRawEventsAction action, IDispatcher dispatcher)
+    {
+        if (action.Mode == RawIngestMode.Replace)
+        {
+            foreach (var logId in action.EventsByLog.Keys) { _coordinator.MarkRebuilt(logId); }
+
+            return Task.CompletedTask;
+        }
+
+        _coordinator.MarkAppended(action.EventsByLog.Keys);
+
+        return Task.CompletedTask;
+    }
+
+    [EffectMethod]
+    public Task HandleLoadEvents(LoadEventsAction action, IDispatcher dispatcher)
+    {
+        _coordinator.MarkRebuilt(action.LogData.Id);
+
+        return Task.CompletedTask;
+    }
+
+    [EffectMethod]
+    public Task HandleLoadEventsPartial(LoadEventsPartialAction action, IDispatcher dispatcher)
+    {
+        _coordinator.MarkAppended([action.LogData.Id]);
+
+        return Task.CompletedTask;
+    }
+}
diff --git a/src/EventLogExpert.Runtime/LogTable/FilteredLogPresenceReducers.cs b/src/EventLogExpert.Runtime/LogTable/FilteredLogPresenceReducers.cs
new file mode 100644
index 000000000..8084d9036
--- /dev/null
+++ b/src/EventLogExpert.Runtime/LogTable/FilteredLogPresenceReducers.cs
@@ -0,0 +1,68 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.EventLogs;
+using Fluxor;
+using System.Collections.Immutable;
+using CloseAllLogsAction = EventLogExpert.Runtime.EventLog.CloseAllLogsAction;
+
+namespace EventLogExpert.Runtime.LogTable;
+
+internal sealed class FilteredLogPresenceReducers
+{
+    [ReducerMethod]
+    public static FilteredLogPresenceState ReduceAddTable(FilteredLogPresenceState state, AddTableAction action) =>
+        state with { ByLog = state.ByLog.SetItem(action.LogData.Id, FilteredLogPresence.Pending) };
+
+    [ReducerMethod(typeof(CloseAllLogsAction))]
+    public static FilteredLogPresenceState ReduceCloseAll(FilteredLogPresenceState state) =>
+        state.ByLog.IsEmpty ?
+            state :
+            state with { ByLog = ImmutableDictionary<EventLogId, FilteredLogPresence>.Empty };
+
+    [ReducerMethod]
+    public static FilteredLogPresenceState ReduceCloseLog(FilteredLogPresenceState state, CloseLogAction action)
+    {
+        var remaining = state.ByLog.Remove(action.LogId);
+
+        return ReferenceEquals(remaining, state.ByLog) ? state : state with { ByLog = remaining };
+    }
+
+    [ReducerMethod]
+    public static FilteredLogPresenceState ReduceInvalidated(
+        FilteredLogPresenceState state,
+        FilteredPresenceInvalidatedAction action)
+    {
+        if (action.FilterVersion <= state.FilterVersion) { return state; }
+
+        var builder = state.ByLog.ToBuilder();
+
+        foreach (var logId in action.LogIds)
+        {
+            if (builder.ContainsKey(logId)) { builder[logId] = FilteredLogPresence.Pending; }
+        }
+
+        return state with { ByLog = builder.ToImmutable(), FilterVersion = action.FilterVersion };
+    }
+
+    [ReducerMethod]
+    public static FilteredLogPresenceState ReduceUpdated(
+        FilteredLogPresenceState state,
+        FilteredPresenceUpdatedAction action)
+    {
+        if (action.FilterVersion != state.FilterVersion) { return state; }
+
+        var builder = state.ByLog.ToBuilder();
+        bool changed = false;
+
+        foreach (var (logId, presence) in action.Verdicts)
+        {
+            if (!builder.TryGetValue(logId, out var current) || current == presence) { continue; }
+
+            builder[logId] = presence;
+            changed = true;
+        }
+
+        return changed ? state with { ByLog = builder.ToImmutable() } : state;
+    }
+}
diff --git a/src/EventLogExpert.Runtime/LogTable/FilteredLogPresenceState.cs b/src/EventLogExpert.Runtime/LogTable/FilteredLogPresenceState.cs
new file mode 100644
index 000000000..d9cdd3f54
--- /dev/null
+++ b/src/EventLogExpert.Runtime/LogTable/FilteredLogPresenceState.cs
@@ -0,0 +1,27 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.EventLogs;
+using Fluxor;
+using System.Collections.Immutable;
+
+namespace EventLogExpert.Runtime.LogTable;
+
+public enum FilteredLogPresence
+{
+    Pending,
+    HasSurvivor,
+    NoSurvivor
+}
+
+[FeatureState]
+public sealed record FilteredLogPresenceState
+{
+    public ImmutableDictionary<EventLogId, FilteredLogPresence> ByLog { get; init; } =
+        ImmutableDictionary<EventLogId, FilteredLogPresence>.Empty;
+
+    internal long FilterVersion { get; init; }
+
+    public bool IsKnownEmpty(EventLogId logId) =>
+        ByLog.TryGetValue(logId, out var presence) && presence == FilteredLogPresence.NoSurvivor;
+}
diff --git a/src/EventLogExpert.Runtime/LogTable/UpdateTableAction.cs b/src/EventLogExpert.Runtime/LogTable/FilteredPresenceInvalidatedAction.cs
similarity index 53%
rename from src/EventLogExpert.Runtime/LogTable/UpdateTableAction.cs
rename to src/EventLogExpert.Runtime/LogTable/FilteredPresenceInvalidatedAction.cs
index 9353a59b4..4267e294e 100644
--- a/src/EventLogExpert.Runtime/LogTable/UpdateTableAction.cs
+++ b/src/EventLogExpert.Runtime/LogTable/FilteredPresenceInvalidatedAction.cs
@@ -2,12 +2,8 @@
 // // Licensed under the MIT License.
 
 using EventLogExpert.Eventing.Common.EventLogs;
+using System.Collections.Immutable;
 
 namespace EventLogExpert.Runtime.LogTable;
 
-public sealed record UpdateTableAction(EventLogId LogId)
-{
-    internal EventColumnView? View { get; init; }
-
-    internal int Version { get; init; }
-}
+internal sealed record FilteredPresenceInvalidatedAction(long FilterVersion, ImmutableArray<EventLogId> LogIds);
diff --git a/src/EventLogExpert.Runtime/LogTable/FilteredPresenceUpdatedAction.cs b/src/EventLogExpert.Runtime/LogTable/FilteredPresenceUpdatedAction.cs
new file mode 100644
index 000000000..16bb2ae16
--- /dev/null
+++ b/src/EventLogExpert.Runtime/LogTable/FilteredPresenceUpdatedAction.cs
@@ -0,0 +1,11 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.EventLogs;
+using System.Collections.Immutable;
+
+namespace EventLogExpert.Runtime.LogTable;
+
+internal sealed record FilteredPresenceUpdatedAction(
+    long FilterVersion,
+    ImmutableArray<KeyValuePair<EventLogId, FilteredLogPresence>> Verdicts);
diff --git a/src/EventLogExpert.Runtime/LogTable/GroupCollapseNotifier.cs b/src/EventLogExpert.Runtime/LogTable/GroupCollapseNotifier.cs
new file mode 100644
index 000000000..47af4f428
--- /dev/null
+++ b/src/EventLogExpert.Runtime/LogTable/GroupCollapseNotifier.cs
@@ -0,0 +1,40 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Logging.Abstractions;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace EventLogExpert.Runtime.LogTable;
+
+internal sealed class GroupCollapseNotifier : IGroupCollapseNotifier
+{
+    private readonly ITraceLogger _logger;
+
+    public GroupCollapseNotifier([FromKeyedServices(LogCategories.EventLog)] ITraceLogger logger)
+    {
+        ArgumentNullException.ThrowIfNull(logger);
+
+        _logger = logger;
+    }
+
+    public event Action? Requested;
+
+    public void Raise()
+    {
+        var handlers = Requested;
+
+        if (handlers is null) { return; }
+
+        foreach (var handler in handlers.GetInvocationList().Cast<Action>())
+        {
+            try
+            {
+                handler();
+            }
+            catch (Exception fault)
+            {
+                _logger.Trace($"{nameof(GroupCollapseNotifier)}: a subscriber threw and was isolated: {fault}");
+            }
+        }
+    }
+}
diff --git a/src/EventLogExpert.Runtime/LogTable/AppendTableEventsAction.cs b/src/EventLogExpert.Runtime/LogTable/IActiveEventLogSource.cs
similarity index 57%
rename from src/EventLogExpert.Runtime/LogTable/AppendTableEventsAction.cs
rename to src/EventLogExpert.Runtime/LogTable/IActiveEventLogSource.cs
index b26688910..a6b4be767 100644
--- a/src/EventLogExpert.Runtime/LogTable/AppendTableEventsAction.cs
+++ b/src/EventLogExpert.Runtime/LogTable/IActiveEventLogSource.cs
@@ -2,10 +2,11 @@
 // // Licensed under the MIT License.
 
 using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Runtime.Common.Sources;
 
 namespace EventLogExpert.Runtime.LogTable;
 
-public sealed record AppendTableEventsAction(EventLogId LogId)
+public interface IActiveEventLogSource : IChangeNotifier
 {
-    internal EventColumnView? View { get; init; }
+    EventLogId? Current { get; }
 }
diff --git a/src/EventLogExpert.Runtime/LogTable/IEventColumnView.cs b/src/EventLogExpert.Runtime/LogTable/IEventColumnView.cs
index 8df5566c5..84bc6b7f7 100644
--- a/src/EventLogExpert.Runtime/LogTable/IEventColumnView.cs
+++ b/src/EventLogExpert.Runtime/LogTable/IEventColumnView.cs
@@ -7,19 +7,10 @@
 
 namespace EventLogExpert.Runtime.LogTable;
 
-/// <summary>
-///     The live display facade: a filter-surviving, sorted view over one or more column-backed logs. The viewport
-///     reads rows by display position through <see cref="Slice" />; selection, highlight, and scroll resolve by
-///     <see cref="EventLocator" /> through <see cref="Rank" /> and <see cref="ResolveByKey" />.
-/// </summary>
 public interface IEventColumnView
 {
     int Count { get; }
 
-    /// <summary>
-    ///     Group-by variant keyed on a named EventData field's whole-number code; (targetCodes length + 1) slots per bin,
-    ///     with the trailing "other" slot also absorbing rows that lack the field.
-    /// </summary>
     void BucketTimeTicksByEventData(
         long minTicks,
         long bucketSpanTicks,
@@ -29,13 +20,6 @@ void BucketTimeTicksByEventData(
         int[] slotCounts,
         CancellationToken cancellationToken);
 
-    /// <summary>
-    ///     HRESULT-code variant of <see cref="BucketTimeTicksByEventData" /> for the ErrorCode dimension: only survivors
-    ///     from a provider in <paramref name="eligibleProviders" /> whose <paramref name="fieldName" /> field - or, when that
-    ///     EventData field is absent, whose UserData carries one of the curated <paramref name="userDataErrorCodePaths" />
-    ///     leaves - holds a nonzero 32-bit HRESULT contribute (their target slot, else the trailing "other" slot); every other
-    ///     row is omitted.
-    /// </summary>
     void BucketTimeTicksByEventDataHResult(
         long minTicks,
         long bucketSpanTicks,
@@ -60,7 +44,6 @@ void BucketTimeTicksByEventDataHResultWithTie(
         int[] slotCounts,
         CancellationToken cancellationToken);
 
-    /// <summary>Group-by EventData string variant keyed on the first usable named candidate field value.</summary>
     void BucketTimeTicksByEventDataString(
         long minTicks,
         long bucketSpanTicks,
@@ -94,7 +77,6 @@ void BucketTimeTicksByEventDataWithTie(
         int[] slotCounts,
         CancellationToken cancellationToken);
 
-    /// <summary>Group-by variant keyed on the numeric event id; (targetIds length + 1) slots per bin.</summary>
     void BucketTimeTicksByEventId(
         long minTicks,
         long bucketSpanTicks,
@@ -113,10 +95,6 @@ void BucketTimeTicksByEventIdWithTie(
         int[] slotCounts,
         CancellationToken cancellationToken);
 
-    /// <summary>
-    ///     Group-by variant of <see cref="BucketTimeTicksBySeverity" /> for a pooled string field; (targetValues length +
-    ///     1) slots per bin.
-    /// </summary>
     void BucketTimeTicksByField(
         long minTicks,
         long bucketSpanTicks,
@@ -137,10 +115,6 @@ void BucketTimeTicksByFieldWithTie(
         int[] slotCounts,
         CancellationToken cancellationToken);
 
-    /// <summary>
-    ///     Additively buckets this view's rows by UTC tick and severity slot; bucket-major
-    ///     slotCounts[i*LevelSeverity.SlotCount + slot], out-of-domain ticks clamp to the end buckets.
-    /// </summary>
     void BucketTimeTicksBySeverity(
         long minTicks,
         long bucketSpanTicks,
@@ -157,13 +131,6 @@ void BucketTimeTicksBySeverityWithTie(
         int[] slotCounts,
         CancellationToken cancellationToken);
 
-    /// <summary>
-    ///     HRESULT-code variant of <see cref="CountEventDataValues" /> for the ErrorCode dimension: tallies this view's
-    ///     survivors from a provider in <paramref name="eligibleProviders" /> by the nonzero 32-bit HRESULT in
-    ///     <paramref name="fieldName" /> or, when that EventData field is absent, one of the curated
-    ///     <paramref name="userDataErrorCodePaths" /> UserData leaves (accumulating across a combined view); resolves the
-    ///     top-N failure codes.
-    /// </summary>
     void CountEventDataHResults(
         string fieldName,
         IReadOnlyCollection<string> eligibleProviders,
@@ -171,84 +138,40 @@ void CountEventDataHResults(
         IDictionary<long, int> counts,
         CancellationToken cancellationToken);
 
-    /// <summary>Tallies this view's rows by the first usable string value from the named EventData candidate fields.</summary>
     void CountEventDataStringValues(string[] candidateFields, IDictionary<string, int> counts, CancellationToken cancellationToken);
 
-    /// <summary>
-    ///     Tallies this view's rows by the whole-number code of a named EventData field (accumulating across a combined
-    ///     view, since a numeric code is store-independent); resolves the top-N group-by categories for the histogram.
-    /// </summary>
     void CountEventDataValues(string fieldName, IDictionary<long, int> counts, CancellationToken cancellationToken);
 
-    /// <summary>
-    ///     Tallies this view's rows by numeric event id into <paramref name="counts" /> (accumulating across a combined
-    ///     view).
-    /// </summary>
     void CountEventIds(IDictionary<int, int> counts, CancellationToken cancellationToken);
 
-    /// <summary>
-    ///     Tallies this view's rows by non-empty pooled string value of field (accumulating, so a combined view sums by
-    ///     logical value across logs); resolves the top-N group-by categories.
-    /// </summary>
     void CountFieldValues(EventFieldId field, IDictionary<string, int> counts, CancellationToken cancellationToken);
 
-    /// <summary>
-    ///     Precomputes the highlight "winners" for <paramref name="orderedColoredFilters" /> and returns an OPAQUE,
-    ///     view-specific handle. The result is NOT guaranteed to be a per-row array - a combined view returns a small sentinel
-    ///     handle - so callers MUST NOT index into it or assume its <c>Length</c> equals the row count; it may only be passed
-    ///     back to the <c>*WithTie</c> bucketing APIs on the SAME view instance. <paramref name="planKey" /> lets
-    ///     implementations cache the underlying winner data and skip recomputation while the coloured-filter predicate set is
-    ///     unchanged (the returned handle itself is not guaranteed to be reused).
-    /// </summary>
     byte[] EnsureHighlightWinners(
         IReadOnlyList<SavedFilter> orderedColoredFilters,
         int planKey,
         CancellationToken cancellationToken);
 
-    /// <summary>Full-detail rehydrate of every display row, in display order, for export and clipboard.</summary>
     IEnumerable<ResolvedEvent> EnumerateDetail();
 
+    IEnumerable<ResolvedEvent> EnumerateDetailLean() => EnumerateDetail();
+
     ResolvedEvent GetDetail(EventLocator locator);
 
-    /// <summary>
-    ///     Lean single-row rehydrate (grid scalars plus Description) for the row addressed by <paramref name="locator" />.
-    /// </summary>
     ResolvedEvent GetDetailLean(EventLocator locator);
 
     string GroupKeyAt(EventLocator locator, ColumnName column);
 
     EventLocator LocatorAt(int index);
 
-    /// <summary>
-    ///     The display position of <paramref name="locator" /> in this view, or <c>-1</c> when the locator is not in the
-    ///     view (filtered out) or does not address this view's log generation.
-    /// </summary>
     int Rank(EventLocator locator);
 
-    /// <summary>
-    ///     Re-resolves a stable <see cref="ValueKey" /> to the locator that currently carries it, or <c>null</c> when no
-    ///     surviving row matches (a null-RecordId event never produces a key; a filtered-out row is absent). Drives selection
-    ///     restore across a reload.
-    /// </summary>
     EventLocator? ResolveByKey(ValueKey key);
 
     IReadOnlyList<DisplayRow> Slice(int start, int count);
 
-    /// <summary>
-    ///     Exception-free resolve of <paramref name="locator" /> to its full <see cref="ResolvedEvent" />: <c>false</c>
-    ///     when the locator no longer addresses a live physical row (the log closed, the store rebuilt to a newer generation,
-    ///     or the index is out of range). A valid but filtered-out row still resolves, so a focused selection stays
-    ///     inspectable after a filter hides it.
-    /// </summary>
     bool TryGetDetail(EventLocator locator, [NotNullWhen(true)] out ResolvedEvent? detail);
 
-    /// <summary>
-    ///     Exception-free read of locator's UTC-tick timestamp from the tick column (no rehydrate); false when it no
-    ///     longer addresses a live row. Like TryGetDetail, a filtered-out row still resolves, so in-view callers must also
-    ///     check Rank.
-    /// </summary>
     bool TryGetTimeTicks(EventLocator locator, out long ticks);
 
-    /// <summary>UTC-tick span across this view's rows: true with [minTicks, maxTicks], false when the view is empty.</summary>
     bool TryGetTimeTicksRange(out long minTicks, out long maxTicks, CancellationToken cancellationToken);
 }
diff --git a/src/EventLogExpert.Runtime/LogTable/IEventDetailResolver.cs b/src/EventLogExpert.Runtime/LogTable/IEventDetailResolver.cs
new file mode 100644
index 000000000..d19ab4a41
--- /dev/null
+++ b/src/EventLogExpert.Runtime/LogTable/IEventDetailResolver.cs
@@ -0,0 +1,12 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.Events;
+using System.Diagnostics.CodeAnalysis;
+
+namespace EventLogExpert.Runtime.LogTable;
+
+public interface IEventDetailResolver
+{
+    bool TryResolve(EventLocator locator, [NotNullWhen(true)] out ResolvedEvent? detail);
+}
diff --git a/src/EventLogExpert.Runtime/LogTable/IGroupCollapseNotifier.cs b/src/EventLogExpert.Runtime/LogTable/IGroupCollapseNotifier.cs
new file mode 100644
index 000000000..b24b80c20
--- /dev/null
+++ b/src/EventLogExpert.Runtime/LogTable/IGroupCollapseNotifier.cs
@@ -0,0 +1,9 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+namespace EventLogExpert.Runtime.LogTable;
+
+public interface IGroupCollapseNotifier
+{
+    event Action Requested;
+}
diff --git a/src/EventLogExpert.Runtime/LogTable/ILogTabBarSource.cs b/src/EventLogExpert.Runtime/LogTable/ILogTabBarSource.cs
new file mode 100644
index 000000000..8c6c56179
--- /dev/null
+++ b/src/EventLogExpert.Runtime/LogTable/ILogTabBarSource.cs
@@ -0,0 +1,11 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Runtime.Common.Sources;
+
+namespace EventLogExpert.Runtime.LogTable;
+
+public interface ILogTabBarSource : IChangeNotifier
+{
+    LogTabBarPresentation Current { get; }
+}
diff --git a/src/EventLogExpert.Runtime/LogTable/ILogTableQueries.cs b/src/EventLogExpert.Runtime/LogTable/ILogTableQueries.cs
new file mode 100644
index 000000000..6f6531bc7
--- /dev/null
+++ b/src/EventLogExpert.Runtime/LogTable/ILogTableQueries.cs
@@ -0,0 +1,27 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.EventLogs;
+
+namespace EventLogExpert.Runtime.LogTable;
+
+public interface ILogTableQueries
+{
+    IReadOnlyList<LogTabGroup> GetTabGroups();
+
+    bool HasActiveLogs();
+
+    bool HasMultipleIndividualTabs();
+
+    bool HasOtherTabsInGroup(LogTabGroupId groupId, EventLogId keepTabId);
+
+    bool HasTabGroup(LogTabGroupId groupId);
+
+    bool IsGroupDescending();
+
+    bool IsGrouping();
+
+    bool IsTabOpen(EventLogId tabId);
+
+    bool IsUngroupedTabOpen(EventLogId tabId);
+}
diff --git a/src/EventLogExpert.Runtime/LogTable/IOrderedViewSource.cs b/src/EventLogExpert.Runtime/LogTable/IOrderedViewSource.cs
new file mode 100644
index 000000000..896a5be0e
--- /dev/null
+++ b/src/EventLogExpert.Runtime/LogTable/IOrderedViewSource.cs
@@ -0,0 +1,11 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+namespace EventLogExpert.Runtime.LogTable;
+
+public interface IOrderedViewSource
+{
+    event Action<OrderedViewPresentation> Updated;
+
+    OrderedViewPresentation Current { get; }
+}
diff --git a/src/EventLogExpert.Runtime/LogTable/LogTabBarPresentation.cs b/src/EventLogExpert.Runtime/LogTable/LogTabBarPresentation.cs
new file mode 100644
index 000000000..34c4daea0
--- /dev/null
+++ b/src/EventLogExpert.Runtime/LogTable/LogTabBarPresentation.cs
@@ -0,0 +1,22 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.EventLogs;
+using System.Collections.Immutable;
+
+namespace EventLogExpert.Runtime.LogTable;
+
+public sealed record LogTabBarPresentation
+{
+    public ImmutableList<LogView> Tabs { get; init; } = [];
+
+    public ImmutableList<LogTabGroup> Groups { get; init; } = [];
+
+    public EventLogId? ActiveTabId { get; init; }
+
+    public ImmutableHashSet<EventLogId> KnownEmptyTabIds { get; init; } = ImmutableHashSet<EventLogId>.Empty;
+
+    public bool HasMultipleTabs => Tabs.Count > 1;
+
+    public bool IsKnownEmpty(EventLogId tabId) => KnownEmptyTabIds.Contains(tabId);
+}
diff --git a/src/EventLogExpert.Runtime/LogTable/LogTabBarSource.cs b/src/EventLogExpert.Runtime/LogTable/LogTabBarSource.cs
new file mode 100644
index 000000000..d3179e610
--- /dev/null
+++ b/src/EventLogExpert.Runtime/LogTable/LogTabBarSource.cs
@@ -0,0 +1,125 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Logging.Abstractions;
+using Fluxor;
+using Microsoft.Extensions.DependencyInjection;
+using System.Collections.Immutable;
+
+namespace EventLogExpert.Runtime.LogTable;
+
+internal sealed class LogTabBarSource : ILogTabBarSource, IDisposable
+{
+    private readonly Lock _gate = new();
+    private readonly IState<LogTableState> _logTableState;
+    private readonly ITraceLogger _logger;
+    private readonly IState<FilteredLogPresenceState> _presenceState;
+
+    private LogTabBarPresentation _current;
+    private bool _disposed;
+
+    public LogTabBarSource(
+        IState<LogTableState> logTableState,
+        IState<FilteredLogPresenceState> presenceState,
+        [FromKeyedServices(LogCategories.EventLog)] ITraceLogger logger)
+    {
+        ArgumentNullException.ThrowIfNull(logTableState);
+        ArgumentNullException.ThrowIfNull(presenceState);
+        ArgumentNullException.ThrowIfNull(logger);
+
+        _logTableState = logTableState;
+        _presenceState = presenceState;
+        _logger = logger;
+
+        _current = Project(logTableState.Value, presenceState.Value);
+        _logTableState.StateChanged += OnStateChanged;
+        _presenceState.StateChanged += OnStateChanged;
+
+        lock (_gate) { _current = Project(_logTableState.Value, _presenceState.Value); }
+    }
+
+    public event Action? Changed;
+
+    public LogTabBarPresentation Current
+    {
+        get { lock (_gate) { return _current; } }
+    }
+
+    public void Dispose()
+    {
+        lock (_gate)
+        {
+            if (_disposed) { return; }
+
+            _disposed = true;
+        }
+
+        _logTableState.StateChanged -= OnStateChanged;
+        _presenceState.StateChanged -= OnStateChanged;
+    }
+
+    private static ImmutableHashSet<EventLogId> ComputeKnownEmptyTabIds(
+        LogTableState logTable,
+        FilteredLogPresenceState presence)
+    {
+        var builder = ImmutableHashSet.CreateBuilder<EventLogId>();
+
+        foreach (var table in logTable.EventTables)
+        {
+            if (table.IsCombined || table.IsLoading) { continue; }
+
+            if (presence.IsKnownEmpty(table.Id)) { builder.Add(table.Id); }
+        }
+
+        return builder.ToImmutable();
+    }
+
+    private static bool IsEqual(LogTabBarPresentation next, LogTabBarPresentation current) =>
+        ReferenceEquals(next.Tabs, current.Tabs) &&
+        ReferenceEquals(next.Groups, current.Groups) &&
+        next.ActiveTabId == current.ActiveTabId &&
+        next.KnownEmptyTabIds.SetEquals(current.KnownEmptyTabIds);
+
+    private static LogTabBarPresentation Project(LogTableState logTable, FilteredLogPresenceState presence) =>
+        new()
+        {
+            Tabs = logTable.EventTables,
+            Groups = logTable.Groups,
+            ActiveTabId = logTable.ActiveEventLogId,
+            KnownEmptyTabIds = ComputeKnownEmptyTabIds(logTable, presence)
+        };
+
+    private void OnStateChanged(object? sender, EventArgs e)
+    {
+        var next = Project(_logTableState.Value, _presenceState.Value);
+
+        lock (_gate)
+        {
+            if (_disposed || IsEqual(next, _current)) { return; }
+
+            _current = next;
+        }
+
+        RaiseChanged();
+    }
+
+    private void RaiseChanged()
+    {
+        var handlers = Changed;
+
+        if (handlers is null) { return; }
+
+        foreach (var handler in handlers.GetInvocationList().Cast<Action>())
+        {
+            try
+            {
+                handler();
+            }
+            catch (Exception fault)
+            {
+                _logger.Trace($"{nameof(LogTabBarSource)}: a subscriber threw and was isolated: {fault}");
+            }
+        }
+    }
+}
diff --git a/src/EventLogExpert.Runtime/LogTable/LogTableQueries.cs b/src/EventLogExpert.Runtime/LogTable/LogTableQueries.cs
new file mode 100644
index 000000000..6a6cd438c
--- /dev/null
+++ b/src/EventLogExpert.Runtime/LogTable/LogTableQueries.cs
@@ -0,0 +1,40 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.EventLogs;
+using Fluxor;
+
+namespace EventLogExpert.Runtime.LogTable;
+
+internal sealed class LogTableQueries(IState<LogTableState> logTableState) : ILogTableQueries
+{
+    private readonly IState<LogTableState> _logTableState = logTableState;
+
+    public IReadOnlyList<LogTabGroup> GetTabGroups() => _logTableState.Value.Groups;
+
+    public bool HasActiveLogs() => _logTableState.Value.EventTables.Any(table => !table.IsCombined);
+
+    public bool HasMultipleIndividualTabs() =>
+        _logTableState.Value.EventTables.Count(table => !table.IsCombined) > 1;
+
+    public bool HasOtherTabsInGroup(LogTabGroupId groupId, EventLogId keepTabId)
+    {
+        var state = _logTableState.Value;
+
+        if (state.Groups.FirstOrDefault(group => group.Id == groupId) is not { } group) { return false; }
+
+        return group.MemberIds.Contains(keepTabId) &&
+            state.EventTables.Count(table => table.GroupId is null && group.MemberIds.Contains(table.Id)) > 1;
+    }
+
+    public bool HasTabGroup(LogTabGroupId groupId) => _logTableState.Value.Groups.Any(group => group.Id == groupId);
+
+    public bool IsGroupDescending() => _logTableState.Value.IsGroupDescending;
+
+    public bool IsGrouping() => _logTableState.Value.GroupBy is not null;
+
+    public bool IsTabOpen(EventLogId tabId) => _logTableState.Value.EventTables.Any(table => table.Id == tabId);
+
+    public bool IsUngroupedTabOpen(EventLogId tabId) =>
+        _logTableState.Value.EventTables.Any(table => table.Id == tabId && table.GroupId is null);
+}
diff --git a/src/EventLogExpert.Runtime/LogTable/LogTableState.cs b/src/EventLogExpert.Runtime/LogTable/LogTableState.cs
index fadfb91a1..509152380 100644
--- a/src/EventLogExpert.Runtime/LogTable/LogTableState.cs
+++ b/src/EventLogExpert.Runtime/LogTable/LogTableState.cs
@@ -2,9 +2,9 @@
 // // Licensed under the MIT License.
 
 using EventLogExpert.Eventing.Common.EventLogs;
-using EventLogExpert.Eventing.Common.Events;
+using EventLogExpert.Filtering.Evaluation;
+using EventLogExpert.Runtime.LogTable.OrderedView;
 using Fluxor;
-using System.Collections.Concurrent;
 using System.Collections.Immutable;
 using System.Runtime.CompilerServices;
 
@@ -13,27 +13,28 @@ namespace EventLogExpert.Runtime.LogTable;
 [FeatureState]
 public sealed record LogTableState
 {
-    internal ImmutableDictionary<EventLogId, EventColumnView> PerLogEvents { get; init; } =
-        ImmutableDictionary<EventLogId, EventColumnView>.Empty;
-
     public ImmutableList<LogView> EventTables { get; init; } = [];
 
     public ImmutableList<LogTabGroup> Groups { get; init; } = [];
 
-    public IEventColumnView DisplayedEvents =>
-        PerLogEvents.IsEmpty
-            ? CombinedColumnView.Empty
-            : PerLogEvents.Count == 1
-                ? SingleLogDisplayList()
-                : AllLogsView();
+    public static IEventColumnView EmptyView => EmptyColumnView.Instance;
+
+    public EventLogId? ActiveEventLogId { get; init; }
 
-    /// <summary>An empty view sentinel for the UI to bind when no tab is active.</summary>
-    public static IEventColumnView EmptyView => CombinedColumnView.Empty;
+    internal OrderedViewReady? ActiveOrderedView { get; init; }
 
-    public ImmutableDictionary<EventLogId, int> EventCountByLog { get; init; } =
-        ImmutableDictionary<EventLogId, int>.Empty;
+    internal ImmutableDictionary<EventLogId, OrderedViewReady> RetainedOrderedViews { get; init; } =
+        ImmutableDictionary<EventLogId, OrderedViewReady>.Empty;
 
-    public EventLogId? ActiveEventLogId { get; init; }
+    internal Filter AppliedFilter { get; init; } = new(null, []);
+
+    internal string? FaultCause { get; init; }
+
+    internal bool OrderedViewDisplayEnabled { get; init; } = true;
+
+    internal long HighestInvalidationSequence { get; init; }
+
+    internal long LastPublishedSnapshotVersion { get; init; } = -1;
 
     public ImmutableDictionary<ColumnName, bool> Columns { get; init; } = ImmutableDictionary<ColumnName, bool>.Empty;
 
@@ -50,11 +51,6 @@ public sealed record LogTableState
 
     public bool IsGroupDescending { get; init; }
 
-    /// <summary>
-    ///     Mirrors the timeline pane's visibility (kept in sync through <c>SetHistogramVisibleAction</c>). A single log
-    ///     with no explicit sort defaults to Date/Time order while the timeline is shown, so the table reads in the same order
-    ///     as the time axis, and to Record ID order while it is hidden. Combined views are unaffected (always Date/Time).
-    /// </summary>
     public bool TimelineVisible { get; init; }
 
     internal ColumnName? RequestedOrderBy { get; init; }
@@ -65,129 +61,293 @@ public sealed record LogTableState
 
     internal bool RequestedIsGroupDescending { get; init; }
 
-    internal int DisplayListVersion { get; init; }
-
     public bool GroupsCollapsedByDefault { get; init; }
 
     public ImmutableHashSet<string> GroupCollapseOverrides { get; init; } =
         ImmutableHashSet.Create<string>(StringComparer.Ordinal);
 
+    internal int DisplayedLogCount => EventTables.Count(table => !table.IsCombined);
+
     internal SortContext SortContext =>
-        new(ResolvedEventOrdering.ResolveDefaultOrderBy(RequestedOrderBy, RequestedGroupBy, PerLogEvents.Count, TimelineVisible),
+        new(ResolvedEventOrdering.ResolveDefaultOrderBy(RequestedOrderBy, RequestedGroupBy, DisplayedLogCount, TimelineVisible),
             RequestedIsDescending,
             RequestedGroupBy,
             RequestedIsGroupDescending);
 
+    internal ColumnName? CommittedEffectiveOrderBy { get; init; }
+
+    internal SortContext CommittedSortContext =>
+        new(CommittedEffectiveOrderBy,
+            IsDescending,
+            GroupBy,
+            IsGroupDescending);
+
+    private ImmutableArray<EventLogId> ActiveScope()
+    {
+        LogView? active = null;
+
+        foreach (LogView tab in EventTables)
+        {
+            if (tab.Id == ActiveEventLogId)
+            {
+                active = tab;
+
+                break;
+            }
+        }
+
+        if (active is null) { return []; }
+
+        if (active.GroupId is not { } groupId) { return [active.Id]; }
+
+        if (groupId.IsAll)
+        {
+            var openLogs = new List<EventLogId>(EventTables.Count);
+
+            foreach (LogView tab in EventTables)
+            {
+                if (!tab.IsCombined) { openLogs.Add(tab.Id); }
+            }
+
+            return Canonical(openLogs);
+        }
+
+        foreach (LogTabGroup candidate in Groups)
+        {
+            if (candidate.Id == groupId) { return Canonical([.. candidate.MemberIds]); }
+        }
+
+        return [];
+    }
+
+    private static ImmutableArray<EventLogId> Canonical(List<EventLogId> logIds)
+    {
+        logIds.Sort(static (left, right) => left.Value.CompareTo(right.Value));
+
+        return [.. logIds];
+    }
+
+    private ViewIdentity BuildViewIdentity() =>
+        new(ActiveEventLogId,
+            ActiveScope(),
+            RequestedOrderBy,
+            RequestedIsDescending,
+            RequestedGroupBy,
+            RequestedIsGroupDescending,
+            TimelineVisible,
+            DisplayedLogCount > 1,
+            AppliedFilter);
+
     internal bool HasPendingSortChange =>
         RequestedOrderBy != OrderBy ||
         RequestedIsDescending != IsDescending ||
         RequestedGroupBy != GroupBy ||
         RequestedIsGroupDescending != IsGroupDescending;
 
-    internal ImmutableDictionary<EventLogId, int> PerLogListVersion { get; init; } =
-        ImmutableDictionary<EventLogId, int>.Empty;
-
-    private static readonly object s_allLogsKey = new();
+    private static readonly ConditionalWeakTable<LogTableState, ViewIdentity> s_ViewIdentitys = [];
 
-    private static readonly ConditionalWeakTable<
-        ImmutableDictionary<EventLogId, EventColumnView>,
-        ConcurrentDictionary<object, CombinedColumnView>> s_viewsByGeneration = [];
+    internal ViewIdentity ViewIdentity =>
+        s_ViewIdentitys.GetValue(this, static state => state.BuildViewIdentity());
 
-    public IEventColumnView DisplayedEventsForTab(LogView tab)
+    internal bool OrderingIsStale
     {
-        if (tab.GroupId is null) { return EventsForLog(tab.Id); }
+        get
+        {
+            var activeTable = EventTables.FirstOrDefault(table => table.Id == ActiveEventLogId);
 
-        if (tab.GroupId.Value.IsAll) { return DisplayedEvents; }
+            if (activeTable is null) { return false; }
 
-        var group = Groups.FirstOrDefault(candidate => candidate.Id == tab.GroupId.Value);
+            if (activeTable.GroupId is null) { return OrderingIsStaleForLog(activeTable.Id); }
+
+            if (IsCombinedOrderedViewCurrent(activeTable) && ActiveOrderedView != null) { return false; }
+
+            if (!activeTable.GroupId.Value.IsAll &&
+                Groups.All(candidate => candidate.Id != activeTable.GroupId.Value))
+            {
+                return false;
+            }
 
-        return group is null ? CombinedColumnView.Empty : GroupView(group);
+            return IsRetainedViewServable(activeTable.Id) &&
+                RetainedOrderedViews[activeTable.Id].Config != SortContext;
+        }
     }
 
-    private IEventColumnView AllLogsView() =>
-        InnerCache().GetOrAdd(
-            s_allLogsKey,
-            static (_, perLog) => new CombinedColumnView([.. perLog.Values], perLog.Values.First().Context),
-            PerLogEvents);
+    private bool OrderingIsStaleForLog(EventLogId logId)
+    {
+        if (IsOrderedViewServing(logId) && ActiveOrderedView != null) { return false; }
+
+        return IsRetainedViewServable(logId) &&
+            RetainedOrderedViews[logId].Config != SortContext;
+    }
+
+    public IEventColumnView DisplayedEventsForTab(LogView tab) =>
+        RoutedReadyForTab(tab)?.View ?? EmptyColumnView.Instance;
+
+    internal ViewContentToken ContentTokenForTab(LogView tab) =>
+        RoutedReadyForTab(tab)?.ContentToken ?? ViewContentToken.Empty;
 
-    private IEventColumnView GroupView(LogTabGroup group)
+    private OrderedViewReady? RoutedReadyForTab(LogView tab)
     {
-        EventColumnView? firstPresent = null;
-        int presentCount = 0;
+        if (tab.GroupId is null) { return RoutedReadyForLog(tab.Id); }
 
-        foreach (var memberId in group.MemberIds)
+        if (tab.GroupId.Value.IsAll)
         {
-            if (PerLogEvents.TryGetValue(memberId, out var view))
-            {
-                firstPresent ??= view;
-                presentCount++;
-            }
+            return IsCombinedOrderedViewCurrent(tab) && ActiveOrderedView != null ?
+                ActiveOrderedView :
+                RetainedReadyFor(tab.Id);
         }
 
-        if (presentCount == 0) { return CombinedColumnView.Empty; }
+        var group = Groups.FirstOrDefault(candidate => candidate.Id == tab.GroupId.Value);
 
-        if (presentCount == 1) { return firstPresent!; }
+        if (group is null) { return null; }
 
-        return InnerCache().GetOrAdd(
-            group.MemberIds,
-            static (_, args) => BuildGroupView(args.PerLogEvents, args.MemberIds),
-            (PerLogEvents, group.MemberIds));
+        return IsCombinedOrderedViewCurrent(tab) && ActiveOrderedView != null ?
+            ActiveOrderedView :
+            RetainedReadyFor(tab.Id);
     }
 
-    private static CombinedColumnView BuildGroupView(
-        ImmutableDictionary<EventLogId, EventColumnView> perLog,
-        ImmutableHashSet<EventLogId> memberIds)
-    {
-        var views = new List<EventColumnView>(memberIds.Count);
+    internal IEventColumnView EventsForLog(EventLogId logId) =>
+        RoutedReadyForLog(logId)?.View ?? EmptyColumnView.Instance;
 
-        foreach (var memberId in memberIds)
+    private OrderedViewReady? RoutedReadyForLog(EventLogId logId)
+    {
+        if (IsOrderedViewServing(logId) && ActiveOrderedView != null)
         {
-            if (perLog.TryGetValue(memberId, out var view)) { views.Add(view); }
+            return ActiveOrderedView;
         }
 
-        return new CombinedColumnView(views, views[0].Context);
+        return RetainedReadyFor(logId);
     }
 
-    private ConcurrentDictionary<object, CombinedColumnView> InnerCache() =>
-        s_viewsByGeneration.GetValue(
-            PerLogEvents, static _ => new ConcurrentDictionary<object, CombinedColumnView>());
-
-    // Caller guarantees PerLogEvents.Count == 1. Use the struct enumerator, not LINQ .Values.First(), to avoid boxing
-    // on this render-path read.
-    private EventColumnView SingleLogDisplayList()
+    internal ImmutableDictionary<EventLogId, OrderedViewReady> RetainOnly(OrderedViewReady served)
     {
-        using var enumerator = PerLogEvents.GetEnumerator();
-        enumerator.MoveNext();
+        if (served.Identity?.ActiveLogId is not { } servedTabId) { return RetainedOrderedViews; }
+
+        var openTabIds = EventTables.Select(table => table.Id).ToHashSet();
+
+        var pruned = RetainedOrderedViews;
 
-        return enumerator.Current.Value;
+        foreach (var tabId in RetainedOrderedViews.Keys)
+        {
+            if (!openTabIds.Contains(tabId)) { pruned = pruned.Remove(tabId); }
+        }
+
+        return openTabIds.Contains(servedTabId) ? pruned.SetItem(servedTabId, served) : pruned;
     }
 
-    public IEventColumnView EventsForLog(EventLogId logId) =>
-        PerLogEvents.TryGetValue(logId, out var view) ? view : CombinedColumnView.Empty;
+    internal LogTableState WithClearedOrderedViewRetention() =>
+        this with
+        {
+            ActiveOrderedView = null,
+            RetainedOrderedViews = ImmutableDictionary<EventLogId, OrderedViewReady>.Empty
+        };
+
+    private OrderedViewReady? RetainedReadyFor(EventLogId tabId) =>
+        IsRetainedViewServable(tabId) ? RetainedOrderedViews[tabId] : null;
+
+    internal bool IsRetainedViewServable(EventLogId tabId) =>
+        tabId == ActiveEventLogId &&
+        RetainedOrderedViews.TryGetValue(tabId, out var retained) &&
+        retained.Identity is { } identity &&
+        identity.Scope.SequenceEqual(ActiveScope()) &&
+        retained.Config == CommittedSortContext &&
+        !retained.Filter.HasFilteringChangedFrom(AppliedFilter);
+
+    internal bool IsOrderedViewServing(EventLogId logId) =>
+        OrderedViewDisplayEnabled &&
+        ActiveOrderedView != null &&
+        ActiveOrderedView.SingleLogId == logId &&
+        logId == ActiveEventLogId &&
+        !HasPendingSortChange &&
+        ActiveOrderedView.Config == SortContext &&
+        !ActiveOrderedView.Filter.HasFilteringChangedFrom(AppliedFilter);
+
+    // is not serving simply falls back to its retained-or-empty view. The tab must be the active one (the engine holds exactly one
+    // scope - the active tab's), and the view must have been published for the identity this state is asking for. That
+    // identity CARRIES the active tab's resolved scope, so identity equality already proves the engine's scope is exactly this
+    // tab's membership - no separate AllLogs/group set comparison is needed. Grouped display routes under exactly the fence
+    // ungrouped already uses: HasPendingSortChange covers the group members, and SortContext is built from the requested
+    // pair, so !HasPendingSortChange with Config == SortContext proves the routed view was ordered under the very GroupBy
+    // the pane is about to group it by (see LogTablePane.RebuildGroupedRowView).
+    private bool IsCombinedOrderedViewCurrent(LogView tab) =>
+        OrderedViewDisplayEnabled &&
+        ActiveOrderedView != null &&
+        tab.Id == ActiveEventLogId &&
+        !HasPendingSortChange &&
+        ActiveOrderedView.Identity == ViewIdentity &&
+        ActiveOrderedView.Config == SortContext &&
+
+        // SEMANTIC, not `==`: Filter's record equality is reference-based on its collections, while the identity above
+        // compares filters semantically. A reference check here would reject a view whose identity already matched -
+        // e.g. re-applying an equivalent filter built from fresh collections - and park the display on the fallback view
+        // with no further request to repair it.
+        !ActiveOrderedView.Filter.HasFilteringChangedFrom(AppliedFilter);
 
     public IEventColumnView GetActiveDisplayedEvents()
     {
         var activeTable = EventTables.FirstOrDefault(table => table.Id == ActiveEventLogId);
 
-        return activeTable is null ? CombinedColumnView.Empty : DisplayedEventsForTab(activeTable);
+        return activeTable is null ? EmptyColumnView.Instance : DisplayedEventsForTab(activeTable);
     }
 
-    public IReadOnlyList<ColumnName> GetOrderedEnabledColumns(ILogTableColumnDefaultsProvider columnDefaults)
+    internal PresentationState PresentationState
+    {
+        get
+        {
+            var activeTable = EventTables.FirstOrDefault(table => table.Id == ActiveEventLogId);
+
+            if (activeTable is null) { return PresentationState.Current; }
+
+            if (activeTable.GroupId is { IsAll: false } groupId &&
+                Groups.All(candidate => candidate.Id != groupId))
+            {
+                return PresentationState.Current;
+            }
+
+            if (!OrderedViewDisplayEnabled) { return PresentationState.Faulted; }
+
+            return ServingOrderedView != null ? PresentationState.Current : PresentationState.Updating;
+        }
+    }
+
+    internal OrderedViewReady? ServingOrderedView
+    {
+        get
+        {
+            if (ActiveOrderedView is null) { return null; }
+
+            var activeTable = EventTables.FirstOrDefault(table => table.Id == ActiveEventLogId);
+
+            if (activeTable is null) { return null; }
+
+            bool serving = activeTable.GroupId is null ?
+                IsOrderedViewServing(activeTable.Id) :
+                IsCombinedOrderedViewCurrent(activeTable);
+
+            return serving ? ActiveOrderedView : null;
+        }
+    }
+
+    public IReadOnlyList<ColumnName> GetOrderedEnabledColumns(ILogTableColumnDefaultsProvider columnDefaults) =>
+        ResolveOrderedEnabledColumns(Columns, ColumnOrder, columnDefaults);
+
+    public static IReadOnlyList<ColumnName> ResolveOrderedEnabledColumns(
+        ImmutableDictionary<ColumnName, bool> columns,
+        ImmutableList<ColumnName> columnOrder,
+        ILogTableColumnDefaultsProvider columnDefaults)
     {
         ArgumentNullException.ThrowIfNull(columnDefaults);
 
-        var enabledColumns = Columns
+        var enabledColumns = columns
             .Where(column => column.Value)
             .Select(column => column.Key)
             .ToHashSet();
 
-        var order = ColumnOrder.IsEmpty ? columnDefaults.ColumnOrder : ColumnOrder;
+        var order = columnOrder.IsEmpty ? columnDefaults.ColumnOrder : columnOrder;
 
         HashSet<ColumnName> present = [];
         List<ColumnName> ordered = [];
 
-        // De-duplicate while preserving first occurrence: a persisted ColumnOrder may contain duplicates
-        // that would otherwise become duplicate export headers (rejected by TabularExportWriter).
         foreach (var column in order)
         {
             if (enabledColumns.Contains(column) && present.Add(column))
@@ -196,8 +356,6 @@ public IReadOnlyList<ColumnName> GetOrderedEnabledColumns(ILogTableColumnDefault
             }
         }
 
-        // Append any enabled column missing from the active order (e.g. enabled but absent from a persisted
-        // ColumnOrder) so it is never silently dropped from the table or an export.
         foreach (var column in columnDefaults.ColumnOrder)
         {
             if (enabledColumns.Contains(column) && present.Add(column))
@@ -211,52 +369,4 @@ public IReadOnlyList<ColumnName> GetOrderedEnabledColumns(ILogTableColumnDefault
 
     public bool IsGroupCollapsed(string groupKey) =>
         GroupsCollapsedByDefault ^ GroupCollapseOverrides.Contains(groupKey);
-
-    // Each call must carry a single log's events (one OwningLog).
-    internal LogTableState WithLogEvents(EventLogId logId, params ResolvedEvent[] events)
-    {
-        for (int i = 1; i < events.Length; i++)
-        {
-            if (!string.Equals(events[i].OwningLog, events[0].OwningLog, StringComparison.Ordinal))
-            {
-                throw new ArgumentException("All events must share one OwningLog.", nameof(events));
-            }
-        }
-
-        int newCount = PerLogEvents.ContainsKey(logId) ? PerLogEvents.Count : PerLogEvents.Count + 1;
-
-        var context = new SortContext(
-            ResolvedEventOrdering.ResolveDefaultOrderBy(OrderBy, GroupBy, newCount, TimelineVisible),
-            IsDescending,
-            GroupBy,
-            IsGroupDescending);
-
-        var builder = PerLogEvents.ToBuilder();
-        builder[logId] = BuildUnfilteredView(logId, events, context);
-
-        foreach (var (id, view) in PerLogEvents)
-        {
-            if (id != logId && !view.HasContext(context))
-            {
-                builder[id] = view.WithContext(context);
-            }
-        }
-
-        return this with { PerLogEvents = builder.ToImmutable() };
-    }
-
-    // Seeds a display view directly from unfiltered events (test/reconcile helper); with no filter every physical row
-    // survives.
-    private static EventColumnView BuildUnfilteredView(
-        EventLogId logId,
-        IReadOnlyList<ResolvedEvent> events,
-        SortContext context)
-    {
-        var reader = EventColumnStore.Build(events, 0, 0).CreateReader(logId);
-        int[] survivors = new int[reader.Count];
-
-        for (int i = 0; i < survivors.Length; i++) { survivors[i] = i; }
-
-        return EventColumnView.Create(reader, survivors, context);
-    }
 }
diff --git a/src/EventLogExpert.Runtime/LogTable/OrderedView/ChunkedOrderIndex.cs b/src/EventLogExpert.Runtime/LogTable/OrderedView/ChunkedOrderIndex.cs
new file mode 100644
index 000000000..2b8264108
--- /dev/null
+++ b/src/EventLogExpert.Runtime/LogTable/OrderedView/ChunkedOrderIndex.cs
@@ -0,0 +1,255 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.Events;
+
+namespace EventLogExpert.Runtime.LogTable.OrderedView;
+
+internal sealed class ChunkedOrderIndex
+{
+    private const int Capacity = 1024;
+
+    private readonly List<OrderKey[]> _buffers = [];
+    private readonly List<int> _counts = [];
+    private readonly Dictionary<LogGeneration, ulong[]> _present = [];
+    private readonly HashSet<LogGeneration> _presentClonedThisBatch = [];
+    private readonly List<OrderKey[]?> _sealed = [];
+
+    private IComparer<OrderKey> _insertComparer;
+
+    internal ChunkedOrderIndex(IComparer<OrderKey> insertComparer) => _insertComparer = insertComparer;
+
+    public int Count
+    {
+        get
+        {
+            int total = 0;
+
+            foreach (int count in _counts) { total += count; }
+
+            return total;
+        }
+    }
+
+    public void Insert(in OrderKey key)
+    {
+        SetPresent(key.Locator);
+
+        if (_buffers.Count == 0)
+        {
+            var first = new OrderKey[Capacity];
+            first[0] = key;
+            _buffers.Add(first);
+            _counts.Add(1);
+            _sealed.Add(null);
+            return;
+        }
+
+        int chunk = ChunkForKey(key);
+
+        if (_counts[chunk] == Capacity)
+        {
+            SplitChunk(chunk);
+            chunk = ChunkForKey(key);
+        }
+
+        InsertIntoChunk(chunk, key);
+    }
+
+    public OrderedViewSnapshot Publish(IComparer<OrderKey> snapshotComparer, long version)
+    {
+        int chunkCount = _buffers.Count;
+
+        var present = new Dictionary<LogGeneration, ulong[]>(_present);
+        _presentClonedThisBatch.Clear();
+
+        if (chunkCount == 0)
+        {
+            return new OrderedViewSnapshot([], [], [0], present, snapshotComparer, version);
+        }
+
+        var chunks = new OrderKey[chunkCount][];
+        var firstOfChunk = new OrderKey[chunkCount];
+        var prefix = new int[chunkCount + 1];
+        int accumulated = 0;
+
+        for (int chunk = 0; chunk < chunkCount; chunk++)
+        {
+            var frozen = _sealed[chunk];
+
+            if (frozen is null)
+            {
+                frozen = new OrderKey[_counts[chunk]];
+                Array.Copy(_buffers[chunk], 0, frozen, 0, _counts[chunk]);
+                _sealed[chunk] = frozen;
+            }
+
+            chunks[chunk] = frozen;
+            firstOfChunk[chunk] = frozen[0];
+            prefix[chunk] = accumulated;
+            accumulated += frozen.Length;
+        }
+
+        prefix[chunkCount] = accumulated;
+
+        return new OrderedViewSnapshot(chunks, firstOfChunk, prefix, present, snapshotComparer, version);
+    }
+
+    internal static ChunkedOrderIndex FromSortedRun(
+        OrderKey[] sortedOrder,
+        IComparer<OrderKey> insertComparer,
+        CancellationToken cancellationToken = default)
+    {
+        var index = new ChunkedOrderIndex(insertComparer);
+
+        index.BulkFill(sortedOrder,
+            cancellationToken);
+
+        return index;
+    }
+
+    internal void RebindInsertComparer(IComparer<OrderKey> insertComparer) => _insertComparer = insertComparer;
+
+    private void BulkFill(OrderKey[] sortedOrder, CancellationToken cancellationToken)
+    {
+        if (sortedOrder.Length == 0) { return; }
+
+        var maxIndexByKey = new Dictionary<LogGeneration, int>();
+
+        for (int position = 0; position < sortedOrder.Length; position++)
+        {
+            if ((position & 8191) == 0) { cancellationToken.ThrowIfCancellationRequested(); }
+
+            var generationKey = new LogGeneration(sortedOrder[position].Locator.LogId, sortedOrder[position].Locator.Generation);
+            int index = sortedOrder[position].Locator.Index;
+
+            if (!maxIndexByKey.TryGetValue(generationKey, out int max) || index > max) { maxIndexByKey[generationKey] = index; }
+        }
+
+        foreach ((LogGeneration generationKey, int maxIndex) in maxIndexByKey)
+        {
+            _present[generationKey] = new ulong[Math.Max((maxIndex >> 6) + 1, 4)];
+            _presentClonedThisBatch.Add(generationKey);
+        }
+
+        for (int position = 0; position < sortedOrder.Length; position++)
+        {
+            if ((position & 8191) == 0) { cancellationToken.ThrowIfCancellationRequested(); }
+
+            EventLocator locator = sortedOrder[position].Locator;
+            var generationKey = new LogGeneration(locator.LogId, locator.Generation);
+            _present[generationKey][locator.Index >> 6] |= 1UL << (locator.Index & 63);
+        }
+
+        for (int offset = 0; offset < sortedOrder.Length; offset += Capacity)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            int take = Math.Min(Capacity, sortedOrder.Length - offset);
+            var buffer = new OrderKey[Capacity];
+            Array.Copy(sortedOrder, offset, buffer, 0, take);
+            _buffers.Add(buffer);
+            _counts.Add(take);
+            _sealed.Add(null);
+        }
+    }
+
+    private int ChunkForKey(in OrderKey key)
+    {
+        int low = 0, high = _buffers.Count - 1, answer = 0;
+
+        while (low <= high)
+        {
+            int mid = (low + high) >> 1;
+
+            if (_insertComparer.Compare(key, _buffers[mid][0]) >= 0)
+            {
+                answer = mid;
+                low = mid + 1;
+            }
+            else
+            {
+                high = mid - 1;
+            }
+        }
+
+        return answer;
+    }
+
+    private void InsertIntoChunk(int chunk, in OrderKey key)
+    {
+        var buffer = _buffers[chunk];
+        int count = _counts[chunk];
+        int position = LowerBound(buffer, count, key);
+
+        Array.Copy(buffer, position, buffer, position + 1, count - position);
+        buffer[position] = key;
+        _counts[chunk] = count + 1;
+        _sealed[chunk] = null;
+    }
+
+    private int LowerBound(OrderKey[] buffer, int count, in OrderKey key)
+    {
+        int low = 0, high = count;
+
+        while (low < high)
+        {
+            int mid = (int)(((uint)low + (uint)high) >> 1);
+
+            if (_insertComparer.Compare(buffer[mid], key) < 0) { low = mid + 1; }
+            else { high = mid; }
+        }
+
+        return low;
+    }
+
+    private void SetPresent(in EventLocator locator)
+    {
+        var key = new LogGeneration(locator.LogId, locator.Generation);
+        int index = locator.Index;
+        int word = index >> 6;
+
+        if (!_present.TryGetValue(key, out var bits))
+        {
+            bits = new ulong[Math.Max(word + 1, 4)];
+            _present[key] = bits;
+            _presentClonedThisBatch.Add(key);
+        }
+        else
+        {
+            if (!_presentClonedThisBatch.Contains(key))
+            {
+                bits = (ulong[])bits.Clone();
+                _present[key] = bits;
+                _presentClonedThisBatch.Add(key);
+            }
+
+            if (word >= bits.Length)
+            {
+                Array.Resize(ref bits, Math.Max(word + 1, bits.Length * 2));
+                _present[key] = bits;
+            }
+        }
+
+        bits[word] |= 1UL << (index & 63);
+    }
+
+    private void SplitChunk(int chunk)
+    {
+        var buffer = _buffers[chunk];
+        int half = Capacity / 2;
+        var left = new OrderKey[Capacity];
+        var right = new OrderKey[Capacity];
+
+        Array.Copy(buffer, 0, left, 0, half);
+        Array.Copy(buffer, half, right, 0, Capacity - half);
+
+        _buffers[chunk] = left;
+        _counts[chunk] = half;
+        _sealed[chunk] = null;
+
+        _buffers.Insert(chunk + 1, right);
+        _counts.Insert(chunk + 1, Capacity - half);
+        _sealed.Insert(chunk + 1, null);
+    }
+}
diff --git a/src/EventLogExpert.Runtime/LogTable/OrderedView/CombinedOrderedColumnView.cs b/src/EventLogExpert.Runtime/LogTable/OrderedView/CombinedOrderedColumnView.cs
new file mode 100644
index 000000000..e57aa61df
--- /dev/null
+++ b/src/EventLogExpert.Runtime/LogTable/OrderedView/CombinedOrderedColumnView.cs
@@ -0,0 +1,737 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.Events;
+using EventLogExpert.Filtering.Compilation;
+using EventLogExpert.Filtering.Persistence;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+
+namespace EventLogExpert.Runtime.LogTable.OrderedView;
+
+internal sealed class CombinedOrderedColumnView : IEventColumnView
+{
+    private readonly int _count;
+    private readonly ConditionalWeakTable<byte[], byte[][]> _highlightHandles = [];
+    private readonly IEventColumnReader[] _readers;
+    private readonly Dictionary<LogGeneration, int> _slotByLogGeneration;
+    private readonly OrderedViewSnapshot _snapshot;
+
+    private Dictionary<ValueKey, EventLocator>? _byKey;
+    private HighlightCache? _highlightCache;
+    private Partition? _partition;
+
+    internal CombinedOrderedColumnView(OrderedViewSnapshot snapshot, IReadOnlyCollection<LogGeneration> exactInScope)
+    {
+        ArgumentNullException.ThrowIfNull(snapshot);
+        ArgumentNullException.ThrowIfNull(exactInScope);
+
+        _snapshot = snapshot;
+        _readers = new IEventColumnReader[exactInScope.Count];
+        _slotByLogGeneration = new Dictionary<LogGeneration, int>(exactInScope.Count);
+
+        int next = 0;
+
+        foreach (LogGeneration logGeneration in exactInScope)
+        {
+            if (!snapshot.TryGetReaderByLog(logGeneration.LogId,
+                logGeneration.Generation,
+                out IEventColumnReader? reader))
+            {
+                throw new ArgumentException(
+                    $"The snapshot pins no reader for in-scope member '{logGeneration.LogId}' generation {logGeneration.Generation}.",
+                    nameof(exactInScope));
+            }
+
+            if (!_slotByLogGeneration.TryAdd(logGeneration, next))
+            {
+                throw new ArgumentException($"Duplicate in-scope member '{logGeneration}'.", nameof(exactInScope));
+            }
+
+            _readers[next] = reader;
+            next++;
+        }
+
+        _count = snapshot.Count;
+    }
+
+    public int Count => _count;
+
+    public void BucketTimeTicksByEventData(
+        long minTicks,
+        long bucketSpanTicks,
+        int bucketCount,
+        string fieldName,
+        long[] targetCodes,
+        int[] slotCounts,
+        CancellationToken cancellationToken)
+    {
+        Partition partition = GetPartition();
+
+        for (int slot = 0; slot < _readers.Length; slot++)
+        {
+            _readers[slot]
+                .BucketTimeTicksByEventData(
+                    partition.RankByPhysical[slot],
+                    minTicks,
+                    bucketSpanTicks,
+                    bucketCount,
+                    fieldName,
+                    targetCodes,
+                    slotCounts,
+                    cancellationToken);
+        }
+    }
+
+    public void BucketTimeTicksByEventDataHResult(
+        long minTicks,
+        long bucketSpanTicks,
+        int bucketCount,
+        string fieldName,
+        IReadOnlyCollection<string> eligibleProviders,
+        IReadOnlyList<string> userDataErrorCodePaths,
+        long[] targetCodes,
+        int[] slotCounts,
+        CancellationToken cancellationToken)
+    {
+        Partition partition = GetPartition();
+
+        for (int slot = 0; slot < _readers.Length; slot++)
+        {
+            _readers[slot]
+                .BucketTimeTicksByEventDataHResult(
+                    partition.RankByPhysical[slot],
+                    minTicks,
+                    bucketSpanTicks,
+                    bucketCount,
+                    fieldName,
+                    eligibleProviders,
+                    userDataErrorCodePaths,
+                    targetCodes,
+                    slotCounts,
+                    cancellationToken);
+        }
+    }
+
+    public void BucketTimeTicksByEventDataHResultWithTie(
+        byte[] highlightWinners,
+        uint[] slotColorMask,
+        long minTicks,
+        long bucketSpanTicks,
+        int bucketCount,
+        string fieldName,
+        IReadOnlyCollection<string> eligibleProviders,
+        IReadOnlyList<string> userDataErrorCodePaths,
+        long[] targetCodes,
+        int[] slotCounts,
+        CancellationToken cancellationToken)
+    {
+        Partition partition = GetPartition();
+        byte[][] childWinners = ResolveChildWinners(highlightWinners);
+
+        for (int slot = 0; slot < _readers.Length; slot++)
+        {
+            _readers[slot]
+                .BucketTimeTicksByEventDataHResultWithTie(
+                    partition.RankByPhysical[slot],
+                    childWinners[slot],
+                    slotColorMask,
+                    minTicks,
+                    bucketSpanTicks,
+                    bucketCount,
+                    fieldName,
+                    eligibleProviders,
+                    userDataErrorCodePaths,
+                    targetCodes,
+                    slotCounts,
+                    cancellationToken);
+        }
+    }
+
+    public void BucketTimeTicksByEventDataString(
+        long minTicks,
+        long bucketSpanTicks,
+        int bucketCount,
+        string[] candidateFields,
+        IReadOnlyDictionary<string, int> rawValueToSlot,
+        int slotCount,
+        int[] slotCounts,
+        CancellationToken cancellationToken)
+    {
+        Partition partition = GetPartition();
+
+        for (int slot = 0; slot < _readers.Length; slot++)
+        {
+            _readers[slot]
+                .BucketTimeTicksByEventDataString(
+                    partition.RankByPhysical[slot],
+                    minTicks,
+                    bucketSpanTicks,
+                    bucketCount,
+                    candidateFields,
+                    rawValueToSlot,
+                    slotCount,
+                    slotCounts,
+                    cancellationToken);
+        }
+    }
+
+    public void BucketTimeTicksByEventDataStringWithTie(
+        byte[] highlightWinners,
+        uint[] slotColorMask,
+        long minTicks,
+        long bucketSpanTicks,
+        int bucketCount,
+        string[] candidateFields,
+        IReadOnlyDictionary<string, int> rawValueToSlot,
+        int slotCount,
+        int[] slotCounts,
+        CancellationToken cancellationToken)
+    {
+        Partition partition = GetPartition();
+        byte[][] childWinners = ResolveChildWinners(highlightWinners);
+
+        for (int slot = 0; slot < _readers.Length; slot++)
+        {
+            _readers[slot]
+                .BucketTimeTicksByEventDataStringWithTie(
+                    partition.RankByPhysical[slot],
+                    childWinners[slot],
+                    slotColorMask,
+                    minTicks,
+                    bucketSpanTicks,
+                    bucketCount,
+                    candidateFields,
+                    rawValueToSlot,
+                    slotCount,
+                    slotCounts,
+                    cancellationToken);
+        }
+    }
+
+    public void BucketTimeTicksByEventDataWithTie(
+        byte[] highlightWinners,
+        uint[] slotColorMask,
+        long minTicks,
+        long bucketSpanTicks,
+        int bucketCount,
+        string fieldName,
+        long[] targetCodes,
+        int[] slotCounts,
+        CancellationToken cancellationToken)
+    {
+        Partition partition = GetPartition();
+        byte[][] childWinners = ResolveChildWinners(highlightWinners);
+
+        for (int slot = 0; slot < _readers.Length; slot++)
+        {
+            _readers[slot]
+                .BucketTimeTicksByEventDataWithTie(
+                    partition.RankByPhysical[slot],
+                    childWinners[slot],
+                    slotColorMask,
+                    minTicks,
+                    bucketSpanTicks,
+                    bucketCount,
+                    fieldName,
+                    targetCodes,
+                    slotCounts,
+                    cancellationToken);
+        }
+    }
+
+    public void BucketTimeTicksByEventId(
+        long minTicks,
+        long bucketSpanTicks,
+        int bucketCount,
+        int[] targetIds,
+        int[] slotCounts,
+        CancellationToken cancellationToken)
+    {
+        Partition partition = GetPartition();
+
+        for (int slot = 0; slot < _readers.Length; slot++)
+        {
+            _readers[slot]
+                .BucketTimeTicksByEventId(
+                    partition.RankByPhysical[slot],
+                    minTicks,
+                    bucketSpanTicks,
+                    bucketCount,
+                    targetIds,
+                    slotCounts,
+                    cancellationToken);
+        }
+    }
+
+    public void BucketTimeTicksByEventIdWithTie(
+        byte[] highlightWinners,
+        uint[] slotColorMask,
+        long minTicks,
+        long bucketSpanTicks,
+        int bucketCount,
+        int[] targetIds,
+        int[] slotCounts,
+        CancellationToken cancellationToken)
+    {
+        Partition partition = GetPartition();
+        byte[][] childWinners = ResolveChildWinners(highlightWinners);
+
+        for (int slot = 0; slot < _readers.Length; slot++)
+        {
+            _readers[slot]
+                .BucketTimeTicksByEventIdWithTie(
+                    partition.RankByPhysical[slot],
+                    childWinners[slot],
+                    slotColorMask,
+                    minTicks,
+                    bucketSpanTicks,
+                    bucketCount,
+                    targetIds,
+                    slotCounts,
+                    cancellationToken);
+        }
+    }
+
+    public void BucketTimeTicksByField(
+        long minTicks,
+        long bucketSpanTicks,
+        int bucketCount,
+        EventFieldId field,
+        string[] targetValues,
+        int[] slotCounts,
+        CancellationToken cancellationToken)
+    {
+        Partition partition = GetPartition();
+
+        for (int slot = 0; slot < _readers.Length; slot++)
+        {
+            _readers[slot]
+                .BucketTimeTicksByField(
+                    partition.RankByPhysical[slot],
+                    minTicks,
+                    bucketSpanTicks,
+                    bucketCount,
+                    field,
+                    targetValues,
+                    slotCounts,
+                    cancellationToken);
+        }
+    }
+
+    public void BucketTimeTicksByFieldWithTie(
+        byte[] highlightWinners,
+        uint[] slotColorMask,
+        long minTicks,
+        long bucketSpanTicks,
+        int bucketCount,
+        EventFieldId field,
+        string[] targetValues,
+        int[] slotCounts,
+        CancellationToken cancellationToken)
+    {
+        Partition partition = GetPartition();
+        byte[][] childWinners = ResolveChildWinners(highlightWinners);
+
+        for (int slot = 0; slot < _readers.Length; slot++)
+        {
+            _readers[slot]
+                .BucketTimeTicksByFieldWithTie(
+                    partition.RankByPhysical[slot],
+                    childWinners[slot],
+                    slotColorMask,
+                    minTicks,
+                    bucketSpanTicks,
+                    bucketCount,
+                    field,
+                    targetValues,
+                    slotCounts,
+                    cancellationToken);
+        }
+    }
+
+    public void BucketTimeTicksBySeverity(
+        long minTicks,
+        long bucketSpanTicks,
+        int bucketCount,
+        int[] slotCounts,
+        CancellationToken cancellationToken)
+    {
+        Partition partition = GetPartition();
+
+        for (int slot = 0; slot < _readers.Length; slot++)
+        {
+            _readers[slot]
+                .BucketTimeTicksBySeverity(
+                    partition.RankByPhysical[slot],
+                    minTicks,
+                    bucketSpanTicks,
+                    bucketCount,
+                    slotCounts,
+                    cancellationToken);
+        }
+    }
+
+    public void BucketTimeTicksBySeverityWithTie(
+        byte[] highlightWinners,
+        uint[] slotColorMask,
+        long minTicks,
+        long bucketSpanTicks,
+        int bucketCount,
+        int[] slotCounts,
+        CancellationToken cancellationToken)
+    {
+        Partition partition = GetPartition();
+        byte[][] childWinners = ResolveChildWinners(highlightWinners);
+
+        for (int slot = 0; slot < _readers.Length; slot++)
+        {
+            _readers[slot]
+                .BucketTimeTicksBySeverityWithTie(
+                    partition.RankByPhysical[slot],
+                    childWinners[slot],
+                    slotColorMask,
+                    minTicks,
+                    bucketSpanTicks,
+                    bucketCount,
+                    slotCounts,
+                    cancellationToken);
+        }
+    }
+
+    public void CountEventDataHResults(
+        string fieldName,
+        IReadOnlyCollection<string> eligibleProviders,
+        IReadOnlyList<string> userDataErrorCodePaths,
+        IDictionary<long, int> counts,
+        CancellationToken cancellationToken)
+    {
+        Partition partition = GetPartition();
+
+        for (int slot = 0; slot < _readers.Length; slot++)
+        {
+            _readers[slot]
+                .CountEventDataHResults(
+                    partition.RankByPhysical[slot],
+                    fieldName,
+                    eligibleProviders,
+                    userDataErrorCodePaths,
+                    counts,
+                    cancellationToken);
+        }
+    }
+
+    public void CountEventDataStringValues(
+        string[] candidateFields,
+        IDictionary<string, int> counts,
+        CancellationToken cancellationToken)
+    {
+        Partition partition = GetPartition();
+
+        for (int slot = 0; slot < _readers.Length; slot++)
+        {
+            _readers[slot]
+                .CountEventDataStringValues(partition.RankByPhysical[slot], candidateFields, counts, cancellationToken);
+        }
+    }
+
+    public void CountEventDataValues(
+        string fieldName,
+        IDictionary<long, int> counts,
+        CancellationToken cancellationToken)
+    {
+        Partition partition = GetPartition();
+
+        for (int slot = 0; slot < _readers.Length; slot++)
+        {
+            _readers[slot].CountEventDataValues(partition.RankByPhysical[slot], fieldName, counts, cancellationToken);
+        }
+    }
+
+    public void CountEventIds(IDictionary<int, int> counts, CancellationToken cancellationToken)
+    {
+        Partition partition = GetPartition();
+
+        for (int slot = 0; slot < _readers.Length; slot++)
+        {
+            _readers[slot].CountEventIds(partition.RankByPhysical[slot], counts, cancellationToken);
+        }
+    }
+
+    public void CountFieldValues(
+        EventFieldId field,
+        IDictionary<string, int> counts,
+        CancellationToken cancellationToken)
+    {
+        Partition partition = GetPartition();
+
+        for (int slot = 0; slot < _readers.Length; slot++)
+        {
+            _readers[slot].CountFieldValues(partition.RankByPhysical[slot], field, counts, cancellationToken);
+        }
+    }
+
+    public byte[] EnsureHighlightWinners(
+        IReadOnlyList<SavedFilter> orderedColoredFilters,
+        int planKey,
+        CancellationToken cancellationToken)
+    {
+        ArgumentNullException.ThrowIfNull(orderedColoredFilters);
+
+        HighlightCache? cache = Volatile.Read(ref _highlightCache);
+        byte[][] childWinners;
+
+        if (cache is not null && cache.PlanKey == planKey)
+        {
+            childWinners = cache.ChildWinners;
+        }
+        else
+        {
+            Partition partition = GetPartition();
+            childWinners = new byte[_readers.Length][];
+
+            for (int slot = 0; slot < _readers.Length; slot++)
+            {
+                childWinners[slot] = FilterService.ClassifyHighlightWinners(
+                    _readers[slot],
+                    partition.SurvivingOrder[slot],
+                    orderedColoredFilters,
+                    cancellationToken);
+            }
+
+            Volatile.Write(ref _highlightCache, new HighlightCache(planKey, childWinners));
+        }
+
+        byte[] handle = new byte[1];
+        _highlightHandles.Add(handle, childWinners);
+
+        return handle;
+    }
+
+    public IEnumerable<ResolvedEvent> EnumerateDetail()
+    {
+        int count = _snapshot.Count;
+
+        for (int display = 0; display < count; display++)
+        {
+            EventLocator locator = _snapshot.At(display).Locator;
+
+            yield return Reader(locator).GetDetail(locator);
+        }
+    }
+
+    public IEnumerable<ResolvedEvent> EnumerateDetailLean()
+    {
+        int count = _snapshot.Count;
+
+        for (int display = 0; display < count; display++)
+        {
+            EventLocator locator = _snapshot.At(display).Locator;
+
+            yield return Reader(locator).GetDetailLean(locator);
+        }
+    }
+
+    public ResolvedEvent GetDetail(EventLocator locator) => Reader(locator).GetDetail(locator);
+
+    public ResolvedEvent GetDetailLean(EventLocator locator) => Reader(locator).GetDetailLean(locator);
+
+    public string GroupKeyAt(EventLocator locator, ColumnName column) =>
+        ResolvedEventGroupKey.For(Reader(locator), locator, column);
+
+    public EventLocator LocatorAt(int index) => _snapshot.At(index).Locator;
+
+    public int Rank(EventLocator locator) => _snapshot.RankOf(new OrderKey(locator));
+
+    public EventLocator? ResolveByKey(ValueKey key)
+    {
+        Dictionary<ValueKey, EventLocator>? byKey = Volatile.Read(ref _byKey);
+
+        if (byKey is null)
+        {
+            byKey = BuildByKey();
+
+            byKey = Interlocked.CompareExchange(ref _byKey, byKey, null) ?? byKey;
+        }
+
+        return byKey.TryGetValue(key, out EventLocator locator) ? locator : null;
+    }
+
+    public IReadOnlyList<DisplayRow> Slice(int start, int count)
+    {
+        if (start < 0) { throw new ArgumentOutOfRangeException(nameof(start)); }
+
+        if (count < 0) { throw new ArgumentOutOfRangeException(nameof(count)); }
+
+        int end = (int)Math.Min((long)start + count, _snapshot.Count);
+
+        if (start >= end) { return []; }
+
+        List<DisplayRow> rows = new(end - start);
+
+        for (int display = start; display < end; display++)
+        {
+            EventLocator locator = _snapshot.At(display).Locator;
+            rows.Add(new DisplayRow(locator, Reader(locator).GetDetailLean(locator)));
+        }
+
+        return rows;
+    }
+
+    public bool TryGetDetail(EventLocator locator, [NotNullWhen(true)] out ResolvedEvent? detail)
+    {
+        if (TryGetReader(locator, out IEventColumnReader? reader))
+        {
+            detail = reader.GetDetail(locator);
+
+            return true;
+        }
+
+        detail = null;
+
+        return false;
+    }
+
+    public bool TryGetTimeTicks(EventLocator locator, out long ticks)
+    {
+        if (TryGetReader(locator, out IEventColumnReader? reader))
+        {
+            ticks = reader.GetTimeTicks(locator);
+
+            return true;
+        }
+
+        ticks = 0;
+
+        return false;
+    }
+
+    public bool TryGetTimeTicksRange(out long minTicks, out long maxTicks, CancellationToken cancellationToken)
+    {
+        Partition partition = GetPartition();
+        long min = long.MaxValue;
+        long max = long.MinValue;
+        bool any = false;
+
+        for (int slot = 0; slot < _readers.Length; slot++)
+        {
+            if (!_readers[slot]
+                .TryGetTimeTicksRange(partition.RankByPhysical[slot],
+                    out long readerMin,
+                    out long readerMax,
+                    cancellationToken))
+            {
+                continue;
+            }
+
+            if (readerMin < min) { min = readerMin; }
+
+            if (readerMax > max) { max = readerMax; }
+
+            any = true;
+        }
+
+        minTicks = any ? min : 0;
+        maxTicks = any ? max : 0;
+
+        return any;
+    }
+
+    private Dictionary<ValueKey, EventLocator> BuildByKey()
+    {
+        int count = _snapshot.Count;
+        Dictionary<ValueKey, EventLocator> map = new(count);
+
+        for (int display = 0; display < count; display++)
+        {
+            EventLocator locator = _snapshot.At(display).Locator;
+
+            if (ValueKey.TryCreate(Reader(locator).GetDetailLean(locator), out ValueKey key))
+            {
+                map.TryAdd(key, locator);
+            }
+        }
+
+        return map;
+    }
+
+    private Partition GetPartition()
+    {
+        Partition? partition = Volatile.Read(ref _partition);
+
+        if (partition is not null) { return partition; }
+
+        int[][] rankByPhysical = new int[_readers.Length][];
+        List<int>[] surviving = new List<int>[_readers.Length];
+
+        for (int slot = 0; slot < _readers.Length; slot++)
+        {
+            rankByPhysical[slot] = new int[_readers[slot].Count];
+            Array.Fill(rankByPhysical[slot], -1);
+            surviving[slot] = [];
+        }
+
+        int count = _snapshot.Count;
+
+        for (int display = 0; display < count; display++)
+        {
+            EventLocator locator = _snapshot.At(display).Locator;
+
+            if (!_slotByLogGeneration.TryGetValue(new LogGeneration(locator.LogId, locator.Generation), out int slot))
+            {
+                throw new InvalidOperationException(
+                    $"The snapshot displays a row for out-of-scope member '{locator.LogId}' generation {locator.Generation}.");
+            }
+
+            rankByPhysical[slot][locator.Index] = display;
+            surviving[slot].Add(locator.Index);
+        }
+
+        int[][] survivingOrder = new int[_readers.Length][];
+
+        for (int slot = 0; slot < _readers.Length; slot++) { survivingOrder[slot] = [.. surviving[slot]]; }
+
+        partition = new Partition(rankByPhysical, survivingOrder);
+
+        return Interlocked.CompareExchange(ref _partition, partition, null) ?? partition;
+    }
+
+    private IEventColumnReader Reader(in EventLocator locator)
+    {
+        if (TryGetReader(locator, out IEventColumnReader? reader)) { return reader; }
+
+        throw new KeyNotFoundException(
+            $"Locator '{locator.LogId}' generation {locator.Generation} index {locator.Index} is not in this view's scope.");
+    }
+
+    private byte[][] ResolveChildWinners(byte[] highlightWinners)
+    {
+        ArgumentNullException.ThrowIfNull(highlightWinners);
+
+        return _highlightHandles.TryGetValue(highlightWinners, out byte[][]? childWinners) ? childWinners :
+            throw new InvalidOperationException("Combined highlight winners must be captured before tie bucketing.");
+    }
+
+    private bool TryGetReader(in EventLocator locator, [NotNullWhen(true)] out IEventColumnReader? reader)
+    {
+        if (_slotByLogGeneration.TryGetValue(new LogGeneration(locator.LogId, locator.Generation), out int slot))
+        {
+            IEventColumnReader candidate = _readers[slot];
+
+            if (locator.Index >= 0 && locator.Index < candidate.Count)
+            {
+                reader = candidate;
+
+                return true;
+            }
+        }
+
+        reader = null;
+
+        return false;
+    }
+
+    private sealed record Partition(int[][] RankByPhysical, int[][] SurvivingOrder);
+
+    private sealed record HighlightCache(int PlanKey, byte[][] ChildWinners);
+}
diff --git a/src/EventLogExpert.Runtime/LogTable/OrderedView/IReaderResolver.cs b/src/EventLogExpert.Runtime/LogTable/OrderedView/IReaderResolver.cs
new file mode 100644
index 000000000..10db633d4
--- /dev/null
+++ b/src/EventLogExpert.Runtime/LogTable/OrderedView/IReaderResolver.cs
@@ -0,0 +1,59 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
+using System.Diagnostics.CodeAnalysis;
+
+namespace EventLogExpert.Runtime.LogTable.OrderedView;
+
+internal interface IReaderResolver
+{
+    int Count { get; }
+
+    IEventColumnReader Resolve(in EventLocator locator);
+
+    bool TryResolve(in EventLocator locator, [NotNullWhen(true)] out IEventColumnReader? reader);
+
+    bool TryResolveByLog(EventLogId logId, int generation, [NotNullWhen(true)] out IEventColumnReader? reader);
+}
+
+internal sealed class FrozenReaderResolver : IReaderResolver
+{
+    private readonly Dictionary<LogGeneration, IEventColumnReader> _readers;
+
+    internal FrozenReaderResolver(Dictionary<LogGeneration, IEventColumnReader> readers) => _readers = readers;
+
+    public int Count => _readers.Count;
+
+    public IEventColumnReader Resolve(in EventLocator locator) =>
+        TryResolve(locator, out IEventColumnReader? reader)
+            ? reader
+            : throw new KeyNotFoundException($"{nameof(FrozenReaderResolver)}: no frozen reader for the requested log generation.");
+
+    public bool TryResolve(in EventLocator locator, [NotNullWhen(true)] out IEventColumnReader? reader) =>
+        _readers.TryGetValue(new LogGeneration(locator.LogId, locator.Generation), out reader);
+
+    public bool TryResolveByLog(EventLogId logId, int generation, [NotNullWhen(true)] out IEventColumnReader? reader) =>
+        _readers.TryGetValue(new LogGeneration(logId, generation), out reader);
+}
+
+internal sealed class LiveReaderResolver : IReaderResolver
+{
+    private readonly Dictionary<LogGeneration, IEventColumnReader> _latestReaders;
+
+    internal LiveReaderResolver(Dictionary<LogGeneration, IEventColumnReader> latestReaders) => _latestReaders = latestReaders;
+
+    public int Count => _latestReaders.Count;
+
+    public IEventColumnReader Resolve(in EventLocator locator) =>
+        TryResolve(locator, out IEventColumnReader? reader)
+            ? reader
+            : throw new KeyNotFoundException($"{nameof(LiveReaderResolver)}: no live reader for the requested log generation.");
+
+    public bool TryResolve(in EventLocator locator, [NotNullWhen(true)] out IEventColumnReader? reader) =>
+        _latestReaders.TryGetValue(new LogGeneration(locator.LogId, locator.Generation), out reader);
+
+    public bool TryResolveByLog(EventLogId logId, int generation, [NotNullWhen(true)] out IEventColumnReader? reader) =>
+        _latestReaders.TryGetValue(new LogGeneration(logId, generation), out reader);
+}
diff --git a/src/EventLogExpert.Runtime/LogTable/OrderedView/LogGeneration.cs b/src/EventLogExpert.Runtime/LogTable/OrderedView/LogGeneration.cs
new file mode 100644
index 000000000..57d98d3e3
--- /dev/null
+++ b/src/EventLogExpert.Runtime/LogTable/OrderedView/LogGeneration.cs
@@ -0,0 +1,8 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.EventLogs;
+
+namespace EventLogExpert.Runtime.LogTable.OrderedView;
+
+internal readonly record struct LogGeneration(EventLogId LogId, int Generation);
diff --git a/src/EventLogExpert.Runtime/LogTable/OrderedView/OrderKey.cs b/src/EventLogExpert.Runtime/LogTable/OrderedView/OrderKey.cs
new file mode 100644
index 000000000..f28f0f77e
--- /dev/null
+++ b/src/EventLogExpert.Runtime/LogTable/OrderedView/OrderKey.cs
@@ -0,0 +1,8 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.Events;
+
+namespace EventLogExpert.Runtime.LogTable.OrderedView;
+
+internal readonly record struct OrderKey(EventLocator Locator);
diff --git a/src/EventLogExpert.Runtime/LogTable/OrderedView/OrderKeyComparerFactory.cs b/src/EventLogExpert.Runtime/LogTable/OrderedView/OrderKeyComparerFactory.cs
new file mode 100644
index 000000000..b1f3cbc7d
--- /dev/null
+++ b/src/EventLogExpert.Runtime/LogTable/OrderedView/OrderKeyComparerFactory.cs
@@ -0,0 +1,64 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.Events;
+
+namespace EventLogExpert.Runtime.LogTable.OrderedView;
+
+internal static class OrderKeyComparerFactory
+{
+    internal static IComparer<OrderKey> Empty { get; } = new EmptyOrderKeyComparer();
+
+    internal static IComparer<OrderKey> Create(SortContext context, IReaderResolver resolver)
+    {
+        ResolvedEventOrdering.CrossComparison cross = ResolvedEventOrdering.SelectCrossColumnComparer(
+            context.OrderBy, context.IsDescending, context.GroupBy, context.IsGroupDescending);
+
+        return new DelegatingOrderKeyComparer(cross, resolver);
+    }
+
+    private sealed class EmptyOrderKeyComparer : IComparer<OrderKey>
+    {
+        public int Compare(OrderKey x, OrderKey y) => 0;
+    }
+}
+
+internal sealed class DelegatingOrderKeyComparer : IComparer<OrderKey>
+{
+    private readonly ResolvedEventOrdering.CrossComparison _cross;
+    private readonly IReaderResolver _resolver;
+
+    internal DelegatingOrderKeyComparer(ResolvedEventOrdering.CrossComparison cross, IReaderResolver resolver)
+    {
+        _cross = cross;
+        _resolver = resolver;
+    }
+
+    internal int PinnedReaderCount => _resolver.Count;
+
+    internal IReaderResolver Resolver => _resolver;
+
+    public int Compare(OrderKey x, OrderKey y)
+    {
+        EventLocator left = x.Locator;
+        EventLocator right = y.Locator;
+
+        IEventColumnReader readerLeft = _resolver.Resolve(left);
+        IEventColumnReader readerRight = _resolver.Resolve(right);
+
+        int byColumn = _cross(readerLeft, left, readerRight, right);
+
+        return byColumn != 0 ? byColumn : CompareIdentity(left, right);
+    }
+
+    private static int CompareIdentity(in EventLocator left, in EventLocator right)
+    {
+        int byLog = left.LogId.Value.CompareTo(right.LogId.Value);
+
+        if (byLog != 0) { return byLog; }
+
+        if (left.Generation != right.Generation) { return left.Generation < right.Generation ? -1 : 1; }
+
+        return left.Index.CompareTo(right.Index);
+    }
+}
diff --git a/src/EventLogExpert.Runtime/LogTable/OrderedView/OrderedColumnView.cs b/src/EventLogExpert.Runtime/LogTable/OrderedView/OrderedColumnView.cs
new file mode 100644
index 000000000..70c533caa
--- /dev/null
+++ b/src/EventLogExpert.Runtime/LogTable/OrderedView/OrderedColumnView.cs
@@ -0,0 +1,454 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.Events;
+using EventLogExpert.Filtering.Compilation;
+using EventLogExpert.Filtering.Persistence;
+using System.Diagnostics.CodeAnalysis;
+
+namespace EventLogExpert.Runtime.LogTable.OrderedView;
+
+internal sealed class OrderedColumnView : IEventColumnView
+{
+    private readonly IEventColumnReader _reader;
+    private readonly OrderedViewSnapshot _snapshot;
+
+    private Dictionary<ValueKey, int>? _byKey;
+    private HighlightWinnerCache? _highlightCache;
+    private PhysicalProjection? _projection;
+
+    internal OrderedColumnView(OrderedViewSnapshot snapshot, IEventColumnReader reader)
+    {
+        ArgumentNullException.ThrowIfNull(snapshot);
+        ArgumentNullException.ThrowIfNull(reader);
+
+        _snapshot = snapshot;
+        _reader = reader;
+    }
+
+    public int Count => _snapshot.Count;
+
+    public void BucketTimeTicksByEventData(
+        long minTicks,
+        long bucketSpanTicks,
+        int bucketCount,
+        string fieldName,
+        long[] targetCodes,
+        int[] slotCounts,
+        CancellationToken cancellationToken) =>
+        _reader.BucketTimeTicksByEventData(
+            RankByPhysical(),
+            minTicks,
+            bucketSpanTicks,
+            bucketCount,
+            fieldName,
+            targetCodes,
+            slotCounts,
+            cancellationToken);
+
+    public void BucketTimeTicksByEventDataHResult(
+        long minTicks,
+        long bucketSpanTicks,
+        int bucketCount,
+        string fieldName,
+        IReadOnlyCollection<string> eligibleProviders,
+        IReadOnlyList<string> userDataErrorCodePaths,
+        long[] targetCodes,
+        int[] slotCounts,
+        CancellationToken cancellationToken) =>
+        _reader.BucketTimeTicksByEventDataHResult(
+            RankByPhysical(),
+            minTicks,
+            bucketSpanTicks,
+            bucketCount,
+            fieldName,
+            eligibleProviders,
+            userDataErrorCodePaths,
+            targetCodes,
+            slotCounts,
+            cancellationToken);
+
+    public void BucketTimeTicksByEventDataHResultWithTie(
+        byte[] highlightWinners,
+        uint[] slotColorMask,
+        long minTicks,
+        long bucketSpanTicks,
+        int bucketCount,
+        string fieldName,
+        IReadOnlyCollection<string> eligibleProviders,
+        IReadOnlyList<string> userDataErrorCodePaths,
+        long[] targetCodes,
+        int[] slotCounts,
+        CancellationToken cancellationToken) =>
+        _reader.BucketTimeTicksByEventDataHResultWithTie(
+            RankByPhysical(),
+            highlightWinners,
+            slotColorMask,
+            minTicks,
+            bucketSpanTicks,
+            bucketCount,
+            fieldName,
+            eligibleProviders,
+            userDataErrorCodePaths,
+            targetCodes,
+            slotCounts,
+            cancellationToken);
+
+    public void BucketTimeTicksByEventDataString(
+        long minTicks,
+        long bucketSpanTicks,
+        int bucketCount,
+        string[] candidateFields,
+        IReadOnlyDictionary<string, int> rawValueToSlot,
+        int slotCount,
+        int[] slotCounts,
+        CancellationToken cancellationToken) =>
+        _reader.BucketTimeTicksByEventDataString(
+            RankByPhysical(),
+            minTicks,
+            bucketSpanTicks,
+            bucketCount,
+            candidateFields,
+            rawValueToSlot,
+            slotCount,
+            slotCounts,
+            cancellationToken);
+
+    public void BucketTimeTicksByEventDataStringWithTie(
+        byte[] highlightWinners,
+        uint[] slotColorMask,
+        long minTicks,
+        long bucketSpanTicks,
+        int bucketCount,
+        string[] candidateFields,
+        IReadOnlyDictionary<string, int> rawValueToSlot,
+        int slotCount,
+        int[] slotCounts,
+        CancellationToken cancellationToken) =>
+        _reader.BucketTimeTicksByEventDataStringWithTie(
+            RankByPhysical(),
+            highlightWinners,
+            slotColorMask,
+            minTicks,
+            bucketSpanTicks,
+            bucketCount,
+            candidateFields,
+            rawValueToSlot,
+            slotCount,
+            slotCounts,
+            cancellationToken);
+
+    public void BucketTimeTicksByEventDataWithTie(
+        byte[] highlightWinners,
+        uint[] slotColorMask,
+        long minTicks,
+        long bucketSpanTicks,
+        int bucketCount,
+        string fieldName,
+        long[] targetCodes,
+        int[] slotCounts,
+        CancellationToken cancellationToken) =>
+        _reader.BucketTimeTicksByEventDataWithTie(
+            RankByPhysical(),
+            highlightWinners,
+            slotColorMask,
+            minTicks,
+            bucketSpanTicks,
+            bucketCount,
+            fieldName,
+            targetCodes,
+            slotCounts,
+            cancellationToken);
+
+    public void BucketTimeTicksByEventId(
+        long minTicks,
+        long bucketSpanTicks,
+        int bucketCount,
+        int[] targetIds,
+        int[] slotCounts,
+        CancellationToken cancellationToken) =>
+        _reader.BucketTimeTicksByEventId(
+            RankByPhysical(),
+            minTicks,
+            bucketSpanTicks,
+            bucketCount,
+            targetIds,
+            slotCounts,
+            cancellationToken);
+
+    public void BucketTimeTicksByEventIdWithTie(
+        byte[] highlightWinners,
+        uint[] slotColorMask,
+        long minTicks,
+        long bucketSpanTicks,
+        int bucketCount,
+        int[] targetIds,
+        int[] slotCounts,
+        CancellationToken cancellationToken) =>
+        _reader.BucketTimeTicksByEventIdWithTie(
+            RankByPhysical(),
+            highlightWinners,
+            slotColorMask,
+            minTicks,
+            bucketSpanTicks,
+            bucketCount,
+            targetIds,
+            slotCounts,
+            cancellationToken);
+
+    public void BucketTimeTicksByField(
+        long minTicks,
+        long bucketSpanTicks,
+        int bucketCount,
+        EventFieldId field,
+        string[] targetValues,
+        int[] slotCounts,
+        CancellationToken cancellationToken) =>
+        _reader.BucketTimeTicksByField(
+            RankByPhysical(),
+            minTicks,
+            bucketSpanTicks,
+            bucketCount,
+            field,
+            targetValues,
+            slotCounts,
+            cancellationToken);
+
+    public void BucketTimeTicksByFieldWithTie(
+        byte[] highlightWinners,
+        uint[] slotColorMask,
+        long minTicks,
+        long bucketSpanTicks,
+        int bucketCount,
+        EventFieldId field,
+        string[] targetValues,
+        int[] slotCounts,
+        CancellationToken cancellationToken) =>
+        _reader.BucketTimeTicksByFieldWithTie(
+            RankByPhysical(),
+            highlightWinners,
+            slotColorMask,
+            minTicks,
+            bucketSpanTicks,
+            bucketCount,
+            field,
+            targetValues,
+            slotCounts,
+            cancellationToken);
+
+    public void BucketTimeTicksBySeverity(
+        long minTicks,
+        long bucketSpanTicks,
+        int bucketCount,
+        int[] slotCounts,
+        CancellationToken cancellationToken) =>
+        _reader.BucketTimeTicksBySeverity(
+            RankByPhysical(),
+            minTicks,
+            bucketSpanTicks,
+            bucketCount,
+            slotCounts,
+            cancellationToken);
+
+    public void BucketTimeTicksBySeverityWithTie(
+        byte[] highlightWinners,
+        uint[] slotColorMask,
+        long minTicks,
+        long bucketSpanTicks,
+        int bucketCount,
+        int[] slotCounts,
+        CancellationToken cancellationToken) =>
+        _reader.BucketTimeTicksBySeverityWithTie(
+            RankByPhysical(),
+            highlightWinners,
+            slotColorMask,
+            minTicks,
+            bucketSpanTicks,
+            bucketCount,
+            slotCounts,
+            cancellationToken);
+
+    public void CountEventDataHResults(
+        string fieldName,
+        IReadOnlyCollection<string> eligibleProviders,
+        IReadOnlyList<string> userDataErrorCodePaths,
+        IDictionary<long, int> counts,
+        CancellationToken cancellationToken) =>
+        _reader.CountEventDataHResults(RankByPhysical(), fieldName, eligibleProviders, userDataErrorCodePaths, counts, cancellationToken);
+
+    public void CountEventDataStringValues(string[] candidateFields, IDictionary<string, int> counts, CancellationToken cancellationToken) =>
+        _reader.CountEventDataStringValues(RankByPhysical(), candidateFields, counts, cancellationToken);
+
+    public void CountEventDataValues(string fieldName, IDictionary<long, int> counts, CancellationToken cancellationToken) =>
+        _reader.CountEventDataValues(RankByPhysical(), fieldName, counts, cancellationToken);
+
+    public void CountEventIds(IDictionary<int, int> counts, CancellationToken cancellationToken) =>
+        _reader.CountEventIds(RankByPhysical(), counts, cancellationToken);
+
+    public void CountFieldValues(EventFieldId field, IDictionary<string, int> counts, CancellationToken cancellationToken) =>
+        _reader.CountFieldValues(RankByPhysical(), field, counts, cancellationToken);
+
+    public byte[] EnsureHighlightWinners(
+        IReadOnlyList<SavedFilter> orderedColoredFilters,
+        int planKey,
+        CancellationToken cancellationToken)
+    {
+        ArgumentNullException.ThrowIfNull(orderedColoredFilters);
+
+        HighlightWinnerCache? cache = Volatile.Read(ref _highlightCache);
+
+        if (cache is { PlanKey: var key, Winners: var winners } && key == planKey && winners.Length == _reader.Count)
+        {
+            return winners;
+        }
+
+        byte[] fresh = FilterService.ClassifyHighlightWinners(_reader, Projection().Order, orderedColoredFilters, cancellationToken);
+        Volatile.Write(ref _highlightCache, new HighlightWinnerCache(planKey, fresh));
+
+        return fresh;
+    }
+
+    public IEnumerable<ResolvedEvent> EnumerateDetail()
+    {
+        int count = _snapshot.Count;
+
+        for (int display = 0; display < count; display++)
+        {
+            yield return _reader.GetDetail(_snapshot.At(display).Locator);
+        }
+    }
+
+    public IEnumerable<ResolvedEvent> EnumerateDetailLean()
+    {
+        int count = _snapshot.Count;
+
+        for (int display = 0; display < count; display++)
+        {
+            yield return _reader.GetDetailLean(_snapshot.At(display).Locator);
+        }
+    }
+
+    public ResolvedEvent GetDetail(EventLocator locator) => _reader.GetDetail(locator);
+
+    public ResolvedEvent GetDetailLean(EventLocator locator) => _reader.GetDetailLean(locator);
+
+    public string GroupKeyAt(EventLocator locator, ColumnName column) => ResolvedEventGroupKey.For(_reader, locator, column);
+
+    public EventLocator LocatorAt(int index) => _snapshot.At(index).Locator;
+
+    public int Rank(EventLocator locator) => _snapshot.RankOf(new OrderKey(locator));
+
+    public EventLocator? ResolveByKey(ValueKey key)
+    {
+        var byKey = Volatile.Read(ref _byKey);
+
+        if (byKey is null)
+        {
+            byKey = BuildByKey();
+
+            byKey = Interlocked.CompareExchange(ref _byKey, byKey, null) ?? byKey;
+        }
+
+        return byKey.TryGetValue(key, out int physical) ? _reader.LocatorAt(physical) : null;
+    }
+
+    public IReadOnlyList<DisplayRow> Slice(int start, int count)
+    {
+        int total = _snapshot.Count;
+        int clampedStart = Math.Clamp(start, 0, total);
+        int clampedCount = Math.Clamp(count, 0, total - clampedStart);
+        List<DisplayRow> rows = new(clampedCount);
+
+        for (int offset = 0; offset < clampedCount; offset++)
+        {
+            EventLocator locator = _snapshot.At(clampedStart + offset).Locator;
+            rows.Add(new DisplayRow(locator, _reader.GetDetailLean(locator)));
+        }
+
+        return rows;
+    }
+
+    public bool TryGetDetail(EventLocator locator, [NotNullWhen(true)] out ResolvedEvent? detail)
+    {
+        if (AddressesReader(locator))
+        {
+            detail = _reader.GetDetail(locator);
+
+            return true;
+        }
+
+        detail = null;
+
+        return false;
+    }
+
+    public bool TryGetTimeTicks(EventLocator locator, out long ticks)
+    {
+        if (AddressesReader(locator))
+        {
+            ticks = _reader.GetTimeTicks(locator);
+
+            return true;
+        }
+
+        ticks = 0;
+
+        return false;
+    }
+
+    public bool TryGetTimeTicksRange(out long minTicks, out long maxTicks, CancellationToken cancellationToken) =>
+        _reader.TryGetTimeTicksRange(RankByPhysical(), out minTicks, out maxTicks, cancellationToken);
+
+    private bool AddressesReader(in EventLocator locator) =>
+        locator.LogId == _reader.LogId
+        && locator.Generation == _reader.Generation
+        && locator.Index >= 0
+        && locator.Index < _reader.Count;
+
+    private Dictionary<ValueKey, int> BuildByKey()
+    {
+        int count = _snapshot.Count;
+        var map = new Dictionary<ValueKey, int>(count);
+
+        for (int display = 0; display < count; display++)
+        {
+            EventLocator locator = _snapshot.At(display).Locator;
+
+            if (ValueKey.TryCreate(_reader.GetDetailLean(locator), out ValueKey key))
+            {
+                map.TryAdd(key, locator.Index);
+            }
+        }
+
+        return map;
+    }
+
+    private PhysicalProjection Projection()
+    {
+        var projection = Volatile.Read(ref _projection);
+
+        if (projection is not null) { return projection; }
+
+        int displayCount = _snapshot.Count;
+        int[] order = new int[displayCount];
+        int[] rankByPhysical = new int[_reader.Count];
+        Array.Fill(rankByPhysical, -1);
+
+        for (int display = 0; display < displayCount; display++)
+        {
+            int physical = _snapshot.At(display).Locator.Index;
+            order[display] = physical;
+            rankByPhysical[physical] = display;
+        }
+
+        projection = new PhysicalProjection(order, rankByPhysical);
+
+        return Interlocked.CompareExchange(ref _projection, projection, null) ?? projection;
+    }
+
+    private int[] RankByPhysical() => Projection().RankByPhysical;
+
+    private sealed record PhysicalProjection(int[] Order, int[] RankByPhysical);
+
+    private sealed record HighlightWinnerCache(int PlanKey, byte[] Winners);
+}
diff --git a/src/EventLogExpert.Runtime/LogTable/OrderedView/OrderedViewDispatchBridge.cs b/src/EventLogExpert.Runtime/LogTable/OrderedView/OrderedViewDispatchBridge.cs
new file mode 100644
index 000000000..58786274f
--- /dev/null
+++ b/src/EventLogExpert.Runtime/LogTable/OrderedView/OrderedViewDispatchBridge.cs
@@ -0,0 +1,34 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using Fluxor;
+
+namespace EventLogExpert.Runtime.LogTable.OrderedView;
+
+internal sealed class OrderedViewDispatchBridge : IDisposable
+{
+    private readonly IDispatcher _dispatcher;
+    private readonly OrderedViewWriter _writer;
+
+    public OrderedViewDispatchBridge(IDispatcher dispatcher, OrderedViewWriter writer)
+    {
+        _dispatcher = dispatcher;
+        _writer = writer;
+        _writer.Updated += OnUpdated;
+        _writer.FaultRaised += OnFaultRaised;
+    }
+
+    public void Dispose()
+    {
+        _writer.Updated -= OnUpdated;
+        _writer.FaultRaised -= OnFaultRaised;
+    }
+
+    public void NotifyShadowFault(Exception fault) => _dispatcher.Dispatch(new OrderedViewDisplayFaultedAction(fault));
+
+    private void OnFaultRaised(Exception fault, ViewIdentity? identity) =>
+        _dispatcher.Dispatch(new OrderedViewDisplayFaultedAction(fault, identity));
+
+    private void OnUpdated(OrderedViewUpdate update) =>
+        _dispatcher.Dispatch(new OrderedViewUpdatedAction(update));
+}
diff --git a/src/EventLogExpert.Runtime/LogTable/OrderedView/OrderedViewScopeState.cs b/src/EventLogExpert.Runtime/LogTable/OrderedView/OrderedViewScopeState.cs
new file mode 100644
index 000000000..f9cde2604
--- /dev/null
+++ b/src/EventLogExpert.Runtime/LogTable/OrderedView/OrderedViewScopeState.cs
@@ -0,0 +1,168 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.EventLogs;
+
+namespace EventLogExpert.Runtime.LogTable.OrderedView;
+
+internal sealed class OrderedViewScopeState
+{
+    private readonly Dictionary<LogGeneration, int> _coverage = [];
+
+    private readonly Dictionary<EventLogId, int> _highestGenerationSeen = [];
+    private readonly HashSet<EventLogId> _removedLogs = [];
+    private readonly HashSet<EventLogId> _scopeLogs = [];
+
+    private bool _scoped;
+
+    public IEnumerable<LogGeneration> Keys => _coverage.Keys;
+
+    public long ScopeVersion { get; private set; }
+
+    public EventLogId? SingleLog
+    {
+        get
+        {
+            if (!_scoped || _scopeLogs.Count != 1) { return null; }
+
+            foreach (EventLogId logId in _scopeLogs) { return logId; }
+
+            return null;
+        }
+    }
+
+    public void AdvanceCoverage(in LogGeneration key, int coveredCount)
+    {
+        if (coveredCount > _coverage.GetValueOrDefault(key)) { _coverage[key] = coveredCount; }
+    }
+
+    public int Coverage(in LogGeneration key) => _coverage.GetValueOrDefault(key);
+
+    public void EvictOutOfScope(in FrozenScope scope, IReadOnlyDictionary<EventLogId, int> activeGeneration)
+    {
+        foreach ((EventLogId logId, int active) in activeGeneration)
+        {
+            if (!scope.Includes(logId)) { RecordGenerationSeen(logId, active); }
+        }
+
+        List<LogGeneration>? evicted = null;
+
+        foreach (LogGeneration key in _coverage.Keys)
+        {
+            bool outOfScope = !scope.Includes(key.LogId);
+            bool closedGeneration = activeGeneration.TryGetValue(key.LogId, out int active) && key.Generation < active;
+
+            if (outOfScope || closedGeneration) { (evicted ??= []).Add(key); }
+        }
+
+        if (evicted is null) { return; }
+
+        foreach (LogGeneration key in evicted)
+        {
+            RecordGenerationSeen(key.LogId, key.Generation);
+            _coverage.Remove(key);
+        }
+    }
+
+    public FrozenScope Freeze()
+    {
+        HashSet<EventLogId>? scope = _scoped ? [.. _scopeLogs] : null;
+
+        return new FrozenScope(scope, [.. _removedLogs]);
+    }
+
+    public RowCoverage FreezeCoverage() => new(new Dictionary<LogGeneration, int>(_coverage));
+
+    public bool Includes(EventLogId logId) =>
+        !_removedLogs.Contains(logId) && (!_scoped || _scopeLogs.Contains(logId));
+
+    public bool IsAtOrAboveGenerationFloor(EventLogId logId, int generation) =>
+        !_highestGenerationSeen.TryGetValue(logId, out int floor) || generation >= floor;
+
+    public void RecordGenerationSeen(EventLogId logId, int generation)
+    {
+        if (_removedLogs.Contains(logId)) { return; }
+
+        if (generation > _highestGenerationSeen.GetValueOrDefault(logId)) { _highestGenerationSeen[logId] = generation; }
+    }
+
+    public void Remove(EventLogId logId)
+    {
+        _removedLogs.Add(logId);
+        _scopeLogs.Remove(logId);
+        _highestGenerationSeen.Remove(logId);
+        DropCoverage(logId);
+    }
+
+    public void Reset()
+    {
+        _coverage.Clear();
+        _highestGenerationSeen.Clear();
+        _removedLogs.Clear();
+        _scopeLogs.Clear();
+        _scoped = true;
+    }
+
+    public bool ScopeEquals(IReadOnlyCollection<EventLogId> scopeLogs)
+    {
+        if (!_scoped) { return false; }
+
+        int matched = 0;
+
+        foreach (EventLogId logId in scopeLogs)
+        {
+            if (!_scopeLogs.Contains(logId)) { return false; }
+
+            matched++;
+        }
+
+        return matched == _scopeLogs.Count;
+    }
+
+    public bool TrySetScope(IReadOnlyCollection<EventLogId> scopeLogs, long scopeVersion)
+    {
+        if (scopeVersion < ScopeVersion) { return false; }
+
+        _scoped = true;
+        ScopeVersion = scopeVersion;
+        _scopeLogs.Clear();
+
+        foreach (EventLogId logId in scopeLogs)
+        {
+            if (!_removedLogs.Contains(logId)) { _scopeLogs.Add(logId); }
+        }
+
+        return true;
+    }
+
+    private void DropCoverage(EventLogId logId)
+    {
+        List<LogGeneration>? drop = null;
+
+        foreach (LogGeneration key in _coverage.Keys)
+        {
+            if (key.LogId == logId) { (drop ??= []).Add(key); }
+        }
+
+        if (drop is null) { return; }
+
+        foreach (LogGeneration key in drop) { _coverage.Remove(key); }
+    }
+}
+
+internal readonly struct FrozenScope
+{
+    private readonly HashSet<EventLogId>? _scopeLogs;
+    private readonly HashSet<EventLogId> _removedLogs;
+
+    internal FrozenScope(HashSet<EventLogId>? scopeLogs, HashSet<EventLogId> removedLogs)
+    {
+        _scopeLogs = scopeLogs;
+        _removedLogs = removedLogs;
+    }
+
+    public int LogCount => _scopeLogs?.Count ?? 0;
+
+    public bool Includes(EventLogId logId) =>
+        !_removedLogs.Contains(logId) && (_scopeLogs is null || _scopeLogs.Contains(logId));
+}
diff --git a/src/EventLogExpert.Runtime/LogTable/OrderedView/OrderedViewShadowEffects.cs b/src/EventLogExpert.Runtime/LogTable/OrderedView/OrderedViewShadowEffects.cs
new file mode 100644
index 000000000..64d5a562b
--- /dev/null
+++ b/src/EventLogExpert.Runtime/LogTable/OrderedView/OrderedViewShadowEffects.cs
@@ -0,0 +1,208 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
+using EventLogExpert.Filtering.Compilation;
+using EventLogExpert.Filtering.Evaluation;
+using EventLogExpert.Runtime.EventLog;
+using EventLogExpert.Runtime.Histogram;
+using Fluxor;
+using System.Collections.Immutable;
+using IDispatcher = Fluxor.IDispatcher;
+
+namespace EventLogExpert.Runtime.LogTable.OrderedView;
+
+internal sealed class OrderedViewShadowEffects(
+    IState<EventLogState> eventLogState,
+    IState<LogTableState> logTableState,
+    IState<RawEventStoreState> rawEventStore,
+    OrderedViewWriter writer,
+    ViewRequestIssuer issuer,
+    OrderedViewDispatchBridge bridge,
+    IDispatcher dispatcher,
+    EventLogConcurrencyState concurrencyState)
+{
+    private readonly OrderedViewDispatchBridge _bridge = bridge;
+    private readonly EventLogConcurrencyState _concurrencyState = concurrencyState;
+    private readonly IDispatcher _dispatcher = dispatcher;
+    private readonly IState<EventLogState> _eventLogState = eventLogState;
+    private readonly ViewRequestIssuer _issuer = issuer;
+    private readonly IState<LogTableState> _logTableState = logTableState;
+    private readonly IState<RawEventStoreState> _rawEventStore = rawEventStore;
+    private readonly OrderedViewWriter _writer = writer;
+
+    [EffectMethod(typeof(AddTableAction))]
+    public Task HandleAddTable(IDispatcher dispatcher) => Shadow(Sync);
+
+    [EffectMethod]
+    public Task HandleApplyFilter(ApplyFilterAction action, IDispatcher dispatcher) => Shadow(Sync);
+
+    [EffectMethod(typeof(CloseAllButThisAction))]
+    public Task HandleCloseAllButThis(IDispatcher dispatcher) => Shadow(Sync);
+
+    [EffectMethod(typeof(CloseAllLogsAction))]
+    public Task HandleCloseAllLogs(IDispatcher dispatcher) =>
+        Shadow(() =>
+        {
+            long sequence = _issuer.ResetForCloseAll();
+
+            _dispatcher.Dispatch(new ViewRequestInvalidatedAction(sequence));
+            _writer.EnqueueClear(_logTableState.Value.ViewIdentity, sequence);
+        });
+
+    [EffectMethod(typeof(CloseGroupAction))]
+    public Task HandleCloseGroup(IDispatcher dispatcher) => Shadow(Sync);
+
+    [EffectMethod]
+    public Task HandleCloseLog(CloseLogAction action, IDispatcher dispatcher) =>
+        Shadow(() =>
+        {
+            _writer.EnqueueRemoveLog(action.LogId);
+            Sync();
+        });
+
+    [EffectMethod(typeof(CloseOthersInGroupAction))]
+    public Task HandleCloseOthersInGroup(IDispatcher dispatcher) => Shadow(Sync);
+
+    [EffectMethod]
+    public Task HandleIngestRawEvents(IngestRawEventsAction action, IDispatcher dispatcher) =>
+        Shadow(() =>
+        {
+            Sync();
+
+            foreach (EventLogId logId in action.EventsByLog.Keys) { Reconcile(logId); }
+        });
+
+    [EffectMethod(typeof(LoadColumnsCompletedAction))]
+    public Task HandleLoadColumnsCompleted(IDispatcher dispatcher) => Shadow(Sync);
+
+    [EffectMethod]
+    public Task HandleLoadEvents(LoadEventsAction action, IDispatcher dispatcher) =>
+        Shadow(() =>
+        {
+            Sync();
+            Reconcile(action.LogData.Id);
+        });
+
+    [EffectMethod]
+    public Task HandleLoadEventsPartial(LoadEventsPartialAction action, IDispatcher dispatcher) =>
+        Shadow(() =>
+        {
+            Sync();
+            Reconcile(action.LogData.Id);
+        });
+
+    [EffectMethod(typeof(MoveTabToGroupAction))]
+    public Task HandleMoveTabToGroup(IDispatcher dispatcher) => Shadow(Sync);
+
+    [EffectMethod(typeof(NewGroupFromTabAction))]
+    public Task HandleNewGroupFromTab(IDispatcher dispatcher) => Shadow(Sync);
+
+    [EffectMethod]
+    public Task HandleOrderedViewDisplayFaulted(OrderedViewDisplayFaultedAction action, IDispatcher dispatcher)
+    {
+        LogTableState state = _logTableState.Value;
+
+        if (action.Identity is not { } faulted || faulted != state.ViewIdentity) { return Task.CompletedTask; }
+
+        if (!_issuer.TryBeginRecovery(faulted, state.LastPublishedSnapshotVersion)) { return Task.CompletedTask; }
+
+        _writer.EnqueueClearFault();
+        _issuer.ResetForClear();
+
+        dispatcher.Dispatch(new OrderedViewDisplayRecoveredAction());
+
+        return Shadow(Sync);
+    }
+
+    [EffectMethod(typeof(RemoveTabFromGroupAction))]
+    public Task HandleRemoveTabFromGroup(IDispatcher dispatcher) => Shadow(Sync);
+
+    [EffectMethod(typeof(SetActiveTableAction))]
+    public Task HandleSetActiveTable(IDispatcher dispatcher) => Shadow(Sync);
+
+    [EffectMethod]
+    public Task HandleSetGroupBy(SetGroupByAction action, IDispatcher dispatcher) => Shadow(Sync);
+
+    [EffectMethod]
+    public Task HandleSetHistogramVisible(SetHistogramVisibleAction action, IDispatcher dispatcher) => Shadow(Sync);
+
+    [EffectMethod]
+    public Task HandleSetOrderBy(SetOrderByAction action, IDispatcher dispatcher) => Shadow(Sync);
+
+    [EffectMethod(typeof(SetTabGroupCollapsedAction))]
+    public Task HandleSetTabGroupCollapsed(IDispatcher dispatcher) => Shadow(Sync);
+
+    [EffectMethod(typeof(ToggleGroupSortingAction))]
+    public Task HandleToggleGroupSorting(IDispatcher dispatcher) => Shadow(Sync);
+
+    [EffectMethod(typeof(ToggleSortingAction))]
+    public Task HandleToggleSorting(IDispatcher dispatcher) => Shadow(Sync);
+
+    private void Reconcile(EventLogId logId)
+    {
+        if (_rawEventStore.Value.ByLog.TryGetValue(logId, out var store))
+        {
+            _writer.EnqueueReconcile(logId, store.CreateReader(logId));
+        }
+    }
+
+    private IReadOnlyDictionary<EventLogId, IEventColumnReader> ScopeReaders(ImmutableArray<EventLogId> scope)
+    {
+        var readers = new Dictionary<EventLogId, IEventColumnReader>(scope.Length);
+
+        foreach (EventLogId logId in scope)
+        {
+            if (_rawEventStore.Value.ByLog.TryGetValue(logId, out var store))
+            {
+                readers[logId] = store.CreateReader(logId);
+            }
+        }
+
+        return readers;
+    }
+
+    private Task Shadow(Action work)
+    {
+        if (!_issuer.Enabled) { return Task.CompletedTask; }
+
+        try { work(); }
+        catch (Exception fault)
+        {
+            _issuer.RecordFault(fault);
+            _bridge.NotifyShadowFault(fault);
+        }
+
+        return Task.CompletedTask;
+    }
+
+    private void Sync()
+    {
+        LogTableState state = _logTableState.Value;
+        ViewIdentity identity = state.ViewIdentity;
+        Filter filter = identity.Filter;
+
+        if (filter.RequiresXml &&
+            _eventLogState.Value.OpenLogs.Values.Any(log => !_concurrencyState.IsLoadedWithXml(log.Id)))
+        {
+            return;
+        }
+
+        if (_issuer.TryIssue(identity) is not { } sequence) { return; }
+
+        Func<IEventColumnReader, EventLocator, bool> survives = FilterService.CompileSurvivorPredicate(filter);
+
+        _dispatcher.Dispatch(new ViewRequestInvalidatedAction(sequence));
+
+        _writer.EnqueueViewRequest(
+            new ViewRequest(
+                identity,
+                sequence,
+                identity.Scope,
+                ScopeReaders(identity.Scope),
+                state.SortContext,
+                filter,
+                (locator, reader) => survives(reader, locator)));
+    }
+}
diff --git a/src/EventLogExpert.Runtime/LogTable/OrderedView/OrderedViewSnapshot.cs b/src/EventLogExpert.Runtime/LogTable/OrderedView/OrderedViewSnapshot.cs
new file mode 100644
index 000000000..2166a3518
--- /dev/null
+++ b/src/EventLogExpert.Runtime/LogTable/OrderedView/OrderedViewSnapshot.cs
@@ -0,0 +1,187 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
+using System.Diagnostics.CodeAnalysis;
+
+namespace EventLogExpert.Runtime.LogTable.OrderedView;
+
+internal sealed class OrderedViewSnapshot
+{
+    private readonly OrderKey[][] _chunks;
+    private readonly IComparer<OrderKey> _comparer;
+    private readonly OrderKey[] _firstOfChunk;
+    private readonly int[] _prefix;
+    private readonly Dictionary<LogGeneration, ulong[]> _presentByLogGeneration;
+
+    internal OrderedViewSnapshot(
+        OrderKey[][] chunks,
+        OrderKey[] firstOfChunk,
+        int[] prefix,
+        Dictionary<LogGeneration, ulong[]> presentByLogGeneration,
+        IComparer<OrderKey> comparer,
+        long version)
+    {
+        _chunks = chunks;
+        _firstOfChunk = firstOfChunk;
+        _prefix = prefix;
+        _presentByLogGeneration = presentByLogGeneration;
+        _comparer = comparer;
+        Version = version;
+    }
+
+    public static OrderedViewSnapshot Empty { get; } =
+        new([], [], [0], [], OrderKeyComparerFactory.Empty, 0);
+
+    public int Count => _prefix.Length == 0 ? 0 : _prefix[^1];
+
+    public long Version { get; }
+
+    internal int PinnedReaderCount => (_comparer as DelegatingOrderKeyComparer)?.PinnedReaderCount ?? 0;
+
+    public OrderKey At(int displayIndex)
+    {
+        int chunk = ChunkForOffset(displayIndex);
+
+        return _chunks[chunk][displayIndex - _prefix[chunk]];
+    }
+
+    public bool Contains(EventLogId logId, int generation, int index)
+    {
+        if (index < 0 || !_presentByLogGeneration.TryGetValue(new LogGeneration(logId, generation), out var bits))
+        {
+            return false;
+        }
+
+        int word = index >> 6;
+
+        if ((uint)word >= (uint)bits.Length) { return false; }
+
+        return (bits[word] & (1UL << (index & 63))) != 0;
+    }
+
+    public int RankOf(in OrderKey key)
+    {
+        EventLocator locator = key.Locator;
+
+        if (_chunks.Length == 0 || !Contains(locator.LogId, locator.Generation, locator.Index)) { return -1; }
+
+        int chunk = ChunkForKey(key);
+        var keys = _chunks[chunk];
+        int within = LowerBound(keys, key);
+
+        return within < keys.Length && _comparer.Compare(keys[within], key) == 0 ? _prefix[chunk] + within : -1;
+    }
+
+    public int SliceInto(int offset, int width, OrderKey[] outBuffer)
+    {
+        int total = Count;
+
+        if (offset < 0 || offset >= total || width <= 0) { return 0; }
+
+        int need = Math.Min(width, total - offset);
+        int written = 0;
+        int chunk = ChunkForOffset(offset);
+
+        while (written < need && chunk < _chunks.Length)
+        {
+            int inChunkStart = (offset + written) - _prefix[chunk];
+            int available = _chunks[chunk].Length - inChunkStart;
+
+            if (available > 0)
+            {
+                int take = Math.Min(available, need - written);
+                Array.Copy(_chunks[chunk], inChunkStart, outBuffer, written, take);
+                written += take;
+            }
+
+            chunk++;
+        }
+
+        return written;
+    }
+
+    internal bool TryGetReader(in EventLocator locator, [NotNullWhen(true)] out IEventColumnReader? reader)
+    {
+        if (_comparer is DelegatingOrderKeyComparer delegating) { return delegating.Resolver.TryResolve(locator, out reader); }
+
+        reader = null;
+
+        return false;
+    }
+
+    internal bool TryGetReaderByLog(
+        EventLogId logId,
+        int generation,
+        [NotNullWhen(true)] out IEventColumnReader? reader)
+    {
+        if (_comparer is DelegatingOrderKeyComparer delegating)
+        {
+            return delegating.Resolver.TryResolveByLog(logId, generation, out reader);
+        }
+
+        reader = null;
+
+        return false;
+    }
+
+    private int ChunkForKey(in OrderKey key)
+    {
+        int low = 0, high = _firstOfChunk.Length - 1, answer = 0;
+
+        while (low <= high)
+        {
+            int mid = (low + high) >> 1;
+
+            if (_comparer.Compare(key, _firstOfChunk[mid]) >= 0)
+            {
+                answer = mid;
+                low = mid + 1;
+            }
+            else
+            {
+                high = mid - 1;
+            }
+        }
+
+        return answer;
+    }
+
+    private int ChunkForOffset(int offset)
+    {
+        int low = 0, high = _prefix.Length - 2, answer = 0;
+
+        while (low <= high)
+        {
+            int mid = (low + high) >> 1;
+
+            if (_prefix[mid] <= offset)
+            {
+                answer = mid;
+                low = mid + 1;
+            }
+            else
+            {
+                high = mid - 1;
+            }
+        }
+
+        return answer;
+    }
+
+    private int LowerBound(OrderKey[] keys, in OrderKey key)
+    {
+        int low = 0, high = keys.Length;
+
+        while (low < high)
+        {
+            int mid = (int)(((uint)low + (uint)high) >> 1);
+
+            if (_comparer.Compare(keys[mid], key) < 0) { low = mid + 1; }
+            else { high = mid; }
+        }
+
+        return low;
+    }
+}
diff --git a/src/EventLogExpert.Runtime/LogTable/OrderedView/OrderedViewState.cs b/src/EventLogExpert.Runtime/LogTable/OrderedView/OrderedViewState.cs
new file mode 100644
index 000000000..8d806f229
--- /dev/null
+++ b/src/EventLogExpert.Runtime/LogTable/OrderedView/OrderedViewState.cs
@@ -0,0 +1,600 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
+using System.Collections.Immutable;
+using System.Runtime.InteropServices;
+
+namespace EventLogExpert.Runtime.LogTable.OrderedView;
+
+internal sealed record RebuildRequest(
+    long Generation,
+    Func<EventLocator, IEventColumnReader, bool> Predicate,
+    SortContext Context,
+    IReadOnlyDictionary<EventLogId, int> RequestedGeneration,
+    bool Hold,
+    RowCoverage Coverage,
+    IReaderResolver BeginResolver,
+    FrozenScope Scope,
+    long ScopeVersion,
+    EventLogId? SingleLog);
+
+internal sealed class OrderedViewState
+{
+    internal const int DefaultBulkBuildThreshold = 50_000;
+    private readonly Dictionary<EventLogId, int> _activeGeneration = [];
+    private readonly Dictionary<LogGeneration, IEventColumnReader> _latestReaders = [];
+    private readonly LiveReaderResolver _liveResolver;
+    private readonly Dictionary<EventLogId, int> _requestedGeneration = [];
+    private readonly OrderedViewScopeState _scopeState = new();
+
+    private SortContext _activeContext = new(null, false, null, false);
+    private ImmutableHashSet<LogGeneration> _adoptedInScope = [];
+    private FrozenScope _adoptedScope;
+    private OrderedViewSnapshot _current = OrderedViewSnapshot.Empty;
+    private long _generation;
+    private bool _holdIngest;
+    private ChunkedOrderIndex _index;
+    private Func<EventLocator, IEventColumnReader, bool> _predicate = static (_, _) => true;
+    private long _publishVersion;
+    private SortContext _requestedContext = new(null, false, null, false);
+    private Func<EventLocator, IEventColumnReader, bool> _requestedPredicate = static (_, _) => true;
+
+    internal OrderedViewState()
+    {
+        _liveResolver = new LiveReaderResolver(_latestReaders);
+        _index = new ChunkedOrderIndex(OrderKeyComparerFactory.Create(_activeContext, _liveResolver));
+        _adoptedScope = _scopeState.Freeze();
+    }
+
+    public ImmutableHashSet<LogGeneration> AdoptedInScope => _adoptedInScope;
+
+    public OrderedViewSnapshot Current => Volatile.Read(ref _current);
+
+    public long Generation => Volatile.Read(ref _generation);
+
+    public int RowCount => _scopeState.FreezeCoverage().RowCount;
+
+    public long ScopeVersion => _scopeState.ScopeVersion;
+
+    internal int TrackedGenerationCount => _requestedGeneration.Count;
+
+    internal int TrackedReaderCount => _latestReaders.Count;
+
+    public static ChunkedOrderIndex BuildIndex(RebuildRequest request) => BuildIndex(request, CancellationToken.None);
+
+    public static ChunkedOrderIndex BuildIndex(RebuildRequest request, CancellationToken cancellationToken) =>
+        BuildIndex(request, cancellationToken, DefaultBulkBuildThreshold);
+
+    public RebuildRequest BeginRebuild(Func<EventLocator, IEventColumnReader, bool> newPredicate, SortContext newContext, bool? hold = null)
+    {
+        _requestedPredicate = newPredicate;
+        _requestedContext = newContext;
+
+        if (hold == true) { _holdIngest = true; }
+
+        return CaptureRequest();
+    }
+
+    public RebuildRequest BeginReset(EventLogId logId, int newGeneration)
+    {
+        if (!_requestedGeneration.TryGetValue(logId, out int current) || newGeneration > current)
+        {
+            _requestedGeneration[logId] = newGeneration;
+        }
+
+        return CaptureRequest();
+    }
+
+    public bool CanRestampAdopted(
+        IReadOnlyCollection<EventLogId> scopeLogs,
+        IReadOnlyDictionary<EventLogId, IEventColumnReader> scopeReaders)
+    {
+        if (_holdIngest) { return false; }
+
+        if (!_scopeState.ScopeEquals(scopeLogs)) { return false; }
+
+        foreach ((EventLogId logId, IEventColumnReader reader) in scopeReaders)
+        {
+            if (!_adoptedScope.Includes(logId)) { return false; }
+
+            if (!_activeGeneration.TryGetValue(logId, out int active) || active != reader.Generation) { return false; }
+
+            if (_scopeState.Coverage(new LogGeneration(logId, reader.Generation)) < reader.Count) { return false; }
+        }
+
+        return true;
+    }
+
+    public RebuildRequest CaptureScopeReseed() => CaptureRequest();
+
+    public OrderedViewSnapshot Clear()
+    {
+        Interlocked.Increment(ref _generation);
+        _latestReaders.Clear();
+        _activeGeneration.Clear();
+        _requestedGeneration.Clear();
+        _scopeState.Reset();
+        _adoptedScope = _scopeState.Freeze();
+        _predicate = static (_, _) => true;
+        _requestedPredicate = static (_, _) => true;
+        _activeContext = new SortContext(null, false, null, false);
+        _requestedContext = new SortContext(null, false, null, false);
+        _holdIngest = false;
+        _index = new ChunkedOrderIndex(OrderKeyComparerFactory.Create(_activeContext, _liveResolver));
+
+        return PublishWith(FreezeReaders());
+    }
+
+    public bool CoversSameGenerations(IReadOnlyDictionary<EventLogId, IEventColumnReader> scopeReaders)
+    {
+        foreach ((EventLogId logId, IEventColumnReader reader) in scopeReaders)
+        {
+            if (_requestedGeneration.TryGetValue(logId, out int requested) && reader.Generation != requested)
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    public void NotifyRebuildFailed(RebuildRequest request)
+    {
+        if (request.Hold && Volatile.Read(ref _generation) == request.Generation) { _holdIngest = false; }
+    }
+
+    public OrderedViewSnapshot Publish() => PublishWith(FreezeReaders());
+
+    public bool ReconcileLog(EventLogId logId, IEventColumnReader reader)
+    {
+        if (!TryAdmitReader(logId, reader, out LogGeneration readerKey, out bool sameCountReplace)) { return false; }
+
+        int from = _scopeState.Coverage(readerKey);
+
+        _scopeState.AdvanceCoverage(readerKey, reader.Count);
+
+        bool mutated = false;
+
+        if (_adoptedScope.Includes(logId) && !_holdIngest && IsCurrent(readerKey, _activeGeneration))
+        {
+            for (int index = from; index < reader.Count; index++)
+            {
+                var locator = new EventLocator(logId, reader.Generation, index);
+
+                if (_predicate(locator, reader))
+                {
+                    _index.Insert(new OrderKey(locator));
+                    mutated = true;
+                }
+            }
+        }
+
+        bool displaysThisGeneration = reader.Count > 0 &&
+            _adoptedScope.Includes(logId) &&
+            _activeGeneration.TryGetValue(logId, out int active) &&
+            active == reader.Generation;
+
+        return mutated ||
+            (displaysThisGeneration && !_adoptedInScope.Contains(readerKey)) ||
+            (displaysThisGeneration && sameCountReplace);
+    }
+
+    public bool ReconcileScopeReaders(IReadOnlyDictionary<EventLogId, IEventColumnReader> scopeReaders)
+    {
+        bool advanced = false;
+
+        foreach ((EventLogId logId, IEventColumnReader reader) in scopeReaders)
+        {
+            if (SeedScopeReader(logId, reader)) { advanced = true; }
+        }
+
+        return advanced;
+    }
+
+    public RebuildRequest RemoveLog(EventLogId logId)
+    {
+        _scopeState.Remove(logId);
+        _requestedGeneration.Remove(logId);
+
+        return CaptureRequest();
+    }
+
+    public void RestoreRequestedFromAdopted()
+    {
+        _requestedContext = _activeContext;
+        _requestedPredicate = _predicate;
+    }
+
+    public bool SeedScopeReader(EventLogId logId, IEventColumnReader reader)
+    {
+        bool admitted = TryAdmitReader(logId, reader, out LogGeneration readerKey, out _);
+
+        if ((admitted || _latestReaders.ContainsKey(readerKey)) &&
+            reader.Generation > _requestedGeneration.GetValueOrDefault(logId, int.MinValue))
+        {
+            _requestedGeneration[logId] = reader.Generation;
+        }
+
+        if (!admitted) { return false; }
+
+        int covered = _scopeState.Coverage(readerKey);
+
+        _scopeState.AdvanceCoverage(readerKey, reader.Count);
+
+        return reader.Count > covered;
+    }
+
+    public void SupersedeInFlight() => Interlocked.Increment(ref _generation);
+
+    public bool TryAdoptRebuild(RebuildRequest request, ChunkedOrderIndex rebuilt)
+    {
+        if (Volatile.Read(ref _generation) != request.Generation) { return false; }
+
+        IReaderResolver commitResolver = FreezeReaders();
+        rebuilt.RebindInsertComparer(OrderKeyComparerFactory.Create(request.Context, commitResolver));
+
+        try
+        {
+            foreach (LogGeneration key in _scopeState.Keys)
+            {
+                if (!request.Scope.Includes(key.LogId)) { continue; }
+
+                if (!IsCurrent(key, _requestedGeneration)) { continue; }
+
+                int from = request.Coverage.CoverageOf(key);
+                int to = _scopeState.Coverage(key);
+
+                for (int index = from; index < to; index++)
+                {
+                    var locator = new EventLocator(key.LogId, key.Generation, index);
+
+                    if (request.Predicate(locator, commitResolver.Resolve(locator)))
+                    {
+                        rebuilt.Insert(new OrderKey(locator));
+                    }
+                }
+            }
+        }
+        catch
+        {
+            // Abort leaves live state intact, but must not leave ingest gated: clear the hold so rows resume (safe under
+            // pure delegation; the fast-path work owns richer re-key recovery).
+            _holdIngest = false;
+
+            throw;
+        }
+
+        _activeGeneration.Clear();
+
+        foreach (var entry in _requestedGeneration) { _activeGeneration[entry.Key] = entry.Value; }
+
+        _adoptedScope = request.Scope;
+        _index = rebuilt;
+        _predicate = request.Predicate;
+        _activeContext = request.Context;
+        _holdIngest = false;
+
+        _scopeState.EvictOutOfScope(_adoptedScope, _activeGeneration);
+        EvictGenerationsOutOfScope();
+
+        PruneReleasedReaders();
+        _index.RebindInsertComparer(OrderKeyComparerFactory.Create(_activeContext, _liveResolver));
+        PublishWith(FreezeReaders());
+
+        return true;
+    }
+
+    public bool TrySetActiveScope(IReadOnlyCollection<EventLogId> scopeLogs, long scopeVersion)
+    {
+        if (!_scopeState.TrySetScope(scopeLogs, scopeVersion)) { return false; }
+
+        Interlocked.Increment(ref _generation);
+
+        return true;
+    }
+
+    internal static ChunkedOrderIndex BuildIndex(RebuildRequest request, CancellationToken cancellationToken, int bulkThreshold)
+    {
+        if (TryBuildBulk(request, cancellationToken, bulkThreshold) is { } bulk) { return bulk; }
+
+        var rebuilt = new ChunkedOrderIndex(OrderKeyComparerFactory.Create(request.Context, request.BeginResolver));
+        int examined = 0;
+
+        foreach ((LogGeneration key, int covered) in request.Coverage.Entries)
+        {
+            if (!request.Scope.Includes(key.LogId)) { continue; }
+
+            if (!IsCurrent(key, request.RequestedGeneration)) { continue; }
+
+            for (int index = 0; index < covered; index++)
+            {
+                if ((examined++ & 8191) == 0) { cancellationToken.ThrowIfCancellationRequested(); }
+
+                var locator = new EventLocator(key.LogId, key.Generation, index);
+
+                if (request.Predicate(locator, request.BeginResolver.Resolve(locator)))
+                {
+                    rebuilt.Insert(new OrderKey(locator));
+                }
+            }
+        }
+
+        return rebuilt;
+    }
+
+    private static ChunkedOrderIndex BuildCombinedBulk(
+        RebuildRequest request,
+        CancellationToken cancellationToken,
+        List<(LogGeneration Key, int Covered)> keys,
+        IComparer<OrderKey> comparer)
+    {
+        var runKeys = new List<LogGeneration>(keys.Count);
+        var runs = new List<int[]>(keys.Count);
+        long totalSurvivors = 0;
+
+        foreach ((LogGeneration key, int covered) in keys)
+        {
+            IEventColumnReader reader = request.BeginResolver.Resolve(new EventLocator(key.LogId, key.Generation, 0));
+            int[] run = SortLogSurvivors(request, cancellationToken, key, covered, reader);
+
+            if (run.Length == 0) { continue; }
+
+            runKeys.Add(key);
+            runs.Add(run);
+            totalSurvivors += run.Length;
+        }
+
+        var merged = new OrderKey[totalSurvivors];
+        var cursors = new int[runs.Count];
+        var queue = new PriorityQueue<int, OrderKey>(comparer);
+
+        for (int run = 0; run < runs.Count; run++)
+        {
+            if ((run & 8191) == 0) { cancellationToken.ThrowIfCancellationRequested(); }
+
+            queue.Enqueue(run, HeadKey(runKeys[run], runs[run], 0));
+        }
+
+        int emitted = 0;
+
+        while (queue.TryDequeue(out int run, out OrderKey head))
+        {
+            if ((emitted & 8191) == 0) { cancellationToken.ThrowIfCancellationRequested(); }
+
+            merged[emitted++] = head;
+            int next = ++cursors[run];
+
+            if (next < runs[run].Length) { queue.Enqueue(run, HeadKey(runKeys[run], runs[run], next)); }
+        }
+
+        return ChunkedOrderIndex.FromSortedRun(merged, comparer, cancellationToken);
+    }
+
+    private static ChunkedOrderIndex BuildSingleLogBulk(
+        RebuildRequest request, CancellationToken cancellationToken, LogGeneration key, int covered, IComparer<OrderKey> comparer)
+    {
+        IEventColumnReader reader = request.BeginResolver.Resolve(new EventLocator(key.LogId, key.Generation, 0));
+        int[] sortedIndices = SortLogSurvivors(request, cancellationToken, key, covered, reader);
+
+        var sortedOrder = new OrderKey[sortedIndices.Length];
+
+        for (int display = 0; display < sortedIndices.Length; display++)
+        {
+            if ((display & 8191) == 0) { cancellationToken.ThrowIfCancellationRequested(); }
+
+            sortedOrder[display] = new OrderKey(new EventLocator(key.LogId, key.Generation, sortedIndices[display]));
+        }
+
+        return ChunkedOrderIndex.FromSortedRun(sortedOrder, comparer, cancellationToken);
+    }
+
+    private static List<(LogGeneration Key, int Covered)> CollectInScopeCurrentKeys(
+        RebuildRequest request, CancellationToken cancellationToken)
+    {
+        var keys = new List<(LogGeneration, int)>();
+        int scanned = 0;
+
+        foreach ((LogGeneration key, int covered) in request.Coverage.Entries)
+        {
+            if ((scanned++ & 8191) == 0) { cancellationToken.ThrowIfCancellationRequested(); }
+
+            if (!request.Scope.Includes(key.LogId)) { continue; }
+
+            if (!IsCurrent(key, request.RequestedGeneration)) { continue; }
+
+            keys.Add((key, covered));
+        }
+
+        return keys;
+    }
+
+    private static OrderKey HeadKey(LogGeneration key, int[] run, int cursor) =>
+        new(new EventLocator(key.LogId, key.Generation, run[cursor]));
+
+    private static bool IsCurrent(in LogGeneration key, IReadOnlyDictionary<EventLogId, int> generation) =>
+        generation.TryGetValue(key.LogId, out int current) && key.Generation == current;
+
+    private static int[] SortLogSurvivors(
+        RebuildRequest request, CancellationToken cancellationToken, LogGeneration key, int covered, IEventColumnReader reader)
+    {
+        var survivors = new List<int>(covered);
+
+        for (int index = 0; index < covered; index++)
+        {
+            if ((index & 8191) == 0) { cancellationToken.ThrowIfCancellationRequested(); }
+
+            var locator = new EventLocator(key.LogId, key.Generation, index);
+
+            if (request.Predicate(locator, reader)) { survivors.Add(index); }
+        }
+
+        return ColumnDirectSort.SortColumnDirect(
+            reader,
+            CollectionsMarshal.AsSpan(survivors),
+            request.Context.OrderBy,
+            request.Context.IsDescending,
+            request.Context.GroupBy,
+            request.Context.IsGroupDescending,
+            cancellationToken);
+    }
+
+    private static ChunkedOrderIndex? TryBuildBulk(RebuildRequest request, CancellationToken cancellationToken, int bulkThreshold)
+    {
+        List<(LogGeneration Key, int Covered)> keys = CollectInScopeCurrentKeys(request, cancellationToken);
+
+        long totalCovered = 0;
+        int summed = 0;
+
+        foreach ((LogGeneration _, int covered) in keys)
+        {
+            if ((summed++ & 8191) == 0) { cancellationToken.ThrowIfCancellationRequested(); }
+
+            totalCovered += covered;
+        }
+
+        if (totalCovered < bulkThreshold) { return null; }
+
+        IComparer<OrderKey> comparer = OrderKeyComparerFactory.Create(request.Context, request.BeginResolver);
+
+        return keys.Count switch
+        {
+            1 => BuildSingleLogBulk(request, cancellationToken, keys[0].Key, keys[0].Covered, comparer),
+            >= 2 => BuildCombinedBulk(request, cancellationToken, keys, comparer),
+            _ => null
+        };
+    }
+
+    private ImmutableHashSet<LogGeneration> BuildAdoptedInScope()
+    {
+        var builder = ImmutableHashSet.CreateBuilder<LogGeneration>();
+
+        foreach ((EventLogId logId, int generation) in _activeGeneration)
+        {
+            var key = new LogGeneration(logId, generation);
+
+            if (_adoptedScope.Includes(logId) &&
+                _latestReaders.TryGetValue(key, out IEventColumnReader? reader) &&
+                reader.Count > 0)
+            {
+                builder.Add(key);
+            }
+        }
+
+        return builder.ToImmutable();
+    }
+
+    private RebuildRequest CaptureRequest()
+    {
+        long generation = Interlocked.Increment(ref _generation);
+        var generationSnapshot = new Dictionary<EventLogId, int>(_requestedGeneration);
+
+        return new RebuildRequest(
+            generation,
+            _requestedPredicate,
+            _requestedContext,
+            generationSnapshot,
+            _holdIngest,
+            _scopeState.FreezeCoverage(),
+            FreezeReaders(),
+            _scopeState.Freeze(),
+            _scopeState.ScopeVersion,
+            _scopeState.SingleLog);
+    }
+
+    private void EvictGenerationsOutOfScope()
+    {
+        HashSet<EventLogId>? evicted = null;
+
+        foreach (EventLogId logId in _activeGeneration.Keys)
+        {
+            if (!_adoptedScope.Includes(logId)) { (evicted ??= []).Add(logId); }
+        }
+
+        foreach (EventLogId logId in _requestedGeneration.Keys)
+        {
+            if (!_adoptedScope.Includes(logId)) { (evicted ??= []).Add(logId); }
+        }
+
+        if (evicted is null) { return; }
+
+        foreach (EventLogId logId in evicted)
+        {
+            _activeGeneration.Remove(logId);
+            _requestedGeneration.Remove(logId);
+        }
+    }
+
+    private FrozenReaderResolver FreezeReaders() =>
+        new(new Dictionary<LogGeneration, IEventColumnReader>(_latestReaders));
+
+    private void PruneReleasedReaders()
+    {
+        List<LogGeneration>? released = null;
+
+        foreach (LogGeneration key in _latestReaders.Keys)
+        {
+            if (!_adoptedScope.Includes(key.LogId) ||
+                !_activeGeneration.TryGetValue(key.LogId, out int active) ||
+                key.Generation < active)
+            {
+                (released ??= []).Add(key);
+            }
+        }
+
+        if (released is null) { return; }
+
+        foreach (LogGeneration key in released)
+        {
+            _scopeState.RecordGenerationSeen(key.LogId, key.Generation);
+            _latestReaders.Remove(key);
+        }
+    }
+
+    private OrderedViewSnapshot PublishWith(IReaderResolver frozenResolver)
+    {
+        _adoptedInScope = BuildAdoptedInScope();
+
+        OrderedViewSnapshot snapshot = _index.Publish(OrderKeyComparerFactory.Create(_activeContext, frozenResolver), ++_publishVersion);
+        Volatile.Write(ref _current, snapshot);
+
+        return snapshot;
+    }
+
+    private bool TryAdmitReader(
+        EventLogId logId, IEventColumnReader reader, out LogGeneration readerKey, out bool sameCountReplace)
+    {
+        readerKey = new LogGeneration(logId, reader.Generation);
+        sameCountReplace = false;
+
+        if (!_scopeState.Includes(logId)) { return false; }
+
+        bool reestablishing = !_requestedGeneration.ContainsKey(logId) && !_activeGeneration.ContainsKey(logId);
+
+        if (reestablishing && !_scopeState.IsAtOrAboveGenerationFloor(logId, reader.Generation)) { return false; }
+
+        if (_latestReaders.TryGetValue(readerKey, out var existing))
+        {
+            bool strictlyNewer = reader.Count > existing.Count ||
+                (reader.Count == existing.Count && reader.ContentVersion > existing.ContentVersion);
+
+            if (!strictlyNewer) { return false; }
+
+            sameCountReplace = reader.Count == existing.Count;
+        }
+
+        _latestReaders[readerKey] = reader;
+
+        if (!_requestedGeneration.ContainsKey(logId)) { _requestedGeneration[logId] = reader.Generation; }
+
+        if (reader.Count > 0 &&
+            !_activeGeneration.ContainsKey(logId) &&
+            _requestedGeneration.GetValueOrDefault(logId, reader.Generation) == reader.Generation)
+        {
+            _activeGeneration[logId] = reader.Generation;
+        }
+
+        return true;
+    }
+}
diff --git a/src/EventLogExpert.Runtime/LogTable/OrderedView/OrderedViewUpdate.cs b/src/EventLogExpert.Runtime/LogTable/OrderedView/OrderedViewUpdate.cs
new file mode 100644
index 000000000..d359f131a
--- /dev/null
+++ b/src/EventLogExpert.Runtime/LogTable/OrderedView/OrderedViewUpdate.cs
@@ -0,0 +1,26 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Filtering.Evaluation;
+using System.Collections.Immutable;
+
+namespace EventLogExpert.Runtime.LogTable.OrderedView;
+
+internal abstract record OrderedViewUpdate(long SnapshotVersion, ViewIdentity? Identity, long Sequence);
+
+internal sealed record OrderedViewReady(
+    long SnapshotVersion,
+    ViewIdentity? Identity,
+    long Sequence,
+    EventLogId? SingleLogId,
+    ImmutableHashSet<LogGeneration> InScope,
+    IEventColumnView View,
+    SortContext Config,
+    Filter Filter) : OrderedViewUpdate(SnapshotVersion, Identity, Sequence)
+{
+    public ViewContentToken ContentToken { get; init; } = ViewContentToken.Empty;
+}
+
+internal sealed record OrderedViewCleared(long SnapshotVersion, ViewIdentity? Identity, long Sequence)
+    : OrderedViewUpdate(SnapshotVersion, Identity, Sequence);
diff --git a/src/EventLogExpert.Runtime/LogTable/OrderedView/OrderedViewWriter.cs b/src/EventLogExpert.Runtime/LogTable/OrderedView/OrderedViewWriter.cs
new file mode 100644
index 000000000..94a9174cc
--- /dev/null
+++ b/src/EventLogExpert.Runtime/LogTable/OrderedView/OrderedViewWriter.cs
@@ -0,0 +1,689 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
+using EventLogExpert.Filtering.Evaluation;
+using System.Collections.Immutable;
+using System.Threading.Channels;
+
+namespace EventLogExpert.Runtime.LogTable.OrderedView;
+
+internal sealed class OrderedViewWriter : IAsyncDisposable
+{
+    private readonly Task? _cadence;
+    private readonly Channel<Command> _commandChannel;
+    private readonly Task _owner;
+    private readonly List<TaskCompletionSource<OrderedViewSnapshot>> _pendingDrain = [];
+    private readonly int _publishEvery;
+    private readonly CancellationTokenSource _shutdown = new();
+    private readonly OrderedViewState _state = new();
+
+    private SortContext _adoptedConfig;
+    private Filter _adoptedFilter;
+    private int _adoptedGeneration;
+    private ViewIdentity? _adoptedIdentity;
+    private EventLogId? _adoptedLog;
+
+    private int _adoptedScopeLogCount;
+
+    private long _adoptedSequence;
+
+    private int _buildsStarted;
+
+    private (Task Task, CancellationTokenSource Cts)? _currentBuild;
+    private RebuildRequest? _desiredBuild;
+    private bool _dirty;
+
+    private bool _faultAnnounced;
+
+    private volatile Exception? _faulted;
+
+    private long _highestSequence;
+    private long _lastUpdateVersion;
+
+    private PendingBuild? _pending;
+    private Filter _pendingFilter;
+    private int _pendingRebuilds;
+
+    private bool _rebuildRequired;
+
+    private bool _seededRowsAwaitingBuild;
+
+    private int _sincePublish;
+
+    private ImmutableHashSet<LogGeneration>? _singleLogInScope;
+    private LogGeneration? _singleLogInScopeKey;
+
+    public OrderedViewWriter(int publishEvery = 256, int publishIntervalMs = 16)
+    {
+        _publishEvery = Math.Max(1, publishEvery);
+        _commandChannel = Channel.CreateUnbounded<Command>(new UnboundedChannelOptions { SingleReader = true });
+        _owner = Task.Run(RunAsync);
+
+        if (publishIntervalMs > 0) { _cadence = Task.Run(() => CadenceLoopAsync(publishIntervalMs)); }
+    }
+
+    public event Action<Exception, ViewIdentity?>? FaultRaised;
+
+    public event Action<OrderedViewUpdate>? Updated;
+
+    private enum CommandKind
+    {
+        ViewRequest,
+        Reset,
+        Adopt,
+        RebuildFailed,
+        Flush,
+        Drain,
+        Reconcile,
+        RemoveLog,
+        Clear,
+        ClearFault
+    }
+
+    public OrderedViewSnapshot Current => _state.Current;
+
+    public Exception? Faulted => _faulted;
+
+    public long Generation => _state.Generation;
+
+    public long ScopeVersion => _state.ScopeVersion;
+
+    internal int BuildsStarted => _buildsStarted;
+
+    internal Task? CurrentBuildTask => _currentBuild?.Task;
+
+    public async ValueTask DisposeAsync()
+    {
+        _shutdown.Cancel();
+        _commandChannel.Writer.TryComplete();
+
+        if (_cadence is not null)
+        {
+            try { await _cadence; }
+            catch (OperationCanceledException) { }
+        }
+        
+        await _owner;
+
+        _desiredBuild = null;
+
+        if (_currentBuild is { } build)
+        {
+            build.Cts.Cancel();
+
+            try { await build.Task; }
+            catch { /* cancelled/faulted build - ignore on dispose */ }
+
+            build.Cts.Dispose();
+            _currentBuild = null;
+        }
+
+        _shutdown.Dispose();
+    }
+
+    public async Task<OrderedViewSnapshot> DrainAsync()
+    {
+        var done = new TaskCompletionSource<OrderedViewSnapshot>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        if (!_commandChannel.Writer.TryWrite(Command.ForDrain(done))) { done.TrySetResult(_state.Current); }
+
+        return await done.Task;
+    }
+
+    public void EnqueueClear(ViewIdentity identity, long sequence) =>
+        _commandChannel.Writer.TryWrite(Command.ForClear(identity, sequence));
+
+    public void EnqueueClearFault() => _commandChannel.Writer.TryWrite(Command.ForClearFault());
+
+    public void EnqueueFlush() => _commandChannel.Writer.TryWrite(Command.ForFlush());
+
+    public void EnqueueReconcile(EventLogId logId, IEventColumnReader reader) =>
+        _commandChannel.Writer.TryWrite(Command.ForReconcile(logId, reader));
+
+    public void EnqueueRemoveLog(EventLogId logId) =>
+        _commandChannel.Writer.TryWrite(Command.ForRemoveLog(logId));
+
+    public void EnqueueResetLog(EventLogId logId, int newGeneration) =>
+        _commandChannel.Writer.TryWrite(Command.ForReset(logId, newGeneration));
+
+    public void EnqueueViewRequest(ViewRequest request) =>
+        _commandChannel.Writer.TryWrite(Command.ForViewRequest(request));
+
+    private OrderedViewUpdate BuildUpdate()
+    {
+        OrderedViewSnapshot snapshot = _state.Current;
+        ImmutableHashSet<LogGeneration> inScope = _state.AdoptedInScope;
+
+        if (_adoptedLog is { } log &&
+            inScope.Contains(new LogGeneration(log, _adoptedGeneration)) &&
+            snapshot.TryGetReaderByLog(log, _adoptedGeneration, out IEventColumnReader? reader))
+        {
+            var singleKey = new LogGeneration(log, _adoptedGeneration);
+
+            if (_singleLogInScope is null || _singleLogInScopeKey != singleKey)
+            {
+                _singleLogInScope = [singleKey];
+                _singleLogInScopeKey = singleKey;
+            }
+
+            return new OrderedViewReady(snapshot.Version,
+                _adoptedIdentity,
+                _adoptedSequence,
+                log,
+                _singleLogInScope,
+                new OrderedColumnView(snapshot, reader),
+                _adoptedConfig,
+                _adoptedFilter)
+            {
+                ContentToken = ViewContentToken.From(_adoptedFilter, _singleLogInScope, snapshot)
+            };
+        }
+
+        if (_adoptedLog is null && inScope.Count > 0)
+        {
+            return new OrderedViewReady(snapshot.Version,
+                _adoptedIdentity,
+                _adoptedSequence,
+                null,
+                inScope,
+                new CombinedOrderedColumnView(snapshot, inScope),
+                _adoptedConfig,
+                _adoptedFilter)
+            {
+                ContentToken = ViewContentToken.From(_adoptedFilter, inScope, snapshot)
+            };
+        }
+
+        if (_adoptedScopeLogCount > 0)
+        {
+            return new OrderedViewReady(snapshot.Version,
+                _adoptedIdentity,
+                _adoptedSequence,
+                _adoptedLog,
+                [],
+                EmptyColumnView.Instance,
+                _adoptedConfig,
+                _adoptedFilter);
+        }
+
+        return new OrderedViewCleared(snapshot.Version, _adoptedIdentity, _adoptedSequence);
+    }
+
+    private async Task CadenceLoopAsync(int intervalMs)
+    {
+        try
+        {
+            while (!_shutdown.IsCancellationRequested)
+            {
+                await Task.Delay(intervalMs, _shutdown.Token);
+
+                _commandChannel.Writer.TryWrite(Command.ForFlush());
+            }
+        }
+        catch (OperationCanceledException) { }
+    }
+
+    private void CancelRunningBuild()
+    {
+        _currentBuild?.Cts.Cancel();
+    }
+
+    private void CompleteRebuild()
+    {
+        _pendingRebuilds--;
+        DisposeCompletedBuild();
+
+        if (_desiredBuild is { } desired)
+        {
+            _desiredBuild = null;
+            StartRebuild(desired);
+        }
+
+        if (_pendingRebuilds != 0 || _pendingDrain.Count <= 0)
+        {
+            return;
+        }
+
+        PublishNow();
+
+        foreach (var signal in _pendingDrain) { signal.TrySetResult(_state.Current); }
+
+        _pendingDrain.Clear();
+    }
+
+    private void Dispatch(in Command command)
+    {
+        switch (command.Kind)
+        {
+            case CommandKind.ViewRequest:
+                if (command.ViewRequest is { } viewRequest) { DispatchViewRequest(viewRequest); }
+
+                break;
+            case CommandKind.Reset:
+                RebindAndStart(_state.BeginReset(command.LogId, command.Generation));
+
+                break;
+            case CommandKind.Reconcile:
+                if (command.Reader is { } reconcileReader)
+                {
+                    bool reconciled;
+
+                    try
+                    {
+                        reconciled = _state.ReconcileLog(command.LogId, reconcileReader);
+                    }
+                    catch (Exception reconcileFault)
+                    {
+                        RecordFault(reconcileFault);
+                        RequireRebuild();
+
+                        break;
+                    }
+
+                    if (reconciled)
+                    {
+                        _dirty = true;
+
+                        if (_state.Current.Count == 0) { PublishNow(); }
+                        else if (++_sincePublish >= _publishEvery) { PublishNow(); }
+                    }
+                }
+
+                break;
+            case CommandKind.RemoveLog:
+                RebindAndStart(_state.RemoveLog(command.LogId));
+
+                break;
+            case CommandKind.Clear:
+                if (command.Sequence <= _highestSequence) { break; }
+
+                _highestSequence = command.Sequence;
+                _state.Clear();
+
+                CancelRunningBuild();
+                _desiredBuild = null;
+                _dirty = false;
+                _sincePublish = 0;
+                _adoptedLog = null;
+                _adoptedScopeLogCount = 0;
+                _adoptedIdentity = command.Identity;
+                _adoptedSequence = command.Sequence;
+                _pending = null;
+
+                _rebuildRequired = false;
+                _faultAnnounced = false;
+                _seededRowsAwaitingBuild = false;
+
+                break;
+            case CommandKind.Adopt:
+                try
+                {
+                    if (command.Request is { } request && command.Rebuilt is { } rebuilt && _state.TryAdoptRebuild(request, rebuilt))
+                    {
+                        _dirty = false;
+                        _sincePublish = 0;
+
+                        _adoptedLog = request.SingleLog;
+                        _adoptedScopeLogCount = request.Scope.LogCount;
+
+                        _adoptedGeneration = _adoptedLog is { } adoptedLog ?
+                            request.RequestedGeneration.GetValueOrDefault(adoptedLog) : 0;
+
+                        _adoptedConfig = request.Context;
+                        _adoptedFilter = _pendingFilter;
+
+                        if (_pending is { } adopting && adopting.EngineGeneration == request.Generation)
+                        {
+                            _adoptedIdentity = adopting.Identity;
+                            _adoptedSequence = adopting.Sequence;
+                            _pending = null;
+                        }
+
+                        _rebuildRequired = false;
+                        _faultAnnounced = false;
+                        _seededRowsAwaitingBuild = false;
+                    }
+                    else if (_seededRowsAwaitingBuild)
+                    {
+                        // rows a retag seeded onto it, exactly as a throwing one would.
+                        RequireRebuild();
+                    }
+                }
+                catch
+                {
+                    // A replay that throws abandons this build just as surely as an off-thread failure does, so its
+                    // token has to go the same way. Left in place it would still name a build that no longer exists,
+                    // and the next request for this same view would attach to it rather than start one - so nothing
+                    // would ever be rebuilt and that identity would never be published. Generation-matched for the
+                    // same reason the off-thread path is: a newer build may already have claimed the slot.
+                    // A build that abandons here takes any rows a retag seeded onto it with it: the replay that was
+                    // going to place them never runs, and no replacement was captured. Repairing is what keeps
+                    // coverage honest about what the index holds.
+                    if (_seededRowsAwaitingBuild) { RequireRebuild(); }
+
+                    if (command.Request is { } abandoned &&
+                        _pending is { } dead &&
+                        dead.EngineGeneration == abandoned.Generation)
+                    {
+                        _pending = null;
+                    }
+
+                    throw;
+                }
+                finally
+                {
+                    CompleteRebuild();
+                }
+
+                break;
+            case CommandKind.RebuildFailed:
+                if (command.Error is { } error)
+                {
+                    var failed = command.Request;
+
+                    bool owned = failed is null || failed.Generation == _state.Generation;
+
+                    ViewIdentity? faultedIdentity = owned && _pending is { } carrying && failed is not null &&
+                        carrying.EngineGeneration == failed.Generation ?
+                        carrying.Identity :
+                        null;
+
+                    RecordFault(error, owned, faultedIdentity);
+
+                    if (failed is not null)
+                    {
+                        _state.NotifyRebuildFailed(failed);
+
+                        if (_pending is { } dead && dead.EngineGeneration == failed.Generation) { _pending = null; }
+                    }
+                }
+
+                if (_seededRowsAwaitingBuild) { RequireRebuild(); }
+
+                CompleteRebuild();
+
+                break;
+            case CommandKind.Flush:
+                if (_dirty) { PublishNow(); }
+
+                break;
+            case CommandKind.ClearFault:
+                _faulted = null;
+                _faultAnnounced = false;
+
+                break;
+            case CommandKind.Drain:
+                if (command.Signal is { } drainSignal)
+                {
+                    if (_pendingRebuilds == 0)
+                    {
+                        PublishNow();
+                        drainSignal.TrySetResult(_state.Current);
+                    }
+                    else
+                    {
+                        _pendingDrain.Add(drainSignal);
+                    }
+                }
+
+                break;
+        }
+    }
+
+    private void DispatchViewRequest(ViewRequest request)
+    {
+        if (request.Sequence <= _highestSequence) { return; }
+
+        _highestSequence = request.Sequence;
+
+        if (_pending is { } pending &&
+            pending.EngineGeneration == _state.Generation &&
+            request.Identity.CoversSameViewAs(pending.Identity) &&
+            _state.CoversSameGenerations(request.ScopeReaders))
+        {
+            if (_state.ReconcileScopeReaders(request.ScopeReaders)) { _seededRowsAwaitingBuild = true; }
+
+            _pending = pending with { Identity = request.Identity, Sequence = request.Sequence };
+
+            return;
+        }
+
+        if (!_rebuildRequired &&
+            !_seededRowsAwaitingBuild &&
+            _adoptedIdentity is { } adoptedIdentity &&
+            request.Identity.CoversSameViewAs(adoptedIdentity) &&
+            _state.CanRestampAdopted(request.ScopeLogs, request.ScopeReaders))
+        {
+            _state.SupersedeInFlight();
+            CancelRunningBuild();
+            _desiredBuild = null;
+            _pending = null;
+
+            _state.RestoreRequestedFromAdopted();
+            _pendingFilter = _adoptedFilter;
+            _adoptedIdentity = request.Identity;
+            _adoptedSequence = request.Sequence;
+            PublishNow();
+
+            return;
+        }
+
+        _pendingFilter = request.Filter;
+        _state.TrySetActiveScope(request.ScopeLogs, request.Sequence);
+        _state.ReconcileScopeReaders(request.ScopeReaders);
+
+        RebuildRequest rebuild = _state.BeginRebuild(request.Predicate, request.Context, request.Hold);
+
+        _pending = new PendingBuild(request.Identity, request.Sequence, rebuild.Generation);
+        StartRebuild(rebuild);
+    }
+
+    private void DisposeCompletedBuild()
+    {
+        _currentBuild?.Cts.Dispose();
+        _currentBuild = null;
+    }
+
+    private void FailPendingDrain()
+    {
+        foreach (var signal in _pendingDrain) { signal.TrySetResult(_state.Current); }
+
+        _pendingDrain.Clear();
+    }
+
+    private void PublishNow()
+    {
+        _state.Publish();
+        _dirty = false;
+        _sincePublish = 0;
+    }
+
+    private void RaiseUpdateIfAdvanced()
+    {
+        if (_rebuildRequired) { return; }
+
+        long version = _state.Current.Version;
+
+        if (version <= _lastUpdateVersion) { return; }
+
+        Action<OrderedViewUpdate>? handler = Updated;
+
+        if (handler is null) { return; }
+
+        OrderedViewUpdate update;
+
+        try
+        {
+            update = BuildUpdate();
+        }
+        catch (Exception buildFault)
+        {
+            _lastUpdateVersion = version;
+            RecordFault(buildFault);
+
+            return;
+        }
+
+        _lastUpdateVersion = version;
+
+        try { handler(update); }
+        catch (Exception subscriberFault) { RecordFault(subscriberFault, announce: false); }
+    }
+
+    private void RebindAndStart(RebuildRequest request)
+    {
+        if (_pending is { } pending) { _pending = pending with { EngineGeneration = request.Generation }; }
+
+        StartRebuild(request);
+    }
+
+    private void RecordFault(Exception fault, bool announce = true, ViewIdentity? identity = null)
+    {
+        _faulted ??= fault;
+
+        if (!announce || _faultAnnounced) { return; }
+
+        _faultAnnounced = true;
+
+        try { FaultRaised?.Invoke(fault, identity); }
+        catch (Exception) { /* a broken fault subscriber must not mask the original fault or kill the owner loop */ }
+    }
+
+    private void RequireRebuild()
+    {
+        if (_rebuildRequired) { return; }
+
+        _rebuildRequired = true;
+
+        RebindAndStart(_state.CaptureScopeReseed());
+    }
+
+    private async Task RunAsync()
+    {
+        var reader = _commandChannel.Reader;
+
+        while (await reader.WaitToReadAsync())
+        {
+            while (reader.TryRead(out var command))
+            {
+                try
+                {
+                    Dispatch(command);
+                }
+                catch (Exception ex)
+                {
+                    // One bad command must not kill the pipeline; record and drain.
+                    RecordFault(ex);
+
+                    if (command is { Kind: CommandKind.Drain, Signal: { } drainSignal }) { drainSignal.TrySetException(ex); }
+                }
+
+                RaiseUpdateIfAdvanced();
+            }
+        }
+
+        FailPendingDrain();
+    }
+
+    private void StartBuild(RebuildRequest request)
+    {
+        _pendingRebuilds++;
+        _buildsStarted++;
+
+        var cts = new CancellationTokenSource();
+        var token = cts.Token;
+
+        var build = Task.Run(() =>
+        {
+            try
+            {
+                ChunkedOrderIndex rebuilt = OrderedViewState.BuildIndex(request, token);
+                _commandChannel.Writer.TryWrite(Command.ForAdopt(request, rebuilt));
+            }
+            catch (OperationCanceledException) when (token.IsCancellationRequested)
+            {
+                _commandChannel.Writer.TryWrite(Command.ForRebuildFailed(null));      // superseded/shutdown - expected, not a fault
+            }
+            catch (Exception ex)
+            {
+                // Includes an OperationCanceledException the token did NOT ask for: a predicate that throws one is a
+                // faulty predicate, not a supersede, and misreporting it would swallow the fault and leave a held gate set.
+                _commandChannel.Writer.TryWrite(Command.ForRebuildFailed(ex, request));   // a faulty predicate - a real fault
+            }
+        });
+
+        _currentBuild = (build, cts);
+    }
+
+    private void StartRebuild(RebuildRequest request)
+    {
+        if (_shutdown.IsCancellationRequested) { return; }
+
+        if (_pendingRebuilds > 0)
+        {
+            _desiredBuild = request;
+            CancelRunningBuild();
+
+            return;
+        }
+
+        StartBuild(request);
+    }
+
+    private readonly struct Command
+    {
+        public CommandKind Kind { get; private init; }
+
+        public IEventColumnReader? Reader { get; private init; }
+
+        public RebuildRequest? Request { get; private init; }
+
+        public ChunkedOrderIndex? Rebuilt { get; private init; }
+
+        public TaskCompletionSource<OrderedViewSnapshot>? Signal { get; private init; }
+
+        public Exception? Error { get; private init; }
+
+        public EventLogId LogId { get; private init; }
+
+        public int Generation { get; private init; }
+
+        public ViewIdentity? Identity { get; private init; }
+
+        public long Sequence { get; private init; }
+
+        public ViewRequest? ViewRequest { get; private init; }
+
+        public static Command ForViewRequest(ViewRequest request) =>
+            new() { Kind = CommandKind.ViewRequest, ViewRequest = request };
+
+        public static Command ForReset(EventLogId logId, int generation) =>
+            new() { Kind = CommandKind.Reset, LogId = logId, Generation = generation };
+
+        public static Command ForReconcile(EventLogId logId, IEventColumnReader reader) =>
+            new() { Kind = CommandKind.Reconcile, LogId = logId, Reader = reader };
+
+        public static Command ForRemoveLog(EventLogId logId) =>
+            new() { Kind = CommandKind.RemoveLog, LogId = logId };
+
+        public static Command ForClear(ViewIdentity identity, long sequence) =>
+            new() { Kind = CommandKind.Clear, Identity = identity, Sequence = sequence };
+
+        public static Command ForAdopt(RebuildRequest request, ChunkedOrderIndex rebuilt) =>
+            new() { Kind = CommandKind.Adopt, Request = request, Rebuilt = rebuilt };
+
+        public static Command ForRebuildFailed(Exception? error, RebuildRequest? request = null) =>
+            new() { Kind = CommandKind.RebuildFailed, Error = error, Request = request };
+
+        public static Command ForFlush() => new() { Kind = CommandKind.Flush };
+
+        public static Command ForClearFault() => new() { Kind = CommandKind.ClearFault };
+
+        public static Command ForDrain(TaskCompletionSource<OrderedViewSnapshot> signal) =>
+            new() { Kind = CommandKind.Drain, Signal = signal };
+    }
+
+    private sealed record PendingBuild(ViewIdentity Identity, long Sequence, long EngineGeneration);
+}
diff --git a/src/EventLogExpert.Runtime/LogTable/OrderedView/RowCoverage.cs b/src/EventLogExpert.Runtime/LogTable/OrderedView/RowCoverage.cs
new file mode 100644
index 000000000..d2ba593a3
--- /dev/null
+++ b/src/EventLogExpert.Runtime/LogTable/OrderedView/RowCoverage.cs
@@ -0,0 +1,27 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+namespace EventLogExpert.Runtime.LogTable.OrderedView;
+
+internal sealed class RowCoverage
+{
+    private readonly Dictionary<LogGeneration, int> _byKey;
+
+    internal RowCoverage(Dictionary<LogGeneration, int> byKey) => _byKey = byKey;
+
+    public IEnumerable<KeyValuePair<LogGeneration, int>> Entries => _byKey;
+
+    public int RowCount
+    {
+        get
+        {
+            int total = 0;
+
+            foreach (int covered in _byKey.Values) { total += covered; }
+
+            return total;
+        }
+    }
+
+    public int CoverageOf(in LogGeneration key) => _byKey.GetValueOrDefault(key);
+}
diff --git a/src/EventLogExpert.Runtime/LogTable/OrderedView/ViewContentToken.cs b/src/EventLogExpert.Runtime/LogTable/OrderedView/ViewContentToken.cs
new file mode 100644
index 000000000..d7740e178
--- /dev/null
+++ b/src/EventLogExpert.Runtime/LogTable/OrderedView/ViewContentToken.cs
@@ -0,0 +1,111 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
+using EventLogExpert.Filtering.Evaluation;
+using System.Collections.Immutable;
+using System.Diagnostics;
+
+namespace EventLogExpert.Runtime.LogTable.OrderedView;
+
+internal readonly record struct ViewContentTokenReaderStamp(EventLogId LogId, int Generation, long ContentVersion, int Count);
+
+public readonly struct ViewContentToken : IEquatable<ViewContentToken>
+{
+    private readonly Filter _filter;
+    private readonly ImmutableArray<ViewContentTokenReaderStamp> _readers;
+    private readonly int _survivorCount;
+
+    private ViewContentToken(Filter filter, ImmutableArray<ViewContentTokenReaderStamp> readers, int survivorCount)
+    {
+        _filter = filter;
+        _readers = readers;
+        _survivorCount = survivorCount;
+    }
+
+    public static ViewContentToken Empty { get; } = new(default, ImmutableArray<ViewContentTokenReaderStamp>.Empty, 0);
+
+    internal static ViewContentToken From(
+        Filter filter,
+        ImmutableHashSet<LogGeneration> inScope,
+        OrderedViewSnapshot snapshot)
+    {
+        ArgumentNullException.ThrowIfNull(snapshot);
+
+        if (inScope.IsEmpty) { return Empty; }
+
+        ImmutableArray<ViewContentTokenReaderStamp>.Builder builder =
+            ImmutableArray.CreateBuilder<ViewContentTokenReaderStamp>(inScope.Count);
+
+        foreach (LogGeneration member in inScope)
+        {
+            bool resolved = snapshot.TryGetReaderByLog(member.LogId, member.Generation, out IEventColumnReader? reader);
+
+            Debug.Assert(resolved, "An in-scope member did not resolve a reader; the view constructor should have thrown.");
+
+            if (resolved)
+            {
+                builder.Add(
+                    new ViewContentTokenReaderStamp(member.LogId, member.Generation, reader!.ContentVersion, reader.Count));
+            }
+        }
+
+        return FromStamps(filter, builder.ToImmutable(), snapshot.Count);
+    }
+
+    internal static ViewContentToken FromStamps(
+        Filter filter, ImmutableArray<ViewContentTokenReaderStamp> readers, int survivorCount)
+    {
+        if (readers.IsDefaultOrEmpty) { return Empty; }
+
+        ImmutableArray<ViewContentTokenReaderStamp> sorted = readers.Sort(static (left, right) =>
+        {
+            int byLog = left.LogId.Value.CompareTo(right.LogId.Value);
+
+            return byLog != 0 ? byLog : left.Generation.CompareTo(right.Generation);
+        });
+
+        return new ViewContentToken(filter, sorted, survivorCount);
+    }
+
+    public static bool operator ==(ViewContentToken left, ViewContentToken right) => left.Equals(right);
+
+    public static bool operator !=(ViewContentToken left, ViewContentToken right) => !left.Equals(right);
+
+    public bool Equals(ViewContentToken other)
+    {
+        ImmutableArray<ViewContentTokenReaderStamp> readers =
+            _readers.IsDefault ? ImmutableArray<ViewContentTokenReaderStamp>.Empty : _readers;
+        ImmutableArray<ViewContentTokenReaderStamp> otherReaders =
+            other._readers.IsDefault ? ImmutableArray<ViewContentTokenReaderStamp>.Empty : other._readers;
+
+        if (readers.Length != otherReaders.Length || _survivorCount != other._survivorCount) { return false; }
+
+        if (readers.Length > 0 && !_filter.Equals(other._filter)) { return false; }
+
+        for (int index = 0; index < readers.Length; index++)
+        {
+            if (!readers[index].Equals(otherReaders[index])) { return false; }
+        }
+
+        return true;
+    }
+
+    public override bool Equals(object? obj) => obj is ViewContentToken other && Equals(other);
+
+    public override int GetHashCode()
+    {
+        ImmutableArray<ViewContentTokenReaderStamp> readers =
+            _readers.IsDefault ? ImmutableArray<ViewContentTokenReaderStamp>.Empty : _readers;
+
+        var hash = new HashCode();
+        hash.Add(_survivorCount);
+
+        if (readers.Length > 0) { hash.Add(_filter); }
+
+        foreach (ViewContentTokenReaderStamp reader in readers) { hash.Add(reader); }
+
+        return hash.ToHashCode();
+    }
+}
diff --git a/src/EventLogExpert.Runtime/LogTable/OrderedView/ViewRequest.cs b/src/EventLogExpert.Runtime/LogTable/OrderedView/ViewRequest.cs
new file mode 100644
index 000000000..48a9736c4
--- /dev/null
+++ b/src/EventLogExpert.Runtime/LogTable/OrderedView/ViewRequest.cs
@@ -0,0 +1,18 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
+using EventLogExpert.Filtering.Evaluation;
+
+namespace EventLogExpert.Runtime.LogTable.OrderedView;
+
+internal sealed record ViewRequest(
+    ViewIdentity Identity,
+    long Sequence,
+    IReadOnlyCollection<EventLogId> ScopeLogs,
+    IReadOnlyDictionary<EventLogId, IEventColumnReader> ScopeReaders,
+    SortContext Context,
+    Filter Filter,
+    Func<EventLocator, IEventColumnReader, bool> Predicate,
+    bool? Hold = null);
diff --git a/src/EventLogExpert.Runtime/LogTable/OrderedView/ViewRequestIssuer.cs b/src/EventLogExpert.Runtime/LogTable/OrderedView/ViewRequestIssuer.cs
new file mode 100644
index 000000000..6764979c6
--- /dev/null
+++ b/src/EventLogExpert.Runtime/LogTable/OrderedView/ViewRequestIssuer.cs
@@ -0,0 +1,75 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+namespace EventLogExpert.Runtime.LogTable.OrderedView;
+
+internal sealed class ViewRequestIssuer
+{
+    private readonly Lock _gate = new();
+
+    private volatile bool _enabled = true;
+    private Exception? _lastFault;
+    private ViewIdentity? _lastIssuedIdentity;
+
+    private ViewIdentity? _recoveringIdentity;
+    private long _recoveringWatermark;
+
+    private long _sequence;
+
+    public bool Enabled
+    {
+        get => _enabled;
+        set => _enabled = value;
+    }
+
+    public Exception? LastFault => Volatile.Read(ref _lastFault);
+
+    public void RecordFault(Exception fault) => Volatile.Write(ref _lastFault, fault);
+
+    public long ResetForClear()
+    {
+        lock (_gate)
+        {
+            _lastIssuedIdentity = null;
+
+            return ++_sequence;
+        }
+    }
+
+    public long ResetForCloseAll()
+    {
+        lock (_gate)
+        {
+            _lastIssuedIdentity = null;
+            _recoveringIdentity = null;
+            _recoveringWatermark = 0;
+
+            return ++_sequence;
+        }
+    }
+
+    public bool TryBeginRecovery(ViewIdentity identity, long servedWatermark)
+    {
+        lock (_gate)
+        {
+            if (_recoveringIdentity == identity && servedWatermark <= _recoveringWatermark) { return false; }
+
+            _recoveringIdentity = identity;
+            _recoveringWatermark = servedWatermark;
+
+            return true;
+        }
+    }
+
+    public long? TryIssue(ViewIdentity identity)
+    {
+        lock (_gate)
+        {
+            if (_lastIssuedIdentity == identity) { return null; }
+
+            _lastIssuedIdentity = identity;
+
+            return ++_sequence;
+        }
+    }
+}
diff --git a/src/EventLogExpert.Runtime/LogTable/OrderedViewDisplayFaultedAction.cs b/src/EventLogExpert.Runtime/LogTable/OrderedViewDisplayFaultedAction.cs
new file mode 100644
index 000000000..00a449cb7
--- /dev/null
+++ b/src/EventLogExpert.Runtime/LogTable/OrderedViewDisplayFaultedAction.cs
@@ -0,0 +1,6 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+namespace EventLogExpert.Runtime.LogTable;
+
+internal sealed record OrderedViewDisplayFaultedAction(Exception Fault, ViewIdentity? Identity = null);
diff --git a/src/EventLogExpert.Runtime/LogTable/OrderedViewDisplayRecoveredAction.cs b/src/EventLogExpert.Runtime/LogTable/OrderedViewDisplayRecoveredAction.cs
new file mode 100644
index 000000000..628acde55
--- /dev/null
+++ b/src/EventLogExpert.Runtime/LogTable/OrderedViewDisplayRecoveredAction.cs
@@ -0,0 +1,6 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+namespace EventLogExpert.Runtime.LogTable;
+
+internal sealed record OrderedViewDisplayRecoveredAction;
diff --git a/src/EventLogExpert.Runtime/LogTable/OrderedViewPresentation.cs b/src/EventLogExpert.Runtime/LogTable/OrderedViewPresentation.cs
new file mode 100644
index 000000000..9f1f40353
--- /dev/null
+++ b/src/EventLogExpert.Runtime/LogTable/OrderedViewPresentation.cs
@@ -0,0 +1,45 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Runtime.LogTable.OrderedView;
+using System.Collections.Immutable;
+
+namespace EventLogExpert.Runtime.LogTable;
+
+public sealed record OrderedViewPresentation(
+    IEventColumnView View,
+    EventLogId? ActiveTabId,
+    DisplayOrdering Ordering,
+    PresentationState State,
+    long Revision,
+    string? FaultCause = null,
+    bool OrderingIsStale = false)
+{
+    public DisplayIndicatorKind IndicatorKind =>
+        State switch
+        {
+            PresentationState.Faulted => DisplayIndicatorKind.Fault,
+            PresentationState.Updating when View.Count == 0 => DisplayIndicatorKind.EmptyPending,
+            PresentationState.Updating when OrderingIsStale => DisplayIndicatorKind.ReorderPending,
+            _ => DisplayIndicatorKind.None
+        };
+
+    public bool GroupsCollapsedByDefault { get; init; }
+
+    public ViewContentToken ContentToken { get; init; } = ViewContentToken.Empty;
+
+    public ImmutableHashSet<string> GroupCollapseOverrides { get; init; } =
+        ImmutableHashSet.Create<string>(StringComparer.Ordinal);
+
+    public string? ActiveLogName { get; init; }
+
+    public ImmutableDictionary<ColumnName, bool> Columns { get; init; } = ImmutableDictionary<ColumnName, bool>.Empty;
+
+    public ImmutableList<ColumnName> ColumnOrder { get; init; } = [];
+
+    public ImmutableDictionary<ColumnName, int> ColumnWidths { get; init; } = ImmutableDictionary<ColumnName, int>.Empty;
+
+    public bool IsGroupCollapsed(string groupKey) =>
+        GroupsCollapsedByDefault ^ GroupCollapseOverrides.Contains(groupKey);
+}
diff --git a/src/EventLogExpert.Runtime/LogTable/OrderedViewSource.cs b/src/EventLogExpert.Runtime/LogTable/OrderedViewSource.cs
new file mode 100644
index 000000000..59474f59e
--- /dev/null
+++ b/src/EventLogExpert.Runtime/LogTable/OrderedViewSource.cs
@@ -0,0 +1,144 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Logging.Abstractions;
+using EventLogExpert.Runtime.LogTable.OrderedView;
+using Fluxor;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace EventLogExpert.Runtime.LogTable;
+
+internal sealed class OrderedViewSource : IOrderedViewSource, IDisposable
+{
+    private readonly Lock _gate = new();
+    private readonly IState<LogTableState> _logTableState;
+    private readonly ITraceLogger _logger;
+
+    private OrderedViewPresentation _current;
+    private bool _disposed;
+
+    public OrderedViewSource(
+        IState<LogTableState> logTableState,
+        [FromKeyedServices(LogCategories.EventLog)] ITraceLogger logger)
+    {
+        ArgumentNullException.ThrowIfNull(logTableState);
+        ArgumentNullException.ThrowIfNull(logger);
+
+        _logTableState = logTableState;
+        _logger = logger;
+
+        _current = Project(logTableState.Value, revision: 0);
+        _logTableState.StateChanged += OnStateChanged;
+
+        lock (_gate)
+        {
+            var reconciled = Project(_logTableState.Value, _current.Revision + 1);
+
+            if (!IsEqual(_current, reconciled)) { _current = reconciled; }
+        }
+    }
+
+    public event Action<OrderedViewPresentation>? Updated;
+
+    public OrderedViewPresentation Current
+    {
+        get { lock (_gate) { return _current; } }
+    }
+
+    public void Dispose()
+    {
+        lock (_gate)
+        {
+            if (_disposed) { return; }
+
+            _disposed = true;
+        }
+
+        _logTableState.StateChanged -= OnStateChanged;
+    }
+
+    private static bool IsEqual(OrderedViewPresentation current, OrderedViewPresentation next) =>
+        ReferenceEquals(current.View, next.View) &&
+        current.ContentToken == next.ContentToken &&
+        current.ActiveTabId == next.ActiveTabId &&
+        current.Ordering == next.Ordering &&
+        current.State == next.State &&
+        current.FaultCause == next.FaultCause &&
+        current.OrderingIsStale == next.OrderingIsStale &&
+        current.GroupsCollapsedByDefault == next.GroupsCollapsedByDefault &&
+        current.ActiveLogName == next.ActiveLogName &&
+        (ReferenceEquals(current.GroupCollapseOverrides, next.GroupCollapseOverrides) ||
+            current.GroupCollapseOverrides.SetEquals(next.GroupCollapseOverrides)) &&
+        ReferenceEquals(current.Columns, next.Columns) &&
+        ReferenceEquals(current.ColumnOrder, next.ColumnOrder) &&
+        ReferenceEquals(current.ColumnWidths, next.ColumnWidths);
+
+    private static OrderedViewPresentation Project(LogTableState state, long revision)
+    {
+        var activeTable = state.EventTables.FirstOrDefault(table => table.Id == state.ActiveEventLogId);
+
+        var ordering = new DisplayOrdering(state.OrderBy, state.IsDescending, state.GroupBy, state.IsGroupDescending);
+
+        IEventColumnView view = activeTable is null ?
+            LogTableState.EmptyView :
+            state.DisplayedEventsForTab(activeTable);
+
+        var presentationState = state.PresentationState;
+
+        return new OrderedViewPresentation(
+            view,
+            activeTable?.Id,
+            ordering,
+            presentationState,
+            revision,
+            presentationState == PresentationState.Faulted ? state.FaultCause : null,
+            state.OrderingIsStale)
+        {
+            ActiveLogName = activeTable is { IsCombined: false } ? activeTable.LogName : null,
+            GroupsCollapsedByDefault = state.GroupsCollapsedByDefault,
+            ContentToken = activeTable is null ? ViewContentToken.Empty : state.ContentTokenForTab(activeTable),
+            GroupCollapseOverrides = state.GroupCollapseOverrides,
+            Columns = state.Columns,
+            ColumnOrder = state.ColumnOrder,
+            ColumnWidths = state.ColumnWidths
+        };
+    }
+
+    private void OnStateChanged(object? sender, EventArgs args)
+    {
+        OrderedViewPresentation published;
+
+        lock (_gate)
+        {
+            if (_disposed) { return; }
+
+            OrderedViewPresentation next = Project(_logTableState.Value, _current.Revision + 1);
+
+            if (IsEqual(_current, next)) { return; }
+
+            _current = next;
+            published = next;
+        }
+
+        Publish(published);
+    }
+
+    private void Publish(OrderedViewPresentation presentation)
+    {
+        Action<OrderedViewPresentation>? handlers = Updated;
+
+        if (handlers is null) { return; }
+
+        foreach (Delegate handler in handlers.GetInvocationList())
+        {
+            try
+            {
+                ((Action<OrderedViewPresentation>)handler)(presentation);
+            }
+            catch (Exception fault)
+            {
+                _logger.Trace($"{nameof(OrderedViewSource)}: a subscriber threw and was isolated: {fault}");
+            }
+        }
+    }
+}
diff --git a/src/EventLogExpert.Runtime/LogTable/OrderedViewUpdatedAction.cs b/src/EventLogExpert.Runtime/LogTable/OrderedViewUpdatedAction.cs
new file mode 100644
index 000000000..b93f90b65
--- /dev/null
+++ b/src/EventLogExpert.Runtime/LogTable/OrderedViewUpdatedAction.cs
@@ -0,0 +1,8 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Runtime.LogTable.OrderedView;
+
+namespace EventLogExpert.Runtime.LogTable;
+
+internal sealed record OrderedViewUpdatedAction(OrderedViewUpdate Update);
diff --git a/src/EventLogExpert.Runtime/LogTable/PresentationState.cs b/src/EventLogExpert.Runtime/LogTable/PresentationState.cs
new file mode 100644
index 000000000..0dee40e43
--- /dev/null
+++ b/src/EventLogExpert.Runtime/LogTable/PresentationState.cs
@@ -0,0 +1,13 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+namespace EventLogExpert.Runtime.LogTable;
+
+public enum PresentationState
+{
+    Current,
+
+    Updating,
+
+    Faulted
+}
diff --git a/src/EventLogExpert.Runtime/LogTable/Reducers.cs b/src/EventLogExpert.Runtime/LogTable/Reducers.cs
index e03ae8f60..d676e5ed8 100644
--- a/src/EventLogExpert.Runtime/LogTable/Reducers.cs
+++ b/src/EventLogExpert.Runtime/LogTable/Reducers.cs
@@ -3,8 +3,11 @@
 
 using EventLogExpert.Eventing.Common.Channels;
 using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
+using EventLogExpert.Filtering.Evaluation;
 using EventLogExpert.Runtime.EventLog;
 using EventLogExpert.Runtime.Histogram;
+using EventLogExpert.Runtime.LogTable.OrderedView;
 using Fluxor;
 using System.Collections.Immutable;
 
@@ -23,15 +26,12 @@ public static LogTableState ReduceAddTable(LogTableState state, AddTableAction a
             IsLoading = true
         };
 
-        var counts = state.EventCountByLog.SetItem(newTable.Id, 0);
-
         if (state.EventTables.IsEmpty)
         {
             return ResetGroupCollapseIfActiveChanged(
                 state with
                 {
                     EventTables = state.EventTables.Add(newTable),
-                    EventCountByLog = counts,
                     ActiveEventLogId = newTable.Id
                 },
                 state.ActiveEventLogId);
@@ -41,144 +41,43 @@ state with
 
         if (combinedTable is not null)
         {
-            return state with
+            // later, by which time the served view it needed to record is already gone.
+            return RetainServedView(state, state with
             {
                 EventTables = state.EventTables.Add(newTable),
-                EventCountByLog = counts
-            };
+            });
         }
 
         combinedTable = new LogView(EventLogId.Create()) { GroupId = LogTabGroupId.AllLogs };
 
-        return ResetGroupCollapseIfActiveChanged(
+        return RetainServedView(state, ResetGroupCollapseIfActiveChanged(
             state with
             {
                 EventTables = state.EventTables
                     .Add(combinedTable)
                     .Add(newTable),
-                EventCountByLog = counts,
                 ActiveEventLogId = combinedTable.Id
             },
-            state.ActiveEventLogId);
-    }
-
-    [ReducerMethod]
-    public static LogTableState ReduceAppendTableEvents(LogTableState state, AppendTableEventsAction action)
-    {
-        var table = state.EventTables.FirstOrDefault(t => action.LogId == t.Id);
-
-        if (table is null || table.IsCombined || action.View is null) { return state; }
-
-        var view = action.View;
-
-        int postCount = state.PerLogEvents.ContainsKey(table.Id) ?
-            state.PerLogEvents.Count :
-            state.PerLogEvents.Count + 1;
-
-        var context = EffectiveSortContext(
-            state.OrderBy, state.IsDescending, state.GroupBy, state.IsGroupDescending, postCount, state.TimelineVisible);
-
-        var perLog = SetLog(state.PerLogEvents, table.Id, view, context);
-        perLog = ReconcileToLogCount(perLog, state);
-        var updatedTable = SetComputerNameIfFirstEvent(table, view);
-        var counts = state.EventCountByLog.SetItem(table.Id, view.Count);
-
-        return state with
-        {
-            PerLogEvents = perLog,
-            EventTables = ReferenceEquals(updatedTable, table) ?
-                state.EventTables :
-                state.EventTables.Replace(table, updatedTable),
-            EventCountByLog = counts
-        };
-    }
-
-    [ReducerMethod]
-    public static LogTableState ReduceAppendTableEventsBatch(
-        LogTableState state,
-        AppendTableEventsBatchAction action)
-    {
-        if (action.ViewsByLog.Count == 0) { return state; }
-
-        // Skip batches for closed logs: avoid resurrecting events and stale counts.
-        bool changed = false;
-        var perLog = state.PerLogEvents;
-        var perLogVersion = state.PerLogListVersion;
-        var counts = state.EventCountByLog;
-        var updatedTables = state.EventTables;
-
-        // Count new logs first so appends use the post-batch sort context (no boundary re-sort).
-        int newLogs = 0;
-
-        foreach (var (logId, _) in action.ViewsByLog)
-        {
-            if (perLog.ContainsKey(logId)) { continue; }
-
-            var table = state.EventTables.FirstOrDefault(t => t.Id == logId);
-
-            if (table is not null && !table.IsCombined) { newLogs++; }
-        }
-
-        var context = EffectiveSortContext(
-            state.OrderBy, state.IsDescending, state.GroupBy, state.IsGroupDescending, perLog.Count + newLogs, state.TimelineVisible);
-
-        foreach (var (logId, view) in action.ViewsByLog)
-        {
-            var table = updatedTables.FirstOrDefault(t => t.Id == logId);
-
-            if (table is null || table.IsCombined) { continue; }
-
-            if (action.VersionByLog.TryGetValue(logId, out var version))
-            {
-                perLogVersion = perLogVersion.SetItem(
-                    logId,
-                    perLogVersion.TryGetValue(logId, out var existingVersion) ? Math.Min(existingVersion, version) : version);
-            }
-            else
-            {
-                perLogVersion = perLogVersion.Remove(logId);
-            }
-
-            perLog = SetLog(perLog, logId, view, context);
-            counts = counts.SetItem(logId, view.Count);
-            changed = true;
-
-            var updatedTable = SetComputerNameIfFirstEvent(table, view);
-
-            if (!ReferenceEquals(updatedTable, table))
-            {
-                updatedTables = updatedTables.Replace(table, updatedTable);
-            }
-        }
-
-        if (!changed) { return state; }
-
-        perLog = ReconcileToLogCount(perLog, state);
-
-        return state with
-        {
-            PerLogEvents = perLog,
-            PerLogListVersion = perLogVersion,
-            EventTables = updatedTables,
-            EventCountByLog = counts
-        };
+            state.ActiveEventLogId));
     }
 
     [ReducerMethod]
     public static LogTableState ReduceApplyFilter(LogTableState state, ApplyFilterAction action) =>
-        state with { DisplayListVersion = state.DisplayListVersion + 1 };
+        RetainServedView(state, state with
+            {
+                AppliedFilter = action.Filter.HasFilteringChangedFrom(state.AppliedFilter) ?
+                    action.Filter :
+                    state.AppliedFilter
+            });
 
     [ReducerMethod(typeof(CloseAllLogsAction))]
     public static LogTableState ReduceCloseAll(LogTableState state) =>
-        ResetGroupCollapse(state with
+        ResetGroupCollapse((state with
         {
             EventTables = [],
             Groups = [],
-            PerLogEvents = ImmutableDictionary<EventLogId, EventColumnView>.Empty,
-            PerLogListVersion = ImmutableDictionary<EventLogId, int>.Empty,
-            EventCountByLog = ImmutableDictionary<EventLogId, int>.Empty,
             ActiveEventLogId = null
-        });
+        }).WithClearedOrderedViewRetention());
 
     [ReducerMethod]
     public static LogTableState ReduceCloseLog(LogTableState state, CloseLogAction action)
@@ -190,24 +89,17 @@ public static LogTableState ReduceCloseLog(LogTableState state, CloseLogAction a
         var (groups, healedTables) = RemoveLogFromGroups(state.Groups, state.EventTables, action.LogId);
         var remainingTables = healedTables.RemoveAll(table => table.Id == action.LogId);
 
-        var counts = state.EventCountByLog.Remove(action.LogId);
-        var perLog = ReconcileToLogCount(state.PerLogEvents.Remove(action.LogId), state);
-        var perLogVersion = state.PerLogListVersion.Remove(action.LogId);
-
         int perLogTabsRemaining = remainingTables.Count(table => !table.IsCombined);
 
         if (perLogTabsRemaining == 0)
         {
             return ResetGroupCollapseIfActiveChanged(
-                state with
+                (state with
                 {
                     EventTables = [],
                     Groups = [],
-                    PerLogEvents = ImmutableDictionary<EventLogId, EventColumnView>.Empty,
-                    PerLogListVersion = ImmutableDictionary<EventLogId, int>.Empty,
-                    EventCountByLog = ImmutableDictionary<EventLogId, int>.Empty,
                     ActiveEventLogId = null
-                },
+                }).WithClearedOrderedViewRetention(),
                 state.ActiveEventLogId);
         }
 
@@ -215,82 +107,32 @@ state with
             ? remainingTables.RemoveAll(table => table.GroupId?.IsAll == true)
             : remainingTables;
 
+        var finalTableIds = finalTables.Select(table => table.Id).ToHashSet();
+
         var updated = state with
         {
             EventTables = finalTables,
             Groups = groups,
-            PerLogEvents = perLog,
-            PerLogListVersion = perLogVersion,
-            EventCountByLog = counts
+            RetainedOrderedViews = state.RetainedOrderedViews.RemoveRange(
+                state.RetainedOrderedViews.Keys.Where(id => !finalTableIds.Contains(id))),
         };
 
-        return ResetGroupCollapseIfActiveChanged(RepairActiveTab(updated, null), state.ActiveEventLogId);
+        return RetainServedView(state, ResetGroupCollapseIfActiveChanged(RepairActiveTab(updated, null), state.ActiveEventLogId));
     }
 
     [ReducerMethod]
-    public static LogTableState ReduceDisplayReady(
-        LogTableState state,
-        DisplayReadyAction action)
+    public static LogTableState ReduceIngestRawEvents(LogTableState state, IngestRawEventsAction action)
     {
-        if (action.Version != state.DisplayListVersion) { return state; }
-
-        var flipped = state with
-        {
-            OrderBy = state.RequestedOrderBy,
-            IsDescending = state.RequestedIsDescending,
-            GroupBy = state.RequestedGroupBy,
-            IsGroupDescending = state.RequestedIsGroupDescending
-        };
-
-        // Skip log ids absent from EventTables: log closed while filter ran.
-        var tablesById = state.EventTables
-            .Where(table => !table.IsCombined)
-            .ToDictionary(table => table.Id);
-
-        // The views were built under the requested context; heal any that pre-date it.
-        int postCount = 0;
-
-        foreach (var (logId, _) in tablesById)
-        {
-            if (action.Views.ContainsKey(logId) || state.PerLogEvents.ContainsKey(logId)) { postCount++; }
-        }
-
-        var context = EffectiveSortContext(
-            flipped.OrderBy, flipped.IsDescending, flipped.GroupBy, flipped.IsGroupDescending, postCount, flipped.TimelineVisible);
-        var perLogBuilder = ImmutableDictionary.CreateBuilder<EventLogId, EventColumnView>();
-        var perLogVersion = state.PerLogListVersion;
-        var counts = state.EventCountByLog;
         var tables = state.EventTables;
 
-        foreach (var (logId, table) in tablesById)
+        foreach (var (logId, events) in action.EventsByLog)
         {
-            if (action.Views.TryGetValue(logId, out var view))
-            {
-                perLogBuilder[logId] = view.HasContext(context) ? view : view.WithContext(context);
-                perLogVersion = perLogVersion.SetItem(logId, action.Version);
-                counts = counts.SetItem(logId, view.Count);
-
-                var updatedTable = SetComputerNameIfFirstEvent(table, view);
+            if (events.Count <= 0) { continue; }
 
-                if (!ReferenceEquals(updatedTable, table)) { tables = tables.Replace(table, updatedTable); }
-            }
-            else if (state.PerLogEvents.TryGetValue(logId, out var existingView))
-            {
-                perLogBuilder[logId] = existingView.HasContext(context) ?
-                    existingView :
-                    existingView.WithContext(context);
-            }
+            tables = LatchComputerNameForLog(tables, logId, events);
         }
 
-        var result = flipped with
-        {
-            PerLogEvents = ReconcileToLogCount(perLogBuilder.ToImmutable(), flipped),
-            PerLogListVersion = perLogVersion,
-            EventTables = tables,
-            EventCountByLog = counts
-        };
-
-        return state.RequestedGroupBy != state.GroupBy ? ResetGroupCollapse(result) : result;
+        return ReferenceEquals(tables, state.EventTables) ? state : state with { EventTables = tables };
     }
 
     [ReducerMethod]
@@ -305,38 +147,44 @@ public static LogTableState ReduceLoadColumnsCompleted(
             ColumnOrder = action.ColumnOrder
         };
 
-        bool liveGroupHidden = updated.GroupBy is { } liveGroup && IsHidden(liveGroup);
         bool requestedGroupHidden = updated.RequestedGroupBy is { } requestedGroup && IsHidden(requestedGroup);
 
-        if (!liveGroupHidden && !requestedGroupHidden) { return updated; }
-
-        var result = updated;
+        if (!requestedGroupHidden) { return updated; }
 
-        if (requestedGroupHidden)
-        {
-            result = result with { RequestedGroupBy = null, RequestedIsGroupDescending = false };
-        }
+        var result = updated with { RequestedGroupBy = null, RequestedIsGroupDescending = false };
 
-        if (liveGroupHidden)
-        {
-            result = result with
-            {
-                GroupBy = null,
-                IsGroupDescending = false,
-                GroupsCollapsedByDefault = false,
-                GroupCollapseOverrides = ImmutableHashSet.Create<string>(StringComparer.Ordinal),
-                PerLogEvents = ResortAllLogs(
-                    updated.PerLogEvents,
-                    EffectiveSortContext(updated.OrderBy, updated.IsDescending, null, false, updated.PerLogEvents.Count, updated.TimelineVisible))
-            };
-        }
-
-        return result;
+        return RetainServedView(state, result);
 
         bool IsHidden(ColumnName column) =>
             !action.LoadedColumns.TryGetValue(column, out bool isVisible) || !isVisible;
     }
 
+    [ReducerMethod]
+    public static LogTableState ReduceLoadEvents(LogTableState state, LoadEventsAction action)
+    {
+        var table = state.EventTables.FirstOrDefault(candidate => action.LogData.Id == candidate.Id);
+
+        if (table is null || table.IsCombined) { return state; }
+
+        var finalized = SetComputerNameFromRawEvents(table, action.Events);
+
+        if (finalized.IsLoading) { finalized = finalized with { IsLoading = false }; }
+
+        return ReferenceEquals(finalized, table) ?
+            state :
+            state with { EventTables = state.EventTables.Replace(table, finalized) };
+    }
+
+    [ReducerMethod]
+    public static LogTableState ReduceLoadEventsPartial(LogTableState state, LoadEventsPartialAction action)
+    {
+        if (action.Events.Count == 0) { return state; }
+
+        var tables = LatchComputerNameForLog(state.EventTables, action.LogData.Id, action.Events);
+
+        return ReferenceEquals(tables, state.EventTables) ? state : state with { EventTables = tables };
+    }
+
     [ReducerMethod]
     public static LogTableState ReduceMoveTabToGroup(LogTableState state, MoveTabToGroupAction action)
     {
@@ -352,7 +200,7 @@ public static LogTableState ReduceMoveTabToGroup(LogTableState state, MoveTabToG
                 RemoveLogFromGroups(state.Groups, state.EventTables, action.TabId);
             var ungrouped = state with { Groups = ungroupedGroups, EventTables = ungroupedTables };
 
-            return ResetGroupCollapseIfActiveChanged(RepairActiveTab(ungrouped, null), state.ActiveEventLogId);
+            return RetainServedView(state, ResetGroupCollapseIfActiveChanged(RepairActiveTab(ungrouped, null), state.ActiveEventLogId));
         }
 
         var target = state.Groups.FirstOrDefault(group => group.Id == action.TargetGroupId);
@@ -364,8 +212,8 @@ public static LogTableState ReduceMoveTabToGroup(LogTableState state, MoveTabToG
         var headerId = tables.FirstOrDefault(table => table.GroupId == action.TargetGroupId)?.Id;
         var updated = state with { Groups = updatedGroups, EventTables = tables };
 
-        return ResetGroupCollapseIfActiveChanged(
-            RedirectActiveToGroupIfHidden(RepairActiveTab(updated, headerId)), state.ActiveEventLogId);
+        return RetainServedView(state, ResetGroupCollapseIfActiveChanged(
+            RedirectActiveToGroupIfHidden(RepairActiveTab(updated, headerId)), state.ActiveEventLogId));
     }
 
     [ReducerMethod]
@@ -385,7 +233,67 @@ public static LogTableState ReduceNewGroupFromTab(LogTableState state, NewGroupF
         var tables = prunedTables.Insert(childIndex, header);
         var updated = state with { Groups = prunedGroups.Add(group), EventTables = tables };
 
-        return ResetGroupCollapseIfActiveChanged(RepairActiveTab(updated, header.Id), state.ActiveEventLogId);
+        return RetainServedView(state, ResetGroupCollapseIfActiveChanged(RepairActiveTab(updated, header.Id), state.ActiveEventLogId));
+    }
+
+    [ReducerMethod]
+    public static LogTableState ReduceOrderedViewDisplayFaulted(LogTableState state, OrderedViewDisplayFaultedAction action)
+    {
+        if (action.Identity is { } faulted && faulted != state.ViewIdentity) { return state; }
+
+        return RetainServedView(state, state with
+            {
+                OrderedViewDisplayEnabled = false,
+                ActiveOrderedView = null,
+                FaultCause = Describe(action.Fault)
+            });
+    }
+
+    [ReducerMethod(typeof(OrderedViewDisplayRecoveredAction))]
+    public static LogTableState ReduceOrderedViewDisplayRecovered(
+        LogTableState state) =>
+        state.OrderedViewDisplayEnabled ?
+            state :
+            state with
+            {
+                OrderedViewDisplayEnabled = true,
+                FaultCause = null
+            };
+
+    [ReducerMethod]
+    public static LogTableState ReduceOrderedViewUpdated(LogTableState state, OrderedViewUpdatedAction action)
+    {
+        LogTableState next = action.Update switch
+        {
+            OrderedViewReady view
+                when view.SnapshotVersion > state.LastPublishedSnapshotVersion
+                    && view.Sequence >= state.HighestInvalidationSequence
+                    && view.Identity == state.ViewIdentity =>
+                AdoptEngineOrdering(state,
+                    state with
+                    {
+                        ActiveOrderedView = view,
+                        LastPublishedSnapshotVersion = view.SnapshotVersion,
+
+                        OrderedViewDisplayEnabled = true,
+                        FaultCause = null
+                    }),
+            OrderedViewCleared invalidation
+                when invalidation.SnapshotVersion > state.LastPublishedSnapshotVersion
+                    && invalidation.Sequence >= state.HighestInvalidationSequence
+                    && invalidation.Identity == state.ViewIdentity =>
+                RetainServedView(state, state with
+                    {
+                        ActiveOrderedView = null,
+                        LastPublishedSnapshotVersion = invalidation.SnapshotVersion,
+
+                        OrderedViewDisplayEnabled = true,
+                        FaultCause = null
+                    }),
+            _ => state
+        };
+
+        return next;
     }
 
     [ReducerMethod]
@@ -396,7 +304,7 @@ public static LogTableState ReduceRemoveTabFromGroup(LogTableState state, Remove
         var (groups, tables) = RemoveLogFromGroups(state.Groups, state.EventTables, action.TabId);
         var updated = state with { Groups = groups, EventTables = tables };
 
-        return ResetGroupCollapseIfActiveChanged(RepairActiveTab(updated, null), state.ActiveEventLogId);
+        return RetainServedView(state, ResetGroupCollapseIfActiveChanged(RepairActiveTab(updated, null), state.ActiveEventLogId));
     }
 
     [ReducerMethod]
@@ -443,9 +351,9 @@ public static LogTableState ReduceSetActiveTable(LogTableState state, SetActiveT
 
         if (activeTable is null) { return state; }
 
-        return ResetGroupCollapseIfActiveChanged(
+        return RetainServedView(state, ResetGroupCollapseIfActiveChanged(
             state with { ActiveEventLogId = activeTable.Id },
-            state.ActiveEventLogId);
+            state.ActiveEventLogId));
     }
 
     [ReducerMethod]
@@ -473,12 +381,11 @@ public static LogTableState ReduceSetGroupBy(LogTableState state, SetGroupByActi
     {
         if (state.RequestedGroupBy == action.GroupBy) { return state; }
 
-        return state with
+        return RetainServedView(state, state with
         {
             RequestedGroupBy = action.GroupBy,
-            RequestedIsGroupDescending = false,
-            DisplayListVersion = state.DisplayListVersion + 1
-        };
+            RequestedIsGroupDescending = false
+        });
     }
 
     [ReducerMethod]
@@ -486,34 +393,24 @@ public static LogTableState ReduceSetHistogramVisible(LogTableState state, SetHi
     {
         if (state.TimelineVisible == action.IsVisible) { return state; }
 
-        // A single log with no explicit sort takes its default order from timeline visibility, so bump the display version
-        // only when that republish will actually follow (see FilteringEffects.HandleSetHistogramVisible). Bumping on a
-        // combined or explicitly sorted toggle would reject an in-flight republish carrying the pre-bump version with no replacement.
-        bool willResort = state.PerLogEvents.Count == 1 &&
-            state.RequestedOrderBy is null &&
-            state.RequestedGroupBy is null;
-
-        return state with
+        return RetainServedView(state, state with
         {
-            TimelineVisible = action.IsVisible,
-            DisplayListVersion = willResort ? state.DisplayListVersion + 1 : state.DisplayListVersion
-        };
+            TimelineVisible = action.IsVisible
+        });
     }
 
     [ReducerMethod]
     public static LogTableState ReduceSetOrderBy(LogTableState state, SetOrderByAction action) =>
-        state.RequestedOrderBy.Equals(action.OrderBy) ?
+        RetainServedView(state, state.RequestedOrderBy.Equals(action.OrderBy) ?
             state with
             {
                 RequestedOrderBy = null,
-                RequestedIsDescending = true,
-                DisplayListVersion = state.DisplayListVersion + 1
+                RequestedIsDescending = true
             } :
             state with
             {
-                RequestedOrderBy = action.OrderBy,
-                DisplayListVersion = state.DisplayListVersion + 1
-            };
+                RequestedOrderBy = action.OrderBy
+            });
 
     [ReducerMethod]
     public static LogTableState ReduceSetTabGroupCollapsed(LogTableState state, SetTabGroupCollapsedAction action)
@@ -524,9 +421,9 @@ public static LogTableState ReduceSetTabGroupCollapsed(LogTableState state, SetT
 
         var updated = state with { Groups = state.Groups.Replace(group, group with { IsCollapsed = action.Collapsed }) };
 
-        return action.Collapsed
-            ? ResetGroupCollapseIfActiveChanged(RedirectActiveToGroupIfHidden(updated), state.ActiveEventLogId)
-            : updated;
+        return action.Collapsed ?
+            RetainServedView(state, ResetGroupCollapseIfActiveChanged(RedirectActiveToGroupIfHidden(updated), state.ActiveEventLogId)) :
+            updated;
     }
 
     [ReducerMethod]
@@ -549,93 +446,105 @@ public static LogTableState ReduceToggleGroupSorting(LogTableState state)
     {
         if (state.RequestedGroupBy is null) { return state; }
 
-        return state with
+        return RetainServedView(state, state with
         {
-            RequestedIsGroupDescending = !state.RequestedIsGroupDescending,
-            DisplayListVersion = state.DisplayListVersion + 1
-        };
+            RequestedIsGroupDescending = !state.RequestedIsGroupDescending
+        });
     }
 
+    [ReducerMethod(typeof(ToggleSortingAction))]
+    public static LogTableState ReduceToggleSorting(LogTableState state) =>
+        RetainServedView(state, state with
+        {
+            RequestedIsDescending = !state.RequestedIsDescending
+        });
+
     [ReducerMethod]
-    public static LogTableState ReduceToggleLoading(LogTableState state, ToggleLoadingAction action)
-    {
-        var table = state.EventTables.FirstOrDefault(table => table.Id == action.LogId);
+    public static LogTableState ReduceViewRequestInvalidated(LogTableState state, ViewRequestInvalidatedAction action) =>
+        action.Sequence <= state.HighestInvalidationSequence ?
+            state :
+            state with
+            {
+                HighestInvalidationSequence = action.Sequence,
 
-        if (table is null) { return state; }
+                RetainedOrderedViews = state.ServingOrderedView is { } served ?
+                    state.RetainOnly(served) :
+                    state.RetainedOrderedViews,
+                ActiveOrderedView = null
+            };
 
-        return state with
-        {
-            EventTables = state.EventTables
-                .Remove(table)
-                .Add(table with { IsLoading = !table.IsLoading })
-        };
-    }
+    private static LogTableState AdoptEngineOrdering(LogTableState prior, LogTableState adopted)
+    {
+        if (!prior.HasPendingSortChange && prior.SortContext == prior.CommittedSortContext) { return adopted; }
 
-    [ReducerMethod(typeof(ToggleSortingAction))]
-    public static LogTableState ReduceToggleSorting(LogTableState state) =>
-        state with
+        var flipped = adopted with
         {
-            RequestedIsDescending = !state.RequestedIsDescending,
-            DisplayListVersion = state.DisplayListVersion + 1
+            OrderBy = adopted.RequestedOrderBy,
+            IsDescending = adopted.RequestedIsDescending,
+            GroupBy = adopted.RequestedGroupBy,
+            IsGroupDescending = adopted.RequestedIsGroupDescending,
+            CommittedEffectiveOrderBy = ResolvedEventOrdering.ResolveDefaultOrderBy(
+                adopted.RequestedOrderBy,
+                adopted.RequestedGroupBy,
+                adopted.DisplayedLogCount,
+                adopted.TimelineVisible)
         };
 
-    [ReducerMethod]
-    public static LogTableState ReduceUpdateTable(LogTableState state, UpdateTableAction action)
-    {
-        var table = state.EventTables.FirstOrDefault(t => action.LogId == t.Id);
+        return prior.RequestedGroupBy != prior.GroupBy ? ResetGroupCollapse(flipped) : flipped;
+    }
 
-        if (table is null || table.IsCombined || action.View is null) { return state; }
+    private static string Describe(Exception fault)
+    {
+        const int MessageLimit = 200;
 
-        var view = action.View;
+        string message = fault.Message ?? string.Empty;
 
-        int postCount = state.PerLogEvents.ContainsKey(table.Id) ?
-            state.PerLogEvents.Count :
-            state.PerLogEvents.Count + 1;
+        if (message.Length <= MessageLimit) { return $"{fault.GetType().Name}: {message}"; }
 
-        var context = EffectiveSortContext(
-            state.OrderBy, state.IsDescending, state.GroupBy, state.IsGroupDescending, postCount, state.TimelineVisible);
+        int cut = MessageLimit;
 
-        // Always store the finalize view: built over the just-rebuilt raw store, its reader (and every locator it hands
-        // out) addresses the current generation, so a pre-finalize view would strand selection.
-        var perLog = SetLog(state.PerLogEvents, table.Id, view, context);
-        var perLogVersion = state.PerLogListVersion.SetItem(table.Id, action.Version);
+        if (char.IsHighSurrogate(message[cut - 1])) { cut--; }
 
-        perLog = ReconcileToLogCount(perLog, state);
-        var updatedTable = SetComputerNameIfFirstEvent(table, view) with { IsLoading = false };
-        var counts = state.EventCountByLog.SetItem(table.Id, view.Count);
+        return $"{fault.GetType().Name}: {message[..cut]}...";
+    }
 
-        return state with
+    private static string? FirstNonEmptyComputerName(IReadOnlyList<ResolvedEvent> events)
+    {
+        for (int index = 0; index < events.Count; index++)
         {
-            PerLogEvents = perLog,
-            PerLogListVersion = perLogVersion,
-            EventTables = state.EventTables.Replace(table, updatedTable),
-            EventCountByLog = counts
-        };
+            string candidate = events[index].ComputerName;
+
+            if (!string.IsNullOrEmpty(candidate)) { return candidate; }
+        }
+
+        return null;
     }
 
-    private static SortContext EffectiveSortContext(
-        ColumnName? orderBy,
-        bool isDescending,
-        ColumnName? groupBy,
-        bool isGroupDescending,
-        int logCount,
-        bool timelineVisible) =>
-        new(ResolvedEventOrdering.ResolveDefaultOrderBy(orderBy, groupBy, logCount, timelineVisible),
-            isDescending,
-            groupBy,
-            isGroupDescending);
-
-    private static ImmutableDictionary<EventLogId, EventColumnView> ReconcileToLogCount(
-        ImmutableDictionary<EventLogId, EventColumnView> perLog,
-        LogTableState state) =>
-        ResortAllLogs(perLog,
-            EffectiveSortContext(
-                state.OrderBy,
-                state.IsDescending,
-                state.GroupBy,
-                state.IsGroupDescending,
-                perLog.Count,
-                state.TimelineVisible));
+    private static ImmutableList<LogView> LatchComputerNameForLog(
+        ImmutableList<LogView> tables,
+        EventLogId logId,
+        IReadOnlyList<ResolvedEvent> events)
+    {
+        int index = 0;
+
+        foreach (var table in tables)
+        {
+            if (table.Id != logId)
+            {
+                index++;
+
+                continue;
+            }
+
+            if (table.IsCombined || !string.IsNullOrEmpty(table.ComputerName)) { return tables; }
+
+            return FirstNonEmptyComputerName(events) is { } resolved ?
+                tables.SetItem(index, table with { ComputerName = resolved }) :
+                tables;
+        }
+
+        return tables;
+    }
 
     private static LogTableState RedirectActiveToGroupIfHidden(LogTableState state)
     {
@@ -716,45 +625,15 @@ private static LogTableState ResetGroupCollapseIfActiveChanged(
         EventLogId? previousActiveId) =>
         updated.ActiveEventLogId == previousActiveId ? updated : ResetGroupCollapse(updated);
 
-    private static ImmutableDictionary<EventLogId, EventColumnView> ResortAllLogs(
-        ImmutableDictionary<EventLogId, EventColumnView> perLog,
-        SortContext context)
-    {
-        if (perLog.IsEmpty) { return perLog; }
-
-        var builder = perLog.ToBuilder();
-
-        foreach (var (logId, view) in perLog)
-        {
-            if (!view.HasContext(context)) { builder[logId] = view.WithContext(context); }
-        }
-
-        return builder.ToImmutable();
-    }
+    private static LogTableState RetainServedView(LogTableState prior, LogTableState next) =>
+        prior.ServingOrderedView is { } served && next.ServingOrderedView is null ?
+            next with { RetainedOrderedViews = next.RetainOnly(served) } :
+            next;
 
-    private static LogView SetComputerNameIfFirstEvent(LogView table, EventColumnView view)
+    private static LogView SetComputerNameFromRawEvents(LogView table, IReadOnlyList<ResolvedEvent> events)
     {
-        if (!string.IsNullOrEmpty(table.ComputerName) || view.Count == 0) { return table; }
+        if (!string.IsNullOrEmpty(table.ComputerName)) { return table; }
 
-        // The first displayed event's ComputerName may be empty (resolver miss); scan display order for the first
-        // non-empty one, matching the AoS reducer.
-        for (int i = 0; i < view.Count; i++)
-        {
-            var candidate = view.GetDetailLean(view.LocatorAt(i));
-
-            if (!string.IsNullOrEmpty(candidate.ComputerName))
-            {
-                return table with { ComputerName = candidate.ComputerName };
-            }
-        }
-
-        return table;
+        return FirstNonEmptyComputerName(events) is { } resolved ? table with { ComputerName = resolved } : table;
     }
-
-    private static ImmutableDictionary<EventLogId, EventColumnView> SetLog(
-        ImmutableDictionary<EventLogId, EventColumnView> perLog,
-        EventLogId logId,
-        EventColumnView view,
-        SortContext context) =>
-        perLog.SetItem(logId, view.HasContext(context) ? view : view.WithContext(context));
 }
diff --git a/src/EventLogExpert.Runtime/LogTable/SetAllGroupsCollapsedAction.cs b/src/EventLogExpert.Runtime/LogTable/SetAllGroupsCollapsedAction.cs
index e274ec4ad..9e373d578 100644
--- a/src/EventLogExpert.Runtime/LogTable/SetAllGroupsCollapsedAction.cs
+++ b/src/EventLogExpert.Runtime/LogTable/SetAllGroupsCollapsedAction.cs
@@ -3,5 +3,4 @@
 
 namespace EventLogExpert.Runtime.LogTable;
 
-// Public so LogTablePane can subscribe via SubscribeToAction, like the other LogTable actions.
 public sealed record SetAllGroupsCollapsedAction(bool Collapsed);
diff --git a/src/EventLogExpert.Runtime/LogTable/ViewIdentity.cs b/src/EventLogExpert.Runtime/LogTable/ViewIdentity.cs
new file mode 100644
index 000000000..202d49e34
--- /dev/null
+++ b/src/EventLogExpert.Runtime/LogTable/ViewIdentity.cs
@@ -0,0 +1,137 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Filtering.Evaluation;
+using System.Collections.Immutable;
+
+namespace EventLogExpert.Runtime.LogTable;
+
+internal sealed class ViewIdentity : IEquatable<ViewIdentity>
+{
+    private readonly EventLogId? _activeLogId;
+    private readonly Filter _filter;
+    private readonly ColumnName? _groupBy;
+    private readonly int _hash;
+    private readonly bool _isDescending;
+    private readonly bool _isGroupDescending;
+
+    private readonly bool _isMultiLogDisplay;
+    private readonly ColumnName? _orderBy;
+
+    private readonly ImmutableArray<EventLogId> _scope;
+    private readonly bool _timelineVisible;
+
+    internal ViewIdentity(
+        EventLogId? activeLogId,
+        ImmutableArray<EventLogId> scope,
+        ColumnName? orderBy,
+        bool isDescending,
+        ColumnName? groupBy,
+        bool isGroupDescending,
+        bool timelineVisible,
+        bool isMultiLogDisplay,
+        Filter filter)
+    {
+        _activeLogId = activeLogId;
+        _scope = scope;
+        _orderBy = orderBy;
+        _isDescending = isDescending;
+        _groupBy = groupBy;
+        _isGroupDescending = isGroupDescending;
+        _timelineVisible = timelineVisible;
+        _isMultiLogDisplay = isMultiLogDisplay;
+        _filter = filter;
+        _hash = ComputeHash();
+    }
+
+    internal EventLogId? ActiveLogId => _activeLogId;
+
+    internal Filter Filter => _filter;
+
+    internal bool IsMultiLogDisplay => _isMultiLogDisplay;
+
+    internal ColumnName? RequestedGroupBy => _groupBy;
+
+    internal bool RequestedIsDescending => _isDescending;
+
+    internal bool RequestedIsGroupDescending => _isGroupDescending;
+
+    internal ColumnName? RequestedOrderBy => _orderBy;
+
+    internal ImmutableArray<EventLogId> Scope => _scope;
+
+    internal bool TimelineVisible => _timelineVisible;
+
+    public static bool operator ==(ViewIdentity? left, ViewIdentity? right) =>
+        left?.Equals(right) ?? right is null;
+
+    public static bool operator !=(ViewIdentity? left, ViewIdentity? right) => !(left == right);
+
+    public bool Equals(ViewIdentity? other)
+    {
+        if (ReferenceEquals(this, other)) { return true; }
+
+        if (other is null || _hash != other._hash) { return false; }
+
+        return _activeLogId == other._activeLogId && CoversSameViewAs(other);
+    }
+
+    public override bool Equals(object? obj) => Equals(obj as ViewIdentity);
+
+    public override int GetHashCode() => _hash;
+
+    internal bool CoversSameViewAs(ViewIdentity other)
+    {
+        if (_orderBy != other._orderBy ||
+            _isDescending != other._isDescending ||
+            _groupBy != other._groupBy ||
+            _isGroupDescending != other._isGroupDescending ||
+            _timelineVisible != other._timelineVisible ||
+            _isMultiLogDisplay != other._isMultiLogDisplay)
+        {
+            return false;
+        }
+
+        if (_scope.Length != other._scope.Length) { return false; }
+
+        for (int index = 0; index < _scope.Length; index++)
+        {
+            if (_scope[index] != other._scope[index]) { return false; }
+        }
+
+        return !_filter.HasFilteringChangedFrom(other._filter);
+    }
+
+    private int ComputeHash()
+    {
+        var hash = new HashCode();
+
+        hash.Add(_activeLogId);
+        hash.Add(_orderBy);
+        hash.Add(_isDescending);
+        hash.Add(_groupBy);
+        hash.Add(_isGroupDescending);
+        hash.Add(_timelineVisible);
+        hash.Add(_isMultiLogDisplay);
+
+        foreach (EventLogId logId in _scope) { hash.Add(logId); }
+
+        hash.Add(_filter.DateFilter);
+
+        ImmutableArray<FilterSnapshot> snapshots = _filter.Snapshots;
+
+        if (snapshots.IsDefault)
+        {
+            hash.Add(-1);
+        }
+        else
+        {
+            hash.Add(snapshots.Length);
+
+            foreach (FilterSnapshot snapshot in snapshots) { hash.Add(snapshot); }
+        }
+
+        return hash.ToHashCode();
+    }
+}
diff --git a/src/EventLogExpert.Runtime/LogTable/ViewRequestInvalidatedAction.cs b/src/EventLogExpert.Runtime/LogTable/ViewRequestInvalidatedAction.cs
new file mode 100644
index 000000000..3ca5ac860
--- /dev/null
+++ b/src/EventLogExpert.Runtime/LogTable/ViewRequestInvalidatedAction.cs
@@ -0,0 +1,6 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+namespace EventLogExpert.Runtime.LogTable;
+
+internal sealed record ViewRequestInvalidatedAction(long Sequence);
diff --git a/src/EventLogExpert.Runtime/Menu/IMenuService.cs b/src/EventLogExpert.Runtime/Menu/IMenuService.cs
deleted file mode 100644
index 55df70826..000000000
--- a/src/EventLogExpert.Runtime/Menu/IMenuService.cs
+++ /dev/null
@@ -1,46 +0,0 @@
-// // Copyright (c) Microsoft Corporation.
-// // Licensed under the MIT License.
-
-namespace EventLogExpert.Runtime.Menu;
-
-/// <summary>
-///     Coordinates a single active popup menu at a time. Hosts subscribe to <see cref="StateChanged" /> and render
-///     <see cref="ActiveItems" /> at (<see cref="PositionX" />, <see cref="PositionY" />).
-/// </summary>
-public interface IMenuService
-{
-    /// <summary>Raised when a top-level menu reports the menubar should switch to the previous (-1) or next (+1) entry.</summary>
-    event Action<int>? NavigateBarRequested;
-
-    event Action? StateChanged;
-
-    /// <summary>
-    ///     False when an existing menu is being replaced and the original opener should be preserved (e.g., menubar
-    ///     arrow-key navigation).
-    /// </summary>
-    bool ActiveCaptureOpener { get; }
-
-    /// <summary>True to focus the first item, false for the last (e.g., ArrowUp open).</summary>
-    bool ActiveFocusFirst { get; }
-
-    IReadOnlyList<MenuItem>? ActiveItems { get; }
-
-    /// <summary>Per-open id; use as a <c>@key</c> so re-opening produces a fresh component instance.</summary>
-    long ActiveMenuId { get; }
-
-    double PositionX { get; }
-
-    double PositionY { get; }
-
-    void Close();
-
-    void NavigateBar(int direction);
-
-    /// <summary>
-    ///     Opens a menu at the given client-coordinate position, replacing any active menu. Pass
-    ///     <paramref name="focusFirst" /> false for ArrowUp opens (focus lands on the last enabled item per WAI-ARIA menubar
-    ///     pattern). Pass <paramref name="captureOpener" /> false when replacing an open menu so closing restores focus to the
-    ///     original opener.
-    /// </summary>
-    void OpenAt(double x, double y, IReadOnlyList<MenuItem> items, bool focusFirst = true, bool captureOpener = true);
-}
diff --git a/src/EventLogExpert.Runtime/Menu/MenuAnchorRect.cs b/src/EventLogExpert.Runtime/Menu/MenuAnchorRect.cs
deleted file mode 100644
index bbfe5e7fc..000000000
--- a/src/EventLogExpert.Runtime/Menu/MenuAnchorRect.cs
+++ /dev/null
@@ -1,21 +0,0 @@
-// // Copyright (c) Microsoft Corporation.
-// // Licensed under the MIT License.
-
-namespace EventLogExpert.Runtime.Menu;
-
-/// <summary>
-///     Bounding rectangle returned by the <c>getMenuElementRect</c> JS interop helper. Used by menu trigger anchors
-///     (top-level menu bar items, FilterPane chevron, and any future split-button or dropdown opener) to position the
-///     popup at the bottom-left of the trigger element.
-/// </summary>
-/// <remarks>
-///     Promoted from per-component duplicates so JS interop deserialization stays consistent across all named
-///     consumers (≥2 callers per the shared-types policy).
-/// </remarks>
-public sealed record MenuAnchorRect(
-    double Left,
-    double Top,
-    double Right,
-    double Bottom,
-    double Width,
-    double Height);
diff --git a/src/EventLogExpert.Runtime/Modal/IModalCoordinator.cs b/src/EventLogExpert.Runtime/Modal/IModalCoordinator.cs
deleted file mode 100644
index 0c4941248..000000000
--- a/src/EventLogExpert.Runtime/Modal/IModalCoordinator.cs
+++ /dev/null
@@ -1,46 +0,0 @@
-// // Copyright (c) Microsoft Corporation.
-// // Licensed under the MIT License.
-
-using EventLogExpert.Runtime.Alerts;
-using Microsoft.AspNetCore.Components;
-using System.Diagnostics.CodeAnalysis;
-
-namespace EventLogExpert.Runtime.Modal;
-
-/// <summary>Coordinates modal lifecycle and owns the inline-alert host registry that callers route through.</summary>
-public interface IModalCoordinator
-{
-    event Action? StateChanged;
-
-    ModalSession? ActiveSession { get; }
-
-    void Complete<TResult>(ModalId modalId, TResult? result);
-
-    void ForceCloseActive();
-
-    /// <summary>Returns the active modal's scope, or <see langword="null" /> if no modal is active.</summary>
-    ModalScope? GetActiveModalScope();
-
-    /// <summary>
-    ///     Opens <typeparamref name="TModal" />. If an active modal exists, asks it to close via the veto pipeline first;
-    ///     if vetoed, returns a result with <see cref="ModalOpenResult{TResult}.WasOpened" /> set to <see langword="false" />.
-    /// </summary>
-    Task<ModalOpenResult<TResult>> PushAsync<TModal, TResult>(IDictionary<string, object?>? parameters = null)
-        where TModal : IComponent;
-
-    /// <summary>Register a modal's close handler, scope, and optional inline-alert host. Stale ids are ignored.</summary>
-    void RegisterModal(ModalRegistration registration);
-
-    /// <summary>
-    ///     Asks the active modal to close. Coalesces concurrent calls; the first verdict wins. Critical-scoped modals
-    ///     reject <see cref="ModalCloseReason.OtherModalActivation" /> immediately, regardless of in-flight state.
-    ///     If a close handler throws <see cref="OperationCanceledException" /> (e.g., from a force-close race), the
-    ///     close is treated as accepted so coalesced awaiters resolve successfully.
-    /// </summary>
-    Task<bool> RequestCloseActiveAsync(ModalCloseReason reason);
-
-    bool TryGetInlineAlertHost([NotNullWhen(true)] out IInlineAlertHost? host);
-
-    void UnregisterModal(ModalId modalId);
-}
-
diff --git a/src/EventLogExpert.Runtime/Modal/IModalService.cs b/src/EventLogExpert.Runtime/Modal/IModalService.cs
deleted file mode 100644
index 466ed138d..000000000
--- a/src/EventLogExpert.Runtime/Modal/IModalService.cs
+++ /dev/null
@@ -1,31 +0,0 @@
-// // Copyright (c) Microsoft Corporation.
-// // Licensed under the MIT License.
-
-using Microsoft.AspNetCore.Components;
-
-namespace EventLogExpert.Runtime.Modal;
-
-/// <summary>
-///     Coordinates a single active modal at a time. Hosts subscribe to <see cref="StateChanged" /> and render
-///     <see cref="ActiveModalType" /> with <see cref="ActiveModalParameters" />.
-/// </summary>
-public interface IModalService
-{
-    event Action? StateChanged;
-
-    /// <summary>Per-show id; use as a <c>@key</c> so reopening produces a fresh component instance.</summary>
-    ModalId ActiveModalId { get; }
-
-    IDictionary<string, object?>? ActiveModalParameters { get; }
-
-    Type? ActiveModalType { get; }
-
-    void CancelActive();
-
-    /// <summary>Complete the active modal's task. Stale ids (from replaced modals) are ignored.</summary>
-    void Complete<TResult>(ModalId modalId, TResult? result);
-
-    /// <summary>Open a modal. Any prior active modal is canceled (its task completes with default).</summary>
-    Task<TResult?> Show<TModal, TResult>(IDictionary<string, object?>? parameters = null)
-        where TModal : IComponent;
-}
diff --git a/src/EventLogExpert.Runtime/Modal/ModalOpenResult.cs b/src/EventLogExpert.Runtime/Modal/ModalOpenResult.cs
deleted file mode 100644
index 2a21378c1..000000000
--- a/src/EventLogExpert.Runtime/Modal/ModalOpenResult.cs
+++ /dev/null
@@ -1,10 +0,0 @@
-// // Copyright (c) Microsoft Corporation.
-// // Licensed under the MIT License.
-
-namespace EventLogExpert.Runtime.Modal;
-
-/// <summary>
-///     Result of <see cref="IModalCoordinator.PushAsync{TModal,TResult}" />. <c>WasOpened</c> distinguishes
-///     user-completion-with-default from preempt-veto.
-/// </summary>
-public sealed record ModalOpenResult<TResult>(TResult? Result, bool WasOpened);
diff --git a/src/EventLogExpert.Runtime/Scenarios/Favorites/IScenarioFavoritesSource.cs b/src/EventLogExpert.Runtime/Scenarios/Favorites/IScenarioFavoritesSource.cs
new file mode 100644
index 000000000..997d6de26
--- /dev/null
+++ b/src/EventLogExpert.Runtime/Scenarios/Favorites/IScenarioFavoritesSource.cs
@@ -0,0 +1,12 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Runtime.Common.Sources;
+using System.Collections.Immutable;
+
+namespace EventLogExpert.Runtime.Scenarios.Favorites;
+
+public interface IScenarioFavoritesSource : IChangeNotifier
+{
+    ImmutableHashSet<string> FavoriteScenarioIds { get; }
+}
diff --git a/src/EventLogExpert.Runtime/Scenarios/Favorites/ScenarioFavoritesSource.cs b/src/EventLogExpert.Runtime/Scenarios/Favorites/ScenarioFavoritesSource.cs
new file mode 100644
index 000000000..bcc730011
--- /dev/null
+++ b/src/EventLogExpert.Runtime/Scenarios/Favorites/ScenarioFavoritesSource.cs
@@ -0,0 +1,20 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Logging.Abstractions;
+using EventLogExpert.Runtime.Common.Sources;
+using Fluxor;
+using System.Collections.Immutable;
+
+namespace EventLogExpert.Runtime.Scenarios.Favorites;
+
+internal sealed class ScenarioFavoritesSource(IState<ScenarioFavoritesState> state, ITraceLogger logger)
+    : ObservableStateSourceBase<ScenarioFavoritesState, ImmutableHashSet<string>>(
+            state,
+            logger,
+            static state => state.FavoriteScenarioIds,
+            static (next, current) => ReferenceEquals(next, current) || next.SetEquals(current)),
+        IScenarioFavoritesSource
+{
+    public ImmutableHashSet<string> FavoriteScenarioIds => CurrentProjection;
+}
diff --git a/src/EventLogExpert.Runtime/StatusBar/IStatusBarSource.cs b/src/EventLogExpert.Runtime/StatusBar/IStatusBarSource.cs
new file mode 100644
index 000000000..9f0dd0832
--- /dev/null
+++ b/src/EventLogExpert.Runtime/StatusBar/IStatusBarSource.cs
@@ -0,0 +1,11 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Runtime.Common.Sources;
+
+namespace EventLogExpert.Runtime.StatusBar;
+
+public interface IStatusBarSource : IChangeNotifier
+{
+    StatusBarPresentation Current { get; }
+}
diff --git a/src/EventLogExpert.Runtime/StatusBar/StatusBarFormatter.cs b/src/EventLogExpert.Runtime/StatusBar/StatusBarFormatter.cs
index a055142bf..2450915fb 100644
--- a/src/EventLogExpert.Runtime/StatusBar/StatusBarFormatter.cs
+++ b/src/EventLogExpert.Runtime/StatusBar/StatusBarFormatter.cs
@@ -5,19 +5,8 @@
 
 namespace EventLogExpert.Runtime.StatusBar;
 
-/// <summary>
-///     Pure presentation helpers for the status bar: the active-source label, the total/shown/selected count phrase,
-///     the filter-lens indicator tooltip, and the coarse screen-reader activity announcement. Kept free of Fluxor so the
-///     UI component stays thin and the logic is unit-testable in isolation, mirroring <c>EventTableColumnFormatter</c>.
-///     Count formatting uses the current culture (thousands separators); tests pin the culture.
-/// </summary>
 public static class StatusBarFormatter
 {
-    /// <summary>
-    ///     Tooltip for the filter-lens indicator that names the narrowing mechanism the breadcrumb/pane owns the detail
-    ///     of: "Filter active", "N lenses", or "Filter + N lenses". Returns <see langword="null" /> when nothing narrows (the
-    ///     indicator is then hidden).
-    /// </summary>
     public static string? FilterIndicatorTooltip(bool persistentActive, int lensCount)
     {
         var lensText = lensCount switch
@@ -36,32 +25,29 @@ public static class StatusBarFormatter
         };
     }
 
-    /// <summary>
-    ///     The coarse activity label announced to screen readers (via the single polite status region). It changes only
-    ///     on state transitions, so per-tick loading/buffer counts - which render as silent visual siblings - never announce.
-    ///     Priority puts a load error first: <paramref name="resolverStatus" /> is only ever an error message or empty, so it
-    ///     must surface even while another log is still loading; then buffer-full, then loading, then continuous updating.
-    /// </summary>
     public static string FormatActivityAnnouncement(
         bool isLoading,
         bool bufferFull,
         bool continuouslyUpdating,
-        string resolverStatus)
+        string resolverStatus,
+        DisplayIndicatorKind displayIndicator = DisplayIndicatorKind.None)
     {
         if (!string.IsNullOrEmpty(resolverStatus)) { return resolverStatus; }
 
+        if (displayIndicator == DisplayIndicatorKind.Fault) { return "These events could not be prepared"; }
+
         if (bufferFull) { return "Buffer full"; }
 
         if (isLoading) { return "Loading"; }
 
-        return continuouslyUpdating ? "Continuously updating" : string.Empty;
+        return displayIndicator switch
+        {
+            DisplayIndicatorKind.EmptyPending => "Loading events",
+            DisplayIndicatorKind.ReorderPending => "Reordering events",
+            _ => continuouslyUpdating ? "Continuously updating" : string.Empty
+        };
     }
 
-    /// <summary>
-    ///     "1,234 events" normally, "200 of 1,234 shown" when the effective (base intersect lenses) filter narrows the
-    ///     view, plus " {middot} 3 selected" only for a multi-select (<paramref name="selectedCount" /> &gt;= 2 - a single
-    ///     click already selects one row, so surfacing "1 selected" would be near-omnipresent noise).
-    /// </summary>
     public static string FormatCounts(int total, int shown, bool isFiltered, int selectedCount)
     {
         var head = isFiltered ? $"{shown:N0} of {total:N0} shown" : $"{total:N0} events";
@@ -69,12 +55,6 @@ public static string FormatCounts(int total, int shown, bool isFiltered, int sel
         return selectedCount >= 2 ? $"{head} \u00b7 {selectedCount:N0} selected" : head;
     }
 
-    /// <summary>
-    ///     The active tab's source label: a channel's <see cref="LogView.LogName" />, an opened file's base name, a named
-    ///     group's name, "All logs (N)" for the implicit all-logs view (N = open per-log tabs), or "Combined (N logs)" for an
-    ///     unnamed group. Remote/computer origin is deliberately omitted (<see cref="LogView.ComputerName" /> is the event's
-    ///     origin machine, not the connection source). Returns "No log open" when there is no active view.
-    /// </summary>
     public static string FormatSource(
         LogView? active,
         IReadOnlyList<LogView> eventTables,
diff --git a/src/EventLogExpert.Runtime/StatusBar/StatusBarPresentation.cs b/src/EventLogExpert.Runtime/StatusBar/StatusBarPresentation.cs
new file mode 100644
index 000000000..a70d711a3
--- /dev/null
+++ b/src/EventLogExpert.Runtime/StatusBar/StatusBarPresentation.cs
@@ -0,0 +1,39 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Runtime.LogTable;
+using System.Collections.Immutable;
+
+namespace EventLogExpert.Runtime.StatusBar;
+
+public readonly record struct LoadingProgress(int Loaded, int Failed);
+
+public sealed record StatusBarPresentation
+{
+    public bool ContinuouslyUpdate { get; init; }
+
+    public int NewEventBufferCount { get; init; }
+
+    public bool NewEventBufferIsFull { get; init; }
+
+    public int SelectionCount { get; init; }
+
+    public bool IsPersistentFilterActive { get; init; }
+
+    public int RawEventTotal { get; init; }
+
+    public ImmutableDictionary<EventLogId, int> RawEventCountsByLog { get; init; } =
+        ImmutableDictionary<EventLogId, int>.Empty;
+
+    public ImmutableDictionary<StatusActivityId, LoadingProgress> LoadingActivities { get; init; } =
+        ImmutableDictionary<StatusActivityId, LoadingProgress>.Empty;
+
+    public string ResolverStatus { get; init; } = string.Empty;
+
+    public ImmutableList<LogView> Tabs { get; init; } = [];
+
+    public ImmutableList<LogTabGroup> Groups { get; init; } = [];
+
+    public EventLogId? ActiveTabId { get; init; }
+}
diff --git a/src/EventLogExpert.Runtime/StatusBar/StatusBarSource.cs b/src/EventLogExpert.Runtime/StatusBar/StatusBarSource.cs
new file mode 100644
index 000000000..f272f6ab2
--- /dev/null
+++ b/src/EventLogExpert.Runtime/StatusBar/StatusBarSource.cs
@@ -0,0 +1,252 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Logging.Abstractions;
+using EventLogExpert.Runtime.EventLog;
+using EventLogExpert.Runtime.FilterPane;
+using EventLogExpert.Runtime.LogTable;
+using Fluxor;
+using Microsoft.Extensions.DependencyInjection;
+using System.Collections.Immutable;
+
+namespace EventLogExpert.Runtime.StatusBar;
+
+internal sealed class StatusBarSource : IStatusBarSource, IDisposable
+{
+    private readonly IState<EventLogState> _eventLogState;
+    private readonly IState<FilterPaneState> _filterPaneState;
+    private readonly Lock _gate = new();
+    private readonly IState<LogTableState> _logTableState;
+    private readonly ITraceLogger _logger;
+    private readonly IState<RawEventCountState> _rawCountState;
+    private readonly IState<StatusBarState> _statusBarState;
+
+    private bool _disposed;
+    private (bool ContinuouslyUpdate, int BufferCount, bool BufferFull, int SelectionCount) _eventLogFacets;
+    private (ImmutableList<LogView> Tabs, ImmutableList<LogTabGroup> Groups, EventLogId? ActiveTabId) _logTableFacets;
+    private bool _persistentFilterActive;
+    private (int Total, ImmutableDictionary<EventLogId, int> ByLog) _rawCountFacets;
+    private (ImmutableDictionary<StatusActivityId, (int, int)> Loading, string Resolver) _statusFacets;
+
+    public StatusBarSource(
+        IState<EventLogState> eventLogState,
+        IState<FilterPaneState> filterPaneState,
+        IState<RawEventCountState> rawCountState,
+        IState<StatusBarState> statusBarState,
+        IState<LogTableState> logTableState,
+        [FromKeyedServices(LogCategories.EventLog)] ITraceLogger logger)
+    {
+        ArgumentNullException.ThrowIfNull(eventLogState);
+        ArgumentNullException.ThrowIfNull(filterPaneState);
+        ArgumentNullException.ThrowIfNull(rawCountState);
+        ArgumentNullException.ThrowIfNull(statusBarState);
+        ArgumentNullException.ThrowIfNull(logTableState);
+        ArgumentNullException.ThrowIfNull(logger);
+
+        _eventLogState = eventLogState;
+        _filterPaneState = filterPaneState;
+        _rawCountState = rawCountState;
+        _statusBarState = statusBarState;
+        _logTableState = logTableState;
+        _logger = logger;
+
+        SeedFacets();
+        
+        _eventLogState.StateChanged += OnEventLogChanged;
+        _filterPaneState.StateChanged += OnFilterPaneChanged;
+        _rawCountState.StateChanged += OnRawCountChanged;
+        _statusBarState.StateChanged += OnStatusBarChanged;
+        _logTableState.StateChanged += OnLogTableChanged;
+
+        lock (_gate) { SeedFacets(); }
+    }
+
+    public event Action? Changed;
+
+    public StatusBarPresentation Current => Project(
+        _eventLogState.Value,
+        _filterPaneState.Value,
+        _rawCountState.Value,
+        _statusBarState.Value,
+        _logTableState.Value);
+
+    public void Dispose()
+    {
+        lock (_gate)
+        {
+            if (_disposed) { return; }
+
+            _disposed = true;
+        }
+
+        _eventLogState.StateChanged -= OnEventLogChanged;
+        _filterPaneState.StateChanged -= OnFilterPaneChanged;
+        _rawCountState.StateChanged -= OnRawCountChanged;
+        _statusBarState.StateChanged -= OnStatusBarChanged;
+        _logTableState.StateChanged -= OnLogTableChanged;
+    }
+
+    private static bool DictEquals<TKey, TValue>(
+        ImmutableDictionary<TKey, TValue> left,
+        ImmutableDictionary<TKey, TValue> right)
+        where TKey : notnull
+    {
+        if (ReferenceEquals(left, right)) { return true; }
+
+        if (left.Count != right.Count) { return false; }
+
+        foreach (var pair in left)
+        {
+            if (!right.TryGetValue(pair.Key, out var value) ||
+                !EqualityComparer<TValue>.Default.Equals(value, pair.Value))
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    private static StatusBarPresentation Project(
+        EventLogState eventLog,
+        FilterPaneState filterPane,
+        RawEventCountState rawCount,
+        StatusBarState statusBar,
+        LogTableState logTable) =>
+        new()
+        {
+            ContinuouslyUpdate = eventLog.ContinuouslyUpdate,
+            NewEventBufferCount = eventLog.NewEventBuffer.Count,
+            NewEventBufferIsFull = eventLog.NewEventBufferIsFull,
+            SelectionCount = eventLog.Selection.Count,
+            IsPersistentFilterActive = filterPane.IsFilteringEnabled,
+            RawEventTotal = rawCount.Total,
+            RawEventCountsByLog = rawCount.ByLog,
+            LoadingActivities = statusBar.EventsLoading.ToImmutableDictionary(
+                pair => pair.Key,
+                pair => new LoadingProgress(pair.Value.Item1, pair.Value.Item2)),
+            ResolverStatus = statusBar.ResolverStatus,
+            Tabs = logTable.EventTables,
+            Groups = logTable.Groups,
+            ActiveTabId = logTable.ActiveEventLogId
+        };
+
+    private static (bool, int, bool, int) ProjectEventLog(EventLogState state) =>
+        (state.ContinuouslyUpdate, state.NewEventBuffer.Count, state.NewEventBufferIsFull, state.Selection.Count);
+
+    private static (ImmutableList<LogView>, ImmutableList<LogTabGroup>, EventLogId?) ProjectLogTable(
+        LogTableState state) =>
+        (state.EventTables, state.Groups, state.ActiveEventLogId);
+
+    private static (int, ImmutableDictionary<EventLogId, int>) ProjectRawCount(RawEventCountState state) =>
+        (state.Total, state.ByLog);
+
+    private static (ImmutableDictionary<StatusActivityId, (int, int)>, string) ProjectStatus(StatusBarState state) =>
+        (state.EventsLoading, state.ResolverStatus);
+
+    private void OnEventLogChanged(object? sender, EventArgs e)
+    {
+        var next = ProjectEventLog(_eventLogState.Value);
+
+        lock (_gate)
+        {
+            if (_disposed || next == _eventLogFacets) { return; }
+
+            _eventLogFacets = next;
+        }
+
+        RaiseChanged();
+    }
+
+    private void OnFilterPaneChanged(object? sender, EventArgs e)
+    {
+        var next = _filterPaneState.Value.IsFilteringEnabled;
+
+        lock (_gate)
+        {
+            if (_disposed || next == _persistentFilterActive) { return; }
+
+            _persistentFilterActive = next;
+        }
+
+        RaiseChanged();
+    }
+
+    private void OnLogTableChanged(object? sender, EventArgs e)
+    {
+        var next = ProjectLogTable(_logTableState.Value);
+
+        lock (_gate)
+        {
+            if (_disposed ||
+                (ReferenceEquals(next.Item1, _logTableFacets.Tabs) &&
+                    ReferenceEquals(next.Item2, _logTableFacets.Groups) &&
+                    next.Item3 == _logTableFacets.ActiveTabId))
+            {
+                return;
+            }
+
+            _logTableFacets = next;
+        }
+
+        RaiseChanged();
+    }
+
+    private void OnRawCountChanged(object? sender, EventArgs e)
+    {
+        var next = ProjectRawCount(_rawCountState.Value);
+
+        lock (_gate)
+        {
+            if (_disposed || (next.Item1 == _rawCountFacets.Total && DictEquals(next.Item2, _rawCountFacets.ByLog)))
+            {
+                return;
+            }
+
+            _rawCountFacets = next;
+        }
+
+        RaiseChanged();
+    }
+
+    private void OnStatusBarChanged(object? sender, EventArgs e)
+    {
+        var next = ProjectStatus(_statusBarState.Value);
+
+        lock (_gate)
+        {
+            if (_disposed ||
+                (next.Item2 == _statusFacets.Resolver && DictEquals(next.Item1, _statusFacets.Loading)))
+            {
+                return;
+            }
+
+            _statusFacets = next;
+        }
+
+        RaiseChanged();
+    }
+
+    private void RaiseChanged()
+    {
+        var handlers = Changed;
+
+        if (handlers is null) { return; }
+
+        foreach (var handler in handlers.GetInvocationList().Cast<Action>())
+        {
+            try { handler(); }
+            catch (Exception fault) { _logger.Trace($"{nameof(StatusBarSource)}: a subscriber threw and was isolated: {fault}"); }
+        }
+    }
+
+    private void SeedFacets()
+    {
+        _eventLogFacets = ProjectEventLog(_eventLogState.Value);
+        _persistentFilterActive = _filterPaneState.Value.IsFilteringEnabled;
+        _rawCountFacets = ProjectRawCount(_rawCountState.Value);
+        _statusFacets = ProjectStatus(_statusBarState.Value);
+        _logTableFacets = ProjectLogTable(_logTableState.Value);
+    }
+}
diff --git a/src/EventLogExpert.Runtime/Alerts/AlertDialogService.cs b/src/EventLogExpert.UI/Alerts/AlertDialogService.cs
similarity index 98%
rename from src/EventLogExpert.Runtime/Alerts/AlertDialogService.cs
rename to src/EventLogExpert.UI/Alerts/AlertDialogService.cs
index d6903ac86..a8fed248b 100644
--- a/src/EventLogExpert.Runtime/Alerts/AlertDialogService.cs
+++ b/src/EventLogExpert.UI/Alerts/AlertDialogService.cs
@@ -1,11 +1,12 @@
 // // Copyright (c) Microsoft Corporation.
 // // Licensed under the MIT License.
 
+using EventLogExpert.Runtime.Alerts;
 using EventLogExpert.Runtime.Banner;
 using EventLogExpert.Runtime.Common.Threading;
-using EventLogExpert.Runtime.Modal;
+using EventLogExpert.UI.Modal;
 
-namespace EventLogExpert.Runtime.Alerts;
+namespace EventLogExpert.UI.Alerts;
 
 public sealed class AlertDialogService(
     IModalCoordinator modalCoordinator,
diff --git a/src/EventLogExpert.UI/Alerts/IInlineAlertHost.cs b/src/EventLogExpert.UI/Alerts/IInlineAlertHost.cs
new file mode 100644
index 000000000..e4ddff5ab
--- /dev/null
+++ b/src/EventLogExpert.UI/Alerts/IInlineAlertHost.cs
@@ -0,0 +1,9 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+namespace EventLogExpert.UI.Alerts;
+
+public interface IInlineAlertHost
+{
+    Task<InlineAlertResult> ShowInlineAlertAsync(InlineAlertRequest request, CancellationToken cancellationToken);
+}
diff --git a/src/EventLogExpert.UI/Alerts/InlineAlertRequest.cs b/src/EventLogExpert.UI/Alerts/InlineAlertRequest.cs
new file mode 100644
index 000000000..3246128e4
--- /dev/null
+++ b/src/EventLogExpert.UI/Alerts/InlineAlertRequest.cs
@@ -0,0 +1,17 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+namespace EventLogExpert.UI.Alerts;
+
+public sealed record InlineAlertRequest(
+    string Title,
+    string Message,
+    string? AcceptLabel,
+    string CancelLabel,
+    bool IsPrompt,
+    string? PromptInitialValue)
+{
+    public Func<string, string?>? Validate { get; init; }
+
+    public string? SecondaryActionLabel { get; init; }
+}
diff --git a/src/EventLogExpert.UI/Alerts/InlineAlertResult.cs b/src/EventLogExpert.UI/Alerts/InlineAlertResult.cs
new file mode 100644
index 000000000..862ead1b4
--- /dev/null
+++ b/src/EventLogExpert.UI/Alerts/InlineAlertResult.cs
@@ -0,0 +1,9 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+namespace EventLogExpert.UI.Alerts;
+
+public sealed record InlineAlertResult(bool Accepted, string? PromptValue)
+{
+    public bool SecondaryChosen { get; init; }
+}
diff --git a/src/EventLogExpert.UI/Banner/BannerCycleStateService.cs b/src/EventLogExpert.UI/Banner/BannerCycleStateService.cs
index 4e6b5d77d..1a2765feb 100644
--- a/src/EventLogExpert.UI/Banner/BannerCycleStateService.cs
+++ b/src/EventLogExpert.UI/Banner/BannerCycleStateService.cs
@@ -3,8 +3,8 @@
 
 using EventLogExpert.Runtime.Banner;
 using EventLogExpert.Runtime.Database;
-using EventLogExpert.Runtime.Modal;
 using EventLogExpert.UI.DatabaseTools;
+using EventLogExpert.UI.Modal;
 
 namespace EventLogExpert.UI.Banner;
 
@@ -24,18 +24,9 @@ public sealed class BannerCycleStateService : IBannerCycleStateService, IDisposa
     private IReadOnlyList<BannerCycleItem> _items = [];
     private bool _modalContentDisplayed;
     private BannerCycleItem? _pendingOverrideItem;
-    // _priorityStolenSelection holds the most recent item that won selection via priorityOverride
-    // (i.e., a newly-arrived higher-priority item). Cleared (a) when its source identity is no longer
-    // in the current source fingerprint, or (b) when the user explicitly navigates via MoveNext/MovePrev
-    // (user-acknowledgment). While non-null, the _userPreferredItem restore path is gated off so a
-    // stale low-priority preference cannot bounce back over the priority-stolen selection on the next
-    // unrelated rebuild.
-    private BannerCycleItem? _priorityStolenSelection;
     private HashSet<(BannerView View, BannerId? EntryId)> _priorSourceFingerprint = [];
+    private BannerCycleItem? _priorityStolenSelection;
     private BannerCycleItem? _selectedItem;
-    // _userPreferredItem captures the last item the user explicitly selected via MoveNext/MovePrev.
-    // It survives temporary source-filter events (e.g., the DatabaseToolsModal suppressing the
-    // Attention banner) so the user's preferred banner is restored when the filter lifts.
     private BannerCycleItem? _userPreferredItem;
 
     public BannerCycleStateService(
@@ -217,7 +208,6 @@ private static bool ItemMatches(BannerCycleItem selected, BannerCycleItem candid
         return selected.EntryId == candidate.EntryId;
     }
 
-    // BannerView enum is ordered for display, not priority - use this rank for comparisons.
     private static int PriorityRank(BannerView view) => view switch
     {
         BannerView.Critical => 6,
@@ -257,7 +247,6 @@ private void RebuildAndReselectLocked()
         bool attentionSuppressed =
             _modalCoordinator.ActiveSession?.ComponentType == typeof(DatabaseToolsModal);
 
-        // Capture each facet snapshot once - the same data drives BuildCycle AND the fingerprint.
         var critical = _critical.CurrentCritical;
         var errors = _errors.ErrorBanners;
         var attentionEntries = _attention.AttentionEntries;
@@ -276,8 +265,6 @@ private void RebuildAndReselectLocked()
             exportProgress,
             infos);
 
-        // Fingerprint is built from the UNFILTERED source - otherwise modal close would re-introduce
-        // Attention and wrongly trigger priorityOverride on every reentry.
         var currentSourceFingerprint = ComputeSourceFingerprintFromSnapshot(
             critical,
             errors,
@@ -291,7 +278,6 @@ private void RebuildAndReselectLocked()
             _priorSourceFingerprint,
             _selectedItem);
 
-        // Advance fingerprint before any early-return so the next rebuild compares against current state.
         _priorSourceFingerprint = currentSourceFingerprint;
 
         if (_userPreferredItem is not null
@@ -318,7 +304,6 @@ private void RebuildAndReselectLocked()
             return;
         }
 
-        // Priority order: explicit override > priority watermark > user-preferred (gated) > current > clamp.
         if (TryApplySelection(_pendingOverrideItem, items)) { _pendingOverrideItem = null; return; }
 
         if (TryApplySelection(priorityOverride, items))
@@ -327,9 +312,6 @@ private void RebuildAndReselectLocked()
             return;
         }
 
-        // Gate user-preferred restore against a still-active priority-stolen item only. This does NOT
-        // block restore when a higher-priority item that COEXISTED with the user's preference is
-        // present - only blocks against a newly-arrived steal that is still in the cycle.
         if (_priorityStolenSelection is null
             && TryApplySelection(_userPreferredItem, items))
         {
diff --git a/src/EventLogExpert.Runtime/Banner/BannerViewSelector.cs b/src/EventLogExpert.UI/Banner/BannerViewSelector.cs
similarity index 96%
rename from src/EventLogExpert.Runtime/Banner/BannerViewSelector.cs
rename to src/EventLogExpert.UI/Banner/BannerViewSelector.cs
index ddb177baa..0078e0d4b 100644
--- a/src/EventLogExpert.Runtime/Banner/BannerViewSelector.cs
+++ b/src/EventLogExpert.UI/Banner/BannerViewSelector.cs
@@ -1,9 +1,10 @@
 // // Copyright (c) Microsoft Corporation.
 // // Licensed under the MIT License.
 
+using EventLogExpert.Runtime.Banner;
 using EventLogExpert.Runtime.Database;
 
-namespace EventLogExpert.Runtime.Banner;
+namespace EventLogExpert.UI.Banner;
 
 public enum BannerView
 {
diff --git a/src/EventLogExpert.UI/Banner/CriticalBanner.razor.cs b/src/EventLogExpert.UI/Banner/CriticalBanner.razor.cs
index 86514d79f..79eb67dd7 100644
--- a/src/EventLogExpert.UI/Banner/CriticalBanner.razor.cs
+++ b/src/EventLogExpert.UI/Banner/CriticalBanner.razor.cs
@@ -13,6 +13,8 @@ namespace EventLogExpert.UI.Banner;
 
 public sealed partial class CriticalBanner : ComponentBase, IDisposable
 {
+    private static readonly TimeSpan s_copiedFeedbackDuration = TimeSpan.FromSeconds(2);
+
     private CancellationTokenSource? _copiedFeedbackCts;
     private string? _recoveryFailureMessage;
     private Button? _reloadButton;
@@ -65,7 +67,7 @@ private async Task OnCopyDetailsClickedAsync(Exception ex)
 
         try
         {
-            await Task.Delay(TimeSpan.FromSeconds(2), cts.Token);
+            await Task.Delay(s_copiedFeedbackDuration, cts.Token);
 
             if (ReferenceEquals(_copiedFeedbackCts, cts))
             {
diff --git a/src/EventLogExpert.UI/Banner/IBannerCycleStateService.cs b/src/EventLogExpert.UI/Banner/IBannerCycleStateService.cs
index 1f5ff4bad..1490c2d86 100644
--- a/src/EventLogExpert.UI/Banner/IBannerCycleStateService.cs
+++ b/src/EventLogExpert.UI/Banner/IBannerCycleStateService.cs
@@ -1,8 +1,6 @@
 // // Copyright (c) Microsoft Corporation.
 // // Licensed under the MIT License.
 
-using EventLogExpert.Runtime.Banner;
-
 namespace EventLogExpert.UI.Banner;
 
 public interface IBannerCycleStateService
diff --git a/src/EventLogExpert.UI/Common/AppStateComponentBase.cs b/src/EventLogExpert.UI/Common/AppStateComponentBase.cs
new file mode 100644
index 000000000..e9b28ae71
--- /dev/null
+++ b/src/EventLogExpert.UI/Common/AppStateComponentBase.cs
@@ -0,0 +1,77 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Runtime.Common.Sources;
+using Microsoft.AspNetCore.Components;
+
+namespace EventLogExpert.UI.Common;
+
+public abstract class AppStateComponentBase : ComponentBase, IAsyncDisposable
+{
+    private readonly List<SourceSubscription> _subscriptions = [];
+
+    private bool _disposed;
+
+    protected bool IsDisposed => _disposed;
+
+    public async ValueTask DisposeAsync()
+    {
+        await DisposeAsyncCore(disposing: true);
+        GC.SuppressFinalize(this);
+    }
+
+    protected virtual ValueTask DisposeAsyncCore(bool disposing)
+    {
+        if (!disposing || _disposed) { return ValueTask.CompletedTask; }
+
+        _disposed = true;
+
+        foreach (var subscription in _subscriptions) { subscription.Dispose(); }
+
+        _subscriptions.Clear();
+
+        return ValueTask.CompletedTask;
+    }
+
+    protected void ObserveSource(Action<Action> subscribe, Action<Action> unsubscribe) =>
+        _subscriptions.Add(new SourceSubscription(subscribe, unsubscribe, () => InvokeAsync(StateHasChanged)));
+
+    protected void ObserveSource(Action<Action> subscribe, Action<Action> unsubscribe, Func<Task> onChangedAsync) =>
+        _subscriptions.Add(new SourceSubscription(subscribe, unsubscribe, () => InvokeAsync(onChangedAsync)));
+
+    protected void ObserveSource(IChangeNotifier source)
+    {
+        ArgumentNullException.ThrowIfNull(source);
+
+        ObserveSource(handler => source.Changed += handler, handler => source.Changed -= handler);
+    }
+
+    protected void ObserveSource(IChangeNotifier source, Func<Task> onChangedAsync)
+    {
+        ArgumentNullException.ThrowIfNull(source);
+
+        ObserveSource(handler => source.Changed += handler, handler => source.Changed -= handler, onChangedAsync);
+    }
+
+    protected void RequestGuardedRender(Action render)
+    {
+        if (_disposed) { return; }
+
+        _ = DispatchGuardedRenderAsync(render);
+    }
+
+    private async Task DispatchGuardedRenderAsync(Action render)
+    {
+        try
+        {
+            await InvokeAsync(() =>
+            {
+                if (_disposed) { return; }
+
+                render();
+            });
+        }
+        catch (ObjectDisposedException) { /* Renderer torn down between the guard and the dispatch; nothing to render. */ }
+        catch (OperationCanceledException) { /* Circuit shutting down; nothing to render. */ }
+    }
+}
diff --git a/src/EventLogExpert.UI/Common/PresentationViewComponentBase.cs b/src/EventLogExpert.UI/Common/PresentationViewComponentBase.cs
new file mode 100644
index 000000000..6c41c4ef1
--- /dev/null
+++ b/src/EventLogExpert.UI/Common/PresentationViewComponentBase.cs
@@ -0,0 +1,64 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Runtime.LogTable;
+using Microsoft.AspNetCore.Components;
+
+namespace EventLogExpert.UI.Common;
+
+public abstract class PresentationViewComponentBase : AppStateComponentBase
+{
+    private bool _disposed;
+
+    private int _hasPendingRenderDispatch;
+
+    protected OrderedViewPresentation Presentation { get; private set; } = null!;
+
+    [Inject]
+    protected IOrderedViewSource ViewSource { get; init; } = null!;
+
+    protected override async ValueTask DisposeAsyncCore(bool disposing)
+    {
+        if (disposing)
+        {
+            _disposed = true;
+            ViewSource.Updated -= OnViewUpdated;
+        }
+
+        await base.DisposeAsyncCore(disposing);
+    }
+
+    protected override void OnInitialized()
+    {
+        ViewSource.Updated += OnViewUpdated;
+        Presentation = ViewSource.Current;
+
+        base.OnInitialized();
+    }
+
+    protected virtual void OnPresentationChanged() { }
+
+    private void AdoptLatestPresentation()
+    {
+        Volatile.Write(ref _hasPendingRenderDispatch, 0);
+        Presentation = ViewSource.Current;
+        OnPresentationChanged();
+        StateHasChanged();
+    }
+
+    private async Task DispatchRenderAsync()
+    {
+        if (_disposed) { return; }
+
+        try { await InvokeAsync(AdoptLatestPresentation); }
+        catch (ObjectDisposedException) { }
+        catch (OperationCanceledException) { }
+    }
+
+    private void OnViewUpdated(OrderedViewPresentation presentation)
+    {
+        if (Interlocked.Exchange(ref _hasPendingRenderDispatch, 1) != 0) { return; }
+
+        _ = DispatchRenderAsync();
+    }
+}
diff --git a/src/EventLogExpert.UI/Common/SourceSubscription.cs b/src/EventLogExpert.UI/Common/SourceSubscription.cs
new file mode 100644
index 000000000..29e8a1018
--- /dev/null
+++ b/src/EventLogExpert.UI/Common/SourceSubscription.cs
@@ -0,0 +1,48 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+namespace EventLogExpert.UI.Common;
+
+public sealed class SourceSubscription : IDisposable
+{
+    private readonly Func<Task> _render;
+    private readonly Action _unsubscribe;
+
+    private volatile bool _disposed;
+
+    public SourceSubscription(Action<Action> subscribe, Action<Action> unsubscribe, Func<Task> render)
+    {
+        ArgumentNullException.ThrowIfNull(subscribe);
+        ArgumentNullException.ThrowIfNull(unsubscribe);
+        ArgumentNullException.ThrowIfNull(render);
+
+        _render = render;
+        _unsubscribe = () => unsubscribe(OnChanged);
+        subscribe(OnChanged);
+    }
+
+    public void Dispose()
+    {
+        if (_disposed) { return; }
+
+        _disposed = true;
+        _unsubscribe();
+    }
+
+    // that lands during teardown (the source is a singleton that outlives this component).
+    private void OnChanged()
+    {
+        if (_disposed) { return; }
+
+        _ = RenderAsync();
+    }
+
+    private async Task RenderAsync()
+    {
+        if (_disposed) { return; }
+
+        try { await _render(); }
+        catch (ObjectDisposedException) { }
+        catch (OperationCanceledException) { }
+    }
+}
diff --git a/src/EventLogExpert.UI/Dashboard/EmptyStateDashboard.razor b/src/EventLogExpert.UI/Dashboard/EmptyStateDashboard.razor
index 3a6af3786..e8a1f4e4f 100644
--- a/src/EventLogExpert.UI/Dashboard/EmptyStateDashboard.razor
+++ b/src/EventLogExpert.UI/Dashboard/EmptyStateDashboard.razor
@@ -1,4 +1,4 @@
-@inherits FluxorComponent
+@inherits AppStateComponentBase
 
 <section aria-labelledby="empty-dashboard-title" class="empty-dashboard" @ref="_dashboardRoot" role="region" tabindex="-1">
     <header class="empty-dashboard__masthead">
@@ -30,7 +30,7 @@
                     }
                 </div>
             }
-            @if (FilterApplied.Value)
+            @if (FilterAppliedSource.IsFilteringEnabled)
             {
                 <div class="empty-dashboard__chip" role="status">
                     <i aria-hidden="true" class="bi bi-funnel"></i>
diff --git a/src/EventLogExpert.UI/Dashboard/EmptyStateDashboard.razor.cs b/src/EventLogExpert.UI/Dashboard/EmptyStateDashboard.razor.cs
index 03955ced5..f0c508572 100644
--- a/src/EventLogExpert.UI/Dashboard/EmptyStateDashboard.razor.cs
+++ b/src/EventLogExpert.UI/Dashboard/EmptyStateDashboard.razor.cs
@@ -16,15 +16,13 @@
 using EventLogExpert.UI.Focus;
 using EventLogExpert.UI.Inputs;
 using EventLogExpert.UI.Modal;
-using Fluxor;
-using Fluxor.Blazor.Web.Components;
 using Microsoft.AspNetCore.Components;
 using System.Collections.Frozen;
 using System.Collections.Immutable;
 
 namespace EventLogExpert.UI.Dashboard;
 
-public sealed partial class EmptyStateDashboard : FluxorComponent
+public sealed partial class EmptyStateDashboard : AppStateComponentBase
 {
     private const string ElevationReasonId = "empty-dashboard-elevation-reason";
 
@@ -76,14 +74,12 @@ public sealed partial class EmptyStateDashboard : FluxorComponent
 
     [Inject] private IScenarioFavoriteCommands FavoriteCommands { get; init; } = null!;
 
-    [Inject] private IStateSelection<ScenarioFavoritesState, ImmutableHashSet<string>> Favorites { get; init; } = null!;
+    [Inject] private IScenarioFavoritesSource FavoritesSource { get; init; } = null!;
 
-    [Inject] private IStateSelection<EventLogState, bool> FilterApplied { get; init; } = null!;
+    [Inject] private IFilterAppliedSource FilterAppliedSource { get; init; } = null!;
 
     [Inject] private IFilterPaneCommands FilterCommands { get; init; } = null!;
 
-    [Inject] private IState<ScenarioFavoritesState> ScenarioFavorites { get; init; } = null!;
-
     [Inject] private IScenarioLaunchService ScenarioLaunch { get; init; } = null!;
 
     [Inject] private IScenarioQueryService ScenarioQuery { get; init; } = null!;
@@ -121,10 +117,9 @@ public sealed partial class EmptyStateDashboard : FluxorComponent
 
     protected override async ValueTask DisposeAsyncCore(bool disposing)
     {
-        if (disposing)
+        if (disposing && !_disposed)
         {
             _disposed = true;
-            Favorites.SelectedValueChanged -= OnFavoritesChanged;
             await _lifetimeCts.CancelAsync();
             _lifetimeCts.Dispose();
         }
@@ -160,9 +155,12 @@ protected override async Task OnAfterRenderAsync(bool firstRender)
 
     protected override void OnInitialized()
     {
-        FilterApplied.Select(state => state.AppliedFilter.IsFilteringEnabled);
-        Favorites.Select(state => state.FavoriteScenarioIds);
-        Favorites.SelectedValueChanged += OnFavoritesChanged;
+        ObserveSource(FilterAppliedSource);
+        ObserveSource(
+            handler => FavoritesSource.Changed += handler,
+            handler => FavoritesSource.Changed -= handler,
+            OnFavoritesChangedAsync);
+
         FavoriteCommands.Load();
         base.OnInitialized();
     }
@@ -267,8 +265,6 @@ private static bool HasReactiveFolderFallback(ScenarioLaunchResult result) =>
             or ChannelLaunchOutcome.NotPresent
             or ChannelLaunchOutcome.Failed);
 
-    // Analytic/Debug channels never have their access evaluated (NotEvaluated), so they must not be
-    // treated as blocked; only a genuine RequiresElevation or a read-failure Unknown disables launch.
     private bool AccessAllowsLaunch(string channel) =>
         _readinessByChannel.GetValueOrDefault(
             channel,
@@ -277,8 +273,6 @@ private bool AccessAllowsLaunch(string channel) =>
 
     private void CancelFolderScan()
     {
-        // No-op once the scan has committed to opening or a cancel is already in flight. The null-field guard plus the
-        // null-before-Dispose ordering in the finally means Cancel() is never called on a disposed source.
         if (_openingLogs || _cancelRequested || _folderLaunchCts is null) { return; }
 
         _cancelRequested = true;
@@ -311,8 +305,6 @@ private Task EnableChannelAsync(string channel) =>
                 return;
             }
 
-            // The committed change is authoritative; re-run the full readiness fetch (never a single-channel probe,
-            // which would make LivePresence treat one channel as the complete set) so the pill reflects real state.
             await RefreshReadinessAsync();
 
             if (!_readinessByChannel.TryGetValue(channel, out var refreshed)
@@ -340,7 +332,7 @@ private IReadOnlyList<ChannelReadiness> GetOptionalChannelReadiness(ScenarioDefi
         scenario.OptionalChannels.IsDefaultOrEmpty ? [] : ReadinessFor(scenario.OptionalChannels);
 
     private bool IsFavored(ScenarioDefinition scenario) =>
-        ScenarioFavorites.Value.FavoriteScenarioIds.Contains(scenario.Id);
+        FavoritesSource.FavoriteScenarioIds.Contains(scenario.Id);
 
     private bool IsLivePresent(ScenarioDefinition scenario) =>
         !_livePresence.Known || scenario.Channels.All(_livePresence.Present.Contains);
@@ -391,9 +383,6 @@ private async Task LaunchScenarioFromFolderCoreAsync(ScenarioDefinition scenario
 
             if (_scanningScenario is not null)
             {
-                // Hide the scan chip before any result dialog. The banner-retry path does not run in the dashboard's
-                // event loop, so it will not auto-render; the explicit render is required there. Clear the scan-end
-                // focus intent too, so an Opening-set request cannot steal focus from a result modal opened below.
                 _scanningScenario = null;
                 _openingLogs = false;
                 _cancelRequested = false;
@@ -406,34 +395,26 @@ private async Task LaunchScenarioFromFolderCoreAsync(ScenarioDefinition scenario
 
         if (DescribeFolderLaunch(scenario, result) is not { } message)
         {
-            // Cancelled: no dialog takes focus and the Cancel chip that had focus is gone, so restore it.
             if (scanStarted) { RestoreFocusAfterScan(); }
 
             return;
         }
 
-        // A launch that opens logs is self-evident (the workspace changes) and only needs the screen-reader detail;
-        // the outcomes that leave the dashboard unchanged need a visible dialog so a sighted user sees them.
         switch (result.Outcome)
         {
             case ScenarioFolderOutcome.Completed:
                 Announcer.Announce(message);
                 break;
             case ScenarioFolderOutcome.Error:
-                // ShowErrorAlert surfaces a banner, which does not capture focus; restore it so a scan that showed the
-                // Cancel chip does not strand keyboard focus on <body>.
                 if (scanStarted) { RestoreFocusAfterScan(); }
 
                 await AlertDialogService.ShowErrorAlert("Open from folder", message);
                 break;
             default:
-                // ShowAlert opens a focus-capturing modal, so it owns focus; issuing a restore here would fight it.
                 await AlertDialogService.ShowAlert("Open from folder", message, "OK");
                 break;
         }
 
-        // Runs on the UI dispatcher via SafeInvokeAsync and must never throw out of onPhase: it executes outside the
-        // service's cancellation catch, so an escaping teardown exception would surface a normal launch as a fault.
         async Task OnFolderScanPhaseAsync(ScenarioFolderPhase phase) =>
             await SafeInvokeAsync(() =>
             {
@@ -460,19 +441,18 @@ await SafeInvokeAsync(() =>
             });
     }
 
-    private async void OnFavoritesChanged(object? _, ImmutableHashSet<string> __)
+    private Task OnFavoritesChangedAsync()
     {
-        try
-        {
-            await InvokeAsync(() =>
-            {
-                RebuildCategories();
-                ReconcileActiveTab();
-                StateHasChanged();
-            });
-        }
-        catch (ObjectDisposedException) { }
-        catch (OperationCanceledException) { }
+        if (_disposed) { return Task.CompletedTask; }
+
+        RebuildCategories();
+        ReconcileActiveTab();
+
+        if (_disposed) { return Task.CompletedTask; }
+
+        StateHasChanged();
+
+        return Task.CompletedTask;
     }
 
     private Task OpenApplicationAndSystemAsync() =>
@@ -589,10 +569,6 @@ private async Task RunGuardedAsync(Func<Task> action)
 
         try
         {
-            // Render immediately (inside the try, so the finally still clears _isBusy if this ever threw) so the
-            // busy-gated controls disable right away. On a normal button click Blazor auto-renders at the first await
-            // inside the action, but the banner-retry path runs outside the dashboard's event loop and gets no
-            // automatic render, so without this the controls would stay visibly enabled during the folder picker.
             await SafeInvokeAsync(StateHasChanged);
             await action();
         }
@@ -600,7 +576,6 @@ private async Task RunGuardedAsync(Func<Task> action)
         {
             _isBusy = false;
 
-            // Re-render after clearing the busy flag for the same non-event-loop reason, so the controls re-enable.
             await SafeInvokeAsync(StateHasChanged);
         }
     }
@@ -609,8 +584,6 @@ private async Task SafeInvokeAsync(Action render)
     {
         if (_disposed) { return; }
 
-        // Matches the OnFavoritesChanged teardown pattern: a render can race the dashboard unmounting when a folder
-        // launch opens logs; treat disposal and cancellation as expected.
         try { await InvokeAsync(render); }
         catch (ObjectDisposedException) { }
         catch (OperationCanceledException) { }
diff --git a/src/EventLogExpert.UI/Database/DatabaseEntryRow.razor.cs b/src/EventLogExpert.UI/Database/DatabaseEntryRow.razor.cs
index c9cede922..a991d86f7 100644
--- a/src/EventLogExpert.UI/Database/DatabaseEntryRow.razor.cs
+++ b/src/EventLogExpert.UI/Database/DatabaseEntryRow.razor.cs
@@ -6,10 +6,10 @@
 using EventLogExpert.Runtime.Banner;
 using EventLogExpert.Runtime.Database;
 using EventLogExpert.Runtime.Database.Upgrade;
-using EventLogExpert.Runtime.Menu;
 using EventLogExpert.UI.Common;
 using EventLogExpert.UI.Focus;
 using EventLogExpert.UI.Inputs;
+using EventLogExpert.UI.Menu;
 using Microsoft.AspNetCore.Components;
 using Microsoft.AspNetCore.Components.Web;
 using System.Globalization;
@@ -18,7 +18,6 @@ namespace EventLogExpert.UI.Database;
 
 public sealed partial class DatabaseEntryRow : ComponentBase
 {
-    // Classification reads one extra stamp so "9+" means more than nine distinct versions.
     private const int OsStampDisplayCap = 9;
 
     private static readonly IReadOnlyDictionary<string, object> s_ariaHiddenTrueAttributes =
@@ -86,14 +85,12 @@ private enum ActionKind
 
     private bool IsRestoreBlocked => IsUpgradeBlocked || IsUpgrading || UpgradeProgress is not null;
 
-    // Bare revisions and non-positive builds carry no provenance without edition/display version.
     private IReadOnlyList<ProviderDatabaseOsStamp> MeaningfulOsStamps => _meaningfulOsStamps;
 
     [Inject] private IMenuService MenuService { get; init; } = null!;
 
     private string OsStampAriaLabel => $"Source OS: {OsStampDetail}";
 
-    // Keep full detail in both title and accessible label so OS info is not hover-only.
     private string OsStampDetail => _osStampDetail;
 
     private string OsStampSummary => _osStampSummary;
@@ -160,7 +157,6 @@ protected override void OnParametersSet()
 
     private static string? FormatBuildRevision(int? build, int? revision)
     {
-        // UBR is meaningful only with a real build; revision 0 is valid for RTM builds.
         if (build is not > 0) { return null; }
 
         return revision is not null
diff --git a/src/EventLogExpert.UI/Database/DatabaseRecoveryHost.cs b/src/EventLogExpert.UI/Database/DatabaseRecoveryHost.cs
index 957e45094..e27baedca 100644
--- a/src/EventLogExpert.UI/Database/DatabaseRecoveryHost.cs
+++ b/src/EventLogExpert.UI/Database/DatabaseRecoveryHost.cs
@@ -5,18 +5,10 @@
 using EventLogExpert.Runtime.Banner;
 using EventLogExpert.Runtime.Common.Threading;
 using EventLogExpert.Runtime.Database;
-using EventLogExpert.Runtime.Modal;
 using EventLogExpert.UI.Modal;
 
 namespace EventLogExpert.UI.Database;
 
-/// <summary>
-///     Coordinates the recovery banner and modal lifecycle in response to
-///     <see cref="IDatabaseService.EntriesChanged" />. Registered as a singleton and force-instantiated in MauiProgram so
-///     it begins observing state at startup. Crashes in event handlers route through
-///     <see cref="ICriticalErrorService.ReportCritical(Exception)" /> to preserve the original Main.razor placement intent
-///     (UnhandledExceptionHandler coverage equivalent).
-/// </summary>
 public sealed class DatabaseRecoveryHost : IDisposable
 {
     private readonly ICriticalErrorService _criticalErrorService;
diff --git a/src/EventLogExpert.UI/Database/DatabaseRecoveryModal.razor.cs b/src/EventLogExpert.UI/Database/DatabaseRecoveryModal.razor.cs
index 4b204a390..af31b8a07 100644
--- a/src/EventLogExpert.UI/Database/DatabaseRecoveryModal.razor.cs
+++ b/src/EventLogExpert.UI/Database/DatabaseRecoveryModal.razor.cs
@@ -4,7 +4,6 @@
 using EventLogExpert.Logging.Abstractions;
 using EventLogExpert.Runtime.Banner;
 using EventLogExpert.Runtime.Database;
-using EventLogExpert.Runtime.Modal;
 using EventLogExpert.UI.Modal;
 using Microsoft.AspNetCore.Components;
 
diff --git a/src/EventLogExpert.UI/DatabaseTools/DatabaseToolsModal.razor.cs b/src/EventLogExpert.UI/DatabaseTools/DatabaseToolsModal.razor.cs
index 5df17dd1c..f2b078e75 100644
--- a/src/EventLogExpert.UI/DatabaseTools/DatabaseToolsModal.razor.cs
+++ b/src/EventLogExpert.UI/DatabaseTools/DatabaseToolsModal.razor.cs
@@ -2,12 +2,12 @@
 // // Licensed under the MIT License.
 
 using EventLogExpert.Logging.Abstractions;
-using EventLogExpert.Runtime.Alerts;
 using EventLogExpert.Runtime.Announcement;
 using EventLogExpert.Runtime.Database;
 using EventLogExpert.Runtime.EventLog;
-using EventLogExpert.Runtime.Modal;
+using EventLogExpert.UI.Alerts;
 using EventLogExpert.UI.DatabaseTools.Tabs;
+using EventLogExpert.UI.Modal;
 using Microsoft.AspNetCore.Components;
 
 namespace EventLogExpert.UI.DatabaseTools;
@@ -120,7 +120,6 @@ protected override async Task<bool> OnRequestCloseAsync(ModalCloseRequest reques
                 if (!closeAnyway.Accepted) { return false; }
             }
 
-            // Async prompts can race Manage-tab upgrades; re-check before closing.
             if (_manageTab is { IsUpgradeInFlight: true }) { return false; }
         }
 
@@ -139,7 +138,6 @@ protected override async Task<bool> OnRequestCloseAsync(ModalCloseRequest reques
             if (!confirm.Accepted) { return false; }
         }
 
-        // Covers upgrades started during the running-operation prompt.
         if (_manageTab is { IsUpgradeInFlight: true }) { return false; }
 
         return true;
diff --git a/src/EventLogExpert.UI/DatabaseTools/IInlineAlertSurface.cs b/src/EventLogExpert.UI/DatabaseTools/IInlineAlertSurface.cs
index 6f7629495..745478e8c 100644
--- a/src/EventLogExpert.UI/DatabaseTools/IInlineAlertSurface.cs
+++ b/src/EventLogExpert.UI/DatabaseTools/IInlineAlertSurface.cs
@@ -1,15 +1,10 @@
 // // Copyright (c) Microsoft Corporation.
 // // Licensed under the MIT License.
 
-using EventLogExpert.Runtime.Alerts;
+using EventLogExpert.UI.Alerts;
 
 namespace EventLogExpert.UI.DatabaseTools;
 
-/// <summary>
-///     Cascading-value surface that lets a child component (e.g. ManageDatabasesTab) raise an inline alert through
-///     its hosting modal. Implemented by <see cref="DatabaseToolsModal" /> via implicit interface satisfaction against the
-///     inherited public <c>ShowInlineAlertAsync</c> from <c>ModalBase</c>.
-/// </summary>
 internal interface IInlineAlertSurface
 {
     Task<InlineAlertResult> ShowInlineAlertAsync(
diff --git a/src/EventLogExpert.UI/DatabaseTools/Tabs/CreateDatabaseTab.razor.cs b/src/EventLogExpert.UI/DatabaseTools/Tabs/CreateDatabaseTab.razor.cs
index 027015e3c..8058f225e 100644
--- a/src/EventLogExpert.UI/DatabaseTools/Tabs/CreateDatabaseTab.razor.cs
+++ b/src/EventLogExpert.UI/DatabaseTools/Tabs/CreateDatabaseTab.razor.cs
@@ -6,9 +6,9 @@
 using EventLogExpert.DatabaseTools.CreateDatabase;
 using EventLogExpert.Eventing.OfflineImaging.Wim;
 using EventLogExpert.Logging.Abstractions;
-using EventLogExpert.Runtime.Alerts;
 using EventLogExpert.Runtime.Common.Versioning;
 using EventLogExpert.Runtime.DatabaseTools.Elevation;
+using EventLogExpert.UI.Alerts;
 using Microsoft.AspNetCore.Components;
 using System.Globalization;
 using System.Text.RegularExpressions;
@@ -94,7 +94,6 @@ protected override CreateDatabaseRequest BuildRequest()
         var source = string.IsNullOrWhiteSpace(_sourcePath) ? null : _sourcePath.Trim();
         var wimIndex = _wimIndex is > 0 ? _wimIndex : null;
 
-        // Only user-marked folders force Directory; image files must auto-detect from extension.
         var imageKind = IsMarkedFolderImage ? OfflineImageKind.Directory : (OfflineImageKind?)null;
 
         return new(
@@ -108,7 +107,6 @@ protected override CreateDatabaseRequest BuildRequest()
             Overwrite: _overwriteConfirmedFor is not null && string.Equals(_overwriteConfirmedFor, _targetPath.Trim(), StringComparison.Ordinal));
     }
 
-    // The confirmed overwrite target is snapshotted so edits during the prompt cannot inherit it.
     protected override async Task<bool> ConfirmBeforeDispatchAsync()
     {
         _overwriteConfirmedFor = null;
@@ -192,7 +190,6 @@ private async Task LoadEditionsAsync()
                 }
                 else if (_imageEditions.All(edition => edition.Index != _wimIndex))
                 {
-                    // A loaded matching index is preserved; otherwise show the first edition as visible confirmation.
                     _wimIndex = _imageEditions[0].Index;
                 }
             }
@@ -248,8 +245,6 @@ private async Task PickTargetAsync()
         if (!string.IsNullOrEmpty(path)) { _targetPath = path; }
     }
 
-    // Directory.Exists can block for seconds on an unresponsive UNC path; the source box re-renders on every keystroke, so
-    // the folder-existence check runs off the UI thread and only its cached result drives the markup.
     private async Task RefreshSourceIsDirectoryAsync(string path)
     {
         string trimmed = path.Trim();
diff --git a/src/EventLogExpert.UI/DatabaseTools/Tabs/ManageDatabasesTab.razor.cs b/src/EventLogExpert.UI/DatabaseTools/Tabs/ManageDatabasesTab.razor.cs
index 38b97030b..997be70c1 100644
--- a/src/EventLogExpert.UI/DatabaseTools/Tabs/ManageDatabasesTab.razor.cs
+++ b/src/EventLogExpert.UI/DatabaseTools/Tabs/ManageDatabasesTab.razor.cs
@@ -2,12 +2,12 @@
 // // Licensed under the MIT License.
 
 using EventLogExpert.Logging.Abstractions;
-using EventLogExpert.Runtime.Alerts;
 using EventLogExpert.Runtime.Announcement;
 using EventLogExpert.Runtime.Banner;
 using EventLogExpert.Runtime.Database;
 using EventLogExpert.Runtime.Database.Upgrade;
 using EventLogExpert.Runtime.EventLog;
+using EventLogExpert.UI.Alerts;
 using EventLogExpert.UI.Common;
 using EventLogExpert.UI.Database;
 using EventLogExpert.UI.Focus;
@@ -20,6 +20,8 @@ namespace EventLogExpert.UI.DatabaseTools.Tabs;
 
 public sealed partial class ManageDatabasesTab : ComponentBase, IAsyncDisposable
 {
+    private const int MaxListedFileNames = 5;
+
     private static readonly TimeSpan s_cancelTimeout = TimeSpan.FromSeconds(30);
 
     private readonly Dictionary<string, bool> _pendingToggles = new(StringComparer.OrdinalIgnoreCase);
@@ -130,12 +132,6 @@ public async Task ExitSelectionModeWithFocusAsync()
         await FocusRestoreAsync(_selectButton);
     }
 
-    /// <summary>
-    ///     Save wrapper invoked by <see cref="DatabaseToolsModal" /> on the unsaved-changes close prompt and by the
-    ///     inline Save button. Returns true on success or no-op; false when blocked by an in-flight upgrade or when the
-    ///     coordinator apply faulted. Sets <see cref="HasDatabaseStateChanged" /> bookkeeping when active state actually
-    ///     changed.
-    /// </summary>
     internal async Task<bool> ApplyPendingTogglesAsync()
     {
         if (IsUpgradeBlocked) { return false; }
@@ -207,8 +203,8 @@ protected override void OnInitialized()
 
     private static string BuildBulkPlainMessage(IReadOnlyList<string> fileNames)
     {
-        var list = string.Join(", ", fileNames.Take(5));
-        var more = fileNames.Count > 5 ? $", and {fileNames.Count - 5} more" : string.Empty;
+        var list = string.Join(", ", fileNames.Take(MaxListedFileNames));
+        var more = fileNames.Count > MaxListedFileNames ? $", and {fileNames.Count - MaxListedFileNames} more" : string.Empty;
 
         return $"Are you sure you want to remove these {fileNames.Count} databases? ({list}{more})";
     }
@@ -233,7 +229,6 @@ private static string GetSkipReason(DatabaseEntry entry, bool isUpgrading)
 
     private async Task AnnounceBulkUpgradeOutcomeAsync(UpgradeBatchResult? result, int attempted)
     {
-        // Gate-denied (singleton upgrade gate held by another caller).
         if (result is null)
         {
             if (AlertSurface is null) { return; }
@@ -253,10 +248,6 @@ private async Task AnnounceBulkUpgradeOutcomeAsync(UpgradeBatchResult? result, i
             return;
         }
 
-        // Exception-fallback: coordinator's RunOperationAsync<T> returns an empty
-        // result on a thrown exception. The error banner already fired upstream;
-        // suppress the success-shaped announcement that would otherwise read
-        // "Upgraded 0 databases" alongside it.
         if (attempted > 0
             && result.Succeeded.Count == 0
             && result.Failed.Count == 0
@@ -329,10 +320,10 @@ private async Task<bool> AskOverwriteAsync(string fileName, CancellationToken ca
 
     private string BuildCancelThenRemoveMessage(IReadOnlyList<string> fileNames, IReadOnlyList<string> upgradingFiles)
     {
-        var upgradingList = string.Join(", ", upgradingFiles.Take(5));
-        var moreUpgrading = upgradingFiles.Count > 5 ? $", and {upgradingFiles.Count - 5} more" : string.Empty;
-        var fileList = string.Join(", ", fileNames.Take(5));
-        var moreFiles = fileNames.Count > 5 ? $", and {fileNames.Count - 5} more" : string.Empty;
+        var upgradingList = string.Join(", ", upgradingFiles.Take(MaxListedFileNames));
+        var moreUpgrading = upgradingFiles.Count > MaxListedFileNames ? $", and {upgradingFiles.Count - MaxListedFileNames} more" : string.Empty;
+        var fileList = string.Join(", ", fileNames.Take(MaxListedFileNames));
+        var moreFiles = fileNames.Count > MaxListedFileNames ? $", and {fileNames.Count - MaxListedFileNames} more" : string.Empty;
 
         string baseMessage = $"Upgrade in progress for: {upgradingList}{moreUpgrading}. " +
             $"This will cancel the upgrade batch(es) \u2014 which may include other files not in your selection \u2014 " +
@@ -394,9 +385,6 @@ void CompletionHandler(object? sender, UpgradeBatchCompletedEventArgs args)
             }
         }
 
-        // Coordinator-only - adding IsFileInAnyKnownBatch here would 30s-hang on background batches
-        // (no UpgradeStateChanged event ever fires to re-trigger). pendingBatches + stillAlive below
-        // already gate Remove via UpgradeBatchCompleted.
         void StateChangedHandler()
         {
             if (!fileNames.Any(f => Coordinator.IsUpgradeInFlight(f)))
@@ -412,8 +400,6 @@ void StateChangedHandler()
         {
             foreach (var (batchId, files) in batchToFiles)
             {
-                // stillAlive includes IsFileInAnyKnownBatch so pendingBatches stays unset for
-                // pre-progress / queued files until the real UpgradeBatchCompleted fires.
                 bool stillAlive = files.Any(file =>
                 {
                     var entry = DatabaseService.Entries.FirstOrDefault(
@@ -546,8 +532,6 @@ private void ExitSelectionMode()
 
     private async Task FocusAfterBulkUpgradeAsync()
     {
-        // After clean-success auto-exit, the bulk strip is gone; focus the Select
-        // button so keyboard users have a stable anchor.
         if (!_isSelectionModeActive)
         {
             await FocusRestoreAsync(_selectButton);
@@ -577,8 +561,6 @@ private async ValueTask FocusEntryRowNameAsync(string fileName)
         await FocusRestoreAsync(_importButton);
     }
 
-    // Lookup by batch membership (active + queued) for the cancel-then-remove flow. Distinct from
-    // GetUpgradeProgressForEntry, which matches by CurrentEntryName for per-row display only.
     private CancellableBatch? GetCancellableBatchForFile(string fileName)
     {
         var manage = ProgressBannerService.ManageDatabasesProgress;
@@ -773,8 +755,6 @@ private async Task OnBulkUpgradeClickAsync()
 
         await AnnounceBulkUpgradeOutcomeAsync(result, eligible.Count);
 
-        // Auto-exit only on a fully-clean batch: any partial-failure/cancellation
-        // leaves the relevant rows selected so the user can retry or inspect.
         bool cleanSuccess = result is not null
             && result.Failed.Count == 0
             && result.Cancelled.Count == 0
@@ -813,9 +793,6 @@ private void OnDatabaseEntriesChanged(object? sender, EventArgs e)
             UpdateSelectionAnnouncement();
         }
 
-        // Always recompute when any selection exists: a row's status / backup /
-        // upgrade state can change in-place (classification completion, backup
-        // restore, upgrade finished) without changing the entry list itself.
         if (_selectedForBulk.Count > 0)
         {
             RecomputeEligibleCount();
@@ -828,10 +805,6 @@ private void OnDatabaseEntriesChanged(object? sender, EventArgs e)
 
         foreach (var key in deadRefs) { _rowRefs.Remove(key); }
 
-        // When the entries list collapses to zero, the Select button and entry rows
-        // disappear from the DOM; restore focus to Import so keyboard users don't lose
-        // their anchor. Exit selection mode in the same step so the bulk strip doesn't
-        // render above an empty-state placeholder.
         if (currentNames.Count == 0)
         {
             if (_isSelectionModeActive)
@@ -1044,8 +1017,6 @@ private async Task RemoveDatabasesAsync(IReadOnlyList<string> fileNames, FocusTa
             _focusRestorationTarget = (anchorFileName, completeTarget);
         }
 
-        // Auto-exit on a fully-clean bulk delete only: any failure leaves the
-        // failed rows selected so the user can retry without re-selecting them.
         if (_isSelectionModeActive && succeeded.Count > 0 && failed.Count == 0)
         {
             ExitSelectionMode();
diff --git a/src/EventLogExpert.UI/DependencyInjection/UiServiceCollectionExtensions.cs b/src/EventLogExpert.UI/DependencyInjection/UIServiceCollectionExtensions.cs
similarity index 51%
rename from src/EventLogExpert.UI/DependencyInjection/UiServiceCollectionExtensions.cs
rename to src/EventLogExpert.UI/DependencyInjection/UIServiceCollectionExtensions.cs
index 150c7660c..8ff69c855 100644
--- a/src/EventLogExpert.UI/DependencyInjection/UiServiceCollectionExtensions.cs
+++ b/src/EventLogExpert.UI/DependencyInjection/UIServiceCollectionExtensions.cs
@@ -4,21 +4,16 @@
 using EventLogExpert.UI.Keyboard;
 using EventLogExpert.UI.LogTable.Find;
 using EventLogExpert.UI.Menu;
+using EventLogExpert.UI.Modal;
+using Microsoft.Extensions.DependencyInjection.Extensions;
 
 namespace Microsoft.Extensions.DependencyInjection;
 
-public static class UiServiceCollectionExtensions
+public static class UIServiceCollectionExtensions
 {
     extension(IServiceCollection services)
     {
-        /// <summary>Registers the EventLogExpert UI-library services into the host container.</summary>
-        /// <remarks>
-        ///     The registered <see cref="KeyboardShortcutService" /> resolves <c>IMenuActionService</c>,
-        ///     <c>IModalCoordinator</c>, and <c>ISettingsService</c> from the container - the host must register those
-        ///     abstractions (the Runtime layer via <c>AddEventLogRuntime</c> plus the host's menu adapter) before resolving UI
-        ///     services.
-        /// </remarks>
-        public IServiceCollection AddEventLogUiServices()
+        public IServiceCollection AddEventLogUIServices()
         {
             ArgumentNullException.ThrowIfNull(services);
 
@@ -27,6 +22,10 @@ public IServiceCollection AddEventLogUiServices()
             services.AddSingleton<IFindMarkerSource, FindMarkerSource>();
             services.AddSingleton<KeyboardShortcutService>();
 
+            services.TryAddSingleton<IMenuService, MenuService>();
+            services.TryAddSingleton<IModalCoordinator, ModalCoordinator>();
+            services.TryAddSingleton<IModalService, ModalService>();
+
             return services;
         }
     }
diff --git a/src/EventLogExpert.UI/DetailsPane/DetailsPane.razor b/src/EventLogExpert.UI/DetailsPane/DetailsPane.razor
index 0138d6a96..c2a94b157 100644
--- a/src/EventLogExpert.UI/DetailsPane/DetailsPane.razor
+++ b/src/EventLogExpert.UI/DetailsPane/DetailsPane.razor
@@ -1,4 +1,8 @@
-@inherits FluxorComponent
+@inherits AppStateComponentBase
+
+@{
+    bool showsLiveModel = _model is not null && _selectedHandle == EventFocus.Current?.CurrentHandle;
+}
 
 <div class="details-pane" data-toggle="@IsExpanded" hidden="@(_selectedEvent is null)">
     <div class="details-resizer"></div>
@@ -35,7 +39,7 @@
         }
 
         <div class="details-headerbar-actions">
-            @if (_isExpanded && _model is not null)
+            @if (_isExpanded && showsLiveModel)
             {
                 <button aria-label="Copy event to clipboard" class="details-copy-event" @onclick="CopyEventAsync" type="button">
                     <i class="bi bi-clipboard"></i>
@@ -57,8 +61,12 @@
     <div class="details-body" id="details-body">
         @if (_model is not null)
         {
-            <div aria-labelledby="details-tab-reader" class="details-reader" hidden="@(_activeTab != DetailsTab.Reader)" id="details-tabpanel-reader" role="tabpanel">
-                @if (_activeTab == DetailsTab.Reader)
+            <div aria-labelledby="details-tab-reader"
+                class="details-reader"
+                hidden="@(_activeTab != DetailsTab.Reader)"
+                id="details-tabpanel-reader"
+                role="tabpanel">
+                @if (_activeTab == DetailsTab.Reader && showsLiveModel)
                 {
                     <div class="details-reader-layout">
                         <div class="reader-rail">
@@ -87,8 +95,6 @@
                                 </dl>
                             }
 
-                            @* Capture the render-time non-null event so the button closures act on the event that was
-                               displayed when clicked, never on a newer/null selection read from the mutable field. *@
                             @if (_selectedEvent is { } correlationEvent && (correlationEvent.ActivityId.HasValue || correlationEvent.RelatedActivityId.HasValue))
                             {
                                 <section class="details-correlation">
@@ -225,7 +231,7 @@
             </div>
 
             <p aria-labelledby="details-tab-xml" class="details-xml" hidden="@(_activeTab != DetailsTab.Xml)" id="details-tabpanel-xml" role="tabpanel">
-                @if (_activeTab == DetailsTab.Xml)
+                @if (_activeTab == DetailsTab.Xml && showsLiveModel)
                 {
                     @if (_resolvedXml is null)
                     {
diff --git a/src/EventLogExpert.UI/DetailsPane/DetailsPane.razor.cs b/src/EventLogExpert.UI/DetailsPane/DetailsPane.razor.cs
index 5b1d0e2ea..1fb5712d2 100644
--- a/src/EventLogExpert.UI/DetailsPane/DetailsPane.razor.cs
+++ b/src/EventLogExpert.UI/DetailsPane/DetailsPane.razor.cs
@@ -1,7 +1,6 @@
 // // Copyright (c) Microsoft Corporation.
 // // Licensed under the MIT License.
 
-using EventLogExpert.Eventing.Common.EventLogs;
 using EventLogExpert.Eventing.Common.Events;
 using EventLogExpert.Eventing.Resolvers;
 using EventLogExpert.Logging.Abstractions;
@@ -12,7 +11,6 @@
 using EventLogExpert.Runtime.LogTable;
 using EventLogExpert.Runtime.Settings;
 using EventLogExpert.UI.Common.Interop;
-using Fluxor;
 using Microsoft.AspNetCore.Components;
 using Microsoft.JSInterop;
 using System.Xml;
@@ -26,18 +24,14 @@ public sealed partial class DetailsPane
 
     private DetailsTab _activeTab = DetailsTab.Reader;
     private IJSObjectReference? _detailsPaneModule;
+    private bool _disposed;
     private DotNetObjectReference<DetailsPane>? _dotNetRef;
     private bool _hasOpened;
     private bool _isExpanded;
     private DetailsReaderModel? _model;
     private string? _resolvedXml;
     private ResolvedEvent? _selectedEvent;
-    /// <summary>
-    ///     Locator of the current focus, used to detect a stale async XML resolution: a re-resolve mid-fetch mints a new
-    ///     <see cref="ResolvedEvent" />, so reference identity can't gate the result but the locator can.
-    /// </summary>
     private EventLocator? _selectedHandle;
-    /// <summary>Cancels any in-flight XML resolution when the selection changes again before completion.</summary>
     private CancellationTokenSource? _xmlResolveCts;
 
     private enum DetailsTab
@@ -46,22 +40,22 @@ private enum DetailsTab
         Xml
     }
 
-    [Inject] private IStateSelection<LogTableState, EventLogId?> ActiveLog { get; init; } = null!;
+    [Inject] private IActiveEventLogSource ActiveEventLog { get; init; } = null!;
 
     [Inject] private IClipboardService Clipboard { get; init; } = null!;
 
+    [Inject] private IEventDetailResolver DetailResolver { get; init; } = null!;
+
+    [Inject] private IEventFocusSource EventFocus { get; init; } = null!;
+
     [Inject] private IEventXmlResolver EventXmlResolver { get; init; } = null!;
 
     [Inject] private IFilterLensCommands FilterLensCommands { get; init; } = null!;
 
-    [Inject] private IStateSelection<EventLogState, SelectionEntry?> Focus { get; init; } = null!;
-
     private string IsExpanded => _isExpanded.ToString().ToLowerInvariant();
 
     [Inject] private IJSRuntime JSRuntime { get; init; } = null!;
 
-    [Inject] private IState<LogTableState> LogTableState { get; init; } = null!;
-
     [Inject] private IDetailsPanePreferencesProvider PreferencesProvider { get; init; } = null!;
 
     [Inject] private ISettingsService Settings { get; init; } = null!;
@@ -81,8 +75,8 @@ protected override async ValueTask DisposeAsyncCore(bool disposing)
     {
         if (disposing)
         {
-            Focus.SelectedValueChanged -= OnFocusChanged;
-            ActiveLog.SelectedValueChanged -= OnActiveLogChanged;
+            _disposed = true;
+
             Settings.TimeZoneChanged -= OnTimeZoneChanged;
 
             try { _xmlResolveCts?.Cancel(); } catch (ObjectDisposedException) { /* CTS already disposed; cancel is moot. */ }
@@ -122,22 +116,14 @@ await _detailsPaneModule.InvokeVoidAsync(
 
     protected override void OnInitialized()
     {
-        Focus.Select(s => s.Focus);
-        Focus.SelectedValueChanged += OnFocusChanged;
-
-        // The active tab / log is the reset signal for the view tab (NOT the selected event's member log, which varies
-        // per selection inside a combined view).
-        ActiveLog.Select(s => s.ActiveEventLogId);
-        ActiveLog.SelectedValueChanged += OnActiveLogChanged;
+        ObserveSource(EventFocus, OnFocusChangedAsync);
+        ObserveSource(ActiveEventLog, OnActiveLogChangedAsync);
 
-        // The reader model pre-renders timestamps in the configured zone, so a zone change must rebuild it.
         Settings.TimeZoneChanged += OnTimeZoneChanged;
 
-        // Seed from the current store value so the pane reflects an existing focus (e.g., a restore that completed
-        // before this component subscribed) instead of staying empty until the next change event.
-        if (Focus.Value is not null)
+        if (EventFocus.Current is not null)
         {
-            OnFocusChanged(this, Focus.Value);
+            _ = OnFocusChangedAsync();
         }
 
         base.OnInitialized();
@@ -177,33 +163,30 @@ private string GetXmlForDisplay()
 
     private bool IsFieldExpanded(int index) => _expandedFields.Contains(index);
 
-    private async void OnActiveLogChanged(object? sender, EventLogId? activeLog)
+    private Task OnActiveLogChangedAsync()
     {
-        try
+        if (!_disposed)
         {
             _activeTab = DetailsTab.Reader;
-
-            await InvokeAsync(StateHasChanged);
-        }
-        catch (Exception ex)
-        {
-            TraceLogger.Error($"{nameof(DetailsPane)}: failed to handle active-log change: {ex}");
+            StateHasChanged();
         }
+
+        return Task.CompletedTask;
     }
 
-    private async void OnFocusChanged(object? sender, SelectionEntry? focus)
+    private async Task OnFocusChangedAsync()
     {
         try
         {
+            if (_disposed) { return; }
+
+            var focus = EventFocus.Current;
             var handle = focus?.CurrentHandle;
             _selectedHandle = handle;
 
-            // A null CurrentHandle (a selection whose row could not be re-resolved after a reload) resolves to nothing,
-            // leaving _selectedEvent/_model null so the pane hides.
             ResolvedEvent? selectedEvent = null;
 
-            if (handle is { } locator
-                && LogTableState.Value.EventsForLog(locator.LogId).TryGetDetail(locator, out var detail))
+            if (handle is { } locator && DetailResolver.TryResolve(locator, out var detail))
             {
                 selectedEvent = detail;
             }
@@ -212,8 +195,6 @@ private async void OnFocusChanged(object? sender, SelectionEntry? focus)
             _model = selectedEvent is { } resolved ? DetailsReaderFormatter.BuildModel(resolved, Settings.TimeZoneInfo) : null;
             _expandedFields.Clear();
 
-            // Cancel any in-flight resolution from a prior selection so a stale fetch
-            // can't overwrite the resolved XML for the now-current selection.
             try { _xmlResolveCts?.Cancel(); } catch (ObjectDisposedException) { /* CTS already disposed; cancel is moot. */ }
 
             _xmlResolveCts?.Dispose();
@@ -223,29 +204,23 @@ private async void OnFocusChanged(object? sender, SelectionEntry? focus)
 
             if (selectedEvent is null)
             {
-                await InvokeAsync(StateHasChanged);
+                StateHasChanged();
 
                 return;
             }
 
-            // The pane stays closed until the user opens something: auto-expand on the FIRST selection, but after the
-            // user has toggled it (_hasOpened) respect their choice on later selections unless the preference opts into
-            // always-expand-on-select.
             if (!_hasOpened || PreferencesProvider.DisplayPaneSelectionPreference) { _isExpanded = true; }
 
-            // Short-circuit: live-watcher events arrive with XML already pre-rendered. Skip the
-            // resolver round-trip (and the "Resolving XML..." flicker) when we already have it.
             if (!string.IsNullOrEmpty(selectedEvent.Xml))
             {
                 _resolvedXml = selectedEvent.Xml;
 
-                await InvokeAsync(StateHasChanged);
+                StateHasChanged();
 
                 return;
             }
 
-            // Render once with the loading sentinel before kicking off the async fetch.
-            await InvokeAsync(StateHasChanged);
+            StateHasChanged();
 
             var cts = new CancellationTokenSource();
             _xmlResolveCts = cts;
@@ -268,9 +243,10 @@ private async void OnFocusChanged(object? sender, SelectionEntry? focus)
                 {
                     TraceLogger.Error($"{nameof(DetailsPane)}: XML resolution failed for selected event: {ex}");
 
-                    // Only surface the failure if we're still the current selection; otherwise a newer selection owns
-                    // _resolvedXml. A re-resolve mints a new event instance, so compare the stable locator, not object identity.
-                    if (_selectedHandle == handle && ReferenceEquals(_xmlResolveCts, cts))
+                    // Only surface the failure if we're still the current selection (locally AND per the source);
+                    // otherwise a newer selection owns _resolvedXml. A re-resolve mints a new event instance, so compare
+                    // the stable locator, not object identity.
+                    if (!_disposed && _selectedHandle == handle && ReferenceEquals(_xmlResolveCts, cts) && EventFocus.Current == focus)
                     {
                         _resolvedXml = string.Empty;
                     }
@@ -278,8 +254,7 @@ private async void OnFocusChanged(object? sender, SelectionEntry? focus)
                     return;
                 }
 
-                // Selection changed while the fetch was in flight; discard the stale result.
-                if (cts.IsCancellationRequested || _selectedHandle != handle)
+                if (_disposed || cts.IsCancellationRequested || _selectedHandle != handle || EventFocus.Current != focus)
                 {
                     return;
                 }
@@ -288,8 +263,6 @@ private async void OnFocusChanged(object? sender, SelectionEntry? focus)
             }
             finally
             {
-                // Always release the per-selection CTS (success, cancel, or failure), but guard against clobbering a
-                // newer CTS installed by a subsequent OnFocusChanged during our await.
                 if (ReferenceEquals(_xmlResolveCts, cts))
                 {
                     _xmlResolveCts = null;
@@ -297,7 +270,7 @@ private async void OnFocusChanged(object? sender, SelectionEntry? focus)
 
                 cts.Dispose();
 
-                await InvokeAsync(StateHasChanged);
+                if (!_disposed) { StateHasChanged(); }
             }
         }
         catch (Exception e)
diff --git a/src/EventLogExpert.UI/EventLogExpert.UI.csproj b/src/EventLogExpert.UI/EventLogExpert.UI.csproj
index 67d3d0764..1871ccc3e 100644
--- a/src/EventLogExpert.UI/EventLogExpert.UI.csproj
+++ b/src/EventLogExpert.UI/EventLogExpert.UI.csproj
@@ -4,6 +4,12 @@
     <RootNamespace>EventLogExpert.UI</RootNamespace>
   </PropertyGroup>
 
+  <ItemGroup>
+    <!-- Blazor Web component + JSInterop references, formerly pulled in transitively through Fluxor.Blazor.Web. The UI no
+         longer consumes Fluxor, so this is now a direct reference at the version the net10 MAUI head already runs. -->
+    <PackageReference Include="Microsoft.AspNetCore.Components.Web" />
+  </ItemGroup>
+
   <ItemGroup>
     <ProjectReference Include="..\EventLogExpert.Eventing.OfflineImaging\EventLogExpert.Eventing.OfflineImaging.csproj" />
     <ProjectReference Include="..\EventLogExpert.Runtime\EventLogExpert.Runtime.csproj" />
diff --git a/src/EventLogExpert.UI/FilterEditor/FilterRow.razor.cs b/src/EventLogExpert.UI/FilterEditor/FilterRow.razor.cs
index c3328908f..5e2c0f6ec 100644
--- a/src/EventLogExpert.UI/FilterEditor/FilterRow.razor.cs
+++ b/src/EventLogExpert.UI/FilterEditor/FilterRow.razor.cs
@@ -5,7 +5,7 @@
 using EventLogExpert.Filtering.Persistence;
 using EventLogExpert.Runtime.FilterLibrary;
 using EventLogExpert.Runtime.FilterPane;
-using Fluxor;
+using EventLogExpert.UI.Common;
 using Microsoft.AspNetCore.Components;
 using System.Collections.Immutable;
 
@@ -16,6 +16,7 @@ public sealed partial class FilterRow : FilterRowBase<SavedFilter?>, IDisposable
     private IReadOnlyList<CachedFilterOption>? _cachedOptions;
     private ImmutableList<LibraryEntry>? _cachedOptionsSource;
     private FilterEditorCore? _coreRef;
+    private SourceSubscription? _librarySubscription;
 
     [Parameter] public Action<FilterId>? OnDisposed { get; set; }
 
@@ -31,8 +32,7 @@ internal IReadOnlyList<CachedFilterOption> CachedOptions
     {
         get
         {
-            // Stable reference required: per-read allocation reparameterizes the editor (WebView2 render bug).
-            var source = FilterLibraryState.Value.Entries;
+            var source = LibraryEntries.Current;
 
             if (_cachedOptions is not null && ReferenceEquals(source, _cachedOptionsSource))
             {
@@ -48,17 +48,29 @@ internal IReadOnlyList<CachedFilterOption> CachedOptions
 
     internal bool IsEditing => _coreRef?.IsEditing ?? false;
 
-    [Inject] private IState<FilterLibraryState> FilterLibraryState { get; init; } = null!;
-
     [Inject] private IFilterPaneCommands FilterPaneCommands { get; init; } = null!;
 
+    [Inject] private ILibraryEntriesSource LibraryEntries { get; init; } = null!;
+
     public void Dispose()
     {
+        _librarySubscription?.Dispose();
+
         if (Value is { } filter) { OnDisposed?.Invoke(filter.Id); }
     }
 
     internal ValueTask FocusEditAsync() => _coreRef?.FocusEditAsync() ?? ValueTask.CompletedTask;
 
+    protected override void OnInitialized()
+    {
+        _librarySubscription = new SourceSubscription(
+            handler => LibraryEntries.Changed += handler,
+            handler => LibraryEntries.Changed -= handler,
+            () => InvokeAsync(StateHasChanged));
+
+        base.OnInitialized();
+    }
+
     private static IReadOnlyList<CachedFilterOption> BuildCachedOptions(ImmutableList<LibraryEntry> entries)
     {
         var eligible = entries
diff --git a/src/EventLogExpert.UI/FilterLenses/LensBreadcrumb.razor b/src/EventLogExpert.UI/FilterLenses/LensBreadcrumb.razor
index 2ff9be1d6..890563f32 100644
--- a/src/EventLogExpert.UI/FilterLenses/LensBreadcrumb.razor
+++ b/src/EventLogExpert.UI/FilterLenses/LensBreadcrumb.razor
@@ -1,7 +1,7 @@
-@inherits FluxorComponent
+@inherits AppStateComponentBase
 
 @{
-    var lenses = LensState.Value.Lenses;
+    var lenses = LensSource.Lenses;
 }
 
 @if (!lenses.IsEmpty)
@@ -16,12 +16,12 @@
 
         @foreach (var lens in lenses)
         {
-            var captured = lens;
-            <span class="lens-chip">
-                <span class="lens-chip-label" title="@lens.Label">@lens.Label</span>
+            var lensId = lens.Id;
+            <span class="lens-lens">
+                <span class="lens-lens-label" title="@lens.Label">@lens.Label</span>
                 <button aria-label="@($"Remove lens: {lens.Label}")"
-                    class="lens-chip-remove"
-                    @onclick="@(() => Commands.RemoveLens(captured))"
+                    class="lens-lens-remove"
+                    @onclick="@(() => Commands.RemoveLens(lensId))"
                     type="button">
                     &times;
                 </button>
diff --git a/src/EventLogExpert.UI/FilterLenses/LensBreadcrumb.razor.cs b/src/EventLogExpert.UI/FilterLenses/LensBreadcrumb.razor.cs
index 78f23ad26..feebfd15a 100644
--- a/src/EventLogExpert.UI/FilterLenses/LensBreadcrumb.razor.cs
+++ b/src/EventLogExpert.UI/FilterLenses/LensBreadcrumb.razor.cs
@@ -2,7 +2,6 @@
 // // Licensed under the MIT License.
 
 using EventLogExpert.Runtime.FilterLenses;
-using Fluxor;
 using Microsoft.AspNetCore.Components;
 using Microsoft.AspNetCore.Components.Web;
 
@@ -12,20 +11,23 @@ public sealed partial class LensBreadcrumb
 {
     [Inject] private IFilterLensCommands Commands { get; init; } = null!;
 
-    [Inject] private IState<FilterLensState> LensState { get; init; } = null!;
+    [Inject] private IFilterLensSource LensSource { get; init; } = null!;
+
+    protected override void OnInitialized()
+    {
+        ObserveSource(LensSource);
+        base.OnInitialized();
+    }
 
     private void HandleKeyDown(KeyboardEventArgs args)
     {
         if (args.Key != "Escape") { return; }
 
-        var lenses = LensState.Value.Lenses;
+        var lenses = LensSource.Lenses;
 
-        // Escape scoped to the breadcrumb pops the most recently pushed lens, and stopPropagation keeps it from reaching
-        // the event table's own Escape handler (which clears the selection). The breadcrumb only renders when a lens is
-        // active, so a plain table Escape is unaffected.
         if (!lenses.IsEmpty)
         {
-            Commands.RemoveLens(lenses[^1]);
+            Commands.RemoveLens(lenses[^1].Id);
         }
     }
 }
diff --git a/src/EventLogExpert.UI/FilterLibrary/FilterLibraryModal.razor b/src/EventLogExpert.UI/FilterLibrary/FilterLibraryModal.razor
index 076d94419..39d397c32 100644
--- a/src/EventLogExpert.UI/FilterLibrary/FilterLibraryModal.razor
+++ b/src/EventLogExpert.UI/FilterLibrary/FilterLibraryModal.razor
@@ -14,26 +14,26 @@
     OnInlineAlertResolved="HandleInlineAlertResolvedAsync"
     @ref="ChromeRef">
     <ChildContent>
-        @if (FilterLibraryState.Value.LoadError)
+        @if (LibraryLoadStatus.Current.LoadError)
         {
             <div class="filter-library-error" role="alert">
                 <p>Could not load saved filters or filter sets. See trace log for details.</p>
                 <Button OnClick="RetryLoad">Retry</Button>
             </div>
         }
-        else if (!FilterLibraryState.Value.IsLoaded)
+        else if (!LibraryLoadStatus.Current.IsLoaded)
         {
             <p aria-busy="true" class="filter-library-loading">Loading filter library&hellip;</p>
         }
         else
         {
             <CascadingValue IsFixed="true" Value="_authoringContext">
-                <SidebarTabs @bind-ActiveTab="_activeTab"
-                    IsTabpanelFocusable="@IsTabpanelEmpty"
-                    @ref="_sidebarTabsRef"
+                <SidebarTabs IsTabpanelFocusable="@IsTabpanelEmpty"
+                    TTab="LibraryTab"
                     TablistAriaLabel="Filter library views"
                     Tabs="@CurrentTabLabels"
-                    TTab="LibraryTab">
+                    @bind-ActiveTab="_activeTab"
+                    @ref="_sidebarTabsRef">
                     <TabContent Context="tab">
                         @{
                             var tagManagementPanelId = GetTagManagementPanelId(tab);
@@ -46,13 +46,13 @@
                                 @onkeydown="HandleTagFilterBarKeyDown"
                                 role="group">
                                 <span class="library-tag-filter-bar-label">Tags:</span>
-                                <Button aria-controls="@(_isTagManagementExpanded ? tagManagementPanelId : null)"
-                                    aria-expanded="@(_isTagManagementExpanded ? "true" : "false")"
-                                    aria-label="@(_isTagManagementExpanded ? "Hide tag management" : "Manage tags")"
-                                    CssClass="library-tag-management-trigger"
+                                <Button CssClass="library-tag-management-trigger"
                                     IconClass="bi bi-gear"
                                     IconOnly
                                     OnClick="ToggleTagManagement"
+                                    aria-controls="@(_isTagManagementExpanded ? tagManagementPanelId : null)"
+                                    aria-expanded="@(_isTagManagementExpanded ? "true" : "false")"
+                                    aria-label="@(_isTagManagementExpanded ? "Hide tag management" : "Manage tags")"
                                     title="Manage tags" />
                                 @{
                                     var visibleTags = AllLibraryTags.Take(TagFilterBarMaxVisible).ToList();
@@ -62,19 +62,19 @@
                                 {
                                     var isSelected = _selectedTagsByTab[tab].Contains(tag, StringComparer.OrdinalIgnoreCase);
 
-                                    <ChromelessButton aria-pressed="@(isSelected ? "true" : "false")"
-                                        CssClass="library-tag-filter-chip"
-                                        OnClick="@(() => ToggleTagFilter(tag))">
+                                    <ChromelessButton CssClass="library-tag-filter-chip"
+                                        OnClick="@(() => ToggleTagFilter(tag))"
+                                        aria-pressed="@(isSelected ? "true" : "false")">
                                         @tag
                                     </ChromelessButton>
                                 }
                                 @if (hiddenTagsCount > 0)
                                 {
-                                    <ChromelessButton aria-controls="@(_isTagOverflowExpanded ? tagOverflowRegionId : null)"
+                                    <ChromelessButton CssClass="library-tag-filter-chip-overflow"
+                                        OnClick="ToggleTagOverflowExpanded"
+                                        aria-controls="@(_isTagOverflowExpanded ? tagOverflowRegionId : null)"
                                         aria-expanded="@(_isTagOverflowExpanded ? "true" : "false")"
-                                        aria-label="@(_isTagOverflowExpanded ? "Hide additional tags" : $"Show {hiddenTagsCount} additional tags")"
-                                        CssClass="library-tag-filter-chip-overflow"
-                                        OnClick="ToggleTagOverflowExpanded">
+                                        aria-label="@(_isTagOverflowExpanded ? "Hide additional tags" : $"Show {hiddenTagsCount} additional tags")">
                                         @(_isTagOverflowExpanded ? "- less" : $"+{hiddenTagsCount} more")
                                     </ChromelessButton>
                                 }
@@ -85,9 +85,9 @@
                                         {
                                             var isOverflowSelected = _selectedTagsByTab[tab].Contains(tag, StringComparer.OrdinalIgnoreCase);
 
-                                            <ChromelessButton aria-pressed="@(isOverflowSelected ? "true" : "false")"
-                                                CssClass="library-tag-filter-chip"
-                                                OnClick="@(() => ToggleTagFilter(tag))">
+                                            <ChromelessButton CssClass="library-tag-filter-chip"
+                                                OnClick="@(() => ToggleTagFilter(tag))"
+                                                aria-pressed="@(isOverflowSelected ? "true" : "false")">
                                                 @tag
                                             </ChromelessButton>
                                         }
@@ -97,7 +97,7 @@
 
                             @if (_isTagManagementExpanded)
                             {
-                                <TagManagementPanel AllEntries="@FilterLibraryState.Value.Entries"
+                                <TagManagementPanel AllEntries="@LibraryEntries.Current"
                                     AllLibraryTags="@AllLibraryTags"
                                     Id="@tagManagementPanelId"
                                     OnTagDeleted="HandleTagDeleted"
@@ -161,7 +161,6 @@
                 AllFilterSets="@AllFilterSets"
                 AllLibraryTags="@AllLibraryTags"
                 Entry="@entry"
-                @key="entry.Id"
                 OnAddToFilterSet="@HandleAddToFilterSetAsync"
                 OnApply="@HandleApplyAsync"
                 OnCopyScenario="@OnCopyScenarioCallback"
@@ -173,6 +172,7 @@
                 OnSaveScenario="@OnSaveScenarioCallback"
                 OnSaveToLibrary="@HandleSaveToLibrary"
                 OnToggleFavorite="@HandleToggleFavorite"
+                @key="entry.Id"
                 @ref="_rowRefs[(tab, entry.Id)]" />
         };
 }
diff --git a/src/EventLogExpert.UI/FilterLibrary/FilterLibraryModal.razor.cs b/src/EventLogExpert.UI/FilterLibrary/FilterLibraryModal.razor.cs
index 893516480..fca0aa5b7 100644
--- a/src/EventLogExpert.UI/FilterLibrary/FilterLibraryModal.razor.cs
+++ b/src/EventLogExpert.UI/FilterLibrary/FilterLibraryModal.razor.cs
@@ -7,12 +7,11 @@
 using EventLogExpert.Runtime.Common.Clipboard;
 using EventLogExpert.Runtime.Common.Files;
 using EventLogExpert.Runtime.FilterLibrary;
-using EventLogExpert.Runtime.Modal;
 using EventLogExpert.Runtime.Scenarios;
+using EventLogExpert.UI.Alerts;
 using EventLogExpert.UI.Common;
 using EventLogExpert.UI.FilterEditor;
 using EventLogExpert.UI.Modal;
-using Fluxor;
 using Microsoft.AspNetCore.Components;
 using Microsoft.AspNetCore.Components.Web;
 using System.Collections.Immutable;
@@ -22,6 +21,8 @@ namespace EventLogExpert.UI.FilterLibrary;
 
 public sealed partial class FilterLibraryModal : ModalBase<bool>
 {
+    private const int MaxPreviewedImportNames = 10;
+    private const int MaxPreviouslyUsedEntries = 50;
     private const int TagFilterBarMaxVisible = 10;
 
     private static readonly (LibraryTab Tab, string Label)[] s_tabs =
@@ -46,15 +47,18 @@ private static readonly (LibraryTab Tab, string Label)[] s_tabs =
     private LibraryTab _activeTab = LibraryTab.Saved;
     private ScenarioAuthoringRowContext? _authoringContext;
     private ScenarioClipboardExporter _clipboardExporter = null!;
+
+    private SourceSubscription? _entriesSubscription;
     private bool _isTagManagementExpanded;
     private bool _isTagOverflowExpanded;
     private bool _justClearedTags;
+    private SourceSubscription? _loadStatusSubscription;
     private LibraryTab? _pendingFocusSourceTab;
     private LibraryEntryId? _pendingFocusTargetEntryId;
     private bool _pendingFocusToActiveTab;
-
     private Dictionary<LibraryTab, ImmutableList<string>>? _selectedTagsBeforeTagOp;
     private SidebarTabs<LibraryTab>? _sidebarTabsRef;
+    private SourceSubscription? _tagBulkUpdateFailedSubscription;
 
     private enum EmptyValueChoice
     {
@@ -68,12 +72,12 @@ private enum EmptyValueChoice
     [Inject] private IAlertDialogService AlertDialogService { get; init; } = null!;
 
     private IReadOnlyList<LibraryEntryFilterSet> AllFilterSets =>
-        [.. FilterLibraryState.Value.Entries
+        [.. LibraryEntries.Current
             .OfType<LibraryEntryFilterSet>()
             .OrderBy(p => p.Name, StringComparer.OrdinalIgnoreCase)];
 
     private IReadOnlyList<string> AllLibraryTags =>
-        [.. FilterLibraryState.Value.Entries
+        [.. LibraryEntries.Current
             .SelectMany(e => e.Tags)
             .Distinct(StringComparer.OrdinalIgnoreCase)
             .OrderBy(t => t, StringComparer.OrdinalIgnoreCase)];
@@ -97,7 +101,7 @@ private IReadOnlyList<LibraryEntry> FavoriteEntries
         {
             var selected = SelectedTagsInLibrary(LibraryTab.Favorites);
 
-            return [.. FilterLibraryState.Value.Entries
+            return [.. LibraryEntries.Current
                 .Where(e => e is LibraryEntrySavedFilter && e.IsFavorite)
                 .Where(e => MatchesTagFilter(e, selected))
                 .OrderBy(e => e.Name, StringComparer.OrdinalIgnoreCase)];
@@ -108,15 +112,19 @@ private IReadOnlyList<LibraryEntry> FavoriteEntries
 
     [Inject] private IFilterLibraryCommands FilterLibraryCommands { get; init; } = null!;
 
-    [Inject] private IState<FilterLibraryState> FilterLibraryState { get; init; } = null!;
+    [Inject] private ILibraryEntriesSource LibraryEntries { get; init; } = null!;
 
-    private EventCallback<LibraryEntryId> OnCopyScenarioCallback => ScenarioAuthoringOptions.Enabled
-        ? EventCallback.Factory.Create<LibraryEntryId>(this, HandleCopyScenarioAsync)
-        : default;
+    [Inject] private ILibraryLoadStatusSource LibraryLoadStatus { get; init; } = null!;
 
-    private EventCallback<LibraryEntryId> OnSaveScenarioCallback => ScenarioAuthoringOptions.Enabled
-        ? EventCallback.Factory.Create<LibraryEntryId>(this, HandleSaveScenarioAsync)
-        : default;
+    private EventCallback<LibraryEntryId> OnCopyScenarioCallback =>
+        ScenarioAuthoringOptions.Enabled ?
+            EventCallback.Factory.Create<LibraryEntryId>(this, HandleCopyScenarioAsync) :
+            default;
+
+    private EventCallback<LibraryEntryId> OnSaveScenarioCallback =>
+        ScenarioAuthoringOptions.Enabled ?
+            EventCallback.Factory.Create<LibraryEntryId>(this, HandleSaveScenarioAsync) :
+            default;
 
     private IReadOnlyList<LibraryEntry> PreviouslyUsedEntries
     {
@@ -124,12 +132,12 @@ private IReadOnlyList<LibraryEntry> PreviouslyUsedEntries
         {
             var selected = SelectedTagsInLibrary(LibraryTab.PreviouslyUsed);
 
-            return [.. FilterLibraryState.Value.Entries
+            return [.. LibraryEntries.Current
                 .Where(e => e is { Origin: LibraryEntryOrigin.AutoTracked, IsFavorite: false })
                 .Where(e => e.LastUsedUtc.HasValue)
                 .Where(e => MatchesTagFilter(e, selected))
                 .OrderByDescending(e => e.LastUsedUtc.GetValueOrDefault())
-                .Take(50)];
+                .Take(MaxPreviouslyUsedEntries)];
         }
     }
 
@@ -139,7 +147,7 @@ private IReadOnlyList<LibraryEntry> SavedEntries
         {
             var selected = SelectedTagsInLibrary(LibraryTab.Saved);
 
-            return [.. FilterLibraryState.Value.Entries
+            return [.. LibraryEntries.Current
                 .Where(e => e is { Origin: LibraryEntryOrigin.UserSaved, IsFavorite: false })
                 .Where(e => MatchesTagFilter(e, selected))
                 .OrderBy(e => e.Name, StringComparer.OrdinalIgnoreCase)];
@@ -147,12 +155,14 @@ private IReadOnlyList<LibraryEntry> SavedEntries
     }
 
     private IReadOnlyList<LibraryEntrySavedFilter> SavedFilterEntries =>
-        [.. FilterLibraryState.Value.Entries.OfType<LibraryEntrySavedFilter>()];
+        [.. LibraryEntries.Current.OfType<LibraryEntrySavedFilter>()];
 
     [Inject] private ScenarioAuthoringOptions ScenarioAuthoringOptions { get; init; } = null!;
 
     [Inject] private IScenarioAuthoringService ScenarioAuthoringService { get; init; } = null!;
 
+    [Inject] private ITagBulkUpdateFailedNotifier TagBulkUpdateFailedNotifier { get; init; } = null!;
+
     internal static void ApplyImportPreflight(
         ImportPreflight preflight,
         IFilterLibraryCommands commands,
@@ -206,9 +216,9 @@ internal static string BuildPreflightSummary(ImportPreflight preflight)
     {
         if (preflight.ImportBlocked)
         {
-            var preview = string.Join("\n  \u2022 ", preflight.InvalidLegacyNames.Take(10));
-            var more = preflight.InvalidLegacyNames.Count > 10
-                ? $"\n  \u2022 ...and {preflight.InvalidLegacyNames.Count - 10} more"
+            var preview = string.Join("\n  \u2022 ", preflight.InvalidLegacyNames.Take(MaxPreviewedImportNames));
+            var more = preflight.InvalidLegacyNames.Count > MaxPreviewedImportNames
+                ? $"\n  \u2022 ...and {preflight.InvalidLegacyNames.Count - MaxPreviewedImportNames} more"
                 : string.Empty;
 
             return "This file contains entries with names that cannot be imported:\n  \u2022 " +
@@ -223,9 +233,9 @@ internal static string BuildPreflightSummary(ImportPreflight preflight)
         if (preflight.ToReplace.Count > 0)
         {
             var conflictList = "\nNames being overwritten:\n  \u2022 " +
-                string.Join("\n  \u2022 ", preflight.ToReplace.Select(p => p.Incoming.Name).Take(10)) +
-                (preflight.ToReplace.Count > 10
-                    ? $"\n  \u2022 ...and {preflight.ToReplace.Count - 10} more"
+                string.Join("\n  \u2022 ", preflight.ToReplace.Select(p => p.Incoming.Name).Take(MaxPreviewedImportNames)) +
+                (preflight.ToReplace.Count > MaxPreviewedImportNames
+                    ? $"\n  \u2022 ...and {preflight.ToReplace.Count - MaxPreviewedImportNames} more"
                     : string.Empty);
 
             lines.Add($"  \u2022 {preflight.ToReplace.Count} existing entries WILL BE OVERWRITTEN (current filter content will be lost){conflictList}");
@@ -303,6 +313,18 @@ internal void RecordPendingFocusAfterRemoval(LibraryTab sourceTab, LibraryEntryI
         _pendingFocusToActiveTab = fallback;
     }
 
+    protected override async ValueTask DisposeAsyncCore(bool disposing)
+    {
+        if (disposing)
+        {
+            _entriesSubscription?.Dispose();
+            _loadStatusSubscription?.Dispose();
+            _tagBulkUpdateFailedSubscription?.Dispose();
+        }
+
+        await base.DisposeAsyncCore(disposing);
+    }
+
     protected override async Task OnAfterRenderAsync(bool firstRender)
     {
         PruneStaleRowRefs();
@@ -343,7 +365,7 @@ protected override async Task OnExportAsync()
     {
         try
         {
-            var entries = FilterLibraryState.Value.Entries;
+            var entries = LibraryEntries.Current;
             var json = ExportService.Serialize(entries);
             var path = await FilePickerService.PickSaveAsync(
                 "Export Filter Library",
@@ -383,7 +405,7 @@ ex is UnauthorizedAccessException or SecurityException or
             return;
         }
 
-        var preflight = ExportService.Deserialize(json, FilterLibraryState.Value.Entries);
+        var preflight = ExportService.Deserialize(json, LibraryEntries.Current);
 
         if (preflight.Error is not null)
         {
@@ -403,7 +425,7 @@ ex is UnauthorizedAccessException or SecurityException or
                 case EmptyValueChoice.Normalize:
                     preflight = ExportService.Deserialize(
                         json,
-                        FilterLibraryState.Value.Entries,
+                        LibraryEntries.Current,
                         normalizeEmptyValues: true);
 
                     if (preflight.Error is not null)
@@ -434,14 +456,25 @@ protected override void OnInitialized()
     {
         base.OnInitialized();
 
-        SubscribeToAction<TagBulkUpdateFailedAction>(_ => RevertOptimisticTagSelection());
+        _entriesSubscription = new SourceSubscription(
+            handler => LibraryEntries.Changed += handler,
+            handler => LibraryEntries.Changed -= handler,
+            () => InvokeAsync(() => { if (!IsDisposed) { StateHasChanged(); } }));
+        _loadStatusSubscription = new SourceSubscription(
+            handler => LibraryLoadStatus.Changed += handler,
+            handler => LibraryLoadStatus.Changed -= handler,
+            () => InvokeAsync(() => { if (!IsDisposed) { StateHasChanged(); } }));
+        _tagBulkUpdateFailedSubscription = new SourceSubscription(
+            handler => TagBulkUpdateFailedNotifier.Failed += handler,
+            handler => TagBulkUpdateFailedNotifier.Failed -= handler,
+            () => InvokeAsync(() => { if (!IsDisposed) { RevertOptimisticTagSelection(); } }));
 
         if (InitialTab is { } tab)
         {
             _activeTab = tab;
         }
 
-        if (!FilterLibraryState.Value.IsLoaded || FilterLibraryState.Value.LoadError)
+        if (!LibraryLoadStatus.Current.IsLoaded || LibraryLoadStatus.Current.LoadError)
         {
             FilterLibraryCommands.LoadLibrary();
         }
@@ -518,7 +551,7 @@ private Task CopyLibraryRowAsync(SavedFilter filter) =>
             "this filter");
 
     private LibraryEntryFilterSet? FindFilterSet(LibraryEntryId entryId) =>
-        FilterLibraryState.Value.Entries.FirstOrDefault(e => e.Id.Equals(entryId)) as LibraryEntryFilterSet;
+        LibraryEntries.Current.FirstOrDefault(e => e.Id.Equals(entryId)) as LibraryEntryFilterSet;
 
     private string GetEmptyStateMessage(LibraryTab tab)
     {
@@ -560,8 +593,10 @@ private Task HandleAddToFilterSetAsync(AddToFilterSetIntent intent)
     private async Task HandleApplyAsync(LibraryEntryId id)
     {
         FilterLibraryCommands.ApplyEntry(id);
-        var entry = FilterLibraryState.Value.Entries.FirstOrDefault(e => e.Id.Equals(id));
+        var entry = LibraryEntries.Current.FirstOrDefault(e => e.Id.Equals(id));
+
         if (entry is not null) { AnnouncementService.Announce($"Applied {entry.Name}"); }
+        
         await CompleteAsync(true);
     }
 
@@ -579,7 +614,8 @@ await _clipboardExporter.CopyAsync(
 
     private async Task HandleExportEntryAsync(LibraryEntryId entryId)
     {
-        var entry = FilterLibraryState.Value.Entries.FirstOrDefault(e => e.Id.Equals(entryId));
+        var entry = LibraryEntries.Current.FirstOrDefault(e => e.Id.Equals(entryId));
+
         if (entry is null) { return; }
 
         try
@@ -607,8 +643,10 @@ ex is UnauthorizedAccessException or SecurityException or
     private async Task HandleReplaceAsync(LibraryEntryId id)
     {
         FilterLibraryCommands.ReplaceWithEntry(id);
-        var entry = FilterLibraryState.Value.Entries.FirstOrDefault(e => e.Id.Equals(id));
+        var entry = LibraryEntries.Current.FirstOrDefault(e => e.Id.Equals(id));
+
         if (entry is not null) { AnnouncementService.Announce($"Replaced filters with {entry.Name}"); }
+
         await CompleteAsync(true);
     }
 
@@ -685,9 +723,10 @@ private void HandleTagRenamed((string OldName, string NewName) e)
             if (index < 0) { continue; }
 
             var without = current.RemoveAt(index);
-            _selectedTagsByTab[tab] = without.Contains(e.NewName, StringComparer.OrdinalIgnoreCase)
-                ? without
-                : without.Insert(index, e.NewName);
+
+            _selectedTagsByTab[tab] = without.Contains(e.NewName, StringComparer.OrdinalIgnoreCase) ?
+                without :
+                without.Insert(index, e.NewName);
         }
     }
 
@@ -729,7 +768,7 @@ private async Task PromptAndApplyImportAsync(ImportPreflight preflight, bool kep
 
         if (!result.Accepted) { return; }
 
-        ApplyImportPreflight(preflight, FilterLibraryCommands, FilterLibraryState.Value.Entries);
+        ApplyImportPreflight(preflight, FilterLibraryCommands, LibraryEntries.Current);
 
         var ambiguousCount = preflight.AmbiguousMatches.Count;
         var updatedCount = CountDistinctUpdates(preflight);
@@ -781,7 +820,7 @@ private void PruneStaleRowRefs()
     {
         if (_rowRefs.Count == 0) { return; }
 
-        var liveIds = FilterLibraryState.Value.Entries.Select(e => e.Id).ToHashSet();
+        var liveIds = LibraryEntries.Current.Select(e => e.Id).ToHashSet();
 
         List<(LibraryTab Tab, LibraryEntryId Id)>? stale = null;
 
@@ -812,7 +851,7 @@ private void RevertOptimisticTagSelection()
 
     private ImmutableList<string> SelectedTagsInLibrary(LibraryTab tab)
     {
-        var available = FilterLibraryState.Value.Entries
+        var available = LibraryEntries.Current
             .SelectMany(e => e.Tags)
             .ToHashSet(StringComparer.OrdinalIgnoreCase);
 
diff --git a/src/EventLogExpert.UI/FilterLibrary/LibraryEntryRow.razor.cs b/src/EventLogExpert.UI/FilterLibrary/LibraryEntryRow.razor.cs
index d7d4581a9..be811c3cb 100644
--- a/src/EventLogExpert.UI/FilterLibrary/LibraryEntryRow.razor.cs
+++ b/src/EventLogExpert.UI/FilterLibrary/LibraryEntryRow.razor.cs
@@ -5,12 +5,11 @@
 using EventLogExpert.Runtime.Announcement;
 using EventLogExpert.Runtime.FilterLibrary;
 using EventLogExpert.Runtime.FilterPane;
-using EventLogExpert.Runtime.Menu;
 using EventLogExpert.UI.Common;
 using EventLogExpert.UI.Common.Interop;
 using EventLogExpert.UI.Focus;
 using EventLogExpert.UI.Inputs;
-using Fluxor;
+using EventLogExpert.UI.Menu;
 using Microsoft.AspNetCore.Components;
 using Microsoft.JSInterop;
 using System.Collections.Immutable;
@@ -64,6 +63,8 @@ public sealed partial class LibraryEntryRow : ComponentBase, IAsyncDisposable
 
     [Parameter][EditorRequired] public EventCallback<FavoriteToggleIntent> OnToggleFavorite { get; set; }
 
+    [Inject] private IActiveFiltersSource ActiveFilters { get; init; } = null!;
+
     [Inject] private IAlertDialogService AlertDialogService { get; init; } = null!;
 
     [Inject] private IAnnouncementService AnnouncementService { get; init; } = null!;
@@ -78,10 +79,6 @@ public sealed partial class LibraryEntryRow : ComponentBase, IAsyncDisposable
 
     [Inject] private IFilterLibraryCommands FilterLibraryCommands { get; init; } = null!;
 
-    [Inject] private IState<FilterLibraryState> FilterLibraryState { get; init; } = null!;
-
-    [Inject] private IState<FilterPaneState> FilterPaneState { get; init; } = null!;
-
     private bool IsFavoritable => Entry is LibraryEntrySavedFilter;
 
     private bool IsMoreMenuOpen =>
@@ -91,9 +88,12 @@ public sealed partial class LibraryEntryRow : ComponentBase, IAsyncDisposable
 
     private string KindAriaLabel => Entry is LibraryEntryFilterSet ? "Filter set" : "Filter";
 
-    private string KindIconClass => Entry is LibraryEntryFilterSet
-        ? "bi bi-collection library-entry-kind-icon"
-        : "bi bi-funnel library-entry-kind-icon";
+    private string KindIconClass =>
+        Entry is LibraryEntryFilterSet ?
+            "bi bi-collection library-entry-kind-icon" :
+            "bi bi-funnel library-entry-kind-icon";
+
+    [Inject] private ILibraryEntriesSource LibraryEntries { get; init; } = null!;
 
     [Inject] private IMenuService MenuService { get; init; } = null!;
 
@@ -236,7 +236,7 @@ private IReadOnlyList<MenuItem> BuildMoreMenu()
 
     private bool HasDuplicateNameOfSameKind(string candidateName)
     {
-        return FilterLibraryState.Value.Entries.Any(other =>
+        return LibraryEntries.Current.Any(other =>
             !other.Id.Equals(Entry.Id) &&
             SameKind(other) &&
             string.Equals(other.Name, candidateName, StringComparison.OrdinalIgnoreCase));
@@ -354,7 +354,7 @@ private async Task OnRenameAsync()
 
     private async Task OnReplaceAsync()
     {
-        if (!FilterPaneState.Value.Filters.IsEmpty)
+        if (!ActiveFilters.Current.IsEmpty)
         {
             var confirmed = await AlertDialogService.ShowAlert(
                 "Replace current filters?",
diff --git a/src/EventLogExpert.UI/FilterLibrary/LibrarySavedTabHeader.razor.cs b/src/EventLogExpert.UI/FilterLibrary/LibrarySavedTabHeader.razor.cs
index f088fbf70..5b4484c8e 100644
--- a/src/EventLogExpert.UI/FilterLibrary/LibrarySavedTabHeader.razor.cs
+++ b/src/EventLogExpert.UI/FilterLibrary/LibrarySavedTabHeader.razor.cs
@@ -7,7 +7,6 @@
 using EventLogExpert.Runtime.Announcement;
 using EventLogExpert.Runtime.FilterLibrary;
 using EventLogExpert.UI.Common;
-using Fluxor;
 using Microsoft.AspNetCore.Components;
 using System.Collections.Immutable;
 
@@ -33,11 +32,11 @@ public sealed partial class LibrarySavedTabHeader : ComponentBase
     [Inject] private IAnnouncementService AnnouncementService { get; init; } = null!;
 
     private IEnumerable<LibraryEntry> ExistingLibraryEntries =>
-        FilterLibraryState.Value.Entries.Concat(ExistingSavedFilters);
+        LibraryEntries.Current.Concat(ExistingSavedFilters);
 
     [Inject] private IFilterLibraryCommands FilterLibraryCommands { get; init; } = null!;
 
-    [Inject] private IState<FilterLibraryState> FilterLibraryState { get; init; } = null!;
+    [Inject] private ILibraryEntriesSource LibraryEntries { get; init; } = null!;
 
     protected override async Task OnAfterRenderAsync(bool firstRender)
     {
diff --git a/src/EventLogExpert.UI/FilterPane/FilterPane.razor b/src/EventLogExpert.UI/FilterPane/FilterPane.razor
index a53e93072..a142c4873 100644
--- a/src/EventLogExpert.UI/FilterPane/FilterPane.razor
+++ b/src/EventLogExpert.UI/FilterPane/FilterPane.razor
@@ -1,5 +1,5 @@
 @using EventLogExpert.Scenarios.Catalog
-@inherits FluxorComponent
+@inherits AppStateComponentBase
 
 <div class="filter-pane" @ref="_filterPaneRootRef">
 <div class="filter-header">
@@ -38,7 +38,7 @@
             Apply Filter Set
         </Button>
 
-        @if (OpenLogCount.Value > 0)
+        @if (OpenLogsPresence.HasOpenLogs)
         {
             <Button aria-controls="scenario-picker"
                 aria-expanded="@(IsScenarioPickerVisible ? "true" : "false")"
@@ -49,13 +49,7 @@
         }
     </div>
 
-    @if (FilterProgressState.Value.IsLoading)
-    {
-        <span class="filter-header-status">
-            [<i aria-label="Loading" class="spinner-border loader-spin" role="status"></i> Applying Filters]
-        </span>
-    }
-    else if (HasFilters && GetActiveFilters() > 0)
+    @if (HasFilters && GetActiveFilters() > 0)
     {
         <span class="filter-header-status">[Active Filters: @GetActiveFilters()]</span>
     }
@@ -115,7 +109,7 @@
             There are no filters to clear.
         </span>
 
-        @if (HasFilters || FilterProgressState.Value.IsLoading)
+        @if (HasFilters)
         {
             <Button aria-label="@(_isFilterListVisible ? "Filters Expanded" : "Filters Collapsed")"
                 CssClass="menu-toggle"
@@ -130,14 +124,14 @@
 <div class="filter-set" data-toggle="@MenuState">
     @if (IsDateFilterVisible)
     {
-        <EditForm class="filter-form flex-row" Model="_model">
+        <EditForm class="filter-form flex-row" EditContext="_editContext">
             <span>
                 After:
-                <InputDate aria-label="After" @bind-Value="_model.After" class="filter-datetime input" disabled="@(!_canEditDate)" Type="InputDateType.DateTimeLocal" />
+                <InputDate aria-label="After" @bind-Value="ModelAfter" class="filter-datetime input" disabled="@(!_canEditDate)" Type="InputDateType.DateTimeLocal" />
             </span>
             <span>
                 Before:
-                <InputDate aria-label="Before" @bind-Value="_model.Before" class="filter-datetime input" disabled="@(!_canEditDate)" Type="InputDateType.DateTimeLocal" />
+                <InputDate aria-label="Before" @bind-Value="ModelBefore" class="filter-datetime input" disabled="@(!_canEditDate)" Type="InputDateType.DateTimeLocal" />
             </span>
 
             @if (_canEditDate)
@@ -165,7 +159,7 @@
                     Remove
                 </DangerButton>
 
-                @if (FilterPaneState.Value.FilteredDateRange?.IsEnabled is true)
+                @if (FilteredDateRange.Current?.IsEnabled is true)
                 {
                     <DangerButton IconClass="bi bi-dash-circle" OnClick="ToggleDateFilter">
                         Disable
@@ -324,7 +318,7 @@
     }
 
     <CascadingValue IsFixed="true" Value="_authoringContext">
-        @foreach (var item in FilterPaneState.Value.Filters)
+        @foreach (var item in ActiveFilters.Current)
         {
             <FilterRow Id="@ComponentId.For(item.Id, ComponentIdScope.PaneFilter).Value"
                 @key="item.Id"
diff --git a/src/EventLogExpert.UI/FilterPane/FilterPane.razor.cs b/src/EventLogExpert.UI/FilterPane/FilterPane.razor.cs
index 7cdf98069..cd7fba46b 100644
--- a/src/EventLogExpert.UI/FilterPane/FilterPane.razor.cs
+++ b/src/EventLogExpert.UI/FilterPane/FilterPane.razor.cs
@@ -12,9 +12,7 @@
 using EventLogExpert.Runtime.EventLog;
 using EventLogExpert.Runtime.FilterLibrary;
 using EventLogExpert.Runtime.FilterPane;
-using EventLogExpert.Runtime.FilterProgress;
 using EventLogExpert.Runtime.Menu;
-using EventLogExpert.Runtime.Modal;
 using EventLogExpert.Runtime.Scenarios;
 using EventLogExpert.Runtime.Settings;
 using EventLogExpert.Scenarios.Catalog;
@@ -22,9 +20,10 @@
 using EventLogExpert.UI.FilterEditor;
 using EventLogExpert.UI.Focus;
 using EventLogExpert.UI.Inputs;
+using EventLogExpert.UI.Menu;
 using EventLogExpert.UI.Modal;
-using Fluxor;
 using Microsoft.AspNetCore.Components;
+using Microsoft.AspNetCore.Components.Forms;
 using Microsoft.AspNetCore.Components.Web;
 using Microsoft.JSInterop;
 using System.Collections.Immutable;
@@ -42,7 +41,6 @@ public sealed partial class FilterPane
     internal string? SelectedScenarioId;
 
     private readonly List<string> _filterSetTags = [];
-    private readonly DateFilter _model = new();
     private readonly List<FilterDraft> _pendingDrafts = [];
     private readonly Dictionary<FilterId, FilterRow?> _rowRefs = new();
 
@@ -53,30 +51,37 @@ public sealed partial class FilterPane
     private bool _canEditDate;
     private ScenarioClipboardExporter _clipboardExporter = null!;
     private TimeZoneInfo _currentTimeZone = TimeZoneInfo.Utc;
+    private volatile bool _disposed;
+    private EditContext _editContext = null!;
     private ElementReference _filterPaneRootRef;
     private bool _focusAddButtonAfterRemove;
     private FilterId? _focusTargetAfterRemove;
     private bool _isFilterListVisible;
     private IJSObjectReference? _menuAnchorModule;
+    private DateFilter _model = new();
     private IReadOnlyList<IGrouping<ScenarioGroup, ScenarioDefinition>> _scenarioMatchGroups = [];
     private ImmutableHashSet<string>? _scenarioMatchSource;
     private IJSObjectReference? _scrollSuppressorModule;
 
     internal IReadOnlyList<string> AvailableFilterSetTags =>
-        AvailableTagsForSets([.. FilterLibraryState.Value.Entries.OfType<LibraryEntryFilterSet>()]);
+        AvailableTagsForSets([.. LibraryEntries.Current.OfType<LibraryEntryFilterSet>()]);
 
     internal bool ScenarioAuthoringEnabled => ScenarioAuthoringOptions.Enabled;
 
     internal IReadOnlyList<LibraryEntryFilterSet> VisibleFilterSets =>
         FilterSetsByTags(
-            [.. FilterLibraryState.Value.Entries.OfType<LibraryEntryFilterSet>()],
+            [.. LibraryEntries.Current.OfType<LibraryEntryFilterSet>()],
             _filterSetTags,
             SelectedFilterSetId);
 
+    [Inject] private IActiveFiltersSource ActiveFilters { get; init; } = null!;
+
     [Inject] private IAlertDialogService AlertDialogService { get; init; } = null!;
 
     [Inject] private IAnnouncementService AnnouncementService { get; init; } = null!;
 
+    [Inject] private IClearAllFiltersNotifier ClearAllFiltersNotifier { get; init; } = null!;
+
     [Inject] private IClipboardService ClipboardService { get; init; } = null!;
 
     private ScenarioGroup? EffectiveScenarioGroup =>
@@ -90,42 +95,44 @@ [.. FilterLibraryState.Value.Entries.OfType<LibraryEntryFilterSet>()],
 
     [Inject] private IFilterLibraryCommands FilterLibraryCommands { get; init; } = null!;
 
-    [Inject] private IState<FilterLibraryState> FilterLibraryState { get; init; } = null!;
-
     [Inject] private IFilterPaneCommands FilterPaneCommands { get; init; } = null!;
 
-    [Inject] private IState<FilterPaneState> FilterPaneState { get; init; } = null!;
-
-    [Inject] private IState<FilterProgressState> FilterProgressState { get; init; } = null!;
+    [Inject] private IFilteredDateRangeSource FilteredDateRange { get; init; } = null!;
 
     private bool HasClearableFilters =>
-        IsDateFilterVisible || FilterPaneState.Value.Filters.IsEmpty is false || _pendingDrafts.Count > 0;
-
-    private bool HasEnabledFilters => FilterPaneState.Value.Filters.Any(filter => filter.IsEnabled);
+        IsDateFilterVisible || ActiveFilters.Current.IsEmpty is false || _pendingDrafts.Count > 0;
 
-    private bool HasFilters =>
-        IsDateFilterVisible || IsFilterSetPickerVisible || IsScenarioPickerVisible || FilterPaneState.Value.Filters.IsEmpty is false || _pendingDrafts.Count > 0;
+    private bool HasEnabledFilters => ActiveFilters.Current.Any(filter => filter.IsEnabled);
 
     private bool HasFilterSets =>
-        FilterLibraryState.Value.IsLoaded
-        && !FilterLibraryState.Value.LoadError
-        && FilterLibraryState.Value.Entries.OfType<LibraryEntryFilterSet>().Any();
+        LibraryLoadStatus.Current is { IsLoaded: true, LoadError: false }
+        && LibraryEntries.Current.OfType<LibraryEntryFilterSet>().Any();
+
+    private bool HasFilters =>
+        IsDateFilterVisible ||
+        IsFilterSetPickerVisible ||
+        IsScenarioPickerVisible ||
+        ActiveFilters.Current.IsEmpty is false ||
+        _pendingDrafts.Count > 0;
 
     private bool HasRecentFilters =>
-        FilterLibraryState.Value.IsLoaded
-        && !FilterLibraryState.Value.LoadError
-        && FilterLibraryState.Value.Entries.OfType<LibraryEntrySavedFilter>().Any(e => e.IsFavorite || e.LastUsedUtc is not null);
+        LibraryLoadStatus.Current is { IsLoaded: true, LoadError: false }
+        && LibraryEntries.Current.OfType<LibraryEntrySavedFilter>().Any(e => e.IsFavorite || e.LastUsedUtc is not null);
 
-    private bool HasSavableFilters => !FilterPaneState.Value.Filters.IsEmpty;
+    private bool HasSavableFilters => !ActiveFilters.Current.IsEmpty;
 
     private bool IsAddFilterMenuOpen =>
         _addFilterMenuId != 0 && MenuService.ActiveMenuId == _addFilterMenuId && MenuService.ActiveItems is not null;
 
-    private bool IsDateFilterVisible => _canEditDate || FilterPaneState.Value.FilteredDateRange is not null;
+    private bool IsDateFilterVisible => _canEditDate || FilteredDateRange.Current is not null;
 
     [Inject] private IJSRuntime JSRuntime { get; init; } = null!;
 
-    [Inject] private IStateSelection<EventLogState, ImmutableHashSet<string>> LoadedLogNames { get; init; } = null!;
+    [Inject] private ILibraryEntriesSource LibraryEntries { get; init; } = null!;
+
+    [Inject] private ILibraryLoadStatusSource LibraryLoadStatus { get; init; } = null!;
+
+    [Inject] private ILoadedLogNamesSource LoadedLogNames { get; init; } = null!;
 
     [Inject] private IMenuActionService MenuActions { get; init; } = null!;
 
@@ -135,7 +142,19 @@ [.. FilterLibraryState.Value.Entries.OfType<LibraryEntryFilterSet>()],
 
     [Inject] private IModalCoordinator ModalCoordinator { get; init; } = null!;
 
-    [Inject] private IStateSelection<EventLogState, int> OpenLogCount { get; init; } = null!;
+    private DateTime? ModelAfter
+    {
+        get => _model.After;
+        set => _model = _model with { After = value };
+    }
+
+    private DateTime? ModelBefore
+    {
+        get => _model.Before;
+        set => _model = _model with { Before = value };
+    }
+
+    [Inject] private IOpenLogsPresenceSource OpenLogsPresence { get; init; } = null!;
 
     private ScenarioDefinition? ResolvedScenario =>
         VisibleScenarioMatches.FirstOrDefault(match => match.Id == SelectedScenarioId)
@@ -147,13 +166,11 @@ [.. FilterLibraryState.Value.Entries.OfType<LibraryEntryFilterSet>()],
 
     [Inject] private IScenarioAuthoringService ScenarioAuthoringService { get; init; } = null!;
 
-    private IReadOnlyList<ScenarioDefinition> ScenarioMatches => [.. ScenarioMatchGroups.SelectMany(group => group)];
-
     private IReadOnlyList<IGrouping<ScenarioGroup, ScenarioDefinition>> ScenarioMatchGroups
     {
         get
         {
-            var names = LoadedLogNames.Value;
+            var names = LoadedLogNames.Current;
 
             if (ReferenceEquals(names, _scenarioMatchSource))
             {
@@ -173,8 +190,12 @@ .. ScenarioQueryService
         }
     }
 
+    private IReadOnlyList<ScenarioDefinition> ScenarioMatches => [.. ScenarioMatchGroups.SelectMany(group => group)];
+
     [Inject] private IScenarioQueryService ScenarioQueryService { get; init; } = null!;
 
+    [Inject] private ISetFilterDateRangeSucceededNotifier SetFilterDateRangeSucceededNotifier { get; init; } = null!;
+
     [Inject] private ISettingsService Settings { get; init; } = null!;
 
     private IReadOnlyList<ScenarioDefinition> VisibleScenarioMatches =>
@@ -239,9 +260,9 @@ internal IReadOnlyList<MenuItem> BuildAddFilterMenu() =>
     {
         if (HasRecentFilters) { return null; }
 
-        if (FilterLibraryState.Value.LoadError) { return FilterPaneAnnouncements.LoadFailedRetryViaModal; }
+        if (LibraryLoadStatus.Current.LoadError) { return FilterPaneAnnouncements.LoadFailedRetryViaModal; }
 
-        return !FilterLibraryState.Value.IsLoaded ?
+        return !LibraryLoadStatus.Current.IsLoaded ?
             FilterPaneAnnouncements.LoadingTryAgain :
             FilterPaneAnnouncements.RecentNoneAvailable;
     }
@@ -254,17 +275,15 @@ internal void OnScenarioGroupChanged(ScenarioGroup? group)
 
     internal void OpenFilterSetPicker()
     {
-        // Re-clicking the trigger is a no-op so an in-progress dropdown selection isn't silently
-        // overwritten by `filterSets.First()` reset. Cancel button is the only way to dismiss the picker.
         if (IsFilterSetPickerVisible) { return; }
 
-        if (FilterLibraryState.Value.LoadError)
+        if (LibraryLoadStatus.Current.LoadError)
         {
             AnnouncementService.Announce(FilterPaneAnnouncements.LoadFailedRetryViaModal);
             return;
         }
 
-        if (!FilterLibraryState.Value.IsLoaded)
+        if (!LibraryLoadStatus.Current.IsLoaded)
         {
             AnnouncementService.Announce(FilterPaneAnnouncements.LoadingTryAgain);
             return;
@@ -273,7 +292,7 @@ internal void OpenFilterSetPicker()
         _filterSetTags.Clear();
         IsFilterSetPickerVisible = true;
         SelectedFilterSetId = HasFilterSets
-            ? FilterLibraryState.Value.Entries
+            ? LibraryEntries.Current
                 .OfType<LibraryEntryFilterSet>()
                 .OrderBy(p => p.Name, StringComparer.OrdinalIgnoreCase)
                 .First().Id
@@ -314,7 +333,7 @@ internal void ReplaceScenarioSelection()
 
     internal bool TryResolveSelectedFilterSet()
     {
-        if (FilterLibraryState.Value.LoadError)
+        if (LibraryLoadStatus.Current.LoadError)
         {
             AnnouncementService.Announce(FilterPaneAnnouncements.LoadFailedRetryViaModal);
             CancelFilterSetPicker();
@@ -322,7 +341,7 @@ internal bool TryResolveSelectedFilterSet()
             return false;
         }
 
-        if (!FilterLibraryState.Value.IsLoaded)
+        if (!LibraryLoadStatus.Current.IsLoaded)
         {
             AnnouncementService.Announce(FilterPaneAnnouncements.LoadingTryAgain);
             CancelFilterSetPicker();
@@ -330,7 +349,7 @@ internal bool TryResolveSelectedFilterSet()
             return false;
         }
 
-        var filterSets = FilterLibraryState.Value.Entries.OfType<LibraryEntryFilterSet>().ToList();
+        var filterSets = LibraryEntries.Current.OfType<LibraryEntryFilterSet>().ToList();
 
         if (filterSets.Any(p => p.Id.Equals(SelectedFilterSetId)))
         {
@@ -349,9 +368,16 @@ protected override async ValueTask DisposeAsyncCore(bool disposing)
     {
         if (disposing)
         {
+            _disposed = true;
+
             Settings.TimeZoneChanged -= UpdateFilterDateTimeZone;
             MenuService.StateChanged -= OnMenuServiceStateChanged;
+        }
+
+        await base.DisposeAsyncCore(disposing);
 
+        if (disposing)
+        {
             await JsModuleInterop.DisposeModuleSafelyAsync(
                 _scrollSuppressorModule,
                 module => module.InvokeVoidAsync("release", _filterPaneRootRef));
@@ -361,8 +387,6 @@ await JsModuleInterop.DisposeModuleSafelyAsync(
             _menuAnchorModule = null;
             _scrollSuppressorModule = null;
         }
-
-        await base.DisposeAsyncCore(disposing);
     }
 
     protected override async Task OnAfterRenderAsync(bool firstRender)
@@ -412,23 +436,45 @@ await _scrollSuppressorModule.InvokeVoidAsync(
 
     protected override void OnInitialized()
     {
-        LoadedLogNames.Select(s => s.LoadedLogNames);
-        OpenLogCount.Select(s => s.OpenLogCount);
+        _editContext = new EditContext(_model);
 
-        SubscribeToAction<ClearAllFiltersAction>(action =>
-        {
-            _canEditDate = false;
-            _pendingDrafts.Clear();
-            IsFilterSetPickerVisible = false;
-            CancelScenarioPicker();
-            SelectedFilterSetId = default;
-            _filterSetTags.Clear();
-        });
-
-        SubscribeToAction<SetFilterDateRangeSuccessAction>(action =>
-        {
-            UpdateFilterDate(action.DateFilter);
-        });
+        ObserveSource(LibraryEntries);
+        ObserveSource(LibraryLoadStatus);
+        ObserveSource(ActiveFilters);
+        ObserveSource(FilteredDateRange);
+        ObserveSource(OpenLogsPresence);
+        ObserveSource(LoadedLogNames);
+
+        ObserveSource(
+            handler => ClearAllFiltersNotifier.Requested += handler,
+            handler => ClearAllFiltersNotifier.Requested -= handler,
+            () =>
+            {
+                if (_disposed) { return Task.CompletedTask; }
+
+                _canEditDate = false;
+                _pendingDrafts.Clear();
+                IsFilterSetPickerVisible = false;
+                CancelScenarioPicker();
+                SelectedFilterSetId = default;
+                _filterSetTags.Clear();
+                StateHasChanged();
+
+                return Task.CompletedTask;
+            });
+
+        ObserveSource(
+            handler => SetFilterDateRangeSucceededNotifier.Succeeded += handler,
+            handler => SetFilterDateRangeSucceededNotifier.Succeeded -= handler,
+            () =>
+            {
+                if (_disposed) { return Task.CompletedTask; }
+
+                UpdateFilterDate(FilteredDateRange.Current);
+                StateHasChanged();
+
+                return Task.CompletedTask;
+            });
 
         Settings.TimeZoneChanged += UpdateFilterDateTimeZone;
         MenuService.StateChanged += OnMenuServiceStateChanged;
@@ -487,8 +533,11 @@ private void AddDateFilter()
 
         var (after, before) = EventLogQueries.GetEventDateRange(DateTime.UtcNow);
 
-        _model.After = after.ConvertTimeZone(_currentTimeZone);
-        _model.Before = before.ConvertTimeZone(_currentTimeZone);
+        _model = _model with
+        {
+            After = after.ConvertTimeZone(_currentTimeZone),
+            Before = before.ConvertTimeZone(_currentTimeZone)
+        };
 
         _isFilterListVisible = true;
         _canEditDate = true;
@@ -550,16 +599,13 @@ private async Task ClearAllFiltersAsync()
     {
         if (!HasClearableFilters) { return; }
 
-        // Counts everything Clear All actually removes: persisted filters (regardless of IsEnabled),
-        // any open date filter row, and any uncommitted pending drafts.
-        int count = FilterPaneState.Value.Filters.Count
-            + _pendingDrafts.Count
-            + (IsDateFilterVisible ? 1 : 0);
+        int count = ActiveFilters.Current.Count +
+            _pendingDrafts.Count +
+            (IsDateFilterVisible ? 1 : 0);
 
-        // HasClearableFilters guarantees count >= 1, so the message is always factual.
-        string message = count == 1
-            ? "Clear 1 filter? This cannot be undone."
-            : $"Clear {count} filters? This cannot be undone.";
+        string message = count == 1 ?
+            "Clear 1 filter? This cannot be undone." :
+            $"Clear {count} filters? This cannot be undone.";
 
         bool confirmed = await AlertDialogService.ShowAlert("Clear All Filters", message, "Clear", "Cancel");
 
@@ -579,22 +625,22 @@ private Task CopyScenarioJsonAsync() =>
 
     private ScenarioExportResult ExportCurrentRows() =>
         ScenarioAuthoringService.ExportRows(
-            [.. FilterPaneState.Value.Filters.Where(filter => filter.IsEnabled)],
+            [.. ActiveFilters.Current.Where(filter => filter.IsEnabled)],
             CurrentChannelNames());
 
     private int GetActiveFilters()
     {
         int count = 0;
 
-        count += FilterPaneState.Value.FilteredDateRange?.IsEnabled is true ? 1 : 0;
-        count += FilterPaneState.Value.Filters.Count(filter => filter.IsEnabled);
+        count += FilteredDateRange.Current?.IsEnabled is true ? 1 : 0;
+        count += ActiveFilters.Current.Count(filter => filter.IsEnabled);
 
         return count;
     }
 
     private string GetFilterSetName(LibraryEntryId id)
     {
-        var set = FilterLibraryState.Value.Entries.OfType<LibraryEntryFilterSet>().FirstOrDefault(p => p.Id.Equals(id));
+        var set = LibraryEntries.Current.OfType<LibraryEntryFilterSet>().FirstOrDefault(p => p.Id.Equals(id));
 
         return set is null ? string.Empty : FormatFilterSetLabel(set);
     }
@@ -623,7 +669,7 @@ private void HandlePendingDiscard(FilterDraft draft)
         _pendingDrafts.Remove(draft);
 
         var target = FilterPaneFocus.ComputeFocusTargetAfterPendingDiscard(
-            FilterPaneState.Value.Filters,
+            ActiveFilters.Current,
             IsFocusable);
 
         _focusTargetAfterRemove = target;
@@ -639,7 +685,7 @@ private void HandlePendingSave(FilterDraft draft, SavedFilter filter)
     private void HandleRemovedFilter(FilterId removedId)
     {
         var target = FilterPaneFocus.ComputeFocusTargetAfterRemove(
-            FilterPaneState.Value.Filters,
+            ActiveFilters.Current,
             removedId,
             IsFocusable);
 
@@ -658,9 +704,7 @@ private void OnFilterSetTagsChanged(List<string> tags)
         _filterSetTags.AddRange(tags);
     }
 
-    // Marshaled through the renderer dispatcher because StateChanged may fire from arbitrary threads;
-    // re-renders so the chevron's aria-expanded reflects open/close state.
-    private void OnMenuServiceStateChanged() => _ = InvokeAsync(StateHasChanged);
+    private void OnMenuServiceStateChanged() => RequestGuardedRender(StateHasChanged);
 
     private void OnRowDisposed(FilterId id) => _rowRefs.Remove(id);
 
@@ -697,7 +741,7 @@ private void PruneStaleRowRefs()
     {
         if (_rowRefs.Count == 0) { return; }
 
-        var liveFilters = FilterPaneState.Value.Filters;
+        var liveFilters = ActiveFilters.Current;
 
         if (liveFilters.Count == 0)
         {
@@ -754,17 +798,24 @@ private async Task SaveScenarioJsonAsync()
 
     private void UpdateFilterDate(DateFilter? updatedDate)
     {
-        _model.Before = updatedDate?.Before?.ConvertTimeZone(_currentTimeZone);
-        _model.After = updatedDate?.After?.ConvertTimeZone(_currentTimeZone);
+        _model = _model with
+        {
+            Before = updatedDate?.Before?.ConvertTimeZone(_currentTimeZone),
+            After = updatedDate?.After?.ConvertTimeZone(_currentTimeZone)
+        };
     }
 
     private void UpdateFilterDateTimeZone(object? sender, TimeZoneInfo timeZoneInfo)
     {
-        _model.Before = _model.Before is not null ?
-            TimeZoneInfo.ConvertTime(_model.Before.Value, _currentTimeZone, timeZoneInfo) : null;
+        if (_disposed) { return; }
 
-        _model.After = _model.After is not null ?
-            TimeZoneInfo.ConvertTime(_model.After.Value, _currentTimeZone, timeZoneInfo) : null;
+        _model = _model with
+        {
+            Before = _model.Before is not null ?
+                TimeZoneInfo.ConvertTime(_model.Before.Value, _currentTimeZone, timeZoneInfo) : null,
+            After = _model.After is not null ?
+                TimeZoneInfo.ConvertTime(_model.After.Value, _currentTimeZone, timeZoneInfo) : null
+        };
 
         _currentTimeZone = timeZoneInfo;
     }
diff --git a/src/EventLogExpert.UI/Keyboard/KeyboardShortcutService.cs b/src/EventLogExpert.UI/Keyboard/KeyboardShortcutService.cs
index a5a3e7274..838b53e4f 100644
--- a/src/EventLogExpert.UI/Keyboard/KeyboardShortcutService.cs
+++ b/src/EventLogExpert.UI/Keyboard/KeyboardShortcutService.cs
@@ -2,19 +2,14 @@
 // // Licensed under the MIT License.
 
 using EventLogExpert.Runtime.Menu;
-using EventLogExpert.Runtime.Modal;
 using EventLogExpert.Runtime.Settings;
 using EventLogExpert.UI.Common.Interop;
 using EventLogExpert.UI.LogTable.Find;
+using EventLogExpert.UI.Modal;
 using Microsoft.JSInterop;
 
 namespace EventLogExpert.UI.Keyboard;
 
-/// <summary>
-///     Hosts the .NET side of the JS keydown bridge. Webview JS calls <see cref="HandleShortcutAsync" /> for any
-///     Ctrl-modified key it considers menu-relevant after the bridge has already synchronously suppressed the browser
-///     default; this class then decides whether to run the corresponding action.
-/// </summary>
 public sealed class KeyboardShortcutService(
     IMenuActionService actions,
     IModalCoordinator modalCoordinator,
@@ -43,9 +38,6 @@ public async ValueTask DisposeAsync()
 
     public async Task EnsureRegisteredAsync(IJSRuntime jsRuntime)
     {
-        // The JS bridge is idempotent on re-register and refreshes its DotNetObjectReference, so we
-        // always invoke it. This keeps shortcuts working after WebView reloads / circuit restarts /
-        // hot reload.
         var previousSelfRef = _selfRef;
         var previousModule = _keyboardModule;
         var newSelfRef = DotNetObjectReference.Create(this);
@@ -82,19 +74,11 @@ public async Task EnsureRegisteredAsync(IJSRuntime jsRuntime)
         }
     }
 
-    /// <summary>
-    ///     Runs the requested shortcut action when applicable. The JS bridge has already synchronously called
-    ///     <c>preventDefault</c>/<c>stopPropagation</c> in capture phase before invoking this method, so the return value
-    ///     would be ignored - this method is intentionally <see cref="Task" /> rather than <c>Task&lt;bool&gt;</c>. When a
-    ///     modal is active, the action is skipped (no-op) so modal keybindings stay isolated; the browser default has still
-    ///     been suppressed by the bridge.
-    /// </summary>
     [JSInvokable]
     public async Task HandleShortcutAsync(string code, bool ctrl, bool alt, bool shift, bool meta)
     {
         if (!ctrl || alt || shift || meta) { return; }
 
-        // Modal-gating happens here, not in JS, so a misbehaving (or stale) bridge can't bypass it.
         if (_modalCoordinator.ActiveSession is not null) { return; }
 
         switch (code)
diff --git a/src/EventLogExpert.UI/Layout/MainContent.razor b/src/EventLogExpert.UI/Layout/MainContent.razor
index 2685eebd0..a348c29c3 100644
--- a/src/EventLogExpert.UI/Layout/MainContent.razor
+++ b/src/EventLogExpert.UI/Layout/MainContent.razor
@@ -1,14 +1,18 @@
-@inherits FluxorComponent
+@inherits AppStateComponentBase
 
-@if (HasActiveLogs.Value)
+@if (OpenLogsSource.HasOpenLogs)
 {
     <FilterPane />
+
     <LensBreadcrumb />
-    @if (HistogramVisible.Value)
+
+    @if (HistogramVisibilitySource.IsVisible)
     {
         <HistogramPane />
     }
+
     <LogTablePane />
+
     <DetailsPane />
 }
 else
diff --git a/src/EventLogExpert.UI/Layout/MainContent.razor.cs b/src/EventLogExpert.UI/Layout/MainContent.razor.cs
index 1d792ac7c..472c577d3 100644
--- a/src/EventLogExpert.UI/Layout/MainContent.razor.cs
+++ b/src/EventLogExpert.UI/Layout/MainContent.razor.cs
@@ -3,24 +3,23 @@
 
 using EventLogExpert.Runtime.EventLog;
 using EventLogExpert.Runtime.Histogram;
-using Fluxor;
-using Fluxor.Blazor.Web.Components;
+using EventLogExpert.UI.Common;
 using Microsoft.AspNetCore.Components;
 
 namespace EventLogExpert.UI.Layout;
 
-public sealed partial class MainContent : FluxorComponent
+public sealed partial class MainContent : AppStateComponentBase
 {
     [Inject]
-    private IStateSelection<EventLogState, bool> HasActiveLogs { get; init; } = null!;
+    private IHistogramVisibilitySource HistogramVisibilitySource { get; init; } = null!;
 
     [Inject]
-    private IStateSelection<HistogramState, bool> HistogramVisible { get; init; } = null!;
+    private IOpenLogsPresenceSource OpenLogsSource { get; init; } = null!;
 
     protected override void OnInitialized()
     {
-        HasActiveLogs.Select(state => state.OpenLogCount > 0);
-        HistogramVisible.Select(state => state.IsVisible);
+        ObserveSource(OpenLogsSource);
+        ObserveSource(HistogramVisibilitySource);
         base.OnInitialized();
     }
 }
diff --git a/src/EventLogExpert.UI/Layout/MainLayout.razor.cs b/src/EventLogExpert.UI/Layout/MainLayout.razor.cs
index a2475df3d..aa5ee2ae7 100644
--- a/src/EventLogExpert.UI/Layout/MainLayout.razor.cs
+++ b/src/EventLogExpert.UI/Layout/MainLayout.razor.cs
@@ -1,98 +1,98 @@
-// // Copyright (c) Microsoft Corporation.
-// // Licensed under the MIT License.
-
-using EventLogExpert.Runtime.Common.AppTitle;
-using EventLogExpert.Runtime.Settings;
-using EventLogExpert.Runtime.Update;
-using EventLogExpert.UI.Keyboard;
-using Microsoft.AspNetCore.Components;
-using Microsoft.JSInterop;
-
-namespace EventLogExpert.UI.Layout;
-
-public sealed partial class MainLayout : IAsyncDisposable
-{
-    [Inject] private IAppTitleService AppTitleService { get; init; } = null!;
-
-    [Inject] private IJSRuntime JSRuntime { get; init; } = null!;
-
-    [Inject] private KeyboardShortcutService KeyboardShortcutService { get; init; } = null!;
-
-    [Inject] private ISettingsService Settings { get; init; } = null!;
-
-    [Inject] private IUpdateService UpdateService { get; init; } = null!;
-
-    private Task<IJSObjectReference>? _themeModuleLoad;
-    private bool _disposed;
-
-    public async ValueTask DisposeAsync()
-    {
-        _disposed = true;
-        Settings.ThemeChanged -= OnThemeChanged;
-
-        await KeyboardShortcutService.UnregisterAsync();
-
-        if (_themeModuleLoad is not null)
-        {
-            try
-            {
-                var module = await _themeModuleLoad;
-                await module.DisposeAsync();
-            }
-            catch (JSDisconnectedException) { }
-            catch (JSException) { }
-            catch (ObjectDisposedException) { }
-            catch (TaskCanceledException) { }
-
-            _themeModuleLoad = null;
-        }
-    }
-
-    protected override async Task OnAfterRenderAsync(bool firstRender)
-    {
-        if (firstRender)
-        {
-            await ApplyThemeAsync();
-            await KeyboardShortcutService.EnsureRegisteredAsync(JSRuntime);
-        }
-
-        await base.OnAfterRenderAsync(firstRender);
-    }
-
-    protected override async Task OnInitializedAsync()
-    {
-        Settings.ThemeChanged += OnThemeChanged;
-
-        await UpdateService.CheckForUpdates(Settings.IsPreReleaseEnabled);
-        AppTitleService.SetLogName(null);
-
-        await base.OnInitializedAsync();
-    }
-
-    private async Task ApplyThemeAsync()
-    {
-        if (_disposed) { return; }
-
-        var load = _themeModuleLoad ??= JSRuntime.InvokeAsync<IJSObjectReference>("import", "./_content/EventLogExpert.UI/Layout/MainLayout.razor.js").AsTask();
-
-        try
-        {
-            var module = await load;
-            await module.InvokeVoidAsync("setTheme", Settings.Theme.ToString().ToLowerInvariant());
-        }
-        catch (Exception ex) when (ex is JSDisconnectedException or JSException or ObjectDisposedException or TaskCanceledException)
-        {
-            ClearFailedThemeLoad(load);
-        }
-    }
-
-    private void ClearFailedThemeLoad(Task<IJSObjectReference> load)
-    {
-        if (!load.IsCompletedSuccessfully && ReferenceEquals(_themeModuleLoad, load))
-        {
-            _themeModuleLoad = null;
-        }
-    }
-
-    private void OnThemeChanged() => _ = InvokeAsync(ApplyThemeAsync);
-}
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Runtime.Common.AppTitle;
+using EventLogExpert.Runtime.Settings;
+using EventLogExpert.Runtime.Update;
+using EventLogExpert.UI.Keyboard;
+using Microsoft.AspNetCore.Components;
+using Microsoft.JSInterop;
+
+namespace EventLogExpert.UI.Layout;
+
+public sealed partial class MainLayout : IAsyncDisposable
+{
+    [Inject] private IAppTitleService AppTitleService { get; init; } = null!;
+
+    [Inject] private IJSRuntime JSRuntime { get; init; } = null!;
+
+    [Inject] private KeyboardShortcutService KeyboardShortcutService { get; init; } = null!;
+
+    [Inject] private ISettingsService Settings { get; init; } = null!;
+
+    [Inject] private IUpdateService UpdateService { get; init; } = null!;
+
+    private Task<IJSObjectReference>? _themeModuleLoad;
+    private bool _disposed;
+
+    public async ValueTask DisposeAsync()
+    {
+        _disposed = true;
+        Settings.ThemeChanged -= OnThemeChanged;
+
+        await KeyboardShortcutService.UnregisterAsync();
+
+        if (_themeModuleLoad is not null)
+        {
+            try
+            {
+                var module = await _themeModuleLoad;
+                await module.DisposeAsync();
+            }
+            catch (JSDisconnectedException) { }
+            catch (JSException) { }
+            catch (ObjectDisposedException) { }
+            catch (TaskCanceledException) { }
+
+            _themeModuleLoad = null;
+        }
+    }
+
+    protected override async Task OnAfterRenderAsync(bool firstRender)
+    {
+        if (firstRender)
+        {
+            await ApplyThemeAsync();
+            await KeyboardShortcutService.EnsureRegisteredAsync(JSRuntime);
+        }
+
+        await base.OnAfterRenderAsync(firstRender);
+    }
+
+    protected override async Task OnInitializedAsync()
+    {
+        Settings.ThemeChanged += OnThemeChanged;
+
+        await UpdateService.CheckForUpdates(Settings.IsPreReleaseEnabled);
+        AppTitleService.SetLogName(null);
+
+        await base.OnInitializedAsync();
+    }
+
+    private async Task ApplyThemeAsync()
+    {
+        if (_disposed) { return; }
+
+        var load = _themeModuleLoad ??= JSRuntime.InvokeAsync<IJSObjectReference>("import", "./_content/EventLogExpert.UI/Layout/MainLayout.razor.js").AsTask();
+
+        try
+        {
+            var module = await load;
+            await module.InvokeVoidAsync("setTheme", Settings.Theme.ToString().ToLowerInvariant());
+        }
+        catch (Exception ex) when (ex is JSDisconnectedException or JSException or ObjectDisposedException or TaskCanceledException)
+        {
+            ClearFailedThemeLoad(load);
+        }
+    }
+
+    private void ClearFailedThemeLoad(Task<IJSObjectReference> load)
+    {
+        if (!load.IsCompletedSuccessfully && ReferenceEquals(_themeModuleLoad, load))
+        {
+            _themeModuleLoad = null;
+        }
+    }
+
+    private void OnThemeChanged() => _ = InvokeAsync(ApplyThemeAsync);
+}
diff --git a/src/EventLogExpert.UI/LogTable/Histogram/HistogramChartState.cs b/src/EventLogExpert.UI/LogTable/Histogram/HistogramChartState.cs
new file mode 100644
index 000000000..1e5bfab6b
--- /dev/null
+++ b/src/EventLogExpert.UI/LogTable/Histogram/HistogramChartState.cs
@@ -0,0 +1,13 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+namespace EventLogExpert.UI.LogTable.Histogram;
+
+internal enum HistogramChartState
+{
+    Pending,
+
+    Ready,
+
+    Failed
+}
diff --git a/src/EventLogExpert.UI/LogTable/Histogram/HistogramPane.razor b/src/EventLogExpert.UI/LogTable/Histogram/HistogramPane.razor
index 8a826035b..fbb4cd8e0 100644
--- a/src/EventLogExpert.UI/LogTable/Histogram/HistogramPane.razor
+++ b/src/EventLogExpert.UI/LogTable/Histogram/HistogramPane.razor
@@ -1,5 +1,5 @@
 @using EventLogExpert.Runtime.Histogram
-@inherits FluxorComponent
+@inherits PresentationViewComponentBase
 
 <div class="histogram-pane">
     <div class="histogram-toolbar">
@@ -173,7 +173,6 @@
                     @for (int index = 0; index < barCount; index++)
                     {
                         var bin = render.Bins[index];
-                        // Integer-align each bar slot to whole pixels so the 1px separator stays uniform; empty bins still hold their slot.
                         int barLeft = (int)Math.Round(index * barWidth);
                         int barRight = (int)Math.Round((index + 1) * barWidth);
                         int slotWidth = Math.Max(1, barRight - barLeft);
@@ -240,6 +239,14 @@
         {
             <div class="histogram-empty">@EmptyStateMessage(_dimension, true)</div>
         }
+        else if (_chartState == HistogramChartState.Failed)
+        {
+            <div class="histogram-empty">The timeline could not be built for these events.</div>
+        }
+        else if (_chartState == HistogramChartState.Pending)
+        {
+            <div class="histogram-empty">Building the timeline...</div>
+        }
         else
         {
             <div class="histogram-empty">No events to chart in the current view.</div>
diff --git a/src/EventLogExpert.UI/LogTable/Histogram/HistogramPane.razor.cs b/src/EventLogExpert.UI/LogTable/Histogram/HistogramPane.razor.cs
index 4d2f9bf17..4bc2c56f1 100644
--- a/src/EventLogExpert.UI/LogTable/Histogram/HistogramPane.razor.cs
+++ b/src/EventLogExpert.UI/LogTable/Histogram/HistogramPane.razor.cs
@@ -9,10 +9,10 @@
 using EventLogExpert.Runtime.FilterPane;
 using EventLogExpert.Runtime.Histogram;
 using EventLogExpert.Runtime.LogTable;
+using EventLogExpert.Runtime.LogTable.OrderedView;
 using EventLogExpert.Runtime.Settings;
 using EventLogExpert.UI.Common.Interop;
 using EventLogExpert.UI.LogTable.Find;
-using Fluxor;
 using Microsoft.AspNetCore.Components;
 using Microsoft.AspNetCore.Components.Web;
 using Microsoft.JSInterop;
@@ -31,6 +31,7 @@ public sealed partial class HistogramPane
     private const int MinWindowBaseBins = 4;
     private const double MinWindowFraction = (double)MinWindowBaseBins / HistogramConstants.MaxBuckets;
     private const int RecomputeThrottleMs = 500;
+    private const int StackHiddenGroupThreshold = 16;
     private const double ZoomInFactor = 0.8;
     private const double ZoomOutFactor = 1.25;
 
@@ -44,21 +45,22 @@ public sealed partial class HistogramPane
     private HistogramData? _baseData;
     private string _binAnnouncement = string.Empty;
     private int? _binCursor;
+    private HistogramChartState _chartState = HistogramChartState.Pending;
     private HistogramDimension _dimension = HistogramDimension.Severity;
     private bool _disposed;
     private DotNetObjectReference<HistogramPane>? _dotNetRef;
     private long[] _findTicks = [];
     private long? _focusedTicks;
     private bool _isZoomed;
+    private ViewContentToken? _lastScannedToken;
     private IJSObjectReference? _module;
-    // Generation for queued pan/zoom: bumped on undo so a pan/zoom initiated before the undo (its stale token captured at schedule time) no-ops instead of reapplying the pre-undo window.
     private int _navToken;
     private double? _pendingViewStartFraction;
     private int _plotHeightPx;
     private bool _recomputePending;
     private HistogramRender? _render;
     private CancellationTokenSource? _scanCts;
-    private int _scanEpoch;
+    private int _scanVersion;
     private int _segmentGroupCount;
     private int[] _segmentHeights = [];
     private SavedFilter[] _tieHighlightFilters = [];
@@ -69,22 +71,18 @@ public sealed partial class HistogramPane
     private long _windowEndTicks;
     private long _windowStartTicks;
 
-    [Inject] private IStateSelection<LogTableState, EventLogId?> ActiveEventLogId { get; init; } = null!;
+    [Inject] private IActiveEventLogSource ActiveEventLog { get; init; } = null!;
 
-    [Inject] private IStateSelection<LogTableState, string?> ActiveOriginLog { get; init; } = null!;
+    [Inject] private IHistogramDimensionRequestSource DimensionRequest { get; init; } = null!;
 
-    [Inject] private IStateSelection<LogTableState, IEventColumnView> ActiveView { get; init; } = null!;
-
-    [Inject] private IStateSelection<HistogramState, HistogramDimensionRequest?> DimensionRequest { get; init; } = null!;
+    [Inject] private IEventFocusSource EventFocus { get; init; } = null!;
 
     [Inject] private IFilterLensCommands FilterLensCommands { get; init; } = null!;
 
-    [Inject] private IStateSelection<FilterPaneState, ImmutableList<SavedFilter>> Filters { get; init; } = null!;
+    [Inject] private IActiveFiltersSource Filters { get; init; } = null!;
 
     [Inject] private IFindMarkerSource FindMarkers { get; init; } = null!;
 
-    [Inject] private IStateSelection<EventLogState, SelectionEntry?> Focus { get; init; } = null!;
-
     [Inject] private IHighlightSelector HighlightSelector { get; init; } = null!;
 
     [Inject] private IJSRuntime JSRuntime { get; init; } = null!;
@@ -137,7 +135,6 @@ public void OnHistogramResized(int widthPx, int heightPx)
 
         if (widthPx <= 0 || heightPx <= 0) { return; }
 
-        // A widened or newly-revealed viewport can push the current zoom depth past the track-width cap, so re-clamp the retained window and render immediately: the inline track width is a percentage the browser re-resolves against the new viewport at once, so deferring the render to an async rescan would briefly expose the stale over-cap track.
         if (_baseData is { } data)
         {
             SetWindowByBins(data, WindowStartBin(data), WindowBinCount(data));
@@ -159,7 +156,7 @@ public void OnHistogramScopeBin(double fraction)
             new DateTime(bin.StartTicks, DateTimeKind.Utc),
             new DateTime(bin.EndTicks, DateTimeKind.Utc),
             _timeZone,
-            ActiveOriginLog.Value);
+            Presentation.ActiveLogName);
     }
 
     [JSInvokable]
@@ -229,12 +226,6 @@ protected override async ValueTask DisposeAsyncCore(bool disposing)
         if (disposing)
         {
             _disposed = true;
-
-            ActiveView.SelectedValueChanged -= OnActiveViewChanged;
-            ActiveEventLogId.SelectedValueChanged -= OnActiveEventLogIdChanged;
-            DimensionRequest.SelectedValueChanged -= OnDimensionRequestChanged;
-            Filters.SelectedValueChanged -= OnFiltersChanged;
-            Focus.SelectedValueChanged -= OnFocusChanged;
             Settings.TimeZoneChanged -= OnTimeZoneChanged;
             FindMarkers.MarksChanged -= OnFindMarksChanged;
 
@@ -285,21 +276,16 @@ protected override async Task OnAfterRenderAsync(bool firstRender)
     protected override void OnInitialized()
     {
         _timeZone = Settings.TimeZoneInfo;
-        ActiveView.Select(state => state.GetActiveDisplayedEvents());
-        ActiveOriginLog.Select(SelectActiveOriginLog);
-        ActiveEventLogId.Select(state => state.ActiveEventLogId);
-        Focus.Select(state => state.Focus);
-        Filters.Select(state => state.Filters);
-        DimensionRequest.Select(state => state.DimensionRequest);
-        ActiveView.SelectedValueChanged += OnActiveViewChanged;
-        ActiveEventLogId.SelectedValueChanged += OnActiveEventLogIdChanged;
-        Focus.SelectedValueChanged += OnFocusChanged;
-        Filters.SelectedValueChanged += OnFiltersChanged;
-        DimensionRequest.SelectedValueChanged += OnDimensionRequestChanged;
+
+        ObserveSource(ActiveEventLog, OnActiveLogChangedAsync);
+        ObserveSource(EventFocus, OnFocusChangedAsync);
+        ObserveSource(Filters, OnFiltersChangedAsync);
+        ObserveSource(DimensionRequest, OnDimensionRequestChangedAsync);
+
         Settings.TimeZoneChanged += OnTimeZoneChanged;
         FindMarkers.MarksChanged += OnFindMarksChanged;
 
-        var initialRequest = DimensionRequest.Value;
+        var initialRequest = DimensionRequest.Current;
 
         if (initialRequest is not null && initialRequest.Token > _appliedDimensionToken)
         {
@@ -311,6 +297,16 @@ protected override void OnInitialized()
         RefreshTieFilters(rescanOnPredicateChange: false);
 
         base.OnInitialized();
+
+        _lastScannedToken = Presentation.ContentToken;
+    }
+
+    protected override void OnPresentationChanged()
+    {
+        if (_lastScannedToken == Presentation.ContentToken) { return; }
+
+        _lastScannedToken = Presentation.ContentToken;
+        ScheduleRecompute();
     }
 
     private static string DimensionLabel(HistogramDimension dimension) => dimension switch
@@ -325,8 +321,6 @@ protected override void OnInitialized()
         _ => dimension.ToString()
     };
 
-    // ErrorCode charts a failure subset, so its empty-state reports the absence of failures (not of the field, which may be
-    // present as errorCode = 0); visibleRange distinguishes a zoomed window with no failures from the whole view having none.
     private static string EmptyStateMessage(HistogramDimension dimension, bool visibleRange) => dimension switch
     {
         HistogramDimension.ErrorCode => visibleRange
@@ -372,13 +366,6 @@ private static string HighlightColorDisplayName(HighlightColor color)
     private static bool IsCategoricalOther(HistogramData data, int group) =>
         group < data.Groups.Count && data.Groups[group].ColorClass == "histogram-cat-other";
 
-    private static string? SelectActiveOriginLog(LogTableState state)
-    {
-        var activeTab = state.EventTables.FirstOrDefault(tab => tab.Id == state.ActiveEventLogId);
-
-        return activeTab is { IsCombined: false } ? activeTab.LogName : null;
-    }
-
     private static bool ShouldArmTie(SavedFilter[] filters)
     {
         if (filters.Length is 0 or > 31) { return false; }
@@ -401,7 +388,6 @@ private void AggregateAndRender(bool syncScrollbar = true)
 
             if (_baseData is { GroupingFieldAbsent: true })
             {
-                // Match the visible empty-state so a screen reader is told why the timeline is blank, and drop any stale bin readout.
                 _binAnnouncement = string.Empty;
                 _announcement = EmptyStateMessage(_dimension, visibleRange: false);
             }
@@ -445,9 +431,6 @@ private void ApplyDimension(HistogramDimension dimension, bool force)
         _dimension = dimension;
         _hiddenGroups.Clear();
 
-        // A retained absent-field result would otherwise render its empty-state under the newly-selected dimension's name
-        // until the rescan lands; clear the live-region status with it so a screen reader isn't left holding the previous
-        // dimension's "no values" message during the gap.
         if (_baseData is { GroupingFieldAbsent: true })
         {
             _baseData = null;
@@ -465,7 +448,6 @@ private void ApplyPublishedWindow()
     {
         if (_baseData is not { } data) { return; }
 
-        // A disjoint-domain reload leaves both the pinned window and the absolute-tick undo history meaningless - including after a Fit cleared _isZoomed but left history - so drop the history and supersede queued nav whenever the retained window falls entirely outside the new domain, before the not-zoomed refit. A same-tab clear/refill reaches here (not OnActiveEventLogIdChanged), so the token bump must live here too.
         bool windowDisjoint = _windowEndTicks < data.MinUtc.Ticks || _windowStartTicks > data.MaxUtc.Ticks;
 
         if (windowDisjoint)
@@ -579,12 +561,11 @@ private void ComputeSegmentHeights(HistogramRender render, int groupCount)
 
         double barsHeight = BarsAreaHeight();
 
-        Span<bool> hidden = groupCount <= 16 ? stackalloc bool[16] : new bool[groupCount];
+        Span<bool> hidden = groupCount <= StackHiddenGroupThreshold ? stackalloc bool[StackHiddenGroupThreshold] : new bool[groupCount];
         hidden = hidden[..groupCount];
 
         for (int group = 0; group < groupCount; group++) { hidden[group] = IsGroupHidden(group); }
 
-        // Normalize bar heights to the tallest VISIBLE bin (hidden legend groups excluded) so toggling a group off rescales the remaining bars to fill the plot, instead of leaving the true tallest bar a 1-2px sliver under a hidden group's scale.
         int maxVisibleBinTotal = 0;
 
         for (int bin = 0; bin < render.Bins.Count; bin++)
@@ -729,39 +710,48 @@ private void MoveBinCursor(int delta)
         StateHasChanged();
     }
 
-    // A tab switch makes the absolute-tick zoom window meaningless, so drop the zoom and rescan at the new tab's full span.
-    private void OnActiveEventLogIdChanged(object? sender, EventLogId? logId) => _ = InvokeAsync(() =>
+    private Task OnActiveLogChangedAsync()
     {
+        if (_disposed) { return Task.CompletedTask; }
+
         _isZoomed = false;
         _windowHistory.Clear();
         SupersedeQueuedNavigation();
-        // Invalidate the old tab's data + render so nothing acts on stale data during the gap, then schedule the rescan directly: a one-member group's header and member tabs share one view, so OnActiveViewChanged is not guaranteed to fire and can't be relied on to republish (ScheduleRecompute de-dupes with it when it does).
         _baseData = null;
         _render = null;
         RefreshFindTicks();
         ScheduleRecompute();
-    });
 
-    private void OnActiveViewChanged(object? sender, IEventColumnView view) => _ = InvokeAsync(ScheduleRecompute);
+        return Task.CompletedTask;
+    }
 
-    private void OnDimensionRequestChanged(object? sender, HistogramDimensionRequest? request) => _ = InvokeAsync(() =>
+    private Task OnDimensionRequestChangedAsync()
     {
-        if (_disposed) { return; }
+        if (_disposed) { return Task.CompletedTask; }
 
-        var current = DimensionRequest.Value;
-        if (current is null || current.Token <= _appliedDimensionToken) { return; }
+        var current = DimensionRequest.Current;
+
+        if (current is null || current.Token <= _appliedDimensionToken) { return Task.CompletedTask; }
 
         _appliedDimensionToken = current.Token;
         ApplyDimension(current.Dimension, force: true);
-    });
+
+        return Task.CompletedTask;
+    }
 
     private void OnDimensionSelected(HistogramDimension dimension)
     {
         ApplyDimension(dimension, force: false);
     }
 
-    private void OnFiltersChanged(object? sender, ImmutableList<SavedFilter> filters) =>
-        _ = InvokeAsync(() => RefreshTieFilters(rescanOnPredicateChange: true));
+    private Task OnFiltersChangedAsync()
+    {
+        if (_disposed) { return Task.CompletedTask; }
+
+        RefreshTieFilters(rescanOnPredicateChange: true);
+
+        return Task.CompletedTask;
+    }
 
     private void OnFindMarksChanged(object? sender, EventArgs args) => _ = InvokeAsync(() =>
     {
@@ -771,11 +761,15 @@ private void OnFindMarksChanged(object? sender, EventArgs args) => _ = InvokeAsy
         StateHasChanged();
     });
 
-    private void OnFocusChanged(object? sender, SelectionEntry? focus) => _ = InvokeAsync(() =>
+    private Task OnFocusChangedAsync()
     {
+        if (_disposed) { return Task.CompletedTask; }
+
         ResolveFocusedTicks();
         StateHasChanged();
-    });
+
+        return Task.CompletedTask;
+    }
 
     private void OnTimeZoneChanged(object? sender, TimeZoneInfo timeZone) => _ = InvokeAsync(() =>
     {
@@ -783,7 +777,6 @@ private void OnTimeZoneChanged(object? sender, TimeZoneInfo timeZone) => _ = Inv
 
         _timeZone = timeZone;
 
-        // Both live regions embed _timeZone-formatted times, so re-render alone would leave a screen reader announcing the old zone until the next pan/zoom/scan.
         ScheduleAnnouncement();
 
         if (_binCursor is { } cursor && _render is { Bins.Count: > 0 } render && cursor < render.Bins.Count)
@@ -821,28 +814,22 @@ private void PushWindowHistory()
         if (_windowHistory.Count > MaxWindowHistory) { _windowHistory.RemoveAt(0); }
     }
 
-    // Segment heights are scaled to the visible groups, so any change to the hidden set must rescale the current render's bars (the pending scan, if any, replaces them once it lands).
     private void RecomputeSegmentHeights()
     {
         if (_render is { } render && _baseData is { } data) { ComputeSegmentHeights(render, data.Groups.Count); }
     }
 
-    // Refresh the cached assertive-region bin readout against the current (post-filter-change) state. The cached string
-    // embeds the highlight description, so it must be re-derived on every highlight change (disarm, plan change, or a
-    // color-only edit that does not rescan) or it can keep announcing a stale highlight after the cursor is dismissed.
     private void RefreshBinAnnouncement() =>
-        _binAnnouncement = _binCursor is { } cursor && _render is { } render && cursor < render.Bins.Count
-            ? BinCursorAnnouncement(render.Bins[cursor])
-            : string.Empty;
+        _binAnnouncement = _binCursor is { } cursor && _render is { } render && cursor < render.Bins.Count ?
+                BinCursorAnnouncement(render.Bins[cursor]) :
+                string.Empty;
 
     private void RefreshFindTicks() =>
-        _findTicks = FindMarkers.Owner == ActiveEventLogId.Value && FindMarkers.Ticks is { Count: > 0 } ticks
-            ? [.. ticks]
-            : [];
+        _findTicks = FindMarkers.Owner == ActiveEventLog.Current && FindMarkers.Ticks is { Count: > 0 } ticks ? [.. ticks] : [];
 
     private void RefreshTieFilters(bool rescanOnPredicateChange)
     {
-        ImmutableList<SavedFilter> filters = Filters.Value;
+        ImmutableList<SavedFilter> filters = Filters.Current;
         SavedFilter[] selected = HighlightSelector.Select(filters);
         int planKey = HighlightSelector.ComputePredicatePlanKey(filters);
 
@@ -855,9 +842,6 @@ private void RefreshTieFilters(bool rescanOnPredicateChange)
 
         if (rescanNeeded && rescanOnPredicateChange)
         {
-            // The rescan will republish _baseData, but until it lands the current masks were resolved against the OLD
-            // eligible list. Invalidate them synchronously so a render in the gap does not map stale ordinals through
-            // the new filters (masks are non-null only when the prior state was armed).
             if (_baseData is { GroupHighlightMasks: not null } data)
             {
                 _baseData = data with { GroupHighlightMasks = null };
@@ -872,6 +856,7 @@ private void RefreshTieFilters(bool rescanOnPredicateChange)
         }
 
         RefreshBinAnnouncement();
+
         StateHasChanged();
     }
 
@@ -880,11 +865,12 @@ private string RegionAria() =>
 
     private void ResolveFocusedTicks()
     {
-        _focusedTicks = Focus.Value?.CurrentHandle is { } handle
-            && ActiveView.Value.Rank(handle) >= 0
-            && ActiveView.Value.TryGetTimeTicks(handle, out long ticks)
-            ? ticks
-            : null;
+        IEventColumnView view = ViewSource.Current.View;
+
+        _focusedTicks =
+            EventFocus.Current?.CurrentHandle is { } handle &&
+            view.Rank(handle) >= 0 &&
+            view.TryGetTimeTicks(handle, out long ticks) ? ticks : null;
     }
 
     private (string? CssName, string Description) ResolveGroupHighlight(uint mask) =>
@@ -892,8 +878,9 @@ private void ResolveFocusedTicks()
 
     private async Task RunScanAsync(
         IEventColumnView view,
+        EventLogId? scannedTabId,
         HistogramDimension dimension,
-        int epoch,
+        int scanVersion,
         SavedFilter[] tieHighlightFilters,
         int tiePlanKey,
         bool useHighlightTie,
@@ -903,7 +890,6 @@ private async Task RunScanAsync(
 
         try
         {
-            // Domain is the view's own survivor span, so the bucketer's edge clamp can't pile off-window rows into false spikes.
             data = await Task.Run(() =>
             {
                 token.ThrowIfCancellationRequested();
@@ -923,6 +909,37 @@ private async Task RunScanAsync(
         {
             TraceLogger.Error($"{nameof(HistogramPane)}: histogram scan failed: {e}");
 
+            // Marshal the failure back rather than only logging it. Without this the pane keeps whatever state the scan
+            // began in and never assigns _baseData, so the empty-state branch reports "no events to chart" - a
+            // statement about the user's data, for a chart that failed to build from it.
+            try
+            {
+                await InvokeAsync(() =>
+                {
+                    // A superseded scan's failure says nothing about the request that replaced it.
+                    if (_disposed || scanVersion != _scanVersion) { return; }
+
+                    _chartState = HistogramChartState.Failed;
+
+                    // Discard the chart rather than merely stop drawing it. Every interaction path reads these fields
+                    // directly, not the rendered markup, so bars left behind stay clickable and drag-selectable and
+                    // would issue a time-range filter derived from a scan that failed - acting on data rather than
+                    // only misreading it. Nothing re-stamps a retained chart the way the grid's rows are re-stamped,
+                    // so there is no version of these bars that stays true.
+                    _baseData = null;
+                    _render = null;
+                    _binCursor = null;
+                    _binAnnouncement = string.Empty;
+
+                    // Retires any summary already queued behind the delay, which would otherwise describe the chart
+                    // that just failed as though it had arrived.
+                    _announceGeneration++;
+
+                    StateHasChanged();
+                });
+            }
+            catch (ObjectDisposedException) { /* Component torn down mid-failure; nothing to report to. */ }
+
             return;
         }
 
@@ -930,11 +947,15 @@ private async Task RunScanAsync(
         {
             await InvokeAsync(() =>
             {
-                if (_disposed || token.IsCancellationRequested || epoch != _scanEpoch || !ReferenceEquals(view, ActiveView.Value)) { return; }
+                if (_disposed ||
+                    token.IsCancellationRequested ||
+                    scanVersion != _scanVersion ||
+                    scannedTabId != ViewSource.Current.ActiveTabId) { return; }
 
                 if (useHighlightTie && tiePlanKey != _tiePlanKey) { return; }
 
                 _baseData = data;
+                _chartState = HistogramChartState.Ready;
                 ResolveFocusedTicks();
                 ApplyPublishedWindow();
                 AggregateAndRender();
@@ -947,9 +968,15 @@ await InvokeAsync(() =>
 
     private void ScheduleRecompute()
     {
-        if (_recomputePending || _disposed) { return; }
+        if (_disposed) { return; }
+
+        _scanVersion++;
+        _chartState = HistogramChartState.Pending;
+
+        if (_recomputePending) { return; }
 
         _recomputePending = true;
+
         _ = ThrottleThenScanAsync();
     }
 
@@ -958,7 +985,7 @@ private void ScopeBin(HistogramRenderBin bin) =>
             new DateTime(bin.StartTicks, DateTimeKind.Utc),
             new DateTime(bin.EndTicks, DateTimeKind.Utc),
             _timeZone,
-            ActiveOriginLog.Value);
+            Presentation.ActiveLogName);
 
     private void ScopeBinCursorOrWindow()
     {
@@ -980,7 +1007,7 @@ private void ScopeToRange()
             new DateTime(render.WindowStartTicks, DateTimeKind.Utc),
             new DateTime(render.WindowEndTicks, DateTimeKind.Utc),
             _timeZone,
-            ActiveOriginLog.Value);
+            Presentation.ActiveLogName);
     }
 
     private void SetWindow(long startTicks, long endTicks)
@@ -1000,13 +1027,11 @@ private void SetWindow(long startTicks, long endTicks)
         AggregateAndRender();
     }
 
-    // Every zoom/pan/fit sets the window here as a whole base-bin range, so the render bounds equal the window and incremental zoom never re-quantizes back to the same bins (no stall).
     private void SetWindowByBins(HistogramData data, int startBin, int binCount, bool recordHistory = false)
     {
         int totalBins = data.BinCount;
         int minBins = Math.Min(MinWindowBaseBins, totalBins);
 
-        // Keep the virtual scroll track under the browser's maximum layout width so scrollWidth == clientWidth / WindowFraction holds and the scrollbar can reach the final bins; a deeper zoom would overflow the cap.
         if (_viewportWidthPx > 0)
         {
             minBins = Math.Max(minBins, HistogramTrackCap.MinBinsForWidth(_viewportWidthPx, totalBins));
@@ -1022,7 +1047,6 @@ private void SetWindowByBins(HistogramData data, int startBin, int binCount, boo
         long newStartTicks = newZoomed ? baseMin + (startBin * span) : baseMin;
         long newEndTicks = newZoomed ? Math.Min((baseMin + ((startBin + binCount) * span)) - 1, data.MaxUtc.Ticks) : data.MaxUtc.Ticks;
 
-        // Record an undo step only when the window actually moves, so a no-op zoom (clamped at the floor or full span) can't leave a dead history entry that swallows the first Undo.
         if (recordHistory && (newStartTicks != _windowStartTicks || newEndTicks != _windowEndTicks)) { PushWindowHistory(); }
 
         _isZoomed = newZoomed;
@@ -1045,14 +1069,15 @@ private void StartScan()
         _scanCts?.Dispose();
         _scanCts = null;
 
-        // Bump the epoch on every supersede -- even when we bail below for a zero-size viewport -- so a prior scan whose
-        // UI publication is already queued is rejected by RunScanAsync's epoch guard and cannot restore stale data (for
-        // example, re-arm masks that a disarm just cleared).
-        int epoch = ++_scanEpoch;
+        int scanVersion = ++_scanVersion;
+
+        _chartState = HistogramChartState.Pending;
 
         if (_viewportWidthPx <= 0 || _plotHeightPx <= 0) { return; }
 
-        IEventColumnView view = ActiveView.Value;
+        var current = ViewSource.Current;
+        IEventColumnView view = current.View;
+        EventLogId? scannedTabId = current.ActiveTabId;
         HistogramDimension dimension = _dimension;
         SavedFilter[] tieHighlightFilters = _tieHighlightFilters;
         int tiePlanKey = _tiePlanKey;
@@ -1060,10 +1085,9 @@ private void StartScan()
         var cts = new CancellationTokenSource();
         _scanCts = cts;
 
-        _ = RunScanAsync(view, dimension, epoch, tieHighlightFilters, tiePlanKey, useHighlightTie, cts.Token);
+        _ = RunScanAsync(view, scannedTabId, dimension, scanVersion, tieHighlightFilters, tiePlanKey, useHighlightTie, cts.Token);
     }
 
-    // Invalidate any pan/zoom queued before an explicit navigation reset (undo, Fit, drag-select, tab switch): the higher generation makes their stale, schedule-time-stamped OnHistogramZoomed/OnHistogramPanned invocations no-op. Every caller is followed by a render (immediate sync-scroll render, or the rescan's after a tab switch) that publishes the new token to JS via applyView.
     private void SupersedeQueuedNavigation() => _navToken++;
 
     private int TargetBins(HistogramData data)
@@ -1084,7 +1108,6 @@ private async Task ThrottleThenScanAsync()
 
     private void ToggleGroup(string key)
     {
-        // Keyed by stable Key so a live-tail re-rank can't swap which category is hidden. Window totals and anomaly flags stay over all groups.
         if (!_hiddenGroups.Remove(key)) { _hiddenGroups.Add(key); }
 
         RecomputeSegmentHeights();
@@ -1103,7 +1126,6 @@ private void UndoZoom()
         long beforeStart = _windowStartTicks;
         long beforeEnd = _windowEndTicks;
 
-        // Pop past any snapshot that, after the track-cap clamp, reproduces the current window (a resize-forced re-clamp can leave the top entry equal to the current view), so Undo always moves visibly.
         while (_windowHistory.Count > 0)
         {
             (long start, long end, bool zoomed) = _windowHistory[^1];
@@ -1137,7 +1159,6 @@ private int WindowBinCount(HistogramData data)
         return endBin - startBin + 1;
     }
 
-    // True when the window's displayed endpoints fall on different calendar days (including a short window straddling midnight), so times need a date to disambiguate.
     private bool WindowCrossesDay() =>
         _render is { } render &&
         ToDisplay(new DateTime(render.WindowStartTicks, DateTimeKind.Utc)).Date
@@ -1160,7 +1181,6 @@ private long WindowFractionToTicks(double fraction)
     private int WindowStartBin(HistogramData data) =>
         (int)Math.Clamp((_windowStartTicks - data.MinUtc.Ticks) / data.BucketSpanTicks, 0, data.BinCount - 1);
 
-    // Explicit keyboard/toolbar zoom supersedes any queued wheel/scroll momentum before zooming; the wheel path (OnHistogramZoomed) calls ApplyZoom directly with no bump, so rapid coalesced wheel zooming isn't self-invalidated.
     private void ZoomFromControl(double factor)
     {
         SupersedeQueuedNavigation();
diff --git a/src/EventLogExpert.UI/LogTable/LogTabBar.razor b/src/EventLogExpert.UI/LogTable/LogTabBar.razor
index af3b0c741..9a687cb6f 100644
--- a/src/EventLogExpert.UI/LogTable/LogTabBar.razor
+++ b/src/EventLogExpert.UI/LogTable/LogTabBar.razor
@@ -1,12 +1,23 @@
-@inherits FluxorComponent
+@inherits AppStateComponentBase
+@{
+    var presentation = Source.Current;
 
-<div class="log-tab-bar" hidden="@(LogTableState.Value.EventTables.Count <= 1)" @ref="_logTabBarRootRef">
+    if (!ReferenceEquals(presentation, _renderedPresentation))
+    {
+        _tabRows = BuildTabRows(presentation);
+        _renderedPresentation = presentation;
+    }
+
+    var tabRows = _tabRows;
+}
+
+<div class="log-tab-bar" hidden="@(!presentation.HasMultipleTabs)" @ref="_logTabBarRootRef">
     <div class="tab-row">
-        @foreach (var row in _tabRows)
+        @foreach (var row in tabRows)
         {
             if (row is AllLogsRow allLogs)
             {
-                <div class="@GetActiveTab(allLogs.Header)" @oncontextmenu="OpenAllLogsMenu"
+                <div class="@GetActiveTab(presentation, allLogs.Header)" @oncontextmenu="OpenAllLogsMenu"
                     @oncontextmenu:preventDefault="true"
                     @oncontextmenu:stopPropagation="true"
                     title="@GetTabTooltip(allLogs.Header)">
@@ -14,14 +25,14 @@
                         @onmousedown="e => OnTabMouseDown(e, allLogs.Header)"
                         role="button"
                         tabindex="0">
-                        @GetTabName(allLogs.Header)
+                        @GetTabName(presentation, allLogs.Header)
                     </span>
                 </div>
             }
             else if (row is GroupRow group)
             {
                 <div class="tab-group">
-                    <div class="@GetActiveTab(group.Header) group-header" @oncontextmenu="args => OpenGroupHeaderMenu(args, group.Group)"
+                    <div class="@GetActiveTab(presentation, group.Header) group-header" @oncontextmenu="args => OpenGroupHeaderMenu(args, group.Group)"
                         @oncontextmenu:preventDefault="true"
                         @oncontextmenu:stopPropagation="true"
                         title="@GetTabTooltip(group.Header)">
@@ -36,7 +47,7 @@
                             @onmousedown="e => OnTabMouseDown(e, group.Header)"
                             role="button"
                             tabindex="0">
-                            @GetTabName(group.Header)
+                            @GetTabName(presentation, group.Header)
                         </span>
                         <i aria-label="Close group"
                             class="bi bi-x"
@@ -46,9 +57,9 @@
                             tabindex="0">
                         </i>
                     </div>
-                    @foreach (var member in VisibleMembers(group))
+                    @foreach (var member in VisibleMembers(presentation, group))
                     {
-                        <div class="@GetTabClass(member, true)" @oncontextmenu="args => OpenMemberMenu(args, member, group.Group)"
+                        <div class="@GetTabClass(presentation, member, true)" @oncontextmenu="args => OpenMemberMenu(args, member, group.Group)"
                             @oncontextmenu:preventDefault="true"
                             @oncontextmenu:stopPropagation="true"
                             title="@GetTabTooltip(member)">
@@ -59,10 +70,10 @@
                                 tabindex="@(member.IsLoading ? -1 : 0)">
                                 @if (member.IsLoading)
                                 {
-                                    <i aria-label="Loading" class="spinner-border loader-spin" role="status"></i>
+                                    <i aria-label="Loading" class="loader-spin spinner-border" role="status"></i>
                                     @:&nbsp;
                                 }
-                                @GetTabName(member)
+                                @GetTabName(presentation, member)
                             </span>
                             <i aria-label="Close log"
                                 class="bi bi-x"
@@ -77,7 +88,7 @@
             }
             else if (row is StandaloneRow standalone)
             {
-                <div class="@GetActiveTab(standalone.Tab)" @oncontextmenu="args => OpenStandaloneMenu(args, standalone.Tab)"
+                <div class="@GetActiveTab(presentation, standalone.Tab)" @oncontextmenu="args => OpenStandaloneMenu(args, standalone.Tab)"
                     @oncontextmenu:preventDefault="true"
                     @oncontextmenu:stopPropagation="true"
                     title="@GetTabTooltip(standalone.Tab)">
@@ -88,10 +99,10 @@
                         tabindex="@(standalone.Tab.IsLoading ? -1 : 0)">
                         @if (standalone.Tab.IsLoading)
                         {
-                            <i aria-label="Loading" class="spinner-border loader-spin" role="status"></i>
+                            <i aria-label="Loading" class="loader-spin spinner-border" role="status"></i>
                             @:&nbsp;
                         }
-                        @GetTabName(standalone.Tab)
+                        @GetTabName(presentation, standalone.Tab)
                     </span>
                     <i aria-label="Close log"
                         class="bi bi-x"
diff --git a/src/EventLogExpert.UI/LogTable/LogTabBar.razor.cs b/src/EventLogExpert.UI/LogTable/LogTabBar.razor.cs
index 0f1dbeb9d..80bd69bfc 100644
--- a/src/EventLogExpert.UI/LogTable/LogTabBar.razor.cs
+++ b/src/EventLogExpert.UI/LogTable/LogTabBar.razor.cs
@@ -7,26 +7,20 @@
 using EventLogExpert.Runtime.Alerts;
 using EventLogExpert.Runtime.EventLog;
 using EventLogExpert.Runtime.LogTable;
-using EventLogExpert.Runtime.Menu;
 using EventLogExpert.UI.Common;
 using EventLogExpert.UI.Common.Interop;
-using Fluxor;
+using EventLogExpert.UI.Menu;
 using Microsoft.AspNetCore.Components;
 using Microsoft.AspNetCore.Components.Web;
 using Microsoft.JSInterop;
-using System.Collections.Immutable;
 
 namespace EventLogExpert.UI.LogTable;
 
 public sealed partial class LogTabBar
 {
-    private EventLogId? _activeEventLogId;
-    private HashSet<EventLogId> _emptyTabIds = [];
-    private ImmutableList<LogView>? _eventTables;
-    private ImmutableList<LogTabGroup> _groups = [];
     private IJSObjectReference? _logTabBarModule;
     private ElementReference _logTabBarRootRef;
-    private LogTableState _logTableState = null!;
+    private LogTabBarPresentation? _renderedPresentation;
     private IJSObjectReference? _scrollSuppressorModule;
     private List<TabRow> _tabRows = [];
 
@@ -38,10 +32,12 @@ public sealed partial class LogTabBar
 
     [Inject] private ILogTableCommands LogTableCommands { get; init; } = null!;
 
-    [Inject] private IState<LogTableState> LogTableState { get; init; } = null!;
-
     [Inject] private IMenuService MenuService { get; init; } = null!;
 
+    [Inject] private ILogTableQueries Queries { get; init; } = null!;
+
+    [Inject] private ILogTabBarSource Source { get; init; } = null!;
+
     [Inject] private ITraceLogger TraceLogger { get; init; } = null!;
 
     protected override async ValueTask DisposeAsyncCore(bool disposing)
@@ -91,55 +87,24 @@ await _scrollSuppressorModule.InvokeVoidAsync(
 
     protected override void OnInitialized()
     {
+        ObserveSource(Source);
         base.OnInitialized();
-
-        var state = LogTableState.Value;
-        _logTableState = state;
-        _eventTables = state.EventTables;
-        _groups = state.Groups;
-        _activeEventLogId = state.ActiveEventLogId;
-        _emptyTabIds = ComputeEmptyTabIds(state);
-        _tabRows = BuildTabRows(state);
     }
 
-    protected override bool ShouldRender()
-    {
-        var state = LogTableState.Value;
-
-        if (ReferenceEquals(state, _logTableState)) { return false; }
-
-        bool tablesChanged = !ReferenceEquals(state.EventTables, _eventTables);
-        bool groupsChanged = !ReferenceEquals(state.Groups, _groups);
-        bool activeChanged = state.ActiveEventLogId != _activeEventLogId;
-        var emptyTabIds = ComputeEmptyTabIds(state);
-        bool emptinessChanged = !emptyTabIds.SetEquals(_emptyTabIds);
-
-        _logTableState = state;
+    protected override bool ShouldRender() => !ReferenceEquals(Source.Current, _renderedPresentation);
 
-        if (!tablesChanged && !groupsChanged && !activeChanged && !emptinessChanged) { return false; }
-
-        _eventTables = state.EventTables;
-        _groups = state.Groups;
-        _activeEventLogId = state.ActiveEventLogId;
-        _emptyTabIds = emptyTabIds;
-
-        if (tablesChanged || groupsChanged) { _tabRows = BuildTabRows(state); }
-
-        return true;
-    }
-
-    private static List<TabRow> BuildTabRows(LogTableState state)
+    private static List<TabRow> BuildTabRows(LogTabBarPresentation presentation)
     {
         var headerGroupIds = new HashSet<LogTabGroupId>();
 
-        foreach (var table in state.EventTables)
+        foreach (var table in presentation.Tabs)
         {
             if (table.GroupId is { IsAll: false } groupId) { headerGroupIds.Add(groupId); }
         }
 
         var memberToGroupId = new Dictionary<EventLogId, LogTabGroupId>();
 
-        foreach (var group in state.Groups)
+        foreach (var group in presentation.Groups)
         {
             if (!headerGroupIds.Contains(group.Id)) { continue; }
 
@@ -149,7 +114,7 @@ private static List<TabRow> BuildTabRows(LogTableState state)
         var membersByGroup = new Dictionary<LogTabGroupId, List<LogView>>();
         var standalone = new List<LogView>();
 
-        foreach (var table in state.EventTables)
+        foreach (var table in presentation.Tabs)
         {
             if (table.GroupId is not null) { continue; }
 
@@ -171,16 +136,16 @@ private static List<TabRow> BuildTabRows(LogTableState state)
 
         var rows = new List<TabRow>();
 
-        if (state.EventTables.FirstOrDefault(table => table.GroupId?.IsAll == true) is { } allLogs)
+        if (presentation.Tabs.FirstOrDefault(table => table.GroupId?.IsAll == true) is { } allLogs)
         {
             rows.Add(new AllLogsRow(allLogs));
         }
 
-        foreach (var header in state.EventTables)
+        foreach (var header in presentation.Tabs)
         {
             if (header.GroupId is not { IsAll: false } headerGroupId) { continue; }
 
-            if (state.Groups.FirstOrDefault(candidate => candidate.Id == headerGroupId) is not { } group)
+            if (presentation.Groups.FirstOrDefault(candidate => candidate.Id == headerGroupId) is not { } group)
             {
                 continue;
             }
@@ -201,20 +166,6 @@ private static List<TabRow> BuildTabRows(LogTableState state)
         return rows;
     }
 
-    private static HashSet<EventLogId> ComputeEmptyTabIds(LogTableState state)
-    {
-        var empty = new HashSet<EventLogId>();
-
-        foreach (var table in state.EventTables)
-        {
-            if (table.IsCombined || table.IsLoading) { continue; }
-
-            if (state.EventCountByLog.GetValueOrDefault(table.Id, 0) <= 0) { empty.Add(table.Id); }
-        }
-
-        return empty;
-    }
-
     private static MenuItem DangerItem(
         string label,
         Action onClick,
@@ -241,6 +192,11 @@ private static string GetTabTooltip(LogView table)
                 $"Computer Name: {table.ComputerName}";
     }
 
+    private static IReadOnlyList<LogView> VisibleMembers(LogTabBarPresentation presentation, GroupRow row) =>
+        row.Group.IsCollapsed
+            ? [.. row.Members.Where(member => member.Id == presentation.ActiveTabId)]
+            : row.Members;
+
     private IReadOnlyList<MenuItem> BuildAllLogsMenu() =>
     [
         DangerItem("Close all logs", ConfirmCloseAllLogsAsync),
@@ -279,7 +235,7 @@ private IReadOnlyList<MenuItem> BuildMoveTargets(LogView tab, LogTabGroupId? exc
     {
         var items = new List<MenuItem>();
 
-        foreach ((LogTabGroupId logTabGroupId, string name, var _) in LogTableState.Value.Groups)
+        foreach ((LogTabGroupId logTabGroupId, string name, var _) in Queries.GetTabGroups())
         {
             if (excludeGroupId is { } excluded && logTabGroupId == excluded) { continue; }
 
@@ -302,17 +258,16 @@ private IReadOnlyList<MenuItem> BuildStandaloneMenu(LogView tab) =>
         CloseOtherTabsItem(tab.Id),
     ];
 
-    private bool CanCloseOthersInGroup(LogTabGroup group, EventLogId keepTabId) =>
-        group.MemberIds.Contains(keepTabId) &&
-        LogTableState.Value.EventTables.Count(tab => tab.GroupId is null && group.MemberIds.Contains(tab.Id)) > 1;
+    private bool CanCloseOtherTabs() => Queries.HasMultipleIndividualTabs();
 
-    private bool CanCloseOtherTabs() => LogTableState.Value.EventTables.Count(tab => !tab.IsCombined) > 1;
+    private bool CanCloseOthersInGroup(LogTabGroup group, EventLogId keepTabId) =>
+        Queries.HasOtherTabsInGroup(group.Id, keepTabId);
 
     private void CloseGroup(LogTabGroup group) => LogTableCommands.CloseGroup(group.Id);
 
     private void CloseLog(LogView table)
     {
-        if (LogTableState.Value.EventTables.All(tab => tab.Id != table.Id)) { return; }
+        if (!Queries.IsTabOpen(table.Id)) { return; }
 
         EventLogCommands.CloseLog(table.Id, table.LogName);
     }
@@ -336,17 +291,17 @@ private async Task ConfirmCloseAllLogsAsync()
         }
     }
 
-    private string GetActiveTab(LogView table) =>
-        LogTableState.Value.ActiveEventLogId == table.Id ? "tab active" : "tab";
+    private string GetActiveTab(LogTabBarPresentation presentation, LogView table) =>
+        presentation.ActiveTabId == table.Id ? "tab active" : "tab";
 
-    private string GetTabClass(LogView table, bool isMember)
+    private string GetTabClass(LogTabBarPresentation presentation, LogView table, bool isMember)
     {
-        string active = GetActiveTab(table);
+        string active = GetActiveTab(presentation, table);
 
         return isMember ? $"{active} member" : active;
     }
 
-    private string GetTabName(LogView table)
+    private string GetTabName(LogTabBarPresentation presentation, LogView table)
     {
         if (table.GroupId?.IsAll == true) { return "Combined"; }
 
@@ -358,9 +313,7 @@ private string GetTabName(LogView table)
 
         if (table.IsLoading) { return tabName; }
 
-        int count = _logTableState.EventCountByLog.GetValueOrDefault(table.Id, 0);
-
-        return count <= 0 ? $"(Empty) {tabName}" : tabName;
+        return presentation.IsKnownEmpty(table.Id) ? $"(Empty) {tabName}" : tabName;
     }
 
     private void OnCloseGroupKeyDown(KeyboardEventArgs e, LogTabGroup group)
@@ -420,7 +373,7 @@ private async Task PromptNewGroupAsync(LogView tab)
 
         if (string.IsNullOrWhiteSpace(name)) { return; }
 
-        if (!LogTableState.Value.EventTables.Any(table => table.Id == tab.Id && table.GroupId is null))
+        if (!Queries.IsUngroupedTabOpen(tab.Id))
         {
             TraceLogger.Trace($"New group skipped: tab '{tab.LogName}' is no longer an open per-log tab.");
             return;
@@ -439,7 +392,7 @@ private async Task PromptRenameAsync(LogTabGroup group)
 
         if (string.IsNullOrWhiteSpace(name)) { return; }
 
-        if (LogTableState.Value.Groups.All(candidate => candidate.Id != group.Id))
+        if (!Queries.HasTabGroup(group.Id))
         {
             TraceLogger.Trace($"Rename skipped: group '{group.Name}' no longer exists.");
             return;
@@ -458,11 +411,6 @@ private void SetActiveLog(LogView table)
     private void ToggleCollapse(LogTabGroup group) =>
         LogTableCommands.SetTabGroupCollapsed(group.Id, !group.IsCollapsed);
 
-    private IReadOnlyList<LogView> VisibleMembers(GroupRow row) =>
-        row.Group.IsCollapsed
-            ? [.. row.Members.Where(member => member.Id == _activeEventLogId)]
-            : row.Members;
-
     private sealed record AllLogsRow(LogView Header) : TabRow;
 
     private sealed record GroupRow(LogView Header, LogTabGroup Group, IReadOnlyList<LogView> Members) : TabRow;
diff --git a/src/EventLogExpert.UI/LogTable/LogTablePane.Find.cs b/src/EventLogExpert.UI/LogTable/LogTablePane.Find.cs
index 6dabb1c09..013303681 100644
--- a/src/EventLogExpert.UI/LogTable/LogTablePane.Find.cs
+++ b/src/EventLogExpert.UI/LogTable/LogTablePane.Find.cs
@@ -11,7 +11,6 @@
 
 namespace EventLogExpert.UI.LogTable;
 
-// In-view incremental Find (Ctrl+F): read-only over the current view; it never dispatches filter/lens/sort/selection actions.
 public sealed partial class LogTablePane
 {
     private const int FindChunkSize = 4096;
@@ -27,8 +26,8 @@ public sealed partial class LogTablePane
     private CancellationTokenSource? _findDebounceCts;
     private int _findFocusSignal;
     private (EventLogId? TableId, ColumnName? GroupBy) _findGroupContext;
-    private List<EventLocator> _findMatches = [];
     private HashSet<EventLocator> _findMatchSet = [];
+    private List<EventLocator> _findMatches = [];
     private bool _findOpen;
     private string _findQuery = string.Empty;
     private IDisposable? _findRegistration;
@@ -50,7 +49,6 @@ public sealed partial class LogTablePane
 
     private int FindMatchCount => _findMatches.Count;
 
-    // Renders Blazor-escaped segments (never MarkupString) so event text can't inject markup; capped at MaxMarksPerCell so a pathological cell can't explode the DOM.
     private IReadOnlyList<FindSegment> BuildFindSegments(string? text)
     {
         string value = text ?? string.Empty;
@@ -82,7 +80,6 @@ private IReadOnlyList<FindSegment> BuildFindSegments(string? text)
 
     private void CancelFindScans()
     {
-        // Bump the epoch so a scan already past its cancellation check is rejected at publish time.
         _findScanEpoch++;
         _findScanCts?.Cancel();
         _findScanCts?.Dispose();
@@ -111,7 +108,6 @@ private Task CloseFind()
         _findDebounceCts?.Dispose();
         _findDebounceCts = null;
 
-        // Re-collapse only the groups Find expanded, keeping the current match's group open so the cursor lands on the event.
         RecollapseFindGroups();
 
         if (TryGetCurrentMatchLocator(out EventLocator locator))
@@ -129,7 +125,7 @@ private Task CloseFind()
     }
 
     private (EventLogId? TableId, ColumnName? GroupBy) CurrentFindGroupContext() =>
-        (_currentTable?.Id, _logTableState.GroupBy);
+        (Presentation.ActiveTabId, Presentation.Ordering.GroupBy);
 
     private async Task DebounceThenScanAsync(CancellationTokenSource cts)
     {
@@ -160,7 +156,6 @@ private void DisposeFind()
 
     private int FindAnchorIndex()
     {
-        // Anchor in event-display-index space (Rank / group StartIndex), not visible-row space, so the first jump targets the right match under headers / collapsed groups.
         if (_cursor is { Kind: TableRowKind.Event, Handle: { } handle })
         {
             int rank = _activeDisplayedEvents.Rank(handle);
@@ -196,7 +191,6 @@ private int FirstMatchAtOrAfterAnchor()
         return 0;
     }
 
-    // Enter/F3 must act on the just-typed query, not a debounce-stale result set: flush the pending debounce and scan now.
     private void FlushPendingFindScan()
     {
         if (_findDebounceCts is null) { return; }
@@ -220,7 +214,6 @@ private void FlushPendingFindScan()
     private bool IsCurrentFindMatch(DisplayRow row) =>
         _findOpen && _findCurrentLocator is { } locator && locator.Equals(row.Loc);
 
-    // Called when the searchable text or event set changed; collapse/regroup deliberately do NOT call this (they keep the same view reference and Find keeps its group-expansion ownership).
     private void NotifyFindViewChanged()
     {
         if (!_findOpen) { return; }
@@ -257,6 +250,15 @@ private void OnFindWholeWordChanged(bool wholeWord)
         RequestFindRender();
     }
 
+    private Task OnGroupCollapseRequestedAsync()
+    {
+        if (_disposed) { return Task.CompletedTask; }
+
+        _findExpandedGroupKeys.Clear();
+
+        return Task.CompletedTask;
+    }
+
     private void OpenFind()
     {
         bool wasOpen = _findOpen;
@@ -276,10 +278,9 @@ private void PruneFindGroupOwnershipOnContextChange()
         }
     }
 
-    // Hand the current match timestamps (owner-tagged, ascending) to the timeline; collected free during the scan, the histogram re-bins them against its current window.
     private void PublishFindMarks(List<long> matchTicks)
     {
-        if (_currentTable is not { } table)
+        if (Presentation.ActiveTabId is not { } tableId)
         {
             FindMarkerSource.Clear();
 
@@ -289,7 +290,7 @@ private void PublishFindMarks(List<long> matchTicks)
         long[] sorted = [.. matchTicks];
         Array.Sort(sorted);
 
-        FindMarkerSource.Publish(table.Id, sorted);
+        FindMarkerSource.Publish(tableId, sorted);
     }
 
     private void PublishFindMatches(List<EventLocator> matches, List<long> matchTicks)
@@ -356,8 +357,6 @@ private bool RecollapseSteppedAwayGroups(GroupedRowView view, string targetGroup
 
     private void RegisterFind() => _findRegistration = FindCoordinator.SetActivePane(OpenFind);
 
-    private void RelinquishFindGroupOwnership() => _ = InvokeAsync(() => _findExpandedGroupKeys.Clear());
-
     private void RequestFindRender()
     {
         _findRenderRequested = true;
@@ -375,7 +374,6 @@ private void ResolveCurrentMatchAfterScan(EventLocator? priorLocator)
             return;
         }
 
-        // Preserve the current match across a rescan: the locator survives a same-generation rescan and the ValueKey survives a reload; else fall back to the first match at/after the cursor.
         if (priorLocator is { } locator && _findMatchSet.Contains(locator))
         {
             SetCurrentMatchIndex(_findMatches.IndexOf(locator));
@@ -451,7 +449,6 @@ private async Task RunFindScanAsync(
         {
             await InvokeAsync(() =>
             {
-                // Publish only if this scan is still the current one: same epoch, same view instance, same query terms.
                 if (epoch != _findScanEpoch ||
                     !ReferenceEquals(view, _activeDisplayedEvents) ||
                     !string.Equals(query, _findQuery, StringComparison.Ordinal) ||
@@ -489,7 +486,6 @@ private void ScheduleFindScan()
             return;
         }
 
-        // Mark scanning immediately so stepping is blocked during the debounce window (otherwise Enter would navigate the pre-edit result set).
         _findScanning = true;
         _findWrapAnnouncement = string.Empty;
 
diff --git a/src/EventLogExpert.UI/LogTable/LogTablePane.razor b/src/EventLogExpert.UI/LogTable/LogTablePane.razor
index 1058d737c..f431a14fa 100644
--- a/src/EventLogExpert.UI/LogTable/LogTablePane.razor
+++ b/src/EventLogExpert.UI/LogTable/LogTablePane.razor
@@ -1,6 +1,6 @@
 @using EventLogExpert.UI.LogTable.Find
 @using EventLogExpert.UI.LogTable.Grouping
-@inherits FluxorComponent
+@inherits PresentationViewComponentBase
 
 <LogTabBar />
 
@@ -19,7 +19,7 @@
                  }
              }
              else { @context.Text }
-        </text>;
+    </text>;
 
     RenderFragment RenderEventRow(DisplayRow row) =>
         @<tr aria-current="@(IsCurrentFindMatch(row) ? "true" : null)"
@@ -85,7 +85,18 @@
             WrapAnnouncement="@_findWrapAnnouncement" />
     }
     <div aria-labelledby="eventTable" class="table-container" @onkeydown="HandleKeyDown" role="region" tabindex="0">
+        @if (_indicator.Spinner)
+        {
+            <div aria-hidden="true" class="table-indicator">
+                <span class="table-indicator-spinner"></span>
+                @if (IndicatorSentence() is { } sentence)
+                {
+                    <span class="table-indicator-text">@sentence</span>
+                }
+            </div>
+        }
         <table aria-label="Event Log Table"
+            aria-busy="@(IsGridBusy() ? "true" : null)"
             aria-multiselectable="true"
             aria-rowcount="@GetAriaRowCount()"
             id="eventTable"
@@ -99,7 +110,7 @@
                     var width = GetColumnWidth(columnHeader);
 
                     <th aria-colindex="@(columnIndex + 1)"
-                        aria-sort="@(_logTableState.OrderBy == columnHeader ? _logTableState.IsDescending ? "descending" : "ascending" : "none")"
+                        aria-sort="@(Presentation.Ordering.OrderBy == columnHeader ? Presentation.Ordering.IsDescending ? "descending" : "ascending" : "none")"
                         class="@columnHeader.ToString().ToLowerInvariant()"
                         data-column="@columnHeader"
                         @key="columnHeader"
@@ -113,14 +124,14 @@
                         {
                             @_headerName
                         }
-                        @if (_logTableState.OrderBy == columnHeader)
+                        @if (Presentation.Ordering.OrderBy == columnHeader)
                         {
-                            <ChromelessButton aria-label="Toggle sort direction"
-                                CssClass="menu-toggle"
-                                data-rotate="@_logTableState.IsDescending.ToString().ToLower()"
+                            <ChromelessButton CssClass="menu-toggle"
                                 IconClass="bi bi-caret-up"
                                 OnClick="ToggleSorting"
-                                StopKeyDownPropagation="true" />
+                                StopKeyDownPropagation="true"
+                                aria-label="Toggle sort direction"
+                                data-rotate="@Presentation.Ordering.IsDescending.ToString().ToLower()" />
                         }
                     </th>
                 }
@@ -133,12 +144,10 @@
             </tr>
             </thead>
             <tbody @oncontextmenu="InvokeContextMenu" @oncontextmenu:preventDefault="true" @oncontextmenu:stopPropagation="true">
-            @if (_currentTable is not null)
+            @if (Presentation.ActiveTabId is not null)
             {
                 @if (_rowView is null)
                 {
-                    @* Ungrouped: ItemsProvider fetches one Slice per viewport window, avoiding the Items= binding's
-                   per-row this[i] re-seek over the K-way merge. *@
                     <Virtualize Context="row" ItemSize="@EventRowHeightPixels" ItemsProvider="LoadEventViewport" @ref="_eventVirtualize">
                         @RenderEventRow(row)
                     </Virtualize>
@@ -147,7 +156,7 @@
                 {
                     var view = _rowView;
 
-                    <Virtualize Context="row" Items="view" ItemSize="@EventRowHeightPixels">
+                    <Virtualize Context="row" ItemSize="@EventRowHeightPixels" Items="view">
                         @if (row.Kind == TableRowKind.Header)
                         {
                             var group = view.GroupAt(row);
diff --git a/src/EventLogExpert.UI/LogTable/LogTablePane.razor.cs b/src/EventLogExpert.UI/LogTable/LogTablePane.razor.cs
index 6a3c287c6..4306d62ce 100644
--- a/src/EventLogExpert.UI/LogTable/LogTablePane.razor.cs
+++ b/src/EventLogExpert.UI/LogTable/LogTablePane.razor.cs
@@ -1,1514 +1,1614 @@
-// // Copyright (c) Microsoft Corporation.
-// // Licensed under the MIT License.
-
-using EventLogExpert.Eventing.Common.EventLogs;
-using EventLogExpert.Eventing.Common.Events;
-using EventLogExpert.Filtering.Common.Filtering;
-using EventLogExpert.Filtering.Compilation;
-using EventLogExpert.Filtering.Evaluation;
-using EventLogExpert.Filtering.Persistence;
-using EventLogExpert.Logging.Abstractions;
-using EventLogExpert.Runtime.Common.Clipboard;
-using EventLogExpert.Runtime.Common.Display;
-using EventLogExpert.Runtime.EventLog;
-using EventLogExpert.Runtime.FilterLenses;
-using EventLogExpert.Runtime.FilterPane;
-using EventLogExpert.Runtime.LogTable;
-using EventLogExpert.Runtime.Menu;
-using EventLogExpert.Runtime.Settings;
-using EventLogExpert.UI.Common;
-using EventLogExpert.UI.Common.Interop;
-using EventLogExpert.UI.LogTable.Grouping;
-using Fluxor;
-using Microsoft.AspNetCore.Components;
-using Microsoft.AspNetCore.Components.Web;
-using Microsoft.AspNetCore.Components.Web.Virtualization;
-using Microsoft.JSInterop;
-using System.Collections.Immutable;
-
-namespace EventLogExpert.UI.LogTable;
-
-public sealed partial class LogTablePane
-{
-    private const int DefaultPageSize = 20;
-    // Must match the CSS `tr { height: 22px }`; Virtualize defaults ItemSize to 50px, so leaving it unset computes the
-    // scroll model against a 50px spacer and jump-to-selected lands at the wrong position. Set explicitly so the model
-    // matches from the first render.
-    private const float EventRowHeightPixels = 22f;
-    private const int MenuValueMaxLength = 40;
-    private const string NoCellValueReason = "No value in this cell to filter on";
-
-    private static readonly IEventColumnView s_emptyView = Runtime.LogTable.LogTableState.EmptyView;
-    private static readonly HashSet<int> s_warnedUnknownColors = [];
-
-    // Keyed on EventLocator (physical, generation-stamped) so the cache survives a re-sort within a generation; default
-    // value equality (a ReferenceEqualityComparer would box every struct key and never match).
-    private readonly Dictionary<EventLocator, string?> _highlightCache = [];
-
-    private IEventColumnView _activeDisplayedEvents = s_emptyView;
-    private SavedFilter[] _activeHighlightFilters = [];
-    private LogView? _currentTable;
-    private TableCursor? _cursor;
-    private DotNetObjectReference<LogTablePane>? _dotNetRef;
-    private ColumnName[] _enabledColumns = null!;
-    private Virtualize<DisplayRow>? _eventVirtualize;
-    private ImmutableList<SavedFilter> _filters = [];
-    private int _filtersHighlightKey;
-    private SelectionEntry? _focus;
-    private bool _focusActiveOnNextRender;
-    private string _headerName = string.Empty;
-    private EventLogId? _highlightCacheTableId;
-    private IEventColumnView? _lastIndexedDisplayedEvents;
-    private LogTableState _logTableState = null!;
-    private int _pageSize = DefaultPageSize;
-    private ColumnName[] _previousEnabledColumns = [];
-    private bool _refreshEventViewportOnRender;
-    private bool _repaintViewportOnNextRender;
-    private bool _rescrollToSelectedOnRender;
-    private bool _resortSelectionOnNextRender;
-    private GroupedRowView? _rowView;
-    private (IEventColumnView View, EventLogId? TableId, ColumnName? GroupBy, bool GroupDescending, bool CollapsedDefault, ImmutableHashSet<string>? Overrides) _rowViewSnapshot;
-    private HashSet<EventLocator> _selectedSet = [];
-    private ImmutableList<SelectionEntry> _selection = [];
-    private EventLocator? _selectionAnchor;
-    private IJSObjectReference? _tableModule;
-    private TimeZoneInfo _timeZoneSettings = null!;
-
-    private EventLocator? ActiveHandle =>
-        _cursor is { Kind: TableRowKind.Event, Handle: { } handle } ? handle : null;
-
-    [Inject] private IClipboardService ClipboardService { get; init; } = null!;
-
-    [Inject] private ILogTableColumnDefaultsProvider ColumnDefaults { get; init; } = null!;
-
-    [Inject] private IEventLogCommands EventLogCommands { get; init; } = null!;
-
-    [Inject] private IFilterLensCommands FilterLensCommands { get; init; } = null!;
-
-    [Inject] private IFilterPaneCommands FilterPaneCommands { get; init; } = null!;
-
-    [Inject] private IState<FilterPaneState> FilterPaneState { get; init; } = null!;
-
-    [Inject] private IFilterService FilterService { get; init; } = null!;
-
-    [Inject] private IStateSelection<EventLogState, SelectionEntry?> Focus { get; init; } = null!;
-
-    [Inject] private IHighlightSelector HighlightSelector { get; init; } = null!;
-
-    [Inject] private IJSRuntime JSRuntime { get; init; } = null!;
-
-    [Inject] private ILogTableCommands LogTableCommands { get; init; } = null!;
-
-    [Inject] private IState<LogTableState> LogTableState { get; init; } = null!;
-
-    [Inject] private IMenuService MenuService { get; init; } = null!;
-
-    [Inject] private IStateSelection<EventLogState, ImmutableList<SelectionEntry>> Selection { get; init; } = null!;
-
-    [Inject] private ISettingsService Settings { get; init; } = null!;
-
-    [Inject] private ITraceLogger TraceLogger { get; init; } = null!;
-
-    [JSInvokable]
-    public void OnColumnReordered(string columnName, string targetColumn, bool insertAfter)
-    {
-        if (Enum.TryParse<ColumnName>(columnName, out var column) &&
-            Enum.TryParse<ColumnName>(targetColumn, out var target))
-        {
-            LogTableCommands.ReorderColumn(column, target, insertAfter);
-        }
-    }
-
-    [JSInvokable]
-    public void OnColumnResized(string columnName, int width)
-    {
-        if (Enum.TryParse<ColumnName>(columnName, out var column))
-        {
-            LogTableCommands.SetColumnWidth(column, width);
-        }
-    }
-
-    // Extracted from the ItemsProvider so the viewport clamp (empty view, start past the end, window overrunning the
-    // tail) is unit-testable without driving the Virtualize component.
-    internal static ItemsProviderResult<DisplayRow> ComputeEventViewport(
-        IEventColumnView displayedEvents,
-        ItemsProviderRequest request)
-    {
-        int totalCount = displayedEvents.Count;
-        int start = Math.Min(request.StartIndex, totalCount);
-        int count = Math.Min(request.Count, totalCount - start);
-
-        IReadOnlyList<DisplayRow> window =
-            count <= 0 ? [] : displayedEvents.Slice(start, count);
-
-        return new ItemsProviderResult<DisplayRow>(window, totalCount);
-    }
-
-    internal static string GetLevelClass(string level) => SeverityIcon.CssClass(LevelSeverity.FromLevelName(level));
-
-    protected override async ValueTask DisposeAsyncCore(bool disposing)
-    {
-        if (disposing)
-        {
-            DisposeFind();
-
-            await JsModuleInterop.DisposeModuleSafelyAsync(
-                _tableModule,
-                static module => module.InvokeVoidAsync("disposeTableEvents"));
-
-            _tableModule = null;
-
-            _dotNetRef?.Dispose();
-        }
-
-        await base.DisposeAsyncCore(disposing);
-    }
-
-    protected override async Task OnAfterRenderAsync(bool firstRender)
-    {
-        // Capture up front and clear: consuming the request after the awaits below could otherwise steal a request
-        // that a background action (e.g. a live-tail append) queued during one of those awaits, dropping that later
-        // render's scroll. A request arriving mid-render stays set and is handled by the next render instead.
-        bool rescrollRequested = _rescrollToSelectedOnRender;
-        _rescrollToSelectedOnRender = false;
-
-        if (firstRender || !_enabledColumns.SequenceEqual(_previousEnabledColumns))
-        {
-            _previousEnabledColumns = _enabledColumns.ToArray();
-
-            try
-            {
-                await InitializeTableEventHandlers();
-            }
-            catch (Exception e)
-            {
-                TraceLogger.Error($"Failed to initialize table event handlers: {e}");
-            }
-        }
-
-        if (firstRender)
-        {
-            try
-            {
-                int measured = _tableModule is not null ? await _tableModule.InvokeAsync<int>("getEventTablePageSize") : 0;
-
-                if (measured > 0) { _pageSize = measured; }
-            }
-            catch (JSDisconnectedException) { /* Circuit gone; fall back to default page size. */ }
-            catch (Exception e)
-            {
-                TraceLogger.Warning($"Failed to measure table page size, using default {DefaultPageSize}: {e}");
-            }
-        }
-
-        if (_focusActiveOnNextRender)
-        {
-            _focusActiveOnNextRender = false;
-            await FocusActiveRow();
-        }
-
-        if (_resortSelectionOnNextRender)
-        {
-            _resortSelectionOnNextRender = false;
-            ResortSelectionForCurrentTable();
-        }
-
-        if (_refreshEventViewportOnRender)
-        {
-            _refreshEventViewportOnRender = false;
-
-            if (_rowView is null && _eventVirtualize is not null)
-            {
-                try
-                {
-                    await _eventVirtualize.RefreshDataAsync();
-                    _repaintViewportOnNextRender = true;
-                    StateHasChanged();
-                }
-                catch (JSDisconnectedException) { /* Circuit gone; nothing to refresh. */ }
-                catch (Exception e)
-                {
-                    TraceLogger.Error($"Failed to refresh the event viewport: {e}");
-                }
-            }
-        }
-
-        if (rescrollRequested)
-        {
-            try
-            {
-                await ScrollToSelectedEvent();
-            }
-            catch (JSDisconnectedException) { /* Circuit gone; nothing to scroll. */ }
-            catch (Exception e)
-            {
-                TraceLogger.Error($"Failed to scroll to selected event: {e}");
-            }
-        }
-
-        if (_findScrollToCurrentOnRender)
-        {
-            try
-            {
-                await ScrollToCurrentFindMatchAsync();
-            }
-            catch (JSDisconnectedException) { /* Circuit gone; nothing to scroll. */ _findScrollToCurrentOnRender = false; }
-            catch (Exception e)
-            {
-                _findScrollToCurrentOnRender = false;
-                TraceLogger.Error($"{nameof(LogTablePane)}: failed to scroll to find match: {e}");
-            }
-        }
-
-        await base.OnAfterRenderAsync(firstRender);
-    }
-
-    protected override async Task OnInitializedAsync()
-    {
-        Focus.Select(s => s.Focus);
-        Selection.Select(s => s.Selection);
-
-        SubscribeToAction<SetActiveTableAction>(_ => RescrollToSelected());
-        SubscribeToAction<DisplayReadyAction>(_ => RescrollToSelected());
-        SubscribeToAction<AppendTableEventsAction>(_ => RescrollToSelected());
-        SubscribeToAction<AppendTableEventsBatchAction>(_ => RescrollToSelected());
-        SubscribeToAction<UpdateTableAction>(_ => RescrollToSelected());
-
-        // A bulk expand/collapse (any trigger) is a user choice: Find relinquishes group-expansion ownership so it won't later undo the user's collapse.
-        SubscribeToAction<SetAllGroupsCollapsedAction>(_ => RelinquishFindGroupOwnership());
-
-        _logTableState = LogTableState.Value;
-
-        _currentTable = _logTableState.EventTables.FirstOrDefault(x => x.Id == _logTableState.ActiveEventLogId);
-        _enabledColumns = GetOrderedEnabledColumns();
-        _focus = Focus.Value;
-        SetCursorEvent(_focus?.CurrentHandle);
-        _selection = Selection.Value;
-        _selectedSet = BuildSelectedSet(_selection);
-        var initialPaneState = FilterPaneState.Value;
-        _filters = initialPaneState.Filters;
-        _activeHighlightFilters = HighlightSelector.Select(initialPaneState.Filters);
-        _filtersHighlightKey = HighlightSelector.ComputeHighlightKey(initialPaneState.Filters);
-        _timeZoneSettings = Settings.TimeZoneInfo;
-
-        WarnOnUnknownFilterColors(_filters);
-
-        RebuildRowMaps();
-
-        RegisterFind();
-
-        await base.OnInitializedAsync();
-    }
-
-    protected override bool ShouldRender()
-    {
-        var currentPaneState = FilterPaneState.Value;
-        var currentFilters = currentPaneState.Filters;
-        bool filtersChanged = !ReferenceEquals(currentFilters, _filters);
-        // The focus is now a value-type SelectionEntry?; compare by OriginHandle (its stable identity). Reference
-        // equality would box and always differ, and full-value equality would re-render on a CurrentHandle re-point.
-        bool focusChanged = Focus.Value?.OriginHandle != _focus?.OriginHandle;
-
-        // Also render for a pending focus move or a post-refresh viewport repaint, neither of which changes Fluxor state.
-        if (!_focusActiveOnNextRender &&
-            !_repaintViewportOnNextRender &&
-            !_rescrollToSelectedOnRender &&
-            !_findRenderRequested &&
-            ReferenceEquals(LogTableState.Value, _logTableState) &&
-            ReferenceEquals(Selection.Value, _selection) &&
-            !focusChanged &&
-            !filtersChanged &&
-            Settings.TimeZoneInfo.Equals(_timeZoneSettings)) { return false; }
-
-        _repaintViewportOnNextRender = false;
-        _findRenderRequested = false;
-
-        bool selectionChanged = !ReferenceEquals(Selection.Value, _selection);
-
-        _logTableState = LogTableState.Value;
-
-        _currentTable = _logTableState.EventTables.FirstOrDefault(x => x.Id == _logTableState.ActiveEventLogId);
-        var previousColumnsForFind = _enabledColumns;
-        _enabledColumns = GetOrderedEnabledColumns();
-        bool findSearchTextChanged = _findOpen && !previousColumnsForFind.SequenceEqual(_enabledColumns);
-
-        if (selectionChanged)
-        {
-            _selection = Selection.Value;
-            _selectedSet = BuildSelectedSet(_selection);
-        }
-
-        if (focusChanged)
-        {
-            _focus = Focus.Value;
-            SetCursorEvent(_focus?.CurrentHandle);
-        }
-
-        if (filtersChanged)
-        {
-            _filters = currentFilters;
-            int newHighlightKey = HighlightSelector.ComputeHighlightKey(currentFilters);
-
-            if (newHighlightKey != _filtersHighlightKey)
-            {
-                _filtersHighlightKey = newHighlightKey;
-                _activeHighlightFilters = HighlightSelector.Select(currentFilters);
-                _highlightCache.Clear();
-                WarnOnUnknownFilterColors(_filters);
-            }
-        }
-
-        findSearchTextChanged |= _findOpen && !Settings.TimeZoneInfo.Equals(_timeZoneSettings);
-        _timeZoneSettings = Settings.TimeZoneInfo;
-
-        RebuildRowMaps();
-
-        if (findSearchTextChanged) { NotifyFindViewChanged(); }
-
-        return true;
-    }
-
-    private static HashSet<EventLocator> BuildSelectedSet(ImmutableList<SelectionEntry> selection)
-    {
-        // Membership tests a rendered row's live locator, so key on CurrentHandle (where the selection currently
-        // resolves), not OriginHandle; entries absent from the live generation carry a null CurrentHandle.
-        var set = new HashSet<EventLocator>(selection.Count);
-
-        foreach (var entry in selection)
-        {
-            if (entry.CurrentHandle is { } handle) { set.Add(handle); }
-        }
-
-        return set;
-    }
-
-    // OriginHandle and CurrentHandle are the same live locator at selection time; ReloadKey re-points the selection
-    // after a reload (null for a null-RecordId row, which cannot be re-resolved).
-    private static SelectionEntry EntryFor(DisplayRow row) =>
-        new(row.Loc, row.Loc, ValueKey.TryCreate(row.Lean, out var key) ? key : null);
-
-    private static string TruncateForMenu(string value)
-    {
-        string collapsed = value.ReplaceLineEndings(" ");
-
-        if (collapsed.Length <= MenuValueMaxLength) { return collapsed; }
-
-        int limit = char.IsHighSurrogate(collapsed[MenuValueMaxLength - 1])
-            ? MenuValueMaxLength - 1
-            : MenuValueMaxLength;
-
-        return collapsed[..limit] + "...";
-    }
-
-    private void AppendCellFilterItems(List<MenuItem> items, ResolvedEvent @event, ColumnName? column)
-    {
-        if (column is not { } cellColumn) { return; }
-
-        if (CellFilterBuilder.MapColumn(cellColumn) is not { } property) { return; }
-
-        string columnLabel = cellColumn.ToFullString();
-
-        if (CellFilterBuilder.TryGetDisplayValue(@event, property, out var value))
-        {
-            string shown = TruncateForMenu(value);
-            string verb = property is EventProperty.Keywords ? "has" : "=";
-
-            items.Add(MenuItem.Item(
-                $"Include only where {columnLabel} {verb} '{shown}'",
-                () => ApplySelectedFilter(@event, property, exclude: false)));
-            items.Add(MenuItem.Item(
-                $"Exclude where {columnLabel} {verb} '{shown}'",
-                () => ApplySelectedFilter(@event, property, exclude: true)));
-        }
-        else
-        {
-            items.Add(MenuItem.Item(
-                $"Include only where {columnLabel}",
-                () => { },
-                isEnabled: false,
-                disabledReason: NoCellValueReason));
-            items.Add(MenuItem.Item(
-                $"Exclude where {columnLabel}",
-                () => { },
-                isEnabled: false,
-                disabledReason: NoCellValueReason));
-        }
-
-        items.Add(MenuItem.Separator());
-    }
-
-    private void ApplyNavSelection(EventLocator target, bool shift)
-    {
-        if (shift)
-        {
-            _selectionAnchor ??= ActiveHandle ?? target;
-            SetCursorEvent(target);
-            DispatchSetSelection(BuildRange(_selectionAnchor.Value, target), target, alreadyOrdered: true);
-        }
-        else
-        {
-            _selectionAnchor = target;
-            SetCursorEvent(target);
-            DispatchSetSelection([EntryFor(target)], target);
-        }
-    }
-
-    private void ApplySelectedFilter(ResolvedEvent selectedEvent, EventProperty property, bool exclude)
-    {
-        if (CellFilterBuilder.TryBuild(selectedEvent, property, exclude, out var filter))
-        {
-            FilterPaneCommands.SetFilter(filter);
-        }
-    }
-
-    private IReadOnlyList<SelectionEntry> BuildRange(EventLocator anchor, EventLocator selected)
-    {
-        int anchorIndex = RowIndexOf(anchor);
-        int activeIndex = RowIndexOf(selected);
-
-        if (anchorIndex < 0 || activeIndex < 0) { return [EntryFor(selected)]; }
-
-        int start = Math.Min(anchorIndex, activeIndex);
-        int end = Math.Max(anchorIndex, activeIndex);
-
-        var slice = _activeDisplayedEvents.Slice(start, end - start + 1);
-        var range = new List<SelectionEntry>(slice.Count);
-
-        foreach (var row in slice) { range.Add(EntryFor(row)); }
-
-        return range;
-    }
-
-    private void DispatchSetSelection(IReadOnlyList<SelectionEntry> entries, EventLocator? focus, bool alreadyOrdered = false)
-    {
-        SelectionEntry? focusEntry = focus is { } focusLocator ? EntryFor(focusLocator) : null;
-
-        // These callers pass ordered, unique entries; skip rank + sort.
-        if (alreadyOrdered)
-        {
-            EventLogCommands.SetSelectedEvents(entries, focusEntry);
-
-            return;
-        }
-
-        var seen = new HashSet<EventLocator>();
-        List<(SelectionEntry Entry, int Index)> inTable = new(entries.Count);
-        List<SelectionEntry> outOfTable = [];
-
-        foreach (var entry in entries)
-        {
-            // Dedupe by OriginHandle (the selection's stable identity); order by the live CurrentHandle position.
-            if (!seen.Add(entry.OriginHandle)) { continue; }
-
-            int index = entry.CurrentHandle is { } handle ? RowIndexOf(handle) : -1;
-
-            if (index >= 0)
-            {
-                inTable.Add((entry, index));
-            }
-            else
-            {
-                outOfTable.Add(entry);
-            }
-        }
-
-        inTable.Sort(static (left, right) => left.Index.CompareTo(right.Index));
-
-        var ordered = new List<SelectionEntry>(inTable.Count + outOfTable.Count);
-
-        foreach (var entry in inTable) { ordered.Add(entry.Entry); }
-
-        ordered.AddRange(outOfTable);
-
-        EventLogCommands.SetSelectedEvents(ordered, focusEntry);
-    }
-
-    // Builds a selection entry from a bare locator; rehydrates the lean row to mint the ReloadKey.
-    private SelectionEntry EntryFor(EventLocator locator) =>
-        new(
-            locator,
-            locator,
-            ValueKey.TryCreate(_activeDisplayedEvents.GetDetailLean(locator), out var key) ? key : null);
-
-    private async Task FocusActiveRow()
-    {
-        int visibleRow = ResolveCursorVisibleRow();
-
-        try
-        {
-            if (_tableModule is null) { return; }
-
-            // No cursor row to land on (e.g. closing Find over an empty table): focus the scroll container so keyboard nav isn't stranded on a removed element.
-            if (visibleRow < 0)
-            {
-                await _tableModule.InvokeVoidAsync("focusTableContainer");
-
-                return;
-            }
-
-            await _tableModule.InvokeVoidAsync("focusEventTableRow", visibleRow);
-        }
-        catch (JSDisconnectedException) { /* Circuit gone; focus best-effort during teardown. */ }
-        catch (Exception e)
-        {
-            TraceLogger.Warning($"Failed to focus active table row: {e}");
-        }
-    }
-
-    private int GetAriaRowCount() => (_rowView?.Count ?? _activeDisplayedEvents.Count) + 1;
-
-    private int GetColumnWidth(ColumnName column) =>
-        _logTableState.ColumnWidths.TryGetValue(column, out int width) ? width : ColumnDefaults.GetColumnWidth(column);
-
-    private string GetCss(EventLocator loc) =>
-        _selectedSet.Contains(loc) ? "table-row selected" : "table-row";
-
-    private int GetCurrentVisibleRow(IEventColumnView displayedEvents)
-    {
-        int cursorRow = ResolveCursorVisibleRow();
-
-        if (cursorRow >= 0) { return cursorRow; }
-
-        if (_selection.Count > 0 && _selection[^1].CurrentHandle is { } fallback)
-        {
-            int fallbackIndex = RowIndexOf(fallback);
-
-            if (fallbackIndex >= 0)
-            {
-                return _rowView?.VisibleRowForEvent(fallbackIndex) ?? fallbackIndex;
-            }
-        }
-
-        int count = _rowView?.Count ?? displayedEvents.Count;
-
-        return count > 0 ? 0 : -1;
-    }
-
-    private string GetDateColumnHeader() =>
-        EventTableColumnFormatter.GetColumnHeader(ColumnName.DateAndTime, Settings.TimeZoneInfo);
-
-    private string GetGroupName() => _logTableState.GroupBy?.ToFullString() ?? string.Empty;
-
-    private string GetGroupValueText(EventGroup group)
-    {
-        if (group.EventCount == 0) { return "(none)"; }
-
-        // M2: rehydrate the representative row (lean suffices for these header columns) and run the timezone/culture
-        // switch. Do NOT read GroupKeyAt here: its canonical key text is not the display header text.
-        var representative = _activeDisplayedEvents.GetDetailLean(_activeDisplayedEvents.LocatorAt(group.StartIndex));
-
-        string? value = _logTableState.GroupBy switch
-        {
-            ColumnName.RecordId => representative.RecordId?.ToString(),
-            ColumnName.Level => representative.Level,
-            ColumnName.DateAndTime => representative.TimeCreated.ConvertTimeZone(_timeZoneSettings).ToString(),
-            ColumnName.ActivityId => representative.ActivityId?.ToString(),
-            ColumnName.Log => representative.LogName,
-            ColumnName.ComputerName => representative.ComputerName,
-            ColumnName.Source => representative.Source,
-            ColumnName.EventId => representative.Id.ToString(),
-            ColumnName.TaskCategory => representative.TaskCategory,
-            ColumnName.Keywords => representative.KeywordsDisplayName,
-            ColumnName.ProcessId => representative.ProcessId?.ToString(),
-            ColumnName.ThreadId => representative.ThreadId?.ToString(),
-            ColumnName.User => representative.UserId?.ToString(),
-            _ => null
-        };
-
-        return string.IsNullOrEmpty(value) ? "(none)" : value;
-    }
-
-    private string? GetHighlight(DisplayRow row)
-    {
-        if (_selectedSet.Contains(row.Loc)) { return null; }
-
-        if (_highlightCache.TryGetValue(row.Loc, out var cached)) { return cached; }
-
-        if (_activeHighlightFilters.Length == 0)
-        {
-            _highlightCache[row.Loc] = null;
-
-            return null;
-        }
-
-        string? color = null;
-        // Highlight filters can reference EventData, so evaluate against the full rehydrated event; the result is
-        // cached per locator (stable within a generation) so the rehydrate happens at most once per physical row.
-        // Resolve defensively: during a tab switch or reload the virtualized rows can momentarily carry a locator from
-        // the prior view/generation. A stale row yields no highlight this frame and recomputes once the view
-        // reconciles - far better than throwing out of the render tree.
-        if (!_activeDisplayedEvents.TryGetDetail(row.Loc, out var detail)) { return null; }
-
-        foreach (var filter in _activeHighlightFilters)
-        {
-            if (!filter.Compiled!.Predicate(detail)) { continue; }
-
-            color = filter.Color.ToCssName();
-
-            break;
-        }
-
-        _highlightCache[row.Loc] = color;
-
-        return color;
-    }
-
-    private ColumnName[] GetOrderedEnabledColumns() =>
-        [.. _logTableState.GetOrderedEnabledColumns(ColumnDefaults)];
-
-    private int GetRowIndex(EventLocator loc)
-    {
-        int index = RowIndexOf(loc);
-
-        if (index < 0) { return 2; }
-
-        return (_rowView?.VisibleRowForEvent(index) ?? index) + 2;
-    }
-
-    private int GetRowStripe(EventLocator loc)
-    {
-        int index = RowIndexOf(loc);
-
-        if (index < 0) { return 0; }
-
-        if (_rowView is null) { return index % 2; }
-
-        return (index - _rowView.GroupForEvent(index).StartIndex) % 2;
-    }
-
-    private async Task HandleKeyDown(KeyboardEventArgs args)
-    {
-        // Esc closes an open Find here BEFORE the selection-clearing Escape branch below, so closing Find never wipes the user's selection.
-        if (_findOpen && args.Code == "Escape")
-        {
-            await CloseFind();
-
-            return;
-        }
-
-        var displayedEvents = _activeDisplayedEvents;
-
-        if (displayedEvents.Count == 0) { return; }
-
-        if (args is { CtrlKey: true, Code: "KeyC" })
-        {
-            await ClipboardService.CopySelectedEvent();
-
-            return;
-        }
-
-        if (args is { CtrlKey: true, Code: "KeyA" })
-        {
-            int total = displayedEvents.Count;
-            var lastLocator = displayedEvents.LocatorAt(total - 1);
-            _selectionAnchor = displayedEvents.LocatorAt(0);
-            SetCursorEvent(lastLocator);
-
-            var allRows = displayedEvents.Slice(0, total);
-            var allEntries = new List<SelectionEntry>(allRows.Count);
-
-            foreach (var row in allRows) { allEntries.Add(EntryFor(row)); }
-
-            DispatchSetSelection(allEntries, lastLocator, alreadyOrdered: true);
-
-            return;
-        }
-
-        if (args.Code == "Escape")
-        {
-            _selectionAnchor = null;
-            SetCursor(null);
-            DispatchSetSelection([], null);
-
-            return;
-        }
-
-        if (_rowView is not null)
-        {
-            if (args.Code is "ArrowLeft")
-            {
-                HandleTreegridLeft();
-
-                return;
-            }
-
-            if (args.Code is "ArrowRight")
-            {
-                HandleTreegridRight();
-
-                return;
-            }
-
-            if (args.Key is "Enter")
-            {
-                if (_cursor is { Kind: TableRowKind.Header, GroupKey: { } enterKey })
-                {
-                    ToggleGroupCollapsed(enterKey);
-                    _focusActiveOnNextRender = true;
-                }
-
-                return;
-            }
-        }
-
-        int count = _rowView?.Count ?? displayedEvents.Count;
-        int currentRow = GetCurrentVisibleRow(displayedEvents);
-        int targetRow;
-        int scanDirection;
-
-        switch (args.Code)
-        {
-            case "ArrowUp":
-                targetRow = Math.Max(0, currentRow - 1);
-                scanDirection = -1;
-                break;
-            case "ArrowDown":
-                targetRow = Math.Min(count - 1, currentRow + 1);
-                scanDirection = 1;
-                break;
-            case "PageUp":
-            case "PageDown":
-                int liveStep = await TryRefreshPageSize();
-                int step = liveStep > 0 ? liveStep : _pageSize;
-
-                if (args.Code == "PageUp")
-                {
-                    targetRow = Math.Max(0, currentRow - step);
-                    scanDirection = -1;
-                }
-                else
-                {
-                    targetRow = Math.Min(count - 1, currentRow + step);
-                    scanDirection = 1;
-                }
-
-                break;
-            case "Home":
-                targetRow = 0;
-                scanDirection = 1;
-                break;
-            case "End":
-                targetRow = count - 1;
-                scanDirection = -1;
-                break;
-            default:
-                return;
-        }
-
-        if (targetRow == currentRow && _cursor is not null) { return; }
-
-        if (_rowView is null)
-        {
-            ApplyNavSelection(displayedEvents.LocatorAt(targetRow), args.ShiftKey);
-            _focusActiveOnNextRender = true;
-
-            return;
-        }
-
-        NavigateGroupedTo(targetRow, scanDirection, args.ShiftKey);
-    }
-
-    private void HandleTreegridLeft()
-    {
-        var view = _rowView;
-
-        if (view is null) { return; }
-
-        if (_cursor is { Kind: TableRowKind.Event, Handle: { } handle })
-        {
-            int index = RowIndexOf(handle);
-
-            if (index >= 0)
-            {
-                SetCursorHeader(view.GroupForEvent(index).Key);
-                _focusActiveOnNextRender = true;
-
-                return;
-            }
-        }
-
-        if (_cursor is { Kind: TableRowKind.Header, GroupKey: { } key } &&
-            view.TryGetGroupByKey(key, out var group) && !group.IsCollapsed)
-        {
-            ToggleGroupCollapsed(key);
-            _focusActiveOnNextRender = true;
-        }
-    }
-
-    private void HandleTreegridRight()
-    {
-        var view = _rowView;
-
-        if (view is null ||
-            _cursor is not { Kind: TableRowKind.Header, GroupKey: { } key } ||
-            !view.TryGetGroupByKey(key, out var group))
-        {
-            return;
-        }
-
-        if (group.IsCollapsed)
-        {
-            ToggleGroupCollapsed(key);
-            _focusActiveOnNextRender = true;
-
-            return;
-        }
-
-        if (group.EventCount > 0)
-        {
-            var firstLocator = _activeDisplayedEvents.LocatorAt(group.StartIndex);
-            _selectionAnchor = firstLocator;
-            SetCursorEvent(firstLocator);
-            DispatchSetSelection([EntryFor(firstLocator)], firstLocator);
-            _focusActiveOnNextRender = true;
-        }
-    }
-
-    private async Task InitializeTableEventHandlers()
-    {
-        _dotNetRef?.Dispose();
-        _dotNetRef = DotNetObjectReference.Create(this);
-
-        _tableModule ??= await JSRuntime.InvokeAsync<IJSObjectReference>(
-            "import",
-            "./_content/EventLogExpert.UI/LogTable/LogTablePane.razor.js");
-
-        await _tableModule.InvokeVoidAsync("initializeTableEvents", _dotNetRef);
-    }
-
-    private void InvokeCellContextMenu(MouseEventArgs args, DisplayRow row, ColumnName? column)
-    {
-        // A stale row (mid tab-switch/reload) has no resolvable detail; skip the menu rather than throw.
-        if (!_activeDisplayedEvents.TryGetDetail(row.Loc, out var detail)) { return; }
-
-        var items = new List<MenuItem>();
-
-        AppendCellFilterItems(items, detail, column);
-        items.AddRange(ShowContextMenuItems(detail));
-
-        MenuService.OpenAt(args.ClientX, args.ClientY, items);
-    }
-
-    private void InvokeContextMenu(MouseEventArgs args)
-    {
-        if (Focus.Value?.CurrentHandle is not { } handle) { return; }
-
-        if (!_activeDisplayedEvents.TryGetDetail(handle, out var clicked)) { return; }
-
-        MenuService.OpenAt(args.ClientX, args.ClientY, ShowContextMenuItems(clicked));
-    }
-
-    private void InvokeGroupContextMenu(MouseEventArgs args, EventGroup group)
-    {
-        SetCursorHeader(group.Key);
-        MenuService.OpenAt(args.ClientX, args.ClientY, ShowGroupContextMenuItems(group));
-    }
-
-    private void InvokeTableColumnMenu(MouseEventArgs args) =>
-        MenuService.OpenAt(args.ClientX, args.ClientY, ShowColumnMenuItems());
-
-    private bool IsSelectionOutOfSortOrder(IReadOnlyList<SelectionEntry> selection)
-    {
-        int lastIndex = -1;
-
-        foreach (var entry in selection)
-        {
-            int index = entry.CurrentHandle is { } handle ? RowIndexOf(handle) : -1;
-
-            if (index < 0) { continue; }
-
-            if (index < lastIndex) { return true; }
-
-            lastIndex = index;
-        }
-
-        return false;
-    }
-
-    private ValueTask<ItemsProviderResult<DisplayRow>> LoadEventViewport(ItemsProviderRequest request) =>
-        ValueTask.FromResult(ComputeEventViewport(_activeDisplayedEvents, request));
-
-    private void NavigateGroupedTo(
-        int targetRow,
-        int scanDirection,
-        bool shift)
-    {
-        var view = _rowView!;
-        var row = view[targetRow];
-
-        if (row.Kind == TableRowKind.Event)
-        {
-            ApplyNavSelection(view.LocatorAt(row), shift);
-            _focusActiveOnNextRender = true;
-
-            return;
-        }
-
-        if (!shift)
-        {
-            SetCursorHeader(view.GroupAt(row).Key);
-            _focusActiveOnNextRender = true;
-
-            return;
-        }
-
-        int probe = targetRow;
-
-        while (probe >= 0 && probe < view.Count && view[probe].Kind == TableRowKind.Header)
-        {
-            probe += scanDirection;
-        }
-
-        if (probe < 0 || probe >= view.Count) { return; }
-
-        ApplyNavSelection(view.LocatorAt(view[probe]), shift: true);
-        _focusActiveOnNextRender = true;
-    }
-
-    private TableCursor? NearestHeaderCursor(int priorVisibleRow)
-    {
-        var groups = _rowView!.Groups;
-
-        if (groups.Count == 0) { return null; }
-
-        foreach (var group in groups)
-        {
-            if (group.VisibleStart >= priorVisibleRow) { return TableCursor.ForHeader(group.Key); }
-        }
-
-        return TableCursor.ForHeader(groups[^1].Key);
-    }
-
-    // Retype an event in a collapsed group to its header.
-    private TableCursor? NormalizeCursor(TableCursor? cursor)
-    {
-        if (_rowView is not { } view ||
-            cursor is not { Kind: TableRowKind.Event, Handle: { } handle })
-        {
-            return cursor;
-        }
-
-        int index = RowIndexOf(handle);
-
-        if (index < 0) { return cursor; }
-
-        var group = view.GroupForEvent(index);
-
-        if (group.IsCollapsed) { return TableCursor.ForHeader(group.Key); }
-
-        return cursor;
-    }
-
-    private void RebuildGroupedRowView(IEventColumnView displayedEvents)
-    {
-        var state = _logTableState;
-
-        if (state.GroupBy is not { } groupBy)
-        {
-            EventLocator? formerGroupFirstLocator = null;
-
-            if (_rowView is { } priorView &&
-                _cursor is { Kind: TableRowKind.Header, GroupKey: { } headerKey } &&
-                priorView.TryGetGroupByKey(headerKey, out var priorGroup) && priorGroup.EventCount > 0)
-            {
-                formerGroupFirstLocator = priorView.FirstLocatorOf(priorGroup);
-            }
-
-            _rowView = null;
-            _rowViewSnapshot = default;
-
-            if (formerGroupFirstLocator is not null)
-            {
-                SetCursorEvent(formerGroupFirstLocator);
-            }
-
-            return;
-        }
-
-        var snapshot = (displayedEvents, _currentTable?.Id, state.GroupBy, state.IsGroupDescending,
-            state.GroupsCollapsedByDefault, (ImmutableHashSet<string>?)state.GroupCollapseOverrides);
-
-        if (_rowView is not null && _rowViewSnapshot.Equals(snapshot)) { return; }
-
-        int priorHeaderRow = _cursor is { Kind: TableRowKind.Header } ? ResolveCursorVisibleRow() : -1;
-
-        _rowViewSnapshot = snapshot;
-        _rowView = GroupedRowView.Build(displayedEvents, groupBy, state.IsGroupCollapsed);
-
-        ReconcileGroupedCursor(priorHeaderRow);
-    }
-
-    private void RebuildRowMaps()
-    {
-        var displayedEvents = ResolveActiveDisplayedEvents();
-        _activeDisplayedEvents = displayedEvents;
-
-        // Drop Find's group-expansion ownership when the group-key namespace (active table / GroupBy) has changed.
-        PruneFindGroupOwnershipOnContextChange();
-
-        var currentTableId = _currentTable?.Id;
-
-        // Highlight results are keyed by locator (stable within a generation across re-sorts). A reload mints a new
-        // EventLogId, so clear the cache only when the active table identity changes, bounding growth without discarding
-        // still-valid entries on every re-sort.
-        if (!Equals(currentTableId, _highlightCacheTableId))
-        {
-            _highlightCacheTableId = currentTableId;
-            _highlightCache.Clear();
-        }
-
-        if (!ReferenceEquals(displayedEvents, _lastIndexedDisplayedEvents))
-        {
-            _lastIndexedDisplayedEvents = displayedEvents;
-            _refreshEventViewportOnRender = true;
-
-            // The event set changed (filter/sort/append/reload) so prior Find matches are stale; collapse/regroup keep the same reference and deliberately don't reach here.
-            NotifyFindViewChanged();
-
-            if (displayedEvents.Count == 0)
-            {
-                _selectionAnchor = null;
-                _cursor = null;
-            }
-            else
-            {
-                // Locators are physical positions within a generation: a re-sort keeps them valid (Rank >= 0); a
-                // reload invalidates them (wrong generation, Rank -1), dropping the stale anchor/cursor.
-                if (_selectionAnchor is { } anchor && displayedEvents.Rank(anchor) < 0)
-                {
-                    _selectionAnchor = null;
-                }
-
-                if (_cursor is { Kind: TableRowKind.Event, Handle: { } cursorHandle } &&
-                    displayedEvents.Rank(cursorHandle) < 0)
-                {
-                    _cursor = null;
-                }
-
-                if (IsSelectionOutOfSortOrder(_selection))
-                {
-                    _resortSelectionOnNextRender = true;
-                }
-            }
-        }
-
-        // Outside the events-ref guard: collapse toggles keep the same reference.
-        RebuildGroupedRowView(displayedEvents);
-    }
-
-    private void ReconcileGroupedCursor(int priorHeaderRow)
-    {
-        if (_rowView is not { } view || _cursor is not { } cursor) { return; }
-
-        if (cursor is { Kind: TableRowKind.Event, Handle: { } handle })
-        {
-            int index = RowIndexOf(handle);
-
-            if (index >= 0)
-            {
-                var group = view.GroupForEvent(index);
-
-                if (group.IsCollapsed) { _cursor = TableCursor.ForHeader(group.Key); }
-            }
-            else
-            {
-                _cursor = null;
-            }
-
-            return;
-        }
-
-        if (cursor is { Kind: TableRowKind.Header, GroupKey: { } key } && !view.TryGetGroupByKey(key, out _))
-        {
-            _cursor = NearestHeaderCursor(priorHeaderRow);
-        }
-    }
-
-    private void RescrollToSelected() =>
-        _ = InvokeAsync(() =>
-        {
-            _rescrollToSelectedOnRender = true;
-            StateHasChanged();
-        });
-
-    private IEventColumnView ResolveActiveDisplayedEvents() =>
-        _currentTable is null ? s_emptyView : _logTableState.DisplayedEventsForTab(_currentTable);
-
-    private int ResolveCursorVisibleRow()
-    {
-        if (_cursor is { Kind: TableRowKind.Header, GroupKey: { } key })
-        {
-            return _rowView?.VisibleRowForHeader(key) ?? -1;
-        }
-
-        if (_cursor is { Kind: TableRowKind.Event, Handle: { } handle })
-        {
-            int index = RowIndexOf(handle);
-
-            if (index >= 0)
-            {
-                return _rowView?.VisibleRowForEvent(index) ?? index;
-            }
-        }
-
-        return -1;
-    }
-
-    private void ResortSelectionForCurrentTable()
-    {
-        DispatchSetSelection(_selection, ActiveHandle ?? _focus?.CurrentHandle);
-    }
-
-    private int RowIndexOf(EventLocator locator) => _activeDisplayedEvents.Rank(locator);
-
-    private async Task ScrollToSelectedEvent()
-    {
-        var target = ActiveHandle
-            ?? _focus?.CurrentHandle
-            ?? (_selection.Count > 0 ? _selection[^1].CurrentHandle : null);
-
-        if (target is not { } handle) { return; }
-
-        if (_activeDisplayedEvents.Count == 0) { return; }
-
-        // Locators are live positions within the current generation; no value-key re-resolve is needed.
-        int index = RowIndexOf(handle);
-
-        if (index < 0) { return; }
-
-        int targetRow = _rowView?.VisibleRowForEvent(index) ?? index;
-
-        if (_tableModule is not null) { await _tableModule.InvokeVoidAsync("scrollToRow", targetRow); }
-    }
-
-    private void SelectEvent(MouseEventArgs args, DisplayRow row)
-    {
-        var displayedEvents = _activeDisplayedEvents;
-
-        switch (args)
-        {
-            case { ShiftKey: true } when displayedEvents.Count > 0:
-                if (_selectionAnchor is null)
-                {
-                    _selectionAnchor = row.Loc;
-                    SetCursorEvent(row.Loc);
-                    DispatchSetSelection([EntryFor(row)], row.Loc);
-
-                    return;
-                }
-
-                SetCursorEvent(row.Loc);
-                var range = BuildRange(_selectionAnchor.Value, row.Loc);
-
-                if (args.CtrlKey)
-                {
-                    var merged = new List<SelectionEntry>(_selection.Count + range.Count);
-                    merged.AddRange(_selection);
-                    merged.AddRange(range);
-                    DispatchSetSelection(merged, row.Loc);
-                }
-                else
-                {
-                    DispatchSetSelection(range, row.Loc, alreadyOrdered: true);
-                }
-
-                return;
-
-            case { CtrlKey: true }:
-                _selectionAnchor = row.Loc;
-                SetCursorEvent(row.Loc);
-
-                if (_selectedSet.Contains(row.Loc))
-                {
-                    var remaining = new List<SelectionEntry>(_selection.Count);
-
-                    foreach (var existing in _selection)
-                    {
-                        // Toggle off by live position (CurrentHandle), not OriginHandle; they differ after a reload.
-                        if (existing.CurrentHandle != row.Loc) { remaining.Add(existing); }
-                    }
-
-                    DispatchSetSelection(remaining, row.Loc);
-                }
-                else
-                {
-                    var combined = new List<SelectionEntry>(_selection.Count + 1);
-                    combined.AddRange(_selection);
-                    combined.Add(EntryFor(row));
-                    DispatchSetSelection(combined, row.Loc);
-                }
-
-                return;
-
-            default:
-                if (args.Button == 2 && _selectedSet.Contains(row.Loc))
-                {
-                    SetCursorEvent(row.Loc);
-                    DispatchSetSelection(_selection, row.Loc);
-
-                    return;
-                }
-
-                _selectionAnchor = row.Loc;
-                SetCursorEvent(row.Loc);
-                DispatchSetSelection([EntryFor(row)], row.Loc);
-
-                return;
-        }
-    }
-
-    private void SelectGroup(EventGroup group)
-    {
-        if (group.EventCount == 0 ||
-            group.StartIndex + group.EventCount > _activeDisplayedEvents.Count)
-        {
-            return;
-        }
-
-        var members = _activeDisplayedEvents.Slice(group.StartIndex, group.EventCount);
-        var entries = new List<SelectionEntry>(members.Count);
-
-        foreach (var row in members) { entries.Add(EntryFor(row)); }
-
-        var activeLocator = members[0].Loc;
-        _selectionAnchor = activeLocator;
-        SetCursorEvent(activeLocator);
-        DispatchSetSelection(entries, activeLocator, alreadyOrdered: true);
-    }
-
-    private void SelectGroupByKey(string key)
-    {
-        if (_rowView is null || !_rowView.TryGetGroupByKey(key, out var group)) { return; }
-
-        SelectGroup(group);
-    }
-
-    private void SetCursor(TableCursor? cursor) => _cursor = NormalizeCursor(cursor);
-
-    private void SetCursorEvent(EventLocator? handle) =>
-        SetCursor(handle is { } locator ? TableCursor.ForEvent(locator) : null);
-
-    private void SetCursorHeader(string groupKey) => SetCursor(TableCursor.ForHeader(groupKey));
-
-    private void SetGroupCollapsed(string key, bool collapse)
-    {
-        if (_rowView is null || !_rowView.TryGetGroupByKey(key, out _)) { return; }
-
-        if (LogTableState.Value.IsGroupCollapsed(key) != collapse)
-        {
-            LogTableCommands.ToggleGroupCollapsed(key);
-        }
-    }
-
-    private IReadOnlyList<MenuItem> ShowColumnMenuItems()
-    {
-        var state = LogTableState.Value;
-        var items = new List<MenuItem>();
-
-        foreach (var (column, isVisible) in state.Columns)
-        {
-            var capturedColumn = column;
-            items.Add(MenuItem.Item(
-                column.ToFullString(),
-                () => LogTableCommands.ToggleColumn(capturedColumn),
-                isChecked: isVisible));
-        }
-
-        items.Add(MenuItem.Separator());
-
-        var orderItems = new List<MenuItem>();
-        foreach (var (column, _) in state.Columns)
-        {
-            var capturedColumn = column;
-            orderItems.Add(MenuItem.Item(
-                column.ToFullString(),
-                () => LogTableCommands.SetOrderBy(capturedColumn),
-                isChecked: state.OrderBy.Equals(capturedColumn)));
-        }
-
-        items.Add(MenuItem.SubMenu("Order By", orderItems));
-
-        var groupItems = new List<MenuItem>
-        {
-            MenuItem.Item(
-                "(none)",
-                () => { if (state.GroupBy is not null) { LogTableCommands.SetGroupBy(null); } },
-                isChecked: state.GroupBy is null)
-        };
-
-        foreach (var (column, _) in state.Columns)
-        {
-            var capturedColumn = column;
-            groupItems.Add(MenuItem.Item(
-                column.ToFullString(),
-                () => { if (!state.GroupBy.Equals(capturedColumn)) { LogTableCommands.SetGroupBy(capturedColumn); } },
-                isChecked: state.GroupBy.Equals(capturedColumn)));
-        }
-
-        items.Add(MenuItem.SubMenu("Group By", groupItems));
-
-        items.Add(MenuItem.Separator());
-        items.Add(MenuItem.Item(
-            "Reset Column Defaults",
-            () => LogTableCommands.ResetColumnDefaults()));
-
-        return items;
-    }
-
-    private IReadOnlyList<MenuItem> ShowContextMenuItems(ResolvedEvent selectedEvent)
-    {
-        return
-        [
-            MenuItem.Item("Copy Selected", () => ClipboardService.CopySelectedEvent(EventCopyFormat.Default)),
-            MenuItem.Item("Copy Selected (Simple)", () => ClipboardService.CopySelectedEvent(EventCopyFormat.Simple)),
-            MenuItem.Item("Copy Selected (XML)", () => ClipboardService.CopySelectedEvent(EventCopyFormat.Xml)),
-            MenuItem.Item("Copy Selected (Full)", () => ClipboardService.CopySelectedEvent(EventCopyFormat.Full)),
-            MenuItem.Separator(),
-            MenuItem.Item("Exclude Events Before", () =>
-                FilterPaneCommands.SetFilterDateRange(
-                    new DateFilter { Before = selectedEvent.TimeCreated })),
-            MenuItem.Item("Exclude Events After", () =>
-                FilterPaneCommands.SetFilterDateRange(
-                    new DateFilter { After = selectedEvent.TimeCreated })),
-            MenuItem.Separator(),
-            MenuItem.Item(
-                "Show Related by Activity ID",
-                () => FilterLensCommands.ShowRelatedByActivityId(selectedEvent.ActivityId, selectedEvent.OwningLog),
-                isEnabled: selectedEvent.ActivityId.HasValue,
-                disabledReason: selectedEvent.ActivityId.HasValue ? null : "This event has no Activity ID."),
-            MenuItem.Item(
-                "Show Events Sharing Related Activity ID",
-                () => FilterLensCommands.ShowRelatedByRelatedActivityId(selectedEvent.RelatedActivityId, selectedEvent.OwningLog),
-                isEnabled: selectedEvent.RelatedActivityId.HasValue,
-                disabledReason: selectedEvent.RelatedActivityId.HasValue ? null : "This event has no Related Activity ID."),
-            MenuItem.Item(
-                "Show Parent Activity",
-                () => FilterLensCommands.ShowParentActivity(selectedEvent.RelatedActivityId, selectedEvent.OwningLog),
-                isEnabled: selectedEvent.RelatedActivityId.HasValue,
-                disabledReason: selectedEvent.RelatedActivityId.HasValue ? null : "This event has no Related Activity ID."),
-            MenuItem.SubMenu(
-                "Show Events Near This Time",
-                [
-                    MenuItem.Item(
-                        "\u00b130 Seconds",
-                        () => FilterLensCommands.ShowEventsNearTime(
-                            selectedEvent.TimeCreated, TimeSpan.FromSeconds(30), Settings.TimeZoneInfo, selectedEvent.OwningLog)),
-                    MenuItem.Item(
-                        "\u00b11 Minute",
-                        () => FilterLensCommands.ShowEventsNearTime(
-                            selectedEvent.TimeCreated, TimeSpan.FromMinutes(1), Settings.TimeZoneInfo, selectedEvent.OwningLog)),
-                    MenuItem.Item(
-                        "\u00b15 Minutes",
-                        () => FilterLensCommands.ShowEventsNearTime(
-                            selectedEvent.TimeCreated, TimeSpan.FromMinutes(5), Settings.TimeZoneInfo, selectedEvent.OwningLog)),
-                    MenuItem.Item(
-                        "\u00b115 Minutes",
-                        () => FilterLensCommands.ShowEventsNearTime(
-                            selectedEvent.TimeCreated, TimeSpan.FromMinutes(15), Settings.TimeZoneInfo, selectedEvent.OwningLog)),
-                    MenuItem.Item(
-                        "\u00b11 Hour",
-                        () => FilterLensCommands.ShowEventsNearTime(
-                            selectedEvent.TimeCreated, TimeSpan.FromHours(1), Settings.TimeZoneInfo, selectedEvent.OwningLog)),
-                ]),
-            MenuItem.Separator(),
-            MenuItem.SubMenu(
-                "More Fields",
-                [
-                    MenuItem.SubMenu("Include", ShowEventFieldItems(selectedEvent, false)),
-                    MenuItem.SubMenu("Exclude", ShowEventFieldItems(selectedEvent, true)),
-                ]),
-        ];
-    }
-
-    private IReadOnlyList<MenuItem> ShowEventFieldItems(ResolvedEvent selectedEvent, bool exclude)
-    {
-        var items = new List<MenuItem>();
-
-        foreach (EventProperty property in Enum.GetValues<EventProperty>())
-        {
-            if (property is EventProperty.Description or EventProperty.Xml) { continue; }
-
-            var capturedProperty = property;
-            bool hasValue = CellFilterBuilder.TryGetDisplayValue(selectedEvent, property, out _);
-
-            items.Add(MenuItem.Item(
-                property.ToFullString(),
-                () => ApplySelectedFilter(selectedEvent, capturedProperty, exclude),
-                isEnabled: hasValue,
-                disabledReason: hasValue ? null : NoCellValueReason));
-        }
-
-        return items;
-    }
-
-    private IReadOnlyList<MenuItem> ShowGroupContextMenuItems(EventGroup group)
-    {
-        bool collapsedNow = LogTableState.Value.IsGroupCollapsed(group.Key);
-
-        return
-        [
-            MenuItem.Item(
-                collapsedNow ? "Expand Group" : "Collapse Group",
-                () => UserSetGroupCollapsed(group.Key, !collapsedNow)),
-            MenuItem.Item("Expand All Groups", () => LogTableCommands.SetAllGroupsCollapsed(false)),
-            MenuItem.Item("Collapse All Groups", () => LogTableCommands.SetAllGroupsCollapsed(true)),
-            MenuItem.Separator(),
-            MenuItem.Item(
-                "Group Descending",
-                () => LogTableCommands.ToggleGroupSortDirection(),
-                isChecked: LogTableState.Value.IsGroupDescending),
-            MenuItem.Separator(),
-            MenuItem.Item("Select Group", () => SelectGroupByKey(group.Key)),
-        ];
-    }
-
-    private void ToggleGroupCollapsed(string groupKey)
-    {
-        // A manual toggle of a Find-expanded group hands ownership back to the user, so Find will not later re-collapse it.
-        _findExpandedGroupKeys.Remove(groupKey);
-        LogTableCommands.ToggleGroupCollapsed(groupKey);
-    }
-
-    private void ToggleSorting() => LogTableCommands.ToggleSortDirection();
-
-    private async Task<int> TryRefreshPageSize()
-    {
-        try
-        {
-            int measured = _tableModule is not null ? await _tableModule.InvokeAsync<int>("getEventTablePageSize") : 0;
-
-            if (measured > 0) { _pageSize = measured; }
-
-            return measured;
-        }
-        catch (JSDisconnectedException) { return 0; }
-        catch (Exception e)
-        {
-            TraceLogger.Warning($"Failed to refresh table page size: {e}");
-
-            return 0;
-        }
-    }
-
-    private void WarnOnUnknownFilterColors(IEnumerable<SavedFilter> filters)
-    {
-        foreach (var filter in filters)
-        {
-            if (Enum.IsDefined(filter.Color)) { continue; }
-
-            int rawValue = (int)filter.Color;
-            bool shouldWarn;
-
-            lock (s_warnedUnknownColors)
-            {
-                shouldWarn = s_warnedUnknownColors.Add(rawValue);
-            }
-
-            if (shouldWarn)
-            {
-                TraceLogger.Warning(
-                    $"Unknown HighlightColor value {rawValue} found in filter set; affected filters will be skipped for highlight resolution.");
-            }
-        }
-    }
-}
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
+using EventLogExpert.Filtering.Common.Filtering;
+using EventLogExpert.Filtering.Compilation;
+using EventLogExpert.Filtering.Evaluation;
+using EventLogExpert.Filtering.Persistence;
+using EventLogExpert.Logging.Abstractions;
+using EventLogExpert.Runtime.Common.Clipboard;
+using EventLogExpert.Runtime.Common.Display;
+using EventLogExpert.Runtime.EventLog;
+using EventLogExpert.Runtime.FilterLenses;
+using EventLogExpert.Runtime.FilterPane;
+using EventLogExpert.Runtime.LogTable;
+using EventLogExpert.Runtime.Settings;
+using EventLogExpert.UI.Common;
+using EventLogExpert.UI.Common.Interop;
+using EventLogExpert.UI.LogTable.Grouping;
+using EventLogExpert.UI.Menu;
+using Microsoft.AspNetCore.Components;
+using Microsoft.AspNetCore.Components.Web;
+using Microsoft.AspNetCore.Components.Web.Virtualization;
+using Microsoft.JSInterop;
+using System.Collections.Immutable;
+
+namespace EventLogExpert.UI.LogTable;
+
+public sealed partial class LogTablePane
+{
+    private const int DefaultPageSize = 20;
+    private const float EventRowHeightPixels = 22f;
+    private const int MenuValueMaxLength = 40;
+    private const string NoCellValueReason = "No value in this cell to filter on";
+
+    private static readonly IEventColumnView s_emptyView = LogTableState.EmptyView;
+    private static readonly HashSet<int> s_warnedUnknownColors = [];
+
+    private readonly Dictionary<EventLocator, string?> _highlightCache = [];
+
+    private IEventColumnView _activeDisplayedEvents = s_emptyView;
+    private SavedFilter[] _activeHighlightFilters = [];
+    private bool _busyAssertedOnLastPaint;
+    private bool _busyHeldForRefresh;
+    private TableCursor? _cursor;
+    private bool _disposed;
+    private DotNetObjectReference<LogTablePane>? _dotNetRef;
+    private ColumnName[] _enabledColumns = null!;
+    private Virtualize<DisplayRow>? _eventVirtualize;
+    private ImmutableList<SavedFilter> _filters = [];
+    private int _filtersHighlightKey;
+    private SelectionEntry? _focus;
+    private bool _focusActiveOnNextRender;
+    private string _headerName = string.Empty;
+    private EventLogId? _highlightCacheTableId;
+    private DisplayedIndicator _indicator = DisplayedIndicator.Nothing;
+    private bool _indicatorRenderRequested;
+    private DisplayIndicatorState _indicatorState = null!;
+    private IEventColumnView? _lastIndexedDisplayedEvents;
+    private int _pageSize = DefaultPageSize;
+    private ColumnName[] _previousEnabledColumns = [];
+    private bool _refreshEventViewportOnRender;
+    private long _renderedPresentationRevision = -1;
+    private bool _rescrollToSelectedOnRender;
+    private IEventColumnView? _rescrolledForView;
+    private bool _resortSelectionOnNextRender;
+    private GroupedRowView? _rowView;
+    private (IEventColumnView View, EventLogId? TableId, ColumnName? GroupBy, bool GroupDescending, bool CollapsedDefault, ImmutableHashSet<string>? Overrides) _rowViewSnapshot;
+    private HashSet<EventLocator> _selectedSet = [];
+    private ImmutableList<SelectionEntry> _selection = [];
+    private EventLocator? _selectionAnchor;
+    private IJSObjectReference? _tableModule;
+    private TimeZoneInfo _timeZoneSettings = null!;
+    private bool _viewportRenderRequested;
+
+    private EventLocator? ActiveHandle =>
+        _cursor is { Kind: TableRowKind.Event, Handle: { } handle } ? handle : null;
+
+    [Inject] private IClipboardService ClipboardService { get; init; } = null!;
+
+    [Inject] private ILogTableColumnDefaultsProvider ColumnDefaults { get; init; } = null!;
+
+    [Inject] private IEventLogCommands EventLogCommands { get; init; } = null!;
+
+    [Inject] private IFilterLensCommands FilterLensCommands { get; init; } = null!;
+
+    [Inject] private IFilterPaneCommands FilterPaneCommands { get; init; } = null!;
+
+    [Inject] private IActiveFiltersSource FilterSelection { get; init; } = null!;
+
+    [Inject] private IFilterService FilterService { get; init; } = null!;
+
+    [Inject] private IEventFocusSource Focus { get; init; } = null!;
+
+    [Inject] private IGroupCollapseNotifier GroupCollapseNotifier { get; init; } = null!;
+
+    [Inject] private IHighlightSelector HighlightSelector { get; init; } = null!;
+
+    [Inject] private DisplayIndicatorGate IndicatorGate { get; init; } = null!;
+
+    [Inject] private IJSRuntime JSRuntime { get; init; } = null!;
+
+    [Inject] private ILogTableCommands LogTableCommands { get; init; } = null!;
+
+    [Inject] private IMenuService MenuService { get; init; } = null!;
+
+    [Inject] private IRevealFocusSource RevealFocusSource { get; init; } = null!;
+
+    [Inject] private IEventSelectionSource Selection { get; init; } = null!;
+
+    [Inject] private ISettingsService Settings { get; init; } = null!;
+
+    [Inject] private ITraceLogger TraceLogger { get; init; } = null!;
+
+    [JSInvokable]
+    public void OnColumnReordered(string columnName, string targetColumn, bool insertAfter)
+    {
+        if (Enum.TryParse<ColumnName>(columnName, out var column) &&
+            Enum.TryParse<ColumnName>(targetColumn, out var target))
+        {
+            LogTableCommands.ReorderColumn(column, target, insertAfter);
+        }
+    }
+
+    [JSInvokable]
+    public void OnColumnResized(string columnName, int width)
+    {
+        if (Enum.TryParse<ColumnName>(columnName, out var column))
+        {
+            LogTableCommands.SetColumnWidth(column, width);
+        }
+    }
+
+    internal static ItemsProviderResult<DisplayRow> ComputeEventViewport(
+        IEventColumnView displayedEvents,
+        ItemsProviderRequest request)
+    {
+        int totalCount = displayedEvents.Count;
+        int start = Math.Min(request.StartIndex, totalCount);
+        int count = Math.Min(request.Count, totalCount - start);
+
+        IReadOnlyList<DisplayRow> window =
+            count <= 0 ? [] : displayedEvents.Slice(start, count);
+
+        return new ItemsProviderResult<DisplayRow>(window, totalCount);
+    }
+
+    internal static string GetLevelClass(string level) => SeverityIcon.CssClass(LevelSeverity.FromLevelName(level));
+
+    protected override async ValueTask DisposeAsyncCore(bool disposing)
+    {
+        if (disposing)
+        {
+            _disposed = true;
+
+            Settings.TimeZoneChanged -= OnTimeZoneChanged;
+
+            DisposeFind();
+
+            _indicatorState?.Dispose();
+
+            await JsModuleInterop.DisposeModuleSafelyAsync(
+                _tableModule,
+                static module => module.InvokeVoidAsync("disposeTableEvents"));
+
+            _tableModule = null;
+
+            _dotNetRef?.Dispose();
+        }
+
+        await base.DisposeAsyncCore(disposing);
+    }
+
+    protected override async Task OnAfterRenderAsync(bool firstRender)
+    {
+        bool rescrollRequested = _rescrollToSelectedOnRender;
+        _rescrollToSelectedOnRender = false;
+
+        _busyAssertedOnLastPaint = IsGridBusy();
+
+        _indicatorState.RecordPaint(_indicator);
+
+        if (firstRender || !_enabledColumns.SequenceEqual(_previousEnabledColumns))
+        {
+            _previousEnabledColumns = _enabledColumns.ToArray();
+
+            try
+            {
+                await InitializeTableEventHandlers();
+            }
+            catch (Exception e)
+            {
+                TraceLogger.Error($"Failed to initialize table event handlers: {e}");
+            }
+        }
+
+        if (firstRender)
+        {
+            try
+            {
+                int measured = _tableModule is not null ? await _tableModule.InvokeAsync<int>("getEventTablePageSize") : 0;
+
+                if (measured > 0) { _pageSize = measured; }
+            }
+            catch (JSDisconnectedException) { /* Circuit gone; fall back to default page size. */ }
+            catch (Exception e)
+            {
+                TraceLogger.Warning($"Failed to measure table page size, using default {DefaultPageSize}: {e}");
+            }
+        }
+
+        if (_focusActiveOnNextRender)
+        {
+            _focusActiveOnNextRender = false;
+            await FocusActiveRow();
+        }
+
+        if (_resortSelectionOnNextRender)
+        {
+            _resortSelectionOnNextRender = false;
+            ResortSelectionForCurrentTable();
+        }
+
+        if (_refreshEventViewportOnRender)
+        {
+            _refreshEventViewportOnRender = false;
+
+            if (_rowView is null && _eventVirtualize is not null)
+            {
+                try
+                {
+                    await _eventVirtualize.RefreshDataAsync();
+                }
+                catch (JSDisconnectedException) { /* Circuit gone; nothing to refresh. */ }
+                catch (Exception e)
+                {
+                    TraceLogger.Error($"Failed to refresh the event viewport: {e}");
+                }
+                finally
+                {
+                    _busyHeldForRefresh = false;
+                    _viewportRenderRequested = true;
+
+                    StateHasChanged();
+                }
+            }
+            else
+            {
+                ReleaseBusyHeldForRefresh();
+            }
+        }
+
+        if (RevealFocusSource.Current is { } revealTarget)
+        {
+            var liveSelection = Selection.Current;
+            var currentFocusTarget = Focus.Current?.CurrentHandle
+                ?? (liveSelection.Count > 0 ? liveSelection[^1].CurrentHandle : null);
+
+            if (currentFocusTarget != revealTarget)
+            {
+                EventLogCommands.ConsumeRevealFocus(revealTarget);
+            }
+            else
+            {
+                try
+                {
+                    if (await TryScrollToRow(revealTarget))
+                    {
+                        EventLogCommands.ConsumeRevealFocus(revealTarget);
+                        rescrollRequested = false;
+                    }
+                }
+                catch (JSDisconnectedException) { /* Circuit gone; leave the reveal pending so a reconnected or remounted pane can retry. */ }
+                catch (Exception e)
+                {
+                    EventLogCommands.ConsumeRevealFocus(revealTarget);
+                    TraceLogger.Error($"Failed to scroll to the restored selection: {e}");
+                }
+            }
+        }
+
+        if (rescrollRequested)
+        {
+            try
+            {
+                await ScrollToSelectedEvent();
+            }
+            catch (JSDisconnectedException) { /* Circuit gone; nothing to scroll. */ }
+            catch (Exception e)
+            {
+                TraceLogger.Error($"Failed to scroll to selected event: {e}");
+            }
+        }
+
+        if (_findScrollToCurrentOnRender)
+        {
+            try
+            {
+                await ScrollToCurrentFindMatchAsync();
+            }
+            catch (JSDisconnectedException) { /* Circuit gone; nothing to scroll. */ _findScrollToCurrentOnRender = false; }
+            catch (Exception e)
+            {
+                _findScrollToCurrentOnRender = false;
+                TraceLogger.Error($"{nameof(LogTablePane)}: failed to scroll to find match: {e}");
+            }
+        }
+
+        // the queue has drained - turns that silent staleness into one extra pass. Cannot spin: if the pass still
+        // cannot adopt, ShouldRender returns false, no render happens, and this method does not run again.
+        if (Presentation.Revision != _renderedPresentationRevision) { StateHasChanged(); }
+
+        await base.OnAfterRenderAsync(firstRender);
+    }
+
+    protected override async Task OnInitializedAsync()
+    {
+        ObserveSource(Focus);
+        ObserveSource(Selection);
+        ObserveSource(FilterSelection);
+
+        ObserveSource(
+            handler => GroupCollapseNotifier.Requested += handler,
+            handler => GroupCollapseNotifier.Requested -= handler,
+            OnGroupCollapseRequestedAsync);
+
+        ObserveSource(RevealFocusSource);
+
+        // The time zone is a plain service event, not Fluxor, and every date cell is rendered through it. FluxorComponent
+        // used to repaint this surface often enough to pick a change up for free; now it must be subscribed directly.
+        Settings.TimeZoneChanged += OnTimeZoneChanged;
+
+        // Owned per component rather than injected: the minimum-visible clock it holds is measured from THIS pane's
+        // paints, and the render its floor asks for has to be marshalled onto this pane's dispatcher.
+        _indicatorState = new DisplayIndicatorState(IndicatorGate, RequestIndicatorRender);
+
+        _enabledColumns = GetOrderedEnabledColumns();
+        _focus = Focus.Current;
+        SetCursorEvent(_focus?.CurrentHandle);
+        _selection = Selection.Current;
+        _selectedSet = BuildSelectedSet(_selection);
+        _filters = FilterSelection.Current;
+        _activeHighlightFilters = HighlightSelector.Select(_filters);
+        _filtersHighlightKey = HighlightSelector.ComputeHighlightKey(_filters);
+        _timeZoneSettings = Settings.TimeZoneInfo;
+
+        // Seed the rescroll guard with the view the pane initialises on. OnPresentationChanged rescrolls only when the
+        // view instance differs from this; the base sets Presentation without ever raising that callback, so leaving the
+        // guard null would make the FIRST publication over these same rows (a collapse, a width change, a fault or
+        // staleness transition - all now advance the revision without moving a row) read as a row change and yank the
+        // viewport to the selection.
+        _rescrolledForView = Presentation.View;
+
+        WarnOnUnknownFilterColors(_filters);
+
+        RebuildRowMaps();
+
+        RegisterFind();
+
+        await base.OnInitializedAsync();
+    }
+
+    protected override void OnPresentationChanged()
+    {
+        if (ReferenceEquals(Presentation.View, _rescrolledForView)) { return; }
+
+        _rescrolledForView = Presentation.View;
+        _rescrollToSelectedOnRender = true;
+    }
+
+    protected override bool ShouldRender()
+    {
+        var currentFilters = FilterSelection.Current;
+        bool filtersChanged = !ReferenceEquals(currentFilters, _filters);
+        bool focusChanged = Focus.Current?.OriginHandle != _focus?.OriginHandle;
+
+        if (!_focusActiveOnNextRender &&
+            !_viewportRenderRequested &&
+            !_rescrollToSelectedOnRender &&
+            RevealFocusSource.Current is null &&
+            !_findRenderRequested &&
+            !_indicatorRenderRequested &&
+            Presentation.Revision == _renderedPresentationRevision &&
+            ReferenceEquals(Selection.Current, _selection) &&
+            !focusChanged &&
+            !filtersChanged &&
+            Settings.TimeZoneInfo.Equals(_timeZoneSettings)) { return false; }
+
+        _viewportRenderRequested = false;
+        _findRenderRequested = false;
+        _indicatorRenderRequested = false;
+        _renderedPresentationRevision = Presentation.Revision;
+
+        _indicator = _indicatorState.Resolve(
+            Presentation.IndicatorKind,
+            Presentation.Revision,
+
+            _busyHeldForRefresh);
+
+        bool selectionChanged = !ReferenceEquals(Selection.Current, _selection);
+
+        var previousColumnsForFind = _enabledColumns;
+        _enabledColumns = GetOrderedEnabledColumns();
+        bool findSearchTextChanged = _findOpen && !previousColumnsForFind.SequenceEqual(_enabledColumns);
+
+        if (selectionChanged)
+        {
+            _selection = Selection.Current;
+            _selectedSet = BuildSelectedSet(_selection);
+        }
+
+        if (focusChanged)
+        {
+            _focus = Focus.Current;
+            SetCursorEvent(_focus?.CurrentHandle);
+        }
+
+        if (filtersChanged)
+        {
+            _filters = currentFilters;
+            int newHighlightKey = HighlightSelector.ComputeHighlightKey(currentFilters);
+
+            if (newHighlightKey != _filtersHighlightKey)
+            {
+                _filtersHighlightKey = newHighlightKey;
+                _activeHighlightFilters = HighlightSelector.Select(currentFilters);
+                _highlightCache.Clear();
+                WarnOnUnknownFilterColors(_filters);
+            }
+        }
+
+        findSearchTextChanged |= _findOpen && !Settings.TimeZoneInfo.Equals(_timeZoneSettings);
+        _timeZoneSettings = Settings.TimeZoneInfo;
+
+        RebuildRowMaps();
+
+        if (findSearchTextChanged) { NotifyFindViewChanged(); }
+
+        return true;
+    }
+
+    private static HashSet<EventLocator> BuildSelectedSet(ImmutableList<SelectionEntry> selection)
+    {
+        var set = new HashSet<EventLocator>(selection.Count);
+
+        foreach (var entry in selection)
+        {
+            if (entry.CurrentHandle is { } handle) { set.Add(handle); }
+        }
+
+        return set;
+    }
+
+    private static SelectionEntry EntryFor(DisplayRow row) =>
+        new(row.Loc, row.Loc, ValueKey.TryCreate(row.Lean, out var key) ? key : null);
+
+    private static string TruncateForMenu(string value)
+    {
+        string collapsed = value.ReplaceLineEndings(" ");
+
+        if (collapsed.Length <= MenuValueMaxLength) { return collapsed; }
+
+        int limit = char.IsHighSurrogate(collapsed[MenuValueMaxLength - 1])
+            ? MenuValueMaxLength - 1
+            : MenuValueMaxLength;
+
+        return collapsed[..limit] + "...";
+    }
+
+    private void AppendCellFilterItems(List<MenuItem> items, ResolvedEvent @event, ColumnName? column)
+    {
+        if (column is not { } cellColumn) { return; }
+
+        if (CellFilterBuilder.MapColumn(cellColumn) is not { } property) { return; }
+
+        string columnLabel = cellColumn.ToFullString();
+
+        if (CellFilterBuilder.TryGetDisplayValue(@event, property, out var value))
+        {
+            string shown = TruncateForMenu(value);
+            string verb = property is EventProperty.Keywords ? "has" : "=";
+
+            items.Add(MenuItem.Item(
+                $"Include only where {columnLabel} {verb} '{shown}'",
+                () => ApplySelectedFilter(@event, property, exclude: false)));
+            items.Add(MenuItem.Item(
+                $"Exclude where {columnLabel} {verb} '{shown}'",
+                () => ApplySelectedFilter(@event, property, exclude: true)));
+        }
+        else
+        {
+            items.Add(MenuItem.Item(
+                $"Include only where {columnLabel}",
+                () => { },
+                isEnabled: false,
+                disabledReason: NoCellValueReason));
+            items.Add(MenuItem.Item(
+                $"Exclude where {columnLabel}",
+                () => { },
+                isEnabled: false,
+                disabledReason: NoCellValueReason));
+        }
+
+        items.Add(MenuItem.Separator());
+    }
+
+    private void ApplyNavSelection(EventLocator target, bool shift)
+    {
+        if (shift)
+        {
+            _selectionAnchor ??= ActiveHandle ?? target;
+            SetCursorEvent(target);
+            DispatchSetSelection(BuildRange(_selectionAnchor.Value, target), target, alreadyOrdered: true);
+        }
+        else
+        {
+            _selectionAnchor = target;
+            SetCursorEvent(target);
+            DispatchSetSelection([EntryFor(target)], target);
+        }
+    }
+
+    private void ApplySelectedFilter(ResolvedEvent selectedEvent, EventProperty property, bool exclude)
+    {
+        if (CellFilterBuilder.TryBuild(selectedEvent, property, exclude, out var filter))
+        {
+            FilterPaneCommands.SetFilter(filter);
+        }
+    }
+
+    private IReadOnlyList<SelectionEntry> BuildRange(EventLocator anchor, EventLocator selected)
+    {
+        int anchorIndex = RowIndexOf(anchor);
+        int activeIndex = RowIndexOf(selected);
+
+        if (anchorIndex < 0 || activeIndex < 0) { return [EntryFor(selected)]; }
+
+        int start = Math.Min(anchorIndex, activeIndex);
+        int end = Math.Max(anchorIndex, activeIndex);
+
+        var slice = _activeDisplayedEvents.Slice(start, end - start + 1);
+        var range = new List<SelectionEntry>(slice.Count);
+
+        foreach (var row in slice) { range.Add(EntryFor(row)); }
+
+        return range;
+    }
+
+    private void DispatchSetSelection(IReadOnlyList<SelectionEntry> entries, EventLocator? focus, bool alreadyOrdered = false)
+    {
+        SelectionEntry? focusEntry = focus is { } focusLocator ? EntryFor(focusLocator) : null;
+
+        if (alreadyOrdered)
+        {
+            EventLogCommands.SetSelectedEvents(entries, focusEntry);
+
+            return;
+        }
+
+        var seen = new HashSet<EventLocator>();
+        List<(SelectionEntry Entry, int Index)> inTable = new(entries.Count);
+        List<SelectionEntry> outOfTable = [];
+
+        foreach (var entry in entries)
+        {
+            if (!seen.Add(entry.OriginHandle)) { continue; }
+
+            int index = entry.CurrentHandle is { } handle ? RowIndexOf(handle) : -1;
+
+            if (index >= 0)
+            {
+                inTable.Add((entry, index));
+            }
+            else
+            {
+                outOfTable.Add(entry);
+            }
+        }
+
+        inTable.Sort(static (left, right) => left.Index.CompareTo(right.Index));
+
+        var ordered = new List<SelectionEntry>(inTable.Count + outOfTable.Count);
+
+        foreach (var entry in inTable) { ordered.Add(entry.Entry); }
+
+        ordered.AddRange(outOfTable);
+
+        EventLogCommands.SetSelectedEvents(ordered, focusEntry);
+    }
+
+    private SelectionEntry EntryFor(EventLocator locator) =>
+        new(
+            locator,
+            locator,
+            ValueKey.TryCreate(_activeDisplayedEvents.GetDetailLean(locator), out var key) ? key : null);
+
+    private async Task FocusActiveRow()
+    {
+        int visibleRow = ResolveCursorVisibleRow();
+
+        try
+        {
+            if (_tableModule is null) { return; }
+
+            if (visibleRow < 0)
+            {
+                await _tableModule.InvokeVoidAsync("focusTableContainer");
+
+                return;
+            }
+
+            await _tableModule.InvokeVoidAsync("focusEventTableRow", visibleRow);
+        }
+        catch (JSDisconnectedException) { /* Circuit gone; focus best-effort during teardown. */ }
+        catch (Exception e)
+        {
+            TraceLogger.Warning($"Failed to focus active table row: {e}");
+        }
+    }
+
+    private int GetAriaRowCount() => (_rowView?.Count ?? _activeDisplayedEvents.Count) + 1;
+
+    private int GetColumnWidth(ColumnName column) =>
+        Presentation.ColumnWidths.TryGetValue(column, out int width) ? width : ColumnDefaults.GetColumnWidth(column);
+
+    private string GetCss(EventLocator loc) =>
+        _selectedSet.Contains(loc) ? "table-row selected" : "table-row";
+
+    private int GetCurrentVisibleRow(IEventColumnView displayedEvents)
+    {
+        int cursorRow = ResolveCursorVisibleRow();
+
+        if (cursorRow >= 0) { return cursorRow; }
+
+        if (_selection.Count > 0 && _selection[^1].CurrentHandle is { } fallback)
+        {
+            int fallbackIndex = RowIndexOf(fallback);
+
+            if (fallbackIndex >= 0)
+            {
+                return _rowView?.VisibleRowForEvent(fallbackIndex) ?? fallbackIndex;
+            }
+        }
+
+        int count = _rowView?.Count ?? displayedEvents.Count;
+
+        return count > 0 ? 0 : -1;
+    }
+
+    private string GetDateColumnHeader() =>
+        EventTableColumnFormatter.GetColumnHeader(ColumnName.DateAndTime, Settings.TimeZoneInfo);
+
+    private string GetGroupName() => Presentation.Ordering.GroupBy?.ToFullString() ?? string.Empty;
+
+    private string GetGroupValueText(EventGroup group)
+    {
+        if (group.EventCount == 0) { return "(none)"; }
+
+        var representative = _activeDisplayedEvents.GetDetailLean(_activeDisplayedEvents.LocatorAt(group.StartIndex));
+
+        string? value = Presentation.Ordering.GroupBy switch
+        {
+            ColumnName.RecordId => representative.RecordId?.ToString(),
+            ColumnName.Level => representative.Level,
+            ColumnName.DateAndTime => representative.TimeCreated.ConvertTimeZone(_timeZoneSettings).ToString(),
+            ColumnName.ActivityId => representative.ActivityId?.ToString(),
+            ColumnName.Log => representative.LogName,
+            ColumnName.ComputerName => representative.ComputerName,
+            ColumnName.Source => representative.Source,
+            ColumnName.EventId => representative.Id.ToString(),
+            ColumnName.TaskCategory => representative.TaskCategory,
+            ColumnName.Keywords => representative.KeywordsDisplayName,
+            ColumnName.ProcessId => representative.ProcessId?.ToString(),
+            ColumnName.ThreadId => representative.ThreadId?.ToString(),
+            ColumnName.User => representative.UserId?.ToString(),
+            _ => null
+        };
+
+        return string.IsNullOrEmpty(value) ? "(none)" : value;
+    }
+
+    private string? GetHighlight(DisplayRow row)
+    {
+        if (_selectedSet.Contains(row.Loc)) { return null; }
+
+        if (_highlightCache.TryGetValue(row.Loc, out var cached)) { return cached; }
+
+        if (_activeHighlightFilters.Length == 0)
+        {
+            _highlightCache[row.Loc] = null;
+
+            return null;
+        }
+
+        string? color = null;
+        if (!_activeDisplayedEvents.TryGetDetail(row.Loc, out var detail)) { return null; }
+
+        foreach (var filter in _activeHighlightFilters)
+        {
+            if (!filter.Compiled!.Predicate(detail)) { continue; }
+
+            color = filter.Color.ToCssName();
+
+            break;
+        }
+
+        _highlightCache[row.Loc] = color;
+
+        return color;
+    }
+
+    private ColumnName[] GetOrderedEnabledColumns() =>
+        [.. LogTableState.ResolveOrderedEnabledColumns(Presentation.Columns, Presentation.ColumnOrder, ColumnDefaults)];
+
+    private int GetRowIndex(EventLocator loc)
+    {
+        int index = RowIndexOf(loc);
+
+        if (index < 0) { return 2; }
+
+        return (_rowView?.VisibleRowForEvent(index) ?? index) + 2;
+    }
+
+    private int GetRowStripe(EventLocator loc)
+    {
+        int index = RowIndexOf(loc);
+
+        if (index < 0) { return 0; }
+
+        if (_rowView is null) { return index % 2; }
+
+        return (index - _rowView.GroupForEvent(index).StartIndex) % 2;
+    }
+
+    private async Task HandleKeyDown(KeyboardEventArgs args)
+    {
+        if (_findOpen && args.Code == "Escape")
+        {
+            await CloseFind();
+
+            return;
+        }
+
+        var displayedEvents = _activeDisplayedEvents;
+
+        if (displayedEvents.Count == 0) { return; }
+
+        if (args is { CtrlKey: true, Code: "KeyC" })
+        {
+            await ClipboardService.CopySelectedEvent();
+
+            return;
+        }
+
+        if (args is { CtrlKey: true, Code: "KeyA" })
+        {
+            int total = displayedEvents.Count;
+            var lastLocator = displayedEvents.LocatorAt(total - 1);
+            _selectionAnchor = displayedEvents.LocatorAt(0);
+            SetCursorEvent(lastLocator);
+
+            var allRows = displayedEvents.Slice(0, total);
+            var allEntries = new List<SelectionEntry>(allRows.Count);
+
+            foreach (var row in allRows) { allEntries.Add(EntryFor(row)); }
+
+            DispatchSetSelection(allEntries, lastLocator, alreadyOrdered: true);
+
+            return;
+        }
+
+        if (args.Code == "Escape")
+        {
+            _selectionAnchor = null;
+            SetCursor(null);
+            DispatchSetSelection([], null);
+
+            return;
+        }
+
+        if (_rowView is not null)
+        {
+            if (args.Code is "ArrowLeft")
+            {
+                HandleTreegridLeft();
+
+                return;
+            }
+
+            if (args.Code is "ArrowRight")
+            {
+                HandleTreegridRight();
+
+                return;
+            }
+
+            if (args.Key is "Enter")
+            {
+                if (_cursor is { Kind: TableRowKind.Header, GroupKey: { } enterKey })
+                {
+                    ToggleGroupCollapsed(enterKey);
+                    _focusActiveOnNextRender = true;
+                }
+
+                return;
+            }
+        }
+
+        int count = _rowView?.Count ?? displayedEvents.Count;
+        int currentRow = GetCurrentVisibleRow(displayedEvents);
+        int targetRow;
+        int scanDirection;
+
+        switch (args.Code)
+        {
+            case "ArrowUp":
+                targetRow = Math.Max(0, currentRow - 1);
+                scanDirection = -1;
+                break;
+            case "ArrowDown":
+                targetRow = Math.Min(count - 1, currentRow + 1);
+                scanDirection = 1;
+                break;
+            case "PageUp":
+            case "PageDown":
+                int liveStep = await TryRefreshPageSize();
+                int step = liveStep > 0 ? liveStep : _pageSize;
+
+                if (args.Code == "PageUp")
+                {
+                    targetRow = Math.Max(0, currentRow - step);
+                    scanDirection = -1;
+                }
+                else
+                {
+                    targetRow = Math.Min(count - 1, currentRow + step);
+                    scanDirection = 1;
+                }
+
+                break;
+            case "Home":
+                targetRow = 0;
+                scanDirection = 1;
+                break;
+            case "End":
+                targetRow = count - 1;
+                scanDirection = -1;
+                break;
+            default:
+                return;
+        }
+
+        if (targetRow == currentRow && _cursor is not null) { return; }
+
+        if (_rowView is null)
+        {
+            ApplyNavSelection(displayedEvents.LocatorAt(targetRow), args.ShiftKey);
+            _focusActiveOnNextRender = true;
+
+            return;
+        }
+
+        NavigateGroupedTo(targetRow, scanDirection, args.ShiftKey);
+    }
+
+    private void HandleTreegridLeft()
+    {
+        var view = _rowView;
+
+        if (view is null) { return; }
+
+        if (_cursor is { Kind: TableRowKind.Event, Handle: { } handle })
+        {
+            int index = RowIndexOf(handle);
+
+            if (index >= 0)
+            {
+                SetCursorHeader(view.GroupForEvent(index).Key);
+                _focusActiveOnNextRender = true;
+
+                return;
+            }
+        }
+
+        if (_cursor is { Kind: TableRowKind.Header, GroupKey: { } key } &&
+            view.TryGetGroupByKey(key, out var group) && !group.IsCollapsed)
+        {
+            ToggleGroupCollapsed(key);
+            _focusActiveOnNextRender = true;
+        }
+    }
+
+    private void HandleTreegridRight()
+    {
+        var view = _rowView;
+
+        if (view is null ||
+            _cursor is not { Kind: TableRowKind.Header, GroupKey: { } key } ||
+            !view.TryGetGroupByKey(key, out var group))
+        {
+            return;
+        }
+
+        if (group.IsCollapsed)
+        {
+            ToggleGroupCollapsed(key);
+            _focusActiveOnNextRender = true;
+
+            return;
+        }
+
+        if (group.EventCount > 0)
+        {
+            var firstLocator = _activeDisplayedEvents.LocatorAt(group.StartIndex);
+            _selectionAnchor = firstLocator;
+            SetCursorEvent(firstLocator);
+            DispatchSetSelection([EntryFor(firstLocator)], firstLocator);
+            _focusActiveOnNextRender = true;
+        }
+    }
+
+    private string? IndicatorSentence() =>
+        _indicator.Sentence switch
+        {
+            DisplayIndicatorKind.EmptyPending => "Loading events\u2026",
+            DisplayIndicatorKind.ReorderPending => "Reordering events\u2026",
+            DisplayIndicatorKind.Fault => Presentation.FaultCause is { Length: > 0 } cause ?
+                $"These events could not be prepared. {cause}" :
+                "These events could not be prepared.",
+            _ => null
+        };
+
+    private async Task InitializeTableEventHandlers()
+    {
+        _dotNetRef?.Dispose();
+        _dotNetRef = DotNetObjectReference.Create(this);
+
+        _tableModule ??= await JSRuntime.InvokeAsync<IJSObjectReference>(
+            "import",
+            "./_content/EventLogExpert.UI/LogTable/LogTablePane.razor.js");
+
+        await _tableModule.InvokeVoidAsync("initializeTableEvents", _dotNetRef);
+    }
+
+    private void InvokeCellContextMenu(MouseEventArgs args, DisplayRow row, ColumnName? column)
+    {
+        if (!_activeDisplayedEvents.TryGetDetail(row.Loc, out var detail)) { return; }
+
+        var items = new List<MenuItem>();
+
+        AppendCellFilterItems(items, detail, column);
+        items.AddRange(ShowContextMenuItems(detail));
+
+        MenuService.OpenAt(args.ClientX, args.ClientY, items);
+    }
+
+    private void InvokeContextMenu(MouseEventArgs args)
+    {
+        if (Focus.Current?.CurrentHandle is not { } handle) { return; }
+
+        if (!_activeDisplayedEvents.TryGetDetail(handle, out var clicked)) { return; }
+
+        MenuService.OpenAt(args.ClientX, args.ClientY, ShowContextMenuItems(clicked));
+    }
+
+    private void InvokeGroupContextMenu(MouseEventArgs args, EventGroup group)
+    {
+        SetCursorHeader(group.Key);
+        MenuService.OpenAt(args.ClientX, args.ClientY, ShowGroupContextMenuItems(group));
+    }
+
+    private void InvokeTableColumnMenu(MouseEventArgs args) =>
+        MenuService.OpenAt(args.ClientX, args.ClientY, ShowColumnMenuItems());
+
+    private bool IsGridBusy() =>
+        Presentation.IndicatorKind == DisplayIndicatorKind.EmptyPending || _busyHeldForRefresh;
+
+    private bool IsSelectionOutOfSortOrder(IReadOnlyList<SelectionEntry> selection)
+    {
+        int lastIndex = -1;
+
+        foreach (var entry in selection)
+        {
+            int index = entry.CurrentHandle is { } handle ? RowIndexOf(handle) : -1;
+
+            if (index < 0) { continue; }
+
+            if (index < lastIndex) { return true; }
+
+            lastIndex = index;
+        }
+
+        return false;
+    }
+
+    private ValueTask<ItemsProviderResult<DisplayRow>> LoadEventViewport(ItemsProviderRequest request) =>
+        ValueTask.FromResult(ComputeEventViewport(_activeDisplayedEvents, request));
+
+    private void NavigateGroupedTo(
+        int targetRow,
+        int scanDirection,
+        bool shift)
+    {
+        var view = _rowView!;
+        var row = view[targetRow];
+
+        if (row.Kind == TableRowKind.Event)
+        {
+            ApplyNavSelection(view.LocatorAt(row), shift);
+            _focusActiveOnNextRender = true;
+
+            return;
+        }
+
+        if (!shift)
+        {
+            SetCursorHeader(view.GroupAt(row).Key);
+            _focusActiveOnNextRender = true;
+
+            return;
+        }
+
+        int probe = targetRow;
+
+        while (probe >= 0 && probe < view.Count && view[probe].Kind == TableRowKind.Header)
+        {
+            probe += scanDirection;
+        }
+
+        if (probe < 0 || probe >= view.Count) { return; }
+
+        ApplyNavSelection(view.LocatorAt(view[probe]), shift: true);
+        _focusActiveOnNextRender = true;
+    }
+
+    private TableCursor? NearestHeaderCursor(int priorVisibleRow)
+    {
+        var groups = _rowView!.Groups;
+
+        if (groups.Count == 0) { return null; }
+
+        foreach (var group in groups)
+        {
+            if (group.VisibleStart >= priorVisibleRow) { return TableCursor.ForHeader(group.Key); }
+        }
+
+        return TableCursor.ForHeader(groups[^1].Key);
+    }
+
+    private TableCursor? NormalizeCursor(TableCursor? cursor)
+    {
+        if (_rowView is not { } view ||
+            cursor is not { Kind: TableRowKind.Event, Handle: { } handle })
+        {
+            return cursor;
+        }
+
+        int index = RowIndexOf(handle);
+
+        if (index < 0) { return cursor; }
+
+        var group = view.GroupForEvent(index);
+
+        if (group.IsCollapsed) { return TableCursor.ForHeader(group.Key); }
+
+        return cursor;
+    }
+
+    private void OnTimeZoneChanged(object? sender, TimeZoneInfo value) => RequestAppStateRender();
+
+    private void RebuildGroupedRowView(IEventColumnView displayedEvents, bool absenceIsFinal)
+    {
+        if (Presentation.Ordering.GroupBy is not { } groupBy)
+        {
+            EventLocator? formerGroupFirstLocator = null;
+
+            if (_rowView is { } priorView &&
+                _cursor is { Kind: TableRowKind.Header, GroupKey: { } headerKey } &&
+                priorView.TryGetGroupByKey(headerKey, out var priorGroup) && priorGroup.EventCount > 0)
+            {
+                formerGroupFirstLocator = priorView.FirstLocatorOf(priorGroup);
+            }
+
+            _rowView = null;
+            _rowViewSnapshot = default;
+
+            if (formerGroupFirstLocator is not null)
+            {
+                SetCursorEvent(formerGroupFirstLocator);
+            }
+
+            return;
+        }
+
+        var snapshot = (displayedEvents,
+            Presentation.ActiveTabId,
+            Presentation.Ordering.GroupBy,
+            Presentation.Ordering.IsGroupDescending,
+            Presentation.GroupsCollapsedByDefault,
+            (ImmutableHashSet<string>?)Presentation.GroupCollapseOverrides);
+
+        if (_rowView is not null && _rowViewSnapshot.Equals(snapshot)) { return; }
+
+        int priorHeaderRow = _cursor is { Kind: TableRowKind.Header } ? ResolveCursorVisibleRow() : -1;
+
+        _rowViewSnapshot = snapshot;
+        _rowView = GroupedRowView.Build(displayedEvents, groupBy, Presentation.IsGroupCollapsed);
+
+        ReconcileGroupedCursor(priorHeaderRow, absenceIsFinal);
+    }
+
+    private void RebuildRowMaps()
+    {
+        var displayedEvents = ResolveActiveDisplayedEvents();
+        _activeDisplayedEvents = displayedEvents;
+
+        PruneFindGroupOwnershipOnContextChange();
+
+        var currentTableId = Presentation.ActiveTabId;
+
+        bool absenceIsFinal = displayedEvents.Count > 0 ||
+            (currentTableId is not null && Presentation.State == PresentationState.Current);
+
+        if (!Equals(currentTableId, _highlightCacheTableId))
+        {
+            _highlightCacheTableId = currentTableId;
+            _highlightCache.Clear();
+        }
+
+        if (!ReferenceEquals(displayedEvents, _lastIndexedDisplayedEvents))
+        {
+            _lastIndexedDisplayedEvents = displayedEvents;
+            _refreshEventViewportOnRender = true;
+
+            if (_busyAssertedOnLastPaint) { _busyHeldForRefresh = true; }
+
+            NotifyFindViewChanged();
+
+            if (displayedEvents.Count > 0)
+            {
+                if (_selectionAnchor is { } anchor && displayedEvents.Rank(anchor) < 0)
+                {
+                    _selectionAnchor = null;
+                }
+
+                if (_cursor is { Kind: TableRowKind.Event, Handle: { } cursorHandle } &&
+                    displayedEvents.Rank(cursorHandle) < 0)
+                {
+                    _cursor = null;
+                }
+
+                if (IsSelectionOutOfSortOrder(_selection))
+                {
+                    _resortSelectionOnNextRender = true;
+                }
+            }
+        }
+
+        if (absenceIsFinal && displayedEvents.Count == 0)
+        {
+            _selectionAnchor = null;
+            _cursor = null;
+        }
+
+        RebuildGroupedRowView(displayedEvents, absenceIsFinal);
+    }
+
+    private void ReconcileGroupedCursor(int priorHeaderRow, bool absenceIsFinal)
+    {
+        if (_rowView is not { } view || _cursor is not { } cursor) { return; }
+
+        if (cursor is { Kind: TableRowKind.Event, Handle: { } handle })
+        {
+            int index = RowIndexOf(handle);
+
+            if (index >= 0)
+            {
+                var group = view.GroupForEvent(index);
+
+                if (group.IsCollapsed) { _cursor = TableCursor.ForHeader(group.Key); }
+            }
+            else if (absenceIsFinal)
+            {
+                _cursor = null;
+            }
+
+            return;
+        }
+
+        if (absenceIsFinal &&
+            cursor is { Kind: TableRowKind.Header, GroupKey: { } key } &&
+            !view.TryGetGroupByKey(key, out _))
+        {
+            _cursor = NearestHeaderCursor(priorHeaderRow);
+        }
+    }
+
+    private void ReleaseBusyHeldForRefresh()    {
+        if (!_busyHeldForRefresh) { return; }
+
+        _busyHeldForRefresh = false;
+        _viewportRenderRequested = true;
+
+        StateHasChanged();
+    }
+
+    private void RequestAppStateRender() => RequestGuardedRender(StateHasChanged);
+
+    private void RequestIndicatorRender() =>
+        RequestGuardedRender(() =>
+        {
+            _indicatorRenderRequested = true;
+
+            StateHasChanged();
+        });
+
+    private IEventColumnView ResolveActiveDisplayedEvents() =>
+        Presentation.ActiveTabId is not null ?
+            Presentation.View :
+            s_emptyView;
+
+    private int ResolveCursorVisibleRow()
+    {
+        if (_cursor is { Kind: TableRowKind.Header, GroupKey: { } key })
+        {
+            return _rowView?.VisibleRowForHeader(key) ?? -1;
+        }
+
+        if (_cursor is { Kind: TableRowKind.Event, Handle: { } handle })
+        {
+            int index = RowIndexOf(handle);
+
+            if (index >= 0)
+            {
+                return _rowView?.VisibleRowForEvent(index) ?? index;
+            }
+        }
+
+        return -1;
+    }
+
+    private void ResortSelectionForCurrentTable()
+    {
+        DispatchSetSelection(_selection, ActiveHandle ?? _focus?.CurrentHandle);
+    }
+
+    private int RowIndexOf(EventLocator locator) => _activeDisplayedEvents.Rank(locator);
+
+    private async Task ScrollToSelectedEvent()
+    {
+        var target = ActiveHandle
+            ?? _focus?.CurrentHandle
+            ?? (_selection.Count > 0 ? _selection[^1].CurrentHandle : null);
+
+        if (target is not { } handle) { return; }
+
+        if (_activeDisplayedEvents.Count == 0) { return; }
+
+        int index = RowIndexOf(handle);
+
+        if (index < 0) { return; }
+
+        int targetRow = _rowView?.VisibleRowForEvent(index) ?? index;
+
+        if (_tableModule is not null) { await _tableModule.InvokeVoidAsync("scrollToRow", targetRow); }
+    }
+
+    private void SelectEvent(MouseEventArgs args, DisplayRow row)
+    {
+        var displayedEvents = _activeDisplayedEvents;
+
+        switch (args)
+        {
+            case { ShiftKey: true } when displayedEvents.Count > 0:
+                if (_selectionAnchor is null)
+                {
+                    _selectionAnchor = row.Loc;
+                    SetCursorEvent(row.Loc);
+                    DispatchSetSelection([EntryFor(row)], row.Loc);
+
+                    return;
+                }
+
+                SetCursorEvent(row.Loc);
+                var range = BuildRange(_selectionAnchor.Value, row.Loc);
+
+                if (args.CtrlKey)
+                {
+                    var merged = new List<SelectionEntry>(_selection.Count + range.Count);
+                    merged.AddRange(_selection);
+                    merged.AddRange(range);
+                    DispatchSetSelection(merged, row.Loc);
+                }
+                else
+                {
+                    DispatchSetSelection(range, row.Loc, alreadyOrdered: true);
+                }
+
+                return;
+
+            case { CtrlKey: true }:
+                _selectionAnchor = row.Loc;
+                SetCursorEvent(row.Loc);
+
+                if (_selectedSet.Contains(row.Loc))
+                {
+                    var remaining = new List<SelectionEntry>(_selection.Count);
+
+                    foreach (var existing in _selection)
+                    {
+                        if (existing.CurrentHandle != row.Loc) { remaining.Add(existing); }
+                    }
+
+                    DispatchSetSelection(remaining, row.Loc);
+                }
+                else
+                {
+                    var combined = new List<SelectionEntry>(_selection.Count + 1);
+                    combined.AddRange(_selection);
+                    combined.Add(EntryFor(row));
+                    DispatchSetSelection(combined, row.Loc);
+                }
+
+                return;
+
+            default:
+                if (args.Button == 2 && _selectedSet.Contains(row.Loc))
+                {
+                    SetCursorEvent(row.Loc);
+                    DispatchSetSelection(_selection, row.Loc);
+
+                    return;
+                }
+
+                _selectionAnchor = row.Loc;
+                SetCursorEvent(row.Loc);
+                DispatchSetSelection([EntryFor(row)], row.Loc);
+
+                return;
+        }
+    }
+
+    private void SelectGroup(EventGroup group)
+    {
+        if (group.EventCount == 0 ||
+            group.StartIndex + group.EventCount > _activeDisplayedEvents.Count)
+        {
+            return;
+        }
+
+        var members = _activeDisplayedEvents.Slice(group.StartIndex, group.EventCount);
+        var entries = new List<SelectionEntry>(members.Count);
+
+        foreach (var row in members) { entries.Add(EntryFor(row)); }
+
+        var activeLocator = members[0].Loc;
+        _selectionAnchor = activeLocator;
+        SetCursorEvent(activeLocator);
+        DispatchSetSelection(entries, activeLocator, alreadyOrdered: true);
+    }
+
+    private void SelectGroupByKey(string key)
+    {
+        if (_rowView is null || !_rowView.TryGetGroupByKey(key, out var group)) { return; }
+
+        SelectGroup(group);
+    }
+
+    private void SetCursor(TableCursor? cursor) => _cursor = NormalizeCursor(cursor);
+
+    private void SetCursorEvent(EventLocator? handle) =>
+        SetCursor(handle is { } locator ? TableCursor.ForEvent(locator) : null);
+
+    private void SetCursorHeader(string groupKey) => SetCursor(TableCursor.ForHeader(groupKey));
+
+    private void SetGroupCollapsed(string key, bool collapse)
+    {
+        if (_rowView is null || !_rowView.TryGetGroupByKey(key, out _)) { return; }
+
+        if (Presentation.IsGroupCollapsed(key) != collapse)
+        {
+            LogTableCommands.ToggleGroupCollapsed(key);
+        }
+    }
+
+    private IReadOnlyList<MenuItem> ShowColumnMenuItems()
+    {
+        var columns = Presentation.Columns;
+        var ordering = Presentation.Ordering;
+        var items = new List<MenuItem>();
+
+        foreach (var (column, isVisible) in columns)
+        {
+            var capturedColumn = column;
+            items.Add(MenuItem.Item(
+                column.ToFullString(),
+                () => LogTableCommands.ToggleColumn(capturedColumn),
+                isChecked: isVisible));
+        }
+
+        items.Add(MenuItem.Separator());
+
+        var orderItems = new List<MenuItem>();
+        foreach (var (column, _) in columns)
+        {
+            var capturedColumn = column;
+            orderItems.Add(MenuItem.Item(
+                column.ToFullString(),
+                () => LogTableCommands.SetOrderBy(capturedColumn),
+                isChecked: ordering.OrderBy.Equals(capturedColumn)));
+        }
+
+        items.Add(MenuItem.SubMenu("Order By", orderItems));
+
+        var groupItems = new List<MenuItem>
+        {
+            MenuItem.Item(
+                "(none)",
+                () => { if (ordering.GroupBy is not null) { LogTableCommands.SetGroupBy(null); } },
+                isChecked: ordering.GroupBy is null)
+        };
+
+        foreach (var (column, _) in columns)
+        {
+            var capturedColumn = column;
+            groupItems.Add(MenuItem.Item(
+                column.ToFullString(),
+                () => { if (!ordering.GroupBy.Equals(capturedColumn)) { LogTableCommands.SetGroupBy(capturedColumn); } },
+                isChecked: ordering.GroupBy.Equals(capturedColumn)));
+        }
+
+        items.Add(MenuItem.SubMenu("Group By", groupItems));
+
+        items.Add(MenuItem.Separator());
+        items.Add(MenuItem.Item(
+            "Reset Column Defaults",
+            () => LogTableCommands.ResetColumnDefaults()));
+
+        return items;
+    }
+
+    private IReadOnlyList<MenuItem> ShowContextMenuItems(ResolvedEvent selectedEvent)
+    {
+        return
+        [
+            MenuItem.Item("Copy Selected", () => ClipboardService.CopySelectedEvent(EventCopyFormat.Default)),
+            MenuItem.Item("Copy Selected (Simple)", () => ClipboardService.CopySelectedEvent(EventCopyFormat.Simple)),
+            MenuItem.Item("Copy Selected (XML)", () => ClipboardService.CopySelectedEvent(EventCopyFormat.Xml)),
+            MenuItem.Item("Copy Selected (Full)", () => ClipboardService.CopySelectedEvent(EventCopyFormat.Full)),
+            MenuItem.Separator(),
+            MenuItem.Item("Exclude Events Before", () =>
+                FilterPaneCommands.SetFilterDateRange(
+                    new DateFilter { Before = selectedEvent.TimeCreated })),
+            MenuItem.Item("Exclude Events After", () =>
+                FilterPaneCommands.SetFilterDateRange(
+                    new DateFilter { After = selectedEvent.TimeCreated })),
+            MenuItem.Separator(),
+            MenuItem.Item(
+                "Show Related by Activity ID",
+                () => FilterLensCommands.ShowRelatedByActivityId(selectedEvent.ActivityId, selectedEvent.OwningLog),
+                isEnabled: selectedEvent.ActivityId.HasValue,
+                disabledReason: selectedEvent.ActivityId.HasValue ? null : "This event has no Activity ID."),
+            MenuItem.Item(
+                "Show Events Sharing Related Activity ID",
+                () => FilterLensCommands.ShowRelatedByRelatedActivityId(selectedEvent.RelatedActivityId, selectedEvent.OwningLog),
+                isEnabled: selectedEvent.RelatedActivityId.HasValue,
+                disabledReason: selectedEvent.RelatedActivityId.HasValue ? null : "This event has no Related Activity ID."),
+            MenuItem.Item(
+                "Show Parent Activity",
+                () => FilterLensCommands.ShowParentActivity(selectedEvent.RelatedActivityId, selectedEvent.OwningLog),
+                isEnabled: selectedEvent.RelatedActivityId.HasValue,
+                disabledReason: selectedEvent.RelatedActivityId.HasValue ? null : "This event has no Related Activity ID."),
+            MenuItem.SubMenu(
+                "Show Events Near This Time",
+                [
+                    MenuItem.Item(
+                        "\u00b130 Seconds",
+                        () => FilterLensCommands.ShowEventsNearTime(
+                            selectedEvent.TimeCreated, TimeSpan.FromSeconds(30), Settings.TimeZoneInfo, selectedEvent.OwningLog)),
+                    MenuItem.Item(
+                        "\u00b11 Minute",
+                        () => FilterLensCommands.ShowEventsNearTime(
+                            selectedEvent.TimeCreated, TimeSpan.FromMinutes(1), Settings.TimeZoneInfo, selectedEvent.OwningLog)),
+                    MenuItem.Item(
+                        "\u00b15 Minutes",
+                        () => FilterLensCommands.ShowEventsNearTime(
+                            selectedEvent.TimeCreated, TimeSpan.FromMinutes(5), Settings.TimeZoneInfo, selectedEvent.OwningLog)),
+                    MenuItem.Item(
+                        "\u00b115 Minutes",
+                        () => FilterLensCommands.ShowEventsNearTime(
+                            selectedEvent.TimeCreated, TimeSpan.FromMinutes(15), Settings.TimeZoneInfo, selectedEvent.OwningLog)),
+                    MenuItem.Item(
+                        "\u00b11 Hour",
+                        () => FilterLensCommands.ShowEventsNearTime(
+                            selectedEvent.TimeCreated, TimeSpan.FromHours(1), Settings.TimeZoneInfo, selectedEvent.OwningLog)),
+                ]),
+            MenuItem.Separator(),
+            MenuItem.SubMenu(
+                "More Fields",
+                [
+                    MenuItem.SubMenu("Include", ShowEventFieldItems(selectedEvent, false)),
+                    MenuItem.SubMenu("Exclude", ShowEventFieldItems(selectedEvent, true)),
+                ]),
+        ];
+    }
+
+    private IReadOnlyList<MenuItem> ShowEventFieldItems(ResolvedEvent selectedEvent, bool exclude)
+    {
+        var items = new List<MenuItem>();
+
+        foreach (EventProperty property in Enum.GetValues<EventProperty>())
+        {
+            if (property is EventProperty.Description or EventProperty.Xml) { continue; }
+
+            var capturedProperty = property;
+            bool hasValue = CellFilterBuilder.TryGetDisplayValue(selectedEvent, property, out _);
+
+            items.Add(MenuItem.Item(
+                property.ToFullString(),
+                () => ApplySelectedFilter(selectedEvent, capturedProperty, exclude),
+                isEnabled: hasValue,
+                disabledReason: hasValue ? null : NoCellValueReason));
+        }
+
+        return items;
+    }
+
+    private IReadOnlyList<MenuItem> ShowGroupContextMenuItems(EventGroup group)
+    {
+        bool collapsedNow = Presentation.IsGroupCollapsed(group.Key);
+
+        return
+        [
+            MenuItem.Item(
+                collapsedNow ? "Expand Group" : "Collapse Group",
+                () => UserSetGroupCollapsed(group.Key, !collapsedNow)),
+            MenuItem.Item("Expand All Groups", () => LogTableCommands.SetAllGroupsCollapsed(false)),
+            MenuItem.Item("Collapse All Groups", () => LogTableCommands.SetAllGroupsCollapsed(true)),
+            MenuItem.Separator(),
+            MenuItem.Item(
+                "Group Descending",
+                () => LogTableCommands.ToggleGroupSortDirection(),
+                isChecked: Presentation.Ordering.IsGroupDescending),
+            MenuItem.Separator(),
+            MenuItem.Item("Select Group", () => SelectGroupByKey(group.Key)),
+        ];
+    }
+
+    private void ToggleGroupCollapsed(string groupKey)
+    {
+        _findExpandedGroupKeys.Remove(groupKey);
+        LogTableCommands.ToggleGroupCollapsed(groupKey);
+    }
+
+    private void ToggleSorting() => LogTableCommands.ToggleSortDirection();
+
+    private async Task<int> TryRefreshPageSize()
+    {
+        try
+        {
+            int measured = _tableModule is not null ? await _tableModule.InvokeAsync<int>("getEventTablePageSize") : 0;
+
+            if (measured > 0) { _pageSize = measured; }
+
+            return measured;
+        }
+        catch (JSDisconnectedException) { return 0; }
+        catch (Exception e)
+        {
+            TraceLogger.Warning($"Failed to refresh table page size: {e}");
+
+            return 0;
+        }
+    }
+
+    private async Task<bool> TryScrollToRow(EventLocator target)
+    {
+        if (_activeDisplayedEvents.Count == 0) { return false; }
+
+        int index = RowIndexOf(target);
+
+        if (index < 0) { return false; }
+
+        if (_tableModule is null) { return false; }
+
+        int targetRow = _rowView?.VisibleRowForEvent(index) ?? index;
+        await _tableModule.InvokeVoidAsync("scrollToRow", targetRow);
+
+        return true;
+    }
+
+    private void WarnOnUnknownFilterColors(IEnumerable<SavedFilter> filters)
+    {
+        foreach (var filter in filters)
+        {
+            if (Enum.IsDefined(filter.Color)) { continue; }
+
+            int rawValue = (int)filter.Color;
+            bool shouldWarn;
+
+            lock (s_warnedUnknownColors)
+            {
+                shouldWarn = s_warnedUnknownColors.Add(rawValue);
+            }
+
+            if (shouldWarn)
+            {
+                TraceLogger.Warning(
+                    $"Unknown HighlightColor value {rawValue} found in filter set; affected filters will be skipped for highlight resolution.");
+            }
+        }
+    }
+}
diff --git a/src/EventLogExpert.UI/LogTable/LogTablePane.razor.css b/src/EventLogExpert.UI/LogTable/LogTablePane.razor.css
index 32da4becc..3ca76bf97 100644
--- a/src/EventLogExpert.UI/LogTable/LogTablePane.razor.css
+++ b/src/EventLogExpert.UI/LogTable/LogTablePane.razor.css
@@ -6,6 +6,51 @@
     background-color: var(--background-dark);
     color: var(--text-primary);
     border-top: 1px solid var(--background-dark);
+    position: relative;
+}
+
+/* Overlaid rather than inserted into the flow: the grid keeps whatever rows it already has readable underneath, and
+   an indicator that pushed the table down would move every row out from under the user's pointer on a re-sort. */
+.table-indicator {
+    position: absolute;
+    top: 6px;
+    right: 12px;
+    z-index: 2;
+    display: flex;
+    align-items: center;
+    gap: 6px;
+    padding: 3px 8px;
+    border-radius: 3px;
+    background-color: var(--background-medium, rgba(0, 0, 0, 0.65));
+    color: var(--text-primary);
+    font-size: 0.85em;
+    pointer-events: none;
+}
+
+.table-indicator-spinner {
+    width: 12px;
+    height: 12px;
+    border: 2px solid currentColor;
+    border-right-color: transparent;
+    border-radius: 50%;
+    animation: table-indicator-spin 0.75s linear infinite;
+}
+
+.table-indicator-text {
+    white-space: nowrap;
+}
+
+@keyframes table-indicator-spin {
+    to {
+        transform: rotate(360deg);
+    }
+}
+
+/* Respect a reduced-motion preference: the indicator still appears, it just stops rotating. */
+@media (prefers-reduced-motion: reduce) {
+    .table-indicator-spinner {
+        animation: none;
+    }
 }
 
 table {
diff --git a/src/EventLogExpert.UI/Menu/IMenuService.cs b/src/EventLogExpert.UI/Menu/IMenuService.cs
new file mode 100644
index 000000000..630ec60b8
--- /dev/null
+++ b/src/EventLogExpert.UI/Menu/IMenuService.cs
@@ -0,0 +1,29 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+namespace EventLogExpert.UI.Menu;
+
+public interface IMenuService
+{
+    event Action<int>? NavigateBarRequested;
+
+    event Action? StateChanged;
+
+    bool ActiveCaptureOpener { get; }
+
+    bool ActiveFocusFirst { get; }
+
+    IReadOnlyList<MenuItem>? ActiveItems { get; }
+
+    long ActiveMenuId { get; }
+
+    double PositionX { get; }
+
+    double PositionY { get; }
+
+    void Close();
+
+    void NavigateBar(int direction);
+
+    void OpenAt(double x, double y, IReadOnlyList<MenuItem> items, bool focusFirst = true, bool captureOpener = true);
+}
diff --git a/src/EventLogExpert.UI/Menu/MenuAnchorRect.cs b/src/EventLogExpert.UI/Menu/MenuAnchorRect.cs
new file mode 100644
index 000000000..453c0ab13
--- /dev/null
+++ b/src/EventLogExpert.UI/Menu/MenuAnchorRect.cs
@@ -0,0 +1,12 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+namespace EventLogExpert.UI.Menu;
+
+public sealed record MenuAnchorRect(
+    double Left,
+    double Top,
+    double Right,
+    double Bottom,
+    double Width,
+    double Height);
diff --git a/src/EventLogExpert.UI/Menu/MenuBar.razor b/src/EventLogExpert.UI/Menu/MenuBar.razor
index aea02baea..fe06d564d 100644
--- a/src/EventLogExpert.UI/Menu/MenuBar.razor
+++ b/src/EventLogExpert.UI/Menu/MenuBar.razor
@@ -1,4 +1,4 @@
-@inherits FluxorComponent
+@inherits AppStateComponentBase
 
 <nav aria-label="Main menu" aria-orientation="horizontal" class="menu-bar" @ref="_menuBarRootRef" role="menubar">
     @for (int index = 0; index < _bars.Count; index++)
diff --git a/src/EventLogExpert.UI/Menu/MenuBar.razor.cs b/src/EventLogExpert.UI/Menu/MenuBar.razor.cs
index 81957bb8c..9e36a16d9 100644
--- a/src/EventLogExpert.UI/Menu/MenuBar.razor.cs
+++ b/src/EventLogExpert.UI/Menu/MenuBar.razor.cs
@@ -16,7 +16,6 @@
 using EventLogExpert.UI.Common;
 using EventLogExpert.UI.Common.Interop;
 using EventLogExpert.UI.Inputs;
-using Fluxor;
 using Microsoft.AspNetCore.Components;
 using Microsoft.AspNetCore.Components.Web;
 using Microsoft.JSInterop;
@@ -47,26 +46,16 @@ public sealed partial class MenuBar
 
     [Inject] private IChannelReadinessService ChannelReadinessService { get; init; } = null!;
 
-    [Inject]
-    private IStateSelection<EventLogState, bool> ContinuouslyUpdate { get; init; } = null!;
+    [Inject] private IEventLogQueries EventLogQueries { get; init; } = null!;
 
-    [Inject]
-    private IStateSelection<FilterPaneState, bool> FilterPaneIsEnabled { get; init; } = null!;
+    [Inject] private IFilterPaneQueries FilterPaneQueries { get; init; } = null!;
 
-    [Inject]
-    private IStateSelection<LogTableState, bool> HasActiveLogs { get; init; } = null!;
-
-    [Inject]
-    private IStateSelection<HistogramState, bool> HistogramVisible { get; init; } = null!;
-
-    [Inject]
-    private IStateSelection<LogTableState, bool> IsGroupDescending { get; init; } = null!;
-
-    [Inject]
-    private IStateSelection<LogTableState, bool> IsGrouping { get; init; } = null!;
+    [Inject] private IHistogramVisibilitySource HistogramVisibility { get; init; } = null!;
 
     [Inject] private IJSRuntime JSRuntime { get; init; } = null!;
 
+    [Inject] private ILogTableQueries LogTableQueries { get; init; } = null!;
+
     [Inject] private IMenuService MenuService { get; init; } = null!;
 
     [Inject] private ISettingsService Settings { get; init; } = null!;
@@ -118,13 +107,6 @@ await _scrollSuppressorModule.InvokeVoidAsync(
 
     protected override void OnInitialized()
     {
-        ContinuouslyUpdate.Select(state => state.ContinuouslyUpdate);
-        FilterPaneIsEnabled.Select(state => state.IsEnabled);
-        HasActiveLogs.Select(state => state.EventTables.Any(table => !table.IsCombined));
-        HistogramVisible.Select(state => state.IsVisible);
-        IsGroupDescending.Select(state => state.IsGroupDescending);
-        IsGrouping.Select(state => state.GroupBy is not null);
-
         Settings.CopyFormatChanged += OnSettingsChanged;
         MenuService.StateChanged += OnMenuServiceStateChanged;
         MenuService.NavigateBarRequested += OnNavigateBarRequested;
@@ -168,7 +150,7 @@ private IReadOnlyList<MenuItem> BuildEdit()
 
     private IReadOnlyList<MenuItem> BuildFile()
     {
-        bool hasActiveLogs = HasActiveLogs.Value;
+        bool hasActiveLogs = LogTableQueries.HasActiveLogs();
 
         return
         [
@@ -242,7 +224,6 @@ private IReadOnlyList<MenuItem> BuildOtherLogsTree(
                 continue;
             }
 
-            // NUL keys folderMap entries so segments containing '-' or '/' can't collide.
             var children = rootChildren;
             var pathBuilder = new StringBuilder();
 
@@ -287,12 +268,11 @@ private List<TopLevel> BuildTopLevel() =>
 
     private IReadOnlyList<MenuItem> BuildView()
     {
-        // Snapshot state at open time. Live updates aren't pushed into an open menu - the next open will reflect any change.
-        bool isFilterEnabled = FilterPaneIsEnabled.Value;
-        bool isContinuouslyUpdating = ContinuouslyUpdate.Value;
-        bool isGrouping = IsGrouping.Value;
-        bool isGroupDescending = IsGroupDescending.Value;
-        bool isHistogramVisible = HistogramVisible.Value;
+        bool isFilterEnabled = FilterPaneQueries.IsEnabled();
+        bool isContinuouslyUpdating = EventLogQueries.IsContinuouslyUpdating();
+        bool isGrouping = LogTableQueries.IsGrouping();
+        bool isGroupDescending = LogTableQueries.IsGroupDescending();
+        bool isHistogramVisible = HistogramVisibility.IsVisible;
 
         return
         [
@@ -381,10 +361,8 @@ private async Task MoveBarFocusTo(int index, bool openIfMenuActive)
 
         _focusedBarIndex = index;
 
-        // If a menu is already open, switch to the new bar's menu so arrow keys feel continuous.
         if (openIfMenuActive && MenuService.ActiveItems is not null)
         {
-            // Preserve the original opener so closing restores focus to the menubar.
             await OpenBarAsync(_bars[index], index, captureOpener: false);
 
             return;
@@ -413,7 +391,6 @@ private async Task OnBarClick(TopLevel bar, int index)
 
     private async Task OnBarHover(TopLevel bar, int index)
     {
-        // Only switch on hover when another menu is already open - matches Win32 menubar behavior.
         if (MenuService.ActiveItems is null || ReferenceEquals(ActiveBar, bar)) { return; }
 
         await OpenBarAsync(bar, index, captureOpener: false);
@@ -438,12 +415,9 @@ private async Task OnBarKeyDown(KeyboardEventArgs args, int index)
                 await MoveBarFocusTo(_bars.Count - 1, true);
                 return;
             case "ArrowDown":
-                // Enter/Space are intentionally not handled here so the browser's native button
-                // click fires once - handling them on keydown would toggle the menu shut.
                 await OpenBarAsync(_bars[index], index);
                 return;
             case "ArrowUp":
-                // WAI-ARIA menubar: ArrowUp opens and focuses the last item.
                 await OpenBarAsync(_bars[index], index, false);
                 return;
             case "Escape":
@@ -457,8 +431,6 @@ private void OnMenuServiceStateChanged()
     {
         if (MenuService.ActiveItems is null)
         {
-            // Invalidate any in-flight OpenBarAsync so a stale continuation can't reopen
-            // the menu after it was closed (overlay click, item activation, Escape, etc.).
             InvalidatePendingOpen();
 
             if (ActiveBar is not null) { ActiveBar = null; }
@@ -474,11 +446,8 @@ private void OnNavigateBarRequested(int direction) =>
 
     private async Task OpenBarAsync(TopLevel bar, int index, bool focusFirst = true, bool captureOpener = true)
     {
-        // Tag this open request so out-of-order JS interop completions from rapid hover/keyboard
-        // navigation (or a close that happens mid-await) don't activate the wrong bar.
         var requestId = Interlocked.Increment(ref _openRequestId);
 
-        // Anchor the dropdown to the bottom-left of the trigger button.
         _menuAnchorModule ??= await JSRuntime.InvokeAsync<IJSObjectReference>(
             "import", "./_content/EventLogExpert.UI/Menu/MenuAnchor.js");
 
diff --git a/src/EventLogExpert.UI/Menu/MenuHost.razor.cs b/src/EventLogExpert.UI/Menu/MenuHost.razor.cs
index 77502e54e..da3b408b0 100644
--- a/src/EventLogExpert.UI/Menu/MenuHost.razor.cs
+++ b/src/EventLogExpert.UI/Menu/MenuHost.razor.cs
@@ -1,7 +1,6 @@
 // // Copyright (c) Microsoft Corporation.
 // // Licensed under the MIT License.
 
-using EventLogExpert.Runtime.Menu;
 using EventLogExpert.UI.Common.Interop;
 using Microsoft.AspNetCore.Components;
 using Microsoft.AspNetCore.Components.Web;
@@ -37,15 +36,9 @@ public async ValueTask DisposeAsync()
 
         _disposed = true;
 
-        // Unsubscribe BEFORE Close() - Close() synchronously raises StateChanged,
-        // which would re-enter OnStateChanged and queue an InvokeAsync that runs
-        // after dispose completes.
         MenuService.StateChanged -= OnStateChanged;
         Registry.ActiveHostChanged -= OnActiveHostChanged;
 
-        // Close on live MenuService state, not on the queued-lambda-mutated
-        // _focusedMenuId - that mirror can lag the singleton when dispose
-        // races a fresh OpenAt.
         if (IsActive && MenuService.ActiveItems is not null)
         {
             MenuService.Close();
@@ -76,7 +69,6 @@ protected override async Task OnAfterRenderAsync(bool firstRender)
             return;
         }
 
-        // Re-clamp every render - popup is hidden until clampMenuPopup reveals it within the viewport.
         if (MenuService.ActiveItems is not null)
         {
             try { await (await GetMenuOverlayAsync()).InvokeVoidAsync("clampMenuPopup", _popupElement); }
@@ -103,7 +95,6 @@ private async ValueTask<IJSObjectReference> GetMenuOverlayAsync() =>
 
     private void HandleKeyDown(KeyboardEventArgs args)
     {
-        // Host-level Escape fallback when focus has drifted outside the menu list (e.g., onto the overlay).
         if (args.Key == "Escape") { MenuService.Close(); }
     }
 
@@ -126,11 +117,8 @@ private void OnActiveHostChanged()
 
     private void OnStateChanged()
     {
-        // Inactive hosts stay subscribed but skip render + JS interop so the
-        // active topmost host owns the menu lifecycle.
         if (_disposed || !IsActive) { return; }
 
-        // StateChanged may fire from arbitrary threads - marshal through the renderer dispatcher.
         _ = InvokeAsync(async () =>
         {
             if (_disposed || !IsActive) { return; }
@@ -140,12 +128,8 @@ private void OnStateChanged()
 
             if (nowOpen && MenuService.ActiveMenuId != _focusedMenuId)
             {
-                // Update synchronously before any await so a re-entrant OnStateChanged
-                // (open immediately followed by close) sees the correct wasOpen.
                 _focusedMenuId = MenuService.ActiveMenuId;
 
-                // Capture the opener before StateHasChanged so document.activeElement is still
-                // the element that triggered the menu, not an item the renderer is about to focus.
                 if (MenuService.ActiveCaptureOpener)
                 {
                     try { await (await GetMenuOverlayAsync()).InvokeVoidAsync("captureMenuOpener"); }
diff --git a/src/EventLogExpert.Runtime/Menu/MenuItem.cs b/src/EventLogExpert.UI/Menu/MenuItem.cs
similarity index 64%
rename from src/EventLogExpert.Runtime/Menu/MenuItem.cs
rename to src/EventLogExpert.UI/Menu/MenuItem.cs
index 430513e02..017fe8980 100644
--- a/src/EventLogExpert.Runtime/Menu/MenuItem.cs
+++ b/src/EventLogExpert.UI/Menu/MenuItem.cs
@@ -1,13 +1,8 @@
 // // Copyright (c) Microsoft Corporation.
 // // Licensed under the MIT License.
 
-namespace EventLogExpert.Runtime.Menu;
+namespace EventLogExpert.UI.Menu;
 
-/// <summary>
-///     Immutable description of a single entry in a menu (menu bar dropdown, context menu, or submenu). Used by the
-///     data-driven MenuRenderer; pair instances via <see cref="Children" /> or <see cref="ChildrenLoader" /> to build
-///     trees.
-/// </summary>
 public sealed record MenuItem
 {
     public string Label { get; init; } = string.Empty;
@@ -22,10 +17,6 @@ public sealed record MenuItem
 
     public Func<Task<IReadOnlyList<MenuItem>>>? ChildrenLoader { get; init; }
 
-    /// <summary>
-    ///     <c>null</c> for non-checkable items; <c>true</c>/<c>false</c> for checkable items so screen readers can
-    ///     announce the toggle state via <c>role="menuitemcheckbox"</c> + <c>aria-checked</c>.
-    /// </summary>
     public bool? IsChecked { get; init; }
 
     public bool IsSeparator { get; init; }
@@ -34,20 +25,10 @@ public sealed record MenuItem
 
     public bool IsDanger { get; init; }
 
-    /// <summary>
-    ///     Optional explanation surfaced to assistive tech (and as a hover title) when <see cref="IsEnabled" /> is
-    ///     <c>false</c>. Items with a non-null reason participate in roving focus and type-ahead so keyboard / screen-reader
-    ///     users can discover that the option exists; activation is still blocked. Use for "not available because X" cases
-    ///     where users need to know the option is there (e.g., "Cached - empty: add filters first").
-    /// </summary>
     public string? DisabledReason { get; init; }
 
     public string? StatusText { get; init; }
 
-    /// <summary>
-    ///     True when the item should participate in roving focus / type-ahead. Enabled items are always focusable;
-    ///     disabled items are focusable only when they expose a <see cref="DisabledReason" /> (informative-disabled pattern).
-    /// </summary>
     public bool IsFocusable => !IsSeparator && (IsEnabled || DisabledReason is not null);
 
     public static MenuItem Separator() => new() { IsSeparator = true };
diff --git a/src/EventLogExpert.UI/Menu/MenuRenderer.razor.cs b/src/EventLogExpert.UI/Menu/MenuRenderer.razor.cs
index 7b6c9e214..e19961b1b 100644
--- a/src/EventLogExpert.UI/Menu/MenuRenderer.razor.cs
+++ b/src/EventLogExpert.UI/Menu/MenuRenderer.razor.cs
@@ -1,7 +1,6 @@
 // // Copyright (c) Microsoft Corporation.
 // // Licensed under the MIT License.
 
-using EventLogExpert.Runtime.Menu;
 using EventLogExpert.UI.Common.Interop;
 using Microsoft.AspNetCore.Components;
 using Microsoft.AspNetCore.Components.Web;
@@ -11,13 +10,9 @@ namespace EventLogExpert.UI.Menu;
 
 public sealed partial class MenuRenderer : IAsyncDisposable
 {
-    // Constant rather than method-level call because Blazor's @onkeydown:preventDefault must
-    // resolve at render time. Tab is handled in HandleListKeyDown so it can close the menu first.
     private const bool PreventDefaultKeyDown = true;
 
-    // Type-ahead matches reset after this idle window (WAI-ARIA Authoring Practices guidance).
     private static readonly TimeSpan s_typeAheadResetWindow = TimeSpan.FromMilliseconds(500);
-    // Per-instance suffix for aria-describedby ids so nested MenuRenderers don't collide.
     private static long s_rendererIdCounter;
 
     private readonly long _rendererId = Interlocked.Increment(ref s_rendererIdCounter);
@@ -35,35 +30,18 @@ public sealed partial class MenuRenderer : IAsyncDisposable
     private string _typeAheadBuffer = string.Empty;
     private DateTimeOffset _typeAheadLastInputAt = DateTimeOffset.MinValue;
 
-    /// <summary>0 for first enabled item, -1 for last. Used by hosts that open the menu via ArrowUp/ArrowDown.</summary>
     [Parameter] public int InitialFocusIndex { get; set; }
 
-    /// <summary>True for the inner <see cref="MenuRenderer" /> instance rendered inside an open submenu.</summary>
     [Parameter] public bool IsSubmenu { get; set; }
 
     [Parameter] public IReadOnlyList<MenuItem>? Items { get; set; }
 
-    /// <summary>
-    ///     Raised when a leaf item (one without children) is activated. Hosts use this to close the popup. Bubbles up
-    ///     through nested renderers.
-    /// </summary>
     [Parameter] public EventCallback OnActivated { get; set; }
 
-    /// <summary>Raised when the user presses ArrowLeft inside a submenu so the parent can collapse and refocus.</summary>
     [Parameter] public EventCallback OnCloseSubmenu { get; set; }
 
-    /// <summary>
-    ///     Raised when the top-level menu wants the menubar to switch to the previous (-1) or next (+1) bar item. Hosts
-    ///     that don't sit on a menubar can ignore this.
-    /// </summary>
     [Parameter] public EventCallback<int> OnNavigateBar { get; set; }
 
-    /// <summary>
-    ///     When true, the renderer will not set <c>_focusedIndex</c> from <see cref="InitialFocusIndex" /> on parameter
-    ///     changes and will not auto-focus the first enabled item on first render. Used for hover-opened submenus so keyboard
-    ///     focus stays on the parent item per WAI-ARIA menu guidance - focus only enters the submenu when the user explicitly
-    ///     opens it via Enter/Space/ArrowRight.
-    /// </summary>
     [Parameter] public bool SuppressInitialFocus { get; set; }
 
     [Inject] private IJSRuntime JSRuntime { get; init; } = null!;
@@ -79,7 +57,6 @@ public async ValueTask DisposeAsync()
         _rendererModule = null;
     }
 
-    /// <summary>Programmatically focus the first/last item; called by hosts after the popup is in the DOM.</summary>
     public Task FocusInitialAsync(bool focusFirst)
     {
         if (Items is null) { return Task.CompletedTask; }
@@ -136,8 +113,6 @@ protected override void OnParametersSet()
             }
             else if (SuppressInitialFocus)
             {
-                // Hover-opened submenu: keep focus on the parent until the user explicitly enters
-                // via Enter/Space/ArrowRight (which re-opens without SuppressInitialFocus).
                 _focusedIndex = -1;
             }
             else
@@ -149,8 +124,6 @@ protected override void OnParametersSet()
         }
         else if (_previousSuppressInitialFocus && !SuppressInitialFocus && _focusedIndex < 0 && Items is not null)
         {
-            // SuppressInitialFocus flipped false while Items stayed the same reference - user
-            // stepped into a hover-opened submenu, so move focus into it.
             _focusedIndex = InitialFocusIndex == 0
                 ? FindEnabledIndex(0, +1)
                 : FindEnabledIndex(Items.Count - 1, -1);
@@ -179,7 +152,6 @@ private int FindEnabledIndex(int start, int direction)
 
     private async Task HandleArrowLeftAsync()
     {
-        // Submenu: collapse to parent. Top-level menu: ask the menubar to switch entries.
         if (IsSubmenu) { await OnCloseSubmenu.InvokeAsync(); }
         else { await OnNavigateBar.InvokeAsync(-1); }
     }
@@ -197,8 +169,6 @@ private async Task HandleArrowRightAsync()
             return;
         }
 
-        // Top-level leaf: ArrowRight advances the menubar. Submenus stay put so users don't lose
-        // their place while navigating.
         if (!IsSubmenu) { await OnNavigateBar.InvokeAsync(+1); }
     }
 
@@ -228,7 +198,6 @@ private async Task HandleListKeyDown(KeyboardEventArgs args)
                 return;
             case "Enter":
             case " ":
-                // Block auto-repeat on activation keys; navigation keys above intentionally allow it.
                 if (args.Repeat) { return; }
 
                 if (_focusedIndex >= 0) { await OnItemActivate(Items[_focusedIndex], _focusedIndex); }
@@ -240,14 +209,11 @@ private async Task HandleListKeyDown(KeyboardEventArgs args)
 
                 return;
             case "Tab":
-                // WAI-ARIA: Tab/Shift+Tab closes the entire menu. preventDefault on the <ul>
-                // blocks browser tab traversal so focus-restore lands on the opener first.
                 await OnActivated.InvokeAsync();
 
                 return;
         }
 
-        // Type-ahead: any single printable character. KeyboardEventArgs.Key respects keyboard layout.
         if (args.Key.Length == 1 && !char.IsControl(args.Key, 0))
         {
             HandleTypeAhead(args.Key);
@@ -268,8 +234,6 @@ private void HandleTypeAhead(string typedKey)
         _typeAheadLastInputAt = now;
         _typeAheadBuffer += typedKey;
 
-        // A buffer of all-the-same-character cycles through matches (e.g., 'S' twice: Save -> System).
-        // Multi-character buffers do exact prefix matching.
         bool repeatedSameChar = true;
 
         for (int charIndex = 1; charIndex < _typeAheadBuffer.Length; charIndex++)
@@ -285,7 +249,6 @@ private void HandleTypeAhead(string typedKey)
         bool isCycling = _typeAheadBuffer.Length == 1 || repeatedSameChar;
         string matchPrefix = isCycling ? _typeAheadBuffer[..1] : _typeAheadBuffer;
 
-        // Cycling matches start after the focused item; multi-letter buffers match from the start.
         int startIndex = isCycling
             ? (_focusedIndex < 0 ? 0 : (_focusedIndex + 1) % Items.Count)
             : 0;
@@ -359,7 +322,6 @@ private async Task OnItemActivate(MenuItem item, int index)
 
         if (item.OnClickAsync is not null)
         {
-            // Surface activation BEFORE invoking so the popup tears down before any modal opens.
             await OnActivated.InvokeAsync();
             await item.OnClickAsync();
         }
@@ -373,8 +335,6 @@ private void OnItemHover(MenuItem item, int index)
     {
         if (!item.IsFocusable) { return; }
 
-        // Informative-disabled items: move focus on hover so the disabled reason is announced,
-        // but never open a submenu or change submenu state.
         if (!item.IsEnabled)
         {
             if (_focusedIndex == index) { return; }
@@ -389,8 +349,6 @@ private void OnItemHover(MenuItem item, int index)
 
         if (item.Children is null && item.ChildrenLoader is null)
         {
-            // Hovering a leaf collapses any open sibling submenu and moves focus to the leaf
-            // so roving tabindex stays in sync with _focusedIndex.
             if (_openItem is null && _focusedIndex == index) { return; }
 
             _openItem = null;
@@ -474,7 +432,6 @@ private async Task TryFocusCurrentAsync()
 
         try
         {
-            // preventScroll keeps the page steady; scrollMenuItemIntoView scrolls within the menu panel.
             await _itemElements[_focusedIndex].FocusAsync(true);
 
             try
diff --git a/src/EventLogExpert.Runtime/Menu/MenuService.cs b/src/EventLogExpert.UI/Menu/MenuService.cs
similarity index 97%
rename from src/EventLogExpert.Runtime/Menu/MenuService.cs
rename to src/EventLogExpert.UI/Menu/MenuService.cs
index 5476d1484..c1321f7be 100644
--- a/src/EventLogExpert.Runtime/Menu/MenuService.cs
+++ b/src/EventLogExpert.UI/Menu/MenuService.cs
@@ -1,7 +1,7 @@
 // // Copyright (c) Microsoft Corporation.
 // // Licensed under the MIT License.
 
-namespace EventLogExpert.Runtime.Menu;
+namespace EventLogExpert.UI.Menu;
 
 internal sealed class MenuService : IMenuService
 {
diff --git a/src/EventLogExpert.UI/Modal/IModalCoordinator.cs b/src/EventLogExpert.UI/Modal/IModalCoordinator.cs
new file mode 100644
index 000000000..759e1888e
--- /dev/null
+++ b/src/EventLogExpert.UI/Modal/IModalCoordinator.cs
@@ -0,0 +1,33 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.UI.Alerts;
+using Microsoft.AspNetCore.Components;
+using System.Diagnostics.CodeAnalysis;
+
+namespace EventLogExpert.UI.Modal;
+
+public interface IModalCoordinator
+{
+    event Action? StateChanged;
+
+    ModalSession? ActiveSession { get; }
+
+    void Complete<TResult>(ModalId modalId, TResult? result);
+
+    void ForceCloseActive();
+
+    ModalScope? GetActiveModalScope();
+
+    Task<ModalOpenResult<TResult>> PushAsync<TModal, TResult>(IDictionary<string, object?>? parameters = null)
+        where TModal : IComponent;
+
+    void RegisterModal(ModalRegistration registration);
+
+    Task<bool> RequestCloseActiveAsync(ModalCloseReason reason);
+
+    bool TryGetInlineAlertHost([NotNullWhen(true)] out IInlineAlertHost? host);
+
+    void UnregisterModal(ModalId modalId);
+}
+
diff --git a/src/EventLogExpert.UI/Modal/IModalService.cs b/src/EventLogExpert.UI/Modal/IModalService.cs
new file mode 100644
index 000000000..1473bc11d
--- /dev/null
+++ b/src/EventLogExpert.UI/Modal/IModalService.cs
@@ -0,0 +1,24 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using Microsoft.AspNetCore.Components;
+
+namespace EventLogExpert.UI.Modal;
+
+public interface IModalService
+{
+    event Action? StateChanged;
+
+    ModalId ActiveModalId { get; }
+
+    IDictionary<string, object?>? ActiveModalParameters { get; }
+
+    Type? ActiveModalType { get; }
+
+    void CancelActive();
+
+    void Complete<TResult>(ModalId modalId, TResult? result);
+
+    Task<TResult?> Show<TModal, TResult>(IDictionary<string, object?>? parameters = null)
+        where TModal : IComponent;
+}
diff --git a/src/EventLogExpert.UI/Modal/ModalBase.cs b/src/EventLogExpert.UI/Modal/ModalBase.cs
index 514d351c6..b985bcd4e 100644
--- a/src/EventLogExpert.UI/Modal/ModalBase.cs
+++ b/src/EventLogExpert.UI/Modal/ModalBase.cs
@@ -1,39 +1,42 @@
 // // Copyright (c) Microsoft Corporation.
 // // Licensed under the MIT License.
 
-using EventLogExpert.Runtime.Alerts;
-using EventLogExpert.Runtime.Modal;
-using Fluxor.Blazor.Web.Components;
+using EventLogExpert.UI.Alerts;
 using Microsoft.AspNetCore.Components;
 
 namespace EventLogExpert.UI.Modal;
 
-/// <summary>
-///     Base for modals shown via <see cref="IModalService" />. Owns the per-show id handshake with the service and
-///     provides Complete/Cancel helpers that close the dialog before completing the task.
-/// </summary>
-public abstract class ModalBase<TResult> : FluxorComponent, IInlineAlertHost
+public abstract class ModalBase<TResult> : ComponentBase, IInlineAlertHost, IAsyncDisposable
 {
     private readonly Lock _inlineAlertLock = new();
 
     private InlineAlertEntry? _activeInlineAlert;
+    private volatile bool _isDisposed;
     private ModalId _modalId;
 
     [Inject] internal IModalCoordinator ModalCoordinator { get; init; } = null!;
 
     [Inject] internal IModalService ModalService { get; init; } = null!;
 
-    /// <summary>Bound by concrete modals via <c>@ref</c> on their <see cref="ModalChrome" />.</summary>
     protected ModalChrome? ChromeRef { get; set; }
 
     protected InlineAlertRequest? CurrentInlineAlert => _activeInlineAlert?.Request;
 
-    /// <summary>Override to mark the modal as Critical (rejects cross-modal cancel via the veto pipeline).</summary>
+    protected bool IsDisposed => _isDisposed;
+
     protected virtual ModalScope Scope => ModalScope.Standard;
 
     public Task CloseAsync() => CompleteAsync(default);
 
-    /// <inheritdoc />
+    public async ValueTask DisposeAsync()
+    {
+        if (_isDisposed) { return; }
+
+        _isDisposed = true;
+        await DisposeAsyncCore(true);
+        GC.SuppressFinalize(this);
+    }
+
     public async Task<InlineAlertResult> ShowInlineAlertAsync(InlineAlertRequest request, CancellationToken cancellationToken)
     {
         ArgumentNullException.ThrowIfNull(request);
@@ -48,7 +51,6 @@ public async Task<InlineAlertResult> ShowInlineAlertAsync(InlineAlertRequest req
             _activeInlineAlert = entry;
         }
 
-        // Replace semantics: a stacked alert cancels any prior one.
         if (prior is not null)
         {
             await prior.CancellationRegistration.DisposeAsync();
@@ -72,8 +74,6 @@ public async Task<InlineAlertResult> ShowInlineAlertAsync(InlineAlertRequest req
         return await tcs.Task;
     }
 
-    // Called by ModalCoordinator. Runs the veto check, then routes to OnCancelAsync (which derived
-    // modals may override for cancel-default-value semantics like PromptModal's string.Empty).
     internal async Task<bool> RequestCloseAsync(ModalCloseRequest request)
     {
         bool accepted = await OnRequestCloseAsync(request);
@@ -95,11 +95,10 @@ protected async Task CompleteAsync(TResult? result)
         ModalService.Complete(_modalId, result);
     }
 
-    protected override async ValueTask DisposeAsyncCore(bool disposing)
+    protected virtual async ValueTask DisposeAsyncCore(bool disposing)
     {
         if (disposing)
         {
-            // Cancel pending inline alert so background callers don't hang on a torn-down modal.
             InlineAlertEntry? pending;
 
             lock (_inlineAlertLock)
@@ -116,20 +115,13 @@ protected override async ValueTask DisposeAsyncCore(bool disposing)
 
             ModalCoordinator.UnregisterModal(_modalId);
 
-            // Defensive: complete the task if we were torn down without an explicit close path.
-            // Stale ids are ignored, so this is a no-op when Complete already ran.
             ModalService.Complete(_modalId, default(TResult));
         }
-
-        await base.DisposeAsyncCore(disposing);
     }
 
-    /// <summary>UI button (Cancel/Close) entry point - routes through the coordinator's veto pipeline.</summary>
     protected Task HandleCancelButtonClickAsync() =>
         ModalCoordinator.RequestCloseActiveAsync(ModalCloseReason.UserDismiss);
 
-    // Route Esc/native-close through the coordinator's veto pipeline. The native dialog handler
-    // can't distinguish Esc from backdrop click, so UserDismiss (generic) is the right reason.
     protected Task HandleDialogClosedByUserAsync() =>
         ModalCoordinator.RequestCloseActiveAsync(ModalCloseReason.UserDismiss);
 
@@ -154,7 +146,6 @@ protected async Task HandleInlineAlertResolvedAsync(InlineAlertResult result)
 
     protected virtual Task OnCancelAsync() => CompleteAsync(default);
 
-    /// <summary>Cleanup hook invoked on every close path. Override for side-effects.</summary>
     protected virtual Task OnClosingAsync() => Task.CompletedTask;
 
     protected virtual Task OnExportAsync() => Task.CompletedTask;
@@ -163,24 +154,29 @@ protected async Task HandleInlineAlertResolvedAsync(InlineAlertResult result)
 
     protected override void OnInitialized()
     {
-        // Capture the active id so a stale modal can never complete a successor's task.
         _modalId = ModalService.ActiveModalId;
         var registration = new ModalRegistration(_modalId, RequestCloseAsync, Scope, this);
         ModalCoordinator.RegisterModal(registration);
         base.OnInitialized();
     }
 
-    /// <summary>Veto hook for modal close requests. Override to block close conditionally (return <see langword="false" />).</summary>
-    /// <remarks>
-    ///     Calling <see cref="IModalCoordinator.RequestCloseActiveAsync" /> from inside this method is unsupported and
-    ///     will deadlock on the coordinator's in-flight close TCS. Throwing <see cref="OperationCanceledException" /> from
-    ///     this method is interpreted by the coordinator as accepting the close.
-    /// </remarks>
     protected virtual Task<bool> OnRequestCloseAsync(ModalCloseRequest request) => Task.FromResult(true);
 
     protected virtual Task OnSaveAsync() => CompleteAsync(default);
 
-    // Sync dispose path for the cancellation callback (BCL Action delegate forces sync - see ShowInlineAlertAsync.Register).
+    private async Task DispatchGuardedRenderAsync()
+    {
+        try
+        {
+            await InvokeAsync(() =>
+            {
+                if (!IsDisposed) { StateHasChanged(); }
+            });
+        }
+        catch (ObjectDisposedException) { /* Renderer torn down between the guard and the dispatch. */ }
+        catch (OperationCanceledException) { /* Circuit shutting down. */ }
+    }
+
     private void TryClearInlineAlertFromCallback(InlineAlertEntry expected, InlineAlertResult? result, bool cancel)
     {
         InlineAlertEntry? cleared;
@@ -206,7 +202,9 @@ private void TryClearInlineAlertFromCallback(InlineAlertEntry expected, InlineAl
             cleared.Tcs.TrySetResult(result ?? new InlineAlertResult(false, null));
         }
 
-        _ = InvokeAsync(StateHasChanged);
+        if (IsDisposed) { return; }
+
+        _ = DispatchGuardedRenderAsync();
     }
 
     private sealed class InlineAlertEntry(InlineAlertRequest request, TaskCompletionSource<InlineAlertResult> tcs)
diff --git a/src/EventLogExpert.UI/Modal/ModalChrome.razor.cs b/src/EventLogExpert.UI/Modal/ModalChrome.razor.cs
index 31525d696..5027cc61e 100644
--- a/src/EventLogExpert.UI/Modal/ModalChrome.razor.cs
+++ b/src/EventLogExpert.UI/Modal/ModalChrome.razor.cs
@@ -1,7 +1,7 @@
 // // Copyright (c) Microsoft Corporation.
 // // Licensed under the MIT License.
 
-using EventLogExpert.Runtime.Alerts;
+using EventLogExpert.UI.Alerts;
 using EventLogExpert.UI.Banner;
 using EventLogExpert.UI.Common;
 using EventLogExpert.UI.Common.Interop;
@@ -88,11 +88,6 @@ public sealed partial class ModalChrome : ComponentBase, IAsyncDisposable
 
     [Parameter] public bool ShowCloseButton { get; set; }
 
-    /// <summary>
-    ///     Opt the footer-extra slot into a full-width row above the action buttons, instead of sharing the row with
-    ///     them. Use when the extra content is a label/control pair that should align with the dialog body rather than compete
-    ///     with the button row for horizontal space.
-    /// </summary>
     [Parameter] public bool StackFooterExtra { get; set; }
 
     [Parameter] public string? Title { get; set; }
diff --git a/src/EventLogExpert.Runtime/Modal/ModalCloseReason.cs b/src/EventLogExpert.UI/Modal/ModalCloseReason.cs
similarity index 84%
rename from src/EventLogExpert.Runtime/Modal/ModalCloseReason.cs
rename to src/EventLogExpert.UI/Modal/ModalCloseReason.cs
index 5aed690bd..029d74f14 100644
--- a/src/EventLogExpert.Runtime/Modal/ModalCloseReason.cs
+++ b/src/EventLogExpert.UI/Modal/ModalCloseReason.cs
@@ -1,7 +1,7 @@
 // // Copyright (c) Microsoft Corporation.
 // // Licensed under the MIT License.
 
-namespace EventLogExpert.Runtime.Modal;
+namespace EventLogExpert.UI.Modal;
 
 public enum ModalCloseReason
 {
diff --git a/src/EventLogExpert.Runtime/Modal/ModalCloseRequest.cs b/src/EventLogExpert.UI/Modal/ModalCloseRequest.cs
similarity index 79%
rename from src/EventLogExpert.Runtime/Modal/ModalCloseRequest.cs
rename to src/EventLogExpert.UI/Modal/ModalCloseRequest.cs
index 607fccba2..8fc3693b2 100644
--- a/src/EventLogExpert.Runtime/Modal/ModalCloseRequest.cs
+++ b/src/EventLogExpert.UI/Modal/ModalCloseRequest.cs
@@ -1,6 +1,6 @@
 // // Copyright (c) Microsoft Corporation.
 // // Licensed under the MIT License.
 
-namespace EventLogExpert.Runtime.Modal;
+namespace EventLogExpert.UI.Modal;
 
 public readonly record struct ModalCloseRequest(ModalCloseReason Reason);
diff --git a/src/EventLogExpert.Runtime/Modal/ModalCoordinator.cs b/src/EventLogExpert.UI/Modal/ModalCoordinator.cs
similarity index 81%
rename from src/EventLogExpert.Runtime/Modal/ModalCoordinator.cs
rename to src/EventLogExpert.UI/Modal/ModalCoordinator.cs
index 58985abb0..9f6f86bd1 100644
--- a/src/EventLogExpert.Runtime/Modal/ModalCoordinator.cs
+++ b/src/EventLogExpert.UI/Modal/ModalCoordinator.cs
@@ -1,11 +1,11 @@
 // // Copyright (c) Microsoft Corporation.
 // // Licensed under the MIT License.
 
-using EventLogExpert.Runtime.Alerts;
+using EventLogExpert.UI.Alerts;
 using Microsoft.AspNetCore.Components;
 using System.Diagnostics.CodeAnalysis;
 
-namespace EventLogExpert.Runtime.Modal;
+namespace EventLogExpert.UI.Modal;
 
 internal sealed class ModalCoordinator : IModalCoordinator, IDisposable
 {
@@ -16,6 +16,7 @@ internal sealed class ModalCoordinator : IModalCoordinator, IDisposable
     private ModalRegistration? _activeRegistration;
     private ModalSession? _activeSession;
     private bool _disposed;
+    private ModalId _inFlightCloseModalId;
     private TaskCompletionSource<bool>? _inFlightCloseTcs;
 
     public ModalCoordinator(IModalService modalService)
@@ -62,8 +63,6 @@ public async Task<ModalOpenResult<TResult>> PushAsync<TModal, TResult>(IDictiona
 
         try
         {
-            // Use the service-derived active id (immediately available) rather than _activeRegistration
-            // (component-lifecycle gap between Show and OnInitialized's RegisterModal).
             if (_modalService.ActiveModalId != ModalId.None)
             {
                 bool accepted = await RequestCloseActiveAsync(ModalCloseReason.OtherModalActivation);
@@ -104,7 +103,6 @@ public async Task<bool> RequestCloseActiveAsync(ModalCloseReason reason)
         {
             ModalRegistration? activeRegistration = GetActiveRegistration();
 
-            // Scope policy FIRST (before coalescing) so Critical+OtherModalActivation is always rejected.
             if (activeRegistration is not null
                 && activeRegistration.Scope == ModalScope.Critical
                 && reason == ModalCloseReason.OtherModalActivation)
@@ -112,14 +110,14 @@ public async Task<bool> RequestCloseActiveAsync(ModalCloseReason reason)
                 return false;
             }
 
-            if (_inFlightCloseTcs is not null)
+            if (_inFlightCloseTcs is not null
+                && activeRegistration is not null
+                && _inFlightCloseModalId == activeRegistration.ModalId)
             {
                 inFlight = _inFlightCloseTcs.Task;
             }
             else if (activeRegistration is null)
             {
-                // Init-window guard: the service may publish ActiveModalId before OnInitialized's RegisterModal lands.
-                // Reject OtherModalActivation during the gap so a not-yet-registered modal can't be preempted past its scope policy.
                 return reason != ModalCloseReason.OtherModalActivation || _modalService.ActiveModalId == ModalId.None;
             }
             else
@@ -127,6 +125,7 @@ public async Task<bool> RequestCloseActiveAsync(ModalCloseReason reason)
                 snapshot = activeRegistration;
                 newTcs = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
                 _inFlightCloseTcs = newTcs;
+                _inFlightCloseModalId = activeRegistration.ModalId;
             }
         }
 
@@ -151,7 +150,14 @@ public async Task<bool> RequestCloseActiveAsync(ModalCloseReason reason)
         }
         finally
         {
-            lock (_stateLock) { _inFlightCloseTcs = null; }
+            lock (_stateLock)
+            {
+                if (ReferenceEquals(_inFlightCloseTcs, newTcs))
+                {
+                    _inFlightCloseTcs = null;
+                    _inFlightCloseModalId = ModalId.None;
+                }
+            }
         }
     }
 
@@ -176,10 +182,6 @@ public void UnregisterModal(ModalId modalId)
         }
     }
 
-    // Stale-clear inside the read path: ModalService publishes ActiveModalId changes BEFORE firing StateChanged,
-    // so reads via _activeRegistration can race the registration's modal being cancelled/completed. If the
-    // stored registration's id no longer matches the service, drop it and return null — the next OnInitialized
-    // (or OnModalServiceStateChanged backstop) will install the correct successor.
     private ModalRegistration? GetActiveRegistration()
     {
         if (_activeRegistration is null) { return null; }
@@ -204,14 +206,12 @@ private void OnModalServiceStateChanged()
             Type? type = _modalService.ActiveModalType;
             IDictionary<string, object?>? parameters = _modalService.ActiveModalParameters;
 
-            // Re-read id after type/parameters reads; bail if a concurrent mutation could have torn the snapshot.
             if (_modalService.ActiveModalId != id) { return; }
 
             ModalSession? newSession = type is null ? null : new ModalSession(id, type, parameters);
             changed = !Equals(_activeSession, newSession);
             _activeSession = newSession;
 
-            // Stale-clear: drop _activeRegistration if the active id moved past it.
             if (_activeRegistration is not null && _activeRegistration.ModalId != id)
             {
                 _activeRegistration = null;
diff --git a/src/EventLogExpert.UI/Modal/ModalCoordinatorLaunchers.cs b/src/EventLogExpert.UI/Modal/ModalCoordinatorLaunchers.cs
index ea644973d..027214320 100644
--- a/src/EventLogExpert.UI/Modal/ModalCoordinatorLaunchers.cs
+++ b/src/EventLogExpert.UI/Modal/ModalCoordinatorLaunchers.cs
@@ -1,7 +1,6 @@
 // // Copyright (c) Microsoft Corporation.
 // // Licensed under the MIT License.
 
-using EventLogExpert.Runtime.Modal;
 using EventLogExpert.Runtime.Update.ReleaseNotes;
 using EventLogExpert.UI.Database;
 using EventLogExpert.UI.DatabaseTools;
@@ -12,7 +11,6 @@
 
 namespace EventLogExpert.UI.Modal;
 
-/// <summary>Typed launchers that route production modal opens through the coordinator's veto pipeline.</summary>
 public static class ModalCoordinatorLaunchers
 {
     extension(IModalCoordinator coordinator)
diff --git a/src/EventLogExpert.UI/Modal/ModalHost.razor.cs b/src/EventLogExpert.UI/Modal/ModalHost.razor.cs
index b769b853d..c443b7800 100644
--- a/src/EventLogExpert.UI/Modal/ModalHost.razor.cs
+++ b/src/EventLogExpert.UI/Modal/ModalHost.razor.cs
@@ -1,7 +1,6 @@
 // // Copyright (c) Microsoft Corporation.
 // // Licensed under the MIT License.
 
-using EventLogExpert.Runtime.Modal;
 using Microsoft.AspNetCore.Components;
 
 namespace EventLogExpert.UI.Modal;
diff --git a/src/EventLogExpert.Runtime/Modal/ModalId.cs b/src/EventLogExpert.UI/Modal/ModalId.cs
similarity index 51%
rename from src/EventLogExpert.Runtime/Modal/ModalId.cs
rename to src/EventLogExpert.UI/Modal/ModalId.cs
index 9ea27e8af..c9869cb18 100644
--- a/src/EventLogExpert.Runtime/Modal/ModalId.cs
+++ b/src/EventLogExpert.UI/Modal/ModalId.cs
@@ -1,12 +1,8 @@
 // // Copyright (c) Microsoft Corporation.
 // // Licensed under the MIT License.
 
-namespace EventLogExpert.Runtime.Modal;
+namespace EventLogExpert.UI.Modal;
 
-/// <summary>
-///     Strongly-typed identifier for an active modal session. Wraps the per-show counter assigned by
-///     <see cref="IModalService" />.
-/// </summary>
 public readonly record struct ModalId(long Value)
 {
     public static ModalId None => new(0);
diff --git a/src/EventLogExpert.UI/Modal/ModalOpenResult.cs b/src/EventLogExpert.UI/Modal/ModalOpenResult.cs
new file mode 100644
index 000000000..a9369211a
--- /dev/null
+++ b/src/EventLogExpert.UI/Modal/ModalOpenResult.cs
@@ -0,0 +1,6 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+namespace EventLogExpert.UI.Modal;
+
+public sealed record ModalOpenResult<TResult>(TResult? Result, bool WasOpened);
diff --git a/src/EventLogExpert.Runtime/Modal/ModalRegistration.cs b/src/EventLogExpert.UI/Modal/ModalRegistration.cs
similarity index 90%
rename from src/EventLogExpert.Runtime/Modal/ModalRegistration.cs
rename to src/EventLogExpert.UI/Modal/ModalRegistration.cs
index 98ff76938..9d40bdaae 100644
--- a/src/EventLogExpert.Runtime/Modal/ModalRegistration.cs
+++ b/src/EventLogExpert.UI/Modal/ModalRegistration.cs
@@ -1,9 +1,9 @@
 // // Copyright (c) Microsoft Corporation.
 // // Licensed under the MIT License.
 
-using EventLogExpert.Runtime.Alerts;
+using EventLogExpert.UI.Alerts;
 
-namespace EventLogExpert.Runtime.Modal;
+namespace EventLogExpert.UI.Modal;
 
 public sealed class ModalRegistration
 {
diff --git a/src/EventLogExpert.Runtime/Modal/ModalScope.cs b/src/EventLogExpert.UI/Modal/ModalScope.cs
similarity index 77%
rename from src/EventLogExpert.Runtime/Modal/ModalScope.cs
rename to src/EventLogExpert.UI/Modal/ModalScope.cs
index 049114606..3a60ee64f 100644
--- a/src/EventLogExpert.Runtime/Modal/ModalScope.cs
+++ b/src/EventLogExpert.UI/Modal/ModalScope.cs
@@ -1,7 +1,7 @@
 // // Copyright (c) Microsoft Corporation.
 // // Licensed under the MIT License.
 
-namespace EventLogExpert.Runtime.Modal;
+namespace EventLogExpert.UI.Modal;
 
 public enum ModalScope
 {
diff --git a/src/EventLogExpert.Runtime/Modal/ModalService.cs b/src/EventLogExpert.UI/Modal/ModalService.cs
similarity index 83%
rename from src/EventLogExpert.Runtime/Modal/ModalService.cs
rename to src/EventLogExpert.UI/Modal/ModalService.cs
index 938977a31..00fd523fc 100644
--- a/src/EventLogExpert.Runtime/Modal/ModalService.cs
+++ b/src/EventLogExpert.UI/Modal/ModalService.cs
@@ -3,7 +3,7 @@
 
 using Microsoft.AspNetCore.Components;
 
-namespace EventLogExpert.Runtime.Modal;
+namespace EventLogExpert.UI.Modal;
 
 internal sealed class ModalService : IModalService
 {
@@ -57,8 +57,6 @@ public void Complete<TResult>(ModalId modalId, TResult? result)
 
             if (_activeTcs is not TaskCompletionSource<TResult?> tcs)
             {
-                // TResult mismatch: caller used the wrong generic. Must be a no-op so the real
-                // awaiter (with the correct type) can still complete.
                 return;
             }
 
@@ -92,8 +90,6 @@ public void Complete<TResult>(ModalId modalId, TResult? result)
             ActiveModalParameters = parameters;
             _activeTcs = tcs;
             _cancelActiveDelegate = () => tcs.TrySetResult(default);
-            // Publish id LAST: writes preceding a Volatile.Write aren't reordered past it, so
-            // cross-thread readers that observe the new id are guaranteed to see the new state.
             Volatile.Write(ref _activeModalId, _idCounter);
         }
 
@@ -115,8 +111,6 @@ private void ClearStateLocked()
         ActiveModalParameters = null;
         _activeTcs = null;
         _cancelActiveDelegate = null;
-        // Publish sentinel id LAST so readers observing id=0 are also guaranteed to see the
-        // cleared type/parameters. Matches the Show() publication-barrier discipline.
         Volatile.Write(ref _activeModalId, 0);
     }
 }
diff --git a/src/EventLogExpert.Runtime/Modal/ModalSession.cs b/src/EventLogExpert.UI/Modal/ModalSession.cs
similarity index 70%
rename from src/EventLogExpert.Runtime/Modal/ModalSession.cs
rename to src/EventLogExpert.UI/Modal/ModalSession.cs
index d1e335dec..8d9885266 100644
--- a/src/EventLogExpert.Runtime/Modal/ModalSession.cs
+++ b/src/EventLogExpert.UI/Modal/ModalSession.cs
@@ -1,9 +1,8 @@
 // // Copyright (c) Microsoft Corporation.
 // // Licensed under the MIT License.
 
-namespace EventLogExpert.Runtime.Modal;
+namespace EventLogExpert.UI.Modal;
 
-/// <summary>Snapshot of the active modal as observed by <see cref="IModalCoordinator" />.</summary>
 public sealed record ModalSession(ModalId Id, Type ComponentType, IDictionary<string, object?>? Parameters)
 {
     public bool Equals(ModalSession? other) => other is not null && Id == other.Id;
diff --git a/src/EventLogExpert.UI/StatusBar/StatusBar.razor b/src/EventLogExpert.UI/StatusBar/StatusBar.razor
index c980a30c6..22508a1f9 100644
--- a/src/EventLogExpert.UI/StatusBar/StatusBar.razor
+++ b/src/EventLogExpert.UI/StatusBar/StatusBar.razor
@@ -1,26 +1,24 @@
 @using EventLogExpert.Eventing.Common.Channels
 @using EventLogExpert.Runtime.StatusBar
-@inherits FluxorComponent
+@inherits PresentationViewComponentBase
 
 @{
-    var eventLog = EventLogSelection.Value;
-    var rawCount = RawCountSelection.Value;
-    var logTable = LogTableSelection.Value;
-    var statusBar = StatusBarSelection.Value;
+    var status = StatusBarSource.Current;
 
-    var activeTable = logTable.EventTables.FirstOrDefault(table => table.Id == logTable.ActiveEventLogId);
-    var hasChannel = logTable.EventTables.Any(table => table.LogPathType == LogPathType.Channel);
-    var isFiltered = eventLog.AppliedFilter.IsFilteringEnabled;
-    var isLoading = !statusBar.EventsLoading.IsEmpty;
+    var activeTable = status.Tabs.FirstOrDefault(table => table.Id == status.ActiveTabId);
+    var hasChannel = status.Tabs.Any(table => table.LogPathType == LogPathType.Channel);
+    var isFiltered = FilterApplied.IsFilteringEnabled;
+    var isLoading = !status.LoadingActivities.IsEmpty;
 
-    var source = StatusBarFormatter.FormatSource(activeTable, logTable.EventTables, logTable.Groups);
-    var filterTooltip = StatusBarFormatter.FilterIndicatorTooltip(FilterActiveSelection.Value, LensCountSelection.Value);
+    var source = StatusBarFormatter.FormatSource(activeTable, status.Tabs, status.Groups);
+    var filterTooltip = StatusBarFormatter.FilterIndicatorTooltip(status.IsPersistentFilterActive, LensSource.Lenses.Count);
 
     var announcement = StatusBarFormatter.FormatActivityAnnouncement(
         isLoading,
-        hasChannel && eventLog.NewEventBufferIsFull,
-        hasChannel && eventLog.ContinuouslyUpdate,
-        statusBar.ResolverStatus);
+        hasChannel && status.NewEventBufferIsFull,
+        hasChannel && status.ContinuouslyUpdate,
+        status.ResolverStatus,
+        ResolveIndicator());
 }
 
 <div class="status-bar">
@@ -29,14 +27,15 @@
 
         @if (activeTable is not null)
         {
-            var total = TotalRawCount(activeTable, logTable.Groups, rawCount);
+            var total = TotalRawCount(activeTable, status.Groups, status);
 
-            var shown = activeTable.IsCombined ?
-                logTable.ActiveFilteredViewCount :
-                logTable.EventCountByLog.GetValueOrDefault(activeTable.Id, 0);
+            var describesActiveTab = Presentation.ActiveTabId == activeTable.Id &&
+                Presentation.State == PresentationState.Current;
+
+            var shown = Presentation.View.Count;
 
             <span aria-hidden="true" class="status-bar-sep">|</span>
-            <span class="status-bar-counts">@StatusBarFormatter.FormatCounts(total, shown, isFiltered, eventLog.SelectionCount)</span>
+            <span class="status-bar-counts">@StatusBarFormatter.FormatCounts(total, shown, isFiltered && describesActiveTab, status.SelectionCount)</span>
         }
 
         @if (isFiltered)
@@ -49,36 +48,36 @@
     <div class="status-bar-right">
         <span aria-atomic="true" aria-live="polite" class="status-bar-announce" role="status">@announcement</span>
 
-        @foreach (var loadingProgress in statusBar.EventsLoading)
+        @foreach (var loadingProgress in status.LoadingActivities)
         {
-            <span class="status-bar-activity">Loading: @loadingProgress.Value.Item1</span>
+            <span class="status-bar-activity">Loading: @loadingProgress.Value.Loaded</span>
 
-            @if (loadingProgress.Value.Item2 > 0)
+            @if (loadingProgress.Value.Failed > 0)
             {
-                <span class="status-bar-activity status-bar-warn">Failed: @loadingProgress.Value.Item2</span>
+                <span class="status-bar-activity status-bar-warn">Failed: @loadingProgress.Value.Failed</span>
             }
         }
 
         @if (hasChannel)
         {
-            @if (eventLog.ContinuouslyUpdate)
+            @if (status.ContinuouslyUpdate)
             {
                 <span class="status-bar-activity status-bar-live">Continuously updating</span>
             }
             else
             {
-                <span aria-live="off" class="status-bar-activity">New Events: @eventLog.NewEventBufferCount</span>
+                <span aria-live="off" class="status-bar-activity">New Events: @status.NewEventBufferCount</span>
 
-                @if (eventLog.NewEventBufferIsFull)
+                @if (status.NewEventBufferIsFull)
                 {
                     <span class="status-bar-activity status-bar-warn">Buffer full</span>
                 }
             }
         }
 
-        @if (!string.IsNullOrEmpty(statusBar.ResolverStatus))
+        @if (!string.IsNullOrEmpty(status.ResolverStatus))
         {
-            <span class="status-bar-activity">@statusBar.ResolverStatus</span>
+            <span class="status-bar-activity">@status.ResolverStatus</span>
         }
     </div>
 </div>
diff --git a/src/EventLogExpert.UI/StatusBar/StatusBar.razor.cs b/src/EventLogExpert.UI/StatusBar/StatusBar.razor.cs
index fb462744a..ac5023cea 100644
--- a/src/EventLogExpert.UI/StatusBar/StatusBar.razor.cs
+++ b/src/EventLogExpert.UI/StatusBar/StatusBar.razor.cs
@@ -1,14 +1,10 @@
 // // Copyright (c) Microsoft Corporation.
 // // Licensed under the MIT License.
 
-using EventLogExpert.Eventing.Common.EventLogs;
-using EventLogExpert.Filtering.Evaluation;
 using EventLogExpert.Runtime.EventLog;
 using EventLogExpert.Runtime.FilterLenses;
-using EventLogExpert.Runtime.FilterPane;
 using EventLogExpert.Runtime.LogTable;
 using EventLogExpert.Runtime.StatusBar;
-using Fluxor;
 using Microsoft.AspNetCore.Components;
 using System.Collections.Immutable;
 
@@ -16,79 +12,59 @@ namespace EventLogExpert.UI.StatusBar;
 
 public sealed partial class StatusBar
 {
-    [Inject]
-    private IStateSelection<EventLogState, (
-        Filter AppliedFilter,
-        bool ContinuouslyUpdate,
-        int NewEventBufferCount,
-        bool NewEventBufferIsFull,
-        int SelectionCount)> EventLogSelection
-    { get; init; } = null!;
-
-    [Inject]
-    private IStateSelection<FilterPaneState, bool> FilterActiveSelection { get; init; } = null!;
-
-    [Inject]
-    private IStateSelection<FilterLensState, int> LensCountSelection { get; init; } = null!;
-
-    [Inject]
-    private IStateSelection<LogTableState, (
-        EventLogId? ActiveEventLogId,
-        ImmutableList<LogView> EventTables,
-        int ActiveFilteredViewCount,
-        ImmutableDictionary<EventLogId, int> EventCountByLog,
-        ImmutableList<LogTabGroup> Groups)> LogTableSelection
-    { get; init; } = null!;
-
-    [Inject]
-    private IStateSelection<RawEventCountState, (
-        int Total,
-        ImmutableDictionary<EventLogId, int> ByLog)> RawCountSelection
-    { get; init; } = null!;
-
-    [Inject]
-    private IStateSelection<StatusBarState, (
-        ImmutableDictionary<StatusActivityId, (int, int)> EventsLoading,
-        string ResolverStatus)> StatusBarSelection
-    { get; init; } = null!;
+    private DisplayIndicatorState _indicatorState = null!;
 
-    protected override void OnInitialized()
+    [Inject] private IFilterAppliedSource FilterApplied { get; init; } = null!;
+
+    [Inject] private DisplayIndicatorGate IndicatorGate { get; init; } = null!;
+
+    [Inject] private IFilterLensSource LensSource { get; init; } = null!;
+
+    [Inject] private IStatusBarSource StatusBarSource { get; init; } = null!;
+
+    protected override async ValueTask DisposeAsyncCore(bool disposing)
     {
-        EventLogSelection.Select(static s =>
-            (s.AppliedFilter, s.ContinuouslyUpdate, s.NewEventBuffer.Count, s.NewEventBufferIsFull, s.Selection.Count));
-        RawCountSelection.Select(static s => (s.Total, s.ByLog));
-        LogTableSelection.Select(static s =>
+        if (disposing)
         {
-            var activeTable = s.EventTables.FirstOrDefault(table => table.Id == s.ActiveEventLogId);
-
-            return (
-                s.ActiveEventLogId,
-                s.EventTables,
-                activeTable is null ? 0 : s.DisplayedEventsForTab(activeTable).Count,
-                s.EventCountByLog,
-                s.Groups);
-        });
-        StatusBarSelection.Select(static s => (s.EventsLoading, s.ResolverStatus));
-        FilterActiveSelection.Select(static s => s.IsFilteringEnabled);
-        LensCountSelection.Select(static s => s.Lenses.Count);
+            _indicatorState?.Dispose();
+        }
+
+        await base.DisposeAsyncCore(disposing);
+    }
+
+    protected override void OnInitialized()
+    {
+        _indicatorState = new DisplayIndicatorState(IndicatorGate, RequestIndicatorRender);
+
+        ObserveSource(StatusBarSource);
+        ObserveSource(FilterApplied);
+        ObserveSource(LensSource);
 
         base.OnInitialized();
     }
 
-    private static int TotalRawCount(
-        LogView activeTable,
-        ImmutableList<LogTabGroup> groups,
-        (int Total, ImmutableDictionary<EventLogId, int> ByLog) rawCount)
+    private static int TotalRawCount(LogView activeTable, ImmutableList<LogTabGroup> groups, StatusBarPresentation status)
     {
-        if (activeTable.GroupId?.IsAll == true) { return rawCount.Total; }
+        if (activeTable.GroupId?.IsAll == true) { return status.RawEventTotal; }
 
         if (activeTable.GroupId is not { } groupId)
         {
-            return rawCount.ByLog.GetValueOrDefault(activeTable.Id, 0);
+            return status.RawEventCountsByLog.GetValueOrDefault(activeTable.Id, 0);
         }
 
         var group = groups.FirstOrDefault(candidate => candidate.Id == groupId);
 
-        return group is null ? 0 : group.MemberIds.Sum(id => rawCount.ByLog.GetValueOrDefault(id, 0));
+        return group is null ? 0 : group.MemberIds.Sum(id => status.RawEventCountsByLog.GetValueOrDefault(id, 0));
+    }
+
+    private void RequestIndicatorRender() => RequestGuardedRender(StateHasChanged);
+
+    private DisplayIndicatorKind ResolveIndicator()
+    {
+        var shown = _indicatorState.Resolve(Presentation.IndicatorKind, Presentation.Revision);
+
+        _indicatorState.RecordPaint(shown);
+
+        return shown.Sentence;
     }
 }
diff --git a/src/EventLogExpert.UI/_Imports.razor b/src/EventLogExpert.UI/_Imports.razor
index b0c561bdb..6a95daca3 100644
--- a/src/EventLogExpert.UI/_Imports.razor
+++ b/src/EventLogExpert.UI/_Imports.razor
@@ -1,20 +1,13 @@
-@* Framework *@
 @using Microsoft.AspNetCore.Components
 @using Microsoft.AspNetCore.Components.Forms
 @using Microsoft.AspNetCore.Components.Web
 @using Microsoft.AspNetCore.Components.Web.Virtualization
 
-@* Fluxor *@
-@using Fluxor
-@using Fluxor.Blazor.Web.Components
-
-@* Filtering (Razor component types) *@
 @using EventLogExpert.Filtering.Common.Filtering
 @using EventLogExpert.Filtering.Drafts
 @using EventLogExpert.Filtering.Evaluation
 @using EventLogExpert.Filtering.Persistence
 
-@* Runtime (Razor component types) *@
 @using EventLogExpert.Runtime.Banner
 @using EventLogExpert.Runtime.Common.Display
 @using EventLogExpert.Runtime.Database
@@ -23,7 +16,6 @@
 @using EventLogExpert.Runtime.LogTable
 @using EventLogExpert.Runtime.Settings
 
-@* UI (Razor component types) *@
 @using EventLogExpert.UI.Announcement
 @using EventLogExpert.UI.Banner
 @using EventLogExpert.UI.Common
diff --git a/src/EventLogExpert/Adapters/Clipboard/MauiClipboardService.cs b/src/EventLogExpert/Adapters/Clipboard/MauiClipboardService.cs
index 6b69de90d..17a60233f 100644
--- a/src/EventLogExpert/Adapters/Clipboard/MauiClipboardService.cs
+++ b/src/EventLogExpert/Adapters/Clipboard/MauiClipboardService.cs
@@ -1,356 +1,82 @@
-// // Copyright (c) Microsoft Corporation.
-// // Licensed under the MIT License.
-
-using EventLogExpert.Eventing.Common.Events;
-using EventLogExpert.Eventing.Resolvers;
-using EventLogExpert.Logging.Abstractions;
-using EventLogExpert.Runtime.Common.Clipboard;
-using EventLogExpert.Runtime.Common.Display;
-using EventLogExpert.Runtime.EventLog;
-using EventLogExpert.Runtime.LogTable;
-using EventLogExpert.Runtime.Settings;
-using Fluxor;
-using System.Collections.Immutable;
-using System.Text;
-using System.Xml;
-using System.Xml.Linq;
-using MauiClipboard = Microsoft.Maui.ApplicationModel.DataTransfer.Clipboard;
-
-namespace EventLogExpert.Adapters.Clipboard;
-
-public sealed class MauiClipboardService : IClipboardService
-{
-    private readonly IStateSelection<LogTableState, ImmutableList<ColumnName>> _columnOrder;
-    private readonly IStateSelection<LogTableState, ImmutableDictionary<ColumnName, bool>> _eventTableColumns;
-    private readonly IStateSelection<EventLogState, SelectionEntry?> _focus;
-    private readonly IState<LogTableState> _logTableState;
-    private readonly IStateSelection<EventLogState, ImmutableList<SelectionEntry>> _selection;
-    private readonly ISettingsService _settings;
-    private readonly ITraceLogger _traceLogger;
-    private readonly IEventXmlResolver _xmlResolver;
-
-    public MauiClipboardService(
-        IStateSelection<LogTableState, ImmutableDictionary<ColumnName, bool>> eventTableColumns,
-        IStateSelection<LogTableState, ImmutableList<ColumnName>> columnOrder,
-        IStateSelection<EventLogState, ImmutableList<SelectionEntry>> selection,
-        IStateSelection<EventLogState, SelectionEntry?> focus,
-        IState<LogTableState> logTableState,
-        ISettingsService settings,
-        IEventXmlResolver xmlResolver,
-        ITraceLogger traceLogger)
-    {
-        _eventTableColumns = eventTableColumns;
-        _columnOrder = columnOrder;
-        _selection = selection;
-        _focus = focus;
-        _logTableState = logTableState;
-        _settings = settings;
-        _xmlResolver = xmlResolver;
-        _traceLogger = traceLogger;
-
-        _eventTableColumns.Select(s => s.Columns);
-        _columnOrder.Select(s => s.ColumnOrder);
-        _selection.Select(s => s.Selection);
-        _focus.Select(s => s.Focus);
-    }
-
-    public async Task CopySelectedEvent(EventCopyFormat? format = null)
-    {
-        // Copy is best-effort: callers are typically Blazor handlers that don't catch, so a failure would surface as an
-        // unhandled UI exception. Log and swallow to preserve fire-and-forget behavior.
-        try
-        {
-            string stringToCopy = await GetFormattedEvent(format).ConfigureAwait(false);
-
-            await MauiClipboard.SetTextAsync(stringToCopy).ConfigureAwait(false);
-        }
-        catch (Exception ex)
-        {
-            _traceLogger.Error($"{nameof(MauiClipboardService)}.{nameof(CopySelectedEvent)}: failed: {ex}");
-        }
-    }
-
-    public async Task CopyTextAsync(string text)
-    {
-        // Same best-effort contract as CopySelectedEvent: callers are typically fire-and-forget UI handlers.
-        try
-        {
-            await MauiClipboard.SetTextAsync(text).ConfigureAwait(false);
-        }
-        catch (Exception ex)
-        {
-            _traceLogger.Error($"{nameof(MauiClipboardService)}.{nameof(CopyTextAsync)}: failed: {ex}");
-        }
-    }
-
-    private static string EscapeMarkdownCell(string? value) =>
-        (value ?? string.Empty)
-            .Replace("\\", "\\\\", StringComparison.Ordinal)
-            .Replace("\r", " ", StringComparison.Ordinal)
-            .Replace("\n", " ", StringComparison.Ordinal)
-            .Replace("|", "\\|", StringComparison.Ordinal);
-
-    private static string FormatXmlForCopy(string xml)
-    {
-        try
-        {
-            return XElement.Parse(xml).ToString();
-        }
-        catch (XmlException)
-        {
-            return xml;
-        }
-    }
-
-    private static ResolvedEvent? ResolveEntry(SelectionEntry? entry, LogTableState logTable)
-    {
-        if (entry?.CurrentHandle is not { } handle) { return null; }
-
-        return logTable.EventsForLog(handle.LogId).TryGetDetail(handle, out var detail) ? detail : null;
-    }
-
-    private void AppendFormattedEvent(
-        StringBuilder builder,
-        EventCopyFormat format,
-        ResolvedEvent @event,
-        string xml)
-    {
-        switch (format)
-        {
-            case EventCopyFormat.Default:
-                foreach ((ColumnName column, _) in _eventTableColumns.Value.Where(x => x.Value))
-                {
-                    switch (column)
-                    {
-                        case ColumnName.RecordId:
-                            builder.Append($"\"{@event.RecordId}\" ");
-                            break;
-                        case ColumnName.Level:
-                            builder.Append($"\"{@event.Level}\" ");
-                            break;
-                        case ColumnName.DateAndTime:
-                            builder.Append($"\"{@event.TimeCreated.ConvertTimeZone(_settings.TimeZoneInfo)}\" ");
-                            break;
-                        case ColumnName.ActivityId:
-                            builder.Append($"\"{@event.ActivityId}\" ");
-                            break;
-                        case ColumnName.Log:
-                            builder.Append($"\"{OwningLogDisplay.ShortName(@event.OwningLog)}\" ");
-                            break;
-                        case ColumnName.ComputerName:
-                            builder.Append($"\"{@event.ComputerName}\" ");
-                            break;
-                        case ColumnName.Source:
-                            builder.Append($"\"{@event.Source}\" ");
-                            break;
-                        case ColumnName.EventId:
-                            builder.Append($"\"{@event.Id}\" ");
-                            break;
-                        case ColumnName.TaskCategory:
-                            builder.Append($"\"{@event.TaskCategory}\" ");
-                            break;
-                        case ColumnName.Keywords:
-                            builder.Append($"\"{@event.KeywordsDisplayName}\" ");
-                            break;
-                        case ColumnName.ProcessId:
-                            builder.Append($"\"{@event.ProcessId}\" ");
-                            break;
-                        case ColumnName.ThreadId:
-                            builder.Append($"\"{@event.ThreadId}\" ");
-                            break;
-                        case ColumnName.User:
-                            builder.Append($"\"{@event.UserId}\" ");
-                            break;
-                    }
-                }
-
-                builder.Append($"\"{@event.Description}\"");
-                break;
-            case EventCopyFormat.Simple:
-                builder.Append($"\"{@event.Level}\" ");
-                builder.Append($"\"{@event.TimeCreated.ConvertTimeZone(_settings.TimeZoneInfo)}\" ");
-                builder.Append($"\"{@event.Source}\" ");
-                builder.Append($"\"{@event.Id}\" ");
-                builder.Append($"\"{@event.Description}\"");
-                break;
-            case EventCopyFormat.Xml:
-                if (!string.IsNullOrEmpty(xml)) { builder.Append(FormatXmlForCopy(xml)); }
-
-                break;
-            case EventCopyFormat.Full:
-            default:
-                builder.AppendLine($"Log Name: {@event.LogName}");
-                builder.AppendLine($"Source: {@event.Source}");
-                builder.AppendLine($"Date: {@event.TimeCreated.ConvertTimeZone(_settings.TimeZoneInfo)}");
-                builder.AppendLine($"Event ID: {@event.Id}");
-                builder.AppendLine($"Task Category: {@event.TaskCategory}");
-                builder.AppendLine($"Level: {@event.Level}");
-                builder.AppendLine($"Keywords: {@event.KeywordsDisplayName}");
-                builder.AppendLine($"User: {@event.UserId}");
-                builder.AppendLine($"Computer: {@event.ComputerName}");
-                builder.AppendLine("Description:");
-                builder.AppendLine(@event.Description);
-                builder.AppendLine("Event Xml:");
-
-                if (!string.IsNullOrEmpty(xml))
-                {
-                    builder.AppendLine(FormatXmlForCopy(xml));
-                }
-
-                break;
-        }
-    }
-
-    private string BuildMarkdownTable(IReadOnlyList<ResolvedEvent> events)
-    {
-        var enabled = _eventTableColumns.Value;
-        var order = _columnOrder.Value;
-        var columns = (order.IsEmpty
-                ? enabled.Where(column => column.Value).Select(column => column.Key).OrderBy(column => column)
-                : order.Where(column => enabled.TryGetValue(column, out bool isEnabled) && isEnabled))
-            .ToList();
-
-        StringBuilder builder = new();
-
-        builder.Append("| ");
-        foreach (var column in columns) { builder.Append(EscapeMarkdownCell(column.ToFullString())).Append(" | "); }
-
-        builder.AppendLine("Description |");
-
-        builder.Append('|');
-        for (int separator = 0; separator <= columns.Count; separator++) { builder.Append(" --- |"); }
-
-        builder.AppendLine();
-
-        foreach (var @event in events)
-        {
-            builder.Append("| ");
-            foreach (var column in columns) { builder.Append(EscapeMarkdownCell(GetColumnText(column, @event))).Append(" | "); }
-
-            builder.Append(EscapeMarkdownCell(@event.Description)).AppendLine(" |");
-        }
-
-        return builder.ToString().TrimEnd();
-    }
-
-    private string FormatEventForCopy(EventCopyFormat format, ResolvedEvent @event, string xml)
-    {
-        if (format == EventCopyFormat.Xml)
-        {
-            return string.IsNullOrEmpty(xml) ? string.Empty : FormatXmlForCopy(xml);
-        }
-
-        StringBuilder builder = new();
-
-        AppendFormattedEvent(builder, format, @event, xml);
-
-        return builder.ToString();
-    }
-
-    private string GetColumnText(ColumnName column, ResolvedEvent @event) =>
-        EventTableColumnFormatter.GetCellText(@event, column, _settings.TimeZoneInfo);
-
-    private async Task<string> GetFormattedEvent(EventCopyFormat? format)
-    {
-        // Snapshot the selection once: re-reading across awaits could see a changed or empty list mid-resolve, copying
-        // the wrong event or throwing. Entries that no longer resolve are dropped.
-        var logTable = _logTableState.Value;
-        var events = ResolveSelection(_selection.Value, logTable);
-        var selected = ResolveEntry(_focus.Value, logTable);
-
-        var resolvedFormat = format ?? _settings.CopyFormat;
-
-        if (resolvedFormat == EventCopyFormat.Markdown)
-        {
-            IReadOnlyList<ResolvedEvent> markdownEvents =
-                events.Count == 0 ? (selected is null ? [] : [selected]) : events;
-
-            return markdownEvents.Count == 0 ? string.Empty : BuildMarkdownTable(markdownEvents);
-        }
-
-        bool needsXml = resolvedFormat is EventCopyFormat.Xml or EventCopyFormat.Full;
-
-        // Selection empty: fall back to the focused entry so a right-click that didn't reach the table still copies the
-        // focused event.
-        if (events.Count == 0)
-        {
-            if (selected is null) { return string.Empty; }
-
-            string xml = needsXml ? await _xmlResolver.GetXmlAsync(selected) : string.Empty;
-
-            return FormatEventForCopy(resolvedFormat, selected, xml);
-        }
-
-        if (events.Count == 1)
-        {
-            // Copy the single selected entry (events[0]), not the focused row, so Ctrl+C copies what's selected even
-            // when the focus cursor moved off (e.g., Ctrl+click toggled the only selected row off but left focus on it).
-            string xml = needsXml ? await _xmlResolver.GetXmlAsync(events[0]) : string.Empty;
-
-            return FormatEventForCopy(resolvedFormat, events[0], xml);
-        }
-
-        string[] xmlByIndex;
-
-        if (needsXml)
-        {
-            int maxConcurrency = Math.Max(2, Math.Min(events.Count, Environment.ProcessorCount));
-            using var resolverLock = new SemaphoreSlim(maxConcurrency, maxConcurrency);
-
-            var resolveTasks = new Task<string>[events.Count];
-
-            for (int i = 0; i < events.Count; i++)
-            {
-                var evt = events[i];
-
-                resolveTasks[i] = ResolveXmlAsync(evt, resolverLock);
-            }
-
-            xmlByIndex = await Task.WhenAll(resolveTasks);
-        }
-        else
-        {
-            xmlByIndex = [];
-        }
-
-        StringBuilder stringToCopy = new();
-
-        for (int i = 0; i < events.Count; i++)
-        {
-            string xml = needsXml ? xmlByIndex[i] : string.Empty;
-
-            AppendFormattedEvent(stringToCopy, resolvedFormat, events[i], xml);
-            stringToCopy.AppendLine();
-        }
-
-        return stringToCopy.ToString();
-    }
-
-    private IReadOnlyList<ResolvedEvent> ResolveSelection(ImmutableList<SelectionEntry> selection, LogTableState logTable)
-    {
-        if (selection.Count == 0) { return []; }
-
-        var resolved = new List<ResolvedEvent>(selection.Count);
-
-        foreach (var entry in selection)
-        {
-            if (ResolveEntry(entry, logTable) is { } detail) { resolved.Add(detail); }
-        }
-
-        return resolved;
-    }
-
-    private async Task<string> ResolveXmlAsync(ResolvedEvent evt, SemaphoreSlim resolverLock)
-    {
-        await resolverLock.WaitAsync().ConfigureAwait(false);
-
-        try
-        {
-            return await _xmlResolver.GetXmlAsync(evt).ConfigureAwait(false);
-        }
-        finally
-        {
-            resolverLock.Release();
-        }
-    }
-}
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Logging.Abstractions;
+using EventLogExpert.Runtime.Common.Clipboard;
+using EventLogExpert.Runtime.EventLog;
+using EventLogExpert.Runtime.LogTable;
+using EventLogExpert.Runtime.Settings;
+using Fluxor;
+using System.Collections.Immutable;
+using MauiClipboard = Microsoft.Maui.ApplicationModel.DataTransfer.Clipboard;
+
+namespace EventLogExpert.Adapters.Clipboard;
+
+public sealed class MauiClipboardService : IClipboardService
+{
+    private readonly IStateSelection<LogTableState, ImmutableList<ColumnName>> _columnOrder;
+    private readonly IStateSelection<LogTableState, ImmutableDictionary<ColumnName, bool>> _eventTableColumns;
+    private readonly IStateSelection<EventLogState, SelectionEntry?> _focus;
+    private readonly IEventCopyFormatter _formatter;
+    private readonly IStateSelection<EventLogState, ImmutableList<SelectionEntry>> _selection;
+    private readonly ISettingsService _settings;
+    private readonly ITraceLogger _traceLogger;
+
+    public MauiClipboardService(
+        IStateSelection<LogTableState, ImmutableDictionary<ColumnName, bool>> eventTableColumns,
+        IStateSelection<LogTableState, ImmutableList<ColumnName>> columnOrder,
+        IStateSelection<EventLogState, ImmutableList<SelectionEntry>> selection,
+        IStateSelection<EventLogState, SelectionEntry?> focus,
+        IEventCopyFormatter formatter,
+        ISettingsService settings,
+        ITraceLogger traceLogger)
+    {
+        _eventTableColumns = eventTableColumns;
+        _columnOrder = columnOrder;
+        _selection = selection;
+        _focus = focus;
+        _formatter = formatter;
+        _settings = settings;
+        _traceLogger = traceLogger;
+
+        _eventTableColumns.Select(s => s.Columns);
+        _columnOrder.Select(s => s.ColumnOrder);
+        _selection.Select(s => s.Selection);
+        _focus.Select(s => s.Focus);
+    }
+
+    public async Task CopySelectedEvent(EventCopyFormat? format = null)
+    {
+        // unhandled UI exception. Log and swallow to preserve fire-and-forget behavior.
+        try
+        {
+            var request = new EventCopyRequest(
+                _selection.Value,
+                _focus.Value,
+                _eventTableColumns.Value,
+                _columnOrder.Value,
+                format ?? _settings.CopyFormat,
+                _settings.TimeZoneInfo);
+
+            string stringToCopy = await _formatter.FormatAsync(request).ConfigureAwait(false);
+
+            await MauiClipboard.SetTextAsync(stringToCopy).ConfigureAwait(false);
+        }
+        catch (Exception ex)
+        {
+            _traceLogger.Error($"{nameof(MauiClipboardService)}.{nameof(CopySelectedEvent)}: failed: {ex}");
+        }
+    }
+
+    public async Task CopyTextAsync(string text)
+    {
+        try
+        {
+            await MauiClipboard.SetTextAsync(text).ConfigureAwait(false);
+        }
+        catch (Exception ex)
+        {
+            _traceLogger.Error($"{nameof(MauiClipboardService)}.{nameof(CopyTextAsync)}: failed: {ex}");
+        }
+    }
+}
diff --git a/src/EventLogExpert/Adapters/Menu/MauiMenuActionService.cs b/src/EventLogExpert/Adapters/Menu/MauiMenuActionService.cs
index 416ee476e..cd4e58db5 100644
--- a/src/EventLogExpert/Adapters/Menu/MauiMenuActionService.cs
+++ b/src/EventLogExpert/Adapters/Menu/MauiMenuActionService.cs
@@ -5,7 +5,6 @@
 using EventLogExpert.Eventing.Readers;
 using EventLogExpert.Logging.Abstractions;
 using EventLogExpert.Runtime.Alerts;
-using EventLogExpert.Runtime.Banner;
 using EventLogExpert.Runtime.Common.Clipboard;
 using EventLogExpert.Runtime.Common.Files;
 using EventLogExpert.Runtime.Common.Versioning;
@@ -16,7 +15,6 @@
 using EventLogExpert.Runtime.Histogram;
 using EventLogExpert.Runtime.LogTable;
 using EventLogExpert.Runtime.Menu;
-using EventLogExpert.Runtime.Modal;
 using EventLogExpert.Runtime.Scenarios;
 using EventLogExpert.Runtime.Settings;
 using EventLogExpert.Runtime.Update;
@@ -27,18 +25,11 @@
 using EventLogExpert.WindowsPlatform.Activation;
 using Fluxor;
 using System.Collections.Immutable;
-using System.Globalization;
 using Application = Microsoft.Maui.Controls.Application;
 using IDispatcher = Fluxor.IDispatcher;
 
 namespace EventLogExpert.Adapters.Menu;
 
-/// <summary>
-///     MAUI implementation of <see cref="IMenuActionService" />. Owns the cancellation token that gates background
-///     log loads (replaces the legacy field on MainPage). Exposes <see cref="OpenLogsBatchAsync" /> publicly so the
-///     page-level drag/drop and command-line handlers can batch multiple opens through the same cancellation lifecycle and
-///     surface one banner alert per gesture for empty logs.
-/// </summary>
 public sealed class MauiMenuActionService(
     IDispatcher dispatcher,
     IEventLogCommands eventLogCommands,
@@ -56,29 +47,21 @@ public sealed class MauiMenuActionService(
     IFilePickerService filePickerService,
     IFolderPickerService folderPickerService,
     IState<EventLogState> eventLogState,
-    IState<LogTableState> logTableState,
-    ILogTableColumnDefaultsProvider columnDefaults,
-    IEventTableExporter eventTableExporter,
-    IExportProgressBannerService exportProgressBannerService,
-    IFileSaveService fileSaveService) : IMenuActionService, IDisposable
+    EventExportCoordinator exportCoordinator) : IMenuActionService, IDisposable
 {
     private readonly IClipboardService _clipboardService = clipboardService;
-    private readonly ILogTableColumnDefaultsProvider _columnDefaults = columnDefaults;
     private readonly ICurrentVersionProvider _currentVersionProvider = currentVersionProvider;
     private readonly IAlertDialogService _dialogService = dialogService;
     private readonly IDispatcher _dispatcher = dispatcher;
     private readonly IEventLogCommands _eventLogCommands = eventLogCommands;
     private readonly IState<EventLogState> _eventLogState = eventLogState;
-    private readonly IEventTableExporter _eventTableExporter = eventTableExporter;
-    private readonly IExportProgressBannerService _exportProgress = exportProgressBannerService;
+    private readonly EventExportCoordinator _exportCoordinator = exportCoordinator;
     private readonly IFilePickerService _filePickerService = filePickerService;
-    private readonly IFileSaveService _fileSaveService = fileSaveService;
     private readonly IFilterLibraryCommands _filterLibraryCommands = filterLibraryCommands;
     private readonly IFilterPaneCommands _filterPaneCommands = filterPaneCommands;
     private readonly IFolderPickerService _folderPickerService = folderPickerService;
     private readonly IHistogramCommands _histogramCommands = histogramCommands;
     private readonly ILogTableCommands _logTableCommands = logTableCommands;
-    private readonly IState<LogTableState> _logTableState = logTableState;
     private readonly IModalCoordinator _modalCoordinator = modalCoordinator;
     private readonly ISettingsService _settings = settings;
     private readonly ITraceLogger _traceLogger = traceLogger;
@@ -86,7 +69,6 @@ public sealed class MauiMenuActionService(
 
     private CancellationTokenSource _cancellationTokenSource = new();
     private bool _disposed;
-    private int _exportInFlight;
 
     public async Task CheckForUpdatesAsync()
     {
@@ -114,8 +96,6 @@ public void Dispose()
 
         _disposed = true;
 
-        // Best-effort cancellation so any in-flight OpenLog effects stop linking new callbacks
-        // to a token whose CTS is about to be disposed (which would surface ObjectDisposedException).
         try
         {
             _cancellationTokenSource.Cancel();
@@ -139,125 +119,7 @@ public void Exit()
         }
     }
 
-    public async Task ExportEventsAsync(ExportFormat format)
-    {
-        var state = _logTableState.Value;
-        var events = state.GetActiveDisplayedEvents();
-
-        if (events.Count == 0)
-        {
-            await _dialogService.ShowAlert(
-                "Export events", "There are no events to export.", "Ok", AlertPresentation.Banner);
-
-            return;
-        }
-
-        // Snapshot everything the export needs before opening the picker, so a state change while the dialog is open
-        // cannot mutate the rows/columns/timezone being written.
-        var columns = state.GetOrderedEnabledColumns(_columnDefaults);
-
-        if (columns.Count == 0)
-        {
-            await _dialogService.ShowAlert(
-                "Export events", "There are no visible columns to export.", "Ok", AlertPresentation.Banner);
-
-            return;
-        }
-
-        var timeZone = _settings.TimeZoneInfo;
-        bool isCsv = format == ExportFormat.Csv;
-        var fileTypes = isCsv ? FileSaveFileTypes.Csv : FileSaveFileTypes.Json;
-        string extension = isCsv ? ".csv" : ".json";
-        string suggestedFileName =
-            $"events-{DateTime.Now.ToString("yyyyMMdd-HHmmss", CultureInfo.InvariantCulture)}{extension}";
-
-        // Only one export may run at a time: the progress banner holds a single entry and the cancel
-        // affordance owns a single CTS, so a concurrent export would orphan the first cancellation.
-        if (Interlocked.CompareExchange(ref _exportInFlight, 1, 0) != 0)
-        {
-            await _dialogService.ShowAlert(
-                "Export events", "An export is already in progress.", "Ok", AlertPresentation.Banner);
-
-            return;
-        }
-
-        CancellationTokenSource cancellation = new();
-        string? savedPath = null;
-        Exception? failure = null;
-        bool canceled = false;
-
-        try
-        {
-            savedPath = await _fileSaveService.SaveStreamingAsync(
-                suggestedFileName,
-                fileTypes,
-                async (stream, _) =>
-                {
-                    // Begin only once the picker has returned a destination and the streaming write is starting;
-                    // dismissing the picker never reaches here, so it stays silent. A Cancel click can race export
-                    // teardown (the CTS is disposed in the finally), so guard the narrow disposed-CTS window.
-                    _exportProgress.Begin(
-                        "Exporting events...",
-                        () => { try { cancellation.Cancel(); } catch (ObjectDisposedException) { /* Teardown disposed the CTS; a late Cancel is a no-op. */ } });
-
-                    // Cancellation gates the WRITE only: ExportAsync throws per-row on Cancel, so AtomicFileWriter
-                    // discards the temp. SaveStreamingAsync gets CancellationToken.None, so once the write completes
-                    // the atomic commit is unconditional - a late Cancel can no longer discard a fully-written export.
-                    await _eventTableExporter.ExportAsync(
-                        stream, format, events, columns, timeZone, includeDescription: true, cancellation.Token);
-                },
-                CancellationToken.None);
-        }
-        catch (OperationCanceledException) when (cancellation.IsCancellationRequested)
-        {
-            canceled = true;
-        }
-        catch (Exception ex)
-        {
-            failure = ex;
-        }
-        finally
-        {
-            // End() raises StateChanged; isolate it so a throwing subscriber can never skip the CTS
-            // disposal or the in-flight reset, which would otherwise wedge every later export.
-            try
-            {
-                _exportProgress.End();
-            }
-            finally
-            {
-                cancellation.Dispose();
-                Interlocked.Exchange(ref _exportInFlight, 0);
-            }
-        }
-
-        if (canceled)
-        {
-            await _dialogService.ShowAlert(
-                "Export canceled", "The export was canceled.", "Ok", AlertPresentation.Banner);
-
-            return;
-        }
-
-        if (failure is not null)
-        {
-            _traceLogger.Error($"Failed to export events: {failure}");
-
-            await _dialogService.ShowAlert("Export failed", failure.Message, "Ok", AlertPresentation.Banner);
-
-            return;
-        }
-
-        // A null path means the user dismissed the save picker; only confirm an actual write.
-        if (savedPath is not null)
-        {
-            await _dialogService.ShowAlert(
-                "Export complete",
-                $"Exported {events.Count:N0} {(events.Count == 1 ? "event" : "events")} to {savedPath}.",
-                "Ok",
-                AlertPresentation.Banner);
-        }
-    }
+    public Task ExportEventsAsync(ExportFormat format) => _exportCoordinator.ExportEventsAsync(format);
 
     public void LoadNewEvents() => _eventLogCommands.LoadNewEvents();
 
@@ -431,69 +293,6 @@ private async Task OpenBrowserAsync(string url)
         }
     }
 
-    private async Task<OpenLogsBatchResult> OpenLogsBatchCoreAsync(
-        IEnumerable<(string Path, LogPathType Type)> logs,
-        bool combineLog,
-        bool showInlineAlerts)
-    {
-        ArgumentNullException.ThrowIfNull(logs);
-
-        List<string>? emptyDisplayNames = null;
-        List<ChannelOutcome>? channelOutcomes = null;
-        var combineForCall = combineLog;
-        var opened = 0;
-        var failed = 0;
-        var skipped = 0;
-
-        foreach (var (path, type) in logs)
-        {
-            var outcome = await OpenLogWithOutcomeAsync(path, type, combineForCall, showInlineAlerts);
-
-            if (type == LogPathType.Channel)
-            {
-                (channelOutcomes ??= []).Add(outcome);
-            }
-
-            switch (outcome.Outcome)
-            {
-                case ChannelLaunchOutcome.Opened:
-                    opened++;
-                    combineForCall = true;
-                    break;
-                case ChannelLaunchOutcome.Empty:
-                    (emptyDisplayNames ??= []).Add(GetEmptyLogDisplayName(path, type));
-                    break;
-                case ChannelLaunchOutcome.AccessDenied:
-                case ChannelLaunchOutcome.NotPresent:
-                case ChannelLaunchOutcome.Failed:
-                    failed++;
-                    break;
-                case ChannelLaunchOutcome.Skipped:
-                    skipped++;
-                    break;
-            }
-        }
-
-        if (emptyDisplayNames is { Count: > 0 })
-        {
-            await _dialogService.ShowAlert(
-                "Empty log",
-                EmptyLogAlertFormatter.BuildMessage(emptyDisplayNames),
-                "Ok",
-                AlertPresentation.Banner);
-        }
-
-        return new OpenLogsBatchResult(
-            opened,
-            emptyDisplayNames?.Count ?? 0,
-            failed,
-            skipped,
-            emptyDisplayNames?.ToImmutableArray() ?? [])
-        {
-            ChannelOutcomes = channelOutcomes?.ToImmutableArray() ?? []
-        };
-    }
-
     private async Task<ChannelOutcome> OpenLogWithOutcomeAsync(
         string logPath,
         LogPathType pathType,
@@ -567,6 +366,69 @@ await _dialogService.ShowAlert(
         return new ChannelOutcome(logPath, ChannelLaunchOutcome.Opened);
     }
 
+    private async Task<OpenLogsBatchResult> OpenLogsBatchCoreAsync(
+        IEnumerable<(string Path, LogPathType Type)> logs,
+        bool combineLog,
+        bool showInlineAlerts)
+    {
+        ArgumentNullException.ThrowIfNull(logs);
+
+        List<string>? emptyDisplayNames = null;
+        List<ChannelOutcome>? channelOutcomes = null;
+        var combineForCall = combineLog;
+        var opened = 0;
+        var failed = 0;
+        var skipped = 0;
+
+        foreach (var (path, type) in logs)
+        {
+            var outcome = await OpenLogWithOutcomeAsync(path, type, combineForCall, showInlineAlerts);
+
+            if (type == LogPathType.Channel)
+            {
+                (channelOutcomes ??= []).Add(outcome);
+            }
+
+            switch (outcome.Outcome)
+            {
+                case ChannelLaunchOutcome.Opened:
+                    opened++;
+                    combineForCall = true;
+                    break;
+                case ChannelLaunchOutcome.Empty:
+                    (emptyDisplayNames ??= []).Add(GetEmptyLogDisplayName(path, type));
+                    break;
+                case ChannelLaunchOutcome.AccessDenied:
+                case ChannelLaunchOutcome.NotPresent:
+                case ChannelLaunchOutcome.Failed:
+                    failed++;
+                    break;
+                case ChannelLaunchOutcome.Skipped:
+                    skipped++;
+                    break;
+            }
+        }
+
+        if (emptyDisplayNames is { Count: > 0 })
+        {
+            await _dialogService.ShowAlert(
+                "Empty log",
+                EmptyLogAlertFormatter.BuildMessage(emptyDisplayNames),
+                "Ok",
+                AlertPresentation.Banner);
+        }
+
+        return new OpenLogsBatchResult(
+            opened,
+            emptyDisplayNames?.Count ?? 0,
+            failed,
+            skipped,
+            emptyDisplayNames?.ToImmutableArray() ?? [])
+        {
+            ChannelOutcomes = channelOutcomes?.ToImmutableArray() ?? []
+        };
+    }
+
     private async Task<bool> TryOpenModalAsync(Func<Task<ModalOpenResult<bool>>> open, string modalName)
     {
         try
@@ -575,9 +437,6 @@ private async Task<bool> TryOpenModalAsync(Func<Task<ModalOpenResult<bool>>> ope
 
             if (!result.WasOpened) { _traceLogger.Trace($"{modalName} open preempted by an active modal."); }
 
-            // Propagate WasOpened so callers like AttentionBanner can surface a fallback error when the
-            // coordinator vetoes preemption (returns ModalOpenResult.NotOpened) rather than misreading
-            // a no-op as a successful open.
             return result.WasOpened;
         }
         catch (Exception ex)
diff --git a/src/EventLogExpert/DependencyInjection/MauiProgramExtensions.cs b/src/EventLogExpert/DependencyInjection/MauiProgramExtensions.cs
index 3ce3c2233..7d76a7a1c 100644
--- a/src/EventLogExpert/DependencyInjection/MauiProgramExtensions.cs
+++ b/src/EventLogExpert/DependencyInjection/MauiProgramExtensions.cs
@@ -19,20 +19,17 @@
 using EventLogExpert.Runtime.Common.Threading;
 using EventLogExpert.Runtime.Database;
 using EventLogExpert.Runtime.DetailsPane;
+using EventLogExpert.Runtime.Export;
 using EventLogExpert.Runtime.LogTable;
 using EventLogExpert.Runtime.Menu;
-using EventLogExpert.Runtime.Modal;
 using EventLogExpert.Runtime.Scenarios;
 using EventLogExpert.Runtime.Settings;
 using EventLogExpert.UI.Alerts;
+using EventLogExpert.UI.Modal;
 using EventLogExpert.WindowsPlatform.Activation;
 
 namespace EventLogExpert.DependencyInjection;
 
-/// <summary>
-///     Themed grouping extensions that keep <see cref="MauiProgram.CreateMauiApp" /> focused on assembly and
-///     lifecycle wiring rather than per-adapter registration churn. Each method represents a cohesive host-side concern.
-/// </summary>
 internal static class MauiProgramExtensions
 {
     extension(IServiceCollection services)
@@ -89,9 +86,9 @@ public IServiceCollection AddMauiAlertDialogService()
 
         public IServiceCollection AddMauiMenuServices()
         {
+            services.AddSingleton<EventExportCoordinator>();
             services.AddSingleton<MauiMenuActionService>();
-            services.AddSingleton<IMenuActionService>(static provider =>
-                provider.GetRequiredService<MauiMenuActionService>());
+            services.Forward<IMenuActionService, MauiMenuActionService>();
 
             return services;
         }
diff --git a/src/EventLogExpert/EventLogExpert.csproj b/src/EventLogExpert/EventLogExpert.csproj
index f1a9d990f..950738907 100644
--- a/src/EventLogExpert/EventLogExpert.csproj
+++ b/src/EventLogExpert/EventLogExpert.csproj
@@ -65,6 +65,7 @@
     </ItemGroup>
 
     <ItemGroup>
+        <PackageReference Include="Fluxor.Blazor.Web" />
         <PackageReference Include="Microsoft.Maui.Controls" />
         <PackageReference Include="Microsoft.Maui.Controls.Compatibility" />
         <PackageReference Include="Microsoft.AspNetCore.Components.WebView.Maui" />
@@ -88,8 +89,10 @@
       fails fast with a clear message rather than a confusing MSB4126 from VS MSBuild.
     -->
     <PropertyGroup>
+      <_HostOSArch>$([System.Runtime.InteropServices.RuntimeInformation]::OSArchitecture)</_HostOSArch>
       <ExplorerExtensionNativePlatform Condition="'$(RuntimeIdentifier)' != '' AND $(RuntimeIdentifier.Contains('-arm64'))">ARM64</ExplorerExtensionNativePlatform>
       <ExplorerExtensionNativePlatform Condition="'$(ExplorerExtensionNativePlatform)' == '' AND '$(RuntimeIdentifier)' == '' AND '$(Platform)' == 'ARM64'">ARM64</ExplorerExtensionNativePlatform>
+      <ExplorerExtensionNativePlatform Condition="'$(ExplorerExtensionNativePlatform)' == '' AND '$(RuntimeIdentifier)' == '' AND '$(Platform)' != 'x64' AND '$(_HostOSArch)' == 'Arm64'">ARM64</ExplorerExtensionNativePlatform>
       <ExplorerExtensionNativePlatform Condition="'$(ExplorerExtensionNativePlatform)' == '' AND ('$(RuntimeIdentifier)' == '' OR $(RuntimeIdentifier.Contains('-x64')))">x64</ExplorerExtensionNativePlatform>
     </PropertyGroup>
 
@@ -222,8 +225,10 @@
     </ItemGroup>
 
     <PropertyGroup>
+      <_HostOSArch>$([System.Runtime.InteropServices.RuntimeInformation]::OSArchitecture)</_HostOSArch>
       <_ElevationHelperRid Condition="'$(RuntimeIdentifier)' != ''">$(RuntimeIdentifier)</_ElevationHelperRid>
       <_ElevationHelperRid Condition="'$(_ElevationHelperRid)' == '' and '$(Platform)' == 'ARM64'">win-arm64</_ElevationHelperRid>
+      <_ElevationHelperRid Condition="'$(_ElevationHelperRid)' == '' and '$(Platform)' != 'x64' and '$(_HostOSArch)' == 'Arm64'">win-arm64</_ElevationHelperRid>
       <_ElevationHelperRid Condition="'$(_ElevationHelperRid)' == ''">win-x64</_ElevationHelperRid>
       <!--
         Anchor the publish output under $(BaseIntermediateOutputPath) (always "obj/") so the SDK's default Content
diff --git a/src/EventLogExpert/GlobalUsings.cs b/src/EventLogExpert/GlobalUsings.cs
index fd1cdc349..78ff45400 100644
--- a/src/EventLogExpert/GlobalUsings.cs
+++ b/src/EventLogExpert/GlobalUsings.cs
@@ -1,6 +1,4 @@
 // // Copyright (c) Microsoft Corporation.
 // // Licensed under the MIT License.
 
-// Disambiguates UI menu data records from Microsoft.Maui.Controls.MenuItem across all
-// Razor and code-behind files in the MAUI project.
-global using MenuItem = EventLogExpert.Runtime.Menu.MenuItem;
+global using MenuItem = EventLogExpert.UI.Menu.MenuItem;
diff --git a/src/EventLogExpert/MauiProgram.cs b/src/EventLogExpert/MauiProgram.cs
index 8981d6f29..58caec16c 100644
--- a/src/EventLogExpert/MauiProgram.cs
+++ b/src/EventLogExpert/MauiProgram.cs
@@ -56,7 +56,6 @@ public static MauiApp CreateMauiApp()
                 .WithLifetime(StoreLifetime.Singleton);
         });
 
-        // Bootstrap infrastructure
         var fileLocationOptions = new FileLocationOptions(FileSystem.AppDataDirectory);
         builder.Services.AddSingleton(fileLocationOptions);
         Directory.CreateDirectory(fileLocationOptions.DatabasePath);
@@ -72,14 +71,11 @@ public static MauiApp CreateMauiApp()
             return client;
         });
 
-        // Provider event-log resolvers
         builder.Services.AddEventLogProviderDatabase();
         builder.Services.AddSingleton<IEventResolverCache, EventResolverCache>();
-        builder.Services.AddSingleton<IEventXmlResolver, EventXmlResolver>();
         builder.Services.AddTransient<IEventResolver>(sp => ActivatorUtilities.CreateInstance<EventResolver>(sp,
             sp.GetRequiredService<ILogSourceFactory>().ForCategory(LogCategories.Resolution)));
 
-        // FilterLibrary persistence
         var appDbPath = Path.Combine(FileSystem.AppDataDirectory, "filter-library.db");
         builder.Services.AddFilterLibrarySqliteStore(appDbPath);
         builder.Services.AddScenarioFavoriteSqliteStore(appDbPath);
@@ -96,13 +92,11 @@ public static MauiApp CreateMauiApp()
         builder.Services.AddBackslashNameMigration();
         builder.Services.AddColumnResetMigration();
 
-        // Top-level layer registration
         builder.Services.AddEventLogFiltering();
         builder.Services.AddEventLogRuntime();
         builder.Services.AddElevatedDatabaseToolsRunner();
-        builder.Services.AddEventLogUiServices();
+        builder.Services.AddEventLogUIServices();
 
-        // Host-side DI groupings (see MauiProgramExtensions for membership)
         builder.Services.AddMauiPreferenceAdapters();
         builder.Services.AddMauiPlatformAdapters();
         builder.Services.AddWindowsPlatformAdapters();
@@ -115,8 +109,6 @@ public static MauiApp CreateMauiApp()
 
         var mauiApp = builder.Build();
 
-        // Force eager construction of BannerService — its ctor subscribes to IDatabaseService.EntriesChanged +
-        // UpgradeBatch* events. Any facet resolves to the same singleton instance.
         mauiApp.Services.GetRequiredService<IAttentionBannerService>();
         mauiApp.Services.GetRequiredService<DatabaseRecoveryHost>();
         mauiApp.Services.GetRequiredService<DebugLogHost>();
diff --git a/src/EventLogExpert/wwwroot/index.html b/src/EventLogExpert/wwwroot/index.html
index c0e0a2394..c9685d083 100644
--- a/src/EventLogExpert/wwwroot/index.html
+++ b/src/EventLogExpert/wwwroot/index.html
@@ -22,7 +22,6 @@
     </div>
 
     <script autostart="false" src="_framework/blazor.webview.js"></script>
-    <script src="_content/Fluxor.Blazor.Web/scripts/index.js"></script>
     <script src="js/app.js"></script>
 </body>
 
diff --git a/tests/Integration/EventLogExpert.ElevationHelper.IntegrationTests/Ipc/IpcMessageWriterTests.cs b/tests/Integration/EventLogExpert.ElevationHelper.IntegrationTests/Ipc/IpcMessageWriterTests.cs
index 9429dfd55..1e3738caa 100644
--- a/tests/Integration/EventLogExpert.ElevationHelper.IntegrationTests/Ipc/IpcMessageWriterTests.cs
+++ b/tests/Integration/EventLogExpert.ElevationHelper.IntegrationTests/Ipc/IpcMessageWriterTests.cs
@@ -8,6 +8,8 @@ namespace EventLogExpert.ElevationHelper.IntegrationTests.Ipc;
 
 public sealed class IpcMessageWriterTests
 {
+    private static readonly TimeSpan s_testTimeout = TimeSpan.FromSeconds(2);
+
     [Fact]
     public async Task DisposeAsync_CalledTwice_DoesNotThrow()
     {
@@ -58,7 +60,7 @@ public async Task WriteAsync_PendingWhileDisposeRuns_CompletesViaCancellationIns
 
         var disposeTask = writer.DisposeAsync().AsTask();
 
-        var completed = await Task.WhenAny(secondWrite, Task.Delay(TimeSpan.FromSeconds(2), TestContext.Current.CancellationToken));
+        var completed = await Task.WhenAny(secondWrite, Task.Delay(s_testTimeout, TestContext.Current.CancellationToken));
         Assert.Same(secondWrite, completed);
 
         stream.ReleaseFirstWrite();
diff --git a/tests/Integration/EventLogExpert.Eventing.IntegrationTests/ProviderMetadata/Wevt/OfflineWevtProviderParityTests.cs b/tests/Integration/EventLogExpert.Eventing.IntegrationTests/ProviderMetadata/Wevt/OfflineWevtProviderParityTests.cs
index d3a6ae2b3..94da7d9d0 100644
--- a/tests/Integration/EventLogExpert.Eventing.IntegrationTests/ProviderMetadata/Wevt/OfflineWevtProviderParityTests.cs
+++ b/tests/Integration/EventLogExpert.Eventing.IntegrationTests/ProviderMetadata/Wevt/OfflineWevtProviderParityTests.cs
@@ -70,7 +70,6 @@ public void Events_KernelPowerTemplates_HaveLengthOutTypeAndArrayCountParity()
             List<TemplateDataNode>? nativeNodes = ParseDataNodes(nativeEvent.Template);
             List<TemplateDataNode>? offlineNodes = ParseDataNodes(offlineEvent.Template);
 
-            // ParseDataNodes ignores structs; the struct parity test owns those templates.
             if (nativeNodes is null || offlineNodes is null || TemplateHasStruct(nativeEvent.Template)) { continue; }
 
             Assert.Equal(nativeNodes, offlineNodes);
@@ -82,7 +81,6 @@ public void Events_KernelPowerTemplates_HaveLengthOutTypeAndArrayCountParity()
 
         Assert.True(comparedCount > 0, "Expected at least one Kernel-Power non-struct template to compare.");
 
-        // Kernel-Power must exercise length references, FILETIME outType, and array counts non-vacuously.
         Assert.True(lengthBearingNodes > 0, "Expected at least one matched length-bearing field (length field-reference parity).");
         Assert.True(fileTimeNodes > 0, "Expected at least one matched FILETIME field (always-emitted outType parity).");
         Assert.True(arrayBearingNodes > 0, "Expected at least one matched array field (count attribute parity).");
@@ -109,7 +107,6 @@ public void Events_NonStructTemplates_HaveStructuralParity()
             List<TemplateDataNode>? nativeNodes = ParseDataNodes(nativeEvent.Template);
             List<TemplateDataNode>? offlineNodes = ParseDataNodes(offlineEvent.Template);
 
-            // ParseDataNodes ignores structs; the struct parity test owns those templates.
             if (nativeNodes is null || offlineNodes is null || TemplateHasStruct(nativeEvent.Template)) { continue; }
 
             Assert.Equal(nativeNodes, offlineNodes);
@@ -148,8 +145,7 @@ public void Events_SharedByIdAndVersion_HaveFieldParity()
     [Fact]
     public void Events_SharedNonStructTemplates_OfflineWritesWheneverNativeDoes()
     {
-        // Count parity catches partial fail-closed regressions that structural parity would skip.
-        (ProviderParityFixture Fixture, string Label)[] corpus =
+        (ProviderParityFixture Fixture, string Label)[] sample =
         [
             (securityAuditing, nameof(securityAuditing)),
             (kernelPower, nameof(kernelPower)),
@@ -157,12 +153,12 @@ public void Events_SharedNonStructTemplates_OfflineWritesWheneverNativeDoes()
         ];
 
         Assert.SkipUnless(
-            corpus.Any(static entry => entry.Fixture.Available),
+            sample.Any(static entry => entry.Fixture.Available),
             "Test requires at least one parity provider and its WEVT_TEMPLATE resource on the host.");
 
         int comparedProviders = 0;
 
-        foreach ((ProviderParityFixture fixture, string label) in corpus)
+        foreach ((ProviderParityFixture fixture, string label) in sample)
         {
             if (!fixture.Available) { continue; }
 
@@ -230,7 +226,6 @@ public void Events_StructTemplates_CanonicalizeToNativeStructure()
 
                 if (nativeShape is null) { continue; }
 
-                // These providers have only non-nested structs, so an empty offline shape is a regression.
                 string? offlineShape = CanonicalizeTemplate(offlineEvent.Template);
                 Assert.True(
                     offlineShape is not null,
@@ -258,7 +253,6 @@ public void Keywords_OfflineEntries_MatchNativeByKeyAndValue()
 
         Assert.NotEmpty(powerShell.Offline!.Keywords);
 
-        // Count parity catches partial keyword decode loss after mask de-duplication.
         Assert.Equal(powerShell.RawKeywordKeyCount, powerShell.Offline!.Keywords.Count);
 
         AssertOfflineMatchesNative(powerShell.Native!.Keywords, powerShell.Offline!.Keywords);
@@ -297,7 +291,6 @@ public void Opcodes_OfflineEntries_MatchNativeByKeyAndValue()
     {
         Assert.SkipUnless(powerShell.Available, SkipReasonFor(powerShell));
 
-        // OPCO ids are already opcode << 16; parity guards the factory's key projection.
         Assert.NotEmpty(powerShell.Offline!.Opcodes);
 
         Assert.Equal(powerShell.RawOpcodeKeyCount, powerShell.Offline!.Opcodes.Count);
@@ -382,7 +375,6 @@ static MessageKey ToKey(MessageModel message) =>
     private static void AssertOfflineMatchesNative<TKey>(IDictionary<TKey, string> native, IDictionary<TKey, string> offline)
         where TKey : notnull
     {
-        // Native may include standard entries the provider binary omits; offline entries must still match by key and value.
         foreach ((TKey key, string offlineValue) in offline)
         {
             Assert.True(native.TryGetValue(key, out string? nativeValue), $"Native result is missing offline key '{key}'.");
@@ -549,7 +541,6 @@ protected ProviderParityFixture(string providerName)
 
         private void CaptureRawTableCounts(string resourceFilePath, Guid publisherGuid)
         {
-            // Raw post-dedup counts catch entries dropped between parse and assembly.
             byte[]? rented = WevtTemplateReader.TryRentWevtResource(resourceFilePath, logger: null, out int size);
 
             if (rented is null) { return; }
diff --git a/tests/Integration/EventLogExpert.Eventing.IntegrationTests/Readers/EventLogWatcherTests.cs b/tests/Integration/EventLogExpert.Eventing.IntegrationTests/Readers/EventLogWatcherTests.cs
index e5de76ae0..f95eddad6 100644
--- a/tests/Integration/EventLogExpert.Eventing.IntegrationTests/Readers/EventLogWatcherTests.cs
+++ b/tests/Integration/EventLogExpert.Eventing.IntegrationTests/Readers/EventLogWatcherTests.cs
@@ -12,15 +12,20 @@ namespace EventLogExpert.Eventing.IntegrationTests.Readers;
 
 public sealed class EventLogWatcherTests
 {
+    private static readonly TimeSpan s_concurrentTimeout = TimeSpan.FromSeconds(30);
+    private static readonly TimeSpan s_interEventDelay = TimeSpan.FromMilliseconds(50);
+    private static readonly TimeSpan s_longTimeout = TimeSpan.FromSeconds(10);
+    private static readonly TimeSpan s_negativeWait = TimeSpan.FromMilliseconds(500);
+    private static readonly TimeSpan s_settleDelay = TimeSpan.FromMilliseconds(200);
+    private static readonly TimeSpan s_testTimeout = TimeSpan.FromSeconds(5);
+
     [Theory]
     [InlineData(Constants.ApplicationLogName)]
     [InlineData(Constants.SystemLogName)]
     public void Constructor_WithCommonLogs_ShouldCreateWatcher(string logName)
     {
-        // Arrange & Act
         using var watcher = new EventLogWatcher(logName);
 
-        // Assert
         Assert.NotNull(watcher);
         Assert.False(watcher.Enabled);
     }
@@ -28,55 +33,46 @@ public void Constructor_WithCommonLogs_ShouldCreateWatcher(string logName)
     [Fact]
     public void Constructor_WithEmptyLogName_ShouldThrowArgumentException()
     {
-        // Arrange & Act & Assert
         Assert.Throws<ArgumentException>(() => new EventLogWatcher(string.Empty));
     }
 
     [Fact]
     public void Constructor_WithInvalidLogName_ShouldThrowFileNotFoundException()
     {
-        // Arrange
         var invalidLogName = "NonExistentLog_" + Guid.NewGuid();
 
-        // Act & Assert
         Assert.Throws<FileNotFoundException>(() => new EventLogWatcher(invalidLogName));
     }
 
     [Fact]
     public void Constructor_WithNullLogName_ShouldThrowArgumentException()
     {
-        // Arrange & Act & Assert
         Assert.Throws<ArgumentNullException>(() => new EventLogWatcher(null!));
     }
 
     [Fact]
     public void Constructor_WithValidBookmark_ShouldCreateWatcher()
     {
-        // Arrange
         using var reader = new EventLogReader(Constants.ApplicationLogName, LogPathType.Channel);
 
         reader.TryGetEvents(out _, 1);
 
         var bookmark = reader.LastBookmark;
 
-        // Act
         using var watcher = new EventLogWatcher(Constants.ApplicationLogName, bookmark);
 
-        // Assert
         Assert.NotNull(watcher);
     }
 
     [Fact]
     public void Constructor_WithWhitespaceLogName_ShouldThrowArgumentException()
     {
-        // Arrange & Act & Assert
         Assert.Throws<ArgumentException>(() => new EventLogWatcher("   "));
     }
 
     [Fact]
     public void Dispose_AfterDispose_ShouldNotReceiveEvents()
     {
-        // Arrange
         var watcher = new EventLogWatcher(Constants.ApplicationLogName);
         int eventCount = 0;
         var eventReceived = new ManualResetEventSlim(false);
@@ -89,7 +85,6 @@ public void Dispose_AfterDispose_ShouldNotReceiveEvents()
 
         watcher.Enabled = true;
 
-        // Act
         watcher.Dispose();
         int countBefore = Volatile.Read(ref eventCount);
         eventReceived.Reset();
@@ -98,9 +93,8 @@ public void Dispose_AfterDispose_ShouldNotReceiveEvents()
         eventLog.Source = Constants.ApplicationLogName;
         eventLog.WriteEntry("Test event after dispose", EventLogEntryType.Information);
 
-        bool received = eventReceived.Wait(TimeSpan.FromMilliseconds(500), TestContext.Current.CancellationToken);
+        bool received = eventReceived.Wait(s_negativeWait, TestContext.Current.CancellationToken);
 
-        // Assert
         int actual = Volatile.Read(ref eventCount);
         Assert.False(received, "Should not have received any event after dispose");
         Assert.Equal(countBefore, actual);
@@ -109,18 +103,15 @@ public void Dispose_AfterDispose_ShouldNotReceiveEvents()
     [Fact]
     public void Dispose_BeforeSubscribe_ShouldNotThrow()
     {
-        // Arrange
         var watcher = new EventLogWatcher(Constants.ApplicationLogName);
         Assert.False(watcher.Enabled);
 
-        // Act & Assert
         watcher.Dispose();
     }
 
     [Fact]
     public void Dispose_ShouldReleaseUnderlyingWaitHandle()
     {
-        // Arrange
         var watcher = new EventLogWatcher(Constants.ApplicationLogName);
         watcher.Enabled = true;
 
@@ -132,10 +123,8 @@ public void Dispose_ShouldReleaseUnderlyingWaitHandle()
         var newEvents = (AutoResetEvent?)newEventsField.GetValue(watcher);
         Assert.NotNull(newEvents);
 
-        // Act
         watcher.Dispose();
 
-        // Assert
         Assert.True(newEvents.SafeWaitHandle.IsClosed, "AutoResetEvent kernel handle leaked after Dispose.");
 
         watcher.Dispose();
@@ -145,7 +134,6 @@ public void Dispose_ShouldReleaseUnderlyingWaitHandle()
     [Fact]
     public void Dispose_WhenCalledFromHandler_ShouldThrowInvalidOperationException()
     {
-        // Arrange
         using var watcher = new EventLogWatcher(Constants.ApplicationLogName);
         Exception? observed = null;
         var observedSet = new ManualResetEventSlim(false);
@@ -169,14 +157,12 @@ public void Dispose_WhenCalledFromHandler_ShouldThrowInvalidOperationException()
 
         watcher.Enabled = true;
 
-        // Act
         using var eventLog = new EventLog(Constants.ApplicationLogName);
         eventLog.Source = Constants.ApplicationLogName;
         eventLog.WriteEntry("Test event for reentrant Dispose", EventLogEntryType.Information);
 
-        bool received = observedSet.Wait(TimeSpan.FromSeconds(5), TestContext.Current.CancellationToken);
+        bool received = observedSet.Wait(s_testTimeout, TestContext.Current.CancellationToken);
 
-        // Assert
         Assert.True(received, "Handler was never invoked, so reentrancy was not exercised");
         var captured = Volatile.Read(ref observed);
         Assert.NotNull(captured);
@@ -187,11 +173,9 @@ public void Dispose_WhenCalledFromHandler_ShouldThrowInvalidOperationException()
     [Fact]
     public void Dispose_WhenCalledMultipleTimes_ShouldNotThrow()
     {
-        // Arrange
         var watcher = new EventLogWatcher(Constants.ApplicationLogName);
         watcher.Enabled = true;
 
-        // Act & Assert
         watcher.Dispose();
         watcher.Dispose();
         watcher.Dispose();
@@ -200,49 +184,39 @@ public void Dispose_WhenCalledMultipleTimes_ShouldNotThrow()
     [Fact]
     public void Dispose_WhenCalled_ShouldUnsubscribe()
     {
-        // Arrange
         var watcher = new EventLogWatcher(Constants.ApplicationLogName);
         watcher.Enabled = true;
 
-        // Act
         watcher.Dispose();
 
-        // Assert
         Assert.False(watcher.Enabled);
     }
 
     [Fact]
     public void Dispose_WhenNotSubscribed_ShouldNotThrow()
     {
-        // Arrange
         var watcher = new EventLogWatcher(Constants.ApplicationLogName);
 
-        // Act & Assert
         watcher.Dispose();
     }
 
     [Fact]
     public void Dispose_WhileSubscribed_ShouldUnsubscribeAndDispose()
     {
-        // Arrange
         var watcher = new EventLogWatcher(Constants.ApplicationLogName);
         watcher.Enabled = true;
         Assert.True(watcher.Enabled);
 
-        // Act
         watcher.Dispose();
 
-        // Assert
         Assert.False(watcher.Enabled);
     }
 
     [Fact]
     public void Enabled_AfterMultipleToggle_ShouldMaintainCorrectState()
     {
-        // Arrange
         using var watcher = new EventLogWatcher(Constants.ApplicationLogName);
 
-        // Act & Assert
         for (int i = 0; i < 3; i++)
         {
             watcher.Enabled = true;
@@ -256,20 +230,16 @@ public void Enabled_AfterMultipleToggle_ShouldMaintainCorrectState()
     [Fact]
     public void Enabled_WhenCreated_ShouldBeFalse()
     {
-        // Arrange & Act
         using var watcher = new EventLogWatcher(Constants.ApplicationLogName);
 
-        // Assert
         Assert.False(watcher.Enabled);
     }
 
     [Fact]
     public async Task Enabled_WhenRacingFromMultipleThreads_ShouldNotHangOrCorruptState()
     {
-        // Arrange
         using var watcher = new EventLogWatcher(Constants.ApplicationLogName);
 
-        // Act
         var tasks = new List<Task>(100);
         var ct = TestContext.Current.CancellationToken;
 
@@ -285,14 +255,12 @@ public async Task Enabled_WhenRacingFromMultipleThreads_ShouldNotHangOrCorruptSt
 
         var allDone = Task.WhenAll(tasks);
 
-        // Assert: timeout regression-tests the RegisteredWaitHandle race.
-        await allDone.WaitAsync(TimeSpan.FromSeconds(30), ct);
+        await allDone.WaitAsync(s_concurrentTimeout, ct);
     }
 
     [Fact]
     public void Enabled_WhenSetToFalseFromHandler_ShouldThrowInvalidOperationException()
     {
-        // Arrange
         using var watcher = new EventLogWatcher(Constants.ApplicationLogName);
         Exception? observed = null;
         var observedSet = new ManualResetEventSlim(false);
@@ -316,14 +284,12 @@ public void Enabled_WhenSetToFalseFromHandler_ShouldThrowInvalidOperationExcepti
 
         watcher.Enabled = true;
 
-        // Act
         using var eventLog = new EventLog(Constants.ApplicationLogName);
         eventLog.Source = Constants.ApplicationLogName;
         eventLog.WriteEntry("Test event for reentrant Enabled=false", EventLogEntryType.Information);
 
-        bool received = observedSet.Wait(TimeSpan.FromSeconds(5), TestContext.Current.CancellationToken);
+        bool received = observedSet.Wait(s_testTimeout, TestContext.Current.CancellationToken);
 
-        // Assert
         Assert.True(received, "Handler was never invoked, so reentrancy was not exercised");
         var captured = Volatile.Read(ref observed);
         Assert.NotNull(captured);
@@ -334,12 +300,10 @@ public void Enabled_WhenSetToFalseFromHandler_ShouldThrowInvalidOperationExcepti
     [Fact]
     public void Enabled_WhenSetToFalseTwice_ShouldNotThrow()
     {
-        // Arrange
         using var watcher = new EventLogWatcher(Constants.ApplicationLogName);
         watcher.Enabled = true;
         watcher.Enabled = false;
 
-        // Act & Assert
         watcher.Enabled = false;
         Assert.False(watcher.Enabled);
     }
@@ -347,25 +311,20 @@ public void Enabled_WhenSetToFalseTwice_ShouldNotThrow()
     [Fact]
     public void Enabled_WhenSetToFalse_ShouldUnsubscribe()
     {
-        // Arrange
         using var watcher = new EventLogWatcher(Constants.ApplicationLogName);
         watcher.Enabled = true;
 
-        // Act
         watcher.Enabled = false;
 
-        // Assert
         Assert.False(watcher.Enabled);
     }
 
     [Fact]
     public void Enabled_WhenSetToSameValue_ShouldNotThrow()
     {
-        // Arrange
         using var watcher = new EventLogWatcher(Constants.ApplicationLogName);
         watcher.Enabled = false;
 
-        // Act & Assert
         watcher.Enabled = false;
         Assert.False(watcher.Enabled);
     }
@@ -373,62 +332,49 @@ public void Enabled_WhenSetToSameValue_ShouldNotThrow()
     [Fact]
     public void Enabled_WhenSetToTrueAfterDispose_ShouldThrowObjectDisposedException()
     {
-        // Arrange
         var watcher = new EventLogWatcher(Constants.ApplicationLogName);
         watcher.Dispose();
 
-        // Act & Assert
         Assert.Throws<ObjectDisposedException>(() => watcher.Enabled = true);
     }
 
     [Fact]
     public void Enabled_WhenSetToTrueTwice_ShouldNotThrow()
     {
-        // Arrange
         using var watcher = new EventLogWatcher(Constants.ApplicationLogName);
         watcher.Enabled = true;
 
-        // Act - Setting to true when already true is a no-op (switch case doesn't match)
         watcher.Enabled = true;
 
-        // Assert
         Assert.True(watcher.Enabled);
     }
 
     [Fact]
     public void Enabled_WhenSetToTrueTwice_ShouldRemainEnabled()
     {
-        // Arrange
         using var watcher = new EventLogWatcher(Constants.ApplicationLogName);
         watcher.Enabled = true;
 
-        // Act - Setting to true when already true is a no-op (switch case doesn't match)
         watcher.Enabled = true;
 
-        // Assert
         Assert.True(watcher.Enabled);
     }
 
     [Fact]
     public void Enabled_WhenSetToTrue_ShouldSubscribe()
     {
-        // Arrange
         using var watcher = new EventLogWatcher(Constants.ApplicationLogName);
 
-        // Act
         watcher.Enabled = true;
 
-        // Assert
         Assert.True(watcher.Enabled);
     }
 
     [Fact]
     public void Enabled_WhenToggled_ShouldUpdateState()
     {
-        // Arrange
         using var watcher = new EventLogWatcher(Constants.ApplicationLogName);
 
-        // Act & Assert
         Assert.False(watcher.Enabled);
 
         watcher.Enabled = true;
@@ -444,7 +390,6 @@ public void Enabled_WhenToggled_ShouldUpdateState()
     [Fact]
     public void EventRecordWritten_AfterResubscribe_ShouldReceiveEvents()
     {
-        // Arrange
         using var watcher = new EventLogWatcher(Constants.ApplicationLogName);
         int eventCount = 0;
         var eventReceived = new ManualResetEventSlim(false);
@@ -455,7 +400,6 @@ public void EventRecordWritten_AfterResubscribe_ShouldReceiveEvents()
             eventReceived.Set();
         };
 
-        // Act
         watcher.Enabled = true;
         watcher.Enabled = false;
         Interlocked.Exchange(ref eventCount, 0);
@@ -467,9 +411,8 @@ public void EventRecordWritten_AfterResubscribe_ShouldReceiveEvents()
         eventLog.Source = Constants.ApplicationLogName;
         eventLog.WriteEntry("Test event after resubscribe", EventLogEntryType.Information);
 
-        bool received = eventReceived.Wait(TimeSpan.FromSeconds(5), TestContext.Current.CancellationToken);
+        bool received = eventReceived.Wait(s_testTimeout, TestContext.Current.CancellationToken);
 
-        // Assert
         int actual = Volatile.Read(ref eventCount);
         Assert.True(received, "Did not receive event within timeout period");
         Assert.True(actual > 0, $"Expected at least one event after resubscribe, but got {actual}.");
@@ -478,7 +421,6 @@ public void EventRecordWritten_AfterResubscribe_ShouldReceiveEvents()
     [Fact]
     public void EventRecordWritten_AfterUnsubscribe_ShouldStopReceivingEvents()
     {
-        // Arrange
         using var watcher = new EventLogWatcher(Constants.ApplicationLogName);
         int eventCount = 0;
         var eventReceived = new ManualResetEventSlim(false);
@@ -491,19 +433,16 @@ public void EventRecordWritten_AfterUnsubscribe_ShouldStopReceivingEvents()
 
         watcher.Enabled = true;
 
-        // Act
         watcher.Enabled = false;
         int countBefore = Volatile.Read(ref eventCount);
         eventReceived.Reset();
 
-        // Stimulus event written AFTER Disable so the test isn't vacuous.
         using var eventLog = new EventLog(Constants.ApplicationLogName);
         eventLog.Source = Constants.ApplicationLogName;
         eventLog.WriteEntry("Test event after unsubscribe", EventLogEntryType.Information);
 
-        bool fired = eventReceived.Wait(TimeSpan.FromMilliseconds(500), TestContext.Current.CancellationToken);
+        bool fired = eventReceived.Wait(s_negativeWait, TestContext.Current.CancellationToken);
 
-        // Assert
         int actual = Volatile.Read(ref eventCount);
         Assert.False(fired, "Should not have received any event after unsubscribe");
         Assert.Equal(countBefore, actual);
@@ -512,7 +451,6 @@ public void EventRecordWritten_AfterUnsubscribe_ShouldStopReceivingEvents()
     [Fact]
     public void EventRecordWritten_ForNormalEvent_ShouldHaveNullError()
     {
-        // Arrange
         using var watcher = new EventLogWatcher(Constants.ApplicationLogName);
         var receivedEvents = new ConcurrentQueue<EventRecord>();
         var eventReceived = new ManualResetEventSlim(false);
@@ -529,14 +467,12 @@ public void EventRecordWritten_ForNormalEvent_ShouldHaveNullError()
 
         watcher.Enabled = true;
 
-        // Act
         using var eventLog = new EventLog(Constants.ApplicationLogName);
         eventLog.Source = Constants.ApplicationLogName;
         eventLog.WriteEntry("Test event for normal-path null Error invariant", EventLogEntryType.Information);
 
-        bool received = eventReceived.Wait(TimeSpan.FromSeconds(5), TestContext.Current.CancellationToken);
+        bool received = eventReceived.Wait(s_testTimeout, TestContext.Current.CancellationToken);
 
-        // Assert
         var snapshot = receivedEvents.ToArray();
         Assert.True(received, "Did not receive event within timeout period");
         Assert.NotEmpty(snapshot);
@@ -546,7 +482,6 @@ public void EventRecordWritten_ForNormalEvent_ShouldHaveNullError()
     [Fact]
     public void EventRecordWritten_ShouldHaveRecordId()
     {
-        // Arrange
         using var watcher = new EventLogWatcher(Constants.ApplicationLogName);
         EventRecord? capturedEvent = null;
         var eventReceived = new ManualResetEventSlim(false);
@@ -559,14 +494,12 @@ public void EventRecordWritten_ShouldHaveRecordId()
 
         watcher.Enabled = true;
 
-        // Act
         using var eventLog = new EventLog(Constants.ApplicationLogName);
         eventLog.Source = Constants.ApplicationLogName;
         eventLog.WriteEntry("Test event for record ID", EventLogEntryType.Information);
 
-        bool received = eventReceived.Wait(TimeSpan.FromSeconds(5), TestContext.Current.CancellationToken);
+        bool received = eventReceived.Wait(s_testTimeout, TestContext.Current.CancellationToken);
 
-        // Assert
         var snapshot = Volatile.Read(ref capturedEvent);
         Assert.True(received, "Did not receive event within timeout period");
         Assert.NotNull(snapshot);
@@ -577,7 +510,6 @@ public void EventRecordWritten_ShouldHaveRecordId()
     [Fact]
     public void EventRecordWritten_ShouldHaveValidTimeCreated()
     {
-        // Arrange
         using var watcher = new EventLogWatcher(Constants.ApplicationLogName);
         EventRecord? capturedEvent = null;
         var eventReceived = new ManualResetEventSlim(false);
@@ -590,17 +522,15 @@ public void EventRecordWritten_ShouldHaveValidTimeCreated()
 
         watcher.Enabled = true;
 
-        // Act
         var beforeWrite = DateTime.UtcNow;
 
         using var eventLog = new EventLog(Constants.ApplicationLogName);
         eventLog.Source = Constants.ApplicationLogName;
         eventLog.WriteEntry("Test event for timestamp", EventLogEntryType.Information);
 
-        bool received = eventReceived.Wait(TimeSpan.FromSeconds(5), TestContext.Current.CancellationToken);
-        var afterWrite = DateTime.UtcNow.AddSeconds(1); // Add buffer for processing
+        bool received = eventReceived.Wait(s_testTimeout, TestContext.Current.CancellationToken);
+        var afterWrite = DateTime.UtcNow.AddSeconds(1);
 
-        // Assert
         var snapshot = Volatile.Read(ref capturedEvent);
         Assert.True(received, "Did not receive event within timeout period");
         Assert.NotNull(snapshot);
@@ -612,7 +542,6 @@ public void EventRecordWritten_ShouldHaveValidTimeCreated()
     [Fact]
     public void EventRecordWritten_ShouldIncludePathName()
     {
-        // Arrange
         using var watcher = new EventLogWatcher(Constants.ApplicationLogName);
         EventRecord? capturedEvent = null;
         var eventReceived = new ManualResetEventSlim(false);
@@ -625,14 +554,12 @@ public void EventRecordWritten_ShouldIncludePathName()
 
         watcher.Enabled = true;
 
-        // Act
         using var eventLog = new EventLog(Constants.ApplicationLogName);
         eventLog.Source = Constants.ApplicationLogName;
         eventLog.WriteEntry("Test event for path validation", EventLogEntryType.Information);
 
-        bool received = eventReceived.Wait(TimeSpan.FromSeconds(5), TestContext.Current.CancellationToken);
+        bool received = eventReceived.Wait(s_testTimeout, TestContext.Current.CancellationToken);
 
-        // Assert
         var snapshot = Volatile.Read(ref capturedEvent);
         Assert.True(received, "Did not receive event within timeout period");
         Assert.NotNull(snapshot);
@@ -642,7 +569,6 @@ public void EventRecordWritten_ShouldIncludePathName()
     [Fact]
     public void EventRecordWritten_ShouldIncludeProperties()
     {
-        // Arrange
         using var watcher = new EventLogWatcher(Constants.ApplicationLogName);
         EventRecord? capturedEvent = null;
         var eventReceived = new ManualResetEventSlim(false);
@@ -655,14 +581,12 @@ public void EventRecordWritten_ShouldIncludeProperties()
 
         watcher.Enabled = true;
 
-        // Act
         using var eventLog = new EventLog(Constants.ApplicationLogName);
         eventLog.Source = Constants.ApplicationLogName;
         eventLog.WriteEntry("Test event for properties", EventLogEntryType.Information);
 
-        bool received = eventReceived.Wait(TimeSpan.FromSeconds(5), TestContext.Current.CancellationToken);
+        bool received = eventReceived.Wait(s_testTimeout, TestContext.Current.CancellationToken);
 
-        // Assert
         var snapshot = Volatile.Read(ref capturedEvent);
         Assert.True(received, "Did not receive event within timeout period");
         Assert.NotNull(snapshot);
@@ -672,7 +596,6 @@ public void EventRecordWritten_ShouldIncludeProperties()
     [Fact]
     public void EventRecordWritten_ShouldProvideCorrectSender()
     {
-        // Arrange
         using var watcher = new EventLogWatcher(Constants.ApplicationLogName);
         object? capturedSender = null;
         var eventReceived = new ManualResetEventSlim(false);
@@ -685,14 +608,12 @@ public void EventRecordWritten_ShouldProvideCorrectSender()
 
         watcher.Enabled = true;
 
-        // Act
         using var eventLog = new EventLog(Constants.ApplicationLogName);
         eventLog.Source = Constants.ApplicationLogName;
         eventLog.WriteEntry("Test event for sender validation", EventLogEntryType.Information);
 
-        bool received = eventReceived.Wait(TimeSpan.FromSeconds(5), TestContext.Current.CancellationToken);
+        bool received = eventReceived.Wait(s_testTimeout, TestContext.Current.CancellationToken);
 
-        // Assert
         var snapshot = Volatile.Read(ref capturedSender);
         Assert.True(received, "Did not receive event within timeout period");
         Assert.NotNull(snapshot);
@@ -702,7 +623,6 @@ public void EventRecordWritten_ShouldProvideCorrectSender()
     [Fact]
     public async Task EventRecordWritten_ShouldReceiveEventsInOrder()
     {
-        // Arrange
         using var watcher = new EventLogWatcher(Constants.ApplicationLogName);
         const int expectedCount = 3;
         var receivedEvents = new ConcurrentQueue<EventRecord>();
@@ -713,7 +633,6 @@ public async Task EventRecordWritten_ShouldReceiveEventsInOrder()
         {
             receivedEvents.Enqueue(record);
 
-            // Bound Signal — ambient callbacks past expectedCount would throw.
             int count = Interlocked.Increment(ref signalCount);
 
             if (count <= expectedCount)
@@ -724,19 +643,17 @@ public async Task EventRecordWritten_ShouldReceiveEventsInOrder()
 
         watcher.Enabled = true;
 
-        // Act
         using var eventLog = new EventLog(Constants.ApplicationLogName);
         eventLog.Source = Constants.ApplicationLogName;
 
         eventLog.WriteEntry("Event A", EventLogEntryType.Information);
-        await Task.Delay(TimeSpan.FromMilliseconds(50), TestContext.Current.CancellationToken);
+        await Task.Delay(s_interEventDelay, TestContext.Current.CancellationToken);
         eventLog.WriteEntry("Event B", EventLogEntryType.Information);
-        await Task.Delay(TimeSpan.FromMilliseconds(50), TestContext.Current.CancellationToken);
+        await Task.Delay(s_interEventDelay, TestContext.Current.CancellationToken);
         eventLog.WriteEntry("Event C", EventLogEntryType.Information);
 
-        bool received = countdown.Wait(TimeSpan.FromSeconds(10), TestContext.Current.CancellationToken);
+        bool received = countdown.Wait(s_longTimeout, TestContext.Current.CancellationToken);
 
-        // Assert
         var snapshot = receivedEvents.ToArray();
         Assert.True(received, "Did not receive all events within timeout period");
         Assert.True(snapshot.Length >= expectedCount, $"Expected at least {expectedCount} events in snapshot, but got {snapshot.Length}.");
@@ -751,7 +668,6 @@ public async Task EventRecordWritten_ShouldReceiveEventsInOrder()
     [Fact]
     public void EventRecordWritten_WhenHandlerThrows_ShouldStillDeliverFutureEvents()
     {
-        // Arrange
         using var watcher = new EventLogWatcher(Constants.ApplicationLogName);
         int attempts = 0;
         var firstObserved = new ManualResetEventSlim(false);
@@ -759,7 +675,6 @@ public void EventRecordWritten_WhenHandlerThrows_ShouldStillDeliverFutureEvents(
 
         watcher.EventRecordWritten += (sender, record) =>
         {
-            // Signal "first observed" before the throw so the stimulus thread can release the second write.
             int n = Interlocked.Increment(ref attempts);
 
             if (n == 1)
@@ -776,15 +691,13 @@ public void EventRecordWritten_WhenHandlerThrows_ShouldStillDeliverFutureEvents(
         using var eventLog = new EventLog(Constants.ApplicationLogName);
         eventLog.Source = Constants.ApplicationLogName;
 
-        // Act
         eventLog.WriteEntry("Test event 1 (handler throws on first invocation)", EventLogEntryType.Information);
-        bool firstReceived = firstObserved.Wait(TimeSpan.FromSeconds(5), TestContext.Current.CancellationToken);
+        bool firstReceived = firstObserved.Wait(s_testTimeout, TestContext.Current.CancellationToken);
         Assert.True(firstReceived, "First handler invocation was not observed");
 
         eventLog.WriteEntry("Test event 2 (handler should still fire)", EventLogEntryType.Information);
-        bool laterReceived = laterObserved.Wait(TimeSpan.FromSeconds(5), TestContext.Current.CancellationToken);
+        bool laterReceived = laterObserved.Wait(s_testTimeout, TestContext.Current.CancellationToken);
 
-        // Assert
         int actual = Volatile.Read(ref attempts);
         Assert.True(laterReceived,
             $"Handler did not fire again after throwing on first invocation; attempts={actual}");
@@ -795,7 +708,6 @@ public void EventRecordWritten_WhenHandlerThrows_ShouldStillDeliverFutureEvents(
     [Fact]
     public void EventRecordWritten_WhenMultipleEventsWritten_ShouldReceiveAll()
     {
-        // Arrange
         using var watcher = new EventLogWatcher(Constants.ApplicationLogName);
         const int expectedCount = 3;
         int eventCount = 0;
@@ -803,7 +715,6 @@ public void EventRecordWritten_WhenMultipleEventsWritten_ShouldReceiveAll()
 
         watcher.EventRecordWritten += (sender, record) =>
         {
-            // Bound Signal — ambient callbacks past expectedCount would throw.
             int count = Interlocked.Increment(ref eventCount);
 
             if (count <= expectedCount)
@@ -814,7 +725,6 @@ public void EventRecordWritten_WhenMultipleEventsWritten_ShouldReceiveAll()
 
         watcher.Enabled = true;
 
-        // Act
         using var eventLog = new EventLog(Constants.ApplicationLogName);
         eventLog.Source = Constants.ApplicationLogName;
 
@@ -822,9 +732,8 @@ public void EventRecordWritten_WhenMultipleEventsWritten_ShouldReceiveAll()
         eventLog.WriteEntry("Test event 2", EventLogEntryType.Warning);
         eventLog.WriteEntry("Test event 3", EventLogEntryType.Error);
 
-        bool received = countdown.Wait(TimeSpan.FromSeconds(10), TestContext.Current.CancellationToken);
+        bool received = countdown.Wait(s_longTimeout, TestContext.Current.CancellationToken);
 
-        // Assert
         int actual = Volatile.Read(ref eventCount);
         Assert.True(received, $"Did not receive all events within timeout period. Got {actual}.");
         Assert.True(actual >= expectedCount, $"Expected at least {expectedCount} events, but got {actual}.");
@@ -833,7 +742,6 @@ public void EventRecordWritten_WhenMultipleEventsWritten_ShouldReceiveAll()
     [Fact]
     public void EventRecordWritten_WhenNotSubscribed_ShouldNotReceiveEvents()
     {
-        // Arrange — handler attached but Enabled is never set to true.
         using var watcher = new EventLogWatcher(Constants.ApplicationLogName);
         int eventCount = 0;
         var eventReceived = new ManualResetEventSlim(false);
@@ -844,14 +752,12 @@ public void EventRecordWritten_WhenNotSubscribed_ShouldNotReceiveEvents()
             eventReceived.Set();
         };
 
-        // Act — stimulus event so the negative case isn't vacuous.
         using var eventLog = new EventLog(Constants.ApplicationLogName);
         eventLog.Source = Constants.ApplicationLogName;
         eventLog.WriteEntry("Test event with watcher not enabled", EventLogEntryType.Information);
 
-        bool received = eventReceived.Wait(TimeSpan.FromMilliseconds(500), TestContext.Current.CancellationToken);
+        bool received = eventReceived.Wait(s_negativeWait, TestContext.Current.CancellationToken);
 
-        // Assert
         int actual = Volatile.Read(ref eventCount);
         Assert.False(received, "Should not have received any event when watcher is not Enabled");
         Assert.Equal(0, actual);
@@ -860,20 +766,17 @@ public void EventRecordWritten_WhenNotSubscribed_ShouldNotReceiveEvents()
     [Fact]
     public void EventRecordWritten_WhenOneOfMultipleHandlersThrows_ShouldStillNotifyOthers()
     {
-        // Arrange
         using var watcher = new EventLogWatcher(Constants.ApplicationLogName);
         int failingCount = 0;
         int succeedingCount = 0;
         var succeedingObserved = new ManualResetEventSlim(false);
 
-        // First subscriber always throws.
         watcher.EventRecordWritten += (sender, record) =>
         {
             Interlocked.Increment(ref failingCount);
             throw new InvalidOperationException("subscriber A always fails");
         };
 
-        // Second subscriber must still fire despite the first throwing.
         watcher.EventRecordWritten += (sender, record) =>
         {
             Interlocked.Increment(ref succeedingCount);
@@ -882,14 +785,12 @@ public void EventRecordWritten_WhenOneOfMultipleHandlersThrows_ShouldStillNotify
 
         watcher.Enabled = true;
 
-        // Act
         using var eventLog = new EventLog(Constants.ApplicationLogName);
         eventLog.Source = Constants.ApplicationLogName;
         eventLog.WriteEntry("Test event for multi-subscriber isolation", EventLogEntryType.Information);
 
-        bool received = succeedingObserved.Wait(TimeSpan.FromSeconds(5), TestContext.Current.CancellationToken);
+        bool received = succeedingObserved.Wait(s_testTimeout, TestContext.Current.CancellationToken);
 
-        // Assert
         int failed = Volatile.Read(ref failingCount);
         int succeeded = Volatile.Read(ref succeedingCount);
         Assert.True(received,
@@ -901,7 +802,6 @@ public void EventRecordWritten_WhenOneOfMultipleHandlersThrows_ShouldStillNotify
     [Fact]
     public void EventRecordWritten_WhenSubscribed_ShouldReceiveEvents()
     {
-        // Arrange
         using var watcher = new EventLogWatcher(Constants.ApplicationLogName);
         int eventCount = 0;
         EventRecord? capturedEvent = null;
@@ -914,16 +814,14 @@ public void EventRecordWritten_WhenSubscribed_ShouldReceiveEvents()
             eventReceived.Set();
         };
 
-        // Act
         watcher.Enabled = true;
 
         using var eventLog = new EventLog(Constants.ApplicationLogName);
         eventLog.Source = Constants.ApplicationLogName;
         eventLog.WriteEntry("Test event for EventLogWatcher", EventLogEntryType.Information);
 
-        bool received = eventReceived.Wait(TimeSpan.FromSeconds(5), TestContext.Current.CancellationToken);
+        bool received = eventReceived.Wait(s_testTimeout, TestContext.Current.CancellationToken);
 
-        // Assert
         int actual = Volatile.Read(ref eventCount);
         var snapshot = Volatile.Read(ref capturedEvent);
         Assert.True(received, "Did not receive event within timeout period");
@@ -934,7 +832,6 @@ public void EventRecordWritten_WhenSubscribed_ShouldReceiveEvents()
     [Fact]
     public void EventRecordWritten_WithBookmark_ShouldReceiveNewEvents()
     {
-        // Arrange
         using var reader = new EventLogReader(Constants.ApplicationLogName, LogPathType.Channel);
         reader.TryGetEvents(out _, 1);
         var bookmark = reader.LastBookmark;
@@ -949,16 +846,14 @@ public void EventRecordWritten_WithBookmark_ShouldReceiveNewEvents()
             eventReceived.Set();
         };
 
-        // Act
         watcher.Enabled = true;
 
         using var eventLog = new EventLog(Constants.ApplicationLogName);
         eventLog.Source = Constants.ApplicationLogName;
         eventLog.WriteEntry("Test event after bookmark", EventLogEntryType.Information);
 
-        bool received = eventReceived.Wait(TimeSpan.FromSeconds(5), TestContext.Current.CancellationToken);
+        bool received = eventReceived.Wait(s_testTimeout, TestContext.Current.CancellationToken);
 
-        // Assert
         int actual = Volatile.Read(ref eventCount);
         Assert.True(received, "Did not receive event within timeout period");
         Assert.True(actual > 0, $"Expected at least one event after bookmark, but got {actual}.");
@@ -967,7 +862,6 @@ public void EventRecordWritten_WithBookmark_ShouldReceiveNewEvents()
     [Fact]
     public async Task EventRecordWritten_WithConcurrentEventWrites_ShouldHandleAllEvents()
     {
-        // Arrange
         using var watcher = new EventLogWatcher(Constants.ApplicationLogName);
         const int expectedCount = 5;
         int eventCount = 0;
@@ -975,7 +869,6 @@ public async Task EventRecordWritten_WithConcurrentEventWrites_ShouldHandleAllEv
 
         watcher.EventRecordWritten += (sender, record) =>
         {
-            // Bound Signal — ambient callbacks past expectedCount would throw.
             int count = Interlocked.Increment(ref eventCount);
 
             if (count <= expectedCount)
@@ -986,7 +879,6 @@ public async Task EventRecordWritten_WithConcurrentEventWrites_ShouldHandleAllEv
 
         watcher.Enabled = true;
 
-        // Act - Write events from multiple threads
         var tasks = new[]
         {
             Task.Run(() =>
@@ -1022,9 +914,8 @@ public async Task EventRecordWritten_WithConcurrentEventWrites_ShouldHandleAllEv
         };
 
         await Task.WhenAll(tasks);
-        bool received = countdown.Wait(TimeSpan.FromSeconds(10), TestContext.Current.CancellationToken);
+        bool received = countdown.Wait(s_longTimeout, TestContext.Current.CancellationToken);
 
-        // Assert
         int actual = Volatile.Read(ref eventCount);
         Assert.True(received, $"Did not receive all events within timeout period. Got {actual} events.");
         Assert.True(actual >= expectedCount, $"Expected at least {expectedCount} events, but got {actual}.");
@@ -1033,14 +924,11 @@ public async Task EventRecordWritten_WithConcurrentEventWrites_ShouldHandleAllEv
     [Fact]
     public void EventRecordWritten_WithInvalidBookmark_ShouldThrowAndNotMaskAsUnauthorizedAccessException()
     {
-        // Arrange
         var invalidBookmark = "InvalidBookmarkString";
         using var watcher = new EventLogWatcher(Constants.ApplicationLogName, invalidBookmark);
 
-        // Act
         var ex = Record.Exception(() => watcher.Enabled = true);
 
-        // Assert — bad bookmark must surface an exception that is not masked as UAE.
         Assert.NotNull(ex);
         Assert.IsNotType<UnauthorizedAccessException>(ex);
     }
@@ -1048,7 +936,6 @@ public void EventRecordWritten_WithInvalidBookmark_ShouldThrowAndNotMaskAsUnauth
     [Fact]
     public void EventRecordWritten_WithMultipleSubscribers_ShouldNotifyAll()
     {
-        // Arrange
         using var watcher = new EventLogWatcher(Constants.ApplicationLogName);
         const int expectedCountPerSubscriber = 1;
         int eventCount1 = 0;
@@ -1057,7 +944,6 @@ public void EventRecordWritten_WithMultipleSubscribers_ShouldNotifyAll()
 
         watcher.EventRecordWritten += (sender, record) =>
         {
-            // Guard CountdownEvent.Signal against ambient over-signal.
             int count = Interlocked.Increment(ref eventCount1);
 
             if (count <= expectedCountPerSubscriber)
@@ -1078,14 +964,12 @@ public void EventRecordWritten_WithMultipleSubscribers_ShouldNotifyAll()
 
         watcher.Enabled = true;
 
-        // Act
         using var eventLog = new EventLog(Constants.ApplicationLogName);
         eventLog.Source = Constants.ApplicationLogName;
         eventLog.WriteEntry("Test event for multiple subscribers", EventLogEntryType.Information);
 
-        bool received = countdown.Wait(TimeSpan.FromSeconds(5), TestContext.Current.CancellationToken);
+        bool received = countdown.Wait(s_testTimeout, TestContext.Current.CancellationToken);
 
-        // Assert
         int actual1 = Volatile.Read(ref eventCount1);
         int actual2 = Volatile.Read(ref eventCount2);
         Assert.True(received, "Did not receive events in all subscribers within timeout period");
@@ -1096,26 +980,22 @@ public void EventRecordWritten_WithMultipleSubscribers_ShouldNotifyAll()
     [Fact]
     public async Task EventRecordWritten_WithNoSubscribers_ShouldNotThrow()
     {
-        // Arrange
         using var watcher = new EventLogWatcher(Constants.ApplicationLogName);
 
-        // Act
         watcher.Enabled = true;
 
         using var eventLog = new EventLog(Constants.ApplicationLogName);
         eventLog.Source = Constants.ApplicationLogName;
         eventLog.WriteEntry("Test event with no subscribers", EventLogEntryType.Information);
 
-        await Task.Delay(TimeSpan.FromMilliseconds(200), TestContext.Current.CancellationToken);
+        await Task.Delay(s_settleDelay, TestContext.Current.CancellationToken);
 
-        // Assert - No exception means success
         Assert.True(watcher.Enabled);
     }
 
     [Fact]
     public void EventRecordWritten_WithRenderXmlFalse_ShouldNotIncludeXml()
     {
-        // Arrange
         using var watcher = new EventLogWatcher(Constants.ApplicationLogName);
         EventRecord? capturedEvent = null;
         var eventReceived = new ManualResetEventSlim(false);
@@ -1128,14 +1008,12 @@ public void EventRecordWritten_WithRenderXmlFalse_ShouldNotIncludeXml()
 
         watcher.Enabled = true;
 
-        // Act
         using var eventLog = new EventLog(Constants.ApplicationLogName);
         eventLog.Source = Constants.ApplicationLogName;
         eventLog.WriteEntry("Test event without XML", EventLogEntryType.Information);
 
-        bool received = eventReceived.Wait(TimeSpan.FromSeconds(5), TestContext.Current.CancellationToken);
+        bool received = eventReceived.Wait(s_testTimeout, TestContext.Current.CancellationToken);
 
-        // Assert
         var snapshot = Volatile.Read(ref capturedEvent);
         Assert.True(received, "Did not receive event within timeout period");
         Assert.NotNull(snapshot);
@@ -1145,7 +1023,6 @@ public void EventRecordWritten_WithRenderXmlFalse_ShouldNotIncludeXml()
     [Fact]
     public void EventRecordWritten_WithRenderXmlTrue_ShouldIncludeXml()
     {
-        // Arrange
         using var watcher = new EventLogWatcher(Constants.ApplicationLogName, true);
         EventRecord? capturedEvent = null;
         var eventReceived = new ManualResetEventSlim(false);
@@ -1158,14 +1035,12 @@ public void EventRecordWritten_WithRenderXmlTrue_ShouldIncludeXml()
 
         watcher.Enabled = true;
 
-        // Act
         using var eventLog = new EventLog(Constants.ApplicationLogName);
         eventLog.Source = Constants.ApplicationLogName;
         eventLog.WriteEntry("Test event for XML rendering", EventLogEntryType.Information);
 
-        bool received = eventReceived.Wait(TimeSpan.FromSeconds(5), TestContext.Current.CancellationToken);
+        bool received = eventReceived.Wait(s_testTimeout, TestContext.Current.CancellationToken);
 
-        // Assert
         var snapshot = Volatile.Read(ref capturedEvent);
         Assert.True(received, "Did not receive event within timeout period");
         Assert.NotNull(snapshot);
@@ -1175,15 +1050,12 @@ public void EventRecordWritten_WithRenderXmlTrue_ShouldIncludeXml()
     [Fact]
     public void Multiple_Watchers_OnDifferentLogs_ShouldBothSubscribe()
     {
-        // Arrange
         using var appWatcher = new EventLogWatcher(Constants.ApplicationLogName);
         using var sysWatcher = new EventLogWatcher(Constants.SystemLogName);
 
-        // Act
         appWatcher.Enabled = true;
         sysWatcher.Enabled = true;
 
-        // Assert - Both watchers should successfully subscribe
         Assert.True(appWatcher.Enabled);
         Assert.True(sysWatcher.Enabled);
     }
@@ -1191,7 +1063,6 @@ public void Multiple_Watchers_OnDifferentLogs_ShouldBothSubscribe()
     [Fact]
     public void Multiple_Watchers_OnSameLog_ShouldAllReceiveEvents()
     {
-        // Arrange
         using var watcher1 = new EventLogWatcher(Constants.ApplicationLogName);
         using var watcher2 = new EventLogWatcher(Constants.ApplicationLogName);
 
@@ -1202,7 +1073,6 @@ public void Multiple_Watchers_OnSameLog_ShouldAllReceiveEvents()
 
         watcher1.EventRecordWritten += (sender, record) =>
         {
-            // Guard CountdownEvent.Signal against ambient over-signal.
             int count = Interlocked.Increment(ref eventCount1);
 
             if (count <= expectedCountPerWatcher)
@@ -1224,14 +1094,12 @@ public void Multiple_Watchers_OnSameLog_ShouldAllReceiveEvents()
         watcher1.Enabled = true;
         watcher2.Enabled = true;
 
-        // Act
         using var eventLog = new EventLog(Constants.ApplicationLogName);
         eventLog.Source = Constants.ApplicationLogName;
         eventLog.WriteEntry("Test event for multiple watchers", EventLogEntryType.Information);
 
-        bool received = countdown.Wait(TimeSpan.FromSeconds(5), TestContext.Current.CancellationToken);
+        bool received = countdown.Wait(s_testTimeout, TestContext.Current.CancellationToken);
 
-        // Assert
         int actual1 = Volatile.Read(ref eventCount1);
         int actual2 = Volatile.Read(ref eventCount2);
         Assert.True(received, "Did not receive events in all watchers within timeout period");
@@ -1242,10 +1110,8 @@ public void Multiple_Watchers_OnSameLog_ShouldAllReceiveEvents()
     [Fact]
     public void SubscribeAndUnsubscribe_WhenRepeated_ShouldWork()
     {
-        // Arrange
         using var watcher = new EventLogWatcher(Constants.ApplicationLogName);
 
-        // Act & Assert - Subscribe and unsubscribe multiple times
         watcher.Enabled = true;
         Assert.True(watcher.Enabled);
 
@@ -1262,11 +1128,9 @@ public void SubscribeAndUnsubscribe_WhenRepeated_ShouldWork()
     [Fact]
     public void Unsubscribe_MultipleTimes_ShouldNotThrow()
     {
-        // Arrange
         using var watcher = new EventLogWatcher(Constants.ApplicationLogName);
         watcher.Enabled = true;
 
-        // Act & Assert
         watcher.Enabled = false;
         watcher.Enabled = false;
         watcher.Enabled = false;
@@ -1277,10 +1141,8 @@ public void Unsubscribe_MultipleTimes_ShouldNotThrow()
     [Fact]
     public void Unsubscribe_WhenNotSubscribed_ShouldNotThrow()
     {
-        // Arrange
         using var watcher = new EventLogWatcher(Constants.ApplicationLogName);
 
-        // Act & Assert
         watcher.Enabled = false;
         Assert.False(watcher.Enabled);
     }
diff --git a/tests/Integration/EventLogExpert.Runtime.IntegrationTests/Database/DatabaseServiceTests.cs b/tests/Integration/EventLogExpert.Runtime.IntegrationTests/Database/DatabaseServiceTests.cs
index 55fc05c74..7f38749ba 100644
--- a/tests/Integration/EventLogExpert.Runtime.IntegrationTests/Database/DatabaseServiceTests.cs
+++ b/tests/Integration/EventLogExpert.Runtime.IntegrationTests/Database/DatabaseServiceTests.cs
@@ -20,6 +20,10 @@ namespace EventLogExpert.Runtime.IntegrationTests.Database;
 public sealed class DatabaseServiceTests : IDisposable
 {
     private const int LinkedCtsPropagationDelayMs = 250;
+    private const int SecondBatchStartDelayMs = 100;
+
+    private static readonly TimeSpan s_disposeTimeout = TimeSpan.FromSeconds(5);
+    private static readonly TimeSpan s_testTimeout = TimeSpan.FromSeconds(10);
 
     private readonly IProviderDatabaseMaintenance _maintenance;
     private readonly ServiceProvider _maintenanceProvider;
@@ -41,7 +45,6 @@ public DatabaseServiceTests()
     [Fact]
     public void ActiveDatabases_ShouldReturnFullPathsOfEnabledReadyEntriesOnly()
     {
-        // Arrange
         var databasePath = CreateDatabaseDirectory();
         CreateDatabaseFile(databasePath, Constants.TestDb1);
         CreateDatabaseFile(databasePath, Constants.TestDb2);
@@ -55,10 +58,8 @@ public void ActiveDatabases_ShouldReturnFullPathsOfEnabledReadyEntriesOnly()
         service.MarkStatus(Constants.TestDb2, DatabaseStatus.Ready);
         service.MarkStatus(Constants.TestDb3, DatabaseStatus.UpgradeRequired);
 
-        // Act
         var activeDatabases = service.Paths;
 
-        // Assert: only TestDb1 (TestDb2 disabled, TestDb3 not ready)
         Assert.Single(activeDatabases);
         Assert.Equal(Path.Join(databasePath, Constants.TestDb1), activeDatabases[0]);
     }
@@ -72,9 +73,6 @@ public async Task ClassifyEntriesAsync_WhenAnyStatusChanges_ShouldRaiseEntriesCh
 
         var service = CreateDatabaseService();
 
-        // Reset to NotClassified so the explicit ClassifyEntriesAsync call below produces real
-        // status changes (V3 → UpgradeRequired). The CreateDatabaseService helper already drained
-        // the ctor-initiated classification.
         service.MarkStatus(Constants.TestDb1, DatabaseStatus.NotClassified);
         service.MarkStatus(Constants.TestDb2, DatabaseStatus.NotClassified);
 
@@ -89,10 +87,6 @@ public async Task ClassifyEntriesAsync_WhenAnyStatusChanges_ShouldRaiseEntriesCh
     [Fact]
     public async Task ClassifyEntriesAsync_WhenEmptyFile_ShouldClassifyAsUnrecognizedSchemaWithoutMutation()
     {
-        // An empty file would otherwise classify as Ready (PRAGMA inspection sees no tables →
-        // currentVersion=Current → no upgrade needed). EventResolver would then EnsureCreated
-        // it on first read, silently rewriting it as a V4 schema. Force it into UnrecognizedSchema
-        // so the user sees the bad file in Settings instead of having it overwritten invisibly.
         var databasePath = CreateDatabaseDirectory();
         CreateDatabaseFile(databasePath, Constants.TestDb1);
 
@@ -187,10 +181,6 @@ public async Task ClassifyEntriesAsync_WhenOneEntryFails_ShouldQuarantineAsClass
         var lockedPath = Path.Combine(databasePath, "locked.db");
         DatabaseSeedUtils.SeedV3Schema(lockedPath);
 
-        // Hold an exclusive lock on the second file so ProviderDbContext cannot open it.
-        // The classification pass must mark the locked entry as ClassificationFailed so the
-        // resolver pipeline cannot consume it later (a Ready status would crash IEventResolver
-        // when it tried to open the same locked file).
         using var blockingHandle = new FileStream(
             lockedPath,
             FileMode.Open,
@@ -208,8 +198,6 @@ public async Task ClassifyEntriesAsync_WhenOneEntryFails_ShouldQuarantineAsClass
         Assert.Equal(DatabaseStatus.UpgradeRequired, v3Entry.Status);
         Assert.Equal(DatabaseStatus.ClassificationFailed, lockedEntry.Status);
 
-        // ClassificationFailed must be excluded from ActiveDatabases so the resolver pipeline
-        // never tries to open the file.
         Assert.DoesNotContain(lockedPath, service.Paths);
     }
 
@@ -217,10 +205,6 @@ public async Task ClassifyEntriesAsync_WhenOneEntryFails_ShouldQuarantineAsClass
     public async Task
         ClassifyEntriesAsync_WhenSqliteFileWithoutProviderDetailsTable_ShouldClassifyAsUnrecognizedSchema()
     {
-        // A valid SQLite file that lacks the ProviderDetails table is not one of our schemas
-        // (V1/V2/V3/V4). Without quarantine, EventResolver would later crash on
-        // ProviderDetails.FirstOrDefault(...) with "no such table". Force UnrecognizedSchema so
-        // ActiveDatabases excludes it before the resolver pipeline ever sees it.
         var databasePath = CreateDatabaseDirectory();
         var dbPath = Path.Combine(databasePath, Constants.TestDb1);
 
@@ -273,48 +257,51 @@ public async Task
     }
 
     [Fact]
-    public async Task ClassifyEntriesAsync_WhenV3Schema_ShouldDetectAsUpgradeRequired()
+    public async Task ClassifyEntriesAsync_WhenV3SchemaWithUpgradeBak_ShouldDetectAsUpgradeRequiredAndBackupExistsTrue()
     {
         var databasePath = CreateDatabaseDirectory();
         var dbPath = Path.Combine(databasePath, Constants.TestDb1);
         DatabaseSeedUtils.SeedV3Schema(dbPath);
 
+        var bakPath = dbPath + DatabaseService.UpgradeBackupSuffix;
+        File.WriteAllText(bakPath, "interrupted-upgrade-backup");
+
         var service = CreateDatabaseService();
 
         await service.ClassifyEntriesAsync(TestContext.Current.CancellationToken);
 
         var entry = Assert.Single(service.Entries);
         Assert.Equal(DatabaseStatus.UpgradeRequired, entry.Status);
-        Assert.False(entry.BackupExists);
+        Assert.True(entry.BackupExists);
+        Assert.True(File.Exists(bakPath), ".upgrade.bak must be preserved for V3 entries so recovery can restore it.");
     }
 
     [Fact]
-    public async Task ClassifyEntriesAsync_WhenV3SchemaWithUpgradeBak_ShouldDetectAsUpgradeRequiredAndBackupExistsTrue()
+    public async Task ClassifyEntriesAsync_WhenV3Schema_ShouldDetectAsUpgradeRequired()
     {
         var databasePath = CreateDatabaseDirectory();
         var dbPath = Path.Combine(databasePath, Constants.TestDb1);
         DatabaseSeedUtils.SeedV3Schema(dbPath);
 
-        var bakPath = dbPath + DatabaseService.UpgradeBackupSuffix;
-        File.WriteAllText(bakPath, "interrupted-upgrade-backup");
-
         var service = CreateDatabaseService();
 
         await service.ClassifyEntriesAsync(TestContext.Current.CancellationToken);
 
         var entry = Assert.Single(service.Entries);
         Assert.Equal(DatabaseStatus.UpgradeRequired, entry.Status);
-        Assert.True(entry.BackupExists);
-        Assert.True(File.Exists(bakPath), ".upgrade.bak must be preserved for V3 entries so recovery can restore it.");
+        Assert.False(entry.BackupExists);
     }
 
     [Fact]
-    public async Task ClassifyEntriesAsync_WhenV4Schema_ShouldDetectAsReady()
+    public async Task ClassifyEntriesAsync_WhenV4SchemaWithUpgradeBak_ShouldDeleteBakAndDetectAsReady()
     {
         var databasePath = CreateDatabaseDirectory();
         var dbPath = Path.Combine(databasePath, Constants.TestDb1);
         DatabaseSeedUtils.SeedV4Schema(dbPath);
 
+        var bakPath = dbPath + DatabaseService.UpgradeBackupSuffix;
+        File.WriteAllText(bakPath, "stale-backup-from-successful-upgrade");
+
         var service = CreateDatabaseService();
 
         await service.ClassifyEntriesAsync(TestContext.Current.CancellationToken);
@@ -322,18 +309,16 @@ public async Task ClassifyEntriesAsync_WhenV4Schema_ShouldDetectAsReady()
         var entry = Assert.Single(service.Entries);
         Assert.Equal(DatabaseStatus.Ready, entry.Status);
         Assert.False(entry.BackupExists);
+        Assert.False(File.Exists(bakPath), "Stale .upgrade.bak must be cleaned up once the main file reaches V4.");
     }
 
     [Fact]
-    public async Task ClassifyEntriesAsync_WhenV4SchemaWithUpgradeBak_ShouldDeleteBakAndDetectAsReady()
+    public async Task ClassifyEntriesAsync_WhenV4Schema_ShouldDetectAsReady()
     {
         var databasePath = CreateDatabaseDirectory();
         var dbPath = Path.Combine(databasePath, Constants.TestDb1);
         DatabaseSeedUtils.SeedV4Schema(dbPath);
 
-        var bakPath = dbPath + DatabaseService.UpgradeBackupSuffix;
-        File.WriteAllText(bakPath, "stale-backup-from-successful-upgrade");
-
         var service = CreateDatabaseService();
 
         await service.ClassifyEntriesAsync(TestContext.Current.CancellationToken);
@@ -341,21 +326,17 @@ public async Task ClassifyEntriesAsync_WhenV4SchemaWithUpgradeBak_ShouldDeleteBa
         var entry = Assert.Single(service.Entries);
         Assert.Equal(DatabaseStatus.Ready, entry.Status);
         Assert.False(entry.BackupExists);
-        Assert.False(File.Exists(bakPath), "Stale .upgrade.bak must be cleaned up once the main file reaches V4.");
     }
 
     [Fact]
     public void Constructor_WhenCalled_ShouldSeedEntriesFromDisk()
     {
-        // Arrange
         var databasePath = CreateDatabaseDirectory();
         CreateDatabaseFile(databasePath, Constants.TestDb1);
         CreateDatabaseFile(databasePath, Constants.TestDb2);
 
-        // Act
         var service = CreateDatabaseService();
 
-        // Assert
         Assert.Equal(2, service.Entries.Count);
         Assert.Contains(service.Entries, entry => entry.FileName == Constants.TestDb1);
         Assert.Contains(service.Entries, entry => entry.FileName == Constants.TestDb2);
@@ -366,27 +347,22 @@ public void Constructor_WhenCalled_ShouldSeedEntriesFromDisk()
     [Fact]
     public void Constructor_WhenDatabaseDirectoryDoesNotExist_ShouldHaveEmptyEntries()
     {
-        // Arrange (no directory created)
         var service = CreateDatabaseService();
 
-        // Assert
         Assert.Empty(service.Entries);
     }
 
     [Fact]
     public void Constructor_WhenDisabledFilenameIsCaseDifferent_ShouldStillMarkDisabled()
     {
-        // Arrange
         var databasePath = CreateDatabaseDirectory();
         CreateDatabaseFile(databasePath, Constants.TestDb1);
 
         var preferences = Substitute.For<IDatabasePreferencesProvider>();
         preferences.DisabledDatabasesPreference.Returns([Constants.TestDb1.ToUpper()]);
 
-        // Act
         var service = CreateDatabaseService(preferences);
 
-        // Assert
         Assert.Single(service.Entries);
         Assert.False(service.Entries[0].IsEnabled);
     }
@@ -394,16 +370,13 @@ public void Constructor_WhenDisabledFilenameIsCaseDifferent_ShouldStillMarkDisab
     [Fact]
     public void Constructor_WhenNonDbFilesPresent_ShouldOnlyIncludeDbFiles()
     {
-        // Arrange
         var databasePath = CreateDatabaseDirectory();
         CreateDatabaseFile(databasePath, Constants.TestDb1);
         File.WriteAllText(Path.Combine(databasePath, "ignored.txt"), "");
         File.WriteAllText(Path.Combine(databasePath, "ignored.json"), "");
 
-        // Act
         var service = CreateDatabaseService();
 
-        // Assert
         Assert.Single(service.Entries);
         Assert.Equal(Constants.TestDb1, service.Entries[0].FileName);
     }
@@ -489,7 +462,7 @@ public async Task DeleteEntryWithBackupAsync_DuringInFlightUpgrade_ShouldThrowIn
             if (args.Phase == UpgradePhase.BackingUp)
             {
                 inFlight.Set();
-                release.Wait(TimeSpan.FromSeconds(10));
+                release.Wait(s_testTimeout);
             }
         };
 
@@ -498,7 +471,7 @@ public async Task DeleteEntryWithBackupAsync_DuringInFlightUpgrade_ShouldThrowIn
             UpgradeProgressScope.Background,
             TestContext.Current.CancellationToken);
 
-        Assert.True(inFlight.Wait(TimeSpan.FromSeconds(10), TestContext.Current.CancellationToken));
+        Assert.True(inFlight.Wait(s_testTimeout, TestContext.Current.CancellationToken));
 
         var ex = await Assert.ThrowsAsync<InvalidOperationException>(() =>
             service.DeleteEntryWithBackupAsync(Constants.TestDb1, TestContext.Current.CancellationToken));
@@ -560,9 +533,6 @@ public async Task DeleteEntryWithBackupAsync_WhenSidecarDeleteFails_PreservesMai
         var walPath = dbPath + "-wal";
         File.WriteAllText(walPath, "wal-content");
 
-        // Hold the WAL with FileShare.None so File.Delete throws IOException; this simulates the
-        // single-process race where SQLite still has the sidecar mapped at delete time. The main
-        // file and the entry must survive so Refresh keeps the entry visible and the user can retry.
         using var lockHandle = new FileStream(walPath, FileMode.Open, FileAccess.Read, FileShare.None);
 
         var service = CreateDatabaseService();
@@ -580,7 +550,7 @@ public void Dispose()
         {
             try
             {
-                service.DisposeAsync().AsTask().Wait(TimeSpan.FromSeconds(5));
+                service.DisposeAsync().AsTask().Wait(s_disposeTimeout);
             }
             catch (Exception)
             {
@@ -623,7 +593,7 @@ public async Task DisposeAsync_WithPendingBatches_ShouldCancelInFlightAndPending
                 string.Equals(args.FileName, Constants.TestDb1, StringComparison.OrdinalIgnoreCase))
             {
                 inFlight.Set();
-                release.Wait(TimeSpan.FromSeconds(10));
+                release.Wait(s_testTimeout);
             }
         };
 
@@ -632,7 +602,7 @@ public async Task DisposeAsync_WithPendingBatches_ShouldCancelInFlightAndPending
             UpgradeProgressScope.Background,
             TestContext.Current.CancellationToken);
 
-        Assert.True(inFlight.Wait(TimeSpan.FromSeconds(10), TestContext.Current.CancellationToken));
+        Assert.True(inFlight.Wait(s_testTimeout, TestContext.Current.CancellationToken));
 
         var pendingBatch = service.UpgradeBatchAsync(
             [Constants.TestDb2],
@@ -643,41 +613,51 @@ public async Task DisposeAsync_WithPendingBatches_ShouldCancelInFlightAndPending
 
         var disposeTask = service.DisposeAsync().AsTask();
 
-        // UpgradeBatchStartedEventArgs exposes Cancel() but not the linked CTS Token.
         await Task.Delay(LinkedCtsPropagationDelayMs, TestContext.Current.CancellationToken);
 
         release.Set();
         await disposeTask;
 
-        // First batch was mid-upgrade when dispose cancelled; rollback restores it and surfaces as
-        // Cancelled.
         var firstResult = await firstBatch;
         Assert.Empty(firstResult.Succeeded);
         Assert.Single(firstResult.Cancelled);
         Assert.Equal(Constants.TestDb1, firstResult.Cancelled[0]);
 
-        // Pending batch was drained by the consumer, observed cancellation per-entry, and surfaced
-        // as Cancelled — strictly more useful than throwing OperationCanceledException.
         var pendingResult = await pendingBatch;
         Assert.Empty(pendingResult.Succeeded);
         Assert.Single(pendingResult.Cancelled);
         Assert.Equal(Constants.TestDb2, pendingResult.Cancelled[0]);
     }
 
+    [Fact]
+    public void EntriesChanged_MultipleSubscribers_FirstThrows_ShouldStillInvokeRest()
+    {
+        var databasePath = CreateDatabaseDirectory();
+        CreateDatabaseFile(databasePath, Constants.TestDb1);
+
+        var service = CreateDatabaseService();
+
+        var secondSubscriberInvocations = 0;
+
+        service.EntriesChanged += (_, _) => throw new InvalidOperationException("first subscriber throws");
+        service.EntriesChanged += (_, _) => Interlocked.Increment(ref secondSubscriberInvocations);
+
+        service.Toggle(Constants.TestDb1);
+
+        Assert.Equal(1, secondSubscriberInvocations);
+    }
+
     [Fact]
     public void Entries_WhenMixedVersionedAndNonVersioned_ShouldSortCorrectly()
     {
-        // Arrange
         var databasePath = CreateDatabaseDirectory();
         CreateDatabaseFile(databasePath, Constants.Windows10 + ".db");
         CreateDatabaseFile(databasePath, Constants.Windows11 + ".db");
         CreateDatabaseFile(databasePath, Constants.SimpleDatabase + ".db");
         CreateDatabaseFile(databasePath, Constants.AnotherDb + ".db");
 
-        // Act
         var service = CreateDatabaseService();
 
-        // Assert: non-versioned first, then versioned numeric desc
         Assert.Equal(4, service.Entries.Count);
         Assert.Equal(Constants.AnotherDb + ".db", service.Entries[0].FileName);
         Assert.Equal(Constants.SimpleDatabase + ".db", service.Entries[1].FileName);
@@ -688,17 +668,14 @@ public void Entries_WhenMixedVersionedAndNonVersioned_ShouldSortCorrectly()
     [Fact]
     public void Entries_WhenNumericVersions_ShouldSortNumericallyNotLexicographically()
     {
-        // Arrange
         var databasePath = CreateDatabaseDirectory();
         CreateDatabaseFile(databasePath, Constants.Server1 + ".db");
         CreateDatabaseFile(databasePath, Constants.Server2 + ".db");
         CreateDatabaseFile(databasePath, Constants.Server10 + ".db");
         CreateDatabaseFile(databasePath, Constants.Server20 + ".db");
 
-        // Act
         var service = CreateDatabaseService();
 
-        // Assert: numeric desc — 20, 10, 2, 1
         Assert.Equal(Constants.Server20 + ".db", service.Entries[0].FileName);
         Assert.Equal(Constants.Server10 + ".db", service.Entries[1].FileName);
         Assert.Equal(Constants.Server2 + ".db", service.Entries[2].FileName);
@@ -708,41 +685,19 @@ public void Entries_WhenNumericVersions_ShouldSortNumericallyNotLexicographicall
     [Fact]
     public void Entries_WhenSimpleNames_ShouldSortByNameAscThenVersionDesc()
     {
-        // Arrange
         var databasePath = CreateDatabaseDirectory();
         CreateDatabaseFile(databasePath, Constants.DatabaseA + ".db");
         CreateDatabaseFile(databasePath, Constants.DatabaseB + ".db");
         CreateDatabaseFile(databasePath, Constants.DatabaseC + ".db");
 
-        // Act
         var service = CreateDatabaseService();
 
-        // Assert: "Database X" splits to "Database " + "X"; FirstPart asc then SecondPart desc
         Assert.Equal(3, service.Entries.Count);
         Assert.Equal(Constants.DatabaseC + ".db", service.Entries[0].FileName);
         Assert.Equal(Constants.DatabaseB + ".db", service.Entries[1].FileName);
         Assert.Equal(Constants.DatabaseA + ".db", service.Entries[2].FileName);
     }
 
-    [Fact]
-    public void EntriesChanged_MultipleSubscribers_FirstThrows_ShouldStillInvokeRest()
-    {
-        var databasePath = CreateDatabaseDirectory();
-        CreateDatabaseFile(databasePath, Constants.TestDb1);
-
-        var service = CreateDatabaseService();
-
-        var secondSubscriberInvocations = 0;
-
-        service.EntriesChanged += (_, _) => throw new InvalidOperationException("first subscriber throws");
-        service.EntriesChanged += (_, _) => Interlocked.Increment(ref secondSubscriberInvocations);
-
-        service.Toggle(Constants.TestDb1);
-
-        // If multicast invoke aborted on the first throwing subscriber, this would be 0.
-        Assert.Equal(1, secondSubscriberInvocations);
-    }
-
     [Fact]
     public async Task EnumerateZipDbEntryNamesAsync_MalformedZip_ShouldReturnEmpty_NotThrow()
     {
@@ -821,8 +776,6 @@ public async Task ImportAsync_FreshlyImportedV3Db_WithStaleBackupAtDestination_S
     {
         var databasePath = CreateDatabaseDirectory();
 
-        // Stale .upgrade.bak at destination (no main file present yet) — simulates a recovery
-        // scenario where a backup is sitting on disk waiting for the next upgrade attempt.
         File.WriteAllText(Path.Combine(databasePath, Constants.TestDb1 + ".upgrade.bak"), "stale-backup");
 
         var sourceDir = Path.Combine(_testDirectory, "source");
@@ -1002,8 +955,6 @@ public async Task ImportAsync_SkipFileNamesProvidedAsCaseSensitiveSet_ShouldStil
         var sourceFile = Path.Combine(sourceDir, Constants.TestDb1);
         File.WriteAllText(sourceFile, "would-overwrite-if-comparer-mismatched");
 
-        // Caller uses an explicitly case-sensitive set with the upper-cased name. Service should
-        // honor its documented case-insensitive skip contract and not overwrite the existing file.
         var caseSensitiveSkip = new HashSet<string>(StringComparer.Ordinal)
         {
             Constants.TestDb1.ToUpperInvariant()
@@ -1027,7 +978,6 @@ public async Task ImportAsync_SkipNamesIncludesZipEntry_ShouldNotExtractThatEntr
     {
         var databasePath = CreateDatabaseDirectory();
 
-        // Pre-create the entry that we'll ask the import to skip.
         var preExistingPath = Path.Combine(databasePath, Constants.TestDb1);
         DatabaseSeedUtils.SeedV4Schema(preExistingPath);
         var preExistingLength = new FileInfo(preExistingPath).Length;
@@ -1060,7 +1010,6 @@ public async Task ImportAsync_SkipNamesIncludesZipEntry_ShouldNotExtractThatEntr
     [Fact]
     public async Task ImportAsync_WhenDbFilesProvided_ShouldCopyAndRefresh()
     {
-        // Arrange
         CreateDatabaseDirectory();
         var sourceDir = Path.Combine(_testDirectory, "source");
         Directory.CreateDirectory(sourceDir);
@@ -1070,10 +1019,8 @@ public async Task ImportAsync_WhenDbFilesProvided_ShouldCopyAndRefresh()
 
         var service = CreateDatabaseService();
 
-        // Act
         var result = await service.ImportAsync([sourceFile], TestContext.Current.CancellationToken);
 
-        // Assert
         Assert.Equal(1, result.Imported);
         Assert.Empty(result.Failures);
         Assert.Single(service.Entries);
@@ -1083,7 +1030,6 @@ public async Task ImportAsync_WhenDbFilesProvided_ShouldCopyAndRefresh()
     [Fact]
     public async Task ImportAsync_WhenMixedSuccessAndFailure_ShouldReturnPartialResult()
     {
-        // Arrange
         var databasePath = CreateDatabaseDirectory();
         var sourceDir = Path.Combine(_testDirectory, "source");
         Directory.CreateDirectory(sourceDir);
@@ -1096,10 +1042,8 @@ public async Task ImportAsync_WhenMixedSuccessAndFailure_ShouldReturnPartialResu
 
         var service = CreateDatabaseService();
 
-        // Act
         var result = await service.ImportAsync([goodZip, malformedZip], TestContext.Current.CancellationToken);
 
-        // Assert
         Assert.Equal(1, result.Imported);
         var failure = Assert.Single(result.Failures);
         Assert.Equal("bad.zip", failure.FileName);
@@ -1110,7 +1054,6 @@ public async Task ImportAsync_WhenMixedSuccessAndFailure_ShouldReturnPartialResu
     [Fact]
     public async Task ImportAsync_WhenNoFilesProvided_ShouldReturnZeroAndNotRefresh()
     {
-        // Arrange
         var databasePath = CreateDatabaseDirectory();
         CreateDatabaseFile(databasePath, Constants.TestDb1);
 
@@ -1118,10 +1061,8 @@ public async Task ImportAsync_WhenNoFilesProvided_ShouldReturnZeroAndNotRefresh(
         var raisedCount = 0;
         service.EntriesChanged += (_, _) => raisedCount++;
 
-        // Act
         var result = await service.ImportAsync([], TestContext.Current.CancellationToken);
 
-        // Assert
         Assert.Equal(0, result.Imported);
         Assert.Empty(result.Failures);
         Assert.Equal(0, raisedCount);
@@ -1130,7 +1071,6 @@ public async Task ImportAsync_WhenNoFilesProvided_ShouldReturnZeroAndNotRefresh(
     [Fact]
     public async Task ImportAsync_WhenTokenAlreadyCanceled_ShouldThrowOperationCanceledException()
     {
-        // Arrange
         CreateDatabaseDirectory();
         var sourceDir = Path.Combine(_testDirectory, "source");
         Directory.CreateDirectory(sourceDir);
@@ -1142,14 +1082,12 @@ public async Task ImportAsync_WhenTokenAlreadyCanceled_ShouldThrowOperationCance
         using var cts = new CancellationTokenSource();
         cts.Cancel();
 
-        // Act + Assert
         await Assert.ThrowsAnyAsync<OperationCanceledException>(() => service.ImportAsync([sourcePath], cts.Token));
     }
 
     [Fact]
     public async Task ImportAsync_WhenZipContainsNonDbFiles_ShouldExtractOnlyDbEntries()
     {
-        // Arrange
         var databasePath = CreateDatabaseDirectory();
         var sourceDir = Path.Combine(_testDirectory, "source");
         Directory.CreateDirectory(sourceDir);
@@ -1159,10 +1097,8 @@ public async Task ImportAsync_WhenZipContainsNonDbFiles_ShouldExtractOnlyDbEntri
 
         var service = CreateDatabaseService();
 
-        // Act
         var result = await service.ImportAsync([zipPath], TestContext.Current.CancellationToken);
 
-        // Assert
         Assert.Equal(1, result.Imported);
         Assert.Empty(result.Failures);
         Assert.True(File.Exists(Path.Combine(databasePath, Constants.TestDb1)));
@@ -1172,7 +1108,6 @@ public async Task ImportAsync_WhenZipContainsNonDbFiles_ShouldExtractOnlyDbEntri
     [Fact]
     public async Task ImportAsync_WhenZipContainsValidDatabases_ShouldExtractDbFiles()
     {
-        // Arrange
         var databasePath = CreateDatabaseDirectory();
         var sourceDir = Path.Combine(_testDirectory, "source");
         Directory.CreateDirectory(sourceDir);
@@ -1182,10 +1117,8 @@ public async Task ImportAsync_WhenZipContainsValidDatabases_ShouldExtractDbFiles
 
         var service = CreateDatabaseService();
 
-        // Act
         var result = await service.ImportAsync([zipPath], TestContext.Current.CancellationToken);
 
-        // Assert
         Assert.Equal(2, result.Imported);
         Assert.Empty(result.Failures);
         Assert.True(File.Exists(Path.Combine(databasePath, Constants.TestDb1)));
@@ -1196,7 +1129,6 @@ public async Task ImportAsync_WhenZipContainsValidDatabases_ShouldExtractDbFiles
     [Fact]
     public async Task ImportAsync_WhenZipIsMalformed_ShouldReturnFailureAndNotLeakFiles()
     {
-        // Arrange
         var databasePath = CreateDatabaseDirectory();
         var sourceDir = Path.Combine(_testDirectory, "source");
         Directory.CreateDirectory(sourceDir);
@@ -1206,10 +1138,8 @@ public async Task ImportAsync_WhenZipIsMalformed_ShouldReturnFailureAndNotLeakFi
 
         var service = CreateDatabaseService();
 
-        // Act
         var result = await service.ImportAsync([malformedZip], TestContext.Current.CancellationToken);
 
-        // Assert
         Assert.Equal(0, result.Imported);
         var failure = Assert.Single(result.Failures);
         Assert.Equal("malformed.zip", failure.FileName);
@@ -1226,8 +1156,6 @@ public async Task InitialClassificationTask_NeverFaults_EvenWhenAllEntriesThrow(
         DatabaseSeedUtils.SeedV3Schema(db1Path);
         DatabaseSeedUtils.SeedV3Schema(db2Path);
 
-        // Hold exclusive locks on every DB file so ProviderDbContext cannot open any of them.
-        // The per-entry catch must turn each failure into ClassificationFailed and the outer
         // wrapper must keep the exposed task in RanToCompletion.
         using var handle1 = new FileStream(db1Path, FileMode.Open, FileAccess.ReadWrite, FileShare.None);
         using var handle2 = new FileStream(db2Path, FileMode.Open, FileAccess.ReadWrite, FileShare.None);
@@ -1268,7 +1196,6 @@ public async Task InitialClassificationTask_WhenLoggerThrowsOnWarn_StillComplete
         DatabaseSeedUtils.SeedV3Schema(db1Path);
         DatabaseSeedUtils.SeedV3Schema(db2Path);
 
-        // Force per-entry classification failures so the per-entry catch fires Warn for every entry.
         using var handle1 = new FileStream(db1Path, FileMode.Open, FileAccess.ReadWrite, FileShare.None);
         using var handle2 = new FileStream(db2Path, FileMode.Open, FileAccess.ReadWrite, FileShare.None);
 
@@ -1295,9 +1222,6 @@ public async Task InitialClassificationTask_WhenSubscriberAndLoggerBothThrow_Sti
         var dbPath = Path.Combine(databasePath, Constants.TestDb1);
         DatabaseSeedUtils.SeedV3Schema(dbPath);
 
-        // Lock the DB so per-entry classification fails — that fires the per-entry SafeLog,
-        // which we use as a synchronization point to attach the throwing EntriesChanged
-        // subscriber BEFORE ClassifyEntriesAsync reaches RaiseEntriesChanged.
         using var handle = new FileStream(dbPath, FileMode.Open, FileAccess.ReadWrite, FileShare.None);
 
         using var subscriberAttached = new ManualResetEventSlim(false);
@@ -1307,10 +1231,8 @@ public async Task InitialClassificationTask_WhenSubscriberAndLoggerBothThrow_Sti
         throwingLogger.When(logger => logger.Warning(Arg.Any<WarningLogHandler>()))
             .Do(_ =>
             {
-                // Worker blocks here until subscriberAttached.Set() below; ensures the
-                // subscriber is wired before the wrapper-catch path can fire. 10s is a
                 // safety valve for slow CI — normal completion is sub-millisecond.
-                subscriberAttached.Wait(TimeSpan.FromSeconds(10));
+                subscriberAttached.Wait(s_testTimeout);
                 throw new IOException("simulated log file lock");
             });
 
@@ -1354,24 +1276,20 @@ public async Task InitialClassificationTask_WhenSubscriberAndLoggerBothThrow_Sti
     [Fact]
     public void MarkStatus_ShouldBePreservedAcrossRefresh()
     {
-        // Arrange
         var databasePath = CreateDatabaseDirectory();
         CreateDatabaseFile(databasePath, Constants.TestDb1);
 
         var service = CreateDatabaseService();
         service.MarkStatus(Constants.TestDb1, DatabaseStatus.UpgradeFailed);
 
-        // Act
         service.Refresh();
 
-        // Assert
         Assert.Equal(DatabaseStatus.UpgradeFailed, service.Entries[0].Status);
     }
 
     [Fact]
     public void MarkStatus_WhenStatusChanges_ShouldUpdateAndRaiseEntriesChanged()
     {
-        // Arrange
         var databasePath = CreateDatabaseDirectory();
         CreateDatabaseFile(databasePath, Constants.TestDb1);
 
@@ -1379,10 +1297,8 @@ public void MarkStatus_WhenStatusChanges_ShouldUpdateAndRaiseEntriesChanged()
         var raisedCount = 0;
         service.EntriesChanged += (_, _) => raisedCount++;
 
-        // Act
         service.MarkStatus(Constants.TestDb1, DatabaseStatus.UpgradeFailed);
 
-        // Assert
         Assert.Equal(DatabaseStatus.UpgradeFailed, service.Entries[0].Status);
         Assert.Equal(1, raisedCount);
     }
@@ -1423,7 +1339,7 @@ public async Task QueuedBatchCount_ShouldReflectQueuedBatchesNotCountingInFlight
                 string.Equals(args.FileName, Constants.TestDb1, StringComparison.OrdinalIgnoreCase))
             {
                 inFlight.Set();
-                release.Wait(TimeSpan.FromSeconds(10));
+                release.Wait(s_testTimeout);
             }
         };
 
@@ -1432,7 +1348,7 @@ public async Task QueuedBatchCount_ShouldReflectQueuedBatchesNotCountingInFlight
             UpgradeProgressScope.Background,
             TestContext.Current.CancellationToken);
 
-        Assert.True(inFlight.Wait(TimeSpan.FromSeconds(10), TestContext.Current.CancellationToken));
+        Assert.True(inFlight.Wait(s_testTimeout, TestContext.Current.CancellationToken));
         Assert.Equal(0, service.QueuedBatchCount);
 
         var secondBatch = service.UpgradeBatchAsync(
@@ -1456,10 +1372,6 @@ public async Task QueuedBatchCount_ShouldReflectQueuedBatchesNotCountingInFlight
     [Fact]
     public async Task Refresh_AfterClassificationSetsBackupExistsTrue_ShouldPreserveBackupExists()
     {
-        // Regression: c9 refactored Refresh() to use `existing with { IsEnabled = ... }` so all
-        // other fields (Status, BackupExists) survive. This test pins that invariant — if a
-        // future change reverts to the positional constructor, BackupExists silently drops to
-        // false and the recovery dialog stops surfacing interrupted upgrades.
         var databasePath = CreateDatabaseDirectory();
         var dbPath = Path.Combine(databasePath, Constants.TestDb1);
         DatabaseSeedUtils.SeedV3Schema(dbPath);
@@ -1481,33 +1393,27 @@ public async Task Refresh_AfterClassificationSetsBackupExistsTrue_ShouldPreserve
     [Fact]
     public void Refresh_WhenCalled_ShouldRaiseEntriesChanged()
     {
-        // Arrange
         CreateDatabaseDirectory();
         var service = CreateDatabaseService();
         var raised = false;
         service.EntriesChanged += (_, _) => raised = true;
 
-        // Act
         service.Refresh();
 
-        // Assert
         Assert.True(raised);
     }
 
     [Fact]
     public void Refresh_WhenNewFilesAppear_ShouldPickThemUp()
     {
-        // Arrange
         var databasePath = CreateDatabaseDirectory();
         var service = CreateDatabaseService();
         Assert.Empty(service.Entries);
 
         CreateDatabaseFile(databasePath, Constants.TestDb1);
 
-        // Act
         service.Refresh();
 
-        // Assert
         Assert.Single(service.Entries);
         Assert.Equal(Constants.TestDb1, service.Entries[0].FileName);
     }
@@ -1515,7 +1421,6 @@ public void Refresh_WhenNewFilesAppear_ShouldPickThemUp()
     [Fact]
     public async Task RemoveAsync_DoesNotTouchUserCreatedDotBakFiles()
     {
-        // Arrange
         var databasePath = CreateDatabaseDirectory();
         var dbPath = Path.Combine(databasePath, Constants.TestDb1);
         CreateDatabaseFile(databasePath, Constants.TestDb1);
@@ -1526,10 +1431,8 @@ public async Task RemoveAsync_DoesNotTouchUserCreatedDotBakFiles()
 
         var service = CreateDatabaseService();
 
-        // Act
         await service.RemoveAsync(Constants.TestDb1, cancellationToken: TestContext.Current.CancellationToken);
 
-        // Assert
         Assert.False(File.Exists(dbPath));
         Assert.True(File.Exists(userBakPath));
         Assert.Equal(userBackupContent, File.ReadAllText(userBakPath));
@@ -1538,7 +1441,6 @@ public async Task RemoveAsync_DoesNotTouchUserCreatedDotBakFiles()
     [Fact]
     public async Task RemoveAsync_DuringInFlightUpgrade_ShouldThrowInvalidOperationException()
     {
-        // Arrange
         var databasePath = CreateDatabaseDirectory();
         DatabaseSeedUtils.SeedV3Schema(Path.Combine(databasePath, Constants.TestDb1));
 
@@ -1552,7 +1454,7 @@ public async Task RemoveAsync_DuringInFlightUpgrade_ShouldThrowInvalidOperationE
             if (args.Phase == UpgradePhase.BackingUp)
             {
                 inFlight.Set();
-                release.Wait(TimeSpan.FromSeconds(10));
+                release.Wait(s_testTimeout);
             }
         };
 
@@ -1561,9 +1463,8 @@ public async Task RemoveAsync_DuringInFlightUpgrade_ShouldThrowInvalidOperationE
             UpgradeProgressScope.Background,
             TestContext.Current.CancellationToken);
 
-        Assert.True(inFlight.Wait(TimeSpan.FromSeconds(10), TestContext.Current.CancellationToken));
+        Assert.True(inFlight.Wait(s_testTimeout, TestContext.Current.CancellationToken));
 
-        // Act + Assert
         var ex = await Assert.ThrowsAsync<InvalidOperationException>(() =>
             service.RemoveAsync(Constants.TestDb1, cancellationToken: TestContext.Current.CancellationToken));
 
@@ -1576,7 +1477,6 @@ public async Task RemoveAsync_DuringInFlightUpgrade_ShouldThrowInvalidOperationE
     [Fact]
     public async Task RemoveAsync_WhenAlreadyCancelledCallerCt_ThrowsOperationCanceled_BeforeAnyPhase()
     {
-        // Arrange
         var databasePath = CreateDatabaseDirectory();
         CreateDatabaseFile(databasePath, Constants.TestDb1);
         var service = CreateDatabaseService();
@@ -1586,7 +1486,6 @@ public async Task RemoveAsync_WhenAlreadyCancelledCallerCt_ThrowsOperationCancel
 
         var dbPath = Path.Combine(databasePath, Constants.TestDb1);
 
-        // Act + Assert
         await Assert.ThrowsAsync<OperationCanceledException>(() =>
             service.RemoveAsync(Constants.TestDb1, cancellationToken: cts.Token));
 
@@ -1597,7 +1496,6 @@ await Assert.ThrowsAsync<OperationCanceledException>(() =>
     [Fact]
     public async Task RemoveAsync_WhenCalled_ShouldDeleteDatabaseAndSidecars()
     {
-        // Arrange
         var databasePath = CreateDatabaseDirectory();
         CreateDatabaseFile(databasePath, Constants.TestDb1);
         File.WriteAllText(Path.Combine(databasePath, $"{Constants.TestDb1}-wal"), "");
@@ -1605,10 +1503,8 @@ public async Task RemoveAsync_WhenCalled_ShouldDeleteDatabaseAndSidecars()
 
         var service = CreateDatabaseService();
 
-        // Act
         await service.RemoveAsync(Constants.TestDb1, cancellationToken: TestContext.Current.CancellationToken);
 
-        // Assert
         Assert.False(File.Exists(Path.Combine(databasePath, Constants.TestDb1)));
         Assert.False(File.Exists(Path.Combine(databasePath, $"{Constants.TestDb1}-wal")));
         Assert.False(File.Exists(Path.Combine(databasePath, $"{Constants.TestDb1}-shm")));
@@ -1618,7 +1514,6 @@ public async Task RemoveAsync_WhenCalled_ShouldDeleteDatabaseAndSidecars()
     [Fact]
     public async Task RemoveAsync_WhenCalled_ShouldRaiseEntriesChanged()
     {
-        // Arrange
         var databasePath = CreateDatabaseDirectory();
         CreateDatabaseFile(databasePath, Constants.TestDb1);
 
@@ -1626,20 +1521,14 @@ public async Task RemoveAsync_WhenCalled_ShouldRaiseEntriesChanged()
         var raised = false;
         service.EntriesChanged += (_, _) => raised = true;
 
-        // Act
         await service.RemoveAsync(Constants.TestDb1, cancellationToken: TestContext.Current.CancellationToken);
 
-        // Assert
         Assert.True(raised);
     }
 
     [Fact]
     public async Task RemoveAsync_WhenEntryDisabled_StillInvokesPrepareCallback()
     {
-        // Arrange — a previously-disabled entry can still be referenced by IEventResolver
-        // instances constructed before the disable (the user disabled it and declined the
-        // modal-close reload prompt). The coordinator must still close any open log views
-        // so SqliteConnection.ClearAllPools + File.Delete don't race with in-flight scopes.
         var databasePath = CreateDatabaseDirectory();
         CreateDatabaseFile(databasePath, Constants.TestDb1);
 
@@ -1658,13 +1547,11 @@ Task PrepareCallback(CancellationToken ct)
             return Task.CompletedTask;
         }
 
-        // Act
         await service.RemoveAsync(
             Constants.TestDb1,
             PrepareCallback,
             TestContext.Current.CancellationToken);
 
-        // Assert
         Assert.True(prepareInvoked);
         Assert.Empty(service.Entries);
     }
@@ -1672,9 +1559,6 @@ await service.RemoveAsync(
     [Fact]
     public async Task RemoveAsync_WhenEntryEnabled_AwaitsPrepareCallback_AfterDisable_BeforeFileDelete()
     {
-        // Arrange — verifies the 4-phase ordering: disable → prepare-callback → file delete.
-        // Track phase order via a shared list. The callback observes IsEnabled (must already
-        // be false) and confirms the file still exists (Step 3 hasn't run yet).
         var databasePath = CreateDatabaseDirectory();
         CreateDatabaseFile(databasePath, Constants.TestDb1);
 
@@ -1682,8 +1566,6 @@ public async Task RemoveAsync_WhenEntryEnabled_AwaitsPrepareCallback_AfterDisabl
         prefs.DisabledDatabasesPreference.Returns([]);
         var service = CreateDatabaseService(prefs);
 
-        // Default IsEnabled is true when the file is not in the disabled-preference list,
-        // so the entry is already enabled — no toggle needed.
         var enabledEntry = Assert.Single(service.Entries);
         Assert.True(enabledEntry.IsEnabled);
 
@@ -1699,19 +1581,15 @@ Task PrepareCallback(CancellationToken ct)
             return Task.CompletedTask;
         }
 
-        // Act
         await service.RemoveAsync(
             Constants.TestDb1,
             PrepareCallback,
             TestContext.Current.CancellationToken);
 
-        // Assert — prepare callback observed IsEnabled=false (Step 1 ran first) and the
-        // file still present (Step 3 had not yet run).
         var observation = Assert.Single(observations);
         Assert.False(observation.IsEnabled);
         Assert.True(observation.FileExists);
 
-        // After RemoveAsync returned, the file is gone and the entry is removed.
         Assert.False(File.Exists(dbPath));
         Assert.Empty(service.Entries);
     }
@@ -1719,7 +1597,6 @@ await service.RemoveAsync(
     [Fact]
     public async Task RemoveAsync_WhenEntryEnabled_RaisesEntriesChangedTwice_OncePerPhaseMutation()
     {
-        // Arrange — Step 1 (disable) and Step 4 (RemoveAt) should each fire EntriesChanged.
         var databasePath = CreateDatabaseDirectory();
         CreateDatabaseFile(databasePath, Constants.TestDb1);
         var service = CreateDatabaseService();
@@ -1729,10 +1606,8 @@ public async Task RemoveAsync_WhenEntryEnabled_RaisesEntriesChangedTwice_OncePer
         var raiseCount = 0;
         service.EntriesChanged += (_, _) => Interlocked.Increment(ref raiseCount);
 
-        // Act
         await service.RemoveAsync(Constants.TestDb1, cancellationToken: TestContext.Current.CancellationToken);
 
-        // Assert — exactly two raises: one for the disable mutation, one for the remove.
         Assert.Equal(2, raiseCount);
         Assert.Empty(service.Entries);
     }
@@ -1740,11 +1615,9 @@ public async Task RemoveAsync_WhenEntryEnabled_RaisesEntriesChangedTwice_OncePer
     [Fact]
     public async Task RemoveAsync_WhenFileNameUnknown_ShouldThrow()
     {
-        // Arrange
         CreateDatabaseDirectory();
         var service = CreateDatabaseService();
 
-        // Act + Assert
         await Assert.ThrowsAsync<InvalidOperationException>(() =>
             service.RemoveAsync("does-not-exist.db", cancellationToken: TestContext.Current.CancellationToken));
     }
@@ -1752,8 +1625,6 @@ await Assert.ThrowsAsync<InvalidOperationException>(() =>
     [Fact]
     public async Task RemoveAsync_WhenPrepareCallbackThrows_RestoresIsEnabled_AndRethrows()
     {
-        // Arrange — Step 2 failure must roll back Step 1. The entry should remain in
-        // Entries with IsEnabled restored to true so the caller can retry.
         var databasePath = CreateDatabaseDirectory();
         CreateDatabaseFile(databasePath, Constants.TestDb1);
 
@@ -1765,13 +1636,11 @@ public async Task RemoveAsync_WhenPrepareCallbackThrows_RestoresIsEnabled_AndRet
 
         var dbPath = Path.Combine(databasePath, Constants.TestDb1);
 
-        // Act
         var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => service.RemoveAsync(
             Constants.TestDb1,
             _ => throw new InvalidOperationException("prepare boom"),
             TestContext.Current.CancellationToken));
 
-        // Assert
         Assert.Equal("prepare boom", ex.Message);
         Assert.True(File.Exists(dbPath));
         var rolledBack = Assert.Single(service.Entries);
@@ -1812,7 +1681,7 @@ public async Task RestoreFromBackupAsync_DuringInFlightUpgrade_ShouldThrowInvali
             if (args.Phase == UpgradePhase.BackingUp)
             {
                 inFlight.Set();
-                release.Wait(TimeSpan.FromSeconds(10));
+                release.Wait(s_testTimeout);
             }
         };
 
@@ -1821,7 +1690,7 @@ public async Task RestoreFromBackupAsync_DuringInFlightUpgrade_ShouldThrowInvali
             UpgradeProgressScope.Background,
             TestContext.Current.CancellationToken);
 
-        Assert.True(inFlight.Wait(TimeSpan.FromSeconds(10), TestContext.Current.CancellationToken));
+        Assert.True(inFlight.Wait(s_testTimeout, TestContext.Current.CancellationToken));
 
         var ex = await Assert.ThrowsAsync<InvalidOperationException>(() =>
             service.RestoreFromBackupAsync(Constants.TestDb1, TestContext.Current.CancellationToken));
@@ -1937,9 +1806,6 @@ public async Task RestoreFromBackupAsync_WhenSidecarDeleteFails_PreservesBackupA
 
         var mainBytesBefore = File.ReadAllBytes(dbPath);
 
-        // Hold the WAL with FileShare.None so File.Delete throws IOException; this simulates the
-        // single-process race where SQLite still has the sidecar mapped at restore time. Main must
-        // be untouched and the backup must survive so the user can retry.
         using var lockHandle = new FileStream(walPath, FileMode.Open, FileAccess.Read, FileShare.None);
 
         var result = await service.RestoreFromBackupAsync(Constants.TestDb1, TestContext.Current.CancellationToken);
@@ -1964,7 +1830,6 @@ public async Task RetryClassificationAsync_AlreadyCancelled_Throws()
         await Assert.ThrowsAsync<OperationCanceledException>(
             async () => await service.RetryClassificationAsync(Constants.TestDb1, cts.Token));
 
-        // Status unchanged since cancellation hits before MarkStatus.
         Assert.Equal(DatabaseStatus.Ready, service.Entries[0].Status);
     }
 
@@ -1999,7 +1864,6 @@ public async Task RetryClassificationAsync_MissingEntry_NoOps()
         CreateDatabaseDirectory();
         var service = CreateDatabaseService();
 
-        // Should not throw; missing entry is treated as stale UI.
         await service.RetryClassificationAsync("does-not-exist.db", TestContext.Current.CancellationToken);
 
         Assert.Empty(service.Entries);
@@ -2012,7 +1876,6 @@ public async Task RetryClassificationAsync_Success_UpdatesEntryToReady()
         DatabaseSeedUtils.SeedV4Schema(Path.Combine(databasePath, Constants.TestDb1));
 
         var service = CreateDatabaseService();
-        // Reset to a stale status so we can observe the classification.
         service.MarkStatus(Constants.TestDb1, DatabaseStatus.ClassificationFailed);
         Assert.Equal(DatabaseStatus.ClassificationFailed, service.Entries[0].Status);
 
@@ -2024,7 +1887,6 @@ public async Task RetryClassificationAsync_Success_UpdatesEntryToReady()
     [Fact]
     public void Toggle_WhenCalled_ShouldFlipIsEnabledAndPersist()
     {
-        // Arrange
         var databasePath = CreateDatabaseDirectory();
         CreateDatabaseFile(databasePath, Constants.TestDb1);
 
@@ -2033,10 +1895,8 @@ public void Toggle_WhenCalled_ShouldFlipIsEnabledAndPersist()
 
         var service = CreateDatabaseService(preferences);
 
-        // Act
         service.Toggle(Constants.TestDb1);
 
-        // Assert
         Assert.False(service.Entries[0].IsEnabled);
 
         preferences.Received(1).DisabledDatabasesPreference =
@@ -2046,7 +1906,6 @@ public void Toggle_WhenCalled_ShouldFlipIsEnabledAndPersist()
     [Fact]
     public void Toggle_WhenCalled_ShouldRaiseEntriesChanged()
     {
-        // Arrange
         var databasePath = CreateDatabaseDirectory();
         CreateDatabaseFile(databasePath, Constants.TestDb1);
 
@@ -2054,21 +1913,17 @@ public void Toggle_WhenCalled_ShouldRaiseEntriesChanged()
         var raised = false;
         service.EntriesChanged += (_, _) => raised = true;
 
-        // Act
         service.Toggle(Constants.TestDb1);
 
-        // Assert
         Assert.True(raised);
     }
 
     [Fact]
     public void Toggle_WhenFileNameUnknown_ShouldThrow()
     {
-        // Arrange
         CreateDatabaseDirectory();
         var service = CreateDatabaseService();
 
-        // Act + Assert
         Assert.Throws<InvalidOperationException>(() => service.Toggle("does-not-exist.db"));
     }
 
@@ -2150,8 +2005,6 @@ public async Task UpgradeBatchAsync_BackupAppearsAfterEnqueue_ShouldFailWithReco
 
         var service = CreateDatabaseService();
 
-        // Caller passed validation (no .upgrade.bak at enqueue), but a stale backup appears between
-        // enqueue and the per-entry TOCTOU re-check inside UpgradeAsync.
         var stalePayload = new byte[] { 0x42, 0x43 };
         File.WriteAllBytes(dbPath + ".upgrade.bak", stalePayload);
 
@@ -2165,8 +2018,6 @@ public async Task UpgradeBatchAsync_BackupAppearsAfterEnqueue_ShouldFailWithReco
 
         Assert.Equal(stalePayload, File.ReadAllBytes(dbPath + ".upgrade.bak"));
 
-        // Disk truth must be reflected on the entry so the recovery host prompts immediately rather
-        // than waiting for the next classification pass.
         Assert.True(service.Entries[0].BackupExists);
     }
 
@@ -2182,9 +2033,6 @@ public async Task UpgradeBatchAsync_BackupCleanupFails_ShouldMarkReadyWithBackup
         var backupPath = dbPath + ".upgrade.bak";
         FileStream? backupLock = null;
 
-        // After File.Copy creates the backup (during BackingUp phase), MigratingSchema fires.
-        // We hold an exclusive lock on the backup so the post-success TryDeleteFile fails — exercising
-        // the cleanup-failure path that previously rolled back the successful upgrade.
         service.UpgradeBatchProgress += (_, args) =>
         {
             if (args.Phase == UpgradePhase.MigratingSchema && backupLock is null)
@@ -2381,8 +2229,6 @@ public async Task UpgradeBatchAsync_MultipleProgressSubscribers_FirstThrows_Shou
 
         Assert.Single(result.Succeeded);
 
-        // BackingUp + MigratingSchema + Verifying = 3 progress events per entry. If multicast invoke
-        // aborted on the first throwing subscriber, this would be 0.
         Assert.Equal(3, secondSubscriberInvocations);
     }
 
@@ -2438,7 +2284,7 @@ public async Task UpgradeBatchAsync_TwoConcurrentBatches_ShouldRunSequentiallyIn
                 string.Equals(args.FileName, Constants.TestDb1, StringComparison.OrdinalIgnoreCase))
             {
                 firstBackingUp.Set();
-                releaseFirst.Wait(TimeSpan.FromSeconds(10));
+                releaseFirst.Wait(s_testTimeout);
             }
         };
 
@@ -2447,14 +2293,14 @@ public async Task UpgradeBatchAsync_TwoConcurrentBatches_ShouldRunSequentiallyIn
             UpgradeProgressScope.Background,
             TestContext.Current.CancellationToken);
 
-        Assert.True(firstBackingUp.Wait(TimeSpan.FromSeconds(10), TestContext.Current.CancellationToken));
+        Assert.True(firstBackingUp.Wait(s_testTimeout, TestContext.Current.CancellationToken));
 
         var secondBatch = service.UpgradeBatchAsync(
             [Constants.TestDb2],
             UpgradeProgressScope.Background,
             TestContext.Current.CancellationToken);
 
-        await Task.Delay(100, TestContext.Current.CancellationToken);
+        await Task.Delay(SecondBatchStartDelayMs, TestContext.Current.CancellationToken);
 
         lock (startedBatchIds)
         {
@@ -2550,8 +2396,6 @@ private DatabaseService CreateDatabaseService(
         var service = new DatabaseService(entryStore, classification, upgrade, import, recovery);
         _services.Add(service);
 
-        // Block until classification finishes so tests observe a stable post-classification
-        // state. Tests that need to observe pre-classification state construct the chain directly.
         service.InitialClassificationTask.GetAwaiter().GetResult();
         return service;
     }
diff --git a/tests/Integration/EventLogExpert.Runtime.IntegrationTests/DebugLog/OperationLogProgressFactoryTests.cs b/tests/Integration/EventLogExpert.Runtime.IntegrationTests/DebugLog/OperationLogProgressFactoryTests.cs
index d8f1078ac..8b5c4f7e6 100644
--- a/tests/Integration/EventLogExpert.Runtime.IntegrationTests/DebugLog/OperationLogProgressFactoryTests.cs
+++ b/tests/Integration/EventLogExpert.Runtime.IntegrationTests/DebugLog/OperationLogProgressFactoryTests.cs
@@ -35,7 +35,7 @@ public void Create_EmptyCategory_Throws()
     }
 
     [Fact]
-    public void Create_NullUiProgress_Throws()
+    public void Create_NullUIProgress_Throws()
     {
         var policy = new LogRoutingPolicy(LoggingOptions.CreateShippedDefaults(), LogLevel.Information);
         using var fileSink = new FileLogSink(_testLogPath, policy, DebugLogFormatter.Format);
diff --git a/tests/Integration/EventLogExpert.Runtime.IntegrationTests/FilterLibrary/FilterLibraryMigrationIntegrationTests.cs b/tests/Integration/EventLogExpert.Runtime.IntegrationTests/FilterLibrary/FilterLibraryMigrationIntegrationTests.cs
index cd67e3f5d..dd081ed69 100644
--- a/tests/Integration/EventLogExpert.Runtime.IntegrationTests/FilterLibrary/FilterLibraryMigrationIntegrationTests.cs
+++ b/tests/Integration/EventLogExpert.Runtime.IntegrationTests/FilterLibrary/FilterLibraryMigrationIntegrationTests.cs
@@ -126,10 +126,6 @@ public async Task Migration_Concurrent_TwoSimultaneousLoadLibraryCalls_MigratorB
     [Fact]
     public async Task Migration_CorruptGroupsLegacyData_FirstLoadMigratesFavorites_SecondLoadRetriesGroupsButStillFails_NoDuplicateFavoriteInsertion()
     {
-        // Behavior verified: with per-section flag check + DedupMigrationEntriesAgainstExisting, partial-success
-        // migration retries on every launch (Groups bit unset → ShouldRunMigration true), but the already-completed
-        // Favorites section is skipped in BuildEntriesFromLegacy AND dedup defends against re-insertion if the bit
-        // somehow regressed. The corrupt Groups JSON is preserved indefinitely for a future fix.
         var dbPath = CreateTempDatabasePath();
         var store = new FilterLibrarySqliteStore(dbPath, Substitute.For<ITraceLogger>());
 
@@ -151,13 +147,9 @@ public async Task Migration_CorruptGroupsLegacyData_FirstLoadMigratesFavorites_S
         await effects.HandleLoadLibrary(dispatcher);
         await effects.HandleLoadLibrary(dispatcher);
 
-        // Both loads invoke the migrator because ShouldRunMigration stays true while Groups remains unmigrated.
         spyMigrator.Received(2).BuildEntriesFromLegacy();
-        // Favorite migrated exactly once (dedup prevents duplicate on retry).
         Assert.Single(await store.LoadAllAsync(TestContext.Current.CancellationToken));
-        // Bitmask: Favorites (1) | Recents (4) = 5; Groups (2) stays unset because the JSON is still corrupt.
         Assert.Equal("5", prefs.GetString(MigrationSectionsKey));
-        // Corrupt Groups JSON preserved for future fix attempt.
         Assert.True(prefs.ContainsKey(SavedGroupsKey));
     }
 
@@ -241,7 +233,7 @@ private static Effects BuildEffects(IFilterLibraryStore store, ILegacyFilterMigr
 
         backslashMigrator ??= Substitute.For<IBackslashNameMigrator>();
 
-        return new Effects(store, libraryState, paneState, migrator, backslashMigrator, Substitute.For<IAnnouncementService>(), Substitute.For<ITraceLogger>());
+        return new Effects(store, libraryState, paneState, migrator, backslashMigrator, Substitute.For<IAnnouncementService>(), Substitute.For<ITraceLogger>(), new TagBulkUpdateFailedNotifier(Substitute.For<ITraceLogger>()));
     }
 
     private string CreateTempDatabasePath()
diff --git a/tests/Shared/EventLogExpert.Eventing.TestUtils/Common/Events/LegacyEventColumnReader.cs b/tests/Shared/EventLogExpert.Eventing.TestUtils/Common/Events/LegacyEventColumnReader.cs
deleted file mode 100644
index 7f5b73427..000000000
--- a/tests/Shared/EventLogExpert.Eventing.TestUtils/Common/Events/LegacyEventColumnReader.cs
+++ /dev/null
@@ -1,765 +0,0 @@
-// // Copyright (c) Microsoft Corporation.
-// // Licensed under the MIT License.
-
-using EventLogExpert.Eventing.Common.EventLogs;
-using EventLogExpert.Eventing.Readers;
-using EventLogExpert.Eventing.Structured;
-
-namespace EventLogExpert.Eventing.Common.Events;
-
-public sealed class LegacyEventColumnReader : IEventColumnReader
-{
-    private readonly IReadOnlyList<ResolvedEvent> _events;
-
-    // Lazily built union of the pooled string columns' distinct values, so the AoS bridge can answer the same bulk
-    // pool-index API as the column store (correctness only; this reader is never on the live path).
-    private LegacyStringPool? _pool;
-
-    public LegacyEventColumnReader(EventLogId logId, int generation, long contentVersion, IReadOnlyList<ResolvedEvent> events)
-    {
-        ArgumentNullException.ThrowIfNull(events);
-
-        LogId = logId;
-        Generation = generation;
-        ContentVersion = contentVersion;
-        _events = events;
-    }
-
-    public long ContentVersion { get; }
-
-    public int Count => _events.Count;
-
-    public IReadOnlyList<ResolvedEvent> Events => _events;
-
-    public int Generation { get; }
-
-    public EventLogId LogId { get; }
-
-    public IReadOnlyList<string?> Pool => StringPool().Values;
-
-    public void BucketTimeTicksByEventData(
-        ReadOnlySpan<int> rankByPhysical,
-        long minTicks,
-        long bucketSpanTicks,
-        int bucketCount,
-        string fieldName,
-        long[] targetCodes,
-        int[] slotCounts,
-        CancellationToken cancellationToken)
-    {
-        ArgumentException.ThrowIfNullOrEmpty(fieldName);
-        ArgumentNullException.ThrowIfNull(targetCodes);
-        ArgumentNullException.ThrowIfNull(slotCounts);
-        ArgumentOutOfRangeException.ThrowIfNotEqual(rankByPhysical.Length, Count);
-
-        int slotCount = targetCodes.Length + 1;
-        int otherSlot = targetCodes.Length;
-
-        for (int index = 0; index < _events.Count; index++)
-        {
-            if (rankByPhysical[index] < 0) { continue; }
-
-            long bucket = (_events[index].TimeCreated.Ticks - minTicks) / bucketSpanTicks;
-            int clamped = bucket < 0 ? 0 : bucket >= bucketCount ? bucketCount - 1 : (int)bucket;
-            int slot = otherSlot;
-
-            if (_events[index].EventData.TryGetValue(fieldName, out EventFieldValue value) && value.TryGetWholeNumber(out long code))
-            {
-                for (int target = 0; target < targetCodes.Length; target++)
-                {
-                    if (targetCodes[target] == code)
-                    {
-                        slot = target;
-
-                        break;
-                    }
-                }
-            }
-
-            slotCounts[(clamped * slotCount) + slot]++;
-        }
-    }
-
-    public void BucketTimeTicksByEventDataHResult(
-        ReadOnlySpan<int> rankByPhysical,
-        long minTicks,
-        long bucketSpanTicks,
-        int bucketCount,
-        string fieldName,
-        IReadOnlyCollection<string> eligibleProviders,
-        IReadOnlyList<string> userDataErrorCodePaths,
-        long[] targetCodes,
-        int[] slotCounts,
-        CancellationToken cancellationToken)
-    {
-        ArgumentException.ThrowIfNullOrEmpty(fieldName);
-        ArgumentNullException.ThrowIfNull(eligibleProviders);
-        ArgumentNullException.ThrowIfNull(userDataErrorCodePaths);
-        ArgumentNullException.ThrowIfNull(targetCodes);
-        ArgumentNullException.ThrowIfNull(slotCounts);
-        ArgumentOutOfRangeException.ThrowIfNotEqual(rankByPhysical.Length, Count);
-
-        int slotCount = targetCodes.Length + 1;
-        int otherSlot = targetCodes.Length;
-        IReadOnlySet<string> eligibleNames = AsOrdinalSet(eligibleProviders);
-
-        for (int index = 0; index < _events.Count; index++)
-        {
-            if (rankByPhysical[index] < 0) { continue; }
-
-            ResolvedEvent resolved = _events[index];
-
-            if (!eligibleNames.Contains(resolved.Source)) { continue; }
-
-            if (!TryGetHResult(resolved, fieldName, userDataErrorCodePaths, out long code)) { continue; }
-
-            long bucket = (resolved.TimeCreated.Ticks - minTicks) / bucketSpanTicks;
-            int clamped = bucket < 0 ? 0 : bucket >= bucketCount ? bucketCount - 1 : (int)bucket;
-            int slot = otherSlot;
-
-            for (int target = 0; target < targetCodes.Length; target++)
-            {
-                if (targetCodes[target] == code) { slot = target; break; }
-            }
-
-            slotCounts[(clamped * slotCount) + slot]++;
-        }
-    }
-
-    public void BucketTimeTicksByEventDataHResultWithTie(ReadOnlySpan<int> rankByPhysical, ReadOnlySpan<byte> highlightWinners, uint[] slotColorMask, long minTicks, long bucketSpanTicks, int bucketCount, string fieldName, IReadOnlyCollection<string> eligibleProviders, IReadOnlyList<string> userDataErrorCodePaths, long[] targetCodes, int[] slotCounts, CancellationToken cancellationToken)
-    {
-        BucketTimeTicksByEventDataHResult(rankByPhysical, minTicks, bucketSpanTicks, bucketCount, fieldName, eligibleProviders, userDataErrorCodePaths, targetCodes, slotCounts, cancellationToken);
-
-        int otherSlot = targetCodes.Length;
-        IReadOnlySet<string> eligibleNames = AsOrdinalSet(eligibleProviders);
-
-        for (int index = 0; index < _events.Count; index++)
-        {
-            if (rankByPhysical[index] < 0) { continue; }
-
-            ResolvedEvent resolved = _events[index];
-
-            if (!eligibleNames.Contains(resolved.Source)) { continue; }
-            if (!TryGetHResult(resolved, fieldName, userDataErrorCodePaths, out long code)) { continue; }
-
-            int slot = otherSlot;
-            for (int target = 0; target < targetCodes.Length; target++)
-            {
-                if (targetCodes[target] == code) { slot = target; break; }
-            }
-
-            slotColorMask[slot] |= 1u << highlightWinners[index];
-        }
-    }
-
-    public void BucketTimeTicksByEventDataString(
-        ReadOnlySpan<int> rankByPhysical,
-        long minTicks,
-        long bucketSpanTicks,
-        int bucketCount,
-        string[] candidateFields,
-        IReadOnlyDictionary<string, int> rawValueToSlot,
-        int slotCount,
-        int[] slotCounts,
-        CancellationToken cancellationToken)
-    {
-        ArgumentNullException.ThrowIfNull(candidateFields);
-        ArgumentNullException.ThrowIfNull(rawValueToSlot);
-        ArgumentNullException.ThrowIfNull(slotCounts);
-        ArgumentOutOfRangeException.ThrowIfNotEqual(rankByPhysical.Length, Count);
-
-        int otherSlot = slotCount - 1;
-
-        for (int index = 0; index < _events.Count; index++)
-        {
-            if (rankByPhysical[index] < 0) { continue; }
-
-            long bucket = (_events[index].TimeCreated.Ticks - minTicks) / bucketSpanTicks;
-            int clamped = bucket < 0 ? 0 : bucket >= bucketCount ? bucketCount - 1 : (int)bucket;
-            int slot = otherSlot;
-
-            for (int candidate = 0; candidate < candidateFields.Length; candidate++)
-            {
-                if (_events[index].EventData.TryGetRawValue(candidateFields[candidate], out EventProperty property)
-                    && property.Reference is string raw
-                    && EventColumnStore.IsUsableRawValue(raw))
-                {
-                    slot = rawValueToSlot.TryGetValue(raw, out int mapped) ? mapped : otherSlot;
-
-                    break;
-                }
-            }
-
-            slotCounts[(clamped * slotCount) + slot]++;
-        }
-    }
-
-    public void BucketTimeTicksByEventDataStringWithTie(ReadOnlySpan<int> rankByPhysical, ReadOnlySpan<byte> highlightWinners, uint[] slotColorMask, long minTicks, long bucketSpanTicks, int bucketCount, string[] candidateFields, IReadOnlyDictionary<string, int> rawValueToSlot, int slotCount, int[] slotCounts, CancellationToken cancellationToken)
-    {
-        BucketTimeTicksByEventDataString(rankByPhysical, minTicks, bucketSpanTicks, bucketCount, candidateFields, rawValueToSlot, slotCount, slotCounts, cancellationToken);
-
-        int otherSlot = slotCount - 1;
-
-        for (int index = 0; index < _events.Count; index++)
-        {
-            if (rankByPhysical[index] < 0) { continue; }
-
-            int slot = otherSlot;
-
-            for (int candidate = 0; candidate < candidateFields.Length; candidate++)
-            {
-                if (_events[index].EventData.TryGetRawValue(candidateFields[candidate], out EventProperty property)
-                    && property.Reference is string raw
-                    && EventColumnStore.IsUsableRawValue(raw))
-                {
-                    slot = rawValueToSlot.TryGetValue(raw, out int mapped) ? mapped : otherSlot;
-                    break;
-                }
-            }
-
-            slotColorMask[slot] |= 1u << highlightWinners[index];
-        }
-    }
-
-    public void BucketTimeTicksByEventDataWithTie(ReadOnlySpan<int> rankByPhysical, ReadOnlySpan<byte> highlightWinners, uint[] slotColorMask, long minTicks, long bucketSpanTicks, int bucketCount, string fieldName, long[] targetCodes, int[] slotCounts, CancellationToken cancellationToken)
-    {
-        BucketTimeTicksByEventData(rankByPhysical, minTicks, bucketSpanTicks, bucketCount, fieldName, targetCodes, slotCounts, cancellationToken);
-
-        int otherSlot = targetCodes.Length;
-
-        for (int index = 0; index < _events.Count; index++)
-        {
-            if (rankByPhysical[index] < 0) { continue; }
-
-            int slot = otherSlot;
-
-            if (_events[index].EventData.TryGetValue(fieldName, out EventFieldValue value) && value.TryGetWholeNumber(out long code))
-            {
-                for (int target = 0; target < targetCodes.Length; target++)
-                {
-                    if (targetCodes[target] == code) { slot = target; break; }
-                }
-            }
-
-            slotColorMask[slot] |= 1u << highlightWinners[index];
-        }
-    }
-
-    public void BucketTimeTicksByEventId(
-        ReadOnlySpan<int> rankByPhysical,
-        long minTicks,
-        long bucketSpanTicks,
-        int bucketCount,
-        int[] targetIds,
-        int[] slotCounts,
-        CancellationToken cancellationToken)
-    {
-        ArgumentNullException.ThrowIfNull(targetIds);
-        ArgumentNullException.ThrowIfNull(slotCounts);
-        ArgumentOutOfRangeException.ThrowIfNotEqual(rankByPhysical.Length, Count);
-
-        int slotCount = targetIds.Length + 1;
-        int otherSlot = targetIds.Length;
-
-        for (int index = 0; index < _events.Count; index++)
-        {
-            if (rankByPhysical[index] < 0) { continue; }
-
-            long bucket = (_events[index].TimeCreated.Ticks - minTicks) / bucketSpanTicks;
-            int clamped = bucket < 0 ? 0 : bucket >= bucketCount ? bucketCount - 1 : (int)bucket;
-            int slot = otherSlot;
-
-            for (int target = 0; target < targetIds.Length; target++)
-            {
-                if (_events[index].Id == targetIds[target]) { slot = target; break; }
-            }
-
-            slotCounts[(clamped * slotCount) + slot]++;
-        }
-    }
-
-    public void BucketTimeTicksByEventIdWithTie(ReadOnlySpan<int> rankByPhysical, ReadOnlySpan<byte> highlightWinners, uint[] slotColorMask, long minTicks, long bucketSpanTicks, int bucketCount, int[] targetIds, int[] slotCounts, CancellationToken cancellationToken)
-    {
-        BucketTimeTicksByEventId(rankByPhysical, minTicks, bucketSpanTicks, bucketCount, targetIds, slotCounts, cancellationToken);
-
-        int otherSlot = targetIds.Length;
-
-        for (int index = 0; index < _events.Count; index++)
-        {
-            if (rankByPhysical[index] < 0) { continue; }
-
-            int slot = otherSlot;
-
-            for (int target = 0; target < targetIds.Length; target++)
-            {
-                if (_events[index].Id == targetIds[target]) { slot = target; break; }
-            }
-
-            slotColorMask[slot] |= 1u << highlightWinners[index];
-        }
-    }
-
-    public void BucketTimeTicksByField(
-        ReadOnlySpan<int> rankByPhysical,
-        long minTicks,
-        long bucketSpanTicks,
-        int bucketCount,
-        EventFieldId field,
-        string[] targetValues,
-        int[] slotCounts,
-        CancellationToken cancellationToken)
-    {
-        ArgumentNullException.ThrowIfNull(targetValues);
-        ArgumentNullException.ThrowIfNull(slotCounts);
-        ArgumentOutOfRangeException.ThrowIfNotEqual(rankByPhysical.Length, Count);
-
-        int slotCount = targetValues.Length + 1;
-        int otherSlot = targetValues.Length;
-
-        for (int index = 0; index < _events.Count; index++)
-        {
-            if (rankByPhysical[index] < 0) { continue; }
-
-            long bucket = (_events[index].TimeCreated.Ticks - minTicks) / bucketSpanTicks;
-            int clamped = bucket < 0 ? 0 : bucket >= bucketCount ? bucketCount - 1 : (int)bucket;
-            int slot = SlotForString(FieldValue(_events[index], field), targetValues, otherSlot);
-            slotCounts[(clamped * slotCount) + slot]++;
-        }
-    }
-
-    public void BucketTimeTicksByFieldWithTie(ReadOnlySpan<int> rankByPhysical, ReadOnlySpan<byte> highlightWinners, uint[] slotColorMask, long minTicks, long bucketSpanTicks, int bucketCount, EventFieldId field, string[] targetValues, int[] slotCounts, CancellationToken cancellationToken)
-    {
-        BucketTimeTicksByField(rankByPhysical, minTicks, bucketSpanTicks, bucketCount, field, targetValues, slotCounts, cancellationToken);
-
-        int otherSlot = targetValues.Length;
-
-        for (int index = 0; index < _events.Count; index++)
-        {
-            if (rankByPhysical[index] < 0) { continue; }
-
-            int slot = SlotForString(FieldValue(_events[index], field), targetValues, otherSlot);
-            slotColorMask[slot] |= 1u << highlightWinners[index];
-        }
-    }
-
-    public void BucketTimeTicksBySeverity(
-        ReadOnlySpan<int> rankByPhysical,
-        long minTicks,
-        long bucketSpanTicks,
-        int bucketCount,
-        int[] slotCounts,
-        CancellationToken cancellationToken)
-    {
-        ArgumentNullException.ThrowIfNull(slotCounts);
-        ArgumentOutOfRangeException.ThrowIfNotEqual(rankByPhysical.Length, Count);
-
-        int slotCount = LevelSeverity.SlotCount;
-
-        for (int index = 0; index < _events.Count; index++)
-        {
-            if (rankByPhysical[index] < 0) { continue; }
-
-            long bucket = (_events[index].TimeCreated.Ticks - minTicks) / bucketSpanTicks;
-            int clamped = bucket < 0 ? 0 : bucket >= bucketCount ? bucketCount - 1 : (int)bucket;
-            int slot = LevelSeverity.Slot(LevelSeverity.FromLevelName(_events[index].Level));
-            slotCounts[(clamped * slotCount) + slot]++;
-        }
-    }
-
-    public void BucketTimeTicksBySeverityWithTie(ReadOnlySpan<int> rankByPhysical, ReadOnlySpan<byte> highlightWinners, uint[] slotColorMask, long minTicks, long bucketSpanTicks, int bucketCount, int[] slotCounts, CancellationToken cancellationToken)
-    {
-        BucketTimeTicksBySeverity(rankByPhysical, minTicks, bucketSpanTicks, bucketCount, slotCounts, cancellationToken);
-
-        for (int index = 0; index < _events.Count; index++)
-        {
-            if (rankByPhysical[index] < 0) { continue; }
-
-            int slot = LevelSeverity.Slot(LevelSeverity.FromLevelName(_events[index].Level));
-            slotColorMask[slot] |= 1u << highlightWinners[index];
-        }
-    }
-
-    public void CopyGuidColumn(EventFieldId field, Guid[] values, bool[] hasValue)
-    {
-        ArgumentNullException.ThrowIfNull(values);
-        ArgumentNullException.ThrowIfNull(hasValue);
-
-        switch (field)
-        {
-            case EventFieldId.ActivityId:
-                for (int index = 0; index < _events.Count; index++)
-                {
-                    Guid? value = _events[index].ActivityId;
-                    values[index] = value ?? Guid.Empty;
-                    hasValue[index] = value.HasValue;
-                }
-
-                break;
-            case EventFieldId.RelatedActivityId:
-                for (int index = 0; index < _events.Count; index++)
-                {
-                    Guid? value = _events[index].RelatedActivityId;
-                    values[index] = value ?? Guid.Empty;
-                    hasValue[index] = value.HasValue;
-                }
-
-                break;
-            default:
-                throw new ArgumentOutOfRangeException(nameof(field), field, "Not a Guid column.");
-        }
-    }
-
-    public void CopyInt64Column(EventFieldId field, long[] values, bool[] hasValue)
-    {
-        ArgumentNullException.ThrowIfNull(values);
-        ArgumentNullException.ThrowIfNull(hasValue);
-
-        for (int index = 0; index < _events.Count; index++)
-        {
-            ResolvedEvent resolvedEvent = _events[index];
-
-            switch (field)
-            {
-                case EventFieldId.Id:
-                    values[index] = resolvedEvent.Id;
-                    hasValue[index] = true;
-                    break;
-                case EventFieldId.RecordId:
-                    values[index] = resolvedEvent.RecordId ?? 0;
-                    hasValue[index] = resolvedEvent.RecordId.HasValue;
-                    break;
-                case EventFieldId.ProcessId:
-                    values[index] = resolvedEvent.ProcessId ?? 0;
-                    hasValue[index] = resolvedEvent.ProcessId.HasValue;
-                    break;
-                case EventFieldId.ThreadId:
-                    values[index] = resolvedEvent.ThreadId ?? 0;
-                    hasValue[index] = resolvedEvent.ThreadId.HasValue;
-                    break;
-                case EventFieldId.TimeCreated:
-                    values[index] = resolvedEvent.TimeCreated.Ticks;
-                    hasValue[index] = true;
-                    break;
-                default:
-                    throw new ArgumentOutOfRangeException(nameof(field), field, "Not an integral column.");
-            }
-        }
-    }
-
-    public void CopyPoolIndexColumn(EventFieldId field, int[] poolIndices)
-    {
-        ArgumentNullException.ThrowIfNull(poolIndices);
-
-        LegacyStringPool pool = StringPool();
-
-        for (int index = 0; index < _events.Count; index++)
-        {
-            string? value = RawPoolString(_events[index], field);
-            poolIndices[index] = value is null ? -1 : pool.IndexOf(value);
-        }
-    }
-
-    public void CountEventDataHResults(ReadOnlySpan<int> rankByPhysical, string fieldName, IReadOnlyCollection<string> eligibleProviders, IReadOnlyList<string> userDataErrorCodePaths, IDictionary<long, int> counts, CancellationToken cancellationToken)
-    {
-        ArgumentException.ThrowIfNullOrEmpty(fieldName);
-        ArgumentNullException.ThrowIfNull(eligibleProviders);
-        ArgumentNullException.ThrowIfNull(userDataErrorCodePaths);
-        ArgumentNullException.ThrowIfNull(counts);
-        ArgumentOutOfRangeException.ThrowIfNotEqual(rankByPhysical.Length, Count);
-
-        IReadOnlySet<string> eligibleNames = AsOrdinalSet(eligibleProviders);
-
-        for (int index = 0; index < _events.Count; index++)
-        {
-            if (rankByPhysical[index] < 0) { continue; }
-
-            ResolvedEvent resolved = _events[index];
-
-            if (!eligibleNames.Contains(resolved.Source)) { continue; }
-
-            if (TryGetHResult(resolved, fieldName, userDataErrorCodePaths, out long code))
-            {
-                counts[code] = counts.TryGetValue(code, out int existing) ? existing + 1 : 1;
-            }
-        }
-    }
-
-    public void CountEventDataStringValues(ReadOnlySpan<int> rankByPhysical, string[] candidateFields, IDictionary<string, int> counts, CancellationToken cancellationToken)
-    {
-        ArgumentNullException.ThrowIfNull(candidateFields);
-        ArgumentNullException.ThrowIfNull(counts);
-        ArgumentOutOfRangeException.ThrowIfNotEqual(rankByPhysical.Length, Count);
-
-        for (int index = 0; index < _events.Count; index++)
-        {
-            if (rankByPhysical[index] < 0) { continue; }
-
-            for (int candidate = 0; candidate < candidateFields.Length; candidate++)
-            {
-                if (_events[index].EventData.TryGetRawValue(candidateFields[candidate], out EventProperty property)
-                    && property.Reference is string raw
-                    && EventColumnStore.IsUsableRawValue(raw))
-                {
-                    counts[raw] = counts.TryGetValue(raw, out int existing) ? existing + 1 : 1;
-
-                    break;
-                }
-            }
-        }
-    }
-
-    public void CountEventDataValues(ReadOnlySpan<int> rankByPhysical, string fieldName, IDictionary<long, int> counts, CancellationToken cancellationToken)
-    {
-        ArgumentException.ThrowIfNullOrEmpty(fieldName);
-        ArgumentNullException.ThrowIfNull(counts);
-        ArgumentOutOfRangeException.ThrowIfNotEqual(rankByPhysical.Length, Count);
-
-        for (int index = 0; index < _events.Count; index++)
-        {
-            if (rankByPhysical[index] < 0) { continue; }
-
-            if (_events[index].EventData.TryGetValue(fieldName, out EventFieldValue value) && value.TryGetWholeNumber(out long code))
-            {
-                counts[code] = counts.TryGetValue(code, out int existing) ? existing + 1 : 1;
-            }
-        }
-    }
-
-    public void CountEventIds(ReadOnlySpan<int> rankByPhysical, IDictionary<int, int> counts, CancellationToken cancellationToken)
-    {
-        ArgumentNullException.ThrowIfNull(counts);
-        ArgumentOutOfRangeException.ThrowIfNotEqual(rankByPhysical.Length, Count);
-
-        for (int index = 0; index < _events.Count; index++)
-        {
-            if (rankByPhysical[index] < 0) { continue; }
-
-            int id = _events[index].Id;
-            counts[id] = counts.TryGetValue(id, out int existing) ? existing + 1 : 1;
-        }
-    }
-
-    public void CountFieldValues(ReadOnlySpan<int> rankByPhysical, EventFieldId field, IDictionary<string, int> counts, CancellationToken cancellationToken)
-    {
-        ArgumentNullException.ThrowIfNull(counts);
-        ArgumentOutOfRangeException.ThrowIfNotEqual(rankByPhysical.Length, Count);
-
-        for (int index = 0; index < _events.Count; index++)
-        {
-            if (rankByPhysical[index] < 0) { continue; }
-
-            string? value = FieldValue(_events[index], field);
-
-            if (string.IsNullOrEmpty(value)) { continue; }
-
-            counts[value] = counts.TryGetValue(value, out int existing) ? existing + 1 : 1;
-        }
-    }
-
-    public EventDataFieldEnumerator EnumerateEventData(EventLocator locator) => new(GetEvent(locator).EventData);
-
-    public UserDataFieldEnumerator EnumerateUserData(EventLocator locator)
-    {
-        ResolvedEvent resolvedEvent = GetEvent(locator);
-
-        return new UserDataFieldEnumerator(resolvedEvent.UserData, resolvedEvent.UserDataIncomplete);
-    }
-
-    public ResolvedEvent GetDetail(EventLocator locator) => GetEvent(locator);
-
-    public ResolvedEvent GetDetailLean(EventLocator locator) => GetEvent(locator);
-
-    // Legacy-adapter convenience: the current store keeps whole ResolvedEvent objects, so a locator resolves directly to
-    // one. The real column store will not retain events; its view rehydrates from columns instead.
-    public ResolvedEvent GetEvent(EventLocator locator)
-    {
-        if (locator.LogId != LogId || locator.Generation != Generation)
-        {
-            throw new ArgumentException("Locator does not belong to this reader's log/generation.", nameof(locator));
-        }
-
-        return _events[locator.Index];
-    }
-
-    public EventFieldValue GetField(EventLocator locator, EventFieldId field) =>
-        ResolvedEventFieldReader.GetField(GetEvent(locator), field);
-
-    public IReadOnlyList<string> GetKeywords(EventLocator locator) => GetEvent(locator).Keywords;
-
-    public long GetTimeTicks(EventLocator locator) => GetEvent(locator).TimeCreated.Ticks;
-
-    public StructuredFieldResult GetUserData(EventLocator locator, string storageKey) =>
-        GetEvent(locator).TryGetUserDataValues(storageKey);
-
-    public bool GetUserDataIncomplete(EventLocator locator) => GetEvent(locator).UserDataIncomplete;
-
-    public EventLocator LocatorAt(int index) => new(LogId, Generation, index);
-
-    public bool TryGetEventData(EventLocator locator, string fieldName, out EventFieldValue value) =>
-        GetEvent(locator).EventData.TryGetValue(fieldName, out value);
-
-    public bool TryGetTimeTicksRange(
-        ReadOnlySpan<int> rankByPhysical,
-        out long minTicks,
-        out long maxTicks,
-        CancellationToken cancellationToken)
-    {
-        ArgumentOutOfRangeException.ThrowIfNotEqual(rankByPhysical.Length, Count);
-
-        long min = long.MaxValue;
-        long max = long.MinValue;
-        bool any = false;
-
-        for (int index = 0; index < _events.Count; index++)
-        {
-            if (rankByPhysical[index] < 0) { continue; }
-
-            long ticks = _events[index].TimeCreated.Ticks;
-            if (ticks < min) { min = ticks; }
-            if (ticks > max) { max = ticks; }
-            any = true;
-        }
-
-        minTicks = any ? min : 0;
-        maxTicks = any ? max : 0;
-
-        return any;
-    }
-
-    private static HashSet<string> AsOrdinalSet(IReadOnlyCollection<string> providers) => new(providers, StringComparer.Ordinal);
-
-    private static bool ContainsOrdinal(IReadOnlyList<string> paths, string value)
-    {
-        for (int index = 0; index < paths.Count; index++)
-        {
-            if (string.Equals(paths[index], value, StringComparison.Ordinal)) { return true; }
-        }
-
-        return false;
-    }
-
-    private static string? FieldValue(ResolvedEvent @event, EventFieldId field) => field switch
-    {
-        EventFieldId.Source => @event.Source,
-        EventFieldId.TaskCategory => @event.TaskCategory,
-        EventFieldId.Opcode => @event.Opcode,
-        EventFieldId.LogName => @event.LogName,
-        EventFieldId.ComputerName => @event.ComputerName,
-        EventFieldId.OwningLog => @event.OwningLog,
-        _ => throw new ArgumentOutOfRangeException(nameof(field), field, "Field is not a supported group-by dimension.")
-    };
-
-    private static string? RawPoolString(ResolvedEvent resolvedEvent, EventFieldId field) => field switch
-    {
-        EventFieldId.Level => resolvedEvent.Level,
-        EventFieldId.LogName => resolvedEvent.LogName,
-        EventFieldId.ComputerName => resolvedEvent.ComputerName,
-        EventFieldId.Source => resolvedEvent.Source,
-        EventFieldId.TaskCategory => resolvedEvent.TaskCategory,
-        EventFieldId.UserId => resolvedEvent.UserId?.Value,
-        EventFieldId.Description => resolvedEvent.Description,
-        EventFieldId.Xml => resolvedEvent.Xml,
-        EventFieldId.OwningLog => resolvedEvent.OwningLog,
-        EventFieldId.Opcode => resolvedEvent.Opcode,
-        _ => throw new ArgumentOutOfRangeException(nameof(field), field, "Not a single pooled string column.")
-    };
-
-    private static int SlotForString(string? value, string[] targets, int otherSlot)
-    {
-        for (int slot = 0; slot < targets.Length; slot++)
-        {
-            if (string.Equals(value, targets[slot], StringComparison.Ordinal)) { return slot; }
-        }
-
-        return otherSlot;
-    }
-
-    // Mirrors EventColumnStore: an eligible row's failure HRESULT comes from its EventData errorCode field, or - when that
-    // field is absent (servicing rows store no EventData) - from a curated UserData Cbs*/ErrorCode leaf. 0x0 and empty
-    // parse to a zero/no code and are dropped like an absent field, so this oracle omits the same rows the store does.
-    private static bool TryGetHResult(ResolvedEvent resolved, string fieldName, IReadOnlyList<string> userDataErrorCodePaths, out long code)
-    {
-        if (resolved.EventData.TryGetValue(fieldName, out EventFieldValue value) && value.TryGetHResult32(out uint hresult) && hresult != 0)
-        {
-            code = hresult;
-
-            return true;
-        }
-
-        if (!resolved.UserData.IsDefaultOrEmpty)
-        {
-            foreach (UserDataField field in resolved.UserData)
-            {
-                if (!ContainsOrdinal(userDataErrorCodePaths, field.Path)) { continue; }
-
-                if (!field.Values.IsDefaultOrEmpty && EventFieldValue.TryParseHResult32(field.Values[0], out uint userDataHresult) && userDataHresult != 0)
-                {
-                    code = userDataHresult;
-
-                    return true;
-                }
-            }
-        }
-
-        code = 0;
-
-        return false;
-    }
-
-    private LegacyStringPool BuildStringPool()
-    {
-        var indexByValue = new Dictionary<string, int>(StringComparer.Ordinal);
-        var values = new List<string?>();
-
-        foreach (ResolvedEvent resolvedEvent in _events)
-        {
-            Add(resolvedEvent.Level, indexByValue, values);
-            Add(resolvedEvent.LogName, indexByValue, values);
-            Add(resolvedEvent.ComputerName, indexByValue, values);
-            Add(resolvedEvent.Source, indexByValue, values);
-            Add(resolvedEvent.TaskCategory, indexByValue, values);
-            Add(resolvedEvent.UserId?.Value, indexByValue, values);
-            Add(resolvedEvent.Description, indexByValue, values);
-            Add(resolvedEvent.Xml, indexByValue, values);
-            Add(resolvedEvent.OwningLog, indexByValue, values);
-            Add(resolvedEvent.Opcode, indexByValue, values);
-        }
-
-        return new LegacyStringPool(values, indexByValue);
-
-        static void Add(string? value, Dictionary<string, int> indexByValue, List<string?> values)
-        {
-            if (value is null || indexByValue.ContainsKey(value)) { return; }
-
-            indexByValue[value] = values.Count;
-            values.Add(value);
-        }
-    }
-
-    private LegacyStringPool StringPool()
-    {
-        LegacyStringPool? existing = Volatile.Read(ref _pool);
-
-        if (existing is not null) { return existing; }
-
-        LegacyStringPool built = BuildStringPool();
-        Volatile.Write(ref _pool, built);
-
-        return built;
-    }
-
-    private sealed class LegacyStringPool
-    {
-        private readonly Dictionary<string, int> _indexByValue;
-
-        internal LegacyStringPool(IReadOnlyList<string?> values, Dictionary<string, int> indexByValue)
-        {
-            Values = values;
-            _indexByValue = indexByValue;
-        }
-
-        internal IReadOnlyList<string?> Values { get; }
-
-        internal int IndexOf(string value) => _indexByValue[value];
-    }
-}
diff --git a/tests/Unit/EventLogExpert.Eventing.Tests/Common/Events/EventColumnReaderBulkColumnTests.cs b/tests/Unit/EventLogExpert.Eventing.Tests/Common/Events/EventColumnReaderBulkColumnTests.cs
index d544483f3..62d7f54fc 100644
--- a/tests/Unit/EventLogExpert.Eventing.Tests/Common/Events/EventColumnReaderBulkColumnTests.cs
+++ b/tests/Unit/EventLogExpert.Eventing.Tests/Common/Events/EventColumnReaderBulkColumnTests.cs
@@ -8,14 +8,6 @@
 
 namespace EventLogExpert.Eventing.Tests.Common.Events;
 
-/// <summary>
-///     Validates the bulk column materializers on <see cref="IEventColumnReader" /> (
-///     <see cref="IEventColumnReader.CopyInt64Column" />, <see cref="IEventColumnReader.CopyGuidColumn" />,
-///     <see cref="IEventColumnReader.CopyPoolIndexColumn" />, and <see cref="IEventColumnReader.Pool" />) against the
-///     per-row <see cref="IEventColumnReader.GetField" /> oracle for a sealed store, an all-pending store, and a mixed
-///     store whose pending tail introduces pooled strings the sealed pool never interned. The legacy adapter answers the
-///     same API, so both backends are checked.
-/// </summary>
 public sealed class EventColumnReaderBulkColumnTests
 {
     private const long ContentVersion = 42;
@@ -33,29 +25,19 @@ public sealed class EventColumnReaderBulkColumnTests
     ];
     private static readonly DateTime s_time = new(2021, 6, 15, 10, 20, 30, DateTimeKind.Utc);
 
-    [Fact]
-    public void BulkColumns_LegacyReader_MatchGetFieldForEveryRow()
-    {
-        ResolvedEvent[] corpus = BuildCorpus();
-
-        AssertBulkColumnParity(new LegacyEventColumnReader(s_logId, Generation, ContentVersion, corpus));
-    }
-
     [Fact]
     public void BulkColumns_MixedStore_WithNovelPendingPoolStrings_MatchGetFieldForEveryRow()
     {
-        ResolvedEvent[] sealedCorpus = BuildCorpus();
-        ResolvedEvent[] pendingCorpus = BuildNovelPendingCorpus();
-        EventColumnStore store = EventColumnStore.Build(sealedCorpus, Generation, ContentVersion).Append(pendingCorpus);
+        ResolvedEvent[] sealedSample = BuildSample();
+        ResolvedEvent[] pendingSample = BuildNovelPendingSample();
+        EventColumnStore store = EventColumnStore.Build(sealedSample, Generation, ContentVersion).Append(pendingSample);
 
-        Assert.Equal(sealedCorpus.Length, store.SealedCount);
-        Assert.Equal(sealedCorpus.Length + pendingCorpus.Length, store.Count);
+        Assert.Equal(sealedSample.Length, store.SealedCount);
+        Assert.Equal(sealedSample.Length + pendingSample.Length, store.Count);
 
         var reader = new EventColumnStoreReader(s_logId, store);
         AssertBulkColumnParity(reader);
 
-        // A pending Source the sealed pool never interned must resolve through the pool extension, i.e. to an index at or
-        // beyond the sealed pool's distinct count.
         var poolIndices = new int[store.Count];
         reader.CopyPoolIndexColumn(EventFieldId.Source, poolIndices);
         int novelIndex = poolIndices[store.Count - 1];
@@ -67,8 +49,8 @@ public void BulkColumns_MixedStore_WithNovelPendingPoolStrings_MatchGetFieldForE
     [Fact]
     public void BulkColumns_PendingStore_MatchGetFieldForEveryRow()
     {
-        ResolvedEvent[] corpus = BuildCorpus();
-        EventColumnStore store = EventColumnStore.Build([], Generation, ContentVersion).Append(corpus);
+        ResolvedEvent[] sample = BuildSample();
+        EventColumnStore store = EventColumnStore.Build([], Generation, ContentVersion).Append(sample);
 
         Assert.Equal(0, store.SealedCount);
 
@@ -78,10 +60,10 @@ public void BulkColumns_PendingStore_MatchGetFieldForEveryRow()
     [Fact]
     public void BulkColumns_SealedStore_MatchGetFieldForEveryRow()
     {
-        ResolvedEvent[] corpus = BuildCorpus();
-        EventColumnStore store = EventColumnStore.Build(corpus, Generation, ContentVersion);
+        ResolvedEvent[] sample = BuildSample();
+        EventColumnStore store = EventColumnStore.Build(sample, Generation, ContentVersion);
 
-        Assert.Equal(corpus.Length, store.SealedCount);
+        Assert.Equal(sample.Length, store.SealedCount);
 
         AssertBulkColumnParity(new EventColumnStoreReader(s_logId, store));
     }
@@ -89,25 +71,25 @@ public void BulkColumns_SealedStore_MatchGetFieldForEveryRow()
     [Fact]
     public void BulkColumns_WrongStorageKind_Throws()
     {
-        ResolvedEvent[] corpus = BuildCorpus();
-        var reader = new EventColumnStoreReader(s_logId, EventColumnStore.Build(corpus, Generation, ContentVersion));
+        ResolvedEvent[] sample = BuildSample();
+        var reader = new EventColumnStoreReader(s_logId, EventColumnStore.Build(sample, Generation, ContentVersion));
 
         Assert.Throws<ArgumentOutOfRangeException>(
-            () => reader.CopyInt64Column(EventFieldId.Level, new long[corpus.Length], new bool[corpus.Length]));
+            () => reader.CopyInt64Column(EventFieldId.Level, new long[sample.Length], new bool[sample.Length]));
         Assert.Throws<ArgumentOutOfRangeException>(
-            () => reader.CopyGuidColumn(EventFieldId.Id, new Guid[corpus.Length], new bool[corpus.Length]));
+            () => reader.CopyGuidColumn(EventFieldId.Id, new Guid[sample.Length], new bool[sample.Length]));
         Assert.Throws<ArgumentOutOfRangeException>(
-            () => reader.CopyPoolIndexColumn(EventFieldId.RecordId, new int[corpus.Length]));
+            () => reader.CopyPoolIndexColumn(EventFieldId.RecordId, new int[sample.Length]));
     }
 
     [Fact]
     public void CopyPoolIndexColumn_KeywordsDisplay_Throws()
     {
-        ResolvedEvent[] corpus = BuildCorpus();
-        var reader = new EventColumnStoreReader(s_logId, EventColumnStore.Build(corpus, Generation, ContentVersion));
+        ResolvedEvent[] sample = BuildSample();
+        var reader = new EventColumnStoreReader(s_logId, EventColumnStore.Build(sample, Generation, ContentVersion));
 
         Assert.Throws<ArgumentOutOfRangeException>(
-            () => reader.CopyPoolIndexColumn(EventFieldId.KeywordsDisplay, new int[corpus.Length]));
+            () => reader.CopyPoolIndexColumn(EventFieldId.KeywordsDisplay, new int[sample.Length]));
     }
 
     private static void AssertBulkColumnParity(IEventColumnReader reader)
@@ -190,7 +172,28 @@ private static void AssertBulkColumnParity(IEventColumnReader reader)
         }
     }
 
-    private static ResolvedEvent[] BuildCorpus() =>
+    private static ResolvedEvent[] BuildNovelPendingSample() =>
+    [
+        new ResolvedEvent("NovelPendingLog", LogPathType.Channel)
+        {
+            Id = 500,
+            TimeCreated = s_time.AddHours(1),
+            Level = "NovelPendingLevel",
+            ComputerName = "NovelPendingHost",
+            Source = "NovelPendingSource",
+            TaskCategory = "NovelPendingTask",
+            LogName = "NovelPendingName",
+            Description = "NovelPendingDescription",
+            Xml = "<NovelPendingXml />",
+            UserId = new SecurityIdentifier("S-1-5-21-9-9-9-9999"),
+            RecordId = 900L,
+            ActivityId = Guid.Parse("55555555-5555-5555-5555-555555555555"),
+            ProcessId = 909,
+            ThreadId = 808
+        }
+    ];
+
+    private static ResolvedEvent[] BuildSample() =>
     [
         new ResolvedEvent("Security", LogPathType.Channel)
         {
@@ -211,7 +214,6 @@ private static ResolvedEvent[] BuildCorpus() =>
             Keywords = ["Audit Success", "Classic"]
         },
 
-        // Absent nullables, null UserId, empty pooled fields.
         new ResolvedEvent("Application", LogPathType.Channel)
         {
             Id = 1000,
@@ -219,7 +221,6 @@ private static ResolvedEvent[] BuildCorpus() =>
             Level = "Error"
         },
 
-        // Shares pooled values with the first row (dedups in the pool) but distinct scalars.
         new ResolvedEvent("Security", LogPathType.Channel)
         {
             Id = 7,
@@ -248,26 +249,4 @@ private static ResolvedEvent[] BuildCorpus() =>
             ThreadId = 22
         }
     ];
-
-    private static ResolvedEvent[] BuildNovelPendingCorpus() =>
-    [
-        // Pooled strings that never appear in BuildCorpus, so the sealed pool cannot index them.
-        new ResolvedEvent("NovelPendingLog", LogPathType.Channel)
-        {
-            Id = 500,
-            TimeCreated = s_time.AddHours(1),
-            Level = "NovelPendingLevel",
-            ComputerName = "NovelPendingHost",
-            Source = "NovelPendingSource",
-            TaskCategory = "NovelPendingTask",
-            LogName = "NovelPendingName",
-            Description = "NovelPendingDescription",
-            Xml = "<NovelPendingXml />",
-            UserId = new SecurityIdentifier("S-1-5-21-9-9-9-9999"),
-            RecordId = 900L,
-            ActivityId = Guid.Parse("55555555-5555-5555-5555-555555555555"),
-            ProcessId = 909,
-            ThreadId = 808
-        }
-    ];
 }
diff --git a/tests/Unit/EventLogExpert.Eventing.Tests/Common/Events/EventColumnStoreEventDataTests.cs b/tests/Unit/EventLogExpert.Eventing.Tests/Common/Events/EventColumnStoreEventDataTests.cs
index 22d206adb..c3dc1e557 100644
--- a/tests/Unit/EventLogExpert.Eventing.Tests/Common/Events/EventColumnStoreEventDataTests.cs
+++ b/tests/Unit/EventLogExpert.Eventing.Tests/Common/Events/EventColumnStoreEventDataTests.cs
@@ -16,75 +16,23 @@ public sealed class EventColumnStoreEventDataTests
     private static readonly string[] s_updateProviders = [WuClient, "Microsoft-Windows-Servicing"];
     private static readonly string[] s_errorCodeUserDataPaths = ["CbsPackageChangeState/ErrorCode", "CbsUpdateChangeState/ErrorCode"];
 
-    [Fact]
-    public void BucketTimeTicksByEventData_ClassifiesRowsByCodeWithOtherForNonTargets()
-    {
-        IEventColumnReader reader = ReaderFor(
-            Event("LogonType", 3L),
-            Event("LogonType", 3L),
-            Event("LogonType", 10L),
-            Event("LogonType", 7L)); // 7 is not a target -> Other
-
-        long[] targetCodes = [3, 10];
-        int slotCount = targetCodes.Length + 1;
-        int[] slotCounts = new int[slotCount];
-        reader.BucketTimeTicksByEventData(AllSurvive(reader.Count), 0, long.MaxValue, 1, "LogonType", targetCodes, slotCounts, CancellationToken.None);
-
-        Assert.Equal(2, slotCounts[0]); // code 3
-        Assert.Equal(1, slotCounts[1]); // code 10
-        Assert.Equal(1, slotCounts[2]); // Other (code 7)
-    }
-
-    [Fact]
-    public void BucketTimeTicksByEventData_IsAllocationFreeOnSealedRows()
-    {
-        // EventColumnStore.Build seals the whole batch. One schema means the field-index memo resolves once, so the
-        // per-row path performs no allocation; only the fixed per-scan memo array (int[schemaCount]) is charged.
-        var events = new ResolvedEvent[8192];
-
-        for (int index = 0; index < events.Length; index++)
-        {
-            events[index] = Event("LogonType", index % 3 == 0 ? 3L : 10L, index);
-        }
-
-        IEventColumnReader reader = EventColumnStore.Build(events, generation: 0, contentVersion: 0).CreateReader(s_logId);
-        int[] rank = AllSurvive(reader.Count);
-        long[] targetCodes = [3, 10];
-        int[] slotCounts = new int[targetCodes.Length + 1];
-
-        // Warm: first scan resolves the schema and JITs.
-        reader.BucketTimeTicksByEventData(rank, 0, long.MaxValue, 1, "LogonType", targetCodes, slotCounts, CancellationToken.None);
-
-        long delta = long.MaxValue;
-
-        for (int iteration = 0; iteration < 16; iteration++)
-        {
-            long before = GC.GetAllocatedBytesForCurrentThread();
-            reader.BucketTimeTicksByEventData(rank, 0, long.MaxValue, 1, "LogonType", targetCodes, slotCounts, CancellationToken.None);
-            delta = Math.Min(delta, GC.GetAllocatedBytesForCurrentThread() - before);
-        }
-
-        // A single per-row byte would cost 8192; the fixed memo array is a few dozen bytes, so this proves the hot path is allocation-free.
-        Assert.True(delta < 512, $"Per-row allocation detected: {delta} bytes over {events.Length} sealed rows.");
-    }
-
     [Fact]
     public void BucketTimeTicksByEventDataHResult_ChartsServicingUserDataErrorCode_OmitsSuccessEmptyAndNoLeaf()
     {
         IEventColumnReader reader = ReaderFor(
             ServicingEvent("CbsPackageChangeState/ErrorCode", "0x800f0816"),
             ServicingEvent("CbsUpdateChangeState/ErrorCode", "0x800F0922"),
-            ServicingEvent("CbsPackageChangeState/ErrorCode", "0x0"),          // success
-            ServicingEvent("CbsUpdateChangeState/ErrorCode", ""),               // empty (event 7)
-            ServicingEvent("CbsPackageInitiateChanges/Client", "CbsTask"));     // no ErrorCode leaf (event 1)
+            ServicingEvent("CbsPackageChangeState/ErrorCode", "0x0"),
+            ServicingEvent("CbsUpdateChangeState/ErrorCode", ""),
+            ServicingEvent("CbsPackageInitiateChanges/Client", "CbsTask"));
 
         long[] targetCodes = [0x800F0816L, 0x800F0922L];
         int[] slotCounts = new int[targetCodes.Length + 1];
         reader.BucketTimeTicksByEventDataHResult(AllSurvive(reader.Count), 0, long.MaxValue, 1, "errorCode", s_updateProviders, s_errorCodeUserDataPaths, targetCodes, slotCounts, CancellationToken.None);
 
-        Assert.Equal(1, slotCounts[0]); // 0x800F0816 (CbsPackageChangeState)
-        Assert.Equal(1, slotCounts[1]); // 0x800F0922 (CbsUpdateChangeState)
-        Assert.Equal(0, slotCounts[2]); // success, empty, and the no-ErrorCode-leaf row are omitted
+        Assert.Equal(1, slotCounts[0]);
+        Assert.Equal(1, slotCounts[1]);
+        Assert.Equal(0, slotCounts[2]);
     }
 
     [Fact]
@@ -103,7 +51,7 @@ public void BucketTimeTicksByEventDataHResult_ClassifiesEligibleFailures_OmitsIn
 
         Assert.Equal(1, slotCounts[0]);
         Assert.Equal(1, slotCounts[1]);
-        Assert.Equal(1, slotCounts[2]); // Other holds only 0x80070005; the zero and ineligible rows are omitted, not bucketed
+        Assert.Equal(1, slotCounts[2]);
     }
 
     [Fact]
@@ -123,8 +71,6 @@ public void BucketTimeTicksByEventDataHResult_IsAllocationFreeOnSealedRows()
 
         reader.BucketTimeTicksByEventDataHResult(rank, 0, long.MaxValue, 1, "errorCode", s_updateProviders, s_errorCodeUserDataPaths, targetCodes, slotCounts, CancellationToken.None);
 
-        // Take the minimum allocation delta across steady-state iterations so a one-off tiered-JIT/background-GC
-        // charge on a single call cannot flake the assertion; a real per-row allocation persists in every iteration.
         long delta = long.MaxValue;
 
         for (int iteration = 0; iteration < 16; iteration++)
@@ -134,8 +80,6 @@ public void BucketTimeTicksByEventDataHResult_IsAllocationFreeOnSealedRows()
             delta = Math.Min(delta, GC.GetAllocatedBytesForCurrentThread() - before);
         }
 
-        // The eligible-index buffer is stack-allocated and the schema memo is a fixed per-scan array, so the per-row path is
-        // allocation-free; a single per-row byte would cost 8192.
         Assert.True(delta < 512, $"Per-row allocation detected: {delta} bytes over {events.Length} sealed rows.");
     }
 
@@ -166,11 +110,57 @@ public void BucketTimeTicksByEventDataString_UsesSameCandidateSelectionAsCounts(
         Assert.Equal(2, slotCounts[2]);
     }
 
+    [Fact]
+    public void BucketTimeTicksByEventData_ClassifiesRowsByCodeWithOtherForNonTargets()
+    {
+        IEventColumnReader reader = ReaderFor(
+            Event("LogonType", 3L),
+            Event("LogonType", 3L),
+            Event("LogonType", 10L),
+            Event("LogonType", 7L));
+
+        long[] targetCodes = [3, 10];
+        int slotCount = targetCodes.Length + 1;
+        int[] slotCounts = new int[slotCount];
+        reader.BucketTimeTicksByEventData(AllSurvive(reader.Count), 0, long.MaxValue, 1, "LogonType", targetCodes, slotCounts, CancellationToken.None);
+
+        Assert.Equal(2, slotCounts[0]);
+        Assert.Equal(1, slotCounts[1]);
+        Assert.Equal(1, slotCounts[2]);
+    }
+
+    [Fact]
+    public void BucketTimeTicksByEventData_IsAllocationFreeOnSealedRows()
+    {
+        var events = new ResolvedEvent[8192];
+
+        for (int index = 0; index < events.Length; index++)
+        {
+            events[index] = Event("LogonType", index % 3 == 0 ? 3L : 10L, index);
+        }
+
+        IEventColumnReader reader = EventColumnStore.Build(events, generation: 0, contentVersion: 0).CreateReader(s_logId);
+        int[] rank = AllSurvive(reader.Count);
+        long[] targetCodes = [3, 10];
+        int[] slotCounts = new int[targetCodes.Length + 1];
+
+        reader.BucketTimeTicksByEventData(rank, 0, long.MaxValue, 1, "LogonType", targetCodes, slotCounts, CancellationToken.None);
+
+        long delta = long.MaxValue;
+
+        for (int iteration = 0; iteration < 16; iteration++)
+        {
+            long before = GC.GetAllocatedBytesForCurrentThread();
+            reader.BucketTimeTicksByEventData(rank, 0, long.MaxValue, 1, "LogonType", targetCodes, slotCounts, CancellationToken.None);
+            delta = Math.Min(delta, GC.GetAllocatedBytesForCurrentThread() - before);
+        }
+
+        Assert.True(delta < 512, $"Per-row allocation detected: {delta} bytes over {events.Length} sealed rows.");
+    }
+
     [Fact]
     public void CountEventDataHResults_CaseInsensitiveAllowlist_IsNormalizedToOrdinal()
     {
-        // A caller-supplied OrdinalIgnoreCase set must be normalized to ordinal so pending matching stays case-sensitive like
-        // the sealed pool lookup; otherwise a case-variant provider would match pending rows but not sealed rows.
         var caseInsensitive = new HashSet<string>([WuClient], StringComparer.OrdinalIgnoreCase);
         ResolvedEvent[] events =
         [
@@ -199,7 +189,7 @@ public void CountEventDataHResults_FoldsHexAndDecimalStringSpellings()
     {
         IEventColumnReader reader = ReaderFor(
             UpdateEvent(WuClient, "0x800F081F"),
-            UpdateEvent(WuClient, "2148468767")); // decimal spelling of 0x800F081F
+            UpdateEvent(WuClient, "2148468767"));
 
         var counts = new Dictionary<long, int>();
         reader.CountEventDataHResults(AllSurvive(reader.Count), "errorCode", s_updateProviders, s_errorCodeUserDataPaths, counts, CancellationToken.None);
@@ -211,7 +201,6 @@ public void CountEventDataHResults_FoldsHexAndDecimalStringSpellings()
     [Fact]
     public void CountEventDataHResults_IsAllocationFreeOnPendingRows()
     {
-        // Stay below TargetChunkSize so Append leaves every row pending (unsealed), exercising the pending provider-match path.
         var events = new ResolvedEvent[3000];
 
         for (int index = 0; index < events.Length; index++)
@@ -237,7 +226,6 @@ public void CountEventDataHResults_IsAllocationFreeOnPendingRows()
             delta = Math.Min(delta, GC.GetAllocatedBytesForCurrentThread() - before);
         }
 
-        // The pending provider match uses a scan-local set built once, not a per-row enumerator (which cost 32 bytes x 3000).
         Assert.True(delta < 4096, $"Per-row allocation detected on pending rows: {delta} bytes over {events.Length} rows.");
     }
 
@@ -272,7 +260,6 @@ public void CountEventDataHResults_ReadsSignExtendedNegativeHexInt32()
     [Fact]
     public void CountEventDataHResults_ServicingUserData_OmitsNonTargetErrorCodePath()
     {
-        // The dimension keys on the two curated Cbs* paths, not any */ErrorCode leaf; an unlisted template is omitted.
         IEventColumnReader reader = ReaderFor(
             ServicingEvent("SomeOtherTemplate/ErrorCode", "0x800f0816"),
             ServicingEvent("CbsPackageChangeState/ErrorCode", "0x800F0922"));
@@ -288,14 +275,12 @@ public void CountEventDataHResults_ServicingUserData_OmitsNonTargetErrorCodePath
     [Fact]
     public void CountEventDataHResults_ServicingUserData_PathMatchIsOrdinal_SealedAndPendingOmitCaseVariant()
     {
-        // Storage keys are canonical, so the sealed pool-index compare is exact; the pending mirror must be ordinal too,
-        // or a case-variant path would chart on one store but not the other. Both must omit it.
         foreach (bool sealRows in new[] { true, false })
         {
-            ResolvedEvent[] corpus = [ServicingEvent("cbspackagechangestate/errorcode", "0x800f0816")];
+            ResolvedEvent[] sample = [ServicingEvent("cbspackagechangestate/errorcode", "0x800f0816")];
             EventColumnStore store = sealRows
-                ? EventColumnStore.Build(corpus, generation: 0, contentVersion: 0)
-                : EventColumnStore.Build([], generation: 0, contentVersion: 0).Append(corpus);
+                ? EventColumnStore.Build(sample, generation: 0, contentVersion: 0)
+                : EventColumnStore.Build([], generation: 0, contentVersion: 0).Append(sample);
             IEventColumnReader reader = store.CreateReader(s_logId);
 
             var counts = new Dictionary<long, int>();
@@ -308,14 +293,12 @@ public void CountEventDataHResults_ServicingUserData_PathMatchIsOrdinal_SealedAn
     [Fact]
     public void CountEventDataHResults_ServicingUserData_ResolvesTargetPathInternedInLaterChunk()
     {
-        // The target UserData path is interned only by the final row, which lands in a later sealed chunk (Build chunks at
-        // 4096 rows); resolving it once against the shared store pool must still find it so the multi-chunk scan charts it.
         const int chunkSize = 4096;
         var events = new ResolvedEvent[chunkSize + 1];
 
         for (int index = 0; index < chunkSize; index++)
         {
-            events[index] = UpdateEvent(WuClient, 0, index); // WUClient success rows fill the first chunk (no Servicing path)
+            events[index] = UpdateEvent(WuClient, 0, index);
         }
 
         events[chunkSize] = ServicingEvent("CbsPackageChangeState/ErrorCode", "0x800f0816", chunkSize);
@@ -334,15 +317,15 @@ public void CountEventDataHResults_ServicingUserData_SealedAndPending_ChartFailu
     {
         foreach (bool sealRows in new[] { true, false })
         {
-            ResolvedEvent[] corpus =
+            ResolvedEvent[] sample =
             [
                 ServicingEvent("CbsPackageChangeState/ErrorCode", "0x800f0816"),
                 ServicingEvent("CbsUpdateChangeState/ErrorCode", "0x800F0922", 1),
                 ServicingEvent("CbsPackageChangeState/ErrorCode", "0x0", 2)
             ];
             EventColumnStore store = sealRows
-                ? EventColumnStore.Build(corpus, generation: 0, contentVersion: 0)
-                : EventColumnStore.Build([], generation: 0, contentVersion: 0).Append(corpus);
+                ? EventColumnStore.Build(sample, generation: 0, contentVersion: 0)
+                : EventColumnStore.Build([], generation: 0, contentVersion: 0).Append(sample);
             IEventColumnReader reader = store.CreateReader(s_logId);
 
             var counts = new Dictionary<long, int>();
@@ -377,10 +360,6 @@ public void CountEventDataStringValues_FallsThroughUnusableOrNonStringCandidates
     [Fact]
     public void CountEventDataStringValues_NonStringReferenceRejectedConsistently()
     {
-        // An exotic EventData reference (a boxed Int64 here; EvtVariantType.Handle -> EvtHandle in the wild) renders as
-        // EventFieldValueKind.String while the row is pending (FromProperty stringifies unrecognized references) but seals
-        // as StoredFieldKind.StringForm. The dimension groups only genuine native strings, so such a value must be rejected
-        // on BOTH paths - never grouped in the live view and then dropped (or the reverse) once its chunk seals.
         ResolvedEvent schemaCarrier = new ResolvedEvent("TestLog", LogPathType.Channel) { Id = 4688, TimeCreated = new DateTime(0, DateTimeKind.Utc) }
             .WithEventData(("NewProcessName", "placeholder"));
         ResolvedEvent exoticReferenceEvent = schemaCarrier with { EventDataValues = [EventProperty.FromReference(42L)] };
@@ -431,7 +410,7 @@ public void CountEventDataValues_FoldsDecimalAndHexSpellingsOfOneCode()
         reader.CountEventDataValues(AllSurvive(reader.Count), "TicketEncryptionType", counts, CancellationToken.None);
 
         Assert.Equal(2, counts.Count);
-        Assert.Equal(2, counts[23]); // decimal 23 and hex "0x17" fold to the same code
+        Assert.Equal(2, counts[23]);
         Assert.Equal(1, counts[18]);
     }
 
@@ -450,7 +429,6 @@ public void CountEventDataValues_OmitsRowsThatLackTheField()
     [Fact]
     public void CountEventDataValues_ReadsUnsignedIntegralCodes()
     {
-        // A UInt32-typed value exercises the unsigned direct-read branch and must fold with the signed Int64 spelling of the same code.
         IEventColumnReader reader = ReaderFor(Event("LogonType", (uint)3), Event("LogonType", 3L));
 
         var counts = new Dictionary<long, int>();
@@ -463,7 +441,6 @@ public void CountEventDataValues_ReadsUnsignedIntegralCodes()
     [Fact]
     public void CountEventDataValues_RejectsHexCodeThatOverflowsALong()
     {
-        // A high-bit hex form must not wrap to a negative code (-1) and fold with a real code.
         IEventColumnReader reader = ReaderFor(Event("TicketEncryptionType", "0xFFFFFFFFFFFFFFFF"), Event("TicketEncryptionType", 23L));
 
         var counts = new Dictionary<long, int>();
@@ -477,8 +454,6 @@ public void CountEventDataValues_RejectsHexCodeThatOverflowsALong()
     [Fact]
     public void HResultScans_MixedEventDataAndUserData_CountAndBucketAgree()
     {
-        // A WUClient EventData errorCode and a Servicing UserData ErrorCode in one store both chart; the EventData-first /
-        // UserData-fallback contributes exactly one slot per row, so the bucket sum equals the count total.
         IEventColumnReader reader = ReaderFor(
             UpdateEvent(WuClient, unchecked((int)0x800F081Fu)),
             ServicingEvent("CbsPackageChangeState/ErrorCode", "0x800f0816", 1));
diff --git a/tests/Unit/EventLogExpert.Eventing.Tests/Common/Events/EventColumnStoreReaderParityTests.cs b/tests/Unit/EventLogExpert.Eventing.Tests/Common/Events/EventColumnStoreReaderParityTests.cs
deleted file mode 100644
index e12ebc56f..000000000
--- a/tests/Unit/EventLogExpert.Eventing.Tests/Common/Events/EventColumnStoreReaderParityTests.cs
+++ /dev/null
@@ -1,596 +0,0 @@
-// // Copyright (c) Microsoft Corporation.
-// // Licensed under the MIT License.
-
-using EventLogExpert.Eventing.Common.Channels;
-using EventLogExpert.Eventing.Common.EventLogs;
-using EventLogExpert.Eventing.Common.Events;
-using EventLogExpert.Eventing.Readers;
-using EventLogExpert.Eventing.Resolvers;
-using EventLogExpert.Eventing.Structured;
-using EventLogExpert.Eventing.TestUtils;
-using System.Collections.Immutable;
-using System.Security;
-using System.Security.Principal;
-
-namespace EventLogExpert.Eventing.Tests.Common.Events;
-
-public sealed class EventColumnStoreReaderParityTests
-{
-    private const long ContentVersion = 42;
-    private const int Generation = 3;
-
-    private static readonly EventLogId s_logId = EventLogId.Create();
-
-    // Every corpus event stamps TimeCreated as Utc: the column store always reconstructs TimeCreated with
-    // DateTimeKind.Utc, and EventFieldValue.AsString() renders a Utc DateTime with a trailing "Z" (round ("O") format),
-    // so an Unspecified-kind source would diverge only in the suffix and break differential parity.
-    private static readonly DateTime s_time = new(2021, 6, 15, 10, 20, 30, DateTimeKind.Utc);
-
-    [Fact]
-    public void EnumerateEventData_PendingRows_MatchLegacyReader()
-    {
-        (IEventColumnReader legacy, IEventColumnReader column, ResolvedEvent[] corpus) = BuildPending();
-
-        AssertEventDataEnumerationParity(legacy, column, corpus.Length);
-    }
-
-    [Fact]
-    public void EnumerateEventData_SealedRows_MatchLegacyReader()
-    {
-        (IEventColumnReader legacy, IEventColumnReader column, ResolvedEvent[] corpus) = BuildSealed();
-
-        AssertEventDataEnumerationParity(legacy, column, corpus.Length);
-    }
-
-    [Fact]
-    public void EnumerateUserData_PendingRows_MatchLegacyReader()
-    {
-        (IEventColumnReader legacy, IEventColumnReader column, ResolvedEvent[] corpus) = BuildPending();
-
-        AssertUserDataEnumerationParity(legacy, column, corpus.Length);
-    }
-
-    [Fact]
-    public void EnumerateUserData_SealedRows_MatchLegacyReader()
-    {
-        (IEventColumnReader legacy, IEventColumnReader column, ResolvedEvent[] corpus) = BuildSealed();
-
-        AssertUserDataEnumerationParity(legacy, column, corpus.Length);
-    }
-
-    [Fact]
-    public void GetField_ForeignLogIdLocator_ThrowsArgumentException()
-    {
-        (IEventColumnReader legacy, IEventColumnReader column, _) = BuildSealed();
-        EventLocator foreign = new(EventLogId.Create(), column.Generation, 0);
-
-        Assert.Throws<ArgumentException>(() => column.GetField(foreign, EventFieldId.Id));
-        Assert.Throws<ArgumentException>(() => legacy.GetField(foreign, EventFieldId.Id));
-    }
-
-    [Fact]
-    public void GetField_PendingRowsForEveryFieldId_MatchLegacyReader()
-    {
-        (IEventColumnReader legacy, IEventColumnReader column, ResolvedEvent[] corpus) = BuildPending();
-
-        AssertGetFieldParity(legacy, column, corpus.Length);
-    }
-
-    [Fact]
-    public void GetField_SealedRowsForEveryFieldId_MatchLegacyReader()
-    {
-        (IEventColumnReader legacy, IEventColumnReader column, ResolvedEvent[] corpus) = BuildSealed();
-
-        AssertGetFieldParity(legacy, column, corpus.Length);
-    }
-
-    [Fact]
-    public void GetField_StaleGenerationLocator_ThrowsArgumentException()
-    {
-        (IEventColumnReader legacy, IEventColumnReader column, _) = BuildSealed();
-        EventLocator stale = new(column.LogId, column.Generation + 1, 0);
-
-        Assert.Throws<ArgumentException>(() => column.GetField(stale, EventFieldId.Id));
-        Assert.Throws<ArgumentException>(() => legacy.GetField(stale, EventFieldId.Id));
-    }
-
-    [Fact]
-    public void GetKeywords_PendingRows_MatchLegacyReader()
-    {
-        (IEventColumnReader legacy, IEventColumnReader column, ResolvedEvent[] corpus) = BuildPending();
-
-        AssertKeywordsParity(legacy, column, corpus.Length);
-    }
-
-    [Fact]
-    public void GetKeywords_SealedRows_MatchLegacyReader()
-    {
-        (IEventColumnReader legacy, IEventColumnReader column, ResolvedEvent[] corpus) = BuildSealed();
-
-        AssertKeywordsParity(legacy, column, corpus.Length);
-    }
-
-    [Fact]
-    public void GetUserData_PendingRowsForEveryProbeKey_MatchLegacyReader()
-    {
-        (IEventColumnReader legacy, IEventColumnReader column, ResolvedEvent[] corpus) = BuildPending();
-
-        AssertUserDataParity(legacy, column, corpus);
-    }
-
-    [Fact]
-    public void GetUserData_SealedRowsForEveryProbeKey_MatchLegacyReader()
-    {
-        (IEventColumnReader legacy, IEventColumnReader column, ResolvedEvent[] corpus) = BuildSealed();
-
-        AssertUserDataParity(legacy, column, corpus);
-    }
-
-    [Fact]
-    public void GetUserDataIncomplete_PendingRows_MatchLegacyReader()
-    {
-        (IEventColumnReader legacy, IEventColumnReader column, ResolvedEvent[] corpus) = BuildPending();
-
-        AssertUserDataIncompleteParity(legacy, column, corpus.Length);
-    }
-
-    [Fact]
-    public void GetUserDataIncomplete_SealedRows_MatchLegacyReader()
-    {
-        (IEventColumnReader legacy, IEventColumnReader column, ResolvedEvent[] corpus) = BuildSealed();
-
-        AssertUserDataIncompleteParity(legacy, column, corpus.Length);
-    }
-
-    [Fact]
-    public void HResultScans_SealedAndPending_MatchLegacyReader()
-    {
-        string[] providers = ["Microsoft-Windows-WindowsUpdateClient", "Microsoft-Windows-Servicing"];
-        string[] userDataPaths = ["CbsPackageChangeState/ErrorCode", "CbsUpdateChangeState/ErrorCode"];
-        long[] targetCodes = [0x800F0823L, 0x800F081FL];
-
-        foreach (bool sealRows in new[] { true, false })
-        {
-            (IEventColumnReader legacy, IEventColumnReader column) = BuildErrorCodeReaders(sealRows);
-            int[] rank = AllSurvive(legacy.Count);
-
-            var legacyCounts = new Dictionary<long, int>();
-            var columnCounts = new Dictionary<long, int>();
-            legacy.CountEventDataHResults(rank, "errorCode", providers, userDataPaths, legacyCounts, CancellationToken.None);
-            column.CountEventDataHResults(rank, "errorCode", providers, userDataPaths, columnCounts, CancellationToken.None);
-            Assert.Equal(legacyCounts.OrderBy(pair => pair.Key), columnCounts.OrderBy(pair => pair.Key));
-
-            int[] legacySlots = new int[targetCodes.Length + 1];
-            int[] columnSlots = new int[targetCodes.Length + 1];
-            legacy.BucketTimeTicksByEventDataHResult(rank, 0, long.MaxValue, 1, "errorCode", providers, userDataPaths, targetCodes, legacySlots, CancellationToken.None);
-            column.BucketTimeTicksByEventDataHResult(rank, 0, long.MaxValue, 1, "errorCode", providers, userDataPaths, targetCodes, columnSlots, CancellationToken.None);
-            Assert.Equal(legacySlots, columnSlots);
-        }
-    }
-
-    [Fact]
-    public void Surface_PendingStore_MatchesLegacyReader()
-    {
-        (IEventColumnReader legacy, IEventColumnReader column, _) = BuildPending();
-
-        AssertSurfaceParity(legacy, column);
-    }
-
-    [Fact]
-    public void Surface_SealedStore_MatchesLegacyReader()
-    {
-        (IEventColumnReader legacy, IEventColumnReader column, _) = BuildSealed();
-
-        AssertSurfaceParity(legacy, column);
-    }
-
-    [Fact]
-    public void TryGetEventData_PendingRowsForEveryProbeName_MatchLegacyReader()
-    {
-        (IEventColumnReader legacy, IEventColumnReader column, ResolvedEvent[] corpus) = BuildPending();
-
-        AssertEventDataParity(legacy, column, corpus);
-    }
-
-    [Fact]
-    public void TryGetEventData_SealedRowsForEveryProbeName_MatchLegacyReader()
-    {
-        (IEventColumnReader legacy, IEventColumnReader column, ResolvedEvent[] corpus) = BuildSealed();
-
-        AssertEventDataParity(legacy, column, corpus);
-    }
-
-    private static int[] AllSurvive(int count)
-    {
-        int[] rank = new int[count];
-
-        for (int index = 0; index < count; index++) { rank[index] = index; }
-
-        return rank;
-    }
-
-    private static void AssertEventDataEnumerationParity(IEventColumnReader legacy, IEventColumnReader column, int count)
-    {
-        for (int index = 0; index < count; index++)
-        {
-            List<(string Name, EventFieldValueKind Kind, string Value)> expected = MaterializeEventData(legacy, legacy.LocatorAt(index));
-            List<(string Name, EventFieldValueKind Kind, string Value)> actual = MaterializeEventData(column, column.LocatorAt(index));
-
-            Assert.Equal(expected, actual);
-        }
-    }
-
-    private static void AssertEventDataParity(IEventColumnReader legacy, IEventColumnReader column, ResolvedEvent[] corpus)
-    {
-        List<string> probeNames = CollectEventDataNames(corpus);
-
-        for (int index = 0; index < corpus.Length; index++)
-        {
-            foreach (string name in probeNames)
-            {
-                bool expectedFound = legacy.TryGetEventData(legacy.LocatorAt(index), name, out EventFieldValue expected);
-                bool actualFound = column.TryGetEventData(column.LocatorAt(index), name, out EventFieldValue actual);
-
-                Assert.Equal(expectedFound, actualFound);
-                Assert.Equal(expected.Kind, actual.Kind);
-                Assert.Equal(expected.AsString(), actual.AsString());
-            }
-        }
-    }
-
-    private static void AssertGetFieldParity(IEventColumnReader legacy, IEventColumnReader column, int count)
-    {
-        foreach (EventFieldId field in Enum.GetValues<EventFieldId>())
-        {
-            for (int index = 0; index < count; index++)
-            {
-                EventFieldValue expected = legacy.GetField(legacy.LocatorAt(index), field);
-                EventFieldValue actual = column.GetField(column.LocatorAt(index), field);
-
-                Assert.Equal(expected.Kind, actual.Kind);
-                Assert.Equal(expected.AsString(), actual.AsString());
-            }
-        }
-    }
-
-    private static void AssertKeywordsParity(IEventColumnReader legacy, IEventColumnReader column, int count)
-    {
-        for (int index = 0; index < count; index++)
-        {
-            IReadOnlyList<string> expected = legacy.GetKeywords(legacy.LocatorAt(index));
-            IReadOnlyList<string> actual = column.GetKeywords(column.LocatorAt(index));
-
-            Assert.Equal(expected, actual);
-        }
-    }
-
-    private static void AssertSurfaceParity(IEventColumnReader legacy, IEventColumnReader column)
-    {
-        Assert.Equal(legacy.LogId, column.LogId);
-        Assert.Equal(legacy.Generation, column.Generation);
-        Assert.Equal(legacy.ContentVersion, column.ContentVersion);
-        Assert.Equal(legacy.Count, column.Count);
-    }
-
-    private static void AssertUserDataEnumerationParity(IEventColumnReader legacy, IEventColumnReader column, int count)
-    {
-        for (int index = 0; index < count; index++)
-        {
-            List<(string Path, EventFieldValueKind Kind, string Value, bool Truncated, bool Absent)> expected =
-                MaterializeUserData(legacy, legacy.LocatorAt(index));
-            List<(string Path, EventFieldValueKind Kind, string Value, bool Truncated, bool Absent)> actual =
-                MaterializeUserData(column, column.LocatorAt(index));
-
-            Assert.Equal(expected, actual);
-        }
-    }
-
-    private static void AssertUserDataIncompleteParity(IEventColumnReader legacy, IEventColumnReader column, int count)
-    {
-        for (int index = 0; index < count; index++)
-        {
-            Assert.Equal(
-                legacy.GetUserDataIncomplete(legacy.LocatorAt(index)),
-                column.GetUserDataIncomplete(column.LocatorAt(index)));
-        }
-    }
-
-    private static void AssertUserDataParity(IEventColumnReader legacy, IEventColumnReader column, ResolvedEvent[] corpus)
-    {
-        List<string> probeKeys = CollectUserDataKeys(corpus);
-
-        for (int index = 0; index < corpus.Length; index++)
-        {
-            foreach (string key in probeKeys)
-            {
-                StructuredFieldResult expected = legacy.GetUserData(legacy.LocatorAt(index), key);
-                StructuredFieldResult actual = column.GetUserData(column.LocatorAt(index), key);
-
-                Assert.Equal(expected.IsAbsent, actual.IsAbsent);
-                Assert.Equal(expected.IsTruncated, actual.IsTruncated);
-                Assert.Equal(expected.PresentValues.ToArray(), actual.PresentValues.ToArray());
-            }
-        }
-    }
-
-    private static ResolvedEvent[] BuildCorpus() =>
-    [
-        // Fully populated scalars, non-null UserId, many keywords, and every side column present (keywords + UserData +
-        // named EventData) so the chunk's per-row offset arithmetic is exercised on a dense row.
-        new ResolvedEvent("Security", LogPathType.Channel)
-        {
-            Id = 4624,
-            TimeCreated = s_time,
-            Level = "Information",
-            ComputerName = "PC1",
-            Source = "Microsoft-Windows-Security-Auditing",
-            TaskCategory = "Logon",
-            Opcode = "Start",
-            LogName = "Security",
-            Description = "An account was logged on.",
-            Xml = "<Event><System /></Event>",
-            UserId = new SecurityIdentifier("S-1-5-18"),
-            RecordId = 99L,
-            ActivityId = Guid.Parse("33333333-3333-3333-3333-333333333333"),
-            RelatedActivityId = Guid.Parse("44444444-4444-4444-4444-444444444444"),
-            ProcessId = 1234,
-            ThreadId = 5678,
-            Keywords = ["Audit Success", "Classic"],
-            UserData = ImmutableArray.Create(new UserDataField("Logon/@type", ImmutableArray.Create("2"), IsTruncated: false))
-        }.WithEventData(("Operation", "Read"), ("Count", 3), ("Succeeded", true)),
-
-        // Absent nullables, null UserId, zero keywords, empty pooled fields, no EventData.
-        new ResolvedEvent("Application", LogPathType.Channel)
-        {
-            Id = 1000,
-            TimeCreated = s_time,
-            Level = "Error"
-        },
-
-        // Exactly one keyword.
-        new ResolvedEvent("System", LogPathType.Channel)
-        {
-            Id = 7,
-            TimeCreated = s_time,
-            Keywords = ["Classic"]
-        },
-
-        // Multi-field UserData with one truncated field (event-level UserDataIncomplete stays false).
-        new ResolvedEvent("live", LogPathType.Channel)
-        {
-            Id = 11,
-            TimeCreated = s_time,
-            UserData = ImmutableArray.Create(
-                new UserDataField("Result/@value", ImmutableArray.Create("ok", "retry"), IsTruncated: true),
-                new UserDataField("Target", ImmutableArray.Create("svc"), IsTruncated: false))
-        },
-
-        // UserDataIncomplete = true with a present field: a matched field's truncation ORs in the event-level flag, and
-        // an absent key yields the present-but-empty truncated result rather than a decisive no-match.
-        new ResolvedEvent("live", LogPathType.Channel)
-        {
-            Id = 12,
-            TimeCreated = s_time,
-            UserData = ImmutableArray.Create(new UserDataField("Path", ImmutableArray.Create("v1"), IsTruncated: false)),
-            UserDataIncomplete = true
-        },
-
-        // EventData covering every StoredFieldKind, including StringForm via a non-array unknown reference that degrades
-        // to its pooled string form (not an array).
-        WithNamedProperties(
-            new ResolvedEvent("live", LogPathType.Channel) { Id = 20, TimeCreated = s_time },
-            ("f00", (sbyte)-5),
-            ("f01", (byte)200),
-            ("f02", (short)-300),
-            ("f03", (ushort)400),
-            ("f04", -70000),
-            ("f05", 80000u),
-            ("f06", -5_000_000_000L),
-            ("f07", 9_000_000_000UL),
-            ("f08", 3.5f),
-            ("f09", 2.5d),
-            ("f10", true),
-            ("f11", new DateTime(2022, 3, 4, 5, 6, 7, DateTimeKind.Utc)),
-            ("f12", (nuint)77),
-            ("f13", (EventProperty)"hello"),
-            ("f14", (EventProperty)new SecurityIdentifier("S-1-5-32-544")),
-            ("f15", Guid.Parse("22222222-2222-2222-2222-222222222222")),
-            ("f16", (EventProperty)(byte[])[1, 2, 3, 4]),
-            ("f17", EventProperty.FromReference(new ushort[] { 7, 8, 9 })),
-            ("f18", EventProperty.FromReference(new uint[] { 10, 11 })),
-            ("f19", EventProperty.FromReference(new[] { -1, -2 })),
-            ("f20", (EventProperty)(string[])["alice", "bob"]),
-            ("f21", EventProperty.FromReference(null)),
-            ("f22", EventProperty.FromReference(new UnknownReference()))),
-
-        // Fail-closed: a non-null schema whose value count matches neither the visible (2) nor the all (3) ordering, so
-        // named access is disabled (schema id -1) even though the values are stored positionally.
-        WithRawSchema(
-            new ResolvedEvent("live", LogPathType.Channel) { Id = 30, TimeCreated = s_time },
-            new TemplateFieldSchema(["a", "b", "c"], ["a", "b"]),
-            "v1", "v2", "v3", "v4"),
-
-        // No schema but with values: named access is disabled, values remain positional.
-        WithRawSchema(
-            new ResolvedEvent("live", LogPathType.Channel) { Id = 31, TimeCreated = s_time },
-            schema: null,
-            "v1", "v2"),
-
-        // Duplicate EventData name: the first index wins for the shared name.
-        new ResolvedEvent("live", LogPathType.Channel) { Id = 40, TimeCreated = s_time }
-            .WithEventData(("Dup", "first"), ("Dup", "second"), ("Other", "x")),
-
-        // Length-provider schema (AllNames longer than VisibleNames) with a value count matching the all ordering: the
-        // provider name resolves under the all ordering.
-        WithRawSchema(
-            new ResolvedEvent("live", LogPathType.Channel) { Id = 50, TimeCreated = s_time },
-            new TemplateFieldSchema(["visA", "visB", "LengthProvider"], ["visA", "visB"]),
-            "a", "b", "len"),
-
-        // Same length-provider schema with a value count matching the visible ordering: the provider name is not
-        // resolvable, exactly as the visible ordering excludes it.
-        WithRawSchema(
-            new ResolvedEvent("live", LogPathType.Channel) { Id = 51, TimeCreated = s_time },
-            new TemplateFieldSchema(["visA", "visB", "LengthProvider"], ["visA", "visB"]),
-            "a", "b"),
-
-        // Positional-empty EventData field NAME at a middle position (design-required "positional-empty node" edge): both
-        // readers must yield the ("", value) pair at that position, keeping the enumerated name sequence at parity.
-        WithRawSchema(
-            new ResolvedEvent("live", LogPathType.Channel) { Id = 60, TimeCreated = s_time },
-            new TemplateFieldSchema(["a", "", "c"], ["a", "", "c"]),
-            "v0", "v1", "v2")
-    ];
-
-    private static ResolvedEvent[] BuildErrorCodeCorpus() =>
-    [
-        ErrorCodeEvent("Microsoft-Windows-WindowsUpdateClient", unchecked((int)0x800F0823u), 0),
-        ErrorCodeEvent("Microsoft-Windows-Servicing", "0x800F081F", 1),
-        ErrorCodeEvent("Microsoft-Windows-WindowsUpdateClient", 0, 2),
-        ErrorCodeEvent("Microsoft-Windows-WindowsUpdateClient", unchecked((int)0x80070005u), 3),
-        new ResolvedEvent("TestLog", LogPathType.Channel) { Id = 44, Source = "Microsoft-Windows-WindowsUpdateClient", TimeCreated = s_time.AddMinutes(4) },
-        ErrorCodeEvent("Some-Other-Provider", unchecked((int)0x800F0823u), 5),
-        // Servicing rows carry their code in UserData, not EventData: a package failure, a success (0x0, omitted),
-        // and a selectable-update failure - so the parity oracle and the store must agree on the UserData fallback.
-        ServicingUserDataEvent("CbsPackageChangeState/ErrorCode", "0x800f0816", 6),
-        ServicingUserDataEvent("CbsPackageChangeState/ErrorCode", "0x0", 7),
-        ServicingUserDataEvent("CbsUpdateChangeState/ErrorCode", "0x800F0922", 8)
-    ];
-
-    private static (IEventColumnReader Legacy, IEventColumnReader Column) BuildErrorCodeReaders(bool sealRows)
-    {
-        ResolvedEvent[] corpus = BuildErrorCodeCorpus();
-        EventColumnStore store = sealRows
-            ? EventColumnStore.Build(corpus, Generation, ContentVersion)
-            : EventColumnStore.Build([], Generation, ContentVersion).Append(corpus);
-
-        return (new LegacyEventColumnReader(s_logId, store.Generation, store.ContentVersion, corpus), new EventColumnStoreReader(s_logId, store));
-    }
-
-    private static (IEventColumnReader Legacy, IEventColumnReader Column, ResolvedEvent[] Corpus) BuildPending()
-    {
-        ResolvedEvent[] corpus = BuildCorpus();
-        EventColumnStore store = EventColumnStore.Build([], Generation, ContentVersion).Append(corpus);
-
-        Assert.Equal(0, store.SealedCount);
-
-        LegacyEventColumnReader legacy = new(s_logId, store.Generation, store.ContentVersion, corpus);
-        EventColumnStoreReader column = new(s_logId, store);
-
-        return (legacy, column, corpus);
-    }
-
-    // Build the legacy reader from the store's generation/content version: Append bumps ContentVersion, so surface
-    // parity holds only when the legacy adapter is stamped with the same values the store settled on.
-    private static (IEventColumnReader Legacy, IEventColumnReader Column, ResolvedEvent[] Corpus) BuildSealed()
-    {
-        ResolvedEvent[] corpus = BuildCorpus();
-        EventColumnStore store = EventColumnStore.Build(corpus, Generation, ContentVersion);
-
-        Assert.Equal(corpus.Length, store.SealedCount);
-
-        LegacyEventColumnReader legacy = new(s_logId, store.Generation, store.ContentVersion, corpus);
-        EventColumnStoreReader column = new(s_logId, store);
-
-        return (legacy, column, corpus);
-    }
-
-    private static List<string> CollectEventDataNames(ResolvedEvent[] corpus)
-    {
-        HashSet<string> names = new(StringComparer.Ordinal);
-
-        foreach (ResolvedEvent resolvedEvent in corpus)
-        {
-            if (resolvedEvent.EventDataSchema is { } schema)
-            {
-                foreach (string name in schema.AllNames) { names.Add(name); }
-                foreach (string name in schema.VisibleNames) { names.Add(name); }
-            }
-        }
-
-        names.Add("NoSuchField");
-        names.Add(string.Empty);
-
-        return [.. names];
-    }
-
-    private static List<string> CollectUserDataKeys(ResolvedEvent[] corpus)
-    {
-        HashSet<string> keys = new(StringComparer.Ordinal);
-
-        foreach (ResolvedEvent resolvedEvent in corpus)
-        {
-            if (!resolvedEvent.UserData.IsDefaultOrEmpty)
-            {
-                foreach (UserDataField field in resolvedEvent.UserData) { keys.Add(field.Path); }
-            }
-        }
-
-        keys.Add("NoSuchKey");
-
-        return [.. keys];
-    }
-
-    private static ResolvedEvent ErrorCodeEvent(string source, object errorCode, int index) =>
-        new ResolvedEvent("TestLog", LogPathType.Channel) { Id = 20, Source = source, TimeCreated = s_time.AddMinutes(index) }
-            .WithEventData(("errorCode", errorCode));
-
-    private static List<(string Name, EventFieldValueKind Kind, string Value)> MaterializeEventData(
-        IEventColumnReader reader,
-        EventLocator locator)
-    {
-        List<(string Name, EventFieldValueKind Kind, string Value)> fields = [];
-
-        foreach (EventDataView.Field field in reader.EnumerateEventData(locator))
-        {
-            fields.Add((field.Name, field.Value.Kind, field.Value.AsString()));
-        }
-
-        return fields;
-    }
-
-    private static List<(string Path, EventFieldValueKind Kind, string Value, bool Truncated, bool Absent)> MaterializeUserData(
-        IEventColumnReader reader,
-        EventLocator locator)
-    {
-        List<(string Path, EventFieldValueKind Kind, string Value, bool Truncated, bool Absent)> fields = [];
-
-        foreach (UserDataFieldEntry entry in reader.EnumerateUserData(locator))
-        {
-            fields.Add((
-                entry.Path,
-                entry.Result.Value.Kind,
-                entry.Result.Value.AsString(),
-                entry.Result.IsTruncated,
-                entry.Result.IsAbsent));
-        }
-
-        return fields;
-    }
-
-    private static ResolvedEvent ServicingUserDataEvent(string path, string errorCode, int index) =>
-        new ResolvedEvent("TestLog", LogPathType.Channel) { Id = 3, Source = "Microsoft-Windows-Servicing", TimeCreated = s_time.AddMinutes(index) }
-            .WithUserData((path, errorCode));
-
-    private static ResolvedEvent WithNamedProperties(ResolvedEvent source, params (string Name, EventProperty Value)[] fields)
-    {
-        string template = "<template>"
-            + string.Concat(fields.Select(field => $"<data name=\"{SecurityElement.Escape(field.Name)}\"/>"))
-            + "</template>";
-
-        TemplateFieldSchema schema = new TemplateAnalyzer().GetTemplateInfo(template).Schema;
-        ImmutableArray<EventProperty>.Builder values = ImmutableArray.CreateBuilder<EventProperty>(fields.Length);
-
-        foreach ((string _, EventProperty value) in fields) { values.Add(value); }
-
-        return source with { EventDataValues = values.MoveToImmutable(), EventDataSchema = schema };
-    }
-
-    private static ResolvedEvent WithRawSchema(ResolvedEvent source, TemplateFieldSchema? schema, params EventProperty[] values) =>
-        source with { EventDataValues = [.. values], EventDataSchema = schema };
-
-    private sealed class UnknownReference
-    {
-        public override string ToString() => "unknown-ref";
-    }
-}
diff --git a/tests/Unit/EventLogExpert.Eventing.Tests/Common/Events/EventColumnStoreReaderTests.cs b/tests/Unit/EventLogExpert.Eventing.Tests/Common/Events/EventColumnStoreReaderTests.cs
new file mode 100644
index 000000000..3498ad46f
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Eventing.Tests/Common/Events/EventColumnStoreReaderTests.cs
@@ -0,0 +1,66 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.Channels;
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
+
+namespace EventLogExpert.Eventing.Tests.Common.Events;
+
+public sealed class EventColumnStoreReaderTests
+{
+    private const long ContentVersion = 42;
+    private const int Generation = 3;
+
+    private static readonly EventLogId s_logId = EventLogId.Create();
+    private static readonly DateTime s_time = new(2021, 6, 15, 10, 20, 30, DateTimeKind.Utc);
+
+    [Fact]
+    public void GetField_ForeignLogIdLocator_ThrowsArgumentException()
+    {
+        IEventColumnReader reader = SealedReader();
+        EventLocator foreign = new(EventLogId.Create(), reader.Generation, 0);
+
+        Assert.Throws<ArgumentException>(() => reader.GetField(foreign, EventFieldId.Id));
+    }
+
+    [Fact]
+    public void GetField_StaleGenerationLocator_ThrowsArgumentException()
+    {
+        IEventColumnReader reader = SealedReader();
+        EventLocator stale = new(reader.LogId, reader.Generation + 1, 0);
+
+        Assert.Throws<ArgumentException>(() => reader.GetField(stale, EventFieldId.Id));
+    }
+
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public void GetKeywords_ReturnsEachRowsKeywordSequence(bool sealRows)
+    {
+        ResolvedEvent[] sample =
+        [
+            new ResolvedEvent("Security", LogPathType.Channel)
+            {
+                Id = 1, TimeCreated = s_time, Keywords = ["Audit Success", "Classic"]
+            },
+            new ResolvedEvent("Application", LogPathType.Channel) { Id = 2, TimeCreated = s_time },
+            new ResolvedEvent("System", LogPathType.Channel) { Id = 3, TimeCreated = s_time, Keywords = ["Classic"] }
+        ];
+
+        IEventColumnReader reader = ReaderOver(sample, sealRows);
+
+        Assert.Equal(["Audit Success", "Classic"], reader.GetKeywords(reader.LocatorAt(0)));
+        Assert.Empty(reader.GetKeywords(reader.LocatorAt(1)));
+        Assert.Equal(["Classic"], reader.GetKeywords(reader.LocatorAt(2)));
+    }
+
+    private static IEventColumnReader ReaderOver(ResolvedEvent[] sample, bool sealRows) =>
+        (sealRows
+            ? EventColumnStore.Build(sample, Generation, ContentVersion)
+            : EventColumnStore.Build([], Generation, ContentVersion).Append(sample))
+        .CreateReader(s_logId);
+
+    private static IEventColumnReader SealedReader() =>
+        ReaderOver([new ResolvedEvent("Security", LogPathType.Channel) { Id = 1, TimeCreated = s_time }], sealRows: true);
+}
diff --git a/tests/Unit/EventLogExpert.Eventing.Tests/Common/Events/LegacyEventColumnReaderTests.cs b/tests/Unit/EventLogExpert.Eventing.Tests/Common/Events/LegacyEventColumnReaderTests.cs
deleted file mode 100644
index 3ced091d8..000000000
--- a/tests/Unit/EventLogExpert.Eventing.Tests/Common/Events/LegacyEventColumnReaderTests.cs
+++ /dev/null
@@ -1,125 +0,0 @@
-// // Copyright (c) Microsoft Corporation.
-// // Licensed under the MIT License.
-
-using EventLogExpert.Eventing.Common.Channels;
-using EventLogExpert.Eventing.Common.EventLogs;
-using EventLogExpert.Eventing.Common.Events;
-using EventLogExpert.Eventing.Structured;
-using EventLogExpert.Eventing.TestUtils;
-using System.Collections.Immutable;
-using System.Security.Principal;
-
-namespace EventLogExpert.Eventing.Tests.Common.Events;
-
-public sealed class LegacyEventColumnReaderTests
-{
-    private static readonly EventLogId s_logId = EventLogId.Create();
-
-    [Fact]
-    public void GetField_LocatorFromDifferentGeneration_Throws()
-    {
-        var reader = CreateReader(new ResolvedEvent("live", LogPathType.Channel));
-        var staleLocator = new EventLocator(s_logId, 999, 0);
-
-        Assert.Throws<ArgumentException>(() => reader.GetField(staleLocator, EventFieldId.Id));
-    }
-
-    [Fact]
-    public void GetField_LocatorFromDifferentLog_Throws()
-    {
-        var reader = CreateReader(new ResolvedEvent("live", LogPathType.Channel));
-        var foreignLocator = new EventLocator(EventLogId.Create(), 3, 0);
-
-        Assert.Throws<ArgumentException>(() => reader.GetField(foreignLocator, EventFieldId.Id));
-    }
-
-    [Fact]
-    public void GetField_NullRecordId_IsNullKind()
-    {
-        var reader = CreateReader(new ResolvedEvent("live", LogPathType.Channel) { RecordId = null });
-
-        Assert.Equal(EventFieldValueKind.Null, reader.GetField(reader.LocatorAt(0), EventFieldId.RecordId).Kind);
-    }
-
-    [Fact]
-    public void GetField_ScalarFields_MatchEvent()
-    {
-        var reader = CreateReader(new ResolvedEvent("live", LogPathType.Channel)
-        {
-            Id = 4624,
-            Level = "Information",
-            Source = "Microsoft-Windows-Security-Auditing",
-            RecordId = 7
-        });
-
-        EventLocator locator = reader.LocatorAt(0);
-
-        Assert.True(reader.GetField(locator, EventFieldId.Id).TryGetInt64(out long id));
-        Assert.Equal(4624L, id);
-        Assert.Equal("Information", reader.GetField(locator, EventFieldId.Level).AsString());
-        Assert.Equal("Microsoft-Windows-Security-Auditing", reader.GetField(locator, EventFieldId.Source).AsString());
-        Assert.True(reader.GetField(locator, EventFieldId.RecordId).TryGetInt64(out long recordId));
-        Assert.Equal(7L, recordId);
-    }
-
-    [Fact]
-    public void GetField_UserId_IsSid()
-    {
-        var reader = CreateReader(new ResolvedEvent("live", LogPathType.Channel) { UserId = new SecurityIdentifier("S-1-5-18") });
-
-        Assert.Equal("S-1-5-18", reader.GetField(reader.LocatorAt(0), EventFieldId.UserId).AsString());
-    }
-
-    [Fact]
-    public void GetUserData_AbsentField_IsAbsent()
-    {
-        var reader = CreateReader(new ResolvedEvent("live", LogPathType.Channel)
-        {
-            UserData = ImmutableArray.Create(new UserDataField("Result/@value", ImmutableArray.Create("ok"), IsTruncated: false))
-        });
-
-        Assert.True(reader.GetUserData(reader.LocatorAt(0), "Missing/@value").IsAbsent);
-    }
-
-    [Fact]
-    public void GetUserData_ReturnsStoredField()
-    {
-        var reader = CreateReader(new ResolvedEvent("live", LogPathType.Channel)
-        {
-            UserData = ImmutableArray.Create(new UserDataField("Result/@value", ImmutableArray.Create("ok"), IsTruncated: false))
-        });
-
-        StructuredFieldResult result = reader.GetUserData(reader.LocatorAt(0), "Result/@value");
-
-        Assert.False(result.IsAbsent);
-        Assert.Equal(["ok"], result.PresentValues.ToArray());
-    }
-
-    [Fact]
-    public void LocatorAt_CarriesReaderLogAndGeneration()
-    {
-        var reader = CreateReader(new ResolvedEvent("live", LogPathType.Channel));
-
-        Assert.Equal(new EventLocator(s_logId, 3, 0), reader.LocatorAt(0));
-    }
-
-    [Fact]
-    public void TryGetEventData_AbsentField_ReturnsFalse()
-    {
-        var reader = CreateReader(new ResolvedEvent("live", LogPathType.Channel).WithEventData(("TargetUserName", "alice")));
-
-        Assert.False(reader.TryGetEventData(reader.LocatorAt(0), "NonExistent", out _));
-    }
-
-    [Fact]
-    public void TryGetEventData_ReturnsNamedField()
-    {
-        var reader = CreateReader(new ResolvedEvent("live", LogPathType.Channel).WithEventData(("TargetUserName", "alice")));
-
-        Assert.True(reader.TryGetEventData(reader.LocatorAt(0), "TargetUserName", out EventFieldValue value));
-        Assert.Equal("alice", value.AsString());
-    }
-
-    private static LegacyEventColumnReader CreateReader(params ResolvedEvent[] events) =>
-        new(s_logId, generation: 3, contentVersion: 1, events);
-}
diff --git a/tests/Unit/EventLogExpert.Eventing.Tests/ProviderMetadata/Wevt/OfflineWevtProviderReaderTests.cs b/tests/Unit/EventLogExpert.Eventing.Tests/ProviderMetadata/Wevt/OfflineWevtProviderReaderTests.cs
index c3eabe77f..07fd713dc 100644
--- a/tests/Unit/EventLogExpert.Eventing.Tests/ProviderMetadata/Wevt/OfflineWevtProviderReaderTests.cs
+++ b/tests/Unit/EventLogExpert.Eventing.Tests/ProviderMetadata/Wevt/OfflineWevtProviderReaderTests.cs
@@ -28,7 +28,6 @@ public sealed class OfflineWevtProviderReaderTests
     [Fact]
     public void BuildChannels_AuxKeyedInlineOnly_FirstWinsAndUnnamedOmitted()
     {
-        // Aux @8 is the reference id; duplicates keep the first row and inline-only unnamed rows are omitted.
         byte[] resource = BuildProviderResource(channels:
         [
             new ChannelSpec(Id: 1, ReferenceId: 16, MessageId: uint.MaxValue, Name: "Operational"),
@@ -74,7 +73,6 @@ public void EscapeXmlAttribute_EscapesEveryXmlSpecialChar(string raw, string exp
     [Fact]
     public void MapToRawContent_FileTimeFlatTemplate_IsNotStructAndWritesFileTime()
     {
-        // A multi-field flat template (FILETIME + UInt32) has numNames == numDesc, so it must NOT be treated as a struct.
         byte[] resource = BuildProviderResource(
             events: [new EventSpec(Id: 200, Version: 0, Channel: 0, Level: 0, Opcode: 0, Task: 0, Keywords: 0, MessageId: uint.MaxValue, ReferencesTemplate: true)],
             template: new TemplateSpec(
@@ -97,7 +95,6 @@ public void MapToRawContent_FileTimeFlatTemplate_IsNotStructAndWritesFileTime()
     [Fact]
     public void MapToRawContent_FixedCountArray_EmitsLiteralCount()
     {
-        // flags@0 bit 0x8 makes count@12 a literal count emitted as count="<n>".
         byte[] resource = BuildProviderResource(
             events: [new EventSpec(Id: 10, Version: 0, Channel: 0, Level: 0, Opcode: 0, Task: 0, Keywords: 0, MessageId: uint.MaxValue, ReferencesTemplate: true)],
             template: new TemplateSpec(
@@ -113,7 +110,6 @@ public void MapToRawContent_FixedCountArray_EmitsLiteralCount()
     [Fact]
     public void MapToRawContent_FixedNumericLengthAnsiString_EmitsLength()
     {
-        // win:AnsiString (0x02) is length-bearing: a fixed length@14=4 emits length="4".
         byte[] resource = BuildProviderResource(
             events: [new EventSpec(Id: 10, Version: 0, Channel: 0, Level: 0, Opcode: 0, Task: 0, Keywords: 0, MessageId: uint.MaxValue, ReferencesTemplate: true)],
             template: new TemplateSpec(
@@ -126,40 +122,37 @@ public void MapToRawContent_FixedNumericLengthAnsiString_EmitsLength()
     }
 
     [Fact]
-    public void MapToRawContent_FixedNumericLengthBinary_EmitsLength()
+    public void MapToRawContent_FixedNumericLengthBinaryNonHexBinary_EmitsLength()
     {
-        // flags@0 bit 0x2 without bit 0x4 makes Binary length@14 a literal byte count.
         byte[] resource = BuildProviderResource(
             events: [new EventSpec(Id: 10, Version: 0, Channel: 0, Level: 0, Opcode: 0, Task: 0, Keywords: 0, MessageId: uint.MaxValue, ReferencesTemplate: true)],
             template: new TemplateSpec(
-                Items: [new TemplateItemSpec(InType: 0x0e, OutType: 0x0f, Count: 0, Name: "Address", Flags: 0x2, Length: 6)],
+                Items: [new TemplateItemSpec(InType: 0x0e, OutType: 0x18, Count: 0, Name: "Address", Flags: 0x2, Length: 16)],
                 NameCount: 1));
 
         string template = Assert.Single(MapResource(resource).Events).Template;
 
-        Assert.Contains("name=\"Address\"", template);
-        Assert.Contains("length=\"6\"", template);
+        Assert.Contains("inType=\"win:Binary\" outType=\"win:IPv6\" length=\"16\"", template);
     }
 
     [Fact]
-    public void MapToRawContent_FixedNumericLengthBinaryNonHexBinary_EmitsLength()
+    public void MapToRawContent_FixedNumericLengthBinary_EmitsLength()
     {
-        // Fixed Binary length is valid for non-hexBinary outTypes such as IPv6 and must render like native.
         byte[] resource = BuildProviderResource(
             events: [new EventSpec(Id: 10, Version: 0, Channel: 0, Level: 0, Opcode: 0, Task: 0, Keywords: 0, MessageId: uint.MaxValue, ReferencesTemplate: true)],
             template: new TemplateSpec(
-                Items: [new TemplateItemSpec(InType: 0x0e, OutType: 0x18, Count: 0, Name: "Address", Flags: 0x2, Length: 16)],
+                Items: [new TemplateItemSpec(InType: 0x0e, OutType: 0x0f, Count: 0, Name: "Address", Flags: 0x2, Length: 6)],
                 NameCount: 1));
 
         string template = Assert.Single(MapResource(resource).Events).Template;
 
-        Assert.Contains("inType=\"win:Binary\" outType=\"win:IPv6\" length=\"16\"", template);
+        Assert.Contains("name=\"Address\"", template);
+        Assert.Contains("length=\"6\"", template);
     }
 
     [Fact]
     public void MapToRawContent_FixedNumericLengthNonBinary_FailsClosedToEmptyTemplate()
     {
-        // Fixed numeric lengths are valid only for string and binary inTypes; other inTypes fail closed.
         byte[] resource = BuildProviderResource(
             events: [new EventSpec(Id: 10, Version: 0, Channel: 0, Level: 0, Opcode: 0, Task: 0, Keywords: 0, MessageId: uint.MaxValue, ReferencesTemplate: true)],
             template: new TemplateSpec(
@@ -174,7 +167,6 @@ public void MapToRawContent_FixedNumericLengthNonBinary_FailsClosedToEmptyTempla
     [Fact]
     public void MapToRawContent_FixedNumericLengthUnicodeString_EmitsLength()
     {
-        // win:UnicodeString (0x01) is length-bearing: a fixed length@14=32 emits length="32".
         byte[] resource = BuildProviderResource(
             events: [new EventSpec(Id: 10, Version: 0, Channel: 0, Level: 0, Opcode: 0, Task: 0, Keywords: 0, MessageId: uint.MaxValue, ReferencesTemplate: true)],
             template: new TemplateSpec(
@@ -189,7 +181,6 @@ public void MapToRawContent_FixedNumericLengthUnicodeString_EmitsLength()
     [Fact]
     public void MapToRawContent_LengthFieldReference_EmitsReferencedFieldName()
     {
-        // flags@0 bit 0x4 makes length@14 a field index, not a numeric length.
         byte[] resource = BuildProviderResource(
             events: [new EventSpec(Id: 10, Version: 0, Channel: 0, Level: 0, Opcode: 0, Task: 0, Keywords: 0, MessageId: uint.MaxValue, ReferencesTemplate: true)],
             template: new TemplateSpec(
@@ -209,7 +200,6 @@ public void MapToRawContent_LengthFieldReference_EmitsReferencedFieldName()
     [Fact]
     public void MapToRawContent_LengthReferenceOutOfRange_FailsClosedToEmptyTemplate()
     {
-        // Unresolvable length references fail the whole template closed rather than emitting a guessed length.
         byte[] resource = BuildProviderResource(
             events: [new EventSpec(Id: 10, Version: 0, Channel: 0, Level: 0, Opcode: 0, Task: 0, Keywords: 0, MessageId: uint.MaxValue, ReferencesTemplate: true)],
             template: new TemplateSpec(
@@ -224,7 +214,6 @@ public void MapToRawContent_LengthReferenceOutOfRange_FailsClosedToEmptyTemplate
     [Fact]
     public void MapToRawContent_NestedStructMember_FailsClosedToEmptyTemplate()
     {
-        // Nested structs are absent from the corpus, so memberCount@6 > 0 fails the whole template closed.
         byte[] resource = BuildProviderResource(
             events: [new EventSpec(Id: 7, Version: 0, Channel: 0, Level: 0, Opcode: 0, Task: 0, Keywords: 0, MessageId: 0, ReferencesTemplate: true)],
             template: new TemplateSpec(
@@ -245,7 +234,6 @@ public void MapToRawContent_NestedStructMember_FailsClosedToEmptyTemplate()
     [Fact]
     public void MapToRawContent_OpcodeValue_PassesHighWordThroughForFactoryProjection()
     {
-        // OPCO values are already high-word shifted, so the reader preserves the raw native value for factory projection.
         byte[] resource = BuildProviderResource(opcodes:
         [
             new IdentifiedSpec(Id: 0, MessageId: uint.MaxValue, Name: "Op0"),
@@ -276,7 +264,6 @@ public void MapToRawContent_OpcodeValue_PassesHighWordThroughForFactoryProjectio
     [Fact]
     public void MapToRawContent_RenderingCriticalOutTypeBytes_EmitExactLiveCasing()
     {
-        // outType spelling is casing-sensitive against the live API: win:Hresult and win:NTStatus are pinned here.
         byte[] resource = BuildProviderResource(
             events: [new EventSpec(Id: 10, Version: 0, Channel: 0, Level: 0, Opcode: 0, Task: 0, Keywords: 0, MessageId: uint.MaxValue, ReferencesTemplate: true)],
             template: new TemplateSpec(
@@ -298,7 +285,6 @@ public void MapToRawContent_RenderingCriticalOutTypeBytes_EmitExactLiveCasing()
     [Fact]
     public void MapToRawContent_StructTemplate_EmitsNestedDataInsideStruct()
     {
-        // memberCount@6 claims appended descriptors by range; no count flag means the struct carries no count.
         byte[] resource = BuildProviderResource(
             events: [new EventSpec(Id: 5, Version: 0, Channel: 0, Level: 0, Opcode: 0, Task: 0, Keywords: 0, MessageId: 0, ReferencesTemplate: true)],
             template: new TemplateSpec(
@@ -357,7 +343,6 @@ public void MapToRawContent_TemplateItemNameOffsetOutOfBounds_FailsClosedToEmpty
                 Items: [new TemplateItemSpec(InType: 0x08, OutType: 0x08, Count: 0, Name: "Field")],
                 NameCount: 1));
 
-        // Unreadable item names make the whole template fail closed rather than emit partial XML.
         WriteUInt32(resource, TemplateOffset + 20 + 16, BufferSize + 0x100);
 
         RawProviderContent content = MapResource(resource);
@@ -387,7 +372,6 @@ public void MapToRawContent_TemplateItemsPointerOverflow_FailsClosedWithoutThrow
     [Fact]
     public void MapToRawContent_TemplateWithUnclaimedAppendedDescriptor_FailsClosedToEmptyTemplate()
     {
-        // Unclaimed appended descriptors fail the exact-partition check and suppress XML output.
         byte[] resource = BuildProviderResource(
             events: [new EventSpec(Id: 10, Version: 0, Channel: 0, Level: 0, Opcode: 0, Task: 0, Keywords: 0, MessageId: uint.MaxValue, ReferencesTemplate: true)],
             template: new TemplateSpec(
@@ -409,7 +393,6 @@ public void MapToRawContent_TruncatedTemplateItemDescriptor_FailsClosedToEmptyTe
                 Items: [new TemplateItemSpec(InType: 0x08, OutType: 0x08, Count: 0, Name: "Field")],
                 NameCount: 1));
 
-        // Truncated descriptors fail the whole template closed instead of writing from partially-read bytes.
         byte[] truncated = resource[..(TemplateOffset + 20 + 4)];
 
         RawProviderContent content = MapResource(truncated);
@@ -420,7 +403,6 @@ public void MapToRawContent_TruncatedTemplateItemDescriptor_FailsClosedToEmptyTe
     [Fact]
     public void MapToRawContent_TwoSiblingStructs_EmitEachWithItsOwnMembers()
     {
-        // Sibling structs claim disjoint member ranges from their own start indexes, not a shared cursor.
         byte[] resource = BuildProviderResource(
             events: [new EventSpec(Id: 6, Version: 0, Channel: 0, Level: 0, Opcode: 0, Task: 0, Keywords: 0, MessageId: 0, ReferencesTemplate: true)],
             template: new TemplateSpec(
@@ -454,7 +436,6 @@ public void MapToRawContent_TwoSiblingStructs_EmitEachWithItsOwnMembers()
     [Fact]
     public void MapToRawContent_UnknownInTypeByte_FailsClosedToEmptyTemplate()
     {
-        // Unknown inType bytes fail closed instead of emitting guessed winmeta tokens.
         byte[] resource = BuildProviderResource(
             events: [new EventSpec(Id: 10, Version: 0, Channel: 0, Level: 0, Opcode: 0, Task: 0, Keywords: 0, MessageId: uint.MaxValue, ReferencesTemplate: true)],
             template: new TemplateSpec(
@@ -469,7 +450,6 @@ public void MapToRawContent_UnknownInTypeByte_FailsClosedToEmptyTemplate()
     [Fact]
     public void MapToRawContent_UnknownOutTypeByte_FailsClosedToEmptyTemplate()
     {
-        // Unknown non-zero outType bytes fail closed instead of emitting guessed winmeta tokens.
         byte[] resource = BuildProviderResource(
             events: [new EventSpec(Id: 10, Version: 0, Channel: 0, Level: 0, Opcode: 0, Task: 0, Keywords: 0, MessageId: uint.MaxValue, ReferencesTemplate: true)],
             template: new TemplateSpec(
@@ -484,7 +464,6 @@ public void MapToRawContent_UnknownOutTypeByte_FailsClosedToEmptyTemplate()
     [Fact]
     public void MapToRawContent_VariableCountArray_EmitsReferencedFieldName()
     {
-        // flags@0 bit 0x10 makes count@12 a field index, not a numeric count.
         byte[] resource = BuildProviderResource(
             events: [new EventSpec(Id: 10, Version: 0, Channel: 0, Level: 0, Opcode: 0, Task: 0, Keywords: 0, MessageId: uint.MaxValue, ReferencesTemplate: true)],
             template: new TemplateSpec(
@@ -504,7 +483,6 @@ public void MapToRawContent_VariableCountArray_EmitsReferencedFieldName()
     [Fact]
     public void MapToRawContent_VariableCountReferenceOutOfRange_FailsClosedToEmptyTemplate()
     {
-        // Unresolvable count references fail the whole template closed rather than emitting a guessed count.
         byte[] resource = BuildProviderResource(
             events: [new EventSpec(Id: 10, Version: 0, Channel: 0, Level: 0, Opcode: 0, Task: 0, Keywords: 0, MessageId: uint.MaxValue, ReferencesTemplate: true)],
             template: new TemplateSpec(
@@ -519,7 +497,6 @@ public void MapToRawContent_VariableCountReferenceOutOfRange_FailsClosedToEmptyT
     [Fact]
     public void MapToRawContent_VariableCountReferenceToStruct_FailsClosedToEmptyTemplate()
     {
-        // Variable counts must reference leaf numeric fields, never structs.
         byte[] resource = BuildProviderResource(
             events: [new EventSpec(Id: 8, Version: 0, Channel: 0, Level: 0, Opcode: 0, Task: 0, Keywords: 0, MessageId: 0, ReferencesTemplate: true)],
             template: new TemplateSpec(
@@ -541,7 +518,6 @@ public void MapToRawContent_VariableCountReferenceToStruct_FailsClosedToEmptyTem
     [Fact]
     public void MapToRawContent_ZeroOutTypeByte_EmitsInTypeDefaultOutType()
     {
-        // Zero outType uses the inType default because the live API always emits an outType.
         byte[] resource = BuildProviderResource(
             events: [new EventSpec(Id: 10, Version: 0, Channel: 0, Level: 0, Opcode: 0, Task: 0, Keywords: 0, MessageId: uint.MaxValue, ReferencesTemplate: true)],
             template: new TemplateSpec(
@@ -567,26 +543,9 @@ public void MapToRawContent_ZeroOutTypeByte_EmitsInTypeDefaultOutType()
     public void ResolveParameterReferences_ResolvesAndTrimsParameterTokens(string raw, string expected) =>
         Assert.Equal(expected, OfflineWevtProviderReader.ResolveParameterReferences(raw, FakeParameterText));
 
-    [Fact]
-    public void TryParse_MapLessProvider_ReturnsNullWhileFullParseReturnsEventsAndTables()
-    {
-        byte[] resource = BuildProviderResource(
-            events: [new EventSpec(Id: 1, Version: 0, Channel: 0, Level: 0, Opcode: 0, Task: 0, Keywords: 0, MessageId: uint.MaxValue)],
-            opcodes: [new IdentifiedSpec(Id: 1, MessageId: uint.MaxValue, Name: "OpcodeName")]);
-
-        Assert.Null(WevtTemplateReader.TryParse(resource, s_publisherGuid, logger: null));
-
-        // Full parse must still yield events and tables when the legacy map API returns null for map-less providers.
-        WevtProviderData data = ParseResource(resource);
-        Assert.Single(data.Events);
-        Assert.Single(data.Opcodes);
-        Assert.Empty(data.Templates.Maps);
-    }
-
     [Fact]
     public void TryParseProvider_ClassicAndModernShareSixteenBitId_ProduceDistinctIds()
     {
-        // Two rows share the 16-bit code 4: one classic (projected to the qualified id) and one modern (kept bare).
         byte[] resource = BuildProviderResource(
             events:
             [
@@ -601,24 +560,9 @@ public void TryParseProvider_ClassicAndModernShareSixteenBitId_ProduceDistinctId
         Assert.Contains(data.Events, e => e is { Id: 4u, Version: 0 });
     }
 
-    [Fact]
-    public void TryParseProvider_ClassicEvent_ProjectsToQualifiedIdWithZeroedVersionAndOpcode()
-    {
-        byte[] resource = BuildProviderResource(
-            events: [new EventSpec(Id: 4, Version: 90, Channel: 0, Level: 0, Opcode: 0x42, Task: 0, Keywords: 0, MessageId: 0x425A0004)]);
-
-        WevtProviderEvent parsed = Assert.Single(ParseResource(resource).Events);
-
-        Assert.Equal(0x425A0004u, parsed.Id);
-        Assert.Equal((byte)0, parsed.Version);
-        Assert.Equal((byte)0, parsed.Opcode);
-        Assert.Equal(0x425A0004u, parsed.MessageId);
-    }
-
     [Fact]
     public void TryParseProvider_ClassicEventHighOpcodeByte_ComposesQualifiedIdWithoutSignExtension()
     {
-        // An opcode byte >= 0x80 must shift in the uint domain; an int-domain shift would sign-extend into the high dword.
         byte[] resource = BuildProviderResource(
             events: [new EventSpec(Id: 1, Version: 6, Channel: 0, Level: 0, Opcode: 0xC0, Task: 0, Keywords: 0, MessageId: 0xC0060001)]);
 
@@ -630,7 +574,6 @@ public void TryParseProvider_ClassicEventHighOpcodeByte_ComposesQualifiedIdWitho
     [Fact]
     public void TryParseProvider_ClassicEventWithValueMap_KeysFieldMapByQualifiedId()
     {
-        // Classic event value maps are theoretical, but map keys must still use the projected event identity.
         byte[] resource = BuildProviderResource(
             events: [new EventSpec(Id: 4, Version: 90, Channel: 0, Level: 0, Opcode: 0x42, Task: 0, Keywords: 0, MessageId: 0x425A0004, ReferencesTemplate: true)],
             template: new TemplateSpec(
@@ -644,6 +587,20 @@ public void TryParseProvider_ClassicEventWithValueMap_KeysFieldMapByQualifiedId(
         Assert.False(data.Templates.EventFieldMaps.ContainsKey(new WevtEventKey(4, 90)));
     }
 
+    [Fact]
+    public void TryParseProvider_ClassicEvent_ProjectsToQualifiedIdWithZeroedVersionAndOpcode()
+    {
+        byte[] resource = BuildProviderResource(
+            events: [new EventSpec(Id: 4, Version: 90, Channel: 0, Level: 0, Opcode: 0x42, Task: 0, Keywords: 0, MessageId: 0x425A0004)]);
+
+        WevtProviderEvent parsed = Assert.Single(ParseResource(resource).Events);
+
+        Assert.Equal(0x425A0004u, parsed.Id);
+        Assert.Equal((byte)0, parsed.Version);
+        Assert.Equal((byte)0, parsed.Opcode);
+        Assert.Equal(0x425A0004u, parsed.MessageId);
+    }
+
     [Fact]
     public void TryParseProvider_FullTables_ReadEveryFieldAtItsOffset()
     {
@@ -684,7 +641,6 @@ public void TryParseProvider_KeywordCountExceedsCap_FailsClosedToEmptyTable()
             opcodes: [new IdentifiedSpec(Id: 1, MessageId: uint.MaxValue, Name: "OpcodeName")],
             keywords: [new KeywordSpec(Mask: 0x1, MessageId: uint.MaxValue, Name: "KeywordName")]);
 
-        // A count above the table cap is malformed; the keyword table fails closed to empty while the other tables parse.
         WriteUInt32(resource, KeywordTableOffset + 8, uint.MaxValue);
 
         WevtProviderData data = ParseResource(resource);
@@ -696,7 +652,6 @@ public void TryParseProvider_KeywordCountExceedsCap_FailsClosedToEmptyTable()
     [Fact]
     public void TryParseProvider_MessageIdCustomerBitSet_LeavesEventUnprojected()
     {
-        // A modern manifest message id sets the customer bit (0x20000000); such an event is not a classic row.
         byte[] resource = BuildProviderResource(
             events: [new EventSpec(Id: 4, Version: 90, Channel: 0, Level: 0, Opcode: 0x42, Task: 0, Keywords: 0, MessageId: 0x625A0004)]);
 
@@ -710,7 +665,6 @@ public void TryParseProvider_MessageIdCustomerBitSet_LeavesEventUnprojected()
     [Fact]
     public void TryParseProvider_OpcodeTableReferenceNonZero_LeavesEventUnprojected()
     {
-        // A non-zero opcode-table reference marks a modern event even when trailing fields look classic.
         byte[] resource = BuildProviderResource(
             events: [new EventSpec(Id: 4, Version: 90, Channel: 0, Level: 0, Opcode: 0x42, Task: 0, Keywords: 0, MessageId: 0x425A0004, OpcodeTableReference: 0x40)]);
 
@@ -734,10 +688,24 @@ public void TryParseProvider_TrailingFieldNonZero_LeavesEventUnprojected()
         Assert.Equal((byte)0x42, parsed.Opcode);
     }
 
+    [Fact]
+    public void TryParse_MapLessProvider_ReturnsNullWhileFullParseReturnsEventsAndTables()
+    {
+        byte[] resource = BuildProviderResource(
+            events: [new EventSpec(Id: 1, Version: 0, Channel: 0, Level: 0, Opcode: 0, Task: 0, Keywords: 0, MessageId: uint.MaxValue)],
+            opcodes: [new IdentifiedSpec(Id: 1, MessageId: uint.MaxValue, Name: "OpcodeName")]);
+
+        Assert.Null(WevtTemplateReader.TryParse(resource, s_publisherGuid, logger: null));
+
+        WevtProviderData data = ParseResource(resource);
+        Assert.Single(data.Events);
+        Assert.Single(data.Opcodes);
+        Assert.Empty(data.Templates.Maps);
+    }
+
     [Fact]
     public void Write_XmlEscapedFieldName_StillMatchesMapInjection()
     {
-        // Map injection must escape raw field keys identically to the written template.
         byte[] resource = BuildProviderResource(
             events: [new EventSpec(Id: 10, Version: 0, Channel: 0, Level: 0, Opcode: 0, Task: 0, Keywords: 0, MessageId: uint.MaxValue, ReferencesTemplate: true)],
             template: new TemplateSpec(
@@ -893,7 +861,6 @@ int Alloc(string? value)
 
                 if (item.MemberCount > 0)
                 {
-                    // A struct descriptor carries no inType: @4 is the member-start index (u16) and @6 the member count.
                     WriteUInt16(buffer, itemOffset + 4, item.MemberStart);
                     WriteUInt16(buffer, itemOffset + 6, item.MemberCount);
                 }
diff --git a/tests/Unit/EventLogExpert.Eventing.Tests/Resolvers/EventResolverCacheTests.cs b/tests/Unit/EventLogExpert.Eventing.Tests/Resolvers/EventResolverCacheTests.cs
index e756692de..010413dfe 100644
--- a/tests/Unit/EventLogExpert.Eventing.Tests/Resolvers/EventResolverCacheTests.cs
+++ b/tests/Unit/EventLogExpert.Eventing.Tests/Resolvers/EventResolverCacheTests.cs
@@ -8,47 +8,42 @@ namespace EventLogExpert.Eventing.Tests.Resolvers;
 
 public sealed class EventResolverCacheTests
 {
+    private const int ClearAllInterleaveDelayMilliseconds = 5;
+
     public enum CacheKind { Description, Value }
 
     [Fact]
     public void ClearAll_AfterAddingItems_ShouldClearBothCaches()
     {
-        // Arrange
         var cache = new EventResolverCache();
 
-        // Force new string instances to avoid string interning
         var testDesc = new string("Test Description".ToCharArray());
         var testValue = new string("Test Value".ToCharArray());
 
         var oldDesc = cache.GetOrAddDescription(testDesc);
         var oldValue = cache.GetOrAddValue(testValue);
 
-        // Act
         cache.ClearAll();
 
-        // Assert
-        // After clearing, calling GetOrAdd with new instances should return those new instances
         var newDescInput = new string("Test Description".ToCharArray());
         var newValueInput = new string("Test Value".ToCharArray());
 
         var newDesc = cache.GetOrAddDescription(newDescInput);
         var newValue = cache.GetOrAddValue(newValueInput);
 
-        Assert.NotSame(oldDesc, newDesc); // Different reference after clear (description cache)
-        Assert.NotSame(oldValue, newValue); // Different reference after clear (value cache)
+        Assert.NotSame(oldDesc, newDesc);
+        Assert.NotSame(oldValue, newValue);
 
-        // But subsequent calls with the same inputs should return cached instances
         var desc2 = cache.GetOrAddDescription(new string("Test Description".ToCharArray()));
         var value2 = cache.GetOrAddValue(new string("Test Value".ToCharArray()));
 
-        Assert.Same(newDesc, desc2); // Should cache the new description instance
-        Assert.Same(newValue, value2); // Should cache the new value instance
+        Assert.Same(newDesc, desc2);
+        Assert.Same(newValue, value2);
     }
 
     [Fact]
     public void ClearAll_ConcurrentCalls_ShouldHandleThreadSafely()
     {
-        // Arrange
         var cache = new EventResolverCache();
         for (int i = 0; i < 100; i++)
         {
@@ -56,13 +51,10 @@ public void ClearAll_ConcurrentCalls_ShouldHandleThreadSafely()
             cache.GetOrAddValue($"Value{i}");
         }
 
-        // Act
         var exception = Record.Exception(() => Parallel.For(0, 10, _ => cache.ClearAll()));
 
-        // Assert
         Assert.Null(exception);
 
-        // Verify post-condition: after clear, new inputs return new instances
         var newInput = new string("PostClear".ToCharArray());
         var result = cache.GetOrAddDescription(newInput);
         Assert.Same(newInput, result);
@@ -71,138 +63,28 @@ public void ClearAll_ConcurrentCalls_ShouldHandleThreadSafely()
     [Fact]
     public void ClearAll_WithEmptyCaches_ShouldNotThrow()
     {
-        // Arrange
         var cache = new EventResolverCache();
 
-        // Act
         var exception = Record.Exception(() => cache.ClearAll());
 
-        // Assert
         Assert.Null(exception);
     }
 
-    [Theory]
-    [InlineData(CacheKind.Description)]
-    [InlineData(CacheKind.Value)]
-    public void GetOrAdd_CalledMultipleTimes_ShouldReturnSameReference(CacheKind kind)
-    {
-        // Arrange
-        var cache = new EventResolverCache();
-        var input = $"Test {kind}";
-
-        // Act
-        var result1 = GetOrAdd(cache, kind, input);
-        var result2 = GetOrAdd(cache, kind, input);
-        var result3 = GetOrAdd(cache, kind, input);
-
-        // Assert
-        Assert.Same(result1, result2);
-        Assert.Same(result2, result3);
-    }
-
-    [Theory]
-    [InlineData(CacheKind.Description)]
-    [InlineData(CacheKind.Value)]
-    public void GetOrAdd_ConcurrentCalls_ShouldHandleThreadSafely(CacheKind kind)
-    {
-        // Arrange
-        var cache = new EventResolverCache();
-        var results = new string[100];
-
-        // Act
-        Parallel.For(0, 100, i =>
-        {
-            results[i] = GetOrAdd(cache, kind, $"{kind}{i % 10}");
-        });
-
-        // Assert
-        // 100 calls were spread across 10 distinct keys ("{kind}0" .. "{kind}9"), 10 calls per key.
-        // For each key, every occurrence must be the same reference (de-dup contract under
-        // contention). The previous loop only stepped i by 10, which meant i % 10 was always 0
-        // and only key "{kind}0" was actually validated; iterating each key 0..9 explicitly
-        // covers all ten distinct cache slots so a regression in any one of them fails the test.
-        for (int key = 0; key < 10; key++)
-        {
-            var expected = results[key];
-            Assert.NotNull(expected);
-
-            for (int occurrence = 1; occurrence < 10; occurrence++)
-            {
-                Assert.Same(expected, results[key + (occurrence * 10)]);
-            }
-        }
-    }
-
-    [Theory]
-    [InlineData(CacheKind.Description, "Description 1", "Description 2")]
-    [InlineData(CacheKind.Value, "Value 1", "Value 2")]
-    public void GetOrAdd_WithDifferentInputs_ShouldReturnDifferentReferences(CacheKind kind, string a, string b)
-    {
-        // Arrange
-        var cache = new EventResolverCache();
-
-        // Act
-        var result1 = GetOrAdd(cache, kind, a);
-        var result2 = GetOrAdd(cache, kind, b);
-
-        // Assert
-        Assert.NotSame(result1, result2);
-        Assert.Equal(a, result1);
-        Assert.Equal(b, result2);
-    }
-
-    [Theory]
-    [InlineData(CacheKind.Description)]
-    [InlineData(CacheKind.Value)]
-    public void GetOrAdd_WithEmptyString_ShouldReturnSameEmptyStringReference(CacheKind kind)
-    {
-        // Arrange
-        var cache = new EventResolverCache();
-
-        // Act
-        var result1 = GetOrAdd(cache, kind, string.Empty);
-        var result2 = GetOrAdd(cache, kind, string.Empty);
-
-        // Assert
-        Assert.Same(result1, result2);
-        Assert.Equal(string.Empty, result1);
-    }
-
-    [Theory]
-    [InlineData(CacheKind.Description)]
-    [InlineData(CacheKind.Value)]
-    public void GetOrAdd_WithNewString_ShouldAddToCache(CacheKind kind)
-    {
-        // Arrange
-        var cache = new EventResolverCache();
-        var input = new string("Test".ToCharArray()); // Force new string instance
-
-        // Act
-        var result = GetOrAdd(cache, kind, input);
-
-        // Assert
-        Assert.Equal(input, result);
-    }
-
     [Fact]
     public void GetOrAddDescription_AtCap_ShouldStopCachingButKeepServingExistingHits()
     {
-        // Arrange - a tiny cap so the bound is reachable without inserting 131072 entries.
         var cache = new EventResolverCache(maxDescriptionCacheSize: 2);
 
         var first = cache.GetOrAddDescription(new string("desc-A".ToCharArray()));
         var second = cache.GetOrAddDescription(new string("desc-B".ToCharArray()));
 
-        // Act - the third distinct description is at the cap, so it is returned as-is (not cached).
         var overflowInput = new string("desc-C".ToCharArray());
         var overflow = cache.GetOrAddDescription(overflowInput);
         var overflowAgain = cache.GetOrAddDescription(new string("desc-C".ToCharArray()));
 
-        // Assert - overflow entry is never interned (different instance each time)...
         Assert.Same(overflowInput, overflow);
         Assert.NotSame(overflow, overflowAgain);
 
-        // ...but entries cached before the cap still dedupe (sharing is preserved, no thrash/clear).
         Assert.Same(first, cache.GetOrAddDescription(new string("desc-A".ToCharArray())));
         Assert.Same(second, cache.GetOrAddDescription(new string("desc-B".ToCharArray())));
     }
@@ -210,14 +92,11 @@ public void GetOrAddDescription_AtCap_ShouldStopCachingButKeepServingExistingHit
     [Fact]
     public void GetOrAddDescription_BelowCap_ShouldInternIdenticalDescriptions()
     {
-        // Arrange
         var cache = new EventResolverCache();
 
-        // Act - two distinct instances with identical content (mirrors many events sharing a description).
         var a = cache.GetOrAddDescription(new string("recurring description".ToCharArray()));
         var b = cache.GetOrAddDescription(new string("recurring description".ToCharArray()));
 
-        // Assert - interned to one shared instance.
         Assert.Same(a, b);
     }
 
@@ -399,6 +278,89 @@ public void GetOrAddSid_WithSameSid_ShouldReturnSameReference()
         Assert.Same(first, second);
     }
 
+    [Theory]
+    [InlineData(CacheKind.Description)]
+    [InlineData(CacheKind.Value)]
+    public void GetOrAdd_CalledMultipleTimes_ShouldReturnSameReference(CacheKind kind)
+    {
+        var cache = new EventResolverCache();
+        var input = $"Test {kind}";
+
+        var result1 = GetOrAdd(cache, kind, input);
+        var result2 = GetOrAdd(cache, kind, input);
+        var result3 = GetOrAdd(cache, kind, input);
+
+        Assert.Same(result1, result2);
+        Assert.Same(result2, result3);
+    }
+
+    [Theory]
+    [InlineData(CacheKind.Description)]
+    [InlineData(CacheKind.Value)]
+    public void GetOrAdd_ConcurrentCalls_ShouldHandleThreadSafely(CacheKind kind)
+    {
+        var cache = new EventResolverCache();
+        var results = new string[100];
+
+        Parallel.For(0, 100, i =>
+        {
+            results[i] = GetOrAdd(cache, kind, $"{kind}{i % 10}");
+        });
+
+        for (int key = 0; key < 10; key++)
+        {
+            var expected = results[key];
+            Assert.NotNull(expected);
+
+            for (int occurrence = 1; occurrence < 10; occurrence++)
+            {
+                Assert.Same(expected, results[key + (occurrence * 10)]);
+            }
+        }
+    }
+
+    [Theory]
+    [InlineData(CacheKind.Description, "Description 1", "Description 2")]
+    [InlineData(CacheKind.Value, "Value 1", "Value 2")]
+    public void GetOrAdd_WithDifferentInputs_ShouldReturnDifferentReferences(CacheKind kind, string a, string b)
+    {
+        var cache = new EventResolverCache();
+
+        var result1 = GetOrAdd(cache, kind, a);
+        var result2 = GetOrAdd(cache, kind, b);
+
+        Assert.NotSame(result1, result2);
+        Assert.Equal(a, result1);
+        Assert.Equal(b, result2);
+    }
+
+    [Theory]
+    [InlineData(CacheKind.Description)]
+    [InlineData(CacheKind.Value)]
+    public void GetOrAdd_WithEmptyString_ShouldReturnSameEmptyStringReference(CacheKind kind)
+    {
+        var cache = new EventResolverCache();
+
+        var result1 = GetOrAdd(cache, kind, string.Empty);
+        var result2 = GetOrAdd(cache, kind, string.Empty);
+
+        Assert.Same(result1, result2);
+        Assert.Equal(string.Empty, result1);
+    }
+
+    [Theory]
+    [InlineData(CacheKind.Description)]
+    [InlineData(CacheKind.Value)]
+    public void GetOrAdd_WithNewString_ShouldAddToCache(CacheKind kind)
+    {
+        var cache = new EventResolverCache();
+        var input = new string("Test".ToCharArray());
+
+        var result = GetOrAdd(cache, kind, input);
+
+        Assert.Equal(input, result);
+    }
+
     [Fact]
     public void MixedOperations_AllCachesConcurrentWithClearAll_ShouldHandleThreadSafely()
     {
@@ -409,7 +371,7 @@ public void MixedOperations_AllCachesConcurrentWithClearAll_ShouldHandleThreadSa
                 () => { for (int i = 0; i < 100; i++) { cache.GetOrAddValue($"Value{i}"); } },
                 () => { for (int i = 0; i < 100; i++) { cache.GetOrAddKeywords(new List<string> { $"Keyword{i % 10}" }); } },
                 () => { for (int i = 0; i < 100; i++) { cache.GetOrAddSid(new SecurityIdentifier($"S-1-5-{18 + (i % 3)}")); } },
-                () => { for (int i = 0; i < 10; i++) { Thread.Sleep(5); cache.ClearAll(); } }));
+                () => { for (int i = 0; i < 10; i++) { Thread.Sleep(ClearAllInterleaveDelayMilliseconds); cache.ClearAll(); } }));
 
         Assert.Null(exception);
     }
@@ -417,10 +379,8 @@ public void MixedOperations_AllCachesConcurrentWithClearAll_ShouldHandleThreadSa
     [Fact]
     public void MixedOperations_ConcurrentDescriptionAndValueAccess_ShouldHandleThreadSafely()
     {
-        // Arrange
         var cache = new EventResolverCache();
 
-        // Act
         var exception = Record.Exception(() =>
             Parallel.For(0, 100, i =>
             {
@@ -434,17 +394,14 @@ public void MixedOperations_ConcurrentDescriptionAndValueAccess_ShouldHandleThre
                 }
             }));
 
-        // Assert
         Assert.Null(exception);
     }
 
     [Fact]
     public void MixedOperations_ConcurrentWithClearAll_ShouldHandleThreadSafely()
     {
-        // Arrange
         var cache = new EventResolverCache();
 
-        // Act
         var exception = Record.Exception(() =>
             Parallel.Invoke(
                 () =>
@@ -465,30 +422,24 @@ public void MixedOperations_ConcurrentWithClearAll_ShouldHandleThreadSafely()
                 {
                     for (int i = 0; i < 10; i++)
                     {
-                        Thread.Sleep(5);
+                        Thread.Sleep(ClearAllInterleaveDelayMilliseconds);
                         cache.ClearAll();
                     }
                 }
             ));
 
-        // Assert
         Assert.Null(exception);
     }
 
     [Fact]
     public void SeparateCaches_DescriptionAndValue_ShouldNotInterfere()
     {
-        // Arrange
         var cache = new EventResolverCache();
         var sharedString = "Shared";
 
-        // Act
         var description = cache.GetOrAddDescription(sharedString);
         var value = cache.GetOrAddValue(sharedString);
 
-        // Assert
-        // Even though they have the same content, they should be cached separately
-        // and both should work independently
         Assert.Equal(sharedString, description);
         Assert.Equal(sharedString, value);
     }
diff --git a/tests/Unit/EventLogExpert.Eventing.Tests/Resolvers/EventXmlResolverTests.cs b/tests/Unit/EventLogExpert.Eventing.Tests/Resolvers/EventXmlResolverTests.cs
index ce2a871c7..9560a2b16 100644
--- a/tests/Unit/EventLogExpert.Eventing.Tests/Resolvers/EventXmlResolverTests.cs
+++ b/tests/Unit/EventLogExpert.Eventing.Tests/Resolvers/EventXmlResolverTests.cs
@@ -9,6 +9,8 @@ namespace EventLogExpert.Eventing.Tests.Resolvers;
 
 public sealed class EventXmlResolverTests
 {
+    private static readonly TimeSpan s_testTimeout = TimeSpan.FromSeconds(5);
+
     [Fact]
     public async Task ClearAll_RemovesEveryEntry()
     {
@@ -42,11 +44,9 @@ public async Task ClearXmlCacheForLog_RemovesEntriesForThatLogOnly()
 
         resolver.ClearXmlCacheForLog("A");
 
-        // B is untouched.
         await resolver.GetXmlAsync(evtB1, TestContext.Current.CancellationToken);
         Assert.Equal(3, getResolveCallCount());
 
-        // A entries were evicted; both are re-resolved.
         await resolver.GetXmlAsync(evtA1, TestContext.Current.CancellationToken);
         await resolver.GetXmlAsync(evtA2, TestContext.Current.CancellationToken);
         Assert.Equal(5, getResolveCallCount());
@@ -55,7 +55,6 @@ public async Task ClearXmlCacheForLog_RemovesEntriesForThatLogOnly()
     [Fact]
     public async Task GetXmlAsync_AtCapacity_EvictsLeastRecentlyUsed()
     {
-        // Initial = max = 2, so eviction kicks in once we exceed 2 entries.
         var resolver = CreateBoundedTrackingResolver(
             key => $"<xml log='{key.OwningLog}' id='{key.RecordId}'/>",
             out var getResolveCallCount,
@@ -68,16 +67,13 @@ public async Task GetXmlAsync_AtCapacity_EvictsLeastRecentlyUsed()
 
         await resolver.GetXmlAsync(evtA, TestContext.Current.CancellationToken);
         await resolver.GetXmlAsync(evtB, TestContext.Current.CancellationToken);
-        // Touch A so B becomes the least-recently-used entry.
         await resolver.GetXmlAsync(evtA, TestContext.Current.CancellationToken);
         await resolver.GetXmlAsync(evtC, TestContext.Current.CancellationToken);
 
-        // A and C should still be cached (B was evicted as LRU); A re-request must not re-resolve.
         await resolver.GetXmlAsync(evtA, TestContext.Current.CancellationToken);
         await resolver.GetXmlAsync(evtC, TestContext.Current.CancellationToken);
         Assert.Equal(3, getResolveCallCount());
 
-        // Re-requesting B triggers another resolve since it was evicted.
         await resolver.GetXmlAsync(evtB, TestContext.Current.CancellationToken);
         Assert.Equal(4, getResolveCallCount());
     }
@@ -89,7 +85,7 @@ public async Task GetXmlAsync_ConcurrentRequestsForSameKey_ResolveOnce()
         var resolver = CreateTrackingResolver(
             _ =>
             {
-                gate.Wait(TimeSpan.FromSeconds(5));
+                gate.Wait(s_testTimeout);
 
                 return "<xml/>";
             },
diff --git a/tests/Unit/EventLogExpert.Filtering.Tests/Compilation/FilterServiceColumnSurvivorTests.cs b/tests/Unit/EventLogExpert.Filtering.Tests/Compilation/FilterServiceColumnSurvivorTests.cs
index c07988a75..8d933f0ac 100644
--- a/tests/Unit/EventLogExpert.Filtering.Tests/Compilation/FilterServiceColumnSurvivorTests.cs
+++ b/tests/Unit/EventLogExpert.Filtering.Tests/Compilation/FilterServiceColumnSurvivorTests.cs
@@ -12,21 +12,13 @@
 
 namespace EventLogExpert.Filtering.Tests.Compilation;
 
-/// <summary>
-///     Differential parity gate asserting <see cref="FilterService.GetSurvivingOrder" /> over a real
-///     <c>EventColumnStore</c> reader returns exactly the AoS oracle survivor set (
-///     <c>MatchesFilters &amp;&amp; MatchesDateFilter</c>) for every battery filter.
-/// </summary>
 public sealed class FilterServiceColumnSurvivorTests
 {
     private static readonly DateTime s_baseTime = new(2024, 6, 1, 0, 0, 0, DateTimeKind.Utc);
-
-    private static readonly IReadOnlyList<ResolvedEvent> s_corpus = BuildCorpus();
-
+    private static readonly IReadOnlyList<ResolvedEvent> s_sample = BuildSample();
     private static readonly IEventColumnReader s_reader =
-        EventColumnStore.Build(s_corpus, generation: 0, contentVersion: 0).CreateReader(EventLogId.Create());
+        EventColumnStore.Build(s_sample, generation: 0, contentVersion: 0).CreateReader(EventLogId.Create());
 
-    // The filter combos exercised against the oracle. Names are xUnit-serializable; ResolveFilter maps each to a Filter.
     public static TheoryData<string> Battery =>
     [
         "empty-no-filters",
@@ -58,10 +50,10 @@ public void GetSurvivingOrder_ForEveryBatteryFilter_MatchesAosOracleSet(string c
 
         var expected = new HashSet<int>();
 
-        for (var index = 0; index < s_corpus.Count; index++)
+        for (var index = 0; index < s_sample.Count; index++)
         {
-            if (s_corpus[index].MatchesFilters(filter.Filters) &&
-                s_corpus[index].MatchesDateFilter(filter.DateFilter))
+            if (s_sample[index].MatchesFilters(filter.Filters) &&
+                s_sample[index].MatchesDateFilter(filter.DateFilter))
             {
                 expected.Add(index);
             }
@@ -79,17 +71,15 @@ public void GetSurvivingOrder_ForEveryBatteryFilter_MatchesAosOracleSet(string c
     [Fact]
     public void GetSurvivingOrder_WhenDateRange_IncludesBothBoundariesInclusive()
     {
-        DateTime after = s_corpus[2].TimeCreated;
-        DateTime before = s_corpus[7].TimeCreated;
+        DateTime after = s_sample[2].TimeCreated;
+        DateTime before = s_sample[7].TimeCreated;
         var filter = new Filter(EnabledDate(after, before), []);
 
         var survivors = new HashSet<int>(FilterService.GetSurvivingOrder(s_reader, filter));
 
-        // Both endpoints are inclusive: the row exactly at After (2) and the row exactly at Before (7) survive.
         Assert.Contains(2, survivors);
         Assert.Contains(7, survivors);
 
-        // Rows immediately outside the range do not.
         Assert.DoesNotContain(1, survivors);
         Assert.DoesNotContain(8, survivors);
     }
@@ -100,13 +90,12 @@ public void GetSurvivingOrder_WhenExcludeFilterYieldsUnknown_HidesOnlyDecisiveMa
         SavedFilter exclude = Exclude("UserData[\"Secret\"] == \"hidden\"");
         CompiledFilter compiled = exclude.Compiled!;
 
-        Assert.Equal(FilterMatch.Unknown, Oracle(compiled, s_corpus[7]));
-        Assert.Equal(FilterMatch.Match, Oracle(compiled, s_corpus[8]));
-        Assert.Equal(FilterMatch.Unknown, Oracle(compiled, s_corpus[9]));
+        Assert.Equal(FilterMatch.Unknown, Oracle(compiled, s_sample[7]));
+        Assert.Equal(FilterMatch.Match, Oracle(compiled, s_sample[8]));
+        Assert.Equal(FilterMatch.Unknown, Oracle(compiled, s_sample[9]));
 
         var survivors = new HashSet<int>(FilterService.GetSurvivingOrder(s_reader, new Filter(null, [exclude])));
 
-        // Exclude hides only the decisive Match (8); the Unknown rows (7, 9) stay visible.
         Assert.DoesNotContain(8, survivors);
         Assert.Contains(7, survivors);
         Assert.Contains(9, survivors);
@@ -118,15 +107,12 @@ public void GetSurvivingOrder_WhenIncludeFilterYieldsUnknown_KeepsThoseRowsVisib
         SavedFilter include = Include("UserData[\"Secret\"] == \"hidden\"");
         CompiledFilter compiled = include.Compiled!;
 
-        // Precondition: the tri-state oracle yields Unknown for the truncated (7) and incomplete-absent (9) rows and a
-        // decisive Match for the complete row (8). Without this the "keeps visible" assertion below would be vacuous.
-        Assert.Equal(FilterMatch.Unknown, Oracle(compiled, s_corpus[7]));
-        Assert.Equal(FilterMatch.Match, Oracle(compiled, s_corpus[8]));
-        Assert.Equal(FilterMatch.Unknown, Oracle(compiled, s_corpus[9]));
+        Assert.Equal(FilterMatch.Unknown, Oracle(compiled, s_sample[7]));
+        Assert.Equal(FilterMatch.Match, Oracle(compiled, s_sample[8]));
+        Assert.Equal(FilterMatch.Unknown, Oracle(compiled, s_sample[9]));
 
         var survivors = new HashSet<int>(FilterService.GetSurvivingOrder(s_reader, new Filter(null, [include])));
 
-        // Include keeps a row on Match OR Unknown; all three UserData rows survive.
         Assert.Contains(7, survivors);
         Assert.Contains(8, survivors);
         Assert.Contains(9, survivors);
@@ -136,7 +122,7 @@ private static void AssertAscendingDistinctPhysicalIndices(IReadOnlyList<int> su
     {
         for (var position = 0; position < survivors.Count; position++)
         {
-            Assert.InRange(survivors[position], 0, s_corpus.Count - 1);
+            Assert.InRange(survivors[position], 0, s_sample.Count - 1);
 
             if (position > 0)
             {
@@ -147,9 +133,8 @@ private static void AssertAscendingDistinctPhysicalIndices(IReadOnlyList<int> su
         }
     }
 
-    private static IReadOnlyList<ResolvedEvent> BuildCorpus() =>
+    private static IReadOnlyList<ResolvedEvent> BuildSample() =>
     [
-        // 0-4: scalar events driving the include/exclude scalar, contains, multi-equals and date arms.
         FilterEventBuilder.CreateTestEvent(
             id: 100, source: "TestSource", level: "Error", computerName: "SERVER01",
             timeCreated: s_baseTime.AddMinutes(0)),
@@ -166,13 +151,11 @@ private static IReadOnlyList<ResolvedEvent> BuildCorpus() =>
             id: 100, source: "TestSource", level: "Information", computerName: "WORKSTATION",
             timeCreated: s_baseTime.AddMinutes(4)),
 
-        // 5-6: EventData events for the presence-required named-field (exact and wildcard) arms.
         EventDataTestFactory.CreateEventWithData(("User", "admin"))
             with { Id = 500, TimeCreated = s_baseTime.AddMinutes(5) },
         EventDataTestFactory.CreateEventWithData(("User", "guest"))
             with { Id = 600, TimeCreated = s_baseTime.AddMinutes(6) },
 
-        // 7: UserData present, truncated, and non-matching -> tri-state Unknown on '==' (the truncated tail could differ).
         new ResolvedEvent("TestLog", LogPathType.Channel)
         {
             Id = 700,
@@ -180,7 +163,6 @@ private static IReadOnlyList<ResolvedEvent> BuildCorpus() =>
             UserData = [new UserDataField("Secret", ["hid"], IsTruncated: true)]
         },
 
-        // 8: UserData present and complete -> decisive Match on '=='.
         new ResolvedEvent("TestLog", LogPathType.Channel)
         {
             Id = 800,
@@ -188,7 +170,6 @@ private static IReadOnlyList<ResolvedEvent> BuildCorpus() =>
             UserData = [new UserDataField("Secret", ["hidden"], IsTruncated: false)]
         },
 
-        // 9: UserDataIncomplete with the probed path absent -> keep-visible Unknown on '=='.
         new ResolvedEvent("TestLog", LogPathType.Channel)
         {
             Id = 900,
diff --git a/tests/Unit/EventLogExpert.Filtering.Tests/Emit/ColumnEmitterParityTests.cs b/tests/Unit/EventLogExpert.Filtering.Tests/Emit/ColumnEmitterParityTests.cs
index 7c4cd5848..ecf031c4d 100644
--- a/tests/Unit/EventLogExpert.Filtering.Tests/Emit/ColumnEmitterParityTests.cs
+++ b/tests/Unit/EventLogExpert.Filtering.Tests/Emit/ColumnEmitterParityTests.cs
@@ -11,15 +11,6 @@
 
 namespace EventLogExpert.Filtering.Tests.Emit;
 
-/// <summary>
-///     Differential parity gate for the column-direct backend. Every battery expression is compiled by both backends;
-///     for each synthetic corpus event the column tri-state result must equal the row oracle (
-///     <c>Evaluate ?? (Predicate ? Match : NoMatch)</c>). Running the column emitter over the row-backed
-///     <see cref="LegacyEventColumnReader" /> isolates the emitter-arm logic; the store parity tests already prove the
-///     real column store reads identically to the legacy reader, so column-over-store equals column-over-legacy
-///     transitively. The corpus deliberately exercises every null/absence case (null UserId, absent nullable ids,
-///     empty/present Xml, multi-value EventData with an absent named field, present + truncated + absent UserData paths).
-/// </summary>
 public sealed class ColumnEmitterParityTests
 {
     private static readonly ResolvedEvent s_eventDataOther =
@@ -31,6 +22,7 @@ public sealed class ColumnEmitterParityTests
         ("Path", @"C:\Windows\System32\cmd.exe"),
         ("Dup", "first"),
         ("Dup", "second"));
+
     private static readonly ResolvedEvent s_readerEnablerEvent = new("TestLog", LogPathType.Channel)
     {
         Id = 700,
@@ -54,7 +46,7 @@ public sealed class ColumnEmitterParityTests
             new UserDataField("Trunc", ["y"], IsTruncated: true)
         ]
     };
-    private static readonly IReadOnlyList<ResolvedEvent> s_corpus =
+    private static readonly IReadOnlyList<ResolvedEvent> s_sample =
     [
         FilterTestFixtures.FullyPopulated,
         FilterTestFixtures.NoNullables,
@@ -68,37 +60,23 @@ public sealed class ColumnEmitterParityTests
         s_userDataIncompleteEvent,
         s_readerEnablerEvent
     ];
+    private static readonly IEventColumnReader s_reader = EventColumnStore
+        .Build([.. s_sample], generation: 1, contentVersion: 1)
+        .CreateReader(EventLogId.Create());
 
-    // Index 1 is FilterTestFixtures.NoNullables: the null-UserId + absent-nullable-ids event that drives the null-vs-present asymmetry.
-
-    // Multi-value EventData: typed values (Int64/bool), a duplicate name (first-wins), and a probed-absent name ("Missing").
-
-    private static readonly LegacyEventColumnReader s_reader =
-        new(EventLogId.Create(), generation: 1, contentVersion: 1, s_corpus);
-
-    // UserDataIncomplete: an absent key yields a keep-visible truncated (not decisive-absent) result.
-
-    /// <summary>
-    ///     The parity battery, each expression tagged with the arm it exercises and the null/absence case(s) it
-    ///     exercises. Every expression compiles on both backends and is differentially checked against all eleven corpus
-    ///     events.
-    /// </summary>
     public static TheoryData<string> DifferentialBattery =>
     [
-        // AndNode / OrNode: lazy tri-state combine (2/3-way, nested, short-circuit).
         "Id == 100 && Source == \"TestSource\"",
         "Id == 100 || Id == 200",
         "(Id == 100 || Id == 200) && Level == \"Error\"",
         "Id == 100 && Source == \"TestSource\" && Level == \"Error\" && ComputerName == \"SERVER01\"",
         "Id == 100 || Id == 200 || Id == 300 || Id == 400",
 
-        // NotNode: general !inner lifted (over scalar, string, and nullable comparisons).
         "!(Id == 100)",
         "!(Source == \"TestSource\")",
         "!(ProcessId == 4)",
         "!(ProcessId != 4)",
 
-        // ComparisonNode typed scalar: Id (non-nullable) and nullable ids.
         "Id == 100",
         "Id != 100",
         "Id > 100",
@@ -116,7 +94,6 @@ public sealed class ColumnEmitterParityTests
         "ActivityId == \"11111111-2222-3333-4444-555555555555\"",
         "ActivityId != \"11111111-2222-3333-4444-555555555555\"",
 
-        // ComparisonNode string-form: string props (always String kind), Id/nullable-id ToString ("" branch).
         "Source == \"TestSource\"",
         "Source != \"TestSource\"",
         "ComputerName == \"SERVER01\"",
@@ -126,11 +103,9 @@ public sealed class ColumnEmitterParityTests
         "ProcessId.ToString() == \"4\"",
         "ProcessId.ToString() != \"4\"",
 
-        // UserId string-form (presence-required): the paired null-guard folds into a single UserId comparison.
         "UserId != null && UserId.Value == \"S-1-5-18\"",
         "UserId != null && UserId.Value != \"S-1-5-18\"",
 
-        // ContainsNode: string props, numeric-id ToString form, UserId (presence-required), and the NOT(UserId.Contains) special.
         "Source.Contains(\"Test\")",
         "Source.Contains(\"test\", StringComparison.OrdinalIgnoreCase)",
         "Description.Contains(\"error occurred\", StringComparison.OrdinalIgnoreCase)",
@@ -140,7 +115,6 @@ public sealed class ColumnEmitterParityTests
         "UserId != null && UserId.Value.Contains(\"S-1-5\", StringComparison.OrdinalIgnoreCase)",
         "UserId != null && !UserId.Value.Contains(\"S-1-5-99\", StringComparison.OrdinalIgnoreCase)",
 
-        // ComparisonNode null-literal (EmitNullComparison): nullable ids, UserId, string props, Id.
         "ProcessId == null",
         "ProcessId != null",
         "ThreadId == null",
@@ -154,10 +128,6 @@ public sealed class ColumnEmitterParityTests
         "Id == null",
         "Id != null",
 
-        // MultiEqualsNode: Int (Id), String (Level, Source), nullable-int absent guard (ProcessId), the
-        // presence-required UserId arm (exercised over the null-UserId corpus event), and the RecordId/ActivityId
-        // dispatch. All reachable via the ordinary array-contains path (Lowerer.ResolveFieldOrToString ->
-        // PropertyResolver), NOT the UserId null-guard collapse.
         "(new[] {\"100\", \"200\"}).Contains(Id.ToString())",
         "(new[] {\"Error\", \"Warning\"}).Contains(Level.ToString())",
         "(new[] {\"TestSource\", \"OtherSource\"}).Contains(Source)",
@@ -166,8 +136,6 @@ public sealed class ColumnEmitterParityTests
         "(new[] {\"1234567890123\", \"999\"}).Contains(RecordId.ToString())",
         "(new[] {\"11111111-2222-3333-4444-555555555555\"}).Contains(ActivityId.ToString())",
 
-        // Multi-select honoring the operator over scalar strings: Is Any Of / Contains Any / Is None Of / Contains
-        // None, including presence-required UserId (corpus[1] NoNullables has a null UserId) and Opcode.
         "(new[] {\"Test\", \"Other\"}).Any(e => Source.Contains(e, StringComparison.OrdinalIgnoreCase))",
         "!(new[] {\"TestSource\"}).Contains(Source)",
         "!(new[] {\"Test\"}).Any(e => Source.Contains(e, StringComparison.OrdinalIgnoreCase))",
@@ -178,7 +146,6 @@ public sealed class ColumnEmitterParityTests
         "!(new[] {\"S-1-5-99\"}).Contains(UserId)",
         "!(new[] {\"S-1-5-99\"}).Any(e => UserId.Contains(e, StringComparison.OrdinalIgnoreCase))",
 
-        // EventData exact-name (presence-required, all ops; typed coercion; duplicate-name first-wins; absent name).
         "EventData[\"User\"] == \"admin\"",
         "EventData[\"User\"] != \"admin\"",
         "EventData[\"User\"] != \"other\"",
@@ -194,7 +161,6 @@ public sealed class ColumnEmitterParityTests
         "EventData[\"Missing\"] == \"x\"",
         "EventData[\"Missing\"] != \"x\"",
 
-        // UserData exact-path (tri-state via the shared UserDataMatch core): present, truncated, incomplete, absent, nested.
         "UserData[\"Foo\"] == \"adminvalue\"",
         "UserData[\"Foo\"] != \"adminvalue\"",
         "UserData[\"Foo\"].Contains(\"admin\", StringComparison.OrdinalIgnoreCase)",
@@ -208,21 +174,15 @@ public sealed class ColumnEmitterParityTests
         "UserData[\"Absent\"] == \"x\"",
         "UserData[\"Foo/Bar\"] == \"x\"",
 
-        // Mixed UserData + scalar: tri-state combine of a decisive scalar arm with a tri-state UserData arm.
         "Id == 100 && UserData[\"Foo\"] == \"adminvalue\"",
         "Id == 999 || UserData[\"Foo\"] == \"adminvalue\"",
         "Id == 100 && Xml.Contains(\"data\")",
 
-        // P2-4b Keywords.Any (three lowered shapes): positive over corpus[0] (Keywords [Audit, System]), negative
-        // elsewhere. The ordinal MatchAnyOf shape with lowercase needles matches nothing; the "System" shape matches corpus[0].
         "Keywords.Any(e => string.Equals(e, \"Audit\", StringComparison.OrdinalIgnoreCase))",
         "Keywords.Any(e => e.Contains(\"audit\", StringComparison.OrdinalIgnoreCase))",
         "Keywords.Any(e => (new[] {\"audit\", \"system\"}).Contains(e))",
         "Keywords.Any(e => (new[] {\"System\", \"Nope\"}).Contains(e))",
 
-        // P2-4b wildcard EventData field names (positional enumeration over corpus[6] rich EventData): exact-op equality
-        // AND inequality, Contains, MultiEquals, the non-first duplicate ("Du*" must reach the 2nd Dup -> "second"), and
-        // empty-match globs.
         "EventData[\"Us*\"] == \"admin\"",
         "EventData[\"Us*\"] != \"admin\"",
         "EventData[\"Pat*\"].Contains(\"cmd\", StringComparison.OrdinalIgnoreCase)",
@@ -232,9 +192,6 @@ public sealed class ColumnEmitterParityTests
         "EventData[\"*zzz*\"] == \"x\"",
         "EventData[\"*cert*\"] == \"x\"",
 
-        // Opcode (pooled string) + RelatedActivityId (nullable Guid): the reader-enabler fields. Opcode exercises the
-        // string-form, Contains, and MultiEquals(String) arms; RelatedActivityId exercises the typed-Guid, ToString
-        // Contains/MultiEquals, and null-comparison arms. corpus[10] sets both; every other event leaves them empty/null.
         "Opcode == \"Start\"",
         "Opcode != \"Start\"",
         "Opcode.Contains(\"tar\", StringComparison.OrdinalIgnoreCase)",
@@ -246,8 +203,6 @@ public sealed class ColumnEmitterParityTests
         "RelatedActivityId.ToString().Contains(\"aaaa\", StringComparison.OrdinalIgnoreCase)",
         "(new[] {\"aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee\"}).Contains(RelatedActivityId.ToString())",
 
-        // P2-4b glob UserData paths (tri-state): present match on corpus[8] Foo, truncated Trunc -> Unknown, and the
-        // incomplete-tail Unknown over corpus[9] (UserDataIncomplete, no path matches -> keep-visible Unknown).
         "UserData[\"*oo\"] == \"adminvalue\"",
         "UserData[\"Tr*\"].Contains(\"y\")",
         "(new[] {\"zzz\", \"admin\"}).Any(e => UserData[\"*oo\"].Contains(e, StringComparison.OrdinalIgnoreCase))",
@@ -257,7 +212,7 @@ public sealed class ColumnEmitterParityTests
 
     [Theory]
     [MemberData(nameof(DifferentialBattery))]
-    public void ColumnBackend_MatchesRowOracle_AcrossCorpus(string expression)
+    public void ColumnBackend_MatchesRowOracle_AcrossSample(string expression)
     {
         Assert.True(
             FilterParser.TryCompile(expression, out CompiledFilter? row, out var rowError),
@@ -268,20 +223,17 @@ public void ColumnBackend_MatchesRowOracle_AcrossCorpus(string expression)
 
         Assert.Equal(row.RequiresXml, column.RequiresXml);
 
-        for (var index = 0; index < s_corpus.Count; index++)
+        for (var index = 0; index < s_sample.Count; index++)
         {
-            FilterMatch expected = Oracle(row, s_corpus[index]);
+            FilterMatch expected = Oracle(row, s_sample[index]);
             FilterMatch actual = column.Evaluate(s_reader, s_reader.LocatorAt(index));
 
             Assert.True(
                 expected == actual,
-                $"Divergence at corpus[{index}] for '{expression}': row={expected}, column={actual}.");
+                $"Divergence at sample[{index}] for '{expression}': row={expected}, column={actual}.");
         }
     }
 
-    // Absolute (not differential) oracle for EventData Contains-Any: first-needle match, second-needle match,
-    // present-but-no-needle NoMatch, and an ABSENT named field NoMatch (presence-required). Also pins the wildcard
-    // field-name path. Exact results on BOTH backends catch a same-direction emitter bug the differential battery can't.
     [Fact]
     public void EventDataContainsAny_Absolute_MatchesAnyNeedleAndRequiresPresence()
     {
@@ -325,15 +277,12 @@ public void EventDataContainsAny_Absolute_MatchesAnyNeedleAndRequiresPresence()
             s_eventDataRich,
             FilterMatch.NoMatch);
 
-        // A typed EventData value (Code = 5L) is coerced to string for the substring test.
         AssertBothBackends(
             "(new[] {\"5\", \"zzz\"}).Any(e => EventData[\"Code\"].Contains(e, StringComparison.OrdinalIgnoreCase))",
             s_eventDataRich,
             FilterMatch.Match);
     }
 
-    // MultiContains on Xml is reachable only via Advanced text (Xml is text-only in Basic), but the compiled filter
-    // must still flag RequiresXml on both backends so the columnar reader materializes Xml before evaluation.
     [Fact]
     public void MultiContains_OnXml_FlagsRequiresXmlOnBothBackends()
     {
@@ -348,8 +297,6 @@ public void MultiContains_OnXml_FlagsRequiresXmlOnBothBackends()
         Assert.True(column.RequiresXml);
     }
 
-    // Presence-required UserId: an absent UserId is NoMatch for ALL FOUR Many operators on BOTH backends. Locks the
-    // negation-presence invariant so "is none of" / "contains none" don't wrongly match a missing UserId.
     [Fact]
     public void MultiSelectOperators_AbsentUserId_IsNoMatchForAllFourOperators()
     {
@@ -367,8 +314,6 @@ public void MultiSelectOperators_AbsentUserId_IsNoMatchForAllFourOperators()
             FilterMatch.NoMatch);
     }
 
-    // Multi-select honoring the operator over a scalar string field: exact (not differential) results pin the four Many
-    // shapes (Is Any Of / Contains Any / Is None Of / Contains None) on BOTH backends.
     [Fact]
     public void MultiSelectOperators_Absolute_OverScalarString()
     {
@@ -396,7 +341,6 @@ public void MultiSelectOperators_Absolute_OverScalarString()
             otherSource,
             FilterMatch.Match);
 
-        // Second-element match: the "any of" must scan the whole list, not just element 0.
         AssertBothBackends("(new[] {\"Nope\", \"OtherSource\"}).Contains(Source)", otherSource, FilterMatch.Match);
         AssertBothBackends(
             "(new[] {\"Nope\", \"Other\"}).Any(e => Source.Contains(e, StringComparison.OrdinalIgnoreCase))",
@@ -409,8 +353,6 @@ public void MultiSelectOperators_Absolute_OverScalarString()
             FilterMatch.NoMatch);
     }
 
-    // Absolute (not differential) oracle for the Opcode reader-enabler field: exact match results pin the string-compare
-    // semantics on BOTH backends, so a same-direction bug in both emitters cannot pass.
     [Fact]
     public void OpcodeEquals_Absolute_MatchesOnlyTheExactValue()
     {
@@ -424,16 +366,12 @@ public void OpcodeEquals_Absolute_MatchesOnlyTheExactValue()
         AssertBothBackends("Opcode.Contains(\"top\", StringComparison.OrdinalIgnoreCase)", stop, FilterMatch.Match);
     }
 
-    // A nullable numeric '!=' on an absent field is Match (typed lift), unlike the presence-required UserId arms.
     [Fact]
     public void ProcessIdNotEquals_OverAbsentProcessId_IsMatch()
     {
         AssertBothBackends("ProcessId != 5", FilterTestFixtures.NoNullables, FilterMatch.Match);
     }
 
-    // Absolute oracle for the RelatedActivityId reader-enabler field: the typed-Guid equality and the null comparison must
-    // distinguish a specific Guid, a different Guid, absent (null), and present-but-Guid.Empty (the has-value flag makes
-    // Guid.Empty a real value, NOT the same as absent).
     [Fact]
     public void RelatedActivityIdComparisons_Absolute_DistinguishGuidNullAndEmpty()
     {
@@ -455,10 +393,6 @@ public void RelatedActivityIdComparisons_Absolute_DistinguishGuidNullAndEmpty()
         AssertBothBackends("RelatedActivityId != null", eventEmpty, FilterMatch.Match);
     }
 
-    // Absolute oracle for UserData Contains-Any (tri-state via the shared UserDataMatch.MultiContains core): needle match,
-    // second-needle match, complete-present no-match (NoMatch), an absent path (decisive NoMatch), and a TRUNCATED
-    // non-match (Unknown - the elided tail could contain a needle). Pins the tri-state on BOTH backends so a
-    // Unknown->NoMatch regression in the shared core cannot pass the differential battery. Also pins the wildcard path.
     [Fact]
     public void UserDataContainsAny_Absolute_TriStateAcrossPresentAbsentTruncated()
     {
@@ -475,33 +409,27 @@ public void UserDataContainsAny_Absolute_TriStateAcrossPresentAbsentTruncated()
             s_userDataPresentTruncated,
             FilterMatch.NoMatch);
 
-        // "Absent" is not present and the event is not UserDataIncomplete: decisive absent -> NoMatch.
         AssertBothBackends(
             "(new[] {\"admin\"}).Any(e => UserData[\"Absent\"].Contains(e, StringComparison.OrdinalIgnoreCase))",
             s_userDataPresentTruncated,
             FilterMatch.NoMatch);
 
-        // "Trunc" is truncated and no visible needle matches -> Unknown (keep-visible; the hidden tail could match).
         AssertBothBackends(
             "(new[] {\"zzz\", \"nomatch\"}).Any(e => UserData[\"Trunc\"].Contains(e, StringComparison.OrdinalIgnoreCase))",
             s_userDataPresentTruncated,
             FilterMatch.Unknown);
 
-        // Wildcard path resolves to "Foo": match pinned.
         AssertBothBackends(
             "(new[] {\"admin\"}).Any(e => UserData[\"*oo\"].Contains(e, StringComparison.OrdinalIgnoreCase))",
             s_userDataPresentTruncated,
             FilterMatch.Match);
 
-        // An ABSENT path on an INCOMPLETE UserData event cannot be decided absent -> Unknown (keep-visible), unlike the
-        // decisive NoMatch an absent path yields on a complete event.
         AssertBothBackends(
             "(new[] {\"anything\"}).Any(e => UserData[\"Absent\"].Contains(e, StringComparison.OrdinalIgnoreCase))",
             s_userDataIncompleteEvent,
             FilterMatch.Unknown);
     }
 
-    // UserId '==' on an absent UserId is NoMatch (presence-required).
     [Fact]
     public void UserIdEquals_OverNullUserId_IsNoMatch()
     {
@@ -511,7 +439,6 @@ public void UserIdEquals_OverNullUserId_IsNoMatch()
             FilterMatch.NoMatch);
     }
 
-    // NOT(UserId.Contains) is presence-required, so an absent UserId is NoMatch (not the naive !inner Match).
     [Fact]
     public void UserIdNotContains_OverNullUserId_IsNoMatch()
     {
@@ -521,7 +448,6 @@ public void UserIdNotContains_OverNullUserId_IsNoMatch()
             FilterMatch.NoMatch);
     }
 
-    // UserId '!=' on an absent UserId is NoMatch (presence-required), the asymmetry counterpart to ProcessId != 5.
     [Fact]
     public void UserIdNotEquals_OverNullUserId_IsNoMatch()
     {
@@ -540,7 +466,7 @@ private static void AssertBothBackends(string expression, ResolvedEvent resolved
             FilterParser.TryCompileColumn(expression, out ColumnCompiledFilter? column, out var columnError),
             $"Column backend failed to compile '{expression}': {columnError}");
 
-        var reader = new LegacyEventColumnReader(EventLogId.Create(), generation: 1, contentVersion: 1, [resolvedEvent]);
+        var reader = EventColumnStore.Build([resolvedEvent], generation: 1, contentVersion: 1).CreateReader(EventLogId.Create());
 
         Assert.Equal(expected, Oracle(row, resolvedEvent));
         Assert.Equal(expected, column.Evaluate(reader, reader.LocatorAt(0)));
diff --git a/tests/Unit/EventLogExpert.Logging.Tests/Concurrency/InterProcessFileLockTests.cs b/tests/Unit/EventLogExpert.Logging.Tests/Concurrency/InterProcessFileLockTests.cs
index 45aa55203..b35fd918a 100644
--- a/tests/Unit/EventLogExpert.Logging.Tests/Concurrency/InterProcessFileLockTests.cs
+++ b/tests/Unit/EventLogExpert.Logging.Tests/Concurrency/InterProcessFileLockTests.cs
@@ -7,6 +7,10 @@ namespace EventLogExpert.Logging.Tests.Concurrency;
 
 public sealed class InterProcessFileLockTests : IDisposable
 {
+    private static readonly TimeSpan s_acquireTimeout = TimeSpan.FromSeconds(5);
+    private static readonly TimeSpan s_contendedTimeout = TimeSpan.FromMilliseconds(300);
+    private static readonly TimeSpan s_testTimeout = TimeSpan.FromSeconds(10);
+
     private readonly string _directory =
         Path.Combine(Path.GetTempPath(), $"elx-filelock-{Guid.NewGuid():N}");
 
@@ -25,11 +29,10 @@ public void Run_ReleasesLockBetweenSequentialCalls()
         var target = TargetPath();
         var fileLock = new InterProcessFileLock("ProviderDbSchema", target);
 
-        fileLock.Run(TimeSpan.FromSeconds(5), static () => { });
+        fileLock.Run(s_acquireTimeout, static () => { });
 
-        // A second sequential acquisition must succeed, proving the handle was released on the first Run's completion.
         var ranAgain = false;
-        fileLock.Run(TimeSpan.FromSeconds(5), () => ranAgain = true);
+        fileLock.Run(s_acquireTimeout, () => ranAgain = true);
 
         Assert.True(ranAgain);
     }
@@ -42,11 +45,10 @@ public void Run_RunsActionAndLeavesSentinelFileOnDisk()
         var fileLock = new InterProcessFileLock("ProviderDbSchema", target);
 
         var ran = false;
-        fileLock.Run(TimeSpan.FromSeconds(5), () => ran = true);
+        fileLock.Run(s_acquireTimeout, () => ran = true);
 
         Assert.True(ran);
 
-        // The sentinel is deliberately never deleted (deleting it would open a pending-deletion race).
         Assert.True(File.Exists(lockPath));
     }
 
@@ -62,8 +64,8 @@ public void Run_WhenHeldByAnotherInstance_ThrowsOnTimeout()
 
         var holder = StartHolder(first, acquired, release, TestContext.Current.CancellationToken);
 
-        Assert.True(acquired.Wait(TimeSpan.FromSeconds(10), TestContext.Current.CancellationToken));
-        Assert.Throws<TimeoutException>(() => second.Run(TimeSpan.FromMilliseconds(300), static () => { }));
+        Assert.True(acquired.Wait(s_testTimeout, TestContext.Current.CancellationToken));
+        Assert.Throws<TimeoutException>(() => second.Run(s_contendedTimeout, static () => { }));
 
         release.Set();
         holder.Join();
@@ -72,6 +74,8 @@ public void Run_WhenHeldByAnotherInstance_ThrowsOnTimeout()
     [Fact]
     public void TryRun_InfiniteTimeout_WaitsForHeldLockThenAcquires()
     {
+        const int ReleaseDelayMilliseconds = 300;
+
         var target = TargetPath();
         var first = new InterProcessFileLock("ProviderDbSchema", target);
         var second = new InterProcessFileLock("ProviderDbSchema", target);
@@ -81,13 +85,11 @@ public void TryRun_InfiniteTimeout_WaitsForHeldLockThenAcquires()
 
         var holder = StartHolder(first, acquired, release, TestContext.Current.CancellationToken);
 
-        Assert.True(acquired.Wait(TimeSpan.FromSeconds(10), TestContext.Current.CancellationToken));
+        Assert.True(acquired.Wait(s_testTimeout, TestContext.Current.CancellationToken));
 
-        // Release the holder shortly after; an infinite-timeout acquire must WAIT for the release rather than
-        // treating the -1ms TimeSpan as an already-expired deadline and returning false.
         var releaser = new Thread(() =>
         {
-            Thread.Sleep(300);
+            Thread.Sleep(ReleaseDelayMilliseconds);
             release.Set();
         });
         releaser.Start();
@@ -101,9 +103,9 @@ public void TryRun_InfiniteTimeout_WaitsForHeldLockThenAcquires()
     }
 
     [Theory]
-    [InlineData(-20000)] // -2ms
-    [InlineData(-15000)] // -1.5ms: a naive (long)TotalMilliseconds cast truncates to -1 (== infinite) and slips through.
-    [InlineData(-1)]     // -1 tick: a naive cast truncates to 0 (== try-once) and slips through.
+    [InlineData(-20000)]
+    [InlineData(-15000)]
+    [InlineData(-1)]
     public void TryRun_NegativeTimeoutBelowInfinite_ThrowsArgumentOutOfRange(long ticks)
     {
         var fileLock = new InterProcessFileLock("ProviderDbSchema", TargetPath());
@@ -124,14 +126,13 @@ public void TryRun_TwoInstancesSamePath_SecondBlockedWhileFirstHolds_ThenSucceed
 
         var holder = StartHolder(first, acquired, release, TestContext.Current.CancellationToken);
 
-        Assert.True(acquired.Wait(TimeSpan.FromSeconds(10), TestContext.Current.CancellationToken));
-        Assert.False(second.TryRun(TimeSpan.FromMilliseconds(300), static () => { }));
+        Assert.True(acquired.Wait(s_testTimeout, TestContext.Current.CancellationToken));
+        Assert.False(second.TryRun(s_contendedTimeout, static () => { }));
 
         release.Set();
         holder.Join();
 
-        // The lock is released when the holder's stream is disposed, so the second instance can now acquire it.
-        Assert.True(second.TryRun(TimeSpan.FromSeconds(10), static () => { }));
+        Assert.True(second.TryRun(s_testTimeout, static () => { }));
     }
 
     private static Thread StartHolder(
@@ -140,10 +141,10 @@ private static Thread StartHolder(
         ManualResetEventSlim release,
         CancellationToken cancellationToken)
     {
-        var holder = new Thread(() => fileLock.Run(TimeSpan.FromSeconds(10), () =>
+        var holder = new Thread(() => fileLock.Run(s_testTimeout, () =>
         {
             acquired.Set();
-            release.Wait(TimeSpan.FromSeconds(10), cancellationToken);
+            release.Wait(s_testTimeout, cancellationToken);
         }));
 
         holder.Start();
diff --git a/tests/Unit/EventLogExpert.Logging.Tests/Concurrency/InterProcessMutexTests.cs b/tests/Unit/EventLogExpert.Logging.Tests/Concurrency/InterProcessMutexTests.cs
index 31b595d58..aa9840775 100644
--- a/tests/Unit/EventLogExpert.Logging.Tests/Concurrency/InterProcessMutexTests.cs
+++ b/tests/Unit/EventLogExpert.Logging.Tests/Concurrency/InterProcessMutexTests.cs
@@ -9,6 +9,10 @@ namespace EventLogExpert.Logging.Tests.Concurrency;
 
 public sealed class InterProcessMutexTests
 {
+    private static readonly TimeSpan s_acquireTimeout = TimeSpan.FromSeconds(5);
+    private static readonly TimeSpan s_contendedTimeout = TimeSpan.FromMilliseconds(300);
+    private static readonly TimeSpan s_testTimeout = TimeSpan.FromSeconds(10);
+
     [Fact]
     public void DeriveName_DebugLogScope_MatchesLegacyFileLogSinkFormat()
     {
@@ -51,8 +55,8 @@ public void Run_WhenHeldByAnotherInstance_ThrowsOnTimeout()
 
         var holder = StartHolder(first, acquired, release, TestContext.Current.CancellationToken);
 
-        Assert.True(acquired.Wait(TimeSpan.FromSeconds(10), TestContext.Current.CancellationToken));
-        Assert.Throws<TimeoutException>(() => second.Run(TimeSpan.FromMilliseconds(300), static () => { }));
+        Assert.True(acquired.Wait(s_testTimeout, TestContext.Current.CancellationToken));
+        Assert.Throws<TimeoutException>(() => second.Run(s_contendedTimeout, static () => { }));
 
         release.Set();
         holder.Join();
@@ -64,8 +68,6 @@ public void TryRun_AfterMutexAbandonedByDeadThread_Recovers()
         var key = UniqueKey();
         var name = InterProcessMutex.DeriveName("AbandonScope", key);
 
-        // Keep the named object alive across the owning thread's death so the abandoned state (not object destruction)
-        // is what the next acquirer observes.
         using var keepAlive = new Mutex(false, name);
 
         var owningThread = new Thread(() =>
@@ -73,7 +75,6 @@ public void TryRun_AfterMutexAbandonedByDeadThread_Recovers()
             var owner = new Mutex(false, name);
             owner.WaitOne();
 
-            // Exit while still owning -> Windows marks the mutex abandoned.
         });
 
         owningThread.Start();
@@ -82,7 +83,7 @@ public void TryRun_AfterMutexAbandonedByDeadThread_Recovers()
         using var mutex = new InterProcessMutex("AbandonScope", key);
         var ran = false;
 
-        Assert.True(mutex.TryRun(TimeSpan.FromSeconds(5), () => ran = true));
+        Assert.True(mutex.TryRun(s_acquireTimeout, () => ran = true));
         Assert.True(ran);
     }
 
@@ -98,16 +99,14 @@ public void TryRun_TwoInstancesSameName_SecondBlockedWhileFirstHolds_ThenSucceed
 
         var holder = StartHolder(first, acquired, release, TestContext.Current.CancellationToken);
 
-        Assert.True(acquired.Wait(TimeSpan.FromSeconds(10), TestContext.Current.CancellationToken));
+        Assert.True(acquired.Wait(s_testTimeout, TestContext.Current.CancellationToken));
 
-        // Separate handle to the same named kernel object cannot acquire while the first holds it - proving true
-        // interprocess coordination rather than an in-process lock.
-        Assert.False(second.TryRun(TimeSpan.FromMilliseconds(300), static () => { }));
+        Assert.False(second.TryRun(s_contendedTimeout, static () => { }));
 
         release.Set();
         holder.Join();
 
-        Assert.True(second.TryRun(TimeSpan.FromSeconds(10), static () => { }));
+        Assert.True(second.TryRun(s_testTimeout, static () => { }));
     }
 
     private static Thread StartHolder(
@@ -116,10 +115,10 @@ private static Thread StartHolder(
         ManualResetEventSlim release,
         CancellationToken cancellationToken)
     {
-        var holder = new Thread(() => mutex.Run(TimeSpan.FromSeconds(10), () =>
+        var holder = new Thread(() => mutex.Run(s_testTimeout, () =>
         {
             acquired.Set();
-            release.Wait(TimeSpan.FromSeconds(10), cancellationToken);
+            release.Wait(s_testTimeout, cancellationToken);
         }));
 
         holder.Start();
diff --git a/tests/Unit/EventLogExpert.Logging.Tests/Routing/BroadcastLogProgressTests.cs b/tests/Unit/EventLogExpert.Logging.Tests/Routing/BroadcastLogProgressTests.cs
index 9bd8f942f..df8571d7c 100644
--- a/tests/Unit/EventLogExpert.Logging.Tests/Routing/BroadcastLogProgressTests.cs
+++ b/tests/Unit/EventLogExpert.Logging.Tests/Routing/BroadcastLogProgressTests.cs
@@ -10,7 +10,7 @@ namespace EventLogExpert.Logging.Tests.Routing;
 public sealed class BroadcastLogProgressTests
 {
     [Fact]
-    public void Report_EachSinkAppliesItsOwnLevel_ReproducingTheUiAllFileWarningSplit()
+    public void Report_EachSinkAppliesItsOwnLevel_ReproducingTheUIAllFileWarningSplit()
     {
         var ui = new RecordingSink(_ => LogLevel.Information);
         var file = new RecordingSink(_ => LogLevel.Warning);
diff --git a/tests/Unit/EventLogExpert.Logging.Tests/Routing/LogRoutingPolicyTests.cs b/tests/Unit/EventLogExpert.Logging.Tests/Routing/LogRoutingPolicyTests.cs
index 77af05112..a7f0da252 100644
--- a/tests/Unit/EventLogExpert.Logging.Tests/Routing/LogRoutingPolicyTests.cs
+++ b/tests/Unit/EventLogExpert.Logging.Tests/Routing/LogRoutingPolicyTests.cs
@@ -9,6 +9,8 @@ namespace EventLogExpert.Logging.Tests.Routing;
 
 public sealed class LogRoutingPolicyTests
 {
+    private static readonly TimeSpan s_testTimeout = TimeSpan.FromMilliseconds(200);
+
     [Fact]
     public void Constructor_NullOptions_Throws() =>
         Assert.Throws<ArgumentNullException>(static () => new LogRoutingPolicy(null!, LogLevel.Information));
@@ -29,8 +31,6 @@ public void FileMinimumFor_EventLog_FollowsGlobalBaseline_ReachableAtTrace()
     {
         var policy = new LogRoutingPolicy(LoggingOptions.CreateShippedDefaults(), LogLevel.Trace);
 
-        // Lowering the global level to Trace reveals EventLog's operational Debug/Trace detail (it is not
-        // channel-authoritatively throttled).
         Assert.Equal(LogLevel.Trace, policy.FileMinimumFor("EventLog"));
         Assert.Equal(LogLevel.Trace, policy.FileMinimumFor("EventLog.Lifecycle"));
     }
@@ -90,8 +90,6 @@ public void FileMinimumFor_UnconfiguredCategory_FollowsGlobalBaseline()
 
         Assert.Equal(LogLevel.Information, policy.FileMinimumFor("App"));
         Assert.Equal(LogLevel.Information, policy.FileMinimumFor("Elevation.Ipc"));
-        // EventLog is intentionally un-floored (unlike Database/DatabaseTools/Offline/Resolution), so it and its
-        // Lifecycle sub-category follow the global baseline.
         Assert.Equal(LogLevel.Information, policy.FileMinimumFor("EventLog"));
         Assert.Equal(LogLevel.Information, policy.FileMinimumFor("EventLog.Lifecycle"));
     }
@@ -113,7 +111,7 @@ public async Task SetCategoryOverride_ConcurrentReadersAndWriter_NeverTearOrThro
     {
         var policy = new LogRoutingPolicy(LoggingOptions.CreateShippedDefaults(), LogLevel.Information);
         using var cancellation = CancellationTokenSource.CreateLinkedTokenSource(TestContext.Current.CancellationToken);
-        cancellation.CancelAfter(TimeSpan.FromMilliseconds(200));
+        cancellation.CancelAfter(s_testTimeout);
         CancellationToken token = cancellation.Token;
 
         Task writer = Task.Run(() =>
@@ -131,8 +129,6 @@ public async Task SetCategoryOverride_ConcurrentReadersAndWriter_NeverTearOrThro
         {
             while (!token.IsCancellationRequested)
             {
-                // Readers must always observe a whole snapshot: either the override is set (Trace) or cleared (the
-                // shipped Warning throttle) - never a torn intermediate that throws or returns an out-of-band level.
                 LogLevel level = policy.FileMinimumFor("Resolution.Modern");
                 Assert.True(level is LogLevel.Trace or LogLevel.Warning);
             }
@@ -173,25 +169,25 @@ public void SetCategoryOverride_EmptyCategory_Throws()
     }
 
     [Fact]
-    public void SetCategoryOverride_Null_RevertsToShippedThrottle()
+    public void SetCategoryOverride_NullForNeverSetCategory_IsNoOp()
     {
         var policy = new LogRoutingPolicy(LoggingOptions.CreateShippedDefaults(), LogLevel.Information);
-        policy.SetCategoryOverride("Resolution", LogLevel.Trace);
 
         policy.SetCategoryOverride("Resolution", level: null);
 
         Assert.Equal(LogLevel.Warning, policy.FileMinimumFor("Resolution"));
-        Assert.Equal(LogLevel.Warning, policy.FileMinimumFor("Resolution.Modern"));
     }
 
     [Fact]
-    public void SetCategoryOverride_NullForNeverSetCategory_IsNoOp()
+    public void SetCategoryOverride_Null_RevertsToShippedThrottle()
     {
         var policy = new LogRoutingPolicy(LoggingOptions.CreateShippedDefaults(), LogLevel.Information);
+        policy.SetCategoryOverride("Resolution", LogLevel.Trace);
 
         policy.SetCategoryOverride("Resolution", level: null);
 
         Assert.Equal(LogLevel.Warning, policy.FileMinimumFor("Resolution"));
+        Assert.Equal(LogLevel.Warning, policy.FileMinimumFor("Resolution.Modern"));
     }
 
     [Fact]
@@ -204,19 +200,18 @@ public void SetCategoryOverride_SameCategoryTwice_ReplacesRatherThanAccumulates(
 
         Assert.Equal(LogLevel.Debug, policy.FileMinimumFor("Resolution"));
 
-        // A single revert must fully clear the category, proving no duplicate entry lingered from the replace.
         policy.SetCategoryOverride("Resolution", level: null);
 
         Assert.Equal(LogLevel.Warning, policy.FileMinimumFor("Resolution"));
     }
 
     [Fact]
-    public void UiMinimumFor_Normal_IsInformation() =>
-        Assert.Equal(LogLevel.Information, new LogRoutingPolicy(LoggingOptions.CreateShippedDefaults(), LogLevel.Information).UiMinimumFor(verbose: false));
+    public void UIMinimumFor_Normal_IsInformation() =>
+        Assert.Equal(LogLevel.Information, new LogRoutingPolicy(LoggingOptions.CreateShippedDefaults(), LogLevel.Information).UIMinimumFor(verbose: false));
 
     [Fact]
-    public void UiMinimumFor_Verbose_IsTrace() =>
-        Assert.Equal(LogLevel.Trace, new LogRoutingPolicy(LoggingOptions.CreateShippedDefaults(), LogLevel.Information).UiMinimumFor(verbose: true));
+    public void UIMinimumFor_Verbose_IsTrace() =>
+        Assert.Equal(LogLevel.Trace, new LogRoutingPolicy(LoggingOptions.CreateShippedDefaults(), LogLevel.Information).UIMinimumFor(verbose: true));
 
     [Fact]
     public void UpdateGlobalBaseline_MovesUnconfiguredCategories_ButConfiguredThrottleStaysAuthoritative()
diff --git a/tests/Unit/EventLogExpert.Logging.Tests/Sinks/UiStreamingSinkTests.cs b/tests/Unit/EventLogExpert.Logging.Tests/Sinks/UIStreamingSinkTests.cs
similarity index 81%
rename from tests/Unit/EventLogExpert.Logging.Tests/Sinks/UiStreamingSinkTests.cs
rename to tests/Unit/EventLogExpert.Logging.Tests/Sinks/UIStreamingSinkTests.cs
index 071ab01b7..f112b5efa 100644
--- a/tests/Unit/EventLogExpert.Logging.Tests/Sinks/UiStreamingSinkTests.cs
+++ b/tests/Unit/EventLogExpert.Logging.Tests/Sinks/UIStreamingSinkTests.cs
@@ -7,13 +7,13 @@
 
 namespace EventLogExpert.Logging.Tests.Sinks;
 
-public sealed class UiStreamingSinkTests
+public sealed class UIStreamingSinkTests
 {
     [Fact]
     public void Emit_AtOrAboveMinimum_ReportsTheRecord()
     {
         var captured = new List<LogRecord>();
-        var sink = new UiStreamingSink(new CapturingProgress(captured), LogLevel.Information);
+        var sink = new UIStreamingSink(new CapturingProgress(captured), LogLevel.Information);
         var record = new LogRecord(DateTime.UtcNow, LogLevel.Warning, "warn");
 
         sink.Emit(record);
@@ -25,7 +25,7 @@ public void Emit_AtOrAboveMinimum_ReportsTheRecord()
     public void Emit_BelowMinimum_ReportsNothing()
     {
         var captured = new List<LogRecord>();
-        var sink = new UiStreamingSink(new CapturingProgress(captured), LogLevel.Information);
+        var sink = new UIStreamingSink(new CapturingProgress(captured), LogLevel.Information);
 
         sink.Emit(new LogRecord(DateTime.UtcNow, LogLevel.Debug, "debug"));
 
@@ -35,7 +35,7 @@ public void Emit_BelowMinimum_ReportsNothing()
     [Fact]
     public void MinimumLevelFor_ReturnsTheConfiguredLevel_RegardlessOfCategory()
     {
-        var sink = new UiStreamingSink(new CapturingProgress([]), LogLevel.Trace);
+        var sink = new UIStreamingSink(new CapturingProgress([]), LogLevel.Trace);
 
         Assert.Equal(LogLevel.Trace, sink.MinimumLevelFor("DatabaseTools.Create"));
         Assert.Equal(LogLevel.Trace, sink.MinimumLevelFor("App"));
@@ -43,12 +43,12 @@ public void MinimumLevelFor_ReturnsTheConfiguredLevel_RegardlessOfCategory()
 
     [Fact]
     public void Constructor_NullProgress_Throws() =>
-        Assert.Throws<ArgumentNullException>(static () => new UiStreamingSink(null!, LogLevel.Information));
+        Assert.Throws<ArgumentNullException>(static () => new UIStreamingSink(null!, LogLevel.Information));
 
     [Fact]
     public void Emit_NullRecord_Throws()
     {
-        var sink = new UiStreamingSink(new CapturingProgress([]), LogLevel.Information);
+        var sink = new UIStreamingSink(new CapturingProgress([]), LogLevel.Information);
 
         Assert.Throws<ArgumentNullException>(() => sink.Emit(null!));
     }
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/Architecture/OrderedViewEngineNeutralityTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/Architecture/OrderedViewEngineNeutralityTests.cs
new file mode 100644
index 000000000..0dbf89cf6
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/Architecture/OrderedViewEngineNeutralityTests.cs
@@ -0,0 +1,138 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Runtime.LogTable.OrderedView;
+using System.Reflection;
+
+namespace EventLogExpert.Runtime.Tests.Architecture;
+
+public sealed class OrderedViewEngineNeutralityTests
+{
+    private const string EngineNamespace = "EventLogExpert.Runtime.LogTable.OrderedView";
+
+    private const string FluxorAssembly = "Fluxor";
+
+    private static readonly HashSet<string> s_sanctionedAdapters = new(StringComparer.Ordinal)
+    {
+        typeof(OrderedViewDispatchBridge).FullName!,
+        typeof(OrderedViewShadowEffects).FullName!
+    };
+
+    [Fact]
+    public void EngineCore_ReferencesNoFluxorTypes()
+    {
+        var offenders = EngineTypes()
+            .Where(type => !s_sanctionedAdapters.Contains(type.FullName ?? type.Name))
+            .Select(type => (type, references: FluxorReferences(type)))
+            .Where(candidate => candidate.references.Count > 0)
+            .Select(candidate => $"{candidate.type.FullName} -> {string.Join(", ", candidate.references)}")
+            .Order(StringComparer.Ordinal)
+            .ToArray();
+
+        Assert.True(
+            offenders.Length == 0,
+            $"Engine-core types must not reference Fluxor. Offenders:{Environment.NewLine}{string.Join(Environment.NewLine, offenders)}");
+    }
+
+    [Fact]
+    public void Scan_CoversTheWholeEngineNamespace()
+    {
+        Type[] engineTypes = EngineTypes();
+
+        Assert.All(s_sanctionedAdapters, adapter => Assert.Contains(engineTypes, type => (type.FullName ?? type.Name) == adapter));
+        Assert.True(
+            engineTypes.Length > s_sanctionedAdapters.Count + 5,
+            $"Expected the engine namespace to hold many core types beyond its {s_sanctionedAdapters.Count} adapters; found {engineTypes.Length}.");
+    }
+
+    [Fact]
+    public void Scanner_DetectsFluxorInTheSanctionedAdapters()
+    {
+        foreach (string adapterName in s_sanctionedAdapters)
+        {
+            Type adapter = EngineTypes().Single(type => (type.FullName ?? type.Name) == adapterName);
+
+            Assert.NotEmpty(FluxorReferences(adapter));
+        }
+    }
+
+    private static IEnumerable<Type> AttributeTypes(IEnumerable<CustomAttributeData> attributes) =>
+        attributes.Select(attribute => attribute.AttributeType);
+
+    private static void CollectFluxor(Type type, SortedSet<string> found)
+    {
+        Type element = type;
+
+        while (element.IsArray || element.IsByRef || element.IsPointer)
+        {
+            element = element.GetElementType()!;
+        }
+
+        if (element.IsGenericParameter) { return; }
+
+        if (string.Equals(element.Assembly.GetName().Name, FluxorAssembly, StringComparison.Ordinal))
+        {
+            found.Add(element.FullName ?? element.Name);
+        }
+
+        if (element.IsGenericType)
+        {
+            foreach (Type argument in element.GetGenericArguments())
+            {
+                CollectFluxor(argument, found);
+            }
+        }
+    }
+
+    private static Type[] EngineTypes() =>
+        [.. typeof(OrderedViewWriter).Assembly
+            .GetTypes()
+            .Where(type => string.Equals(type.Namespace, EngineNamespace, StringComparison.Ordinal))];
+
+    private static IReadOnlyList<string> FluxorReferences(Type type)
+    {
+        var found = new SortedSet<string>(StringComparer.Ordinal);
+
+        foreach (Type referenced in ReferencedTypes(type))
+        {
+            CollectFluxor(referenced, found);
+        }
+
+        return [.. found];
+    }
+
+    private static IEnumerable<Type> ReferencedTypes(Type type)
+    {
+        const BindingFlags Members =
+            BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static | BindingFlags.DeclaredOnly;
+
+        if (type.BaseType is { } baseType) { yield return baseType; }
+
+        foreach (Type contract in type.GetInterfaces()) { yield return contract; }
+
+        foreach (Type attribute in AttributeTypes(type.GetCustomAttributesData())) { yield return attribute; }
+
+        foreach (FieldInfo field in type.GetFields(Members))
+        {
+            yield return field.FieldType;
+
+            foreach (Type attribute in AttributeTypes(field.GetCustomAttributesData())) { yield return attribute; }
+        }
+
+        foreach (PropertyInfo property in type.GetProperties(Members)) { yield return property.PropertyType; }
+
+        foreach (ConstructorInfo constructor in type.GetConstructors(Members))
+        {
+            foreach (ParameterInfo parameter in constructor.GetParameters()) { yield return parameter.ParameterType; }
+        }
+
+        foreach (MethodInfo method in type.GetMethods(Members))
+        {
+            yield return method.ReturnType;
+
+            foreach (ParameterInfo parameter in method.GetParameters()) { yield return parameter.ParameterType; }
+
+            foreach (Type attribute in AttributeTypes(method.GetCustomAttributesData())) { yield return attribute; }
+        }
+    }
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/Architecture/RuntimePackageNeutralityTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/Architecture/RuntimePackageNeutralityTests.cs
new file mode 100644
index 000000000..828d6a523
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/Architecture/RuntimePackageNeutralityTests.cs
@@ -0,0 +1,71 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using System.Text.Json;
+
+namespace EventLogExpert.Runtime.Tests.Architecture;
+
+public sealed class RuntimePackageNeutralityTests
+{
+    private const string ForbiddenPackageIdPrefix = "Microsoft.AspNetCore.";
+    private const string RepositoryMarkerFile = "EventLogExpert.slnx";
+
+    private static readonly string[] s_forbiddenPackageIds = ["Fluxor.Blazor.Web"];
+
+    [Fact]
+    public void RuntimeRestoreGraph_ContainsNoUIToolkitPackages()
+    {
+        IReadOnlyList<string> restoredPackageIds = ReadRestoredPackageIds();
+
+        Assert.NotEmpty(restoredPackageIds);
+
+        string[] forbidden = [.. restoredPackageIds
+            .Where(IsForbidden)
+            .Distinct(StringComparer.OrdinalIgnoreCase)
+            .Order(StringComparer.Ordinal)];
+
+        Assert.Empty(forbidden);
+    }
+
+    private static bool IsForbidden(string packageId) =>
+        packageId.StartsWith(ForbiddenPackageIdPrefix, StringComparison.OrdinalIgnoreCase) ||
+        s_forbiddenPackageIds.Contains(packageId, StringComparer.OrdinalIgnoreCase);
+
+    private static IReadOnlyList<string> ReadRestoredPackageIds()
+    {
+        string assetsPath = LocateRuntimeAssetsFile();
+
+        Assert.True(File.Exists(assetsPath), $"Expected a restore graph at '{assetsPath}'. Run a restore first.");
+
+        using FileStream stream = File.OpenRead(assetsPath);
+        using JsonDocument document = JsonDocument.Parse(stream);
+
+        List<string> packageIds = [];
+
+        foreach (JsonProperty target in document.RootElement.GetProperty("targets").EnumerateObject())
+        {
+            foreach (JsonProperty library in target.Value.EnumerateObject())
+            {
+                int separatorIndex = library.Name.IndexOf('/', StringComparison.Ordinal);
+
+                packageIds.Add(separatorIndex < 0 ? library.Name : library.Name[..separatorIndex]);
+            }
+        }
+
+        return packageIds;
+    }
+
+    private static string LocateRuntimeAssetsFile()
+    {
+        DirectoryInfo? directory = new(AppContext.BaseDirectory);
+
+        while (directory is not null && !File.Exists(Path.Combine(directory.FullName, RepositoryMarkerFile)))
+        {
+            directory = directory.Parent;
+        }
+
+        Assert.NotNull(directory);
+
+        return Path.Combine(directory.FullName, "src", "EventLogExpert.Runtime", "obj", "project.assets.json");
+    }
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/Architecture/RuntimeToolkitNeutralityTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/Architecture/RuntimeToolkitNeutralityTests.cs
new file mode 100644
index 000000000..86df368ac
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/Architecture/RuntimeToolkitNeutralityTests.cs
@@ -0,0 +1,63 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Runtime.Alerts;
+using System.Reflection.Metadata;
+using System.Reflection.PortableExecutable;
+
+namespace EventLogExpert.Runtime.Tests.Architecture;
+
+public sealed class RuntimeToolkitNeutralityTests
+{
+    private static readonly string[] s_allowedAspNetCoreReferences = [];
+
+    [Fact]
+    public void Runtime_ReferencesNoAspNetCoreTypesBeyondTheAllowedSet()
+    {
+        string[] actual = [.. ReadTypeReferences()
+            .Where(reference => IsUnderRoot(reference.Namespace, "Microsoft.AspNetCore"))
+            .Select(reference => reference.FullName)
+            .Distinct(StringComparer.Ordinal)
+            .Order(StringComparer.Ordinal)];
+
+        Assert.Equal([.. s_allowedAspNetCoreReferences.Order(StringComparer.Ordinal)], actual);
+    }
+
+    [Fact]
+    public void Scanner_DetectsReferencesThatAreKnownToBePresent()
+    {
+        IReadOnlyList<(string Namespace, string FullName)> references = ReadTypeReferences();
+
+        Assert.Contains(references, reference => IsUnderRoot(reference.Namespace, "Fluxor"));
+        Assert.Contains(references, reference => IsUnderRoot(reference.Namespace, "Microsoft.Extensions"));
+    }
+
+    private static bool IsUnderRoot(string candidateNamespace, string root) =>
+        string.Equals(candidateNamespace, root, StringComparison.Ordinal) ||
+        candidateNamespace.StartsWith(root + ".", StringComparison.Ordinal);
+
+    private static IReadOnlyList<(string Namespace, string FullName)> ReadTypeReferences()
+    {
+        string assemblyPath = typeof(IAlertDialogService).Assembly.Location;
+
+        Assert.True(File.Exists(assemblyPath), $"Expected EventLogExpert.Runtime at '{assemblyPath}'.");
+
+        using FileStream stream = File.OpenRead(assemblyPath);
+        using PEReader peReader = new(stream);
+        MetadataReader reader = peReader.GetMetadataReader();
+
+        List<(string Namespace, string FullName)> references = new(reader.TypeReferences.Count);
+
+        foreach (TypeReferenceHandle handle in reader.TypeReferences)
+        {
+            TypeReference typeReference = reader.GetTypeReference(handle);
+            string typeNamespace = reader.GetString(typeReference.Namespace);
+            string typeName = reader.GetString(typeReference.Name);
+
+            references.Add((typeNamespace,
+                typeNamespace.Length == 0 ? typeName : string.Concat(typeNamespace, ".", typeName)));
+        }
+
+        return references;
+    }
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/Common/Clipboard/EventCopyFormatterTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/Common/Clipboard/EventCopyFormatterTests.cs
new file mode 100644
index 000000000..a210d5325
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/Common/Clipboard/EventCopyFormatterTests.cs
@@ -0,0 +1,220 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.Channels;
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
+using EventLogExpert.Eventing.Resolvers;
+using EventLogExpert.Runtime.Common.Clipboard;
+using EventLogExpert.Runtime.EventLog;
+using EventLogExpert.Runtime.LogTable;
+using NSubstitute;
+using System.Collections.Immutable;
+
+namespace EventLogExpert.Runtime.Tests.Common.Clipboard;
+
+public sealed class EventCopyFormatterTests
+{
+    private static readonly ImmutableDictionary<ColumnName, bool> s_columns = ImmutableDictionary<ColumnName, bool>.Empty
+        .Add(ColumnName.Level, true)
+        .Add(ColumnName.Source, true)
+        .Add(ColumnName.EventId, true);
+    private static readonly EventLogId s_logId = EventLogId.Create();
+
+    private static readonly ImmutableList<ColumnName> s_order =
+        ImmutableList.Create(ColumnName.Level, ColumnName.Source, ColumnName.EventId);
+
+    [Fact]
+    public async Task FormatAsync_DefaultFormat_RendersTheEnabledColumnsThenDescription()
+    {
+        var locator = new EventLocator(s_logId, 0, 0);
+
+        var detailResolver = Substitute.For<IEventDetailResolver>();
+        detailResolver.TryResolve(locator, out Arg.Any<ResolvedEvent?>())
+            .Returns(call => { call[1] = Event(1, 4000, "ProviderA", "Alpha"); return true; });
+
+        var formatter = new EventCopyFormatter(detailResolver, Substitute.For<IEventXmlResolver>());
+
+        string result = await formatter.FormatAsync(
+            Request([Entry(locator)], focus: null, EventCopyFormat.Default),
+            TestContext.Current.CancellationToken);
+
+        Assert.Contains("\"Information\"", result);
+        Assert.Contains("\"ProviderA\"", result);
+        Assert.Contains("\"4000\"", result);
+        Assert.Contains("\"Alpha\"", result);
+    }
+
+    [Fact]
+    public async Task FormatAsync_DropsSelectedEntriesThatNoLongerResolve()
+    {
+        var locatorA = new EventLocator(s_logId, 0, 0);
+        var locatorB = new EventLocator(s_logId, 0, 1);
+        var eventA = Event(recordId: 1, id: 4000, source: "ProviderA", description: "Alpha");
+
+        var detailResolver = Substitute.For<IEventDetailResolver>();
+        detailResolver.TryResolve(locatorA, out Arg.Any<ResolvedEvent?>())
+            .Returns(call => { call[1] = eventA; return true; });
+
+        var formatter = new EventCopyFormatter(detailResolver, Substitute.For<IEventXmlResolver>());
+
+        string result = await formatter.FormatAsync(
+            Request([Entry(locatorA), Entry(locatorB)], focus: null, EventCopyFormat.Simple),
+            TestContext.Current.CancellationToken);
+
+        Assert.Contains("ProviderA", result);
+        Assert.Contains("Alpha", result);
+
+        Assert.Single(result.Split('\n', StringSplitOptions.RemoveEmptyEntries));
+    }
+
+    [Fact]
+    public async Task FormatAsync_EmptySelectionAndNoFocus_ReturnsEmpty()
+    {
+        var formatter = new EventCopyFormatter(
+            Substitute.For<IEventDetailResolver>(),
+            Substitute.For<IEventXmlResolver>());
+
+        string result = await formatter.FormatAsync(
+            Request([], focus: null, EventCopyFormat.Full),
+            TestContext.Current.CancellationToken);
+
+        Assert.Equal(string.Empty, result);
+    }
+
+    [Fact]
+    public async Task FormatAsync_EmptySelection_FallsBackToTheFocusedEntry()
+    {
+        var focusLocator = new EventLocator(s_logId, 0, 3);
+
+        var detailResolver = Substitute.For<IEventDetailResolver>();
+        detailResolver.TryResolve(focusLocator, out Arg.Any<ResolvedEvent?>())
+            .Returns(call => { call[1] = Event(7, 6000, "FocusProvider", "FocusedDescription"); return true; });
+
+        var formatter = new EventCopyFormatter(detailResolver, Substitute.For<IEventXmlResolver>());
+
+        string result = await formatter.FormatAsync(
+            Request([], Entry(focusLocator), EventCopyFormat.Simple),
+            TestContext.Current.CancellationToken);
+
+        Assert.Contains("FocusProvider", result);
+        Assert.Contains("FocusedDescription", result);
+    }
+
+    [Fact]
+    public async Task FormatAsync_MarkdownFormat_BuildsATableWithAHeaderRow()
+    {
+        var locator = new EventLocator(s_logId, 0, 0);
+
+        var detailResolver = Substitute.For<IEventDetailResolver>();
+        detailResolver.TryResolve(locator, out Arg.Any<ResolvedEvent?>())
+            .Returns(call => { call[1] = Event(1, 4000, "ProviderA", "Alpha"); return true; });
+
+        var formatter = new EventCopyFormatter(detailResolver, Substitute.For<IEventXmlResolver>());
+
+        string result = await formatter.FormatAsync(
+            Request([Entry(locator)], focus: null, EventCopyFormat.Markdown),
+            TestContext.Current.CancellationToken);
+
+        Assert.StartsWith("|", result);
+        Assert.Contains("Description", result);
+        Assert.Contains("---", result);
+        Assert.Contains("ProviderA", result);
+    }
+
+    [Fact]
+    public async Task FormatAsync_MultipleEntriesXml_MapsEachEventToItsOwnResolvedXml()
+    {
+        var locatorA = new EventLocator(s_logId, 0, 0);
+        var locatorB = new EventLocator(s_logId, 0, 1);
+        var eventA = Event(1, 4000, "ProviderA", "Alpha");
+        var eventB = Event(2, 5000, "ProviderB", "Beta");
+
+        var detailResolver = Substitute.For<IEventDetailResolver>();
+        detailResolver.TryResolve(locatorA, out Arg.Any<ResolvedEvent?>()).Returns(call => { call[1] = eventA; return true; });
+        detailResolver.TryResolve(locatorB, out Arg.Any<ResolvedEvent?>()).Returns(call => { call[1] = eventB; return true; });
+
+        var xmlResolver = Substitute.For<IEventXmlResolver>();
+        xmlResolver.GetXmlAsync(eventA, Arg.Any<CancellationToken>()).Returns(new ValueTask<string>("<Event>AAA</Event>"));
+        xmlResolver.GetXmlAsync(eventB, Arg.Any<CancellationToken>()).Returns(new ValueTask<string>("<Event>BBB</Event>"));
+
+        var formatter = new EventCopyFormatter(detailResolver, xmlResolver);
+
+        string result = await formatter.FormatAsync(
+            Request([Entry(locatorA), Entry(locatorB)], focus: null, EventCopyFormat.Full),
+            TestContext.Current.CancellationToken);
+
+        int providerA = result.IndexOf("ProviderA", StringComparison.Ordinal);
+        int aaa = result.IndexOf("AAA", StringComparison.Ordinal);
+        int providerB = result.IndexOf("ProviderB", StringComparison.Ordinal);
+        int bbb = result.IndexOf("BBB", StringComparison.Ordinal);
+
+        Assert.True(providerA >= 0 && aaa >= 0 && providerB >= 0 && bbb >= 0);
+        Assert.True(providerA < aaa && aaa < providerB && providerB < bbb,
+            $"expected ProviderA < AAA < ProviderB < BBB, got {providerA}, {aaa}, {providerB}, {bbb}");
+    }
+
+    [Fact]
+    public async Task FormatAsync_RendersEverySurvivingEntry_WhenAllResolve()
+    {
+        var locatorA = new EventLocator(s_logId, 0, 0);
+        var locatorB = new EventLocator(s_logId, 0, 1);
+
+        var detailResolver = Substitute.For<IEventDetailResolver>();
+        detailResolver.TryResolve(locatorA, out Arg.Any<ResolvedEvent?>())
+            .Returns(call => { call[1] = Event(1, 4000, "ProviderA", "Alpha"); return true; });
+        detailResolver.TryResolve(locatorB, out Arg.Any<ResolvedEvent?>())
+            .Returns(call => { call[1] = Event(2, 5000, "ProviderB", "Beta"); return true; });
+
+        var formatter = new EventCopyFormatter(detailResolver, Substitute.For<IEventXmlResolver>());
+
+        string result = await formatter.FormatAsync(
+            Request([Entry(locatorA), Entry(locatorB)], focus: null, EventCopyFormat.Simple),
+            TestContext.Current.CancellationToken);
+
+        Assert.Contains("Alpha", result);
+        Assert.Contains("Beta", result);
+        Assert.Equal(2, result.Split('\n', StringSplitOptions.RemoveEmptyEntries).Length);
+    }
+
+    [Fact]
+    public async Task FormatAsync_XmlFormat_RendersTheResolvedXml()
+    {
+        var locator = new EventLocator(s_logId, 0, 0);
+
+        var detailResolver = Substitute.For<IEventDetailResolver>();
+        detailResolver.TryResolve(locator, out Arg.Any<ResolvedEvent?>())
+            .Returns(call => { call[1] = Event(1, 4000, "ProviderA", "Alpha"); return true; });
+
+        var xmlResolver = Substitute.For<IEventXmlResolver>();
+        xmlResolver.GetXmlAsync(Arg.Any<ResolvedEvent>(), Arg.Any<CancellationToken>())
+            .Returns(new ValueTask<string>("<Event><Data>payload</Data></Event>"));
+
+        var formatter = new EventCopyFormatter(detailResolver, xmlResolver);
+
+        string result = await formatter.FormatAsync(
+            Request([Entry(locator)], focus: null, EventCopyFormat.Xml),
+            TestContext.Current.CancellationToken);
+
+        Assert.Contains("payload", result);
+    }
+
+    private static SelectionEntry Entry(EventLocator locator) => new(locator, locator, null);
+
+    private static ResolvedEvent Event(long recordId, int id, string source, string description) =>
+        new("Application", LogPathType.Channel)
+        {
+            RecordId = recordId,
+            Id = id,
+            Level = "Information",
+            Source = source,
+            Description = description,
+            TimeCreated = new DateTime(2026, 1, 1, 0, 0, 0, DateTimeKind.Utc)
+        };
+
+    private static EventCopyRequest Request(
+        ImmutableList<SelectionEntry> selection,
+        SelectionEntry? focus,
+        EventCopyFormat format) =>
+        new(selection, focus, s_columns, s_order, format, TimeZoneInfo.Utc);
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/DatabaseTools/DatabaseToolsServiceTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/DatabaseTools/DatabaseToolsServiceTests.cs
index b56bb17b0..a01ee046c 100644
--- a/tests/Unit/EventLogExpert.Runtime.Tests/DatabaseTools/DatabaseToolsServiceTests.cs
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/DatabaseTools/DatabaseToolsServiceTests.cs
@@ -41,9 +41,11 @@ await service.ShowAsync(
     [Fact]
     public async Task DurationIsMeasured_AndGreaterThanZero()
     {
+        const int MeasurableWorkDelayMilliseconds = 50;
+
         var fake = new RecordingOperation(async _ =>
         {
-            await Task.Delay(50);
+            await Task.Delay(MeasurableWorkDelayMilliseconds);
             return DatabaseToolsOutcome.Succeeded;
         });
         var (service, _) = CreateSut(showOperation: () => fake);
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/DatabaseTools/Elevation/ElevatedDatabaseToolsRunnerTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/DatabaseTools/Elevation/ElevatedDatabaseToolsRunnerTests.cs
index bad32f0ad..c58dafd0c 100644
--- a/tests/Unit/EventLogExpert.Runtime.Tests/DatabaseTools/Elevation/ElevatedDatabaseToolsRunnerTests.cs
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/DatabaseTools/Elevation/ElevatedDatabaseToolsRunnerTests.cs
@@ -21,10 +21,14 @@ namespace EventLogExpert.Runtime.Tests.DatabaseTools.Elevation;
 
 public sealed class ElevatedDatabaseToolsRunnerTests
 {
+    private const int RunnerSettleDelayMilliseconds = 50;
+
     private static readonly TimeSpan s_testExitGrace = TimeSpan.FromMilliseconds(500);
     private static readonly TimeSpan s_testGrace = TimeSpan.FromMilliseconds(500);
-    private static readonly TimeSpan s_testHelloTimeout = TimeSpan.FromMilliseconds(500);
+    private static readonly TimeSpan s_testHelloTimeout = TimeSpan.FromSeconds(10);
     private static readonly TimeSpan s_testReadTimeout = TimeSpan.FromSeconds(5);
+    private static readonly TimeSpan s_testShortHelloTimeout = TimeSpan.FromMilliseconds(500);
+    private static readonly TimeSpan s_testTimeout = TimeSpan.FromSeconds(10);
     private static readonly UTF8Encoding s_utf8NoBom = new(encoderShouldEmitUTF8Identifier: false);
 
     [Fact]
@@ -230,7 +234,7 @@ public async Task HelloTimeout_HelperSilent_RunnerReturnsFailedWithTimeoutMessag
         var fakeProcess = new FakeElevatedHelperProcess(server, processId: 6262);
         var host = new FakeElevatedHelperProcessHost((_, _) => Task.FromResult<IElevatedHelperProcess>(fakeProcess));
         var logger = new LoggerUtils.RecordingTraceLogger();
-        var runner = CreateRunner(host, logger);
+        var runner = CreateRunner(host, logger, s_testShortHelloTimeout);
         var logProgress = new ListProgress<LogRecord>();
 
         var runTask = runner.ShowAsync(
@@ -519,11 +523,10 @@ public async Task RunAsync_WhenCancelledBeforeHandshakeAndHelperUnkillable_Centr
             new ShowProvidersRequest(null, null),
             logProgress, progress: null, cts.Token);
 
-        // Let the runner enter the Hello wait before cancelling.
-        await Task.Delay(50, ct);
+        await Task.Delay(RunnerSettleDelayMilliseconds, ct);
         cts.Cancel();
 
-        var result = await runTask.WaitAsync(TimeSpan.FromSeconds(10), ct);
+        var result = await runTask.WaitAsync(s_testTimeout, ct);
 
         Assert.Equal(DatabaseToolsOutcome.Cancelled, result.Outcome);
         Assert.True(fakeProcess.WasKilled);
@@ -553,7 +556,7 @@ public async Task RunAsync_WhenFirstEnvelopeIsNotHelloAndHelperUnkillable_Centra
 
         await WriteMessageAsync(clientWriter, new LogMessage(DateTime.UtcNow, LogLevel.Information, "early log"), ct);
 
-        var result = await runTask.WaitAsync(TimeSpan.FromSeconds(10), ct);
+        var result = await runTask.WaitAsync(s_testTimeout, ct);
 
         Assert.Equal(DatabaseToolsOutcome.Failed, result.Outcome);
         Assert.Contains("HelloMessage", result.FailureSummary);
@@ -563,7 +566,6 @@ public async Task RunAsync_WhenFirstEnvelopeIsNotHelloAndHelperUnkillable_Centra
     [Fact]
     public async Task RunAsync_WhenHelloTimeoutAndHelperUnkillable_CentralizedFinallyCleansUpWithinBoundedTime()
     {
-        // No-Hello plus unkillable helper must still bound every cleanup wait.
         var ct = TestContext.Current.CancellationToken;
         await using var pipes = await HelperPipePair.CreateAsync(ct); var server = pipes.Server; var client = pipes.Client;
         var fakeProcess = new FakeElevatedHelperProcess(server, processId: 4242)
@@ -572,7 +574,7 @@ public async Task RunAsync_WhenHelloTimeoutAndHelperUnkillable_CentralizedFinall
         };
         var host = new FakeElevatedHelperProcessHost((_, _) => Task.FromResult<IElevatedHelperProcess>(fakeProcess));
         var logger = new LoggerUtils.RecordingTraceLogger();
-        var runner = CreateRunner(host, logger);
+        var runner = CreateRunner(host, logger, s_testShortHelloTimeout);
 
         using var cts = CancellationTokenSource.CreateLinkedTokenSource(ct);
         var logProgress = new ListProgress<LogRecord>();
@@ -581,8 +583,7 @@ public async Task RunAsync_WhenHelloTimeoutAndHelperUnkillable_CentralizedFinall
             new ShowProvidersRequest(null, null),
             logProgress, progress: null, cts.Token);
 
-        // No Hello forces the 500 ms timeout; 10 s only bounds regression hangs.
-        var result = await runTask.WaitAsync(TimeSpan.FromSeconds(10), ct);
+        var result = await runTask.WaitAsync(s_testTimeout, ct);
 
         Assert.Equal(DatabaseToolsOutcome.Failed, result.Outcome);
         Assert.Contains("Hello", result.FailureSummary, StringComparison.OrdinalIgnoreCase);
@@ -621,7 +622,7 @@ public async Task RunAsync_WhenHelperKillSucceedsAfterCancel_ReportsForceKilled(
 
             cts.Cancel();
 
-            var result = await runTask.WaitAsync(TimeSpan.FromSeconds(10), ct);
+            var result = await runTask.WaitAsync(s_testTimeout, ct);
 
             Assert.Equal(DatabaseToolsOutcome.Cancelled, result.Outcome);
             Assert.Contains("force-killed", result.FailureSummary, StringComparison.OrdinalIgnoreCase);
@@ -637,7 +638,6 @@ public async Task RunAsync_WhenHelperKillSucceedsAfterCancel_ReportsForceKilled(
     [Fact]
     public async Task RunAsync_WhenHelperUnkillableAfterCancel_DoesNotHangAndReportsOrphan()
     {
-        // Unkillable post-cancel helpers must dispose the pipe to unblock the drain instead of hanging on exit.
         var ct = TestContext.Current.CancellationToken;
         await using var pipes = await HelperPipePair.CreateAsync(ct); var server = pipes.Server; var client = pipes.Client;
         var fakeProcess = new FakeElevatedHelperProcess(server, processId: 4242)
@@ -665,8 +665,7 @@ public async Task RunAsync_WhenHelperUnkillableAfterCancel_DoesNotHangAndReports
 
         cts.Cancel();
 
-        // 10 s bounds regressions around the cancellation-grace and exit-grace waits.
-        var result = await runTask.WaitAsync(TimeSpan.FromSeconds(10), ct);
+        var result = await runTask.WaitAsync(s_testTimeout, ct);
 
         Assert.Equal(DatabaseToolsOutcome.Cancelled, result.Outcome);
         Assert.Contains("could not be terminated", result.FailureSummary, StringComparison.OrdinalIgnoreCase);
@@ -693,10 +692,10 @@ public async Task RunAsync_WhenPipeClosedBeforeHelloAndHelperUnkillable_Centrali
             new ShowProvidersRequest(null, null),
             logProgress, progress: null, cts.Token);
 
-        await Task.Delay(50, ct);
+        await Task.Delay(RunnerSettleDelayMilliseconds, ct);
         await client.DisposeAsync();
 
-        var result = await runTask.WaitAsync(TimeSpan.FromSeconds(10), ct);
+        var result = await runTask.WaitAsync(s_testTimeout, ct);
 
         Assert.Equal(DatabaseToolsOutcome.Failed, result.Outcome);
         Assert.Contains("Pipe closed", result.FailureSummary, StringComparison.OrdinalIgnoreCase);
@@ -727,7 +726,7 @@ public async Task RunAsync_WhenProtocolMismatchAndHelperUnkillable_CentralizedFi
 
         await WriteMessageAsync(clientWriter, new HelloMessage(4242, ProtocolVersion: 99), ct);
 
-        var result = await runTask.WaitAsync(TimeSpan.FromSeconds(10), ct);
+        var result = await runTask.WaitAsync(s_testTimeout, ct);
 
         Assert.Equal(DatabaseToolsOutcome.Failed, result.Outcome);
         Assert.Contains("protocol version", result.FailureSummary, StringComparison.OrdinalIgnoreCase);
@@ -850,6 +849,9 @@ private static async Task AssertHappyPathOperationAsync(
     private static ElevatedDatabaseToolsRunner CreateRunner(IElevatedHelperProcessHost host, ITraceLogger logger) =>
         new(host, logger, s_testHelloTimeout, s_testGrace, s_testExitGrace);
 
+    private static ElevatedDatabaseToolsRunner CreateRunner(IElevatedHelperProcessHost host, ITraceLogger logger, TimeSpan helloTimeout) =>
+        new(host, logger, helloTimeout, s_testGrace, s_testExitGrace);
+
     private static void DisposeSafely(IDisposable disposable)
     {
         try { disposable.Dispose(); }
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/DependencyInjection/RuntimeServiceCollectionExtensionsTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/DependencyInjection/RuntimeServiceCollectionExtensionsTests.cs
index 7163f6422..9ae334956 100644
--- a/tests/Unit/EventLogExpert.Runtime.Tests/DependencyInjection/RuntimeServiceCollectionExtensionsTests.cs
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/DependencyInjection/RuntimeServiceCollectionExtensionsTests.cs
@@ -21,15 +21,16 @@
 using EventLogExpert.Runtime.DatabaseTools.Elevation;
 using EventLogExpert.Runtime.DebugLog;
 using EventLogExpert.Runtime.EventLog;
+using EventLogExpert.Runtime.FilterLenses;
 using EventLogExpert.Runtime.FilterLibrary;
 using EventLogExpert.Runtime.FilterPane;
 using EventLogExpert.Runtime.Histogram;
 using EventLogExpert.Runtime.LogTable;
 using EventLogExpert.Runtime.Menu;
-using EventLogExpert.Runtime.Modal;
 using EventLogExpert.Runtime.Scenarios;
 using EventLogExpert.Runtime.Scenarios.Favorites;
 using EventLogExpert.Runtime.Settings;
+using EventLogExpert.Runtime.StatusBar;
 using EventLogExpert.Runtime.Update;
 using EventLogExpert.Runtime.Update.Deployment;
 using EventLogExpert.Scenarios.Catalog;
@@ -88,7 +89,6 @@ public async Task AddElevatedDatabaseToolsRunner_ShouldResolveRunnerWhenHostIsRe
     [InlineData(typeof(IInfoBannerService))]
     public async Task AddEventLogRuntime_BannerFacets_AreSingletons(Type facetType)
     {
-        // Arrange
         var services = new ServiceCollection();
         RegisterHostDependencies(services);
         services.AddEventLogRuntime();
@@ -96,17 +96,12 @@ public async Task AddEventLogRuntime_BannerFacets_AreSingletons(Type facetType)
         await using var provider = services.BuildServiceProvider(
             new ServiceProviderOptions { ValidateScopes = true, ValidateOnBuild = true });
 
-        // Resolve from TWO DIFFERENT SCOPES: singleton instances are shared across scopes,
-        // scoped instances would be distinct. Resolving twice from the same scope cannot
-        // distinguish singleton from scoped (both would return the same per-scope instance).
         await using var scope1 = provider.CreateAsyncScope();
         await using var scope2 = provider.CreateAsyncScope();
 
-        // Act
         var first = scope1.ServiceProvider.GetService(facetType);
         var second = scope2.ServiceProvider.GetService(facetType);
 
-        // Assert
         Assert.NotNull(first);
         Assert.Same(first, second);
     }
@@ -114,7 +109,6 @@ public async Task AddEventLogRuntime_BannerFacets_AreSingletons(Type facetType)
     [Fact]
     public async Task AddEventLogRuntime_Resolves5BannerFacetsToSameSingleton()
     {
-        // Arrange
         var services = new ServiceCollection();
         RegisterHostDependencies(services);
         services.AddEventLogRuntime();
@@ -122,13 +116,9 @@ public async Task AddEventLogRuntime_Resolves5BannerFacetsToSameSingleton()
         await using var provider = services.BuildServiceProvider(
             new ServiceProviderOptions { ValidateScopes = true, ValidateOnBuild = true });
 
-        // Resolve from two scopes: locks in same-instance + singleton-lifetime invariants
-        // in one test. If any facet were registered Scoped instead of Singleton, the
-        // cross-scope assertion would fail (per-scope instances would be distinct).
         await using var scope1 = provider.CreateAsyncScope();
         await using var scope2 = provider.CreateAsyncScope();
 
-        // Act
         var attentionScope1 = scope1.ServiceProvider.GetRequiredService<IAttentionBannerService>();
         var progressScope1 = scope1.ServiceProvider.GetRequiredService<IProgressBannerService>();
         var criticalScope1 = scope1.ServiceProvider.GetRequiredService<ICriticalErrorService>();
@@ -136,8 +126,6 @@ public async Task AddEventLogRuntime_Resolves5BannerFacetsToSameSingleton()
         var infoScope1 = scope1.ServiceProvider.GetRequiredService<IInfoBannerService>();
         var attentionScope2 = scope2.ServiceProvider.GetRequiredService<IAttentionBannerService>();
 
-        // Assert: all five facets resolve to the same backing BannerService instance
-        // within a scope, AND that instance is shared across scopes (singleton lifetime).
         Assert.Same(attentionScope1, progressScope1);
         Assert.Same(attentionScope1, criticalScope1);
         Assert.Same(attentionScope1, errorScope1);
@@ -148,7 +136,6 @@ public async Task AddEventLogRuntime_Resolves5BannerFacetsToSameSingleton()
     [Fact]
     public async Task AddEventLogRuntime_SharesOneFileLogSinkSingleton()
     {
-        // Arrange
         var services = new ServiceCollection();
         RegisterHostDependencies(services);
         services.AddEventLogRuntime();
@@ -159,34 +146,45 @@ public async Task AddEventLogRuntime_SharesOneFileLogSinkSingleton()
         await using var scope1 = provider.CreateAsyncScope();
         await using var scope2 = provider.CreateAsyncScope();
 
-        // Act: the IDebugLogReader (whose ClearAsync truncates the writer), the ILogSourceFactory sink list,
-        // and OperationLogProgressFactory all inject the concrete FileLogSink. A single shared singleton is
-        // load-bearing: a second instance would let the reader's Clear truncate a different handle than the
-        // one the sinks write through.
         var sinkScope1 = scope1.ServiceProvider.GetRequiredService<FileLogSink>();
         var sinkScope2 = scope2.ServiceProvider.GetRequiredService<FileLogSink>();
 
-        // Assert: one shared singleton, and every file-sink consumer resolves against it.
         Assert.Same(sinkScope1, sinkScope2);
         Assert.NotNull(scope1.ServiceProvider.GetRequiredService<IDebugLogReader>());
         Assert.NotNull(scope1.ServiceProvider.GetRequiredService<IOperationLogProgressFactory>());
     }
 
     [Theory]
-    // Command facades.
     [InlineData(typeof(IEventLogCommands))]
     [InlineData(typeof(IFilterLibraryCommands))]
     [InlineData(typeof(IFilterPaneCommands))]
     [InlineData(typeof(ILogTableCommands))]
     [InlineData(typeof(IScenarioFavoriteCommands))]
     [InlineData(typeof(IEventLogQueries))]
-    // UI capabilities.
+    [InlineData(typeof(ILogTableQueries))]
+    [InlineData(typeof(IFilterPaneQueries))]
+    [InlineData(typeof(IFilterLensSource))]
+    [InlineData(typeof(IOpenLogsPresenceSource))]
+    [InlineData(typeof(IHistogramVisibilitySource))]
+    [InlineData(typeof(IEventFocusSource))]
+    [InlineData(typeof(IActiveEventLogSource))]
+    [InlineData(typeof(IFilterAppliedSource))]
+    [InlineData(typeof(IScenarioFavoritesSource))]
+    [InlineData(typeof(ILogTabBarSource))]
+    [InlineData(typeof(IStatusBarSource))]
+    [InlineData(typeof(IHistogramDimensionRequestSource))]
+    [InlineData(typeof(IActiveFiltersSource))]
+    [InlineData(typeof(IEventSelectionSource))]
+    [InlineData(typeof(IGroupCollapseNotifier))]
+    [InlineData(typeof(ITagBulkUpdateFailedNotifier))]
+    [InlineData(typeof(IClearAllFiltersNotifier))]
+    [InlineData(typeof(ISetFilterDateRangeSucceededNotifier))]
+    [InlineData(typeof(ILibraryEntriesSource))]
+    [InlineData(typeof(ILibraryLoadStatusSource))]
+    [InlineData(typeof(IFilteredDateRangeSource))]
+    [InlineData(typeof(ILoadedLogNamesSource))]
     [InlineData(typeof(IHighlightSelector))]
     [InlineData(typeof(ILogTableColumnDefaultsProvider))]
-    // ILogReloadCoordinator omitted: it forwards to the Fluxor-registered Effects type,
-    // which is auto-registered by AddFluxor (not by AddEventLogRuntime). Production wiring
-    // covers it; here it would require also bootstrapping Fluxor scanning in the test.
-    // Application services (moved out of MauiProgram into AddEventLogRuntime).
     [InlineData(typeof(IAppTitleService))]
     [InlineData(typeof(IAttentionBannerService))]
     [InlineData(typeof(IProgressBannerService))]
@@ -197,23 +195,18 @@ public async Task AddEventLogRuntime_SharesOneFileLogSinkSingleton()
     [InlineData(typeof(IDatabaseService))]
     [InlineData(typeof(IActiveDatabases))]
     [InlineData(typeof(IDatabaseOperationCoordinator))]
-    [InlineData(typeof(IModalCoordinator))]
     [InlineData(typeof(ILogWatcherService))]
-    [InlineData(typeof(IMenuService))]
-    [InlineData(typeof(IModalService))]
     [InlineData(typeof(ISettingsService))]
     [InlineData(typeof(ITraceLogger))]
     [InlineData(typeof(ILogSourceFactory))]
     [InlineData(typeof(IDebugLogReader))]
     [InlineData(typeof(IOperationLogProgressFactory))]
-    // Update + deployment services.
     [InlineData(typeof(ICurrentVersionProvider))]
     [InlineData(typeof(IDeploymentService))]
     [InlineData(typeof(IGitHubService))]
     [InlineData(typeof(IPackageDeploymentService))]
     [InlineData(typeof(IPackageVersionProvider))]
     [InlineData(typeof(IUpdateService))]
-    // Built-in scenarios.
     [InlineData(typeof(BuiltInScenarioRegistry))]
     [InlineData(typeof(IScenarioQueryService))]
     [InlineData(typeof(IScenarioApplyService))]
@@ -221,14 +214,8 @@ public async Task AddEventLogRuntime_SharesOneFileLogSinkSingleton()
     [InlineData(typeof(IScenarioAuthoringService))]
     public async Task AddEventLogRuntime_ShouldResolveHostFacingAbstraction(Type serviceType)
     {
-        // Arrange
         var services = new ServiceCollection();
 
-        // Dependencies the host normally provides (IDispatcher comes from Fluxor; the
-        // others are concrete options/identity/IO surfaces that AddEventLogRuntime doesn't
-        // own). Substituting them keeps this smoke test focused on the wiring inside
-        // AddEventLogRuntime while letting the dependency-injection container actually
-        // build each registered service.
         services.AddSingleton(Substitute.For<IDispatcher>());
         services.AddSingleton(Substitute.For<IAlertDialogService>());
         services.AddSingleton(Substitute.For<IApplicationRestartService>());
@@ -239,11 +226,38 @@ public async Task AddEventLogRuntime_ShouldResolveHostFacingAbstraction(Type ser
         services.AddSingleton(Substitute.For<IMainThreadService>());
         services.AddSingleton(Substitute.For<IWindowsIdentityProvider>());
         services.AddSingleton(Substitute.For<IFilePickerService>());
-        services.AddSingleton(Substitute.For<IState<EventLogState>>());
-        services.AddSingleton(Substitute.For<IState<FilterPaneState>>());
-        services.AddSingleton(Substitute.For<IState<LogTableState>>());
+        var filterPaneState = Substitute.For<IState<FilterPaneState>>();
+        filterPaneState.Value.Returns(new FilterPaneState());
+        services.AddSingleton(filterPaneState);
+        var rawEventCountState = Substitute.For<IState<RawEventCountState>>();
+        rawEventCountState.Value.Returns(new RawEventCountState());
+        services.AddSingleton(rawEventCountState);
+        var statusBarState = Substitute.For<IState<StatusBarState>>();
+        statusBarState.Value.Returns(new StatusBarState());
+        services.AddSingleton(statusBarState);
+
+        var eventLogState = Substitute.For<IState<EventLogState>>();
+        eventLogState.Value.Returns(new EventLogState());
+        services.AddSingleton(eventLogState);
+        var filterLensState = Substitute.For<IState<FilterLensState>>();
+        filterLensState.Value.Returns(new FilterLensState());
+        services.AddSingleton(filterLensState);
+        var logTableState = Substitute.For<IState<LogTableState>>();
+        logTableState.Value.Returns(new LogTableState());
+        services.AddSingleton(logTableState);
         services.AddSingleton(Substitute.For<IState<RawEventStoreState>>());
-        services.AddSingleton(Substitute.For<IState<HistogramState>>());
+        var filteredLogPresenceState = Substitute.For<IState<FilteredLogPresenceState>>();
+        filteredLogPresenceState.Value.Returns(new FilteredLogPresenceState());
+        services.AddSingleton(filteredLogPresenceState);
+        var histogramState = Substitute.For<IState<HistogramState>>();
+        histogramState.Value.Returns(new HistogramState());
+        services.AddSingleton(histogramState);
+        var filterLibraryState = Substitute.For<IState<FilterLibraryState>>();
+        filterLibraryState.Value.Returns(new FilterLibraryState());
+        services.AddSingleton(filterLibraryState);
+        var scenarioFavoritesState = Substitute.For<IState<ScenarioFavoritesState>>();
+        scenarioFavoritesState.Value.Returns(new ScenarioFavoritesState());
+        services.AddSingleton(scenarioFavoritesState);
         services.AddSingleton(Substitute.For<IStateSelection<EventLogState, bool>>());
         services.AddSingleton(new FileLocationOptions(Path.Combine(Path.GetTempPath(), "EventLogExpertTests")));
         services.AddSingleton<HttpClient>();
@@ -258,17 +272,14 @@ public async Task AddEventLogRuntime_ShouldResolveHostFacingAbstraction(Type ser
 
         await using var scope = provider.CreateAsyncScope();
 
-        // Act
         var resolved = scope.ServiceProvider.GetService(serviceType);
 
-        // Assert
         Assert.NotNull(resolved);
     }
 
     [Fact]
     public async Task AddEventLogRuntime_WhenVerboseResolutionPersistedOff_LeavesResolutionAtShippedThrottle()
     {
-        // Arrange
         var services = new ServiceCollection();
         var preferences = Substitute.For<ISettingsPreferencesProvider>();
         preferences.VerboseResolutionPreference.Returns(false);
@@ -280,17 +291,14 @@ public async Task AddEventLogRuntime_WhenVerboseResolutionPersistedOff_LeavesRes
 
         await using var scope = provider.CreateAsyncScope();
 
-        // Act
         var routingPolicy = scope.ServiceProvider.GetRequiredService<LogRoutingPolicy>();
 
-        // Assert: no runtime override, so the fine categories follow the shipped Resolution throttle.
         Assert.Equal(LogLevel.Warning, routingPolicy.FileMinimumFor("Resolution"));
     }
 
     [Fact]
     public async Task AddEventLogRuntime_WhenVerboseResolutionPersistedOn_SeedsResolutionOverrideAtConstruction()
     {
-        // Arrange
         var services = new ServiceCollection();
         var preferences = Substitute.For<ISettingsPreferencesProvider>();
         preferences.VerboseResolutionPreference.Returns(true);
@@ -302,10 +310,8 @@ public async Task AddEventLogRuntime_WhenVerboseResolutionPersistedOn_SeedsResol
 
         await using var scope = provider.CreateAsyncScope();
 
-        // Act: the routing policy is the shared singleton the file sink reads on every emit.
         var routingPolicy = scope.ServiceProvider.GetRequiredService<LogRoutingPolicy>();
 
-        // Assert: a persisted-ON toggle is in effect the moment the singleton is visible, before DebugLogHost resolves.
         Assert.Equal(LogLevel.Trace, routingPolicy.FileMinimumFor("Resolution"));
         Assert.Equal(LogLevel.Trace, routingPolicy.FileMinimumFor("Resolution.Modern"));
     }
@@ -328,6 +334,30 @@ public async Task BothSqliteStores_ShareOneDatabasePath_ResolveIndependently()
         Assert.NotNull(scope.ServiceProvider.GetService<IScenarioFavoriteStore>());
     }
 
+    [Fact]
+    public async Task Notifiers_ResolveTheirConcreteAndInterfaceAsOneSharedSingleton()
+    {
+        var services = new ServiceCollection();
+        RegisterHostDependencies(services);
+        services.AddEventLogRuntime();
+
+        await using var provider = services.BuildServiceProvider(
+            new ServiceProviderOptions { ValidateScopes = true, ValidateOnBuild = true });
+
+        Assert.Same(
+            provider.GetRequiredService<GroupCollapseNotifier>(),
+            provider.GetRequiredService<IGroupCollapseNotifier>());
+        Assert.Same(
+            provider.GetRequiredService<TagBulkUpdateFailedNotifier>(),
+            provider.GetRequiredService<ITagBulkUpdateFailedNotifier>());
+        Assert.Same(
+            provider.GetRequiredService<ClearAllFiltersNotifier>(),
+            provider.GetRequiredService<IClearAllFiltersNotifier>());
+        Assert.Same(
+            provider.GetRequiredService<SetFilterDateRangeSucceededNotifier>(),
+            provider.GetRequiredService<ISetFilterDateRangeSucceededNotifier>());
+    }
+
     private static void RegisterHostDependencies(IServiceCollection services, ISettingsPreferencesProvider? preferences = null)
     {
         services.AddSingleton(Substitute.For<IDispatcher>());
@@ -342,9 +372,15 @@ private static void RegisterHostDependencies(IServiceCollection services, ISetti
         services.AddSingleton(Substitute.For<IFilePickerService>());
         services.AddSingleton(Substitute.For<IState<EventLogState>>());
         services.AddSingleton(Substitute.For<IState<FilterPaneState>>());
+        services.AddSingleton(Substitute.For<IState<RawEventCountState>>());
+        services.AddSingleton(Substitute.For<IState<StatusBarState>>());
+        services.AddSingleton(Substitute.For<IState<FilterLensState>>());
         services.AddSingleton(Substitute.For<IState<LogTableState>>());
         services.AddSingleton(Substitute.For<IState<RawEventStoreState>>());
+        services.AddSingleton(Substitute.For<IState<FilteredLogPresenceState>>());
         services.AddSingleton(Substitute.For<IState<HistogramState>>());
+        services.AddSingleton(Substitute.For<IState<FilterLibraryState>>());
+        services.AddSingleton(Substitute.For<IState<ScenarioFavoritesState>>());
         services.AddSingleton(Substitute.For<IStateSelection<EventLogState, bool>>());
         services.AddSingleton(new FileLocationOptions(Path.Combine(Path.GetTempPath(), "EventLogExpertTests")));
         services.AddSingleton<HttpClient>();
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/EventLog/DatabaseCoordinationEffectsReloadTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/EventLog/DatabaseCoordinationEffectsReloadTests.cs
index c94678724..e7f2c6522 100644
--- a/tests/Unit/EventLogExpert.Runtime.Tests/EventLog/DatabaseCoordinationEffectsReloadTests.cs
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/EventLog/DatabaseCoordinationEffectsReloadTests.cs
@@ -14,6 +14,8 @@ namespace EventLogExpert.Runtime.Tests.EventLog;
 
 public sealed class DatabaseCoordinationEffectsReloadTests
 {
+    private static readonly TimeSpan s_testTimeout = TimeSpan.FromSeconds(5);
+
     private readonly LogCloseCoordinator _closeCoordinator = new();
     private readonly IDispatcher _dispatcher = Substitute.For<IDispatcher>();
     private readonly IEventLogCommands _eventLogCommands = Substitute.For<IEventLogCommands>();
@@ -109,7 +111,7 @@ public async Task ReloadAllActiveLogsAsync_CalledSequentiallyTwice_CoordinatorLo
 
         var sut = CreateSut();
         await sut.ReloadAllActiveLogsAsync(Ct);
-        await sut.ReloadAllActiveLogsAsync(Ct).WaitAsync(TimeSpan.FromSeconds(5), Ct);
+        await sut.ReloadAllActiveLogsAsync(Ct).WaitAsync(s_testTimeout, Ct);
 
         _dispatcher.Received(2).Dispatch(Arg.Any<CloseLogAction>());
         _eventLogCommands.Received(2).OpenLog("Application", LogPathType.Channel, Arg.Any<CancellationToken>());
@@ -158,8 +160,6 @@ public async Task ReloadAllActiveLogsAsync_CloseThrowsThenSubsequentCallProceeds
         {
             if (!signalCompletionOnDispatch)
             {
-                // Cancel deterministically at the close-await point (not via a wall-clock timer) so the first
-                // reload always fails at the same place and the Received(2) assertion can't race CI scheduling.
                 firstCallCts!.Cancel();
 
                 return;
@@ -177,7 +177,7 @@ public async Task ReloadAllActiveLogsAsync_CloseThrowsThenSubsequentCallProceeds
         }
 
         signalCompletionOnDispatch = true;
-        await sut.ReloadAllActiveLogsAsync(Ct).WaitAsync(TimeSpan.FromSeconds(5), Ct);
+        await sut.ReloadAllActiveLogsAsync(Ct).WaitAsync(s_testTimeout, Ct);
 
         _eventLogCommands.Received(2).OpenLog("Application", LogPathType.Channel, Arg.Any<CancellationToken>());
     }
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/EventLog/EffectsTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/EventLog/EffectsTests.cs
index aceea402f..c5c0a7ac2 100644
--- a/tests/Unit/EventLogExpert.Runtime.Tests/EventLog/EffectsTests.cs
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/EventLog/EffectsTests.cs
@@ -13,7 +13,6 @@
 using EventLogExpert.Runtime.Banner;
 using EventLogExpert.Runtime.Database;
 using EventLogExpert.Runtime.EventLog;
-using EventLogExpert.Runtime.FilterProgress;
 using EventLogExpert.Runtime.LogTable;
 using EventLogExpert.Runtime.StatusBar;
 using EventLogExpert.Runtime.Tests.TestUtils.Constants;
@@ -28,20 +27,21 @@ namespace EventLogExpert.Runtime.Tests.EventLog;
 
 public sealed class EffectsTests
 {
+    private static readonly TimeSpan s_testTimeout = TimeSpan.FromSeconds(5);
+
     [Fact]
-    public async Task HandleAddEvent_ContinuouslyUpdate_QueueFaithful_AppendedViewContainsNewEvent()
+    public async Task Flush_WhenAnEventBuffersDuringIt_ConsumesOnlyTheSnapshotAndPreservesTheNewEvent()
     {
-        // Regression (live-tail one-event lag): drive HandleAddEvent then drain the dispatch queue in Fluxor order. The
-        // rebuild effect reads the store only AFTER the ingest reducer applies, so the appended view contains the new
-        // event. Against the pre-fix same-effect read the view was built from the empty pre-ingest store and stayed empty.
         var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
+        var eventA = FilterEventBuilder.CreateTestEvent(100, logName: Constants.LogNameTestLog);
+        var eventB = FilterEventBuilder.CreateTestEvent(200, logName: Constants.LogNameTestLog);
 
         var state = new EventLogState
         {
-            ContinuouslyUpdate = true,
+            ContinuouslyUpdate = false,
             OpenLogs = ImmutableDictionary<string, OpenLogInfo>.Empty
                 .Add(Constants.LogNameTestLog, new OpenLogInfo(logData.Id, LogPathType.Channel)),
-            NewEventBuffer = [],
+            NewEventBuffer = [eventA],
             AppliedFilter = new Filter(null, [])
         };
 
@@ -53,29 +53,37 @@ public async Task HandleAddEvent_ContinuouslyUpdate_QueueFaithful_AppendedViewCo
         var (effects, mockDispatcher, _) = CreateEffectsWithMutableState(() => state, () => rawState);
         var pending = CaptureDispatchQueue(mockDispatcher);
 
-        AppendTableEventsBatchAction? captured = null;
-        mockDispatcher.When(d => d.Dispatch(Arg.Any<AppendTableEventsBatchAction>()))
-            .Do(call => captured = call.ArgAt<AppendTableEventsBatchAction>(0));
+        IReadOnlyList<ResolvedEvent> snapshot = [eventA];
+        var rawByLog = new Dictionary<EventLogId, IReadOnlyList<ResolvedEvent>> { [logData.Id] = snapshot };
 
-        var newEvent = FilterEventBuilder.CreateTestEvent(100, logName: Constants.LogNameTestLog);
+        pending.Enqueue(new IngestRawEventsAction(rawByLog, RawIngestMode.Prepend));
+        pending.Enqueue(new NewEventBufferConsumedAction(snapshot));
+        pending.Enqueue(new AddEventAction(eventB));
 
-        // Act
-        await effects.HandleAddEvent(new AddEventAction(newEvent), mockDispatcher);
-        await DrainDispatchQueueAsync(pending, effects, mockDispatcher, () => rawState, r => rawState = r);
+        while (pending.Count > 0)
+        {
+            switch (pending.Dequeue())
+            {
+                case IngestRawEventsAction ingest:
+                    rawState = RawEventStoreReducers.ReduceIngestRawEvents(rawState, ingest);
+                    break;
+                case AddEventAction add:
+                    state = Reducers.ReduceAddEvent(state, add);
+                    await effects.HandleAddEvent(add, mockDispatcher);
+                    break;
+                case NewEventBufferConsumedAction consumed:
+                    state = Reducers.ReduceNewEventBufferConsumed(state, consumed);
+                    break;
+            }
+        }
 
-        // Assert: a single batched append whose view for the log contains the just-arrived event.
-        Assert.NotNull(captured);
-        Assert.True(captured.ViewsByLog.ContainsKey(logData.Id));
-        Assert.Equal(1, captured.ViewsByLog[logData.Id].Count);
-        Assert.Equal(newEvent.Id, captured.ViewsByLog[logData.Id].EnumerateDetail().First().Id);
-        mockDispatcher.DidNotReceive().Dispatch(Arg.Any<NewEventBufferConsumedAction>());
+        Assert.Single(state.NewEventBuffer);
+        Assert.Same(eventB, state.NewEventBuffer[0]);
     }
 
     [Fact]
     public async Task HandleAddEvent_WhenContinuouslyUpdateFalse_DoesNotDispatch_BufferingIsReducerOnly()
     {
-        // Buffering for the non-continuously-update path is now an atomic reducer (ReduceAddEvent), so the effect itself
-        // dispatches nothing - it only drives the live tail. Buffer contents / full-flag are covered by the reducer tests.
         var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
         var activeLogs = ImmutableDictionary<string, EventLogData>.Empty.Add(Constants.LogNameTestLog, logData);
 
@@ -83,19 +91,14 @@ public async Task HandleAddEvent_WhenContinuouslyUpdateFalse_DoesNotDispatch_Buf
 
         var newEvent = FilterEventBuilder.CreateTestEvent(100, logName: Constants.LogNameTestLog);
 
-        // Act
         await effects.HandleAddEvent(new AddEventAction(newEvent), mockDispatcher);
 
-        // Assert
         mockDispatcher.DidNotReceive().Dispatch(Arg.Any<object>());
     }
 
     [Fact]
     public async Task HandleAddEvent_WhenContinuouslyUpdateTrue_AndEventFilteredOut_ShouldNotAppend()
     {
-        // Arrange: continuously-update live tail with an active filter that hides the new event. The producer ingests and
-        // queues a rebuild unconditionally; draining after the ingest reducer, the rebuild effect must skip the append
-        // because the event is filtered out, and must NOT consume the buffer (live tail passes BufferEntriesToConsume:null).
         var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
 
         var state = new EventLogState
@@ -120,22 +123,15 @@ public async Task HandleAddEvent_WhenContinuouslyUpdateTrue_AndEventFilteredOut_
         var pending = CaptureDispatchQueue(mockDispatcher);
         var newEvent = FilterEventBuilder.CreateTestEvent(100, logName: Constants.LogNameTestLog);
 
-        // Act
         await effects.HandleAddEvent(new AddEventAction(newEvent), mockDispatcher);
         await DrainDispatchQueueAsync(pending, effects, mockDispatcher, () => rawState, r => rawState = r);
 
-        // Assert: no display append (event hidden) and no buffer consume on the live-tail path.
-        mockDispatcher.DidNotReceive().Dispatch(Arg.Any<AppendTableEventsBatchAction>());
-        mockDispatcher.DidNotReceive().Dispatch(Arg.Any<AppendTableEventsAction>());
         mockDispatcher.DidNotReceive().Dispatch(Arg.Any<NewEventBufferConsumedAction>());
-        mockDispatcher.DidNotReceive().Dispatch(Arg.Any<DisplayReadyAction>());
     }
 
     [Fact]
     public async Task HandleAddEvent_WhenContinuouslyUpdateTrue_AndEventFilteredOut_ShouldStillIngestRaw()
     {
-        // Arrange: a live-tail event the active filter hides still belongs in the raw store. The producer ingests and
-        // queues the rebuild unconditionally; the filter gate lives in the rebuild effect, not here.
         var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
         var activeLogs = ImmutableDictionary<string, EventLogData>.Empty.Add(Constants.LogNameTestLog, logData);
 
@@ -147,22 +143,15 @@ public async Task HandleAddEvent_WhenContinuouslyUpdateTrue_AndEventFilteredOut_
 
         var newEvent = FilterEventBuilder.CreateTestEvent(100, logName: Constants.LogNameTestLog);
 
-        // Act
         await effects.HandleAddEvent(new AddEventAction(newEvent), mockDispatcher);
 
-        // Assert: raw is ingested unconditionally (Prepend) and a rebuild is queued even though the display append itself
-        // is filter-gated inside the rebuild effect.
         mockDispatcher.Received(1).Dispatch(Arg.Is<IngestRawEventsAction>(a => a != null &&
             a.Mode == RawIngestMode.Prepend && a.EventsByLog.ContainsKey(logData.Id)));
-        mockDispatcher.Received(1).Dispatch(Arg.Is<RebuildDisplayViewsAction>(a => a != null &&
-            a.NewEventsByLog.ContainsKey(logData.Id) && a.BufferEntriesToConsume == null));
-        mockDispatcher.DidNotReceive().Dispatch(Arg.Any<AppendTableEventsAction>());
     }
 
     [Fact]
-    public async Task HandleAddEvent_WhenContinuouslyUpdateTrue_ShouldIngestRawAndQueueRebuild()
+    public async Task HandleAddEvent_WhenContinuouslyUpdateTrue_ShouldIngestRaw()
     {
-        // Arrange
         var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
 
         var state = new EventLogState
@@ -184,478 +173,27 @@ public async Task HandleAddEvent_WhenContinuouslyUpdateTrue_ShouldIngestRawAndQu
         var newEvent = FilterEventBuilder.CreateTestEvent(100, logName: Constants.LogNameTestLog);
         var action = new AddEventAction(newEvent);
 
-        // Act
         await effects.HandleAddEvent(action, mockDispatcher);
 
-        // Assert: the producer ingests the raw event and queues a rebuild continuation carrying the new event. It does not
-        // build the display view itself - that runs in the rebuild effect, after the ingest reducer applies.
         mockDispatcher.Received(1).Dispatch(Arg.Is<IngestRawEventsAction>(a => a != null &&
             a.Mode == RawIngestMode.Prepend && a.EventsByLog.ContainsKey(logData.Id)));
-
-        mockDispatcher.Received(1).Dispatch(Arg.Is<RebuildDisplayViewsAction>(a => a != null &&
-            a.BufferEntriesToConsume == null &&
-            a.NewEventsByLog.ContainsKey(logData.Id) &&
-            a.NewEventsByLog[logData.Id].Count == 1 &&
-            a.NewEventsByLog[logData.Id][0].Id == newEvent.Id));
-
-        mockDispatcher.DidNotReceive().Dispatch(Arg.Any<AppendTableEventsAction>());
-        mockDispatcher.DidNotReceive().Dispatch(Arg.Any<DisplayReadyAction>());
     }
 
     [Fact]
     public async Task HandleAddEvent_WhenLogNotActive_ShouldNotDispatchActions()
     {
-        // Arrange
         var (effects, mockDispatcher) = CreateEffects();
         var newEvent = FilterEventBuilder.CreateTestEvent(100, logName: Constants.LogNameTestLog);
         var action = new AddEventAction(newEvent);
 
-        // Act
         await effects.HandleAddEvent(action, mockDispatcher);
 
-        // Assert: No dispatches should occur
         mockDispatcher.DidNotReceive().Dispatch(Arg.Any<object>());
     }
 
-    [Fact]
-    public async Task HandleApplyFilter_FilterBranch_ShouldBracketDisplayedEventsUpdateWithFilterProgress()
-    {
-        var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
-        var activeLogs = ImmutableDictionary<string, EventLogData>.Empty.Add(Constants.LogNameTestLog, logData);
-
-        var (effects, mockDispatcher, _, _, _) = CreateEffectsWithServices(activeLogs: activeLogs);
-
-        var filter = FilterBuilder.CreateTestFilter(isEnabled: true);
-        var action = new ApplyFilterAction(new Filter(null, [filter]));
-
-        await effects.HandleApplyFilter(action, mockDispatcher);
-
-        Received.InOrder(() =>
-        {
-            mockDispatcher.Dispatch(Arg.Is<SetFilterProgressAction>(a => a != null && a.IsLoading));
-            mockDispatcher.Dispatch(Arg.Any<DisplayReadyAction>());
-            mockDispatcher.Dispatch(Arg.Is<SetFilterProgressAction>(a => a != null && !a.IsLoading));
-        });
-    }
-
-    [Fact]
-    public async Task HandleApplyFilter_FilterBranch_WhenFilterServiceThrows_ShouldStillClearFilterProgress()
-    {
-        var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
-        var raw = new List<ResolvedEvent> { FilterEventBuilder.CreateTestEvent(100) };
-
-        var state = new EventLogState
-        {
-            ContinuouslyUpdate = false,
-            OpenLogs = ImmutableDictionary<string, OpenLogInfo>.Empty
-                .Add(Constants.LogNameTestLog, new OpenLogInfo(logData.Id, LogPathType.Channel)),
-            NewEventBuffer = [],
-            AppliedFilter = new Filter(null, [])
-        };
-
-        var seeded = new RawEventStoreState
-        {
-            ByLog = ImmutableDictionary<EventLogId, EventColumnStore>.Empty.Add(logData.Id, EventColumnStore.Build(raw, 0, 0))
-        };
-
-        var reads = 0;
-
-        var (effects, mockDispatcher, _) = CreateEffectsWithMutableState(
-            () => state,
-            () =>
-            {
-                // The pass-1 snapshot (read 1) succeeds and the progress spinner turns on; the post-build
-                // store re-check (read 2, inside the try) faults. The finally must still clear the spinner.
-                if (Interlocked.Increment(ref reads) >= 2)
-                {
-                    throw new InvalidOperationException("boom");
-                }
-
-                return seeded;
-            });
-
-        var action = new ApplyFilterAction(new Filter(null, []));
-
-        await Assert.ThrowsAsync<InvalidOperationException>(() => effects.HandleApplyFilter(action, mockDispatcher));
-
-        mockDispatcher.Received(1).Dispatch(Arg.Is<SetFilterProgressAction>(a => a != null && a.IsLoading));
-        mockDispatcher.Received(1).Dispatch(Arg.Is<SetFilterProgressAction>(a => a != null && !a.IsLoading));
-        mockDispatcher.DidNotReceive().Dispatch(Arg.Any<DisplayReadyAction>());
-    }
-
-    [Fact]
-    public async Task HandleApplyFilter_FilterBranch_WhenFinalizeArrivesDuringOffThreadBuild_ShouldRefilterAndReflectIt()
-    {
-        var snapshotData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
-        var snapshotRaw = new List<ResolvedEvent> { FilterEventBuilder.CreateTestEvent(200) };
-
-        var finalizedRaw = new List<ResolvedEvent>
-        {
-            FilterEventBuilder.CreateTestEvent(200),
-            FilterEventBuilder.CreateTestEvent(201),
-            FilterEventBuilder.CreateTestEvent(202)
-        };
-
-        var state = new EventLogState
-        {
-            ContinuouslyUpdate = false,
-            OpenLogs = ImmutableDictionary<string, OpenLogInfo>.Empty
-                .Add(Constants.LogNameTestLog, new OpenLogInfo(snapshotData.Id, LogPathType.Channel)),
-            NewEventBuffer = [],
-            AppliedFilter = new Filter(null, [])
-        };
-
-        RawEventStoreState RawStateWith(IReadOnlyList<ResolvedEvent> events, long contentVersion = 0) => new()
-        {
-            ByLog = ImmutableDictionary<EventLogId, EventColumnStore>.Empty.Add(snapshotData.Id, EventColumnStore.Build(events, 0, contentVersion))
-        };
-
-        var (effects, mockDispatcher, _) =
-            CreateEffectsWithMutableState(
-                () => state,
-                SequencedRaw(RawStateWith(snapshotRaw), RawStateWith(finalizedRaw, 1)));
-
-        // An empty filter passes every row, so the assertion can require the full post-race count.
-        await effects.HandleApplyFilter(new ApplyFilterAction(new Filter(null, [])), mockDispatcher);
-
-        // The pass-1 snapshot saw only event 200 at ContentVersion 0; the post-build re-check saw the
-        // finalize rebuild at ContentVersion 1 and refiltered, so the published view reflects all three.
-        mockDispatcher.Received(1)
-            .Dispatch(Arg.Is<DisplayReadyAction>(a => a != null &&
-                a.Views.ContainsKey(snapshotData.Id) &&
-                a.Views[snapshotData.Id].Count == finalizedRaw.Count &&
-                a.Views[snapshotData.Id].EnumerateDetail().Any(e => e.Id == 202)));
-    }
-
-    [Fact]
-    public async Task HandleApplyFilter_FilterBranch_WhenLiveTailArrivesDuringOffThreadBuild_ShouldRefilterAndIncludeIt()
-    {
-        var snapshotData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
-        var snapshotRaw = new List<ResolvedEvent> { FilterEventBuilder.CreateTestEvent(100) };
-
-        var liveTailRaw = new List<ResolvedEvent>
-        {
-            FilterEventBuilder.CreateTestEvent(100),
-            FilterEventBuilder.CreateTestEvent(101)
-        };
-
-        var state = new EventLogState
-        {
-            ContinuouslyUpdate = false,
-            OpenLogs = ImmutableDictionary<string, OpenLogInfo>.Empty
-                .Add(Constants.LogNameTestLog, new OpenLogInfo(snapshotData.Id, LogPathType.Channel)),
-            NewEventBuffer = [],
-            AppliedFilter = new Filter(null, [])
-        };
-
-        RawEventStoreState RawStateWith(IReadOnlyList<ResolvedEvent> events, long contentVersion = 0) => new()
-        {
-            ByLog = ImmutableDictionary<EventLogId, EventColumnStore>.Empty.Add(snapshotData.Id, EventColumnStore.Build(events, 0, contentVersion))
-        };
-
-        var (effects, mockDispatcher, _) =
-            CreateEffectsWithMutableState(
-                () => state,
-                SequencedRaw(RawStateWith(snapshotRaw), RawStateWith(liveTailRaw, 1)));
-
-        // An empty filter passes every row, so the assertion can require the full post-race count.
-        await effects.HandleApplyFilter(new ApplyFilterAction(new Filter(null, [])), mockDispatcher);
-
-        // The pass-1 snapshot saw only event 100 at ContentVersion 0; the post-build re-check saw the
-        // live-tail append at ContentVersion 1 and refiltered, so the published view includes event 101.
-        mockDispatcher.Received(1)
-            .Dispatch(Arg.Is<DisplayReadyAction>(a => a != null &&
-                a.Views.ContainsKey(snapshotData.Id) &&
-                a.Views[snapshotData.Id].Count == liveTailRaw.Count &&
-                a.Views[snapshotData.Id].EnumerateDetail().Any(e => e.Id == 101)));
-    }
-
-    [Fact]
-    public async Task HandleApplyFilter_FilterBranch_WhenLogClosedDuringFilter_ShouldOmitStaleSliceFromDispatch()
-    {
-        // Arrange: the log closes (raw store and open-log map both drop it) while the filter
-        // task is running. The post-filter dispatch must omit the closed log's slice. (The
-        // reducer also skips unknown log ids, but checking at the effect keeps the dispatch minimal.)
-        var snapshotEvents = new List<ResolvedEvent> { FilterEventBuilder.CreateTestEvent(100) };
-        var snapshotData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
-        var snapshotRaw = snapshotEvents;
-
-        var openState = new EventLogState
-        {
-            ContinuouslyUpdate = false,
-            OpenLogs = ImmutableDictionary<string, OpenLogInfo>.Empty
-                .Add(Constants.LogNameTestLog, new OpenLogInfo(snapshotData.Id, LogPathType.Channel)),
-            NewEventBuffer = [],
-            AppliedFilter = new Filter(null, [])
-        };
-
-        var openRaw = new RawEventStoreState
-        {
-            ByLog = ImmutableDictionary<EventLogId, EventColumnStore>.Empty.Add(snapshotData.Id, EventColumnStore.Build(snapshotRaw, 0, 0))
-        };
-
-        var closedRaw = new RawEventStoreState();
-
-        var (effects, mockDispatcher, _) =
-            CreateEffectsWithMutableState(() => openState, SequencedRaw(openRaw, closedRaw));
-
-        var action = new ApplyFilterAction(new Filter(null, []));
-
-        // Act
-        await effects.HandleApplyFilter(action, mockDispatcher);
-
-        // Assert: the raw store dropped the log during the off-thread build (the post-snapshot reads
-        // return an empty store), so the post-build re-check finds it gone and DisplayReady omits its slice.
-        mockDispatcher.Received(1)
-            .Dispatch(Arg.Is<DisplayReadyAction>(a => a != null && !a.Views.ContainsKey(snapshotData.Id)));
-    }
-
-    [Fact]
-    public async Task HandleApplyFilter_FilterBranch_WhenLogEventsChangeDuringFilter_ShouldRefilterFromCurrentState()
-    {
-        // Arrange: single open log; a live event arrives during the first filter pass (the raw
-        // event list ref changes). The new filter must be re-applied to the post-mutation rows in
-        // a single retry pass so the user sees the filter applied to the updated row set, not stale rows.
-        var snapshotEvents = new List<ResolvedEvent> { FilterEventBuilder.CreateTestEvent(100) };
-        var snapshotData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
-        var snapshotRaw = snapshotEvents;
-
-        var liveTailEvents = new List<ResolvedEvent>
-        {
-            FilterEventBuilder.CreateTestEvent(100),
-            FilterEventBuilder.CreateTestEvent(101)
-        };
-
-        var liveTailRaw = liveTailEvents;
-
-        var state = new EventLogState
-        {
-            ContinuouslyUpdate = false,
-            OpenLogs = ImmutableDictionary<string, OpenLogInfo>.Empty
-                .Add(Constants.LogNameTestLog, new OpenLogInfo(snapshotData.Id, LogPathType.Channel)),
-            NewEventBuffer = [],
-            AppliedFilter = new Filter(null, [])
-        };
-
-        var snapshotRawState = new RawEventStoreState
-        {
-            ByLog = ImmutableDictionary<EventLogId, EventColumnStore>.Empty.Add(snapshotData.Id, EventColumnStore.Build(snapshotRaw, 0, 0))
-        };
-
-        var postLiveTailRawState = new RawEventStoreState
-        {
-            ByLog = ImmutableDictionary<EventLogId, EventColumnStore>.Empty.Add(snapshotData.Id, EventColumnStore.Build(liveTailRaw, 0, 1))
-        };
-
-        var (effects, mockDispatcher, _) =
-            CreateEffectsWithMutableState(
-                () => state,
-                SequencedRaw(snapshotRawState, postLiveTailRawState));
-
-        var action = new ApplyFilterAction(new Filter(null, []));
-
-        // Act
-        await effects.HandleApplyFilter(action, mockDispatcher);
-
-        // Assert: the pass-1 snapshot saw ContentVersion 0 (event 100 only); the post-build re-check saw
-        // the live-tail rebuild at ContentVersion 1 and refiltered from current state, so the published view
-        // reflects the updated row set (event 101), not the stale pass-1 rows.
-        mockDispatcher.Received(1)
-            .Dispatch(Arg.Is<DisplayReadyAction>(a => a != null &&
-                a.Views.ContainsKey(snapshotData.Id) &&
-                a.Views[snapshotData.Id].Count == liveTailRaw.Count &&
-                a.Views[snapshotData.Id].EnumerateDetail().Any(e => e.Id == 101)));
-    }
-
-    [Fact]
-    public async Task HandleApplyFilter_FilterBranch_WhenLogStillStaleAfterRetry_ShouldOmitStaleSliceFromDispatch()
-    {
-        // Arrange: the raw event list changes during pass 1 AND again during pass 2. The pass-2 result is
-        // still stale, so the slice is omitted (the reducer's carry-forward keeps the existing rows, avoiding
-        // lost live events) AND a ConvergeFilterAction is scheduled to re-filter the log once it stabilizes.
-        var snapshotEvents = new List<ResolvedEvent>();
-        var snapshotData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
-        var snapshotRaw = snapshotEvents;
-
-        var pass1MutationEvents = new List<ResolvedEvent> { FilterEventBuilder.CreateTestEvent(100) };
-
-        var pass2MutationEvents = new List<ResolvedEvent>
-        {
-            FilterEventBuilder.CreateTestEvent(100),
-            FilterEventBuilder.CreateTestEvent(101)
-        };
-
-        var pass1MutationRaw = pass1MutationEvents;
-        var pass2MutationRaw = pass2MutationEvents;
-
-        var state = new EventLogState
-        {
-            ContinuouslyUpdate = false,
-            OpenLogs = ImmutableDictionary<string, OpenLogInfo>.Empty
-                .Add(Constants.LogNameTestLog, new OpenLogInfo(snapshotData.Id, LogPathType.Channel)),
-            NewEventBuffer = [],
-            AppliedFilter = new Filter(null, [])
-        };
-
-        RawEventStoreState RawStateWith(IReadOnlyList<ResolvedEvent> events, long contentVersion = 0) => new()
-        {
-            ByLog = ImmutableDictionary<EventLogId, EventColumnStore>.Empty.Add(snapshotData.Id, EventColumnStore.Build(events, 0, contentVersion))
-        };
-
-        var (effects, mockDispatcher, _) =
-            CreateEffectsWithMutableState(
-                () => state,
-                SequencedRaw(
-                    RawStateWith(snapshotRaw),
-                    RawStateWith(pass1MutationRaw, 1),
-                    RawStateWith(pass2MutationRaw, 2),
-                    RawStateWith(pass2MutationRaw, 3)));
-
-        var action = new ApplyFilterAction(new Filter(null, []));
-
-        // Act
-        await effects.HandleApplyFilter(action, mockDispatcher);
-
-        // Assert: pass 1 saw ContentVersion 0; the post-build re-check saw ContentVersion 1 (stale) and
-        // refiltered; the pass-2 re-check saw ContentVersion 3 against the pass-2 snapshot's ContentVersion 2,
-        // so the slice is still stale and omitted, and a convergence pass is scheduled while the progress
-        // spinner stays on (cleared later by the converging pass).
-        mockDispatcher.Received(1)
-            .Dispatch(Arg.Is<DisplayReadyAction>(a => a != null && !a.Views.ContainsKey(snapshotData.Id)));
-
-        mockDispatcher.Received(1)
-            .Dispatch(Arg.Is<ConvergeFilterAction>(a => a != null && a.StaleIds.Contains(snapshotData.Id)));
-
-        mockDispatcher.DidNotReceive().Dispatch(Arg.Is<SetFilterProgressAction>(a => a != null && !a.IsLoading));
-    }
-
-    [Fact]
-    public async Task HandleApplyFilter_FilterBranch_WhenSupersededByNewerFilter_ShouldDropStaleResults()
-    {
-        var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
-
-        var state = new EventLogState
-        {
-            ContinuouslyUpdate = false,
-            OpenLogs = ImmutableDictionary<string, OpenLogInfo>.Empty
-                .Add(Constants.LogNameTestLog, new OpenLogInfo(logData.Id, LogPathType.Channel)),
-            NewEventBuffer = [],
-            AppliedFilter = new Filter(null, [])
-        };
-
-        var rawState = new RawEventStoreState
-        {
-            ByLog = ImmutableDictionary<EventLogId, EventColumnStore>.Empty.Add(
-                logData.Id,
-                EventColumnStore.Build(new List<ResolvedEvent> { FilterEventBuilder.CreateTestEvent(100) }, 0, 0))
-        };
-
-        var (effects, mockDispatcher, _) =
-            CreateEffectsWithMutableState(() => state, () => rawState);
-
-        // The stale run's own progress-true dispatch stands in for a concurrent newer filter: it bumps the
-        // filter token exactly once, so the stale run's post-build token guard drops it before it can publish.
-        var superseded = 0;
-
-        mockDispatcher
-            .When(d => d.Dispatch(Arg.Is<SetFilterProgressAction>(a => a != null && a.IsLoading)))
-            .Do(_ =>
-            {
-                if (Interlocked.Exchange(ref superseded, 1) == 0)
-                {
-                    effects.ConcurrencyState.InvalidateInFlightFilters();
-                }
-            });
-
-        // The stale run is superseded mid-flight and must publish nothing.
-        await effects.HandleApplyFilter(new ApplyFilterAction(new Filter(null, [])), mockDispatcher);
-
-        mockDispatcher.DidNotReceive().Dispatch(Arg.Any<DisplayReadyAction>());
-
-        // A subsequent run captures the current token and lands normally.
-        await effects.HandleApplyFilter(new ApplyFilterAction(new Filter(null, [])), mockDispatcher);
-
-        mockDispatcher.Received(1)
-            .Dispatch(Arg.Is<DisplayReadyAction>(a => a != null && a.Views[logData.Id].EnumerateDetail().Any(e => e.Id == 100)));
-
-        // The stale run's finally was suppressed by the token guard, so only the fresh run cleared the spinner.
-        mockDispatcher.Received(1).Dispatch(Arg.Is<SetFilterProgressAction>(a => a != null && !a.IsLoading));
-    }
-
-    [Fact]
-    public async Task HandleApplyFilter_ReloadBranch_ShouldClearStaleFilterProgressSpinner()
-    {
-        // The reload path must dispatch SetFilterProgressAction(false) to clear any spinner
-        // left over from a superseded filter-only run. Without this clear, the reload's
-        // per-table IsLoading takes over the UI but the (stale) filter spinner would appear
-        // stuck. The reload path itself must never dispatch SetFilterProgressAction(true);
-        // per-table loading covers the close+reopen window.
-        var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
-        var activeLogs = ImmutableDictionary<string, EventLogData>.Empty.Add(Constants.LogNameTestLog, logData);
-
-        var (effects, mockDispatcher, _, _, _) = CreateEffectsWithServices(activeLogs: activeLogs);
-
-        // Route CloseLog to HandleCloseLog so the reload's close-completion TCS resolves
-        // quickly. Without this routing, HandleApplyFilter parks on LogCloseTimeout (30s).
-        var closeTasks = new List<Task>();
-
-        mockDispatcher
-            .When(d => d.Dispatch(Arg.Any<CloseLogAction>()))
-            .Do(callInfo =>
-            {
-                closeTasks.Add(effects.HandleCloseLog(callInfo.ArgAt<CloseLogAction>(0), mockDispatcher));
-            });
-
-        var xmlFilter = FilterBuilder.CreateTestFilter(FilterTestConstants.FilterXmlContainsData, isEnabled: true);
-        var action = new ApplyFilterAction(new Filter(null, [xmlFilter]));
-
-        await effects.HandleApplyFilter(action, mockDispatcher);
-
-        Assert.True(action.Filter.RequiresXml);
-        mockDispatcher.Received(1).Dispatch(Arg.Is<SetFilterProgressAction>(a => a != null && !a.IsLoading));
-        mockDispatcher.DidNotReceive().Dispatch(Arg.Is<SetFilterProgressAction>(a => a != null && a.IsLoading));
-
-        // Surface any HandleCloseLog faults before exiting the test.
-        await Task.WhenAll(closeTasks);
-    }
-
-    [Fact]
-    public async Task HandleApplyFilter_ShouldFilterAndDispatchUpdate()
-    {
-        // Arrange
-        var events = new List<ResolvedEvent>
-        {
-            FilterEventBuilder.CreateTestEvent(100, level: FilterTestConstants.EventLevelError),
-            FilterEventBuilder.CreateTestEvent(200, level: FilterTestConstants.EventLevelInformation)
-        };
-
-        var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
-        var activeLogs = ImmutableDictionary<string, EventLogData>.Empty.Add(Constants.LogNameTestLog, logData);
-
-        var (effects, mockDispatcher, _, _, _) = CreateEffectsWithServices(activeLogs: activeLogs);
-
-        var filter = new Filter(null, []);
-        var action = new ApplyFilterAction(filter);
-
-        // Act
-        await effects.HandleApplyFilter(action, mockDispatcher);
-
-        // Assert: the columnar filter path publishes a DisplayReady for the active log.
-        mockDispatcher.Received(1).Dispatch(Arg.Any<DisplayReadyAction>());
-    }
-
     [Fact]
     public async Task HandleApplyFilter_WhenCloseAllArrivesMidReopenLoop_ShouldDispatchCloseLogForJustReopenedLogs()
     {
-        // Arrange: pin down the per-iteration revalidation in the reopen loop. With two
-        // logs needing reload, hook the FIRST OpenLogAction dispatch to land CloseAll
-        // before the second iteration. The loop must:
-        //   (1) detect the supersession on iteration 2,
-        //   (2) dispatch CloseLogAction for the log it already reopened on iteration 1,
-        //   (3) NOT dispatch the second OpenLog,
-        //   (4) clear pending selection restore for both logs in the reload set.
-        // Without per-iteration revalidation, both OpenLogs would land and re-add the logs
-        // the user just closed.
         var logData1 = new EventLogData(Constants.LogNameLog1, LogPathType.Channel);
         var logData2 = new EventLogData(Constants.LogNameLog2, LogPathType.Channel);
 
@@ -674,8 +212,6 @@ public async Task HandleApplyFilter_WhenCloseAllArrivesMidReopenLoop_ShouldDispa
                 closeTasks.Add(effects.HandleCloseLog(callInfo.ArgAt<CloseLogAction>(0), mockDispatcher));
             });
 
-        // Hook the FIRST OpenLogAction dispatch to land CloseAll synchronously, which bumps
-        // reload token before the loop's next iteration check.
         var openLogCount = 0;
 
         mockDispatcher
@@ -686,8 +222,6 @@ public async Task HandleApplyFilter_WhenCloseAllArrivesMidReopenLoop_ShouldDispa
 
                 if (openLogCount == 1)
                 {
-                    // Run HandleCloseAll synchronously inside the dispatch hook so the next
-                    // loop iteration sees the bumped reload token.
                     effects.HandleCloseAll(mockDispatcher).GetAwaiter().GetResult();
                 }
             });
@@ -695,30 +229,18 @@ public async Task HandleApplyFilter_WhenCloseAllArrivesMidReopenLoop_ShouldDispa
         var xmlFilter = FilterBuilder.CreateTestFilter(FilterTestConstants.FilterXmlContainsData, isEnabled: true);
         var filter = new Filter(null, [xmlFilter]);
 
-        // Act
         await effects.HandleApplyFilter(new ApplyFilterAction(filter), mockDispatcher);
 
-        // Assert: exactly one OpenLog dispatched (the second iteration bailed). A CloseLog
-        // for the first-reopened log must have been dispatched as cleanup. The original two
-        // CloseLog dispatches (reload-path close+await) plus the cleanup CloseLog = 3 total
-        // CloseLog dispatches for these two log names.
         mockDispatcher.Received(1).Dispatch(Arg.Any<OpenLogAction>());
 
-        // The cleanup CloseLog targets the log we already reopened (Log1).
         mockDispatcher.Received().Dispatch(Arg.Is<CloseLogAction>(a => a != null && a.LogName == Constants.LogNameLog1));
 
-        // Surface any HandleCloseLog faults before exiting the test.
         await Task.WhenAll(closeTasks);
     }
 
     [Fact]
     public async Task HandleApplyFilter_WhenCloseAllSupersedesReload_ShouldClearPendingSelectionRestoreEntries()
     {
-        // Arrange: pin down that when CloseAll supersedes a reload, the
-        // _pendingSelectionRestore entries the reload wrote are cleared before bail-out.
-        // Without this cleanup, a later manual reopen of the same log name would consume
-        // stale selection state from the canceled reload (HandleLoadEvents reads
-        // _pendingSelectionRestore unconditionally on each load).
         var selectedEvent = FilterEventBuilder.CreateTestEvent(100, recordId: 42, logName: Constants.LogNameTestLog);
 
         var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
@@ -774,20 +296,13 @@ public async Task HandleApplyFilter_WhenCloseAllSupersedesReload_ShouldClearPend
         var xmlFilter = FilterBuilder.CreateTestFilter(FilterTestConstants.FilterXmlContainsData, isEnabled: true);
         var filter = new Filter(null, [xmlFilter]);
 
-        // Act: start ApplyFilter; it writes the pending selection restore entry (selected
-        // event has RecordId=42), then parks waiting for close-completion.
         var applyFilterTask = effects.HandleApplyFilter(new ApplyFilterAction(filter), mockDispatcher);
 
-        // Land CloseAll while the reload is parked.
         await effects.HandleCloseAll(mockDispatcher);
 
         watcherCompletion.SetResult();
-        await applyFilterTask.WaitAsync(TimeSpan.FromSeconds(5), TestContext.Current.CancellationToken);
+        await applyFilterTask.WaitAsync(s_testTimeout, TestContext.Current.CancellationToken);
 
-        // Assert: a subsequent HandleLoadEvents for the same log name must find NO pending
-        // selection restore entry (otherwise selection would be restored from the canceled
-        // reload). HandleLoadEvents consumes the entry via TryRemove; if the entry isn't
-        // there, no SetSelectedEvents dispatch occurs.
         var reopenLogData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
 
         var reloadedEvents = ImmutableArray.Create(
@@ -803,17 +318,11 @@ public async Task HandleApplyFilter_WhenCloseAllSupersedesReload_ShouldClearPend
     [Fact]
     public async Task HandleApplyFilter_WhenCloseAllSupersedesReload_ShouldNotReopenClosedLogs()
     {
-        // Arrange: pin down that a CloseAll landing WHILE ReloadLogsWithXmlAsync is parked
-        // on the close-completion TCS suppresses the reopen loop. Without the version
-        // recheck in ReloadLogsWithXmlAsync, the reload would re-add the just-closed logs
-        // because OpenLogAction's reducer treats missing logs as adds.
         var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
         var activeLogs = ImmutableDictionary<string, EventLogData>.Empty.Add(Constants.LogNameTestLog, logData);
 
         var (effects, mockDispatcher, mockLogWatcher, _, _) = CreateEffectsWithServices(activeLogs: activeLogs);
 
-        // Gate HandleCloseLog so the reload's close-completion TCS stays unsignaled until
-        // we have a chance to land a CloseAll on the same dispatcher.
         var watcherCompletion = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
         mockLogWatcher.RemoveLogAsync(Arg.Any<string>()).Returns(watcherCompletion.Task);
 
@@ -829,35 +338,25 @@ public async Task HandleApplyFilter_WhenCloseAllSupersedesReload_ShouldNotReopen
         var xmlFilter = FilterBuilder.CreateTestFilter(FilterTestConstants.FilterXmlContainsData, isEnabled: true);
         var filter = new Filter(null, [xmlFilter]);
 
-        // Act: start HandleApplyFilter; it parks waiting for the close-completion TCS.
         var applyFilterTask = effects.HandleApplyFilter(new ApplyFilterAction(filter), mockDispatcher);
 
         Assert.False(applyFilterTask.IsCompleted,
             "HandleApplyFilter must wait for HandleCloseLog before populating the restore map.");
 
-        // While ReloadLogsWithXmlAsync is parked, simulate a CloseAll landing on the
-        // dispatcher. This bumps reload token so the parked reload sees itself
-        // as superseded and skips its reopen loop.
         await effects.HandleCloseAll(mockDispatcher);
 
-        // Release HandleCloseLog; the close-completion TCS signals and the reload continues.
         watcherCompletion.SetResult();
 
-        await applyFilterTask.WaitAsync(TimeSpan.FromSeconds(5), TestContext.Current.CancellationToken);
+        await applyFilterTask.WaitAsync(s_testTimeout, TestContext.Current.CancellationToken);
 
-        // Assert: no OpenLogAction was dispatched for the closed log. The CloseLogAction
-        // from the reload itself is fine; only the post-await reopen must be suppressed.
         mockDispatcher.DidNotReceive().Dispatch(Arg.Any<OpenLogAction>());
 
-        // Surface any HandleCloseLog faults before exiting the test.
         await Task.WhenAll(closeTasks);
     }
 
     [Fact]
     public async Task HandleApplyFilter_WhenFilterDoesNotRequireXml_ShouldNotReloadLogs()
     {
-        // Arrange: single active log + non-XML filter (Id-based). RequiresXml should be false,
-        // so HandleApplyFilter should fall through to DisplayReady and never close/open logs.
         var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
         var activeLogs = ImmutableDictionary<string, EventLogData>.Empty.Add(Constants.LogNameTestLog, logData);
 
@@ -867,29 +366,21 @@ public async Task HandleApplyFilter_WhenFilterDoesNotRequireXml_ShouldNotReloadL
         var filter = new Filter(null, [nonXmlFilter]);
         var action = new ApplyFilterAction(filter);
 
-        // Act
         await effects.HandleApplyFilter(action, mockDispatcher);
 
-        // Assert: DisplayReady path; no Close/Open dispatches.
         Assert.False(filter.RequiresXml);
         mockDispatcher.DidNotReceive().Dispatch(Arg.Any<CloseLogAction>());
         mockDispatcher.DidNotReceive().Dispatch(Arg.Any<OpenLogAction>());
-        mockDispatcher.Received(1).Dispatch(Arg.Any<DisplayReadyAction>());
     }
 
     [Fact]
     public async Task HandleApplyFilter_WhenFilterRequiresXmlAndLogLacksXml_ShouldCloseAndReopenLog()
     {
-        // Arrange: active log has not been loaded with XML, so it must be re-read.
         var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
         var activeLogs = ImmutableDictionary<string, EventLogData>.Empty.Add(Constants.LogNameTestLog, logData);
 
         var (effects, mockDispatcher, _, _, _) = CreateEffectsWithServices(activeLogs: activeLogs);
 
-        // Route CloseLog to HandleCloseLog so HandleApplyFilter's await on the close-completion
-        // TCS resolves quickly (otherwise it hits LogCloseTimeout, 30s). Capture the routed
-        // tasks so any fault in HandleCloseLog surfaces at the end of the test instead of
-        // being swallowed by the discard.
         var closeTasks = new List<Task>();
 
         mockDispatcher
@@ -903,10 +394,8 @@ public async Task HandleApplyFilter_WhenFilterRequiresXmlAndLogLacksXml_ShouldCl
         var filter = new Filter(null, [xmlFilter]);
         var action = new ApplyFilterAction(filter);
 
-        // Act
         await effects.HandleApplyFilter(action, mockDispatcher);
 
-        // Assert
         Assert.True(filter.RequiresXml);
 
         mockDispatcher.Received(1)
@@ -917,22 +406,12 @@ public async Task HandleApplyFilter_WhenFilterRequiresXmlAndLogLacksXml_ShouldCl
             .Dispatch(Arg.Is<OpenLogAction>(a => a != null &&
                 a.LogName == Constants.LogNameTestLog && a.LogPathType == LogPathType.Channel));
 
-        // Reload path returns early; no DisplayReady until LoadEvents fires.
-        mockDispatcher.DidNotReceive().Dispatch(Arg.Any<DisplayReadyAction>());
-
-        // Surface any HandleCloseLog faults before exiting the test.
         await Task.WhenAll(closeTasks);
     }
 
     [Fact]
     public async Task HandleApplyFilter_WhenFilterRequiresXml_AwaitsCloseCompletionBeforeReturning()
     {
-        // Arrange: RemoveLogAsync is gated by a controlled TCS so HandleCloseLog cannot
-        // complete until the test signals it. HandleCloseLog clears _pendingSelectionRestore
-        // for the log name AFTER awaiting the watcher, then signals the close-completion
-        // TCS in its finally block. HandleApplyFilter must await that close-completion TCS
-        // before populating _pendingSelectionRestore; otherwise the in-flight close wipes
-        // the freshly-written entry. This test pins down the ordering invariant.
         var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
         var activeLogs = ImmutableDictionary<string, EventLogData>.Empty.Add(Constants.LogNameTestLog, logData);
 
@@ -941,9 +420,6 @@ public async Task HandleApplyFilter_WhenFilterRequiresXml_AwaitsCloseCompletionB
         var watcherCompletion = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
         mockLogWatcher.RemoveLogAsync(Arg.Any<string>()).Returns(watcherCompletion.Task);
 
-        // Capture each routed close so any fault in HandleCloseLog surfaces before the test
-        // ends (the discarded `_ = effects.HandleCloseLog(...)` would otherwise let a fault
-        // be silently observed by the finalizer).
         var closeTasks = new List<Task>();
 
         mockDispatcher
@@ -956,41 +432,29 @@ public async Task HandleApplyFilter_WhenFilterRequiresXml_AwaitsCloseCompletionB
         var xmlFilter = FilterBuilder.CreateTestFilter(FilterTestConstants.FilterXmlContainsData, isEnabled: true);
         var filter = new Filter(null, [xmlFilter]);
 
-        // Act: start HandleApplyFilter; it must remain pending until watcherCompletion fires.
         var applyFilterTask = effects.HandleApplyFilter(new ApplyFilterAction(filter), mockDispatcher);
 
-        // Assert: task is blocked because HandleCloseLog can't finish until RemoveLogAsync
-        // returns. Without the close-completion await in HandleApplyFilter, the task would
-        // already be completed (it would have written the restore map and returned).
         Assert.False(applyFilterTask.IsCompleted,
             "HandleApplyFilter must wait for HandleCloseLog before populating the restore map.");
 
-        // Release HandleCloseLog; the finally block signals the close-completion TCS.
         watcherCompletion.SetResult();
 
-        await applyFilterTask.WaitAsync(TimeSpan.FromSeconds(5), TestContext.Current.CancellationToken);
+        await applyFilterTask.WaitAsync(s_testTimeout, TestContext.Current.CancellationToken);
 
-        // OpenLog should now have been dispatched (only happens after the close await).
         mockDispatcher.Received(1)
             .Dispatch(Arg.Is<OpenLogAction>(a => a != null &&
                 a.LogName == Constants.LogNameTestLog && a.LogPathType == LogPathType.Channel));
 
-        // Surface any HandleCloseLog faults before exiting the test.
         await Task.WhenAll(closeTasks);
     }
 
     [Fact]
     public async Task HandleApplyFilter_WhenFilterRequiresXml_ShouldRestoreSelectionAfterReload()
     {
-        // Arrange: active log with one previously-selected event (RecordId=42). After the
-        // XML filter triggers a reload, HandleLoadEvents should consume the pending restore
-        // entry and dispatch SelectEvents with the matching event from the new event set.
         var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
 
         var selectedEvent = FilterEventBuilder.CreateTestEvent(100, recordId: 42, logName: Constants.LogNameTestLog);
 
-        // The reload's finalized rebuild is already in the store by the time HandleLoadEvents runs; seed it
-        // so the effect builds the view and consumes the pending restore instead of early-returning.
         var reloadedEvents = new List<ResolvedEvent>
         {
             FilterEventBuilder.CreateTestEvent(100, recordId: 42, logName: Constants.LogNameTestLog),
@@ -1041,12 +505,6 @@ public async Task HandleApplyFilter_WhenFilterRequiresXml_ShouldRestoreSelection
 
         var mockDispatcher = Substitute.For<IDispatcher>();
 
-        // Route CloseLog dispatches into HandleCloseLog so the close-completion TCSes
-        // get signaled. HandleCloseLog clears _pendingSelectionRestore for the log name as
-        // part of its async cleanup; HandleApplyFilter must await the close before writing
-        // the restore map. Without this routing the await would hit LogCloseTimeout (30s).
-        // Capture the routed tasks so any fault in HandleCloseLog surfaces at the end of
-        // the test instead of being swallowed by the discard.
         var closeTasks = new List<Task>();
 
         mockDispatcher
@@ -1059,32 +517,23 @@ public async Task HandleApplyFilter_WhenFilterRequiresXml_ShouldRestoreSelection
         var xmlFilter = FilterBuilder.CreateTestFilter(FilterTestConstants.FilterXmlContainsData, isEnabled: true);
         var filter = new Filter(null, [xmlFilter]);
 
-        // Act 1: Apply the XML filter, populating _pendingSelectionRestore for "TestLog".
         await effects.HandleApplyFilter(new ApplyFilterAction(filter), mockDispatcher);
 
-        // Act 2: Simulate the subsequent LoadEvents that the new OpenLog produces (the reloaded events,
-        // seeded into the store above, include the previously-selected RecordId=42 plus an unrelated one).
         await effects.HandleLoadEvents(new LoadEventsAction(logData, reloadedEvents), mockDispatcher);
 
-        // Assert: SetSelectedEvents dispatched with exactly the restored event (RecordId=42).
         mockDispatcher.Received(1)
             .Dispatch(Arg.Is<SetSelectedEventsAction>(a => a != null &&
                 a.Selection.Count() == 1 && a.Selection.First().ReloadKey!.Value.RecordId == 42));
 
-        // Surface any HandleCloseLog faults before exiting the test.
+        mockDispatcher.Received(1)
+            .Dispatch(Arg.Is<RequestRevealFocusAction>(a => a != null && a.Target == new EventLocator(logData.Id, 0, 0)));
+
         await Task.WhenAll(closeTasks);
     }
 
     [Fact]
     public async Task HandleApplyFilter_WhenNewerApplyFilterRacesReload_ShouldStillReopenClosedLogs()
     {
-        // Arrange: pin down that a newer ApplyFilter racing in while ReloadLogsWithXmlAsync
-        // is parked must NOT cause the parked reload to skip its reopen. The newer filter
-        // only bumps filter token; only CloseAll bumps reload token. Without
-        // that distinction, the round-2 guard treated any token bump as supersession
-        // and left the user's logs closed (the newer ApplyFilter sees empty OpenLogs
-        // because the CloseLog reducer already removed them, finds nothing to reload, and
-        // returns).
         var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
         var activeLogs = ImmutableDictionary<string, EventLogData>.Empty.Add(Constants.LogNameTestLog, logData);
 
@@ -1105,92 +554,26 @@ public async Task HandleApplyFilter_WhenNewerApplyFilterRacesReload_ShouldStillR
         var xmlFilter1 = FilterBuilder.CreateTestFilter(FilterTestConstants.FilterXmlContainsData, isEnabled: true);
         var filter1 = new Filter(null, [xmlFilter1]);
 
-        // Act: start the first ApplyFilter; it parks waiting for the close-completion TCS.
         var applyFilterTask = effects.HandleApplyFilter(new ApplyFilterAction(filter1), mockDispatcher);
 
         Assert.False(applyFilterTask.IsCompleted,
             "HandleApplyFilter must wait for HandleCloseLog before populating the restore map.");
 
-        // Race a NEWER ApplyFilter in. Use a non-XML filter so it goes through the fast
-        // ApplyFilterAndPublishAsync path (no reload needed), but it still bumps
-        // filter token at the top of HandleApplyFilter. It must NOT bump
-        // reload token, so the parked first reload should still reopen its log.
         var nonXmlFilter = FilterBuilder.CreateTestFilter(isEnabled: true);
         var filter2 = new Filter(null, [nonXmlFilter]);
         await effects.HandleApplyFilter(new ApplyFilterAction(filter2), mockDispatcher);
 
-        // Release the parked HandleCloseLog so the first reload can proceed.
         watcherCompletion.SetResult();
 
-        await applyFilterTask.WaitAsync(TimeSpan.FromSeconds(5), TestContext.Current.CancellationToken);
+        await applyFilterTask.WaitAsync(s_testTimeout, TestContext.Current.CancellationToken);
 
-        // Assert: OpenLog WAS dispatched for the closed log by the first reload (which
-        // would not have happened if the round-2 guard had treated filter2's filter token
-        // bump as supersession).
         mockDispatcher.Received(1)
             .Dispatch(Arg.Is<OpenLogAction>(a => a != null &&
                 a.LogName == Constants.LogNameTestLog && a.LogPathType == LogPathType.Channel));
 
-        // Surface any HandleCloseLog faults before exiting the test.
         await Task.WhenAll(closeTasks);
     }
 
-    [Fact]
-    public async Task HandleApplyFilter_WhenReloadSupersedesFilterOnly_ShouldDropFilterOnlyResults()
-    {
-        // A reload-path ApplyFilter invalidates any in-flight filter-only run by bumping the
-        // filter token (FilteringEffects.HandleApplyFilter calls InvalidateInFlightFilters
-        // before awaiting the reload). The older filter-only run then holds a stale token, so
-        // its post-build token guard must drop its DisplayReady rather than let it land on top
-        // of the newer applied filter.
-        var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
-
-        var state = new EventLogState
-        {
-            ContinuouslyUpdate = false,
-            OpenLogs = ImmutableDictionary<string, OpenLogInfo>.Empty
-                .Add(Constants.LogNameTestLog, new OpenLogInfo(logData.Id, LogPathType.Channel)),
-            NewEventBuffer = [],
-            AppliedFilter = new Filter(null, [])
-        };
-
-        var rawState = new RawEventStoreState
-        {
-            ByLog = ImmutableDictionary<EventLogId, EventColumnStore>.Empty.Add(
-                logData.Id,
-                EventColumnStore.Build(new List<ResolvedEvent> { FilterEventBuilder.CreateTestEvent(999) }, 0, 0))
-        };
-
-        var (effects, mockDispatcher, _) =
-            CreateEffectsWithMutableState(() => state, () => rawState);
-
-        // Model the concurrent reload's token bump: invalidate in-flight filters exactly once,
-        // on the stale run's own progress-true dispatch. That fires after the stale run captured
-        // its token and before its post-build guard, so the guard drops the stale result just as
-        // a real reload-path ApplyFilter would.
-        var superseded = 0;
-
-        mockDispatcher
-            .When(d => d.Dispatch(Arg.Is<SetFilterProgressAction>(a => a != null && a.IsLoading)))
-            .Do(_ =>
-            {
-                if (Interlocked.Exchange(ref superseded, 1) == 0)
-                {
-                    effects.ConcurrencyState.InvalidateInFlightFilters();
-                }
-            });
-
-        var staleFilterModel = FilterBuilder.CreateTestFilter(FilterTestConstants.FilterIdEquals999, isEnabled: true);
-        var staleFilter = new Filter(null, [staleFilterModel]);
-
-        await effects.HandleApplyFilter(new ApplyFilterAction(staleFilter), mockDispatcher);
-
-        // The stale filter-only run must NOT have dispatched its DisplayReady for id 999.
-        mockDispatcher.DidNotReceive()
-            .Dispatch(Arg.Is<DisplayReadyAction>(a => a != null &&
-                a.Views.ContainsKey(logData.Id) && a.Views[logData.Id].EnumerateDetail().Any(e => e.Id == 999)));
-    }
-
     [Fact]
     public async Task HandleCloseAll_DispatchesStateClearsBeforeWatcherDrain()
     {
@@ -1205,7 +588,7 @@ public async Task HandleCloseAll_DispatchesStateClearsBeforeWatcherDrain()
         mockResolverCache.Received(1).ClearAll();
 
         watcherTcs.SetResult();
-        await closeTask.WaitAsync(TimeSpan.FromSeconds(5), TestContext.Current.CancellationToken);
+        await closeTask.WaitAsync(s_testTimeout, TestContext.Current.CancellationToken);
 
         Assert.True(closeTask.IsCompletedSuccessfully);
         await mockLogWatcher.Received(1).RemoveAllAsync();
@@ -1214,7 +597,6 @@ public async Task HandleCloseAll_DispatchesStateClearsBeforeWatcherDrain()
     [Fact]
     public async Task HandleCloseAll_ShouldClearAllResolvedXml()
     {
-        // Arrange
         var mockEventLogState = Substitute.For<IState<EventLogState>>();
 
         mockEventLogState.Value.Returns(new EventLogState
@@ -1244,23 +626,18 @@ public async Task HandleCloseAll_ShouldClearAllResolvedXml()
             Substitute.For<ICriticalErrorService>(),
             mockDispatcher);
 
-        // Act
         await effects.HandleCloseAll(mockDispatcher);
 
-        // Assert
         mockXmlResolver.Received(1).ClearAll();
     }
 
     [Fact]
     public async Task HandleCloseAll_ShouldRemoveAllLogsAndClearCache()
     {
-        // Arrange
         var (effects, mockDispatcher, mockLogWatcher, mockResolverCache, _) = CreateEffectsWithServices();
 
-        // Act
         await effects.HandleCloseAll(mockDispatcher);
 
-        // Assert
         await mockLogWatcher.Received(1).RemoveAllAsync();
         mockResolverCache.Received(1).ClearAll();
     }
@@ -1268,10 +645,6 @@ public async Task HandleCloseAll_ShouldRemoveAllLogsAndClearCache()
     [Fact]
     public async Task HandleCloseLog_AwaitsWatcherShutdown_BeforeSignalingCloseCompletion()
     {
-        // Arrange: RemoveLogAsync returns a TCS we control; HandleCloseLog must NOT
-        // signal its close-completion TCS until that TCS finishes. Verifies the B2
-        // ordering fix: per-event resolver scopes (and their pooled SQLite handles) must
-        // drain before the coordinator believes the log is closed.
         var (effects, mockDispatcher, mockLogWatcher, _, _) = CreateEffectsWithServices();
 
         var watcherTcs = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
@@ -1280,19 +653,15 @@ public async Task HandleCloseLog_AwaitsWatcherShutdown_BeforeSignalingCloseCompl
         var logId = EventLogId.Create();
         var action = new CloseLogAction(logId, Constants.LogNameTestLog);
 
-        // Act
         var closeTask = effects.HandleCloseLog(action, mockDispatcher);
 
-        // Give HandleCloseLog a chance to advance to the await.
         await Task.Delay(50, TestContext.Current.CancellationToken);
 
-        // Assert: close has not completed because the watcher hasn't released yet.
         Assert.False(closeTask.IsCompleted, "HandleCloseLog should be blocked on RemoveLogAsync.");
 
-        // Now release the watcher; HandleCloseLog should complete promptly.
         watcherTcs.SetResult();
 
-        await closeTask.WaitAsync(TimeSpan.FromSeconds(5), TestContext.Current.CancellationToken);
+        await closeTask.WaitAsync(s_testTimeout, TestContext.Current.CancellationToken);
 
         Assert.True(closeTask.IsCompletedSuccessfully);
     }
@@ -1300,8 +669,6 @@ public async Task HandleCloseLog_AwaitsWatcherShutdown_BeforeSignalingCloseCompl
     [Fact]
     public async Task HandleCloseLog_ShouldClearResolvedXmlForLog()
     {
-        // Arrange: verify the IEventXmlResolver entry for the closed log is evicted so a
-        // subsequent reopen doesn't return stale text from the previous log instance.
         var logId = EventLogId.Create();
         var mockEventLogState = Substitute.For<IState<EventLogState>>();
 
@@ -1333,25 +700,20 @@ public async Task HandleCloseLog_ShouldClearResolvedXmlForLog()
         var mockDispatcher = Substitute.For<IDispatcher>();
         var action = new CloseLogAction(logId, Constants.LogNameTestLog);
 
-        // Act
         await effects.HandleCloseLog(action, mockDispatcher);
 
-        // Assert
         mockXmlResolver.Received(1).ClearXmlCacheForLog(Constants.LogNameTestLog);
     }
 
     [Fact]
     public async Task HandleCloseLog_ShouldRemoveLogAndDispatchCloseAction()
     {
-        // Arrange
         var logId = EventLogId.Create();
         var (effects, mockDispatcher, mockLogWatcher, _, _) = CreateEffectsWithServices();
         var action = new CloseLogAction(logId, Constants.LogNameTestLog);
 
-        // Act
         await effects.HandleCloseLog(action, mockDispatcher);
 
-        // Assert
         await mockLogWatcher.Received(1).RemoveLogAsync(Constants.LogNameTestLog);
 
         mockDispatcher.Received(1)
@@ -1362,22 +724,18 @@ public async Task HandleCloseLog_ShouldRemoveLogAndDispatchCloseAction()
     [Fact]
     public async Task HandleCloseLog_WhenLastLog_ShouldClearResolverCache()
     {
-        // Arrange: state has no active logs (reducer already removed the last one)
         var logId = EventLogId.Create();
         var (effects, mockDispatcher, mockLogWatcher, mockResolverCache, _) = CreateEffectsWithServices();
         var action = new CloseLogAction(logId, Constants.LogNameTestLog);
 
-        // Act
         await effects.HandleCloseLog(action, mockDispatcher);
 
-        // Assert
         mockResolverCache.Received(1).ClearAll();
     }
 
     [Fact]
     public async Task HandleCloseLog_WhenOtherLogsRemain_ShouldNotClearResolverCache()
     {
-        // Arrange: state still has another active log
         var logData = new EventLogData(Constants.LogNameLog1, LogPathType.Channel);
 
         var activeLogs = ImmutableDictionary<string, EventLogData>.Empty
@@ -1387,188 +745,11 @@ public async Task HandleCloseLog_WhenOtherLogsRemain_ShouldNotClearResolverCache
         var closingLogId = EventLogId.Create();
         var action = new CloseLogAction(closingLogId, Constants.LogNameTestLog);
 
-        // Act
         await effects.HandleCloseLog(action, mockDispatcher);
 
-        // Assert
         mockResolverCache.DidNotReceive().ClearAll();
     }
 
-    [Fact]
-    public async Task HandleConvergeFilter_WhenSnapshotStable_PublishesFreshAndDoesNotReschedule()
-    {
-        // Arrange: the convergence target's raw list is stable across the pass; the converge must publish the
-        // re-filtered slice, clear the progress spinner, and NOT schedule another ConvergeFilterAction.
-        var events = new List<ResolvedEvent> { FilterEventBuilder.CreateTestEvent(100) };
-        var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
-        var raw = events;
-
-        var state = new EventLogState
-        {
-            ContinuouslyUpdate = false,
-            OpenLogs = ImmutableDictionary<string, OpenLogInfo>.Empty
-                .Add(Constants.LogNameTestLog, new OpenLogInfo(logData.Id, LogPathType.Channel)),
-            NewEventBuffer = [],
-            AppliedFilter = new Filter(null, [])
-        };
-
-        var rawState = new RawEventStoreState
-        {
-            ByLog = ImmutableDictionary<EventLogId, EventColumnStore>.Empty.Add(logData.Id, EventColumnStore.Build(raw, 0, 0))
-        };
-
-        var (effects, mockDispatcher, mockFilterService) =
-            CreateEffectsWithMutableState(() => state, () => rawState);
-
-        mockFilterService.FilterActiveLogs(Arg.Any<IReadOnlyList<(EventLogId Id, IReadOnlyList<ResolvedEvent> Events)>>(), Arg.Any<Filter>())
-            .Returns(new Dictionary<EventLogId, IReadOnlyList<ResolvedEvent>> { [logData.Id] = raw });
-
-        // Act
-        await effects.HandleConvergeFilter(
-            new ConvergeFilterAction([logData.Id], effects.ConcurrencyState.GetCurrentFilterToken()),
-            mockDispatcher);
-
-        // Assert: converged slice published, progress cleared, no further convergence scheduled.
-        mockDispatcher.Received(1)
-            .Dispatch(Arg.Is<DisplayReadyAction>(a => a != null && a.Views.ContainsKey(logData.Id)));
-
-        mockDispatcher.Received(1).Dispatch(Arg.Is<SetFilterProgressAction>(a => a != null && !a.IsLoading));
-
-        mockDispatcher.DidNotReceive().Dispatch(Arg.Any<ConvergeFilterAction>());
-    }
-
-    [Fact]
-    public async Task HandleConvergeFilter_WhenSupersededByNewerToken_DoesNotPublish()
-    {
-        // Arrange: a newer operation bumps the filter token while the converge pass is off-thread
-        // building its view; the post-await token guard must drop the stale convergence without
-        // dispatching DisplayReady.
-        var events = new List<ResolvedEvent> { FilterEventBuilder.CreateTestEvent(100) };
-        var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
-        var raw = events;
-
-        var state = new EventLogState
-        {
-            ContinuouslyUpdate = false,
-            OpenLogs = ImmutableDictionary<string, OpenLogInfo>.Empty
-                .Add(Constants.LogNameTestLog, new OpenLogInfo(logData.Id, LogPathType.Channel)),
-            NewEventBuffer = [],
-            AppliedFilter = new Filter(null, [])
-        };
-
-        var rawState = new RawEventStoreState
-        {
-            ByLog = ImmutableDictionary<EventLogId, EventColumnStore>.Empty.Add(logData.Id, EventColumnStore.Build(raw, 0, 0))
-        };
-
-        // Model a newer operation superseding the converge pass mid-flight: the first raw-store read
-        // HandleConvergeFilter performs (ResidualOpenStale, after its initial token check and before
-        // the post-build guard) bumps the filter token exactly once. The post-build guard must then
-        // drop the stale convergence without dispatching DisplayReady.
-        EffectsHarness? harness = null;
-        var superseded = 0;
-
-        var (effects, mockDispatcher, _) = CreateEffectsWithMutableState(
-            () => state,
-            () =>
-            {
-                if (harness is { } inFlight && Interlocked.Exchange(ref superseded, 1) == 0)
-                {
-                    inFlight.ConcurrencyState.InvalidateInFlightFilters();
-                }
-
-                return rawState;
-            });
-
-        harness = effects;
-
-        // Act
-        await effects.HandleConvergeFilter(
-            new ConvergeFilterAction([logData.Id], effects.ConcurrencyState.GetCurrentFilterToken()),
-            mockDispatcher);
-
-        // Assert: superseded run published nothing.
-        mockDispatcher.DidNotReceive().Dispatch(Arg.Any<DisplayReadyAction>());
-    }
-
-    [Fact]
-    public async Task HandleConvergeFilter_WhenTargetLogClosed_PrunesWithoutFilteringOrPublishing()
-    {
-        // Arrange: the convergence target closed before the converge ran; it must be pruned (no filter pass, no
-        // DisplayReady, no re-schedule) and the progress spinner cleared so it cannot spin on a gone log.
-        var closedId = EventLogId.Create();
-
-        var state = new EventLogState
-        {
-            ContinuouslyUpdate = false,
-            OpenLogs = ImmutableDictionary<string, OpenLogInfo>.Empty,
-            NewEventBuffer = [],
-            AppliedFilter = new Filter(null, [])
-        };
-
-        var rawState = new RawEventStoreState();
-
-        var (effects, mockDispatcher, mockFilterService) =
-            CreateEffectsWithMutableState(() => state, () => rawState);
-
-        // Act
-        await effects.HandleConvergeFilter(
-            new ConvergeFilterAction([closedId], effects.ConcurrencyState.GetCurrentFilterToken()),
-            mockDispatcher);
-
-        // Assert: pruned to empty: no filtering, no publish, no re-converge; progress cleared.
-        mockFilterService.DidNotReceive()
-            .FilterActiveLogs(Arg.Any<IReadOnlyList<(EventLogId Id, IReadOnlyList<ResolvedEvent> Events)>>(), Arg.Any<Filter>());
-
-        mockDispatcher.DidNotReceive().Dispatch(Arg.Any<DisplayReadyAction>());
-        mockDispatcher.DidNotReceive().Dispatch(Arg.Any<ConvergeFilterAction>());
-        mockDispatcher.Received(1).Dispatch(Arg.Is<SetFilterProgressAction>(a => a != null && !a.IsLoading));
-    }
-
-    [Fact]
-    public async Task HandleLoadEvents_ShouldFilterAndDispatchUpdateTable()
-    {
-        // Arrange: the raw-store reducer for LoadEventsAction runs synchronously before this effect
-        // in production, so the finalized rebuild is already in the store. HandleLoadEvents builds the
-        // columnar display view over that store (the filter is applied inside the build) and hands the
-        // pre-built view to the reducer via UpdateTableAction.
-        var events = new List<ResolvedEvent>
-        {
-            FilterEventBuilder.CreateTestEvent(100, level: FilterTestConstants.EventLevelError),
-            FilterEventBuilder.CreateTestEvent(200, level: FilterTestConstants.EventLevelInformation)
-        };
-
-        var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
-
-        var state = new EventLogState
-        {
-            ContinuouslyUpdate = false,
-            OpenLogs = ImmutableDictionary<string, OpenLogInfo>.Empty
-                .Add(Constants.LogNameTestLog, new OpenLogInfo(logData.Id, LogPathType.Channel)),
-            NewEventBuffer = [],
-            AppliedFilter = new Filter(null, [])
-        };
-
-        var rawState = new RawEventStoreState
-        {
-            ByLog = ImmutableDictionary<EventLogId, EventColumnStore>.Empty.Add(
-                logData.Id,
-                EventColumnStore.Build(events, 0, 0))
-        };
-
-        var (effects, mockDispatcher, _) =
-            CreateEffectsWithMutableState(() => state, () => rawState);
-
-        var action = new LoadEventsAction(logData, events);
-
-        // Act
-        await effects.HandleLoadEvents(action, mockDispatcher);
-
-        // Assert: a pre-built display view for the finalized log is handed to the reducer.
-        mockDispatcher.Received(1).Dispatch(Arg.Is<UpdateTableAction>(a => a != null &&
-            a.LogId == logData.Id && a.View != null && a.View.Count == 2));
-    }
-
     [Fact]
     public async Task HandleLoadNewEvents_ShouldIngestRawPrependFromBuffer()
     {
@@ -1589,7 +770,6 @@ public async Task HandleLoadNewEvents_ShouldIngestRawPrependFromBuffer()
     [Fact]
     public async Task HandleLoadNewEvents_ShouldProcessBufferAndDispatchActions()
     {
-        // Arrange
         var bufferedEvents = new List<ResolvedEvent>
         {
             FilterEventBuilder.CreateTestEvent(100, logName: Constants.LogNameTestLog),
@@ -1615,19 +795,13 @@ public async Task HandleLoadNewEvents_ShouldProcessBufferAndDispatchActions()
         var (effects, mockDispatcher, _) = CreateEffectsWithMutableState(() => state, () => rawState);
         var pending = CaptureDispatchQueue(mockDispatcher);
 
-        // Act
         await effects.HandleLoadNewEvents(mockDispatcher);
         await DrainDispatchQueueAsync(pending, effects, mockDispatcher, () => rawState, r => rawState = r);
 
-        // Assert: a single batched append carrying both buffered events (built from the post-ingest store), then the
-        // buffer consume of exactly the captured snapshot.
         mockDispatcher.Received(1)
-            .Dispatch(Arg.Is<AppendTableEventsBatchAction>(a => a != null &&
-                a.ViewsByLog.Count == 1 &&
-                a.ViewsByLog.ContainsKey(logData.Id) &&
-                a.ViewsByLog[logData.Id].Count == 2));
-
-        mockDispatcher.DidNotReceive().Dispatch(Arg.Any<DisplayReadyAction>());
+            .Dispatch(Arg.Is<IngestRawEventsAction>(a => a != null &&
+                a.EventsByLog.ContainsKey(logData.Id) &&
+                a.EventsByLog[logData.Id].Count == 2));
 
         mockDispatcher.Received(1)
             .Dispatch(Arg.Is<NewEventBufferConsumedAction>(a => a != null && a.ConsumedEvents.Count == 2));
@@ -1636,7 +810,6 @@ public async Task HandleLoadNewEvents_ShouldProcessBufferAndDispatchActions()
     [Fact]
     public async Task HandleLoadNewEvents_WhenAllEventsFiltered_ShouldNotDispatchAppendBatch()
     {
-        // Arrange
         var bufferedEvents = new List<ResolvedEvent>
         {
             FilterEventBuilder.CreateTestEvent(100, logName: Constants.LogNameTestLog)
@@ -1665,14 +838,9 @@ public async Task HandleLoadNewEvents_WhenAllEventsFiltered_ShouldNotDispatchApp
 
         var pending = CaptureDispatchQueue(mockDispatcher);
 
-        // Act
         await effects.HandleLoadNewEvents(mockDispatcher);
         await DrainDispatchQueueAsync(pending, effects, mockDispatcher, () => rawState, r => rawState = r);
 
-        // Assert: every buffered event is filtered out, so no display append - but the captured snapshot is still consumed
-        // (a successful zero-view rebuild), so the "New Events" count resets.
-        mockDispatcher.DidNotReceive().Dispatch(Arg.Any<AppendTableEventsBatchAction>());
-
         mockDispatcher.Received(1)
             .Dispatch(Arg.Is<NewEventBufferConsumedAction>(a => a != null && a.ConsumedEvents.Count == 1));
     }
@@ -1680,8 +848,6 @@ public async Task HandleLoadNewEvents_WhenAllEventsFiltered_ShouldNotDispatchApp
     [Fact]
     public async Task HandleLoadNewEvents_WhenBufferSpansMultipleLogs_ShouldGroupIntoSingleBatch()
     {
-        // Arrange
-        // FilterEventBuilder.CreateTestEvent always sets OwningLog="TestLog"; override via `with` to span 2 logs.
         var bufferedEvents = new List<ResolvedEvent>
         {
             FilterEventBuilder.CreateTestEvent(100) with { OwningLog = Constants.LogNameApplication },
@@ -1709,78 +875,26 @@ public async Task HandleLoadNewEvents_WhenBufferSpansMultipleLogs_ShouldGroupInt
                 .Add(testLog.Id, EventColumnStore.Empty)
         };
 
-        var (effects, mockDispatcher, _) = CreateEffectsWithMutableState(() => state, () => rawState);
-        var pending = CaptureDispatchQueue(mockDispatcher);
-
-        AppendTableEventsBatchAction? captured = null;
-
-        mockDispatcher
-            .When(dispatcher => dispatcher.Dispatch(Arg.Any<AppendTableEventsBatchAction>()))
-            .Do(call => captured = call.ArgAt<AppendTableEventsBatchAction>(0));
-
-        // Act
-        await effects.HandleLoadNewEvents(mockDispatcher);
-        await DrainDispatchQueueAsync(pending, effects, mockDispatcher, () => rawState, r => rawState = r);
-
-        // Assert: a single batched append covering both logs.
-        mockDispatcher.Received(1).Dispatch(Arg.Any<AppendTableEventsBatchAction>());
-        Assert.NotNull(captured);
-        Assert.Equal(2, captured.ViewsByLog.Count);
-        Assert.Equal(2, captured.ViewsByLog[applicationLog.Id].Count);
-        Assert.Equal(1, captured.ViewsByLog[testLog.Id].Count);
-    }
-
-    [Fact]
-    public async Task HandleLoadNewEvents_WhenRebuildThrows_PreservesBufferByNotClearing()
-    {
-        // Clear-on-throw guard: when the rebuild throws (e.g. a broken compiled filter), the continuation must NOT consume
-        // the buffer, so the count stays instead of clearing with no row shown.
-        var bufferedEvents = new List<ResolvedEvent>
-        {
-            FilterEventBuilder.CreateTestEvent(100, logName: Constants.LogNameTestLog)
-        };
-
-        var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
-
-        var state = new EventLogState
-        {
-            ContinuouslyUpdate = false,
-            OpenLogs = ImmutableDictionary<string, OpenLogInfo>.Empty
-                .Add(Constants.LogNameTestLog, new OpenLogInfo(logData.Id, LogPathType.Channel)),
-            NewEventBuffer = bufferedEvents,
-            AppliedFilter = new Filter(null, [])
-        };
-
-        var rawState = new RawEventStoreState
-        {
-            ByLog = ImmutableDictionary<EventLogId, EventColumnStore>.Empty.Add(logData.Id, EventColumnStore.Empty)
-        };
-
-        var (effects, mockDispatcher, mockFilterService) = CreateEffectsWithMutableState(() => state, () => rawState);
+        var (effects, mockDispatcher, _) = CreateEffectsWithMutableState(() => state, () => rawState);
 
-        mockFilterService.GetFilteredEvents(Arg.Any<IEnumerable<ResolvedEvent>>(), Arg.Any<Filter>())
-            .Returns(_ => throw new InvalidOperationException("filter compile failed"));
+        IngestRawEventsAction? captured = null;
 
-        var pending = CaptureDispatchQueue(mockDispatcher);
+        mockDispatcher
+            .When(dispatcher => dispatcher.Dispatch(Arg.Any<IngestRawEventsAction>()))
+            .Do(call => captured = call.ArgAt<IngestRawEventsAction>(0));
 
-        // Act
         await effects.HandleLoadNewEvents(mockDispatcher);
 
-        await Assert.ThrowsAsync<InvalidOperationException>(() =>
-            DrainDispatchQueueAsync(pending, effects, mockDispatcher, () => rawState, r => rawState = r));
-
-        // Assert: the rebuild threw before appending, so neither the append nor the buffer consume fired - the count stays.
-        mockDispatcher.DidNotReceive().Dispatch(Arg.Any<AppendTableEventsBatchAction>());
-        mockDispatcher.DidNotReceive().Dispatch(Arg.Any<NewEventBufferConsumedAction>());
+        mockDispatcher.Received(1).Dispatch(Arg.Any<IngestRawEventsAction>());
+        Assert.NotNull(captured);
+        Assert.Equal(2, captured.EventsByLog.Count);
+        Assert.Equal(2, captured.EventsByLog[applicationLog.Id].Count);
+        Assert.Single(captured.EventsByLog[testLog.Id]);
     }
 
     [Fact]
     public async Task HandleOpenLog_AwaitsInitialClassificationTask_BeforeResolverConstruction()
     {
-        // Arrange: block classification with a pending TCS so we can verify the resolver
-        // is NOT looked up until classification completes. Determinism comes from the await
-        // semantics: the IServiceProvider mock cannot be invoked while the await is parked
-        // on an incomplete task, so an immediate post-call assertion is sufficient.
         var logData = new EventLogData(Constants.LogNameApplication, LogPathType.Channel);
         var activeLogs = ImmutableDictionary<string, EventLogData>.Empty.Add(Constants.LogNameApplication, logData);
 
@@ -1793,34 +907,23 @@ public async Task HandleOpenLog_AwaitsInitialClassificationTask_BeforeResolverCo
 
         var action = new OpenLogAction(Constants.LogNameApplication, LogPathType.Channel);
 
-        // Act 1: start the open; await yields back at InitialClassificationTask.
         var openTask = effects.HandleOpenLog(action, mockDispatcher);
 
-        // Assert 1: resolver lookup MUST NOT have been touched yet.
         mockServiceProvider.DidNotReceive().GetService(typeof(IEventResolver));
 
-        // Act 2: release classification; let HandleOpenLog finish.
         classificationTcs.SetResult(true);
         await openTask;
 
-        // Assert 2: resolver lookup happens after classification.
         mockServiceProvider.Received(1).GetService(typeof(IEventResolver));
     }
 
     [Fact]
     public async Task HandleOpenLog_LogClosedDuringClassificationAwait_DoesNotDispatchAddTable()
     {
-        // Arrange: simulate the user closing the log (HandleCloseLog dispatch already removed
-        // it from OpenLogs and canceled its CTS) while HandleOpenLog is parked on the
-        // classification await. After the await releases, HandleOpenLog must bail BEFORE
-        // calling LoadLogAsync; otherwise LoadLogAsync's AddTable dispatch would resurrect
-        // a table entry the user already dismissed, leaving an orphan in LogTableState.
         var logData = new EventLogData(Constants.LogNameApplication, LogPathType.Channel);
 
-
         var classificationTcs = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
 
-        // Use a mutable IState so we can flip OpenLogs to "log closed" partway through.
         var mockEventLogState = Substitute.For<IState<EventLogState>>();
 
         var initialState = new EventLogState
@@ -1860,22 +963,17 @@ public async Task HandleOpenLog_LogClosedDuringClassificationAwait_DoesNotDispat
         var mockDispatcher = Substitute.For<IDispatcher>();
         var action = new OpenLogAction(Constants.LogNameApplication, LogPathType.Channel);
 
-        // Act 1: start the open; await yields back at InitialClassificationTask.
         var openTask = effects.HandleOpenLog(action, mockDispatcher);
 
-        // Act 2: simulate HandleCloseLog: remove the log from OpenLogs.
         mockEventLogState.Value.Returns(new EventLogState
         {
             OpenLogs = ImmutableDictionary<string, OpenLogInfo>.Empty,
             AppliedFilter = new Filter(null, [])
         });
 
-        // Act 3: release classification; HandleOpenLog should detect the missing log and bail.
         classificationTcs.SetResult(true);
         await openTask;
 
-        // Assert: neither AddTable (would orphan in LogTableState) nor any resolver work
-        // happened. The bail-out path returns silently after the post-await identity check.
         mockServiceProvider.DidNotReceive().GetService(typeof(IEventResolver));
 
         mockDispatcher.DidNotReceive().Dispatch(Arg.Any<AddTableAction>());
@@ -1884,9 +982,6 @@ public async Task HandleOpenLog_LogClosedDuringClassificationAwait_DoesNotDispat
     [Fact]
     public async Task HandleOpenLog_ResolverThrows_CallsReportCritical_DoesNotPropagate()
     {
-        // Arrange: resolver factory throws (e.g., DI graph misconfiguration). HandleOpenLog
-        // must surface this as a Reload-tier banner via ICriticalErrorService.ReportCritical and
-        // return cleanly instead of letting the exception escape the effect.
         var logData = new EventLogData(Constants.LogNameApplication, LogPathType.Channel);
         var activeLogs = ImmutableDictionary<string, EventLogData>.Empty.Add(Constants.LogNameApplication, logData);
 
@@ -1898,10 +993,8 @@ public async Task HandleOpenLog_ResolverThrows_CallsReportCritical_DoesNotPropag
 
         var action = new OpenLogAction(Constants.LogNameApplication, LogPathType.Channel);
 
-        // Act: must not throw.
         await effects.HandleOpenLog(action, mockDispatcher);
 
-        // Assert: exact exception forwarded to banner; no resolver-status dispatch fired.
         mockCriticalErrorService.Received(1).ReportCritical(thrown);
 
         mockDispatcher.DidNotReceive().Dispatch(Arg.Any<SetResolverStatusAction>());
@@ -1918,8 +1011,6 @@ public async Task HandleOpenLog_ReverseEagerLoad_DispatchesExactlyOneEagerPartia
 
         await openLog.HandleOpenLog(new OpenLogAction(Constants.LogNameApplication, LogPathType.Channel), dispatcher);
 
-        // The in-memory load finishes well under the 3-second partial timer, so the eager dispatch is the only
-        // partial, asserting the eager path fires exactly once.
         var partials = AllPartialActions(dispatcher);
         Assert.Single(partials);
         Assert.NotEmpty(partials[0].Events);
@@ -1941,14 +1032,10 @@ public async Task HandleOpenLog_ReverseEagerLoad_EmptyLog_SeedsWatcherWithNullBo
     [Fact]
     public async Task HandleOpenLog_ReverseEagerLoad_FinalListContainsEveryEventOnceSortedDescending()
     {
-        // 250 > the eager first-paint threshold (200), so the eager dispatch fires.
         const int total = 250;
         var fakeFactory = new FakeEventLogReaderFactory(
             new FakeEventLogReader(BuildReverseBatches(total, batchSize: 30), newestBookmark: "NEWEST"));
 
-        // Delay the newest batch so older batches resolve and AddRange first, scrambling completion order. The
-        // sequence-ordered drain (not a physical re-sort) still reassembles the final list in read order, so it stays
-        // complete, deduplicated, and newest-first.
         var (openLog, dispatcher, _) = CreateEagerLoadEffects(
             fakeFactory,
             resolveDelayMs: recordId => recordId > total - 30 ? 15 : 0);
@@ -1966,13 +1053,6 @@ public async Task HandleOpenLog_ReverseEagerLoad_FinalListContainsEveryEventOnce
     [Fact]
     public async Task HandleOpenLog_ReverseEagerLoad_NonDescendingArrival_HoldsPhysicalIndexStableAcrossFinalization()
     {
-        // Regression (highlight cache + selection stale after the partial-load finalization rebuild): the highlight
-        // cache and selection are keyed on EventLocator = (LogId, Generation, physical Index). Partials stream in
-        // arrival order and finalization rebuilds the raw store at the SAME Generation. A finalization RecordId-DESC
-        // re-sort would reassign physical indices while keeping Generation, so a partial-era locator would keep
-        // passing the Generation guard yet resolve to a DIFFERENT physical row (stale highlight colors, wrong selected
-        // event) whenever arrival order differs from RecordId-DESC. This corpus reaches that case: a null RecordId at
-        // its read position, a non-monotonic read (5000), and a duplicate RecordId (997).
         var arrivalRecordIds = new List<long?> { 1000, 999, 998, null, 5000, 997, 997, 996 };
         for (long next = 995; arrivalRecordIds.Count < 230; next--) { arrivalRecordIds.Add(next); }
 
@@ -1983,22 +1063,15 @@ public async Task HandleOpenLog_ReverseEagerLoad_NonDescendingArrival_HoldsPhysi
 
         await openLog.HandleOpenLog(new OpenLogAction(Constants.LogNameApplication, LogPathType.Channel), dispatcher);
 
-        // Finalization dispatches in physical read (arrival) order; no vestigial RecordId-DESC re-sort.
         var finalEvents = SingleFinalEvents(dispatcher);
         var finalRecordIds = finalEvents.Select(resolved => resolved.RecordId).ToList();
         Assert.Equal(arrivalRecordIds, finalRecordIds);
 
-        // The eager partial is a positional PREFIX of the finalized list, so every physical Index a partial-era
-        // locator captured still addresses the same row after the rebuild.
         var partialEvents = AllPartialEvents(dispatcher).ToList();
         var partialRecordIds = partialEvents.Select(resolved => resolved.RecordId).ToList();
         Assert.NotEmpty(partialRecordIds);
         Assert.Equal(finalRecordIds.Take(partialRecordIds.Count).ToList(), partialRecordIds);
 
-        // Resolve the exact defect through the real locator machinery: a locator minted against the mid-load partial
-        // store must address the SAME event through the finalized store. Rebuild both column stores the way the
-        // reducers do at a shared Generation 0 (Build preserves input order, so physical index i == the i-th arrived
-        // event) and probe the null-RecordId and non-monotonic rows, the positions a RecordId-DESC re-sort would move.
         var logId = EventLogId.Create();
         var partialReader = EventColumnStore.Build(partialEvents, generation: 0, contentVersion: 0).CreateReader(logId);
         var finalReader = EventColumnStore.Build(finalEvents, generation: 0, contentVersion: 1).CreateReader(logId);
@@ -2035,13 +1108,10 @@ public async Task HandleOpenLog_ReverseEagerLoad_PartialDeltasAreDisjointAndSubs
     [Fact]
     public async Task HandleOpenLog_ReverseEagerLoad_PartialDeltasAreSortedNewestFirstDespiteCompletionOrder()
     {
-        const int total = 250; // > eager threshold (200) so a partial dispatches mid-load
+        const int total = 250;
         var fakeFactory = new FakeEventLogReaderFactory(
             new FakeEventLogReader(BuildReverseBatches(total, batchSize: 30), newestBookmark: "NEWEST"));
 
-        // Delay a second-newest batch so it resolves after older batches, scrambling completion order WITHIN the
-        // eager partial. The sequence-ordered drain (not a sort) still assembles each dispatched delta in read order,
-        // so the eager first paint renders newest-first.
         var (openLog, dispatcher, _) = CreateEagerLoadEffects(
             fakeFactory,
             resolveDelayMs: recordId => recordId is >= 191 and <= 220 ? 30 : 0);
@@ -2078,7 +1148,6 @@ public async Task HandleOpenLog_ReverseEagerLoad_PartialDeltasStayNewestFirstAcr
         var partialIds = AllPartialEvents(dispatcher).Select(resolved => resolved.RecordId).ToList();
         Assert.NotEmpty(partialIds);
 
-        // Strictly newest-first across every delta (no cross-delta inversion).
         Assert.Equal(partialIds.OrderByDescending(id => id).ToList(), partialIds);
 
         var finalIds = SingleFinalEvents(dispatcher).Select(resolved => resolved.RecordId).ToList();
@@ -2095,10 +1164,8 @@ public async Task HandleOpenLog_ReverseEagerLoad_SeedsWatcherFromNewestBookmark(
 
         await openLog.HandleOpenLog(new OpenLogAction(Constants.LogNameApplication, LogPathType.Channel), dispatcher);
 
-        // Under a reverse read the watcher must resume from the newest event; the reader exposes only NewestBookmark.
         watcher.Received(1).AddLog(Constants.LogNameApplication, "NEWEST_BOOKMARK", Arg.Any<bool>());
 
-        // Lock the activation contract: the load path requested a reverse (newest-first) read.
         Assert.True(fakeFactory.ReverseDirectionRequested);
     }
 
@@ -2109,14 +1176,13 @@ public async Task HandleOpenLog_ReverseEagerLoad_WhenReadStopsOnError_SurfacesLo
         var fakeFactory = new FakeEventLogReaderFactory(
             new FakeEventLogReader(BuildReverseBatches(total, batchSize: 30), newestBookmark: "NEWEST")
             {
-                LastErrorCode = 5 // a non-null error once the batches run out: a failed read, not a clean end-of-results
+                LastErrorCode = 5
             });
 
         var (openLog, dispatcher, _) = CreateEagerLoadEffects(fakeFactory);
 
         await openLog.HandleOpenLog(new OpenLogAction(Constants.LogNameApplication, LogPathType.Channel), dispatcher);
 
-        // A read that stops on a Win32 error is surfaced as a failure, not dispatched as a successful final load.
         dispatcher.Received().Dispatch(Arg.Is<SetResolverStatusAction>(a => a != null &&
             a.ResolverStatus.Contains("Error") && a.ResolverStatus.Contains(Constants.LogNameApplication)));
         Assert.Empty(dispatcher.ReceivedCalls().Select(call => call.GetArguments()[0]).OfType<LoadEventsAction>());
@@ -2132,7 +1198,6 @@ public async Task HandleOpenLog_ReverseEagerLoad_WhenReaderInvalid_SurfacesLoadF
 
         await openLog.HandleOpenLog(new OpenLogAction(Constants.LogNameApplication, LogPathType.Channel), dispatcher);
 
-        // A log that fails to open surfaces an error instead of a misleading empty final load, and never seeds the watcher.
         dispatcher.Received().Dispatch(Arg.Is<SetResolverStatusAction>(a => a != null &&
             a.ResolverStatus.Contains("Error") && a.ResolverStatus.Contains(Constants.LogNameApplication)));
         Assert.Empty(dispatcher.ReceivedCalls().Select(call => call.GetArguments()[0]).OfType<LoadEventsAction>());
@@ -2163,12 +1228,11 @@ public async Task HandleOpenLog_ShouldThreadOpenLogsIdIntoDispatchedAddTableActi
     [Fact]
     public async Task HandleOpenLog_WhenCancelled_ShouldDispatchCloseAndClearStatus()
     {
-        // Arrange
         var logData = new EventLogData(Constants.LogNameApplication, LogPathType.Channel);
         var activeLogs = ImmutableDictionary<string, EventLogData>.Empty.Add(Constants.LogNameApplication, logData);
 
         var cts = new CancellationTokenSource();
-        await cts.CancelAsync(); // Cancel immediately
+        await cts.CancelAsync();
 
         var (effects, mockDispatcher) = CreateEffects(
             activeLogs: activeLogs,
@@ -2176,10 +1240,8 @@ public async Task HandleOpenLog_WhenCancelled_ShouldDispatchCloseAndClearStatus(
 
         var action = new OpenLogAction(Constants.LogNameApplication, LogPathType.Channel, cts.Token);
 
-        // Act
         await effects.HandleOpenLog(action, mockDispatcher);
 
-        // Assert
         mockDispatcher.Received().Dispatch(Arg.Any<CloseLogAction>());
         mockDispatcher.Received().Dispatch(Arg.Any<ClearStatusAction>());
     }
@@ -2187,14 +1249,11 @@ public async Task HandleOpenLog_WhenCancelled_ShouldDispatchCloseAndClearStatus(
     [Fact]
     public async Task HandleOpenLog_WhenLogNotInOpenLogs_ShouldDispatchError()
     {
-        // Arrange
         var (effects, mockDispatcher) = CreateEffects(hasEventResolver: true);
         var action = new OpenLogAction(Constants.LogNameTestLog, LogPathType.Channel);
 
-        // Act
         await effects.HandleOpenLog(action, mockDispatcher);
 
-        // Assert
         mockDispatcher.Received(1)
             .Dispatch(Arg.Is<SetResolverStatusAction>(a => a != null &&
                 a.ResolverStatus.Contains("Error") && a.ResolverStatus.Contains(Constants.LogNameTestLog)));
@@ -2203,7 +1262,6 @@ public async Task HandleOpenLog_WhenLogNotInOpenLogs_ShouldDispatchError()
     [Fact]
     public async Task HandleOpenLog_WhenNoEventResolver_ShouldDispatchError()
     {
-        // Arrange
         var logData = new EventLogData(Constants.LogNameApplication, LogPathType.Channel);
         var activeLogs = ImmutableDictionary<string, EventLogData>.Empty.Add(Constants.LogNameApplication, logData);
 
@@ -2213,10 +1271,8 @@ public async Task HandleOpenLog_WhenNoEventResolver_ShouldDispatchError()
 
         var action = new OpenLogAction(Constants.LogNameApplication, LogPathType.Channel);
 
-        // Act
         await effects.HandleOpenLog(action, mockDispatcher);
 
-        // Assert
         mockDispatcher.Received(1)
             .Dispatch(Arg.Is<SetResolverStatusAction>(a => a != null &&
                 a.ResolverStatus.Contains("Error")));
@@ -2225,7 +1281,6 @@ public async Task HandleOpenLog_WhenNoEventResolver_ShouldDispatchError()
     [Fact]
     public async Task HandleSetContinuouslyUpdate_WhenFalse_ShouldNotProcessBuffer()
     {
-        // Arrange
         var bufferedEvents = new List<ResolvedEvent>
         {
             FilterEventBuilder.CreateTestEvent(100, logName: Constants.LogNameTestLog)
@@ -2234,17 +1289,14 @@ public async Task HandleSetContinuouslyUpdate_WhenFalse_ShouldNotProcessBuffer()
         var (effects, mockDispatcher) = CreateEffects(newEventBuffer: bufferedEvents);
         var action = new SetContinuouslyUpdateAction(false);
 
-        // Act
         await effects.HandleSetContinuouslyUpdate(action, mockDispatcher);
 
-        // Assert
-        mockDispatcher.DidNotReceive().Dispatch(Arg.Any<DisplayReadyAction>());
+        mockDispatcher.DidNotReceive().Dispatch(Arg.Any<IngestRawEventsAction>());
     }
 
     [Fact]
     public async Task HandleSetContinuouslyUpdate_WhenTrue_ShouldProcessBuffer()
     {
-        // Arrange
         var bufferedEvents = new List<ResolvedEvent>
         {
             FilterEventBuilder.CreateTestEvent(100, logName: Constants.LogNameTestLog)
@@ -2259,386 +1311,14 @@ public async Task HandleSetContinuouslyUpdate_WhenTrue_ShouldProcessBuffer()
 
         var action = new SetContinuouslyUpdateAction(true);
 
-        // Act
         await effects.HandleSetContinuouslyUpdate(action, mockDispatcher);
 
-        // Assert: ProcessNewEventBuffer ingests the buffered events and queues the display rebuild continuation.
-        mockDispatcher.Received(1).Dispatch(Arg.Any<RebuildDisplayViewsAction>());
-        mockDispatcher.DidNotReceive().Dispatch(Arg.Any<DisplayReadyAction>());
-    }
-
-    [Fact]
-    public async Task HandleSetOrderBy_SortEffect_ShouldRepublishUnderRequestedContextAtCapturedVersion()
-    {
-        var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
-
-        var events = new List<ResolvedEvent>
-        {
-            FilterEventBuilder.CreateTestEvent(id: 1, source: "A"),
-            FilterEventBuilder.CreateTestEvent(id: 2, source: "B")
-        };
-        var rawEvents = events;
-
-        var rawState = new RawEventStoreState
-        {
-            ByLog = ImmutableDictionary<EventLogId, EventColumnStore>.Empty.Add(logData.Id, EventColumnStore.Build(rawEvents, 0, 0))
-        };
-
-        var eventLogState = new EventLogState
-        {
-            ContinuouslyUpdate = false,
-            OpenLogs = ImmutableDictionary<string, OpenLogInfo>.Empty
-                .Add(Constants.LogNameTestLog, new OpenLogInfo(logData.Id, LogPathType.Channel)),
-            NewEventBuffer = [],
-            AppliedFilter = new Filter(null, [])
-        };
-
-        var logTableState = new LogTableState
-        {
-            RequestedOrderBy = ColumnName.Source,
-            DisplayListVersion = 7
-        };
-
-        var (effects, mockDispatcher, _) =
-            CreateEffectsWithMutableState(() => eventLogState, () => rawState, logTableState);
-
-        await effects.Filtering.HandleSetOrderBy(new SetOrderByAction(ColumnName.Source), mockDispatcher);
-
-        mockDispatcher.Received(1).Dispatch(Arg.Is<DisplayReadyAction>(a => a != null &&
-            a.Version == 7 &&
-            a.Views.ContainsKey(logData.Id) &&
-            a.Views[logData.Id].HasContext(new SortContext(ColumnName.Source, true, null, false))));
-    }
-
-    [Fact]
-    public async Task HandleToggleGroupSorting_WhenNoPendingGroup_DoesNotRepublish()
-    {
-        var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
-
-        var rawState = new RawEventStoreState
-        {
-            ByLog = ImmutableDictionary<EventLogId, EventColumnStore>.Empty
-        };
-
-        var eventLogState = new EventLogState
-        {
-            ContinuouslyUpdate = false,
-            OpenLogs = ImmutableDictionary<string, OpenLogInfo>.Empty
-                .Add(Constants.LogNameTestLog, new OpenLogInfo(logData.Id, LogPathType.Channel)),
-            NewEventBuffer = [],
-            AppliedFilter = new Filter(null, [])
-        };
-
-        var logTableState = new LogTableState();
-
-        var (effects, mockDispatcher, _) =
-            CreateEffectsWithMutableState(() => eventLogState, () => rawState, logTableState);
-
-        await effects.Filtering.HandleToggleGroupSorting(mockDispatcher);
-
-        mockDispatcher.DidNotReceive().Dispatch(Arg.Any<DisplayReadyAction>());
-    }
-
-    [Fact]
-    public async Task HandleUpdateTable_WhenNoSortPending_DoesNotRepublish()
-    {
-        var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
-
-        var rawState = new RawEventStoreState
-        {
-            ByLog = ImmutableDictionary<EventLogId, EventColumnStore>.Empty.Add(
-                logData.Id,
-                EventColumnStore.Build(new List<ResolvedEvent> { FilterEventBuilder.CreateTestEvent(id: 1, source: "A") }, 0, 0))
-        };
-
-        var eventLogState = new EventLogState
-        {
-            ContinuouslyUpdate = false,
-            OpenLogs = ImmutableDictionary<string, OpenLogInfo>.Empty
-                .Add(Constants.LogNameTestLog, new OpenLogInfo(logData.Id, LogPathType.Channel)),
-            NewEventBuffer = [],
-            AppliedFilter = new Filter(null, [])
-        };
-
-        var logTableState = new LogTableState
-        {
-            OrderBy = ColumnName.Source,
-            RequestedOrderBy = ColumnName.Source
-        };
-
-        var (effects, mockDispatcher, _) =
-            CreateEffectsWithMutableState(() => eventLogState, () => rawState, logTableState);
-
-        await effects.Filtering.HandleUpdateTable(mockDispatcher);
-
-        mockDispatcher.DidNotReceive().Dispatch(Arg.Any<DisplayReadyAction>());
-    }
-
-    [Fact]
-    public async Task HandleUpdateTable_WhenSortPendingMultiLog_RepublishesEveryLogUnderRequested()
-    {
-        var logA = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
-        var logB = new EventLogData("SecondTestLog", LogPathType.Channel);
-
-        var eventsA = new List<ResolvedEvent> { FilterEventBuilder.CreateTestEvent(id: 1, source: "A") };
-        var eventsB = new List<ResolvedEvent> { FilterEventBuilder.CreateTestEvent(id: 2, source: "B") };
-
-        var rawState = new RawEventStoreState
-        {
-            ByLog = ImmutableDictionary<EventLogId, EventColumnStore>.Empty
-                .Add(logA.Id, EventColumnStore.Build(eventsA, 0, 0))
-                .Add(logB.Id, EventColumnStore.Build(eventsB, 0, 0))
-        };
-
-        var eventLogState = new EventLogState
-        {
-            ContinuouslyUpdate = false,
-            OpenLogs = ImmutableDictionary<string, OpenLogInfo>.Empty
-                .Add(Constants.LogNameTestLog, new OpenLogInfo(logA.Id, LogPathType.Channel))
-                .Add("SecondTestLog", new OpenLogInfo(logB.Id, LogPathType.Channel)),
-            NewEventBuffer = [],
-            AppliedFilter = new Filter(null, [])
-        };
-
-        var logTableState = new LogTableState
-        {
-            RequestedOrderBy = ColumnName.Source,
-            DisplayListVersion = 3
-        };
-
-        var (effects, mockDispatcher, _) =
-            CreateEffectsWithMutableState(() => eventLogState, () => rawState, logTableState);
-
-        await effects.Filtering.HandleUpdateTable(mockDispatcher);
-
-        var requested = new SortContext(ColumnName.Source, true, null, false);
-        mockDispatcher.Received(1).Dispatch(Arg.Is<DisplayReadyAction>(a => a != null &&
-            a.Version == 3 &&
-            a.Views.ContainsKey(logA.Id) && a.Views[logA.Id].HasContext(requested) &&
-            a.Views.ContainsKey(logB.Id) && a.Views[logB.Id].HasContext(requested)));
-    }
-
-    [Fact]
-    public async Task HandleUpdateTable_WhenSortPending_RepublishesUnderRequestedContextAtCapturedVersion()
-    {
-        var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
-
-        var events = new List<ResolvedEvent>
-        {
-            FilterEventBuilder.CreateTestEvent(id: 1, source: "A"),
-            FilterEventBuilder.CreateTestEvent(id: 2, source: "B")
-        };
-        var rawEvents = events;
-
-        var rawState = new RawEventStoreState
-        {
-            ByLog = ImmutableDictionary<EventLogId, EventColumnStore>.Empty.Add(logData.Id, EventColumnStore.Build(rawEvents, 0, 0))
-        };
-
-        var eventLogState = new EventLogState
-        {
-            ContinuouslyUpdate = false,
-            OpenLogs = ImmutableDictionary<string, OpenLogInfo>.Empty
-                .Add(Constants.LogNameTestLog, new OpenLogInfo(logData.Id, LogPathType.Channel)),
-            NewEventBuffer = [],
-            AppliedFilter = new Filter(null, [])
-        };
-
-        var logTableState = new LogTableState
-        {
-            RequestedOrderBy = ColumnName.Source,
-            DisplayListVersion = 7
-        };
-
-        var (effects, mockDispatcher, _) =
-            CreateEffectsWithMutableState(() => eventLogState, () => rawState, logTableState);
-
-        await effects.Filtering.HandleUpdateTable(mockDispatcher);
-
-        mockDispatcher.Received(1).Dispatch(Arg.Is<DisplayReadyAction>(a => a != null &&
-            a.Version == 7 &&
-            a.Views.ContainsKey(logData.Id) &&
-            a.Views[logData.Id].HasContext(new SortContext(ColumnName.Source, true, null, false))));
-    }
-
-    [Fact]
-    public async Task RebuildDisplayViews_TwoIngestsBeforeRebuilds_FinalViewContainsBothEvents()
-    {
-        // Concurrency safety: model two live events whose ingests both land before either rebuild drains (the worst-case
-        // interleaving). Because each rebuild reconstructs the whole view from the current store rather than appending only
-        // its own event, every rebuild yields a superset, so neither event is dropped.
-        var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
-
-        var state = new EventLogState
-        {
-            ContinuouslyUpdate = true,
-            OpenLogs = ImmutableDictionary<string, OpenLogInfo>.Empty
-                .Add(Constants.LogNameTestLog, new OpenLogInfo(logData.Id, LogPathType.Channel)),
-            NewEventBuffer = [],
-            AppliedFilter = new Filter(null, [])
-        };
-
-        var rawState = new RawEventStoreState
-        {
-            ByLog = ImmutableDictionary<EventLogId, EventColumnStore>.Empty.Add(logData.Id, EventColumnStore.Empty)
-        };
-
-        var (effects, mockDispatcher, _) = CreateEffectsWithMutableState(() => state, () => rawState);
-
-        var eventA = FilterEventBuilder.CreateTestEvent(100, logName: Constants.LogNameTestLog);
-        var eventB = FilterEventBuilder.CreateTestEvent(200, logName: Constants.LogNameTestLog);
-
-        IReadOnlyList<ResolvedEvent> justA = [eventA];
-        IReadOnlyList<ResolvedEvent> justB = [eventB];
-        var byLogA = new Dictionary<EventLogId, IReadOnlyList<ResolvedEvent>> { [logData.Id] = justA };
-        var byLogB = new Dictionary<EventLogId, IReadOnlyList<ResolvedEvent>> { [logData.Id] = justB };
-
-        var pending = new Queue<object>();
-
-        // Both ingests enqueued ahead of both rebuilds - the interleaving where B's rebuild could miss A under a naive
-        // append-only design.
-        pending.Enqueue(new IngestRawEventsAction(byLogA, RawIngestMode.Prepend));
-        pending.Enqueue(new IngestRawEventsAction(byLogB, RawIngestMode.Prepend));
-        pending.Enqueue(new RebuildDisplayViewsAction(byLogA, BufferEntriesToConsume: null));
-        pending.Enqueue(new RebuildDisplayViewsAction(byLogB, BufferEntriesToConsume: null));
-
-        AppendTableEventsBatchAction? lastAppend = null;
-        mockDispatcher.When(d => d.Dispatch(Arg.Any<AppendTableEventsBatchAction>()))
-            .Do(call => lastAppend = call.ArgAt<AppendTableEventsBatchAction>(0));
-
-        // Act
-        await DrainDispatchQueueAsync(pending, effects, mockDispatcher, () => rawState, r => rawState = r);
-
-        // Assert: the final rebuilt view holds BOTH events.
-        Assert.NotNull(lastAppend);
-        Assert.Equal(2, lastAppend.ViewsByLog[logData.Id].Count);
-        var ids = lastAppend.ViewsByLog[logData.Id].EnumerateDetail().Select(detail => detail.Id).ToHashSet();
-        Assert.Contains(eventA.Id, ids);
-        Assert.Contains(eventB.Id, ids);
-    }
-
-    [Fact]
-    public async Task RebuildDisplayViews_WhenEventBuffersDuringFlush_ConsumesOnlySnapshotAndPreservesNewEvent()
-    {
-        // Flush-race resurrection ordering (Ingest(A), Rebuild(A), AddEvent(B)): the ordering that resurrected the flushed
-        // A under the old whole-buffer write. Atomic reducer buffering + identity consume keep B and don't resurrect A.
-        var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
-        var eventA = FilterEventBuilder.CreateTestEvent(100, logName: Constants.LogNameTestLog);
-        var eventB = FilterEventBuilder.CreateTestEvent(200, logName: Constants.LogNameTestLog);
-
-        var state = new EventLogState
-        {
-            ContinuouslyUpdate = false,
-            OpenLogs = ImmutableDictionary<string, OpenLogInfo>.Empty
-                .Add(Constants.LogNameTestLog, new OpenLogInfo(logData.Id, LogPathType.Channel)),
-            NewEventBuffer = [eventA],
-            AppliedFilter = new Filter(null, [])
-        };
-
-        var rawState = new RawEventStoreState
-        {
-            ByLog = ImmutableDictionary<EventLogId, EventColumnStore>.Empty.Add(logData.Id, EventColumnStore.Empty)
-        };
-
-        var (effects, mockDispatcher, _) = CreateEffectsWithMutableState(() => state, () => rawState);
-        var pending = CaptureDispatchQueue(mockDispatcher);
-
-        IReadOnlyList<ResolvedEvent> snapshot = [eventA];
-        var rawByLog = new Dictionary<EventLogId, IReadOnlyList<ResolvedEvent>> { [logData.Id] = snapshot };
-
-        pending.Enqueue(new IngestRawEventsAction(rawByLog, RawIngestMode.Prepend));
-        pending.Enqueue(new RebuildDisplayViewsAction(rawByLog, BufferEntriesToConsume: snapshot));
-        pending.Enqueue(new AddEventAction(eventB));
-
-        // Faithful drain that also applies the EventLogState buffer reducers, so the final buffer reflects both the
-        // mid-flush AddEvent(B) and the flush's targeted consume.
-        while (pending.Count > 0)
-        {
-            switch (pending.Dequeue())
-            {
-                case IngestRawEventsAction ingest:
-                    rawState = RawEventStoreReducers.ReduceIngestRawEvents(rawState, ingest);
-                    break;
-                case AddEventAction add:
-                    // Reducer runs before the effect in Fluxor; the effect no-ops for the non-live-tail path.
-                    state = Reducers.ReduceAddEvent(state, add);
-                    await effects.HandleAddEvent(add, mockDispatcher);
-                    break;
-                case RebuildDisplayViewsAction rebuild:
-                    await effects.HandleRebuildDisplayViews(rebuild, mockDispatcher);
-                    break;
-                case NewEventBufferConsumedAction consumed:
-                    state = Reducers.ReduceNewEventBufferConsumed(state, consumed);
-                    break;
-            }
-        }
-
-        // Assert: the flush consumed only A; B - buffered during the flush - survives with the count intact.
-        Assert.Single(state.NewEventBuffer);
-        Assert.Same(eventB, state.NewEventBuffer[0]);
-    }
-
-    [Fact]
-    public async Task RebuildDisplayViews_WhenLogAbsentFromStore_SkipsFilterAndStillRebuildsOtherLogs()
-    {
-        // Guards the reordered guard (raw.TryGetValue before GetFilteredEvents): a log a concurrent close dropped is
-        // skipped without filtering, so a throwing filter can't abort the batch. Fails under the pre-fix operand order.
-        var openLog = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
-        var closedLog = new EventLogData(Constants.LogNameApplication, LogPathType.Channel);
-
-        var openEvent = FilterEventBuilder.CreateTestEvent(100, logName: Constants.LogNameTestLog);
-        var closedEvent = FilterEventBuilder.CreateTestEvent(200, logName: Constants.LogNameApplication);
-
-        var state = new EventLogState
-        {
-            OpenLogs = ImmutableDictionary<string, OpenLogInfo>.Empty
-                .Add(Constants.LogNameTestLog, new OpenLogInfo(openLog.Id, LogPathType.Channel)),
-            NewEventBuffer = [],
-            AppliedFilter = new Filter(null, [])
-        };
-
-        // Only the open log survives in the raw store; the closed log was dropped by a concurrent CloseLog reducer.
-        var rawState = new RawEventStoreState
-        {
-            ByLog = ImmutableDictionary<EventLogId, EventColumnStore>.Empty
-                .Add(openLog.Id, EventColumnStore.Build(new List<ResolvedEvent> { openEvent }, 0, 0))
-        };
-
-        var (effects, mockDispatcher, mockFilterService) = CreateEffectsWithMutableState(() => state, () => rawState);
-
-        // The filter throws if it is ever asked about the closed log's events; the reordered guard must never call it.
-        mockFilterService.GetFilteredEvents(
-                Arg.Is<IEnumerable<ResolvedEvent>>(events => events != null && events.Any(e => e.Id == closedEvent.Id)),
-                Arg.Any<Filter>())
-            .Returns(_ => throw new InvalidOperationException("filter must not run for a log absent from the store"));
-
-        var action = new RebuildDisplayViewsAction(
-            new Dictionary<EventLogId, IReadOnlyList<ResolvedEvent>>
-            {
-                [closedLog.Id] = [closedEvent],
-                [openLog.Id] = [openEvent]
-            },
-            BufferEntriesToConsume: new List<ResolvedEvent> { openEvent });
-
-        AppendTableEventsBatchAction? captured = null;
-        mockDispatcher.When(d => d.Dispatch(Arg.Any<AppendTableEventsBatchAction>()))
-            .Do(call => captured = call.ArgAt<AppendTableEventsBatchAction>(0));
-
-        // Act: must not throw despite the closed log's throwing filter.
-        await effects.HandleRebuildDisplayViews(action, mockDispatcher);
-
-        // Assert: the open log rendered, the closed (absent) log was skipped, and the buffer was consumed.
-        Assert.NotNull(captured);
-        Assert.True(captured.ViewsByLog.ContainsKey(openLog.Id));
-        Assert.False(captured.ViewsByLog.ContainsKey(closedLog.Id));
-        mockDispatcher.Received(1).Dispatch(Arg.Any<NewEventBufferConsumedAction>());
+        mockDispatcher.Received(1).Dispatch(Arg.Any<IngestRawEventsAction>());
     }
 
     [Fact]
     public void ReduceNewEventBufferConsumed_RemovesOnlyCapturedEntriesByReferenceIdentity()
     {
-        // The flush consume removes exactly the captured snapshot (by reference identity) and leaves any event buffered
-        // afterward; a blanket clear would drop it. Newest events prepend, so the survivor sits at the head.
         var eventA = FilterEventBuilder.CreateTestEvent(100, logName: Constants.LogNameTestLog);
         var eventB = FilterEventBuilder.CreateTestEvent(200, logName: Constants.LogNameTestLog);
 
@@ -2654,8 +1334,6 @@ public void ReduceNewEventBufferConsumed_RemovesOnlyCapturedEntriesByReferenceId
     [Fact]
     public void ReduceNewEventBufferConsumed_UsesReferenceIdentity_NotValueEquality()
     {
-        // Reference identity, not value equality: a double-delivered event yields two value-equal instances; the consume
-        // must remove only the captured instance and keep the other.
         var captured = FilterEventBuilder.CreateTestEvent(100, logName: Constants.LogNameTestLog);
         var duplicate = captured with { };
         Assert.Equal(captured, duplicate);
@@ -2673,7 +1351,6 @@ public void ReduceNewEventBufferConsumed_UsesReferenceIdentity_NotValueEquality(
     [Fact]
     public void ReopenAfterDatabaseRemoval_DispatchesOpenLogPerSnapshotEntry()
     {
-        // Arrange
         var (effects, mockDispatcher, _, _, _) = CreateEffectsWithServices();
         var coordinator = (ILogReloadCoordinator)effects.DatabaseCoordination;
 
@@ -2683,10 +1360,8 @@ public void ReopenAfterDatabaseRemoval_DispatchesOpenLogPerSnapshotEntry()
             new LogReopenInfo(Constants.LogNameLog2, LogPathType.File)
         };
 
-        // Act
         coordinator.ReopenAfterDatabaseRemoval(snapshot);
 
-        // Assert
         mockDispatcher.Received(1)
             .Dispatch(Arg.Is<OpenLogAction>(a => a != null &&
                 a.LogName == Constants.LogNameLog1 && a.LogPathType == LogPathType.Channel));
@@ -2709,8 +1384,6 @@ private static IReadOnlyList<EventRecord[]> BuildBatchesFromRecordIds(IReadOnlyL
     {
         var batches = new List<EventRecord[]>();
 
-        // Preserve the given arrival order verbatim (no reverse, no sort) so a test can drive a read whose order
-        // differs from RecordId-DESC: null RecordIds at their read position, a non-monotonic read, or a duplicate id.
         for (int start = 0; start < recordIds.Count; start += batchSize)
         {
             int count = Math.Min(batchSize, recordIds.Count - start);
@@ -2747,16 +1420,10 @@ private static EffectsHarness BuildHarness(
         var logTableState = Substitute.For<IState<LogTableState>>();
         logTableState.Value.Returns(logTableStateValue ?? new LogTableState());
 
-        var coordinator = new PartialLoadCoordinator(dispatcher, rawEventStore, eventLogState, logTableState, Timeout.InfiniteTimeSpan);
-
         var filtering = new FilteringEffects(
             eventLogState,
-            rawEventStore,
-            logTableState,
-            logger,
-            closeCoordinator,
-            concurrencyState,
-            TimeSpan.Zero);
+            new LiveTailIngestCoordinator(dispatcher, Timeout.InfiniteTimeSpan),
+            new XmlReloadCoordinator(eventLogState, closeCoordinator, concurrencyState, logger));
 
         var openLog = new OpenLogEffects(
             eventLogState,
@@ -2769,16 +1436,13 @@ private static EffectsHarness BuildHarness(
             criticalErrorService,
             closeCoordinator,
             concurrencyState,
-            coordinator,
+            new LiveTailIngestCoordinator(dispatcher, Timeout.InfiniteTimeSpan),
             new EventLogReaderFactory());
 
         var logReload = new LogReloadEffects(
             eventLogState,
-            logTableState,
             rawEventStore,
-            filterService,
-            closeCoordinator,
-            coordinator);
+            closeCoordinator);
 
         var databaseCoordination = new DatabaseCoordinationEffects(
             eventLogState,
@@ -2818,7 +1482,6 @@ private static IReadOnlyList<EventRecord[]> BuildReverseBatches(int total, int b
     {
         var batches = new List<EventRecord[]>();
 
-        // Newest first (descending RecordId), mirroring a reverse read.
         for (int start = total; start >= 1; start -= batchSize)
         {
             int count = Math.Min(batchSize, start);
@@ -2835,8 +1498,6 @@ private static IReadOnlyList<EventRecord[]> BuildReverseBatches(int total, int b
         return batches;
     }
 
-    // Records dispatches into a FIFO queue instead of letting them take effect, so a test can drain them after the
-    // producing effect returns - reproducing Fluxor's nested-dispatch ordering (a nested Dispatch is queued, not run inline).
     private static Queue<object> CaptureDispatchQueue(IDispatcher dispatcher)
     {
         var pending = new Queue<object>();
@@ -2896,9 +1557,6 @@ private static (OpenLogEffects openLog, IDispatcher dispatcher, ILogWatcherServi
         var rawEventStore = Substitute.For<IState<RawEventStoreState>>();
         rawEventStore.Value.Returns(new RawEventStoreState());
 
-        var coordinatorLogTableState = Substitute.For<IState<LogTableState>>();
-        coordinatorLogTableState.Value.Returns(new LogTableState());
-
         var openLog = new OpenLogEffects(
             eventLogState,
             Substitute.For<ITraceLogger>(),
@@ -2910,7 +1568,7 @@ private static (OpenLogEffects openLog, IDispatcher dispatcher, ILogWatcherServi
             Substitute.For<ICriticalErrorService>(),
             new LogCloseCoordinator(),
             new EventLogConcurrencyState(),
-            new PartialLoadCoordinator(dispatcher, rawEventStore, eventLogState, coordinatorLogTableState, Timeout.InfiniteTimeSpan),
+            new LiveTailIngestCoordinator(dispatcher, Timeout.InfiniteTimeSpan),
             readerFactory);
 
         return (openLog, dispatcher, watcher);
@@ -3163,27 +1821,25 @@ private static (EffectsHarness effects,
         return (effects, mockDispatcher, mockLogWatcherService, mockResolverCache, mockFilterService);
     }
 
-    // Drains the queue faithfully: IngestRawEventsAction applies the real raw-store reducer, RebuildDisplayViewsAction runs
-    // its real effect (so it sees the post-ingest store). Draining rather than hand-seeding is what catches the stale read.
-    private static async Task DrainDispatchQueueAsync(
+    private static Task DrainDispatchQueueAsync(
         Queue<object> pending,
         EffectsHarness effects,
         IDispatcher dispatcher,
         Func<RawEventStoreState> getRaw,
         Action<RawEventStoreState> setRaw)
     {
+        _ = effects;
+        _ = dispatcher;
+
         while (pending.Count > 0)
         {
-            switch (pending.Dequeue())
+            if (pending.Dequeue() is IngestRawEventsAction ingest)
             {
-                case IngestRawEventsAction ingest:
-                    setRaw(RawEventStoreReducers.ReduceIngestRawEvents(getRaw(), ingest));
-                    break;
-                case RebuildDisplayViewsAction rebuild:
-                    await effects.HandleRebuildDisplayViews(rebuild, dispatcher);
-                    break;
+                setRaw(RawEventStoreReducers.ReduceIngestRawEvents(getRaw(), ingest));
             }
         }
+
+        return Task.CompletedTask;
     }
 
     private static IState<RawEventStoreState> EmptyRawStore()
@@ -3201,10 +1857,6 @@ private static SelectionEntry RestoreEntry(ResolvedEvent evt, EventLogId logId,
         return new SelectionEntry(handle, handle, reloadKey);
     }
 
-    // Builds a raw-store provider whose reads model the columnar filter race guard (M1 monotonic
-    // ContentVersion). The pass-1 snapshot is read #1; a store carrying a higher ContentVersion on
-    // read #2 onward is how the effect detects a rebuild that landed during the off-thread build,
-    // which drives the pass-2 refilter. Reads past the supplied set clamp to the last state.
     private static Func<RawEventStoreState> SequencedRaw(params RawEventStoreState[] statesByRead)
     {
         var reads = 0;
@@ -3223,9 +1875,6 @@ private static IReadOnlyList<ResolvedEvent> SingleFinalEvents(IDispatcher dispat
             .Single()
             .Events;
 
-    // Wrapper that bundles the post-split effects classes together with their
-    // shared singletons so existing tests keep their `effects.HandleXxx(...)`
-    // call shape. Each method delegates to the appropriate split class.
     private sealed class EffectsHarness(
         FilteringEffects filtering,
         OpenLogEffects openLog,
@@ -3257,9 +1906,6 @@ public Task HandleApplyFilter(ApplyFilterAction action, IDispatcher dispatcher)
         public Task HandleCloseLog(CloseLogAction action, IDispatcher dispatcher) =>
             OpenLog.HandleCloseLog(action, dispatcher);
 
-        public Task HandleConvergeFilter(ConvergeFilterAction action, IDispatcher dispatcher) =>
-            Filtering.HandleConvergeFilter(action, dispatcher);
-
         public Task HandleLoadEvents(LoadEventsAction action, IDispatcher dispatcher) =>
             LogReload.HandleLoadEvents(action, dispatcher);
 
@@ -3268,9 +1914,6 @@ public Task HandleLoadEvents(LoadEventsAction action, IDispatcher dispatcher) =>
         public Task HandleOpenLog(OpenLogAction action, IDispatcher dispatcher) =>
             OpenLog.HandleOpenLog(action, dispatcher);
 
-        public Task HandleRebuildDisplayViews(RebuildDisplayViewsAction action, IDispatcher dispatcher) =>
-            LogReload.HandleRebuildDisplayViews(action, dispatcher);
-
         public Task HandleSetContinuouslyUpdate(SetContinuouslyUpdateAction action, IDispatcher dispatcher) =>
             Filtering.HandleSetContinuouslyUpdate(action, dispatcher);
     }
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/EventLog/EventFocusSourceTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/EventLog/EventFocusSourceTests.cs
new file mode 100644
index 000000000..4830ab930
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/EventLog/EventFocusSourceTests.cs
@@ -0,0 +1,120 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
+using EventLogExpert.Logging.Abstractions;
+using EventLogExpert.Runtime.EventLog;
+using Fluxor;
+using NSubstitute;
+
+namespace EventLogExpert.Runtime.Tests.EventLog;
+
+public sealed class EventFocusSourceTests
+{
+    [Fact]
+    public void AThrowingSubscriber_IsIsolatedFromOtherSubscribers()
+    {
+        var harness = new Harness(Focus(1));
+        var reachedSecond = 0;
+        harness.Source.Changed += () => throw new InvalidOperationException("subscriber blew up");
+        harness.Source.Changed += () => reachedSecond++;
+
+        harness.SetFocus(Focus(2));
+
+        Assert.Equal(1, reachedSecond);
+    }
+
+    [Fact]
+    public void Changed_DoesNotFire_WhenFocusUnchanged()
+    {
+        var focus = Focus(1);
+        var harness = new Harness(focus);
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.SetState(new EventLogState { Focus = focus, ContinuouslyUpdate = true });
+
+        Assert.Equal(0, raised);
+    }
+
+    [Fact]
+    public void Changed_FiresWithLatestFocus_OnFocusChange()
+    {
+        var harness = new Harness(Focus(1));
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        var next = Focus(2);
+        harness.SetFocus(next);
+
+        Assert.Equal(1, raised);
+        Assert.Equal(next, harness.Source.Current);
+    }
+
+    [Fact]
+    public void Construction_AdoptsAChangeThatLandsBetweenSeedAndSubscribe()
+    {
+        // focused state (the reconcile), with no StateChanged raised in between.
+        var seeded = Focus(7);
+        var state = Substitute.For<IState<EventLogState>>();
+        state.Value.Returns(new EventLogState(), new EventLogState { Focus = seeded });
+
+        using var source = new EventFocusSource(state, Substitute.For<ITraceLogger>());
+
+        Assert.Equal(seeded, source.Current);
+    }
+
+    [Fact]
+    public void Current_ReflectsTheInitialFocus()
+    {
+        var focus = Focus(1);
+        var harness = new Harness(focus);
+
+        Assert.Equal(focus, harness.Source.Current);
+    }
+
+    [Fact]
+    public void Dispose_StopsRaising()
+    {
+        var harness = new Harness(Focus(1));
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.Source.Dispose();
+        harness.SetFocus(Focus(2));
+
+        Assert.Equal(0, raised);
+    }
+
+    private static SelectionEntry Focus(int index)
+    {
+        var handle = new EventLocator(EventLogId.Create(), 0, index);
+
+        return new SelectionEntry(handle, handle, null);
+    }
+
+    private sealed class Harness
+    {
+        private readonly IState<EventLogState> _state = Substitute.For<IState<EventLogState>>();
+
+        public Harness(SelectionEntry? focus)
+        {
+            State = new EventLogState { Focus = focus };
+            _state.Value.Returns(_ => State);
+            Source = new EventFocusSource(_state, Substitute.For<ITraceLogger>());
+        }
+
+        public EventFocusSource Source { get; }
+
+        public EventLogState State { get; private set; }
+
+        public void SetFocus(SelectionEntry? focus) => SetState(new EventLogState { Focus = focus });
+
+        public void SetState(EventLogState state)
+        {
+            State = state;
+            _state.StateChanged += Raise.Event<EventHandler>(_state, EventArgs.Empty);
+        }
+    }
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/EventLog/EventLogQueriesTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/EventLog/EventLogQueriesTests.cs
index b26f47fed..f82ea3f45 100644
--- a/tests/Unit/EventLogExpert.Runtime.Tests/EventLog/EventLogQueriesTests.cs
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/EventLog/EventLogQueriesTests.cs
@@ -92,6 +92,18 @@ public void GetPropertyValues_ReturnsDistinctSortedSourcesAcrossEvents()
         Assert.Equal(["Alpha", "Bravo"], sources);
     }
 
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public void IsContinuouslyUpdating_ReflectsTheEventLogState(bool continuouslyUpdate)
+    {
+        var queries = new EventLogQueries(
+            StateReturning(new RawEventStoreState()),
+            EventLogStateReturning(new EventLogState { ContinuouslyUpdate = continuouslyUpdate }));
+
+        Assert.Equal(continuouslyUpdate, queries.IsContinuouslyUpdating());
+    }
+
     [Fact]
     public void RoundOrFallback_WhenNewestIsExactHour_DoesNotPushBeforeForward()
     {
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/EventLog/EventSelectionSourceTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/EventLog/EventSelectionSourceTests.cs
new file mode 100644
index 000000000..f4d7dd9c6
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/EventLog/EventSelectionSourceTests.cs
@@ -0,0 +1,126 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
+using EventLogExpert.Logging.Abstractions;
+using EventLogExpert.Runtime.EventLog;
+using Fluxor;
+using NSubstitute;
+using System.Collections.Immutable;
+
+namespace EventLogExpert.Runtime.Tests.EventLog;
+
+public sealed class EventSelectionSourceTests
+{
+    private static readonly EventLogId LogId = EventLogId.Create();
+    private static readonly SelectionEntry AnEntry = Entry(0);
+
+    [Fact]
+    public void AThrowingSubscriber_IsIsolatedFromOtherSubscribers()
+    {
+        var harness = new Harness(ImmutableList<SelectionEntry>.Empty);
+        var reachedSecond = 0;
+        harness.Source.Changed += () => throw new InvalidOperationException("subscriber blew up");
+        harness.Source.Changed += () => reachedSecond++;
+
+        harness.SetSelection(ImmutableList.Create(AnEntry));
+
+        Assert.Equal(1, reachedSecond);
+    }
+
+    [Fact]
+    public void Changed_DoesNotFire_WhenSelectionReferenceUnchanged()
+    {
+        var selection = ImmutableList.Create(AnEntry);
+        var harness = new Harness(selection);
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.SetState(new EventLogState { Selection = selection });
+
+        Assert.Equal(0, raised);
+        Assert.Same(selection, harness.Source.Current);
+    }
+
+    [Fact]
+    public void Changed_Fires_WhenSelectionInstanceChanges()
+    {
+        var harness = new Harness(ImmutableList<SelectionEntry>.Empty);
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        var next = ImmutableList.Create(AnEntry);
+        harness.SetSelection(next);
+
+        Assert.Equal(1, raised);
+        Assert.Same(next, harness.Source.Current);
+    }
+
+    [Fact]
+    public void Construction_AdoptsAChangeThatLandsBetweenSeedAndSubscribe()
+    {
+        // populated list (the reconcile), with no StateChanged raised in between.
+        var reconciled = ImmutableList.Create(AnEntry);
+        var state = Substitute.For<IState<EventLogState>>();
+        state.Value.Returns(new EventLogState(), new EventLogState { Selection = reconciled });
+
+        using var source = new EventSelectionSource(state, Substitute.For<ITraceLogger>());
+
+        Assert.Same(reconciled, source.Current);
+    }
+
+    [Fact]
+    public void Current_ReflectsTheInitialState()
+    {
+        var selection = ImmutableList.Create(AnEntry);
+        var harness = new Harness(selection);
+
+        Assert.Same(selection, harness.Source.Current);
+    }
+
+    [Fact]
+    public void Dispose_StopsRaising()
+    {
+        var harness = new Harness(ImmutableList<SelectionEntry>.Empty);
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.Source.Dispose();
+        harness.SetSelection(ImmutableList.Create(AnEntry));
+
+        Assert.Equal(0, raised);
+    }
+
+    private static SelectionEntry Entry(int index)
+    {
+        var handle = new EventLocator(LogId, 0, index);
+
+        return new SelectionEntry(handle, handle, null);
+    }
+
+    private sealed class Harness
+    {
+        private readonly IState<EventLogState> _state = Substitute.For<IState<EventLogState>>();
+
+        public Harness(ImmutableList<SelectionEntry> selection)
+        {
+            State = new EventLogState { Selection = selection };
+            _state.Value.Returns(_ => State);
+            Source = new EventSelectionSource(_state, Substitute.For<ITraceLogger>());
+        }
+
+        public EventSelectionSource Source { get; }
+
+        public EventLogState State { get; private set; }
+
+        public void SetSelection(ImmutableList<SelectionEntry> selection) =>
+            SetState(new EventLogState { Selection = selection });
+
+        public void SetState(EventLogState state)
+        {
+            State = state;
+            _state.StateChanged += Raise.Event<EventHandler>(_state, EventArgs.Empty);
+        }
+    }
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/EventLog/FilterAppliedSourceTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/EventLog/FilterAppliedSourceTests.cs
new file mode 100644
index 000000000..8c4b47da7
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/EventLog/FilterAppliedSourceTests.cs
@@ -0,0 +1,111 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Logging.Abstractions;
+using EventLogExpert.Runtime.EventLog;
+using Fluxor;
+using NSubstitute;
+
+namespace EventLogExpert.Runtime.Tests.EventLog;
+
+public sealed class FilterAppliedSourceTests
+{
+    [Fact]
+    public void AThrowingSubscriber_IsIsolatedFromOtherSubscribers()
+    {
+        var harness = new Harness(filtering: false);
+        var reachedSecond = 0;
+        harness.Source.Changed += () => throw new InvalidOperationException("subscriber blew up");
+        harness.Source.Changed += () => reachedSecond++;
+
+        harness.SetState(filtering: true);
+
+        Assert.Equal(1, reachedSecond);
+    }
+
+    [Fact]
+    public void Changed_DoesNotFire_WhenFilteringUnchanged()
+    {
+        var harness = new Harness(filtering: true);
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.SetState(filtering: true);
+
+        Assert.Equal(0, raised);
+        Assert.True(harness.Source.IsFilteringEnabled);
+    }
+
+    [Fact]
+    public void Changed_FiresWithLatestState_WhenFilteringFlips()
+    {
+        var harness = new Harness(filtering: false);
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.SetState(filtering: true);
+
+        Assert.Equal(1, raised);
+        Assert.True(harness.Source.IsFilteringEnabled);
+    }
+
+    [Fact]
+    public void Construction_AdoptsAChangeThatLandsBetweenSeedAndSubscribe()
+    {
+        // (the seed) then a filtered state (the reconcile), with no StateChanged raised in between.
+        var state = Substitute.For<IState<EventLogState>>();
+        state.Value.Returns(new EventLogState(), Filtering());
+
+        using var source = new FilterAppliedSource(state, Substitute.For<ITraceLogger>());
+
+        Assert.True(source.IsFilteringEnabled);
+    }
+
+    [Fact]
+    public void Dispose_StopsRaising()
+    {
+        var harness = new Harness(filtering: false);
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.Source.Dispose();
+        harness.SetState(filtering: true);
+
+        Assert.Equal(0, raised);
+    }
+
+    [Fact]
+    public void IsFilteringEnabled_ReflectsTheInitialState()
+    {
+        var harness = new Harness(filtering: true);
+
+        Assert.True(harness.Source.IsFilteringEnabled);
+    }
+
+    private static EventLogState Filtering() =>
+        new() { AppliedFilter = new Filter(new DateFilter { IsEnabled = true }, []) };
+
+    private sealed class Harness
+    {
+        private readonly IState<EventLogState> _state = Substitute.For<IState<EventLogState>>();
+
+        public Harness(bool filtering)
+        {
+            State = filtering ? Filtering() : new EventLogState();
+            _state.Value.Returns(_ => State);
+            Source = new FilterAppliedSource(_state, Substitute.For<ITraceLogger>());
+        }
+
+        public FilterAppliedSource Source { get; }
+
+        public EventLogState State { get; private set; }
+
+        public void SetState(bool filtering) => SetState(filtering ? Filtering() : new EventLogState());
+
+        public void SetState(EventLogState state)
+        {
+            State = state;
+            _state.StateChanged += Raise.Event<EventHandler>(_state, EventArgs.Empty);
+        }
+    }
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/EventLog/LiveTailIngestCoordinatorTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/EventLog/LiveTailIngestCoordinatorTests.cs
new file mode 100644
index 000000000..6340d64e0
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/EventLog/LiveTailIngestCoordinatorTests.cs
@@ -0,0 +1,288 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.Channels;
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
+using EventLogExpert.Runtime.EventLog;
+using EventLogExpert.Runtime.LogTable;
+using NSubstitute;
+using IDispatcher = Fluxor.IDispatcher;
+
+namespace EventLogExpert.Runtime.Tests.EventLog;
+
+public sealed class LiveTailIngestCoordinatorTests
+{
+    private static readonly TimeSpan s_dormant = Timeout.InfiniteTimeSpan;
+
+    private static readonly TimeSpan s_manual = TimeSpan.FromMinutes(10);
+
+    [Fact]
+    public async Task ConcurrentEnqueueAndFlush_DeliversEveryEventExactlyOnceInOrder()
+    {
+        var recorder = new DispatchRecorder();
+        using var coordinator = new LiveTailIngestCoordinator(recorder.Dispatcher, s_manual);
+        EventLogId logId = EventLogId.Create();
+        const int total = 4000;
+
+        Task producer = Task.Run(
+            () =>
+            {
+                for (int recordId = 1; recordId <= total; recordId++) { coordinator.Enqueue(logId, MakeEvent(recordId)); }
+            },
+            TestContext.Current.CancellationToken);
+
+        Task flusher = Task.Run(
+            () =>
+            {
+                for (int attempt = 0; attempt < 200; attempt++) { coordinator.Flush(); }
+            },
+            TestContext.Current.CancellationToken);
+
+        await Task.WhenAll(producer, flusher);
+
+        coordinator.Flush();
+
+        long[] delivered = recorder.RecordIdsFor(logId);
+
+        Assert.Equal(total, delivered.Length);
+        Assert.Equal(total, delivered.Distinct().Count());
+        Assert.Equal(Enumerable.Range(1, total).Select(value => (long)value), delivered);
+    }
+
+    [Fact]
+    public void DiscardAll_LeavesNothingToDispatch()
+    {
+        var recorder = new DispatchRecorder();
+        using var coordinator = new LiveTailIngestCoordinator(recorder.Dispatcher, s_manual);
+        EventLogId logId = EventLogId.Create();
+
+        coordinator.Enqueue(logId, MakeEvent(1));
+        recorder.Clear();
+
+        coordinator.Enqueue(logId, MakeEvent(2));
+        coordinator.DiscardAll();
+        coordinator.Flush();
+
+        Assert.Empty(recorder.Ingests);
+    }
+
+    [Fact]
+    public void Discard_DropsOnlyThatLogsPendingEvents()
+    {
+        var recorder = new DispatchRecorder();
+        using var coordinator = new LiveTailIngestCoordinator(recorder.Dispatcher, s_manual);
+        EventLogId dropped = EventLogId.Create();
+        EventLogId kept = EventLogId.Create();
+
+        coordinator.Enqueue(dropped, MakeEvent(1));
+        recorder.Clear();
+
+        coordinator.Enqueue(dropped, MakeEvent(2));
+        coordinator.Enqueue(kept, MakeEvent(3));
+        coordinator.Discard(dropped);
+        coordinator.Flush();
+
+        Assert.Empty(recorder.RecordIdsFor(dropped));
+        Assert.Equal([3], recorder.RecordIdsFor(kept));
+    }
+
+    [Fact]
+    public void Dispose_DropsPendingWorkAndIgnoresLaterUse()
+    {
+        var recorder = new DispatchRecorder();
+        var coordinator = new LiveTailIngestCoordinator(recorder.Dispatcher, s_manual);
+        EventLogId logId = EventLogId.Create();
+
+        coordinator.Enqueue(logId, MakeEvent(1));
+        recorder.Clear();
+
+        coordinator.Enqueue(logId, MakeEvent(2));
+        coordinator.Dispose();
+
+        coordinator.Flush();
+        coordinator.Enqueue(logId, MakeEvent(3));
+        coordinator.Flush();
+
+        Assert.Empty(recorder.Ingests);
+    }
+
+    [Fact]
+    public void Enqueue_AfterAFlush_TakesTheLeadingEdgeAgainOnceTheWindowHasElapsed()
+    {
+        var recorder = new DispatchRecorder();
+
+        using var coordinator = new LiveTailIngestCoordinator(recorder.Dispatcher, TimeSpan.Zero);
+        EventLogId logId = EventLogId.Create();
+
+        coordinator.Enqueue(logId, MakeEvent(1));
+        coordinator.Enqueue(logId, MakeEvent(2));
+
+        Assert.Equal(2, recorder.Ingests.Count);
+    }
+
+    [Fact]
+    public void Enqueue_AtThePendingCap_FlushesWithoutWaitingForTheWindow()
+    {
+        var recorder = new DispatchRecorder();
+        using var coordinator = new LiveTailIngestCoordinator(recorder.Dispatcher, s_manual);
+        EventLogId logId = EventLogId.Create();
+
+        coordinator.Enqueue(logId, MakeEvent(1));
+        recorder.Clear();
+
+        for (int recordId = 0; recordId < 1000; recordId++) { coordinator.Enqueue(logId, MakeEvent(recordId + 2)); }
+
+        Assert.Single(recorder.Ingests);
+        Assert.Equal(1000, recorder.RecordIdsFor(logId).Length);
+    }
+
+    [Fact]
+    public void Enqueue_OnAFreshCoordinatorWithALongWindow_StillFlushesTheLeadingEdge()
+    {
+        var recorder = new DispatchRecorder();
+        using var coordinator = new LiveTailIngestCoordinator(recorder.Dispatcher, TimeSpan.FromDays(40));
+        EventLogId logId = EventLogId.Create();
+
+        coordinator.Enqueue(logId, MakeEvent(1));
+
+        Assert.Equal([1], recorder.RecordIdsFor(logId));
+    }
+
+    [Fact]
+    public void Enqueue_WhenIdle_FlushesImmediatelySoASparseTailPaysNoLatency()
+    {
+        var recorder = new DispatchRecorder();
+        using var coordinator = new LiveTailIngestCoordinator(recorder.Dispatcher, s_manual);
+        EventLogId logId = EventLogId.Create();
+
+        coordinator.Enqueue(logId, MakeEvent(1));
+
+        Assert.Equal([1], recorder.RecordIdsFor(logId));
+    }
+
+    [Fact]
+    public void Enqueue_WhileBusy_CoalescesIntoOneIngestPerLogInArrivalOrder()
+    {
+        var recorder = new DispatchRecorder();
+        using var coordinator = new LiveTailIngestCoordinator(recorder.Dispatcher, s_manual);
+        EventLogId logId = EventLogId.Create();
+
+        coordinator.Enqueue(logId, MakeEvent(1));
+        recorder.Clear();
+
+        for (int recordId = 2; recordId <= 6; recordId++) { coordinator.Enqueue(logId, MakeEvent(recordId)); }
+
+        Assert.Empty(recorder.Ingests);
+
+        coordinator.Flush();
+
+        Assert.Single(recorder.Ingests);
+        Assert.Equal([2, 3, 4, 5, 6], recorder.RecordIdsFor(logId));
+    }
+
+    [Fact]
+    public void Enqueue_WithANonPositiveWindow_FlushesEveryEventInline()
+    {
+        var recorder = new DispatchRecorder();
+        using var coordinator = new LiveTailIngestCoordinator(recorder.Dispatcher, s_dormant);
+        EventLogId logId = EventLogId.Create();
+
+        coordinator.Enqueue(logId, MakeEvent(1));
+        coordinator.Enqueue(logId, MakeEvent(2));
+        coordinator.Enqueue(logId, MakeEvent(3));
+
+        Assert.Equal(3, recorder.Ingests.Count);
+        Assert.Equal([1, 2, 3], recorder.RecordIdsFor(logId));
+    }
+
+    [Fact]
+    public void Flush_CarriesEveryTouchedLogInOneAction()
+    {
+        var recorder = new DispatchRecorder();
+        using var coordinator = new LiveTailIngestCoordinator(recorder.Dispatcher, s_manual);
+        EventLogId first = EventLogId.Create();
+        EventLogId second = EventLogId.Create();
+
+        coordinator.Enqueue(first, MakeEvent(1));
+        recorder.Clear();
+
+        coordinator.Enqueue(first, MakeEvent(2));
+        coordinator.Enqueue(second, MakeEvent(3));
+        coordinator.Flush();
+
+        Assert.Single(recorder.Ingests);
+        Assert.Equal(2, recorder.Ingests[0].EventsByLog.Count);
+        Assert.Equal([2], recorder.RecordIdsFor(first));
+        Assert.Equal([3], recorder.RecordIdsFor(second));
+    }
+
+    [Fact]
+    public void Flush_WhenNothingIsPending_DispatchesNothing()
+    {
+        var recorder = new DispatchRecorder();
+        using var coordinator = new LiveTailIngestCoordinator(recorder.Dispatcher, s_manual);
+
+        coordinator.Flush();
+        coordinator.Flush();
+
+        Assert.Empty(recorder.Ingests);
+    }
+
+    private static ResolvedEvent MakeEvent(long recordId) =>
+        new("Log", LogPathType.Channel)
+        {
+            RecordId = recordId,
+            TimeCreated = new DateTime(2026, 1, 1, 0, 0, 0, DateTimeKind.Utc).AddMilliseconds(recordId),
+            Id = 1000,
+            Level = "Information",
+            Source = "Provider.A",
+            LogName = "Channel"
+        };
+
+    private sealed class DispatchRecorder
+    {
+        private readonly Lock _gate = new();
+
+        public DispatchRecorder()
+        {
+            Dispatcher = Substitute.For<IDispatcher>();
+
+            Dispatcher
+                .When(dispatcher => dispatcher.Dispatch(Arg.Any<object>()))
+                .Do(call =>
+                {
+                    lock (_gate)
+                    {
+                        switch (call[0])
+                        {
+                            case IngestRawEventsAction ingest: Ingests.Add(ingest); break;
+                        }
+                    }
+                });
+        }
+
+        public IDispatcher Dispatcher { get; }
+
+        public List<IngestRawEventsAction> Ingests { get; } = [];
+
+        public void Clear()
+        {
+            lock (_gate)
+            {
+                Ingests.Clear();
+            }
+        }
+
+        public long[] RecordIdsFor(EventLogId logId)
+        {
+            lock (_gate)
+            {
+                return [.. Ingests
+                    .Where(ingest => ingest.EventsByLog.ContainsKey(logId))
+                    .SelectMany(ingest => ingest.EventsByLog[logId])
+                    .Select(resolved => resolved.RecordId ?? 0)];
+            }
+        }
+    }
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/EventLog/LoadedLogNamesSourceTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/EventLog/LoadedLogNamesSourceTests.cs
new file mode 100644
index 000000000..dbe972890
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/EventLog/LoadedLogNamesSourceTests.cs
@@ -0,0 +1,112 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Logging.Abstractions;
+using EventLogExpert.Runtime.EventLog;
+using Fluxor;
+using NSubstitute;
+using System.Collections.Immutable;
+
+namespace EventLogExpert.Runtime.Tests.EventLog;
+
+public sealed class LoadedLogNamesSourceTests
+{
+    [Fact]
+    public void AThrowingSubscriber_IsIsolatedFromOtherSubscribers()
+    {
+        var harness = new Harness(ImmutableHashSet<string>.Empty);
+        var reachedSecond = 0;
+        harness.Source.Changed += () => throw new InvalidOperationException("subscriber blew up");
+        harness.Source.Changed += () => reachedSecond++;
+
+        harness.SetNames(ImmutableHashSet.Create("Application"));
+
+        Assert.Equal(1, reachedSecond);
+    }
+
+    [Fact]
+    public void Changed_DoesNotFire_WhenSetReferenceUnchanged()
+    {
+        var names = ImmutableHashSet.Create("Application");
+        var harness = new Harness(names);
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.SetState(new EventLogState { LoadedLogNames = names });
+
+        Assert.Equal(0, raised);
+        Assert.Same(names, harness.Source.Current);
+    }
+
+    [Fact]
+    public void Changed_Fires_WhenSetInstanceChanges()
+    {
+        var harness = new Harness(ImmutableHashSet<string>.Empty);
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        var next = ImmutableHashSet.Create("Application");
+        harness.SetNames(next);
+
+        Assert.Equal(1, raised);
+        Assert.Same(next, harness.Source.Current);
+    }
+
+    [Fact]
+    public void Construction_AdoptsAChangeThatLandsBetweenSeedAndSubscribe()
+    {
+        var reconciled = ImmutableHashSet.Create("Application");
+        var state = Substitute.For<IState<EventLogState>>();
+        state.Value.Returns(new EventLogState(), new EventLogState { LoadedLogNames = reconciled });
+
+        using var source = new LoadedLogNamesSource(state, Substitute.For<ITraceLogger>());
+
+        Assert.Same(reconciled, source.Current);
+    }
+
+    [Fact]
+    public void Current_ReflectsTheInitialState()
+    {
+        var names = ImmutableHashSet.Create("Application");
+        var harness = new Harness(names);
+
+        Assert.Same(names, harness.Source.Current);
+    }
+
+    [Fact]
+    public void Dispose_StopsRaising()
+    {
+        var harness = new Harness(ImmutableHashSet<string>.Empty);
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.Source.Dispose();
+        harness.SetNames(ImmutableHashSet.Create("Application"));
+
+        Assert.Equal(0, raised);
+    }
+
+    private sealed class Harness
+    {
+        private readonly IState<EventLogState> _state = Substitute.For<IState<EventLogState>>();
+
+        public Harness(ImmutableHashSet<string> names)
+        {
+            State = new EventLogState { LoadedLogNames = names };
+            _state.Value.Returns(_ => State);
+            Source = new LoadedLogNamesSource(_state, Substitute.For<ITraceLogger>());
+        }
+
+        public LoadedLogNamesSource Source { get; }
+
+        public EventLogState State { get; private set; }
+
+        public void SetNames(ImmutableHashSet<string> names) => SetState(new EventLogState { LoadedLogNames = names });
+
+        public void SetState(EventLogState state)
+        {
+            State = state;
+            _state.StateChanged += Raise.Event<EventHandler>(_state, EventArgs.Empty);
+        }
+    }
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/EventLog/OpenLogsPresenceSourceTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/EventLog/OpenLogsPresenceSourceTests.cs
new file mode 100644
index 000000000..eed754725
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/EventLog/OpenLogsPresenceSourceTests.cs
@@ -0,0 +1,123 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.Channels;
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Logging.Abstractions;
+using EventLogExpert.Runtime.EventLog;
+using Fluxor;
+using NSubstitute;
+using System.Collections.Immutable;
+
+namespace EventLogExpert.Runtime.Tests.EventLog;
+
+public sealed class OpenLogsPresenceSourceTests
+{
+    [Fact]
+    public void AThrowingSubscriber_IsIsolatedFromOtherSubscribers()
+    {
+        var harness = new Harness(openLogs: false);
+        var reachedSecond = 0;
+        harness.Source.Changed += () => throw new InvalidOperationException("subscriber blew up");
+        harness.Source.Changed += () => reachedSecond++;
+
+        harness.SetState(openLogs: true);
+
+        Assert.Equal(1, reachedSecond);
+    }
+
+    [Fact]
+    public void Changed_DoesNotFire_WhenPresenceUnchanged()
+    {
+        var harness = new Harness(openLogs: true);
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.SetState(WithOpenLogs(2));
+
+        Assert.Equal(0, raised);
+        Assert.True(harness.Source.HasOpenLogs);
+    }
+
+    [Fact]
+    public void Changed_FiresWithLatestPresence_WhenPresenceFlips()
+    {
+        var harness = new Harness(openLogs: false);
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.SetState(openLogs: true);
+
+        Assert.Equal(1, raised);
+        Assert.True(harness.Source.HasOpenLogs);
+    }
+
+    [Fact]
+    public void Construction_AdoptsAChangeThatLandsBetweenSeedAndSubscribe()
+    {
+        // seed) then an open-logs state (the reconcile), with no StateChanged raised in between.
+        var state = Substitute.For<IState<EventLogState>>();
+        state.Value.Returns(new EventLogState(), WithOpenLogs(1));
+
+        using var source = new OpenLogsPresenceSource(state, Substitute.For<ITraceLogger>());
+
+        Assert.True(source.HasOpenLogs);
+    }
+
+    [Fact]
+    public void Dispose_StopsRaising()
+    {
+        var harness = new Harness(openLogs: false);
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.Source.Dispose();
+        harness.SetState(openLogs: true);
+
+        Assert.Equal(0, raised);
+    }
+
+    [Fact]
+    public void HasOpenLogs_ReflectsTheInitialState()
+    {
+        var harness = new Harness(openLogs: true);
+
+        Assert.True(harness.Source.HasOpenLogs);
+    }
+
+    private static EventLogState WithOpenLogs(int count)
+    {
+        var openLogs = ImmutableDictionary<string, OpenLogInfo>.Empty;
+
+        for (var index = 0; index < count; index++)
+        {
+            openLogs = openLogs.Add($"Log{index}", new OpenLogInfo(EventLogId.Create(), LogPathType.Channel));
+        }
+
+        return new EventLogState { OpenLogs = openLogs };
+    }
+
+    private sealed class Harness
+    {
+        private readonly IState<EventLogState> _state = Substitute.For<IState<EventLogState>>();
+
+        public Harness(bool openLogs)
+        {
+            State = openLogs ? WithOpenLogs(1) : new EventLogState();
+            _state.Value.Returns(_ => State);
+            Source = new OpenLogsPresenceSource(_state, Substitute.For<ITraceLogger>());
+        }
+
+        public OpenLogsPresenceSource Source { get; }
+
+        public EventLogState State { get; private set; }
+
+        public void SetState(bool openLogs) => SetState(openLogs ? WithOpenLogs(1) : new EventLogState());
+
+        public void SetState(EventLogState state)
+        {
+            State = state;
+            _state.StateChanged += Raise.Event<EventHandler>(_state, EventArgs.Empty);
+        }
+    }
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/EventLog/PartialLoadCoordinatorTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/EventLog/PartialLoadCoordinatorTests.cs
deleted file mode 100644
index 8b9bfc457..000000000
--- a/tests/Unit/EventLogExpert.Runtime.Tests/EventLog/PartialLoadCoordinatorTests.cs
+++ /dev/null
@@ -1,234 +0,0 @@
-// // Copyright (c) Microsoft Corporation.
-// // Licensed under the MIT License.
-
-using EventLogExpert.Eventing.Common.Channels;
-using EventLogExpert.Eventing.Common.EventLogs;
-using EventLogExpert.Eventing.Common.Events;
-using EventLogExpert.Runtime.EventLog;
-using EventLogExpert.Runtime.LogTable;
-using Fluxor;
-using NSubstitute;
-using IDispatcher = Fluxor.IDispatcher;
-
-namespace EventLogExpert.Runtime.Tests.EventLog;
-
-public sealed class PartialLoadCoordinatorTests
-{
-    [Fact]
-    public void Discard_RemovesBufferAndAllowsReopen()
-    {
-        var harness = Create();
-        var logId = EventLogId.Create();
-        harness.Seed(logId, 1);
-
-        harness.Coordinator.Enqueue(logId, 0); // first-seen: flushes immediately
-        harness.Coordinator.Enqueue(logId, 0); // already seen: buffered
-        harness.Dispatched.Clear();
-
-        harness.Coordinator.Discard(logId);
-        harness.Coordinator.Flush();
-        Assert.Empty(harness.Dispatched);
-
-        harness.Coordinator.Enqueue(logId, 0); // seen was cleared, so first-seen again
-        Assert.Single(harness.Dispatched);
-    }
-
-    [Fact]
-    public void DiscardAll_ClearsAllBuffers()
-    {
-        var harness = Create();
-        var first = EventLogId.Create();
-        var second = EventLogId.Create();
-        harness.Seed(first, 1);
-        harness.Seed(second, 1);
-
-        harness.Coordinator.Enqueue(first, 0);
-        harness.Coordinator.Enqueue(second, 0);
-        harness.Coordinator.Enqueue(first, 0);
-        harness.Coordinator.Enqueue(second, 0);
-        harness.Dispatched.Clear();
-
-        harness.Coordinator.DiscardAll();
-        harness.Coordinator.Flush();
-
-        Assert.Empty(harness.Dispatched);
-    }
-
-    [Fact]
-    public void Dispose_ThenEnqueueAndFlush_IsSilent()
-    {
-        var harness = Create();
-        var logId = EventLogId.Create();
-        harness.Seed(logId, 1);
-
-        harness.Coordinator.Dispose();
-        harness.Coordinator.Enqueue(logId, 0);
-        harness.Coordinator.Flush();
-
-        Assert.Empty(harness.Dispatched);
-    }
-
-    [Fact]
-    public void Enqueue_BufferStraddlingVersions_FlushesMinVersion()
-    {
-        var harness = Create();
-        var logId = EventLogId.Create();
-        harness.Seed(logId, 1);
-
-        harness.Coordinator.Enqueue(logId, 5);
-        harness.Dispatched.Clear();
-
-        harness.Coordinator.Enqueue(logId, 3);
-        harness.Coordinator.Enqueue(logId, 8);
-        harness.Coordinator.Flush();
-
-        var batch = Assert.IsType<AppendTableEventsBatchAction>(Assert.Single(harness.Dispatched));
-        Assert.Equal(3, batch.VersionByLog[logId]);
-    }
-
-    [Fact]
-    public void Enqueue_FirstDeltaForLog_FlushesImmediately()
-    {
-        var harness = Create();
-        var logId = EventLogId.Create();
-        harness.Seed(logId, 1);
-
-        harness.Coordinator.Enqueue(logId, 0);
-
-        var batch = Assert.IsType<AppendTableEventsBatchAction>(Assert.Single(harness.Dispatched));
-        Assert.True(batch.ViewsByLog.ContainsKey(logId));
-        Assert.Equal(1, batch.ViewsByLog[logId].Count);
-    }
-
-    [Fact]
-    public void Enqueue_FirstSeen_EmitsVersionByLog()
-    {
-        var harness = Create();
-        var logId = EventLogId.Create();
-        harness.Seed(logId, 1);
-
-        harness.Coordinator.Enqueue(logId, 7);
-
-        var batch = Assert.IsType<AppendTableEventsBatchAction>(Assert.Single(harness.Dispatched));
-        Assert.Equal(7, batch.VersionByLog[logId]);
-    }
-
-    [Fact]
-    public void Enqueue_ForLogAbsentFromStore_DispatchesNothing()
-    {
-        // In the columnar model a delta is only a dirty signal; the events live in the raw store. A log that the
-        // store does not hold (closed, or never ingested) produces no view and therefore dispatches nothing.
-        var harness = Create();
-
-        harness.Coordinator.Enqueue(EventLogId.Create(), 0);
-
-        Assert.Empty(harness.Dispatched);
-    }
-
-    [Fact]
-    public void Flush_BuffersAcrossLogs_DispatchesOneBatchForAllLogs()
-    {
-        var harness = Create();
-        var first = EventLogId.Create();
-        var second = EventLogId.Create();
-        harness.Seed(first, 1);
-        harness.Seed(second, 1);
-
-        // The first delta per log flushes immediately; subsequent deltas buffer for the next flush.
-        harness.Coordinator.Enqueue(first, 0);
-        harness.Coordinator.Enqueue(second, 0);
-        harness.Dispatched.Clear();
-
-        harness.Coordinator.Enqueue(first, 0);
-        harness.Coordinator.Enqueue(second, 0);
-        harness.Coordinator.Flush();
-
-        var batch = Assert.IsType<AppendTableEventsBatchAction>(Assert.Single(harness.Dispatched));
-        Assert.Equal(2, batch.ViewsByLog.Count);
-    }
-
-    [Fact]
-    public void MarkFinalized_DropsAlreadyBufferedDelta()
-    {
-        var harness = Create();
-        var logId = EventLogId.Create();
-        harness.Seed(logId, 1);
-
-        harness.Coordinator.Enqueue(logId, 0); // first-seen: flushes immediately and clears the buffer
-        harness.Coordinator.Enqueue(logId, 0); // already seen: buffered, not yet flushed
-        harness.Dispatched.Clear();
-
-        harness.Coordinator.MarkFinalized(logId);
-        harness.Coordinator.Flush();
-
-        Assert.Empty(harness.Dispatched);
-    }
-
-    [Fact]
-    public void MarkFinalized_ThenLateEnqueue_DropsTheLateEvents()
-    {
-        var harness = Create();
-        var logId = EventLogId.Create();
-        harness.Seed(logId, 1);
-
-        harness.Coordinator.Enqueue(logId, 0);
-        harness.Dispatched.Clear();
-
-        harness.Coordinator.MarkFinalized(logId);
-        harness.Coordinator.Enqueue(logId, 0);
-        harness.Coordinator.Flush();
-
-        Assert.Empty(harness.Dispatched);
-    }
-
-    private static Harness Create()
-    {
-        var dispatched = new List<object>();
-        var dispatcher = Substitute.For<IDispatcher>();
-        dispatcher.When(d => d.Dispatch(Arg.Any<object>())).Do(call => dispatched.Add(call.ArgAt<object>(0)));
-
-        var storeHolder = new StoreHolder();
-        var rawState = Substitute.For<IState<RawEventStoreState>>();
-        rawState.Value.Returns(_ => storeHolder.State);
-
-        var eventLogState = Substitute.For<IState<EventLogState>>();
-        eventLogState.Value.Returns(new EventLogState());
-
-        var logTableState = Substitute.For<IState<LogTableState>>();
-        logTableState.Value.Returns(new LogTableState());
-
-        var coordinator = new PartialLoadCoordinator(
-            dispatcher, rawState, eventLogState, logTableState, Timeout.InfiniteTimeSpan);
-
-        return new Harness(coordinator, dispatched, storeHolder);
-    }
-
-    private static ResolvedEvent NewEvent(long recordId) =>
-        new("Application", LogPathType.Channel) { RecordId = recordId };
-
-    private sealed class Harness(PartialLoadCoordinator coordinator, List<object> dispatched, StoreHolder store)
-    {
-        public PartialLoadCoordinator Coordinator => coordinator;
-
-        public List<object> Dispatched => dispatched;
-
-        // Ingest is what populates the raw store in production; the coordinator only rebuilds the view from it. Seed the
-        // store so a flush for this log produces a non-empty view.
-        public void Seed(EventLogId logId, int count)
-        {
-            var events = new List<ResolvedEvent>(count);
-
-            for (int i = 0; i < count; i++) { events.Add(NewEvent(i + 1)); }
-
-            store.State = store.State with
-            {
-                ByLog = store.State.ByLog.SetItem(logId, EventColumnStore.Build(events, 0, 0))
-            };
-        }
-    }
-
-    private sealed class StoreHolder
-    {
-        public RawEventStoreState State { get; set; } = new();
-    }
-}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/EventLog/RevealFocusReducersTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/EventLog/RevealFocusReducersTests.cs
new file mode 100644
index 000000000..e7e5fb84a
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/EventLog/RevealFocusReducersTests.cs
@@ -0,0 +1,101 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
+using EventLogExpert.Runtime.EventLog;
+
+namespace EventLogExpert.Runtime.Tests.EventLog;
+
+public sealed class RevealFocusReducersTests
+{
+    private static readonly EventLogId s_logA = EventLogId.Create();
+    private static readonly EventLogId s_logB = EventLogId.Create();
+
+    [Fact]
+    public void ReduceCloseAll_ClearsThePendingReveal()
+    {
+        var state = new EventLogState { PendingRevealFocus = new EventLocator(s_logA, 0, 7) };
+
+        state = Reducers.ReduceCloseAll(state);
+
+        Assert.Null(state.PendingRevealFocus);
+    }
+
+    [Fact]
+    public void ReduceCloseLog_ClearsThePendingReveal_WhenItTargetsTheClosedLog()
+    {
+        var state = new EventLogState { PendingRevealFocus = new EventLocator(s_logA, 0, 7) };
+
+        state = Reducers.ReduceCloseLog(state, new CloseLogAction(s_logA, "Application"));
+
+        Assert.Null(state.PendingRevealFocus);
+    }
+
+    [Fact]
+    public void ReduceCloseLog_KeepsThePendingReveal_WhenItTargetsADifferentLog()
+    {
+        var revealForA = new EventLocator(s_logA, 0, 7);
+        var state = new EventLogState { PendingRevealFocus = revealForA };
+
+        state = Reducers.ReduceCloseLog(state, new CloseLogAction(s_logB, "System"));
+
+        Assert.Equal(revealForA, state.PendingRevealFocus);
+    }
+
+    [Fact]
+    public void ReduceRequestRevealFocus_ANewerTarget_Supersedes()
+    {
+        var first = new EventLocator(s_logA, 0, 1);
+        var second = new EventLocator(s_logA, 0, 2);
+        var state = Reducers.ReduceRequestRevealFocus(new EventLogState(), new RequestRevealFocusAction(first));
+
+        state = Reducers.ReduceRequestRevealFocus(state, new RequestRevealFocusAction(second));
+
+        Assert.Equal(second, state.PendingRevealFocus);
+    }
+
+    [Fact]
+    public void ReduceRequestRevealFocus_ReRequestingSameTarget_LeavesStateReferenceUnchanged()
+    {
+        var target = new EventLocator(s_logA, 0, 7);
+        var state = Reducers.ReduceRequestRevealFocus(new EventLogState(), new RequestRevealFocusAction(target));
+
+        var next = Reducers.ReduceRequestRevealFocus(state, new RequestRevealFocusAction(target));
+
+        Assert.Same(state, next);
+    }
+
+    [Fact]
+    public void ReduceRequestRevealFocus_SetsThePendingTarget()
+    {
+        var target = new EventLocator(s_logA, 0, 7);
+
+        var state = Reducers.ReduceRequestRevealFocus(new EventLogState(), new RequestRevealFocusAction(target));
+
+        Assert.Equal(target, state.PendingRevealFocus);
+    }
+
+    [Fact]
+    public void ReduceRevealFocusConsumed_ClearsWhenTheTargetMatches()
+    {
+        var target = new EventLocator(s_logA, 0, 7);
+        var state = Reducers.ReduceRequestRevealFocus(new EventLogState(), new RequestRevealFocusAction(target));
+
+        state = Reducers.ReduceRevealFocusConsumed(state, new RevealFocusConsumedAction(target));
+
+        Assert.Null(state.PendingRevealFocus);
+    }
+
+    [Fact]
+    public void ReduceRevealFocusConsumed_DoesNotClearANewerTarget_WhenConsumingAnOlderOne()
+    {
+        var older = new EventLocator(s_logA, 0, 1);
+        var newer = new EventLocator(s_logB, 0, 3);
+        var state = new EventLogState { PendingRevealFocus = newer };
+
+        state = Reducers.ReduceRevealFocusConsumed(state, new RevealFocusConsumedAction(older));
+
+        Assert.Equal(newer, state.PendingRevealFocus);
+    }
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/Export/EventExportCoordinatorTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/Export/EventExportCoordinatorTests.cs
new file mode 100644
index 000000000..9b9626577
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/Export/EventExportCoordinatorTests.cs
@@ -0,0 +1,373 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.Channels;
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
+using EventLogExpert.Logging.Abstractions;
+using EventLogExpert.Runtime.Alerts;
+using EventLogExpert.Runtime.Banner;
+using EventLogExpert.Runtime.Common.Files;
+using EventLogExpert.Runtime.Export;
+using EventLogExpert.Runtime.LogTable;
+using EventLogExpert.Runtime.LogTable.OrderedView;
+using EventLogExpert.Runtime.Settings;
+using EventLogExpert.Runtime.Tests.TestUtils;
+using Fluxor;
+using NSubstitute;
+using System.Collections.Immutable;
+
+namespace EventLogExpert.Runtime.Tests.Export;
+
+public sealed class EventExportCoordinatorTests
+{
+    private const string LogName = "Application";
+
+    private static readonly TimeSpan s_testTimeout = TimeSpan.FromSeconds(5);
+
+    private readonly IAlertDialogService _dialogs = Substitute.For<IAlertDialogService>();
+    private readonly IEventTableExporter _exporter = Substitute.For<IEventTableExporter>();
+    private readonly IFileSaveService _fileSave = Substitute.For<IFileSaveService>();
+    private readonly IState<LogTableState> _logTableState = Substitute.For<IState<LogTableState>>();
+    private readonly IExportProgressBannerService _progress = Substitute.For<IExportProgressBannerService>();
+    private readonly ISettingsService _settings = Substitute.For<ISettingsService>();
+
+    private LogTableState _state = new();
+
+    public EventExportCoordinatorTests()
+    {
+        _logTableState.Value.Returns(_ => _state);
+        _settings.TimeZoneInfo.Returns(TimeZoneInfo.Utc);
+    }
+
+    [Fact]
+    public async Task Export_KeepsTheRowsItCaptured_WhenTheDisplayMovesBeforeTheWriteBegins()
+    {
+        _state = StateWith(Event(1, "Alpha"), Event(2, "Beta"), Event(3, "Gamma"));
+
+        LogTableState afterTheUserMovedOn = StateWith(Event(9, "Zeta"));
+
+        _fileSave.SaveStreamingAsync(
+                Arg.Any<string>(),
+                Arg.Any<IReadOnlyDictionary<string, IReadOnlyList<string>>>(),
+                Arg.Any<Func<Stream, CancellationToken, Task>>(),
+                Arg.Any<CancellationToken>())
+            .Returns(async callInfo =>
+            {
+                _state = afterTheUserMovedOn;
+
+                await callInfo.ArgAt<Func<Stream, CancellationToken, Task>>(2)(Stream.Null, CancellationToken.None);
+
+                return (string?)"C:\\events.csv";
+            });
+
+        await CreateCoordinator().ExportEventsAsync(ExportFormat.Csv);
+
+        IEventColumnView written = ExportedRows()!;
+
+        Assert.Equal(3, written.Count);
+        Assert.Equal(1, afterTheUserMovedOn.GetActiveDisplayedEvents().Count);
+
+        Assert.Equal(
+            ["Alpha", "Beta", "Gamma"],
+            written.EnumerateDetail().Select(@event => @event.Source).OrderBy(source => source, StringComparer.Ordinal));
+
+        Assert.DoesNotContain("Zeta", written.EnumerateDetail().Select(@event => @event.Source));
+    }
+
+    [Fact]
+    public async Task Export_TakesTheRowsAndTheColumnsThatDescribeThemFromOneRead()
+    {
+        LogTableState twoColumns = StateWith(Event(1, "Alpha")) with
+        {
+            Columns = ImmutableDictionary.CreateRange(new Dictionary<ColumnName, bool> { [ColumnName.Source] = true, [ColumnName.EventId] = true }),
+            ColumnOrder = [ColumnName.Source, ColumnName.EventId]
+        };
+
+        LogTableState oneColumnLater = twoColumns with
+        {
+            Columns = ImmutableDictionary.CreateRange(new Dictionary<ColumnName, bool> { [ColumnName.Source] = true }),
+            ColumnOrder = [ColumnName.Source]
+        };
+
+        bool firstRead = true;
+
+        _logTableState.Value.Returns(_ =>
+        {
+            if (!firstRead) { return oneColumnLater; }
+
+            firstRead = false;
+
+            return twoColumns;
+        });
+
+        CaptureWrite();
+
+        await CreateCoordinator().ExportEventsAsync(ExportFormat.Csv);
+
+        Assert.Equal([ColumnName.Source, ColumnName.EventId], ExportedColumns()!);
+    }
+
+    [Fact]
+    public async Task Export_WhenTheEngineFailedButRowsAreStillOnScreen_WritesTheRowsTheUserCanSee()
+    {
+        _state = Reducers.ReduceOrderedViewDisplayFaulted(
+            StateWith(Event(1, "Alpha")),
+            new OrderedViewDisplayFaultedAction(new InvalidOperationException("bad predicate")));
+
+        Assert.Equal(PresentationState.Faulted, _state.PresentationState);
+        Assert.Equal(1, _state.GetActiveDisplayedEvents().Count);
+
+        CaptureWrite();
+
+        await CreateCoordinator().ExportEventsAsync(ExportFormat.Csv);
+
+        await _fileSave.Received(1).SaveStreamingAsync(
+            Arg.Any<string>(),
+            Arg.Any<IReadOnlyDictionary<string, IReadOnlyList<string>>>(),
+            Arg.Any<Func<Stream, CancellationToken, Task>>(),
+            Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public async Task Export_WhileAnotherIsStillWriting_RefusesRatherThanOrphaningTheFirstCancellation()
+    {
+        _state = StateWith(Event(1, "Alpha"));
+
+        var firstWriteReached = new TaskCompletionSource();
+        var releaseFirstWrite = new TaskCompletionSource();
+
+        _fileSave.SaveStreamingAsync(
+                Arg.Any<string>(),
+                Arg.Any<IReadOnlyDictionary<string, IReadOnlyList<string>>>(),
+                Arg.Any<Func<Stream, CancellationToken, Task>>(),
+                Arg.Any<CancellationToken>())
+            .Returns(async _ =>
+            {
+                firstWriteReached.TrySetResult();
+
+                await releaseFirstWrite.Task;
+
+                return (string?)"C:\\events.csv";
+            });
+
+        EventExportCoordinator coordinator = CreateCoordinator();
+
+        Task first = coordinator.ExportEventsAsync(ExportFormat.Csv);
+
+        await firstWriteReached.Task;
+
+        Task second = coordinator.ExportEventsAsync(ExportFormat.Csv);
+
+        Task finished = await Task.WhenAny(
+            second,
+            Task.Delay(s_testTimeout, TestContext.Current.CancellationToken));
+
+        Assert.True(ReferenceEquals(finished, second), "A second export was allowed to start while the first held the write.");
+
+        await second;
+
+        await _dialogs.Received(1).ShowAlert(
+            "Export events", "An export is already in progress.", Arg.Any<string>(), Arg.Any<AlertPresentation>());
+
+        releaseFirstWrite.TrySetResult();
+
+        await first;
+    }
+
+    [Fact]
+    public async Task Export_WhileTheRowsAreStillBeingPrepared_SaysSoRatherThanClaimingThereAreNone()
+    {
+        _state = StateWith();
+
+        await CreateCoordinator().ExportEventsAsync(ExportFormat.Csv);
+
+        await _fileSave.DidNotReceive().SaveStreamingAsync(
+            Arg.Any<string>(),
+            Arg.Any<IReadOnlyDictionary<string, IReadOnlyList<string>>>(),
+            Arg.Any<Func<Stream, CancellationToken, Task>>(),
+            Arg.Any<CancellationToken>());
+
+        await _dialogs.Received(1).ShowAlert(
+            "Export events",
+            "These events are still being prepared. Please try again once they have finished loading.",
+            Arg.Any<string>(),
+            Arg.Any<AlertPresentation>());
+    }
+
+    [Fact]
+    public async Task Export_WhileTheViewCouldNotBePrepared_SaysSoRatherThanClaimingThereAreNone()
+    {
+        _state = StateWith() with { OrderedViewDisplayEnabled = false, FaultCause = "InvalidOperationException: bad predicate" };
+
+        await CreateCoordinator().ExportEventsAsync(ExportFormat.Csv);
+
+        await _fileSave.DidNotReceive().SaveStreamingAsync(
+            Arg.Any<string>(),
+            Arg.Any<IReadOnlyDictionary<string, IReadOnlyList<string>>>(),
+            Arg.Any<Func<Stream, CancellationToken, Task>>(),
+            Arg.Any<CancellationToken>());
+
+        await _dialogs.Received(1).ShowAlert(
+            "Export events",
+            "These events cannot be exported because the view could not be prepared.",
+            Arg.Any<string>(),
+            Arg.Any<AlertPresentation>());
+    }
+
+    [Fact]
+    public async Task Export_WithNoLogOpenAtAll_TellsTheUserAndNeverOpensTheSavePicker()
+    {
+        _state = StateWith() with { ActiveEventLogId = null };
+
+        Assert.Null(_state.ServingOrderedView);
+        Assert.Equal(PresentationState.Current, _state.PresentationState);
+
+        await CreateCoordinator().ExportEventsAsync(ExportFormat.Csv);
+
+        await _fileSave.DidNotReceive().SaveStreamingAsync(
+            Arg.Any<string>(),
+            Arg.Any<IReadOnlyDictionary<string, IReadOnlyList<string>>>(),
+            Arg.Any<Func<Stream, CancellationToken, Task>>(),
+            Arg.Any<CancellationToken>());
+
+        await _dialogs.Received(1).ShowAlert(
+            "Export events", "There are no events to export.", Arg.Any<string>(), Arg.Any<AlertPresentation>());
+    }
+
+    [Fact]
+    public async Task Export_WithNoRowsAndNothingLeftToWaitFor_TellsTheUserAndNeverOpensTheSavePicker()
+    {
+        _state = SettledEmpty();
+
+        Assert.NotNull(_state.ServingOrderedView);
+        Assert.Equal(PresentationState.Current, _state.PresentationState);
+
+        await CreateCoordinator().ExportEventsAsync(ExportFormat.Csv);
+
+        await _fileSave.DidNotReceive().SaveStreamingAsync(
+            Arg.Any<string>(),
+            Arg.Any<IReadOnlyDictionary<string, IReadOnlyList<string>>>(),
+            Arg.Any<Func<Stream, CancellationToken, Task>>(),
+            Arg.Any<CancellationToken>());
+
+        await _dialogs.Received(1).ShowAlert(
+            "Export events", "There are no events to export.", Arg.Any<string>(), Arg.Any<AlertPresentation>());
+    }
+
+    [Fact]
+    public async Task Export_WithNoVisibleColumns_TellsTheUserAndNeverOpensTheSavePicker()
+    {
+        _state = StateWith(Event(1, "Alpha")) with
+        {
+            Columns = ImmutableDictionary.CreateRange(new Dictionary<ColumnName, bool> { [ColumnName.Source] = false }),
+            ColumnOrder = [ColumnName.Source]
+        };
+
+        await CreateCoordinator().ExportEventsAsync(ExportFormat.Csv);
+
+        await _fileSave.DidNotReceive().SaveStreamingAsync(
+            Arg.Any<string>(),
+            Arg.Any<IReadOnlyDictionary<string, IReadOnlyList<string>>>(),
+            Arg.Any<Func<Stream, CancellationToken, Task>>(),
+            Arg.Any<CancellationToken>());
+
+        await _dialogs.Received(1).ShowAlert(
+            "Export events", "There are no visible columns to export.", Arg.Any<string>(), Arg.Any<AlertPresentation>());
+    }
+
+    [Fact]
+    public async Task Export_WritesTheRowsTheDisplayIsShowing()
+    {
+        _state = StateWith(Event(1, "Alpha"), Event(2, "Beta"), Event(3, "Gamma"));
+        CaptureWrite();
+
+        await CreateCoordinator().ExportEventsAsync(ExportFormat.Csv);
+
+        Assert.Equal(3, ExportedRows()!.Count);
+    }
+
+    private static ResolvedEvent Event(long recordId, string source) =>
+        new(LogName, LogPathType.Channel)
+        {
+            RecordId = recordId,
+            TimeCreated = new DateTime(2026, 1, 1, 0, 0, 0, DateTimeKind.Utc).AddMilliseconds(recordId),
+            Id = 1000,
+            Level = "Information",
+            Source = source,
+            LogName = LogName
+        };
+
+    private static LogTableState Serving(LogTableState state, EventLogId logId, IEventColumnView view) =>
+        state with
+        {
+            ActiveOrderedView = new OrderedViewReady(
+                SnapshotVersion: 1,
+                Identity: state.ViewIdentity,
+                Sequence: state.HighestInvalidationSequence,
+                SingleLogId: logId,
+                InScope: [new LogGeneration(logId, 0)],
+                View: view,
+                Config: state.SortContext,
+                Filter: state.AppliedFilter)
+        };
+
+    private static LogTableState SettledEmpty()
+    {
+        LogTableState state = StateWith();
+
+        return Serving(state, state.ActiveEventLogId!.Value, EmptyColumnView.Instance);
+    }
+
+    private static LogTableState StateWith(params ResolvedEvent[] events)
+    {
+        var logId = EventLogId.Create();
+
+        var state = new LogTableState
+        {
+            ActiveEventLogId = logId,
+            EventTables = [new LogView(logId) { LogName = LogName }],
+            Columns = ImmutableDictionary.CreateRange(new Dictionary<ColumnName, bool> { [ColumnName.Source] = true }),
+            ColumnOrder = [ColumnName.Source]
+        };
+
+        if (events.Length == 0) { return state; }
+
+        return Serving(state, logId, DisplayViewTestFactory.Build(logId, events));
+    }
+
+    private void CaptureWrite() =>
+        _fileSave.SaveStreamingAsync(
+                Arg.Any<string>(),
+                Arg.Any<IReadOnlyDictionary<string, IReadOnlyList<string>>>(),
+                Arg.Any<Func<Stream, CancellationToken, Task>>(),
+                Arg.Any<CancellationToken>())
+            .Returns(async callInfo =>
+            {
+                await callInfo.ArgAt<Func<Stream, CancellationToken, Task>>(2)(Stream.Null, CancellationToken.None);
+
+                return (string?)"C:\\events.csv";
+            });
+
+    private EventExportCoordinator CreateCoordinator() =>
+        new(_logTableState,
+            _exporter,
+            _fileSave,
+            _progress,
+            _dialogs,
+            _settings,
+            new ColumnDefaults(),
+            Substitute.For<ITraceLogger>());
+
+    private IReadOnlyList<ColumnName>? ExportedColumns() =>
+        _exporter.ReceivedCalls()
+            .Where(call => call.GetMethodInfo().Name == nameof(IEventTableExporter.ExportAsync))
+            .Select(call => (IReadOnlyList<ColumnName>)call.GetArguments()[3]!)
+            .FirstOrDefault();
+
+    private IEventColumnView? ExportedRows() =>
+        _exporter.ReceivedCalls()
+            .Where(call => call.GetMethodInfo().Name == nameof(IEventTableExporter.ExportAsync))
+            .Select(call => (IEventColumnView)call.GetArguments()[2]!)
+            .FirstOrDefault();
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/Export/EventTableExporterTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/Export/EventTableExporterTests.cs
index 20fc3fcaf..c8bb47d3f 100644
--- a/tests/Unit/EventLogExpert.Runtime.Tests/Export/EventTableExporterTests.cs
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/Export/EventTableExporterTests.cs
@@ -6,6 +6,7 @@
 using EventLogExpert.Eventing.Common.Events;
 using EventLogExpert.Runtime.Export;
 using EventLogExpert.Runtime.LogTable;
+using EventLogExpert.Runtime.Tests.LogTable.TestSupport;
 using System.Text.Json;
 
 namespace EventLogExpert.Runtime.Tests.Export;
@@ -29,7 +30,6 @@ public async Task ExportAsync_CancelledToken_ThrowsAndWritesNothing()
         EventTableExporter exporter = new(new TabularExportWriter());
         using MemoryStream stream = new();
 
-        // A Cancel during the export must throw so AtomicFileWriter discards the temp; nothing is written.
         await Assert.ThrowsAnyAsync<OperationCanceledException>(() => exporter.ExportAsync(
             stream, ExportFormat.Csv, BuildView(s_events), s_columns, s_utc, includeDescription: false, cancellation.Token));
 
@@ -170,15 +170,18 @@ public async Task ExportAsync_NoEvents_Csv_WritesHeaderOnly()
         Assert.Equal("Event ID,Source\r\n", ExportTestHelpers.DecodeWithoutBom(bytes));
     }
 
-    // The exporter now consumes an IEventColumnView, so round-trip the events through a real column store (null orderBy
-    // preserves the input order the assertions expect) rather than a hand-rolled adapter.
     private static IEventColumnView BuildView(IReadOnlyList<ResolvedEvent> events)
     {
         var reader = EventColumnStore.Build(events, generation: 0, contentVersion: 0).CreateReader(EventLogId.Create());
-        int[] survivors = Enumerable.Range(0, events.Count).ToArray();
-
-        return EventColumnView.Create(
-            reader, survivors, orderBy: null, isDescending: false, groupBy: null, isGroupDescending: false);
+        int[] survivors = [.. Enumerable.Range(0, events.Count)];
+
+        return AosReferenceView.Create(
+            reader,
+            survivors,
+            orderBy: null,
+            isDescending: false,
+            groupBy: null,
+            isGroupDescending: false);
     }
 
     private static async Task<byte[]> ExportAsync(
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/FilterLenses/FilterLensCommandsTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/FilterLenses/FilterLensCommandsTests.cs
index f88c620f3..88c45b775 100644
--- a/tests/Unit/EventLogExpert.Runtime.Tests/FilterLenses/FilterLensCommandsTests.cs
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/FilterLenses/FilterLensCommandsTests.cs
@@ -23,12 +23,12 @@ public void ClearLenses_DispatchesClear()
     public void RemoveLens_DispatchesRemove()
     {
         var dispatcher = Substitute.For<IDispatcher>();
-        var lens = new FilterLens { Label = "x", Kind = LensKind.Property };
+        var id = FilterLensId.Create();
 
-        new FilterLensCommands(dispatcher).RemoveLens(lens);
+        new FilterLensCommands(dispatcher).RemoveLens(id);
 
         dispatcher.Received(1).Dispatch(Arg.Is<RemoveFilterLensAction>(action =>
-            action != null && action.Lens == lens));
+            action != null && action.Id == id));
     }
 
     [Theory]
@@ -71,7 +71,6 @@ public void ShowEventsNearTime_InRangeNonStandardRadius_RendersLosslessChipSuffi
     {
         var dispatcher = Substitute.For<IDispatcher>();
 
-        // 90s is within (0, 1h] but not an offered duration; the suffix renders it losslessly as "90s", not a rounded "2m".
         new FilterLensCommands(dispatcher).ShowEventsNearTime(
             new DateTime(2024, 1, 1, 12, 0, 0, DateTimeKind.Utc), TimeSpan.FromSeconds(90), TimeZoneInfo.Utc);
 
@@ -90,43 +89,35 @@ public void ShowEventsNearTime_LabelRendersAnchorInDisplayZone()
 
         new FilterLensCommands(dispatcher).ShowEventsNearTime(anchor, TimeSpan.FromMinutes(5), displayZone);
 
-        // Built with the same culture-sensitive ":T" the production label uses, so the assertion holds under any ambient
-        // culture; the anchor renders in the +5 display zone (17:00:00), not UTC (12:00:00).
         dispatcher.Received(1).Dispatch(Arg.Is<PushFilterLensAction>(action =>
             action != null &&
             action.Lens.Label == $"Near {expectedAnchor:T} \u00b15m"));
     }
 
     [Fact]
-    public void ShowEventsNearTime_MinValueAnchor_ClampsLowerBoundWithoutThrowing()
+    public void ShowEventsNearTime_MinValueAnchorWithNegativeOffsetZone_RendersLabelWithoutThrowing()
     {
         var dispatcher = Substitute.For<IDispatcher>();
+        var westOfUtc = TimeZoneInfo.CreateCustomTimeZone("test-5", TimeSpan.FromHours(-5), "test-5", "test-5");
 
-        // A degenerate default(DateTime) anchor must not throw - DateTime boundary arithmetic throws on underflow; the
-        // lower bound clamps to DateTime.MinValue.
         new FilterLensCommands(dispatcher).ShowEventsNearTime(
-            DateTime.MinValue, TimeSpan.FromSeconds(30), TimeZoneInfo.Utc);
+            DateTime.MinValue, TimeSpan.FromSeconds(30), westOfUtc);
 
-        dispatcher.Received(1).Dispatch(Arg.Is<PushFilterLensAction>(action =>
-            action != null &&
-            action.Lens.Window!.After == DateTime.MinValue &&
-            action.Lens.Window.Before == DateTime.MinValue.AddSeconds(30)));
+        dispatcher.Received(1).Dispatch(Arg.Any<PushFilterLensAction>());
     }
 
     [Fact]
-    public void ShowEventsNearTime_MinValueAnchorWithNegativeOffsetZone_RendersLabelWithoutThrowing()
+    public void ShowEventsNearTime_MinValueAnchor_ClampsLowerBoundWithoutThrowing()
     {
         var dispatcher = Substitute.For<IDispatcher>();
-        var westOfUtc = TimeZoneInfo.CreateCustomTimeZone("test-5", TimeSpan.FromHours(-5), "test-5", "test-5");
 
-        // Guards the chip-label conversion for a degenerate default(DateTime) anchor against a non-UTC display zone: on
-        // net10 TimeZoneInfo.ConvertTimeFromUtc clamps an out-of-range result to DateTime.MinValue instead of throwing, so
-        // the label renders without crashing the context-menu handler. (Legacy .NET Framework threw for this exact case; a
-        // future retarget that reintroduced the throw would fail this test rather than crashing at runtime.)
         new FilterLensCommands(dispatcher).ShowEventsNearTime(
-            DateTime.MinValue, TimeSpan.FromSeconds(30), westOfUtc);
+            DateTime.MinValue, TimeSpan.FromSeconds(30), TimeZoneInfo.Utc);
 
-        dispatcher.Received(1).Dispatch(Arg.Any<PushFilterLensAction>());
+        dispatcher.Received(1).Dispatch(Arg.Is<PushFilterLensAction>(action =>
+            action != null &&
+            action.Lens.Window!.After == DateTime.MinValue &&
+            action.Lens.Window.Before == DateTime.MinValue.AddSeconds(30)));
     }
 
     [Theory]
@@ -148,8 +139,6 @@ public void ShowEventsNearTime_SubSecondRadius_ThrowsAndDoesNotDispatch()
     {
         var dispatcher = Substitute.For<IDispatcher>();
 
-        // The window is whole-second granularity; a sub-second radius (which the compact suffix cannot render losslessly)
-        // is rejected rather than silently rounded.
         Assert.Throws<ArgumentOutOfRangeException>(() => new FilterLensCommands(dispatcher).ShowEventsNearTime(
             new DateTime(2024, 1, 1, 12, 0, 0, DateTimeKind.Utc), TimeSpan.FromMilliseconds(500), TimeZoneInfo.Utc));
 
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/FilterLenses/FilterLensReducerTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/FilterLenses/FilterLensReducerTests.cs
index 286f3b457..eea09848f 100644
--- a/tests/Unit/EventLogExpert.Runtime.Tests/FilterLenses/FilterLensReducerTests.cs
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/FilterLenses/FilterLensReducerTests.cs
@@ -41,6 +41,30 @@ public void Push_AddsLensToTopOfStack()
         Assert.Same(b, result.Lenses[1]);
     }
 
+    [Fact]
+    public void RemoveForLog_NoMatch_ReturnsSameStateInstance()
+    {
+        var state = new FilterLensState { Lenses = [LensFromLog("a", "LogA")] };
+
+        var result = Reducers.ReduceRemoveForLog(state, new RemoveLensesForLogAction("LogB"));
+
+        Assert.Same(state, result);
+    }
+
+    [Fact]
+    public void RemoveForLog_RemovesOnlyLensesFromThatLog()
+    {
+        var fromA1 = LensFromLog("a1", "LogA");
+        var fromB = LensFromLog("b", "LogB");
+        var fromA2 = LensFromLog("a2", "LogA");
+        var state = new FilterLensState { Lenses = [fromA1, fromB, fromA2] };
+
+        var result = Reducers.ReduceRemoveForLog(state, new RemoveLensesForLogAction("LogA"));
+
+        Assert.Single(result.Lenses);
+        Assert.Same(fromB, result.Lenses[0]);
+    }
+
     [Fact]
     public void Remove_DuplicateContentLenses_RemovesOnlyTargetedInstance()
     {
@@ -49,7 +73,7 @@ public void Remove_DuplicateContentLenses_RemovesOnlyTargetedInstance()
         Assert.NotEqual(first.Id, second.Id);
         var state = new FilterLensState { Lenses = [first, second] };
 
-        var result = Reducers.ReduceRemove(state, new RemoveFilterLensAction(second));
+        var result = Reducers.ReduceRemove(state, new RemoveFilterLensAction(second.Id));
 
         Assert.Single(result.Lenses);
         Assert.Same(first, result.Lenses[0]);
@@ -62,7 +86,7 @@ public void Remove_RemovesSpecificLens()
         var b = Lens("b");
         var state = new FilterLensState { Lenses = [a, b] };
 
-        var result = Reducers.ReduceRemove(state, new RemoveFilterLensAction(a));
+        var result = Reducers.ReduceRemove(state, new RemoveFilterLensAction(a.Id));
 
         Assert.Single(result.Lenses);
         Assert.Same(b, result.Lenses[0]);
@@ -73,35 +97,11 @@ public void Remove_UnknownLens_ReturnsSameStateInstance()
     {
         var state = new FilterLensState { Lenses = [Lens("a")] };
 
-        var result = Reducers.ReduceRemove(state, new RemoveFilterLensAction(Lens("other")));
+        var result = Reducers.ReduceRemove(state, new RemoveFilterLensAction(Lens("other").Id));
 
         Assert.Same(state, result);
     }
 
-    [Fact]
-    public void RemoveForLog_NoMatch_ReturnsSameStateInstance()
-    {
-        var state = new FilterLensState { Lenses = [LensFromLog("a", "LogA")] };
-
-        var result = Reducers.ReduceRemoveForLog(state, new RemoveLensesForLogAction("LogB"));
-
-        Assert.Same(state, result);
-    }
-
-    [Fact]
-    public void RemoveForLog_RemovesOnlyLensesFromThatLog()
-    {
-        var fromA1 = LensFromLog("a1", "LogA");
-        var fromB = LensFromLog("b", "LogB");
-        var fromA2 = LensFromLog("a2", "LogA");
-        var state = new FilterLensState { Lenses = [fromA1, fromB, fromA2] };
-
-        var result = Reducers.ReduceRemoveForLog(state, new RemoveLensesForLogAction("LogA"));
-
-        Assert.Single(result.Lenses);
-        Assert.Same(fromB, result.Lenses[0]);
-    }
-
     private static FilterLens Lens(string label) =>
         new() { Label = label, Kind = LensKind.Property, ExcludeFilters = [] };
 
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/FilterLenses/FilterLensSourceTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/FilterLenses/FilterLensSourceTests.cs
new file mode 100644
index 000000000..f8f5419c1
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/FilterLenses/FilterLensSourceTests.cs
@@ -0,0 +1,117 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Logging.Abstractions;
+using EventLogExpert.Runtime.FilterLenses;
+using Fluxor;
+using NSubstitute;
+using System.Collections.Immutable;
+
+namespace EventLogExpert.Runtime.Tests.FilterLenses;
+
+public sealed class FilterLensSourceTests
+{
+    [Fact]
+    public void AThrowingSubscriber_IsIsolatedFromOtherSubscribers()
+    {
+        var harness = new Harness(Lens("First"));
+        var reachedSecond = 0;
+        harness.Source.Changed += () => throw new InvalidOperationException("subscriber blew up");
+        harness.Source.Changed += () => reachedSecond++;
+
+        harness.SetLenses(harness.State.Lenses.Add(Lens("Second")));
+
+        Assert.Equal(1, reachedSecond);
+    }
+
+    [Fact]
+    public void Changed_DoesNotFire_WhenProjectionUnchanged()
+    {
+        var lens = Lens("First");
+        var harness = new Harness(lens);
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.SetLenses([lens with { OriginLog = "not-part-of-the-projection" }]);
+
+        Assert.Equal(0, raised);
+    }
+
+    [Fact]
+    public void Changed_FiresWithLatestLenses_OnStateChange()
+    {
+        var harness = new Harness(Lens("First"));
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        var added = Lens("Second");
+        harness.SetLenses(harness.State.Lenses.Add(added));
+
+        Assert.Equal(1, raised);
+        Assert.Equal(2, harness.Source.Lenses.Count);
+        Assert.Equal(new FilterLensSummary(added.Id, "Second"), harness.Source.Lenses[^1]);
+    }
+
+    [Fact]
+    public void Construction_AdoptsAChangeThatLandsBetweenSeedAndSubscribe()
+    {
+        // one-lens state (the reconcile), with no StateChanged raised in between.
+        var state = Substitute.For<IState<FilterLensState>>();
+        state.Value.Returns(new FilterLensState(), new FilterLensState { Lenses = [Lens("First")] });
+
+        using var source = new FilterLensSource(state, Substitute.For<ITraceLogger>());
+
+        Assert.Single(source.Lenses);
+    }
+
+    [Fact]
+    public void Dispose_StopsRaising()
+    {
+        var harness = new Harness(Lens("First"));
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.Source.Dispose();
+        harness.SetLenses(harness.State.Lenses.Add(Lens("Second")));
+
+        Assert.Equal(0, raised);
+    }
+
+    [Fact]
+    public void Lenses_SummarizeTheActiveLenses()
+    {
+        var first = Lens("First");
+        var second = Lens("Second");
+        var harness = new Harness(first, second);
+
+        var lenses = harness.Source.Lenses;
+
+        Assert.Equal(2, lenses.Count);
+        Assert.Equal(new FilterLensSummary(first.Id, "First"), lenses[0]);
+        Assert.Equal(new FilterLensSummary(second.Id, "Second"), lenses[1]);
+    }
+
+    private static FilterLens Lens(string label) => new() { Label = label, Kind = LensKind.Property };
+
+    private sealed class Harness
+    {
+        private readonly IState<FilterLensState> _state = Substitute.For<IState<FilterLensState>>();
+
+        public Harness(params FilterLens[] lenses)
+        {
+            State = new FilterLensState { Lenses = [.. lenses] };
+            _state.Value.Returns(_ => State);
+            Source = new FilterLensSource(_state, Substitute.For<ITraceLogger>());
+        }
+
+        public FilterLensSource Source { get; }
+
+        public FilterLensState State { get; private set; }
+
+        public void SetLenses(ImmutableList<FilterLens> lenses)
+        {
+            State = State with { Lenses = lenses };
+            _state.StateChanged += Raise.Event<EventHandler>(_state, EventArgs.Empty);
+        }
+    }
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/FilterLibrary/FilterLibraryEffectsTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/FilterLibrary/FilterLibraryEffectsTests.cs
index 49ddcc129..9e40192c3 100644
--- a/tests/Unit/EventLogExpert.Runtime.Tests/FilterLibrary/FilterLibraryEffectsTests.cs
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/FilterLibrary/FilterLibraryEffectsTests.cs
@@ -15,6 +15,12 @@ namespace EventLogExpert.Runtime.Tests.FilterLibrary;
 
 public sealed class FilterLibraryEffectsTests
 {
+    private const int PollDelayMilliseconds = 10;
+    private const int SettleDelayMilliseconds = 150;
+
+    private static readonly TimeSpan s_shortTimeout = TimeSpan.FromSeconds(2);
+    private static readonly TimeSpan s_testTimeout = TimeSpan.FromSeconds(5);
+
     [Fact]
     public async Task ApplyBulkTagUpdate_ReissueAgainstLatestSnapshotFails_ReloadsLibrary_AnnouncesFailure_DispatchesNoProjection()
     {
@@ -35,7 +41,7 @@ public async Task ApplyBulkTagUpdate_ReissueAgainstLatestSnapshotFails_ReloadsLi
                 if (bulkCalls == 1)
                 {
                     var list = call.ArgAt<IReadOnlyList<LibraryEntry>>(0);
-                    return Task.FromResult<IReadOnlyList<LibraryEntryId>>(list.Select(e => e.Id).ToList());
+                    return Task.FromResult<IReadOnlyList<LibraryEntryId>>([.. list.Select(e => e.Id)]);
                 }
 
                 return Task.FromException<IReadOnlyList<LibraryEntryId>>(new InvalidOperationException("reissue-fail"));
@@ -93,9 +99,7 @@ await effects.HandleAddFilterToExistingFilterSet(
             new AddFilterToExistingFilterSetAction(filterSet.Id, duplicate, source.Id),
             dispatcher);
 
-        // Did NOT update the filter set (duplicate).
         await store.DidNotReceive().UpdateAsync(Arg.Is<LibraryEntry>(e => e != null && e.Id == filterSet.Id), Arg.Any<CancellationToken>());
-        // But DID promote the source.
         await store.Received(1).UpdateAsync(Arg.Is<LibraryEntry>(e => e != null && e.Id == source.Id && e.Origin == LibraryEntryOrigin.UserSaved), Arg.Any<CancellationToken>());
     }
 
@@ -130,7 +134,6 @@ await effects.HandleAddFilterToExistingFilterSet(
     [Fact]
     public async Task HandleAddFilterToExistingFilterSet_SameTextDifferentMode_AppendsAsDistinctFilter()
     {
-        // Mode-drift policy: distinct Mode + same ComparisonText must coexist in a filter set.
         var advanced = SavedFilter.TryCreate("Level == 4", mode: FilterMode.Advanced);
         var basic = SavedFilter.TryCreate("Level == 4", mode: FilterMode.Basic);
         Assert.NotNull(advanced);
@@ -517,9 +520,6 @@ public async Task HandleLoadLibrary_Concurrent_TwoSimultaneousDispatches_Migrato
         var migratedEntry = BuildFilterEntry("migrated");
         var migrator = Substitute.For<ILegacyFilterMigrator>();
         var migrationComplete = 0;
-        // Realistic mock: ShouldRunMigration returns true until the migrator marks completion (matches the
-        // real LegacyFilterMigrator's per-section flag semantics). The previous test relied on the now-removed
-        // entries.IsEmpty guard to suppress the second BuildEntriesFromLegacy call.
         migrator.ShouldRunMigration().Returns(_ => Volatile.Read(ref migrationComplete) == 0);
         migrator.When(m => m.MarkMigrationCompleted(Arg.Any<LegacyMigrationSections>()))
             .Do(_ => Volatile.Write(ref migrationComplete, 1));
@@ -577,11 +577,11 @@ public async Task HandleLoadLibrary_DispatchesStartedActionBeforeAcquiringGate()
         var load2 = default(Task);
         try
         {
-            await migratorReachedSignal.Task.WaitAsync(TimeSpan.FromSeconds(5), ct);
+            await migratorReachedSignal.Task.WaitAsync(s_testTimeout, ct);
             load2 = Task.Run(() => effects.HandleLoadLibrary(dispatcher), ct);
             await PollUntilAsync(
                 () => dispatcher.ReceivedCalls().Count(c => c.GetArguments().FirstOrDefault() is LoadLibraryStartedAction) >= 2,
-                TimeSpan.FromSeconds(5),
+                s_testTimeout,
                 ct);
 
             dispatcher.Received(2).Dispatch(Arg.Any<LoadLibraryStartedAction>());
@@ -589,8 +589,6 @@ await PollUntilAsync(
         }
         finally
         {
-            // Always release the migrator so the load tasks unblock even if an assertion or polling timeout
-            // throws - otherwise xUnit's per-test cleanup hangs waiting for the still-running load tasks.
             migratorReleaser.Release();
             if (load2 is not null) { await Task.WhenAll(load1, load2); }
             else { await load1; }
@@ -734,8 +732,6 @@ public async Task HandleLoadLibrary_MigratorShouldRunReturnsFalse_SkipsBuildEntr
     [Fact]
     public async Task HandleLoadLibrary_NonEmptyStore_FilterSetsSameNameDifferentFilters_BothSurvive()
     {
-        // Presets are user-created with no name-uniqueness invariant; same-name presets with distinct
-        // filter content must both persist. Dedup must key on name + filters fingerprint, not name alone.
         var existingFilter = SavedFilter.TryCreate("Level == 4");
         Assert.NotNull(existingFilter);
         var existingFilterSet = new LibraryEntryFilterSet
@@ -750,7 +746,7 @@ public async Task HandleLoadLibrary_NonEmptyStore_FilterSetsSameNameDifferentFil
         {
             Name = "Errors",
             CreatedUtc = DateTimeOffset.UtcNow,
-            Filters = ImmutableList.Create(migratedFilter), // different filters
+            Filters = ImmutableList.Create(migratedFilter),
         };
         var sections = LegacyMigrationSections.Favorites | LegacyMigrationSections.Groups | LegacyMigrationSections.Recents;
         var migrator = Substitute.For<ILegacyFilterMigrator>();
@@ -763,7 +759,6 @@ public async Task HandleLoadLibrary_NonEmptyStore_FilterSetsSameNameDifferentFil
 
         await effects.HandleLoadLibrary(dispatcher);
 
-        // Distinct filter content → migrated filter set is NOT deduped → AddRange called with it.
         await store.Received(1).AddRangeAsync(Arg.Is<IEnumerable<LibraryEntry>>(e => e != null && e.Count() == 1 && e.First() is LibraryEntryFilterSet), Arg.Any<CancellationToken>());
         migrator.Received(1).MarkMigrationCompleted(sections);
         dispatcher.Received(1).Dispatch(Arg.Is<LoadLibrarySuccessAction>(a => a != null && a.Entries.Count == 2));
@@ -772,10 +767,6 @@ public async Task HandleLoadLibrary_NonEmptyStore_FilterSetsSameNameDifferentFil
     [Fact]
     public async Task HandleLoadLibrary_NonEmptyStore_MigrationEntriesOverlap_DedupsAgainstExisting_NoDuplicateInsertion()
     {
-        // Critical defense against the SetString-throws-then-retry duplication scenario: if a prior launch
-        // successfully ran AddRange but failed MarkMigrationCompleted, the next launch reads the populated
-        // store, ShouldRunMigration still returns true, BuildEntriesFromLegacy re-emits the same entries
-        // (fresh GUIDs but same content), and the migration must NOT re-insert them as content-duplicates.
         var existingFavorite = BuildFilterEntryWithText("Favorite", "Level == 4");
         var existingFilterSet = BuildFilterSetEntry("Errors");
         var duplicateFavorite = BuildFilterEntryWithText("Favorite", "Level == 4");
@@ -791,11 +782,8 @@ public async Task HandleLoadLibrary_NonEmptyStore_MigrationEntriesOverlap_Dedups
 
         await effects.HandleLoadLibrary(dispatcher);
 
-        // Both migration entries collide with existing store content → AddRange must NOT be called with them.
         await store.DidNotReceive().AddRangeAsync(Arg.Any<IEnumerable<LibraryEntry>>(), Arg.Any<CancellationToken>());
-        // Bitmask still advances - the section is "complete" from the persistence perspective.
         migrator.Received(1).MarkMigrationCompleted(sections);
-        // Loaded entries reflect the existing store (no duplicates).
         dispatcher.Received(1).Dispatch(Arg.Is<LoadLibrarySuccessAction>(a => a != null && a.Entries.Count == 2));
     }
 
@@ -804,7 +792,7 @@ public async Task HandleLoadLibrary_NonEmptyStore_MigrationEntriesPartiallyOverl
     {
         var existing = BuildFilterEntryWithText("Existing", "Level == 4");
         var dupeOverlap = BuildFilterEntryWithText("Existing", "Level == 4");
-        var newEntry = BuildFilterEntryWithText("New", "Level == 5"); // does not collide
+        var newEntry = BuildFilterEntryWithText("New", "Level == 5");
         var sections = LegacyMigrationSections.Favorites | LegacyMigrationSections.Groups | LegacyMigrationSections.Recents;
         var migrator = Substitute.For<ILegacyFilterMigrator>();
         migrator.ShouldRunMigration().Returns(true);
@@ -816,7 +804,6 @@ public async Task HandleLoadLibrary_NonEmptyStore_MigrationEntriesPartiallyOverl
 
         await effects.HandleLoadLibrary(dispatcher);
 
-        // Only the non-overlapping entry is inserted.
         await store.Received(1).AddRangeAsync(Arg.Is<IEnumerable<LibraryEntry>>(e => e != null && e.Count() == 1 && e.First().Id == newEntry.Id), Arg.Any<CancellationToken>());
         migrator.Received(1).MarkMigrationCompleted(sections);
         dispatcher.Received(1).Dispatch(Arg.Is<LoadLibrarySuccessAction>(a => a != null && a.Entries.Count == 2));
@@ -922,7 +909,6 @@ public async Task HandleLoadLibrary_WhenStoreThrows_DispatchesStartedThenFailure
     [Fact]
     public async Task HandleRecordEntryApplied_BumpReturnsFalse_SkipsDispatchAndPrune()
     {
-        // SQL bump returns false (concurrent SetIsFavorite committed) → no dispatch, no prune.
         var entry = BuildFilterEntry("First") with { Origin = LibraryEntryOrigin.AutoTracked };
         var (effects, store, dispatcher, _, _) = CreateEffects(state: new FilterLibraryState { Entries = [entry] });
         store.TryBumpLastUsedIfNotFavoriteAsync(Arg.Any<LibraryEntryId>(), Arg.Any<DateTimeOffset>(), Arg.Any<CancellationToken>()).Returns(false);
@@ -975,7 +961,6 @@ public async Task HandleRecordEntryApplied_NotFavoriteBumpSucceeds_DispatchesUpd
     [Fact]
     public async Task HandleRecordEntryApplied_PruneDeleteReturnsFalse_DoesNotDispatchDeleteSuccess()
     {
-        // SQL DELETE returns false (entry was promoted/favorited since snapshot) → don't orphan state.
         var seedFilter = SavedFilter.TryCreate("Level == 4");
         Assert.NotNull(seedFilter);
         var entries = new List<LibraryEntry>();
@@ -1014,7 +999,6 @@ public async Task HandleRecordEntryApplied_PruneDeleteReturnsFalse_DoesNotDispat
     [Fact]
     public async Task HandleRecordEntryApplied_PrunesOldestAutoTrackedEntries_WhenCapExceeded()
     {
-        // Seed 50 AutoTracked recents (at-cap) + the entry we're about to bump.
         var seedFilter = SavedFilter.TryCreate("Level == 4");
         Assert.NotNull(seedFilter);
         var entries = new List<LibraryEntry>();
@@ -1030,9 +1014,6 @@ public async Task HandleRecordEntryApplied_PrunesOldestAutoTrackedEntries_WhenCa
             });
         }
 
-        // The 51st entry - about to be bumped (will project into the prune snapshot).
-        // Pre-bump LastUsedUtc doesn't affect the prune order - the effect overwrites it with UtcNow
-        // and that's the value that lands in the snapshot before PruneFromSnapshot runs.
         var bumpTarget = new LibraryEntrySavedFilter
         {
             Name = "bumped",
@@ -1050,7 +1031,6 @@ public async Task HandleRecordEntryApplied_PrunesOldestAutoTrackedEntries_WhenCa
 
         await effects.HandleRecordEntryApplied(new RecordEntryAppliedAction(bumpTarget.Id), dispatcher);
 
-        // SQL-guarded delete no-ops if the row was concurrently promoted/favorited.
         await store.Received(1).TryDeleteAutoTrackedIfNotFavoriteAsync(Arg.Is(oldestId), Arg.Any<CancellationToken>());
         dispatcher.Received(1).Dispatch(Arg.Is<DeleteLibraryEntrySuccessAction>(a => a != null && a.EntryId == oldestId));
     }
@@ -1068,7 +1048,6 @@ public async Task HandleRecordEntryApplied_UnknownId_IsNoOp()
     [Fact]
     public async Task HandleRecordFilterApplied_CollisionBranch_BumpsExistingAndDispatchesAddSuccess()
     {
-        // In-memory state has no match; SQL INSERT OR IGNORE collides with an existing AutoTracked row.
         var filter = SavedFilter.TryCreate("Level == 4");
         Assert.NotNull(filter);
         var existing = new LibraryEntrySavedFilter
@@ -1133,7 +1112,6 @@ public async Task HandleRecordFilterApplied_CollisionBranch_StateAlreadyHasEntry
             });
         }
 
-        // The "already in state" collision target - distinct ComparisonText so in-memory match misses.
         var alreadyInState = new LibraryEntrySavedFilter
         {
             Name = "already-in-state",
@@ -1142,7 +1120,7 @@ public async Task HandleRecordFilterApplied_CollisionBranch_StateAlreadyHasEntry
             LastUsedUtc = new DateTimeOffset(2026, 5, 1, 0, 0, 49, TimeSpan.Zero),
             Filter = SavedFilter.TryCreate("Level == 1999")!,
         };
-        entries.Add(alreadyInState);  // state count now 50 (at cap)
+        entries.Add(alreadyInState);
 
         var newFilter = SavedFilter.TryCreate("Level == 2777");
         Assert.NotNull(newFilter);
@@ -1155,10 +1133,8 @@ public async Task HandleRecordFilterApplied_CollisionBranch_StateAlreadyHasEntry
 
         await effects.HandleRecordFilterApplied(new RecordFilterAppliedAction(newFilter), dispatcher);
 
-        // Snapshot should be 50 (SetItem on the existing row, not Add); prune sees count == cap; no delete.
         await store.DidNotReceive().TryDeleteAutoTrackedIfNotFavoriteAsync(Arg.Any<LibraryEntryId>(), Arg.Any<CancellationToken>());
         dispatcher.DidNotReceive().Dispatch(Arg.Any<DeleteLibraryEntrySuccessAction>());
-        // Bump + AddSuccess dispatch still happen as part of the collision-bump path.
         dispatcher.Received(1).Dispatch(Arg.Is<AddLibraryEntrySuccessAction>(a => a != null && a.Entry.Id == alreadyInState.Id));
     }
 
@@ -1244,7 +1220,6 @@ public async Task HandleRecordFilterApplied_NoExisting_InsertsAutoTrackedEntry()
     [Fact]
     public async Task HandleRecordFilterApplied_PrunesOldestAutoTrackedEntries_WhenInsertExceedsCap()
     {
-        // Mirrors the HandleRecordEntryApplied prune test for the auto-create insert path.
         var seedFilter = SavedFilter.TryCreate("Level == 4");
         Assert.NotNull(seedFilter);
         var entries = new List<LibraryEntry>();
@@ -1256,7 +1231,6 @@ public async Task HandleRecordFilterApplied_PrunesOldestAutoTrackedEntries_WhenI
                 CreatedUtc = DateTimeOffset.UtcNow,
                 Origin = LibraryEntryOrigin.AutoTracked,
                 LastUsedUtc = new DateTimeOffset(2026, 5, 1, 0, 0, i, TimeSpan.Zero),
-                // Distinct ComparisonText per entry forces the effect through AddOrReturnExistingFilter.
                 Filter = SavedFilter.TryCreate($"Level == {i + 100}")!,
             });
         }
@@ -1325,7 +1299,6 @@ public async Task HandleRecordFilterApplied_TupleMatch_BumpsLastUsedAndDispatche
     [Fact]
     public async Task HandleRecordFilterApplied_UserSavedExisting_BumpsAndSkipsAutoTrack()
     {
-        // Re-applying a user-saved filter refreshes its LastUsedUtc; no AutoTracked duplicate.
         var filter = SavedFilter.TryCreate("Level == 4");
         Assert.NotNull(filter);
         var existing = new LibraryEntrySavedFilter
@@ -1730,18 +1703,6 @@ public async Task HandleSetIsFavorite_AlreadyAtTargetState_IsNoOp()
         dispatcher.DidNotReceive().Dispatch(Arg.Any<UpdateLibraryEntrySuccessAction>());
     }
 
-    [Fact]
-    public async Task HandleSetIsFavorite_False_OnFilter_BumpsLastUsedToNow()
-    {
-        var filter = BuildFilterEntry("First") with { IsFavorite = true };
-        var (effects, store, dispatcher, _, _) = CreateEffects(state: new FilterLibraryState { Entries = [filter] });
-
-        await effects.HandleSetIsFavorite(new SetIsFavoriteAction(filter.Id, IsFavorite: false), dispatcher);
-
-        await store.Received(1).UpdateAsync(Arg.Is<LibraryEntry>(e => e != null &&
-            e.Id == filter.Id && !e.IsFavorite && e.LastUsedUtc != null), Arg.Any<CancellationToken>());
-    }
-
     [Fact]
     public async Task HandleSetIsFavorite_False_OnFilterSet_LeavesLastUsedNull()
     {
@@ -1761,6 +1722,18 @@ public async Task HandleSetIsFavorite_False_OnFilterSet_LeavesLastUsedNull()
         await store.Received(1).UpdateAsync(Arg.Is<LibraryEntry>(e => e != null && e.Id == filterSet.Id && !e.IsFavorite && e.LastUsedUtc == null), Arg.Any<CancellationToken>());
     }
 
+    [Fact]
+    public async Task HandleSetIsFavorite_False_OnFilter_BumpsLastUsedToNow()
+    {
+        var filter = BuildFilterEntry("First") with { IsFavorite = true };
+        var (effects, store, dispatcher, _, _) = CreateEffects(state: new FilterLibraryState { Entries = [filter] });
+
+        await effects.HandleSetIsFavorite(new SetIsFavoriteAction(filter.Id, IsFavorite: false), dispatcher);
+
+        await store.Received(1).UpdateAsync(Arg.Is<LibraryEntry>(e => e != null &&
+            e.Id == filter.Id && !e.IsFavorite && e.LastUsedUtc != null), Arg.Any<CancellationToken>());
+    }
+
     [Fact]
     public async Task HandleSetIsFavorite_True_SetsFavoriteClearsLastUsedAndPromotesOrigin()
     {
@@ -1868,8 +1841,8 @@ public async Task WriteGate_SerializesConcurrentPersistAndDispatchAsyncCalls()
         var task1 = effects.HandleSaveEntry(new SaveEntryAction(entry1.Id), dispatcher);
         var task2 = effects.HandleSaveEntry(new SaveEntryAction(entry2.Id), dispatcher);
 
-        await PollUntilAsync(() => Volatile.Read(ref totalCalls) == 1, TimeSpan.FromSeconds(2), TestContext.Current.CancellationToken);
-        await Task.Delay(150, TestContext.Current.CancellationToken);
+        await PollUntilAsync(() => Volatile.Read(ref totalCalls) == 1, s_shortTimeout, TestContext.Current.CancellationToken);
+        await Task.Delay(SettleDelayMilliseconds, TestContext.Current.CancellationToken);
 
         Assert.Equal(1, Volatile.Read(ref totalCalls));
 
@@ -1940,7 +1913,10 @@ private static (Effects effects, IFilterLibraryStore store, IDispatcher dispatch
         if (!storeWasSupplied)
         {
             store.LoadAllAsync(Arg.Any<CancellationToken>()).Returns([]);
-            store.UpdateRangeAsync(Arg.Any<IReadOnlyList<LibraryEntry>>(), Arg.Any<CancellationToken>()).ReturnsForAnyArgs(ci => ci.ArgAt<IReadOnlyList<LibraryEntry>>(0).Select(e => e.Id).ToList());
+            store.UpdateRangeAsync(Arg.Any<IReadOnlyList<LibraryEntry>>(), Arg.Any<CancellationToken>()).ReturnsForAnyArgs(ci =>
+            [
+                .. ci.ArgAt<IReadOnlyList<LibraryEntry>>(0).Select(e => e.Id)
+            ]);
         }
 
         var stateMock = Substitute.For<IState<FilterLibraryState>>();
@@ -1964,7 +1940,7 @@ private static (Effects effects, IFilterLibraryStore store, IDispatcher dispatch
 
         var logger = Substitute.For<ITraceLogger>();
         var dispatcher = Substitute.For<IDispatcher>();
-        var effects = new Effects(store, stateMock, paneStateMock, migrator, backslashMigrator, announcementService, logger);
+        var effects = new Effects(store, stateMock, paneStateMock, migrator, backslashMigrator, announcementService, logger, new TagBulkUpdateFailedNotifier(Substitute.For<ITraceLogger>()));
 
         return (effects, store, dispatcher, stateMock, migrator, logger);
     }
@@ -1975,11 +1951,10 @@ private static async Task PollUntilAsync(Func<bool> predicate, TimeSpan timeout,
         while (DateTime.UtcNow < deadline)
         {
             if (predicate()) { return; }
-            await Task.Delay(10, cancellationToken);
+            await Task.Delay(PollDelayMilliseconds, cancellationToken);
         }
         if (!predicate()) { throw new TimeoutException($"Predicate did not become true within {timeout}."); }
     }
 
-    // Used for the unknown-concrete-type wildcard test (covers the throw arm in HandleApplyLibraryEntry).
     private sealed record UnknownLibraryEntry : LibraryEntry;
 }
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/FilterLibrary/LibraryEntriesSourceTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/FilterLibrary/LibraryEntriesSourceTests.cs
new file mode 100644
index 000000000..5f887e150
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/FilterLibrary/LibraryEntriesSourceTests.cs
@@ -0,0 +1,117 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Logging.Abstractions;
+using EventLogExpert.Runtime.FilterLibrary;
+using Fluxor;
+using NSubstitute;
+using System.Collections.Immutable;
+
+namespace EventLogExpert.Runtime.Tests.FilterLibrary;
+
+public sealed class LibraryEntriesSourceTests
+{
+    private static readonly LibraryEntry AnEntry =
+        new LibraryEntryFilterSet { Name = "set", CreatedUtc = DateTimeOffset.UnixEpoch, Filters = [] };
+
+    [Fact]
+    public void AThrowingSubscriber_IsIsolatedFromOtherSubscribers()
+    {
+        var harness = new Harness(ImmutableList<LibraryEntry>.Empty);
+        var reachedSecond = 0;
+        harness.Source.Changed += () => throw new InvalidOperationException("subscriber blew up");
+        harness.Source.Changed += () => reachedSecond++;
+
+        harness.SetEntries(ImmutableList.Create(AnEntry));
+
+        Assert.Equal(1, reachedSecond);
+    }
+
+    [Fact]
+    public void Changed_DoesNotFire_WhenEntriesReferenceUnchanged()
+    {
+        var entries = ImmutableList.Create(AnEntry);
+        var harness = new Harness(entries);
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.SetState(new FilterLibraryState { Entries = entries, IsLoaded = true });
+
+        Assert.Equal(0, raised);
+        Assert.Same(entries, harness.Source.Current);
+    }
+
+    [Fact]
+    public void Changed_Fires_WhenEntriesInstanceChanges()
+    {
+        var harness = new Harness(ImmutableList<LibraryEntry>.Empty);
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        var next = ImmutableList.Create(AnEntry);
+        harness.SetEntries(next);
+
+        Assert.Equal(1, raised);
+        Assert.Same(next, harness.Source.Current);
+    }
+
+    [Fact]
+    public void Construction_AdoptsAChangeThatLandsBetweenSeedAndSubscribe()
+    {
+        // list (the reconcile), with no StateChanged raised in between.
+        var reconciled = ImmutableList.Create(AnEntry);
+        var state = Substitute.For<IState<FilterLibraryState>>();
+        state.Value.Returns(new FilterLibraryState(), new FilterLibraryState { Entries = reconciled });
+
+        using var source = new LibraryEntriesSource(state, Substitute.For<ITraceLogger>());
+
+        Assert.Same(reconciled, source.Current);
+    }
+
+    [Fact]
+    public void Current_ReflectsTheInitialState()
+    {
+        var entries = ImmutableList.Create(AnEntry);
+        var harness = new Harness(entries);
+
+        Assert.Same(entries, harness.Source.Current);
+    }
+
+    [Fact]
+    public void Dispose_StopsRaising()
+    {
+        var harness = new Harness(ImmutableList<LibraryEntry>.Empty);
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.Source.Dispose();
+        harness.SetEntries(ImmutableList.Create(AnEntry));
+
+        Assert.Equal(0, raised);
+    }
+
+    private sealed class Harness
+    {
+        private readonly IState<FilterLibraryState> _state = Substitute.For<IState<FilterLibraryState>>();
+
+        public Harness(ImmutableList<LibraryEntry> entries)
+        {
+            State = new FilterLibraryState { Entries = entries };
+            _state.Value.Returns(_ => State);
+            Source = new LibraryEntriesSource(_state, Substitute.For<ITraceLogger>());
+        }
+
+        public LibraryEntriesSource Source { get; }
+
+        public FilterLibraryState State { get; private set; }
+
+        public void SetEntries(ImmutableList<LibraryEntry> entries) =>
+            SetState(new FilterLibraryState { Entries = entries });
+
+        public void SetState(FilterLibraryState state)
+        {
+            State = state;
+            _state.StateChanged += Raise.Event<EventHandler>(_state, EventArgs.Empty);
+        }
+    }
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/FilterLibrary/LibraryLoadStatusSourceTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/FilterLibrary/LibraryLoadStatusSourceTests.cs
new file mode 100644
index 000000000..62af9361e
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/FilterLibrary/LibraryLoadStatusSourceTests.cs
@@ -0,0 +1,122 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Logging.Abstractions;
+using EventLogExpert.Runtime.FilterLibrary;
+using Fluxor;
+using NSubstitute;
+using System.Collections.Immutable;
+
+namespace EventLogExpert.Runtime.Tests.FilterLibrary;
+
+public sealed class LibraryLoadStatusSourceTests
+{
+    private static readonly LibraryEntry AnEntry =
+        new LibraryEntryFilterSet { Name = "set", CreatedUtc = DateTimeOffset.UnixEpoch, Filters = [] };
+
+    [Fact]
+    public void AThrowingSubscriber_IsIsolatedFromOtherSubscribers()
+    {
+        var harness = new Harness(new FilterLibraryState());
+        var reachedSecond = 0;
+        harness.Source.Changed += () => throw new InvalidOperationException("subscriber blew up");
+        harness.Source.Changed += () => reachedSecond++;
+
+        harness.SetState(new FilterLibraryState { IsLoaded = true });
+
+        Assert.Equal(1, reachedSecond);
+    }
+
+    [Fact]
+    public void Changed_DoesNotFire_WhenStatusUnchanged()
+    {
+        var harness = new Harness(new FilterLibraryState { IsLoaded = true });
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.SetState(new FilterLibraryState { IsLoaded = true, Entries = ImmutableList.Create(AnEntry) });
+
+        Assert.Equal(0, raised);
+    }
+
+    [Fact]
+    public void Changed_Fires_WhenIsLoadedFlips()
+    {
+        var harness = new Harness(new FilterLibraryState());
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.SetState(new FilterLibraryState { IsLoaded = true });
+
+        Assert.Equal(1, raised);
+        Assert.Equal(new LibraryLoadStatus(true, false), harness.Source.Current);
+    }
+
+    [Fact]
+    public void Changed_Fires_WhenLoadErrorFlips()
+    {
+        var harness = new Harness(new FilterLibraryState { IsLoaded = true });
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.SetState(new FilterLibraryState { IsLoaded = true, LoadError = true });
+
+        Assert.Equal(1, raised);
+        Assert.Equal(new LibraryLoadStatus(true, true), harness.Source.Current);
+    }
+
+    [Fact]
+    public void Construction_AdoptsAChangeThatLandsBetweenSeedAndSubscribe()
+    {
+        // loaded status (the reconcile), with no StateChanged raised in between.
+        var state = Substitute.For<IState<FilterLibraryState>>();
+        state.Value.Returns(new FilterLibraryState(), new FilterLibraryState { IsLoaded = true });
+
+        using var source = new LibraryLoadStatusSource(state, Substitute.For<ITraceLogger>());
+
+        Assert.Equal(new LibraryLoadStatus(true, false), source.Current);
+    }
+
+    [Fact]
+    public void Current_ReflectsTheInitialState()
+    {
+        var harness = new Harness(new FilterLibraryState { IsLoaded = true });
+
+        Assert.Equal(new LibraryLoadStatus(true, false), harness.Source.Current);
+    }
+
+    [Fact]
+    public void Dispose_StopsRaising()
+    {
+        var harness = new Harness(new FilterLibraryState());
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.Source.Dispose();
+        harness.SetState(new FilterLibraryState { IsLoaded = true });
+
+        Assert.Equal(0, raised);
+    }
+
+    private sealed class Harness
+    {
+        private readonly IState<FilterLibraryState> _state = Substitute.For<IState<FilterLibraryState>>();
+
+        public Harness(FilterLibraryState initial)
+        {
+            State = initial;
+            _state.Value.Returns(_ => State);
+            Source = new LibraryLoadStatusSource(_state, Substitute.For<ITraceLogger>());
+        }
+
+        public LibraryLoadStatusSource Source { get; }
+
+        public FilterLibraryState State { get; private set; }
+
+        public void SetState(FilterLibraryState state)
+        {
+            State = state;
+            _state.StateChanged += Raise.Event<EventHandler>(_state, EventArgs.Empty);
+        }
+    }
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/FilterLibrary/TagBulkUpdateFailedNotifierTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/FilterLibrary/TagBulkUpdateFailedNotifierTests.cs
new file mode 100644
index 000000000..79a7682bf
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/FilterLibrary/TagBulkUpdateFailedNotifierTests.cs
@@ -0,0 +1,44 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Logging.Abstractions;
+using EventLogExpert.Runtime.FilterLibrary;
+using NSubstitute;
+
+namespace EventLogExpert.Runtime.Tests.FilterLibrary;
+
+public sealed class TagBulkUpdateFailedNotifierTests
+{
+    [Fact]
+    public void Raise_InvokesSubscribers()
+    {
+        var notifier = new TagBulkUpdateFailedNotifier(Substitute.For<ITraceLogger>());
+        var raised = 0;
+        notifier.Failed += () => raised++;
+
+        notifier.Raise();
+
+        Assert.Equal(1, raised);
+    }
+
+    [Fact]
+    public void Raise_IsolatesAThrowingSubscriber()
+    {
+        var notifier = new TagBulkUpdateFailedNotifier(Substitute.For<ITraceLogger>());
+        var reachedSecond = 0;
+        notifier.Failed += () => throw new InvalidOperationException("subscriber blew up");
+        notifier.Failed += () => reachedSecond++;
+
+        notifier.Raise();
+
+        Assert.Equal(1, reachedSecond);
+    }
+
+    [Fact]
+    public void Raise_WithNoSubscribers_DoesNotThrow()
+    {
+        var notifier = new TagBulkUpdateFailedNotifier(Substitute.For<ITraceLogger>());
+
+        notifier.Raise();
+    }
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/FilterPane/ActiveFiltersSourceTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/FilterPane/ActiveFiltersSourceTests.cs
new file mode 100644
index 000000000..b8f6e14b5
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/FilterPane/ActiveFiltersSourceTests.cs
@@ -0,0 +1,118 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Filtering.Persistence;
+using EventLogExpert.Logging.Abstractions;
+using EventLogExpert.Runtime.FilterPane;
+using Fluxor;
+using NSubstitute;
+using System.Collections.Immutable;
+
+namespace EventLogExpert.Runtime.Tests.FilterPane;
+
+public sealed class ActiveFiltersSourceTests
+{
+    private static readonly SavedFilter AFilter =
+        new() { Color = HighlightColor.None, IsEnabled = true, ComparisonText = "Id == 1", Compiled = null! };
+
+    [Fact]
+    public void AThrowingSubscriber_IsIsolatedFromOtherSubscribers()
+    {
+        var harness = new Harness(ImmutableList<SavedFilter>.Empty);
+        var reachedSecond = 0;
+        harness.Source.Changed += () => throw new InvalidOperationException("subscriber blew up");
+        harness.Source.Changed += () => reachedSecond++;
+
+        harness.SetFilters(ImmutableList.Create(AFilter));
+
+        Assert.Equal(1, reachedSecond);
+    }
+
+    [Fact]
+    public void Changed_DoesNotFire_WhenFiltersReferenceUnchanged()
+    {
+        var filters = ImmutableList.Create(AFilter);
+        var harness = new Harness(filters);
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.SetState(new FilterPaneState { Filters = filters });
+
+        Assert.Equal(0, raised);
+        Assert.Same(filters, harness.Source.Current);
+    }
+
+    [Fact]
+    public void Changed_Fires_WhenFilterListInstanceChanges()
+    {
+        var harness = new Harness(ImmutableList<SavedFilter>.Empty);
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        var next = ImmutableList.Create(AFilter);
+        harness.SetFilters(next);
+
+        Assert.Equal(1, raised);
+        Assert.Same(next, harness.Source.Current);
+    }
+
+    [Fact]
+    public void Construction_AdoptsAChangeThatLandsBetweenSeedAndSubscribe()
+    {
+        // list (the reconcile), with no StateChanged raised in between.
+        var reconciled = ImmutableList.Create(AFilter);
+        var state = Substitute.For<IState<FilterPaneState>>();
+        state.Value.Returns(new FilterPaneState(), new FilterPaneState { Filters = reconciled });
+
+        using var source = new ActiveFiltersSource(state, Substitute.For<ITraceLogger>());
+
+        Assert.Same(reconciled, source.Current);
+    }
+
+    [Fact]
+    public void Current_ReflectsTheInitialState()
+    {
+        var filters = ImmutableList.Create(AFilter);
+        var harness = new Harness(filters);
+
+        Assert.Same(filters, harness.Source.Current);
+    }
+
+    [Fact]
+    public void Dispose_StopsRaising()
+    {
+        var harness = new Harness(ImmutableList<SavedFilter>.Empty);
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.Source.Dispose();
+        harness.SetFilters(ImmutableList.Create(AFilter));
+
+        Assert.Equal(0, raised);
+    }
+
+    private sealed class Harness
+    {
+        private readonly IState<FilterPaneState> _state = Substitute.For<IState<FilterPaneState>>();
+
+        public Harness(ImmutableList<SavedFilter> filters)
+        {
+            State = new FilterPaneState { Filters = filters };
+            _state.Value.Returns(_ => State);
+            Source = new ActiveFiltersSource(_state, Substitute.For<ITraceLogger>());
+        }
+
+        public ActiveFiltersSource Source { get; }
+
+        public FilterPaneState State { get; private set; }
+
+        public void SetFilters(ImmutableList<SavedFilter> filters) =>
+            SetState(new FilterPaneState { Filters = filters });
+
+        public void SetState(FilterPaneState state)
+        {
+            State = state;
+            _state.StateChanged += Raise.Event<EventHandler>(_state, EventArgs.Empty);
+        }
+    }
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/FilterPane/ClearAllFiltersNotifierTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/FilterPane/ClearAllFiltersNotifierTests.cs
new file mode 100644
index 000000000..87512c5c4
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/FilterPane/ClearAllFiltersNotifierTests.cs
@@ -0,0 +1,44 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Logging.Abstractions;
+using EventLogExpert.Runtime.FilterPane;
+using NSubstitute;
+
+namespace EventLogExpert.Runtime.Tests.FilterPane;
+
+public sealed class ClearAllFiltersNotifierTests
+{
+    [Fact]
+    public void Raise_InvokesSubscribers()
+    {
+        var notifier = new ClearAllFiltersNotifier(Substitute.For<ITraceLogger>());
+        var raised = 0;
+        notifier.Requested += () => raised++;
+
+        notifier.Raise();
+
+        Assert.Equal(1, raised);
+    }
+
+    [Fact]
+    public void Raise_IsolatesAThrowingSubscriber()
+    {
+        var notifier = new ClearAllFiltersNotifier(Substitute.For<ITraceLogger>());
+        var reachedSecond = 0;
+        notifier.Requested += () => throw new InvalidOperationException("subscriber blew up");
+        notifier.Requested += () => reachedSecond++;
+
+        notifier.Raise();
+
+        Assert.Equal(1, reachedSecond);
+    }
+
+    [Fact]
+    public void Raise_WithNoSubscribers_DoesNotThrow()
+    {
+        var notifier = new ClearAllFiltersNotifier(Substitute.For<ITraceLogger>());
+
+        notifier.Raise();
+    }
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/FilterPane/EffectsTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/FilterPane/EffectsTests.cs
index db7fef901..02542ba9f 100644
--- a/tests/Unit/EventLogExpert.Runtime.Tests/FilterPane/EffectsTests.cs
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/FilterPane/EffectsTests.cs
@@ -7,11 +7,11 @@
 using EventLogExpert.Filtering.Persistence;
 using EventLogExpert.Filtering.TestUtils;
 using EventLogExpert.Filtering.TestUtils.Constants;
+using EventLogExpert.Logging.Abstractions;
 using EventLogExpert.Runtime.EventLog;
 using EventLogExpert.Runtime.FilterLenses;
 using EventLogExpert.Runtime.FilterLibrary;
 using EventLogExpert.Runtime.FilterPane;
-using EventLogExpert.Runtime.FilterProgress;
 using EventLogExpert.Runtime.LogTable;
 using EventLogExpert.Runtime.Tests.TestUtils.Constants;
 using Fluxor;
@@ -27,24 +27,19 @@ public sealed class EffectsTests
     [Fact]
     public async Task HandleAddFilter_WhenComparisonValueExists_ShouldUpdateEventTableFilters()
     {
-        // Arrange
         var filterModel = FilterBuilder.CreateTestFilter(isEnabled: true);
 
         var (effects, mockDispatcher) = CreateEffects(true, ImmutableList.Create(filterModel));
         var action = new AddFilterAction(filterModel);
 
-        // Act
         await effects.HandleAddFilter(action, mockDispatcher);
 
-        // Assert
         mockDispatcher.Received().Dispatch(Arg.Any<ApplyFilterAction>());
-        mockDispatcher.DidNotReceive().Dispatch(Arg.Any<SetFilterProgressAction>());
     }
 
     [Fact]
     public async Task HandleAddFilter_WhenComparisonValueIsNull_ShouldNotUpdateEventTableFilters()
     {
-        // Arrange
         var filterModel = new SavedFilter
         {
             ComparisonText = string.Empty,
@@ -54,26 +49,21 @@ public async Task HandleAddFilter_WhenComparisonValueIsNull_ShouldNotUpdateEvent
         var (effects, mockDispatcher) = CreateEffects();
         var action = new AddFilterAction(filterModel);
 
-        // Act
         await effects.HandleAddFilter(action, mockDispatcher);
 
-        // Assert
         mockDispatcher.DidNotReceive().Dispatch(Arg.Any<ApplyFilterAction>());
     }
 
     [Fact]
     public async Task HandleAddFilter_WhenFilterHasBasicFilter_ShouldRecordFilterApplied()
     {
-        // Arrange
         var filterModel = FilterBuilder.CreateTestFilter(basicFilter: CreateBasicFilter());
 
         var (effects, mockDispatcher) = CreateEffects();
         var action = new AddFilterAction(filterModel);
 
-        // Act
         await effects.HandleAddFilter(action, mockDispatcher);
 
-        // Assert
         mockDispatcher.Received(1).Dispatch(Arg.Is<RecordFilterAppliedAction>(x =>
             x != null &&
             x.Filter.ComparisonText == FilterTestConstants.FilterIdEquals100));
@@ -82,33 +72,53 @@ public async Task HandleAddFilter_WhenFilterHasBasicFilter_ShouldRecordFilterApp
     [Fact]
     public async Task HandleAddFilter_WhenFilterHasNoBasicFilter_ShouldRecordFilterApplied()
     {
-        // Arrange
         var filterModel = FilterBuilder.CreateTestFilter();
 
         var (effects, mockDispatcher) = CreateEffects();
         var action = new AddFilterAction(filterModel);
 
-        // Act
         await effects.HandleAddFilter(action, mockDispatcher);
 
-        // Assert
         mockDispatcher.Received(1).Dispatch(Arg.Is<RecordFilterAppliedAction>(x =>
             x != null &&
             x.Filter.ComparisonText == FilterTestConstants.FilterIdEquals100));
     }
 
+    [Fact]
+    public async Task HandleClearAllFilters_RaisesTheNotifierOncePerDispatch()
+    {
+        var filterPaneState = Substitute.For<IState<FilterPaneState>>();
+        filterPaneState.Value.Returns(new FilterPaneState());
+        var appliedFilter = Substitute.For<IStateSelection<EventLogState, Filter>>();
+        appliedFilter.Value.Returns(new Filter(null, []));
+        var rawEventStore = Substitute.For<IState<RawEventStoreState>>();
+        rawEventStore.Value.Returns(new RawEventStoreState());
+        var lensState = Substitute.For<IState<FilterLensState>>();
+        lensState.Value.Returns(new FilterLensState());
+
+        var notifier = new ClearAllFiltersNotifier(Substitute.For<ITraceLogger>());
+        var raised = 0;
+        notifier.Requested += () => raised++;
+
+        var effects = new Effects(
+            appliedFilter, rawEventStore, filterPaneState, lensState,
+            notifier, new SetFilterDateRangeSucceededNotifier(Substitute.For<ITraceLogger>()));
+
+        await effects.HandleClearAllFilters(Substitute.For<IDispatcher>());
+        await effects.HandleClearAllFilters(Substitute.For<IDispatcher>());
+
+        Assert.Equal(2, raised);
+    }
+
     [Fact]
     public async Task HandleClearAllFilters_ShouldUpdateEventTableFilters()
     {
-        // Arrange
         var (effects, mockDispatcher) = CreateEffects(
             true,
             appliedFilter: new Filter(null, CreateSingleEnabledFilters()));
 
-        // Act
         await effects.HandleClearAllFilters(mockDispatcher);
 
-        // Assert
         mockDispatcher.Received(1).Dispatch(Arg.Any<ApplyFilterAction>());
     }
 
@@ -125,74 +135,57 @@ public async Task HandleMergeFilters_ShouldUpdateEventTableFilters()
     [Fact]
     public async Task HandleRemoveAdvancedFilter_ShouldUpdateEventTableFilters()
     {
-        // Arrange
         var (effects, mockDispatcher) = CreateEffects(
             true,
             appliedFilter: new Filter(null, CreateSingleEnabledFilters()));
 
-        // Act
         await effects.HandleRemoveAdvancedFilter(mockDispatcher);
 
-        // Assert
         mockDispatcher.Received(1).Dispatch(Arg.Any<ApplyFilterAction>());
     }
 
     [Fact]
-    public async Task HandleSetFilter_ShouldUpdateEventTableFilters()
+    public async Task HandleSetFilterDateRangeSuccess_RaisesTheNotifierOncePerDispatch()
     {
-        // Arrange
-        var filterModel = FilterBuilder.CreateTestFilter(isEnabled: true);
-
-        var (effects, mockDispatcher) = CreateEffects(true, ImmutableList.Create(filterModel));
-        var action = new SetFilterAction(filterModel);
-
-        // Act
-        await effects.HandleSetFilter(action, mockDispatcher);
-
-        // Assert
-        mockDispatcher.Received(1).Dispatch(Arg.Any<ApplyFilterAction>());
+        var filterPaneState = Substitute.For<IState<FilterPaneState>>();
+        filterPaneState.Value.Returns(new FilterPaneState());
+        var appliedFilter = Substitute.For<IStateSelection<EventLogState, Filter>>();
+        appliedFilter.Value.Returns(new Filter(null, []));
+        var rawEventStore = Substitute.For<IState<RawEventStoreState>>();
+        rawEventStore.Value.Returns(new RawEventStoreState());
+        var lensState = Substitute.For<IState<FilterLensState>>();
+        lensState.Value.Returns(new FilterLensState());
+
+        var notifier = new SetFilterDateRangeSucceededNotifier(Substitute.For<ITraceLogger>());
+        var raised = 0;
+        notifier.Succeeded += () => raised++;
+
+        var effects = new Effects(
+            appliedFilter, rawEventStore, filterPaneState, lensState,
+            new ClearAllFiltersNotifier(Substitute.For<ITraceLogger>()), notifier);
+
+        await effects.HandleSetFilterDateRangeSuccess(Substitute.For<IDispatcher>());
+        await effects.HandleSetFilterDateRangeSuccess(Substitute.For<IDispatcher>());
+
+        Assert.Equal(2, raised);
     }
 
     [Fact]
-    public async Task HandleSetFilter_WhenFilterHasBasicFilter_ShouldRecordFilterApplied()
-    {
-        // Arrange
-        var filterModel = FilterBuilder.CreateTestFilter(basicFilter: CreateBasicFilter());
-
-        var (effects, mockDispatcher) = CreateEffects();
-        var action = new SetFilterAction(filterModel);
-
-        // Act
-        await effects.HandleSetFilter(action, mockDispatcher);
-
-        // Assert
-        mockDispatcher.Received(1).Dispatch(Arg.Is<RecordFilterAppliedAction>(x =>
-            x != null &&
-            x.Filter.ComparisonText == FilterTestConstants.FilterIdEquals100));
-    }
-
-    [Fact]
-    public async Task HandleSetFilter_WhenFilterHasNoBasicFilter_ShouldRecordFilterApplied()
+    public async Task HandleSetFilterDateRangeSuccess_ShouldUpdateEventTableFilters()
     {
-        // Arrange
-        var filterModel = FilterBuilder.CreateTestFilter();
+        var filterModel = FilterBuilder.CreateTestFilter(isEnabled: true);
 
-        var (effects, mockDispatcher) = CreateEffects();
+        var (effects, mockDispatcher) = CreateEffects(true, ImmutableList.Create(filterModel));
         var action = new SetFilterAction(filterModel);
 
-        // Act
-        await effects.HandleSetFilter(action, mockDispatcher);
+        await effects.HandleSetFilterDateRangeSuccess(mockDispatcher);
 
-        // Assert
-        mockDispatcher.Received(1).Dispatch(Arg.Is<RecordFilterAppliedAction>(x =>
-            x != null &&
-            x.Filter.ComparisonText == FilterTestConstants.FilterIdEquals100));
+        mockDispatcher.Received(1).Dispatch(Arg.Any<ApplyFilterAction>());
     }
 
     [Fact]
     public async Task HandleSetFilterDateRange_WhenAfterIsNull_ShouldUseRangeFromActiveLogs()
     {
-        // Arrange
         var oldest = new DateTime(2024, 1, 1, 8, 30, 45, DateTimeKind.Utc);
         var newest = new DateTime(2024, 1, 1, 14, 15, 0, DateTimeKind.Utc);
         var unrelatedBefore = new DateTime(2024, 1, 1, 23, 0, 0, DateTimeKind.Utc);
@@ -208,10 +201,8 @@ public async Task HandleSetFilterDateRange_WhenAfterIsNull_ShouldUseRangeFromAct
         var (effects, mockDispatcher) = CreateEffects(logsWithEvents: [(logData, events)]);
         var action = new SetFilterDateRangeAction(new DateFilter { Before = unrelatedBefore });
 
-        // Act
         await effects.HandleSetFilterDateRange(action, mockDispatcher);
 
-        // Assert
         var expectedAfter = new DateTime(2024, 1, 1, 8, 0, 0, DateTimeKind.Utc);
         mockDispatcher.Received(1).Dispatch(Arg.Is<SetFilterDateRangeSuccessAction>(x =>
             x != null &&
@@ -223,7 +214,6 @@ public async Task HandleSetFilterDateRange_WhenAfterIsNull_ShouldUseRangeFromAct
     [Fact]
     public async Task HandleSetFilterDateRange_WhenBeforeIsNull_ShouldUseRangeFromActiveLogs()
     {
-        // Arrange
         var oldest = new DateTime(2024, 1, 1, 8, 30, 45, DateTimeKind.Utc);
         var newest = new DateTime(2024, 1, 1, 14, 15, 0, DateTimeKind.Utc);
         var unrelatedAfter = new DateTime(2023, 12, 1, 0, 0, 0, DateTimeKind.Utc);
@@ -239,10 +229,8 @@ public async Task HandleSetFilterDateRange_WhenBeforeIsNull_ShouldUseRangeFromAc
         var (effects, mockDispatcher) = CreateEffects(logsWithEvents: [(logData, events)]);
         var action = new SetFilterDateRangeAction(new DateFilter { After = unrelatedAfter });
 
-        // Act
         await effects.HandleSetFilterDateRange(action, mockDispatcher);
 
-        // Assert
         var expectedBefore = new DateTime(2024, 1, 1, 15, 0, 0, DateTimeKind.Utc);
         mockDispatcher.Received(1).Dispatch(Arg.Is<SetFilterDateRangeSuccessAction>(x =>
             x != null &&
@@ -254,7 +242,6 @@ public async Task HandleSetFilterDateRange_WhenBeforeIsNull_ShouldUseRangeFromAc
     [Fact]
     public async Task HandleSetFilterDateRange_WhenBothNullAcrossMultipleLogs_ShouldComputeRange()
     {
-        // Arrange
         var logAOldest = new DateTime(2024, 1, 1, 4, 0, 0, DateTimeKind.Utc);
         var logANewest = new DateTime(2024, 1, 1, 6, 0, 0, DateTimeKind.Utc);
         var logBOldest = new DateTime(2024, 1, 5, 20, 0, 0, DateTimeKind.Utc);
@@ -282,10 +269,8 @@ public async Task HandleSetFilterDateRange_WhenBothNullAcrossMultipleLogs_Should
         var (effects, mockDispatcher) = CreateEffects(logsWithEvents: [(logA, eventsA), (logB, eventsB)]);
         var action = new SetFilterDateRangeAction(new DateFilter());
 
-        // Act
         await effects.HandleSetFilterDateRange(action, mockDispatcher);
 
-        // Assert
         mockDispatcher.Received(1).Dispatch(Arg.Is<SetFilterDateRangeSuccessAction>(x =>
             x != null &&
             x.DateFilter != null &&
@@ -296,17 +281,14 @@ public async Task HandleSetFilterDateRange_WhenBothNullAcrossMultipleLogs_Should
     [Fact]
     public async Task HandleSetFilterDateRange_WhenBothProvided_ShouldUseProvidedValues()
     {
-        // Arrange
         var after = new DateTime(2024, 1, 1, 10, 0, 0, DateTimeKind.Utc);
         var before = new DateTime(2024, 1, 1, 14, 0, 0, DateTimeKind.Utc);
 
         var (effects, mockDispatcher) = CreateEffects();
         var action = new SetFilterDateRangeAction(new DateFilter { After = after, Before = before });
 
-        // Act
         await effects.HandleSetFilterDateRange(action, mockDispatcher);
 
-        // Assert
         mockDispatcher.Received(1).Dispatch(Arg.Is<SetFilterDateRangeSuccessAction>(x =>
             x != null &&
             x.DateFilter != null &&
@@ -317,7 +299,6 @@ public async Task HandleSetFilterDateRange_WhenBothProvided_ShouldUseProvidedVal
     [Fact]
     public async Task HandleSetFilterDateRange_WhenExistingDateRangeHasAfter_ShouldUseExistingAfter()
     {
-        // Arrange
         var existingAfter = new DateTime(2024, 1, 1, 8, 0, 0, DateTimeKind.Utc);
         var newBefore = new DateTime(2024, 1, 1, 16, 0, 0, DateTimeKind.Utc);
 
@@ -326,10 +307,8 @@ public async Task HandleSetFilterDateRange_WhenExistingDateRangeHasAfter_ShouldU
 
         var action = new SetFilterDateRangeAction(new DateFilter { Before = newBefore });
 
-        // Act
         await effects.HandleSetFilterDateRange(action, mockDispatcher);
 
-        // Assert
         mockDispatcher.Received(1).Dispatch(Arg.Is<SetFilterDateRangeSuccessAction>(x =>
             x != null &&
             x.DateFilter != null &&
@@ -340,7 +319,6 @@ public async Task HandleSetFilterDateRange_WhenExistingDateRangeHasAfter_ShouldU
     [Fact]
     public async Task HandleSetFilterDateRange_WhenExistingDateRangeHasBefore_ShouldUseExistingBefore()
     {
-        // Arrange
         var existingBefore = new DateTime(2024, 1, 1, 16, 0, 0, DateTimeKind.Utc);
         var newAfter = new DateTime(2024, 1, 1, 8, 0, 0, DateTimeKind.Utc);
 
@@ -349,10 +327,8 @@ public async Task HandleSetFilterDateRange_WhenExistingDateRangeHasBefore_Should
 
         var action = new SetFilterDateRangeAction(new DateFilter { After = newAfter });
 
-        // Act
         await effects.HandleSetFilterDateRange(action, mockDispatcher);
 
-        // Assert
         mockDispatcher.Received(1).Dispatch(Arg.Is<SetFilterDateRangeSuccessAction>(x =>
             x != null &&
             x.DateFilter != null &&
@@ -363,39 +339,62 @@ public async Task HandleSetFilterDateRange_WhenExistingDateRangeHasBefore_Should
     [Fact]
     public async Task HandleSetFilterDateRange_WhenFilterDateModelIsNull_ShouldDispatchSuccessWithNull()
     {
-        // Arrange
         var (effects, mockDispatcher) = CreateEffects();
         var action = new SetFilterDateRangeAction(null);
 
-        // Act
         await effects.HandleSetFilterDateRange(action, mockDispatcher);
 
-        // Assert
         mockDispatcher.Received(1).Dispatch(Arg.Is<SetFilterDateRangeSuccessAction>(x =>
             x != null &&
             x.DateFilter == null));
     }
 
     [Fact]
-    public async Task HandleSetFilterDateRangeSuccess_ShouldUpdateEventTableFilters()
+    public async Task HandleSetFilter_ShouldUpdateEventTableFilters()
     {
-        // Arrange
         var filterModel = FilterBuilder.CreateTestFilter(isEnabled: true);
 
         var (effects, mockDispatcher) = CreateEffects(true, ImmutableList.Create(filterModel));
         var action = new SetFilterAction(filterModel);
 
-        // Act
-        await effects.HandleSetFilterDateRangeSuccess(mockDispatcher);
+        await effects.HandleSetFilter(action, mockDispatcher);
 
-        // Assert
         mockDispatcher.Received(1).Dispatch(Arg.Any<ApplyFilterAction>());
     }
 
+    [Fact]
+    public async Task HandleSetFilter_WhenFilterHasBasicFilter_ShouldRecordFilterApplied()
+    {
+        var filterModel = FilterBuilder.CreateTestFilter(basicFilter: CreateBasicFilter());
+
+        var (effects, mockDispatcher) = CreateEffects();
+        var action = new SetFilterAction(filterModel);
+
+        await effects.HandleSetFilter(action, mockDispatcher);
+
+        mockDispatcher.Received(1).Dispatch(Arg.Is<RecordFilterAppliedAction>(x =>
+            x != null &&
+            x.Filter.ComparisonText == FilterTestConstants.FilterIdEquals100));
+    }
+
+    [Fact]
+    public async Task HandleSetFilter_WhenFilterHasNoBasicFilter_ShouldRecordFilterApplied()
+    {
+        var filterModel = FilterBuilder.CreateTestFilter();
+
+        var (effects, mockDispatcher) = CreateEffects();
+        var action = new SetFilterAction(filterModel);
+
+        await effects.HandleSetFilter(action, mockDispatcher);
+
+        mockDispatcher.Received(1).Dispatch(Arg.Is<RecordFilterAppliedAction>(x =>
+            x != null &&
+            x.Filter.ComparisonText == FilterTestConstants.FilterIdEquals100));
+    }
+
     [Fact]
     public async Task HandleToggleFilterDate_ShouldUpdateEventTableFilters()
     {
-        // Arrange
         var (effects, mockDispatcher) = CreateEffects(
             true,
             filteredDateRange: new DateFilter
@@ -404,56 +403,44 @@ public async Task HandleToggleFilterDate_ShouldUpdateEventTableFilters()
                 Before = new DateTime(2024, 1, 2, 0, 0, 0, DateTimeKind.Utc)
             });
 
-        // Act
         await effects.HandleToggleFilterDate(mockDispatcher);
 
-        // Assert
         mockDispatcher.Received(1).Dispatch(Arg.Any<ApplyFilterAction>());
     }
 
     [Fact]
     public async Task HandleToggleFilterEnabled_ShouldUpdateEventTableFilters()
     {
-        // Arrange
         var (effects, mockDispatcher) = CreateEffects(true, CreateSingleEnabledFilters());
 
-        // Act
         await effects.HandleToggleFilterEnabled(mockDispatcher);
 
-        // Assert
         mockDispatcher.Received(1).Dispatch(Arg.Any<ApplyFilterAction>());
     }
 
     [Fact]
     public async Task HandleToggleFilterExcluded_ShouldUpdateEventTableFilters()
     {
-        // Arrange
         var (effects, mockDispatcher) = CreateEffects(true, CreateSingleEnabledFilters());
 
-        // Act
         await effects.HandleToggleFilterExcluded(mockDispatcher);
 
-        // Assert
         mockDispatcher.Received(1).Dispatch(Arg.Any<ApplyFilterAction>());
     }
 
     [Fact]
     public async Task HandleToggleIsEnabled_ShouldUpdateEventTableFilters()
     {
-        // Arrange
         var (effects, mockDispatcher) = CreateEffects(true, CreateSingleEnabledFilters());
 
-        // Act
         await effects.HandleToggleIsEnabled(mockDispatcher);
 
-        // Assert
         mockDispatcher.Received(1).Dispatch(Arg.Any<ApplyFilterAction>());
     }
 
     [Fact]
     public async Task UpdateEventTableFilters_WhenEquivalentFiltersFromDifferentInstances_ShouldNotDispatch()
     {
-        // Arrange
         var paneFilters = ImmutableList.Create(
             FilterBuilder.CreateTestFilter(isEnabled: true,
                 isExcluded: false));
@@ -467,17 +454,14 @@ public async Task UpdateEventTableFilters_WhenEquivalentFiltersFromDifferentInst
             paneFilters,
             appliedFilter: new Filter(null, appliedFilters));
 
-        // Act
         await effects.HandleToggleIsEnabled(mockDispatcher);
 
-        // Assert
         mockDispatcher.DidNotReceive().Dispatch(Arg.Any<ApplyFilterAction>());
     }
 
     [Fact]
     public async Task UpdateEventTableFilters_WhenFilterPaneDisabled_ShouldOnlyKeepExcludedFilters()
     {
-        // Arrange
         var filters = ImmutableList.Create(
             FilterBuilder.CreateTestFilter(isEnabled: true,
                 isExcluded: false),
@@ -488,10 +472,8 @@ public async Task UpdateEventTableFilters_WhenFilterPaneDisabled_ShouldOnlyKeepE
 
         var (effects, mockDispatcher) = CreateEffects(false, filters);
 
-        // Act
         await effects.HandleToggleIsEnabled(mockDispatcher);
 
-        // Assert
         mockDispatcher.Received(1).Dispatch(Arg.Is<ApplyFilterAction>(x =>
             x != null &&
             x.Filter.Filters.Count == 1 &&
@@ -501,7 +483,6 @@ public async Task UpdateEventTableFilters_WhenFilterPaneDisabled_ShouldOnlyKeepE
     [Fact]
     public async Task UpdateEventTableFilters_WhenFilterPaneEnabled_ShouldIncludeEnabledFilters()
     {
-        // Arrange
         var filters = ImmutableList.Create(
             FilterBuilder.CreateTestFilter(isEnabled: true,
                 isExcluded: false),
@@ -512,10 +493,8 @@ public async Task UpdateEventTableFilters_WhenFilterPaneEnabled_ShouldIncludeEna
 
         var (effects, mockDispatcher) = CreateEffects(true, filters);
 
-        // Act
         await effects.HandleToggleIsEnabled(mockDispatcher);
 
-        // Assert
         mockDispatcher.Received(1).Dispatch(Arg.Is<ApplyFilterAction>(x =>
             x != null &&
             x.Filter.Filters.Count == 1 &&
@@ -525,18 +504,14 @@ public async Task UpdateEventTableFilters_WhenFilterPaneEnabled_ShouldIncludeEna
     [Fact]
     public async Task UpdateEventTableFilters_WhenFilterUnchanged_ShouldNotDispatch()
     {
-        // Arrange
         var filters = CreateSingleEnabledFilters();
         var (effects, mockDispatcher) = CreateEffects(
             true,
             filters,
             appliedFilter: new Filter(null, filters));
 
-        // Act
         await effects.HandleToggleIsEnabled(mockDispatcher);
 
-        // Assert
-        mockDispatcher.DidNotReceive().Dispatch(Arg.Any<SetFilterProgressAction>());
         mockDispatcher.DidNotReceive().Dispatch(Arg.Any<ApplyFilterAction>());
     }
 
@@ -589,7 +564,7 @@ private static (Effects effects, IDispatcher mockDispatcher) CreateEffects(
         var mockLensState = Substitute.For<IState<FilterLensState>>();
         mockLensState.Value.Returns(new FilterLensState());
 
-        var effects = new Effects(mockAppliedFilter, mockRawEventStore, mockFilterPaneState, mockLensState);
+        var effects = new Effects(mockAppliedFilter, mockRawEventStore, mockFilterPaneState, mockLensState, new ClearAllFiltersNotifier(Substitute.For<ITraceLogger>()), new SetFilterDateRangeSucceededNotifier(Substitute.For<ITraceLogger>()));
         var mockDispatcher = Substitute.For<IDispatcher>();
 
         return (effects, mockDispatcher);
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/FilterPane/FilterPaneQueriesTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/FilterPane/FilterPaneQueriesTests.cs
new file mode 100644
index 000000000..2542070af
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/FilterPane/FilterPaneQueriesTests.cs
@@ -0,0 +1,38 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Runtime.FilterPane;
+using Fluxor;
+using NSubstitute;
+
+namespace EventLogExpert.Runtime.Tests.FilterPane;
+
+public sealed class FilterPaneQueriesTests
+{
+    [Fact]
+    public void IsEnabled_ReadsIsEnabled_NotIsFilteringEnabled()
+    {
+        var state = new FilterPaneState { IsEnabled = true, Filters = [] };
+
+        Assert.True(new FilterPaneQueries(StateReturning(state)).IsEnabled());
+        Assert.False(state.IsFilteringEnabled);
+    }
+
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public void IsEnabled_ReflectsTheMasterToggle(bool enabled)
+    {
+        var queries = new FilterPaneQueries(StateReturning(new FilterPaneState { IsEnabled = enabled }));
+
+        Assert.Equal(enabled, queries.IsEnabled());
+    }
+
+    private static IState<FilterPaneState> StateReturning(FilterPaneState state)
+    {
+        var stateMock = Substitute.For<IState<FilterPaneState>>();
+        stateMock.Value.Returns(state);
+
+        return stateMock;
+    }
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/FilterPane/FilteredDateRangeSourceTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/FilterPane/FilteredDateRangeSourceTests.cs
new file mode 100644
index 000000000..fd7484957
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/FilterPane/FilteredDateRangeSourceTests.cs
@@ -0,0 +1,119 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Logging.Abstractions;
+using EventLogExpert.Runtime.FilterPane;
+using Fluxor;
+using NSubstitute;
+
+namespace EventLogExpert.Runtime.Tests.FilterPane;
+
+public sealed class FilteredDateRangeSourceTests
+{
+    private static readonly DateFilter ARange = new() { After = DateTimeOffset.UnixEpoch.UtcDateTime };
+
+    [Fact]
+    public void AThrowingSubscriber_IsIsolatedFromOtherSubscribers()
+    {
+        var harness = new Harness(new FilterPaneState());
+        var reachedSecond = 0;
+        harness.Source.Changed += () => throw new InvalidOperationException("subscriber blew up");
+        harness.Source.Changed += () => reachedSecond++;
+
+        harness.SetState(new FilterPaneState { FilteredDateRange = ARange });
+
+        Assert.Equal(1, reachedSecond);
+    }
+
+    [Fact]
+    public void Changed_DoesNotFire_WhenRangeValueUnchanged()
+    {
+        var harness = new Harness(new FilterPaneState { FilteredDateRange = new DateFilter { After = ARange.After } });
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.SetState(new FilterPaneState { FilteredDateRange = new DateFilter { After = ARange.After } });
+
+        Assert.Equal(0, raised);
+    }
+
+    [Fact]
+    public void Changed_Fires_WhenRangeChanges()
+    {
+        var harness = new Harness(new FilterPaneState());
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.SetState(new FilterPaneState { FilteredDateRange = ARange });
+
+        Assert.Equal(1, raised);
+        Assert.Equal(ARange, harness.Source.Current);
+    }
+
+    [Fact]
+    public void Changed_Fires_WhenRangeCleared()
+    {
+        var harness = new Harness(new FilterPaneState { FilteredDateRange = ARange });
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.SetState(new FilterPaneState());
+
+        Assert.Equal(1, raised);
+        Assert.Null(harness.Source.Current);
+    }
+
+    [Fact]
+    public void Construction_AdoptsAChangeThatLandsBetweenSeedAndSubscribe()
+    {
+        var state = Substitute.For<IState<FilterPaneState>>();
+        state.Value.Returns(new FilterPaneState(), new FilterPaneState { FilteredDateRange = ARange });
+
+        using var source = new FilteredDateRangeSource(state, Substitute.For<ITraceLogger>());
+
+        Assert.Equal(ARange, source.Current);
+    }
+
+    [Fact]
+    public void Current_ReflectsTheInitialState()
+    {
+        var harness = new Harness(new FilterPaneState { FilteredDateRange = ARange });
+
+        Assert.Equal(ARange, harness.Source.Current);
+    }
+
+    [Fact]
+    public void Dispose_StopsRaising()
+    {
+        var harness = new Harness(new FilterPaneState());
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.Source.Dispose();
+        harness.SetState(new FilterPaneState { FilteredDateRange = ARange });
+
+        Assert.Equal(0, raised);
+    }
+
+    private sealed class Harness
+    {
+        private readonly IState<FilterPaneState> _state = Substitute.For<IState<FilterPaneState>>();
+
+        public Harness(FilterPaneState initial)
+        {
+            State = initial;
+            _state.Value.Returns(_ => State);
+            Source = new FilteredDateRangeSource(_state, Substitute.For<ITraceLogger>());
+        }
+
+        public FilteredDateRangeSource Source { get; }
+
+        public FilterPaneState State { get; private set; }
+
+        public void SetState(FilterPaneState state)
+        {
+            State = state;
+            _state.StateChanged += Raise.Event<EventHandler>(_state, EventArgs.Empty);
+        }
+    }
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/FilterPane/ReplaceFiltersTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/FilterPane/ReplaceFiltersTests.cs
index e8b17ce65..f0157294d 100644
--- a/tests/Unit/EventLogExpert.Runtime.Tests/FilterPane/ReplaceFiltersTests.cs
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/FilterPane/ReplaceFiltersTests.cs
@@ -3,6 +3,7 @@
 
 using EventLogExpert.Filtering.Persistence;
 using EventLogExpert.Filtering.TestUtils;
+using EventLogExpert.Logging.Abstractions;
 using EventLogExpert.Runtime.EventLog;
 using EventLogExpert.Runtime.FilterLenses;
 using EventLogExpert.Runtime.FilterPane;
@@ -20,34 +21,27 @@ public sealed class ReplaceFiltersTests
     [Fact]
     public async Task HandleReplaceFilters_DispatchesUpdateEventTableFilters()
     {
-        // Arrange
         var (effects, dispatcher) = CreateEffects(isEnabled: true, filters: [FilterBuilder.CreateTestFilter(isEnabled: true)]);
 
-        // Act
         await effects.HandleReplaceFilters(dispatcher);
 
-        // Assert
         dispatcher.Received(1).Dispatch(Arg.Any<ApplyFilterAction>());
     }
 
     [Fact]
     public void ReduceReplaceFilters_AssignsFreshIds()
     {
-        // Arrange
         var input = FilterBuilder.CreateTestFilter();
         var action = new ReplaceFiltersAction([input]);
 
-        // Act
         var result = Reducers.ReduceReplaceFilters(new FilterPaneState(), action);
 
-        // Assert
         Assert.NotEqual(input.Id, result.Filters[0].Id);
     }
 
     [Fact]
     public void ReduceReplaceFilters_PreservesOtherStateFields()
     {
-        // Arrange
         var initialState = new FilterPaneState
         {
             IsEnabled = false,
@@ -61,10 +55,8 @@ public void ReduceReplaceFilters_PreservesOtherStateFields()
 
         var action = new ReplaceFiltersAction([FilterBuilder.CreateTestFilter()]);
 
-        // Act
         var result = Reducers.ReduceReplaceFilters(initialState, action);
 
-        // Assert
         Assert.False(result.IsEnabled);
         Assert.Equal(initialState.FilteredDateRange, result.FilteredDateRange);
     }
@@ -72,17 +64,14 @@ public void ReduceReplaceFilters_PreservesOtherStateFields()
     [Fact]
     public void ReduceReplaceFilters_ReplacesFilters()
     {
-        // Arrange
         var stale = FilterBuilder.CreateTestFilter(isEnabled: true);
         var initialState = new FilterPaneState { Filters = [stale] };
 
         var newFilter = FilterBuilder.CreateTestFilter();
         var action = new ReplaceFiltersAction([newFilter]);
 
-        // Act
         var result = Reducers.ReduceReplaceFilters(initialState, action);
 
-        // Assert
         Assert.Single(result.Filters);
         Assert.DoesNotContain(result.Filters, f => f.Id == stale.Id);
     }
@@ -107,7 +96,7 @@ private static (Effects effects, IDispatcher dispatcher) CreateEffects(
         var mockLensState = Substitute.For<IState<FilterLensState>>();
         mockLensState.Value.Returns(new FilterLensState());
 
-        var effects = new Effects(mockAppliedFilter, mockRawEventStore, mockFilterPaneState, mockLensState);
+        var effects = new Effects(mockAppliedFilter, mockRawEventStore, mockFilterPaneState, mockLensState, new ClearAllFiltersNotifier(Substitute.For<ITraceLogger>()), new SetFilterDateRangeSucceededNotifier(Substitute.For<ITraceLogger>()));
         var dispatcher = Substitute.For<IDispatcher>();
 
         return (effects, dispatcher);
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/FilterPane/RestoreFilterPaneStateTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/FilterPane/RestoreFilterPaneStateTests.cs
index cf2b2a9e8..4503fb926 100644
--- a/tests/Unit/EventLogExpert.Runtime.Tests/FilterPane/RestoreFilterPaneStateTests.cs
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/FilterPane/RestoreFilterPaneStateTests.cs
@@ -3,6 +3,7 @@
 
 using EventLogExpert.Filtering.Persistence;
 using EventLogExpert.Filtering.TestUtils;
+using EventLogExpert.Logging.Abstractions;
 using EventLogExpert.Runtime.EventLog;
 using EventLogExpert.Runtime.FilterLenses;
 using EventLogExpert.Runtime.FilterPane;
@@ -65,7 +66,7 @@ private static (Effects Effects, IDispatcher Dispatcher) CreateEffects(bool isEn
         var lensState = Substitute.For<IState<FilterLensState>>();
         lensState.Value.Returns(new FilterLensState());
 
-        var effects = new Effects(appliedFilter, rawEventStore, filterPaneState, lensState);
+        var effects = new Effects(appliedFilter, rawEventStore, filterPaneState, lensState, new ClearAllFiltersNotifier(Substitute.For<ITraceLogger>()), new SetFilterDateRangeSucceededNotifier(Substitute.For<ITraceLogger>()));
 
         return (effects, Substitute.For<IDispatcher>());
     }
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/FilterPane/SetFilterDateRangeSucceededNotifierTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/FilterPane/SetFilterDateRangeSucceededNotifierTests.cs
new file mode 100644
index 000000000..a6b6baea9
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/FilterPane/SetFilterDateRangeSucceededNotifierTests.cs
@@ -0,0 +1,44 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Logging.Abstractions;
+using EventLogExpert.Runtime.FilterPane;
+using NSubstitute;
+
+namespace EventLogExpert.Runtime.Tests.FilterPane;
+
+public sealed class SetFilterDateRangeSucceededNotifierTests
+{
+    [Fact]
+    public void Raise_InvokesSubscribers()
+    {
+        var notifier = new SetFilterDateRangeSucceededNotifier(Substitute.For<ITraceLogger>());
+        var raised = 0;
+        notifier.Succeeded += () => raised++;
+
+        notifier.Raise();
+
+        Assert.Equal(1, raised);
+    }
+
+    [Fact]
+    public void Raise_IsolatesAThrowingSubscriber()
+    {
+        var notifier = new SetFilterDateRangeSucceededNotifier(Substitute.For<ITraceLogger>());
+        var reachedSecond = 0;
+        notifier.Succeeded += () => throw new InvalidOperationException("subscriber blew up");
+        notifier.Succeeded += () => reachedSecond++;
+
+        notifier.Raise();
+
+        Assert.Equal(1, reachedSecond);
+    }
+
+    [Fact]
+    public void Raise_WithNoSubscribers_DoesNotThrow()
+    {
+        var notifier = new SetFilterDateRangeSucceededNotifier(Substitute.For<ITraceLogger>());
+
+        notifier.Raise();
+    }
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/FilterProgress/FilterProgressStoreTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/FilterProgress/FilterProgressStoreTests.cs
deleted file mode 100644
index af6aeae46..000000000
--- a/tests/Unit/EventLogExpert.Runtime.Tests/FilterProgress/FilterProgressStoreTests.cs
+++ /dev/null
@@ -1,71 +0,0 @@
-// // Copyright (c) Microsoft Corporation.
-// // Licensed under the MIT License.
-
-using EventLogExpert.Runtime.FilterProgress;
-
-namespace EventLogExpert.Runtime.Tests.FilterProgress;
-
-public sealed class FilterProgressStateTests
-{
-    [Fact]
-    public void FilterProgressState_DefaultState_ShouldNotBeLoading()
-    {
-        var state = new FilterProgressState();
-
-        Assert.False(state.IsLoading);
-    }
-}
-
-public sealed class FilterProgressActionTests
-{
-    [Fact]
-    public void SetFilterProgressAction_ShouldCreateAction()
-    {
-        var action = new SetFilterProgressAction(true);
-
-        Assert.True(action.IsLoading);
-    }
-}
-
-public sealed class FilterProgressReducerTests
-{
-    [Fact]
-    public void ReduceCloseAll_WhenLoading_ShouldClearLoadingFlag()
-    {
-        var state = new FilterProgressState { IsLoading = true };
-
-        var result = Reducers.ReduceCloseAll(state);
-
-        Assert.False(result.IsLoading);
-    }
-
-    [Fact]
-    public void ReduceCloseAll_WhenNotLoading_ShouldReturnSameState()
-    {
-        var state = new FilterProgressState { IsLoading = false };
-
-        var result = Reducers.ReduceCloseAll(state);
-
-        Assert.Same(state, result);
-    }
-
-    [Fact]
-    public void ReduceSetFilterProgress_WithDifferentValue_ShouldFlagLoading()
-    {
-        var state = new FilterProgressState { IsLoading = false };
-
-        var result = Reducers.ReduceSetFilterProgress(state, new SetFilterProgressAction(true));
-
-        Assert.True(result.IsLoading);
-    }
-
-    [Fact]
-    public void ReduceSetFilterProgress_WithUnchangedValue_ShouldReturnSameState()
-    {
-        var state = new FilterProgressState { IsLoading = true };
-
-        var result = Reducers.ReduceSetFilterProgress(state, new SetFilterProgressAction(true));
-
-        Assert.Same(state, result);
-    }
-}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/Histogram/HistogramBuilderTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/Histogram/HistogramBuilderTests.cs
index 8a2f15a6b..d1a3736fc 100644
--- a/tests/Unit/EventLogExpert.Runtime.Tests/Histogram/HistogramBuilderTests.cs
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/Histogram/HistogramBuilderTests.cs
@@ -7,7 +7,7 @@
 using EventLogExpert.Eventing.TestUtils;
 using EventLogExpert.Filtering.Persistence;
 using EventLogExpert.Runtime.Histogram;
-using EventLogExpert.Runtime.LogTable;
+using EventLogExpert.Runtime.Tests.LogTable.TestSupport;
 using EventLogExpert.Runtime.Tests.TestUtils;
 
 namespace EventLogExpert.Runtime.Tests.Histogram;
@@ -16,6 +16,79 @@ public sealed class HistogramBuilderTests
 {
     private static readonly EventLogId s_logId = EventLogId.Create();
 
+    [Fact]
+    public void BuildWithHighlightTie_GroupBySource_WhenNineDistinctValues_EmitsNoOtherGroup()
+    {
+        var events = SourceEvents(("s01", 9), ("s02", 8), ("s03", 7), ("s04", 6), ("s05", 5), ("s06", 4), ("s07", 3), ("s08", 2), ("s09", 1));
+        var view = DisplayViewTestFactory.Build(s_logId, events);
+        SavedFilter filter = CreateFilter("Id == 0");
+        byte[] highlightWinners = view.EnsureHighlightWinners([filter], planKey: 1, CancellationToken.None);
+
+        HistogramData? data = HistogramBuilder.BuildWithHighlightTie(view, HistogramDimension.Source, maxBuckets: 100, highlightWinners, CancellationToken.None);
+
+        Assert.NotNull(data);
+        Assert.Equal(9, data!.Groups.Count);
+        Assert.DoesNotContain(data.Groups, group => group.Key == "cat-other");
+        Assert.Equal(10, data.SlotCount);
+    }
+
+    [Fact]
+    public void BuildWithHighlightTie_GroupBySource_WhenThirteenDistinctValues_KeepsTopEightWithOther()
+    {
+        var events = SourceEvents(
+            ("s01", 13),
+            ("s02", 12),
+            ("s03", 11),
+            ("s04", 10),
+            ("s05", 9),
+            ("s06", 8),
+            ("s07", 7),
+            ("s08", 6),
+            ("s09", 5),
+            ("s10", 4),
+            ("s11", 3),
+            ("s12", 2),
+            ("s13", 1));
+        var view = DisplayViewTestFactory.Build(s_logId, events);
+        SavedFilter filter = CreateFilter("Id == 0");
+        byte[] highlightWinners = view.EnsureHighlightWinners([filter], planKey: 1, CancellationToken.None);
+
+        HistogramData? data = HistogramBuilder.BuildWithHighlightTie(view, HistogramDimension.Source, maxBuckets: 100, highlightWinners, CancellationToken.None);
+
+        Assert.NotNull(data);
+        Assert.Equal(HistogramConstants.MaxGroupByCategories + 1, data!.Groups.Count);
+        Assert.Equal("Other (5 sources)", data.Groups[0].Label);
+        Assert.Equal(15, GroupTotal(data, 0));
+    }
+
+    [Fact]
+    public void BuildWithHighlightTie_GroupBySource_WhenTwelveDistinctValues_EmitsNoOtherGroup()
+    {
+        var events = SourceEvents(
+            ("s01", 12),
+            ("s02", 11),
+            ("s03", 10),
+            ("s04", 9),
+            ("s05", 8),
+            ("s06", 7),
+            ("s07", 6),
+            ("s08", 5),
+            ("s09", 4),
+            ("s10", 3),
+            ("s11", 2),
+            ("s12", 1));
+        var view = DisplayViewTestFactory.Build(s_logId, events);
+        SavedFilter filter = CreateFilter("Id == 0");
+        byte[] highlightWinners = view.EnsureHighlightWinners([filter], planKey: 1, CancellationToken.None);
+
+        HistogramData? data = HistogramBuilder.BuildWithHighlightTie(view, HistogramDimension.Source, maxBuckets: 100, highlightWinners, CancellationToken.None);
+
+        Assert.NotNull(data);
+        Assert.Equal(HistogramConstants.GraceGroupByCategories, data!.Groups.Count);
+        Assert.DoesNotContain(data.Groups, group => group.Key == "cat-other");
+        Assert.Equal(13, data.SlotCount);
+    }
+
     [Fact]
     public void Build_AllEventsAtSameTime_ProducesASingleBucket()
     {
@@ -49,16 +122,14 @@ public void Build_CapsBucketCountAtMaxBuckets()
     [Fact]
     public void Build_CombinedView_GroupBySource_SumsByLogicalValueAcrossStores()
     {
-        // "shared" appears in both child stores (each with its own string pool); the top-N resolution is by logical value,
-        // so the combined category count sums both stores rather than mis-classifying by a per-store pool index.
         var first = DisplayViewTestFactory.Build(EventLogId.Create(), SourceEvents(("shared", 2), ("only-a", 1)));
         var second = DisplayViewTestFactory.Build(EventLogId.Create(), SourceEvents(("shared", 3), ("only-b", 1)));
-        var combined = new CombinedColumnView([first, second], first.Context);
+        var combined = new AosReferenceCombinedView([first, second], first.Context);
 
         HistogramData? data = HistogramBuilder.Build(combined, HistogramDimension.Source, maxBuckets: 100, CancellationToken.None);
 
         Assert.NotNull(data);
-        Assert.Equal("shared", data!.Groups[0].Label); // most frequent across both stores (5)
+        Assert.Equal("shared", data!.Groups[0].Label);
         Assert.Equal(5, GroupTotal(data, 0));
         Assert.Equal(7, data.Total);
     }
@@ -68,7 +139,7 @@ public void Build_CombinedView_SumsCountsAndSpansAllChildViews()
     {
         var first = DisplayViewTestFactory.Build(EventLogId.Create(), EventsAt(0, 100));
         var second = DisplayViewTestFactory.Build(EventLogId.Create(), EventsAt(200, 300));
-        var combined = new CombinedColumnView([first, second], first.Context);
+        var combined = new AosReferenceCombinedView([first, second], first.Context);
 
         HistogramData? data = HistogramBuilder.Build(combined, HistogramDimension.Severity, maxBuckets: 10, CancellationToken.None);
 
@@ -106,8 +177,6 @@ public void Build_FollowLatest_BucketsEverySurvivorOverTheSurvivorSpan()
     [Fact]
     public void Build_GroupByErrorCode_ChartsServicingUserDataErrorCode_OmitsSuccess()
     {
-        // Servicing failures store their HRESULT in a UserData Cbs*/ErrorCode leaf (not EventData); the dimension must
-        // chart them end-to-end alongside a WUClient EventData failure, and omit a servicing success (0x0).
         var events = new List<ResolvedEvent>(ErrorCodeEvents(("Microsoft-Windows-WindowsUpdateClient", unchecked((int)0x800F081Fu), 2)))
         {
             ServicingUserDataEvent("CbsPackageChangeState/ErrorCode", "0x800F0823", 10),
@@ -120,7 +189,7 @@ public void Build_GroupByErrorCode_ChartsServicingUserDataErrorCode_OmitsSuccess
 
         Assert.NotNull(data);
         Assert.False(data!.GroupingFieldAbsent);
-        Assert.Equal(3, data.Total); // 2 WUClient 0x800F081F + 1 servicing 0x800F0823; the 0x0 success is omitted
+        Assert.Equal(3, data.Total);
         Assert.Contains(data.Groups, group => group.Label == "0x800F0823 CBS_E_NEW_SERVICING_STACK_REQUIRED");
     }
 
@@ -135,7 +204,7 @@ public void Build_GroupByErrorCode_NoFailures_SignalsEmptyStateWithZeroTotalAndN
         Assert.NotNull(data);
         Assert.True(data!.GroupingFieldAbsent);
         Assert.Empty(data.Groups);
-        Assert.Equal(0, data.Total); // the failure-subset count, not view.Count, so the region label never overstates
+        Assert.Equal(0, data.Total);
         Assert.Equal("error-code events", data.EventNoun);
     }
 
@@ -150,7 +219,7 @@ public void Build_GroupByErrorCode_OmitsSuccessesAndIneligibleProviders()
         HistogramData? data = HistogramBuilder.Build(view, HistogramDimension.ErrorCode, maxBuckets: 100, CancellationToken.None);
 
         Assert.NotNull(data);
-        Assert.Equal(2, data!.Total); // only the eligible failures contribute; successes and other providers are omitted
+        Assert.Equal(2, data!.Total);
         Assert.Equal(2, GroupTotal(data, 0));
     }
 
@@ -213,7 +282,6 @@ public void Build_GroupByLog_EscalatesToFullPathWhenFileNameAndParentBothCollide
         HistogramData? data = HistogramBuilder.Build(view, HistogramDimension.Log, maxBuckets: 100, CancellationToken.None);
 
         Assert.NotNull(data);
-        // Same file name AND parent folder ("logs"), so the parenthetical form also collides and both escalate to the full owning-log path.
         Assert.Equal(@"C:\logs\Security.evtx", data!.Groups[0].Label);
         Assert.Equal(@"D:\logs\Security.evtx", data.Groups[1].Label);
         Assert.NotEqual(data.Groups[0].Label, data.Groups[1].Label);
@@ -232,10 +300,10 @@ public void Build_GroupByLog_LabelsWithShortNameAndKeepsSameShortNameLogsSeparat
 
         Assert.NotNull(data);
         Assert.Equal(3, data!.Groups.Count);
-        Assert.Equal("Security.evtx (logsA)", data.Groups[0].Label); // colliding file names disambiguated by parent folder...
+        Assert.Equal("Security.evtx (logsA)", data.Groups[0].Label);
         Assert.Equal("Security.evtx (logsB)", data.Groups[1].Label);
         Assert.Equal("System", data.Groups[2].Label);
-        Assert.Equal(@"cat:C:\logsA\Security.evtx", data.Groups[0].Key); // ...while the toggle Key stays the raw owning-log path
+        Assert.Equal(@"cat:C:\logsA\Security.evtx", data.Groups[0].Key);
         Assert.NotEqual(data.Groups[0].Key, data.Groups[1].Key);
         Assert.Equal(3, GroupTotal(data, 0));
         Assert.Equal(2, GroupTotal(data, 1));
@@ -246,14 +314,14 @@ public void Build_GroupByLog_LabelsWithShortNameAndKeepsSameShortNameLogsSeparat
     [Fact]
     public void Build_GroupByLogonType_FieldAbsentFromView_SignalsEmptyState()
     {
-        var view = DisplayViewTestFactory.Build(s_logId, EventsAt(0, 100, 200)); // no EventData at all
+        var view = DisplayViewTestFactory.Build(s_logId, EventsAt(0, 100, 200));
 
         HistogramData? data = HistogramBuilder.Build(view, HistogramDimension.LogonType, maxBuckets: 100, CancellationToken.None);
 
         Assert.NotNull(data);
         Assert.True(data!.GroupingFieldAbsent);
         Assert.Empty(data.Groups);
-        Assert.Equal(3, data.Total); // the true survivor count, so the accessible region label isn't "0 events"
+        Assert.Equal(3, data.Total);
     }
 
     [Fact]
@@ -264,7 +332,7 @@ public void Build_GroupByLogonType_RowsWithoutTheFieldFallToOther()
         HistogramData? data = HistogramBuilder.Build(view, HistogramDimension.LogonType, maxBuckets: 100, CancellationToken.None);
 
         Assert.NotNull(data);
-        Assert.Equal(3, GroupTotal(data, 0)); // Other absorbs the 3 field-less rows
+        Assert.Equal(3, GroupTotal(data, 0));
         Assert.Equal("Network", data!.Groups[1].Label);
         Assert.Equal(2, GroupTotal(data, 1));
     }
@@ -272,7 +340,6 @@ public void Build_GroupByLogonType_RowsWithoutTheFieldFallToOther()
     [Fact]
     public void Build_GroupByLogonType_SplitsByDecodedLabel()
     {
-        // LogonType 3 = Network (x3), 10 = RemoteInteractive (x2).
         var view = DisplayViewTestFactory.Build(s_logId, EventDataEvents("LogonType", (3, 3), (10, 2)));
 
         HistogramData? data = HistogramBuilder.Build(view, HistogramDimension.LogonType, maxBuckets: 100, CancellationToken.None);
@@ -568,7 +635,6 @@ public void Build_GroupBySource_WhenTwelveDistinctValuesAndTieInactive_KeepsTopE
     [Fact]
     public void Build_GroupByTicketEncryptionType_DecimalAndHexCodesFoldIntoOneBand()
     {
-        // 0x17 and 23 are the same RC4 etype; the numeric-code scan must fold both spellings into one group.
         var view = DisplayViewTestFactory.Build(s_logId, EventDataEvents("TicketEncryptionType", (23, 2), ("0x17", 1)));
 
         HistogramData? data = HistogramBuilder.Build(view, HistogramDimension.TicketEncryptionType, maxBuckets: 100, CancellationToken.None);
@@ -603,79 +669,6 @@ public void Build_RecordsPerSeverityCountsInTheBaseBuffer()
         Assert.Equal(4, data.Total);
     }
 
-    [Fact]
-    public void BuildWithHighlightTie_GroupBySource_WhenNineDistinctValues_EmitsNoOtherGroup()
-    {
-        var events = SourceEvents(("s01", 9), ("s02", 8), ("s03", 7), ("s04", 6), ("s05", 5), ("s06", 4), ("s07", 3), ("s08", 2), ("s09", 1));
-        var view = DisplayViewTestFactory.Build(s_logId, events);
-        SavedFilter filter = CreateFilter("Id == 0");
-        byte[] highlightWinners = view.EnsureHighlightWinners([filter], planKey: 1, CancellationToken.None);
-
-        HistogramData? data = HistogramBuilder.BuildWithHighlightTie(view, HistogramDimension.Source, maxBuckets: 100, highlightWinners, CancellationToken.None);
-
-        Assert.NotNull(data);
-        Assert.Equal(9, data!.Groups.Count);
-        Assert.DoesNotContain(data.Groups, group => group.Key == "cat-other");
-        Assert.Equal(10, data.SlotCount);
-    }
-
-    [Fact]
-    public void BuildWithHighlightTie_GroupBySource_WhenThirteenDistinctValues_KeepsTopEightWithOther()
-    {
-        var events = SourceEvents(
-            ("s01", 13),
-            ("s02", 12),
-            ("s03", 11),
-            ("s04", 10),
-            ("s05", 9),
-            ("s06", 8),
-            ("s07", 7),
-            ("s08", 6),
-            ("s09", 5),
-            ("s10", 4),
-            ("s11", 3),
-            ("s12", 2),
-            ("s13", 1));
-        var view = DisplayViewTestFactory.Build(s_logId, events);
-        SavedFilter filter = CreateFilter("Id == 0");
-        byte[] highlightWinners = view.EnsureHighlightWinners([filter], planKey: 1, CancellationToken.None);
-
-        HistogramData? data = HistogramBuilder.BuildWithHighlightTie(view, HistogramDimension.Source, maxBuckets: 100, highlightWinners, CancellationToken.None);
-
-        Assert.NotNull(data);
-        Assert.Equal(HistogramConstants.MaxGroupByCategories + 1, data!.Groups.Count);
-        Assert.Equal("Other (5 sources)", data.Groups[0].Label);
-        Assert.Equal(15, GroupTotal(data, 0));
-    }
-
-    [Fact]
-    public void BuildWithHighlightTie_GroupBySource_WhenTwelveDistinctValues_EmitsNoOtherGroup()
-    {
-        var events = SourceEvents(
-            ("s01", 12),
-            ("s02", 11),
-            ("s03", 10),
-            ("s04", 9),
-            ("s05", 8),
-            ("s06", 7),
-            ("s07", 6),
-            ("s08", 5),
-            ("s09", 4),
-            ("s10", 3),
-            ("s11", 2),
-            ("s12", 1));
-        var view = DisplayViewTestFactory.Build(s_logId, events);
-        SavedFilter filter = CreateFilter("Id == 0");
-        byte[] highlightWinners = view.EnsureHighlightWinners([filter], planKey: 1, CancellationToken.None);
-
-        HistogramData? data = HistogramBuilder.BuildWithHighlightTie(view, HistogramDimension.Source, maxBuckets: 100, highlightWinners, CancellationToken.None);
-
-        Assert.NotNull(data);
-        Assert.Equal(HistogramConstants.GraceGroupByCategories, data!.Groups.Count);
-        Assert.DoesNotContain(data.Groups, group => group.Key == "cat-other");
-        Assert.Equal(13, data.SlotCount);
-    }
-
     private static SavedFilter CreateFilter(string text) =>
         SavedFilter.TryCreate(text, color: HighlightColor.LightRed, isEnabled: true)
         ?? throw new InvalidOperationException($"Failed to compile test filter '{text}'.");
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/Histogram/HistogramDimensionRequestSourceTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/Histogram/HistogramDimensionRequestSourceTests.cs
new file mode 100644
index 000000000..47eaf76cb
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/Histogram/HistogramDimensionRequestSourceTests.cs
@@ -0,0 +1,116 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Logging.Abstractions;
+using EventLogExpert.Runtime.Histogram;
+using Fluxor;
+using NSubstitute;
+
+namespace EventLogExpert.Runtime.Tests.Histogram;
+
+public sealed class HistogramDimensionRequestSourceTests
+{
+    [Fact]
+    public void AThrowingSubscriber_IsIsolatedFromOtherSubscribers()
+    {
+        var harness = new Harness(new HistogramDimensionRequest(HistogramDimension.Severity, 1));
+        var reachedSecond = 0;
+        harness.Source.Changed += () => throw new InvalidOperationException("subscriber blew up");
+        harness.Source.Changed += () => reachedSecond++;
+
+        harness.SetRequest(new HistogramDimensionRequest(HistogramDimension.EventId, 2));
+
+        Assert.Equal(1, reachedSecond);
+    }
+
+    [Fact]
+    public void Changed_DoesNotFire_WhenDimensionRequestUnchanged()
+    {
+        var harness = new Harness(new HistogramDimensionRequest(HistogramDimension.Severity, 1));
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.SetState(new HistogramState
+        {
+            DimensionRequest = new HistogramDimensionRequest(HistogramDimension.Severity, 1),
+            IsVisible = true
+        });
+
+        Assert.Equal(0, raised);
+        Assert.Equal(new HistogramDimensionRequest(HistogramDimension.Severity, 1), harness.Source.Current);
+    }
+
+    [Fact]
+    public void Changed_FiresWithLatestRequest_WhenRequestChanges()
+    {
+        var harness = new Harness(new HistogramDimensionRequest(HistogramDimension.Severity, 1));
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        var next = new HistogramDimensionRequest(HistogramDimension.EventId, 2);
+        harness.SetRequest(next);
+
+        Assert.Equal(1, raised);
+        Assert.Equal(next, harness.Source.Current);
+    }
+
+    [Fact]
+    public void Construction_AdoptsAChangeThatLandsBetweenSeedAndSubscribe()
+    {
+        // (the reconcile), with no StateChanged raised in between.
+        var reconciled = new HistogramDimensionRequest(HistogramDimension.EventId, 5);
+        var state = Substitute.For<IState<HistogramState>>();
+        state.Value.Returns(new HistogramState(), new HistogramState { DimensionRequest = reconciled });
+
+        using var source = new HistogramDimensionRequestSource(state, Substitute.For<ITraceLogger>());
+
+        Assert.Equal(reconciled, source.Current);
+    }
+
+    [Fact]
+    public void Current_ReflectsTheInitialState()
+    {
+        var request = new HistogramDimensionRequest(HistogramDimension.Log, 3);
+        var harness = new Harness(request);
+
+        Assert.Equal(request, harness.Source.Current);
+    }
+
+    [Fact]
+    public void Dispose_StopsRaising()
+    {
+        var harness = new Harness(new HistogramDimensionRequest(HistogramDimension.Severity, 1));
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.Source.Dispose();
+        harness.SetRequest(new HistogramDimensionRequest(HistogramDimension.EventId, 2));
+
+        Assert.Equal(0, raised);
+    }
+
+    private sealed class Harness
+    {
+        private readonly IState<HistogramState> _state = Substitute.For<IState<HistogramState>>();
+
+        public Harness(HistogramDimensionRequest? request)
+        {
+            State = new HistogramState { DimensionRequest = request };
+            _state.Value.Returns(_ => State);
+            Source = new HistogramDimensionRequestSource(_state, Substitute.For<ITraceLogger>());
+        }
+
+        public HistogramDimensionRequestSource Source { get; }
+
+        public HistogramState State { get; private set; }
+
+        public void SetRequest(HistogramDimensionRequest? request) =>
+            SetState(new HistogramState { DimensionRequest = request });
+
+        public void SetState(HistogramState state)
+        {
+            State = state;
+            _state.StateChanged += Raise.Event<EventHandler>(_state, EventArgs.Empty);
+        }
+    }
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/Histogram/HistogramHighlightTieTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/Histogram/HistogramHighlightTieTests.cs
index 7333f7b2c..3d7c71f87 100644
--- a/tests/Unit/EventLogExpert.Runtime.Tests/Histogram/HistogramHighlightTieTests.cs
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/Histogram/HistogramHighlightTieTests.cs
@@ -7,32 +7,17 @@
 using EventLogExpert.Filtering.TestUtils.Constants;
 using EventLogExpert.Runtime.Histogram;
 using EventLogExpert.Runtime.LogTable;
+using EventLogExpert.Runtime.Tests.LogTable.TestSupport;
 using EventLogExpert.Runtime.Tests.TestUtils;
 
 namespace EventLogExpert.Runtime.Tests.Histogram;
 
 public sealed class HistogramHighlightTieTests
 {
-    [Fact]
-    public void Build_WhenHighlightTieIsNotRequested_LeavesGroupMasksNull()
-    {
-        EventColumnView view = DisplayViewTestFactory.Build(
-            EventLogId.Create(),
-            [FilterEventBuilder.CreateTestEvent(20)]);
-
-        HistogramData data = HistogramBuilder.Build(
-            view,
-            HistogramDimension.EventId,
-            HistogramConstants.MaxBuckets,
-            TestContext.Current.CancellationToken)!;
-
-        Assert.Null(data.GroupHighlightMasks);
-    }
-
     [Fact]
     public void BuildWithHighlightTie_FieldDimension_SetsMasksForCountedRows()
     {
-        EventColumnView view = DisplayViewTestFactory.Build(
+        AosReferenceView view = DisplayViewTestFactory.Build(
             EventLogId.Create(),
             [FilterEventBuilder.CreateTestEvent(20, source: "Alpha")]);
         SavedFilter[] filters = [CreateFilter("Id == 20", HighlightColor.LightRed)];
@@ -55,7 +40,7 @@ public void BuildWithHighlightTie_FieldDimension_SetsMasksForCountedRows()
     [InlineData(HistogramDimension.ProcessImage)]
     public void BuildWithHighlightTie_PreservesSlotCountsAcrossDimensions(HistogramDimension dimension)
     {
-        EventColumnView view = DisplayViewTestFactory.Build(
+        AosReferenceView view = DisplayViewTestFactory.Build(
             EventLogId.Create(),
             [
                 FilterEventBuilder.CreateTestEvent(20, source: "Alpha", level: FilterTestConstants.EventLevelError),
@@ -77,7 +62,7 @@ public void BuildWithHighlightTie_PreservesSlotCountsAcrossDimensions(HistogramD
     [Fact]
     public void BuildWithHighlightTie_UsesCapturedWinnerArrayWhenViewCacheChanges()
     {
-        EventColumnView view = DisplayViewTestFactory.Build(
+        AosReferenceView view = DisplayViewTestFactory.Build(
             EventLogId.Create(),
             [FilterEventBuilder.CreateTestEvent(20)]);
         SavedFilter[] firstFilters = [CreateFilter("Id == 20", HighlightColor.LightRed)];
@@ -94,7 +79,7 @@ public void BuildWithHighlightTie_UsesCapturedWinnerArrayWhenViewCacheChanges()
     [Fact]
     public void BuildWithHighlightTie_WhenGroupHasOneWinner_StoresThatWinnerMask()
     {
-        EventColumnView view = DisplayViewTestFactory.Build(
+        AosReferenceView view = DisplayViewTestFactory.Build(
             EventLogId.Create(),
             [FilterEventBuilder.CreateTestEvent(20), FilterEventBuilder.CreateTestEvent(20)]);
         SavedFilter[] filters = [CreateFilter("Id == 20", HighlightColor.LightRed)];
@@ -114,7 +99,7 @@ public void BuildWithHighlightTie_WhenGroupHasOneWinner_StoresThatWinnerMask()
     [Fact]
     public void BuildWithHighlightTie_WhenGroupHasUncoloredRow_IncludesBitZero()
     {
-        EventColumnView view = DisplayViewTestFactory.Build(
+        AosReferenceView view = DisplayViewTestFactory.Build(
             EventLogId.Create(),
             [
                 FilterEventBuilder.CreateTestEvent(20, source: FilterTestConstants.EventSourceTestSource),
@@ -137,7 +122,7 @@ public void BuildWithHighlightTie_WhenGroupHasUncoloredRow_IncludesBitZero()
     [Fact]
     public void BuildWithHighlightTie_WhenSeverityGroupFoldsSlots_OrsSlotMasks()
     {
-        EventColumnView view = DisplayViewTestFactory.Build(
+        AosReferenceView view = DisplayViewTestFactory.Build(
             EventLogId.Create(),
             [
                 FilterEventBuilder.CreateTestEvent(20, level: FilterTestConstants.EventLevelError),
@@ -161,16 +146,32 @@ public void BuildWithHighlightTie_WhenSeverityGroupFoldsSlots_OrsSlotMasks()
         Assert.Equal((1u << 1) | (1u << 2), data.GroupHighlightMasks![group]);
     }
 
+    [Fact]
+    public void Build_WhenHighlightTieIsNotRequested_LeavesGroupMasksNull()
+    {
+        AosReferenceView view = DisplayViewTestFactory.Build(
+            EventLogId.Create(),
+            [FilterEventBuilder.CreateTestEvent(20)]);
+
+        HistogramData data = HistogramBuilder.Build(
+            view,
+            HistogramDimension.EventId,
+            HistogramConstants.MaxBuckets,
+            TestContext.Current.CancellationToken)!;
+
+        Assert.Null(data.GroupHighlightMasks);
+    }
+
     [Fact]
     public void CombinedColumnView_BuildWithHighlightTie_OrsPerChildMasks()
     {
-        EventColumnView first = DisplayViewTestFactory.Build(
+        AosReferenceView first = DisplayViewTestFactory.Build(
             EventLogId.Create(),
             [FilterEventBuilder.CreateTestEvent(20, source: "Alpha")]);
-        EventColumnView second = DisplayViewTestFactory.Build(
+        AosReferenceView second = DisplayViewTestFactory.Build(
             EventLogId.Create(),
             [FilterEventBuilder.CreateTestEvent(20, source: "Beta")]);
-        var combined = new CombinedColumnView(
+        var combined = new AosReferenceCombinedView(
             [first, second],
             new SortContext(orderBy: null, isDescending: false, groupBy: null, isGroupDescending: false));
         SavedFilter[] filters =
@@ -189,10 +190,10 @@ public void CombinedColumnView_BuildWithHighlightTie_OrsPerChildMasks()
     [Fact]
     public void CombinedColumnView_BuildWithHighlightTie_RejectsForeignWinnerHandle()
     {
-        EventColumnView first = DisplayViewTestFactory.Build(
+        AosReferenceView first = DisplayViewTestFactory.Build(
             EventLogId.Create(),
             [FilterEventBuilder.CreateTestEvent(20)]);
-        var combined = new CombinedColumnView(
+        var combined = new AosReferenceCombinedView(
             [first],
             new SortContext(orderBy: null, isDescending: false, groupBy: null, isGroupDescending: false));
 
@@ -203,7 +204,7 @@ public void CombinedColumnView_BuildWithHighlightTie_RejectsForeignWinnerHandle(
     [Fact]
     public void EnsureHighlightWinners_AfterPlanChange_ReturnsPlanConsistentSnapshot()
     {
-        EventColumnView view = DisplayViewTestFactory.Build(
+        AosReferenceView view = DisplayViewTestFactory.Build(
             EventLogId.Create(),
             [FilterEventBuilder.CreateTestEvent(20), FilterEventBuilder.CreateTestEvent(21)]);
         SavedFilter[] firstFilters = [CreateFilter("Id == 20", HighlightColor.LightRed)];
@@ -222,7 +223,7 @@ public void EnsureHighlightWinners_AfterPlanChange_ReturnsPlanConsistentSnapshot
     [Fact]
     public void EventColumnView_WithContext_PreservesCapturedHighlightWinners()
     {
-        EventColumnView view = DisplayViewTestFactory.Build(
+        AosReferenceView view = DisplayViewTestFactory.Build(
             EventLogId.Create(),
             [
                 FilterEventBuilder.CreateTestEvent(20, timeCreated: DateTime.UtcNow.AddMinutes(1)),
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/Histogram/HistogramVisibilitySourceTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/Histogram/HistogramVisibilitySourceTests.cs
new file mode 100644
index 000000000..d9602b8a3
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/Histogram/HistogramVisibilitySourceTests.cs
@@ -0,0 +1,108 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Logging.Abstractions;
+using EventLogExpert.Runtime.Histogram;
+using Fluxor;
+using NSubstitute;
+
+namespace EventLogExpert.Runtime.Tests.Histogram;
+
+public sealed class HistogramVisibilitySourceTests
+{
+    [Fact]
+    public void AThrowingSubscriber_IsIsolatedFromOtherSubscribers()
+    {
+        var harness = new Harness(visible: false);
+        var reachedSecond = 0;
+        harness.Source.Changed += () => throw new InvalidOperationException("subscriber blew up");
+        harness.Source.Changed += () => reachedSecond++;
+
+        harness.SetVisible(true);
+
+        Assert.Equal(1, reachedSecond);
+    }
+
+    [Fact]
+    public void Changed_DoesNotFire_WhenVisibilityUnchanged()
+    {
+        var harness = new Harness(visible: true);
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.SetState(new HistogramState { IsVisible = true, NextDimensionToken = 7 });
+
+        Assert.Equal(0, raised);
+        Assert.True(harness.Source.IsVisible);
+    }
+
+    [Fact]
+    public void Changed_FiresWithLatestVisibility_WhenVisibilityFlips()
+    {
+        var harness = new Harness(visible: false);
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.SetVisible(true);
+
+        Assert.Equal(1, raised);
+        Assert.True(harness.Source.IsVisible);
+    }
+
+    [Fact]
+    public void Construction_AdoptsAChangeThatLandsBetweenSeedAndSubscribe()
+    {
+        // then visible (the reconcile), with no StateChanged raised in between.
+        var state = Substitute.For<IState<HistogramState>>();
+        state.Value.Returns(new HistogramState { IsVisible = false }, new HistogramState { IsVisible = true });
+
+        using var source = new HistogramVisibilitySource(state, Substitute.For<ITraceLogger>());
+
+        Assert.True(source.IsVisible);
+    }
+
+    [Fact]
+    public void Dispose_StopsRaising()
+    {
+        var harness = new Harness(visible: false);
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.Source.Dispose();
+        harness.SetVisible(true);
+
+        Assert.Equal(0, raised);
+    }
+
+    [Fact]
+    public void IsVisible_ReflectsTheInitialState()
+    {
+        var harness = new Harness(visible: true);
+
+        Assert.True(harness.Source.IsVisible);
+    }
+
+    private sealed class Harness
+    {
+        private readonly IState<HistogramState> _state = Substitute.For<IState<HistogramState>>();
+
+        public Harness(bool visible)
+        {
+            State = new HistogramState { IsVisible = visible };
+            _state.Value.Returns(_ => State);
+            Source = new HistogramVisibilitySource(_state, Substitute.For<ITraceLogger>());
+        }
+
+        public HistogramVisibilitySource Source { get; }
+
+        public HistogramState State { get; private set; }
+
+        public void SetState(HistogramState state)
+        {
+            State = state;
+            _state.StateChanged += Raise.Event<EventHandler>(_state, EventArgs.Empty);
+        }
+
+        public void SetVisible(bool visible) => SetState(new HistogramState { IsVisible = visible });
+    }
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/ActiveEventLogSourceTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/ActiveEventLogSourceTests.cs
new file mode 100644
index 000000000..ac556d184
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/ActiveEventLogSourceTests.cs
@@ -0,0 +1,112 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Logging.Abstractions;
+using EventLogExpert.Runtime.LogTable;
+using Fluxor;
+using NSubstitute;
+
+namespace EventLogExpert.Runtime.Tests.LogTable;
+
+public sealed class ActiveEventLogSourceTests
+{
+    [Fact]
+    public void AThrowingSubscriber_IsIsolatedFromOtherSubscribers()
+    {
+        var harness = new Harness(EventLogId.Create());
+        var reachedSecond = 0;
+        harness.Source.Changed += () => throw new InvalidOperationException("subscriber blew up");
+        harness.Source.Changed += () => reachedSecond++;
+
+        harness.SetActive(EventLogId.Create());
+
+        Assert.Equal(1, reachedSecond);
+    }
+
+    [Fact]
+    public void Changed_DoesNotFire_WhenActiveTabUnchanged()
+    {
+        var active = EventLogId.Create();
+        var harness = new Harness(active);
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.SetState(new LogTableState { ActiveEventLogId = active, GroupBy = ColumnName.Source });
+
+        Assert.Equal(0, raised);
+    }
+
+    [Fact]
+    public void Changed_FiresWithLatestActiveTab_OnChange()
+    {
+        var harness = new Harness(EventLogId.Create());
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        var next = EventLogId.Create();
+        harness.SetActive(next);
+
+        Assert.Equal(1, raised);
+        Assert.Equal(next, harness.Source.Current);
+    }
+
+    [Fact]
+    public void Construction_AdoptsAChangeThatLandsBetweenSeedAndSubscribe()
+    {
+        // an active-tab state (the reconcile), with no StateChanged raised in between.
+        var seeded = EventLogId.Create();
+        var state = Substitute.For<IState<LogTableState>>();
+        state.Value.Returns(new LogTableState(), new LogTableState { ActiveEventLogId = seeded });
+
+        using var source = new ActiveEventLogSource(state, Substitute.For<ITraceLogger>());
+
+        Assert.Equal(seeded, source.Current);
+    }
+
+    [Fact]
+    public void Current_ReflectsTheInitialActiveTab()
+    {
+        var active = EventLogId.Create();
+        var harness = new Harness(active);
+
+        Assert.Equal(active, harness.Source.Current);
+    }
+
+    [Fact]
+    public void Dispose_StopsRaising()
+    {
+        var harness = new Harness(EventLogId.Create());
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.Source.Dispose();
+        harness.SetActive(EventLogId.Create());
+
+        Assert.Equal(0, raised);
+    }
+
+    private sealed class Harness
+    {
+        private readonly IState<LogTableState> _state = Substitute.For<IState<LogTableState>>();
+
+        public Harness(EventLogId? active)
+        {
+            State = new LogTableState { ActiveEventLogId = active };
+            _state.Value.Returns(_ => State);
+            Source = new ActiveEventLogSource(_state, Substitute.For<ITraceLogger>());
+        }
+
+        public ActiveEventLogSource Source { get; }
+
+        public LogTableState State { get; private set; }
+
+        public void SetActive(EventLogId? active) => SetState(new LogTableState { ActiveEventLogId = active });
+
+        public void SetState(LogTableState state)
+        {
+            State = state;
+            _state.StateChanged += Raise.Event<EventHandler>(_state, EventArgs.Empty);
+        }
+    }
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/EventColumnViewTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/AosReferenceViewTests.cs
similarity index 69%
rename from tests/Unit/EventLogExpert.Runtime.Tests/LogTable/EventColumnViewTests.cs
rename to tests/Unit/EventLogExpert.Runtime.Tests/LogTable/AosReferenceViewTests.cs
index ac40c2370..29c6bc1fa 100644
--- a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/EventColumnViewTests.cs
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/AosReferenceViewTests.cs
@@ -7,41 +7,28 @@
 using EventLogExpert.Runtime.LogTable;
 using EventLogExpert.Runtime.Tests.LogTable.TestSupport;
 using System.Security.Principal;
+using static EventLogExpert.Runtime.Tests.LogTable.TestSupport.DivergenceReport;
 
 namespace EventLogExpert.Runtime.Tests.LogTable;
 
-/// <summary>
-///     End-to-end display parity for <see cref="EventColumnView" /> over a REAL <see cref="EventColumnStore" />
-///     (built and sealed into columnar chunks, so the view rehydrates from columns, not the original objects). Across the
-///     full 756-config sort matrix the view must (a) report the corpus count, (b) display the same order as the
-///     array-of-structs oracle <see cref="AosReferenceOrdering.OrderedEvents" />, and (c) round-trip every
-///     <see cref="DisplayRow.Loc" /> through <see cref="EventColumnView.Rank" /> and <c>GetDetail</c>. A filtered survivor
-///     subset must display exactly those rows. The corpus uses distinct non-null RecordIds so both sort paths resolve to
-///     one strict total order (the null-RecordId tie-burst corpus is <see cref="ColumnDirectSortKernelTests" />' job, not
-///     this wrapper's).
-/// </summary>
-public sealed class EventColumnViewTests
+public sealed class AosReferenceViewTests
 {
-    private static readonly ColumnName[] s_allColumns = Enum.GetValues<ColumnName>();
-    private static readonly bool[] s_bools = [false, true];
-    private static readonly IReadOnlyList<SortConfig> s_allConfigs = BuildAllConfigs();
-
+    private static readonly IReadOnlyList<SortConfig> s_allConfigs = SortConfigMatrix.All();
     private static readonly EventLogId s_logId = EventLogId.Create();
-    private static readonly IReadOnlyList<ResolvedEvent> s_corpus = BuildCorpus();
-
+    private static readonly IReadOnlyList<ResolvedEvent> s_sample = BuildSample();
     private static readonly IEventColumnReader s_reader =
-        EventColumnStore.Build(s_corpus, generation: 0, contentVersion: 0).CreateReader(s_logId);
+        EventColumnStore.Build(s_sample, generation: 0, contentVersion: 0).CreateReader(s_logId);
 
     [Fact]
-    public void Create_CountMatchesCorpus_ForEveryConfig()
+    public void Create_CountMatchesSample_ForEveryConfig()
     {
         int[] survivors = AllIndices();
 
         foreach (SortConfig config in s_allConfigs)
         {
-            EventColumnView view = CreateView(survivors, config);
+            AosReferenceView view = CreateView(survivors, config);
 
-            Assert.Equal(s_corpus.Count, view.Count);
+            Assert.Equal(s_sample.Count, view.Count);
         }
     }
 
@@ -52,25 +39,22 @@ public void Create_FilteredSurvivors_DisplaysExactlyThatSubset()
         var survivorSet = survivors.ToHashSet();
         var config = new SortConfig(ColumnName.DateAndTime, IsDescending: false, GroupBy: null, IsGroupDescending: false);
 
-        EventColumnView view = CreateView(survivors, config);
+        AosReferenceView view = CreateView(survivors, config);
         IReadOnlyList<DisplayRow> displayed = view.Slice(0, view.Count);
 
         Assert.Equal(survivors.Length, view.Count);
         Assert.Equal(survivors.Length, displayed.Count);
 
-        // The displayed physical rows are EXACTLY the survivor set (order-independent set equality).
         Assert.Equal(survivorSet, displayed.Select(row => row.Loc.Index).ToHashSet());
 
-        // The displayed order still matches the oracle sorted over just the survivor events.
-        IReadOnlyList<ResolvedEvent> oracle = AosReferenceOrdering.OrderedEvents(survivors.Select(index => s_corpus[index]), config.OrderBy, config.IsDescending, config.GroupBy, config.IsGroupDescending);
+        IReadOnlyList<ResolvedEvent> oracle = AosReferenceOrdering.OrderedEvents(survivors.Select(index => s_sample[index]), config.OrderBy, config.IsDescending, config.GroupBy, config.IsGroupDescending);
 
         for (int displayIndex = 0; displayIndex < oracle.Count; displayIndex++)
         {
             Assert.True(SameValueIdentity(oracle[displayIndex], displayed[displayIndex].Lean));
         }
 
-        // A filtered-out physical row ranks -1; a surviving one ranks to a display slot that maps back to it.
-        for (int physical = 0; physical < s_corpus.Count; physical++)
+        for (int physical = 0; physical < s_sample.Count; physical++)
         {
             int rank = view.Rank(s_reader.LocatorAt(physical));
 
@@ -95,11 +79,11 @@ public void MatrixIsFullCrossProduct()
     [Fact]
     public void Rank_LocatorOutsideView_ReturnsMinusOne()
     {
-        EventColumnView view = CreateView(AllIndices(), new SortConfig(null, IsDescending: false, GroupBy: null, IsGroupDescending: false));
+        AosReferenceView view = CreateView(AllIndices(), new SortConfig(null, IsDescending: false, GroupBy: null, IsGroupDescending: false));
 
         Assert.Equal(-1, view.Rank(new EventLocator(EventLogId.Create(), 0, 0)));
         Assert.Equal(-1, view.Rank(new EventLocator(s_logId, 999, 0)));
-        Assert.Equal(-1, view.Rank(new EventLocator(s_logId, 0, s_corpus.Count)));
+        Assert.Equal(-1, view.Rank(new EventLocator(s_logId, 0, s_sample.Count)));
         Assert.Equal(-1, view.Rank(new EventLocator(s_logId, 0, -1)));
     }
 
@@ -111,9 +95,9 @@ public void Slice_MatchesAoSOracleOrder_ForEveryConfig()
 
         foreach (SortConfig config in s_allConfigs)
         {
-            EventColumnView view = CreateView(survivors, config);
+            AosReferenceView view = CreateView(survivors, config);
             IReadOnlyList<DisplayRow> displayed = view.Slice(0, view.Count);
-            IReadOnlyList<ResolvedEvent> oracle = AosReferenceOrdering.OrderedEvents(s_corpus, config.OrderBy, config.IsDescending, config.GroupBy, config.IsGroupDescending);
+            IReadOnlyList<ResolvedEvent> oracle = AosReferenceOrdering.OrderedEvents(s_sample, config.OrderBy, config.IsDescending, config.GroupBy, config.IsGroupDescending);
 
             if (displayed.Count != oracle.Count)
             {
@@ -142,7 +126,7 @@ public void Slice_RowLocatorsRoundTrip_ForEveryConfig()
 
         foreach (SortConfig config in s_allConfigs)
         {
-            EventColumnView view = CreateView(survivors, config);
+            AosReferenceView view = CreateView(survivors, config);
             IReadOnlyList<DisplayRow> displayed = view.Slice(0, view.Count);
 
             for (int displayIndex = 0; displayIndex < displayed.Count; displayIndex++)
@@ -172,8 +156,8 @@ public void Slice_WithStartOffset_MapsWindowToDisplayPositions()
         const int start = 3;
         const int count = 4;
         var config = new SortConfig(ColumnName.RecordId, IsDescending: false, GroupBy: null, IsGroupDescending: false);
-        EventColumnView view = CreateView(AllIndices(), config);
-        IReadOnlyList<ResolvedEvent> oracle = AosReferenceOrdering.OrderedEvents(s_corpus, config.OrderBy, config.IsDescending, config.GroupBy, config.IsGroupDescending);
+        AosReferenceView view = CreateView(AllIndices(), config);
+        IReadOnlyList<ResolvedEvent> oracle = AosReferenceOrdering.OrderedEvents(s_sample, config.OrderBy, config.IsDescending, config.GroupBy, config.IsGroupDescending);
 
         IReadOnlyList<DisplayRow> window = view.Slice(start, count);
 
@@ -188,40 +172,9 @@ public void Slice_WithStartOffset_MapsWindowToDisplayPositions()
         }
     }
 
-    private static int[] AllIndices() => Enumerable.Range(0, s_corpus.Count).ToArray();
-
-    // Test-local copy of the ColumnDirectSortKernelTests config matrix: the full order x group x asc/desc cross-product.
-    // Kept independent of the kernel suite's private fixture so the two suites do not couple.
-    private static IReadOnlyList<SortConfig> BuildAllConfigs()
-    {
-        var configs = new List<SortConfig>();
-
-        foreach (ColumnName? orderBy in OrderByOptions())
-        {
-            foreach (bool isDescending in s_bools)
-            {
-                configs.Add(new SortConfig(orderBy, isDescending, null, false));
-            }
-        }
-
-        foreach (ColumnName groupBy in s_allColumns)
-        {
-            foreach (bool isGroupDescending in s_bools)
-            {
-                foreach (ColumnName? orderBy in OrderByOptions())
-                {
-                    foreach (bool isDescending in s_bools)
-                    {
-                        configs.Add(new SortConfig(orderBy, isDescending, groupBy, isGroupDescending));
-                    }
-                }
-            }
-        }
-
-        return configs;
-    }
+    private static int[] AllIndices() => Enumerable.Range(0, s_sample.Count).ToArray();
 
-    private static IReadOnlyList<ResolvedEvent> BuildCorpus()
+    private static IReadOnlyList<ResolvedEvent> BuildSample()
     {
         var guidA = new Guid("00000001-0000-0000-0000-000000000000");
         var guidB = new Guid("00000002-0000-0000-0000-000000000000");
@@ -233,9 +186,6 @@ private static IReadOnlyList<ResolvedEvent> BuildCorpus()
         var middle = new DateTime(2024, 6, 1, 0, 0, 0, DateTimeKind.Utc);
         var late = new DateTime(2024, 12, 1, 0, 0, 0, DateTimeKind.Utc);
 
-        // Distinct non-null RecordIds (1..16): the RecordId tie-break is the ultimate arbiter of both the AoS and the
-        // column-direct chains, so a unique RecordId makes the total order deterministic and identical between them. Every
-        // other column repeats to exercise per-column ties that resolve through that shared tie-break.
         return
         [
             FilterEventBuilder.CreateTestEvent(id: 5, recordId: 1, source: "Alpha", level: "Information", computerName: "Host-A", logName: "AppLog", taskCategory: "Cat-A", keywords: ["K1"], processId: 30, threadId: 9, activityId: guidA, userId: sidLow, timeCreated: middle),
@@ -257,35 +207,21 @@ private static IReadOnlyList<ResolvedEvent> BuildCorpus()
         ];
     }
 
-    private static EventColumnView CreateView(ReadOnlySpan<int> survivors, SortConfig config) =>
-        EventColumnView.Create(s_reader, survivors, config.OrderBy, config.IsDescending, config.GroupBy, config.IsGroupDescending);
-
-    private static string Describe(IReadOnlyList<string> failures) =>
-        $"{failures.Count} divergence(s):{Environment.NewLine}{string.Join(Environment.NewLine, failures.Take(25))}";
+    private static AosReferenceView CreateView(ReadOnlySpan<int> survivors, SortConfig config) =>
+        AosReferenceView.Create(s_reader, survivors, config.OrderBy, config.IsDescending, config.GroupBy, config.IsGroupDescending);
 
     private static int[] FilteredSurvivors()
     {
-        // A non-contiguous, shuffled subset of physical rows (like a filter result): drop two indices and reverse the rest
-        // so the kernel must impose the canonical order regardless of the survivor input order.
-        List<int> survivors = Enumerable.Range(0, s_corpus.Count).Where(index => index != 2 && index != 11).ToList();
+        List<int> survivors = Enumerable.Range(0, s_sample.Count).Where(index => index != 2 && index != 11).ToList();
         survivors.Reverse();
 
         return survivors.ToArray();
     }
 
-    private static IEnumerable<ColumnName?> OrderByOptions()
-    {
-        yield return null;
-
-        foreach (ColumnName column in s_allColumns) { yield return column; }
-    }
-
     private static bool SameValueIdentity(ResolvedEvent expected, ResolvedEvent actual) =>
         expected.RecordId == actual.RecordId
         && expected.Id == actual.Id
         && expected.TimeCreated == actual.TimeCreated
         && string.Equals(expected.Source, actual.Source, StringComparison.Ordinal)
         && string.Equals(expected.Level, actual.Level, StringComparison.Ordinal);
-
-    private readonly record struct SortConfig(ColumnName? OrderBy, bool IsDescending, ColumnName? GroupBy, bool IsGroupDescending);
 }
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/ColumnDirectOrderingParityTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/ColumnDirectOrderingParityTests.cs
index 70e063ea3..d9d2b02fc 100644
--- a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/ColumnDirectOrderingParityTests.cs
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/ColumnDirectOrderingParityTests.cs
@@ -1,52 +1,39 @@
 // // Copyright (c) Microsoft Corporation.
 // // Licensed under the MIT License.
 
-using EventLogExpert.Eventing.Common.EventLogs;
 using EventLogExpert.Eventing.Common.Events;
 using EventLogExpert.Filtering.TestUtils;
 using EventLogExpert.Runtime.LogTable;
 using EventLogExpert.Runtime.Tests.LogTable.TestSupport;
 using System.Security.Principal;
+using static EventLogExpert.Runtime.Tests.LogTable.TestSupport.DivergenceReport;
 
 namespace EventLogExpert.Runtime.Tests.LogTable;
 
-/// <summary>
-///     Differential parity for the column-side group keys: the live
-///     <see cref="ResolvedEventGroupKey.For(IEventColumnReader, EventLocator, ColumnName)" /> and
-///     <see cref="IEventColumnView.GroupKeyAt" /> must match the relocated array-of-structs group key
-///     <see cref="AosReferenceGroupKey.For(ColumnName, ResolvedEvent)" /> for every column and event, and their contiguous
-///     group runs must match over the grouped-sort order produced by the reference comparer
-///     <see cref="AosReferenceOrdering.Reference" />. A <see cref="LegacyEventColumnReader" /> reads the same
-///     <see cref="ResolvedEvent" /> corpus, so any divergence isolates the column-side group-key logic rather than the
-///     store.
-/// </summary>
 public sealed class ColumnDirectOrderingParityTests
 {
     private static readonly ColumnName[] s_allColumns = Enum.GetValues<ColumnName>();
-    private static readonly bool[] s_bools = [false, true];
-    private static readonly IReadOnlyList<ResolvedEvent> s_edgeCorpus = BuildEdgeCorpus();
-    private static readonly LegacyEventColumnView s_edgeView = NewView(s_edgeCorpus);
-    private static readonly IReadOnlyList<SortConfig> s_allConfigs = BuildAllConfigs();
+    private static readonly IReadOnlyList<ResolvedEvent> s_edgeSample = BuildEdgeSample();
+    private static readonly IReadOnlyList<SortConfig> s_allConfigs = SortConfigMatrix.All();
+    private static readonly IEventColumnReader s_edgeReader = ColumnReaderTestFactory.ReaderOver(s_edgeSample);
 
     [Fact]
     public void GroupKeyAt_MatchesArrayOfStructsGroupKey_ForEveryColumnAndEvent()
     {
         var failures = new List<string>();
 
-        for (int index = 0; index < s_edgeCorpus.Count; index++)
+        for (int index = 0; index < s_edgeSample.Count; index++)
         {
-            EventLocator locator = s_edgeView.LocatorAt(index);
+            EventLocator locator = s_edgeReader.LocatorAt(index);
 
             foreach (ColumnName column in s_allColumns)
             {
-                string arrayOfStructsKey = AosReferenceGroupKey.For(column, s_edgeCorpus[index]);
-                string viewKey = s_edgeView.GroupKeyAt(locator, column);
-                string readerKey = ResolvedEventGroupKey.For(s_edgeView.Reader, locator, column);
+                string arrayOfStructsKey = AosReferenceGroupKey.For(column, s_edgeSample[index]);
+                string readerKey = ResolvedEventGroupKey.For(s_edgeReader, locator, column);
 
-                if (!string.Equals(arrayOfStructsKey, viewKey, StringComparison.Ordinal) ||
-                    !string.Equals(arrayOfStructsKey, readerKey, StringComparison.Ordinal))
+                if (!string.Equals(arrayOfStructsKey, readerKey, StringComparison.Ordinal))
                 {
-                    failures.Add($"event {index} column {column}: aos='{arrayOfStructsKey}' view='{viewKey}' reader='{readerKey}'");
+                    failures.Add($"event {index} column {column}: aos='{arrayOfStructsKey}' reader='{readerKey}'");
                 }
             }
         }
@@ -62,11 +49,11 @@ public void GroupKeyRuns_MatchArrayOfStructs_ForEveryGroupColumn()
         foreach (ColumnName column in s_allColumns)
         {
             Comparison<ResolvedEvent> comparer = AosReferenceOrdering.Reference(null, false, column, false);
-            int[] order = Enumerable.Range(0, s_edgeCorpus.Count).ToArray();
-            Array.Sort(order, (left, right) => comparer(s_edgeCorpus[left], s_edgeCorpus[right]));
+            int[] order = Enumerable.Range(0, s_edgeSample.Count).ToArray();
+            Array.Sort(order, (left, right) => comparer(s_edgeSample[left], s_edgeSample[right]));
 
-            List<string> arrayOfStructsKeys = order.Select(index => AosReferenceGroupKey.For(column, s_edgeCorpus[index])).ToList();
-            List<string> columnKeys = order.Select(index => s_edgeView.GroupKeyAt(s_edgeView.LocatorAt(index), column)).ToList();
+            List<string> arrayOfStructsKeys = order.Select(index => AosReferenceGroupKey.For(column, s_edgeSample[index])).ToList();
+            List<string> columnKeys = order.Select(index => ResolvedEventGroupKey.For(s_edgeReader, s_edgeReader.LocatorAt(index), column)).ToList();
 
             if (!arrayOfStructsKeys.SequenceEqual(columnKeys, StringComparer.Ordinal))
             {
@@ -90,36 +77,7 @@ public void MatrixCovers756Configs_IncludingNullOrderByDescendingInBothArms()
         Assert.Contains(s_allConfigs, config => config.OrderBy is null && config.IsDescending && config.GroupBy is not null);
     }
 
-    private static IReadOnlyList<SortConfig> BuildAllConfigs()
-    {
-        var configs = new List<SortConfig>();
-
-        foreach (ColumnName? orderBy in OrderByOptions())
-        {
-            foreach (bool isDescending in s_bools)
-            {
-                configs.Add(new SortConfig(orderBy, isDescending, null, false));
-            }
-        }
-
-        foreach (ColumnName groupBy in s_allColumns)
-        {
-            foreach (bool isGroupDescending in s_bools)
-            {
-                foreach (ColumnName? orderBy in OrderByOptions())
-                {
-                    foreach (bool isDescending in s_bools)
-                    {
-                        configs.Add(new SortConfig(orderBy, isDescending, groupBy, isGroupDescending));
-                    }
-                }
-            }
-        }
-
-        return configs;
-    }
-
-    private static IReadOnlyList<ResolvedEvent> BuildEdgeCorpus()
+    private static IReadOnlyList<ResolvedEvent> BuildEdgeSample()
     {
         var guidLow = new Guid("00000001-0000-0000-0000-000000000000");
         var guidHigh = new Guid("ffffffff-0000-0000-0000-000000000000");
@@ -131,53 +89,30 @@ private static IReadOnlyList<ResolvedEvent> BuildEdgeCorpus()
 
         return
         [
-            // Numeric 2-vs-10: numeric order (2 < 10) is the opposite of lexical ("10" < "2"); Guid low < high; equal time.
             FilterEventBuilder.CreateTestEvent(id: 2, recordId: 2, processId: 2, threadId: 2, source: "Alpha", level: "Information", timeCreated: early, activityId: guidLow, userId: sidLow),
             FilterEventBuilder.CreateTestEvent(id: 10, recordId: 10, processId: 10, threadId: 10, source: "Alpha", level: "Information", timeCreated: early, activityId: guidHigh, userId: sidHigh),
 
-            // Equal primary on Source/Level/EventId/time with distinct RecordId → exercises the RecordId tie-break.
             FilterEventBuilder.CreateTestEvent(id: 1, recordId: 5, source: "Beta", level: "Error", timeCreated: middle),
             FilterEventBuilder.CreateTestEvent(id: 1, recordId: 7, source: "Beta", level: "Error", timeCreated: middle),
 
-            // Absent nullable columns vs an all-present twin (Absent sorts first).
             FilterEventBuilder.CreateTestEvent(id: 3, source: "Gamma", level: "Warning", timeCreated: late),
             FilterEventBuilder.CreateTestEvent(id: 3, recordId: 100, processId: 100, threadId: 100, source: "Gamma", level: "Warning", timeCreated: late, activityId: guidLow, userId: sidLow),
 
-            // Grouped-secondary triple: same Source + Level, distinct time → within-tie falls through to DateAndTime.
             FilterEventBuilder.CreateTestEvent(id: 50, recordId: 201, source: "Delta", level: "Info2", timeCreated: early),
             FilterEventBuilder.CreateTestEvent(id: 50, recordId: 202, source: "Delta", level: "Info2", timeCreated: middle),
             FilterEventBuilder.CreateTestEvent(id: 50, recordId: 203, source: "Delta", level: "Info2", timeCreated: late),
 
-            // Distinct values across the string columns (Log / ComputerName / TaskCategory / Keywords / User).
             FilterEventBuilder.CreateTestEvent(id: 4, recordId: 300, source: "Epsilon", computerName: "Host-A", logName: "AppLog", taskCategory: "Cat-A", keywords: ["K1"], userId: sidLow, timeCreated: early),
             FilterEventBuilder.CreateTestEvent(id: 4, recordId: 301, source: "Epsilon", computerName: "Host-B", logName: "SysLog", taskCategory: "Cat-B", keywords: ["K2"], userId: sidHigh, timeCreated: middle),
 
-            // ActivityId high/low pair (typed Guid.CompareTo: low < high on .NET, same as the "D" string order).
             FilterEventBuilder.CreateTestEvent(id: 6, recordId: 400, source: "Zeta", timeCreated: early, activityId: guidHigh),
             FilterEventBuilder.CreateTestEvent(id: 6, recordId: 401, source: "Zeta", timeCreated: early, activityId: guidLow),
 
-            // Equal on everything with null RecordId, distinct OwningLog → exercises the final OwningLog tie-break.
             FilterEventBuilder.CreateTestEvent(id: 7, source: "Eta", level: "Ledger", timeCreated: early, owningLog: "LogX"),
             FilterEventBuilder.CreateTestEvent(id: 7, source: "Eta", level: "Ledger", timeCreated: early, owningLog: "LogY")
         ];
     }
 
-    private static string Describe(IReadOnlyList<string> failures) =>
-        $"{failures.Count} divergence(s):{Environment.NewLine}{string.Join(Environment.NewLine, failures.Take(25))}";
-
-    private static LegacyEventColumnView NewView(IReadOnlyList<ResolvedEvent> corpus) =>
-        new(EventLogId.Create(), generation: 1, contentVersion: 1, corpus);
-
-    private static IEnumerable<ColumnName?> OrderByOptions()
-    {
-        yield return null;
-
-        foreach (ColumnName column in s_allColumns)
-        {
-            yield return column;
-        }
-    }
-
     private static List<int> RunLengths(IReadOnlyList<string> keys)
     {
         var lengths = new List<int>();
@@ -198,6 +133,4 @@ private static List<int> RunLengths(IReadOnlyList<string> keys)
 
         return lengths;
     }
-
-    private readonly record struct SortConfig(ColumnName? OrderBy, bool IsDescending, ColumnName? GroupBy, bool IsGroupDescending);
 }
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/ColumnDirectSortKernelTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/ColumnDirectSortKernelTests.cs
index 707a579ab..225ccea0f 100644
--- a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/ColumnDirectSortKernelTests.cs
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/ColumnDirectSortKernelTests.cs
@@ -1,31 +1,21 @@
 // // Copyright (c) Microsoft Corporation.
 // // Licensed under the MIT License.
 
-using EventLogExpert.Eventing.Common.EventLogs;
 using EventLogExpert.Eventing.Common.Events;
 using EventLogExpert.Filtering.TestUtils;
 using EventLogExpert.Runtime.LogTable;
 using EventLogExpert.Runtime.Tests.LogTable.TestSupport;
 using System.Diagnostics;
 using System.Security.Principal;
+using static EventLogExpert.Runtime.Tests.LogTable.TestSupport.DivergenceReport;
 
 namespace EventLogExpert.Runtime.Tests.LogTable;
 
-/// <summary>
-///     Differential parity for the bulk column-scan sort kernel (
-///     <see cref="ResolvedEventOrdering.SortColumnDirect" />): over the full 756-config sort matrix it must produce the
-///     exact physical-index order that sorting the same survivors through the relocated array-of-structs reference
-///     comparer (<see cref="AosReferenceOrdering.Reference" />) plus the same final physical-index ascending tie-break
-///     produces. A <see cref="LegacyEventColumnReader" /> feeds both sides the same corpus, so any divergence isolates the
-///     kernel. A perf smoke test guards that the kernel finishes on a large synthetic corpus.
-/// </summary>
 public sealed class ColumnDirectSortKernelTests(ITestOutputHelper output)
 {
-    private static readonly ColumnName[] s_allColumns = Enum.GetValues<ColumnName>();
-    private static readonly bool[] s_bools = [false, true];
-    private static readonly IReadOnlyList<SortConfig> s_allConfigs = BuildAllConfigs();
-    private static readonly IReadOnlyList<ResolvedEvent> s_edgeCorpus = BuildEdgeCorpus();
-    private static readonly IReadOnlyList<ResolvedEvent> s_tieBurstCorpus = BuildTieBurstCorpus();
+    private static readonly IReadOnlyList<SortConfig> s_allConfigs = SortConfigMatrix.All();
+    private static readonly IReadOnlyList<ResolvedEvent> s_edgeSample = BuildEdgeSample();
+    private static readonly IReadOnlyList<ResolvedEvent> s_tieBurstSample = BuildTieBurstSample();
 
     private readonly ITestOutputHelper _output = output;
 
@@ -33,20 +23,19 @@ public sealed class ColumnDirectSortKernelTests(ITestOutputHelper output)
     public void MatrixCovers756Configs_AcrossOrderGroupAscendingDescending()
     {
         Assert.Equal(756, s_allConfigs.Count);
-        Assert.Contains(s_allConfigs, config => config.OrderBy is null && config.IsDescending && config.GroupBy is null);
-        Assert.Contains(s_allConfigs, config => config.OrderBy is null && config.IsDescending && config.GroupBy is not null);
+        Assert.Contains(s_allConfigs, config => config.OrderBy is null && config is { IsDescending: true, GroupBy: null });
+        Assert.Contains(s_allConfigs, config => config.OrderBy is null && config is { IsDescending: true, GroupBy: not null });
     }
 
     [Fact]
-    public void SortColumnDirect_CompletesWithinBudget_OnLargeSyntheticCorpus()
+    public void SortColumnDirect_CompletesWithinBudget_OnLargeSyntheticSample()
     {
-        const int eventCount = 200_000;
-        const int budgetMilliseconds = 20_000;
-        IReadOnlyList<ResolvedEvent> corpus = BuildPerfCorpus(eventCount);
-        var reader = NewReader(corpus);
-        int[] survivors = AllIndices(eventCount);
+        const int EventCount = 200_000;
+        const int BudgetMilliseconds = 20_000;
+        IReadOnlyList<ResolvedEvent> sample = BuildPerfSample(EventCount);
+        var reader = ColumnReaderTestFactory.ReaderOver(sample);
+        int[] survivors = AllIndices(EventCount);
 
-        // A representative spread: ungrouped default, an ordered descending column, and a grouped-plus-ordered chain.
         SortConfig[] configs =
         [
             new SortConfig(null, false, null, false),
@@ -57,48 +46,42 @@ public void SortColumnDirect_CompletesWithinBudget_OnLargeSyntheticCorpus()
         foreach (SortConfig config in configs)
         {
             var stopwatch = Stopwatch.StartNew();
-            int[] sorted = ResolvedEventOrdering.SortColumnDirect(
-                reader, survivors, config.OrderBy, config.IsDescending, config.GroupBy, config.IsGroupDescending);
+            int[] sorted = ColumnDirectSort.SortColumnDirect(
+                reader, survivors, config.OrderBy, config.IsDescending, config.GroupBy, config.IsGroupDescending, TestContext.Current.CancellationToken);
             stopwatch.Stop();
 
-            Assert.Equal(eventCount, sorted.Length);
-            _output.WriteLine($"SortColumnDirect {config}: {stopwatch.ElapsedMilliseconds} ms for {eventCount:N0} events");
+            Assert.Equal(EventCount, sorted.Length);
+            _output.WriteLine($"SortColumnDirect {config}: {stopwatch.ElapsedMilliseconds} ms for {EventCount:N0} events");
 
             Assert.True(
-                stopwatch.ElapsedMilliseconds < budgetMilliseconds,
-                $"{config} took {stopwatch.ElapsedMilliseconds} ms, over the {budgetMilliseconds} ms budget");
+                stopwatch.ElapsedMilliseconds < BudgetMilliseconds,
+                $"{config} took {stopwatch.ElapsedMilliseconds} ms, over the {BudgetMilliseconds} ms budget");
         }
 
-        // Log the array-of-structs baseline for context only; a strict "faster than AoS" assert is too flaky for CI.
         var baseline = Stopwatch.StartNew();
-        _ = AosReferenceOrdering.Order(corpus, ColumnName.DateAndTime, isDescending: true).Length;
+        _ = AosReferenceOrdering.Order(sample, ColumnName.DateAndTime, isDescending: true).Length;
         baseline.Stop();
-        _output.WriteLine($"AosReferenceOrdering.Order (reference baseline, DateAndTime desc): {baseline.ElapsedMilliseconds} ms for {eventCount:N0} events");
+        _output.WriteLine($"AosReferenceOrdering.Order (reference baseline, DateAndTime desc): {baseline.ElapsedMilliseconds} ms for {EventCount:N0} events");
     }
 
     [Theory]
     [InlineData(false)]
     [InlineData(true)]
-    public void SortColumnDirect_FullTieCorpus_ReordersToAscendingIndexTieBreak_RegardlessOfDescending(bool isDescending)
+    public void SortColumnDirect_FullTieSample_ReordersToAscendingIndexTieBreak_RegardlessOfDescending(bool isDescending)
     {
-        // Four byte-identical events with a null RecordId in one OwningLog: the whole chain (RecordId, time, OwningLog)
-        // ties, so only the final physical-index tie-break separates rows. The survivors are handed in DESCENDING index
-        // order, so the expected ascending result can ONLY come from the tie-break actively reordering - the test fails if
-        // WithIndexTieBreak is broken to return 0 (a pre-sorted input would leave it a placebo). That tie-break is ascending
-        // and never negated, so a descending order still lands ascending physical index.
         var when = new DateTime(2024, 3, 3, 3, 3, 3, DateTimeKind.Utc);
-        IReadOnlyList<ResolvedEvent> corpus =
+        IReadOnlyList<ResolvedEvent> sample =
         [
             FilterEventBuilder.CreateTestEvent(id: 9, source: "Same", level: "Same", timeCreated: when, owningLog: "L"),
             FilterEventBuilder.CreateTestEvent(id: 9, source: "Same", level: "Same", timeCreated: when, owningLog: "L"),
             FilterEventBuilder.CreateTestEvent(id: 9, source: "Same", level: "Same", timeCreated: when, owningLog: "L"),
             FilterEventBuilder.CreateTestEvent(id: 9, source: "Same", level: "Same", timeCreated: when, owningLog: "L")
         ];
-        var reader = NewReader(corpus);
+        var reader = ColumnReaderTestFactory.ReaderOver(sample);
         int[] survivors = [3, 2, 1, 0];
 
-        int[] order = ResolvedEventOrdering.SortColumnDirect(
-            reader, survivors, ColumnName.DateAndTime, isDescending, groupBy: null, isGroupDescending: false);
+        int[] order = ColumnDirectSort.SortColumnDirect(
+            reader, survivors, ColumnName.DateAndTime, isDescending, groupBy: null, isGroupDescending: false, TestContext.Current.CancellationToken);
 
         Assert.Equal(new[] { 0, 1, 2, 3 }, order);
     }
@@ -111,60 +94,52 @@ public void SortColumnDirect_FullTieCorpus_ReordersToAscendingIndexTieBreak_Rega
     public void SortColumnDirect_GroupedChain_NegatesGroupAndWithinOrderIndependently(
         bool isWithinDescending, bool isGroupDescending, int[] expectedOrder)
     {
-        // Two Source groups (Alpha < Beta ordinally), two distinct RecordIds within each. With groupBy=Source and
-        // orderBy=RecordId the two GroupedChain negations are isolated: the group order flips with isGroupDescending and
-        // the within-group order flips with isDescending, independently. These direct expected orders guard the two
-        // -Math.Sign(...) sites in GroupedChain without routing through the AoS parity oracle.
         var when = new DateTime(2024, 1, 1, 0, 0, 0, DateTimeKind.Utc);
-        IReadOnlyList<ResolvedEvent> corpus =
+        IReadOnlyList<ResolvedEvent> sample =
         [
             FilterEventBuilder.CreateTestEvent(id: 1, recordId: 1, source: "Alpha", timeCreated: when, owningLog: "L"),
             FilterEventBuilder.CreateTestEvent(id: 1, recordId: 2, source: "Alpha", timeCreated: when, owningLog: "L"),
             FilterEventBuilder.CreateTestEvent(id: 1, recordId: 3, source: "Beta", timeCreated: when, owningLog: "L"),
             FilterEventBuilder.CreateTestEvent(id: 1, recordId: 4, source: "Beta", timeCreated: when, owningLog: "L")
         ];
-        var reader = NewReader(corpus);
+        var reader = ColumnReaderTestFactory.ReaderOver(sample);
 
-        int[] order = ResolvedEventOrdering.SortColumnDirect(
-            reader, AllIndices(corpus.Count), ColumnName.RecordId, isWithinDescending, ColumnName.Source, isGroupDescending);
+        int[] order = ColumnDirectSort.SortColumnDirect(
+            reader, AllIndices(sample.Count), ColumnName.RecordId, isWithinDescending, ColumnName.Source, isGroupDescending, TestContext.Current.CancellationToken);
 
         Assert.Equal(expectedOrder, order);
     }
 
     [Fact]
-    public void SortColumnDirect_MatchesOracleOrder_ForEveryConfig_OverEdgeCorpus()
+    public void SortColumnDirect_MatchesOracleOrder_ForEveryConfig_OverEdgeSample()
     {
-        AssertParityForEveryConfig(s_edgeCorpus, AllIndices(s_edgeCorpus.Count), "edge");
+        AssertParityForEveryConfig(s_edgeSample, AllIndices(s_edgeSample.Count), "edge");
     }
 
     [Fact]
     public void SortColumnDirect_MatchesOracleOrder_ForEveryConfig_OverFilteredSurvivors()
     {
-        // A non-contiguous, shuffled survivor subset (like a filter result): the kernel must still return the canonical
-        // order over exactly those physical rows, independent of the input order.
-        int[] survivors = FilteredSurvivors(s_edgeCorpus.Count);
+        int[] survivors = FilteredSurvivors(s_edgeSample.Count);
 
-        AssertParityForEveryConfig(s_edgeCorpus, survivors, "filtered-survivors");
+        AssertParityForEveryConfig(s_edgeSample, survivors, "filtered-survivors");
     }
 
     [Fact]
     public void SortColumnDirect_MatchesOracleOrder_ForEveryConfig_OverNullRecordIdTieBursts()
     {
-        // Full-tie bursts (identical events, null RecordId) plus equal-primary/equal-OwningLog groups exercise M4: the
-        // chain ties all the way through RecordId and OwningLog, so only the final physical-index tie-break separates them.
-        AssertParityForEveryConfig(s_tieBurstCorpus, AllIndices(s_tieBurstCorpus.Count), "tie-burst");
+        AssertParityForEveryConfig(s_tieBurstSample, AllIndices(s_tieBurstSample.Count), "tie-burst");
     }
 
     [Fact]
     public void SortColumnDirect_ReturnsPermutationOfSurvivors_ForEveryConfig()
     {
-        var reader = NewReader(s_edgeCorpus);
-        int[] survivors = FilteredSurvivors(s_edgeCorpus.Count);
+        var reader = ColumnReaderTestFactory.ReaderOver(s_edgeSample);
+        int[] survivors = FilteredSurvivors(s_edgeSample.Count);
 
         foreach (SortConfig config in s_allConfigs)
         {
-            int[] sorted = ResolvedEventOrdering.SortColumnDirect(
-                reader, survivors, config.OrderBy, config.IsDescending, config.GroupBy, config.IsGroupDescending);
+            int[] sorted = ColumnDirectSort.SortColumnDirect(
+                reader, survivors, config.OrderBy, config.IsDescending, config.GroupBy, config.IsGroupDescending, TestContext.Current.CancellationToken);
 
             Assert.Equal(survivors.Length, sorted.Length);
             Assert.Equal(survivors.OrderBy(index => index), sorted.OrderBy(index => index));
@@ -173,36 +148,7 @@ public void SortColumnDirect_ReturnsPermutationOfSurvivors_ForEveryConfig()
 
     private static int[] AllIndices(int count) => Enumerable.Range(0, count).ToArray();
 
-    private static IReadOnlyList<SortConfig> BuildAllConfigs()
-    {
-        var configs = new List<SortConfig>();
-
-        foreach (ColumnName? orderBy in OrderByOptions())
-        {
-            foreach (bool isDescending in s_bools)
-            {
-                configs.Add(new SortConfig(orderBy, isDescending, null, false));
-            }
-        }
-
-        foreach (ColumnName groupBy in s_allColumns)
-        {
-            foreach (bool isGroupDescending in s_bools)
-            {
-                foreach (ColumnName? orderBy in OrderByOptions())
-                {
-                    foreach (bool isDescending in s_bools)
-                    {
-                        configs.Add(new SortConfig(orderBy, isDescending, groupBy, isGroupDescending));
-                    }
-                }
-            }
-        }
-
-        return configs;
-    }
-
-    private static IReadOnlyList<ResolvedEvent> BuildEdgeCorpus()
+    private static IReadOnlyList<ResolvedEvent> BuildEdgeSample()
     {
         var guidLow = new Guid("00000001-0000-0000-0000-000000000000");
         var guidHigh = new Guid("ffffffff-0000-0000-0000-000000000000");
@@ -212,10 +158,6 @@ private static IReadOnlyList<ResolvedEvent> BuildEdgeCorpus()
         var middle = new DateTime(2024, 6, 1, 0, 0, 0, DateTimeKind.Utc);
         var late = new DateTime(2024, 12, 1, 0, 0, 0, DateTimeKind.Utc);
 
-        // Oracle-vs-kernel edge: do not pair a null and an empty-string value in the same string column here. The
-        // AosReferenceOrdering oracle is struct-based and sorts null before "" (raw string.Compare), while the live
-        // SortColumnDirect reads through the reader (AsString collapses null to "") and ties them, so pairing the two
-        // in one column would fail this parity test spuriously. No current row does so.
         return
         [
             FilterEventBuilder.CreateTestEvent(id: 2, recordId: 2, processId: 2, threadId: 2, source: "Alpha", level: "Information", timeCreated: early, activityId: guidLow, userId: sidLow),
@@ -232,11 +174,14 @@ private static IReadOnlyList<ResolvedEvent> BuildEdgeCorpus()
             FilterEventBuilder.CreateTestEvent(id: 6, recordId: 400, source: "Zeta", timeCreated: early, activityId: guidHigh),
             FilterEventBuilder.CreateTestEvent(id: 6, recordId: 401, source: "Zeta", timeCreated: early, activityId: guidLow),
             FilterEventBuilder.CreateTestEvent(id: 7, source: "Eta", level: "Ledger", timeCreated: early, owningLog: "LogX"),
-            FilterEventBuilder.CreateTestEvent(id: 7, source: "Eta", level: "Ledger", timeCreated: early, owningLog: "LogY")
+            FilterEventBuilder.CreateTestEvent(id: 7, source: "Eta", level: "Ledger", timeCreated: early, owningLog: "LogY"),
+
+            FilterEventBuilder.CreateTestEvent(id: 8, recordId: 500, source: "Theta", level: "", timeCreated: early),
+            FilterEventBuilder.CreateTestEvent(id: 8, recordId: 501, source: "Theta", level: "", timeCreated: early)
         ];
     }
 
-    private static IReadOnlyList<ResolvedEvent> BuildPerfCorpus(int count)
+    private static IReadOnlyList<ResolvedEvent> BuildPerfSample(int count)
     {
         var guids = new[]
         {
@@ -270,40 +215,31 @@ private static IReadOnlyList<ResolvedEvent> BuildPerfCorpus(int count)
         return events;
     }
 
-    private static IReadOnlyList<ResolvedEvent> BuildTieBurstCorpus()
+    private static IReadOnlyList<ResolvedEvent> BuildTieBurstSample()
     {
         var when = new DateTime(2024, 3, 3, 3, 3, 3, DateTimeKind.Utc);
         var events = new List<ResolvedEvent>();
 
-        // Six fully identical events with null RecordId: every chain (incl. OwningLog) ties, so only the physical index
-        // separates them.
         for (int index = 0; index < 6; index++)
         {
             events.Add(FilterEventBuilder.CreateTestEvent(
                 id: 9, source: "Same", level: "Same", timeCreated: when, owningLog: "SameLog"));
         }
 
-        // Same primary, null RecordId, distinct OwningLog: the OwningLog tie-break separates them before the index step.
         events.Add(FilterEventBuilder.CreateTestEvent(id: 9, source: "Same", level: "Same", timeCreated: when, owningLog: "LogB"));
         events.Add(FilterEventBuilder.CreateTestEvent(id: 9, source: "Same", level: "Same", timeCreated: when, owningLog: "LogA"));
 
-        // Same primary and OwningLog with distinct RecordId: the RecordId tie-break separates them.
         events.Add(FilterEventBuilder.CreateTestEvent(id: 9, recordId: 20, source: "Same", level: "Same", timeCreated: when, owningLog: "SameLog"));
         events.Add(FilterEventBuilder.CreateTestEvent(id: 9, recordId: 10, source: "Same", level: "Same", timeCreated: when, owningLog: "SameLog"));
 
-        // A couple of distinct rows so grouped/ordered configs still see more than one group.
         events.Add(FilterEventBuilder.CreateTestEvent(id: 1, recordId: 1, source: "Other", level: "Info", timeCreated: when.AddHours(1), owningLog: "SameLog"));
         events.Add(FilterEventBuilder.CreateTestEvent(id: 2, source: "Other", level: "Info", timeCreated: when.AddHours(2), owningLog: "SameLog"));
 
         return events;
     }
 
-    private static string Describe(IReadOnlyList<string> failures) =>
-        $"{failures.Count} divergence(s):{Environment.NewLine}{string.Join(Environment.NewLine, failures.Take(25))}";
-
     private static int[] FilteredSurvivors(int count)
     {
-        // Every physical row except a couple, handed to the kernel in a shuffled (non-sorted) order.
         var survivors = Enumerable.Range(0, count).Where(index => index != 1 && index != 4).ToList();
         var shuffled = new List<int>(survivors);
 
@@ -317,13 +253,7 @@ private static int[] FilteredSurvivors(int count)
         return shuffled.ToArray();
     }
 
-    private static LegacyEventColumnReader NewReader(IReadOnlyList<ResolvedEvent> corpus) =>
-        new(EventLogId.Create(), generation: 1, contentVersion: 1, corpus);
-
-    // The oracle order: sort the survivors through the relocated array-of-structs reference comparer, then break residual
-    // ties by physical index ascending (the same total-order completion the kernel appends), so the comparison is
-    // well-defined on ties.
-    private static int[] OracleOrder(IReadOnlyList<ResolvedEvent> corpus, int[] survivors, SortConfig config)
+    private static int[] OracleOrder(IReadOnlyList<ResolvedEvent> sample, int[] survivors, SortConfig config)
     {
         Comparison<ResolvedEvent> chain = AosReferenceOrdering.Reference(
             config.OrderBy, config.IsDescending, config.GroupBy, config.IsGroupDescending);
@@ -331,7 +261,7 @@ private static int[] OracleOrder(IReadOnlyList<ResolvedEvent> corpus, int[] surv
 
         Array.Sort(order, (a, b) =>
         {
-            int compared = chain(corpus[a], corpus[b]);
+            int compared = chain(sample[a], sample[b]);
 
             return compared != 0 ? compared : a.CompareTo(b);
         });
@@ -339,26 +269,16 @@ private static int[] OracleOrder(IReadOnlyList<ResolvedEvent> corpus, int[] surv
         return order;
     }
 
-    private static IEnumerable<ColumnName?> OrderByOptions()
-    {
-        yield return null;
-
-        foreach (ColumnName column in s_allColumns)
-        {
-            yield return column;
-        }
-    }
-
-    private void AssertParityForEveryConfig(IReadOnlyList<ResolvedEvent> corpus, int[] survivors, string label)
+    private void AssertParityForEveryConfig(IReadOnlyList<ResolvedEvent> sample, int[] survivors, string label)
     {
-        var reader = NewReader(corpus);
+        var reader = ColumnReaderTestFactory.ReaderOver(sample);
         var failures = new List<string>();
 
         foreach (SortConfig config in s_allConfigs)
         {
-            int[] actual = ResolvedEventOrdering.SortColumnDirect(
-                reader, survivors, config.OrderBy, config.IsDescending, config.GroupBy, config.IsGroupDescending);
-            int[] expected = OracleOrder(corpus, survivors, config);
+            int[] actual = ColumnDirectSort.SortColumnDirect(
+                reader, survivors, config.OrderBy, config.IsDescending, config.GroupBy, config.IsGroupDescending, TestContext.Current.CancellationToken);
+            int[] expected = OracleOrder(sample, survivors, config);
 
             if (!actual.SequenceEqual(expected))
             {
@@ -368,6 +288,4 @@ private void AssertParityForEveryConfig(IReadOnlyList<ResolvedEvent> corpus, int
 
         Assert.True(failures.Count == 0, Describe(failures));
     }
-
-    private readonly record struct SortConfig(ColumnName? OrderBy, bool IsDescending, ColumnName? GroupBy, bool IsGroupDescending);
 }
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/ColumnDirectSortTieBreakTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/ColumnDirectSortTieBreakTests.cs
new file mode 100644
index 000000000..cd968dd75
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/ColumnDirectSortTieBreakTests.cs
@@ -0,0 +1,60 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.Channels;
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
+using EventLogExpert.Runtime.LogTable;
+using EventLogExpert.Runtime.Tests.LogTable.TestSupport;
+
+namespace EventLogExpert.Runtime.Tests.LogTable;
+
+public sealed class ColumnDirectSortTieBreakTests
+{
+    [Fact]
+    public void HeavyTies_ColumnDirectSort_TieBreaksByPhysicalIndex()
+    {
+        long?[] recordIds = [5, null, 5, 2, null, 5, 2, 8, null, 2];
+        ResolvedEvent[] events = [.. recordIds.Select(BuildTiedEvent)];
+
+        EventLogId logId = EventLogId.Create();
+        IEventColumnReader reader = EventColumnStore.Build(events, generation: 0, contentVersion: 0).CreateReader(logId);
+        int[] survivors = [.. Enumerable.Range(0, events.Length)];
+
+        AssertTiedOrder(reader, events, survivors, new SortContext(ColumnName.Source, false, null, false),
+            [1, 4, 8, 3, 6, 9, 0, 2, 5, 7]);
+        AssertTiedOrder(reader, events, survivors, new SortContext(ColumnName.Source, true, null, false),
+            [7, 0, 2, 5, 3, 6, 9, 1, 4, 8]);
+    }
+
+    private static void AssertTiedOrder(
+        IEventColumnReader reader,
+        IReadOnlyList<ResolvedEvent> events,
+        int[] survivors,
+        SortContext context,
+        int[] expectedPhysical)
+    {
+        int[] production = ColumnDirectSort.SortColumnDirect(
+            reader, survivors, context.OrderBy, context.IsDescending, context.GroupBy, context.IsGroupDescending);
+
+        Assert.Equal(expectedPhysical, production);
+
+        int[] oracle = AosReferenceOrdering.Order(
+            events, context.OrderBy, context.IsDescending, context.GroupBy, context.IsGroupDescending);
+
+        Assert.Equal(expectedPhysical, oracle);
+    }
+
+    private static ResolvedEvent BuildTiedEvent(long? recordId) =>
+        new("HeavyTies", LogPathType.Channel)
+        {
+            RecordId = recordId,
+            TimeCreated = new DateTime(2026, 6, 1, 12, 0, 0, DateTimeKind.Utc),
+            Id = 1000,
+            Level = "Information",
+            Source = "Provider.A",
+            TaskCategory = "Logon",
+            ComputerName = "HOST-1",
+            LogName = "Channel0"
+        };
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/CombinedColumnViewDifferentialTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/CombinedColumnViewDifferentialTests.cs
deleted file mode 100644
index 440e46709..000000000
--- a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/CombinedColumnViewDifferentialTests.cs
+++ /dev/null
@@ -1,307 +0,0 @@
-// // Copyright (c) Microsoft Corporation.
-// // Licensed under the MIT License.
-
-using EventLogExpert.Eventing.Common.Channels;
-using EventLogExpert.Eventing.Common.EventLogs;
-using EventLogExpert.Eventing.Common.Events;
-using EventLogExpert.Runtime.LogTable;
-using EventLogExpert.Runtime.Tests.LogTable.TestSupport;
-using EventLogExpert.Runtime.Tests.TestUtils;
-
-namespace EventLogExpert.Runtime.Tests.LogTable;
-
-/// <summary>
-///     Differential parity for <see cref="CombinedColumnView" /> (the live SoA multi-log backing) against the
-///     relocated AoS <c>ReferenceCombinedView</c> oracle, locking the column-direct K-way merge for the operations
-///     selection and the highlight cache depend on: <c>Count</c>, <c>LocatorAt</c>, <c>Rank</c>, <c>ResolveByKey</c>, and
-///     a re-merge after a per-log append.
-/// </summary>
-public sealed class CombinedColumnViewDifferentialTests
-{
-    private static readonly string[] s_computers = ["HOST-1", "HOST-2"];
-    private static readonly ColumnName?[] s_groupBys = [null, ColumnName.Source, ColumnName.Level];
-    private static readonly string[] s_levels = ["Information", "Warning", "Error", "Critical"];
-    private static readonly ColumnName?[] s_orderBys =
-        [null, ColumnName.DateAndTime, ColumnName.Source, ColumnName.Level, ColumnName.EventId];
-    private static readonly string[] s_sources = ["Provider.A", "Provider.B", "Provider.C"];
-    private static readonly string[] s_tasks = ["", "Logon", "Service"];
-
-    [Fact]
-    public void CombinedColumnView_MatchesReferenceOracle_AfterPerLogReMerge()
-    {
-        // Design SS14 test 15: appending to one log and re-merging must keep the combined column view aligned with the
-        // AoS oracle (both Rank/LocatorAt/ResolveByKey and merged order) at the same and grown corpus.
-        var corpus = new Corpus(seed: 31337, logCount: 3);
-        corpus.SeedInterleaved(totalEvents: 210);
-
-        var contexts = new[]
-        {
-            new SortContext(ColumnName.DateAndTime, true, null, false),
-            new SortContext(ColumnName.Source, false, ColumnName.Level, false),
-        };
-
-        foreach (var context in contexts)
-        {
-            var (column, oracle) = corpus.BuildViews(context);
-            AssertParity(column, oracle, corpus, $"initial orderBy={context.OrderBy}");
-        }
-
-        corpus.Append(logIndex: 1, count: 75);
-
-        foreach (var context in contexts)
-        {
-            var (column, oracle) = corpus.BuildViews(context);
-            AssertParity(column, oracle, corpus, $"after-append orderBy={context.OrderBy}");
-        }
-    }
-
-    [Theory]
-    [InlineData(1)]
-    [InlineData(42)]
-    [InlineData(2026)]
-    [InlineData(8675309)]
-    public void CombinedColumnView_MatchesReferenceOracle_OverRandomContexts(int seed)
-    {
-        var corpus = new Corpus(seed, logCount: 2 + (seed % 3));
-        corpus.SeedInterleaved(totalEvents: 300);
-
-        foreach (var orderBy in s_orderBys)
-        {
-            foreach (var groupBy in s_groupBys)
-            {
-                foreach (bool descending in new[] { true, false })
-                {
-                    var context = new SortContext(orderBy, descending, groupBy, false);
-                    var (column, oracle) = corpus.BuildViews(context);
-
-                    AssertParity(column, oracle, corpus, $"seed={seed} orderBy={orderBy} groupBy={groupBy} desc={descending}");
-                }
-            }
-        }
-    }
-
-    private static void AssertParity(CombinedColumnView column, ReferenceCombinedView oracle, Corpus corpus, string label)
-    {
-        Assert.Equal(oracle.Count, column.Count);
-
-        // Merged order (LocatorAt) and Rank parity at every position: the corpus is totally ordered, so the SoA
-        // column-direct merge and the AoS oracle must resolve identically, row for row.
-        for (int i = 0; i < oracle.Count; i++)
-        {
-            var locator = column.LocatorAt(i);
-            int columnRank = column.Rank(locator);
-
-            Assert.True(SameEvent(oracle[i], column.GetDetailLean(locator)), $"LocatorAt/order mismatch at {label}[{i}].");
-            Assert.Equal(i, columnRank);
-            Assert.Equal(oracle.Rank(oracle[i]), columnRank);
-        }
-
-        // ResolveByKey parity: the SoA value-key resolve must land on the same event (and rank) as the AoS
-        // reference-or-equivalent-key resolve for a spread of in-corpus events.
-        foreach (var probe in corpus.SampleEvents())
-        {
-            var oracleResolved = oracle.ResolveByKey(probe);
-            Assert.NotNull(oracleResolved);
-
-            Assert.True(ValueKey.TryCreate(probe, out var key));
-
-            var columnLocator = column.ResolveByKey(key);
-            Assert.NotNull(columnLocator);
-
-            Assert.True(
-                SameEvent(oracleResolved, column.GetDetailLean(columnLocator.Value)),
-                $"ResolveByKey target mismatch at {label}.");
-            Assert.Equal(oracle.Rank(oracleResolved), column.Rank(columnLocator.Value));
-        }
-
-        // An event from an absent log resolves to nothing in either view.
-        var foreign = new ResolvedEvent("AbsentLog", LogPathType.Channel)
-        {
-            RecordId = long.MaxValue,
-            TimeCreated = new DateTime(2020, 1, 1, 0, 0, 0, DateTimeKind.Utc),
-            Id = 1,
-            Source = "Provider.A",
-            Level = "Information"
-        };
-
-        Assert.Equal(-1, oracle.Rank(foreign));
-        Assert.Null(oracle.ResolveByKey(foreign));
-        Assert.True(ValueKey.TryCreate(foreign, out var foreignKey));
-        Assert.Null(column.ResolveByKey(foreignKey));
-        Assert.Equal(-1, column.Rank(new EventLocator(EventLogId.Create(), 0, 0)));
-    }
-
-    private static bool SameEvent(ResolvedEvent expected, ResolvedEvent actual) =>
-        expected.RecordId == actual.RecordId
-        && expected.TimeCreated == actual.TimeCreated
-        && expected.Id == actual.Id
-        && expected.LogPathType == actual.LogPathType
-        && string.Equals(expected.OwningLog, actual.OwningLog, StringComparison.Ordinal)
-        && string.Equals(expected.Level, actual.Level, StringComparison.Ordinal)
-        && string.Equals(expected.Source, actual.Source, StringComparison.Ordinal)
-        && string.Equals(expected.TaskCategory, actual.TaskCategory, StringComparison.Ordinal);
-
-    private sealed class Corpus
-    {
-        private readonly EventLogId[] _logIds;
-        private readonly long[] _nextRecordId;
-        private readonly List<List<ResolvedEvent>> _perLog;
-        private readonly Random _rng;
-
-        private DateTime _clock = new(2026, 1, 1, 0, 0, 0, DateTimeKind.Utc);
-
-        public Corpus(int seed, int logCount)
-        {
-            _rng = new Random(seed);
-            _perLog = new List<List<ResolvedEvent>>(logCount);
-            _logIds = new EventLogId[logCount];
-            _nextRecordId = new long[logCount];
-
-            for (int k = 0; k < logCount; k++)
-            {
-                _perLog.Add([]);
-                _logIds[k] = EventLogId.Create();
-                _nextRecordId[k] = 1;
-            }
-        }
-
-        public void Append(int logIndex, int count)
-        {
-            for (int i = 0; i < count; i++) { AppendOne(logIndex); }
-        }
-
-        public (CombinedColumnView Column, ReferenceCombinedView Oracle) BuildViews(SortContext context)
-        {
-            var columnViews = new List<EventColumnView>(_perLog.Count);
-
-            for (int k = 0; k < _perLog.Count; k++)
-            {
-                columnViews.Add(DisplayViewTestFactory.Build(_logIds[k], _perLog[k], context));
-            }
-
-            return (new CombinedColumnView(columnViews, context), new ReferenceCombinedView(_perLog, context));
-        }
-
-        public IEnumerable<ResolvedEvent> SampleEvents()
-        {
-            foreach (var log in _perLog)
-            {
-                if (log.Count == 0) { continue; }
-
-                foreach (int index in new[] { 0, log.Count / 4, log.Count / 2, (3 * log.Count) / 4, log.Count - 1 })
-                {
-                    yield return log[index];
-                }
-            }
-        }
-
-        public void SeedInterleaved(int totalEvents)
-        {
-            // Guarantee every log is non-empty so every log participates in the merge, then interleave the rest at random
-            // so the logs weave together in the merged stream.
-            for (int k = 0; k < _perLog.Count; k++) { AppendOne(k); }
-
-            for (int i = _perLog.Count; i < totalEvents; i++) { AppendOne(_rng.Next(_perLog.Count)); }
-        }
-
-        private void AppendOne(int logIndex)
-        {
-            _clock = _clock.AddMilliseconds(1 + _rng.Next(50)); // globally unique + monotonic -> a total order
-
-            _perLog[logIndex].Add(new ResolvedEvent($"Log{logIndex}", LogPathType.Channel)
-            {
-                RecordId = _nextRecordId[logIndex]++,
-                TimeCreated = _clock,
-                Id = 1000 + _rng.Next(6),
-                Level = s_levels[_rng.Next(s_levels.Length)],
-                Source = s_sources[_rng.Next(s_sources.Length)],
-                TaskCategory = s_tasks[_rng.Next(s_tasks.Length)],
-                ComputerName = s_computers[_rng.Next(s_computers.Length)]
-            });
-        }
-    }
-
-    // Test-only re-implementation of the deleted AoS CombinedEventView oracle over a reference-sorted flattened list. The
-    // corpus is totally ordered (distinct OwningLog per log, globally unique monotonic clock, per-log RecordId), so the
-    // K-way merge the production oracle performed collapses to sorting the concatenated events by the reference comparer;
-    // Rank/ResolveByKey reproduce the oracle's reference-or-value-key window match verbatim.
-    private sealed class ReferenceCombinedView
-    {
-        private readonly Comparison<ResolvedEvent> _comparer;
-        private readonly ResolvedEvent[] _merged;
-
-        public ReferenceCombinedView(IReadOnlyList<IReadOnlyList<ResolvedEvent>> perLog, SortContext context)
-        {
-            var flattened = new List<ResolvedEvent>();
-
-            foreach (var log in perLog) { flattened.AddRange(log); }
-
-            _comparer = AosReferenceOrdering.Reference(
-                context.OrderBy, context.IsDescending, context.GroupBy, context.IsGroupDescending);
-
-            int[] order = AosReferenceOrdering.Order(
-                flattened, context.OrderBy, context.IsDescending, context.GroupBy, context.IsGroupDescending);
-            _merged = new ResolvedEvent[order.Length];
-
-            for (int i = 0; i < order.Length; i++) { _merged[i] = flattened[order[i]]; }
-        }
-
-        public int Count => _merged.Length;
-
-        public ResolvedEvent this[int index] => _merged[index];
-
-        public int Rank(ResolvedEvent target)
-        {
-            ArgumentNullException.ThrowIfNull(target);
-
-            for (int i = LowerBound(target); i < _merged.Length && _comparer(_merged[i], target) == 0; i++)
-            {
-                if (Matches(_merged[i], target)) { return i; }
-            }
-
-            return -1;
-        }
-
-        public ResolvedEvent? ResolveByKey(ResolvedEvent candidate)
-        {
-            ArgumentNullException.ThrowIfNull(candidate);
-
-            for (int i = LowerBound(candidate); i < _merged.Length && _comparer(_merged[i], candidate) == 0; i++)
-            {
-                if (Matches(_merged[i], candidate)) { return _merged[i]; }
-            }
-
-            return null;
-        }
-
-        // Reference first, then the (RecordId + time + OwningLog + LogName) value key; a null RecordId never matches by key
-        // so distinct error-read events stay separate - identical to the deleted oracle's window scan.
-        private static bool Matches(ResolvedEvent current, ResolvedEvent target)
-        {
-            if (ReferenceEquals(current, target)) { return true; }
-
-            if (current.RecordId is null || target.RecordId is null) { return false; }
-
-            return current.RecordId == target.RecordId
-                && current.TimeCreated == target.TimeCreated
-                && string.Equals(current.OwningLog, target.OwningLog, StringComparison.Ordinal)
-                && string.Equals(current.LogName, target.LogName, StringComparison.Ordinal);
-        }
-
-        private int LowerBound(ResolvedEvent target)
-        {
-            int low = 0;
-            int high = _merged.Length;
-
-            while (low < high)
-            {
-                int mid = low + ((high - low) >> 1);
-
-                if (_comparer(_merged[mid], target) < 0) { low = mid + 1; }
-                else { high = mid; }
-            }
-
-            return low;
-        }
-    }
-}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/DisplayIndicatorGateTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/DisplayIndicatorGateTests.cs
new file mode 100644
index 000000000..55458bfe9
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/DisplayIndicatorGateTests.cs
@@ -0,0 +1,314 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.Channels;
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
+using EventLogExpert.Runtime.LogTable;
+using EventLogExpert.Runtime.Tests.TestUtils;
+using System.Diagnostics;
+using static EventLogExpert.Runtime.Tests.LogTable.TestSupport.DisplayIndicatorTestFactory;
+
+namespace EventLogExpert.Runtime.Tests.LogTable;
+
+public sealed class DisplayIndicatorGateTests
+{
+    private static readonly TimeSpan s_testTimeout = TimeSpan.FromSeconds(5);
+
+    [Fact]
+    public void AFaultLandingMidSort_ReArms_BecauseItIsADifferentKindEvenThoughSomethingWasAlreadyOwed()
+    {
+        using var world = new Gate();
+
+        world.Publish(DisplayIndicatorKind.ReorderPending);
+        world.ElapseUntilFired();
+
+        Assert.True(world.IsFired(DisplayIndicatorKind.ReorderPending));
+
+        world.Publish(DisplayIndicatorKind.Fault);
+
+        Assert.False(world.IsFired(DisplayIndicatorKind.Fault), "the fault must serve its own delay");
+
+        world.ElapseUntilFired();
+
+        Assert.True(world.IsFired(DisplayIndicatorKind.Fault));
+    }
+
+    [Fact]
+    public void AGateBuiltOverAnAlreadyPendingDisplay_ArmsFromWhatIsAlreadyOnScreen()
+    {
+        var source = new FakeSource(PresentationFor(DisplayIndicatorKind.EmptyPending, revision: 7));
+        var delay = new ControllableDelay();
+
+        using var gate = new DisplayIndicatorGate(source, delay.Delay);
+
+        Assert.Single(delay.Requested);
+
+        delay.Elapse();
+        WaitUntil(() => gate.IsFiredFor(DisplayIndicatorKind.EmptyPending, 7));
+    }
+
+    [Fact]
+    public void AKindThatEndsBeforeItsDelay_NeverBecomesWorthShowing()
+    {
+        using var world = new Gate();
+
+        world.Publish(DisplayIndicatorKind.EmptyPending);
+        world.Publish(DisplayIndicatorKind.None);
+        world.ElapseExpectingNothing();
+
+        Assert.False(world.IsFired(DisplayIndicatorKind.EmptyPending));
+    }
+
+    [Fact]
+    public void AKindThatRecurs_ServesItsOwnDelayEachTime_RatherThanResumingTheFirstOne()
+    {
+        using var world = new Gate();
+
+        world.Publish(DisplayIndicatorKind.EmptyPending);
+        world.ElapseUntilFired();
+
+        Assert.True(world.IsFired(DisplayIndicatorKind.EmptyPending));
+
+        world.Publish(DisplayIndicatorKind.ReorderPending);
+        world.Publish(DisplayIndicatorKind.EmptyPending);
+
+        Assert.False(
+            world.IsFired(DisplayIndicatorKind.EmptyPending),
+            "the second empty indicator must serve its own delay");
+    }
+
+    [Fact]
+    public void ASupersededIndicator_CannotFire_EvenIfItsDelayCompletesAfterBeingReplaced()
+    {
+        using var world = new Gate();
+
+        long supersededRevision = world.Publish(DisplayIndicatorKind.EmptyPending);
+
+        world.Publish(DisplayIndicatorKind.ReorderPending);
+
+        world.ElapseIgnoringCancellationUntilFired(expectedAnnouncements: 1);
+
+        Assert.False(
+            world.IsFired(DisplayIndicatorKind.EmptyPending, supersededRevision),
+            "the superseded indicator must not fire even though its own delay completed");
+
+        Assert.True(world.IsFired(DisplayIndicatorKind.ReorderPending), "the live indicator must still fire");
+    }
+
+    [Fact]
+    public void ASurfaceStillPaintingAnEarlierFrame_IsAnsweredAboutItsOwnFrame_NotTheOneItHasNotSeen()
+    {
+        using var world = new Gate();
+
+        long laggingRevision = world.Publish(DisplayIndicatorKind.Fault);
+
+        world.ElapseUntilFired();
+
+        Assert.True(world.IsFired(DisplayIndicatorKind.Fault, laggingRevision));
+
+        world.Publish(DisplayIndicatorKind.None);
+        world.Publish(DisplayIndicatorKind.Fault);
+
+        Assert.True(
+            world.IsFired(DisplayIndicatorKind.Fault, laggingRevision),
+            "a surface on the older frame must still see the indicator that was current for it");
+
+        Assert.False(
+            world.IsFired(DisplayIndicatorKind.Fault, world.Revision),
+            "a surface on the newest frame must see the re-armed indicator, which has not fired");
+    }
+
+    [Fact]
+    public void AnElapsedOnset_IsAnnounced_BecauseNoPublicationDescribesIt()
+    {
+        using var world = new Gate();
+
+        world.Publish(DisplayIndicatorKind.EmptyPending);
+
+        Assert.Equal(0, world.Announcements);
+
+        world.ElapseUntilFired();
+
+        Assert.Equal(1, world.Announcements);
+    }
+
+    [Fact]
+    public void OrdinaryRepublication_DoesNotRestartTheDelay()
+    {
+        using var world = new Gate();
+
+        world.Publish(DisplayIndicatorKind.EmptyPending);
+        world.Publish(DisplayIndicatorKind.EmptyPending);
+        world.Publish(DisplayIndicatorKind.EmptyPending);
+
+        Assert.Single(world.RequestedDelays);
+
+        world.ElapseUntilFired();
+
+        Assert.True(world.IsFired(DisplayIndicatorKind.EmptyPending));
+    }
+
+    [Fact]
+    public void TheDelayAsked_IsTheOneTheUserAgreed()
+    {
+        using var world = new Gate();
+
+        world.Publish(DisplayIndicatorKind.ReorderPending);
+
+        Assert.Equal(TimeSpan.FromMilliseconds(200), Assert.Single(world.RequestedDelays));
+    }
+
+    private static void WaitUntil(Func<bool> condition)
+    {
+        var deadline = Stopwatch.StartNew();
+
+        while (!condition())
+        {
+            Assert.True(deadline.Elapsed < s_testTimeout, "the gate never reached the expected state");
+
+            Thread.Sleep(1);
+        }
+    }
+
+    private sealed class ControllableDelay
+    {
+        private readonly List<Pending> _pending = [];
+        private readonly Lock _sync = new();
+
+        public List<TimeSpan> Requested { get; } = [];
+
+        public Task Delay(TimeSpan duration, CancellationToken token)
+        {
+            var completion = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+
+            lock (_sync)
+            {
+                Requested.Add(duration);
+                _pending.Add(new Pending(completion, token));
+            }
+
+            return completion.Task;
+        }
+
+        public void Elapse()
+        {
+            foreach (var pending in Take())
+            {
+                if (pending.Token.IsCancellationRequested)
+                {
+                    pending.Completion.TrySetCanceled(pending.Token);
+                }
+                else
+                {
+                    pending.Completion.TrySetResult();
+                }
+            }
+        }
+
+        public void ElapseIgnoringCancellation()
+        {
+            foreach (var pending in Take()) { pending.Completion.TrySetResult(); }
+        }
+
+        private Pending[] Take()
+        {
+            lock (_sync)
+            {
+                Pending[] outstanding = [.. _pending];
+
+                _pending.Clear();
+
+                return outstanding;
+            }
+        }
+
+        private sealed record Pending(TaskCompletionSource Completion, CancellationToken Token);
+    }
+
+    private sealed class FakeSource(OrderedViewPresentation initial) : IOrderedViewSource
+    {
+        public event Action<OrderedViewPresentation>? Updated;
+
+        public OrderedViewPresentation Current { get; private set; } = initial;
+
+        public void Publish(OrderedViewPresentation presentation)
+        {
+            Current = presentation;
+
+            Updated?.Invoke(presentation);
+        }
+    }
+
+    private sealed class Gate : IDisposable
+    {
+        private static readonly TimeSpan SettleWindow = TimeSpan.FromMilliseconds(100);
+
+        private readonly ControllableDelay _delay = new();
+        private readonly DisplayIndicatorGate _gate;
+        private readonly FakeSource _source;
+
+        private int _announcements;
+
+        public Gate()
+        {
+            _source = new FakeSource(PresentationFor(DisplayIndicatorKind.None, revision: 0));
+            _gate = new DisplayIndicatorGate(_source, _delay.Delay);
+            _gate.OnsetElapsed += () => Interlocked.Increment(ref _announcements);
+        }
+
+        public int Announcements => Volatile.Read(ref _announcements);
+
+        public IReadOnlyList<TimeSpan> RequestedDelays => _delay.Requested;
+
+        public long Revision { get; private set; }
+
+        public void Dispose() => _gate.Dispose();
+
+        public void ElapseExpectingNothing()
+        {
+            int before = Announcements;
+
+            _delay.Elapse();
+
+            Thread.Sleep(SettleWindow);
+
+            Assert.Equal(before, Announcements);
+        }
+
+        public void ElapseIgnoringCancellationUntilFired(int expectedAnnouncements)
+        {
+            int before = Announcements;
+
+            _delay.ElapseIgnoringCancellation();
+
+            WaitUntil(() => Announcements >= before + expectedAnnouncements);
+
+            Thread.Sleep(SettleWindow);
+
+            Assert.Equal(before + expectedAnnouncements, Announcements);
+        }
+
+        public void ElapseUntilFired()
+        {
+            int before = Announcements;
+
+            _delay.Elapse();
+
+            WaitUntil(() => Announcements > before);
+        }
+
+        public bool IsFired(DisplayIndicatorKind kind) => IsFired(kind, Revision);
+
+        public bool IsFired(DisplayIndicatorKind kind, long revision) => _gate.IsFiredFor(kind, revision);
+
+        public long Publish(DisplayIndicatorKind kind)
+        {
+            Revision++;
+
+            _source.Publish(PresentationFor(kind, Revision));
+
+            return Revision;
+        }
+    }
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/DisplayIndicatorKindTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/DisplayIndicatorKindTests.cs
new file mode 100644
index 000000000..63e4def14
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/DisplayIndicatorKindTests.cs
@@ -0,0 +1,95 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.Channels;
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
+using EventLogExpert.Runtime.LogTable;
+using EventLogExpert.Runtime.Tests.TestUtils;
+
+namespace EventLogExpert.Runtime.Tests.LogTable;
+
+public sealed class DisplayIndicatorKindTests
+{
+    [Fact]
+    public void CurrentWithNoRows_OwesNothing_BecauseTheEmptinessIsTheAnswer()
+    {
+        Assert.Equal(DisplayIndicatorKind.None, Presentation(rows: 0, PresentationState.Current).IndicatorKind);
+    }
+
+    [Fact]
+    public void CurrentWithRows_OwesNothing()
+    {
+        Assert.Equal(DisplayIndicatorKind.None, Presentation(rows: 3, PresentationState.Current).IndicatorKind);
+    }
+
+    [Fact]
+    public void FaultedWithNoRows_OwesTheFault()
+    {
+        Assert.Equal(DisplayIndicatorKind.Fault, Presentation(rows: 0, PresentationState.Faulted).IndicatorKind);
+    }
+
+    [Fact]
+    public void FaultedWithRows_OwesTheFault_NotTheReorderItAlsoSatisfies()
+    {
+        var faultedMidSort = Presentation(rows: 3, PresentationState.Faulted, orderingIsStale: true);
+
+        Assert.Equal(DisplayIndicatorKind.Fault, faultedMidSort.IndicatorKind);
+    }
+
+    [Fact]
+    public void UpdatingWithNoRows_OwesTheEmptyExplanation_EvenWhenASortIsAlsoPending()
+    {
+        var emptyAndReordering = Presentation(rows: 0, PresentationState.Updating, orderingIsStale: true);
+
+        Assert.Equal(DisplayIndicatorKind.EmptyPending, emptyAndReordering.IndicatorKind);
+    }
+
+    [Fact]
+    public void UpdatingWithRowsAndAPendingReorder_OwesTheReorder()
+    {
+        var reordering = Presentation(rows: 3, PresentationState.Updating, orderingIsStale: true);
+
+        Assert.Equal(DisplayIndicatorKind.ReorderPending, reordering.IndicatorKind);
+    }
+
+    [Fact]
+    public void UpdatingWithRowsAndNoPendingReorder_OwesNothing_SoOrdinaryLiveTailDoesNotNag()
+    {
+        Assert.Equal(DisplayIndicatorKind.None, Presentation(rows: 3, PresentationState.Updating).IndicatorKind);
+    }
+
+    private static ResolvedEvent Event(int recordId) =>
+        new("TestLog", LogPathType.Channel)
+        {
+            RecordId = recordId,
+            TimeCreated = new DateTime(2026, 1, 1, 0, 0, 0, DateTimeKind.Utc).AddMilliseconds(recordId),
+            Id = 1000,
+            Level = "Information",
+            Source = "Alpha",
+            LogName = "TestLog"
+        };
+
+    private static OrderedViewPresentation Presentation(
+        int rows,
+        PresentationState state,
+        bool orderingIsStale = false)
+    {
+        var logId = EventLogId.Create();
+
+        IEventColumnView view = rows == 0 ?
+            LogTableState.EmptyView :
+            DisplayViewTestFactory.Build(logId, [.. Enumerable.Range(1, rows).Select(Event)]);
+
+        Assert.Equal(rows, view.Count);
+
+        return new OrderedViewPresentation(
+            view,
+            logId,
+            default,
+            state,
+            Revision: 1,
+            FaultCause: state == PresentationState.Faulted ? "InvalidOperationException: bad predicate" : null,
+            OrderingIsStale: orderingIsStale);
+    }
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/DisplayIndicatorStateTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/DisplayIndicatorStateTests.cs
new file mode 100644
index 000000000..1d31e866d
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/DisplayIndicatorStateTests.cs
@@ -0,0 +1,346 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.Channels;
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
+using EventLogExpert.Runtime.LogTable;
+using EventLogExpert.Runtime.Tests.TestUtils;
+using System.Diagnostics;
+using static EventLogExpert.Runtime.Tests.LogTable.TestSupport.DisplayIndicatorTestFactory;
+
+namespace EventLogExpert.Runtime.Tests.LogTable;
+
+public sealed class DisplayIndicatorStateTests
+{
+    private static readonly TimeSpan s_testTimeout = TimeSpan.FromSeconds(5);
+
+    [Fact]
+    public void AConditionBecomingWorthShowing_AsksForARender_BecauseNoPublicationSaysSo()
+    {
+        using var surface = new Surface();
+
+        surface.Publish(DisplayIndicatorKind.EmptyPending);
+
+        int before = surface.RenderRequests;
+
+        surface.ElapseOnset();
+
+        WaitUntil(() => surface.RenderRequests > before);
+    }
+
+    [Fact]
+    public void AConditionThatEndsFirst_ShowsNothingAtAll()
+    {
+        using var surface = new Surface();
+
+        surface.Publish(DisplayIndicatorKind.EmptyPending);
+
+        Assert.Equal(DisplayedIndicator.Nothing, surface.Paint(DisplayIndicatorKind.EmptyPending));
+
+        surface.Publish(DisplayIndicatorKind.None);
+
+        Assert.Equal(DisplayedIndicator.Nothing, surface.Paint(DisplayIndicatorKind.None));
+    }
+
+    [Fact]
+    public void AConditionThatServesItsDelay_ShowsItsOwnSentence()
+    {
+        using var surface = new Surface();
+
+        surface.Publish(DisplayIndicatorKind.EmptyPending);
+        surface.ElapseOnset();
+
+        var shown = surface.Paint(DisplayIndicatorKind.EmptyPending);
+
+        Assert.Equal(DisplayIndicatorKind.EmptyPending, shown.Sentence);
+        Assert.True(shown.Spinner);
+    }
+
+    [Fact]
+    public void ARepaintingSurface_DoesNotKeepRestartingTheFloor()
+    {
+        using var surface = new Surface();
+
+        surface.Publish(DisplayIndicatorKind.EmptyPending);
+        surface.ElapseOnset();
+
+        surface.Paint(DisplayIndicatorKind.EmptyPending);
+        surface.Paint(DisplayIndicatorKind.EmptyPending);
+        surface.Paint(DisplayIndicatorKind.EmptyPending);
+
+        Assert.Single(surface.FloorDelaysRequested);
+    }
+
+    [Fact]
+    public void ASpinnerAlreadyOnScreen_StaysForItsMinimumEvenAfterEverythingSettles()
+    {
+        using var surface = new Surface();
+
+        surface.Publish(DisplayIndicatorKind.EmptyPending);
+        surface.ElapseOnset();
+        surface.Paint(DisplayIndicatorKind.EmptyPending);
+
+        surface.Publish(DisplayIndicatorKind.None);
+
+        var settledButFloored = surface.Paint(DisplayIndicatorKind.None);
+
+        Assert.Equal(DisplayIndicatorKind.None, settledButFloored.Sentence);
+        Assert.True(settledButFloored.Spinner, "the spinner owes its minimum visible time");
+
+        surface.ElapseFloor();
+
+        Assert.Equal(DisplayedIndicator.Nothing, surface.Paint(DisplayIndicatorKind.None));
+    }
+
+    [Fact]
+    public void ASurfaceWhoseRowsAreStillArriving_KeepsTheSpinnerAfterTheStateSettles()
+    {
+        using var surface = new Surface();
+
+        surface.Publish(DisplayIndicatorKind.EmptyPending);
+        surface.ElapseOnset();
+        surface.Paint(DisplayIndicatorKind.EmptyPending);
+
+        surface.Publish(DisplayIndicatorKind.None);
+        surface.ElapseFloor();
+
+        Assert.True(
+            surface.Paint(DisplayIndicatorKind.None, surfaceStillCatchingUp: true).Spinner,
+            "the rows have not landed yet");
+
+        Assert.Equal(
+            DisplayedIndicator.Nothing,
+            surface.Paint(DisplayIndicatorKind.None, surfaceStillCatchingUp: false));
+    }
+
+    [Fact]
+    public void ASwapBetweenTwoConditions_DropsTheOldSentenceImmediatelyAndKeepsAGenericSpinner()
+    {
+        using var surface = new Surface();
+
+        surface.Publish(DisplayIndicatorKind.ReorderPending);
+        surface.ElapseOnset();
+
+        Assert.Equal(DisplayIndicatorKind.ReorderPending, surface.Paint(DisplayIndicatorKind.ReorderPending).Sentence);
+
+        surface.Publish(DisplayIndicatorKind.Fault);
+
+        var duringTheSwap = surface.Paint(DisplayIndicatorKind.Fault);
+
+        Assert.Equal(DisplayIndicatorKind.None, duringTheSwap.Sentence);
+        Assert.True(duringTheSwap.Spinner, "the swap must not blink");
+
+        surface.ElapseOnset();
+
+        Assert.Equal(DisplayIndicatorKind.Fault, surface.Paint(DisplayIndicatorKind.Fault).Sentence);
+    }
+
+    [Fact]
+    public void AnExpiringFloor_AsksForARender_BecauseNothingElseWill()
+    {
+        using var surface = new Surface();
+
+        surface.Publish(DisplayIndicatorKind.EmptyPending);
+        surface.ElapseOnset();
+        surface.Paint(DisplayIndicatorKind.EmptyPending);
+        surface.Publish(DisplayIndicatorKind.None);
+        surface.Paint(DisplayIndicatorKind.None);
+
+        int before = surface.RenderRequests;
+
+        surface.ElapseFloor();
+
+        Assert.True(surface.RenderRequests > before, "the floor's expiry must ask for the paint that ends it");
+    }
+
+    [Fact]
+    public void NothingIsRetainedIfNothingWasEverShown()
+    {
+        using var surface = new Surface();
+
+        surface.Publish(DisplayIndicatorKind.EmptyPending);
+        surface.Paint(DisplayIndicatorKind.EmptyPending);
+
+        surface.Publish(DisplayIndicatorKind.Fault);
+
+        Assert.Equal(DisplayedIndicator.Nothing, surface.Paint(DisplayIndicatorKind.Fault));
+    }
+
+    [Fact]
+    public void TheFloorStartsAtThePaint_NotWhenTheConditionBecameWorthShowing()
+    {
+        using var surface = new Surface();
+
+        surface.Publish(DisplayIndicatorKind.EmptyPending);
+        surface.ElapseOnset();
+
+        Assert.Empty(surface.FloorDelaysRequested);
+
+        surface.Paint(DisplayIndicatorKind.EmptyPending);
+
+        Assert.Equal(TimeSpan.FromMilliseconds(300), Assert.Single(surface.FloorDelaysRequested));
+    }
+
+    [Fact]
+    public void TheSentenceIsNeverFloored_OnlyTheSpinnerIs()
+    {
+        using var surface = new Surface();
+
+        surface.Publish(DisplayIndicatorKind.ReorderPending);
+        surface.ElapseOnset();
+        surface.Paint(DisplayIndicatorKind.ReorderPending);
+
+        surface.Publish(DisplayIndicatorKind.None);
+
+        Assert.Equal(DisplayIndicatorKind.None, surface.Paint(DisplayIndicatorKind.None).Sentence);
+    }
+
+    private static void WaitUntil(Func<bool> condition)
+    {
+        var deadline = Stopwatch.StartNew();
+
+        while (!condition())
+        {
+            Assert.True(deadline.Elapsed < s_testTimeout, "the surface never reached the expected state");
+
+            Thread.Sleep(1);
+        }
+    }
+
+    private sealed class ControllableDelay
+    {
+        private readonly List<Pending> _pending = [];
+        private readonly Lock _sync = new();
+
+        public List<TimeSpan> Requested { get; } = [];
+
+        public Task Delay(TimeSpan duration, CancellationToken token)
+        {
+            var completion = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+
+            lock (_sync)
+            {
+                Requested.Add(duration);
+                _pending.Add(new Pending(completion, token));
+            }
+
+            return completion.Task;
+        }
+
+        public void Elapse()
+        {
+            Pending[] outstanding;
+
+            lock (_sync)
+            {
+                outstanding = [.. _pending];
+
+                _pending.Clear();
+            }
+
+            foreach (var pending in outstanding)
+            {
+                if (pending.Token.IsCancellationRequested)
+                {
+                    pending.Completion.TrySetCanceled(pending.Token);
+                }
+                else
+                {
+                    pending.Completion.TrySetResult();
+                }
+            }
+        }
+
+        private sealed record Pending(TaskCompletionSource Completion, CancellationToken Token);
+    }
+
+    private sealed class FakeSource(OrderedViewPresentation initial) : IOrderedViewSource
+    {
+        public event Action<OrderedViewPresentation>? Updated;
+
+        public OrderedViewPresentation Current { get; private set; } = initial;
+
+        public void Publish(OrderedViewPresentation presentation)
+        {
+            Current = presentation;
+
+            Updated?.Invoke(presentation);
+        }
+    }
+
+    private sealed class Surface : IDisposable
+    {
+        private readonly ControllableDelay _floorDelay = new();
+        private readonly DisplayIndicatorGate _gate;
+        private readonly ControllableDelay _onsetDelay = new();
+        private readonly FakeSource _source;
+        private readonly DisplayIndicatorState _state;
+
+        private int _renderRequests;
+
+        public Surface()
+        {
+            _source = new FakeSource(PresentationFor(DisplayIndicatorKind.None, revision: 0));
+            _gate = new DisplayIndicatorGate(_source, _onsetDelay.Delay);
+            _state = new DisplayIndicatorState(
+                _gate,
+                () => Interlocked.Increment(ref _renderRequests),
+                _floorDelay.Delay);
+        }
+
+        public IReadOnlyList<TimeSpan> FloorDelaysRequested => _floorDelay.Requested;
+
+        public int RenderRequests => Volatile.Read(ref _renderRequests);
+
+        private long Revision { get; set; }
+
+        public void Dispose()
+        {
+            _state.Dispose();
+            _gate.Dispose();
+        }
+
+        public void ElapseFloor()
+        {
+            int before = RenderRequests;
+
+            _floorDelay.Elapse();
+
+            WaitUntil(() => RenderRequests > before);
+        }
+
+        public void ElapseOnset()
+        {
+            bool announced = false;
+
+            void OnElapsed() => announced = true;
+
+            _gate.OnsetElapsed += OnElapsed;
+
+            try
+            {
+                _onsetDelay.Elapse();
+
+                WaitUntil(() => announced);
+            }
+            finally { _gate.OnsetElapsed -= OnElapsed; }
+        }
+
+        public DisplayedIndicator Paint(DisplayIndicatorKind kind, bool surfaceStillCatchingUp = false)
+        {
+            var shown = _state.Resolve(kind, Revision, surfaceStillCatchingUp);
+
+            _state.RecordPaint(shown);
+
+            return shown;
+        }
+
+        public void Publish(DisplayIndicatorKind kind)
+        {
+            Revision++;
+
+            _source.Publish(PresentationFor(kind, Revision));
+        }
+    }
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/EffectsTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/EffectsTests.cs
index 85b081d9d..13f109de3 100644
--- a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/EffectsTests.cs
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/EffectsTests.cs
@@ -1,6 +1,7 @@
 // // Copyright (c) Microsoft Corporation.
 // // Licensed under the MIT License.
 
+using EventLogExpert.Logging.Abstractions;
 using EventLogExpert.Runtime.LogTable;
 using Fluxor;
 using NSubstitute;
@@ -15,7 +16,6 @@ public sealed class EffectsTests
     [Fact]
     public async Task HandleLoadColumns_ShouldLoadAllColumnsFromPreferences()
     {
-        // Arrange
         var enabledColumns = new List<ColumnName>
         {
             ColumnName.Level,
@@ -25,10 +25,8 @@ public async Task HandleLoadColumns_ShouldLoadAllColumnsFromPreferences()
 
         var (effects, mockDispatcher, mockPreferencesProvider) = CreateEffects(enabledColumns);
 
-        // Act
         await effects.HandleLoadColumns(mockDispatcher);
 
-        // Assert
         mockDispatcher.Received(1).Dispatch(Arg.Is<LoadColumnsCompletedAction>(action =>
             action != null &&
             action.LoadedColumns.Count == Enum.GetValues<ColumnName>().Length));
@@ -37,7 +35,6 @@ public async Task HandleLoadColumns_ShouldLoadAllColumnsFromPreferences()
     [Fact]
     public async Task HandleLoadColumns_ShouldLoadWidthsFromPreferences()
     {
-        // Arrange
         var enabledColumns = new List<ColumnName> { ColumnName.Level };
         var savedWidths = new Dictionary<ColumnName, int>
         {
@@ -47,10 +44,8 @@ public async Task HandleLoadColumns_ShouldLoadWidthsFromPreferences()
         var (effects, mockDispatcher, mockPreferencesProvider) = CreateEffects(enabledColumns);
         mockPreferencesProvider.ColumnWidthsPreference.Returns(savedWidths);
 
-        // Act
         await effects.HandleLoadColumns(mockDispatcher);
 
-        // Assert
         mockDispatcher.Received(1).Dispatch(Arg.Is<LoadColumnsCompletedAction>(action =>
             action != null &&
             action.ColumnWidths[ColumnName.Level] == 150));
@@ -59,7 +54,6 @@ public async Task HandleLoadColumns_ShouldLoadWidthsFromPreferences()
     [Fact]
     public async Task HandleLoadColumns_ShouldMarkDisabledColumnsAsFalse()
     {
-        // Arrange
         var enabledColumns = new List<ColumnName>
         {
             ColumnName.Level
@@ -67,10 +61,8 @@ public async Task HandleLoadColumns_ShouldMarkDisabledColumnsAsFalse()
 
         var (effects, mockDispatcher, mockPreferencesProvider) = CreateEffects(enabledColumns);
 
-        // Act
         await effects.HandleLoadColumns(mockDispatcher);
 
-        // Assert
         mockDispatcher.Received(1).Dispatch(Arg.Is<LoadColumnsCompletedAction>(action =>
             action != null &&
             action.LoadedColumns[ColumnName.Source] == false &&
@@ -80,7 +72,6 @@ public async Task HandleLoadColumns_ShouldMarkDisabledColumnsAsFalse()
     [Fact]
     public async Task HandleLoadColumns_ShouldMarkEnabledColumnsAsTrue()
     {
-        // Arrange
         var enabledColumns = new List<ColumnName>
         {
             ColumnName.Level,
@@ -89,10 +80,8 @@ public async Task HandleLoadColumns_ShouldMarkEnabledColumnsAsTrue()
 
         var (effects, mockDispatcher, mockPreferencesProvider) = CreateEffects(enabledColumns);
 
-        // Act
         await effects.HandleLoadColumns(mockDispatcher);
 
-        // Assert
         mockDispatcher.Received(1).Dispatch(Arg.Is<LoadColumnsCompletedAction>(action =>
             action != null &&
             action.LoadedColumns[ColumnName.Level] == true &&
@@ -102,15 +91,12 @@ public async Task HandleLoadColumns_ShouldMarkEnabledColumnsAsTrue()
     [Fact]
     public async Task HandleLoadColumns_ShouldUseDefaultOrderWhenNotSaved()
     {
-        // Arrange
         var enabledColumns = new List<ColumnName> { ColumnName.Level };
 
         var (effects, mockDispatcher, _) = CreateEffects(enabledColumns);
 
-        // Act
         await effects.HandleLoadColumns(mockDispatcher);
 
-        // Assert
         mockDispatcher.Received(1).Dispatch(Arg.Is<LoadColumnsCompletedAction>(action =>
             action != null &&
             action.ColumnOrder.SequenceEqual(s_columnDefaults.ColumnOrder)));
@@ -119,15 +105,12 @@ public async Task HandleLoadColumns_ShouldUseDefaultOrderWhenNotSaved()
     [Fact]
     public async Task HandleLoadColumns_ShouldUseDefaultWidthsWhenNotSaved()
     {
-        // Arrange
         var enabledColumns = new List<ColumnName> { ColumnName.Level };
 
         var (effects, mockDispatcher, _) = CreateEffects(enabledColumns);
 
-        // Act
         await effects.HandleLoadColumns(mockDispatcher);
 
-        // Assert
         mockDispatcher.Received(1).Dispatch(Arg.Is<LoadColumnsCompletedAction>(action =>
             action != null &&
             action.ColumnWidths[ColumnName.Level] == s_columnDefaults.GetColumnWidth(ColumnName.Level)));
@@ -136,17 +119,14 @@ public async Task HandleLoadColumns_ShouldUseDefaultWidthsWhenNotSaved()
     [Fact]
     public async Task HandleLoadColumns_ShouldUseSavedOrderWhenPresent()
     {
-        // Arrange
         var enabledColumns = new List<ColumnName> { ColumnName.Source, ColumnName.Level };
         var savedOrder = new List<ColumnName> { ColumnName.Source, ColumnName.Level };
 
         var (effects, mockDispatcher, mockPreferencesProvider) = CreateEffects(enabledColumns);
         mockPreferencesProvider.ColumnOrderPreference.Returns(savedOrder);
 
-        // Act
         await effects.HandleLoadColumns(mockDispatcher);
 
-        // Assert
         mockDispatcher.Received(1).Dispatch(Arg.Is<LoadColumnsCompletedAction>(action =>
             action != null &&
             action.ColumnOrder[0] == ColumnName.Source &&
@@ -156,15 +136,12 @@ public async Task HandleLoadColumns_ShouldUseSavedOrderWhenPresent()
     [Fact]
     public async Task HandleLoadColumns_WhenNoColumnsEnabled_ShouldMarkAllAsFalse()
     {
-        // Arrange
         var enabledColumns = new List<ColumnName>();
 
         var (effects, mockDispatcher, mockPreferencesProvider) = CreateEffects(enabledColumns);
 
-        // Act
         await effects.HandleLoadColumns(mockDispatcher);
 
-        // Assert
         mockDispatcher.Received(1).Dispatch(Arg.Is<LoadColumnsCompletedAction>(action =>
             action != null &&
             action.LoadedColumns.All(kvp => kvp.Value == false)));
@@ -173,7 +150,6 @@ public async Task HandleLoadColumns_WhenNoColumnsEnabled_ShouldMarkAllAsFalse()
     [Fact]
     public async Task HandleReorderColumn_ShouldPersistToPreferences()
     {
-        // Arrange - state reflects post-reducer result (Source moved to index 0)
         var postReducerState = new LogTableState
         {
             ColumnOrder = [ColumnName.Source, ColumnName.Level, ColumnName.DateAndTime]
@@ -183,10 +159,8 @@ public async Task HandleReorderColumn_ShouldPersistToPreferences()
 
         var action = new ReorderColumnAction(ColumnName.Source, ColumnName.Level, false);
 
-        // Act
         await effects.HandleReorderColumn(action, mockDispatcher);
 
-        // Assert
         _ = mockPreferencesProvider.Received(1).ColumnOrderPreference =
             Arg.Is<IEnumerable<ColumnName>>(order => order != null && order.First() == ColumnName.Source);
     }
@@ -194,14 +168,11 @@ public async Task HandleReorderColumn_ShouldPersistToPreferences()
     [Fact]
     public async Task HandleResetColumnDefaults_ShouldResetAllColumnSettingsToDefaults()
     {
-        // Arrange
         var enabledColumns = new List<ColumnName> { ColumnName.Level, ColumnName.Source };
         var (effects, mockDispatcher, mockPreferencesProvider) = CreateEffects(enabledColumns);
 
-        // Act
         await effects.HandleResetColumnDefaults(mockDispatcher);
 
-        // Assert
         _ = mockPreferencesProvider.Received(1).EnabledEventTableColumnsPreference =
             Arg.Is<IEnumerable<ColumnName>>(columns =>
                 columns != null && columns.SequenceEqual(s_columnDefaults.EnabledColumns));
@@ -226,10 +197,30 @@ public async Task HandleResetColumnDefaults_ShouldResetAllColumnSettingsToDefaul
             action.LoadedColumns[ColumnName.ActivityId] == false));
     }
 
+    [Fact]
+    public async Task HandleSetAllGroupsCollapsed_RaisesTheGroupCollapseNotifier()
+    {
+        var notifier = new GroupCollapseNotifier(Substitute.For<ITraceLogger>());
+        var raised = 0;
+        notifier.Requested += () => raised++;
+
+        var logTableState = Substitute.For<IState<LogTableState>>();
+        logTableState.Value.Returns(new LogTableState());
+        var effects = new Effects(
+            Substitute.For<ILogTablePreferencesProvider>(),
+            logTableState,
+            s_columnDefaults,
+            new NoOpColumnResetMigrator(),
+            notifier);
+
+        await effects.HandleSetAllGroupsCollapsed(Substitute.For<IDispatcher>());
+
+        Assert.Equal(1, raised);
+    }
+
     [Fact]
     public async Task HandleSetColumnWidth_ShouldPersistToPreferences()
     {
-        // Arrange
         var postReducerState = new LogTableState
         {
             ColumnWidths = new Dictionary<ColumnName, int>
@@ -242,10 +233,8 @@ public async Task HandleSetColumnWidth_ShouldPersistToPreferences()
 
         var action = new SetColumnWidthAction(ColumnName.Level, 200);
 
-        // Act
         await effects.HandleSetColumnWidth(action, mockDispatcher);
 
-        // Assert
         _ = mockPreferencesProvider.Received(1).ColumnWidthsPreference =
             Arg.Is<IDictionary<ColumnName, int>>(width => width != null && width[ColumnName.Level] == 200);
     }
@@ -253,7 +242,6 @@ public async Task HandleSetColumnWidth_ShouldPersistToPreferences()
     [Fact]
     public async Task HandleToggleColumn_ShouldOnlyChangeToggledColumn()
     {
-        // Arrange
         var enabledColumns = new List<ColumnName>
         {
             ColumnName.Level,
@@ -265,10 +253,8 @@ public async Task HandleToggleColumn_ShouldOnlyChangeToggledColumn()
         var (effects, mockDispatcher, mockPreferencesProvider) = CreateEffects(enabledColumns);
         var action = new ToggleColumnAction(ColumnName.DateAndTime);
 
-        // Act
         await effects.HandleToggleColumn(action, mockDispatcher);
 
-        // Assert
         mockDispatcher.Received(1).Dispatch(Arg.Is<LoadColumnsCompletedAction>(action =>
             action != null &&
             action.LoadedColumns[ColumnName.Level] == true &&
@@ -280,7 +266,6 @@ public async Task HandleToggleColumn_ShouldOnlyChangeToggledColumn()
     [Fact]
     public async Task HandleToggleColumn_ShouldUpdatePreferences()
     {
-        // Arrange
         var enabledColumns = new List<ColumnName>
         {
             ColumnName.Level,
@@ -290,10 +275,8 @@ public async Task HandleToggleColumn_ShouldUpdatePreferences()
         var (effects, mockDispatcher, mockPreferencesProvider) = CreateEffects(enabledColumns);
         var action = new ToggleColumnAction(ColumnName.Source);
 
-        // Act
         await effects.HandleToggleColumn(action, mockDispatcher);
 
-        // Assert
         _ = mockPreferencesProvider.Received(1).EnabledEventTableColumnsPreference =
             Arg.Is<IEnumerable<ColumnName>>(columns =>
                 columns != null &&
@@ -303,7 +286,6 @@ public async Task HandleToggleColumn_ShouldUpdatePreferences()
     [Fact]
     public async Task HandleToggleColumn_WhenColumnDisabled_ShouldEnableIt()
     {
-        // Arrange
         var enabledColumns = new List<ColumnName>
         {
             ColumnName.DateAndTime,
@@ -313,10 +295,8 @@ public async Task HandleToggleColumn_WhenColumnDisabled_ShouldEnableIt()
         var (effects, mockDispatcher, mockPreferencesProvider) = CreateEffects(enabledColumns);
         var action = new ToggleColumnAction(ColumnName.Level);
 
-        // Act
         await effects.HandleToggleColumn(action, mockDispatcher);
 
-        // Assert
         mockDispatcher.Received(1).Dispatch(Arg.Is<LoadColumnsCompletedAction>(action =>
             action != null &&
             action.LoadedColumns[ColumnName.Level] == true &&
@@ -327,7 +307,6 @@ public async Task HandleToggleColumn_WhenColumnDisabled_ShouldEnableIt()
     [Fact]
     public async Task HandleToggleColumn_WhenColumnEnabled_ShouldDisableIt()
     {
-        // Arrange
         var enabledColumns = new List<ColumnName>
         {
             ColumnName.Level,
@@ -338,10 +317,8 @@ public async Task HandleToggleColumn_WhenColumnEnabled_ShouldDisableIt()
         var (effects, mockDispatcher, mockPreferencesProvider) = CreateEffects(enabledColumns);
         var action = new ToggleColumnAction(ColumnName.Level);
 
-        // Act
         await effects.HandleToggleColumn(action, mockDispatcher);
 
-        // Assert
         mockDispatcher.Received(1).Dispatch(Arg.Is<LoadColumnsCompletedAction>(action =>
             action != null &&
             action.LoadedColumns[ColumnName.Level] == false &&
@@ -352,7 +329,6 @@ public async Task HandleToggleColumn_WhenColumnEnabled_ShouldDisableIt()
     [Fact]
     public async Task HandleToggleColumn_WhenDisabling_ShouldRemoveFromPreferences()
     {
-        // Arrange
         var enabledColumns = new List<ColumnName>
         {
             ColumnName.Level,
@@ -363,10 +339,8 @@ public async Task HandleToggleColumn_WhenDisabling_ShouldRemoveFromPreferences()
         var (effects, mockDispatcher, mockPreferencesProvider) = CreateEffects(enabledColumns);
         var action = new ToggleColumnAction(ColumnName.Source);
 
-        // Act
         await effects.HandleToggleColumn(action, mockDispatcher);
 
-        // Assert
         var _ = mockPreferencesProvider.Received(1).EnabledEventTableColumnsPreference =
             Arg.Is<IEnumerable<ColumnName>>(columns =>
                 columns != null &&
@@ -379,7 +353,6 @@ public async Task HandleToggleColumn_WhenDisabling_ShouldRemoveFromPreferences()
     [Fact]
     public async Task HandleToggleColumn_WhenEnabling_ShouldPersistToPreferences()
     {
-        // Arrange
         var enabledColumns = new List<ColumnName>
         {
             ColumnName.Level
@@ -388,10 +361,8 @@ public async Task HandleToggleColumn_WhenEnabling_ShouldPersistToPreferences()
         var (effects, mockDispatcher, mockPreferencesProvider) = CreateEffects(enabledColumns);
         var action = new ToggleColumnAction(ColumnName.Source);
 
-        // Act
         await effects.HandleToggleColumn(action, mockDispatcher);
 
-        // Assert
         _ = mockPreferencesProvider.Received(1).EnabledEventTableColumnsPreference =
             Arg.Is<IEnumerable<ColumnName>>(columns =>
                 columns != null &&
@@ -411,7 +382,7 @@ private static (Effects effects, IDispatcher mockDispatcher, ILogTablePreference
         var mockState = Substitute.For<IState<LogTableState>>();
         mockState.Value.Returns(state ?? new LogTableState());
 
-        var effects = new Effects(mockPreferencesProvider, mockState, s_columnDefaults, new NoOpColumnResetMigrator());
+        var effects = new Effects(mockPreferencesProvider, mockState, s_columnDefaults, new NoOpColumnResetMigrator(), new GroupCollapseNotifier(Substitute.For<ITraceLogger>()));
         var mockDispatcher = Substitute.For<IDispatcher>();
 
         return (effects, mockDispatcher, mockPreferencesProvider);
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/EmptyColumnViewTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/EmptyColumnViewTests.cs
new file mode 100644
index 000000000..0f25d9aed
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/EmptyColumnViewTests.cs
@@ -0,0 +1,127 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
+using EventLogExpert.Runtime.LogTable;
+
+namespace EventLogExpert.Runtime.Tests.LogTable;
+
+public sealed class EmptyColumnViewTests
+{
+    private const int BucketCount = 4;
+    private const long BucketSpanTicks = 1;
+    private const long MinTicks = 0;
+
+    private static readonly EventLocator s_absent = new(EventLogId.Create(), 0, 0);
+    private static readonly IEventColumnView s_empty = EmptyColumnView.Instance;
+
+    [Fact]
+    public void Count_IsZero() => Assert.Equal(0, s_empty.Count);
+
+    [Fact]
+    public void Detail_ThrowsForALocatorItDoesNotOwn()
+    {
+        Assert.Throws<KeyNotFoundException>(() => s_empty.GetDetail(s_absent));
+        Assert.Throws<KeyNotFoundException>(() => s_empty.GetDetailLean(s_absent));
+        Assert.Throws<KeyNotFoundException>(() => s_empty.GroupKeyAt(s_absent, ColumnName.Source));
+    }
+
+    [Fact]
+    public void EnumerateDetail_YieldsNothing() => Assert.Empty(s_empty.EnumerateDetail());
+
+    [Fact]
+    public void HighlightTieKernels_AcceptAnyHandleAndMutateNothing()
+    {
+        byte[] foreignHandle = [9, 9, 9];
+        uint[] slotColorMask = [0xAAAAAAAAu, 0xBBBBBBBBu];
+        int[] slotCounts = [5, 5, 5, 5];
+        byte[] handleBeforeCalls = [.. foreignHandle];
+        uint[] maskBeforeCalls = [.. slotColorMask];
+        int[] countsBeforeCalls = [.. slotCounts];
+        IReadOnlyCollection<string> eligibleProviders = ["Provider"];
+        IReadOnlyList<string> userDataErrorCodePaths = ["System/Data"];
+        IReadOnlyDictionary<string, int> rawValueToSlot = new Dictionary<string, int> { ["value"] = 0 };
+        var cancellationToken = TestContext.Current.CancellationToken;
+
+        s_empty.BucketTimeTicksByEventIdWithTie(
+            foreignHandle, slotColorMask, MinTicks, BucketSpanTicks, BucketCount, [20], slotCounts, cancellationToken);
+        s_empty.BucketTimeTicksBySeverityWithTie(
+            foreignHandle, slotColorMask, MinTicks, BucketSpanTicks, BucketCount, slotCounts, cancellationToken);
+        s_empty.BucketTimeTicksByFieldWithTie(
+            foreignHandle, slotColorMask, MinTicks, BucketSpanTicks, BucketCount, EventFieldId.Source, ["value"], slotCounts, cancellationToken);
+        s_empty.BucketTimeTicksByEventDataWithTie(
+            foreignHandle, slotColorMask, MinTicks, BucketSpanTicks, BucketCount, "Field", [1], slotCounts, cancellationToken);
+        s_empty.BucketTimeTicksByEventDataHResultWithTie(
+            foreignHandle, slotColorMask, MinTicks, BucketSpanTicks, BucketCount, "Field", eligibleProviders, userDataErrorCodePaths, [1], slotCounts,
+            cancellationToken);
+        s_empty.BucketTimeTicksByEventDataStringWithTie(
+            foreignHandle, slotColorMask, MinTicks, BucketSpanTicks, BucketCount, ["Field"], rawValueToSlot, BucketCount, slotCounts, cancellationToken);
+
+        Assert.Equal(handleBeforeCalls, foreignHandle);
+        Assert.Equal(maskBeforeCalls, slotColorMask);
+        Assert.Equal(countsBeforeCalls, slotCounts);
+    }
+
+    [Fact]
+    public void HighlightWinners_ReturnsADistinctHandlePerCall()
+    {
+        byte[] emptyFirst = s_empty.EnsureHighlightWinners([], 0, TestContext.Current.CancellationToken);
+        byte[] emptySecond = s_empty.EnsureHighlightWinners([], 0, TestContext.Current.CancellationToken);
+
+        Assert.Single(emptyFirst);
+        Assert.NotSame(emptyFirst, emptySecond);
+    }
+
+    [Fact]
+    public void Histogram_KernelsLeaveTheirAccumulatorsUntouched()
+    {
+        int[] emptySlots = new int[BucketCount];
+        Dictionary<int, int> emptyCounts = [];
+
+        s_empty.BucketTimeTicksBySeverity(MinTicks, BucketSpanTicks, BucketCount, emptySlots, TestContext.Current.CancellationToken);
+        s_empty.CountEventIds(emptyCounts, TestContext.Current.CancellationToken);
+
+        Assert.All(emptySlots, slot => Assert.Equal(0, slot));
+        Assert.Empty(emptyCounts);
+    }
+
+    [Fact]
+    public void LocatorAt_RejectsEveryIndex()
+    {
+        Assert.Throws<ArgumentOutOfRangeException>(() => s_empty.LocatorAt(0));
+        Assert.Throws<ArgumentOutOfRangeException>(() => s_empty.LocatorAt(-1));
+    }
+
+    [Fact]
+    public void RankAndResolve_ReportAbsenceRatherThanThrowing()
+    {
+        Assert.Equal(-1, s_empty.Rank(s_absent));
+
+        var key = new ValueKey(1, DateTime.UnixEpoch, "Source", "Log");
+
+        Assert.Null(s_empty.ResolveByKey(key));
+    }
+
+    [Fact]
+    public void Slice_ReturnsNothingAndRejectsNegativeArguments()
+    {
+        Assert.Empty(s_empty.Slice(0, 10));
+        Assert.Throws<ArgumentOutOfRangeException>(() => s_empty.Slice(-1, 1));
+        Assert.Throws<ArgumentOutOfRangeException>(() => s_empty.Slice(0, -1));
+    }
+
+    [Fact]
+    public void TryGetters_ReportFailureWithAbsentOutputs()
+    {
+        Assert.False(s_empty.TryGetDetail(s_absent, out ResolvedEvent? emptyDetail));
+        Assert.Null(emptyDetail);
+
+        Assert.False(s_empty.TryGetTimeTicks(s_absent, out long emptyTicks));
+        Assert.Equal(0, emptyTicks);
+
+        Assert.False(s_empty.TryGetTimeTicksRange(out long emptyMin, out long emptyMax, TestContext.Current.CancellationToken));
+        Assert.Equal(0, emptyMin);
+        Assert.Equal(0, emptyMax);
+    }
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/EventDetailResolverTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/EventDetailResolverTests.cs
new file mode 100644
index 000000000..c01e137e8
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/EventDetailResolverTests.cs
@@ -0,0 +1,108 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.Channels;
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
+using EventLogExpert.Runtime.LogTable;
+using Fluxor;
+using NSubstitute;
+using System.Collections.Immutable;
+
+namespace EventLogExpert.Runtime.Tests.LogTable;
+
+public sealed class EventDetailResolverTests
+{
+    private const string LogName = "Application";
+
+    [Fact]
+    public void ALocatorForAClosedLog_DoesNotResolve()
+    {
+        var harness = new Harness(Event(1, "Alpha"));
+        var locator = harness.LocatorAt(0);
+
+        Assert.True(harness.Resolver.TryResolve(locator, out _));
+
+        harness.CloseLog();
+
+        Assert.False(harness.Resolver.TryResolve(locator, out var afterClose));
+        Assert.Null(afterClose);
+    }
+
+    [Fact]
+    public void ALocatorForALogThatWasNeverOpened_DoesNotResolve()
+    {
+        var harness = new Harness(Event(1, "Alpha"));
+
+        Assert.False(harness.Resolver.TryResolve(new EventLocator(EventLogId.Create(), 0, 0), out _));
+    }
+
+    [Fact]
+    public void ALocatorFromADifferentGeneration_DoesNotResolve()
+    {
+        var harness = new Harness(Event(1, "Alpha"));
+        var mismatched = harness.LocatorAt(0) with { Generation = harness.LocatorAt(0).Generation + 1 };
+
+        Assert.False(harness.Resolver.TryResolve(mismatched, out var detail));
+        Assert.Null(detail);
+    }
+
+    [Fact]
+    public void ARowHiddenByTheActiveFilter_StillResolves()
+    {
+        var harness = new Harness(Event(1, "Alpha"), Event(2, "Beta"));
+
+        Assert.True(harness.Resolver.TryResolve(harness.LocatorAt(0), out var first));
+        Assert.True(harness.Resolver.TryResolve(harness.LocatorAt(1), out var second));
+        Assert.Equal(1, first.Id);
+        Assert.Equal(2, second.Id);
+    }
+
+    [Fact]
+    public void AnOutOfRangeLocator_DoesNotResolve()
+    {
+        var harness = new Harness(Event(1, "Alpha"));
+
+        Assert.False(harness.Resolver.TryResolve(harness.LocatorAt(5), out _));
+        Assert.False(harness.Resolver.TryResolve(harness.LocatorAt(-1), out _));
+    }
+
+    [Fact]
+    public void ResolvedDetail_CarriesTheFieldsTheLeanDisplayReadOmits()
+    {
+        var harness = new Harness(Event(1, "Alpha") with { Xml = "<Event />" });
+
+        Assert.True(harness.Resolver.TryResolve(harness.LocatorAt(0), out var detail));
+        Assert.Equal("<Event />", detail.Xml);
+    }
+
+    private static ResolvedEvent Event(int id, string source) =>
+        new(LogName, LogPathType.Channel) { Id = id, RecordId = id, Source = source };
+
+    private sealed class Harness
+    {
+        private readonly IState<RawEventStoreState> _rawEventStore = Substitute.For<IState<RawEventStoreState>>();
+
+        private RawEventStoreState _state;
+
+        public Harness(params ResolvedEvent[] events)
+        {
+            _state = new RawEventStoreState
+            {
+                ByLog = ImmutableDictionary<EventLogId, EventColumnStore>.Empty
+                    .Add(LogId, EventColumnStore.Build(events, 0, 0))
+            };
+
+            _rawEventStore.Value.Returns(_ => _state);
+            Resolver = new EventDetailResolver(_rawEventStore);
+        }
+
+        public EventLogId LogId { get; } = EventLogId.Create();
+
+        public EventDetailResolver Resolver { get; }
+
+        public void CloseLog() => _state = new RawEventStoreState();
+
+        public EventLocator LocatorAt(int index) => new(LogId, 0, index);
+    }
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/FilteredLogPresenceCoordinatorTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/FilteredLogPresenceCoordinatorTests.cs
new file mode 100644
index 000000000..6dcb8f775
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/FilteredLogPresenceCoordinatorTests.cs
@@ -0,0 +1,385 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.Channels;
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
+using EventLogExpert.Filtering.TestUtils;
+using EventLogExpert.Filtering.TestUtils.Constants;
+using EventLogExpert.Runtime.EventLog;
+using EventLogExpert.Runtime.LogTable;
+using Fluxor;
+using NSubstitute;
+using IDispatcher = Fluxor.IDispatcher;
+
+namespace EventLogExpert.Runtime.Tests.LogTable;
+
+public sealed class FilteredLogPresenceCoordinatorTests
+{
+    private const string LogName = "TestLog";
+
+    [Fact]
+    public void AppendCarryingTheFirstSurvivor_FlipsAKnownEmptyLogToNonEmpty()
+    {
+        var harness = Create();
+        var logId = harness.OpenLog(rowCount: 2, computerName: FilterTestConstants.EventComputerServer02);
+        harness.ApplyFilter(FilterOnServer01());
+        harness.Coordinator.MarkFilterChanged();
+        harness.SettlePresence();
+        Assert.Equal(FilteredLogPresence.NoSurvivor, harness.VerdictFor(logId));
+        harness.Dispatched.Clear();
+
+        harness.AppendRows(logId, rowCount: 1, computerName: FilterTestConstants.EventComputerServer01);
+        harness.Coordinator.MarkAppended([logId]);
+
+        Assert.Equal(FilteredLogPresence.HasSurvivor, harness.VerdictFor(logId));
+    }
+
+    [Fact]
+    public void AppendToAKnownNonEmptyLog_DoesNoFurtherWork()
+    {
+        var harness = Create();
+        var logId = harness.OpenLog(rowCount: 2, computerName: FilterTestConstants.EventComputerServer01);
+        harness.ApplyFilter(FilterOnServer01());
+        harness.Coordinator.MarkFilterChanged();
+        harness.SettlePresence();
+        harness.Dispatched.Clear();
+
+        harness.Coordinator.MarkAppended([logId]);
+
+        Assert.Empty(harness.Dispatched.OfType<FilteredPresenceUpdatedAction>());
+    }
+
+    [Fact]
+    public void ClosedLog_IsNotGivenAVerdict()
+    {
+        var harness = Create();
+        var logId = harness.OpenLog(rowCount: 3);
+        harness.CloseLogButLeaveStore(logId);
+
+        harness.Coordinator.MarkFilterChanged();
+
+        Assert.DoesNotContain(
+            harness.Dispatched.OfType<FilteredPresenceUpdatedAction>().SelectMany(update => update.Verdicts),
+            verdict => verdict.Key == logId);
+    }
+
+    [Fact]
+    public void Dispose_ThenSignal_PublishesNothing()
+    {
+        var harness = Create();
+        harness.OpenLog(rowCount: 1);
+        harness.Coordinator.Dispose();
+        harness.Dispatched.Clear();
+
+        harness.Coordinator.MarkFilterChanged();
+
+        Assert.Empty(harness.Dispatched);
+    }
+
+    [Fact]
+    public void FilterChange_OpensAnEpochAndReturnsOpenLogsToPending()
+    {
+        var harness = Create();
+        harness.OpenLog(rowCount: 1);
+
+        harness.Coordinator.MarkFilterChanged();
+
+        var invalidated = harness.Dispatched.OfType<FilteredPresenceInvalidatedAction>().Single();
+        Assert.Equal(1, invalidated.FilterVersion);
+        Assert.Single(invalidated.LogIds);
+    }
+
+    [Fact]
+    public void FilterChange_PublishesAVerdictForEveryOpenLog()
+    {
+        var harness = Create();
+        var withRows = harness.OpenLog(rowCount: 3);
+        var empty = harness.OpenLog(rowCount: 0);
+
+        harness.Coordinator.MarkFilterChanged();
+
+        Assert.Equal(FilteredLogPresence.HasSurvivor, harness.VerdictFor(withRows));
+        Assert.Equal(FilteredLogPresence.NoSurvivor, harness.VerdictFor(empty));
+    }
+
+    [Fact]
+    public void FilterExcludingEveryRow_MarksTheLogKnownEmpty()
+    {
+        var harness = Create();
+        var logId = harness.OpenLog(rowCount: 4, computerName: FilterTestConstants.EventComputerServer02);
+        harness.ApplyFilter(FilterOnServer01());
+
+        harness.Coordinator.MarkFilterChanged();
+
+        Assert.Equal(FilteredLogPresence.NoSurvivor, harness.VerdictFor(logId));
+    }
+
+    [Fact]
+    public void FilterMatchingOneRow_MarksTheLogNonEmpty()
+    {
+        var harness = Create();
+        var logId = harness.OpenLog(rowCount: 4, computerName: FilterTestConstants.EventComputerServer01);
+        harness.ApplyFilter(FilterOnServer01());
+
+        harness.Coordinator.MarkFilterChanged();
+
+        Assert.Equal(FilteredLogPresence.HasSurvivor, harness.VerdictFor(logId));
+    }
+
+    [Fact]
+    public void RawEmptyLog_UnderAnyFilter_IsKnownEmptyWithoutScanning()
+    {
+        var harness = Create();
+        harness.ApplyFilter(FilterOnServer01());
+        var logId = harness.OpenLog(rowCount: 0);
+
+        harness.Coordinator.MarkFilterChanged();
+
+        Assert.Equal(FilteredLogPresence.NoSurvivor, harness.VerdictFor(logId));
+    }
+
+    [Fact]
+    public void UnfilteredLog_WithRows_IsKnownNonEmptyWithoutScanning()
+    {
+        var harness = Create();
+        var logId = harness.OpenLog(rowCount: 5);
+
+        harness.Coordinator.MarkFilterChanged();
+
+        Assert.Equal(FilteredLogPresence.HasSurvivor, harness.VerdictFor(logId));
+    }
+
+    [Fact]
+    public void XmlRequiringFilter_AfterAPartialReload_RescansTheLogsThatDidNotReload()
+    {
+        var harness = Create();
+        var logA = harness.OpenLog(rowCount: 3, loadedWithXml: true);
+        var logB = harness.OpenLog(rowCount: 3, loadedWithXml: false);
+        harness.ApplyFilter(FilterRequiringXml());
+
+        harness.Coordinator.MarkFilterChanged();
+
+        Assert.Empty(harness.Dispatched.OfType<FilteredPresenceUpdatedAction>());
+
+        harness.CompleteXmlReload(logB);
+
+        Assert.NotNull(harness.VerdictFor(logA));
+        Assert.NotNull(harness.VerdictFor(logB));
+    }
+
+    [Fact]
+    public void XmlRequiringFilter_WhenALogLosesItsXmlLoadMidScan_DoesNotDropTheOtherDirtyLogs()
+    {
+        var harness = Create();
+        var logA = harness.OpenLog(rowCount: 3, loadedWithXml: true);
+        var logB = harness.OpenLog(rowCount: 3, loadedWithXml: true);
+        harness.ApplyFilter(FilterRequiringXml());
+        harness.ClearXmlLoadOnNextDrain(logB);
+
+        harness.Coordinator.MarkFilterChanged();
+
+        Assert.Empty(harness.Dispatched.OfType<FilteredPresenceUpdatedAction>());
+
+        harness.CompleteXmlReload(logB);
+
+        Assert.NotNull(harness.VerdictFor(logA));
+        Assert.NotNull(harness.VerdictFor(logB));
+    }
+
+    [Fact]
+    public void XmlRequiringFilter_WhenTheDeferringLogIsClosed_RescansTheLogsThatRemain()
+    {
+        var harness = Create();
+        var logA = harness.OpenLog(rowCount: 3, loadedWithXml: true);
+        var logB = harness.OpenLog(rowCount: 3, loadedWithXml: false);
+        harness.ApplyFilter(FilterRequiringXml());
+
+        harness.Coordinator.MarkFilterChanged();
+        Assert.Empty(harness.Dispatched.OfType<FilteredPresenceUpdatedAction>());
+
+        harness.CloseLog(logB);
+
+        Assert.NotNull(harness.VerdictFor(logA));
+    }
+
+    [Fact]
+    public void XmlRequiringFilter_WithALogNotLoadedWithXml_PublishesNothing()
+    {
+        var harness = Create();
+        harness.OpenLog(rowCount: 3, loadedWithXml: false);
+        harness.ApplyFilter(FilterRequiringXml());
+
+        harness.Coordinator.MarkFilterChanged();
+
+        Assert.Empty(harness.Dispatched.OfType<FilteredPresenceUpdatedAction>());
+    }
+
+    private static Harness Create() => new();
+
+    private static Filter FilterOnServer01() =>
+        new(null, [FilterBuilder.CreateTestFilter(FilterTestConstants.FilterComputerNameEqualsServer01, isEnabled: true)]);
+
+    private static Filter FilterRequiringXml() =>
+        new(null, [FilterBuilder.CreateTestFilter(FilterTestConstants.FilterXmlContainsData, isEnabled: true)]);
+
+    private sealed class Harness
+    {
+        private readonly EventLogConcurrencyState _concurrencyState = new();
+        private readonly IState<EventLogState> _eventLogState = Substitute.For<IState<EventLogState>>();
+        private readonly IState<FilteredLogPresenceState> _presenceState =
+            Substitute.For<IState<FilteredLogPresenceState>>();
+        private readonly IState<RawEventStoreState> _rawEventStore = Substitute.For<IState<RawEventStoreState>>();
+
+        private EventLogState _eventLog = new();
+        private FilteredLogPresenceState _presence = new();
+        private RawEventStoreState _raw = new();
+
+        public Harness()
+        {
+            var dispatcher = Substitute.For<IDispatcher>();
+            dispatcher.When(target => target.Dispatch(Arg.Any<object>())).Do(call => Record(call.Arg<object>()!));
+
+            _eventLogState.Value.Returns(_ => _eventLog);
+            _rawEventStore.Value.Returns(_ => _raw);
+            _presenceState.Value.Returns(_ => _presence);
+
+            Coordinator = new FilteredLogPresenceCoordinator(
+                dispatcher,
+                _eventLogState,
+                _rawEventStore,
+                _presenceState,
+                _concurrencyState,
+                scanInline: true);
+        }
+
+        public FilteredLogPresenceCoordinator Coordinator { get; }
+
+        public List<object> Dispatched { get; } = [];
+
+        public void AppendRows(EventLogId logId, int rowCount, string computerName)
+        {
+            var existing = _raw.ByLog[logId];
+            var appended = existing.Append(Rows(rowCount, computerName, startRecordId: existing.Count + 1));
+
+            _raw = _raw with { ByLog = _raw.ByLog.SetItem(logId, appended) };
+        }
+
+        public void ApplyFilter(Filter filter) => _eventLog = _eventLog with { AppliedFilter = filter };
+
+        public void ClearXmlLoadOnNextDrain(EventLogId logId) =>
+            Coordinator.OnBatchDrainedForTest = () =>
+            {
+                _concurrencyState.ClearLoadedWithXml(logId);
+                Coordinator.OnBatchDrainedForTest = null;
+            };
+
+        public void CloseLog(EventLogId logId)
+        {
+            CloseLogButLeaveStore(logId);
+            Coordinator.Discard(logId);
+        }
+
+        public void CloseLogButLeaveStore(EventLogId logId)
+        {
+            var name = _eventLog.OpenLogs.First(pair => pair.Value.Id == logId).Key;
+
+            _eventLog = _eventLog with { OpenLogs = _eventLog.OpenLogs.Remove(name) };
+        }
+
+        public void CompleteXmlReload(EventLogId logId)
+        {
+            _concurrencyState.MarkLoadedWithXml(logId);
+            Coordinator.MarkRebuilt(logId);
+        }
+
+        public EventLogId OpenLog(int rowCount, string computerName = FilterTestConstants.EventComputerServer01, bool loadedWithXml = true)
+        {
+            var logId = EventLogId.Create();
+            string name = $"{LogName}{_eventLog.OpenLogs.Count}";
+
+            _eventLog = _eventLog with
+            {
+                OpenLogs = _eventLog.OpenLogs.SetItem(name, new OpenLogInfo(logId, LogPathType.Channel))
+            };
+
+            _raw = _raw with
+            {
+                ByLog = _raw.ByLog.SetItem(
+                    logId,
+                    EventColumnStore.Build(Rows(rowCount, computerName, startRecordId: 1), generation: 0, contentVersion: 1))
+            };
+
+            if (loadedWithXml) { _concurrencyState.MarkLoadedWithXml(logId); }
+
+            return logId;
+        }
+
+        public void SettlePresence()
+        {
+            foreach (var invalidated in Dispatched.OfType<FilteredPresenceInvalidatedAction>())
+            {
+                _presence = _presence with { FilterVersion = invalidated.FilterVersion };
+            }
+
+            foreach (var update in Dispatched.OfType<FilteredPresenceUpdatedAction>())
+            {
+                if (update.FilterVersion != _presence.FilterVersion) { continue; }
+
+                var byLog = _presence.ByLog;
+
+                foreach (var (logId, presence) in update.Verdicts) { byLog = byLog.SetItem(logId, presence); }
+
+                _presence = _presence with { ByLog = byLog };
+            }
+        }
+
+        public FilteredLogPresence? VerdictFor(EventLogId logId)
+        {
+            foreach (var update in Enumerable.Reverse(Dispatched).OfType<FilteredPresenceUpdatedAction>())
+            {
+                foreach (var (candidate, presence) in update.Verdicts)
+                {
+                    if (candidate == logId) { return presence; }
+                }
+            }
+
+            return null;
+        }
+
+        private static List<ResolvedEvent> Rows(int count, string computerName, int startRecordId)
+        {
+            var rows = new List<ResolvedEvent>(count);
+
+            for (int index = 0; index < count; index++)
+            {
+                rows.Add(
+                    new ResolvedEvent(LogName, LogPathType.Channel)
+                    {
+                        Id = 100 + index,
+                        RecordId = startRecordId + index,
+                        ComputerName = computerName
+                    });
+            }
+
+            return rows;
+        }
+
+        private void Record(object action)
+        {
+            Dispatched.Add(action);
+
+            if (action is FilteredPresenceInvalidatedAction invalidated)
+            {
+                var byLog = _presence.ByLog;
+
+                foreach (var logId in invalidated.LogIds)
+                {
+                    byLog = byLog.SetItem(logId, FilteredLogPresence.Pending);
+                }
+
+                _presence = _presence with { ByLog = byLog, FilterVersion = invalidated.FilterVersion };
+            }
+        }
+    }
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/GroupCollapseNotifierTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/GroupCollapseNotifierTests.cs
new file mode 100644
index 000000000..35b240aa1
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/GroupCollapseNotifierTests.cs
@@ -0,0 +1,44 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Logging.Abstractions;
+using EventLogExpert.Runtime.LogTable;
+using NSubstitute;
+
+namespace EventLogExpert.Runtime.Tests.LogTable;
+
+public sealed class GroupCollapseNotifierTests
+{
+    [Fact]
+    public void Raise_InvokesSubscribers()
+    {
+        var notifier = new GroupCollapseNotifier(Substitute.For<ITraceLogger>());
+        var raised = 0;
+        notifier.Requested += () => raised++;
+
+        notifier.Raise();
+
+        Assert.Equal(1, raised);
+    }
+
+    [Fact]
+    public void Raise_IsolatesAThrowingSubscriber()
+    {
+        var notifier = new GroupCollapseNotifier(Substitute.For<ITraceLogger>());
+        var reachedSecond = 0;
+        notifier.Requested += () => throw new InvalidOperationException("subscriber blew up");
+        notifier.Requested += () => reachedSecond++;
+
+        notifier.Raise();
+
+        Assert.Equal(1, reachedSecond);
+    }
+
+    [Fact]
+    public void Raise_WithNoSubscribers_DoesNotThrow()
+    {
+        var notifier = new GroupCollapseNotifier(Substitute.For<ITraceLogger>());
+
+        notifier.Raise();
+    }
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/LegacyEventColumnViewTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/LegacyEventColumnViewTests.cs
deleted file mode 100644
index 5c825dc9f..000000000
--- a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/LegacyEventColumnViewTests.cs
+++ /dev/null
@@ -1,110 +0,0 @@
-// // Copyright (c) Microsoft Corporation.
-// // Licensed under the MIT License.
-
-using EventLogExpert.Eventing.Common.Channels;
-using EventLogExpert.Eventing.Common.EventLogs;
-using EventLogExpert.Eventing.Common.Events;
-using EventLogExpert.Runtime.Tests.LogTable.TestSupport;
-
-namespace EventLogExpert.Runtime.Tests.LogTable;
-
-public sealed class LegacyEventColumnViewTests
-{
-    private static readonly EventLogId s_logId = EventLogId.Create();
-
-    [Fact]
-    public void Count_ReflectsEvents()
-    {
-        var view = CreateView(Event(1, 1), Event(2, 2), Event(3, 3));
-
-        Assert.Equal(3, view.Count);
-    }
-
-    [Fact]
-    public void GetDetail_LocatorFromDifferentGeneration_Throws()
-    {
-        var view = CreateView(Event(1, 1));
-        var stale = new EventLocator(s_logId, 999, 0);
-
-        Assert.Throws<ArgumentException>(() => view.GetDetail(stale));
-    }
-
-    [Fact]
-    public void GetDetail_ReturnsEventAtLocator()
-    {
-        var second = Event(20, 2);
-        var view = CreateView(Event(10, 1), second, Event(30, 3));
-
-        Assert.Same(second, view.GetDetail(view.LocatorAt(1)));
-    }
-
-    [Fact]
-    public void GetDetailLean_ReturnsEventAtLocator()
-    {
-        var second = Event(20, 2);
-        var view = CreateView(Event(10, 1), second, Event(30, 3));
-
-        Assert.Same(second, view.GetDetailLean(view.LocatorAt(1)));
-    }
-
-    [Fact]
-    public void Rank_IndexPastEnd_ReturnsMinusOne()
-    {
-        var view = CreateView(Event(1, 1), Event(2, 2));
-
-        Assert.Equal(-1, view.Rank(new EventLocator(s_logId, 2, 5)));
-    }
-
-    [Fact]
-    public void Rank_LocatorFromDifferentGeneration_ReturnsMinusOne()
-    {
-        var view = CreateView(Event(1, 1));
-        var stale = new EventLocator(s_logId, 999, 0);
-
-        Assert.Equal(-1, view.Rank(stale));
-    }
-
-    [Fact]
-    public void Rank_LocatorInView_ReturnsPhysicalIndex()
-    {
-        var view = CreateView(Event(1, 1), Event(2, 2), Event(3, 3));
-
-        Assert.Equal(2, view.Rank(view.LocatorAt(2)));
-    }
-
-    [Fact]
-    public void Reader_ExposesSameCount()
-    {
-        var view = CreateView(Event(1, 1), Event(2, 2));
-
-        Assert.Equal(view.Count, view.Reader.Count);
-    }
-
-    [Fact]
-    public void Slice_PastEnd_IsEmpty()
-    {
-        var view = CreateView(Event(1, 1));
-
-        Assert.Empty(view.Slice(5, 3));
-    }
-
-    [Fact]
-    public void Slice_ReturnsRequestedWindow()
-    {
-        var view = CreateView(Event(1, 1), Event(2, 2), Event(3, 3), Event(4, 4));
-
-        var window = view.Slice(1, 2);
-
-        Assert.Equal(2, window.Count);
-        Assert.Equal(2, window[0].Lean.Id);
-        Assert.Equal(3, window[1].Lean.Id);
-        Assert.Equal(view.LocatorAt(1), window[0].Loc);
-        Assert.Equal(view.LocatorAt(2), window[1].Loc);
-    }
-
-    private static LegacyEventColumnView CreateView(params ResolvedEvent[] events) =>
-        new(s_logId, generation: 2, contentVersion: 1, events);
-
-    private static ResolvedEvent Event(int id, long recordId) =>
-        new("live", LogPathType.Channel) { Id = id, RecordId = recordId };
-}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/LogTabBarSourceTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/LogTabBarSourceTests.cs
new file mode 100644
index 000000000..040a31b3c
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/LogTabBarSourceTests.cs
@@ -0,0 +1,260 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Logging.Abstractions;
+using EventLogExpert.Runtime.LogTable;
+using Fluxor;
+using NSubstitute;
+using System.Collections.Immutable;
+
+namespace EventLogExpert.Runtime.Tests.LogTable;
+
+public sealed class LogTabBarSourceTests
+{
+    private static readonly EventLogId Alpha = EventLogId.Create();
+    private static readonly EventLogId Beta = EventLogId.Create();
+
+    [Fact]
+    public void AThrowingSubscriber_IsIsolatedFromOtherSubscribers()
+    {
+        var harness = new Harness(TwoTabs());
+        var reachedSecond = 0;
+        harness.Source.Changed += () => throw new InvalidOperationException("subscriber blew up");
+        harness.Source.Changed += () => reachedSecond++;
+
+        harness.SetPresence(Presence((Alpha, FilteredLogPresence.NoSurvivor)));
+
+        Assert.Equal(1, reachedSecond);
+    }
+
+    [Fact]
+    public void Changed_DoesNotFire_WhenAnIrrelevantLogTableFacetChanges()
+    {
+        var harness = new Harness(TwoTabs());
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.SetLogTable(harness.LogTable with { OrderBy = ColumnName.Source });
+
+        Assert.Equal(0, raised);
+    }
+
+    [Fact]
+    public void Changed_DoesNotFire_WhenPresenceChangesButKnownEmptyDoesNot()
+    {
+        var harness = new Harness(TwoTabs());
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.SetPresence(Presence((Alpha, FilteredLogPresence.HasSurvivor)));
+
+        Assert.Equal(0, raised);
+    }
+
+    [Fact]
+    public void Changed_Fires_WhenActiveTabChanges()
+    {
+        var harness = new Harness(TwoTabs());
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.SetLogTable(harness.LogTable with { ActiveEventLogId = Beta });
+
+        Assert.Equal(1, raised);
+        Assert.Equal(Beta, harness.Source.Current.ActiveTabId);
+    }
+
+    [Fact]
+    public void Changed_Fires_WhenKnownEmptySwapsAtTheSameCardinality()
+    {
+        var harness = new Harness(TwoTabs(), Presence((Alpha, FilteredLogPresence.NoSurvivor)));
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.SetPresence(Presence((Beta, FilteredLogPresence.NoSurvivor)));
+
+        Assert.Equal(1, raised);
+        Assert.True(harness.Source.Current.IsKnownEmpty(Beta));
+        Assert.False(harness.Source.Current.IsKnownEmpty(Alpha));
+    }
+
+    [Fact]
+    public void Changed_Fires_WhenPresenceKnownEmptyChanges_EvenWhenLogTableIsUnchanged()
+    {
+        var harness = new Harness(TwoTabs());
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.SetPresence(Presence((Alpha, FilteredLogPresence.NoSurvivor)));
+
+        Assert.Equal(1, raised);
+        Assert.True(harness.Source.Current.IsKnownEmpty(Alpha));
+    }
+
+    [Fact]
+    public void Construction_ReconcilesLogTableChangeThatLandsBetweenSeedAndSubscribe()
+    {
+        var logTableState = Substitute.For<IState<LogTableState>>();
+        logTableState.Value.Returns(new LogTableState(), TwoTabs());
+        var presenceState = Substitute.For<IState<FilteredLogPresenceState>>();
+        presenceState.Value.Returns(new FilteredLogPresenceState());
+
+        using var source = new LogTabBarSource(logTableState, presenceState, Substitute.For<ITraceLogger>());
+
+        Assert.Equal(2, source.Current.Tabs.Count);
+    }
+
+    [Fact]
+    public void Construction_ReconcilesPresenceThatLandsBetweenSeedAndSubscribe()
+    {
+        var logTableState = Substitute.For<IState<LogTableState>>();
+        logTableState.Value.Returns(TwoTabs());
+        var presenceState = Substitute.For<IState<FilteredLogPresenceState>>();
+        presenceState.Value.Returns(new FilteredLogPresenceState(), Presence((Alpha, FilteredLogPresence.NoSurvivor)));
+
+        using var source = new LogTabBarSource(logTableState, presenceState, Substitute.For<ITraceLogger>());
+
+        Assert.True(source.Current.IsKnownEmpty(Alpha));
+    }
+
+    [Fact]
+    public void Dispose_IsIdempotentAndStopsRaisingForBothInputs()
+    {
+        var harness = new Harness(TwoTabs());
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.Source.Dispose();
+        harness.Source.Dispose();
+
+        harness.SetLogTable(harness.LogTable with { ActiveEventLogId = Beta });
+        harness.SetPresence(Presence((Alpha, FilteredLogPresence.NoSurvivor)));
+
+        Assert.Equal(0, raised);
+    }
+
+    [Fact]
+    public void Dispose_UnsubscribesFromBothStates()
+    {
+        var logTableState = Substitute.For<IState<LogTableState>>();
+        logTableState.Value.Returns(TwoTabs());
+        var presenceState = Substitute.For<IState<FilteredLogPresenceState>>();
+        presenceState.Value.Returns(new FilteredLogPresenceState());
+        var source = new LogTabBarSource(logTableState, presenceState, Substitute.For<ITraceLogger>());
+
+        source.Dispose();
+
+        logTableState.Received().StateChanged -= Arg.Any<EventHandler>();
+        presenceState.Received().StateChanged -= Arg.Any<EventHandler>();
+    }
+
+    [Fact]
+    public void EitherInputNotification_ReprojectsBothLiveValues_SoTheInputsConverge()
+    {
+        var harness = new Harness(TwoTabs());
+
+        harness.MutateLogTableWithoutRaising(harness.LogTable with { ActiveEventLogId = Beta });
+        harness.SetPresence(Presence((Alpha, FilteredLogPresence.NoSurvivor)));
+
+        Assert.Equal(Beta, harness.Source.Current.ActiveTabId);
+        Assert.True(harness.Source.Current.IsKnownEmpty(Alpha));
+    }
+
+    [Fact]
+    public void HasMultipleTabs_CountsAllTabsIncludingCombined()
+    {
+        var state = new LogTableState
+        {
+            EventTables =
+            [
+                new LogView(Alpha) { GroupId = LogTabGroupId.AllLogs },
+                new LogView(Beta) { LogName = "Beta" }
+            ]
+        };
+        var harness = new Harness(state);
+
+        Assert.True(harness.Source.Current.HasMultipleTabs);
+    }
+
+    [Fact]
+    public void KnownEmptyTabIds_ExcludesPendingLoadingAndCombinedTabs()
+    {
+        var combined = EventLogId.Create();
+        var loading = EventLogId.Create();
+        var absentVerdict = EventLogId.Create();
+        var explicitPending = EventLogId.Create();
+        var state = new LogTableState
+        {
+            EventTables =
+            [
+                new LogView(combined) { GroupId = LogTabGroupId.AllLogs },
+                new LogView(loading) { LogName = "Loading", IsLoading = true },
+                new LogView(absentVerdict) { LogName = "AbsentVerdict" },
+                new LogView(explicitPending) { LogName = "ExplicitPending" },
+                new LogView(Alpha) { LogName = "Alpha" }
+            ]
+        };
+        var presence = Presence(
+            (combined, FilteredLogPresence.NoSurvivor),
+            (loading, FilteredLogPresence.NoSurvivor),
+            (explicitPending, FilteredLogPresence.Pending),
+            (Alpha, FilteredLogPresence.NoSurvivor));
+
+        var harness = new Harness(state, presence);
+
+        Assert.Equal([Alpha], harness.Source.Current.KnownEmptyTabIds);
+    }
+
+    private static FilteredLogPresenceState Presence(params (EventLogId Id, FilteredLogPresence Verdict)[] verdicts)
+    {
+        var byLog = ImmutableDictionary<EventLogId, FilteredLogPresence>.Empty;
+
+        foreach (var (id, verdict) in verdicts) { byLog = byLog.SetItem(id, verdict); }
+
+        return new FilteredLogPresenceState { ByLog = byLog };
+    }
+
+    private static LogTableState TwoTabs() =>
+        new()
+        {
+            ActiveEventLogId = Alpha,
+            EventTables = [new LogView(Alpha) { LogName = "Alpha" }, new LogView(Beta) { LogName = "Beta" }]
+        };
+
+    private sealed class Harness
+    {
+        private readonly IState<LogTableState> _logTableState = Substitute.For<IState<LogTableState>>();
+        private readonly IState<FilteredLogPresenceState> _presenceState =
+            Substitute.For<IState<FilteredLogPresenceState>>();
+
+        public Harness(LogTableState logTable, FilteredLogPresenceState? presence = null)
+        {
+            LogTable = logTable;
+            Presence = presence ?? new FilteredLogPresenceState();
+            _logTableState.Value.Returns(_ => LogTable);
+            _presenceState.Value.Returns(_ => Presence);
+            Source = new LogTabBarSource(_logTableState, _presenceState, Substitute.For<ITraceLogger>());
+        }
+
+        public LogTableState LogTable { get; private set; }
+
+        public FilteredLogPresenceState Presence { get; private set; }
+
+        public LogTabBarSource Source { get; }
+
+        public void MutateLogTableWithoutRaising(LogTableState next) => LogTable = next;
+
+        public void SetLogTable(LogTableState next)
+        {
+            LogTable = next;
+            _logTableState.StateChanged += Raise.Event<EventHandler>(_logTableState, EventArgs.Empty);
+        }
+
+        public void SetPresence(FilteredLogPresenceState next)
+        {
+            Presence = next;
+            _presenceState.StateChanged += Raise.Event<EventHandler>(_presenceState, EventArgs.Empty);
+        }
+    }
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/LogTabGroupTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/LogTabGroupTests.cs
index 62535221f..28db2cc65 100644
--- a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/LogTabGroupTests.cs
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/LogTabGroupTests.cs
@@ -5,7 +5,7 @@
 using EventLogExpert.Eventing.Common.EventLogs;
 using EventLogExpert.Eventing.Common.Events;
 using EventLogExpert.Runtime.LogTable;
-using EventLogExpert.Runtime.Tests.LogTable.TestSupport;
+using EventLogExpert.Runtime.LogTable.OrderedView;
 using EventLogExpert.Runtime.Tests.TestUtils;
 using System.Collections.Immutable;
 using Reducers = EventLogExpert.Runtime.LogTable.Reducers;
@@ -14,15 +14,6 @@ namespace EventLogExpert.Runtime.Tests.LogTable;
 
 public sealed class LogTabGroupTests
 {
-    [Fact]
-    public void DisplayedEventsForTab_AllLogsHeader_ReturnsTheSameInstanceAsDisplayedEvents()
-    {
-        var (state, _) = SeedLogs([MakeEvent(0, 1, Time(0, 1))], [MakeEvent(1, 1, Time(1, 1))]);
-        var allLogs = state.EventTables.Single(table => table.GroupId?.IsAll == true);
-
-        Assert.True(ReferenceEquals(state.DisplayedEvents, state.DisplayedEventsForTab(allLogs)));
-    }
-
     [Fact]
     public void DisplayedEventsForTab_GroupWithNoPresentMembers_IsEmpty()
     {
@@ -38,92 +29,7 @@ public void DisplayedEventsForTab_GroupWithNoPresentMembers_IsEmpty()
     }
 
     [Fact]
-    public void DisplayedEventsForTab_SingleMemberGroup_ReturnsThatMembersList()
-    {
-        var (state, ids) = SeedLogs([MakeEvent(0, 1, Time(0, 1))], [MakeEvent(1, 1, Time(1, 1))]);
-
-        var groupId = NewGroup(ref state, ids[0]);
-        var header = state.EventTables.Single(table => table.GroupId == groupId);
-
-        Assert.True(ReferenceEquals(state.EventsForLog(ids[0]), state.DisplayedEventsForTab(header)));
-    }
-
-    [Fact]
-    public void DisplayedEventsForTab_StandaloneTab_ReturnsThatLogsList()
-    {
-        var (state, ids) = SeedLogs([MakeEvent(0, 1, Time(0, 1))]);
-        var tab = state.EventTables.Single(table => table.Id == ids[0]);
-
-        Assert.True(ReferenceEquals(state.EventsForLog(ids[0]), state.DisplayedEventsForTab(tab)));
-    }
-
-    [Fact]
-    public void DisplayedEventsForTab_UserGroup_AfterAMemberListChanges_ReturnsNewInstance()
-    {
-        var state = TwoMemberGroup(out var groupId);
-        var members = state.Groups.Single().MemberIds.ToArray();
-        var before = state.DisplayedEventsForTab(state.EventTables.Single(table => table.GroupId == groupId));
-
-        state = AppendBatch(state, members[0], MakeEvent(0, 99, Time(0, 99)));
-        var after = state.DisplayedEventsForTab(state.EventTables.Single(table => table.GroupId == groupId));
-
-        Assert.False(ReferenceEquals(before, after));
-    }
-
-    [Fact]
-    public void DisplayedEventsForTab_UserGroup_AfterMembershipChanges_ReturnsNewInstance()
-    {
-        var log0 = new[] { MakeEvent(0, 1, Time(0, 30)) };
-        var log1 = new[] { MakeEvent(1, 1, Time(1, 20)) };
-        var log2 = new[] { MakeEvent(2, 1, Time(2, 10)) };
-        var (state, ids) = SeedLogs(log0, log1, log2);
-
-        var groupId = NewGroup(ref state, ids[0]);
-        state = Reducers.ReduceMoveTabToGroup(state, new MoveTabToGroupAction(ids[1], groupId));
-        var before = state.DisplayedEventsForTab(state.EventTables.Single(table => table.GroupId == groupId));
-
-        state = Reducers.ReduceMoveTabToGroup(state, new MoveTabToGroupAction(ids[2], groupId));
-        var after = state.DisplayedEventsForTab(state.EventTables.Single(table => table.GroupId == groupId));
-
-        Assert.False(ReferenceEquals(before, after));
-        Assert.Equal(3, after.Count);
-    }
-
-    [Fact]
-    public void DisplayedEventsForTab_UserGroup_MergesOnlyItsMembers()
-    {
-        var log0 = new[] { MakeEvent(0, 1, Time(0, 30)), MakeEvent(0, 2, Time(0, 10)) };
-        var log1 = new[] { MakeEvent(1, 1, Time(1, 20)) };
-        var log2 = new[] { MakeEvent(2, 1, Time(2, 30)), MakeEvent(2, 2, Time(2, 5)) };
-        var (state, ids) = SeedLogs(log0, log1, log2);
-
-        var groupId = NewGroup(ref state, ids[0]);
-        state = Reducers.ReduceMoveTabToGroup(state, new MoveTabToGroupAction(ids[2], groupId));
-        var header = state.EventTables.Single(table => table.GroupId == groupId);
-
-        var view = state.DisplayedEventsForTab(header);
-
-        AssertViewExactly(state, view, [.. log0, .. log2]);
-
-        var displayed = view.Slice(0, view.Count);
-
-        foreach (var excluded in log1)
-        {
-            Assert.DoesNotContain(displayed, row => SameEvent(excluded, row.Lean));
-        }
-    }
-
-    [Fact]
-    public void DisplayedEventsForTab_UserGroup_SameGeneration_ReturnsSameInstance()
-    {
-        var state = TwoMemberGroup(out var groupId);
-        var header = state.EventTables.Single(table => table.GroupId == groupId);
-
-        Assert.True(ReferenceEquals(state.DisplayedEventsForTab(header), state.DisplayedEventsForTab(header)));
-    }
-
-    [Fact]
-    public void GetActiveDisplayedEvents_ActiveNamedGroupHeader_ReturnsGroupMembersNotAllLogs()
+    public void GetActiveDisplayedEvents_ActiveNamedGroupHeader_ReturnsWhatThatGroupsTabIsShowing()
     {
         var (state, ids) = SeedLogs(
             [MakeEvent(0, 1, Time(0, 1))],
@@ -136,13 +42,22 @@ public void GetActiveDisplayedEvents_ActiveNamedGroupHeader_ReturnsGroupMembersN
         var header = state.EventTables.Single(table => table.GroupId == groupId);
         state = state with { ActiveEventLogId = header.Id };
 
+        var served = new OrderedViewReady(
+            SnapshotVersion: 1,
+            Identity: state.ViewIdentity,
+            Sequence: state.HighestInvalidationSequence,
+            SingleLogId: null,
+            InScope: [new LogGeneration(ids[0], 0), new LogGeneration(ids[1], 0)],
+            View: LogTableState.EmptyView,
+            Config: state.CommittedSortContext,
+            Filter: state.AppliedFilter);
+
+        state = state with { RetainedOrderedViews = RetainedViewTestFactory.RetainedMap(served) };
+
         var active = state.GetActiveDisplayedEvents();
 
-        // Export scopes to the group's members (ids[0], ids[1]); NOT the all-logs view that also includes the
-        // standalone ids[2]. Before the fix this returned DisplayedEvents (every log).
-        Assert.True(ReferenceEquals(active, state.DisplayedEventsForTab(header)));
-        Assert.False(ReferenceEquals(active, state.DisplayedEvents));
-        Assert.Equal(2, active.Count);
+        Assert.Same(served.View, active);
+        Assert.Same(state.DisplayedEventsForTab(header), active);
     }
 
     [Fact]
@@ -157,6 +72,39 @@ public void ReduceCloseAll_ClearsGroups()
         Assert.Empty(state.EventTables);
     }
 
+    [Fact]
+    public void ReduceCloseLog_ClosingAGroupMember_PrunesItFromBothMemberIdsAndTheRawStore()
+    {
+        var state = new LogTableState();
+        var rawStore = new RawEventStoreState();
+        var logs = new EventLogData[3];
+
+        for (int i = 0; i < logs.Length; i++)
+        {
+            logs[i] = new EventLogData($"Log{i}", LogPathType.Channel);
+
+            var addTable = new AddTableAction(logs[i]);
+            state = Reducers.ReduceAddTable(state, addTable);
+            rawStore = RawEventStoreReducers.ReduceAddTable(rawStore, addTable);
+        }
+
+        var groupId = NewGroup(ref state, logs[0].Id);
+        state = Reducers.ReduceMoveTabToGroup(state, new MoveTabToGroupAction(logs[1].Id, groupId));
+
+        Assert.Contains(logs[1].Id, state.Groups.Single(group => group.Id == groupId).MemberIds);
+        Assert.True(rawStore.ByLog.ContainsKey(logs[1].Id));
+
+        var closeMember = new CloseLogAction(logs[1].Id);
+        state = Reducers.ReduceCloseLog(state, closeMember);
+        rawStore = RawEventStoreReducers.ReduceCloseLog(rawStore, closeMember);
+
+        Assert.DoesNotContain(logs[1].Id, state.Groups.Single(group => group.Id == groupId).MemberIds);
+        Assert.False(rawStore.ByLog.ContainsKey(logs[1].Id));
+
+        Assert.Contains(logs[0].Id, state.Groups.Single(group => group.Id == groupId).MemberIds);
+        Assert.True(rawStore.ByLog.ContainsKey(logs[0].Id));
+    }
+
     [Fact]
     public void ReduceCloseLog_ClosingANonMember_KeepsTheUserGroupAndItsHeader()
     {
@@ -502,37 +450,6 @@ public void ReduceSetTabGroupCollapsed_WithUnknownGroup_IsANoOp()
         Assert.Same(state, result);
     }
 
-    private static LogTableState AppendBatch(LogTableState state, EventLogId logId, params ResolvedEvent[] events) =>
-        Reducers.ReduceAppendTableEventsBatch(state, new AppendTableEventsBatchAction
-        {
-            ViewsByLog = new Dictionary<EventLogId, EventColumnView>
-            {
-                [logId] = DisplayViewTestFactory.Build(logId, events)
-            }
-        });
-
-    private static void AssertViewExactly(
-        LogTableState state, IEventColumnView view, IReadOnlyList<ResolvedEvent> expected)
-    {
-        var oracle = AosReferenceOrdering.OrderedEvents(
-            expected,
-            ResolvedEventOrdering.ResolveDefaultOrderBy(state.OrderBy, state.GroupBy, state.PerLogEvents.Count, state.TimelineVisible),
-            state.IsDescending,
-            state.GroupBy,
-            state.IsGroupDescending);
-
-        Assert.Equal(oracle.Count, view.Count);
-
-        // The view rehydrates fresh ResolvedEvent objects from columns, so compare by value identity rather than
-        // reference (the AoS oracle holds the original object graph).
-        var displayed = view.Slice(0, view.Count);
-
-        for (int i = 0; i < oracle.Count; i++)
-        {
-            Assert.True(SameEvent(oracle[i], displayed[i].Lean), $"Order mismatch at index {i}.");
-        }
-    }
-
     private static ResolvedEvent MakeEvent(int logIndex, long? recordId, DateTime time) =>
         new($"Log{logIndex}", LogPathType.Channel) { RecordId = recordId, TimeCreated = time, Level = "Information" };
 
@@ -543,28 +460,18 @@ private static LogTabGroupId NewGroup(ref LogTableState state, EventLogId tabId)
         return state.Groups.Single(group => group.MemberIds.Contains(tabId)).Id;
     }
 
-    private static bool SameEvent(ResolvedEvent expected, ResolvedEvent actual) =>
-        expected.RecordId == actual.RecordId
-        && expected.Id == actual.Id
-        && expected.TimeCreated == actual.TimeCreated
-        && string.Equals(expected.Level, actual.Level, StringComparison.Ordinal);
-
     private static (LogTableState State, EventLogId[] Ids) SeedLogs(params IReadOnlyList<ResolvedEvent>[] perLog)
     {
         var state = new LogTableState();
         var ids = new EventLogId[perLog.Length];
-        var batch = new Dictionary<EventLogId, EventColumnView>(perLog.Length);
 
         for (int i = 0; i < perLog.Length; i++)
         {
             var data = new EventLogData($"Log{i}", LogPathType.Channel);
             ids[i] = data.Id;
             state = Reducers.ReduceAddTable(state, new AddTableAction(data));
-            batch[data.Id] = DisplayViewTestFactory.Build(data.Id, perLog[i]);
         }
 
-        state = Reducers.ReduceAppendTableEventsBatch(state, new AppendTableEventsBatchAction { ViewsByLog = batch });
-
         return (state, ids);
     }
 
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/LogTableQueriesTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/LogTableQueriesTests.cs
new file mode 100644
index 000000000..13b0d76b9
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/LogTableQueriesTests.cs
@@ -0,0 +1,214 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Runtime.LogTable;
+using Fluxor;
+using NSubstitute;
+using System.Collections.Immutable;
+
+namespace EventLogExpert.Runtime.Tests.LogTable;
+
+public sealed class LogTableQueriesTests
+{
+    [Fact]
+    public void GetTabGroups_ReturnsTheCurrentGroups()
+    {
+        var groupId = LogTabGroupId.Create();
+        var state = new LogTableState
+        {
+            Groups = [new LogTabGroup(groupId, "Group", ImmutableHashSet<EventLogId>.Empty)]
+        };
+
+        var groups = new LogTableQueries(StateReturning(state)).GetTabGroups();
+
+        Assert.Single(groups);
+        Assert.Equal(groupId, groups[0].Id);
+    }
+
+    [Fact]
+    public void HasActiveLogs_WhenANonCombinedTab_IsTrue_EvenWhileLoading()
+    {
+        var state = new LogTableState
+        {
+            EventTables = [new LogView(EventLogId.Create()) { LogName = "Application", IsLoading = true }]
+        };
+
+        Assert.True(new LogTableQueries(StateReturning(state)).HasActiveLogs());
+    }
+
+    [Fact]
+    public void HasActiveLogs_WhenNoTabs_IsFalse()
+    {
+        var queries = new LogTableQueries(StateReturning(new LogTableState()));
+
+        Assert.False(queries.HasActiveLogs());
+    }
+
+    [Fact]
+    public void HasActiveLogs_WhenOnlyCombinedTab_IsFalse()
+    {
+        var state = new LogTableState
+        {
+            EventTables = [new LogView(EventLogId.Create()) { GroupId = LogTabGroupId.AllLogs }]
+        };
+
+        Assert.False(new LogTableQueries(StateReturning(state)).HasActiveLogs());
+    }
+
+    [Fact]
+    public void HasMultipleIndividualTabs_ExcludesCombinedTabs()
+    {
+        var state = new LogTableState
+        {
+            EventTables =
+            [
+                new LogView(EventLogId.Create()) { GroupId = LogTabGroupId.AllLogs },
+                new LogView(EventLogId.Create()) { LogName = "Alpha" }
+            ]
+        };
+
+        Assert.False(new LogTableQueries(StateReturning(state)).HasMultipleIndividualTabs());
+    }
+
+    [Fact]
+    public void HasMultipleIndividualTabs_WhenTwoIndividualTabs_IsTrue()
+    {
+        var state = new LogTableState
+        {
+            EventTables =
+            [
+                new LogView(EventLogId.Create()) { LogName = "Alpha" },
+                new LogView(EventLogId.Create()) { LogName = "Beta" }
+            ]
+        };
+
+        Assert.True(new LogTableQueries(StateReturning(state)).HasMultipleIndividualTabs());
+    }
+
+    [Fact]
+    public void HasOtherTabsInGroup_CountsCurrentOpenUngroupedMembersOnly()
+    {
+        var groupId = LogTabGroupId.Create();
+        var present = EventLogId.Create();
+        var absent = EventLogId.Create();
+        var state = new LogTableState
+        {
+            EventTables = [new LogView(present) { LogName = "Present" }],
+            Groups = [new LogTabGroup(groupId, "Group", ImmutableHashSet.Create(present, absent))]
+        };
+
+        Assert.False(new LogTableQueries(StateReturning(state)).HasOtherTabsInGroup(groupId, present));
+    }
+
+    [Fact]
+    public void HasOtherTabsInGroup_WhenGroupMissing_IsFalse() =>
+        Assert.False(new LogTableQueries(StateReturning(new LogTableState()))
+            .HasOtherTabsInGroup(LogTabGroupId.Create(), EventLogId.Create()));
+
+    [Fact]
+    public void HasOtherTabsInGroup_WhenTwoOpenUngroupedMembers_IsTrue()
+    {
+        var groupId = LogTabGroupId.Create();
+        var keep = EventLogId.Create();
+        var other = EventLogId.Create();
+        var state = new LogTableState
+        {
+            EventTables =
+            [
+                new LogView(keep) { LogName = "Keep" },
+                new LogView(other) { LogName = "Other" }
+            ],
+            Groups = [new LogTabGroup(groupId, "Group", ImmutableHashSet.Create(keep, other))]
+        };
+
+        Assert.True(new LogTableQueries(StateReturning(state)).HasOtherTabsInGroup(groupId, keep));
+    }
+
+    [Fact]
+    public void HasTabGroup_ReflectsWhetherTheGroupExists()
+    {
+        var groupId = LogTabGroupId.Create();
+        var state = new LogTableState
+        {
+            Groups = [new LogTabGroup(groupId, "Group", ImmutableHashSet<EventLogId>.Empty)]
+        };
+        var queries = new LogTableQueries(StateReturning(state));
+
+        Assert.True(queries.HasTabGroup(groupId));
+        Assert.False(queries.HasTabGroup(LogTabGroupId.Create()));
+    }
+
+    [Fact]
+    public void IsGroupDescending_ReadsCommittedDirection_NotRequested()
+    {
+        var state = new LogTableState { IsGroupDescending = false, RequestedIsGroupDescending = true };
+
+        Assert.False(new LogTableQueries(StateReturning(state)).IsGroupDescending());
+    }
+
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public void IsGroupDescending_ReflectsTheCommittedDirection(bool descending)
+    {
+        var state = new LogTableState { GroupBy = ColumnName.Source, IsGroupDescending = descending };
+
+        Assert.Equal(descending, new LogTableQueries(StateReturning(state)).IsGroupDescending());
+    }
+
+    [Fact]
+    public void IsGrouping_ReadsCommittedGroupBy_NotRequested()
+    {
+        var state = new LogTableState { GroupBy = null, RequestedGroupBy = ColumnName.Source };
+
+        Assert.False(new LogTableQueries(StateReturning(state)).IsGrouping());
+    }
+
+    [Fact]
+    public void IsGrouping_ReflectsWhetherAColumnIsGrouped()
+    {
+        Assert.False(new LogTableQueries(StateReturning(new LogTableState { GroupBy = null })).IsGrouping());
+        Assert.True(new LogTableQueries(StateReturning(new LogTableState { GroupBy = ColumnName.Source })).IsGrouping());
+    }
+
+    [Fact]
+    public void IsTabOpen_ReflectsWhetherTheTabIsOpen()
+    {
+        var open = EventLogId.Create();
+        var state = new LogTableState { EventTables = [new LogView(open) { LogName = "Open" }] };
+        var queries = new LogTableQueries(StateReturning(state));
+
+        Assert.True(queries.IsTabOpen(open));
+        Assert.False(queries.IsTabOpen(EventLogId.Create()));
+    }
+
+    [Fact]
+    public void IsUngroupedTabOpen_WhenTabHasAGroupId_IsFalse()
+    {
+        var tab = EventLogId.Create();
+        var state = new LogTableState
+        {
+            EventTables = [new LogView(tab) { LogName = "Header", GroupId = LogTabGroupId.Create() }]
+        };
+
+        Assert.False(new LogTableQueries(StateReturning(state)).IsUngroupedTabOpen(tab));
+    }
+
+    [Fact]
+    public void IsUngroupedTabOpen_WhenTabIsOpenAndUngrouped_IsTrue()
+    {
+        var tab = EventLogId.Create();
+        var state = new LogTableState { EventTables = [new LogView(tab) { LogName = "Tab" }] };
+
+        Assert.True(new LogTableQueries(StateReturning(state)).IsUngroupedTabOpen(tab));
+    }
+
+    private static IState<LogTableState> StateReturning(LogTableState state)
+    {
+        var stateMock = Substitute.For<IState<LogTableState>>();
+        stateMock.Value.Returns(state);
+
+        return stateMock;
+    }
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/LogTableReducerDifferentialTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/LogTableReducerDifferentialTests.cs
deleted file mode 100644
index cb97fbaad..000000000
--- a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/LogTableReducerDifferentialTests.cs
+++ /dev/null
@@ -1,469 +0,0 @@
-// // Copyright (c) Microsoft Corporation.
-// // Licensed under the MIT License.
-
-using EventLogExpert.Eventing.Common.Channels;
-using EventLogExpert.Eventing.Common.EventLogs;
-using EventLogExpert.Eventing.Common.Events;
-using EventLogExpert.Runtime.LogTable;
-using EventLogExpert.Runtime.Tests.LogTable.TestSupport;
-using EventLogExpert.Runtime.Tests.TestUtils;
-using Reducers = EventLogExpert.Runtime.LogTable.Reducers;
-
-namespace EventLogExpert.Runtime.Tests.LogTable;
-
-// Randomized reducer ops checked against the array-of-structs oracle. The live path is now the columnar view, so the
-// oracle is the retained AoS sort and parity is asserted by VALUE identity (the view rehydrates fresh objects from
-// columns) over count, display order, Rank, Slice, and ResolveByKey.
-public sealed class LogTableReducerDifferentialTests
-{
-    [Fact]
-    public void DisplayedEvents_IsIdentityStable_UntilPerLogEventsChange()
-    {
-        var harness = new Harness(seed: 5);
-        harness.AppendToAnyLog();
-
-        var state = harness.State;
-
-        // Same PerLogEvents identity -> same combined instance.
-        Assert.Same(state.DisplayedEvents, state.DisplayedEvents);
-
-        var resorted = Reducers.ReduceToggleGroupSorting(state); // no GroupBy -> no-op, returns same state
-        Assert.Same(state, resorted);
-
-        var requested = Reducers.ReduceSetOrderBy(state, new SetOrderByAction(ColumnName.Level));
-        Assert.Same(state.PerLogEvents, requested.PerLogEvents);
-        Assert.Equal(state.DisplayListVersion + 1, requested.DisplayListVersion);
-
-        var afterOrderBy = Settle(requested);
-        Assert.NotSame(state.PerLogEvents, afterOrderBy.PerLogEvents);
-        Assert.NotSame(state.DisplayedEvents, afterOrderBy.DisplayedEvents);
-
-        harness.AppendToAnyLog();
-        Assert.NotSame(state.DisplayedEvents, harness.State.DisplayedEvents);
-    }
-
-    [Theory]
-    [InlineData(1)]
-    [InlineData(7)]
-    [InlineData(42)]
-    [InlineData(101)]
-    [InlineData(2026)]
-    [InlineData(31337)]
-    [InlineData(8675309)]
-    [InlineData(int.MaxValue)]
-    public void Reducers_KeepDisplayedAndPerLogViewsMatchingTheOracle_OverRandomOps(int seed)
-    {
-        var harness = new Harness(seed);
-
-        harness.Run(operationCount: 300);
-    }
-
-    private static LogTableState Settle(LogTableState state)
-    {
-        // The off-thread rebuild re-sorts every per-log view to the requested context and republishes; mirror that by
-        // healing the stored views to the requested context and dispatching DisplayReady.
-        var context = state.SortContext;
-        var views = new Dictionary<EventLogId, EventColumnView>(state.PerLogEvents.Count);
-
-        foreach (var (logId, view) in state.PerLogEvents)
-        {
-            views[logId] = view.WithContext(context);
-        }
-
-        return Reducers.ReduceDisplayReady(
-            state,
-            new DisplayReadyAction { Views = views, Version = state.DisplayListVersion });
-    }
-
-    private sealed class Harness
-    {
-        private static readonly string[] s_levels = ["Information", "Warning", "Error", "Critical"];
-        private static readonly string[] s_sources = ["Provider.A", "Provider.B", "Provider.C"];
-        private static readonly string[] s_tasks = ["", "Logon", "Service"];
-
-        private readonly ColumnName?[] _groupBys = [null, ColumnName.Source, ColumnName.Level, ColumnName.EventId];
-        private readonly List<LogModel> _logs = [];
-        private readonly ColumnName?[] _orderBys =
-            [null, ColumnName.DateAndTime, ColumnName.Level, ColumnName.Source, ColumnName.EventId, ColumnName.TaskCategory];
-        private readonly Random _rng;
-
-        public Harness(int seed) => _rng = new Random(seed);
-
-        public LogTableState State { get; private set; } = new();
-
-        private ColumnName? EffectiveOrderBy =>
-            ResolvedEventOrdering.ResolveDefaultOrderBy(State.OrderBy, State.GroupBy, OpenLogs().Count, State.TimelineVisible);
-
-        public void AppendToAnyLog()
-        {
-            var log = OpenLogs().FirstOrDefault() ?? AddLog();
-            AppendBatch([(log, GenerateBatch(log, 1 + _rng.Next(20)))]);
-        }
-
-        public void Run(int operationCount)
-        {
-            for (int step = 0; step < operationCount; step++)
-            {
-                ApplyRandomOperation();
-                AssertDisplayedMatchesOracle(step);
-                AssertPerLogViewsMatchOracle(step);
-                AssertRankMatchesOracle(step);
-                AssertSliceMatchesOracle(step);
-                AssertResolveByKeyRoundTrips(step);
-            }
-        }
-
-        private static bool SameEvent(ResolvedEvent expected, ResolvedEvent actual) =>
-            expected.RecordId == actual.RecordId
-            && expected.Id == actual.Id
-            && expected.TimeCreated == actual.TimeCreated
-            && expected.LogPathType == actual.LogPathType
-            && string.Equals(expected.OwningLog, actual.OwningLog, StringComparison.Ordinal)
-            && string.Equals(expected.Level, actual.Level, StringComparison.Ordinal)
-            && string.Equals(expected.Source, actual.Source, StringComparison.Ordinal)
-            && string.Equals(expected.TaskCategory, actual.TaskCategory, StringComparison.Ordinal);
-
-        private LogModel AddLog()
-        {
-            var data = new EventLogData($"Log{_logs.Count}", LogPathType.Channel);
-            var model = new LogModel(data.Id, data.Name, new DateTime(2026, 1, 1).AddDays(_logs.Count));
-            _logs.Add(model);
-            State = Reducers.ReduceAddTable(State, new AddTableAction(data));
-
-            return model;
-        }
-
-        private void AppendBatch(IReadOnlyList<(LogModel Log, IReadOnlyList<ResolvedEvent> Events)> batch)
-        {
-            var byLog = new Dictionary<EventLogId, EventColumnView>(batch.Count);
-
-            foreach (var (log, events) in batch)
-            {
-                log.Events.AddRange(events);
-
-                // Production rebuilds the full view over the whole raw store per append; mirror that with the full model.
-                byLog[log.Id] = DisplayViewTestFactory.Build(log.Id, log.Events);
-            }
-
-            State = Reducers.ReduceAppendTableEventsBatch(State, new AppendTableEventsBatchAction { ViewsByLog = byLog });
-        }
-
-        private void AppendSingle(LogModel log)
-        {
-            var events = GenerateBatch(log, 1 + _rng.Next(20));
-            log.Events.AddRange(events);
-
-            State = Reducers.ReduceAppendTableEvents(
-                State,
-                new AppendTableEventsAction(log.Id) { View = DisplayViewTestFactory.Build(log.Id, log.Events) });
-        }
-
-        private void ApplyRandomOperation()
-        {
-            var open = OpenLogs();
-            int roll = _rng.Next(100);
-
-            if (open.Count == 0 || (roll < 16 && _logs.Count(l => l.IsOpen) < 4))
-            {
-                var log = AddLog();
-                AppendBatch([(log, GenerateBatch(log, 1 + _rng.Next(30)))]);
-            }
-            else if (roll < 40)
-            {
-                int logCount = 1 + _rng.Next(open.Count);
-                var chosen = open.OrderBy(_ => _rng.Next()).Take(logCount)
-                    .Select(log => (log, (IReadOnlyList<ResolvedEvent>)GenerateBatch(log, 1 + _rng.Next(30)))).ToList();
-                AppendBatch(chosen);
-            }
-            else if (roll < 50)
-            {
-                AppendSingle(open[_rng.Next(open.Count)]);
-            }
-            else if (roll < 60)
-            {
-                Finalize(open[_rng.Next(open.Count)]);
-            }
-            else if (roll < 70)
-            {
-                ReapplyFilter(open);
-            }
-            else if (roll < 76)
-            {
-                // A batch addressed to an already-closed log must be dropped, not resurrected.
-                StaleAppendToClosedLog(open);
-            }
-            else if (roll < 83)
-            {
-                ApplySort(Reducers.ReduceSetOrderBy(State, new SetOrderByAction(_orderBys[_rng.Next(_orderBys.Length)])));
-            }
-            else if (roll < 89)
-            {
-                ApplySort(Reducers.ReduceSetGroupBy(State, new SetGroupByAction(_groupBys[_rng.Next(_groupBys.Length)])));
-            }
-            else if (roll < 93)
-            {
-                ApplySort(Reducers.ReduceToggleGroupSorting(State));
-            }
-            else if (roll < 97)
-            {
-                ApplySort(Reducers.ReduceToggleSorting(State));
-            }
-            else
-            {
-                // May close the last open log (the K->0 reconciliation branch).
-                CloseLog(open[_rng.Next(open.Count)]);
-            }
-        }
-
-        private void ApplySort(LogTableState requested)
-        {
-            State = requested.DisplayListVersion != State.DisplayListVersion ? Settle(requested) : requested;
-        }
-
-        private void AssertDisplayedMatchesOracle(int step)
-        {
-            var oracle = Oracle();
-            var displayed = State.DisplayedEvents;
-
-            Assert.True(
-                oracle.Count == displayed.Count,
-                $"Displayed count mismatch at step {step}: oracle={oracle.Count} displayed={displayed.Count} ({Describe()}).");
-
-            var rows = displayed.Slice(0, displayed.Count);
-
-            for (int i = 0; i < oracle.Count; i++)
-            {
-                Assert.True(
-                    SameEvent(oracle[i], rows[i].Lean),
-                    $"Displayed order mismatch at step {step}, index {i} ({Describe()}).");
-            }
-        }
-
-        private void AssertPerLogViewsMatchOracle(int step)
-        {
-            foreach (var log in OpenLogs())
-            {
-                var oracle = AosReferenceOrdering.OrderedEvents(
-                    log.Events, EffectiveOrderBy, State.IsDescending, State.GroupBy, State.IsGroupDescending);
-                var view = State.EventsForLog(log.Id);
-
-                Assert.True(
-                    oracle.Count == view.Count,
-                    $"Per-log count mismatch at step {step} for {log.Name}: oracle={oracle.Count} view={view.Count}.");
-
-                var rows = view.Slice(0, view.Count);
-
-                for (int i = 0; i < oracle.Count; i++)
-                {
-                    Assert.True(
-                        SameEvent(oracle[i], rows[i].Lean),
-                        $"Per-log order mismatch at step {step}, {log.Name}[{i}] ({Describe()}).");
-                }
-            }
-        }
-
-        private void AssertRankMatchesOracle(int step)
-        {
-            var displayed = State.DisplayedEvents;
-
-            if (displayed.Count == 0) { return; }
-
-            var rows = displayed.Slice(0, displayed.Count);
-
-            foreach (int index in SampleIndices(displayed.Count))
-            {
-                int rank = displayed.Rank(rows[index].Loc);
-
-                Assert.True(rank == index, $"Rank mismatch at step {step}: expected {index} got {rank} ({Describe()}).");
-            }
-        }
-
-        private void AssertResolveByKeyRoundTrips(int step)
-        {
-            var displayed = State.DisplayedEvents;
-
-            if (displayed.Count == 0) { return; }
-
-            var rows = displayed.Slice(0, displayed.Count);
-
-            foreach (int index in SampleIndices(displayed.Count))
-            {
-                var row = rows[index];
-
-                // The corpus uses non-null RecordIds, so every row carries a stable key that must re-resolve to its
-                // own locator, the value-key restore path across a reload.
-                Assert.True(ValueKey.TryCreate(row.Lean, out var key), $"Row missing a key at step {step}, index {index}.");
-                Assert.Equal(row.Loc, displayed.ResolveByKey(key));
-            }
-        }
-
-        private void AssertSliceMatchesOracle(int step)
-        {
-            var oracle = Oracle();
-            var displayed = State.DisplayedEvents;
-
-            foreach (var (start, count) in SampleWindows(oracle.Count))
-            {
-                var slice = displayed.Slice(start, count);
-                int expected = start >= oracle.Count ? 0 : Math.Min(count, oracle.Count - start);
-
-                Assert.True(
-                    slice.Count == expected,
-                    $"Slice length mismatch at step {step}, window ({start},{count}): expected {expected} got {slice.Count}.");
-
-                for (int i = 0; i < slice.Count; i++)
-                {
-                    Assert.True(
-                        SameEvent(oracle[start + i], slice[i].Lean),
-                        $"Slice element mismatch at step {step}, window ({start},{count})[{i}] ({Describe()}).");
-                }
-            }
-        }
-
-        private void CloseLog(LogModel log)
-        {
-            log.IsOpen = false;
-            State = Reducers.ReduceCloseLog(State, new CloseLogAction(log.Id));
-        }
-
-        private string Describe() =>
-            $"orderBy={State.OrderBy?.ToString() ?? "null"} desc={State.IsDescending} " +
-            $"groupBy={State.GroupBy?.ToString() ?? "null"} groupDesc={State.IsGroupDescending} logs={OpenLogs().Count}";
-
-        private void Finalize(LogModel log)
-        {
-            log.Events.Clear();
-            log.Events.AddRange(GenerateBatch(log, 1 + _rng.Next(60)));
-
-            State = Reducers.ReduceUpdateTable(
-                State,
-                new UpdateTableAction(log.Id)
-                {
-                    View = DisplayViewTestFactory.Build(log.Id, log.Events),
-                    Version = State.DisplayListVersion
-                });
-        }
-
-        private List<ResolvedEvent> GenerateBatch(LogModel log, int count)
-        {
-            var batch = new List<ResolvedEvent>(count);
-
-            for (int i = 0; i < count; i++)
-            {
-                log.LastTime = log.LastTime.AddMilliseconds(1 + _rng.Next(1000));
-
-                batch.Add(new ResolvedEvent(log.Name, LogPathType.Channel)
-                {
-                    RecordId = log.NextRecordId++,
-                    TimeCreated = log.LastTime,
-                    Id = 1000 + _rng.Next(6),
-                    Level = s_levels[_rng.Next(s_levels.Length)],
-                    Source = s_sources[_rng.Next(s_sources.Length)],
-                    TaskCategory = s_tasks[_rng.Next(s_tasks.Length)]
-                });
-            }
-
-            return batch;
-        }
-
-        private List<LogModel> OpenLogs() => _logs.Where(log => log.IsOpen).ToList();
-
-        private IReadOnlyList<ResolvedEvent> Oracle() =>
-            AosReferenceOrdering.OrderedEvents(
-                OpenLogs().SelectMany(log => log.Events),
-                EffectiveOrderBy, State.IsDescending, State.GroupBy, State.IsGroupDescending);
-
-        private void ReapplyFilter(IReadOnlyList<LogModel> open)
-        {
-            var activeLogs = new Dictionary<EventLogId, IReadOnlyList<ResolvedEvent>>(open.Count);
-
-            foreach (var log in open)
-            {
-                // Omit a log to exercise the preserve (stale-snapshot) branch.
-                if (_rng.Next(4) == 0) { continue; }
-
-                var kept = log.Events.Where(_ => _rng.Next(3) != 0).ToList();
-                log.Events.Clear();
-                log.Events.AddRange(kept);
-                activeLogs[log.Id] = kept;
-            }
-
-            var context = State.SortContext;
-            var views = new Dictionary<EventLogId, EventColumnView>(activeLogs.Count);
-
-            foreach (var (logId, events) in activeLogs)
-            {
-                views[logId] = DisplayViewTestFactory.Build(logId, events, context);
-            }
-
-            State = Reducers.ReduceDisplayReady(
-                State,
-                new DisplayReadyAction { Views = views, Version = State.DisplayListVersion });
-        }
-
-        private IEnumerable<int> SampleIndices(int count)
-        {
-            foreach (int candidate in new[] { 0, count / 2, count - 1 })
-            {
-                if (candidate >= 0 && candidate < count) { yield return candidate; }
-            }
-
-            for (int i = 0; i < 5; i++) { yield return _rng.Next(count); }
-        }
-
-        private IEnumerable<(int Start, int Count)> SampleWindows(int total)
-        {
-            yield return (0, 0);
-            yield return (0, total);
-
-            if (total == 0)
-            {
-                yield return (0, 4); // overrun on an empty view -> empty slice
-                yield break;
-            }
-
-            yield return (0, Math.Min(8, total));
-            yield return (Math.Max(0, total - 5), 5);            // tail, may overrun -> clamped
-            yield return (total, 3);                             // start at end -> empty
-            yield return (_rng.Next(total), 1 + _rng.Next(16));  // random window, may overrun -> clamped
-        }
-
-        private void StaleAppendToClosedLog(IReadOnlyList<LogModel> open)
-        {
-            var closed = _logs.Where(log => !log.IsOpen).ToList();
-
-            if (closed.Count == 0)
-            {
-                AppendSingle(open[_rng.Next(open.Count)]); // nothing closed yet; keep the op productive
-                return;
-            }
-
-            // Ghost events: not added to the model; the reducer drops them.
-            var target = closed[_rng.Next(closed.Count)];
-            var ghosts = GenerateBatch(target, 1 + _rng.Next(10));
-
-            State = Reducers.ReduceAppendTableEventsBatch(State, new AppendTableEventsBatchAction
-            {
-                ViewsByLog = new Dictionary<EventLogId, EventColumnView>
-                {
-                    [target.Id] = DisplayViewTestFactory.Build(target.Id, ghosts)
-                }
-            });
-        }
-
-        private sealed class LogModel(EventLogId id, string name, DateTime startTime)
-        {
-            public List<ResolvedEvent> Events { get; } = [];
-
-            public EventLogId Id { get; } = id;
-
-            public bool IsOpen { get; set; } = true;
-
-            public DateTime LastTime { get; set; } = startTime;
-
-            public string Name { get; } = name;
-
-            public long NextRecordId { get; set; } = 1;
-        }
-    }
-}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/LogTableReducerInvariantTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/LogTableReducerInvariantTests.cs
deleted file mode 100644
index fe2fd99c4..000000000
--- a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/LogTableReducerInvariantTests.cs
+++ /dev/null
@@ -1,297 +0,0 @@
-// // Copyright (c) Microsoft Corporation.
-// // Licensed under the MIT License.
-
-using EventLogExpert.Eventing.Common.Channels;
-using EventLogExpert.Eventing.Common.EventLogs;
-using EventLogExpert.Eventing.Common.Events;
-using EventLogExpert.Runtime.LogTable;
-using EventLogExpert.Runtime.Tests.LogTable.TestSupport;
-using EventLogExpert.Runtime.Tests.TestUtils;
-using Reducers = EventLogExpert.Runtime.LogTable.Reducers;
-
-namespace EventLogExpert.Runtime.Tests.LogTable;
-
-// Named-edge invariants; the differential test is the broad guard. The live path is the columnar view, so parity is by
-// value identity against the retained array-of-structs oracle.
-public sealed class LogTableReducerInvariantTests
-{
-    [Fact]
-    public void AppendingBatches_WhetherOutrankingOrStraddling_PreserveDisplayOrder()
-    {
-        // Level descending: Warning > Information > Error > Critical (ordinal). The old segmented list took a fast path
-        // or a merge fallback depending on whether the batch outranked or straddled; the columnar view rebuilds the
-        // whole order each time, so the only observable invariant is that display order stays exact regardless.
-        var info = MakeEvent(0, 1, Time(0, 1), level: "Information");
-        var error = MakeEvent(0, 2, Time(0, 2), level: "Error");
-        var warning = MakeEvent(0, 3, Time(0, 3), level: "Warning");
-        var info2 = MakeEvent(0, 4, Time(0, 4), level: "Information");
-        var critical = MakeEvent(0, 5, Time(0, 5), level: "Critical");
-
-        var data = new EventLogData("Log0", LogPathType.Channel);
-        var state = Reducers.ReduceAddTable(new LogTableState(), new AddTableAction(data));
-        state = Reducers.ReduceSetOrderBy(state, new SetOrderByAction(ColumnName.Level));
-        state = Settle(state);
-
-        state = AppendBatch(state, data.Id, info, error);
-        AssertDisplayedExactly(state, [info, error]);
-
-        // An outranking batch prepends ahead of the earlier events.
-        state = AppendBatch(state, data.Id, warning);
-        AssertDisplayedExactly(state, [info, error, warning]);
-
-        // A straddling batch interleaves with the earlier events.
-        state = AppendBatch(state, data.Id, info2, critical);
-        AssertDisplayedExactly(state, [info, error, warning, info2, critical]);
-    }
-
-    [Fact]
-    public void CloseLog_DropsExactlyThatLogsEvents_AndLeavesTheRestIntact()
-    {
-        var log0 = new[] { MakeEvent(0, 1, Time(0, 1)), MakeEvent(0, 2, Time(0, 2)) };
-        var log1 = new[] { MakeEvent(1, 1, Time(1, 1)), MakeEvent(1, 2, Time(1, 2)) };
-        var log2 = new[] { MakeEvent(2, 1, Time(2, 1)), MakeEvent(2, 2, Time(2, 2)) };
-        var (state, ids) = SeedLogs(log0, log1, log2);
-
-        state = Reducers.ReduceCloseLog(state, new CloseLogAction(ids[1]));
-
-        Assert.Equal(0, state.EventsForLog(ids[1]).Count);
-
-        var displayed = state.DisplayedEvents.Slice(0, state.DisplayedEvents.Count);
-
-        foreach (var dropped in log1)
-        {
-            Assert.DoesNotContain(displayed, row => SameEvent(dropped, row.Lean));
-        }
-
-        // Two per-log tables plus a fresh combined table remain.
-        Assert.Equal(2, state.EventTables.Count(table => !table.IsCombined));
-        Assert.Single(state.EventTables, table => table.IsCombined);
-        Assert.DoesNotContain(state.EventTables, table => table.Id == ids[1]);
-
-        // Independent oracle (test-owned refs), so a wipe fails loudly.
-        AssertDisplayedExactly(state, [.. log0, .. log2]);
-    }
-
-    [Fact]
-    public void DefaultOrder_IsRecordIdForOneLog_DateAndTimeForTwo_AndReconcilesAcrossTheBoundary()
-    {
-        // RecordId and timestamp order deliberately disagree here.
-        var a = MakeEvent(0, 1, Time(0, 30));
-        var b = MakeEvent(0, 2, Time(0, 10));
-        var c = MakeEvent(1, 1, Time(1, 20));
-        var d = MakeEvent(1, 2, Time(1, 5));
-
-        var log0 = new EventLogData("Log0", LogPathType.Channel);
-        var state = Reducers.ReduceAddTable(new LogTableState(), new AddTableAction(log0));
-        state = AppendBatch(state, log0.Id, a, b);
-
-        // One log: natural RecordId order.
-        Assert.Null(state.SortContext.OrderBy);
-        AssertEveryLogIsOnTheCurrentContext(state);
-        AssertDisplayedExactly(state, [a, b]);
-
-        // Opening a second log flips the default to DateAndTime.
-        var log1 = new EventLogData("Log1", LogPathType.Channel);
-        state = Reducers.ReduceAddTable(state, new AddTableAction(log1));
-        state = AppendBatch(state, log1.Id, c, d);
-
-        Assert.Equal(ColumnName.DateAndTime, state.SortContext.OrderBy);
-        AssertEveryLogIsOnTheCurrentContext(state);
-        AssertDisplayedExactly(state, [a, b, c, d]);
-
-        // Close back to one log: default returns to RecordId.
-        state = Reducers.ReduceCloseLog(state, new CloseLogAction(log1.Id));
-
-        Assert.Null(state.SortContext.OrderBy);
-        AssertEveryLogIsOnTheCurrentContext(state);
-        AssertDisplayedExactly(state, [a, b]);
-    }
-
-    [Fact]
-    public void NullRecordIdTies_WithinALog_ResolveToAStableBijection()
-    {
-        // Null-RecordId, same-timestamp reads tie on every sort key; the physical locator (its Index) is what separates
-        // them, so Rank must still map each displayed row to a distinct position.
-        var sharedTime = Time(0, 10);
-        var (state, _) = SeedLogs(
-        [
-            MakeEvent(0, 5, Time(0, 1)),
-            MakeEvent(0, null, sharedTime, level: "Error"),
-            MakeEvent(0, null, sharedTime, level: "Error"),
-            MakeEvent(0, null, sharedTime, level: "Error"),
-            MakeEvent(0, 6, Time(0, 20))
-        ]);
-
-        var displayed = state.DisplayedEvents;
-        Assert.Equal(5, displayed.Count);
-
-        var rows = displayed.Slice(0, displayed.Count);
-        var positions = new HashSet<int>();
-
-        foreach (var row in rows)
-        {
-            int index = displayed.Rank(row.Loc);
-
-            Assert.InRange(index, 0, displayed.Count - 1);
-            Assert.True(positions.Add(index), $"Index {index} was claimed by two events (not a bijection).");
-        }
-
-        Assert.Equal(displayed.Count, positions.Count);
-    }
-
-    [Fact]
-    public void SetGroupBy_TransitionsEveryLogAtomically_ThenFastPathAppendsStayConsistent()
-    {
-        var log0 = new[] { MakeEvent(0, 1, Time(0, 5), source: "A"), MakeEvent(0, 2, Time(0, 3), source: "B") };
-        var log1 = new[] { MakeEvent(1, 1, Time(1, 9), source: "B"), MakeEvent(1, 2, Time(1, 1), source: "A") };
-        var (state, ids) = SeedLogs(log0, log1);
-
-        state = Reducers.ReduceSetGroupBy(state, new SetGroupByAction(ColumnName.Source));
-        state = Settle(state);
-
-        AssertEveryLogIsOnTheCurrentContext(state);
-
-        var append0 = MakeEvent(0, 3, Time(0, 7), source: "A");
-        var append1 = MakeEvent(1, 3, Time(1, 4), source: "B");
-        state = AppendMultiLogBatch(state, (ids[0], [append0]), (ids[1], [append1]));
-
-        AssertEveryLogIsOnTheCurrentContext(state);
-        AssertDisplayedExactly(state, [.. log0, .. log1, append0, append1]);
-    }
-
-    [Fact]
-    public void SetOrderBy_TransitionsEveryLogAtomically_ThenFastPathAppendsStayConsistent()
-    {
-        var log0 = new[] { MakeEvent(0, 1, Time(0, 5)), MakeEvent(0, 2, Time(0, 3)) };
-        var log1 = new[] { MakeEvent(1, 1, Time(1, 9)), MakeEvent(1, 2, Time(1, 1)) };
-        var (state, ids) = SeedLogs(log0, log1);
-
-        state = Reducers.ReduceSetOrderBy(state, new SetOrderByAction(ColumnName.Level));
-        state = Settle(state);
-
-        // Atomicity: no view may lag the old context.
-        AssertEveryLogIsOnTheCurrentContext(state);
-
-        var append0 = MakeEvent(0, 3, Time(0, 7), level: "Critical");
-        var append1 = MakeEvent(1, 3, Time(1, 4), level: "Warning");
-        state = AppendMultiLogBatch(state, (ids[0], [append0]), (ids[1], [append1]));
-
-        AssertEveryLogIsOnTheCurrentContext(state);
-
-        // Independent oracle: the six refs we created.
-        AssertDisplayedExactly(state, [.. log0, .. log1, append0, append1]);
-    }
-
-    private static LogTableState AppendBatch(LogTableState state, EventLogId logId, params ResolvedEvent[] events) =>
-        AppendMultiLogBatch(state, (logId, events));
-
-    // The columnar view is a full snapshot rebuilt over the whole raw store per append, so accumulate the delta onto the
-    // log's current events (rehydrated from the stored view) and store the full rebuilt view, mirroring production.
-    private static LogTableState AppendMultiLogBatch(
-        LogTableState state, params (EventLogId LogId, ResolvedEvent[] Events)[] perLog)
-    {
-        var views = new Dictionary<EventLogId, EventColumnView>(perLog.Length);
-
-        foreach (var (logId, events) in perLog)
-        {
-            List<ResolvedEvent> all = state.PerLogEvents.TryGetValue(logId, out var existing)
-                ? [.. existing.EnumerateDetail(), .. events]
-                : [.. events];
-
-            views[logId] = DisplayViewTestFactory.Build(logId, all);
-        }
-
-        return Reducers.ReduceAppendTableEventsBatch(state, new AppendTableEventsBatchAction { ViewsByLog = views });
-    }
-
-    // Asserts against test-owned refs, so a dropped event fails loudly. The view rehydrates fresh objects, so compare by
-    // value identity rather than reference.
-    private static void AssertDisplayedExactly(LogTableState state, IReadOnlyList<ResolvedEvent> expected)
-    {
-        var oracle = AosReferenceOrdering.OrderedEvents(
-            expected,
-            ResolvedEventOrdering.ResolveDefaultOrderBy(state.OrderBy, state.GroupBy, state.PerLogEvents.Count, state.TimelineVisible),
-            state.IsDescending,
-            state.GroupBy,
-            state.IsGroupDescending);
-
-        var displayed = state.DisplayedEvents;
-
-        Assert.Equal(oracle.Count, displayed.Count);
-
-        var rows = displayed.Slice(0, displayed.Count);
-
-        for (int i = 0; i < oracle.Count; i++)
-        {
-            Assert.True(SameEvent(oracle[i], rows[i].Lean), $"Order mismatch at index {i}.");
-        }
-    }
-
-    private static void AssertEveryLogIsOnTheCurrentContext(LogTableState state)
-    {
-        var displayed = new SortContext(
-            ResolvedEventOrdering.ResolveDefaultOrderBy(state.OrderBy, state.GroupBy, state.PerLogEvents.Count, state.TimelineVisible),
-            state.IsDescending,
-            state.GroupBy,
-            state.IsGroupDescending);
-
-        foreach (var view in state.PerLogEvents.Values)
-        {
-            Assert.True(view.HasContext(displayed), "A per-log view lagged the state's displayed context.");
-        }
-    }
-
-    private static ResolvedEvent MakeEvent(
-        int logIndex, long? recordId, DateTime time, string level = "Information", string source = "Provider") =>
-        new($"Log{logIndex}", LogPathType.Channel)
-        {
-            RecordId = recordId,
-            TimeCreated = time,
-            Level = level,
-            Source = source
-        };
-
-    private static bool SameEvent(ResolvedEvent expected, ResolvedEvent actual) =>
-        expected.RecordId == actual.RecordId
-        && expected.Id == actual.Id
-        && expected.TimeCreated == actual.TimeCreated
-        && string.Equals(expected.Level, actual.Level, StringComparison.Ordinal)
-        && string.Equals(expected.Source, actual.Source, StringComparison.Ordinal);
-
-    private static (LogTableState State, EventLogId[] Ids) SeedLogs(params IReadOnlyList<ResolvedEvent>[] perLog)
-    {
-        var state = new LogTableState();
-        var ids = new EventLogId[perLog.Length];
-        var batch = new Dictionary<EventLogId, EventColumnView>(perLog.Length);
-
-        for (int i = 0; i < perLog.Length; i++)
-        {
-            var data = new EventLogData($"Log{i}", LogPathType.Channel);
-            ids[i] = data.Id;
-            state = Reducers.ReduceAddTable(state, new AddTableAction(data));
-            batch[data.Id] = DisplayViewTestFactory.Build(data.Id, perLog[i]);
-        }
-
-        state = Reducers.ReduceAppendTableEventsBatch(state, new AppendTableEventsBatchAction { ViewsByLog = batch });
-
-        return (state, ids);
-    }
-
-    private static LogTableState Settle(LogTableState state)
-    {
-        var context = state.SortContext;
-        var views = new Dictionary<EventLogId, EventColumnView>(state.PerLogEvents.Count);
-
-        foreach (var (logId, view) in state.PerLogEvents)
-        {
-            views[logId] = view.WithContext(context);
-        }
-
-        return Reducers.ReduceDisplayReady(
-            state,
-            new DisplayReadyAction { Views = views, Version = state.DisplayListVersion });
-    }
-
-    private static DateTime Time(int logIndex, int seconds) =>
-        new DateTime(2026, 1, 1, 0, 0, 0, DateTimeKind.Utc).AddDays(logIndex).AddSeconds(seconds);
-}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/LogTableStoreTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/LogTableStoreTests.cs
index dbad22b50..d7ed2b588 100644
--- a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/LogTableStoreTests.cs
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/LogTableStoreTests.cs
@@ -7,12 +7,13 @@
 using EventLogExpert.Filtering.TestUtils;
 using EventLogExpert.Filtering.TestUtils.Constants;
 using EventLogExpert.Runtime.LogTable;
-using EventLogExpert.Runtime.Tests.LogTable.TestSupport;
-using EventLogExpert.Runtime.Tests.TestUtils;
+using EventLogExpert.Runtime.LogTable.OrderedView;
 using EventLogExpert.Runtime.Tests.TestUtils.Constants;
 using System.Collections.Immutable;
 using ApplyFilterAction = EventLogExpert.Runtime.EventLog.ApplyFilterAction;
 using CloseLogAction = EventLogExpert.Runtime.LogTable.CloseLogAction;
+using LoadEventsAction = EventLogExpert.Runtime.EventLog.LoadEventsAction;
+using LoadEventsPartialAction = EventLogExpert.Runtime.EventLog.LoadEventsPartialAction;
 using Reducers = EventLogExpert.Runtime.LogTable.Reducers;
 
 namespace EventLogExpert.Runtime.Tests.LogTable;
@@ -21,149 +22,29 @@ public sealed class LogTableStoreTests
 {
     private static readonly ColumnDefaults s_columnDefaults = new();
 
-    [Fact]
-    public void DisplayedEvents_WithSingleLog_ShouldResolveAClonedEventToTheLiveIndex()
-    {
-        var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
-        var state = new LogTableState();
-        state = Reducers.ReduceAddTable(state, new AddTableAction(logData));
-        state = Reducers.ReduceUpdateTable(
-            state,
-            CreateUpdateAction(state, logData.Id, new List<ResolvedEvent>
-            {
-                new(Constants.LogNameTestLog, LogPathType.Channel) { Id = 1, RecordId = 10 },
-                new(Constants.LogNameTestLog, LogPathType.Channel) { Id = 2, RecordId = 20 }
-            }));
-
-        var displayed = state.DisplayedEvents;
-        var liveRow = displayed.Slice(0, displayed.Count).First(row => row.Lean.RecordId == 20);
-        var clone = new ResolvedEvent(Constants.LogNameTestLog, LogPathType.Channel) { Id = 2, RecordId = 20 };
-
-        // A value-equal clone (e.g. a reloaded selection) resolves to the live instance's index via the single-log
-        // fast path, matching CombinedColumnView's key-based Rank rather than returning -1.
-        Assert.True(ValueKey.TryCreate(clone, out var key));
-        var resolved = displayed.ResolveByKey(key);
-        Assert.NotNull(resolved);
-        Assert.Equal(displayed.Rank(liveRow.Loc), displayed.Rank(resolved.Value));
-    }
-
-    [Fact]
-    public void DisplayedEvents_WithSingleLog_ShouldReturnAStableReferenceAcrossReads()
-    {
-        var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
-        var state = new LogTableState();
-        state = Reducers.ReduceAddTable(state, new AddTableAction(logData));
-        state = Reducers.ReduceAppendTableEvents(
-            state,
-            CreateAppendAction(state, logData.Id, new List<ResolvedEvent>
-            {
-                FilterEventBuilder.CreateTestEvent(100, recordId: 10)
-            }));
-
-        // LogTablePane skips re-indexing while DisplayedEvents is reference-stable, so the fast path must
-        // return the same instance across reads when PerLogEvents is unchanged.
-        Assert.Same(state.DisplayedEvents, state.DisplayedEvents);
-    }
-
-    [Fact]
-    public void DisplayedEvents_WithSingleLog_ShouldServeThePerLogListDirectly()
-    {
-        // Arrange: one open log with events.
-        var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
-        var state = new LogTableState();
-        state = Reducers.ReduceAddTable(state, new AddTableAction(logData));
-        state = Reducers.ReduceAppendTableEvents(
-            state,
-            CreateAppendAction(state, logData.Id, new List<ResolvedEvent>
-            {
-                FilterEventBuilder.CreateTestEvent(100, recordId: 10),
-                FilterEventBuilder.CreateTestEvent(200, recordId: 20)
-            }));
-
-        // Assert: the single-log fast path returns the per-log list itself (same reference as EventsForLog),
-        // bypassing the CombinedColumnView merge wrapper used for multiple logs.
-        Assert.Same(state.EventsForLog(logData.Id), state.DisplayedEvents);
-    }
-
-    [Fact]
-    public void DisplayedEvents_WithTwoLogs_ShouldServeCombinedViewNotAPerLogList()
-    {
-        // Arrange: two open logs. Both tables are added before either is populated so that every
-        // per-log list is built under the same (multi-log) sort context, matching the real load flow.
-        var first = new EventLogData(Constants.LogNameLog1, LogPathType.Channel);
-        var second = new EventLogData(Constants.LogNameLog2, LogPathType.Channel);
-        var state = new LogTableState();
-        state = Reducers.ReduceAddTable(state, new AddTableAction(first));
-        state = Reducers.ReduceAddTable(state, new AddTableAction(second));
-        state = Reducers.ReduceUpdateTable(
-            state,
-            CreateUpdateAction(state, first.Id, new List<ResolvedEvent>
-            {
-                new(Constants.LogNameLog1, LogPathType.Channel) { Id = 100, RecordId = 10 }
-            }));
-        state = Reducers.ReduceUpdateTable(
-            state,
-            CreateUpdateAction(state, second.Id, new List<ResolvedEvent>
-            {
-                new(Constants.LogNameLog2, LogPathType.Channel) { Id = 200, RecordId = 20 }
-            }));
-
-        // Assert: with multiple logs the merged view is served, distinct from either per-log list.
-        Assert.NotSame(state.EventsForLog(first.Id), state.DisplayedEvents);
-        Assert.NotSame(state.EventsForLog(second.Id), state.DisplayedEvents);
-        Assert.Equal(2, state.DisplayedEvents.Count);
-    }
-
     [Fact]
     public void EventTableAction_AddTable_ShouldStoreLogData()
     {
-        // Arrange
         var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
 
-        // Act
         var action = new AddTableAction(logData);
 
-        // Assert
         Assert.Equal(logData, action.LogData);
     }
 
     [Fact]
     public void EventTableAction_CloseLog_ShouldStoreLogId()
     {
-        // Arrange
         var logId = EventLogId.Create();
 
-        // Act
         var action = new CloseLogAction(logId);
 
-        // Assert
         Assert.Equal(logId, action.LogId);
     }
 
-    [Fact]
-    public void EventTableAction_DisplayReady_ShouldStoreLists()
-    {
-        // Arrange
-        var logId = EventLogId.Create();
-        var events = new List<ResolvedEvent> { FilterEventBuilder.CreateTestEvent(100) };
-
-        var views = new Dictionary<EventLogId, EventColumnView>
-        {
-            { logId, DisplayViewTestFactory.Build(logId, events, new SortContext(null, true, null, false)) }
-        };
-
-        // Act
-        var action = new DisplayReadyAction { Views = views };
-
-        // Assert
-        Assert.Single(action.Views);
-        Assert.True(action.Views.ContainsKey(logId));
-    }
-
     [Fact]
     public void EventTableAction_LoadColumnsCompleted_ShouldStoreColumns()
     {
-        // Arrange
         var columns = new Dictionary<ColumnName, bool>
         {
             { ColumnName.Level, true },
@@ -178,10 +59,8 @@ public void EventTableAction_LoadColumnsCompleted_ShouldStoreColumns()
 
         var order = s_columnDefaults.ColumnOrder;
 
-        // Act
         var action = new LoadColumnsCompletedAction(columns.ToImmutableDictionary(), widths.ToImmutableDictionary(), order);
 
-        // Assert
         Assert.Equal(2, action.LoadedColumns.Count);
         Assert.True(action.LoadedColumns[ColumnName.Level]);
         Assert.True(action.LoadedColumns[ColumnName.DateAndTime]);
@@ -190,86 +69,42 @@ public void EventTableAction_LoadColumnsCompleted_ShouldStoreColumns()
     [Fact]
     public void EventTableAction_SetActiveTable_ShouldStoreLogId()
     {
-        // Arrange
         var logId = EventLogId.Create();
 
-        // Act
         var action = new SetActiveTableAction(logId);
 
-        // Assert
         Assert.Equal(logId, action.LogId);
     }
 
     [Fact]
     public void EventTableAction_SetOrderBy_ShouldStoreColumnName()
     {
-        // Act
         var action = new SetOrderByAction(ColumnName.Level);
 
-        // Assert
         Assert.Equal(ColumnName.Level, action.OrderBy);
     }
 
     [Fact]
     public void EventTableAction_SetOrderBy_WithNull_ShouldStoreNull()
     {
-        // Act
         var action = new SetOrderByAction(null);
 
-        // Assert
         Assert.Null(action.OrderBy);
     }
 
     [Fact]
     public void EventTableAction_ToggleColumn_ShouldStoreColumnName()
     {
-        // Act
         var action = new ToggleColumnAction(ColumnName.Source);
 
-        // Assert
         Assert.Equal(ColumnName.Source, action.ColumnName);
     }
 
-    [Fact]
-    public void EventTableAction_ToggleLoading_ShouldStoreLogId()
-    {
-        // Arrange
-        var logId = EventLogId.Create();
-
-        // Act
-        var action = new ToggleLoadingAction(logId);
-
-        // Assert
-        Assert.Equal(logId, action.LogId);
-    }
-
-    [Fact]
-    public void EventTableAction_UpdateTable_ShouldStoreLogIdAndEvents()
-    {
-        // Arrange
-        var logId = EventLogId.Create();
-
-        var events = new List<ResolvedEvent>
-        {
-            FilterEventBuilder.CreateTestEvent(100),
-            FilterEventBuilder.CreateTestEvent(200)
-        };
-
-        // Act
-        var action = CreateUpdateAction(new LogTableState(), logId, events, version: 0);
-
-        // Assert
-        Assert.Equal(logId, action.LogId);
-        Assert.Equal(2, action.View?.Count);
-    }
-
     [Fact]
     public void IntegrationTest_ColumnManagement()
     {
-        // Arrange
         var state = new LogTableState();
 
-        // Act: Load columns
         var columns = new Dictionary<ColumnName, bool>
         {
             { ColumnName.Level, true },
@@ -281,59 +116,28 @@ public void IntegrationTest_ColumnManagement()
             state,
             new LoadColumnsCompletedAction(columns.ToImmutableDictionary(), ImmutableDictionary<ColumnName, int>.Empty, s_columnDefaults.ColumnOrder));
 
-        // Assert
         Assert.Equal(3, state.Columns.Count);
         Assert.True(state.Columns[ColumnName.Level]);
         Assert.False(state.Columns[ColumnName.Source]);
     }
 
-    [Fact]
-    public void IntegrationTest_LoadAndUpdateTableEvents()
-    {
-        // Arrange
-        var state = new LogTableState();
-        var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
-
-        // Act: Add table
-        state = Reducers.ReduceAddTable(state, new AddTableAction(logData));
-        Assert.True(state.EventTables.First().IsLoading);
-
-        // Act: Update table with events
-        var events = new List<ResolvedEvent>
-        {
-            FilterEventBuilder.CreateTestEvent(100),
-            FilterEventBuilder.CreateTestEvent(200)
-        };
-
-        state = Reducers.ReduceUpdateTable(state, CreateUpdateAction(state, logData.Id, events));
-
-        // Assert
-        Assert.False(state.EventTables.First().IsLoading);
-        Assert.Equal(2, state.DisplayedEvents.Count);
-    }
-
     [Fact]
     public void IntegrationTest_OpenMultipleLogsAndCloseOne()
     {
-        // Arrange
         var state = new LogTableState();
         var logData1 = new EventLogData(Constants.LogNameLog1, LogPathType.Channel);
         var logData2 = new EventLogData(Constants.LogNameLog2, LogPathType.Channel);
         var logData3 = new EventLogData(Constants.LogNameLog3, LogPathType.Channel);
 
-        // Act: Open three logs
         state = Reducers.ReduceAddTable(state, new AddTableAction(logData1));
         state = Reducers.ReduceAddTable(state, new AddTableAction(logData2));
         state = Reducers.ReduceAddTable(state, new AddTableAction(logData3));
 
-        // Assert: Should have 4 tables (3 logs + 1 combined)
         Assert.Equal(4, state.EventTables.Count);
         Assert.Single(state.EventTables, t => t.IsCombined);
 
-        // Act: Close one log
         state = Reducers.ReduceCloseLog(state, new CloseLogAction(logData2.Id));
 
-        // Assert: Should have 3 tables (2 logs + 1 combined)
         Assert.Equal(3, state.EventTables.Count);
         Assert.Single(state.EventTables, t => t.IsCombined);
         Assert.DoesNotContain(state.EventTables, t => t.Id == logData2.Id);
@@ -359,10 +163,8 @@ public void IsGroupCollapsed_XorsDefaultAndOverride(bool collapsedByDefault, boo
     [Fact]
     public void LogTableState_DefaultState_ShouldHaveCorrectDefaults()
     {
-        // Arrange & Act
         var state = new LogTableState();
 
-        // Assert
         Assert.Empty(state.EventTables);
         Assert.Null(state.ActiveEventLogId);
         Assert.Empty(state.Columns);
@@ -373,89 +175,210 @@ public void LogTableState_DefaultState_ShouldHaveCorrectDefaults()
     }
 
     [Fact]
-    public void LogView_ComputerName_AfterFirstEventArrives_ShouldBeStoredOnTable()
+    public void LogView_ComputerName_WhenAlreadyLatched_ShouldNotBeOverwrittenByRawLoad()
     {
-        // Arrange
         var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
         var state = new LogTableState();
         state = Reducers.ReduceAddTable(state, new AddTableAction(logData));
 
-        var firstBatch = new List<ResolvedEvent>
+        state = Reducers.ReduceLoadEventsPartial(
+            state,
+            new LoadEventsPartialAction(
+                logData,
+                [
+                    new(Constants.LogNameTestLog, LogPathType.Channel)
+                    {
+                        Id = 10, RecordId = 1, ComputerName = FilterTestConstants.EventComputerServer01
+                    }
+                ]));
+
+        state = Reducers.ReduceLoadEvents(
+            state,
+            new LoadEventsAction(
+                logData,
+                [
+                    new(Constants.LogNameTestLog, LogPathType.Channel)
+                    {
+                        Id = 11, RecordId = 2, ComputerName = FilterTestConstants.EventComputerServer02
+                    }
+                ]));
+
+        Assert.Equal(
+            FilterTestConstants.EventComputerServer01,
+            state.EventTables.First(t => t.Id == logData.Id).ComputerName);
+    }
+
+    [Fact]
+    public void LogView_ComputerName_WhenIngestTargetsCombinedTab_ShouldNotLatch()
+    {
+        var combinedId = EventLogId.Create();
+        var state = new LogTableState
+        {
+            EventTables = [new LogView(combinedId) { GroupId = LogTabGroupId.AllLogs, LogName = Constants.LogNameTestLog }]
+        };
+
+        var byLog = new Dictionary<EventLogId, IReadOnlyList<ResolvedEvent>>
         {
-            new(Constants.LogNameTestLog, LogPathType.Channel) { Id = 10, RecordId = 1, ComputerName = FilterTestConstants.EventComputerServer01 }
+            [combinedId] =
+            [
+                new(Constants.LogNameTestLog, LogPathType.Channel)
+                {
+                    Id = 10, RecordId = 1, ComputerName = FilterTestConstants.EventComputerServer01
+                }
+            ]
         };
 
-        state = Reducers.ReduceAppendTableEvents(
-            state,
-            CreateAppendAction(state, logData.Id, firstBatch));
+        var next = Reducers.ReduceIngestRawEvents(state, new IngestRawEventsAction(byLog, RawIngestMode.Append));
+
+        Assert.Equal(string.Empty, next.EventTables.First(t => t.Id == combinedId).ComputerName);
+    }
+
+    [Fact]
+    public void LogView_ComputerName_WhenIngestTargetsUnknownLog_ShouldLeaveTablesUntouched()
+    {
+        var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
+        var state = new LogTableState();
+        state = Reducers.ReduceAddTable(state, new AddTableAction(logData));
 
-        var secondBatch = new List<ResolvedEvent>
+        var byLog = new Dictionary<EventLogId, IReadOnlyList<ResolvedEvent>>
         {
-            new(Constants.LogNameTestLog, LogPathType.Channel) { Id = 11, RecordId = 2, ComputerName = FilterTestConstants.EventComputerServer02 }
+            [EventLogId.Create()] =
+            [
+                new(Constants.LogNameTestLog, LogPathType.Channel)
+                {
+                    Id = 10, RecordId = 1, ComputerName = FilterTestConstants.EventComputerServer01
+                }
+            ]
         };
 
-        // Act: second batch with a different ComputerName must not overwrite the latched value
-        state = Reducers.ReduceAppendTableEvents(
-            state,
-            CreateAppendAction(state, logData.Id, secondBatch));
+        var next = Reducers.ReduceIngestRawEvents(state, new IngestRawEventsAction(byLog, RawIngestMode.Append));
 
-        // Assert: ComputerName latches to the first non-empty observed value
-        var table = state.EventTables.First(t => t.Id == logData.Id);
-        Assert.Equal(FilterTestConstants.EventComputerServer01, table.ComputerName);
+        Assert.Equal(string.Empty, next.EventTables.First(t => t.Id == logData.Id).ComputerName);
     }
 
     [Fact]
-    public void LogView_ComputerName_WhenFirstEventHasEmptyComputerName_ShouldUseLaterEventInBatch()
+    public void LogView_ComputerName_WhenLiveTailIngestArrives_ShouldLatch()
     {
-        // Arrange: first event has an empty ComputerName (resolver miss); second carries the name
         var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
         var state = new LogTableState();
         state = Reducers.ReduceAddTable(state, new AddTableAction(logData));
 
-        var batch = new List<ResolvedEvent>
+        var byLog = new Dictionary<EventLogId, IReadOnlyList<ResolvedEvent>>
         {
-            new(Constants.LogNameTestLog, LogPathType.Channel) { Id = 10, RecordId = 1, ComputerName = string.Empty },
-            new(Constants.LogNameTestLog, LogPathType.Channel) { Id = 11, RecordId = 2, ComputerName = FilterTestConstants.EventComputerServer01 }
+            [logData.Id] =
+            [
+                new(Constants.LogNameTestLog, LogPathType.Channel)
+                {
+                    Id = 10, RecordId = 1, ComputerName = FilterTestConstants.EventComputerServer01
+                }
+            ]
         };
 
-        // Act
-        state = Reducers.ReduceAppendTableEvents(
-            state,
-            CreateAppendAction(state, logData.Id, batch));
+        state = Reducers.ReduceIngestRawEvents(state, new IngestRawEventsAction(byLog, RawIngestMode.Append));
 
-        // Assert: reducer scans past the empty leading event and latches the first non-empty value
-        var table = state.EventTables.First(t => t.Id == logData.Id);
-        Assert.Equal(FilterTestConstants.EventComputerServer01, table.ComputerName);
+        Assert.Equal(
+            FilterTestConstants.EventComputerServer01,
+            state.EventTables.First(t => t.Id == logData.Id).ComputerName);
     }
 
     [Fact]
     public void LogView_ComputerName_WhenNoEvents_ShouldReturnEmpty()
     {
-        // Arrange
         var model = new LogView(EventLogId.Create());
 
-        // Act
         var computerName = model.ComputerName;
 
-        // Assert
         Assert.Equal(string.Empty, computerName);
     }
 
+    [Fact]
+    public void LogView_ComputerName_WhenPartialRawLoadArrives_ShouldLatchBeforeFinalize()
+    {
+        var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
+        var state = new LogTableState();
+        state = Reducers.ReduceAddTable(state, new AddTableAction(logData));
+
+        var partial = new List<ResolvedEvent>
+        {
+            new(Constants.LogNameTestLog, LogPathType.Channel)
+            {
+                Id = 10, RecordId = 1, ComputerName = FilterTestConstants.EventComputerServer01
+            }
+        };
+
+        state = Reducers.ReduceLoadEventsPartial(state, new LoadEventsPartialAction(logData, partial));
+
+        Assert.Equal(
+            FilterTestConstants.EventComputerServer01,
+            state.EventTables.First(t => t.Id == logData.Id).ComputerName);
+    }
+
+    [Fact]
+    public void LogView_ComputerName_WhenRawLoadCompletes_ShouldLatchWithoutDisplayFinalize()
+    {
+        var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
+        var state = new LogTableState();
+        state = Reducers.ReduceAddTable(state, new AddTableAction(logData));
+
+        var events = new List<ResolvedEvent>
+        {
+            new(Constants.LogNameTestLog, LogPathType.Channel) { Id = 10, RecordId = 1, ComputerName = string.Empty },
+            new(Constants.LogNameTestLog, LogPathType.Channel)
+            {
+                Id = 11, RecordId = 2, ComputerName = FilterTestConstants.EventComputerServer01
+            }
+        };
+
+        state = Reducers.ReduceLoadEvents(state, new LoadEventsAction(logData, events));
+
+        Assert.Equal(
+            FilterTestConstants.EventComputerServer01,
+            state.EventTables.First(t => t.Id == logData.Id).ComputerName);
+    }
+
+    [Fact]
+    public void LogView_IsLoading_WhenRawLoadCompletesWithNoEvents_ShouldStillClear()
+    {
+        var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
+        var state = new LogTableState();
+        state = Reducers.ReduceAddTable(state, new AddTableAction(logData));
+
+        state = Reducers.ReduceLoadEvents(state, new LoadEventsAction(logData, []));
+
+        Assert.False(state.EventTables.First(t => t.Id == logData.Id).IsLoading);
+    }
+
+    [Fact]
+    public void LogView_IsLoading_WhenRawLoadCompletes_ShouldClearWithoutDisplayFinalize()
+    {
+        var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
+        var state = new LogTableState();
+        state = Reducers.ReduceAddTable(state, new AddTableAction(logData));
+
+        Assert.True(state.EventTables.First(t => t.Id == logData.Id).IsLoading);
+
+        var events = new List<ResolvedEvent>
+        {
+            new(Constants.LogNameTestLog, LogPathType.Channel) { Id = 10, RecordId = 1 }
+        };
+
+        state = Reducers.ReduceLoadEvents(state, new LoadEventsAction(logData, events));
+
+        Assert.False(state.EventTables.First(t => t.Id == logData.Id).IsLoading);
+    }
+
     [Fact]
     public void LogView_ShouldHaveUniqueId()
     {
-        // Arrange & Act
         var model1 = new LogView(EventLogId.Create());
         var model2 = new LogView(EventLogId.Create());
 
-        // Assert
         Assert.NotEqual(model1.Id, model2.Id);
     }
 
     [Fact]
     public void ReduceAddTable_WhenCombinedExists_ShouldNotCreateAnotherCombined()
     {
-        // Arrange
         var logData1 = new EventLogData(Constants.LogNameLog1, LogPathType.Channel);
         var logData2 = new EventLogData(Constants.LogNameLog2, LogPathType.Channel);
         var state = new LogTableState();
@@ -465,10 +388,8 @@ public void ReduceAddTable_WhenCombinedExists_ShouldNotCreateAnotherCombined()
         var logData3 = new EventLogData(Constants.LogNameLog3, LogPathType.Channel);
         var action = new AddTableAction(logData3);
 
-        // Act
         var newState = Reducers.ReduceAddTable(state, action);
 
-        // Assert
         Assert.Equal(4, newState.EventTables.Count);
         Assert.Single(newState.EventTables, t => t.IsCombined);
     }
@@ -494,30 +415,24 @@ public void ReduceAddTable_WhenFirstLogSetsActive_ResetsCollapse()
     [Fact]
     public void ReduceAddTable_WhenFirstTable_ShouldBeLoading()
     {
-        // Arrange
         var state = new LogTableState();
         var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
         var action = new AddTableAction(logData);
 
-        // Act
         var newState = Reducers.ReduceAddTable(state, action);
 
-        // Assert
         Assert.True(newState.EventTables.First().IsLoading);
     }
 
     [Fact]
     public void ReduceAddTable_WhenFirstTable_ShouldSetAsActive()
     {
-        // Arrange
         var state = new LogTableState();
         var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
         var action = new AddTableAction(logData);
 
-        // Act
         var newState = Reducers.ReduceAddTable(state, action);
 
-        // Assert
         Assert.Single(newState.EventTables);
         Assert.NotNull(newState.ActiveEventLogId);
         Assert.Equal(logData.Id, newState.EventTables.First().Id);
@@ -527,15 +442,12 @@ public void ReduceAddTable_WhenFirstTable_ShouldSetAsActive()
     [Fact]
     public void ReduceAddTable_WhenFirstTable_WithFilePath_ShouldSetFileName()
     {
-        // Arrange
         var state = new LogTableState();
         var logData = new EventLogData(Constants.FilePathTestEvtx, LogPathType.File);
         var action = new AddTableAction(logData);
 
-        // Act
         var newState = Reducers.ReduceAddTable(state, action);
 
-        // Assert
         Assert.Equal(Constants.FilePathTestEvtx, newState.EventTables.First().FileName);
         Assert.Equal(LogPathType.File, newState.EventTables.First().LogPathType);
     }
@@ -543,15 +455,12 @@ public void ReduceAddTable_WhenFirstTable_WithFilePath_ShouldSetFileName()
     [Fact]
     public void ReduceAddTable_WhenFirstTable_WithLogName_ShouldNotSetFileName()
     {
-        // Arrange
         var state = new LogTableState();
         var logData = new EventLogData(Constants.LogNameApplication, LogPathType.Channel);
         var action = new AddTableAction(logData);
 
-        // Act
         var newState = Reducers.ReduceAddTable(state, action);
 
-        // Assert
         Assert.Null(newState.EventTables.First().FileName);
         Assert.Equal(Constants.LogNameApplication, newState.EventTables.First().LogName);
         Assert.Equal(LogPathType.Channel, newState.EventTables.First().LogPathType);
@@ -582,7 +491,6 @@ public void ReduceAddTable_WhenSecondLogSwitchesToCombined_ResetsCollapse()
     [Fact]
     public void ReduceAddTable_WhenSecondTable_ShouldCreateCombinedTable()
     {
-        // Arrange
         var logData1 = new EventLogData(Constants.LogNameLog1, LogPathType.Channel);
         var state = new LogTableState();
         state = Reducers.ReduceAddTable(state, new AddTableAction(logData1));
@@ -590,10 +498,8 @@ public void ReduceAddTable_WhenSecondTable_ShouldCreateCombinedTable()
         var logData2 = new EventLogData(Constants.LogNameLog2, LogPathType.Channel);
         var action = new AddTableAction(logData2);
 
-        // Act
         var newState = Reducers.ReduceAddTable(state, action);
 
-        // Assert
         Assert.Equal(3, newState.EventTables.Count);
         Assert.Contains(newState.EventTables, t => t.IsCombined);
     }
@@ -601,7 +507,6 @@ public void ReduceAddTable_WhenSecondTable_ShouldCreateCombinedTable()
     [Fact]
     public void ReduceAddTable_WhenSecondTable_ShouldSetCombinedAsActive()
     {
-        // Arrange
         var logData1 = new EventLogData(Constants.LogNameLog1, LogPathType.Channel);
         var state = new LogTableState();
         state = Reducers.ReduceAddTable(state, new AddTableAction(logData1));
@@ -609,663 +514,99 @@ public void ReduceAddTable_WhenSecondTable_ShouldSetCombinedAsActive()
         var logData2 = new EventLogData(Constants.LogNameLog2, LogPathType.Channel);
         var action = new AddTableAction(logData2);
 
-        // Act
         var newState = Reducers.ReduceAddTable(state, action);
 
-        // Assert
         var combinedTable = newState.EventTables.First(t => t.IsCombined);
         Assert.Equal(combinedTable.Id, newState.ActiveEventLogId);
     }
 
     [Fact]
-    public void ReduceAppendTableEvents_ShouldAppendEventsToExistingDisplayedEvents()
+    public void ReduceApplyFilter_PreservesRequestedSort()
     {
-        // Arrange
-        var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
-        var state = new LogTableState();
-        state = Reducers.ReduceAddTable(state, new AddTableAction(logData));
-
-        var initialEvents = new List<ResolvedEvent>
+        var state = new LogTableState
         {
-            FilterEventBuilder.CreateTestEvent(100, recordId: 1),
-            FilterEventBuilder.CreateTestEvent(200, recordId: 2)
+            RequestedOrderBy = ColumnName.Source,
+            RequestedGroupBy = ColumnName.EventId,
+            RequestedIsDescending = false,
+            RequestedIsGroupDescending = true
         };
 
-        state = Reducers.ReduceAppendTableEvents(
+        var result = Reducers.ReduceApplyFilter(
             state,
-            CreateAppendAction(state, logData.Id, initialEvents));
-
-        var deltaEvents = new List<ResolvedEvent>
-        {
-            FilterEventBuilder.CreateTestEvent(300, recordId: 3),
-            FilterEventBuilder.CreateTestEvent(400, recordId: 4)
-        };
-
-        var action = CreateAppendAction(state, logData.Id, deltaEvents);
-
-        // Act
-        var newState = Reducers.ReduceAppendTableEvents(state, action);
+            new ApplyFilterAction(new Filter(null, [])));
 
-        // Assert
-        var updatedTable = newState.EventTables.First(t => t.Id == logData.Id);
-        Assert.Equal(4, newState.DisplayedEvents.Count);
-        Assert.Equal(4, newState.EventCountByLog[updatedTable.Id]);
+        Assert.Equal(ColumnName.Source, result.RequestedOrderBy);
+        Assert.Equal(ColumnName.EventId, result.RequestedGroupBy);
+        Assert.False(result.RequestedIsDescending);
+        Assert.True(result.RequestedIsGroupDescending);
     }
 
     [Fact]
-    public void ReduceAppendTableEvents_ShouldNotChangeIsLoading()
+    public void ReduceCloseAll_ResetsCollapse()
     {
-        // Arrange
-        var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
-        var state = new LogTableState();
-        state = Reducers.ReduceAddTable(state, new AddTableAction(logData));
-
-        // Table should be in loading state after AddTable
-        Assert.True(state.EventTables.First(t => t.Id == logData.Id).IsLoading);
-
-        var action = CreateAppendAction(state, 
-            logData.Id,
-            new List<ResolvedEvent> { FilterEventBuilder.CreateTestEvent(100, recordId: 1) });
+        var table = new LogView(EventLogId.Create()) { LogName = "A" };
+        var state = new LogTableState
+        {
+            EventTables = ImmutableList.Create(table),
+            ActiveEventLogId = table.Id,
+            GroupsCollapsedByDefault = true,
+            GroupCollapseOverrides = ImmutableHashSet.Create("g")
+        };
 
-        // Act
-        var newState = Reducers.ReduceAppendTableEvents(state, action);
+        var result = Reducers.ReduceCloseAll(state);
 
-        // Assert: IsLoading should still be true (partial update doesn't complete loading)
-        var updatedTable = newState.EventTables.First(t => t.Id == logData.Id);
-        Assert.True(updatedTable.IsLoading);
-        Assert.Equal(1, newState.DisplayedEvents.Count);
+        Assert.Null(result.ActiveEventLogId);
+        Assert.False(result.GroupsCollapsedByDefault);
+        Assert.Empty(result.GroupCollapseOverrides);
     }
 
     [Fact]
-    public void ReduceAppendTableEvents_ShouldPreserveSortOrder()
+    public void ReduceCloseLog_WhenActiveChanges_ResetsCollapse()
     {
-        // Arrange
-        var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
-        var state = new LogTableState();
-        state = Reducers.ReduceAddTable(state, new AddTableAction(logData));
-
-        var initialEvents = new List<ResolvedEvent>
-        {
-            FilterEventBuilder.CreateTestEvent(100, recordId: 10),
-            FilterEventBuilder.CreateTestEvent(200, recordId: 20)
-        };
-
-        state = Reducers.ReduceAppendTableEvents(
-            state,
-            CreateAppendAction(state, logData.Id, initialEvents));
-
-        // Append events with record IDs that should sort between and after existing
-        var deltaEvents = new List<ResolvedEvent>
+        var tableA = new LogView(EventLogId.Create()) { LogName = "A" };
+        var tableB = new LogView(EventLogId.Create()) { LogName = "B" };
+        var combined = new LogView(EventLogId.Create()) { GroupId = LogTabGroupId.AllLogs };
+        var state = new LogTableState
         {
-            FilterEventBuilder.CreateTestEvent(300, recordId: 5),
-            FilterEventBuilder.CreateTestEvent(400, recordId: 15)
+            EventTables = ImmutableList.Create(combined, tableA, tableB),
+            ActiveEventLogId = combined.Id,
+            GroupsCollapsedByDefault = true,
+            GroupCollapseOverrides = ImmutableHashSet.Create("g")
         };
 
-        var action = CreateAppendAction(state, logData.Id, deltaEvents);
-
-        // Act
-        var newState = Reducers.ReduceAppendTableEvents(state, action);
-
-        // Assert: sort is by DateAndTime descending; ties on TimeCreated fall through
-        // to the RecordId tiebreaker, which preserves descending RecordId order here.
-        var displayedEvents = newState.DisplayedEvents;
-        Assert.Equal(4, displayedEvents.Count);
+        var result = Reducers.ReduceCloseLog(state, new CloseLogAction(tableB.Id));
 
-        var recordIds = displayedEvents.EnumerateDetail().Select(e => e.RecordId).ToList();
-        Assert.Equal(recordIds.OrderByDescending(x => x).ToList(), recordIds);
+        Assert.Equal(tableA.Id, result.ActiveEventLogId);
+        Assert.False(result.GroupsCollapsedByDefault);
+        Assert.Empty(result.GroupCollapseOverrides);
     }
 
     [Fact]
-    public void ReduceAppendTableEvents_WhenGrouped_MergesIntoExistingAndNewGroups()
+    public void ReduceLoadColumnsCompleted_WhenGroupColumnHidden_AsksToUngroupWithoutMovingTheRowsYet()
     {
-        var baseTime = new DateTime(2024, 1, 1, 12, 0, 0, DateTimeKind.Utc);
-        var table = new LogView(EventLogId.Create()) { LogName = "Application" };
         var state = new LogTableState
         {
-            EventTables = ImmutableList.Create(table),
-            ActiveEventLogId = table.Id,
             GroupBy = ColumnName.Source,
-            IsDescending = false,
-            EventCountByLog = ImmutableDictionary<EventLogId, int>.Empty.Add(table.Id, 0)
+            IsGroupDescending = true,
+            RequestedGroupBy = ColumnName.Source,
+            RequestedIsGroupDescending = true,
+            GroupCollapseOverrides = ImmutableHashSet.Create("g"),
+            OrderBy = ColumnName.EventId,
+            IsDescending = false
         };
 
-        IReadOnlyList<ResolvedEvent> batch1 =
-        [
-            FilterEventBuilder.CreateTestEvent(id: 100, source: "A", timeCreated: baseTime.AddSeconds(1)),
-            FilterEventBuilder.CreateTestEvent(id: 200, source: "B", timeCreated: baseTime.AddSeconds(2))
-        ];
-        state = Reducers.ReduceAppendTableEvents(state, CreateAppendAction(state, table.Id, batch1));
-
-        IReadOnlyList<ResolvedEvent> batch2 =
-        [
-            FilterEventBuilder.CreateTestEvent(id: 300, source: "A", timeCreated: baseTime.AddSeconds(3)),
-            FilterEventBuilder.CreateTestEvent(id: 500, source: "C", timeCreated: baseTime.AddSeconds(5))
-        ];
-        var result = Reducers.ReduceAppendTableEvents(state, CreateAppendAction(state, table.Id, batch2));
-
-        Assert.Equal(new[] { "A", "A", "B", "C" }, result.DisplayedEvents.EnumerateDetail().Select(e => e.Source));
-        Assert.Equal(new[] { 100, 300, 200, 500 }, result.DisplayedEvents.EnumerateDetail().Select(e => e.Id));
-    }
-
-    [Fact]
-    public void ReduceAppendTableEvents_WhenTableNotFound_ShouldReturnUnchangedState()
-    {
-        // Arrange
-        var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
-        var state = new LogTableState();
-        state = Reducers.ReduceAddTable(state, new AddTableAction(logData));
-
-        var unknownLogId = EventLogId.Create();
-
-        var action = CreateAppendAction(state, 
-            unknownLogId,
-            new List<ResolvedEvent> { FilterEventBuilder.CreateTestEvent(100) });
-
-        // Act
-        var newState = Reducers.ReduceAppendTableEvents(state, action);
-
-        // Assert
-        Assert.Same(state, newState);
-    }
-
-    [Fact]
-    public void ReduceAppendTableEventsBatch_WhenBatchTargetsClosedLog_ShouldSkipThatBatch()
-    {
-        // Arrange: open log plus a stale log id whose tab no longer exists (race: closed mid-flight)
-        var openLog = new EventLogData(Constants.LogNameLog1, LogPathType.Channel);
-        var state = new LogTableState();
-        state = Reducers.ReduceAddTable(state, new AddTableAction(openLog));
-
-        var staleLogId = EventLogId.Create();
-        var batches = new Dictionary<EventLogId, IReadOnlyList<ResolvedEvent>>
-        {
-            { openLog.Id, [new ResolvedEvent(Constants.LogNameLog1, LogPathType.Channel) { Id = 10, RecordId = 1 }] },
-            { staleLogId, [new ResolvedEvent("ClosedLog", LogPathType.Channel) { Id = 99, RecordId = 99 }] }
-        };
-
-        // Act
-        var newState = Reducers.ReduceAppendTableEventsBatch(
-            state,
-            CreateAppendBatchAction(state, batches));
-
-        // Assert: stale batch is skipped; canonical and EventCountByLog only reflect the open log
-        Assert.Equal(1, newState.DisplayedEvents.Count);
-        var displayedRows = newState.DisplayedEvents.Slice(0, newState.DisplayedEvents.Count);
-        Assert.Equal(1L, displayedRows[0].Lean.RecordId);
-        Assert.False(newState.EventCountByLog.ContainsKey(staleLogId));
-        Assert.Equal(1, newState.EventCountByLog[openLog.Id]);
-    }
-
-    [Fact]
-    public void ReduceAppendTableEventsBatch_WhenGrouped_MergesIntoExistingGroups()
-    {
-        var baseTime = new DateTime(2024, 1, 1, 12, 0, 0, DateTimeKind.Utc);
-        var table = new LogView(EventLogId.Create()) { LogName = "Application" };
-        var state = new LogTableState
-        {
-            EventTables = ImmutableList.Create(table),
-            ActiveEventLogId = table.Id,
-            GroupBy = ColumnName.Source,
-            IsDescending = false,
-            EventCountByLog = ImmutableDictionary<EventLogId, int>.Empty.Add(table.Id, 0)
-        };
-
-        state = Reducers.ReduceAppendTableEvents(
-            state,
-            CreateAppendAction(state, table.Id,
-            [
-                FilterEventBuilder.CreateTestEvent(id: 100, source: "A", timeCreated: baseTime.AddSeconds(1)),
-                FilterEventBuilder.CreateTestEvent(id: 200, source: "B", timeCreated: baseTime.AddSeconds(2))
-            ]));
-
-        var byLog = new Dictionary<EventLogId, IReadOnlyList<ResolvedEvent>>
-        {
-            [table.Id] =
-            [
-                FilterEventBuilder.CreateTestEvent(id: 300, source: "A", timeCreated: baseTime.AddSeconds(3)),
-                FilterEventBuilder.CreateTestEvent(id: 500, source: "C", timeCreated: baseTime.AddSeconds(5))
-            ]
-        };
-
-        var result = Reducers.ReduceAppendTableEventsBatch(state, CreateAppendBatchAction(state, byLog));
-
-        Assert.Equal(new[] { "A", "A", "B", "C" }, result.DisplayedEvents.EnumerateDetail().Select(e => e.Source));
-        Assert.Equal(new[] { 100, 300, 200, 500 }, result.DisplayedEvents.EnumerateDetail().Select(e => e.Id));
-    }
-
-    [Fact]
-    public void ReduceApplyFilter_BumpsVersionAndPreservesRequestedSort()
-    {
-        var state = new LogTableState
-        {
-            RequestedOrderBy = ColumnName.Source,
-            RequestedGroupBy = ColumnName.EventId,
-            RequestedIsDescending = false,
-            RequestedIsGroupDescending = true,
-            DisplayListVersion = 3
-        };
-
-        var result = Reducers.ReduceApplyFilter(
-            state,
-            new ApplyFilterAction(new Filter(null, [])));
-
-        Assert.Equal(4, result.DisplayListVersion);
-        Assert.Equal(ColumnName.Source, result.RequestedOrderBy);
-        Assert.Equal(ColumnName.EventId, result.RequestedGroupBy);
-        Assert.False(result.RequestedIsDescending);
-        Assert.True(result.RequestedIsGroupDescending);
-    }
-
-    [Fact]
-    public void ReduceCloseAll_ResetsCollapse()
-    {
-        var table = new LogView(EventLogId.Create()) { LogName = "A" };
-        var state = new LogTableState
-        {
-            EventTables = ImmutableList.Create(table),
-            ActiveEventLogId = table.Id,
-            GroupsCollapsedByDefault = true,
-            GroupCollapseOverrides = ImmutableHashSet.Create("g")
-        };
-
-        var result = Reducers.ReduceCloseAll(state);
-
-        Assert.Null(result.ActiveEventLogId);
-        Assert.False(result.GroupsCollapsedByDefault);
-        Assert.Empty(result.GroupCollapseOverrides);
-    }
-
-    [Fact]
-    public void ReduceCloseLog_WhenActiveChanges_ResetsCollapse()
-    {
-        var tableA = new LogView(EventLogId.Create()) { LogName = "A" };
-        var tableB = new LogView(EventLogId.Create()) { LogName = "B" };
-        var combined = new LogView(EventLogId.Create()) { GroupId = LogTabGroupId.AllLogs };
-        var state = new LogTableState
-        {
-            EventTables = ImmutableList.Create(combined, tableA, tableB),
-            ActiveEventLogId = combined.Id,
-            EventCountByLog = ImmutableDictionary<EventLogId, int>.Empty
-                .Add(tableA.Id, 0)
-                .Add(tableB.Id, 0),
-            GroupsCollapsedByDefault = true,
-            GroupCollapseOverrides = ImmutableHashSet.Create("g")
-        };
-
-        var result = Reducers.ReduceCloseLog(state, new CloseLogAction(tableB.Id));
-
-        Assert.Equal(tableA.Id, result.ActiveEventLogId);
-        Assert.False(result.GroupsCollapsedByDefault);
-        Assert.Empty(result.GroupCollapseOverrides);
-    }
-
-    [Fact]
-    public void ReduceDisplayReady_WhenFilterSupersedesSort_DropsSortRebuildAndAppliesLatest()
-    {
-        var seeded = SeedTabled(new List<ResolvedEvent>
-        {
-            FilterEventBuilder.CreateTestEvent(id: 1, source: "A"),
-            FilterEventBuilder.CreateTestEvent(id: 2, source: "B")
-        });
-
-        var afterSort = Reducers.ReduceSetOrderBy(seeded, new SetOrderByAction(ColumnName.Source));
-        var afterFilter = Reducers.ReduceApplyFilter(
-            afterSort,
-            new ApplyFilterAction(new Filter(null, [])));
-
-        var lists = new Dictionary<EventLogId, EventColumnView>(afterFilter.PerLogEvents.Count);
-
-        foreach (var (logId, list) in afterFilter.PerLogEvents)
-        {
-            lists[logId] = DisplayViewTestFactory.Build(logId, [.. list.EnumerateDetail()], afterFilter.SortContext);
-        }
-
-        var droppedSortRebuild = Reducers.ReduceDisplayReady(
-            afterFilter,
-            new DisplayReadyAction { Views = lists, Version = afterSort.DisplayListVersion });
-
-        Assert.Same(afterFilter, droppedSortRebuild);
-        Assert.Null(droppedSortRebuild.OrderBy);
-
-        var appliedFilterRebuild = Reducers.ReduceDisplayReady(
-            afterFilter,
-            new DisplayReadyAction { Views = lists, Version = afterFilter.DisplayListVersion });
-
-        Assert.Equal(ColumnName.Source, appliedFilterRebuild.OrderBy);
-        Assert.Equal(ColumnName.Source, appliedFilterRebuild.RequestedOrderBy);
-    }
-
-    [Fact]
-    public void ReduceDisplayReady_WhenLogIsNotInLists_ShouldPreserveExistingCanonicalRows()
-    {
-        // Arrange: log A has rows in canonical (live-load via UpdateTable); a filter dispatch
-        // then arrives with empty Views (e.g. log opened mid-filter so the snapshot did
-        // not include it). The omitted log's rows must stay in canonical; otherwise a fresh
-        // load could be silently scrubbed by a stale filter result.
-        var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
-        var state = new LogTableState();
-        state = Reducers.ReduceAddTable(state, new AddTableAction(logData));
-
-        var loadedEvents = new List<ResolvedEvent>
-        {
-            new(Constants.LogNameTestLog, LogPathType.Channel) { Id = 10, RecordId = 1 },
-            new(Constants.LogNameTestLog, LogPathType.Channel) { Id = 11, RecordId = 2 }
-        };
-
-        state = Reducers.ReduceUpdateTable(state, CreateUpdateAction(state, logData.Id, loadedEvents));
-
-        var emptyLists = new Dictionary<EventLogId, EventColumnView>();
-        var action = new DisplayReadyAction { Views = emptyLists };
-
-        // Act
-        var newState = Reducers.ReduceDisplayReady(state, action);
-
-        // Assert: table still exists, canonical rows preserved, count map preserved.
-        Assert.Single(newState.EventTables);
-        Assert.Equal(2, newState.DisplayedEvents.Count);
-        Assert.Equal(2, newState.EventCountByLog[logData.Id]);
-    }
-
-    [Fact]
-    public void ReduceDisplayReady_WhenPrebuiltContextMatchesLiveContext_ShouldSwapReferenceWithoutResorting()
-    {
-        var logData = new EventLogData(Constants.LogNameLog1, LogPathType.Channel);
-        var state = new LogTableState();
-        state = Reducers.ReduceAddTable(state, new AddTableAction(logData));
-
-        var events = new List<ResolvedEvent>
-        {
-            new(Constants.LogNameLog1, LogPathType.Channel) { Id = 10, RecordId = 1 },
-            new(Constants.LogNameLog1, LogPathType.Channel) { Id = 20, RecordId = 2 },
-            new(Constants.LogNameLog1, LogPathType.Channel) { Id = 30, RecordId = 3 }
-        };
-
-        var prebuilt = DisplayViewTestFactory.Build(logData.Id, events, new SortContext(null, true, null, false));
-
-        var lists = new Dictionary<EventLogId, EventColumnView> { { logData.Id, prebuilt } };
-
-        var after = Reducers.ReduceDisplayReady(state, new DisplayReadyAction { Views = lists });
-
-        Assert.Same(prebuilt, after.PerLogEvents[logData.Id]);
-        Assert.Equal(new[] { 30, 20, 10 }, after.DisplayedEvents.EnumerateDetail().Select(e => e.Id).ToArray());
-    }
-
-    [Fact]
-    public void ReduceDisplayReady_WhenPrebuiltContextStale_ShouldHealToLiveContext()
-    {
-        var logData = new EventLogData(Constants.LogNameLog1, LogPathType.Channel);
-        var state = new LogTableState
-        {
-            OrderBy = ColumnName.DateAndTime,
-            IsDescending = true,
-            RequestedOrderBy = ColumnName.DateAndTime,
-            RequestedIsDescending = true
-        };
-        state = Reducers.ReduceAddTable(state, new AddTableAction(logData));
-
-        var baseTime = new DateTime(2024, 1, 1, 0, 0, 0, DateTimeKind.Utc);
-
-        var events = new List<ResolvedEvent>
-        {
-            new(Constants.LogNameLog1, LogPathType.Channel) { Id = 10, RecordId = 1, TimeCreated = baseTime.AddMinutes(1) },
-            new(Constants.LogNameLog1, LogPathType.Channel) { Id = 20, RecordId = 2, TimeCreated = baseTime.AddMinutes(2) },
-            new(Constants.LogNameLog1, LogPathType.Channel) { Id = 30, RecordId = 3, TimeCreated = baseTime.AddMinutes(3) }
-        };
-
-        var prebuilt = DisplayViewTestFactory.Build(
-            logData.Id,
-            events,
-            new SortContext(ColumnName.DateAndTime, false, null, false));
-
-        var lists = new Dictionary<EventLogId, EventColumnView> { { logData.Id, prebuilt } };
-
-        var after = Reducers.ReduceDisplayReady(state, new DisplayReadyAction { Views = lists });
-
-        Assert.NotSame(prebuilt, after.PerLogEvents[logData.Id]);
-        Assert.Equal(3, after.PerLogEvents[logData.Id].Count);
-        Assert.Equal(new[] { 30, 20, 10 }, after.DisplayedEvents.EnumerateDetail().Select(e => e.Id).ToArray());
-    }
-
-    [Fact]
-    public void ReduceDisplayReady_WhenRequestedDiffersFromLive_ShouldSwapReferenceAndFlipLiveAtomically()
-    {
-        var baseTime = new DateTime(2024, 1, 1, 0, 0, 0, DateTimeKind.Utc);
-        var events = new List<ResolvedEvent>
-        {
-            FilterEventBuilder.CreateTestEvent(id: 1, source: "B", timeCreated: baseTime.AddMinutes(2)),
-            FilterEventBuilder.CreateTestEvent(id: 2, source: "A", timeCreated: baseTime.AddMinutes(1))
-        };
-
-        var seeded = SeedTabled(events, orderBy: ColumnName.DateAndTime, isDescending: true);
-        var requested = seeded with
-        {
-            RequestedOrderBy = ColumnName.Source,
-            RequestedIsDescending = false,
-            DisplayListVersion = seeded.DisplayListVersion + 1
-        };
-
-        var logId = requested.PerLogEvents.Keys.Single();
-        var prebuilt = DisplayViewTestFactory.Build(logId, events, requested.SortContext);
-        var lists = new Dictionary<EventLogId, EventColumnView> { { logId, prebuilt } };
-
-        var after = Reducers.ReduceDisplayReady(
-            requested,
-            new DisplayReadyAction { Views = lists, Version = requested.DisplayListVersion });
-
-        Assert.Same(prebuilt, after.PerLogEvents[logId]);
-        Assert.Equal(ColumnName.Source, after.OrderBy);
-        Assert.False(after.IsDescending);
-        Assert.Equal(new[] { "A", "B" }, after.DisplayedEvents.EnumerateDetail().Select(e => e.Source));
-    }
-
-    [Fact]
-    public void ReduceDisplayReady_WhenRequestedGroupByDiffers_ShouldResetCollapseState()
-    {
-        var events = new List<ResolvedEvent>
-        {
-            FilterEventBuilder.CreateTestEvent(id: 1, source: "A"),
-            FilterEventBuilder.CreateTestEvent(id: 2, source: "B")
-        };
-
-        var seeded = SeedTabled(events, collapseOverrides: ImmutableHashSet.Create("stale"));
-        var requested = seeded with
-        {
-            RequestedGroupBy = ColumnName.Source,
-            DisplayListVersion = seeded.DisplayListVersion + 1,
-            GroupsCollapsedByDefault = true
-        };
-
-        var logId = requested.PerLogEvents.Keys.Single();
-        var prebuilt = DisplayViewTestFactory.Build(logId, events, requested.SortContext);
-        var lists = new Dictionary<EventLogId, EventColumnView> { { logId, prebuilt } };
-
-        var after = Reducers.ReduceDisplayReady(
-            requested,
-            new DisplayReadyAction { Views = lists, Version = requested.DisplayListVersion });
-
-        Assert.Equal(ColumnName.Source, after.GroupBy);
-        Assert.False(after.GroupsCollapsedByDefault);
-        Assert.Empty(after.GroupCollapseOverrides);
-    }
-
-    [Fact]
-    public void ReduceDisplayReady_WhenSecondLogOpensAcrossTheGap_HealsOneLogListToTwoLogDefault()
-    {
-        var first = new EventLogData(Constants.LogNameLog1, LogPathType.Channel);
-        var second = new EventLogData(Constants.LogNameLog2, LogPathType.Channel);
-        var state = new LogTableState();
-        state = Reducers.ReduceAddTable(state, new AddTableAction(first));
-        state = Reducers.ReduceAddTable(state, new AddTableAction(second));
-
-        state = Reducers.ReduceUpdateTable(
-            state,
-            CreateUpdateAction(state, second.Id, new List<ResolvedEvent>
-            {
-                new(Constants.LogNameLog2, LogPathType.Channel) { Id = 200, RecordId = 20 }
-            }));
-
-        var baseTime = new DateTime(2024, 1, 1, 0, 0, 0, DateTimeKind.Utc);
-        var firstEvents = new List<ResolvedEvent>
-        {
-            new(Constants.LogNameLog1, LogPathType.Channel) { Id = 10, RecordId = 1, TimeCreated = baseTime.AddMinutes(3) },
-            new(Constants.LogNameLog1, LogPathType.Channel) { Id = 20, RecordId = 2, TimeCreated = baseTime.AddMinutes(2) },
-            new(Constants.LogNameLog1, LogPathType.Channel) { Id = 30, RecordId = 3, TimeCreated = baseTime.AddMinutes(1) }
-        };
-
-        var prebuiltOneLog = DisplayViewTestFactory.Build(first.Id, firstEvents, new SortContext(null, true, null, false));
-        Assert.Equal(new[] { 30, 20, 10 }, prebuiltOneLog.EnumerateDetail().Select(e => e.Id).ToArray());
-
-        var lists = new Dictionary<EventLogId, EventColumnView> { { first.Id, prebuiltOneLog } };
-
-        var after = Reducers.ReduceDisplayReady(
-            state, new DisplayReadyAction { Views = lists, Version = state.DisplayListVersion });
-
-        var healed = after.PerLogEvents[first.Id];
-        Assert.NotSame(prebuiltOneLog, healed);
-        Assert.True(healed.HasContext(new SortContext(ColumnName.DateAndTime, true, null, false)));
-        Assert.Equal(new[] { 10, 20, 30 }, healed.EnumerateDetail().Select(e => e.Id).ToArray());
-    }
-
-    [Fact]
-    public void ReduceDisplayReady_WhenSomeLogsOmitted_ShouldReplaceIncludedAndPreserveOmitted()
-    {
-        // Arrange: two logs, both populated via UpdateTable. Filter dispatch arrives for log A
-        // only (e.g. log B opened or finished loading after the snapshot). Log A's rows must be
-        // replaced by the filter result; log B's rows must be preserved untouched.
-        var logData1 = new EventLogData(Constants.LogNameLog1, LogPathType.Channel);
-        var logData2 = new EventLogData(Constants.LogNameLog2, LogPathType.Channel);
-        var state = new LogTableState();
-        state = Reducers.ReduceAddTable(state, new AddTableAction(logData1));
-        state = Reducers.ReduceAddTable(state, new AddTableAction(logData2));
-
-        var log1Loaded = new List<ResolvedEvent>
-        {
-            new(Constants.LogNameLog1, LogPathType.Channel) { Id = 100, RecordId = 1 },
-            new(Constants.LogNameLog1, LogPathType.Channel) { Id = 101, RecordId = 2 }
-        };
-
-        var log2Loaded = new List<ResolvedEvent>
-        {
-            new(Constants.LogNameLog2, LogPathType.Channel) { Id = 200, RecordId = 1 },
-            new(Constants.LogNameLog2, LogPathType.Channel) { Id = 201, RecordId = 2 },
-            new(Constants.LogNameLog2, LogPathType.Channel) { Id = 202, RecordId = 3 }
-        };
-
-        state = Reducers.ReduceUpdateTable(state, CreateUpdateAction(state, logData1.Id, log1Loaded));
-        state = Reducers.ReduceUpdateTable(state, CreateUpdateAction(state, logData2.Id, log2Loaded));
-
-        var log1Filtered = new List<ResolvedEvent>
-        {
-            new(Constants.LogNameLog1, LogPathType.Channel) { Id = 100, RecordId = 1 }
-        };
-
-        var lists = new Dictionary<EventLogId, EventColumnView>
-        {
-            { logData1.Id, DisplayViewTestFactory.Build(logData1.Id, log1Filtered, state.SortContext) }
-        };
-
-        // Act
-        var newState = Reducers.ReduceDisplayReady(state, new DisplayReadyAction { Views = lists });
-
-        // Assert: log A reduced from 2 to 1, log B's 3 rows untouched; counts reflect both.
-        Assert.Equal(4, newState.DisplayedEvents.Count);
-        Assert.Equal(1, newState.DisplayedEvents.EnumerateDetail().Count(e => e.OwningLog == Constants.LogNameLog1));
-        Assert.Equal(3, newState.DisplayedEvents.EnumerateDetail().Count(e => e.OwningLog == Constants.LogNameLog2));
-        Assert.Equal(1, newState.EventCountByLog[logData1.Id]);
-        Assert.Equal(3, newState.EventCountByLog[logData2.Id]);
-    }
-
-    [Fact]
-    public void ReduceDisplayReady_WhenTableComputerNameEmpty_ShouldLatchFromFirstNonEmptyEvent()
-    {
-        // Arrange: log first becomes visible via DisplayReady (filter clear), not via append
-        var logData = new EventLogData(Constants.LogNameLog1, LogPathType.Channel);
-        var state = new LogTableState();
-        state = Reducers.ReduceAddTable(state, new AddTableAction(logData));
-
-        var revealedEvents = new List<ResolvedEvent>
-        {
-            new(Constants.LogNameLog1, LogPathType.Channel) { Id = 10, RecordId = 1, ComputerName = string.Empty },
-            new(Constants.LogNameLog1, LogPathType.Channel) { Id = 11, RecordId = 2, ComputerName = FilterTestConstants.EventComputerServer01 }
-        };
-
-        var lists = new Dictionary<EventLogId, EventColumnView>
-        {
-            { logData.Id, DisplayViewTestFactory.Build(logData.Id, revealedEvents, state.SortContext) }
-        };
-
-        // Act
-        var newState = Reducers.ReduceDisplayReady(state, new DisplayReadyAction { Views = lists });
-
-        // Assert: DisplayReady also latches ComputerName, not just the append paths
-        var updatedTable = newState.EventTables.First(t => t.Id == logData.Id);
-        Assert.Equal(FilterTestConstants.EventComputerServer01, updatedTable.ComputerName);
-    }
-
-    [Fact]
-    public void ReduceDisplayReady_WhenVersionStale_ShouldDropAndWhenMatching_ShouldApply()
-    {
-        var requested = Reducers.ReduceSetOrderBy(
-            SeedTabled(new List<ResolvedEvent>
-            {
-                FilterEventBuilder.CreateTestEvent(id: 1, source: "A"),
-                FilterEventBuilder.CreateTestEvent(id: 2, source: "B")
-            }),
-            new SetOrderByAction(ColumnName.Source));
-
-        var lists = new Dictionary<EventLogId, EventColumnView>(requested.PerLogEvents.Count);
-
-        foreach (var (logId, list) in requested.PerLogEvents)
-        {
-            lists[logId] = DisplayViewTestFactory.Build(logId, [.. list.EnumerateDetail()], requested.SortContext);
-        }
-
-        var stale = Reducers.ReduceDisplayReady(
-            requested,
-            new DisplayReadyAction { Views = lists, Version = requested.DisplayListVersion - 1 });
-
-        Assert.Same(requested, stale);
-        Assert.Null(stale.OrderBy);
-
-        var applied = Reducers.ReduceDisplayReady(
-            requested,
-            new DisplayReadyAction { Views = lists, Version = requested.DisplayListVersion });
-
-        Assert.Equal(ColumnName.Source, applied.OrderBy);
-    }
-
-    [Fact]
-    public void ReduceLoadColumnsCompleted_WhenGroupColumnHidden_ClearsGroupAndResortsUngrouped()
-    {
-        var state = new LogTableState
-        {
-            GroupBy = ColumnName.Source,
-            IsGroupDescending = true,
-            GroupCollapseOverrides = ImmutableHashSet.Create("g"),
-            OrderBy = ColumnName.EventId,
-            IsDescending = false,
-            PerLogEvents = BuildPerLog(
-                new List<ResolvedEvent>
-                {
-                    FilterEventBuilder.CreateTestEvent(id: 2, source: "B"),
-                    FilterEventBuilder.CreateTestEvent(id: 1, source: "A")
-                },
-                [],
-                orderBy: ColumnName.EventId, isDescending: false, groupBy: ColumnName.Source, isGroupDescending: true)
-        };
-
-        var hiddenColumns = ImmutableDictionary<ColumnName, bool>.Empty
-            .Add(ColumnName.Source, false)
-            .Add(ColumnName.EventId, true);
+        var hiddenColumns = ImmutableDictionary<ColumnName, bool>.Empty
+            .Add(ColumnName.Source, false)
+            .Add(ColumnName.EventId, true);
 
         var result = Reducers.ReduceLoadColumnsCompleted(
             state,
             new LoadColumnsCompletedAction(hiddenColumns, ImmutableDictionary<ColumnName, int>.Empty, []));
 
-        Assert.Null(result.GroupBy);
-        Assert.False(result.IsGroupDescending);
-        Assert.Empty(result.GroupCollapseOverrides);
-        Assert.Equal(new[] { 1, 2 }, result.DisplayedEvents.EnumerateDetail().Select(e => e.Id));
+        Assert.Null(result.RequestedGroupBy);
+        Assert.False(result.RequestedIsGroupDescending);
+        Assert.Equal(ColumnName.Source, result.GroupBy);
+        Assert.True(result.HasPendingSortChange);
     }
 
     [Fact]
@@ -1285,7 +626,7 @@ public void ReduceLoadColumnsCompleted_WhenGroupColumnStaysVisible_KeepsGroup()
     }
 
     [Fact]
-    public void ReduceLoadColumnsCompleted_WhenLiveAndRequestedGroupBothHidden_ClearsBoth()
+    public void ReduceLoadColumnsCompleted_WhenLiveAndRequestedGroupBothHidden_ClearsTheRequest()
     {
         var state = new LogTableState
         {
@@ -1303,10 +644,9 @@ public void ReduceLoadColumnsCompleted_WhenLiveAndRequestedGroupBothHidden_Clear
             state,
             new LoadColumnsCompletedAction(columns, ImmutableDictionary<ColumnName, int>.Empty, []));
 
-        Assert.Null(result.GroupBy);
-        Assert.False(result.IsGroupDescending);
         Assert.Null(result.RequestedGroupBy);
         Assert.False(result.RequestedIsGroupDescending);
+        Assert.Equal(ColumnName.Source, result.GroupBy);
     }
 
     [Fact]
@@ -1326,8 +666,8 @@ public void ReduceLoadColumnsCompleted_WhenLiveGroupHiddenButRequestedGroupVisib
             state,
             new LoadColumnsCompletedAction(columns, ImmutableDictionary<ColumnName, int>.Empty, []));
 
-        Assert.Null(result.GroupBy);
         Assert.Equal(ColumnName.Level, result.RequestedGroupBy);
+        Assert.Equal(ColumnName.Source, result.GroupBy);
     }
 
     [Fact]
@@ -1354,9 +694,9 @@ public void ReduceLoadColumnsCompleted_WhenRequestedGroupHiddenWhileLiveUngroupe
     }
 
     [Fact]
-    public void ReduceLoadColumnsCompleted_WhenResetDefaultsHidesGroupColumn_ClearsGroup()
+    public void ReduceLoadColumnsCompleted_WhenResetDefaultsHidesGroupColumn_AsksToUngroup()
     {
-        var state = new LogTableState { GroupBy = ColumnName.ActivityId };
+        var state = new LogTableState { GroupBy = ColumnName.ActivityId, RequestedGroupBy = ColumnName.ActivityId };
 
         var defaults = ImmutableDictionary<ColumnName, bool>.Empty
             .Add(ColumnName.Level, true)
@@ -1366,7 +706,8 @@ public void ReduceLoadColumnsCompleted_WhenResetDefaultsHidesGroupColumn_ClearsG
             state,
             new LoadColumnsCompletedAction(defaults, ImmutableDictionary<ColumnName, int>.Empty, []));
 
-        Assert.Null(result.GroupBy);
+        Assert.Null(result.RequestedGroupBy);
+        Assert.Equal(ColumnName.ActivityId, result.GroupBy);
     }
 
     [Fact]
@@ -1428,7 +769,7 @@ public void ReduceSetAllGroupsCollapsed_WhenNotGrouping_NoOps()
     }
 
     [Fact]
-    public void ReduceSetGroupBy_IsLightweight_SetsRequestedWithoutTouchingLiveOrLists()
+    public void ReduceSetGroupBy_IsLightweight_SetsRequestedWithoutCommittingLive()
     {
         var state = SeedTabled(new List<ResolvedEvent>
         {
@@ -1438,15 +779,13 @@ public void ReduceSetGroupBy_IsLightweight_SetsRequestedWithoutTouchingLiveOrLis
 
         var result = Reducers.ReduceSetGroupBy(state, new SetGroupByAction(ColumnName.Source));
 
-        Assert.Same(state.PerLogEvents, result.PerLogEvents);
-        Assert.Equal(state.DisplayListVersion + 1, result.DisplayListVersion);
         Assert.Equal(ColumnName.Source, result.RequestedGroupBy);
         Assert.False(result.RequestedIsGroupDescending);
         Assert.Null(result.GroupBy);
     }
 
     [Fact]
-    public void ReduceSetGroupBy_SetsGroupResortsAndResetsDirectionAndCollapse()
+    public void ReduceSetGroupBy_WhenAdopted_CommitsGroupResetsDirectionAndClearsStaleCollapse()
     {
         var state = SeedTabled(
             new List<ResolvedEvent>
@@ -1462,11 +801,10 @@ public void ReduceSetGroupBy_SetsGroupResortsAndResetsDirectionAndCollapse()
         Assert.Equal(ColumnName.Source, result.GroupBy);
         Assert.False(result.IsGroupDescending);
         Assert.Empty(result.GroupCollapseOverrides);
-        Assert.Equal(new[] { "A", "B" }, result.DisplayedEvents.EnumerateDetail().Select(e => e.Source));
     }
 
     [Fact]
-    public void ReduceSetGroupBy_WhenNull_ClearsGroupingAndResortsUngrouped()
+    public void ReduceSetGroupBy_WhenNullAndAdopted_ClearsCommittedGrouping()
     {
         var state = SeedTabled(
             new List<ResolvedEvent>
@@ -1481,7 +819,6 @@ public void ReduceSetGroupBy_WhenNull_ClearsGroupingAndResortsUngrouped()
         var result = Settle(Reducers.ReduceSetGroupBy(state, new SetGroupByAction(null)));
 
         Assert.Null(result.GroupBy);
-        Assert.Equal(new[] { 1, 2 }, result.DisplayedEvents.EnumerateDetail().Select(e => e.Id));
     }
 
     [Fact]
@@ -1504,42 +841,18 @@ public void ReduceSetGroupBy_WhenSameColumn_PreservesDirectionAndCollapse()
     }
 
     [Fact]
-    public void ReduceSetOrderBy_IsLightweight_SetsRequestedWithoutTouchingLiveOrLists()
+    public void ReduceSetOrderBy_IsLightweight_SetsRequestedWithoutCommittingLive()
     {
         var state = SeedTabled(new List<ResolvedEvent>
         {
-            FilterEventBuilder.CreateTestEvent(id: 1, source: "A"),
-            FilterEventBuilder.CreateTestEvent(id: 2, source: "B")
-        });
-
-        var result = Reducers.ReduceSetOrderBy(state, new SetOrderByAction(ColumnName.Source));
-
-        Assert.Same(state.PerLogEvents, result.PerLogEvents);
-        Assert.Equal(state.DisplayListVersion + 1, result.DisplayListVersion);
-        Assert.Equal(ColumnName.Source, result.RequestedOrderBy);
-        Assert.Null(result.OrderBy);
-    }
-
-    [Fact]
-    public void ReduceSetOrderBy_LeavesPerLogListsConsistentWithLiveDisplayedContext()
-    {
-        var state = SeedTabled(
-            new List<ResolvedEvent>
-            {
-                FilterEventBuilder.CreateTestEvent(id: 1, source: "A"),
-                FilterEventBuilder.CreateTestEvent(id: 2, source: "B")
-            },
-            groupBy: ColumnName.Source);
-
-        var afterSort = Reducers.ReduceSetOrderBy(state, new SetOrderByAction(ColumnName.EventId));
+            FilterEventBuilder.CreateTestEvent(id: 1, source: "A"),
+            FilterEventBuilder.CreateTestEvent(id: 2, source: "B")
+        });
 
-        var displayed = new SortContext(
-            ResolvedEventOrdering.ResolveDefaultOrderBy(afterSort.OrderBy, afterSort.GroupBy, afterSort.PerLogEvents.Count, afterSort.TimelineVisible),
-            afterSort.IsDescending,
-            afterSort.GroupBy,
-            afterSort.IsGroupDescending);
+        var result = Reducers.ReduceSetOrderBy(state, new SetOrderByAction(ColumnName.Source));
 
-        Assert.All(afterSort.PerLogEvents.Values, list => Assert.True(list.HasContext(displayed)));
+        Assert.Equal(ColumnName.Source, result.RequestedOrderBy);
+        Assert.Null(result.OrderBy);
     }
 
     [Fact]
@@ -1567,7 +880,7 @@ public void ReduceToggleGroupCollapsed_WhenNotGrouping_NoOps()
     }
 
     [Fact]
-    public void ReduceToggleGroupSorting_IsLightweight_SetsRequestedWithoutTouchingLiveOrLists()
+    public void ReduceToggleGroupSorting_IsLightweight_SetsRequestedWithoutCommittingLive()
     {
         var state = SeedTabled(
             new List<ResolvedEvent>
@@ -1579,15 +892,13 @@ public void ReduceToggleGroupSorting_IsLightweight_SetsRequestedWithoutTouchingL
 
         var result = Reducers.ReduceToggleGroupSorting(state);
 
-        Assert.Same(state.PerLogEvents, result.PerLogEvents);
-        Assert.Equal(state.DisplayListVersion + 1, result.DisplayListVersion);
         Assert.True(result.RequestedIsGroupDescending);
         Assert.False(result.IsGroupDescending);
         Assert.Equal(ColumnName.Source, result.GroupBy);
     }
 
     [Fact]
-    public void ReduceToggleGroupSorting_WhenGrouped_FlipsDirectionAndResorts()
+    public void ReduceToggleGroupSorting_WhenGroupedAndAdopted_FlipsCommittedDirection()
     {
         var state = SeedTabled(
             new List<ResolvedEvent>
@@ -1600,7 +911,6 @@ public void ReduceToggleGroupSorting_WhenGrouped_FlipsDirectionAndResorts()
         var result = Settle(Reducers.ReduceToggleGroupSorting(state));
 
         Assert.True(result.IsGroupDescending);
-        Assert.Equal(new[] { "B", "A" }, result.DisplayedEvents.EnumerateDetail().Select(e => e.Source));
     }
 
     [Fact]
@@ -1632,11 +942,10 @@ public void ReduceToggleSorting_ComposesOffRequestedWithoutTouchingLive()
 
         Assert.False(afterSecond.RequestedIsDescending);
         Assert.True(afterSecond.IsDescending);
-        Assert.Equal(state.DisplayListVersion + 2, afterSecond.DisplayListVersion);
     }
 
     [Fact]
-    public void ReduceToggleSorting_IsLightweight_SetsRequestedWithoutTouchingLiveOrLists()
+    public void ReduceToggleSorting_IsLightweight_SetsRequestedWithoutCommittingLive()
     {
         var state = SeedTabled(new List<ResolvedEvent>
         {
@@ -1646,565 +955,27 @@ public void ReduceToggleSorting_IsLightweight_SetsRequestedWithoutTouchingLiveOr
 
         var result = Reducers.ReduceToggleSorting(state);
 
-        Assert.Same(state.PerLogEvents, result.PerLogEvents);
-        Assert.Equal(state.DisplayListVersion + 1, result.DisplayListVersion);
         Assert.False(result.RequestedIsDescending);
         Assert.True(result.IsDescending);
     }
 
-    [Fact]
-    public void ReduceUpdateTable_AfterPartialAppends_ShouldReplaceNotMergeWithPartials()
-    {
-        // Arrange: partial AppendTableEvents land first (live-load deltas), then UpdateTable arrives with the full filtered list
-        var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
-        var state = new LogTableState { IsDescending = false };
-        state = Reducers.ReduceAddTable(state, new AddTableAction(logData));
-
-        var partial1 = new List<ResolvedEvent>
-        {
-            new(Constants.LogNameTestLog, LogPathType.Channel) { Id = 10, RecordId = 1 },
-            new(Constants.LogNameTestLog, LogPathType.Channel) { Id = 11, RecordId = 2 }
-        };
-
-        state = Reducers.ReduceAppendTableEvents(
-            state,
-            CreateAppendAction(state, logData.Id, partial1));
-
-        var partial2 = new List<ResolvedEvent>
-        {
-            new(Constants.LogNameTestLog, LogPathType.Channel) { Id = 12, RecordId = 3 }
-        };
-
-        state = Reducers.ReduceAppendTableEvents(
-            state,
-            CreateAppendAction(state, logData.Id, partial2));
-
-        Assert.Equal(3, state.DisplayedEvents.Count);
-
-        var fullLoad = new List<ResolvedEvent>
-        {
-            new(Constants.LogNameTestLog, LogPathType.Channel) { Id = 20, RecordId = 1 },
-            new(Constants.LogNameTestLog, LogPathType.Channel) { Id = 21, RecordId = 2 },
-            new(Constants.LogNameTestLog, LogPathType.Channel) { Id = 22, RecordId = 3 },
-            new(Constants.LogNameTestLog, LogPathType.Channel) { Id = 23, RecordId = 4 }
-        };
-
-        // Act
-        state = Reducers.ReduceUpdateTable(
-            state,
-            CreateUpdateAction(state, logData.Id, fullLoad));
-
-        // Assert: partials are dropped before merging the full slice; canonical is exactly the full load
-        Assert.Equal(4, state.DisplayedEvents.Count);
-        Assert.Equal(state.DisplayedEvents.EnumerateDetail().Select(e => e.RecordId), [1L, 2L, 3L, 4L]);
-        Assert.Equal(4, state.EventCountByLog[logData.Id]);
-    }
-
-    [Fact]
-    public void ReduceUpdateTable_ShouldUpdateTableEvents()
-    {
-        // Arrange
-        var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
-        var state = new LogTableState();
-        state = Reducers.ReduceAddTable(state, new AddTableAction(logData));
-
-        var events = new List<ResolvedEvent>
-        {
-            FilterEventBuilder.CreateTestEvent(100),
-            FilterEventBuilder.CreateTestEvent(200)
-        };
-
-        var action = CreateUpdateAction(state, logData.Id, events);
-
-        // Act
-        var newState = Reducers.ReduceUpdateTable(state, action);
-
-        // Assert
-        var updatedTable = newState.EventTables.First(t => t.Id == logData.Id);
-        Assert.Equal(2, newState.DisplayedEvents.Count);
-        Assert.Equal(2, newState.EventCountByLog[updatedTable.Id]);
-        Assert.False(updatedTable.IsLoading);
-    }
-
-    [Fact]
-    public void ReduceUpdateTable_WhenCalledTwiceForSameLog_ShouldReplaceNotDuplicate()
-    {
-        // Arrange: first UpdateTable populates canonical with two events
-        var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
-        var state = new LogTableState { IsDescending = false };
-        state = Reducers.ReduceAddTable(state, new AddTableAction(logData));
-
-        var firstLoad = new List<ResolvedEvent>
-        {
-            new(Constants.LogNameTestLog, LogPathType.Channel) { Id = 10, RecordId = 1 },
-            new(Constants.LogNameTestLog, LogPathType.Channel) { Id = 11, RecordId = 2 }
-        };
-
-        state = Reducers.ReduceUpdateTable(state, CreateUpdateAction(state, logData.Id, firstLoad));
-        Assert.Equal(2, state.DisplayedEvents.Count);
-
-        var secondLoad = new List<ResolvedEvent>
-        {
-            new(Constants.LogNameTestLog, LogPathType.Channel) { Id = 12, RecordId = 3 },
-            new(Constants.LogNameTestLog, LogPathType.Channel) { Id = 13, RecordId = 4 },
-            new(Constants.LogNameTestLog, LogPathType.Channel) { Id = 14, RecordId = 5 }
-        };
-
-        // Act: second UpdateTable for the same log (e.g., filter-driven reload)
-        state = Reducers.ReduceUpdateTable(state, CreateUpdateAction(state, logData.Id, secondLoad));
-
-        // Assert: canonical reflects only the second load; first load is replaced, not appended
-        Assert.Equal(3, state.DisplayedEvents.Count);
-        Assert.Equal(state.DisplayedEvents.EnumerateDetail().Select(e => e.RecordId), [3L, 4L, 5L]);
-        Assert.Equal(3, state.EventCountByLog[logData.Id]);
-    }
-
-    [Fact]
-    public void ReduceUpdateTable_WhenDescendingOrderRequested_ShouldMergeInDescendingOrder()
-    {
-        // Arrange: two logs, descending sort
-        var logData1 = new EventLogData(Constants.LogNameLog1, LogPathType.Channel);
-        var logData2 = new EventLogData(Constants.LogNameLog2, LogPathType.Channel);
-        var state = new LogTableState { IsDescending = true };
-        state = Reducers.ReduceAddTable(state, new AddTableAction(logData1));
-        state = Reducers.ReduceAddTable(state, new AddTableAction(logData2));
-
-        var eventsLog1 = new List<ResolvedEvent>
-        {
-            new(Constants.LogNameLog1, LogPathType.Channel) { Id = 10, RecordId = 1 },
-            new(Constants.LogNameLog1, LogPathType.Channel) { Id = 11, RecordId = 3 }
-        };
-
-        var eventsLog2 = new List<ResolvedEvent>
-        {
-            new(Constants.LogNameLog2, LogPathType.Channel) { Id = 20, RecordId = 2 },
-            new(Constants.LogNameLog2, LogPathType.Channel) { Id = 21, RecordId = 4 }
-        };
-
-        // Act
-        state = Reducers.ReduceUpdateTable(state, CreateUpdateAction(state, logData1.Id, eventsLog1));
-        state = Reducers.ReduceUpdateTable(state, CreateUpdateAction(state, logData2.Id, eventsLog2));
-
-        // Assert: canonical view in descending RecordId order
-        Assert.Equal(4, state.DisplayedEvents.Count);
-        var rows = state.DisplayedEvents.Slice(0, state.DisplayedEvents.Count);
-        Assert.Equal(4L, rows[0].Lean.RecordId);
-        Assert.Equal(3L, rows[1].Lean.RecordId);
-        Assert.Equal(2L, rows[2].Lean.RecordId);
-        Assert.Equal(1L, rows[3].Lean.RecordId);
-    }
-
-    [Fact]
-    public void ReduceUpdateTable_WhenGrouped_ReplacesLogSliceAndRetainsOtherLogGrouped()
-    {
-        var baseTime = new DateTime(2024, 1, 1, 12, 0, 0, DateTimeKind.Utc);
-        var log1 = new LogView(EventLogId.Create()) { LogName = "Log1" };
-        var log2 = new LogView(EventLogId.Create()) { LogName = "Log2" };
-        var combined = new LogView(EventLogId.Create()) { GroupId = LogTabGroupId.AllLogs };
-
-        var existing = AosReferenceOrdering.OrderedEvents(
-            new List<ResolvedEvent>
-            {
-                FilterEventBuilder.CreateTestEvent(id: 1, source: "A", timeCreated: baseTime.AddSeconds(1), owningLog: "Log1"),
-                FilterEventBuilder.CreateTestEvent(id: 2, source: "A", timeCreated: baseTime.AddSeconds(2), owningLog: "Log2")
-            },
-            orderBy: null,
-            isDescending: false,
-            groupBy: ColumnName.Source);
-
-        var state = new LogTableState
-        {
-            EventTables = ImmutableList.Create(combined, log1, log2),
-            ActiveEventLogId = combined.Id,
-            GroupBy = ColumnName.Source,
-            IsDescending = false,
-            PerLogEvents = BuildPerLog(
-                existing, [log1, log2], orderBy: null, isDescending: false, groupBy: ColumnName.Source),
-            EventCountByLog = ImmutableDictionary<EventLogId, int>.Empty
-                .Add(log1.Id, 1)
-                .Add(log2.Id, 1)
-        };
-
-        IReadOnlyList<ResolvedEvent> log1Replacement =
-        [
-            FilterEventBuilder.CreateTestEvent(id: 3, source: "A", timeCreated: baseTime.AddSeconds(3), owningLog: "Log1")
-        ];
-
-        var result = Reducers.ReduceUpdateTable(state, CreateUpdateAction(state, log1.Id, log1Replacement));
-
-        Assert.Equal(new[] { 2, 3 }, result.DisplayedEvents.EnumerateDetail().Select(e => e.Id).OrderBy(id => id));
-        Assert.DoesNotContain(result.DisplayedEvents.EnumerateDetail(), e => e.Id == 1);
-        Assert.Equal(new[] { "A", "A" }, result.DisplayedEvents.EnumerateDetail().Select(e => e.Source));
-    }
-
-    [Fact]
-    public void ReduceUpdateTable_WhenListVersionSetByDisplayReady_InstallsViewWithoutResortBump()
-    {
-        var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
-        var state = Reducers.ReduceAddTable(new LogTableState(), new AddTableAction(logData));
-        state = state with { DisplayListVersion = 5 };
-
-        var events = new List<ResolvedEvent>
-        {
-            new(Constants.LogNameTestLog, LogPathType.Channel) { Id = 10, RecordId = 1 },
-            new(Constants.LogNameTestLog, LogPathType.Channel) { Id = 11, RecordId = 2 }
-        };
-        var fresh = DisplayViewTestFactory.Build(logData.Id, events, state.SortContext);
-
-        state = Reducers.ReduceDisplayReady(
-            state,
-            new DisplayReadyAction
-            {
-                Views = new Dictionary<EventLogId, EventColumnView> { [logData.Id] = fresh },
-                Version = 5
-            });
-
-        var installed = state.PerLogEvents[logData.Id];
-
-        var result = Reducers.ReduceUpdateTable(state, CreateUpdateAction(state, logData.Id, events, version: 5));
-
-        // A finalize matching the DisplayReady-published version re-installs an equivalent view: same content, the
-        // per-log version stays pinned at 5, and the resort generation is left untouched.
-        var after = result.PerLogEvents[logData.Id];
-        Assert.Equal(
-            installed.EnumerateDetail().Select(e => e.RecordId),
-            after.EnumerateDetail().Select(e => e.RecordId));
-        Assert.Equal(5, result.DisplayListVersion);
-        Assert.Equal(5, result.PerLogListVersion[logData.Id]);
-    }
-
-    [Fact]
-    public void ReduceUpdateTable_WhenListVersionStaleFromMidLoadFilterChange_HealsToFinalizeSlice()
-    {
-        var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
-        var state = Reducers.ReduceAddTable(new LogTableState(), new AddTableAction(logData));
-
-        var streamed = new List<ResolvedEvent>
-        {
-            new(Constants.LogNameTestLog, LogPathType.Channel) { Id = 10, RecordId = 1 },
-            new(Constants.LogNameTestLog, LogPathType.Channel) { Id = 11, RecordId = 2 }
-        };
-        state = state with { DisplayListVersion = 1 };
-
-        state = Reducers.ReduceAppendTableEventsBatch(
-            state,
-            CreateAppendBatchAction(
-                state,
-                new Dictionary<EventLogId, IReadOnlyList<ResolvedEvent>> { [logData.Id] = streamed },
-                new Dictionary<EventLogId, int> { [logData.Id] = 0 }));
-
-        var finalizeSlice = new List<ResolvedEvent>
-        {
-            new(Constants.LogNameTestLog, LogPathType.Channel) { Id = 20, RecordId = 3 },
-            new(Constants.LogNameTestLog, LogPathType.Channel) { Id = 21, RecordId = 4 }
-        };
-        var result = Reducers.ReduceUpdateTable(state, CreateUpdateAction(state, logData.Id, finalizeSlice, version: 1));
-
-        Assert.Equal([3L, 4L], result.DisplayedEvents.EnumerateDetail().Select(e => e.RecordId).OrderBy(r => r));
-    }
-
-    [Fact]
-    public void ReduceUpdateTable_WhenOlderBatchAppendsAfterDisplayReadyTag_HealsAtFinalize()
-    {
-        var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
-        var state = Reducers.ReduceAddTable(new LogTableState(), new AddTableAction(logData));
-        state = state with { DisplayListVersion = 2 };
-
-        var rebuilt = new List<ResolvedEvent>
-        {
-            new(Constants.LogNameTestLog, LogPathType.Channel) { Id = 20, RecordId = 3 },
-            new(Constants.LogNameTestLog, LogPathType.Channel) { Id = 21, RecordId = 4 }
-        };
-        state = Reducers.ReduceDisplayReady(
-            state,
-            new DisplayReadyAction
-            {
-                Views = new Dictionary<EventLogId, EventColumnView>
-                {
-                    [logData.Id] = DisplayViewTestFactory.Build(logData.Id, rebuilt, state.SortContext)
-                },
-                Version = 2
-            });
-        Assert.Equal(2, state.PerLogListVersion[logData.Id]);
-
-        state = Reducers.ReduceAppendTableEventsBatch(
-            state,
-            CreateAppendBatchAction(
-                state,
-                new Dictionary<EventLogId, IReadOnlyList<ResolvedEvent>>
-                {
-                    [logData.Id] = new List<ResolvedEvent>
-                    {
-                        new(Constants.LogNameTestLog, LogPathType.Channel) { Id = 10, RecordId = 1 }
-                    }
-                },
-                new Dictionary<EventLogId, int> { [logData.Id] = 1 }));
-        Assert.Equal(1, state.PerLogListVersion[logData.Id]);
-
-        var finalizeSlice = new List<ResolvedEvent>
-        {
-            new(Constants.LogNameTestLog, LogPathType.Channel) { Id = 20, RecordId = 3 },
-            new(Constants.LogNameTestLog, LogPathType.Channel) { Id = 21, RecordId = 4 },
-            new(Constants.LogNameTestLog, LogPathType.Channel) { Id = 22, RecordId = 5 }
-        };
-        var result = Reducers.ReduceUpdateTable(state, CreateUpdateAction(state, logData.Id, finalizeSlice, version: 2));
-
-        Assert.Equal([3L, 4L, 5L], result.DisplayedEvents.EnumerateDetail().Select(e => e.RecordId).OrderBy(r => r));
-    }
-
-    [Fact]
-    public void ReduceUpdateTable_WhenSecondLogIsEmpty_ShouldKeepFirstLogEvents()
-    {
-        // Arrange: one log populated, one log empty (but not loading), ascending RecordId order
-        var logData1 = new EventLogData(Constants.LogNameLog1, LogPathType.Channel);
-        var logData2 = new EventLogData(Constants.LogNameLog2, LogPathType.Channel);
-        var state = new LogTableState { IsDescending = false };
-        state = Reducers.ReduceAddTable(state, new AddTableAction(logData1));
-        state = Reducers.ReduceAddTable(state, new AddTableAction(logData2));
-
-        var eventsLog1 = new List<ResolvedEvent>
-        {
-            new(Constants.LogNameLog1, LogPathType.Channel) { Id = 10, RecordId = 5 },
-            new(Constants.LogNameLog1, LogPathType.Channel) { Id = 11, RecordId = 7 }
-        };
-
-        // Act
-        state = Reducers.ReduceUpdateTable(state, CreateUpdateAction(state, logData1.Id, eventsLog1));
-        state = Reducers.ReduceUpdateTable(state, CreateUpdateAction(state, logData2.Id, []));
-
-        // Assert: canonical view contains only the populated log's events
-        Assert.Equal(2, state.DisplayedEvents.Count);
-        var rows = state.DisplayedEvents.Slice(0, state.DisplayedEvents.Count);
-        Assert.Equal(5L, rows[0].Lean.RecordId);
-        Assert.Equal(7L, rows[1].Lean.RecordId);
-    }
-
-    [Fact]
-    public void ReduceUpdateTable_WhenSecondLogPopulated_ShouldMergeIntoCanonicalInSortedOrder()
-    {
-        // Arrange: two logs with interleaved RecordIds, ascending RecordId order
-        var logData1 = new EventLogData(Constants.LogNameLog1, LogPathType.Channel);
-        var logData2 = new EventLogData(Constants.LogNameLog2, LogPathType.Channel);
-        var state = new LogTableState { IsDescending = false };
-        state = Reducers.ReduceAddTable(state, new AddTableAction(logData1));
-        state = Reducers.ReduceAddTable(state, new AddTableAction(logData2));
-
-        var eventsLog1 = new List<ResolvedEvent>
-        {
-            new(Constants.LogNameLog1, LogPathType.Channel) { Id = 10, RecordId = 1 },
-            new(Constants.LogNameLog1, LogPathType.Channel) { Id = 11, RecordId = 3 }
-        };
-
-        var eventsLog2 = new List<ResolvedEvent>
-        {
-            new(Constants.LogNameLog2, LogPathType.Channel) { Id = 20, RecordId = 2 },
-            new(Constants.LogNameLog2, LogPathType.Channel) { Id = 21, RecordId = 4 }
-        };
-
-        // Act: UpdateTable maintains the canonical view atomically; no follow-up call needed.
-        state = Reducers.ReduceUpdateTable(state, CreateUpdateAction(state, logData1.Id, eventsLog1));
-        state = Reducers.ReduceUpdateTable(state, CreateUpdateAction(state, logData2.Id, eventsLog2));
-
-        // Assert: canonical view interleaves both logs in RecordId order
-        Assert.Equal(4, state.DisplayedEvents.Count);
-        var rows = state.DisplayedEvents.Slice(0, state.DisplayedEvents.Count);
-        Assert.Equal(1L, rows[0].Lean.RecordId);
-        Assert.Equal(2L, rows[1].Lean.RecordId);
-        Assert.Equal(3L, rows[2].Lean.RecordId);
-        Assert.Equal(4L, rows[3].Lean.RecordId);
-        Assert.Equal(Constants.LogNameLog1, rows[0].Lean.OwningLog);
-        Assert.Equal(Constants.LogNameLog2, rows[1].Lean.OwningLog);
-    }
-
-    [Fact]
-    public void ReduceUpdateTable_WhenStreamingListHasNoVersionTag_RebuildsAtFinalize()
-    {
-        var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
-        var state = Reducers.ReduceAddTable(new LogTableState(), new AddTableAction(logData));
-
-        var events = new List<ResolvedEvent>
-        {
-            new(Constants.LogNameTestLog, LogPathType.Channel) { Id = 10, RecordId = 1 },
-            new(Constants.LogNameTestLog, LogPathType.Channel) { Id = 11, RecordId = 2 }
-        };
-        state = Reducers.ReduceAppendTableEventsBatch(
-            state,
-            CreateAppendBatchAction(state, 
-                new Dictionary<EventLogId, IReadOnlyList<ResolvedEvent>> { [logData.Id] = events }));
-
-        Assert.False(state.PerLogListVersion.ContainsKey(logData.Id));
-
-        var before = state.PerLogEvents[logData.Id];
-        var result = Reducers.ReduceUpdateTable(state, CreateUpdateAction(state, logData.Id, events, version: 0));
-
-        Assert.NotSame(before, result.PerLogEvents[logData.Id]);
-    }
-
-    [Fact]
-    public void ReduceUpdateTable_WhenTableNotFound_ShouldReturnStateUnchanged()
-    {
-        // Arrange: empty state, no tables
-        var state = new LogTableState();
-        var staleLogId = EventLogId.Create();
-        var events = new List<ResolvedEvent> { FilterEventBuilder.CreateTestEvent(100) };
-        var action = CreateUpdateAction(state, staleLogId, events);
-
-        // Act: stale UpdateTable for a non-existent table
-        var newState = Reducers.ReduceUpdateTable(state, action);
-
-        // Assert: state unchanged, no exception thrown
-        Assert.Same(state, newState);
-    }
-
-    [Fact]
-    public void ReduceUpdateTable_WhenTimeCreatedDivergesFromRecordId_ShouldMergeByTimeCreated()
-    {
-        // Arrange: RecordIds ascending but TimeCreated descending: verifies sort is by timestamp
-        var baseTime = new DateTime(2024, 1, 1, 12, 0, 0, DateTimeKind.Utc);
-
-        var log1Events = new List<ResolvedEvent>
-        {
-            new(Constants.LogNameLog1, LogPathType.Channel) { Id = 10, RecordId = 1, TimeCreated = baseTime.AddSeconds(40) },
-            new(Constants.LogNameLog1, LogPathType.Channel) { Id = 11, RecordId = 2, TimeCreated = baseTime.AddSeconds(20) }
-        };
-
-        var log2Events = new List<ResolvedEvent>
-        {
-            new(Constants.LogNameLog2, LogPathType.Channel) { Id = 20, RecordId = 1, TimeCreated = baseTime.AddSeconds(30) },
-            new(Constants.LogNameLog2, LogPathType.Channel) { Id = 21, RecordId = 2, TimeCreated = baseTime.AddSeconds(10) }
-        };
-
-        var logData1 = new EventLogData(Constants.LogNameLog1, LogPathType.Channel);
-        var logData2 = new EventLogData(Constants.LogNameLog2, LogPathType.Channel);
-        var state = new LogTableState { IsDescending = false };
-        state = Reducers.ReduceAddTable(state, new AddTableAction(logData1));
-        state = Reducers.ReduceAddTable(state, new AddTableAction(logData2));
-
-        // Act
-        state = Reducers.ReduceUpdateTable(state, CreateUpdateAction(state, logData1.Id, log1Events));
-        state = Reducers.ReduceUpdateTable(state, CreateUpdateAction(state, logData2.Id, log2Events));
-
-        // Assert: canonical comes out time-ordered, not RecordId-ordered
-        var actualTimes = state.DisplayedEvents.EnumerateDetail().Select(e => e.TimeCreated).ToList();
-        var expectedTimes = new List<DateTime>
-        {
-            baseTime.AddSeconds(10),
-            baseTime.AddSeconds(20),
-            baseTime.AddSeconds(30),
-            baseTime.AddSeconds(40)
-        };
-        Assert.Equal(expectedTimes, actualTimes);
-    }
-
-    [Fact]
-    public void ReduceUpdateTable_WhenVersionMatchesAndCountEqual_InstallsViewWithoutResortBump()
-    {
-        var logData = new EventLogData(Constants.LogNameTestLog, LogPathType.Channel);
-        var state = Reducers.ReduceAddTable(new LogTableState(), new AddTableAction(logData));
-
-        var events = new List<ResolvedEvent>
-        {
-            new(Constants.LogNameTestLog, LogPathType.Channel) { Id = 10, RecordId = 1 },
-            new(Constants.LogNameTestLog, LogPathType.Channel) { Id = 11, RecordId = 2 }
-        };
-        state = Reducers.ReduceAppendTableEventsBatch(
-            state,
-            CreateAppendBatchAction(
-                state,
-                new Dictionary<EventLogId, IReadOnlyList<ResolvedEvent>> { [logData.Id] = events },
-                new Dictionary<EventLogId, int> { [logData.Id] = 0 }));
-
-        var before = state.PerLogEvents[logData.Id];
-        int versionBefore = state.DisplayListVersion;
-
-        var result = Reducers.ReduceUpdateTable(state, CreateUpdateAction(state, logData.Id, events, version: 0));
-
-        // The columnar reducer installs the pre-built finalize view (no in-reducer re-sort to skip). A redundant
-        // same-version finalize is a display no-op: identical content and order, and it never bumps the resort
-        // generation that would force downstream views to rebuild.
-        var after = result.PerLogEvents[logData.Id];
-        Assert.Equal(
-            before.EnumerateDetail().Select(e => e.RecordId),
-            after.EnumerateDetail().Select(e => e.RecordId));
-        Assert.Equal(versionBefore, result.DisplayListVersion);
-    }
-
-    // Seeds PerLogEvents keyed by each event's OwningLog.
-    private static ImmutableDictionary<EventLogId, EventColumnView> BuildPerLog(
-        IEnumerable<ResolvedEvent> events,
-        IEnumerable<LogView> tables,
-        ColumnName? orderBy = null,
-        bool isDescending = true,
-        ColumnName? groupBy = null,
-        bool isGroupDescending = false)
-    {
-        var byLog = events.GroupBy(resolved => resolved.OwningLog).ToList();
-
-        // Match the reducers' default: RecordId for one log while the timeline is hidden, else DateAndTime.
-        var context = new SortContext(
-            ResolvedEventOrdering.ResolveDefaultOrderBy(orderBy, groupBy, byLog.Count, timelineVisible: false),
-            isDescending,
-            groupBy,
-            isGroupDescending);
-
-        var idByName = tables.Where(table => !table.IsCombined).ToDictionary(table => table.LogName, table => table.Id);
-
-        return byLog
-            .ToImmutableDictionary(
-                group => idByName.TryGetValue(group.Key, out var id) ? id : EventLogId.Create(),
-                group =>
-                {
-                    EventLogId logId = idByName.TryGetValue(group.Key, out var id) ? id : EventLogId.Create();
-                    return DisplayViewTestFactory.Build(logId, group.ToList(), context);
-                });
-    }
-
-    private static AppendTableEventsAction CreateAppendAction(
-        LogTableState state,
-        EventLogId logId,
-        IReadOnlyList<ResolvedEvent> events)
-    {
-        List<ResolvedEvent> all = state.PerLogEvents.TryGetValue(logId, out var existing)
-            ? [.. existing.EnumerateDetail(), .. events]
-            : [.. events];
-
-        return new AppendTableEventsAction(logId) { View = DisplayViewTestFactory.Build(logId, all) };
-    }
-
-    private static AppendTableEventsBatchAction CreateAppendBatchAction(
-        LogTableState state,
-        IReadOnlyDictionary<EventLogId, IReadOnlyList<ResolvedEvent>> eventsByLog,
-        IReadOnlyDictionary<EventLogId, int>? versionByLog = null)
+    private static LogTableState AdoptRequestedOrdering(LogTableState state)
     {
-        var views = new Dictionary<EventLogId, EventColumnView>(eventsByLog.Count);
-
-        foreach (var (logId, events) in eventsByLog)
-        {
-            List<ResolvedEvent> all = state.PerLogEvents.TryGetValue(logId, out var existing)
-                ? [.. existing.EnumerateDetail(), .. events]
-                : [.. events];
+        if (state.ActiveEventLogId is not { } activeId) { return state; }
 
-            views[logId] = DisplayViewTestFactory.Build(logId, all);
-        }
+        var ready = new OrderedViewReady(
+            SnapshotVersion: state.LastPublishedSnapshotVersion + 1,
+            Identity: state.ViewIdentity,
+            Sequence: state.HighestInvalidationSequence,
+            SingleLogId: activeId,
+            InScope: [new LogGeneration(activeId, 0)],
+            View: LogTableState.EmptyView,
+            Config: state.SortContext,
+            Filter: state.AppliedFilter);
 
-        return new AppendTableEventsBatchAction
-        {
-            ViewsByLog = views,
-            VersionByLog = versionByLog ?? ImmutableDictionary<EventLogId, int>.Empty
-        };
+        return Reducers.ReduceOrderedViewUpdated(state, new OrderedViewUpdatedAction(ready));
     }
 
-    private static UpdateTableAction CreateUpdateAction(
-        LogTableState state,
-        EventLogId logId,
-        IReadOnlyList<ResolvedEvent> events,
-        int? version = null) =>
-        new(logId)
-        {
-            View = DisplayViewTestFactory.Build(logId, events),
-            Version = version ?? state.DisplayListVersion
-        };
-
     private static LogTableState SeedTabled(
         IReadOnlyList<ResolvedEvent> events,
         ColumnName? orderBy = null,
@@ -2215,7 +986,6 @@ private static LogTableState SeedTabled(
     {
         var logData = new EventLogData(events[0].OwningLog, LogPathType.Channel);
         var state = Reducers.ReduceAddTable(new LogTableState(), new AddTableAction(logData));
-        var tables = state.EventTables.Where(table => !table.IsCombined).ToList();
 
         return state with
         {
@@ -2227,21 +997,9 @@ private static LogTableState SeedTabled(
             RequestedGroupBy = groupBy,
             IsGroupDescending = isGroupDescending,
             RequestedIsGroupDescending = isGroupDescending,
-            PerLogEvents = BuildPerLog(events, tables, orderBy, isDescending, groupBy, isGroupDescending),
             GroupCollapseOverrides = collapseOverrides ?? ImmutableHashSet.Create<string>(StringComparer.Ordinal)
         };
     }
 
-    private static LogTableState Settle(LogTableState state)
-    {
-        var context = state.SortContext;
-        var views = new Dictionary<EventLogId, EventColumnView>(state.PerLogEvents.Count);
-
-        foreach (var (logId, view) in state.PerLogEvents)
-        {
-            views[logId] = view.WithContext(context);
-        }
-
-        return Reducers.ReduceDisplayReady(state, new DisplayReadyAction { Views = views, Version = state.DisplayListVersion });
-    }
+    private static LogTableState Settle(LogTableState state) => AdoptRequestedOrdering(state);
 }
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/CombinedViewParityAsserts.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/CombinedViewParityAsserts.cs
new file mode 100644
index 000000000..8a5d21bed
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/CombinedViewParityAsserts.cs
@@ -0,0 +1,93 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
+using EventLogExpert.Runtime.LogTable;
+using EventLogExpert.Runtime.LogTable.OrderedView;
+using EventLogExpert.Runtime.Tests.LogTable.TestSupport;
+
+namespace EventLogExpert.Runtime.Tests.LogTable.OrderedView;
+
+internal static class CombinedViewParityAsserts
+{
+    public static void AssertGroupRunsMatch(IEventColumnView expected, IEventColumnView actual, ColumnName groupBy)
+    {
+        Assert.Equal(expected.Count, actual.Count);
+        Assert.Equal(GroupRuns(expected, groupBy), GroupRuns(actual, groupBy));
+    }
+
+    public static void AssertOrderMatchesReference(
+        IEventColumnView facade,
+        IReadOnlyList<(EventLogId LogId, IReadOnlyList<ResolvedEvent> Events)> perLog,
+        SortContext context)
+    {
+        ArgumentNullException.ThrowIfNull(facade);
+        ArgumentNullException.ThrowIfNull(perLog);
+
+        var flattened = new List<(EventLogId LogId, int Index, ResolvedEvent Event)>();
+
+        foreach ((EventLogId logId, IReadOnlyList<ResolvedEvent> events) in perLog)
+        {
+            for (int index = 0; index < events.Count; index++) { flattened.Add((logId, index, events[index])); }
+        }
+
+        int[] expected = AosReferenceOrdering.Order(
+            [.. flattened.Select(entry => entry.Event)],
+            context.OrderBy,
+            context.IsDescending,
+            context.GroupBy,
+            context.IsGroupDescending);
+
+        Assert.Equal(expected.Length, facade.Count);
+
+        for (int position = 0; position < expected.Length; position++)
+        {
+            (EventLogId logId, int index, _) = flattened[expected[position]];
+            EventLocator actual = facade.LocatorAt(position);
+
+            Assert.Equal(logId, actual.LogId);
+            Assert.Equal(index, actual.Index);
+        }
+    }
+
+    public static void AssertSnapshotOrderMatchesReference(
+        OrderedViewSnapshot snapshot, EventLogId logId, IReadOnlyList<ResolvedEvent> events, SortContext context)
+    {
+        int[] expected = AosReferenceOrdering.Order(
+            events, context.OrderBy, context.IsDescending, context.GroupBy, context.IsGroupDescending);
+
+        Assert.Equal(expected.Length, snapshot.Count);
+
+        for (int position = 0; position < expected.Length; position++)
+        {
+            EventLocator locator = snapshot.At(position).Locator;
+
+            Assert.Equal(logId, locator.LogId);
+            Assert.Equal(expected[position], locator.Index);
+            Assert.Equal(position, snapshot.RankOf(new OrderKey(locator)));
+            Assert.True(snapshot.Contains(locator.LogId, locator.Generation, locator.Index));
+        }
+    }
+
+    public static List<(string Key, int Count)> GroupRuns(IEventColumnView view, ColumnName groupBy)
+    {
+        var runs = new List<(string Key, int Count)>();
+
+        for (int index = 0; index < view.Count; index++)
+        {
+            string key = view.GroupKeyAt(view.LocatorAt(index), groupBy);
+
+            if (runs.Count > 0 && string.Equals(runs[^1].Key, key, StringComparison.Ordinal))
+            {
+                runs[^1] = (key, runs[^1].Count + 1);
+            }
+            else
+            {
+                runs.Add((key, 1));
+            }
+        }
+
+        return runs;
+    }
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/Faults.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/Faults.cs
new file mode 100644
index 000000000..e8706276e
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/Faults.cs
@@ -0,0 +1,12 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Runtime.LogTable;
+
+namespace EventLogExpert.Runtime.Tests.LogTable.OrderedView;
+
+internal static class Faults
+{
+    internal static OrderedViewDisplayFaultedAction Any =>
+        new(new InvalidOperationException("the engine failed"));
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/OrderedColumnViewLeanEnumerationTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/OrderedColumnViewLeanEnumerationTests.cs
new file mode 100644
index 000000000..42510fed3
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/OrderedColumnViewLeanEnumerationTests.cs
@@ -0,0 +1,115 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.Channels;
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
+using EventLogExpert.Eventing.TestUtils;
+using EventLogExpert.Runtime.LogTable;
+using EventLogExpert.Runtime.LogTable.OrderedView;
+using System.Security.Principal;
+
+namespace EventLogExpert.Runtime.Tests.LogTable.OrderedView;
+
+public sealed class OrderedColumnViewLeanEnumerationTests
+{
+    [Fact]
+    public void EnumerateDetailLean_PreservesGridFieldsInDisplayOrder_ButOmitsDetailFields()
+    {
+        const int count = 64;
+        ResolvedEvent[] events = BuildDetailRichEvents(count);
+
+        OrderedColumnView view = BuildView(events, new SortContext(ColumnName.EventId, isDescending: true, groupBy: null, isGroupDescending: false));
+
+        List<ResolvedEvent> full = [.. view.EnumerateDetail()];
+        List<ResolvedEvent> lean = [.. view.EnumerateDetailLean()];
+
+        long?[] expectedByDisplay = [.. Enumerable.Range(1, count).Reverse().Select(recordId => (long?)recordId)];
+        Assert.Equal(expectedByDisplay, full.Select(@event => @event.RecordId));
+        Assert.Equal(expectedByDisplay, lean.Select(@event => @event.RecordId));
+
+        Assert.All(full, @event =>
+        {
+            Assert.NotEmpty(@event.Xml);
+            Assert.True(@event.EventData.Count > 0);
+            Assert.False(@event.UserData.IsDefaultOrEmpty);
+        });
+
+        for (int i = 0; i < lean.Count; i++)
+        {
+            ResolvedEvent expected = full[i];
+            ResolvedEvent actual = lean[i];
+
+            Assert.Equal(string.Empty, actual.Xml);
+            Assert.Equal(0, actual.EventData.Count);
+            Assert.True(actual.UserData.IsDefaultOrEmpty);
+
+            Assert.Equal(expected.RecordId, actual.RecordId);
+            Assert.Equal(expected.TimeCreated, actual.TimeCreated);
+            Assert.Equal(expected.Level, actual.Level);
+            Assert.Equal(expected.Source, actual.Source);
+            Assert.Equal(expected.Id, actual.Id);
+            Assert.Equal(expected.TaskCategory, actual.TaskCategory);
+            Assert.Equal(expected.ComputerName, actual.ComputerName);
+            Assert.Equal(expected.Description, actual.Description);
+            Assert.Equal(expected.KeywordsDisplayName, actual.KeywordsDisplayName);
+            Assert.Equal(expected.ProcessId, actual.ProcessId);
+            Assert.Equal(expected.ThreadId, actual.ThreadId);
+            Assert.Equal(expected.ActivityId, actual.ActivityId);
+            Assert.Equal(expected.OwningLog, actual.OwningLog);
+            Assert.Equal(expected.UserId, actual.UserId);
+        }
+    }
+
+    private static ResolvedEvent[] BuildDetailRichEvents(int count)
+    {
+        var baseTime = new DateTime(2026, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+        string[] keywords = ["Audit Success"];
+        var activityId = new Guid("11112222-3333-4444-5555-666677778888");
+        var userId = new SecurityIdentifier("S-1-5-21-1004336348-1177238915-682003330-512");
+        var events = new ResolvedEvent[count];
+
+        for (int i = 0; i < count; i++)
+        {
+            events[i] = new ResolvedEvent("Application", LogPathType.Channel)
+            {
+                RecordId = i + 1,
+                TimeCreated = baseTime.AddSeconds(i),
+                Level = i % 2 == 0 ? "Information" : "Error",
+                Source = "Microsoft-Windows-Servicing",
+                Id = 1000 + i,
+                TaskCategory = "None",
+                ComputerName = "DESKTOP-AB12CDE",
+                Keywords = keywords,
+                ProcessId = 4000 + i,
+                ThreadId = 8000 + i,
+                ActivityId = activityId,
+                UserId = userId,
+                Description = $"Row {i} entered the running state for package KB{5000000 + i}.",
+                Xml =
+                    $"<Event><System><EventID>{1000 + i}</EventID></System>" +
+                    $"<EventData><Data Name='PackageIdentifier'>KB{5000000 + i}</Data></EventData></Event>"
+            }.WithEventData(
+                ("PackageIdentifier", $"KB{5000000 + i}"),
+                ("CurrentState", "Installed"),
+                ("ErrorCode", (long)i))
+             .WithUserData(
+                ("CbsPackageChangeState/ErrorCode", $"0x{i:X8}"));
+        }
+
+        return events;
+    }
+
+    private static OrderedColumnView BuildView(ResolvedEvent[] events, SortContext context)
+    {
+        EventLogId logId = EventLogId.Create();
+        IEventColumnReader reader = EventColumnStore.Build(events, generation: 0, contentVersion: 0).CreateReader(logId);
+
+        var state = new OrderedViewState();
+        state.ReconcileLog(logId, reader);
+        RebuildRequest request = state.BeginRebuild(static (_, _) => true, context);
+        Assert.True(state.TryAdoptRebuild(request, OrderedViewState.BuildIndex(request)));
+
+        return new OrderedColumnView(state.Current, reader);
+    }
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/OrderedViewAdoptedInScopeTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/OrderedViewAdoptedInScopeTests.cs
new file mode 100644
index 000000000..963fe7544
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/OrderedViewAdoptedInScopeTests.cs
@@ -0,0 +1,335 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.Channels;
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
+using EventLogExpert.Runtime.LogTable;
+using EventLogExpert.Runtime.LogTable.OrderedView;
+
+namespace EventLogExpert.Runtime.Tests.LogTable.OrderedView;
+
+public sealed class OrderedViewAdoptedInScopeTests
+{
+    private static readonly SortContext s_context = new(ColumnName.DateAndTime, false, null, false);
+
+    [Fact]
+    public void AdoptedInScope_AfterClear_IsEmpty()
+    {
+        EventLogId logId = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        ReconcileAll(state, logId, generation: 0, count: 5);
+        Rebuild(state);
+        Assert.NotEmpty(state.AdoptedInScope);
+
+        state.Clear();
+
+        Assert.Empty(state.AdoptedInScope);
+    }
+
+    [Fact]
+    public void AdoptedInScope_AfterRebuild_ContainsEveryInScopeLogThatHasRows()
+    {
+        EventLogId logA = EventLogId.Create();
+        EventLogId logB = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        ReconcileAll(state, logA, generation: 0, count: 12);
+        ReconcileAll(state, logB, generation: 0, count: 8);
+        Rebuild(state);
+
+        Assert.Equal(
+            new HashSet<LogGeneration> { new(logA, 0), new(logB, 0) },
+            state.AdoptedInScope.ToHashSet());
+    }
+
+    [Fact]
+    public void AdoptedInScope_EveryMemberResolves_SoTheCombinedViewBuildsWithoutThrowing()
+    {
+        EventLogId logA = EventLogId.Create();
+        EventLogId logB = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        ReconcileAll(state, logA, generation: 0, count: 11);
+        ReconcileAll(state, logB, generation: 0, count: 4);
+        RebuildRequest request = state.BeginRebuild((locator, _) => locator.LogId == logA, s_context);
+        Assert.True(state.TryAdoptRebuild(request, OrderedViewState.BuildIndex(request, CancellationToken.None)));
+
+        var facade = new CombinedOrderedColumnView(state.Current, [.. state.AdoptedInScope]);
+
+        Assert.Equal(state.Current.Count, facade.Count);
+    }
+
+    [Fact]
+    public void AdoptedInScope_ReflectsTheAdoptedScope_NotLiveScope()
+    {
+        EventLogId logA = EventLogId.Create();
+        EventLogId logB = EventLogId.Create();
+        EventLogId logC = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        ReconcileAll(state, logA, generation: 0, count: 7);
+        ReconcileAll(state, logB, generation: 0, count: 5);
+        ReconcileAll(state, logC, generation: 0, count: 6);
+        Rebuild(state);
+
+        RebuildRequest? narrowed = ViewRequests.AdvanceScope(state, [logA, logB], 1);
+        Assert.NotNull(narrowed);
+        Assert.True(state.TryAdoptRebuild(narrowed, OrderedViewState.BuildIndex(narrowed, CancellationToken.None)));
+
+        Assert.Equal(
+            new HashSet<LogGeneration> { new(logA, 0), new(logB, 0) },
+            state.AdoptedInScope.ToHashSet());
+    }
+
+    [Fact]
+    public void AdoptedInScope_ResetAdoptedBeforeNewGenerationReader_ExcludesReaderlessMember_AndFacadeBuilds()
+    {
+        EventLogId logA = EventLogId.Create();
+        EventLogId logB = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        ReconcileAll(state, logA, generation: 0, count: 10);
+        ReconcileAll(state, logB, generation: 0, count: 6);
+        Rebuild(state);
+
+        RebuildRequest reset = state.BeginReset(logB, newGeneration: 1);
+        Assert.True(state.TryAdoptRebuild(reset, OrderedViewState.BuildIndex(reset, CancellationToken.None)));
+
+        Assert.DoesNotContain(new LogGeneration(logB, 1), state.AdoptedInScope);
+        Assert.Contains(new LogGeneration(logA, 0), state.AdoptedInScope);
+
+        var facade = new CombinedOrderedColumnView(state.Current, [.. state.AdoptedInScope]);
+        Assert.Equal(state.Current.Count, facade.Count);
+    }
+
+    [Fact]
+    public void AdoptedInScope_ResetToAZeroEventGenerationWithAReconciledEmptyReader_IsExcluded()
+    {
+        EventLogId logA = EventLogId.Create();
+        EventLogId logB = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        ReconcileAll(state, logA, generation: 0, count: 8);
+        ReconcileAll(state, logB, generation: 0, count: 5);
+        Rebuild(state);
+
+        RebuildRequest reset = state.BeginReset(logB, newGeneration: 1);
+        Assert.False(state.ReconcileLog(logB, Reader(logB, generation: 1, count: 0)));
+        Assert.True(state.TryAdoptRebuild(reset, OrderedViewState.BuildIndex(reset, CancellationToken.None)));
+
+        Assert.DoesNotContain(new LogGeneration(logB, 1), state.AdoptedInScope);
+
+        var facade = new CombinedOrderedColumnView(state.Current, [.. state.AdoptedInScope]);
+        Assert.Equal(state.Current.Count, facade.Count);
+    }
+
+    [Fact]
+    public void AdoptedInScope_UpdatesOnLiveTailPublish_WhenAnEmptyInScopeLogGainsItsFirstRow()
+    {
+        EventLogId logA = EventLogId.Create();
+        EventLogId logB = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        ReconcileAll(state, logA, generation: 0, count: 8);
+        Assert.False(state.ReconcileLog(logB, Reader(logB, generation: 0, count: 0)));
+        Rebuild(state);
+        Assert.DoesNotContain(new LogGeneration(logB, 0), state.AdoptedInScope);
+
+        Assert.True(state.ReconcileLog(logB, Reader(logB, generation: 0, count: 3)));
+        state.Publish();
+
+        Assert.Contains(new LogGeneration(logB, 0), state.AdoptedInScope);
+
+        var facade = new CombinedOrderedColumnView(state.Current, [.. state.AdoptedInScope]);
+        Assert.Equal(state.Current.Count, facade.Count);
+    }
+
+    [Fact]
+    public void AdoptedInScope_ZeroEventLog_IsAbsent()
+    {
+        EventLogId withRows = EventLogId.Create();
+        EventLogId empty = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        ReconcileAll(state, withRows, generation: 0, count: 9);
+        Assert.False(state.ReconcileLog(empty, Reader(empty, generation: 0, count: 0)));
+        Rebuild(state);
+
+        Assert.Contains(new LogGeneration(withRows, 0), state.AdoptedInScope);
+        Assert.DoesNotContain(new LogGeneration(empty, 0), state.AdoptedInScope);
+    }
+
+    [Fact]
+    public void AdoptedInScope_ZeroSurvivorMember_IsPresentAndItsReaderResolves()
+    {
+        EventLogId logA = EventLogId.Create();
+        EventLogId logB = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        ReconcileAll(state, logA, generation: 0, count: 10);
+        ReconcileAll(state, logB, generation: 0, count: 6);
+
+        RebuildRequest request = state.BeginRebuild((locator, _) => locator.LogId == logA, s_context);
+        Assert.True(state.TryAdoptRebuild(request, OrderedViewState.BuildIndex(request, CancellationToken.None)));
+
+        Assert.Contains(new LogGeneration(logB, 0), state.AdoptedInScope);
+        Assert.True(state.Current.TryGetReaderByLog(logB, 0, out _));
+        Assert.Equal(10, state.Current.Count);
+    }
+
+    [Fact]
+    public void ReconcileLog_RegistersAPostResetZeroSurvivorGeneration_KeyedOnPublishedLogGenerationNotLogId()
+    {
+        EventLogId logA = EventLogId.Create();
+        EventLogId logB = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        ReconcileAll(state, logA, generation: 0, count: 8);
+        ReconcileAll(state, logB, generation: 0, count: 5);
+
+        RebuildRequest filtered = state.BeginRebuild(static (_, _) => false, s_context);
+        Assert.True(state.TryAdoptRebuild(filtered, OrderedViewState.BuildIndex(filtered, CancellationToken.None)));
+
+        RebuildRequest reset = state.BeginReset(logB, newGeneration: 1);
+        Assert.True(state.TryAdoptRebuild(reset, OrderedViewState.BuildIndex(reset, CancellationToken.None)));
+        Assert.DoesNotContain(new LogGeneration(logB, 1), state.AdoptedInScope);
+
+        Assert.True(state.ReconcileLog(logB, Reader(logB, generation: 1, count: 4)));
+        state.Publish();
+
+        Assert.Contains(new LogGeneration(logB, 1), state.AdoptedInScope);
+    }
+
+    [Fact]
+    public void ReconcileLog_RegistersTheFirstZeroSurvivorMember_ThenSuppressesFurtherFilteredGrowth()
+    {
+        EventLogId logId = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        RebuildRequest request = state.BeginRebuild(static (_, _) => false, s_context);
+        Assert.True(state.TryAdoptRebuild(request, OrderedViewState.BuildIndex(request, CancellationToken.None)));
+
+        Assert.True(state.ReconcileLog(logId, Reader(logId, generation: 0, count: 3)));
+        state.Publish();
+        Assert.Contains(new LogGeneration(logId, 0), state.AdoptedInScope);
+
+        Assert.False(state.ReconcileLog(logId, Reader(logId, generation: 0, count: 6)));
+    }
+
+    [Fact]
+    public void ReconcileLog_ReturnsFalse_ForAZeroEventReader()
+    {
+        EventLogId logId = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        Assert.False(state.ReconcileLog(logId, Reader(logId, generation: 0, count: 0)));
+    }
+
+    [Fact]
+    public void ReconcileLog_ReturnsFalse_WhenTheLogIsOutOfScope()
+    {
+        EventLogId inScope = EventLogId.Create();
+        EventLogId outOfScope = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        RebuildRequest? narrowed = ViewRequests.AdvanceScope(state, [inScope], 1);
+        Assert.NotNull(narrowed);
+        Assert.True(state.TryAdoptRebuild(narrowed, OrderedViewState.BuildIndex(narrowed, CancellationToken.None)));
+
+        Assert.False(state.ReconcileLog(outOfScope, Reader(outOfScope, generation: 0, count: 3)));
+    }
+
+    [Fact]
+    public void ReconcileLog_ReturnsFalse_WhenTheReaderIsNotStrictlyNewer()
+    {
+        EventLogId logId = EventLogId.Create();
+        IEventColumnReader reader = Reader(logId, generation: 0, count: 6);
+        var state = new OrderedViewState();
+
+        Assert.True(state.ReconcileLog(logId, reader));
+        Assert.False(state.ReconcileLog(logId, reader));
+    }
+
+    [Fact]
+    public void ReconcileLog_ReturnsTrue_ForAStrictlyNewerSameCountContentReplace()
+    {
+        EventLogId logId = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        Assert.True(state.ReconcileLog(logId, Reader(logId, generation: 0, count: 5)));
+
+        IEventColumnReader replaced =
+            EventColumnStore.Build(MakeEvents("Log", firstRecordId: 1, count: 5), generation: 0, contentVersion: 1).CreateReader(logId);
+
+        Assert.True(state.ReconcileLog(logId, replaced));
+    }
+
+    [Fact]
+    public void ReconcileLog_ReturnsTrue_WhenRowsEnterTheIndex()
+    {
+        EventLogId logId = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        Assert.True(state.ReconcileLog(logId, Reader(logId, generation: 0, count: 6)));
+    }
+
+    [Fact]
+    public void ScopeExpansionWindow_HoldsNewScopeRowsOutOfTheIndex_SoAdoptedInScopeStaysCoherentAndTheFacadePartitions()
+    {
+        EventLogId logA = EventLogId.Create();
+        EventLogId logB = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        ReconcileAll(state, logA, generation: 0, count: 8);
+        RebuildRequest? scopeA = ViewRequests.AdvanceScope(state, [logA], 1);
+        Assert.NotNull(scopeA);
+        Assert.True(state.TryAdoptRebuild(scopeA, OrderedViewState.BuildIndex(scopeA, CancellationToken.None)));
+
+        Assert.NotNull(ViewRequests.AdvanceScope(state, [logA, logB], 2));
+        state.ReconcileLog(logB, Reader(logB, generation: 0, count: 4));
+        state.Publish();
+
+        Assert.Equal(8, state.Current.Count);
+        Assert.DoesNotContain(new LogGeneration(logB, 0), state.AdoptedInScope);
+
+        var facade = new CombinedOrderedColumnView(state.Current, [.. state.AdoptedInScope]);
+        var eventIdCounts = new Dictionary<int, int>();
+        facade.CountEventIds(eventIdCounts, CancellationToken.None);
+        Assert.Equal(8, facade.Count);
+    }
+
+    private static List<ResolvedEvent> MakeEvents(string owningLog, long firstRecordId, int count)
+    {
+        var clock = new DateTime(2026, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+        var events = new List<ResolvedEvent>(count);
+
+        for (int i = 0; i < count; i++)
+        {
+            events.Add(new ResolvedEvent(owningLog, LogPathType.Channel)
+            {
+                RecordId = firstRecordId + i,
+                TimeCreated = clock.AddSeconds(i),
+                Id = 1000 + (i % 5),
+                Level = "Information",
+                Source = "Provider.A",
+                LogName = owningLog
+            });
+        }
+
+        return events;
+    }
+
+    private static IEventColumnReader Reader(EventLogId logId, int generation, int count) =>
+        EventColumnStore.Build(MakeEvents("Log", firstRecordId: 1, count), generation, contentVersion: generation).CreateReader(logId);
+
+    private static void Rebuild(OrderedViewState state)
+    {
+        RebuildRequest request = state.BeginRebuild(static (_, _) => true, s_context);
+        Assert.True(state.TryAdoptRebuild(request, OrderedViewState.BuildIndex(request, CancellationToken.None)));
+    }
+
+    private static void ReconcileAll(OrderedViewState state, EventLogId logId, int generation, int count) =>
+        state.ReconcileLog(logId, Reader(logId, generation, count));
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/OrderedViewBuildSchedulerTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/OrderedViewBuildSchedulerTests.cs
new file mode 100644
index 000000000..ebab18455
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/OrderedViewBuildSchedulerTests.cs
@@ -0,0 +1,509 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.Channels;
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
+using EventLogExpert.Runtime.LogTable;
+using EventLogExpert.Runtime.LogTable.OrderedView;
+using EventLogExpert.Runtime.Tests.LogTable.TestSupport;
+
+namespace EventLogExpert.Runtime.Tests.LogTable.OrderedView;
+
+public sealed class OrderedViewBuildSchedulerTests
+{
+    private static readonly Filter s_emptyFilter = new(null, []);
+
+    [Fact]
+    public async Task Clear_DropsDesiredBuild_SoNoFurtherBuilderStarts()
+    {
+        EventLogId logId = EventLogId.Create();
+        var events = MakeEvents(200);
+        IEventColumnReader reader = EventColumnStore.Build(events, generation: 0, contentVersion: 0).CreateReader(logId);
+
+        using var blocking = new ManualResetEventSlim(false);
+        using var entered = new ManualResetEventSlim(false);
+        int gateArmed = 1;
+
+        await using var writer = new OrderedViewWriter(publishEvery: 16, publishIntervalMs: 4);
+
+        writer.EnqueueReconcile(logId, reader);
+
+        writer.EnqueueViewRequest(ViewRequests.For(
+            new SortContext(ColumnName.Level, false, null, false), s_emptyFilter, [logId], Predicate));
+
+        Assert.True(entered.Wait(OrderedViewTestTimeouts.Default, TestContext.Current.CancellationToken));
+
+        writer.EnqueueViewRequest(ViewRequests.For(
+            new SortContext(ColumnName.Source, true, null, false), s_emptyFilter, [logId]));
+
+        writer.EnqueueClear(ViewRequests.Identity(), ViewRequests.NextSequence());
+
+        blocking.Set();
+
+        OrderedViewSnapshot snapshot = await writer.DrainAsync();
+
+        Assert.Null(writer.Faulted);
+        Assert.Equal(0, snapshot.Count);
+
+        Assert.Equal(1, writer.BuildsStarted);
+        return;
+
+        bool Predicate(EventLocator locator, IEventColumnReader columnReader)
+        {
+            if (Interlocked.Exchange(ref gateArmed, 0) == 1)
+            {
+                entered.Set();
+                blocking.Wait(OrderedViewTestTimeouts.Default);
+            }
+
+            return true;
+        }
+    }
+
+    [Fact]
+    public async Task DeferredBuild_RetaggedByALaterRequest_AdoptsTheLatestIdentityAndSequence()
+    {
+        EventLogId logA = EventLogId.Create();
+        EventLogId logB = EventLogId.Create();
+        var events = MakeEvents(200);
+        IEventColumnReader reader = EventColumnStore.Build(events, generation: 0, contentVersion: 0).CreateReader(logA);
+
+        using var blocking = new ManualResetEventSlim(false);
+        using var entered = new ManualResetEventSlim(false);
+        int gateArmed = 1;
+
+        await using var writer = new OrderedViewWriter(publishEvery: 16, publishIntervalMs: 4);
+
+        ViewRequest initial = ViewRequests.For(
+            new SortContext(ColumnName.Level, false, null, false), s_emptyFilter, [logA, logB], Predicate, activeLogId: logA);
+
+        var deferredContext = new SortContext(ColumnName.Source, true, null, false);
+        ViewRequest deferred = ViewRequests.For(deferredContext, s_emptyFilter, [logA, logB], activeLogId: logA);
+
+        ViewRequest retag = ViewRequests.For(deferredContext, s_emptyFilter, [logA, logB], activeLogId: logB);
+
+        var matched = new TaskCompletionSource<OrderedViewUpdate>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        writer.Updated += update =>
+        {
+            if (update is OrderedViewReady && update.Sequence == retag.Sequence) { matched.TrySetResult(update); }
+        };
+
+        writer.EnqueueReconcile(logA, reader);
+
+        writer.EnqueueViewRequest(initial);
+
+        Assert.True(entered.Wait(OrderedViewTestTimeouts.Default, TestContext.Current.CancellationToken));
+
+        writer.EnqueueViewRequest(deferred);
+        writer.EnqueueViewRequest(retag);
+
+        blocking.Set();
+
+        await writer.DrainAsync();
+
+        Assert.Null(writer.Faulted);
+
+        Assert.Equal(2, writer.BuildsStarted);
+
+        OrderedViewUpdate published = await matched.Task.WaitAsync(OrderedViewTestTimeouts.Default, TestContext.Current.CancellationToken);
+
+        Assert.Equal(retag.Identity, published.Identity);
+        Assert.Equal(retag.Sequence, published.Sequence);
+        return;
+
+        bool Predicate(EventLocator locator, IEventColumnReader columnReader)
+        {
+            if (Interlocked.Exchange(ref gateArmed, 0) == 1)
+            {
+                entered.Set();
+                blocking.Wait(OrderedViewTestTimeouts.Default);
+            }
+
+            return true;
+        }
+    }
+
+    [Fact]
+    public async Task Dispose_WithABufferedCompletionAndADeferredRequest_NeverHandsOffTheDeferredBuild()
+    {
+        EventLogId logId = EventLogId.Create();
+        var events = MakeEvents(120);
+        IEventColumnReader reader = EventColumnStore.Build(events, generation: 0, contentVersion: 0).CreateReader(logId);
+
+        using var buildEntered = new ManualResetEventSlim(false);
+        using var releaseBuild = new ManualResetEventSlim(false);
+        using var ownerParked = new ManualResetEventSlim(false);
+        using var releaseOwner = new ManualResetEventSlim(false);
+        int buildGate = 1;
+        int ownerGate = 0;
+
+        var writer = new OrderedViewWriter(publishEvery: 8, publishIntervalMs: 0);
+
+        writer.Updated += _ =>
+        {
+            if (Interlocked.Exchange(ref ownerGate, 0) == 1)
+            {
+                ownerParked.Set();
+                releaseOwner.Wait(OrderedViewTestTimeouts.Default);
+            }
+        };
+
+        EventColumnStore store = EnqueueGrowingReconciles(writer, logId, EventColumnStore.Empty, events, 0, 64, chunkSize: 64);
+
+        writer.EnqueueViewRequest(ViewRequests.For(
+            new SortContext(ColumnName.Level, false, null, false), s_emptyFilter, [logId], Predicate));
+
+        Assert.True(buildEntered.Wait(OrderedViewTestTimeouts.Default, TestContext.Current.CancellationToken));
+
+        writer.EnqueueViewRequest(ViewRequests.For(
+            new SortContext(ColumnName.Source, true, null, false), s_emptyFilter, [logId]));
+
+        Interlocked.Exchange(ref ownerGate, 1);
+
+        EnqueueGrowingReconciles(writer, logId, store, events, 64, events.Count, chunkSize: 1);
+
+        Assert.True(ownerParked.Wait(OrderedViewTestTimeouts.Default, TestContext.Current.CancellationToken),
+            "The owner never parked, so the completion below would not be buffered at disposal.");
+
+        Task? build = writer.CurrentBuildTask;
+
+        Assert.NotNull(build);
+
+        releaseBuild.Set();
+        await build.WaitAsync(OrderedViewTestTimeouts.Default, TestContext.Current.CancellationToken);
+
+        ValueTask disposal = writer.DisposeAsync();
+
+        releaseOwner.Set();
+
+        await disposal;
+
+        Assert.Equal(1, writer.BuildsStarted);
+        return;
+
+        bool Predicate(EventLocator locator, IEventColumnReader columnReader)
+        {
+            if (Interlocked.Exchange(ref buildGate, 0) == 1)
+            {
+                buildEntered.Set();
+                releaseBuild.Wait(OrderedViewTestTimeouts.Default);
+            }
+
+            return true;
+        }
+    }
+
+    [Fact]
+    public async Task Dispose_WithARunningBuildAndADeferredRequest_TerminatesWithoutStartingMore()
+    {
+        EventLogId logId = EventLogId.Create();
+        var events = MakeEvents(200);
+        IEventColumnReader reader = EventColumnStore.Build(events, generation: 0, contentVersion: 0).CreateReader(logId);
+
+        using var blocking = new ManualResetEventSlim(false);
+        using var entered = new ManualResetEventSlim(false);
+        int gateArmed = 1;
+
+        var writer = new OrderedViewWriter(publishEvery: 16, publishIntervalMs: 4);
+
+        writer.EnqueueReconcile(logId, reader);
+
+        writer.EnqueueViewRequest(ViewRequests.For(
+            new SortContext(ColumnName.Level, false, null, false), s_emptyFilter, [logId], Predicate));
+
+        Assert.True(entered.Wait(OrderedViewTestTimeouts.Default, TestContext.Current.CancellationToken));
+
+        writer.EnqueueViewRequest(ViewRequests.For(
+            new SortContext(ColumnName.Source, true, null, false), s_emptyFilter, [logId]));
+
+        ValueTask disposal = writer.DisposeAsync();
+
+        blocking.Set();
+
+        await disposal;
+
+        Assert.Equal(1, writer.BuildsStarted);
+        return;
+
+        bool Predicate(EventLocator locator, IEventColumnReader columnReader)
+        {
+            if (Interlocked.Exchange(ref gateArmed, 0) == 1)
+            {
+                entered.Set();
+                blocking.Wait(OrderedViewTestTimeouts.Default);
+            }
+
+            return true;
+        }
+    }
+
+    [Fact]
+    public async Task Dispose_WithBufferedUnconsumedRequests_NeverStartsOrRetainsBuild()
+    {
+        EventLogId logId = EventLogId.Create();
+        var events = MakeEvents(64);
+        IEventColumnReader reader = EventColumnStore.Build(events, generation: 0, contentVersion: 0).CreateReader(logId);
+
+        using var ownerParked = new ManualResetEventSlim(false);
+        using var release = new ManualResetEventSlim(false);
+        int gateArmed = 1;
+
+        var writer = new OrderedViewWriter(publishEvery: 8, publishIntervalMs: 4);
+
+        writer.Updated += _ =>
+        {
+            if (Interlocked.Exchange(ref gateArmed, 0) == 1)
+            {
+                ownerParked.Set();
+                release.Wait(OrderedViewTestTimeouts.Default);
+            }
+        };
+
+        EnqueueGrowingReconciles(writer, logId, EventColumnStore.Empty, events, 0, events.Count, chunkSize: 1);
+
+        Assert.True(ownerParked.Wait(OrderedViewTestTimeouts.Default, TestContext.Current.CancellationToken),
+            "The owner never parked, so the commands below would not still be buffered at disposal.");
+
+        writer.EnqueueViewRequest(ViewRequests.For(
+            new SortContext(ColumnName.Source, true, null, false), s_emptyFilter, [logId]));
+
+        writer.EnqueueRemoveLog(EventLogId.Create());
+        writer.EnqueueResetLog(logId, newGeneration: 1);
+
+        ValueTask disposal = writer.DisposeAsync();
+
+        release.Set();
+
+        await disposal;
+
+        Assert.Equal(0, writer.BuildsStarted);
+    }
+
+    [Fact]
+    public async Task DrainAsync_WaitsForADeferredBuild_AndDoesNotHang()
+    {
+        EventLogId logId = EventLogId.Create();
+        var events = MakeEvents(200);
+        IEventColumnReader reader = EventColumnStore.Build(events, generation: 0, contentVersion: 0).CreateReader(logId);
+
+        using var blocking = new ManualResetEventSlim(false);
+        using var entered = new ManualResetEventSlim(false);
+        int gateArmed = 1;
+
+        await using var writer = new OrderedViewWriter(publishEvery: 16, publishIntervalMs: 4);
+
+        writer.EnqueueReconcile(logId, reader);
+
+        writer.EnqueueViewRequest(ViewRequests.For(
+            new SortContext(ColumnName.Level, false, null, false), s_emptyFilter, [logId], Predicate));
+
+        Assert.True(entered.Wait(OrderedViewTestTimeouts.Default, TestContext.Current.CancellationToken));
+
+        writer.EnqueueViewRequest(ViewRequests.For(
+            new SortContext(ColumnName.EventId, false, null, false), s_emptyFilter, [logId]));
+
+        writer.EnqueueViewRequest(ViewRequests.For(
+            new SortContext(ColumnName.DateAndTime, true, null, false), s_emptyFilter, [logId]));
+
+        var finalContext = new SortContext(ColumnName.Source, true, null, false);
+        writer.EnqueueViewRequest(ViewRequests.For(finalContext, s_emptyFilter, [logId]));
+
+        Task<OrderedViewSnapshot> drain = writer.DrainAsync();
+
+        blocking.Set();
+
+        OrderedViewSnapshot snapshot = await drain.WaitAsync(OrderedViewTestTimeouts.Default, TestContext.Current.CancellationToken);
+
+        Assert.Null(writer.Faulted);
+        Assert.Equal(2, writer.BuildsStarted);
+
+        CombinedViewParityAsserts.AssertSnapshotOrderMatchesReference(snapshot, logId, events, finalContext);
+        return;
+
+        bool Predicate(EventLocator locator, IEventColumnReader columnReader)
+        {
+            if (Interlocked.Exchange(ref gateArmed, 0) == 1)
+            {
+                entered.Set();
+                blocking.Wait(OrderedViewTestTimeouts.Default);
+            }
+
+            return true;
+        }
+    }
+
+    [Fact]
+    public async Task RemoveLog_WithADeferredRequest_ReplacesItAndDropsTheClosedLogsRows()
+    {
+        EventLogId logA = EventLogId.Create();
+        EventLogId logB = EventLogId.Create();
+        var events = MakeEvents(120);
+        IEventColumnReader readerA = EventColumnStore.Build(events, generation: 0, contentVersion: 0).CreateReader(logA);
+        IEventColumnReader readerB = EventColumnStore.Build(events, generation: 0, contentVersion: 0).CreateReader(logB);
+
+        using var blocking = new ManualResetEventSlim(false);
+        using var entered = new ManualResetEventSlim(false);
+        int gateArmed = 1;
+
+        await using var writer = new OrderedViewWriter(publishEvery: 16, publishIntervalMs: 4);
+
+        writer.EnqueueReconcile(logA, readerA);
+        writer.EnqueueReconcile(logB, readerB);
+
+        writer.EnqueueViewRequest(ViewRequests.For(
+            new SortContext(ColumnName.Level, false, null, false), s_emptyFilter, [logA, logB], Predicate));
+
+        Assert.True(entered.Wait(OrderedViewTestTimeouts.Default, TestContext.Current.CancellationToken));
+
+        writer.EnqueueViewRequest(ViewRequests.For(
+            new SortContext(ColumnName.Source, true, null, false), s_emptyFilter, [logA, logB]));
+
+        writer.EnqueueRemoveLog(logB);
+
+        blocking.Set();
+
+        OrderedViewSnapshot snapshot = await writer.DrainAsync();
+
+        Assert.Null(writer.Faulted);
+        Assert.Equal(2, writer.BuildsStarted);
+
+        Assert.Equal(events.Count, snapshot.Count);
+
+        for (int i = 0; i < snapshot.Count; i++) { Assert.Equal(logA, snapshot.At(i).Locator.LogId); }
+
+        return;
+
+        bool Predicate(EventLocator locator, IEventColumnReader columnReader)
+        {
+            if (Interlocked.Exchange(ref gateArmed, 0) == 1)
+            {
+                entered.Set();
+                blocking.Wait(OrderedViewTestTimeouts.Default);
+            }
+
+            return true;
+        }
+    }
+
+    [Fact]
+    public async Task ScopeSwitchStorm_BoundsRunningAndQueuedBuilds_WhileAdoptingLatest()
+    {
+        EventLogId logId = EventLogId.Create();
+        var events = MakeEvents(200);
+        IEventColumnReader reader = EventColumnStore.Build(events, generation: 0, contentVersion: 0).CreateReader(logId);
+
+        using var blocking = new ManualResetEventSlim(false);
+        using var entered = new ManualResetEventSlim(false);
+        int gateArmed = 1;
+
+        await using var writer = new OrderedViewWriter(publishEvery: 16, publishIntervalMs: 4);
+
+        writer.EnqueueReconcile(logId, reader);
+
+        writer.EnqueueViewRequest(ViewRequests.For(
+            new SortContext(ColumnName.Level, false, null, false), s_emptyFilter, [logId], Predicate));
+
+        Assert.True(entered.Wait(OrderedViewTestTimeouts.Default, TestContext.Current.CancellationToken),
+            "The first build never started, so the storm below would not exercise the bound.");
+
+        ColumnName[] storm = [ColumnName.EventId, ColumnName.Source, ColumnName.DateAndTime, ColumnName.Level, ColumnName.Source];
+        var finalContext = new SortContext(ColumnName.Source, true, null, false);
+
+        for (int i = 0; i < storm.Length - 1; i++)
+        {
+            writer.EnqueueViewRequest(ViewRequests.For(new SortContext(storm[i], i % 2 == 0, null, false), s_emptyFilter, [logId]));
+        }
+
+        writer.EnqueueViewRequest(ViewRequests.For(finalContext, s_emptyFilter, [logId]));
+
+        blocking.Set();
+
+        OrderedViewSnapshot snapshot = await writer.DrainAsync();
+
+        Assert.Null(writer.Faulted);
+
+        Assert.Equal(2, writer.BuildsStarted);
+        CombinedViewParityAsserts.AssertSnapshotOrderMatchesReference(snapshot, logId, events, finalContext);
+        return;
+
+        bool Predicate(EventLocator locator, IEventColumnReader columnReader)
+        {
+            if (Interlocked.Exchange(ref gateArmed, 0) == 1)
+            {
+                entered.Set();
+                blocking.Wait(OrderedViewTestTimeouts.Default);
+            }
+
+            return true;
+        }
+    }
+
+    [Fact]
+    public async Task UncancelledOperationCanceledException_IsSurfacedAsAFault()
+    {
+        EventLogId logId = EventLogId.Create();
+        var events = MakeEvents(50);
+        IEventColumnReader reader = EventColumnStore.Build(events, generation: 0, contentVersion: 0).CreateReader(logId);
+
+        await using var writer = new OrderedViewWriter(publishEvery: 16, publishIntervalMs: 4);
+
+        writer.EnqueueReconcile(logId, reader);
+
+        writer.EnqueueViewRequest(ViewRequests.For(
+            new SortContext(ColumnName.Level, false, null, false),
+            s_emptyFilter,
+            [logId],
+            static (_, _) => throw new OperationCanceledException("predicate threw OCE without any cancellation")));
+
+        await writer.DrainAsync();
+
+        Assert.NotNull(writer.Faulted);
+        Assert.IsType<OperationCanceledException>(writer.Faulted);
+    }
+
+    private static EventColumnStore EnqueueGrowingReconciles(
+        OrderedViewWriter writer,
+        EventLogId logId,
+        EventColumnStore store,
+        List<ResolvedEvent> events,
+        int fromIndex,
+        int toIndex,
+        int chunkSize)
+    {
+        for (int from = fromIndex; from < toIndex; from += chunkSize)
+        {
+            store = store.Append(events.GetRange(from, Math.Min(chunkSize, toIndex - from)));
+            writer.EnqueueReconcile(logId, store.CreateReader(logId));
+        }
+
+        return store;
+    }
+
+    private static List<ResolvedEvent> MakeEvents(int count)
+    {
+        var rng = new Random(20260728);
+        var clock = new DateTime(2026, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+        string[] sources = ["Provider.A", "Provider.B", "Provider.C", "Provider.D"];
+        string[] levels = ["Information", "Warning", "Error", "Critical"];
+        var events = new List<ResolvedEvent>(count);
+
+        for (int i = 0; i < count; i++)
+        {
+            clock = clock.AddMilliseconds(1 + rng.Next(10));
+
+            events.Add(new ResolvedEvent("Log", LogPathType.Channel)
+            {
+                RecordId = i + 1,
+                TimeCreated = clock,
+                Id = 1000 + rng.Next(5),
+                Level = levels[rng.Next(levels.Length)],
+                Source = sources[rng.Next(sources.Length)],
+                LogName = "Channel"
+            });
+        }
+
+        return events;
+    }
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/OrderedViewBulkBuildTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/OrderedViewBulkBuildTests.cs
new file mode 100644
index 000000000..28537ff52
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/OrderedViewBulkBuildTests.cs
@@ -0,0 +1,550 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.Channels;
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
+using EventLogExpert.Runtime.LogTable;
+using EventLogExpert.Runtime.LogTable.OrderedView;
+using System.Security.Principal;
+
+namespace EventLogExpert.Runtime.Tests.LogTable.OrderedView;
+
+public sealed class OrderedViewBulkBuildTests
+{
+    private static readonly ColumnName[] s_everyGroupColumn =
+    [
+        ColumnName.RecordId,
+        ColumnName.Level,
+        ColumnName.DateAndTime,
+        ColumnName.ActivityId,
+        ColumnName.Log,
+        ColumnName.ComputerName,
+        ColumnName.Source,
+        ColumnName.EventId,
+        ColumnName.TaskCategory,
+        ColumnName.Keywords,
+        ColumnName.ProcessId,
+        ColumnName.ThreadId,
+        ColumnName.User
+    ];
+    private static readonly ColumnName?[] s_groupBys =
+    [
+        null,
+        ColumnName.Source,
+        ColumnName.Level,
+        ColumnName.User,
+        ColumnName.EventId,
+        ColumnName.Keywords
+    ];
+    private static readonly ColumnName?[] s_orderBys =
+    [
+        null,
+        ColumnName.RecordId,
+        ColumnName.DateAndTime,
+        ColumnName.EventId,
+        ColumnName.Level,
+        ColumnName.Source,
+        ColumnName.TaskCategory,
+        ColumnName.ComputerName,
+        ColumnName.ActivityId,
+        ColumnName.ProcessId,
+        ColumnName.ThreadId,
+        ColumnName.Log,
+        ColumnName.User,
+        ColumnName.Keywords
+    ];
+
+    [Fact]
+    public void BulkAdopt_ReplaysTailArrivingBeforeAdopt_MatchesIncremental()
+    {
+        var sample = new OrderedViewSample(seed: 7788, logCount: 1);
+        sample.SeedInterleaved(totalEvents: 3000);
+        EventLogId logId = sample.LogId(0);
+
+        foreach (SortContext context in new[] { ByDate(), Physical(), Grouped(), ByDate(descending: true) })
+        {
+            IEventColumnReader seedReader = sample.PrefixReader(0, 2000);
+            IEventColumnReader grownReader = sample.PrefixReader(0, 3000);
+
+            OrderedViewSnapshot bulk = AdoptWithTailReplay(logId, seedReader, grownReader, context, bulkThreshold: 0);
+            OrderedViewSnapshot incremental = AdoptWithTailReplay(logId, seedReader, grownReader, context, bulkThreshold: int.MaxValue);
+
+            AssertSnapshotsEqual(incremental, bulk, $"tail-replay {Describe(context)}");
+        }
+    }
+
+    [Fact]
+    public void BulkAdopt_ThenLiveTailGrowth_MatchesIncrementalGrowth()
+    {
+        var sample = new OrderedViewSample(seed: 4242, logCount: 1);
+        sample.SeedInterleaved(totalEvents: 3000);
+        EventLogId logId = sample.LogId(0);
+
+        foreach (SortContext context in new[] { ByDate(), Physical(), Grouped(), ByDate(descending: true) })
+        {
+            IEventColumnReader seedReader = sample.PrefixReader(0, 2000);
+            IEventColumnReader grownReader = sample.PrefixReader(0, 3000);
+
+            OrderedViewSnapshot bulk = GrowAndPublish(logId, seedReader, grownReader, context, bulkThreshold: 0);
+            OrderedViewSnapshot incremental = GrowAndPublish(logId, seedReader, grownReader, context, bulkThreshold: int.MaxValue);
+
+            AssertSnapshotsEqual(incremental, bulk, $"grown {Describe(context)}");
+        }
+    }
+
+    [Fact]
+    public void BulkPath_IsReachedAndAgreesWithIncremental_AtForcedThreshold()
+    {
+        var sample = new OrderedViewSample(seed: 555, logCount: 1);
+        sample.SeedInterleaved(totalEvents: 300);
+        IEventColumnReader reader = sample.Reader(0);
+        EventLogId logId = sample.LogId(0);
+
+        var state = new OrderedViewState();
+        state.ReconcileLog(logId, reader);
+        RebuildRequest request = state.BeginRebuild(static (_, _) => true, Grouped());
+
+        ChunkedOrderIndex bulk = OrderedViewState.BuildIndex(request, CancellationToken.None, bulkThreshold: 0);
+        ChunkedOrderIndex incremental = OrderedViewState.BuildIndex(request, CancellationToken.None, int.MaxValue);
+
+        Assert.Equal(incremental.Count, bulk.Count);
+        Assert.True(bulk.Count > 0);
+    }
+
+    [Theory]
+    [InlineData(101)]
+    [InlineData(2027)]
+    public void Bulk_MatchesIncremental_AcrossTheSortCrossProduct(int seed)
+    {
+        var sample = new OrderedViewSample(seed, logCount: 1);
+        sample.SeedInterleaved(totalEvents: 400);
+        IEventColumnReader reader = sample.Reader(0);
+        EventLogId logId = sample.LogId(0);
+
+        foreach (SortContext context in AllContexts())
+        {
+            AssertBulkMatchesIncremental(reader, logId, static (_, _) => true, context, $"seed={seed} {Describe(context)}");
+        }
+    }
+
+    [Theory]
+    [InlineData(1)]
+    [InlineData(2)]
+    [InlineData(1023)]
+    [InlineData(1024)]
+    [InlineData(1025)]
+    [InlineData(2049)]
+    public void Bulk_MatchesIncremental_AtChunkBoundaries(int rows)
+    {
+        var sample = new OrderedViewSample(seed: 71, logCount: 1);
+        sample.SeedInterleaved(rows);
+        IEventColumnReader reader = sample.Reader(0);
+        EventLogId logId = sample.LogId(0);
+
+        AssertBulkMatchesIncremental(reader, logId, static (_, _) => true, ByDate(), $"rows={rows} ByDate");
+        AssertBulkMatchesIncremental(reader, logId, static (_, _) => true, Grouped(), $"rows={rows} Grouped");
+    }
+
+    [Fact]
+    public void Bulk_MatchesIncremental_EqualTicksAcrossDateTimeKind()
+    {
+        var shared = new DateTime(2026, 3, 4, 5, 6, 7, DateTimeKind.Utc);
+        var events = new List<ResolvedEvent>();
+
+        for (int i = 0; i < 60; i++)
+        {
+            DateTimeKind kind = i % 3 == 0 ? DateTimeKind.Unspecified : i % 3 == 1 ? DateTimeKind.Local : DateTimeKind.Utc;
+
+            events.Add(new ResolvedEvent("KindLog", LogPathType.Channel)
+            {
+                RecordId = i % 5 == 0 ? null : i,
+                TimeCreated = DateTime.SpecifyKind(shared, kind),
+                Id = 1000 + (i % 4),
+                Level = i % 2 == 0 ? "" : "Error",
+                Source = $"Provider.{i % 3}"
+            });
+        }
+
+        (IEventColumnReader reader, EventLogId logId) = BuildReader(events);
+
+        foreach (SortContext context in new[] { ByDate(), ByDate(descending: true), Grouped() })
+        {
+            AssertBulkMatchesIncremental(reader, logId, static (_, _) => true, context, $"mixed-kind {Describe(context)}");
+        }
+    }
+
+    [Theory]
+    [InlineData(3110)]
+    public void Bulk_MatchesIncremental_ForEveryGroupColumn(int seed)
+    {
+        var sample = new OrderedViewSample(seed, logCount: 1);
+        sample.SeedInterleaved(totalEvents: 400);
+        IEventColumnReader reader = sample.Reader(0);
+        EventLogId logId = sample.LogId(0);
+
+        foreach (ColumnName groupBy in s_everyGroupColumn)
+        {
+            foreach (bool groupDescending in new[] { false, true })
+            {
+                var context = new SortContext(null, false, groupBy, groupDescending);
+                AssertBulkMatchesIncremental(reader, logId, static (_, _) => true, context, $"everyGroup {Describe(context)}");
+            }
+        }
+    }
+
+    [Fact]
+    public void Bulk_MatchesIncremental_MixedNullEmptyAndValueInGroupColumn()
+    {
+        var events = new List<ResolvedEvent>();
+
+        for (int i = 0; i < 200; i++)
+        {
+            string level = (i % 3) switch { 0 => "", 1 => "Warning", _ => "Error" };
+
+            events.Add(new ResolvedEvent("MixLog", LogPathType.Channel)
+            {
+                RecordId = i % 4 == 0 ? null : i,
+                TimeCreated = new DateTime(2026, 1, 1, 0, 0, 0, DateTimeKind.Utc).AddSeconds(i % 17),
+                Id = 1000 + (i % 6),
+                Level = level,
+                Source = i % 5 == 0 ? "" : $"Src.{i % 7}",
+                TaskCategory = i % 2 == 0 ? "" : "Logon"
+            });
+        }
+
+        (IEventColumnReader reader, EventLogId logId) = BuildReader(events);
+
+        foreach (SortContext context in AllContexts())
+        {
+            AssertBulkMatchesIncremental(reader, logId, static (_, _) => true, context, $"mixed-null {Describe(context)}");
+        }
+    }
+
+    [Fact]
+    public void Bulk_MatchesIncremental_WithGenuineNullPooledStringAndDuplicatePools()
+    {
+        var first = new List<ResolvedEvent>();
+        var second = new List<ResolvedEvent>();
+        var sid = new SecurityIdentifier(WellKnownSidType.LocalSystemSid, null);
+
+        for (int i = 0; i < 130; i++)
+        {
+            (i < 65 ? first : second).Add(new ResolvedEvent("DupLog", LogPathType.Channel)
+            {
+                RecordId = i % 6 == 0 ? null : i,
+                TimeCreated = new DateTime(2026, 2, 2, 0, 0, 0, DateTimeKind.Utc).AddSeconds(i % 23),
+                Id = 1000 + (i % 5),
+                Level = i % 3 == 0 ? "" : "Error",
+                Source = $"Shared.{i % 4}",
+                UserId = i % 2 == 0 ? null : sid
+            });
+        }
+
+        EventLogId logId = EventLogId.Create();
+        IEventColumnReader reader = EventColumnStore.Build(first, 0, 0).Append(second).CreateReader(logId);
+
+        foreach (SortContext context in AllContexts())
+        {
+            AssertBulkMatchesIncremental(reader, logId, static (_, _) => true, context, $"dup-pool {Describe(context)}");
+        }
+    }
+
+    [Fact]
+    public void Bulk_MatchesIncremental_WithSparseFilteredSurvivors()
+    {
+        var sample = new OrderedViewSample(seed: 9021, logCount: 1);
+        sample.SeedInterleaved(totalEvents: 900);
+        IEventColumnReader reader = sample.Reader(0);
+        EventLogId logId = sample.LogId(0);
+
+        bool Predicate(EventLocator locator, IEventColumnReader _) => locator.Index % 7 == 0 || locator.Index > 850;
+
+        foreach (SortContext context in new[] { Physical(), ByDate(), Grouped() })
+        {
+            AssertBulkMatchesIncremental(reader, logId, Predicate, context, $"sparse {Describe(context)}");
+        }
+    }
+
+    [Fact]
+    public void CombinedBulkAdopt_ReplaysMultiLogTail_MatchesIncremental()
+    {
+        var sample = new OrderedViewSample(seed: 6161, logCount: 3);
+        sample.SeedInterleaved(totalEvents: 2400);
+
+        foreach (SortContext context in new[] { ByDate(), Physical(), Grouped() })
+        {
+            OrderedViewSnapshot bulk = AdoptCombinedWithTailReplay(sample, context, bulkThreshold: 0);
+            OrderedViewSnapshot incremental = AdoptCombinedWithTailReplay(sample, context, bulkThreshold: int.MaxValue);
+
+            AssertSnapshotsEqual(incremental, bulk, $"combined tail-replay {Describe(context)}");
+        }
+    }
+
+    [Fact]
+    public void CombinedBulk_HonorsCancellation()
+    {
+        var sample = new OrderedViewSample(seed: 3737, logCount: 12);
+        sample.SeedInterleaved(totalEvents: 6000);
+
+        var state = new OrderedViewState();
+        for (int k = 0; k < sample.LogCount; k++) { state.ReconcileLog(sample.LogId(k), sample.Reader(k)); }
+
+        RebuildRequest request = state.BeginRebuild(static (_, _) => true, ByDate());
+
+        using var cancelled = new CancellationTokenSource();
+        cancelled.Cancel();
+
+        Assert.Throws<OperationCanceledException>(
+            () => OrderedViewState.BuildIndex(request, cancelled.Token, bulkThreshold: 0));
+    }
+
+    [Theory]
+    [InlineData(2, 909)]
+    [InlineData(3, 606)]
+    [InlineData(4, 4004)]
+    public void CombinedBulk_MatchesIncremental_AcrossCrossProduct(int logCount, int seed)
+    {
+        var sample = new OrderedViewSample(seed, logCount);
+        sample.SeedInterleaved(totalEvents: 500);
+        var logs = ReadersOf(sample);
+
+        foreach (SortContext context in AllContexts())
+        {
+            AssertCombinedBulkMatchesIncremental(logs, static (_, _) => true, context, $"combined k={logCount} {Describe(context)}");
+        }
+    }
+
+    [Fact]
+    public void CombinedBulk_MatchesIncremental_SameOwningLogDistinctLogId()
+    {
+        var first = new List<ResolvedEvent>();
+        var second = new List<ResolvedEvent>();
+        var shared = new DateTime(2026, 5, 5, 0, 0, 0, DateTimeKind.Utc);
+
+        for (int i = 0; i < 120; i++)
+        {
+            var row = new ResolvedEvent("SharedName", LogPathType.Channel)
+            {
+                RecordId = null,
+                TimeCreated = shared,
+                Id = 1000,
+                Level = "Error",
+                Source = "Provider.X"
+            };
+            first.Add(row);
+            second.Add(row);
+        }
+
+        EventLogId logIdA = EventLogId.Create();
+        EventLogId logIdB = EventLogId.Create();
+        var logs = new[]
+        {
+            (logIdA, EventColumnStore.Build(first, 0, 0).CreateReader(logIdA)),
+            (logIdB, EventColumnStore.Build(second, 0, 0).CreateReader(logIdB))
+        };
+
+        foreach (SortContext context in new[] { ByDate(), Physical(), Grouped(), ByDate(descending: true) })
+        {
+            AssertCombinedBulkMatchesIncremental(logs, static (_, _) => true, context, $"same-owninglog {Describe(context)}");
+        }
+    }
+
+    [Fact]
+    public void CombinedBulk_MatchesIncremental_WithSparseFiltersAndAnEmptyAndSingleSurvivorLog()
+    {
+        var sample = new OrderedViewSample(seed: 8123, logCount: 3);
+        sample.SeedInterleaved(totalEvents: 600);
+        var logs = ReadersOf(sample);
+        EventLogId log0 = logs[0].LogId;
+        EventLogId log1 = logs[1].LogId;
+
+        bool Predicate(EventLocator locator, IEventColumnReader _) =>
+            (locator.LogId == log0 && (locator.Index % 5 == 0 || locator.Index > 180)) ||
+            (locator.LogId == log1 && locator.Index == 3);
+
+        foreach (SortContext context in new[] { ByDate(), Grouped() })
+        {
+            AssertCombinedBulkMatchesIncremental(logs, Predicate, context, $"combined-sparse {Describe(context)}");
+        }
+    }
+
+    private static OrderedViewSnapshot AdoptCombinedWithTailReplay(OrderedViewSample sample, SortContext context, int bulkThreshold)
+    {
+        var state = new OrderedViewState();
+
+        for (int k = 0; k < sample.LogCount; k++)
+        {
+            state.ReconcileLog(sample.LogId(k), sample.PrefixReader(k, sample.Events(k).Count - 200));
+        }
+
+        RebuildRequest request = state.BeginRebuild(static (_, _) => true, context);
+
+        for (int k = 0; k < sample.LogCount; k++) { state.ReconcileLog(sample.LogId(k), sample.Reader(k)); }
+
+        Assert.True(state.TryAdoptRebuild(request, OrderedViewState.BuildIndex(request, CancellationToken.None, bulkThreshold)));
+
+        return state.Publish();
+    }
+
+    private static OrderedViewSnapshot AdoptWithTailReplay(
+        EventLogId logId,
+        IEventColumnReader seedReader,
+        IEventColumnReader grownReader,
+        SortContext context,
+        int bulkThreshold)
+    {
+        var state = new OrderedViewState();
+        state.ReconcileLog(logId, seedReader);
+        RebuildRequest request = state.BeginRebuild(static (_, _) => true, context);
+        state.ReconcileLog(logId, grownReader);
+        Assert.True(state.TryAdoptRebuild(request, OrderedViewState.BuildIndex(request, CancellationToken.None, bulkThreshold)));
+
+        return state.Publish();
+    }
+
+    private static IEnumerable<SortContext> AllContexts()
+    {
+        foreach (ColumnName? groupBy in s_groupBys)
+        {
+            foreach (ColumnName? orderBy in s_orderBys)
+            {
+                foreach (bool descending in new[] { false, true })
+                {
+                    if (groupBy is null)
+                    {
+                        yield return new SortContext(orderBy, descending, null, false);
+                    }
+                    else
+                    {
+                        foreach (bool groupDescending in new[] { false, true })
+                        {
+                            yield return new SortContext(orderBy, descending, groupBy, groupDescending);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    private static void AssertBulkMatchesIncremental(
+        IEventColumnReader reader,
+        EventLogId logId,
+        Func<EventLocator, IEventColumnReader, bool> predicate,
+        SortContext context,
+        string label)
+    {
+        var state = new OrderedViewState();
+        state.ReconcileLog(logId, reader);
+        RebuildRequest request = state.BeginRebuild(predicate, context);
+
+        ChunkedOrderIndex incremental = OrderedViewState.BuildIndex(request, CancellationToken.None, int.MaxValue);
+        ChunkedOrderIndex bulk = OrderedViewState.BuildIndex(request, CancellationToken.None, bulkThreshold: 0);
+
+        IComparer<OrderKey> comparer = OrderKeyComparerFactory.Create(context, request.BeginResolver);
+        OrderedViewSnapshot incrementalSnapshot = incremental.Publish(comparer, 0);
+        OrderedViewSnapshot bulkSnapshot = bulk.Publish(comparer, 0);
+        AssertSnapshotsEqual(incrementalSnapshot, bulkSnapshot, label);
+
+        for (int index = 0; index < reader.Count; index++)
+        {
+            Assert.Equal(
+                incrementalSnapshot.Contains(logId, reader.Generation, index),
+                bulkSnapshot.Contains(logId, reader.Generation, index));
+        }
+    }
+
+    private static void AssertCombinedBulkMatchesIncremental(
+        IReadOnlyList<(EventLogId LogId, IEventColumnReader Reader)> logs,
+        Func<EventLocator, IEventColumnReader, bool> predicate,
+        SortContext context,
+        string label)
+    {
+        var state = new OrderedViewState();
+        foreach ((EventLogId logId, IEventColumnReader reader) in logs) { state.ReconcileLog(logId, reader); }
+
+        RebuildRequest request = state.BeginRebuild(predicate, context);
+
+        ChunkedOrderIndex incremental = OrderedViewState.BuildIndex(request, CancellationToken.None, int.MaxValue);
+        ChunkedOrderIndex bulk = OrderedViewState.BuildIndex(request, CancellationToken.None, bulkThreshold: 0);
+
+        IComparer<OrderKey> comparer = OrderKeyComparerFactory.Create(context, request.BeginResolver);
+        OrderedViewSnapshot incrementalSnapshot = incremental.Publish(comparer, 0);
+        OrderedViewSnapshot bulkSnapshot = bulk.Publish(comparer, 0);
+        AssertSnapshotsEqual(incrementalSnapshot, bulkSnapshot, label);
+
+        foreach ((EventLogId logId, IEventColumnReader reader) in logs)
+        {
+            for (int index = 0; index < reader.Count; index++)
+            {
+                Assert.Equal(
+                    incrementalSnapshot.Contains(logId, reader.Generation, index),
+                    bulkSnapshot.Contains(logId, reader.Generation, index));
+            }
+        }
+    }
+
+    private static void AssertSnapshotsEqual(OrderedViewSnapshot expected, OrderedViewSnapshot actual, string label)
+    {
+        Assert.Equal(expected.Count, actual.Count);
+
+        for (int display = 0; display < expected.Count; display++)
+        {
+            EventLocator expectedLocator = expected.At(display).Locator;
+            EventLocator actualLocator = actual.At(display).Locator;
+
+            Assert.True(
+                expectedLocator == actualLocator,
+                $"{label}: display[{display}] expected {expectedLocator} but bulk gave {actualLocator}");
+
+            Assert.Equal(display, actual.RankOf(new OrderKey(expectedLocator)));
+            Assert.True(actual.Contains(expectedLocator.LogId, expectedLocator.Generation, expectedLocator.Index), label);
+        }
+
+        Assert.Equal(-1, actual.RankOf(new OrderKey(new EventLocator(EventLogId.Create(), 0, 0))));
+    }
+
+    private static (IEventColumnReader Reader, EventLogId LogId) BuildReader(IReadOnlyList<ResolvedEvent> events)
+    {
+        EventLogId logId = EventLogId.Create();
+
+        return (EventColumnStore.Build(events, 0, 0).CreateReader(logId), logId);
+    }
+
+    private static SortContext ByDate(bool descending = false) => new(ColumnName.DateAndTime, descending, null, false);
+
+    private static string Describe(SortContext context) =>
+        $"order={context.OrderBy?.ToString() ?? "none"}{(context.IsDescending ? " desc" : "")} " +
+        $"group={context.GroupBy?.ToString() ?? "none"}{(context.IsGroupDescending ? " desc" : "")}";
+
+    private static SortContext Grouped() => new(ColumnName.DateAndTime, false, ColumnName.Source, false);
+
+    private static OrderedViewSnapshot GrowAndPublish(
+        EventLogId logId,
+        IEventColumnReader seedReader,
+        IEventColumnReader grownReader,
+        SortContext context,
+        int bulkThreshold)
+    {
+        var state = new OrderedViewState();
+        state.ReconcileLog(logId, seedReader);
+        RebuildRequest request = state.BeginRebuild(static (_, _) => true, context);
+        Assert.True(state.TryAdoptRebuild(request, OrderedViewState.BuildIndex(request, CancellationToken.None, bulkThreshold)));
+        state.Publish();
+
+        state.ReconcileLog(logId, grownReader);
+
+        return state.Publish();
+    }
+
+    private static SortContext Physical() => new(null, false, null, false);
+
+    private static (EventLogId LogId, IEventColumnReader Reader)[] ReadersOf(OrderedViewSample sample)
+    {
+        var logs = new (EventLogId, IEventColumnReader)[sample.LogCount];
+
+        for (int k = 0; k < sample.LogCount; k++) { logs[k] = (sample.LogId(k), sample.Reader(k)); }
+
+        return logs;
+    }
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/OrderedViewCombinedRoutingTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/OrderedViewCombinedRoutingTests.cs
new file mode 100644
index 000000000..b3fe7b0a8
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/OrderedViewCombinedRoutingTests.cs
@@ -0,0 +1,594 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
+using EventLogExpert.Filtering.Persistence;
+using EventLogExpert.Runtime.EventLog;
+using EventLogExpert.Runtime.LogTable;
+using EventLogExpert.Runtime.LogTable.OrderedView;
+using EventLogExpert.Runtime.Tests.LogTable.TestSupport;
+using NSubstitute;
+using System.Collections.Immutable;
+using Reducers = EventLogExpert.Runtime.LogTable.Reducers;
+using static EventLogExpert.Runtime.Tests.LogTable.OrderedView.CombinedViewParityAsserts;
+using static EventLogExpert.Runtime.Tests.TestUtils.RetainedViewTestFactory;
+
+namespace EventLogExpert.Runtime.Tests.LogTable.OrderedView;
+
+public sealed class OrderedViewCombinedRoutingTests
+{
+    [Fact]
+    public async Task ARetainedCombinedView_IsRefusedByASingleLogTabCoveringTheSameLogs()
+    {
+        CombinedRoutedSetup setup = await BuildAllLogsAsync(seed: 331, logCount: 1, events: 60, emptyLogs: 1);
+        EventLogId logA = setup.LogIds[0];
+        OrderedViewReady served = setup.Routed.ActiveOrderedView!;
+
+        Assert.Null(served.SingleLogId);
+
+        LogTableState switchedToMember = setup.Routed with
+        {
+            ActiveEventLogId = logA,
+            ActiveOrderedView = null,
+            RetainedOrderedViews = RetainedMap(served)
+        };
+
+        Assert.Same(EmptyColumnView.Instance, switchedToMember.EventsForLog(logA));
+        Assert.False(switchedToMember.IsRetainedViewServable(logA));
+    }
+
+    [Fact]
+    public async Task ARetainedCombinedView_StillServesItsOwnTabWhenAMemberIsEmpty()
+    {
+        CombinedRoutedSetup setup = await BuildAllLogsAsync(seed: 330, logCount: 2, events: 90, emptyLogs: 1);
+        OrderedViewReady served = setup.Routed.ActiveOrderedView!;
+
+        Assert.DoesNotContain(setup.EmptyLogIds[0], served.InScope.Select(member => member.LogId));
+        Assert.Contains(setup.EmptyLogIds[0], served.Identity!.Scope);
+
+        LogTableState retaining = setup.Routed with { ActiveOrderedView = null, RetainedOrderedViews = RetainedMap(served) };
+
+        Assert.True(retaining.IsRetainedViewServable(retaining.ActiveEventLogId!.Value));
+    }
+
+    [Fact]
+    public async Task AllLogsTab_DisplayFaulted_KeepsShowingTheRowsItWasShowing()
+    {
+        CombinedRoutedSetup setup = await BuildAllLogsAsync(seed: 301, logCount: 3, events: 90, emptyLogs: 0);
+
+        IEventColumnView beforeFault = setup.Routed.GetActiveDisplayedEvents();
+
+        LogTableState faulted = Reducers.ReduceOrderedViewDisplayFaulted(setup.Routed, Faults.Any);
+
+        Assert.Null(faulted.ActiveOrderedView);
+        Assert.Equal(PresentationState.Faulted, faulted.PresentationState);
+        Assert.Same(beforeFault, faulted.GetActiveDisplayedEvents());
+    }
+
+    [Fact]
+    public async Task AllLogsTab_GroupedDisplay_ServesEngineCombinedViewWithGroupParity()
+    {
+        CombinedRoutedSetup setup = await BuildAllLogsAsync(
+            seed: 302, logCount: 3, events: 90, emptyLogs: 0, groupBy: ColumnName.Source);
+
+        IEventColumnView routed = setup.Routed.GetActiveDisplayedEvents();
+
+        Assert.IsType<CombinedOrderedColumnView>(routed);
+        AssertOrderMatchesReference(routed, setup.PerLog, setup.Routed.SortContext);
+    }
+
+    [Fact]
+    public async Task AllLogsTab_NewlyOpenedLogNotYetInScope_StopsServingUntilTheScopeCatchesUp()
+    {
+        CombinedRoutedSetup setup = await BuildAllLogsAsync(seed: 303, logCount: 3, events: 90, emptyLogs: 0);
+
+        LogTableState opening = setup.Routed with
+        {
+            EventTables = setup.Routed.EventTables.Add(new LogView(EventLogId.Create()))
+        };
+
+        Assert.Same(EmptyColumnView.Instance, opening.GetActiveDisplayedEvents());
+    }
+
+    [Fact]
+    public async Task AllLogsTab_PendingGroupChange_StopsServingTheViewBuiltUnderTheOldGrouping()
+    {
+        CombinedRoutedSetup setup = await BuildAllLogsAsync(seed: 302, logCount: 3, events: 90, emptyLogs: 0);
+
+        IEventColumnView beforeRegroup = setup.Routed.GetActiveDisplayedEvents();
+
+        LogTableState pending = Reducers.ReduceSetGroupBy(setup.Routed, new SetGroupByAction(ColumnName.Source));
+
+        Assert.True(pending.HasPendingSortChange);
+
+        Assert.Equal(PresentationState.Updating, pending.PresentationState);
+        Assert.Same(beforeRegroup, pending.GetActiveDisplayedEvents());
+
+        Assert.True(pending.OrderingIsStale);
+    }
+
+    [Fact]
+    public async Task AllLogsTab_PendingSortChange_KeepsShowingTheOrderItAlreadyBuilt()
+    {
+        CombinedRoutedSetup setup = await BuildAllLogsAsync(seed: 304, logCount: 3, events: 90, emptyLogs: 0);
+
+        IEventColumnView beforeResort = setup.Routed.GetActiveDisplayedEvents();
+
+        LogTableState resorting = Reducers.ReduceToggleSorting(setup.Routed);
+
+        Assert.True(resorting.HasPendingSortChange);
+        Assert.Equal(PresentationState.Updating, resorting.PresentationState);
+        Assert.Same(beforeResort, resorting.GetActiveDisplayedEvents());
+        Assert.True(resorting.OrderingIsStale);
+    }
+
+    [Fact]
+    public async Task AllLogsTab_RequestSuperseded_ClearsRoutedViewAndBridgesWithWhatWasOnScreen()
+    {
+        CombinedRoutedSetup setup = await BuildAllLogsAsync(seed: 305, logCount: 3, events: 90, emptyLogs: 0);
+
+        IEventColumnView beforeInvalidation = setup.Routed.GetActiveDisplayedEvents();
+
+        LogTableState resacoped = Reducers.ReduceViewRequestInvalidated(
+            setup.Routed,
+            new ViewRequestInvalidatedAction(setup.Routed.HighestInvalidationSequence + 1));
+
+        Assert.Null(resacoped.ActiveOrderedView);
+        Assert.Equal(PresentationState.Updating, resacoped.PresentationState);
+        Assert.Same(beforeInvalidation, resacoped.GetActiveDisplayedEvents());
+    }
+
+    [Fact]
+    public async Task AllLogsTab_ServesEngineCombinedViewWithFullParityToAnIndependentReference()
+    {
+        CombinedRoutedSetup setup = await BuildAllLogsAsync(seed: 306, logCount: 3, events: 120, emptyLogs: 0);
+
+        IEventColumnView routedView = setup.Routed.GetActiveDisplayedEvents();
+
+        Assert.IsType<CombinedOrderedColumnView>(routedView);
+        Assert.True(routedView.Count > 0);
+        AssertOrderMatchesReference(routedView, setup.PerLog, setup.Routed.SortContext);
+    }
+
+    [Fact]
+    public async Task AllLogsTab_StaleAppliedFilter_StopsServingTheViewBuiltUnderTheOldFilter()
+    {
+        CombinedRoutedSetup setup = await BuildAllLogsAsync(seed: 307, logCount: 3, events: 90, emptyLogs: 0);
+
+        SavedFilter levelError = SavedFilter.TryCreate("Level == \"Error\"") ??
+            throw new InvalidOperationException("Level filter failed to compile.");
+        LogTableState filterChanged = setup.Routed with { AppliedFilter = new Filter(null, [levelError]) };
+
+        Assert.Same(EmptyColumnView.Instance, filterChanged.GetActiveDisplayedEvents());
+    }
+
+    [Fact]
+    public async Task AllLogsTab_WithAnEmptyOpenLog_StillServesEngine()
+    {
+        CombinedRoutedSetup setup = await BuildAllLogsAsync(seed: 308, logCount: 2, events: 90, emptyLogs: 1);
+
+        IEventColumnView routedView = setup.Routed.GetActiveDisplayedEvents();
+
+        Assert.Equal(4, setup.Routed.EventTables.Count);
+        Assert.Contains(setup.EmptyLogIds[0], setup.Routed.ViewIdentity.Scope);
+        Assert.IsType<CombinedOrderedColumnView>(routedView);
+        Assert.True(routedView.Count > 0);
+        AssertOrderMatchesReference(routedView, setup.PerLog, setup.Routed.SortContext);
+    }
+
+    [Fact]
+    public async Task CombinedScopeWithOneNonEmptyMember_ReportsNoSingleLog_SoSuppressionCannotFireForIt()
+    {
+        CombinedRoutedSetup setup = await BuildAllLogsAsync(seed: 319, logCount: 1, events: 60, emptyLogs: 1);
+        EventLogId logA = setup.LogIds[0];
+
+        Assert.NotNull(setup.Routed.ActiveOrderedView);
+        Assert.Single(setup.Routed.ActiveOrderedView.InScope);
+        Assert.Null(setup.Routed.ActiveOrderedView.SingleLogId);
+        Assert.IsType<CombinedOrderedColumnView>(setup.Routed.GetActiveDisplayedEvents());
+
+        LogTableState switchedToMember = setup.Routed with { ActiveEventLogId = logA };
+
+        Assert.False(switchedToMember.IsOrderedViewServing(logA));
+        Assert.Same(EmptyColumnView.Instance, switchedToMember.EventsForLog(logA));
+    }
+
+    [Fact]
+    public async Task CombinedServing_NeverSatisfiesTheSingleLogSuppressionPredicate()
+    {
+        CombinedRoutedSetup allLogs = await BuildAllLogsAsync(seed: 310, logCount: 3, events: 90, emptyLogs: 0);
+
+        Assert.IsType<CombinedOrderedColumnView>(allLogs.Routed.GetActiveDisplayedEvents());
+
+        foreach (EventLogId memberId in allLogs.LogIds)
+        {
+            Assert.False(allLogs.Routed.IsOrderedViewServing(memberId));
+        }
+
+        GroupRoutedSetup oneMember = await BuildGroupAsync(seed: 311, logCount: 3, events: 90, memberCount: 1);
+
+        Assert.NotNull(oneMember.Routed.ActiveOrderedView);
+        Assert.Equal(oneMember.MemberIds[0], oneMember.Routed.ActiveOrderedView.SingleLogId);
+        Assert.False(oneMember.Routed.IsOrderedViewServing(oneMember.MemberIds[0]));
+    }
+
+    [Fact]
+    public async Task CombinedServing_OrdersRowsTheWayAnIndependentReferenceDoes()
+    {
+        CombinedRoutedSetup setup = await BuildAllLogsAsync(seed: 511, logCount: 3, events: 90, emptyLogs: 0);
+
+        IEventColumnView combined = setup.Routed.GetActiveDisplayedEvents();
+
+        Assert.IsType<CombinedOrderedColumnView>(combined);
+
+        AssertOrderMatchesReference(combined, setup.PerLog, setup.Routed.SortContext);
+    }
+
+    [Fact]
+    public async Task GroupTab_MembershipDivergesFromScope_StopsServingTheViewBuiltForTheOldMembership()
+    {
+        GroupRoutedSetup setup = await BuildGroupAsync(seed: 312, logCount: 3, events: 90, memberCount: 2);
+
+        LogTabGroup widened = setup.Group with { MemberIds = setup.Group.MemberIds.Add(setup.OutsiderId) };
+        LogTableState diverged = setup.Routed with { Groups = [widened] };
+
+        Assert.Same(EmptyColumnView.Instance, diverged.GetActiveDisplayedEvents());
+    }
+
+    [Fact]
+    public async Task GroupTab_NotTheActiveTab_IsNeverGivenTheActiveTabsView()
+    {
+        GroupRoutedSetup setup = await BuildGroupAsync(seed: 313, logCount: 3, events: 90, memberCount: 2);
+
+        LogTableState background = setup.Routed with { ActiveEventLogId = setup.OutsiderId };
+
+        Assert.Same(EmptyColumnView.Instance, background.DisplayedEventsForTab(setup.Header));
+    }
+
+    [Fact]
+    public async Task GroupTab_OneMember_ServesTheEngineSingleLogViewWithParity()
+    {
+        GroupRoutedSetup setup = await BuildGroupAsync(seed: 314, logCount: 3, events: 90, memberCount: 1);
+
+        IEventColumnView routedView = setup.Routed.GetActiveDisplayedEvents();
+
+        Assert.IsType<OrderedColumnView>(routedView);
+        Assert.True(routedView.Count > 0);
+        AssertOrderMatchesReference(routedView, setup.PerLog, setup.Routed.SortContext);
+    }
+
+    [Fact]
+    public async Task GroupTab_SubsetOfOpenLogs_ServesEngineCombinedViewWithFullParityToAnIndependentReference()
+    {
+        GroupRoutedSetup setup = await BuildGroupAsync(seed: 315, logCount: 3, events: 120, memberCount: 2);
+
+        IEventColumnView routedView = setup.Routed.GetActiveDisplayedEvents();
+
+        Assert.IsType<CombinedOrderedColumnView>(routedView);
+        Assert.True(routedView.Count > 0);
+
+        Assert.True(routedView.Count < setup.AllLogsRowCount);
+        AssertOrderMatchesReference(routedView, setup.PerLog, setup.Routed.SortContext);
+    }
+
+    [Fact]
+    public void ScopeAdvance_RejectsARebuildCapturedUnderThePreviousScope()
+    {
+        var sample = new OrderedViewSample(seed: 321, logCount: 2);
+        sample.SeedInterleaved(60);
+        EventLogId logA = sample.LogId(0), logB = sample.LogId(1);
+
+        var state = new OrderedViewState();
+        IEventColumnReader readerA = sample.Reader(0), readerB = sample.Reader(1);
+
+        state.ReconcileLog(logA, readerA);
+        state.ReconcileLog(logB, readerB);
+
+        Assert.NotNull(ViewRequests.AdvanceScope(state, [logA, logB], 1));
+
+        RebuildRequest staleForCombined = state.BeginRebuild((_, _) => true, new SortContext(ColumnName.DateAndTime, true, null, false));
+        Assert.Equal(1, staleForCombined.ScopeVersion);
+        Assert.Null(staleForCombined.SingleLog);
+
+        Assert.True(state.TrySetActiveScope([logB], scopeVersion: 2));
+        Assert.False(state.TryAdoptRebuild(staleForCombined, OrderedViewState.BuildIndex(staleForCombined, CancellationToken.None)));
+
+        RebuildRequest reseed = state.CaptureScopeReseed();
+        Assert.Equal(2, reseed.ScopeVersion);
+        Assert.Equal(logB, reseed.SingleLog);
+        Assert.True(state.TryAdoptRebuild(reseed, OrderedViewState.BuildIndex(reseed, CancellationToken.None)));
+    }
+
+    [Fact]
+    public async Task StaleInvalidation_DoesNotWipeANewerRequestsPublication()
+    {
+        CombinedRoutedSetup setup = await BuildAllLogsAsync(seed: 322, logCount: 3, events: 90, emptyLogs: 0);
+
+        Assert.NotNull(setup.Routed.ActiveOrderedView);
+
+        LogTableState stale = Reducers.ReduceViewRequestInvalidated(
+            setup.Routed,
+            new ViewRequestInvalidatedAction(setup.Routed.HighestInvalidationSequence));
+
+        Assert.NotNull(stale.ActiveOrderedView);
+        Assert.IsType<CombinedOrderedColumnView>(stale.GetActiveDisplayedEvents());
+    }
+
+    [Fact]
+    public async Task TabSwitch_AllLogsToSingleLogAndBack_RoutesTheRightEngineViewEachTime()
+    {
+        var sample = new OrderedViewSample(seed: 317, logCount: 3);
+        sample.SeedInterleaved(120);
+        EventLogId[] logIds = [sample.LogId(0), sample.LogId(1), sample.LogId(2)];
+        RawEventStoreState rawStore = RawStore(sample, logIds, []);
+        var combined = new LogView(EventLogId.Create()) { GroupId = LogTabGroupId.AllLogs };
+        ImmutableList<LogView> tables = [combined, .. logIds.Select(id => new LogView(id))];
+
+        LogTableState Live(EventLogId activeId) => CommittedFrom(
+            new LogTableState { ActiveEventLogId = activeId, EventTables = tables, IsDescending = true, RequestedIsDescending = true });
+
+        await using var harness = new OrderedViewShadowHarness();
+        var capture = new InvalidationCapture(harness);
+        var eventLog = new EventLogState();
+        CancellationToken cancellationToken = TestContext.Current.CancellationToken;
+
+        LogTableState allLogsFirst = await RouteAsync(harness, capture, Live(combined.Id), rawStore, eventLog, cancellationToken);
+        Assert.IsType<CombinedOrderedColumnView>(allLogsFirst.GetActiveDisplayedEvents());
+        int combinedCount = allLogsFirst.GetActiveDisplayedEvents().Count;
+
+        LogTableState single = await RouteAsync(harness, capture, Live(logIds[1]), rawStore, eventLog, cancellationToken);
+        IEventColumnView singleView = single.GetActiveDisplayedEvents();
+        Assert.IsType<OrderedColumnView>(singleView);
+        Assert.True(singleView.Count < combinedCount);
+        AssertOrderMatchesReference(singleView, [(logIds[1], sample.Events(1))], single.SortContext);
+
+        LogTableState allLogsAgain = await RouteAsync(harness, capture, Live(combined.Id), rawStore, eventLog, cancellationToken);
+        IEventColumnView reseeded = allLogsAgain.GetActiveDisplayedEvents();
+        Assert.IsType<CombinedOrderedColumnView>(reseeded);
+        Assert.Equal(combinedCount, reseeded.Count);
+        AssertOrderMatchesReference(
+            reseeded,
+            [.. logIds.Select((id, index) => (id, sample.Events(index)))],
+            allLogsAgain.SortContext);
+    }
+
+    [Fact]
+    public async Task TheReferenceCheckItself_FailsWhenTheOrderIsWrong()
+    {
+        CombinedRoutedSetup setup = await BuildAllLogsAsync(seed: 512, logCount: 3, events: 90, emptyLogs: 0);
+
+        IEventColumnView combined = setup.Routed.GetActiveDisplayedEvents();
+
+        IReadOnlyList<(EventLogId LogId, IReadOnlyList<ResolvedEvent> Events)> perturbed =
+            [.. setup.PerLog.Select(entry => (entry.LogId, (IReadOnlyList<ResolvedEvent>)[.. entry.Events.Reverse()]))];
+
+        Assert.ThrowsAny<Exception>(
+            () => AssertOrderMatchesReference(combined, perturbed, setup.Routed.SortContext));
+    }
+
+    [Fact]
+    public async Task ViewRequest_CarriesItsScopeReaders_SoEveryRoutablePublishIsMemberComplete()
+    {
+        var sample = new OrderedViewSample(seed: 320, logCount: 2);
+        sample.SeedInterleaved(80);
+        EventLogId logA = sample.LogId(0), logB = sample.LogId(1);
+        CancellationToken cancellationToken = TestContext.Current.CancellationToken;
+
+        await using var writer = new OrderedViewWriter(publishIntervalMs: 0);
+        var updates = new List<OrderedViewUpdate>();
+        Lock gate = new();
+
+        writer.Updated += update =>
+        {
+            lock (gate) { updates.Add(update); }
+        };
+
+        ViewRequest request = ViewRequests.For(
+            new SortContext(ColumnName.DateAndTime, true, null, false),
+            ViewRequests.EmptyFilter,
+            [logA, logB],
+            readers: new Dictionary<EventLogId, IEventColumnReader>
+            {
+                [logA] = sample.Reader(0), [logB] = sample.Reader(1)
+            });
+
+        writer.EnqueueViewRequest(request);
+        await writer.DrainAsync().WaitAsync(OrderedViewTestTimeouts.Default, cancellationToken);
+        await writer.DrainAsync().WaitAsync(OrderedViewTestTimeouts.Default, cancellationToken);
+
+        OrderedViewReady[] routable;
+
+        lock (gate)
+        {
+            routable = [.. updates.OfType<OrderedViewReady>().Where(update => update.Identity == request.Identity)];
+        }
+
+        Assert.NotEmpty(routable);
+
+        Assert.All(routable, ready =>
+        {
+            Assert.Null(ready.SingleLogId);
+            Assert.Equal([logA, logB], ready.InScope.Select(member => member.LogId).ToHashSet());
+        });
+    }
+
+    private static async Task<CombinedRoutedSetup> BuildAllLogsAsync(
+        int seed,
+        int logCount,
+        int events,
+        int emptyLogs,
+        ColumnName? groupBy = null)
+    {
+        var sample = new OrderedViewSample(seed, logCount);
+        sample.SeedInterleaved(events);
+        EventLogId[] logIds = [.. Enumerable.Range(0, logCount).Select(sample.LogId)];
+        EventLogId[] emptyLogIds = [.. Enumerable.Range(0, emptyLogs).Select(_ => EventLogId.Create())];
+
+        var combined = new LogView(EventLogId.Create()) { GroupId = LogTabGroupId.AllLogs };
+        ImmutableList<LogView> tables =
+            [combined, .. logIds.Select(id => new LogView(id)), .. emptyLogIds.Select(id => new LogView(id))];
+
+        LogTableState live = CommittedFrom(
+            new LogTableState
+            {
+                ActiveEventLogId = combined.Id,
+                EventTables = tables,
+                IsDescending = true,
+                RequestedIsDescending = true,
+
+                GroupBy = groupBy,
+                RequestedGroupBy = groupBy
+            });
+
+        (LogTableState scoped, LogTableState routed) = await RouteWithScopeAsync(
+            live, RawStore(sample, logIds, emptyLogIds), new EventLogState(), TestContext.Current.CancellationToken);
+
+        return new CombinedRoutedSetup(
+            scoped,
+            routed,
+            logIds,
+            emptyLogIds,
+            [.. logIds.Select((id, index) => (id, sample.Events(index)))]);
+    }
+
+    private static async Task<GroupRoutedSetup> BuildGroupAsync(int seed, int logCount, int events, int memberCount)
+    {
+        var sample = new OrderedViewSample(seed, logCount);
+        sample.SeedInterleaved(events);
+        EventLogId[] logIds = [.. Enumerable.Range(0, logCount).Select(sample.LogId)];
+        EventLogId[] memberIds = [.. logIds.Take(memberCount)];
+
+        var groupId = LogTabGroupId.Create();
+        var header = new LogView(EventLogId.Create()) { GroupId = groupId };
+        var group = new LogTabGroup(groupId, "Group", [.. memberIds]);
+
+        LogTableState live = CommittedFrom(
+            new LogTableState
+            {
+                ActiveEventLogId = header.Id,
+                EventTables = [header, .. logIds.Select(id => new LogView(id))],
+                Groups = [group],
+                IsDescending = true,
+                RequestedIsDescending = true
+            });
+
+        (LogTableState scoped, LogTableState routed) = await RouteWithScopeAsync(
+            live, RawStore(sample, logIds, []), new EventLogState(), TestContext.Current.CancellationToken);
+
+        return new GroupRoutedSetup(
+            scoped,
+            routed,
+            header,
+            group,
+            memberIds,
+            logIds[^1],
+            Enumerable.Range(0, logCount).Sum(index => sample.Events(index).Count),
+            [.. memberIds.Select(id => (id, sample.Events(Array.IndexOf(logIds, id))))]);
+    }
+
+    private static LogTableState CommittedFrom(LogTableState state) =>
+        state with
+        {
+            CommittedEffectiveOrderBy = ResolvedEventOrdering.ResolveDefaultOrderBy(
+                state.OrderBy, state.GroupBy, state.DisplayedLogCount, state.TimelineVisible)
+        };
+
+    private static RawEventStoreState RawStore(OrderedViewSample sample, EventLogId[] logIds, EventLogId[] emptyLogIds)
+    {
+        ImmutableDictionary<EventLogId, EventColumnStore> byLog = ImmutableDictionary<EventLogId, EventColumnStore>.Empty;
+
+        for (int i = 0; i < logIds.Length; i++)
+        {
+            byLog = byLog.Add(logIds[i], EventColumnStore.Build(sample.Events(i), 0, 0));
+        }
+
+        foreach (EventLogId emptyLogId in emptyLogIds)
+        {
+            byLog = byLog.Add(emptyLogId, EventColumnStore.Build([], 0, 0));
+        }
+
+        return new RawEventStoreState { ByLog = byLog };
+    }
+
+    private static async Task<LogTableState> RouteAsync(
+        OrderedViewShadowHarness harness,
+        InvalidationCapture capture,
+        LogTableState live,
+        RawEventStoreState rawStore,
+        EventLogState eventLog,
+        CancellationToken cancellationToken)
+    {
+        harness.SetState(live, rawStore, eventLog);
+        await harness.Effects.HandleSetActiveTable(harness.Dispatcher);
+
+        OrderedViewUpdate update = await harness.DrainToUpdateAsync(cancellationToken);
+        LogTableState scoped = Reducers.ReduceViewRequestInvalidated(
+            live with { AppliedFilter = eventLog.AppliedFilter }, capture.Latest);
+
+        Assert.Null(harness.Issuer.LastFault);
+
+        return Reducers.ReduceOrderedViewUpdated(scoped, new OrderedViewUpdatedAction(update));
+    }
+
+    private static async Task<(LogTableState Scoped, LogTableState Routed)> RouteWithScopeAsync(
+        LogTableState live,
+        RawEventStoreState rawStore,
+        EventLogState eventLog,
+        CancellationToken cancellationToken)
+    {
+        await using var harness = new OrderedViewShadowHarness();
+        var capture = new InvalidationCapture(harness);
+
+        LogTableState routed = await RouteAsync(harness, capture, live, rawStore, eventLog, cancellationToken);
+        LogTableState scoped = Reducers.ReduceViewRequestInvalidated(
+            live with { AppliedFilter = eventLog.AppliedFilter }, capture.Latest);
+
+        return (scoped, routed);
+    }
+
+    private sealed class InvalidationCapture
+    {
+        private readonly Lock _gate = new();
+
+        private ViewRequestInvalidatedAction? _latest;
+
+        public InvalidationCapture(OrderedViewShadowHarness harness) =>
+            harness.Dispatcher.When(dispatcher => dispatcher.Dispatch(Arg.Any<object>())).Do(callInfo =>
+            {
+                if (callInfo.Arg<object>() is ViewRequestInvalidatedAction invalidation)
+                {
+                    lock (_gate) { _latest = invalidation; }
+                }
+            });
+
+        public ViewRequestInvalidatedAction Latest
+        {
+            get
+            {
+                lock (_gate)
+                {
+                    return _latest ?? throw new InvalidOperationException("The shadow issued no view request.");
+                }
+            }
+        }
+    }
+
+    private sealed record CombinedRoutedSetup(
+        LogTableState Scoped,
+        LogTableState Routed,
+        EventLogId[] LogIds,
+        EventLogId[] EmptyLogIds,
+        IReadOnlyList<(EventLogId LogId, IReadOnlyList<ResolvedEvent> Events)> PerLog);
+
+    private sealed record GroupRoutedSetup(
+        LogTableState Scoped,
+        LogTableState Routed,
+        LogView Header,
+        LogTabGroup Group,
+        EventLogId[] MemberIds,
+        EventLogId OutsiderId,
+        int AllLogsRowCount,
+        IReadOnlyList<(EventLogId LogId, IReadOnlyList<ResolvedEvent> Events)> PerLog);
+}
+
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/OrderedViewDifferentialTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/OrderedViewDifferentialTests.cs
new file mode 100644
index 000000000..56e0e1939
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/OrderedViewDifferentialTests.cs
@@ -0,0 +1,355 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
+using EventLogExpert.Runtime.LogTable;
+using EventLogExpert.Runtime.LogTable.OrderedView;
+using EventLogExpert.Runtime.Tests.LogTable.TestSupport;
+
+namespace EventLogExpert.Runtime.Tests.LogTable.OrderedView;
+
+public sealed class OrderedViewDifferentialTests
+{
+    private static readonly ColumnName[] s_allGroupColumns =
+    [
+        ColumnName.RecordId,
+        ColumnName.Level,
+        ColumnName.DateAndTime,
+        ColumnName.ActivityId,
+        ColumnName.Log,
+        ColumnName.ComputerName,
+        ColumnName.Source,
+        ColumnName.EventId,
+        ColumnName.TaskCategory,
+        ColumnName.Keywords,
+        ColumnName.ProcessId,
+        ColumnName.ThreadId,
+        ColumnName.User
+    ];
+    private static readonly ColumnName?[] s_groupBys =
+    [
+        null,
+        ColumnName.Source,
+        ColumnName.Level,
+        ColumnName.EventId,
+        ColumnName.ComputerName,
+        ColumnName.TaskCategory
+    ];
+    private static readonly ColumnName?[] s_orderBys =
+    [
+        null,
+        ColumnName.RecordId,
+        ColumnName.DateAndTime,
+        ColumnName.EventId,
+        ColumnName.Level,
+        ColumnName.Source,
+        ColumnName.TaskCategory,
+        ColumnName.ComputerName,
+        ColumnName.ActivityId,
+        ColumnName.ProcessId,
+        ColumnName.ThreadId,
+        ColumnName.Log,
+        ColumnName.User,
+        ColumnName.Keywords
+    ];
+
+    [Theory]
+    [InlineData(9753)]
+    public void Combined_EveryGroupColumn_ProducesOneContiguousRunPerKeyAcrossLogs(int seed)
+    {
+        var sample = new OrderedViewSample(seed, logCount: 3);
+        sample.SeedInterleaved(totalEvents: 180);
+
+        var readers = new IEventColumnReader[sample.LogCount];
+        for (int k = 0; k < sample.LogCount; k++) { readers[k] = sample.Reader(k); }
+
+        foreach (ColumnName groupBy in s_allGroupColumns)
+        {
+            foreach (bool groupDescending in new[] { false, true })
+            {
+                var context = new SortContext(null, true, groupBy, groupDescending);
+                var state = new OrderedViewState();
+                ReconcileInterleaved(state, sample, readers);
+                RebuildTo(state, static (_, _) => true, context);
+
+                var view = new CombinedOrderedColumnView(state.Current, state.AdoptedInScope);
+
+                AssertOneRunPerKey(view, groupBy, $"seed={seed} combined groupBy={groupBy} groupDescending={groupDescending}");
+            }
+        }
+    }
+
+    [Theory]
+    [InlineData(999)]
+    [InlineData(4242)]
+    public void Combined_MatchesOrderingOracle_AcrossContexts(int seed)
+    {
+        var sample = new OrderedViewSample(seed, logCount: 3);
+        sample.SeedInterleaved(totalEvents: 180);
+
+        foreach (SortContext context in Contexts())
+        {
+            AssertCombinedParity(sample, context, $"seed={seed} {Describe(context)}");
+        }
+    }
+
+    [Theory]
+    [InlineData(8642)]
+    public void SingleLog_EveryGroupColumn_ProducesOneContiguousRunPerKey(int seed)
+    {
+        var sample = new OrderedViewSample(seed, logCount: 1);
+        sample.SeedInterleaved(totalEvents: 160);
+        IEventColumnReader reader = sample.Reader(0);
+        EventLogId logId = sample.LogId(0);
+
+        foreach (ColumnName groupBy in s_allGroupColumns)
+        {
+            foreach (bool groupDescending in new[] { false, true })
+            {
+                var context = new SortContext(null, true, groupBy, groupDescending);
+                OrderedViewState state = DriveReconcileThenRebuild(logId, reader, static (_, _) => true, context);
+                var view = new OrderedColumnView(state.Current, reader);
+
+                AssertOneRunPerKey(view, groupBy, $"seed={seed} groupBy={groupBy} groupDescending={groupDescending}");
+            }
+        }
+    }
+
+    [Theory]
+    [InlineData(31337)]
+    public void SingleLog_FilterSurvivingSubset_MatchesOrderingOracle(int seed)
+    {
+        var sample = new OrderedViewSample(seed, logCount: 1);
+        sample.SeedInterleaved(totalEvents: 150);
+
+        var survivors = new HashSet<int>(Enumerable.Range(0, sample.Events(0).Count).Where(static i => i % 3 != 0));
+
+        foreach (SortContext context in Contexts())
+        {
+            AssertSingleLogParity(sample, context, survivors, driveWithRebuild: true, $"seed={seed} filtered {Describe(context)}");
+        }
+    }
+
+    [Theory]
+    [InlineData(13579)]
+    public void SingleLog_LiveInsertUnderContext_MatchesOrderingOracle(int seed)
+    {
+        var sample = new OrderedViewSample(seed, logCount: 1);
+        sample.SeedInterleaved(totalEvents: 140);
+
+        foreach (SortContext context in Contexts())
+        {
+            AssertSingleLogParity(sample, context, survivorSet: null, driveWithRebuild: false, $"seed={seed} live-insert {Describe(context)}");
+        }
+    }
+
+    [Theory]
+    [InlineData(12345)]
+    [InlineData(24680)]
+    public void SingleLog_MatchesOrderingOracle_AcrossContexts(int seed)
+    {
+        var sample = new OrderedViewSample(seed, logCount: 1);
+        sample.SeedInterleaved(totalEvents: 160);
+
+        foreach (SortContext context in Contexts())
+        {
+            AssertSingleLogParity(sample, context, survivorSet: null, driveWithRebuild: true, $"seed={seed} {Describe(context)}");
+        }
+    }
+
+    private static void AssertCombinedParity(OrderedViewSample sample, SortContext context, string label)
+    {
+        int logCount = sample.LogCount;
+        var readers = new IEventColumnReader[logCount];
+        var flatLocators = new List<EventLocator>();
+        var flatEvents = new List<ResolvedEvent>();
+
+        for (int k = 0; k < logCount; k++)
+        {
+            readers[k] = sample.Reader(k);
+            int count = readers[k].Count;
+
+            for (int i = 0; i < count; i++)
+            {
+                flatLocators.Add(new EventLocator(sample.LogId(k), readers[k].Generation, i));
+                flatEvents.Add(sample.Events(k)[i]);
+            }
+        }
+
+        int[] aosOrder = AosReferenceOrdering.Order(
+            flatEvents, context.OrderBy, context.IsDescending, context.GroupBy, context.IsGroupDescending);
+
+        var state = new OrderedViewState();
+        ReconcileInterleaved(state, sample, readers);
+        RebuildTo(state, static (_, _) => true, context);
+        OrderedViewSnapshot snap = state.Current;
+
+        Assert.Equal(flatLocators.Count, snap.Count);
+
+        for (int i = 0; i < snap.Count; i++)
+        {
+            EventLocator engineLocator = snap.At(i).Locator;
+
+            Assert.Equal(flatLocators[aosOrder[i]], engineLocator);
+            Assert.Equal(i, snap.RankOf(new OrderKey(engineLocator)));
+            Assert.True(snap.Contains(engineLocator.LogId, engineLocator.Generation, engineLocator.Index), $"membership {label}[{i}]");
+        }
+
+        AssertSliceMatchesSequential(snap, label);
+        Assert.Equal(-1, snap.RankOf(new OrderKey(new EventLocator(EventLogId.Create(), 0, 0))));
+    }
+
+    private static void AssertOneRunPerKey(IEventColumnView view, ColumnName groupBy, string label)
+    {
+        var seen = new HashSet<string>(StringComparer.Ordinal);
+        string? currentKey = null;
+        int runs = 0;
+
+        for (int index = 0; index < view.Count; index++)
+        {
+            string key = view.GroupKeyAt(view.LocatorAt(index), groupBy);
+
+            if (currentKey is not null && string.Equals(key, currentKey, StringComparison.Ordinal)) { continue; }
+
+            Assert.True(seen.Add(key), $"group key '{key}' recurs in a later run ({label})");
+
+            currentKey = key;
+            runs++;
+        }
+
+        Assert.Equal(seen.Count, runs);
+    }
+
+    private static void AssertSingleLogParity(
+        OrderedViewSample sample, SortContext context, HashSet<int>? survivorSet, bool driveWithRebuild, string label)
+    {
+        IEventColumnReader reader = sample.Reader(0);
+        EventLogId logId = sample.LogId(0);
+        int count = reader.Count;
+
+        int[] survivors = (survivorSet is null ? Enumerable.Range(0, count) : survivorSet.OrderBy(static i => i)).ToArray();
+
+        var survivingEvents = new ResolvedEvent[survivors.Length];
+        for (int i = 0; i < survivors.Length; i++) { survivingEvents[i] = sample.Events(0)[survivors[i]]; }
+
+        int[] aosOrder = AosReferenceOrdering.Order(
+            survivingEvents, context.OrderBy, context.IsDescending, context.GroupBy, context.IsGroupDescending);
+
+        Func<EventLocator, IEventColumnReader, bool> predicate = survivorSet is null ? static (_, _) => true : (locator, _) => survivorSet.Contains(locator.Index);
+        OrderedViewState state = driveWithRebuild
+            ? DriveReconcileThenRebuild(logId, reader, predicate, context)
+            : DriveRebuildThenReconcile(logId, reader, predicate, context);
+
+        OrderedViewSnapshot snap = state.Current;
+
+        Assert.Equal(survivors.Length, snap.Count);
+
+        for (int i = 0; i < snap.Count; i++)
+        {
+            EventLocator engineLocator = snap.At(i).Locator;
+
+            Assert.Equal(survivors[aosOrder[i]], engineLocator.Index);
+            Assert.Equal(i, snap.RankOf(new OrderKey(engineLocator)));
+            Assert.True(snap.Contains(engineLocator.LogId, engineLocator.Generation, engineLocator.Index), $"membership {label}[{i}]");
+        }
+
+        AssertSliceMatchesSequential(snap, label);
+
+        for (int i = 0; i < count; i++)
+        {
+            if (survivorSet is null || survivorSet.Contains(i)) { continue; }
+
+            var absent = new EventLocator(logId, reader.Generation, i);
+            Assert.False(snap.Contains(absent.LogId, absent.Generation, absent.Index), $"filtered membership {label}[{i}]");
+            Assert.Equal(-1, snap.RankOf(new OrderKey(absent)));
+        }
+
+        Assert.Equal(-1, snap.RankOf(new OrderKey(new EventLocator(EventLogId.Create(), 0, 0))));
+    }
+
+    private static void AssertSliceMatchesSequential(OrderedViewSnapshot snap, string label)
+    {
+        if (snap.Count == 0) { return; }
+
+        int offset = snap.Count / 3;
+        int width = Math.Min(50, snap.Count - offset);
+        var buffer = new OrderKey[width];
+        int written = snap.SliceInto(offset, width, buffer);
+
+        Assert.Equal(width, written);
+
+        for (int i = 0; i < written; i++)
+        {
+            Assert.Equal(snap.At(offset + i).Locator, buffer[i].Locator);
+        }
+    }
+
+    private static IEnumerable<SortContext> Contexts()
+    {
+        foreach (ColumnName? orderBy in s_orderBys)
+        {
+            foreach (ColumnName? groupBy in s_groupBys)
+            {
+                foreach (bool descending in new[] { false, true })
+                {
+                    if (groupBy is null)
+                    {
+                        yield return new SortContext(orderBy, descending, null, false);
+
+                        continue;
+                    }
+
+                    foreach (bool groupDescending in new[] { false, true })
+                    {
+                        yield return new SortContext(orderBy, descending, groupBy, groupDescending);
+                    }
+                }
+            }
+        }
+    }
+
+    private static string Describe(SortContext context) =>
+        $"orderBy={context.OrderBy} desc={context.IsDescending} groupBy={context.GroupBy} groupDesc={context.IsGroupDescending}";
+
+    private static OrderedViewState DriveRebuildThenReconcile(
+        EventLogId logId, IEventColumnReader reader, Func<EventLocator, IEventColumnReader, bool> predicate, SortContext context)
+    {
+        var state = new OrderedViewState();
+        RebuildTo(state, predicate, context);
+        state.ReconcileLog(logId, reader);
+        state.Publish();
+
+        return state;
+    }
+
+    private static OrderedViewState DriveReconcileThenRebuild(
+        EventLogId logId, IEventColumnReader reader, Func<EventLocator, IEventColumnReader, bool> predicate, SortContext context)
+    {
+        var state = new OrderedViewState();
+        state.ReconcileLog(logId, reader);
+        RebuildTo(state, predicate, context);
+
+        return state;
+    }
+
+    private static void RebuildTo(OrderedViewState state, Func<EventLocator, IEventColumnReader, bool> predicate, SortContext context)
+    {
+        RebuildRequest request = state.BeginRebuild(predicate, context);
+        Assert.True(state.TryAdoptRebuild(request, OrderedViewState.BuildIndex(request)));
+    }
+
+    private static void ReconcileInterleaved(OrderedViewState state, OrderedViewSample sample, IEventColumnReader[] readers)
+    {
+        int max = 0;
+        for (int k = 0; k < readers.Length; k++) { max = Math.Max(max, readers[k].Count); }
+
+        for (int i = 0; i < max; i++)
+        {
+            for (int k = 0; k < readers.Length; k++)
+            {
+                if (i < readers[k].Count) { state.ReconcileLog(sample.LogId(k), sample.PrefixReader(k, i + 1)); }
+            }
+        }
+    }
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/OrderedViewFaultRecoveryTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/OrderedViewFaultRecoveryTests.cs
new file mode 100644
index 000000000..e2f30ae5f
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/OrderedViewFaultRecoveryTests.cs
@@ -0,0 +1,516 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.Channels;
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
+using EventLogExpert.Runtime.EventLog;
+using EventLogExpert.Runtime.LogTable;
+using EventLogExpert.Runtime.LogTable.OrderedView;
+using NSubstitute;
+using Reducers = EventLogExpert.Runtime.LogTable.Reducers;
+
+namespace EventLogExpert.Runtime.Tests.LogTable.OrderedView;
+
+public sealed class OrderedViewFaultRecoveryTests
+{
+    [Fact]
+    public async Task AFaultAfterRecovering_IsStillAnnounced()
+    {
+        await using var writer = new OrderedViewWriter(publishIntervalMs: 0);
+
+        int announced = 0;
+        writer.FaultRaised += (_, _) => Interlocked.Increment(ref announced);
+
+        var logId = EventLogId.Create();
+
+        writer.EnqueueViewRequest(ViewRequests.For(
+            new SortContext(ColumnName.RecordId, false, null, false),
+            new Filter(null, []),
+            [logId],
+            static (_, _) => throw new InvalidOperationException("a predicate that will not run"),
+            readers: Readers(logId),
+            activeLogId: logId));
+
+        await writer.DrainAsync();
+
+        Assert.NotNull(writer.Faulted);
+        Assert.Equal(1, Volatile.Read(ref announced));
+
+        writer.EnqueueViewRequest(ViewRequests.For(
+            new SortContext(ColumnName.Source, false, null, false),
+            new Filter(null, []),
+            [logId],
+            static (_, _) => throw new InvalidOperationException("still latched"),
+            readers: Readers(logId),
+            activeLogId: logId));
+
+        await writer.DrainAsync();
+
+        Assert.Equal(1, Volatile.Read(ref announced));
+
+        writer.EnqueueClearFault();
+        await writer.DrainAsync();
+
+        Assert.Null(writer.Faulted);
+
+        writer.EnqueueViewRequest(ViewRequests.For(
+            new SortContext(ColumnName.Level, false, null, false),
+            new Filter(null, []),
+            [logId],
+            static (_, _) => throw new InvalidOperationException("after recovery"),
+            readers: Readers(logId),
+            activeLogId: logId));
+
+        await writer.DrainAsync();
+
+        Assert.Equal(2, Volatile.Read(ref announced));
+    }
+
+    [Fact]
+    public void AFaultCauseCutMidCharacter_DoesNotLeaveHalfOfOneBehind()
+    {
+        var logId = EventLogId.Create();
+
+        LogTableState faulted = Reducers.ReduceOrderedViewDisplayFaulted(
+            new LogTableState
+            {
+                ActiveEventLogId = logId, EventTables = [new LogView(logId) { LogName = "Application" }]
+            },
+            new OrderedViewDisplayFaultedAction(new InvalidOperationException(new string('x', 199) + "\U0001F600 tail")));
+
+        Assert.NotNull(faulted.FaultCause);
+        Assert.DoesNotContain(faulted.FaultCause, char.IsSurrogate);
+    }
+
+    [Fact]
+    public void AFaultCauseFromAnUnboundedMessage_IsKeptShortEnoughToHold()
+    {
+        var logId = EventLogId.Create();
+
+        LogTableState faulted = Reducers.ReduceOrderedViewDisplayFaulted(
+            new LogTableState
+            {
+                ActiveEventLogId = logId, EventTables = [new LogView(logId) { LogName = "Application" }]
+            },
+            new OrderedViewDisplayFaultedAction(new InvalidOperationException(new string('x', 5000))));
+
+        Assert.NotNull(faulted.FaultCause);
+        Assert.True(faulted.FaultCause.Length < 300, $"cause was {faulted.FaultCause.Length} characters");
+    }
+
+    [Fact]
+    public void AFaultForARequestTheDisplayHasMovedOnFrom_DoesNotBlankIt()
+    {
+        var logId = EventLogId.Create();
+
+        var serving = new LogTableState
+        {
+            ActiveEventLogId = logId, EventTables = [new LogView(logId) { LogName = "Application" }]
+        };
+
+        var stale = new OrderedViewDisplayFaultedAction(
+            new InvalidOperationException("a question already abandoned"),
+            ViewRequests.Identity([logId], logId, ColumnName.Level));
+
+        LogTableState after = Reducers.ReduceOrderedViewDisplayFaulted(serving, stale);
+
+        Assert.True(after.OrderedViewDisplayEnabled);
+        Assert.Null(after.FaultCause);
+    }
+
+    [Fact]
+    public async Task AFaultNamingARequestTheDisplayHasMovedOnFrom_ClaimsNothingAndAsksNothing()
+    {
+        await using var harness = new OrderedViewShadowHarness();
+
+        var logId = EventLogId.Create();
+        LogTableState superseded = StateWith(logId);
+        LogTableState current = StateWith(logId) with { RequestedOrderBy = ColumnName.Level };
+
+        harness.SetState(current, new RawEventStoreState(), new EventLogState());
+
+        await harness.Effects.HandleOrderedViewDisplayFaulted(
+            new OrderedViewDisplayFaultedAction(
+                new InvalidOperationException("engine blew up"),
+                superseded.ViewIdentity),
+            harness.Dispatcher);
+
+        harness.Dispatcher.DidNotReceive().Dispatch(Arg.Any<OrderedViewDisplayRecoveredAction>());
+        harness.Dispatcher.DidNotReceive().Dispatch(Arg.Any<ViewRequestInvalidatedAction>());
+
+        Assert.True(harness.Issuer.TryBeginRecovery(current.ViewIdentity, current.LastPublishedSnapshotVersion));
+    }
+
+    [Fact]
+    public void AFaultOnATabWhoseGroupHasVanished_StopsBeingReported_RatherThanStrandingTheDisplay()
+    {
+        var logId = EventLogId.Create();
+        var vanishedGroupId = LogTabGroupId.Create();
+
+        LogTableState faulted = Reducers.ReduceOrderedViewDisplayFaulted(
+            new LogTableState
+            {
+                ActiveEventLogId = logId,
+                EventTables = [new LogView(logId) { LogName = "Application", GroupId = vanishedGroupId }],
+                Groups = [new LogTabGroup(vanishedGroupId, "Servers", [logId])]
+            },
+            Faults.Any);
+
+        Assert.Equal(PresentationState.Faulted, faulted.PresentationState);
+
+        LogTableState afterTheGroupWasDeleted = faulted with { Groups = [] };
+
+        Assert.Equal(PresentationState.Current, afterTheGroupWasDeleted.PresentationState);
+        Assert.False(afterTheGroupWasDeleted.OrderingIsStale, "the two derivations must agree on a settled tab");
+    }
+
+    [Fact]
+    public void AFaultOutlivingTheTabItHappenedOn_StopsBeingReported_BecauseNothingIsPendingAnyMore()
+    {
+        var logId = EventLogId.Create();
+
+        LogTableState faulted = Reducers.ReduceOrderedViewDisplayFaulted(
+            new LogTableState
+            {
+                ActiveEventLogId = logId, EventTables = [new LogView(logId) { LogName = "Application" }]
+            },
+            Faults.Any);
+
+        Assert.Equal(PresentationState.Faulted, faulted.PresentationState);
+
+        LogTableState afterTheTabClosed = faulted with { ActiveEventLogId = null };
+
+        Assert.Equal(PresentationState.Current, afterTheTabClosed.PresentationState);
+    }
+
+    [Fact]
+    public async Task AFaultThatNamesNoRequest_IsLeftToTheEngineThatAlreadyRepairsIt()
+    {
+        await using var harness = new OrderedViewShadowHarness();
+
+        LogTableState state = StateWith(EventLogId.Create());
+        harness.SetState(state, new RawEventStoreState(), new EventLogState());
+
+        await harness.Effects.HandleOrderedViewDisplayFaulted(Faults.Any, harness.Dispatcher);
+
+        harness.Dispatcher.DidNotReceive().Dispatch(Arg.Any<OrderedViewDisplayRecoveredAction>());
+        Assert.True(harness.Issuer.TryBeginRecovery(state.ViewIdentity, state.LastPublishedSnapshotVersion));
+    }
+
+    [Fact]
+    public async Task AFault_ForgetsTheFailedRequestSoTheRetryCanActuallyBeIssued()
+    {
+        await using var harness = new OrderedViewShadowHarness();
+
+        LogTableState state = StateWith(EventLogId.Create());
+        harness.SetState(state, new RawEventStoreState(), new EventLogState());
+
+        ViewIdentity identity = state.ViewIdentity;
+
+        Assert.NotNull(harness.Issuer.TryIssue(identity));
+        Assert.Null(harness.Issuer.TryIssue(identity));
+
+        await harness.Effects.HandleOrderedViewDisplayFaulted(
+            new OrderedViewDisplayFaultedAction(new InvalidOperationException("engine blew up"), identity),
+            harness.Dispatcher);
+
+        harness.Dispatcher.Received(1).Dispatch(Arg.Any<ViewRequestInvalidatedAction>());
+    }
+
+    [Fact]
+    public async Task AFault_ReTrustsTheEngineBeforeAnythingCanBeAdoptedUnderIt()
+    {
+        await using var harness = new OrderedViewShadowHarness();
+
+        LogTableState state = StateWith(EventLogId.Create());
+        harness.SetState(state, new RawEventStoreState(), new EventLogState());
+
+        await harness.Effects.HandleOrderedViewDisplayFaulted(
+            new OrderedViewDisplayFaultedAction(new InvalidOperationException("engine blew up"), state.ViewIdentity),
+            harness.Dispatcher);
+
+        harness.Dispatcher.Received(1).Dispatch(Arg.Any<OrderedViewDisplayRecoveredAction>());
+    }
+
+    [Fact]
+    public void AFault_SaysWhatWentWrong_AndTheAnswerThatFollowsClearsIt()
+    {
+        var logId = EventLogId.Create();
+
+        LogTableState faulted = Reducers.ReduceOrderedViewDisplayFaulted(
+            new LogTableState
+            {
+                ActiveEventLogId = logId, EventTables = [new LogView(logId) { LogName = "Application" }]
+            },
+            new OrderedViewDisplayFaultedAction(new InvalidOperationException("a predicate that will not compile")));
+
+        Assert.Contains("InvalidOperationException", faulted.FaultCause);
+        Assert.Contains("will not compile", faulted.FaultCause);
+
+        LogTableState recovered = Reducers.ReduceOrderedViewUpdated(faulted, ReadyFor(faulted, logId));
+
+        Assert.Null(recovered.FaultCause);
+    }
+
+    [Fact]
+    public void ARecoveredFrameWithASortStillPending_IsActuallyServed_NotJustTrustedAgain()
+    {
+        var logId = EventLogId.Create();
+
+        LogTableState faulted = Reducers.ReduceOrderedViewDisplayFaulted(
+            new LogTableState
+            {
+                ActiveEventLogId = logId,
+                EventTables = [new LogView(logId) { LogName = "Application" }],
+                RequestedOrderBy = ColumnName.Source
+            },
+            Faults.Any);
+
+        Assert.Equal(PresentationState.Faulted, faulted.PresentationState);
+        Assert.True(faulted.HasPendingSortChange);
+
+        LogTableState recovered = Reducers.ReduceOrderedViewUpdated(faulted, ReadyFor(faulted, logId));
+
+        Assert.True(recovered.OrderedViewDisplayEnabled);
+        Assert.False(recovered.HasPendingSortChange, "the rescuing frame must settle the ordering it was built under");
+        Assert.Equal(PresentationState.Current, recovered.PresentationState);
+    }
+
+    [Fact]
+    public async Task AnAnswerBetweenTwoFaults_EarnsTheSameRequestAnotherAttempt()
+    {
+        await using var harness = new OrderedViewShadowHarness();
+
+        var logId = EventLogId.Create();
+        LogTableState state = StateWith(logId);
+        harness.SetState(state, new RawEventStoreState(), new EventLogState());
+
+        ViewIdentity identity = state.ViewIdentity;
+        long liveTailSequence = state.HighestInvalidationSequence;
+        var fault = new OrderedViewDisplayFaultedAction(new InvalidOperationException("engine blew up"), identity);
+
+        await harness.Effects.HandleOrderedViewDisplayFaulted(fault, harness.Dispatcher);
+
+        var reIssue = harness.Dispatcher.ReceivedCalls()
+            .Select(call => call.GetArguments()[0])
+            .OfType<ViewRequestInvalidatedAction>()
+            .Last();
+
+        state = Reducers.ReduceViewRequestInvalidated(state, reIssue);
+        Assert.True(state.HighestInvalidationSequence > liveTailSequence);
+
+        for (var tail = 1; tail <= 4; tail++)
+        {
+            LogTableState published = Reducers.ReduceOrderedViewUpdated(
+                state,
+                ReadyAt(state, logId, state.LastPublishedSnapshotVersion + tail, liveTailSequence));
+
+            Assert.Equal(state.LastPublishedSnapshotVersion, published.LastPublishedSnapshotVersion);
+
+            state = published;
+            harness.SetState(state, new RawEventStoreState(), new EventLogState());
+
+            await harness.Effects.HandleOrderedViewDisplayFaulted(fault, harness.Dispatcher);
+        }
+
+        harness.Dispatcher.Received(1).Dispatch(Arg.Any<OrderedViewDisplayRecoveredAction>());
+
+        state = Reducers.ReduceOrderedViewUpdated(
+            state,
+            ReadyAt(state, logId, state.LastPublishedSnapshotVersion + 1, state.HighestInvalidationSequence));
+
+        harness.SetState(state, new RawEventStoreState(), new EventLogState());
+
+        await harness.Effects.HandleOrderedViewDisplayFaulted(fault, harness.Dispatcher);
+
+        harness.Dispatcher.Received(2).Dispatch(Arg.Any<OrderedViewDisplayRecoveredAction>());
+    }
+
+    [Fact]
+    public async Task ChangingTheDisplayAfterAFault_EarnsAFreshAttempt()
+    {
+        await using var harness = new OrderedViewShadowHarness();
+
+        var logId = EventLogId.Create();
+        LogTableState first = StateWith(logId);
+        harness.SetState(first, new RawEventStoreState(), new EventLogState());
+
+        await harness.Effects.HandleOrderedViewDisplayFaulted(
+            new OrderedViewDisplayFaultedAction(new InvalidOperationException("engine blew up"), first.ViewIdentity),
+            harness.Dispatcher);
+
+        LogTableState second = StateWith(logId) with { RequestedOrderBy = ColumnName.Level };
+        harness.SetState(second, new RawEventStoreState(), new EventLogState());
+
+        await harness.Effects.HandleOrderedViewDisplayFaulted(
+            new OrderedViewDisplayFaultedAction(new InvalidOperationException("engine blew up"), second.ViewIdentity),
+            harness.Dispatcher);
+
+        harness.Dispatcher.Received(2).Dispatch(Arg.Any<OrderedViewDisplayRecoveredAction>());
+    }
+
+    [Fact]
+    public void ClosingEverything_RetiresTheClaimSoAReopenedDisplayCanFailOnItsOwnTerms()
+    {
+        var issuer = new ViewRequestIssuer();
+        ViewIdentity identity = StateWith(EventLogId.Create()).ViewIdentity;
+
+        Assert.True(issuer.TryBeginRecovery(identity, servedWatermark: 0));
+        Assert.False(issuer.TryBeginRecovery(identity, servedWatermark: 0));
+
+        issuer.ResetForCloseAll();
+
+        Assert.True(issuer.TryBeginRecovery(identity, servedWatermark: 0));
+    }
+
+    [Fact]
+    public void ForgettingTheIssuedRequestToRetryIt_DoesNotAlsoForgetThatItWasTried()
+    {
+        var issuer = new ViewRequestIssuer();
+        ViewIdentity identity = StateWith(EventLogId.Create()).ViewIdentity;
+
+        Assert.True(issuer.TryBeginRecovery(identity, servedWatermark: 0));
+
+        issuer.ResetForClear();
+
+        Assert.False(issuer.TryBeginRecovery(identity, servedWatermark: 0));
+    }
+
+    [Fact]
+    public void ManyThreadsClaimingTheSameRecovery_ProduceExactlyOneAttempt()
+    {
+        ViewIdentity identity = StateWith(EventLogId.Create()).ViewIdentity;
+        var contenders = Math.Max(Environment.ProcessorCount, 4);
+
+        for (var round = 0; round < 200; round++)
+        {
+            var issuer = new ViewRequestIssuer();
+            using var release = new Barrier(contenders);
+            var claims = 0;
+
+            Parallel.For(0, contenders, _ =>
+            {
+                release.SignalAndWait();
+
+                if (issuer.TryBeginRecovery(identity, servedWatermark: 0)) { Interlocked.Increment(ref claims); }
+            });
+
+            Assert.Equal(1, claims);
+        }
+    }
+
+    [Fact]
+    public void Recovering_MovesTheDisplayFromFailedToWaiting_NotStraightBackToCurrent()
+    {
+        var logId = EventLogId.Create();
+
+        LogTableState faulted = Reducers.ReduceOrderedViewDisplayFaulted(
+            new LogTableState
+            {
+                ActiveEventLogId = logId,
+                EventTables = [new LogView(logId) { LogName = "Application" }]
+            }, Faults.Any);
+
+        Assert.Equal(PresentationState.Faulted, faulted.PresentationState);
+
+        LogTableState recovered = Reducers.ReduceOrderedViewDisplayRecovered(faulted);
+
+        Assert.True(recovered.OrderedViewDisplayEnabled);
+        Assert.Null(recovered.ActiveOrderedView);
+        Assert.Equal(PresentationState.Updating, recovered.PresentationState);
+    }
+
+    [Fact]
+    public void Recovering_TakesTheReasonWithIt_SoWaitingNeverCarriesAStaleOne()
+    {
+        var logId = EventLogId.Create();
+
+        LogTableState faulted = Reducers.ReduceOrderedViewDisplayFaulted(
+            new LogTableState
+            {
+                ActiveEventLogId = logId, EventTables = [new LogView(logId) { LogName = "Application" }]
+            },
+            Faults.Any);
+
+        Assert.NotNull(faulted.FaultCause);
+
+        LogTableState recovered = Reducers.ReduceOrderedViewDisplayRecovered(faulted);
+
+        Assert.Equal(PresentationState.Updating, recovered.PresentationState);
+        Assert.Null(recovered.FaultCause);
+    }
+
+    [Fact]
+    public async Task TheSameFailingRequest_IsRetriedOnce_NotForever()
+    {
+        await using var harness = new OrderedViewShadowHarness();
+
+        LogTableState state = StateWith(EventLogId.Create());
+        harness.SetState(state, new RawEventStoreState(), new EventLogState());
+
+        var fault = new OrderedViewDisplayFaultedAction(
+            new InvalidOperationException("engine blew up"),
+            state.ViewIdentity);
+
+        await harness.Effects.HandleOrderedViewDisplayFaulted(fault, harness.Dispatcher);
+        await harness.Effects.HandleOrderedViewDisplayFaulted(fault, harness.Dispatcher);
+        await harness.Effects.HandleOrderedViewDisplayFaulted(fault, harness.Dispatcher);
+
+        harness.Dispatcher.Received(1).Dispatch(Arg.Any<OrderedViewDisplayRecoveredAction>());
+    }
+
+    private static IReadOnlyDictionary<EventLogId, IEventColumnReader> Readers(EventLogId logId)
+    {
+        List<ResolvedEvent> events =
+        [
+            new("Application", LogPathType.Channel)
+            {
+                RecordId = 1,
+                TimeCreated = new DateTime(2026, 1, 1, 0, 0, 0, DateTimeKind.Utc),
+                Id = 1000,
+                Level = "Information",
+                Source = "Provider.A",
+                LogName = "Application"
+            }
+        ];
+
+        return new Dictionary<EventLogId, IEventColumnReader>
+        {
+            [logId] = EventColumnStore.Build(events, generation: 0, contentVersion: 0).CreateReader(logId)
+        };
+    }
+
+    private static OrderedViewUpdatedAction ReadyAt(
+        LogTableState state,
+        EventLogId logId,
+        long snapshotVersion,
+        long sequence) =>
+        new(new OrderedViewReady(
+            SnapshotVersion: snapshotVersion,
+            Identity: state.ViewIdentity,
+            Sequence: sequence,
+            SingleLogId: logId,
+            InScope: [new LogGeneration(logId, 0)],
+            View: EmptyColumnView.Instance,
+            Config: state.SortContext,
+            Filter: state.AppliedFilter));
+
+    private static OrderedViewUpdatedAction ReadyFor(LogTableState state, EventLogId logId) =>
+        new(new OrderedViewReady(
+            SnapshotVersion: state.LastPublishedSnapshotVersion + 1,
+            Identity: state.ViewIdentity,
+            Sequence: state.HighestInvalidationSequence,
+            SingleLogId: logId,
+            InScope: [new LogGeneration(logId, 0)],
+            View: EmptyColumnView.Instance,
+            Config: state.SortContext,
+            Filter: state.AppliedFilter));
+
+    private static LogTableState StateWith(EventLogId logId) =>
+        new()
+        {
+            ActiveEventLogId = logId,
+            EventTables = [new LogView(logId) { LogName = "Application" }]
+        };
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/OrderedViewInvariantTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/OrderedViewInvariantTests.cs
new file mode 100644
index 000000000..bcfc10a3e
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/OrderedViewInvariantTests.cs
@@ -0,0 +1,407 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.Channels;
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
+using EventLogExpert.Runtime.LogTable;
+using EventLogExpert.Runtime.LogTable.OrderedView;
+
+namespace EventLogExpert.Runtime.Tests.LogTable.OrderedView;
+
+public sealed class OrderedViewInvariantTests
+{
+    private static readonly SortContext s_defaultContext = new(ColumnName.RecordId, false, null, false);
+
+    [Fact]
+    public void AdoptFailureDuringTailReplay_LeavesEngineFullyIntact()
+    {
+        EventLogId logId = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        Reconcile(state, logId, count: 100);
+        state.Publish();
+
+        RebuildRequest request = state.BeginRebuild(
+            static (locator, _) => locator.Index >= 105 ? throw new InvalidOperationException("boom") : true, s_defaultContext);
+
+        Reconcile(state, logId, count: 111);
+
+        ChunkedOrderIndex rebuilt = BuildCandidate(request);
+        Assert.Throws<InvalidOperationException>(() => state.TryAdoptRebuild(request, rebuilt));
+
+        Assert.Equal(100, state.Current.Count);
+
+        Reconcile(state, logId, count: 112);
+        state.Publish();
+        Assert.Equal(112, state.Current.Count);
+    }
+
+    [Fact]
+    public void BeginReset_IgnoresStaleLowerGeneration_SoNewerReloadIsNotRegressed()
+    {
+        EventLogId logId = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        Reconcile(state, logId, count: 20);
+        state.Publish();
+        Reconcile(state, logId, count: 15, generation: 2, recordIdBase: 500);
+
+        state.BeginReset(logId, newGeneration: 2);
+        RebuildRequest request = state.BeginReset(logId, newGeneration: 1);
+        Assert.True(state.TryAdoptRebuild(request, BuildCandidate(request)));
+
+        Assert.Equal(15, state.Current.Count);
+        for (int i = 0; i < state.Current.Count; i++) { Assert.Equal(2, state.Current.At(i).Locator.Generation); }
+    }
+
+    [Fact]
+    public void Clear_SupersedesInFlightRebuild_SoAStaleAdoptCannotResurrectClearedRows()
+    {
+        EventLogId logId = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        Reconcile(state, logId, count: 50);
+        state.Publish();
+
+        RebuildRequest inFlight = state.BeginRebuild(static (_, _) => true, s_defaultContext);
+        ChunkedOrderIndex rebuilt = BuildCandidate(inFlight);
+
+        state.Clear();
+        Assert.Equal(0, state.Current.Count);
+
+        Assert.False(state.TryAdoptRebuild(inFlight, rebuilt));
+        Assert.Equal(0, state.Current.Count);
+    }
+
+    [Fact]
+    public void ClosedGenerationReaders_ArePruned_AfterReload()
+    {
+        EventLogId logId = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        Reconcile(state, logId, count: 30);
+        state.Publish();
+        Reconcile(state, logId, count: 20, generation: 1, recordIdBase: 500);
+        Assert.Equal(2, state.TrackedReaderCount);
+
+        RebuildRequest reset = state.BeginReset(logId, newGeneration: 1);
+        Assert.True(state.TryAdoptRebuild(reset, BuildCandidate(reset)));
+
+        Assert.Equal(1, state.TrackedReaderCount);
+        Assert.Equal(1, state.Current.PinnedReaderCount);
+        Assert.Equal(20, state.Current.Count);
+    }
+
+    [Fact]
+    public void FrontInserts_UnderDescendingOrder_PreserveOrder()
+    {
+        EventLogId logId = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        Rebuild(state, static (_, _) => true, new SortContext(ColumnName.RecordId, true, null, false));
+        Reconcile(state, logId, count: 4000);
+        state.Publish();
+
+        OrderedViewSnapshot snap = state.Current;
+        Assert.Equal(4000, snap.Count);
+
+        for (int i = 0; i < snap.Count; i++) { Assert.Equal(4000 - 1 - i, snap.At(i).Locator.Index); }
+    }
+
+    [Fact]
+    public void HeldRebuild_FailingInTailReplay_ClearsHoldSoReconcileResumes()
+    {
+        EventLogId logId = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        Reconcile(state, logId, count: 2);
+        state.Publish();
+
+        RebuildRequest held = state.BeginRebuild(
+            static (locator, _) => locator.Index >= 5 ? throw new InvalidOperationException("boom") : true, s_defaultContext, hold: true);
+        Reconcile(state, logId, count: 7);
+
+        Assert.Throws<InvalidOperationException>(() => state.TryAdoptRebuild(held, BuildCandidate(held)));
+
+        Reconcile(state, logId, count: 8);
+        state.Publish();
+        Assert.True(state.Current.Contains(logId, 0, 7));
+    }
+
+    [Fact]
+    public void Hold_ClearsAtAdopt_SoALaterReconcileAdmitsNormally()
+    {
+        EventLogId logId = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        Reconcile(state, logId, count: 2);
+        RebuildRequest held = state.BeginRebuild(static (_, _) => true, s_defaultContext, hold: true);
+        Assert.True(state.TryAdoptRebuild(held, BuildCandidate(held)));
+
+        Reconcile(state, logId, count: 3);
+        state.Publish();
+        Assert.Equal(3, state.Current.Count);
+        Assert.True(state.Current.Contains(logId, 0, 2));
+    }
+
+    [Fact]
+    public void Hold_GatesReconcile_ThenAdmitsHeldRowsAtAdopt()
+    {
+        EventLogId logId = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        Reconcile(state, logId, count: 2);
+        state.Publish();
+
+        RebuildRequest held = state.BeginRebuild(static (_, _) => true, s_defaultContext, hold: true);
+
+        Reconcile(state, logId, count: 3);
+        OrderedViewSnapshot mid = state.Publish();
+        Assert.Equal(2, mid.Count);
+        Assert.Equal(3, state.RowCount);
+        Assert.False(mid.Contains(logId, 0, 2));
+
+        Assert.True(state.TryAdoptRebuild(held, BuildCandidate(held)));
+        Assert.Equal(3, state.Current.Count);
+        Assert.True(state.Current.Contains(logId, 0, 2));
+    }
+
+    [Fact]
+    public void Hold_IsSticky_AcrossExplicitStableSupersession_UntilAdopt()
+    {
+        EventLogId logId = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        Reconcile(state, logId, count: 2);
+        state.Publish();
+
+        RebuildRequest holding = state.BeginRebuild(static (_, _) => true, s_defaultContext, hold: true);
+        RebuildRequest stable = state.BeginRebuild(static (_, _) => true, s_defaultContext, hold: false);
+
+        Assert.False(state.TryAdoptRebuild(holding, BuildCandidate(holding)));
+
+        Reconcile(state, logId, count: 3);
+        OrderedViewSnapshot mid = state.Publish();
+        Assert.Equal(2, mid.Count);
+
+        Assert.True(state.TryAdoptRebuild(stable, BuildCandidate(stable)));
+        Assert.Equal(3, state.Current.Count);
+        Assert.True(state.Current.Contains(logId, 0, 2));
+    }
+
+    [Fact]
+    public void MidRebuildPublish_ShowsConsistentOldFrame_ThenNewAfterAdopt()
+    {
+        EventLogId logId = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        Reconcile(state, logId, count: 5000);
+        state.Publish();
+
+        RebuildRequest request = state.BeginRebuild((locator, _) => locator.Index % 2 == 0, s_defaultContext);
+
+        Reconcile(state, logId, count: 6000);
+        OrderedViewSnapshot mid = state.Publish();
+        Assert.Equal(6000, mid.Count);
+
+        Assert.True(state.TryAdoptRebuild(request, BuildCandidate(request)));
+        OrderedViewSnapshot post = state.Current;
+        Assert.Equal(3000, post.Count);
+        for (int i = 0; i < post.Count; i++) { Assert.Equal(0, post.At(i).Locator.Index % 2); }
+    }
+
+    [Fact]
+    public void PendingFilter_IsInherited_ByLaterReset()
+    {
+        EventLogId logId = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        Reconcile(state, logId, count: 100);
+        state.Publish();
+
+        RebuildRequest filter = state.BeginRebuild((locator, _) => locator.Index % 2 == 0, s_defaultContext);
+        RebuildRequest reset = state.BeginReset(logId, newGeneration: 1);
+
+        Assert.False(state.TryAdoptRebuild(filter, BuildCandidate(filter)));
+
+        Reconcile(state, logId, count: 100, generation: 1, recordIdBase: 500);
+
+        Assert.True(state.TryAdoptRebuild(reset, BuildCandidate(reset)));
+
+        OrderedViewSnapshot snap = state.Current;
+        Assert.Equal(50, snap.Count);
+        for (int i = 0; i < snap.Count; i++)
+        {
+            Assert.Equal(1, snap.At(i).Locator.Generation);
+            Assert.Equal(0, snap.At(i).Locator.Index % 2);
+        }
+    }
+
+    [Fact]
+    public void PendingReset_IsInherited_ByLaterSupersedingRebuild()
+    {
+        EventLogId logId = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        Reconcile(state, logId, count: 100);
+        state.Publish();
+
+        RebuildRequest reset = state.BeginReset(logId, newGeneration: 1);
+        RebuildRequest filter = state.BeginRebuild((locator, _) => locator.Index < 100, s_defaultContext);
+
+        Assert.False(state.TryAdoptRebuild(reset, BuildCandidate(reset)));
+
+        Reconcile(state, logId, count: 50, generation: 1, recordIdBase: 500);
+
+        Assert.True(state.TryAdoptRebuild(filter, BuildCandidate(filter)));
+
+        OrderedViewSnapshot snap = state.Current;
+        Assert.Equal(50, snap.Count);
+        Assert.False(snap.Contains(logId, 0, 0));
+        Assert.True(snap.Contains(logId, 1, 0));
+    }
+
+    [Fact]
+    public void RemoveLog_ThenReconcileAnotherLog_KeepsRemovedReaderResolvableUntilAdopt()
+    {
+        EventLogId removedLog = EventLogId.Create();
+        EventLogId keptLog = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        Reconcile(state, removedLog, count: 10);
+        state.Publish();
+
+        RebuildRequest removeRequest = state.RemoveLog(removedLog);
+
+        Reconcile(state, keptLog, count: 1, recordIdBase: 1000);
+
+        Assert.True(state.TryAdoptRebuild(removeRequest, BuildCandidate(removeRequest)));
+        Assert.Equal(1, state.Current.Count);
+        Assert.True(state.Current.Contains(keptLog, 0, 0));
+        Assert.False(state.Current.Contains(removedLog, 0, 0));
+    }
+
+    [Fact]
+    public void RetainedSnapshot_IsIsolated_FromLaterInsertsAndPublish()
+    {
+        EventLogId logId = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        Reconcile(state, logId, count: 3000);
+        state.Publish();
+        OrderedViewSnapshot old = state.Current;
+
+        int oldCount = old.Count;
+        var oldFull = new OrderKey[oldCount];
+        old.SliceInto(0, oldCount, oldFull);
+
+        Reconcile(state, logId, count: 6000);
+        state.Publish();
+        OrderedViewSnapshot fresh = state.Current;
+
+        var recheck = new OrderKey[oldCount];
+        int written = old.SliceInto(0, oldCount, recheck);
+
+        Assert.Equal(3000, oldCount);
+        Assert.Equal(oldCount, written);
+        Assert.True(recheck.AsSpan().SequenceEqual(oldFull.AsSpan()));
+        Assert.Equal(6000, fresh.Count);
+        Assert.True(fresh.Version > old.Version);
+    }
+
+    [Fact]
+    public void SnapshotVersion_StaysMonotonic_AcrossRebuildAdopt()
+    {
+        EventLogId logId = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        Reconcile(state, logId, count: 400);
+        for (int i = 0; i < 5; i++) { state.Publish(); }
+        long beforeRebuild = state.Current.Version;
+
+        Rebuild(state, static (_, _) => true, new SortContext(ColumnName.Source, false, null, false));
+
+        Assert.True(state.Current.Version > beforeRebuild, $"version regressed: {beforeRebuild} -> {state.Current.Version}");
+    }
+
+    [Fact]
+    public void StaleGeneration_ForLateFirstSeenLog_IsRejectedOnReplay()
+    {
+        EventLogId primary = EventLogId.Create();
+        EventLogId late = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        Reconcile(state, primary, count: 50);
+        state.Publish();
+
+        RebuildRequest request = state.BeginRebuild(static (_, _) => true, s_defaultContext);
+
+        Reconcile(state, late, count: 2, generation: 1, recordIdBase: 500);
+        Reconcile(state, late, count: 2, generation: 0, recordIdBase: 700);
+
+        Assert.True(state.TryAdoptRebuild(request, BuildCandidate(request)));
+
+        OrderedViewSnapshot snap = state.Current;
+        Assert.True(snap.Contains(late, 1, 0));
+        Assert.False(snap.Contains(late, 0, 1));
+    }
+
+    [Fact]
+    public void SupersededRebuild_IsDiscarded_AndFreshAdopts()
+    {
+        EventLogId logId = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        Reconcile(state, logId, count: 4000);
+        state.Publish();
+
+        RebuildRequest stale = state.BeginRebuild((locator, _) => locator.Index < 1000, s_defaultContext);
+        ChunkedOrderIndex staleIndex = BuildCandidate(stale);
+
+        RebuildRequest fresh = state.BeginRebuild((locator, _) => locator.Index >= 2000, s_defaultContext);
+        ChunkedOrderIndex freshIndex = BuildCandidate(fresh);
+
+        Assert.False(state.TryAdoptRebuild(stale, staleIndex));
+        Assert.True(state.TryAdoptRebuild(fresh, freshIndex));
+
+        OrderedViewSnapshot snap = state.Current;
+        Assert.Equal(2000, snap.Count);
+        Assert.Equal(2000, snap.At(0).Locator.Index);
+        Assert.False(snap.Contains(logId, 0, 1999));
+        Assert.True(snap.Contains(logId, 0, 2000));
+    }
+
+    private static ChunkedOrderIndex BuildCandidate(RebuildRequest request) => OrderedViewState.BuildIndex(request);
+
+    private static IEventColumnReader Reader(EventLogId logId, int count, int generation, long recordIdBase)
+    {
+        var clock = new DateTime(2026, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+        var events = new List<ResolvedEvent>(count);
+
+        for (int i = 0; i < count; i++)
+        {
+            events.Add(new ResolvedEvent("Log", LogPathType.Channel)
+            {
+                RecordId = recordIdBase + i,
+                TimeCreated = clock.AddMilliseconds(recordIdBase + i),
+                Id = 1000,
+                Level = "Information",
+                Source = "Provider.A",
+                LogName = "Channel"
+            });
+        }
+
+        return EventColumnStore.Build(events, generation, generation).CreateReader(logId);
+    }
+
+    private static void Rebuild(OrderedViewState state, Func<EventLocator, IEventColumnReader, bool> predicate, SortContext context)
+    {
+        RebuildRequest request = state.BeginRebuild(predicate, context);
+        Assert.True(state.TryAdoptRebuild(request, BuildCandidate(request)));
+    }
+
+    private static void Reconcile(
+        OrderedViewState state, EventLogId logId, int count, int generation = 0, long recordIdBase = 0) =>
+        state.ReconcileLog(logId, Reader(logId, count, generation, recordIdBase));
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/OrderedViewReaderLifetimeTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/OrderedViewReaderLifetimeTests.cs
new file mode 100644
index 000000000..3296bfaab
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/OrderedViewReaderLifetimeTests.cs
@@ -0,0 +1,141 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.Channels;
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
+using EventLogExpert.Runtime.LogTable;
+using EventLogExpert.Runtime.LogTable.OrderedView;
+
+namespace EventLogExpert.Runtime.Tests.LogTable.OrderedView;
+
+public sealed class OrderedViewReaderLifetimeTests
+{
+    [Fact]
+    public void RetainedSnapshot_StaysValid_AfterReload_AndReusedIndicesDoNotAlias()
+    {
+        EventLogId logId = EventLogId.Create();
+        var generation0 = MakeEvents("Log", firstRecordId: 1, count: 30);
+        IEventColumnReader reader0 = EventColumnStore.Build(generation0, generation: 0, contentVersion: 0).CreateReader(logId);
+
+        var context = new SortContext(ColumnName.DateAndTime, false, null, false);
+        var state = new OrderedViewState();
+
+        state.ReconcileLog(logId, reader0);
+
+        Rebuild(state, context);
+        OrderedViewSnapshot generation0Snapshot = state.Current;
+        EventLocator[] generation0Order = Order(generation0Snapshot);
+
+        Assert.Equal(30, generation0Snapshot.Count);
+
+        var generation1 = MakeEvents("Log", firstRecordId: 500, count: 20);
+        IEventColumnReader reader1 = EventColumnStore.Build(generation1, generation: 1, contentVersion: 1).CreateReader(logId);
+
+        state.ReconcileLog(logId, reader1);
+
+        state.Publish();
+        Assert.Equal(30, state.Current.Count);
+
+        RebuildRequest reset = state.BeginReset(logId, newGeneration: 1);
+        Adopt(state, reset);
+        OrderedViewSnapshot reloaded = state.Current;
+
+        Assert.Equal(20, reloaded.Count);
+        foreach (EventLocator locator in generation0Order) { Assert.False(reloaded.Contains(logId, 0, locator.Index)); }
+        for (int i = 0; i < reader1.Count; i++) { Assert.True(reloaded.Contains(logId, 1, i)); }
+
+        Assert.Equal(30, generation0Snapshot.Count);
+        Assert.Equal(generation0Order, Order(generation0Snapshot));
+
+        for (int i = 0; i < generation0Snapshot.Count; i++)
+        {
+            Assert.Equal(i, generation0Snapshot.RankOf(new OrderKey(generation0Order[i])));
+            Assert.True(generation0Snapshot.Contains(logId, 0, generation0Order[i].Index));
+        }
+    }
+
+    [Fact]
+    public void RetainedSnapshot_StaysValid_AfterSameGenerationAppend()
+    {
+        EventLogId logId = EventLogId.Create();
+        var initial = MakeEvents("Log", firstRecordId: 1, count: 40);
+        var store = EventColumnStore.Build(initial, generation: 0, contentVersion: 0);
+        IEventColumnReader reader0 = store.CreateReader(logId);
+
+        var context = new SortContext(ColumnName.Source, false, null, false);
+        var state = new OrderedViewState();
+
+        state.ReconcileLog(logId, reader0);
+
+        Rebuild(state, context);
+        OrderedViewSnapshot before = state.Current;
+        EventLocator[] beforeOrder = Order(before);
+
+        Assert.Equal(40, before.Count);
+
+        var appended = MakeEvents("Log", firstRecordId: 41, count: 25);
+        IEventColumnReader reader1 = store.Append(appended).CreateReader(logId);
+
+        Assert.Equal(0, reader1.Generation);
+        Assert.Equal(65, reader1.Count);
+
+        state.ReconcileLog(logId, reader1);
+
+        state.Publish();
+        OrderedViewSnapshot after = state.Current;
+
+        Assert.NotEqual(before.Version, after.Version);
+        Assert.Equal(40, before.Count);
+        Assert.Equal(beforeOrder, Order(before));
+
+        for (int i = 0; i < before.Count; i++)
+        {
+            Assert.Equal(i, before.RankOf(new OrderKey(beforeOrder[i])));
+            Assert.True(before.Contains(logId, 0, beforeOrder[i].Index));
+        }
+
+        Assert.Equal(65, after.Count);
+        foreach (EventLocator locator in beforeOrder) { Assert.True(after.Contains(logId, 0, locator.Index)); }
+    }
+
+    private static void Adopt(OrderedViewState state, RebuildRequest request) =>
+        Assert.True(state.TryAdoptRebuild(request, OrderedViewState.BuildIndex(request)));
+
+    private static List<ResolvedEvent> MakeEvents(string owningLog, long firstRecordId, int count)
+    {
+        var clock = new DateTime(2026, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+        string[] sources = ["Provider.A", "Provider.B", "Provider.C"];
+        var events = new List<ResolvedEvent>(count);
+
+        for (int i = 0; i < count; i++)
+        {
+            events.Add(new ResolvedEvent(owningLog, LogPathType.Channel)
+            {
+                RecordId = firstRecordId + i,
+                TimeCreated = clock.AddMilliseconds(i),
+                Id = 1000 + (i % 4),
+                Level = "Information",
+                Source = sources[i % sources.Length],
+                LogName = "Channel"
+            });
+        }
+
+        return events;
+    }
+
+    private static EventLocator[] Order(OrderedViewSnapshot snapshot)
+    {
+        var order = new EventLocator[snapshot.Count];
+
+        for (int i = 0; i < order.Length; i++) { order[i] = snapshot.At(i).Locator; }
+
+        return order;
+    }
+
+    private static void Rebuild(OrderedViewState state, SortContext context)
+    {
+        RebuildRequest request = state.BeginRebuild(static (_, _) => true, context);
+        Adopt(state, request);
+    }
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/OrderedViewSample.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/OrderedViewSample.cs
new file mode 100644
index 000000000..04dd6ee00
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/OrderedViewSample.cs
@@ -0,0 +1,102 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.Channels;
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
+
+namespace EventLogExpert.Runtime.Tests.LogTable.OrderedView;
+
+internal sealed class OrderedViewSample
+{
+    private static readonly Guid[] s_activityIds =
+        [new("11111111-1111-1111-1111-111111111111"), new("22222222-2222-2222-2222-222222222222")];
+    private static readonly string[] s_computers = ["HOST-1", "HOST-2"];
+    private static readonly string[][] s_keywords = [[], ["Audit Success"], ["Audit Failure"]];
+    private static readonly string[] s_levels = ["Information", "Warning", "Error", "Critical", ""];
+    private static readonly string[] s_sources = ["Provider.A", "Provider.B", "Provider.C"];
+    private static readonly string[] s_tasks = ["", "Logon", "Service"];
+
+    private readonly bool _allowNulls;
+    private readonly bool _allowTies;
+    private readonly EventLogId[] _logIds;
+    private readonly long[] _nextRecordId;
+    private readonly List<List<ResolvedEvent>> _perLog;
+    private readonly Random _rng;
+
+    private DateTime _clock = new(2026, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+
+    public OrderedViewSample(int seed, int logCount, bool allowTies = true, bool allowNulls = true)
+    {
+        _rng = new Random(seed);
+        _allowTies = allowTies;
+        _allowNulls = allowNulls;
+        _perLog = new List<List<ResolvedEvent>>(logCount);
+        _logIds = new EventLogId[logCount];
+        _nextRecordId = new long[logCount];
+
+        for (int k = 0; k < logCount; k++)
+        {
+            _perLog.Add([]);
+            _logIds[k] = EventLogId.Create();
+            _nextRecordId[k] = 1;
+        }
+    }
+
+    public int LogCount => _perLog.Count;
+
+    public void Append(int logIndex, int count)
+    {
+        for (int i = 0; i < count; i++) { AppendOne(logIndex); }
+    }
+
+    public IReadOnlyList<ResolvedEvent> Events(int logIndex) => _perLog[logIndex];
+
+    public EventLocator[] Locators(int logIndex, int generation = 0)
+    {
+        var locators = new EventLocator[_perLog[logIndex].Count];
+
+        for (int i = 0; i < locators.Length; i++) { locators[i] = new EventLocator(_logIds[logIndex], generation, i); }
+
+        return locators;
+    }
+
+    public EventLogId LogId(int logIndex) => _logIds[logIndex];
+
+    public IEventColumnReader PrefixReader(int logIndex, int count, int generation = 0, long contentVersion = 0) =>
+        EventColumnStore.Build(_perLog[logIndex].Take(count).ToList(), generation, contentVersion)
+            .CreateReader(_logIds[logIndex]);
+
+    public IEventColumnReader Reader(int logIndex, int generation = 0, long contentVersion = 0) =>
+        EventColumnStore.Build(_perLog[logIndex], generation, contentVersion).CreateReader(_logIds[logIndex]);
+
+    public void SeedInterleaved(int totalEvents)
+    {
+        for (int k = 0; k < _perLog.Count; k++) { AppendOne(k); }
+
+        for (int i = _perLog.Count; i < totalEvents; i++) { AppendOne(_rng.Next(_perLog.Count)); }
+    }
+
+    private void AppendOne(int logIndex)
+    {
+        _clock = _clock.AddMilliseconds(_allowTies && _rng.Next(4) == 0 ? 0 : 1 + _rng.Next(50));
+
+        long? recordId = _allowNulls && _rng.Next(12) == 0 ? null : _nextRecordId[logIndex]++;
+
+        _perLog[logIndex].Add(new ResolvedEvent($"Log{logIndex}", LogPathType.Channel)
+        {
+            RecordId = recordId,
+            TimeCreated = _clock,
+            Id = 1000 + _rng.Next(5),
+            Level = s_levels[_rng.Next(s_levels.Length)],
+            Source = s_sources[_rng.Next(s_sources.Length)],
+            TaskCategory = s_tasks[_rng.Next(s_tasks.Length)],
+            ComputerName = s_computers[_rng.Next(s_computers.Length)],
+            LogName = $"Channel{logIndex}",
+            Keywords = s_keywords[_rng.Next(s_keywords.Length)],
+            ActivityId = _allowNulls && _rng.Next(2) == 0 ? null : s_activityIds[_rng.Next(s_activityIds.Length)],
+            ProcessId = _allowNulls && _rng.Next(2) == 0 ? null : 1 + _rng.Next(4),
+            ThreadId = _allowNulls && _rng.Next(2) == 0 ? null : 1 + _rng.Next(4)
+        });
+    }
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/OrderedViewScopeBuildTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/OrderedViewScopeBuildTests.cs
new file mode 100644
index 000000000..71b4ffbc7
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/OrderedViewScopeBuildTests.cs
@@ -0,0 +1,716 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.Channels;
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
+using EventLogExpert.Runtime.LogTable;
+using EventLogExpert.Runtime.LogTable.OrderedView;
+
+namespace EventLogExpert.Runtime.Tests.LogTable.OrderedView;
+
+public sealed class OrderedViewScopeBuildTests
+{
+    private static readonly SortContext s_context = new(ColumnName.RecordId, false, null, false);
+
+    [Fact]
+    public void A_B_A_WithTailsForBothLogs_ConvergesExactlyOnce()
+    {
+        EventLogId logA = EventLogId.Create();
+        EventLogId logB = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        AdoptScope(state, [logA], new Dictionary<EventLogId, IEventColumnReader> { [logA] = Reader(logA, 30, 0, 0) });
+        state.ReconcileLog(logA, Reader(logA, 45, 0, 0));
+
+        AdoptScope(state, [logB], new Dictionary<EventLogId, IEventColumnReader> { [logB] = Reader(logB, 20, 0, 1000) });
+        state.ReconcileLog(logB, Reader(logB, 26, 0, 1000));
+
+        AdoptScope(state, [logA], new Dictionary<EventLogId, IEventColumnReader> { [logA] = Reader(logA, 45, 0, 0) });
+
+        Assert.Equal(45, state.Current.Count);
+        AssertNoDuplicateLocators(state.Current);
+        Assert.Equal(45, state.RowCount);
+    }
+
+    [Fact]
+    public void A_B_EvictTo_A_WithNoNewAEvents_ShowsARows()
+    {
+        EventLogId logA = EventLogId.Create();
+        EventLogId logB = EventLogId.Create();
+        IEventColumnReader readerA = Reader(logA, 24, 0, 0);
+        var state = new OrderedViewState();
+
+        AdoptScope(state, [logA], new Dictionary<EventLogId, IEventColumnReader> { [logA] = readerA });
+        Assert.Equal(24, state.Current.Count);
+
+        AdoptScope(state, [logB], new Dictionary<EventLogId, IEventColumnReader> { [logB] = Reader(logB, 9, 0, 1000) });
+        Assert.Equal(9, state.Current.Count);
+
+        AdoptScope(state, [logA], new Dictionary<EventLogId, IEventColumnReader> { [logA] = readerA });
+
+        Assert.Equal(24, state.Current.Count);
+        for (int index = 0; index < 24; index++) { Assert.True(state.Current.Contains(logA, 0, index)); }
+    }
+
+    [Fact]
+    public void Adopt_DoesNotRegressLiveCoverage_SoNoLocatorIsInsertedTwice()
+    {
+        EventLogId logId = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        state.ReconcileLog(logId, Reader(logId, 50, 0, 0));
+
+        RebuildRequest request = state.BeginRebuild(static (_, _) => true, s_context);
+
+        state.ReconcileLog(logId, Reader(logId, 80, 0, 0));
+
+        Assert.True(state.TryAdoptRebuild(request, OrderedViewState.BuildIndex(request, CancellationToken.None)));
+
+        Assert.Equal(80, state.Current.Count);
+        Assert.Equal(80, state.RowCount);
+        AssertNoDuplicateLocators(state.Current);
+    }
+
+    [Fact]
+    public void AfterEviction_StaleLowerGenerationReader_IsStillRejected()
+    {
+        EventLogId logA = EventLogId.Create();
+        EventLogId logB = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        AdoptScope(state,
+            [logA, logB],
+            new Dictionary<EventLogId, IEventColumnReader> { [logA] = Reader(logA, 10, 0, 0), [logB] = Reader(logB, 8, 0, 1000) });
+
+        state.ReconcileLog(logB, Reader(logB, 6, 2, 2000));
+        RebuildRequest reset = state.BeginReset(logB, newGeneration: 2);
+        Assert.True(state.TryAdoptRebuild(reset, OrderedViewState.BuildIndex(reset, CancellationToken.None)));
+        Assert.True(state.Current.Contains(logB, 2, 0));
+
+        AdoptScope(state, [logA], new Dictionary<EventLogId, IEventColumnReader> { [logA] = Reader(logA, 10, 0, 0) });
+
+        AdoptScope(state,
+            [logA, logB],
+            new Dictionary<EventLogId, IEventColumnReader> { [logA] = Reader(logA, 10, 0, 0), [logB] = Reader(logB, 7, 1, 3000) });
+
+        Assert.Equal(10, state.Current.Count);
+        Assert.False(state.Current.Contains(logB, 1, 0));
+        Assert.DoesNotContain(new LogGeneration(logB, 1), state.AdoptedInScope);
+    }
+
+    [Fact]
+    public void AfterEviction_StaleLowerGenerationThatOnlyEverHadAZeroRowGeneration_IsStillRejected()
+    {
+        EventLogId logA = EventLogId.Create();
+        EventLogId logB = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        AdoptScope(state,
+            [logA, logB],
+            new Dictionary<EventLogId, IEventColumnReader> { [logA] = Reader(logA, 6, 0, 0), [logB] = Reader(logB, 8, 2, 1000) });
+
+        AdoptScope(state, [logA], new Dictionary<EventLogId, IEventColumnReader> { [logA] = Reader(logA, 6, 0, 0) });
+
+        AdoptScope(state,
+            [logA, logB],
+            new Dictionary<EventLogId, IEventColumnReader> { [logA] = Reader(logA, 6, 0, 0), [logB] = Reader(logB, 0, 5, 3000) });
+
+        Assert.Equal(6, state.Current.Count);
+
+        AdoptScope(state, [logA], new Dictionary<EventLogId, IEventColumnReader> { [logA] = Reader(logA, 6, 0, 0) });
+
+        AdoptScope(state,
+            [logA, logB],
+            new Dictionary<EventLogId, IEventColumnReader> { [logA] = Reader(logA, 6, 0, 0), [logB] = Reader(logB, 7, 3, 4000) });
+
+        Assert.Equal(6, state.Current.Count);
+        Assert.False(state.Current.Contains(logB, 3, 0));
+        Assert.DoesNotContain(new LogGeneration(logB, 3), state.AdoptedInScope);
+    }
+
+    [Fact]
+    public void AfterEviction_StaleLowerGeneration_IsRejected_EvenWhenTheHigherGenerationWasOnlyEverAPinnedReader()
+    {
+        EventLogId logA = EventLogId.Create();
+        EventLogId logB = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        AdoptScope(state,
+            [logA, logB],
+            new Dictionary<EventLogId, IEventColumnReader> { [logA] = Reader(logA, 6, 0, 0), [logB] = Reader(logB, 8, 0, 1000) });
+
+        Assert.False(state.ReconcileLog(logB, Reader(logB, 0, 5, 3000)));
+
+        AdoptScope(state, [logA], new Dictionary<EventLogId, IEventColumnReader> { [logA] = Reader(logA, 6, 0, 0) });
+
+        AdoptScope(state,
+            [logA, logB],
+            new Dictionary<EventLogId, IEventColumnReader> { [logA] = Reader(logA, 6, 0, 0), [logB] = Reader(logB, 7, 3, 4000) });
+
+        Assert.Equal(6, state.Current.Count);
+        Assert.False(state.Current.Contains(logB, 3, 0));
+        Assert.DoesNotContain(new LogGeneration(logB, 3), state.AdoptedInScope);
+    }
+
+    [Fact]
+    public void AfterEviction_StaleLowerGeneration_IsRejected_WhenTheHigherGenerationNeverHadAReaderAtAll()
+    {
+        EventLogId logA = EventLogId.Create();
+        EventLogId logB = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        AdoptScope(state,
+            [logA, logB],
+            new Dictionary<EventLogId, IEventColumnReader> { [logA] = Reader(logA, 6, 0, 0), [logB] = Reader(logB, 8, 0, 1000) });
+
+        RebuildRequest reset = state.BeginReset(logB, newGeneration: 5);
+        Assert.True(state.TryAdoptRebuild(reset, OrderedViewState.BuildIndex(reset, CancellationToken.None)));
+
+        Assert.Equal(6, state.Current.Count);
+
+        AdoptScope(state, [logA], new Dictionary<EventLogId, IEventColumnReader> { [logA] = Reader(logA, 6, 0, 0) });
+
+        AdoptScope(state,
+            [logA, logB],
+            new Dictionary<EventLogId, IEventColumnReader> { [logA] = Reader(logA, 6, 0, 0), [logB] = Reader(logB, 7, 3, 4000) });
+
+        Assert.Equal(6, state.Current.Count);
+        Assert.False(state.Current.Contains(logB, 3, 0));
+        Assert.DoesNotContain(new LogGeneration(logB, 3), state.AdoptedInScope);
+    }
+
+    [Fact]
+    public void BuildIndex_SkipsClosedGenerationCoverageKeys_UnderAPendingReset()
+    {
+        EventLogId logId = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        state.ReconcileLog(logId, Reader(logId, 12, 0, 0));
+        state.ReconcileLog(logId, Reader(logId, 5, 1, 500));
+
+        RebuildRequest reset = state.BeginReset(logId, newGeneration: 1);
+
+        Assert.Equal(17, state.RowCount);
+
+        ChunkedOrderIndex candidate = OrderedViewState.BuildIndex(reset, CancellationToken.None);
+
+        Assert.True(state.TryAdoptRebuild(reset, candidate));
+        Assert.Equal(5, state.Current.Count);
+        for (int index = 0; index < 5; index++) { Assert.True(state.Current.Contains(logId, 1, index)); }
+
+        Assert.False(state.Current.Contains(logId, 0, 0));
+    }
+
+    [Fact]
+    public void Clear_ThenLateReconcile_DoesNotResurrectClosedLog()
+    {
+        EventLogId logId = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        state.ReconcileLog(logId, Reader(logId, 15, 0, 0));
+        RebuildRequest request = state.BeginRebuild(static (_, _) => true, s_context);
+        Assert.True(state.TryAdoptRebuild(request, OrderedViewState.BuildIndex(request, CancellationToken.None)));
+        Assert.Equal(15, state.Current.Count);
+
+        state.Clear();
+
+        Assert.False(state.ReconcileLog(logId, Reader(logId, 20, 0, 0)));
+
+        state.Publish();
+        Assert.Equal(0, state.Current.Count);
+        Assert.Equal(0, state.RowCount);
+        Assert.Empty(state.AdoptedInScope);
+    }
+
+    [Fact]
+    public void ClosedGenerationCoverage_IsEvictedWithItsReader_AfterAnInScopeReload()
+    {
+        EventLogId logId = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        state.ReconcileLog(logId, Reader(logId, 12, 0, 0));
+        state.ReconcileLog(logId, Reader(logId, 5, 1, 500));
+
+        Assert.Equal(17, state.RowCount);
+
+        RebuildRequest reset = state.BeginReset(logId, newGeneration: 1);
+        Assert.True(state.TryAdoptRebuild(reset, OrderedViewState.BuildIndex(reset, CancellationToken.None)));
+
+        Assert.Equal(5, state.Current.Count);
+        Assert.Equal(5, state.RowCount);
+        Assert.Equal(1, state.TrackedReaderCount);
+    }
+
+    [Fact]
+    public void Coverage_NeverExceedsPinnedReaderCount_AcrossEvictAndReturn()
+    {
+        EventLogId logA = EventLogId.Create();
+        EventLogId logB = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        AdoptScope(state,
+            [logA, logB],
+            new Dictionary<EventLogId, IEventColumnReader> { [logA] = Reader(logA, 14, 0, 0), [logB] = Reader(logB, 11, 0, 1000) });
+
+        Assert.Equal(25, state.RowCount);
+        Assert.Equal(2, state.TrackedReaderCount);
+
+        AdoptScope(state, [logA], new Dictionary<EventLogId, IEventColumnReader> { [logA] = Reader(logA, 14, 0, 0) });
+
+        Assert.Equal(14, state.RowCount);
+        Assert.Equal(1, state.TrackedReaderCount);
+
+        AdoptScope(state,
+            [logA, logB],
+            new Dictionary<EventLogId, IEventColumnReader> { [logA] = Reader(logA, 14, 0, 0), [logB] = Reader(logB, 11, 0, 1000) });
+
+        Assert.Equal(25, state.RowCount);
+        Assert.Equal(2, state.TrackedReaderCount);
+        Assert.Equal(25, state.Current.Count);
+    }
+
+    [Fact]
+    public void Eviction_DropsGenerationMaps_SoOutOfScopeReloadIsNotHeldOutOnReturn()
+    {
+        EventLogId logA = EventLogId.Create();
+        EventLogId logB = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        AdoptScope(state,
+            [logA, logB],
+            new Dictionary<EventLogId, IEventColumnReader> { [logA] = Reader(logA, 10, 0, 0), [logB] = Reader(logB, 8, 0, 1000) });
+
+        AdoptScope(state, [logA], new Dictionary<EventLogId, IEventColumnReader> { [logA] = Reader(logA, 10, 0, 0) });
+
+        Assert.Equal(1, state.TrackedGenerationCount);
+
+        AdoptScope(state,
+            [logA, logB],
+            new Dictionary<EventLogId, IEventColumnReader> { [logA] = Reader(logA, 10, 0, 0), [logB] = Reader(logB, 7, 3, 2000) });
+
+        Assert.Equal(17, state.Current.Count);
+        Assert.Contains(new LogGeneration(logB, 3), state.AdoptedInScope);
+        for (int index = 0; index < 7; index++) { Assert.True(state.Current.Contains(logB, 3, index)); }
+
+        Assert.True(state.ReconcileLog(logB, Reader(logB, 12, 3, 2000)));
+        state.Publish();
+        Assert.Equal(22, state.Current.Count);
+    }
+
+    [Fact]
+    public void FirstSightOfANewLogDuringAnInFlightBuild_StillReachesTheAdoptedView()
+    {
+        EventLogId established = EventLogId.Create();
+        EventLogId newcomer = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        state.ReconcileLog(established, Reader(established, 8, 0, 0));
+
+        RebuildRequest request = state.BeginRebuild(static (_, _) => true, s_context);
+        ChunkedOrderIndex candidate = OrderedViewState.BuildIndex(request, CancellationToken.None);
+
+        Assert.Equal(8, candidate.Count);
+
+        state.ReconcileLog(newcomer, Reader(newcomer, 6, 0, 1000));
+
+        Assert.True(state.TryAdoptRebuild(request, candidate));
+
+        Assert.Equal(14, state.Current.Count);
+        for (int index = 0; index < 6; index++) { Assert.True(state.Current.Contains(newcomer, 0, index)); }
+
+        for (int i = 0; i < state.Current.Count; i++)
+        {
+            Assert.True(state.Current.TryGetReader(state.Current.At(i).Locator, out _));
+        }
+
+        Assert.True(state.ReconcileLog(newcomer, Reader(newcomer, 10, 0, 1000)));
+        state.Publish();
+        Assert.Equal(18, state.Current.Count);
+    }
+
+    [Fact]
+    public void HigherGenerationLiveReader_DoesNotClaimTheDisplayedGeneration_SoAnInFlightBuildCannotRegressIt()
+    {
+        EventLogId logId = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        Assert.False(state.ReconcileLog(logId, Reader(logId, 0, 0, 0)));
+
+        RebuildRequest request = state.BeginRebuild(static (_, _) => true, s_context);
+        ChunkedOrderIndex candidate = OrderedViewState.BuildIndex(request, CancellationToken.None);
+
+        Assert.False(state.ReconcileLog(logId, Reader(logId, 5, 1, 500)));
+
+        state.Publish();
+        Assert.Equal(0, state.Current.Count);
+
+        Assert.True(state.TryAdoptRebuild(request, candidate));
+
+        Assert.Equal(0, state.Current.Count);
+        Assert.Equal(5, state.RowCount);
+
+        RebuildRequest reset = state.BeginReset(logId, newGeneration: 1);
+        Assert.True(state.TryAdoptRebuild(reset, OrderedViewState.BuildIndex(reset, CancellationToken.None)));
+
+        Assert.Equal(5, state.Current.Count);
+        for (int index = 0; index < 5; index++) { Assert.True(state.Current.Contains(logId, 1, index)); }
+    }
+
+    [Fact]
+    public void HigherGenerationReconcile_DuringAnInFlightBuild_DoesNotPublishAnUnresolvableMix()
+    {
+        EventLogId logId = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        state.ReconcileLog(logId, Reader(logId, 10, 0, 0));
+
+        RebuildRequest request = state.BeginRebuild(static (_, _) => true, s_context);
+        ChunkedOrderIndex candidate = OrderedViewState.BuildIndex(request, CancellationToken.None);
+
+        Assert.Equal(10, candidate.Count);
+
+        state.ReconcileLog(logId, Reader(logId, 5, 1, 500));
+
+        Assert.True(state.TryAdoptRebuild(request, candidate));
+
+        OrderedViewSnapshot snapshot = state.Current;
+
+        Assert.Equal(10, snapshot.Count);
+
+        for (int i = 0; i < snapshot.Count; i++)
+        {
+            EventLocator locator = snapshot.At(i).Locator;
+
+            Assert.True(snapshot.TryGetReader(locator, out _),
+                $"published locator {locator.LogId.Value}/gen{locator.Generation}/#{locator.Index} has no reader in its own snapshot");
+        }
+
+        var generations = new HashSet<int>();
+        for (int i = 0; i < snapshot.Count; i++) { generations.Add(snapshot.At(i).Locator.Generation); }
+
+        Assert.True(generations.Count <= 1, $"snapshot mixes generations: [{string.Join(", ", generations)}]");
+    }
+
+    [Fact]
+    public void PendingHigherReset_DoesNotStrandTheStillDisplayedGenerationsLiveTail()
+    {
+        EventLogId logA = EventLogId.Create();
+        EventLogId logB = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        AdoptScope(state,
+            [logA, logB],
+            new Dictionary<EventLogId, IEventColumnReader> { [logA] = Reader(logA, 4, 0, 0), [logB] = Reader(logB, 10, 2, 1000) });
+
+        AdoptScope(state, [logA], new Dictionary<EventLogId, IEventColumnReader> { [logA] = Reader(logA, 4, 0, 0) });
+
+        AdoptScope(state,
+            [logA, logB],
+            new Dictionary<EventLogId, IEventColumnReader> { [logA] = Reader(logA, 4, 0, 0), [logB] = Reader(logB, 10, 2, 1000) });
+
+        Assert.Equal(14, state.Current.Count);
+
+        state.BeginReset(logB, newGeneration: 5);
+
+        Assert.True(state.ReconcileLog(logB, Reader(logB, 16, 2, 1000)));
+
+        state.Publish();
+        Assert.Equal(20, state.Current.Count);
+        Assert.True(state.Current.Contains(logB, 2, 15));
+    }
+
+    [Fact]
+    public void PublishedSnapshotHasNoBitsetForAnEvictedKey()
+    {
+        EventLogId logA = EventLogId.Create();
+        EventLogId logB = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        AdoptScope(state,
+            [logA, logB],
+            new Dictionary<EventLogId, IEventColumnReader> { [logA] = Reader(logA, 6, 0, 0), [logB] = Reader(logB, 5, 0, 1000) });
+
+        OrderedViewSnapshot wide = state.Current;
+        Assert.True(wide.Contains(logB, 0, 0));
+
+        AdoptScope(state, [logA], new Dictionary<EventLogId, IEventColumnReader> { [logA] = Reader(logA, 6, 0, 0) });
+
+        Assert.False(state.Current.Contains(logB, 0, 0));
+        Assert.Equal(-1, state.Current.RankOf(new OrderKey(new EventLocator(logB, 0, 0))));
+
+        Assert.True(wide.Contains(logB, 0, 0));
+    }
+
+    [Fact]
+    public void ReconcileCoverage_PredicateFault_LeavesCoverageAtLeastEvaluated()
+    {
+        EventLogId logId = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        RebuildRequest request = state.BeginRebuild(
+            static (locator, _) => locator.Index >= 5 ? throw new InvalidOperationException("boom") : true, s_context);
+        Assert.True(state.TryAdoptRebuild(request, OrderedViewState.BuildIndex(request, CancellationToken.None)));
+
+        Assert.Throws<InvalidOperationException>(() => state.ReconcileLog(logId, Reader(logId, 10, 0, 0)));
+
+        Assert.Equal(10, state.RowCount);
+
+        RebuildRequest recovery = state.BeginRebuild(static (_, _) => true, s_context);
+        Assert.True(state.TryAdoptRebuild(recovery, OrderedViewState.BuildIndex(recovery, CancellationToken.None)));
+        Assert.Equal(10, state.Current.Count);
+    }
+
+    [Fact]
+    public void ScopeAdopt_PrunesOutOfScopeReadersAfterTheIndexSwap()
+    {
+        EventLogId logA = EventLogId.Create();
+        EventLogId logB = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        AdoptScope(state,
+            [logA, logB],
+            new Dictionary<EventLogId, IEventColumnReader> { [logA] = Reader(logA, 7, 0, 0), [logB] = Reader(logB, 4, 0, 1000) });
+
+        Assert.Equal(2, state.Current.PinnedReaderCount);
+
+        AdoptScope(state, [logA], new Dictionary<EventLogId, IEventColumnReader> { [logA] = Reader(logA, 7, 0, 0) });
+
+        Assert.Equal(1, state.TrackedReaderCount);
+        Assert.Equal(1, state.Current.PinnedReaderCount);
+        Assert.False(state.Current.TryGetReaderByLog(logB, 0, out _));
+    }
+
+    [Fact]
+    public void ScopeRequest_WithHigherGenerationReader_RebuildsAtTheRequestedGeneration()
+    {
+        EventLogId logId = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        AdoptScope(state, [logId], new Dictionary<EventLogId, IEventColumnReader> { [logId] = Reader(logId, 9, 0, 0) });
+        Assert.Equal(9, state.Current.Count);
+
+        AdoptScope(state, [logId], new Dictionary<EventLogId, IEventColumnReader> { [logId] = Reader(logId, 6, 1, 500) });
+
+        Assert.Equal(6, state.Current.Count);
+        Assert.Contains(new LogGeneration(logId, 1), state.AdoptedInScope);
+        Assert.False(state.Current.Contains(logId, 0, 0));
+    }
+
+    [Fact]
+    public void ScopeRequest_WithZeroRowHigherGenerationReader_StopsPublishingThePreviousGeneration()
+    {
+        EventLogId logId = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        AdoptScope(state, [logId], new Dictionary<EventLogId, IEventColumnReader> { [logId] = Reader(logId, 9, 0, 0) });
+        Assert.Equal(9, state.Current.Count);
+
+        AdoptScope(state, [logId], new Dictionary<EventLogId, IEventColumnReader> { [logId] = Reader(logId, 0, 1, 500) });
+
+        Assert.Equal(0, state.Current.Count);
+        Assert.False(state.Current.Contains(logId, 0, 0));
+
+        Assert.Empty(state.AdoptedInScope);
+    }
+
+    [Fact]
+    public void ScopeSeeding_DoesNotInsertIntoTheOutgoingIndex_EvenWhenTheOutgoingScopeIsStillAdopted()
+    {
+        EventLogId logA = EventLogId.Create();
+        EventLogId logB = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        AdoptScope(state, [logA], new Dictionary<EventLogId, IEventColumnReader> { [logA] = Reader(logA, 12, 0, 0) });
+
+        Assert.True(state.TrySetActiveScope([logB], ViewRequests.NextSequence()));
+        state.ReconcileScopeReaders(new Dictionary<EventLogId, IEventColumnReader> { [logB] = Reader(logB, 20, 0, 1000) });
+
+        state.Publish();
+        Assert.Equal(12, state.Current.Count);
+        Assert.False(state.Current.Contains(logB, 0, 0));
+        Assert.Equal(32, state.RowCount);
+
+        RebuildRequest reseed = state.CaptureScopeReseed();
+        Assert.True(state.TryAdoptRebuild(reseed, OrderedViewState.BuildIndex(reseed, CancellationToken.None)));
+
+        Assert.Equal(20, state.Current.Count);
+    }
+
+    [Fact]
+    public void ScopeSwitch_OwnerSynchronousWork_IsIndependentOfEnteringLogRowCount()
+    {
+        EventLogId logA = EventLogId.Create();
+        EventLogId logB = EventLogId.Create();
+        int predicateCalls = 0;
+        var state = new OrderedViewState();
+
+        bool CountingPredicate(EventLocator locator, IEventColumnReader reader)
+        {
+            Interlocked.Increment(ref predicateCalls);
+
+            return true;
+        }
+
+        Assert.True(state.TrySetActiveScope([logA], ViewRequests.NextSequence()));
+        state.ReconcileScopeReaders(new Dictionary<EventLogId, IEventColumnReader> { [logA] = Reader(logA, 5, 0, 0) });
+
+        RebuildRequest first = state.BeginRebuild(CountingPredicate, s_context);
+        Assert.True(state.TryAdoptRebuild(first, OrderedViewState.BuildIndex(first, CancellationToken.None)));
+
+        int afterAdopt = Volatile.Read(ref predicateCalls);
+
+        Assert.True(state.TrySetActiveScope([logB], ViewRequests.NextSequence()));
+        state.ReconcileScopeReaders(new Dictionary<EventLogId, IEventColumnReader> { [logB] = Reader(logB, 20_000, 0, 1000) });
+
+        Assert.Equal(afterAdopt, Volatile.Read(ref predicateCalls));
+        Assert.Equal(20_005, state.RowCount);
+
+        RebuildRequest second = state.BeginRebuild(CountingPredicate, s_context);
+        Assert.True(state.TryAdoptRebuild(second, OrderedViewState.BuildIndex(second, CancellationToken.None)));
+
+        int afterSwitch = Volatile.Read(ref predicateCalls);
+
+        Assert.True(state.TrySetActiveScope([logB], ViewRequests.NextSequence()));
+        state.ReconcileScopeReaders(new Dictionary<EventLogId, IEventColumnReader> { [logB] = Reader(logB, 40_000, 0, 1000) });
+
+        Assert.Equal(afterSwitch, Volatile.Read(ref predicateCalls));
+        Assert.Equal(40_000, state.RowCount);
+    }
+
+    [Fact]
+    public void SupersededBuild_NeverEvictsTheAdoptedScope()
+    {
+        EventLogId logA = EventLogId.Create();
+        EventLogId logB = EventLogId.Create();
+        EventLogId logC = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        AdoptScope(state, [logA], new Dictionary<EventLogId, IEventColumnReader> { [logA] = Reader(logA, 10, 0, 0) });
+
+        Assert.True(state.TrySetActiveScope([logB], ViewRequests.NextSequence()));
+        state.ReconcileScopeReaders(new Dictionary<EventLogId, IEventColumnReader> { [logB] = Reader(logB, 8, 0, 1000) });
+        RebuildRequest towardsB = state.CaptureScopeReseed();
+        ChunkedOrderIndex indexForB = OrderedViewState.BuildIndex(towardsB, CancellationToken.None);
+
+        Assert.True(state.TrySetActiveScope([logC], ViewRequests.NextSequence()));
+        state.ReconcileScopeReaders(new Dictionary<EventLogId, IEventColumnReader> { [logC] = Reader(logC, 6, 0, 2000) });
+        RebuildRequest towardsC = state.CaptureScopeReseed();
+
+        Assert.False(state.TryAdoptRebuild(towardsB, indexForB));
+
+        Assert.Equal(24, state.RowCount);
+        Assert.Equal(3, state.TrackedReaderCount);
+
+        Assert.True(state.TryAdoptRebuild(towardsC, OrderedViewState.BuildIndex(towardsC, CancellationToken.None)));
+
+        Assert.Equal(6, state.Current.Count);
+        Assert.Equal(6, state.RowCount);
+        Assert.Equal(1, state.TrackedReaderCount);
+    }
+
+    [Fact]
+    public void TailReplay_IteratesCurrentCoverage_RecoversDuringBuildTailForEnteringScope()
+    {
+        EventLogId logA = EventLogId.Create();
+        EventLogId logB = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        AdoptScope(state, [logA], new Dictionary<EventLogId, IEventColumnReader> { [logA] = Reader(logA, 10, 0, 0) });
+
+        Assert.True(state.TrySetActiveScope([logA, logB], ViewRequests.NextSequence()));
+        RebuildRequest reseed = state.CaptureScopeReseed();
+        ChunkedOrderIndex candidate = OrderedViewState.BuildIndex(reseed, CancellationToken.None);
+
+        Assert.Equal(10, candidate.Count);
+
+        Assert.False(state.ReconcileLog(logB, Reader(logB, 12, 0, 1000)));
+
+        Assert.True(state.TryAdoptRebuild(reseed, candidate));
+
+        Assert.Equal(22, state.Current.Count);
+        for (int index = 0; index < 12; index++) { Assert.True(state.Current.Contains(logB, 0, index)); }
+
+        AssertNoDuplicateLocators(state.Current);
+    }
+
+    [Fact]
+    public void ZeroRowFirstSight_DoesNotClaimTheDisplayedGeneration_SoAPendingReloadCanStillBecomeDisplayed()
+    {
+        EventLogId logId = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        Assert.False(state.ReconcileLog(logId, Reader(logId, 0, 0, 0)));
+
+        state.BeginReset(logId, newGeneration: 1);
+
+        Assert.True(state.ReconcileLog(logId, Reader(logId, 5, 1, 500)));
+
+        state.Publish();
+
+        Assert.Equal(5, state.Current.Count);
+        Assert.Contains(new LogGeneration(logId, 1), state.AdoptedInScope);
+    }
+
+    [Fact]
+    public void ZeroRowFirstSight_EstablishesNoDisplayedGeneration_SoTheLogStaysUnroutable()
+    {
+        EventLogId logId = EventLogId.Create();
+        var state = new OrderedViewState();
+
+        AdoptScope(state, [logId], new Dictionary<EventLogId, IEventColumnReader> { [logId] = Reader(logId, 0, 0, 0) });
+
+        Assert.Equal(0, state.Current.Count);
+        Assert.Empty(state.AdoptedInScope);
+
+        Assert.True(state.ReconcileLog(logId, Reader(logId, 6, 0, 0)));
+        state.Publish();
+
+        Assert.Equal(6, state.Current.Count);
+        Assert.Contains(new LogGeneration(logId, 0), state.AdoptedInScope);
+    }
+
+    private static void AdoptScope(
+        OrderedViewState state,
+        IReadOnlyCollection<EventLogId> scopeLogs,
+        IReadOnlyDictionary<EventLogId, IEventColumnReader> scopeReaders)
+    {
+        Assert.True(state.TrySetActiveScope(scopeLogs, ViewRequests.NextSequence()));
+        state.ReconcileScopeReaders(scopeReaders);
+
+        RebuildRequest request = state.BeginRebuild(static (_, _) => true, s_context);
+
+        Assert.True(state.TryAdoptRebuild(request, OrderedViewState.BuildIndex(request, CancellationToken.None)));
+    }
+
+    private static void AssertNoDuplicateLocators(OrderedViewSnapshot snapshot)
+    {
+        var seen = new HashSet<EventLocator>(snapshot.Count);
+
+        for (int i = 0; i < snapshot.Count; i++)
+        {
+            Assert.True(seen.Add(snapshot.At(i).Locator), $"duplicate locator at display position {i}");
+        }
+    }
+
+    private static IEventColumnReader Reader(EventLogId logId, int count, int generation, long recordIdBase)
+    {
+        var clock = new DateTime(2026, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+        var events = new List<ResolvedEvent>(count);
+
+        for (int i = 0; i < count; i++)
+        {
+            events.Add(new ResolvedEvent("Log", LogPathType.Channel)
+            {
+                RecordId = recordIdBase + i,
+                TimeCreated = clock.AddMilliseconds(recordIdBase + i),
+                Id = 1000,
+                Level = "Information",
+                Source = "Provider.A",
+                LogName = "Channel"
+            });
+        }
+
+        return EventColumnStore.Build(events, generation, generation).CreateReader(logId);
+    }
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/OrderedViewScopeStateTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/OrderedViewScopeStateTests.cs
new file mode 100644
index 000000000..294214655
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/OrderedViewScopeStateTests.cs
@@ -0,0 +1,31 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Runtime.LogTable.OrderedView;
+
+namespace EventLogExpert.Runtime.Tests.LogTable.OrderedView;
+
+public sealed class OrderedViewScopeStateTests
+{
+    [Fact]
+    public void TrySetScope_AfterReset_StillRejectsAStaleLowerVersion()
+    {
+        var scope = new OrderedViewScopeState();
+        Assert.True(scope.TrySetScope([], scopeVersion: 5));
+
+        scope.Reset();
+
+        Assert.False(scope.TrySetScope([], scopeVersion: 3));
+        Assert.Equal(5L, scope.ScopeVersion);
+    }
+
+    [Fact]
+    public void TrySetScope_RejectsAStrictlyLowerVersion()
+    {
+        var scope = new OrderedViewScopeState();
+
+        Assert.True(scope.TrySetScope([], scopeVersion: 5));
+        Assert.False(scope.TrySetScope([], scopeVersion: 4));
+        Assert.Equal(5L, scope.ScopeVersion);
+    }
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/OrderedViewShadowHarness.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/OrderedViewShadowHarness.cs
new file mode 100644
index 000000000..99340a49e
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/OrderedViewShadowHarness.cs
@@ -0,0 +1,93 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Runtime.EventLog;
+using EventLogExpert.Runtime.LogTable;
+using EventLogExpert.Runtime.LogTable.OrderedView;
+using EventLogExpert.Runtime.Tests.LogTable.TestSupport;
+using Fluxor;
+using NSubstitute;
+using IDispatcher = Fluxor.IDispatcher;
+
+namespace EventLogExpert.Runtime.Tests.LogTable.OrderedView;
+
+internal sealed class OrderedViewShadowHarness : IAsyncDisposable
+{
+    private EventLogState _eventLog = new();
+    private LogTableState _logTable = new();
+    private RawEventStoreState _rawStore = new();
+
+    public OrderedViewShadowHarness()
+    {
+        var logTableState = Substitute.For<IState<LogTableState>>();
+        logTableState.Value.Returns(_ => _logTable);
+
+        var rawEventStore = Substitute.For<IState<RawEventStoreState>>();
+        rawEventStore.Value.Returns(_ => _rawStore);
+
+        var eventLogState = Substitute.For<IState<EventLogState>>();
+        eventLogState.Value.Returns(_ => _eventLog);
+
+        Bridge = new OrderedViewDispatchBridge(Dispatcher, Writer);
+
+        Effects = new OrderedViewShadowEffects(eventLogState,
+            logTableState,
+            rawEventStore,
+            Writer,
+            Issuer,
+            Bridge,
+            Dispatcher,
+            new EventLogConcurrencyState());
+    }
+
+    public OrderedViewDispatchBridge Bridge { get; }
+
+    public IDispatcher Dispatcher { get; } = Substitute.For<IDispatcher>();
+
+    public OrderedViewShadowEffects Effects { get; }
+
+    public ViewRequestIssuer Issuer { get; } = new();
+
+    public OrderedViewWriter Writer { get; } = new(publishIntervalMs: 0);
+
+    public async ValueTask DisposeAsync()
+    {
+        Bridge.Dispose();
+        await Writer.DisposeAsync();
+    }
+
+    public async Task<OrderedViewUpdate> DrainToUpdateAsync(CancellationToken cancellationToken)
+    {
+        OrderedViewUpdate? latest = null;
+        Lock gate = new();
+
+        void Capture(OrderedViewUpdate update)
+        {
+            lock (gate) { latest = update; }
+        }
+
+        Writer.Updated += Capture;
+
+        try
+        {
+            await Writer.DrainAsync().WaitAsync(OrderedViewTestTimeouts.Default, cancellationToken);
+            await Writer.DrainAsync().WaitAsync(OrderedViewTestTimeouts.Default, cancellationToken);
+        }
+        finally
+        {
+            Writer.Updated -= Capture;
+        }
+
+        lock (gate)
+        {
+            return latest ?? throw new InvalidOperationException("The writer raised no update.");
+        }
+    }
+
+    public void SetState(LogTableState logTable, RawEventStoreState rawStore, EventLogState eventLog)
+    {
+        _logTable = logTable;
+        _rawStore = rawStore;
+        _eventLog = eventLog;
+    }
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/OrderedViewShadowTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/OrderedViewShadowTests.cs
new file mode 100644
index 000000000..65d90ca9c
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/OrderedViewShadowTests.cs
@@ -0,0 +1,1337 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.Channels;
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
+using EventLogExpert.Filtering.Persistence;
+using EventLogExpert.Logging.Abstractions;
+using EventLogExpert.Runtime.EventLog;
+using EventLogExpert.Runtime.Histogram;
+using EventLogExpert.Runtime.LogTable;
+using EventLogExpert.Runtime.LogTable.OrderedView;
+using EventLogExpert.Runtime.Tests.LogTable.TestSupport;
+using Fluxor;
+using NSubstitute;
+using System.Collections.Immutable;
+using CloseLogAction = EventLogExpert.Runtime.LogTable.CloseLogAction;
+using Reducers = EventLogExpert.Runtime.LogTable.Reducers;
+using static EventLogExpert.Runtime.Tests.LogTable.OrderedView.CombinedViewParityAsserts;
+using static EventLogExpert.Runtime.Tests.TestUtils.RetainedViewTestFactory;
+
+namespace EventLogExpert.Runtime.Tests.LogTable.OrderedView;
+
+public sealed class OrderedViewShadowTests
+{
+    [Fact]
+    public async Task AFrameThatRe_TrustsTheEngine_AlsoCommitsTheOrderingItWasBuiltUnder()
+    {
+        RoutedSetup setup = await BuildRoutedAsync(seed: 105, count: 60, TestContext.Current.CancellationToken, ColumnName.Source);
+        LogTableState pending = PendingSortState(setup) with { OrderedViewDisplayEnabled = false };
+
+        LogTableState after = Reducers.ReduceOrderedViewUpdated(pending, Republish(setup));
+
+        Assert.True(after.OrderedViewDisplayEnabled);
+        Assert.Equal(pending.RequestedGroupBy, after.GroupBy);
+        Assert.False(after.HasPendingSortChange);
+    }
+
+    [Fact]
+    public async Task ARetainedView_IsNotServedAfterItsScopeShrank()
+    {
+        RoutedSetup setup = await BuildRoutedAsync(seed: 204, count: 60, TestContext.Current.CancellationToken);
+
+        var departed = EventLogId.Create();
+        ViewIdentity current = setup.Routed.ViewIdentity;
+
+        LogTableState shrunk = Retaining(setup) with
+        {
+            RetainedOrderedViews = RetainedMap(setup.Update with
+            {
+                Identity = new ViewIdentity(current.ActiveLogId,
+                    current.Scope.Add(departed),
+                    current.RequestedOrderBy,
+                    current.RequestedIsDescending,
+                    current.RequestedGroupBy,
+                    current.RequestedIsGroupDescending,
+                    current.TimelineVisible,
+                    current.IsMultiLogDisplay,
+                    current.Filter)
+            })
+        };
+
+        Assert.Same(EmptyColumnView.Instance, shrunk.EventsForLog(setup.LogId));
+    }
+
+    [Fact]
+    public async Task ARetainedView_IsNotServedAfterTheFilterChanged()
+    {
+        RoutedSetup setup = await BuildRoutedAsync(seed: 202, count: 60, TestContext.Current.CancellationToken);
+
+        LogTableState filtered = Retaining(setup) with
+        {
+            AppliedFilter = new Filter(new DateFilter { IsEnabled = true }, [])
+        };
+
+        Assert.Same(EmptyColumnView.Instance, filtered.EventsForLog(setup.LogId));
+    }
+
+    [Fact]
+    public async Task ARetainedView_IsNotServedAfterTheOrderingItWasBuiltUnderMoved()
+    {
+        RoutedSetup setup = await BuildRoutedAsync(seed: 203, count: 60, TestContext.Current.CancellationToken);
+
+        LogTableState reordered = Retaining(setup) with { GroupBy = ColumnName.Source };
+
+        Assert.Same(EmptyColumnView.Instance, reordered.EventsForLog(setup.LogId));
+    }
+
+    [Fact]
+    public async Task ARetainedView_IsNotServedToADifferentTab()
+    {
+        RoutedSetup setup = await BuildRoutedAsync(seed: 201, count: 60, TestContext.Current.CancellationToken);
+
+        var otherTab = EventLogId.Create();
+
+        Assert.Same(EmptyColumnView.Instance, Retaining(setup).EventsForLog(otherTab));
+    }
+
+    [Fact]
+    public async Task ARetainedView_IsNotServedToADifferentTabCoveringTheSameLogs()
+    {
+        RoutedSetup setup = await BuildRoutedAsync(seed: 206, count: 60, TestContext.Current.CancellationToken);
+        ViewIdentity current = setup.Routed.ViewIdentity;
+
+        LogTableState otherTab = Retaining(setup) with
+        {
+            RetainedOrderedViews = RetainedMap(setup.Update with
+            {
+                Identity = new ViewIdentity(EventLogId.Create(),
+                    current.Scope,
+                    current.RequestedOrderBy,
+                    current.RequestedIsDescending,
+                    current.RequestedGroupBy,
+                    current.RequestedIsGroupDescending,
+                    current.TimelineVisible,
+                    current.IsMultiLogDisplay,
+                    current.Filter)
+            })
+        };
+
+        Assert.False(otherTab.IsRetainedViewServable(setup.LogId));
+    }
+
+    [Fact]
+    public async Task ARetainedView_IsNotTakenFromAnUpdateTheDisplayNeverServed()
+    {
+        RoutedSetup setup = await BuildRoutedAsync(seed: 207, count: 60, TestContext.Current.CancellationToken);
+
+        OrderedViewReady onScreen = setup.Update with { SnapshotVersion = setup.Update.SnapshotVersion - 1 };
+
+        LogTableState declined = setup.Routed with
+        {
+            RequestedOrderBy = ColumnName.Source,
+            RetainedOrderedViews = RetainedMap(onScreen)
+        };
+
+        Assert.NotNull(declined.ActiveOrderedView);
+        Assert.Null(declined.ServingOrderedView);
+
+        LogTableState afterDrop = Reducers.ReduceSetOrderBy(declined, new SetOrderByAction(ColumnName.Level));
+
+        Assert.Same(onScreen, afterDrop.RetainedFor(onScreen));
+    }
+
+    [Fact]
+    public async Task ARetainedView_IsStillServedByAFaultedEngine_BecauseTheRowsWereAlreadyOnScreen()
+    {
+        RoutedSetup setup = await BuildRoutedAsync(seed: 205, count: 60, TestContext.Current.CancellationToken);
+
+        LogTableState faulted = Retaining(setup) with { OrderedViewDisplayEnabled = false };
+
+        Assert.True(faulted.IsRetainedViewServable(setup.Routed.ActiveEventLogId!.Value));
+        Assert.Equal(PresentationState.Faulted, faulted.PresentationState);
+    }
+
+    [Fact]
+    public async Task ARetainedView_ServesTheSameTabWhileTheNextOneIsBuilding()
+    {
+        RoutedSetup setup = await BuildRoutedAsync(seed: 200, count: 60, TestContext.Current.CancellationToken);
+
+        Assert.Same(setup.Update.View, Retaining(setup).EventsForLog(setup.LogId));
+    }
+
+    [Fact]
+    public async Task ASortChange_RetainsWhatWasOnScreenWithoutWaitingForTheDriver()
+    {
+        RoutedSetup setup = await BuildRoutedAsync(seed: 205, count: 60, TestContext.Current.CancellationToken);
+
+        Assert.NotNull(setup.Routed.ServingOrderedView);
+
+        LogTableState afterSort = Reducers.ReduceSetOrderBy(setup.Routed, new SetOrderByAction(ColumnName.Source));
+
+        Assert.Null(afterSort.ServingOrderedView);
+        Assert.Same(setup.Update, afterSort.RetainedFor(setup.Update));
+    }
+
+    [Fact]
+    public async Task AddingASecondLog_ReturningToTheFirst_ServesItsRetainedViewNotBlank()
+    {
+        RoutedSetup setup = await BuildRoutedAsync(seed: 94, count: 60, TestContext.Current.CancellationToken);
+        EventLogId logA = setup.LogId;
+
+        Assert.True(setup.Update.View.Count > 0);
+        Assert.NotSame(EmptyColumnView.Instance, setup.Update.View);
+
+        LogTableState afterAdd = Reducers.ReduceAddTable(
+            setup.Routed, new AddTableAction(new EventLogData("Log1", LogPathType.Channel)));
+
+        Assert.NotEqual(logA, afterAdd.ActiveEventLogId);
+        Assert.Same(EmptyColumnView.Instance, afterAdd.EventsForLog(logA));
+
+        LogTableState backOnA = Reducers.ReduceSetActiveTable(afterAdd, new SetActiveTableAction(logA));
+
+        Assert.Equal(logA, backOnA.ActiveEventLogId);
+        Assert.False(backOnA.IsOrderedViewServing(logA));
+        Assert.True(backOnA.IsRetainedViewServable(logA));
+        Assert.Same(setup.Update, backOnA.RetainedFor(setup.Update));
+        Assert.Same(setup.Update.View, backOnA.EventsForLog(logA));
+        Assert.True(backOnA.OrderingIsStale);
+        Assert.Equal(PresentationState.Updating, backOnA.PresentationState);
+
+        LogTableState withoutRetention = backOnA with
+        {
+            RetainedOrderedViews = ImmutableDictionary<EventLogId, OrderedViewReady>.Empty
+        };
+
+        Assert.Same(EmptyColumnView.Instance, withoutRetention.EventsForLog(logA));
+    }
+
+    [Fact]
+    public async Task AdoptingANewGrouping_ClearsTheCollapseKeysOfTheGroupingItReplaces()
+    {
+        RoutedSetup setup = await BuildRoutedAsync(seed: 103, count: 60, TestContext.Current.CancellationToken, ColumnName.Source);
+        LogTableState pending = PendingSortState(setup) with
+        {
+            GroupsCollapsedByDefault = true,
+            GroupCollapseOverrides = ImmutableHashSet.Create(StringComparer.Ordinal, "1000")
+        };
+
+        LogTableState committed = Reducers.ReduceOrderedViewUpdated(pending, Republish(setup));
+
+        Assert.False(committed.GroupsCollapsedByDefault);
+        Assert.Empty(committed.GroupCollapseOverrides);
+    }
+
+    [Fact]
+    public async Task AdoptingTheEnginesAnswer_CommitsTheOrderingItWasBuiltFor()
+    {
+        RoutedSetup setup = await BuildRoutedAsync(seed: 101, count: 60, TestContext.Current.CancellationToken, ColumnName.Source);
+        LogTableState pending = PendingSortState(setup);
+
+        Assert.True(pending.HasPendingSortChange);
+
+        LogTableState committed = Reducers.ReduceOrderedViewUpdated(pending, Republish(setup));
+
+        Assert.Equal(ColumnName.Source, committed.GroupBy);
+        Assert.False(committed.HasPendingSortChange);
+    }
+
+    [Fact]
+    public async Task AfterAnEngineFault_TheRetainedViewServes()
+    {
+        RoutedSetup setup = await BuildRoutedAsync(seed: 98, count: 60, TestContext.Current.CancellationToken);
+        EventLogId logA = setup.LogId;
+
+        LogTableState faulted = Reducers.ReduceOrderedViewDisplayFaulted(setup.Routed, Faults.Any);
+
+        Assert.False(faulted.OrderedViewDisplayEnabled);
+        Assert.Same(setup.Update.View, faulted.EventsForLog(logA));
+
+        LogTableState withoutRetention = faulted with
+        {
+            RetainedOrderedViews = ImmutableDictionary<EventLogId, OrderedViewReady>.Empty
+        };
+
+        Assert.Equal(0, withoutRetention.EventsForLog(logA).Count);
+    }
+
+    [Fact]
+    public async Task ApplyFilter_ActiveDateRange_ShadowMatchesLiveFilteredSubset()
+    {
+        var sample = new OrderedViewSample(seed: 31, logCount: 1);
+        sample.SeedInterleaved(120);
+        EventLogId logId = sample.LogId(0);
+
+        await using var harness = new OrderedViewShadowHarness();
+
+        var (unfiltered, rawStore, eventLog, reader) = SingleLog(logId, sample.Events(0), descending: true);
+        harness.SetState(unfiltered, rawStore, eventLog);
+        await harness.Effects.HandleLoadEvents(new LoadEventsAction(LogData(logId), sample.Events(0)), harness.Dispatcher);
+
+        OrderedViewSnapshot unfilteredSnapshot = await harness.Writer.DrainAsync();
+        int unfilteredCount = unfilteredSnapshot.Count;
+        AssertShadowMatchesReference(unfilteredSnapshot, reader, logId, sample.Events(0), unfiltered.SortContext);
+
+        var filter = new Filter(
+            new DateFilter { After = sample.Events(0)[20].TimeCreated, Before = sample.Events(0)[90].TimeCreated, IsEnabled = true },
+            []);
+        var (filtered, _, filteredEventLog, _) = SingleLogFiltered(logId, sample.Events(0), filter, descending: true);
+        harness.SetState(filtered, rawStore, filteredEventLog);
+        await harness.Effects.HandleApplyFilter(new ApplyFilterAction(filter), harness.Dispatcher);
+
+        OrderedViewSnapshot filteredSnapshot = await harness.Writer.DrainAsync();
+
+        Assert.InRange(filteredSnapshot.Count, 1, unfilteredCount - 1);
+        AssertShadowSurvivorsAreInReferenceOrder(filteredSnapshot, reader, sample.Events(0), filtered.SortContext);
+        Assert.Null(harness.Issuer.LastFault);
+    }
+
+    [Fact]
+    public async Task ApplyFilter_ColumnFilter_ShadowMatchesLiveSurvivorPredicate()
+    {
+        var sample = new OrderedViewSample(seed: 41, logCount: 1);
+        sample.SeedInterleaved(120);
+        EventLogId logId = sample.LogId(0);
+
+        await using var harness = new OrderedViewShadowHarness();
+        var (unfiltered, rawStore, eventLog, reader) = SingleLog(logId, sample.Events(0), descending: true);
+        harness.SetState(unfiltered, rawStore, eventLog);
+        await harness.Effects.HandleLoadEvents(new LoadEventsAction(LogData(logId), sample.Events(0)), harness.Dispatcher);
+        int unfilteredCount = (await harness.Writer.DrainAsync()).Count;
+
+        SavedFilter levelError = SavedFilter.TryCreate("Level == \"Error\"") ??
+            throw new InvalidOperationException("Level filter failed to compile.");
+        var filter = new Filter(null, [levelError]);
+        var (filtered, _, filteredEventLog, _) = SingleLogFiltered(logId, sample.Events(0), filter, descending: true);
+        harness.SetState(filtered, rawStore, filteredEventLog);
+        await harness.Effects.HandleApplyFilter(new ApplyFilterAction(filter), harness.Dispatcher);
+
+        OrderedViewSnapshot filteredSnapshot = await harness.Writer.DrainAsync();
+
+        Assert.InRange(filteredSnapshot.Count, 1, unfilteredCount - 1);
+        AssertShadowSurvivorsAreInReferenceOrder(filteredSnapshot, reader, sample.Events(0), filtered.SortContext);
+        Assert.Null(harness.Issuer.LastFault);
+    }
+
+    [Fact]
+    public async Task ApplyFilter_DisabledDateFilterClearsAnActiveFilter_ShadowReturnsToEveryRow()
+    {
+        var sample = new OrderedViewSample(seed: 37, logCount: 1);
+        sample.SeedInterleaved(90);
+        EventLogId logId = sample.LogId(0);
+
+        await using var harness = new OrderedViewShadowHarness();
+        var (unfiltered, rawStore, eventLog, reader) = SingleLog(logId, sample.Events(0), descending: true);
+        harness.SetState(unfiltered, rawStore, eventLog);
+        await harness.Effects.HandleLoadEvents(new LoadEventsAction(LogData(logId), sample.Events(0)), harness.Dispatcher);
+        int fullCount = (await harness.Writer.DrainAsync()).Count;
+
+        SavedFilter levelError = SavedFilter.TryCreate("Level == \"Error\"") ??
+            throw new InvalidOperationException("Level filter failed to compile.");
+        var active = new Filter(null, [levelError]);
+        var (activeState, _, activeEventLog, _) = SingleLogFiltered(logId, sample.Events(0), active, descending: true);
+        harness.SetState(activeState, rawStore, activeEventLog);
+        await harness.Effects.HandleApplyFilter(new ApplyFilterAction(active), harness.Dispatcher);
+
+        OrderedViewSnapshot narrowed = await harness.Writer.DrainAsync();
+        Assert.InRange(narrowed.Count, 1, fullCount - 1);
+        AssertShadowSurvivorsAreInReferenceOrder(narrowed, reader, sample.Events(0), activeState.SortContext);
+
+        var disabled = new Filter(
+            new DateFilter { After = sample.Events(0)[40].TimeCreated, Before = sample.Events(0)[41].TimeCreated, IsEnabled = false },
+            []);
+        var (fullState, _, fullEventLog, _) = SingleLogFiltered(logId, sample.Events(0), disabled, descending: true);
+        harness.SetState(fullState, rawStore, fullEventLog);
+        await harness.Effects.HandleApplyFilter(new ApplyFilterAction(disabled), harness.Dispatcher);
+
+        AssertShadowMatchesReference(
+            await harness.Writer.DrainAsync(), reader, logId, sample.Events(0), fullState.SortContext);
+
+        Assert.Null(harness.Issuer.LastFault);
+    }
+
+    [Fact]
+    public async Task CloseAllLogs_EmptiesTheShadow()
+    {
+        var sample = new OrderedViewSample(seed: 13, logCount: 1);
+        sample.SeedInterleaved(50);
+        EventLogId logId = sample.LogId(0);
+
+        await using var harness = new OrderedViewShadowHarness();
+        var (logTable, rawStore, eventLog, _) = SingleLog(logId, sample.Events(0), descending: true);
+        harness.SetState(logTable, rawStore, eventLog);
+        await harness.Effects.HandleLoadEvents(new LoadEventsAction(LogData(logId), sample.Events(0)), harness.Dispatcher);
+        Assert.True((await harness.Writer.DrainAsync()).Count > 0);
+
+        harness.SetState(new LogTableState(), new RawEventStoreState(), new EventLogState());
+        await harness.Effects.HandleCloseAllLogs(harness.Dispatcher);
+
+        Assert.Equal(0, (await harness.Writer.DrainAsync()).Count);
+        Assert.Null(harness.Issuer.LastFault);
+    }
+
+    [Fact]
+    public async Task CloseThenReopenWithFreshId_ShadowRebuildsForTheNewLog()
+    {
+        var sample = new OrderedViewSample(seed: 53, logCount: 1);
+        sample.SeedInterleaved(50);
+        EventLogId original = sample.LogId(0);
+        IReadOnlyList<ResolvedEvent> events = [.. sample.Events(0)];
+
+        await using var harness = new OrderedViewShadowHarness();
+        var (loaded, loadedRaw, eventLog, _) = SingleLog(original, events, descending: true);
+        harness.SetState(loaded, loadedRaw, eventLog);
+        await harness.Effects.HandleLoadEvents(new LoadEventsAction(LogData(original), events), harness.Dispatcher);
+        Assert.True((await harness.Writer.DrainAsync()).Count > 0);
+
+        harness.SetState(new LogTableState(), new RawEventStoreState(), new EventLogState());
+        await harness.Effects.HandleCloseLog(new CloseLogAction(original), harness.Dispatcher);
+        Assert.Equal(0, (await harness.Writer.DrainAsync()).Count);
+
+        EventLogId reopened = EventLogId.Create();
+        var (reloaded, reloadedRaw, _, reopenedReader) = SingleLog(reopened, events, descending: true);
+        harness.SetState(reloaded, reloadedRaw, eventLog);
+        await harness.Effects.HandleLoadEvents(new LoadEventsAction(LogData(reopened), events), harness.Dispatcher);
+        AssertShadowMatchesReference(
+            await harness.Writer.DrainAsync(), reopenedReader, reopened, events, reloaded.SortContext);
+
+        Assert.Null(harness.Issuer.LastFault);
+    }
+
+    [Fact]
+    public async Task Disabled_ShadowIgnoresEveryAction()
+    {
+        var sample = new OrderedViewSample(seed: 17, logCount: 1);
+        sample.SeedInterleaved(30);
+        EventLogId logId = sample.LogId(0);
+
+        await using var harness = new OrderedViewShadowHarness();
+        harness.Issuer.Enabled = false;
+        var (logTable, rawStore, eventLog, _) = SingleLog(logId, sample.Events(0), descending: true);
+        harness.SetState(logTable, rawStore, eventLog);
+
+        await harness.Effects.HandleLoadEvents(new LoadEventsAction(LogData(logId), sample.Events(0)), harness.Dispatcher);
+
+        Assert.Equal(0, (await harness.Writer.DrainAsync()).Count);
+        Assert.Null(harness.Issuer.LastFault);
+    }
+
+    [Fact]
+    public async Task ForcingTheGroupingOff_RecordsWhatWasOnScreen_BecauseNothingLaterCan()
+    {
+        RoutedSetup setup = await BuildRoutedAsync(seed: 411, count: 60, TestContext.Current.CancellationToken);
+
+        LogTableState groupedRequest = setup.Routed with
+        {
+            GroupBy = ColumnName.Source, RequestedGroupBy = ColumnName.Source
+        };
+
+        LogTableState grouped = groupedRequest with
+        {
+            ActiveOrderedView = setup.Update with { Config = groupedRequest.SortContext }
+        };
+
+        Assert.NotNull(grouped.ServingOrderedView);
+
+        LogTableState ungrouped = Reducers.ReduceLoadColumnsCompleted(
+            grouped,
+            new LoadColumnsCompletedAction(
+                ImmutableDictionary<ColumnName, bool>.Empty.Add(ColumnName.Source, false),
+                grouped.ColumnWidths,
+                grouped.ColumnOrder));
+
+        Assert.Equal(ColumnName.Source, ungrouped.GroupBy);
+        Assert.Null(ungrouped.RequestedGroupBy);
+        Assert.Same(grouped.ServingOrderedView, ungrouped.RetainedFor(grouped.ServingOrderedView!));
+    }
+
+    [Fact]
+    public async Task GoNoGo_AfterAFault_TheDisplayKeepsTheRowsTheUserWasReading()
+    {
+        RoutedSetup setup = await BuildRoutedAsync(seed: 900, count: 60, TestContext.Current.CancellationToken);
+
+        Assert.True(setup.Routed.GetActiveDisplayedEvents().Count > 0);
+
+        LogTableState faulted = Reducers.ReduceOrderedViewDisplayFaulted(setup.Routed, Faults.Any);
+
+        Assert.False(faulted.OrderedViewDisplayEnabled);
+        Assert.Equal(PresentationState.Faulted, faulted.PresentationState);
+
+        Assert.True(
+            faulted.GetActiveDisplayedEvents().Count > 0,
+            "A faulted display must keep the rows the user was already reading. The fault is reported by the "
+            + "presentation state and its cause, not by taking the rows away.");
+
+        Assert.True(
+            faulted.IsRetainedViewServable(setup.Routed.ActiveEventLogId!.Value),
+            "and the retained bridge must be what carries them once the old path is gone");
+    }
+
+    [Fact]
+    public async Task GroupRestructure_MoveTabIntoGroup_ExpandsActiveScopeShadowReconcilesBothMembers()
+    {
+        var sample = new OrderedViewSample(seed: 59, logCount: 2);
+        sample.SeedInterleaved(80);
+        EventLogId member0 = sample.LogId(0), member1 = sample.LogId(1);
+        var groupId = LogTabGroupId.Create();
+        var header = new LogView(EventLogId.Create()) { GroupId = groupId };
+
+        var rawStore = new RawEventStoreState
+        {
+            ByLog = ImmutableDictionary<EventLogId, EventColumnStore>.Empty
+                .Add(member0, EventColumnStore.Build(sample.Events(0), 0, 0))
+                .Add(member1, EventColumnStore.Build(sample.Events(1), 0, 0))
+        };
+
+        LogTableState GroupState(ImmutableHashSet<EventLogId> members) => CommittedFrom(new LogTableState
+        {
+            ActiveEventLogId = header.Id,
+            EventTables = [header, new LogView(member0), new LogView(member1)],
+            Groups = [new LogTabGroup(groupId, "Group", members)],
+            IsDescending = true,
+            RequestedIsDescending = true
+        });
+
+        await using var harness = new OrderedViewShadowHarness();
+
+        LogTableState oneMember = GroupState([member0]);
+        harness.SetState(oneMember, rawStore, new EventLogState());
+        await harness.Effects.HandleNewGroupFromTab(harness.Dispatcher);
+        IEventColumnReader member0Reader = EventColumnStore.Build(sample.Events(0), 0, 0).CreateReader(member0);
+        OrderedViewSnapshot oneMemberSnapshot = await harness.Writer.DrainAsync();
+        AssertShadowMatchesReference(
+            oneMemberSnapshot, member0Reader, member0, sample.Events(0), oneMember.SortContext);
+        int oneMemberCount = oneMemberSnapshot.Count;
+
+        LogTableState twoMembers = GroupState([member0, member1]);
+        harness.SetState(twoMembers, rawStore, new EventLogState());
+        await harness.Effects.HandleMoveTabToGroup(harness.Dispatcher);
+
+        OrderedViewSnapshot snapshot = await harness.Writer.DrainAsync();
+
+        Assert.True(snapshot.Count > oneMemberCount);
+        Assert.Equal(sample.Events(0).Count + sample.Events(1).Count, snapshot.Count);
+        Assert.Null(harness.Issuer.LastFault);
+    }
+
+    [Fact]
+    public async Task InitialLoad_ShadowMatchesLiveDefaultDescendingOrder()
+    {
+        var sample = new OrderedViewSample(seed: 7, logCount: 1);
+        sample.SeedInterleaved(80);
+        EventLogId logId = sample.LogId(0);
+        var (logTable, rawStore, eventLog, reader) = SingleLog(logId, sample.Events(0), descending: true);
+
+        await using var harness = new OrderedViewShadowHarness();
+        harness.SetState(logTable, rawStore, eventLog);
+        await harness.Effects.HandleLoadEvents(new LoadEventsAction(LogData(logId), sample.Events(0)), harness.Dispatcher);
+
+        AssertShadowMatchesReference(
+            await harness.Writer.DrainAsync(), reader, logId, sample.Events(0), logTable.SortContext);
+
+        Assert.Null(harness.Issuer.LastFault);
+    }
+
+    [Fact]
+    public async Task Invalidating_KeepsWhatWasOnScreenRatherThanLosingIt()
+    {
+        RoutedSetup setup = await BuildRoutedAsync(seed: 206, count: 60, TestContext.Current.CancellationToken);
+
+        LogTableState invalidated = Reducers.ReduceViewRequestInvalidated(
+            setup.Routed,
+            new ViewRequestInvalidatedAction(setup.Routed.HighestInvalidationSequence + 1));
+
+        Assert.Null(invalidated.ActiveOrderedView);
+        Assert.Same(setup.Update, invalidated.RetainedFor(setup.Update));
+    }
+
+    [Fact]
+    public async Task LiveTailAppend_IngestRawEvents_ShadowGrowsToMatchLive()
+    {
+        var sample = new OrderedViewSample(seed: 43, logCount: 1);
+        sample.SeedInterleaved(60);
+        EventLogId logId = sample.LogId(0);
+        IReadOnlyList<ResolvedEvent> initial = [.. sample.Events(0)];
+
+        await using var harness = new OrderedViewShadowHarness();
+        var (before, beforeRaw, eventLog, initialReader) = SingleLog(logId, initial, descending: true);
+        harness.SetState(before, beforeRaw, eventLog);
+        await harness.Effects.HandleLoadEvents(new LoadEventsAction(LogData(logId), initial), harness.Dispatcher);
+        AssertShadowMatchesReference(await harness.Writer.DrainAsync(), initialReader, logId, initial, before.SortContext);
+
+        sample.Append(0, 30);
+        IReadOnlyList<ResolvedEvent> grown = [.. sample.Events(0)];
+        var (after, afterRaw, _, grownReader) = SingleLog(logId, grown, descending: true);
+        harness.SetState(after, afterRaw, eventLog);
+        var appended = grown.Skip(initial.Count).ToList();
+        await harness.Effects.HandleIngestRawEvents(
+            new IngestRawEventsAction(new Dictionary<EventLogId, IReadOnlyList<ResolvedEvent>> { [logId] = appended }, RawIngestMode.Prepend),
+            harness.Dispatcher);
+
+        AssertShadowMatchesReference(await harness.Writer.DrainAsync(), grownReader, logId, grown, after.SortContext);
+        Assert.Null(harness.Issuer.LastFault);
+    }
+
+    [Fact]
+    public async Task PartialThenFinalLoad_ShadowReconcilesMonotonicallyToMatchLive()
+    {
+        var sample = new OrderedViewSample(seed: 47, logCount: 1);
+        sample.SeedInterleaved(100);
+        EventLogId logId = sample.LogId(0);
+        IReadOnlyList<ResolvedEvent> all = [.. sample.Events(0)];
+        IReadOnlyList<ResolvedEvent> partial = [.. all.Take(40)];
+
+        await using var harness = new OrderedViewShadowHarness();
+
+        var (partialState, partialRaw, eventLog, partialReader) = SingleLog(logId, partial, descending: true);
+        harness.SetState(partialState, partialRaw, eventLog);
+        await harness.Effects.HandleLoadEventsPartial(new LoadEventsPartialAction(LogData(logId), partial), harness.Dispatcher);
+        AssertShadowMatchesReference(
+            await harness.Writer.DrainAsync(), partialReader, logId, partial, partialState.SortContext);
+
+        var (finalState, finalRaw, _, finalReader) = SingleLog(logId, all, descending: true);
+        harness.SetState(finalState, finalRaw, eventLog);
+        await harness.Effects.HandleLoadEvents(new LoadEventsAction(LogData(logId), all), harness.Dispatcher);
+        AssertShadowMatchesReference(await harness.Writer.DrainAsync(), finalReader, logId, all, finalState.SortContext);
+        Assert.Null(harness.Issuer.LastFault);
+    }
+
+    [Theory]
+    [InlineData(1)]
+    [InlineData(7)]
+    [InlineData(42)]
+    [InlineData(101)]
+    [InlineData(2026)]
+    [InlineData(31337)]
+    [InlineData(8675309)]
+    [InlineData(int.MaxValue)]
+    public async Task RandomizedOrderingWalk_ShadowMatchesTheReferenceAfterEveryStep(int seed)
+    {
+        const int MinSeedEvents = 30;
+        const int MaxSeedEvents = 120;
+        const int MinOperations = 90;
+        const int MaxOperations = 160;
+
+        var random = new Random(seed);
+        var sample = new OrderedViewSample(seed, logCount: 1);
+        sample.SeedInterleaved(random.Next(MinSeedEvents, MaxSeedEvents));
+        EventLogId logId = sample.LogId(0);
+        IReadOnlyList<ResolvedEvent> events = sample.Events(0);
+
+        ColumnName?[] orderColumns =
+        [
+            null, ColumnName.RecordId, ColumnName.DateAndTime, ColumnName.Source, ColumnName.EventId,
+            ColumnName.Level, ColumnName.TaskCategory, ColumnName.ComputerName
+        ];
+        ColumnName?[] groupColumns = [null, ColumnName.Source, ColumnName.EventId, ColumnName.Level];
+
+        await using var harness = new OrderedViewShadowHarness();
+
+        var (initial, rawStore, eventLog, reader) = SingleLog(logId, events, descending: random.Next(2) == 0);
+        harness.SetState(initial, rawStore, eventLog);
+        await harness.Effects.HandleLoadEvents(new LoadEventsAction(LogData(logId), events), harness.Dispatcher);
+        AssertShadowMatchesReference(await harness.Writer.DrainAsync(), reader, logId, events, initial.SortContext);
+
+        int operations = random.Next(MinOperations, MaxOperations);
+
+        for (int step = 0; step < operations; step++)
+        {
+            ColumnName? orderBy = orderColumns[random.Next(orderColumns.Length)];
+            ColumnName? groupBy = groupColumns[random.Next(groupColumns.Length)];
+            bool descending = random.Next(2) == 0;
+            bool groupDescending = random.Next(2) == 0;
+
+            LogTableState state = CommittedFrom(initial with
+            {
+                OrderBy = orderBy,
+                RequestedOrderBy = orderBy,
+                IsDescending = descending,
+                RequestedIsDescending = descending,
+                GroupBy = groupBy,
+                RequestedGroupBy = groupBy,
+                IsGroupDescending = groupDescending,
+                RequestedIsGroupDescending = groupDescending
+            });
+
+            harness.SetState(state, rawStore, eventLog);
+            await harness.Effects.HandleSetOrderBy(new SetOrderByAction(orderBy), harness.Dispatcher);
+
+            AssertShadowMatchesReference(await harness.Writer.DrainAsync(), reader, logId, events, state.SortContext);
+        }
+    }
+
+    [Fact]
+    public void ReduceApplyFilter_SemanticNoOp_RetainsTheExistingFilterInstance()
+    {
+        SavedFilter levelError = SavedFilter.TryCreate("Level == \"Error\"") ??
+            throw new InvalidOperationException("Level filter failed to compile.");
+
+        Filter original = new(null, [levelError]);
+        var state = new LogTableState { AppliedFilter = original };
+
+        LogTableState after = Reducers.ReduceApplyFilter(state, new ApplyFilterAction(new Filter(null, [levelError])));
+
+        Assert.Same(original.Filters, after.AppliedFilter.Filters);
+    }
+
+    [Fact]
+    public async Task ReduceOrderedViewDisplayFaulted_StopsTrustingTheEngineButKeepsTheRows()
+    {
+        RoutedSetup setup = await BuildRoutedAsync(seed: 82, count: 80, TestContext.Current.CancellationToken);
+
+        IEventColumnView beforeFault = setup.Routed.EventsForLog(setup.LogId);
+
+        LogTableState after = Reducers.ReduceOrderedViewDisplayFaulted(setup.Routed, Faults.Any);
+
+        Assert.False(after.OrderedViewDisplayEnabled);
+        Assert.Null(after.ActiveOrderedView);
+
+        Assert.Equal(PresentationState.Faulted, after.PresentationState);
+        Assert.Same(beforeFault, after.EventsForLog(setup.LogId));
+    }
+
+    [Fact]
+    public async Task ReduceOrderedViewUpdated_ClearedUpdateClearsRoutedView()
+    {
+        RoutedSetup setup = await BuildRoutedAsync(seed: 80, count: 80, TestContext.Current.CancellationToken);
+
+        var invalidation = new OrderedViewCleared(
+            setup.Update.SnapshotVersion + 1, setup.Routed.ViewIdentity, setup.Update.Sequence);
+        LogTableState after = Reducers.ReduceOrderedViewUpdated(setup.Routed, new OrderedViewUpdatedAction(invalidation));
+        Assert.Null(after.ActiveOrderedView);
+    }
+
+    [Fact]
+    public async Task ReduceOrderedViewUpdated_ClearedUpdateForAnotherIdentity_LeavesRoutedView()
+    {
+        RoutedSetup setup = await BuildRoutedAsync(seed: 82, count: 80, TestContext.Current.CancellationToken);
+
+        var foreign = new OrderedViewCleared(
+            setup.Update.SnapshotVersion + 1,
+            ViewRequests.Identity(scope: [EventLogId.Create()]),
+            setup.Update.Sequence);
+        LogTableState after = Reducers.ReduceOrderedViewUpdated(setup.Routed, new OrderedViewUpdatedAction(foreign));
+        Assert.Same(setup.Routed.ActiveOrderedView, after.ActiveOrderedView);
+    }
+
+    [Fact]
+    public async Task ReduceOrderedViewUpdated_RejectsAMismatchedIdentityEvenWhenNewer()
+    {
+        RoutedSetup setup = await BuildRoutedAsync(seed: 79, count: 80, TestContext.Current.CancellationToken);
+
+        OrderedViewReady wrongIdentity = setup.Update with
+        {
+            Identity = ViewRequests.Identity(scope: [EventLogId.Create()]),
+            SnapshotVersion = setup.Update.SnapshotVersion + 1
+        };
+        LogTableState after = Reducers.ReduceOrderedViewUpdated(setup.Routed, new OrderedViewUpdatedAction(wrongIdentity));
+        Assert.Same(setup.Routed.ActiveOrderedView, after.ActiveOrderedView);
+    }
+
+    [Fact]
+    public async Task ReduceOrderedViewUpdated_RejectsAPublicationFromASupersededIssue()
+    {
+        RoutedSetup setup = await BuildRoutedAsync(seed: 83, count: 80, TestContext.Current.CancellationToken);
+
+        OrderedViewReady later = setup.Update with { SnapshotVersion = setup.Update.SnapshotVersion + 5 };
+        Assert.NotNull(Reducers.ReduceOrderedViewUpdated(setup.Routed, new OrderedViewUpdatedAction(later)).ActiveOrderedView);
+
+        LogTableState invalidated = Reducers.ReduceViewRequestInvalidated(
+            setup.Routed, new ViewRequestInvalidatedAction(setup.Update.Sequence + 1));
+
+        Assert.True(later.Sequence < invalidated.HighestInvalidationSequence);
+        Assert.Null(Reducers.ReduceOrderedViewUpdated(invalidated, new OrderedViewUpdatedAction(later)).ActiveOrderedView);
+    }
+
+    [Fact]
+    public async Task ReduceOrderedViewUpdated_RejectsOlderSnapshotVersion()
+    {
+        RoutedSetup setup = await BuildRoutedAsync(seed: 78, count: 80, TestContext.Current.CancellationToken);
+
+        OrderedViewReady older = setup.Update with { SnapshotVersion = setup.Update.SnapshotVersion - 1 };
+        LogTableState after = Reducers.ReduceOrderedViewUpdated(setup.Routed, new OrderedViewUpdatedAction(older));
+        Assert.Same(setup.Routed.ActiveOrderedView, after.ActiveOrderedView);
+    }
+
+    [Fact]
+    public async Task ReduceOrderedViewUpdated_RejectsUpdateBuiltUnderASupersededIdentity()
+    {
+        RoutedSetup setup = await BuildRoutedAsync(seed: 77, count: 80, TestContext.Current.CancellationToken);
+
+        OrderedViewReady straggler = setup.Update with
+        {
+            Identity = ViewRequests.Identity(scope: [setup.LogId], orderBy: ColumnName.Level),
+            SnapshotVersion = setup.Update.SnapshotVersion + 1
+        };
+        LogTableState after = Reducers.ReduceOrderedViewUpdated(setup.Routed, new OrderedViewUpdatedAction(straggler));
+        Assert.Same(setup.Routed.ActiveOrderedView, after.ActiveOrderedView);
+    }
+
+    [Fact]
+    public async Task ReduceViewRequestInvalidated_InvalidatesRoutedViewAndAdvancesSequence()
+    {
+        RoutedSetup setup = await BuildRoutedAsync(seed: 81, count: 80, TestContext.Current.CancellationToken);
+
+        long next = setup.Routed.HighestInvalidationSequence + 1;
+        LogTableState after = Reducers.ReduceViewRequestInvalidated(setup.Routed, new ViewRequestInvalidatedAction(next));
+        Assert.Null(after.ActiveOrderedView);
+        Assert.Equal(next, after.HighestInvalidationSequence);
+    }
+
+    [Fact]
+    public async Task RoutedEngineView_ReachesTheDisplayWithEngineOrigin()
+    {
+        RoutedSetup setup = await BuildRoutedAsync(seed: 96, count: 60, TestContext.Current.CancellationToken);
+
+        Assert.True(setup.Routed.IsOrderedViewServing(setup.LogId));
+
+        var state = Substitute.For<IState<LogTableState>>();
+
+        state.Value.Returns(setup.Routed);
+
+        using var source = new OrderedViewSource(state, Substitute.For<ITraceLogger>());
+
+        Assert.Equal(PresentationState.Current, source.Current.State);
+        Assert.Same(setup.Update.View, source.Current.View);
+        Assert.Equal(setup.LogId, source.Current.ActiveTabId);
+    }
+
+    [Fact]
+    public async Task RoutingSeam_AppliedFilterMismatch_StopsServingTheViewBuiltUnderTheOldFilter()
+    {
+        RoutedSetup setup = await BuildRoutedAsync(seed: 76, count: 80, TestContext.Current.CancellationToken);
+
+        SavedFilter levelError = SavedFilter.TryCreate("Level == \"Error\"") ??
+            throw new InvalidOperationException("Level filter failed to compile.");
+        LogTableState filterChanged = setup.Routed with { AppliedFilter = new Filter(null, [levelError]) };
+        Assert.Same(EmptyColumnView.Instance, filterChanged.EventsForLog(setup.LogId));
+    }
+
+    [Fact]
+    public async Task RoutingSeam_EmptyActiveLog_ServesAFinalEmptyAnswerRatherThanWaiting()
+    {
+        EventLogId logId = EventLogId.Create();
+        await using var harness = new OrderedViewShadowHarness();
+
+        var (live, rawStore, eventLog, _) = SingleLog(logId, [], descending: true);
+        harness.SetState(live, rawStore, eventLog);
+        await harness.Effects.HandleLoadEvents(new LoadEventsAction(LogData(logId), []), harness.Dispatcher);
+
+        OrderedViewUpdate update = await DrainToUpdateAsync(harness, TestContext.Current.CancellationToken);
+
+        var ready = Assert.IsType<OrderedViewReady>(update);
+        Assert.Equal(0, ready.View.Count);
+        Assert.Equal(logId, ready.SingleLogId);
+
+        LogTableState routed = Reducers.ReduceOrderedViewUpdated(live, new OrderedViewUpdatedAction(ready));
+
+        Assert.Equal(0, routed.EventsForLog(logId).Count);
+        Assert.Equal(PresentationState.Current, routed.PresentationState);
+    }
+
+    [Fact]
+    public async Task RoutingSeam_GroupedActiveLog_ServesEngineViewWithGroupParity()
+    {
+        RoutedSetup setup = await BuildRoutedAsync(
+            seed: 73, count: 80, TestContext.Current.CancellationToken, groupBy: ColumnName.Source);
+
+        IEventColumnView routed = setup.Routed.EventsForLog(setup.LogId);
+
+        Assert.True(setup.Routed.IsOrderedViewServing(setup.LogId));
+        Assert.IsType<OrderedColumnView>(routed);
+        AssertOrderMatchesReference(routed, [(setup.LogId, setup.Events)], setup.Routed.SortContext);
+    }
+
+    [Fact]
+    public async Task RoutingSeam_NonActiveLogId_IsNeverGivenTheActiveTabsView()
+    {
+        RoutedSetup setup = await BuildRoutedAsync(seed: 75, count: 80, TestContext.Current.CancellationToken);
+
+        Assert.Same(EmptyColumnView.Instance, setup.Routed.EventsForLog(EventLogId.Create()));
+    }
+
+    [Fact]
+    public async Task RoutingSeam_OrderedViewDisplayDisabled_StopsServingTheEnginesView()
+    {
+        RoutedSetup setup = await BuildRoutedAsync(seed: 74, count: 80, TestContext.Current.CancellationToken);
+
+        LogTableState disabled = setup.Routed with { OrderedViewDisplayEnabled = false };
+        Assert.Same(EmptyColumnView.Instance, disabled.EventsForLog(setup.LogId));
+    }
+
+    [Fact]
+    public async Task RoutingSeam_PendingGroupChange_StopsServingTheViewBuiltUnderTheOldGrouping()
+    {
+        RoutedSetup setup = await BuildRoutedAsync(seed: 73, count: 80, TestContext.Current.CancellationToken);
+
+        IEventColumnView beforeRegroup = setup.Routed.EventsForLog(setup.LogId);
+
+        LogTableState pending = Reducers.ReduceSetGroupBy(setup.Routed, new SetGroupByAction(ColumnName.Source));
+
+        Assert.True(pending.HasPendingSortChange);
+        Assert.False(pending.IsOrderedViewServing(setup.LogId));
+
+        Assert.Equal(PresentationState.Updating, pending.PresentationState);
+        Assert.Same(beforeRegroup, pending.EventsForLog(setup.LogId));
+    }
+
+    [Fact]
+    public async Task RoutingSeam_PendingSortChange_DoesNotFlipTheRowsAheadOfTheHeader()
+    {
+        RoutedSetup setup = await BuildRoutedAsync(seed: 72, count: 80, TestContext.Current.CancellationToken);
+
+        LogTableState pending = setup.Routed with { OrderBy = ColumnName.Source };
+        Assert.True(pending.HasPendingSortChange);
+        Assert.Same(EmptyColumnView.Instance, pending.EventsForLog(setup.LogId));
+    }
+
+    [Fact]
+    public async Task RoutingSeam_SemanticallyEqualFilterRebuiltFromFreshCollections_StaysServed()
+    {
+        RoutedSetup setup = await BuildRoutedAsync(seed: 84, count: 80, TestContext.Current.CancellationToken);
+
+        SavedFilter levelError = SavedFilter.TryCreate("Level == \"Error\"") ??
+            throw new InvalidOperationException("Level filter failed to compile.");
+
+        Filter adopted = new(null, [levelError]);
+        Filter reapplied = new(null, [levelError]);
+
+        Assert.NotEqual(adopted, reapplied);
+
+        LogTableState state = setup.Routed with
+        {
+            AppliedFilter = reapplied, ActiveOrderedView = setup.Update with { Filter = adopted }
+        };
+
+        Assert.True(state.IsOrderedViewServing(setup.LogId));
+    }
+
+    [Fact]
+    public async Task RoutingSeam_UngroupedSingleLog_FlipsReadToOrderedViewMatchingLive()
+    {
+        RoutedSetup setup = await BuildRoutedAsync(seed: 71, count: 120, TestContext.Current.CancellationToken);
+
+        Assert.True(setup.BridgeDispatched);
+        Assert.NotNull(setup.Routed.ActiveOrderedView);
+        Assert.Same(setup.Update.View, setup.Routed.EventsForLog(setup.LogId));
+        AssertOrderMatchesReference(
+            setup.Routed.EventsForLog(setup.LogId), [(setup.LogId, setup.Events)], setup.Routed.SortContext);
+    }
+
+    [Fact]
+    public async Task SetActiveTable_SwitchesActiveLog_ShadowRescopesToTheNewLog()
+    {
+        var sample = new OrderedViewSample(seed: 61, logCount: 2);
+        sample.SeedInterleaved(80);
+        EventLogId log0 = sample.LogId(0), log1 = sample.LogId(1);
+
+        var rawStore = new RawEventStoreState
+        {
+            ByLog = ImmutableDictionary<EventLogId, EventColumnStore>.Empty
+                .Add(log0, EventColumnStore.Build(sample.Events(0), 0, 0))
+                .Add(log1, EventColumnStore.Build(sample.Events(1), 0, 0))
+        };
+
+        LogTableState StateActive(EventLogId active) => CommittedFrom(new LogTableState
+        {
+            ActiveEventLogId = active,
+            EventTables = [new LogView(log0), new LogView(log1)],
+            IsDescending = true,
+            RequestedIsDescending = true
+        });
+
+        await using var harness = new OrderedViewShadowHarness();
+
+        LogTableState active0 = StateActive(log0);
+        harness.SetState(active0, rawStore, new EventLogState());
+        await harness.Effects.HandleLoadEvents(new LoadEventsAction(LogData(log0), sample.Events(0)), harness.Dispatcher);
+        IEventColumnReader reader0 = EventColumnStore.Build(sample.Events(0), 0, 0).CreateReader(log0);
+        AssertShadowMatchesReference(
+            await harness.Writer.DrainAsync(), reader0, log0, sample.Events(0), active0.SortContext);
+
+        LogTableState active1 = StateActive(log1);
+        harness.SetState(active1, rawStore, new EventLogState());
+        await harness.Effects.HandleSetActiveTable(harness.Dispatcher);
+        IEventColumnReader reader1 = EventColumnStore.Build(sample.Events(1), 0, 0).CreateReader(log1);
+        AssertShadowMatchesReference(
+            await harness.Writer.DrainAsync(), reader1, log1, sample.Events(1), active1.SortContext);
+        Assert.Null(harness.Issuer.LastFault);
+    }
+
+    [Fact]
+    public async Task SetHistogramVisible_SingleLogNoExplicitSort_ShadowReSortsToTimelineOrder()
+    {
+        EventLogId logId = EventLogId.Create();
+        List<ResolvedEvent> events = Rows("Log0", (1, 50), (2, 10), (3, 60), (4, 20), (5, 40), (6, 30));
+
+        await using var harness = new OrderedViewShadowHarness();
+
+        var (hidden, rawStore, eventLog, reader) = SingleLog(logId, events, descending: true);
+        harness.SetState(hidden, rawStore, eventLog);
+        await harness.Effects.HandleLoadEvents(new LoadEventsAction(LogData(logId), events), harness.Dispatcher);
+        AssertShadowMatchesReference(await harness.Writer.DrainAsync(), reader, logId, events, hidden.SortContext);
+
+        LogTableState shown = CommittedFrom(new LogTableState
+        {
+            ActiveEventLogId = logId,
+            EventTables = [new LogView(logId)],
+            IsDescending = true,
+            RequestedIsDescending = true,
+            TimelineVisible = true
+        });
+        harness.SetState(shown, rawStore, eventLog);
+        await harness.Effects.HandleSetHistogramVisible(new SetHistogramVisibleAction(true), harness.Dispatcher);
+
+        AssertReferenceOrderChanges(events, hidden.SortContext, shown.SortContext);
+        AssertShadowMatchesReference(await harness.Writer.DrainAsync(), reader, logId, events, shown.SortContext);
+        Assert.Null(harness.Issuer.LastFault);
+    }
+
+    [Fact]
+    public async Task TheSurvivorOrderCheckItself_FailsWhenTheOrderIsWrong()
+    {
+        var sample = new OrderedViewSample(seed: 61, logCount: 1);
+        sample.SeedInterleaved(80);
+        EventLogId logId = sample.LogId(0);
+
+        await using var harness = new OrderedViewShadowHarness();
+        var (state, rawStore, eventLog, reader) = SingleLog(logId, sample.Events(0), descending: true);
+        harness.SetState(state, rawStore, eventLog);
+        await harness.Effects.HandleLoadEvents(new LoadEventsAction(LogData(logId), sample.Events(0)), harness.Dispatcher);
+
+        OrderedViewSnapshot snapshot = await harness.Writer.DrainAsync();
+
+        SortContext opposite = new(
+            state.SortContext.OrderBy,
+            !state.SortContext.IsDescending,
+            state.SortContext.GroupBy,
+            state.SortContext.IsGroupDescending);
+
+        Assert.ThrowsAny<Exception>(
+            () => AssertShadowSurvivorsAreInReferenceOrder(snapshot, reader, sample.Events(0), opposite));
+    }
+
+    [Fact]
+    public async Task ToggleSorting_ShadowFlipsToAscending()
+    {
+        var sample = new OrderedViewSample(seed: 11, logCount: 1);
+        sample.SeedInterleaved(80);
+        EventLogId logId = sample.LogId(0);
+
+        await using var harness = new OrderedViewShadowHarness();
+
+        var (descending, rawStore, eventLog, reader) = SingleLog(logId, sample.Events(0), descending: true);
+        harness.SetState(descending, rawStore, eventLog);
+        await harness.Effects.HandleLoadEvents(new LoadEventsAction(LogData(logId), sample.Events(0)), harness.Dispatcher);
+        AssertShadowMatchesReference(
+            await harness.Writer.DrainAsync(), reader, logId, sample.Events(0), descending.SortContext);
+
+        var (ascending, _, _, _) = SingleLog(logId, sample.Events(0), descending: false);
+        harness.SetState(ascending, rawStore, eventLog);
+        await harness.Effects.HandleToggleSorting(harness.Dispatcher);
+
+        AssertReferenceOrderChanges(sample.Events(0), descending.SortContext, ascending.SortContext);
+        AssertShadowMatchesReference(
+            await harness.Writer.DrainAsync(), reader, logId, sample.Events(0), ascending.SortContext);
+    }
+
+    [Fact]
+    public async Task TopologyGrowsToTwoLogs_ShadowReKeysActiveSingleLogTabToDateAndTime()
+    {
+        EventLogId log0 = EventLogId.Create();
+        EventLogId log1 = EventLogId.Create();
+
+        List<ResolvedEvent> events0 = Rows("Log0", (1, 50), (2, 10), (3, 60), (4, 20), (5, 40), (6, 30));
+        List<ResolvedEvent> events1 = Rows("Log1", (1, 15), (2, 25), (3, 35));
+
+        await using var harness = new OrderedViewShadowHarness();
+
+        var (oneLog, oneRaw, eventLog, reader) = SingleLog(log0, events0, descending: true);
+        harness.SetState(oneLog, oneRaw, eventLog);
+        await harness.Effects.HandleLoadEvents(new LoadEventsAction(LogData(log0), events0), harness.Dispatcher);
+        AssertShadowMatchesReference(await harness.Writer.DrainAsync(), reader, log0, events0, oneLog.SortContext);
+
+        var (twoLog, twoRaw) = TwoLogs(log0, events0, log1, events1, descending: true);
+        harness.SetState(twoLog, twoRaw, eventLog);
+        await harness.Effects.HandleAddTable(harness.Dispatcher);
+
+        AssertReferenceOrderChanges(events0, oneLog.SortContext, twoLog.SortContext);
+
+        AssertShadowMatchesReference(await harness.Writer.DrainAsync(), reader, log0, events0, twoLog.SortContext);
+        Assert.Null(harness.Issuer.LastFault);
+    }
+
+    private static void AssertReferenceOrderChanges(
+        IReadOnlyList<ResolvedEvent> events,
+        SortContext before,
+        SortContext after)
+    {
+        int[] beforeOrder = AosReferenceOrdering.Order(
+            events, before.OrderBy, before.IsDescending, before.GroupBy, before.IsGroupDescending);
+
+        int[] afterOrder = AosReferenceOrdering.Order(
+            events, after.OrderBy, after.IsDescending, after.GroupBy, after.IsGroupDescending);
+
+        Assert.NotEqual(beforeOrder, afterOrder);
+    }
+
+    private static void AssertShadowMatchesReference(
+        OrderedViewSnapshot snapshot,
+        IEventColumnReader reader,
+        EventLogId logId,
+        IReadOnlyList<ResolvedEvent> events,
+        SortContext context)
+    {
+        var shadow = new OrderedColumnView(snapshot, reader);
+
+        int[] expected = AosReferenceOrdering.Order(
+            events, context.OrderBy, context.IsDescending, context.GroupBy, context.IsGroupDescending);
+
+        Assert.Equal(expected.Length, shadow.Count);
+
+        for (int position = 0; position < expected.Length; position++)
+        {
+            EventLocator actual = shadow.LocatorAt(position);
+
+            Assert.Equal(logId, actual.LogId);
+            Assert.Equal(expected[position], actual.Index);
+        }
+    }
+
+    private static void AssertShadowSurvivorsAreInReferenceOrder(
+        OrderedViewSnapshot snapshot,
+        IEventColumnReader reader,
+        IReadOnlyList<ResolvedEvent> events,
+        SortContext context)
+    {
+        var shadow = new OrderedColumnView(snapshot, reader);
+
+        var survivors = new List<ResolvedEvent>(shadow.Count);
+
+        for (int position = 0; position < shadow.Count; position++)
+        {
+            survivors.Add(events[shadow.LocatorAt(position).Index]);
+        }
+
+        int[] resorted = AosReferenceOrdering.Order(
+            survivors, context.OrderBy, context.IsDescending, context.GroupBy, context.IsGroupDescending);
+
+        for (int position = 0; position < resorted.Length; position++)
+        {
+            Assert.Equal(position, resorted[position]);
+        }
+    }
+
+    private static async Task<RoutedSetup> BuildRoutedAsync(
+        int seed,
+        int count,
+        CancellationToken cancellationToken,
+        ColumnName? groupBy = null)
+    {
+        var sample = new OrderedViewSample(seed, logCount: 1);
+        sample.SeedInterleaved(count);
+        EventLogId logId = sample.LogId(0);
+
+        await using var harness = new OrderedViewShadowHarness();
+        bool bridgeDispatched = false;
+        harness.Dispatcher.When(dispatcher => dispatcher.Dispatch(Arg.Any<object>())).Do(callInfo =>
+        {
+            if (callInfo.Arg<object>() is OrderedViewUpdatedAction) { Volatile.Write(ref bridgeDispatched, true); }
+        });
+
+        var (initial, rawStore, eventLog, _) = SingleLog(logId, sample.Events(0), descending: true);
+
+        LogTableState live = initial with
+        {
+            AppliedFilter = eventLog.AppliedFilter,
+            GroupBy = groupBy,
+            RequestedGroupBy = groupBy
+        };
+
+        if (groupBy is not null) { live = CommittedFrom(live); }
+
+        harness.SetState(live, rawStore, eventLog);
+        await harness.Effects.HandleLoadEvents(new LoadEventsAction(LogData(logId), sample.Events(0)), harness.Dispatcher);
+
+        OrderedViewReady update = await DrainToReadyAsync(harness, cancellationToken);
+
+        LogTableState routed = Reducers.ReduceOrderedViewUpdated(live, new OrderedViewUpdatedAction(update));
+
+        return new RoutedSetup(routed, update, logId, Volatile.Read(ref bridgeDispatched), [.. sample.Events(0)]);
+    }
+
+    private static LogTableState CommittedFrom(LogTableState state) =>
+        state with
+        {
+            CommittedEffectiveOrderBy = ResolvedEventOrdering.ResolveDefaultOrderBy(
+                state.OrderBy, state.GroupBy, state.DisplayedLogCount, state.TimelineVisible)
+        };
+
+    private static async Task<OrderedViewReady> DrainToReadyAsync(OrderedViewShadowHarness harness, CancellationToken cancellationToken)
+    {
+        OrderedViewUpdate update = await DrainToUpdateAsync(harness, cancellationToken);
+
+        return update as OrderedViewReady ??
+            throw new InvalidOperationException("The writer did not raise a single-log view update.");
+    }
+
+    private static async Task<OrderedViewUpdate> DrainToUpdateAsync(OrderedViewShadowHarness harness, CancellationToken cancellationToken) =>
+        await harness.DrainToUpdateAsync(cancellationToken);
+
+    private static bool IsFragmentedBy(IEventColumnView view, ColumnName groupBy)
+    {
+        List<(string Key, int Count)> runs = GroupRuns(view, groupBy);
+
+        return runs.Count != runs.Select(run => run.Key).Distinct(StringComparer.Ordinal).Count();
+    }
+
+    private static EventLocator[] Locators(IEventColumnView view)
+    {
+        var locators = new EventLocator[view.Count];
+
+        for (int displayIndex = 0; displayIndex < view.Count; displayIndex++)
+        {
+            locators[displayIndex] = view.LocatorAt(displayIndex);
+        }
+
+        return locators;
+    }
+
+    private static EventLogData LogData(EventLogId logId) => new("Log0", LogPathType.Channel) { Id = logId };
+
+    private static LogTableState PendingSortState(RoutedSetup setup)
+    {
+        LogTableState pending = setup.Routed with { GroupBy = null, IsGroupDescending = false };
+
+        return CommittedFrom(pending);
+    }
+
+    private static OrderedViewUpdatedAction Republish(RoutedSetup setup) =>
+        new(setup.Update with { SnapshotVersion = setup.Update.SnapshotVersion + 1 });
+
+    private static LogTableState Retaining(RoutedSetup setup) =>
+        setup.Routed with
+        {
+            ActiveOrderedView = null,
+            RetainedOrderedViews = RetainedMap(setup.Update)
+        };
+
+    private static List<ResolvedEvent> Rows(string owningLog, params (long RecordId, int TimeMs)[] rows)
+    {
+        var baseTime = new DateTime(2026, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+        var events = new List<ResolvedEvent>(rows.Length);
+
+        foreach ((long recordId, int timeMs) in rows)
+        {
+            events.Add(new ResolvedEvent(owningLog, LogPathType.Channel)
+            {
+                RecordId = recordId,
+                TimeCreated = baseTime.AddMilliseconds(timeMs),
+                Id = 1000,
+                Level = "Information",
+                Source = "Provider.A",
+                LogName = owningLog
+            });
+        }
+
+        return events;
+    }
+
+    private static (LogTableState LogTable, RawEventStoreState RawStore, EventLogState EventLog, IEventColumnReader Reader) SingleLog(
+        EventLogId logId, IReadOnlyList<ResolvedEvent> events, bool descending)
+    {
+        EventColumnStore store = EventColumnStore.Build(events, 0, 0);
+
+        var rawStore = new RawEventStoreState
+        {
+            ByLog = ImmutableDictionary<EventLogId, EventColumnStore>.Empty.Add(logId, store)
+        };
+
+        LogTableState logTable = CommittedFrom(new LogTableState
+        {
+            ActiveEventLogId = logId,
+            EventTables = [new LogView(logId)],
+            IsDescending = descending,
+            RequestedIsDescending = descending
+        });
+
+        return (logTable, rawStore, new EventLogState(), store.CreateReader(logId));
+    }
+
+    private static (LogTableState LogTable, RawEventStoreState RawStore, EventLogState EventLog, IEventColumnReader Reader) SingleLogFiltered(
+        EventLogId logId, IReadOnlyList<ResolvedEvent> events, Filter filter, bool descending)
+    {
+        EventColumnStore store = EventColumnStore.Build(events, 0, 0);
+        IEventColumnReader reader = store.CreateReader(logId);
+
+        var rawStore = new RawEventStoreState
+        {
+            ByLog = ImmutableDictionary<EventLogId, EventColumnStore>.Empty.Add(logId, store)
+        };
+
+        LogTableState logTable = new()
+        {
+            ActiveEventLogId = logId,
+            EventTables = [new LogView(logId)],
+            IsDescending = descending,
+            RequestedIsDescending = descending,
+
+            AppliedFilter = filter
+        };
+
+        return (logTable, rawStore, new EventLogState { AppliedFilter = filter }, reader);
+    }
+
+    private static List<ResolvedEvent> SourcedRows(
+        string owningLog,
+        params (long RecordId, int TimeMs, string Source)[] rows)
+    {
+        var baseTime = new DateTime(2026, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+        var events = new List<ResolvedEvent>(rows.Length);
+
+        foreach ((long recordId, int timeMs, string source) in rows)
+        {
+            events.Add(new ResolvedEvent(owningLog, LogPathType.Channel)
+            {
+                RecordId = recordId,
+                TimeCreated = baseTime.AddMilliseconds(timeMs),
+                Id = 1000,
+                Level = "Information",
+                Source = source,
+                LogName = owningLog
+            });
+        }
+
+        return events;
+    }
+
+    private static (LogTableState LogTable, RawEventStoreState RawStore) TwoLogs(
+        EventLogId log0, IReadOnlyList<ResolvedEvent> events0,
+        EventLogId log1, IReadOnlyList<ResolvedEvent> events1, bool descending)
+    {
+        var rawStore = new RawEventStoreState
+        {
+            ByLog = ImmutableDictionary<EventLogId, EventColumnStore>.Empty
+                .Add(log0, EventColumnStore.Build(events0, 0, 0))
+                .Add(log1, EventColumnStore.Build(events1, 0, 0))
+        };
+
+        LogTableState logTable = CommittedFrom(new LogTableState
+        {
+            ActiveEventLogId = log0,
+            EventTables = [new LogView(log0), new LogView(log1)],
+            IsDescending = descending,
+            RequestedIsDescending = descending
+        });
+
+        return (logTable, rawStore);
+    }
+
+    private sealed record RoutedSetup(
+        LogTableState Routed,
+        OrderedViewReady Update,
+        EventLogId LogId,
+        bool BridgeDispatched,
+        ResolvedEvent[] Events);
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/OrderedViewWriterConcurrencyTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/OrderedViewWriterConcurrencyTests.cs
new file mode 100644
index 000000000..054ca8cdb
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/OrderedViewWriterConcurrencyTests.cs
@@ -0,0 +1,161 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.Channels;
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
+using EventLogExpert.Runtime.LogTable;
+using EventLogExpert.Runtime.LogTable.OrderedView;
+using EventLogExpert.Runtime.Tests.LogTable.TestSupport;
+
+namespace EventLogExpert.Runtime.Tests.LogTable.OrderedView;
+
+public sealed class OrderedViewWriterConcurrencyTests
+{
+    private const int ReconcileChunkSize = 1;
+    private const int SliceBufferSize = 256;
+
+    private static readonly Filter s_emptyFilter = new(null, []);
+
+    [Fact]
+    public async Task ConcurrentReader_ObservesMonotonicConsistentSnapshots_AcrossLiveReconcileAndRebuild()
+    {
+        EventLogId logId = EventLogId.Create();
+        var events = MakeEvents(count: 8000);
+        var finalContext = new SortContext(ColumnName.Level, true, null, false);
+
+        await using var writer = new OrderedViewWriter(publishEvery: 64, publishIntervalMs: 4);
+        writer.EnqueueViewRequest(ViewRequests.For(new SortContext(ColumnName.Source, false, null, false), s_emptyFilter, [logId]));
+
+        long failures = 0;
+        Exception? readerError = null;
+        using var stop = new ManualResetEventSlim(false);
+
+        var readerThread = new Thread(() =>
+        {
+            try
+            {
+                var buffer = new OrderKey[SliceBufferSize];
+                long lastVersion = -1;
+
+                while (!stop.IsSet)
+                {
+                    OrderedViewSnapshot snapshot = writer.Current;
+                    int written = snapshot.SliceInto(0, buffer.Length, buffer);
+
+                    if (snapshot.Version < lastVersion) { Interlocked.Increment(ref failures); }
+
+                    if (written > 0 && snapshot.RankOf(new OrderKey(snapshot.At(0).Locator)) != 0) { Interlocked.Increment(ref failures); }
+                    if (written > 1 && snapshot.RankOf(new OrderKey(buffer[written - 1].Locator)) != written - 1) { Interlocked.Increment(ref failures); }
+
+                    lastVersion = snapshot.Version;
+                }
+            }
+            catch (Exception ex) { readerError = ex; }
+        });
+
+        readerThread.Start();
+
+        EventColumnStore store = EventColumnStore.Empty;
+        bool rebuildRequested = false;
+
+        for (int from = 0; from < events.Count; from += ReconcileChunkSize)
+        {
+            int size = Math.Min(ReconcileChunkSize, events.Count - from);
+            store = store.Append(events.GetRange(from, size));
+            writer.EnqueueReconcile(logId, store.CreateReader(logId));
+
+            if (!rebuildRequested && from + size >= events.Count / 2)
+            {
+                writer.EnqueueViewRequest(ViewRequests.For(finalContext, s_emptyFilter, [logId]));
+                rebuildRequested = true;
+            }
+        }
+
+        OrderedViewSnapshot final = await writer.DrainAsync().WaitAsync(OrderedViewTestTimeouts.Default, TestContext.Current.CancellationToken);
+        stop.Set();
+        readerThread.Join();
+
+        Assert.Null(readerError);
+        Assert.Equal(0, Interlocked.Read(ref failures));
+        Assert.Null(writer.Faulted);
+        CombinedViewParityAsserts.AssertSnapshotOrderMatchesReference(final, logId, events, finalContext);
+    }
+
+    [Fact]
+    public async Task Writer_ReplaysTailArrivingDuringRebuild_MatchesLiveView()
+    {
+        EventLogId logId = EventLogId.Create();
+        var events = MakeEvents(count: 400);
+
+        var context = new SortContext(ColumnName.Source, false, null, false);
+
+        await using var writer = new OrderedViewWriter(publishEvery: 32, publishIntervalMs: 4);
+
+        EventColumnStore store = EventColumnStore.Build(events.GetRange(0, 120), generation: 0, contentVersion: 0);
+
+        writer.EnqueueReconcile(logId, store.CreateReader(logId));
+
+        writer.EnqueueViewRequest(ViewRequests.For(context, s_emptyFilter, [logId]));
+
+        for (int index = 120; index < events.Count; index++)
+        {
+            store = store.Append(events.GetRange(index, 1));
+            writer.EnqueueReconcile(logId, store.CreateReader(logId));
+        }
+
+        OrderedViewSnapshot snapshot = await writer.DrainAsync();
+
+        Assert.Null(writer.Faulted);
+        CombinedViewParityAsserts.AssertSnapshotOrderMatchesReference(snapshot, logId, events, context);
+    }
+
+    [Fact]
+    public async Task Writer_SupersededRebuilds_ConvergeToLatestOrdering_NoFault()
+    {
+        EventLogId logId = EventLogId.Create();
+        var events = MakeEvents(count: 350);
+        IEventColumnReader reader = EventColumnStore.Build(events, generation: 0, contentVersion: 0).CreateReader(logId);
+
+        await using var writer = new OrderedViewWriter(publishEvery: 16, publishIntervalMs: 4);
+
+        writer.EnqueueReconcile(logId, reader);
+
+        writer.EnqueueViewRequest(ViewRequests.For(new SortContext(ColumnName.Level, false, null, false), s_emptyFilter, [logId]));
+        writer.EnqueueViewRequest(ViewRequests.For(new SortContext(ColumnName.EventId, true, null, false), s_emptyFilter, [logId]));
+        writer.EnqueueViewRequest(ViewRequests.For(new SortContext(ColumnName.DateAndTime, false, ColumnName.Source, false), s_emptyFilter, [logId]));
+        var finalContext = new SortContext(ColumnName.Source, true, null, false);
+        writer.EnqueueViewRequest(ViewRequests.For(finalContext, s_emptyFilter, [logId]));
+
+        OrderedViewSnapshot snapshot = await writer.DrainAsync();
+
+        Assert.Null(writer.Faulted);
+        CombinedViewParityAsserts.AssertSnapshotOrderMatchesReference(snapshot, logId, events, finalContext);
+    }
+
+    private static List<ResolvedEvent> MakeEvents(int count)
+    {
+        var rng = new Random(20260212);
+        var clock = new DateTime(2026, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+        string[] sources = ["Provider.A", "Provider.B", "Provider.C", "Provider.D"];
+        string[] levels = ["Information", "Warning", "Error", "Critical"];
+        var events = new List<ResolvedEvent>(count);
+
+        for (int i = 0; i < count; i++)
+        {
+            clock = clock.AddMilliseconds(1 + rng.Next(10));
+
+            events.Add(new ResolvedEvent("Log", LogPathType.Channel)
+            {
+                RecordId = i + 1,
+                TimeCreated = clock,
+                Id = 1000 + rng.Next(5),
+                Level = levels[rng.Next(levels.Length)],
+                Source = sources[rng.Next(sources.Length)],
+                LogName = "Channel"
+            });
+        }
+
+        return events;
+    }
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/OrderedViewWriterFaultStateTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/OrderedViewWriterFaultStateTests.cs
new file mode 100644
index 000000000..4ae31fd1b
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/OrderedViewWriterFaultStateTests.cs
@@ -0,0 +1,684 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.Channels;
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
+using EventLogExpert.Runtime.LogTable;
+using EventLogExpert.Runtime.LogTable.OrderedView;
+
+namespace EventLogExpert.Runtime.Tests.LogTable.OrderedView;
+
+public sealed class OrderedViewWriterFaultStateTests
+{
+    private static readonly SortContext s_context = new(ColumnName.RecordId, false, null, false);
+
+    private static TimeSpan SignalTimeout => TimeSpan.FromSeconds(20);
+    private static TimeSpan Timeout => TimeSpan.FromSeconds(30);
+
+    [Fact]
+    public async Task ABuildAbandonedWhileAdopting_AlsoLeavesNoTokenBehind()
+    {
+        EventLogId logId = EventLogId.Create();
+
+        await using var writer = new OrderedViewWriter(publishEvery: 1, publishIntervalMs: 0);
+
+        writer.EnqueueReconcile(logId, Reader(logId, count: 3000));
+        writer.EnqueueViewRequest(Request(logId, static (locator, _) => locator.Index >= 3000 ? throw new InvalidOperationException("tail") : true, ColumnName.Source));
+        writer.EnqueueReconcile(logId, Reader(logId, count: 3200));
+        await writer.DrainAsync().WaitAsync(Timeout, TestContext.Current.CancellationToken);
+
+        Assert.NotNull(writer.Faulted);
+
+        int startedAfterAbandon = writer.BuildsStarted;
+
+        writer.EnqueueViewRequest(Request(logId, orderBy: ColumnName.Source));
+        OrderedViewSnapshot snapshot = await writer.DrainAsync().WaitAsync(Timeout, TestContext.Current.CancellationToken);
+
+        Assert.True(writer.BuildsStarted > startedAfterAbandon, "the retry must START a build, not attach to the abandoned one");
+        Assert.Equal(3200, snapshot.Count);
+    }
+
+    [Fact]
+    public async Task ADamagedIndex_IsNeverHandedToTheDisplay_BeforeTheRebuildThatRepairsItLands()
+    {
+        EventLogId logId = EventLogId.Create();
+        int thrown = 0;
+        List<int> publishedCounts = [];
+
+        await using var writer = new OrderedViewWriter(publishEvery: 1, publishIntervalMs: 0);
+
+        writer.Updated += update =>
+        {
+            if (update is OrderedViewReady ready) { lock (publishedCounts) { publishedCounts.Add(ready.View.Count); } }
+        };
+
+        writer.EnqueueReconcile(logId, Reader(logId, count: 100));
+        writer.EnqueueViewRequest(Request(logId,
+            (locator, _) => locator.Index < 100 || Interlocked.Exchange(ref thrown, 1) != 0
+                ? true
+                : throw new InvalidOperationException("a row that could not be ordered")));
+
+        await writer.DrainAsync().WaitAsync(Timeout, TestContext.Current.CancellationToken);
+
+        writer.EnqueueReconcile(logId, Reader(logId, count: 150));
+        writer.EnqueueReconcile(logId, Reader(logId, count: 180));
+        await writer.DrainAsync().WaitAsync(Timeout, TestContext.Current.CancellationToken);
+        await writer.DrainAsync().WaitAsync(Timeout, TestContext.Current.CancellationToken);
+
+        lock (publishedCounts)
+        {
+            Assert.DoesNotContain(publishedCounts, count => count is > 100 and < 150);
+        }
+    }
+
+    [Fact]
+    public async Task AFailedBuild_LeavesNoTokenBehind_SoTheSameRequestCanBeBuiltAgain()
+    {
+        EventLogId logId = EventLogId.Create();
+
+        await using var writer = new OrderedViewWriter(publishEvery: 1, publishIntervalMs: 0);
+
+        writer.EnqueueReconcile(logId, Reader(logId, count: 50));
+        await writer.DrainAsync().WaitAsync(Timeout, TestContext.Current.CancellationToken);
+
+        writer.EnqueueViewRequest(Request(logId, static (_, _) => throw new InvalidOperationException("first build")));
+        await writer.DrainAsync().WaitAsync(Timeout, TestContext.Current.CancellationToken);
+
+        Assert.NotNull(writer.Faulted);
+
+        int startedAfterFailure = writer.BuildsStarted;
+
+        writer.EnqueueViewRequest(Request(logId));
+        OrderedViewSnapshot snapshot = await writer.DrainAsync().WaitAsync(Timeout, TestContext.Current.CancellationToken);
+
+        Assert.True(writer.BuildsStarted > startedAfterFailure, "the retry must START a build, not re-tag the dead one");
+        Assert.Equal(50, snapshot.Count);
+    }
+
+    [Fact]
+    public async Task AFaultFromASupersededBuild_LeavesTheBuildThatReplacedItAlone()
+    {
+        EventLogId logId = EventLogId.Create();
+
+        using var parked = new ManualResetEventSlim(false);
+        using var entered = new ManualResetEventSlim(false);
+
+        CancellationToken token = TestContext.Current.CancellationToken;
+
+        await using var writer = new OrderedViewWriter(publishEvery: 1, publishIntervalMs: 0);
+
+        writer.EnqueueReconcile(logId, Reader(logId, count: 200));
+
+        writer.EnqueueViewRequest(Request(logId, (locator, _) =>
+        {
+            if (locator.Index != 0) { return true; }
+
+            entered.Set();
+            parked.Wait(SignalTimeout, token);
+
+            throw new InvalidOperationException("superseded, then failed for real");
+        }));
+
+        Assert.True(entered.Wait(SignalTimeout, token), "the first build must actually be running");
+
+        ViewRequest replacement = Request(logId, orderBy: ColumnName.Source);
+        writer.EnqueueViewRequest(replacement);
+
+        parked.Set();
+
+        OrderedViewUpdate? last = null;
+        writer.Updated += update => Volatile.Write(ref last, update);
+
+        await writer.DrainAsync().WaitAsync(Timeout, TestContext.Current.CancellationToken);
+        await writer.DrainAsync().WaitAsync(Timeout, TestContext.Current.CancellationToken);
+
+        var ready = Assert.IsType<OrderedViewReady>(Volatile.Read(ref last));
+
+        Assert.Equal(replacement.Identity, ready.Identity);
+    }
+
+    [Fact]
+    public async Task AFaultRaisedAfterAnAdopt_IsAnnouncedAgain_ButTheRecordOfTheFirstOneSurvivesIt()
+    {
+        EventLogId logId = EventLogId.Create();
+
+        await using var writer = new OrderedViewWriter(publishEvery: 1, publishIntervalMs: 0);
+
+        int announced = 0;
+        writer.FaultRaised += (_, _) => Interlocked.Increment(ref announced);
+
+        writer.EnqueueReconcile(logId, Reader(logId, count: 40));
+        writer.EnqueueViewRequest(Request(logId, static (_, _) => throw new InvalidOperationException("first")));
+        await writer.DrainAsync().WaitAsync(Timeout, TestContext.Current.CancellationToken);
+
+        Assert.Equal(1, Volatile.Read(ref announced));
+
+        writer.EnqueueViewRequest(Request(logId, orderBy: ColumnName.Source));
+        await writer.DrainAsync().WaitAsync(Timeout, TestContext.Current.CancellationToken);
+
+        Assert.NotNull(writer.Faulted);
+
+        writer.EnqueueViewRequest(Request(logId, static (_, _) => throw new InvalidOperationException("second"), ColumnName.Level));
+        await writer.DrainAsync().WaitAsync(Timeout, TestContext.Current.CancellationToken);
+
+        Assert.Equal(2, Volatile.Read(ref announced));
+    }
+
+    [Fact]
+    public async Task AReconcileThatThrowsPartWayThrough_IsHealedWithoutAnyoneAskingForANewView()
+    {
+        EventLogId logId = EventLogId.Create();
+        int thrown = 0;
+
+        await using var writer = new OrderedViewWriter(publishEvery: 1, publishIntervalMs: 0);
+
+        writer.EnqueueReconcile(logId, Reader(logId, count: 100));
+
+        writer.EnqueueViewRequest(Request(logId,
+            (locator, _) => locator.Index < 100 || Interlocked.Exchange(ref thrown, 1) != 0
+                ? true
+                : throw new InvalidOperationException("a row that could not be ordered")));
+
+        await writer.DrainAsync().WaitAsync(Timeout, TestContext.Current.CancellationToken);
+
+        writer.EnqueueReconcile(logId, Reader(logId, count: 150));
+        await writer.DrainAsync().WaitAsync(Timeout, TestContext.Current.CancellationToken);
+
+        Assert.Equal(1, Volatile.Read(ref thrown));
+
+        OrderedViewSnapshot snapshot = await writer.DrainAsync().WaitAsync(Timeout, TestContext.Current.CancellationToken);
+
+        Assert.Equal(150, snapshot.Count);
+    }
+
+    [Fact]
+    public async Task ARepairStartedWhileARequestIsInFlight_StillAnswersThatRequest()
+    {
+        EventLogId logId = EventLogId.Create();
+        int parkedOnce = 0;
+
+        using var parked = new ManualResetEventSlim(false);
+        using var entered = new ManualResetEventSlim(false);
+
+        CancellationToken token = TestContext.Current.CancellationToken;
+
+        await using var writer = new OrderedViewWriter(publishEvery: 1, publishIntervalMs: 0);
+
+        writer.EnqueueReconcile(logId, Reader(logId, count: 100));
+        writer.EnqueueViewRequest(Request(logId, static (locator, _) => locator.Index >= 100 ? throw new InvalidOperationException("unordered") : true));
+        await writer.DrainAsync().WaitAsync(Timeout, TestContext.Current.CancellationToken);
+
+        ViewRequest inFlight = Request(logId, (locator, _) =>
+        {
+            if (locator.Index == 0 && Interlocked.Exchange(ref parkedOnce, 1) == 0)
+            {
+                entered.Set();
+                parked.Wait(SignalTimeout, token);
+            }
+
+            return true;
+        }, ColumnName.Source);
+
+        writer.EnqueueViewRequest(inFlight);
+
+        Assert.True(entered.Wait(SignalTimeout, token), "the request must still be building when the damage lands");
+
+        writer.EnqueueReconcile(logId, Reader(logId, count: 150));
+        parked.Set();
+
+        OrderedViewUpdate? last = null;
+        writer.Updated += update => Volatile.Write(ref last, update);
+
+        await writer.DrainAsync().WaitAsync(Timeout, TestContext.Current.CancellationToken);
+        await writer.DrainAsync().WaitAsync(Timeout, TestContext.Current.CancellationToken);
+
+        var ready = Assert.IsType<OrderedViewReady>(Volatile.Read(ref last));
+
+        Assert.Equal(inFlight.Identity, ready.Identity);
+    }
+
+    [Fact]
+    public async Task ARetagThatSeedsNothingNew_LeavesAnIntactViewPublishing()
+    {
+        EventLogId logId = EventLogId.Create();
+        int parkedOnce = 0;
+        int raised = 0;
+
+        using var parked = new ManualResetEventSlim(false);
+        using var entered = new ManualResetEventSlim(false);
+
+        CancellationToken token = TestContext.Current.CancellationToken;
+
+        await using var writer = new OrderedViewWriter(publishEvery: 1, publishIntervalMs: 0);
+
+        IEventColumnReader settled = Reader(logId, count: 100);
+
+        writer.EnqueueReconcile(logId, settled);
+        writer.EnqueueViewRequest(Request(logId));
+        await writer.DrainAsync().WaitAsync(Timeout, TestContext.Current.CancellationToken);
+
+        writer.EnqueueViewRequest(Request(logId, (locator, _) =>
+        {
+            if (locator.Index == 0 && Interlocked.Exchange(ref parkedOnce, 1) == 0)
+            {
+                entered.Set();
+                parked.Wait(SignalTimeout, token);
+
+                throw new InvalidOperationException("the ridden build fails");
+            }
+
+            return true;
+        }, ColumnName.Source));
+
+        Assert.True(entered.Wait(SignalTimeout, token), "the build must be in flight to be retagged");
+
+        int startedAfterAdopt = writer.BuildsStarted;
+
+        writer.EnqueueViewRequest(ViewRequests.For(
+            new SortContext(ColumnName.Source, false, null, false),
+            ViewRequests.EmptyFilter,
+            [logId],
+            static (_, _) => true,
+            readers: new Dictionary<EventLogId, IEventColumnReader> { [logId] = Reader(logId, count: 100, contentVersion: 500) },
+            activeLogId: logId));
+
+        parked.Set();
+        await writer.DrainAsync().WaitAsync(Timeout, TestContext.Current.CancellationToken);
+
+        Assert.NotNull(writer.Faulted);
+
+        Assert.Equal(startedAfterAdopt, writer.BuildsStarted);
+
+        writer.Updated += _ => Interlocked.Increment(ref raised);
+
+        writer.EnqueueReconcile(logId, Reader(logId, count: 200));
+        await writer.DrainAsync().WaitAsync(Timeout, TestContext.Current.CancellationToken);
+
+        Assert.True(Volatile.Read(ref raised) > 0, "an intact view must keep publishing after a retag that owed nothing");
+    }
+
+    [Fact]
+    public async Task ASubscriberThatThrows_IsNotReportedAsAnEngineFailure_AndDoesNotMuteTheNextRealOne()
+    {
+        EventLogId logId = EventLogId.Create();
+
+        await using var writer = new OrderedViewWriter(publishEvery: 1, publishIntervalMs: 0);
+
+        int announced = 0;
+        writer.FaultRaised += (_, _) => Interlocked.Increment(ref announced);
+        writer.Updated += _ => throw new InvalidOperationException("a subscriber that cannot cope");
+
+        writer.EnqueueReconcile(logId, Reader(logId, count: 30));
+        await writer.DrainAsync().WaitAsync(Timeout, TestContext.Current.CancellationToken);
+
+        Assert.Equal(0, Volatile.Read(ref announced));
+
+        writer.EnqueueViewRequest(Request(logId, static (_, _) => throw new InvalidOperationException("a real one")));
+        await writer.DrainAsync().WaitAsync(Timeout, TestContext.Current.CancellationToken);
+
+        Assert.Equal(1, Volatile.Read(ref announced));
+    }
+
+    [Fact]
+    public async Task ATailReplayThatThrows_DoesNotSuppressPublishing_BecauseItDamagedNothing()
+    {
+        EventLogId logId = EventLogId.Create();
+        int raised = 0;
+
+        await using var writer = new OrderedViewWriter(publishEvery: 1, publishIntervalMs: 0);
+
+        writer.Updated += _ => Interlocked.Increment(ref raised);
+
+        writer.EnqueueReconcile(logId, Reader(logId, count: 3000));
+        writer.EnqueueViewRequest(Request(logId, static (locator, _) => locator.Index >= 3000 ? throw new InvalidOperationException("tail") : true));
+        writer.EnqueueReconcile(logId, Reader(logId, count: 3200));
+        await writer.DrainAsync().WaitAsync(Timeout, TestContext.Current.CancellationToken);
+
+        Assert.NotNull(writer.Faulted);
+
+        int before = Volatile.Read(ref raised);
+
+        writer.EnqueueReconcile(logId, Reader(logId, count: 3400));
+        await writer.DrainAsync().WaitAsync(Timeout, TestContext.Current.CancellationToken);
+
+        Assert.True(Volatile.Read(ref raised) > before, "publishing must continue after a fault that damaged nothing");
+    }
+
+    [Fact]
+    public async Task ClosingEverythingAfterAFailedRepair_ReportsTheNextFailureAgain()
+    {
+        EventLogId logId = EventLogId.Create();
+
+        await using var writer = new OrderedViewWriter(publishEvery: 1, publishIntervalMs: 0);
+
+        int announced = 0;
+        writer.FaultRaised += (_, _) => Interlocked.Increment(ref announced);
+
+        writer.EnqueueReconcile(logId, Reader(logId, count: 100));
+        writer.EnqueueViewRequest(Request(logId, static (locator, _) => locator.Index >= 100 ? throw new InvalidOperationException("a row that can never be ordered") : true));
+        await writer.DrainAsync().WaitAsync(Timeout, TestContext.Current.CancellationToken);
+
+        writer.EnqueueReconcile(logId, Reader(logId, count: 150));
+        await writer.DrainAsync().WaitAsync(Timeout, TestContext.Current.CancellationToken);
+
+        Assert.Equal(1, Volatile.Read(ref announced));
+
+        writer.EnqueueClear(ViewRequests.Identity(), ViewRequests.NextSequence());
+        await writer.DrainAsync().WaitAsync(Timeout, TestContext.Current.CancellationToken);
+
+        EventLogId reopened = EventLogId.Create();
+        IEventColumnReader reopenedReader = Reader(reopened, count: 20);
+
+        writer.EnqueueReconcile(reopened, reopenedReader);
+
+        writer.EnqueueViewRequest(ViewRequests.For(
+            s_context,
+            ViewRequests.EmptyFilter,
+            [reopened],
+            static (_, _) => throw new InvalidOperationException("the next one"),
+            readers: new Dictionary<EventLogId, IEventColumnReader> { [reopened] = reopenedReader },
+            activeLogId: reopened));
+
+        await writer.DrainAsync().WaitAsync(Timeout, TestContext.Current.CancellationToken);
+
+        Assert.Equal(2, Volatile.Read(ref announced));
+    }
+
+    [Fact]
+    public async Task ClosingEverything_ReleasesADisplayStrandedByARepairThatCouldNotSucceed()
+    {
+        EventLogId logId = EventLogId.Create();
+
+        await using var writer = new OrderedViewWriter(publishEvery: 1, publishIntervalMs: 0);
+
+        writer.EnqueueReconcile(logId, Reader(logId, count: 100));
+        writer.EnqueueViewRequest(Request(logId, static (locator, _) => locator.Index >= 100 ? throw new InvalidOperationException("a row that can never be ordered") : true));
+        await writer.DrainAsync().WaitAsync(Timeout, TestContext.Current.CancellationToken);
+
+        writer.EnqueueReconcile(logId, Reader(logId, count: 150));
+        await writer.DrainAsync().WaitAsync(Timeout, TestContext.Current.CancellationToken);
+
+        OrderedViewUpdate? afterClose = null;
+        writer.Updated += update => Volatile.Write(ref afterClose, update);
+
+        writer.EnqueueClear(ViewRequests.Identity(), ViewRequests.NextSequence());
+        await writer.DrainAsync().WaitAsync(Timeout, TestContext.Current.CancellationToken);
+
+        Assert.NotNull(Volatile.Read(ref afterClose));
+    }
+
+    [Fact]
+    public async Task OnceTheOwedRowsArePlaced_AViewTheEngineAlreadyHolds_IsRestampedAgain()
+    {
+        EventLogId logId = EventLogId.Create();
+        int parkedOnce = 0;
+
+        using var parked = new ManualResetEventSlim(false);
+        using var entered = new ManualResetEventSlim(false);
+
+        CancellationToken token = TestContext.Current.CancellationToken;
+
+        await using var writer = new OrderedViewWriter(publishEvery: 1, publishIntervalMs: 0);
+
+        writer.EnqueueReconcile(logId, Reader(logId, count: 100));
+        writer.EnqueueViewRequest(Request(logId));
+        await writer.DrainAsync().WaitAsync(Timeout, TestContext.Current.CancellationToken);
+
+        IEventColumnReader grown = Reader(logId, count: 150);
+
+        writer.EnqueueViewRequest(Request(logId, (locator, _) =>
+        {
+            if (locator.Index == 0 && Interlocked.Exchange(ref parkedOnce, 1) == 0)
+            {
+                entered.Set();
+                parked.Wait(SignalTimeout, token);
+            }
+
+            return true;
+        }, ColumnName.Source));
+
+        Assert.True(entered.Wait(SignalTimeout, token), "the build must be in flight to be retagged");
+
+        writer.EnqueueViewRequest(ViewRequests.For(
+            new SortContext(ColumnName.Source, false, null, false),
+            ViewRequests.EmptyFilter,
+            [logId],
+            static (_, _) => true,
+            readers: new Dictionary<EventLogId, IEventColumnReader> { [logId] = grown },
+            activeLogId: logId));
+
+        parked.Set();
+        await writer.DrainAsync().WaitAsync(Timeout, TestContext.Current.CancellationToken);
+        await writer.DrainAsync().WaitAsync(Timeout, TestContext.Current.CancellationToken);
+
+        int startedBeforeRestamp = writer.BuildsStarted;
+
+        writer.EnqueueViewRequest(ViewRequests.For(
+            new SortContext(ColumnName.Source, false, null, false),
+            ViewRequests.EmptyFilter,
+            [logId],
+            static (_, _) => true,
+            readers: new Dictionary<EventLogId, IEventColumnReader> { [logId] = grown },
+            activeLogId: logId,
+            sequence: ViewRequests.NextSequence()));
+
+        await writer.DrainAsync().WaitAsync(Timeout, TestContext.Current.CancellationToken);
+
+        Assert.Equal(startedBeforeRestamp, writer.BuildsStarted);
+    }
+
+    [Fact]
+    public async Task RepeatedDamage_StartsOneRepairPerEpisode_NotOnePerFailure()
+    {
+        EventLogId logId = EventLogId.Create();
+        int thrown = 0;
+
+        await using var writer = new OrderedViewWriter(publishEvery: 1, publishIntervalMs: 0);
+
+        writer.EnqueueReconcile(logId, Reader(logId, count: 100));
+
+        writer.EnqueueViewRequest(Request(logId,
+            (locator, _) => locator.Index < 100 || Interlocked.Increment(ref thrown) > 3
+                ? true
+                : throw new InvalidOperationException("a row that could not be ordered")));
+
+        await writer.DrainAsync().WaitAsync(Timeout, TestContext.Current.CancellationToken);
+
+        int startedBeforeDamage = writer.BuildsStarted;
+
+        writer.EnqueueReconcile(logId, Reader(logId, count: 150));
+        writer.EnqueueReconcile(logId, Reader(logId, count: 200));
+        writer.EnqueueReconcile(logId, Reader(logId, count: 250));
+        await writer.DrainAsync().WaitAsync(Timeout, TestContext.Current.CancellationToken);
+        await writer.DrainAsync().WaitAsync(Timeout, TestContext.Current.CancellationToken);
+
+        Assert.Equal(1, writer.BuildsStarted - startedBeforeDamage);
+    }
+
+    [Fact]
+    public async Task SeedingTwoGrownLogsInOneRetag_TakesRowsFromBothOfThem()
+    {
+        EventLogId first = EventLogId.Create();
+        EventLogId second = EventLogId.Create();
+
+        using var parked = new ManualResetEventSlim(false);
+        using var entered = new ManualResetEventSlim(false);
+
+        CancellationToken token = TestContext.Current.CancellationToken;
+
+        await using var writer = new OrderedViewWriter(publishEvery: 1, publishIntervalMs: 0);
+
+        var startingReaders = new Dictionary<EventLogId, IEventColumnReader>
+        {
+            [first] = Reader(first, count: 50), [second] = Reader(second, count: 50)
+        };
+
+        writer.EnqueueViewRequest(ViewRequests.For(
+            s_context, ViewRequests.EmptyFilter, [first, second], static (_, _) => true, readers: startingReaders));
+
+        await writer.DrainAsync().WaitAsync(Timeout, TestContext.Current.CancellationToken);
+
+        writer.EnqueueViewRequest(ViewRequests.For(
+            new SortContext(ColumnName.Source, false, null, false),
+            ViewRequests.EmptyFilter,
+            [first, second],
+            (_, _) =>
+            {
+                entered.Set();
+                parked.Wait(SignalTimeout, token);
+
+                return true;
+            },
+            readers: startingReaders));
+
+        Assert.True(entered.Wait(SignalTimeout, token), "the build must be in flight to be retagged");
+
+        writer.EnqueueViewRequest(ViewRequests.For(
+            new SortContext(ColumnName.Source, false, null, false),
+            ViewRequests.EmptyFilter,
+            [first, second],
+            static (_, _) => true,
+            readers: new Dictionary<EventLogId, IEventColumnReader>
+            {
+                [first] = Reader(first, count: 80), [second] = Reader(second, count: 80)
+            }));
+
+        parked.Set();
+        await writer.DrainAsync().WaitAsync(Timeout, TestContext.Current.CancellationToken);
+        await writer.DrainAsync().WaitAsync(Timeout, TestContext.Current.CancellationToken);
+
+        Assert.Equal(160, writer.Current.Count);
+    }
+
+    [Fact]
+    public async Task WhileARepairIsOutstanding_AskingForTheSameViewAgain_DoesNotRepublishTheDamagedIndex()
+    {
+        EventLogId logId = EventLogId.Create();
+        int raised = 0;
+
+        await using var writer = new OrderedViewWriter(publishEvery: 1, publishIntervalMs: 0);
+
+        writer.EnqueueReconcile(logId, Reader(logId, count: 100));
+        writer.EnqueueViewRequest(Request(logId, static (locator, _) => locator.Index >= 100 ? throw new InvalidOperationException("a row that can never be ordered") : true));
+        await writer.DrainAsync().WaitAsync(Timeout, TestContext.Current.CancellationToken);
+
+        writer.EnqueueReconcile(logId, Reader(logId, count: 150));
+        await writer.DrainAsync().WaitAsync(Timeout, TestContext.Current.CancellationToken);
+
+        writer.Updated += _ => Interlocked.Increment(ref raised);
+
+        long publishedBefore = writer.Current.Version;
+
+        writer.EnqueueViewRequest(Request(logId, static (locator, _) => locator.Index >= 100 ? throw new InvalidOperationException("still unordered") : true));
+        await writer.DrainAsync().WaitAsync(Timeout, TestContext.Current.CancellationToken);
+
+        Assert.Equal(0, Volatile.Read(ref raised));
+        Assert.Equal(1, writer.Current.Version - publishedBefore);
+    }
+
+    [Fact]
+    public async Task WhileSeededRowsAreOwed_AViewTheEngineAlreadyHolds_IsRebuiltRatherThanRestamped()
+    {
+        EventLogId logId = EventLogId.Create();
+        int parkedOnce = 0;
+
+        using var parked = new ManualResetEventSlim(false);
+        using var entered = new ManualResetEventSlim(false);
+
+        CancellationToken token = TestContext.Current.CancellationToken;
+
+        await using var writer = new OrderedViewWriter(publishEvery: 1, publishIntervalMs: 0);
+
+        writer.EnqueueReconcile(logId, Reader(logId, count: 100));
+        writer.EnqueueViewRequest(Request(logId));
+        await writer.DrainAsync().WaitAsync(Timeout, TestContext.Current.CancellationToken);
+
+        writer.EnqueueViewRequest(Request(logId, (locator, _) =>
+        {
+            if (locator.Index == 0 && Interlocked.Exchange(ref parkedOnce, 1) == 0)
+            {
+                entered.Set();
+                parked.Wait(SignalTimeout, token);
+            }
+
+            return true;
+        }, ColumnName.Source));
+
+        Assert.True(entered.Wait(SignalTimeout, token), "the second view must still be building");
+
+        IEventColumnReader grown = Reader(logId, count: 150);
+
+        writer.EnqueueViewRequest(ViewRequests.For(
+            new SortContext(ColumnName.Source, false, null, false),
+            ViewRequests.EmptyFilter,
+            [logId],
+            static (_, _) => true,
+            readers: new Dictionary<EventLogId, IEventColumnReader> { [logId] = grown },
+            activeLogId: logId));
+
+        int startedBeforeRestamp = writer.BuildsStarted;
+
+        List<int> publishedForRestamp = [];
+
+        ViewRequest restamp = ViewRequests.For(
+            s_context,
+            ViewRequests.EmptyFilter,
+            [logId],
+            static (_, _) => true,
+            readers: new Dictionary<EventLogId, IEventColumnReader> { [logId] = grown },
+            activeLogId: logId);
+
+        writer.Updated += update =>
+        {
+            if (update is OrderedViewReady ready && ready.Sequence == restamp.Sequence)
+            {
+                lock (publishedForRestamp) { publishedForRestamp.Add(ready.View.Count); }
+            }
+        };
+
+        writer.EnqueueViewRequest(restamp);
+
+        parked.Set();
+        await writer.DrainAsync().WaitAsync(Timeout, TestContext.Current.CancellationToken);
+        await writer.DrainAsync().WaitAsync(Timeout, TestContext.Current.CancellationToken);
+
+        lock (publishedForRestamp)
+        {
+            Assert.DoesNotContain(publishedForRestamp, count => count < 150);
+        }
+    }
+
+    private static IEventColumnReader Reader(EventLogId logId, int count, int contentVersion = -1)
+    {
+        var clock = new DateTime(2026, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+        var events = new List<ResolvedEvent>(count);
+
+        for (int index = 0; index < count; index++)
+        {
+            events.Add(new ResolvedEvent("Application", LogPathType.Channel)
+            {
+                RecordId = index,
+                TimeCreated = clock.AddSeconds(index),
+                Id = 1000 + (index % 7),
+                Level = "Information",
+                Source = "Provider.A",
+                LogName = "Application"
+            });
+        }
+
+        return EventColumnStore.Build(events, generation: 0, contentVersion: contentVersion < 0 ? count : contentVersion)
+            .CreateReader(logId);
+    }
+
+    private static ViewRequest Request(
+        EventLogId logId,
+        Func<EventLocator, IEventColumnReader, bool>? predicate = null,
+        ColumnName orderBy = ColumnName.RecordId) =>
+        ViewRequests.For(
+            orderBy == ColumnName.RecordId ? s_context : new SortContext(orderBy, false, null, false),
+            ViewRequests.EmptyFilter,
+            [logId],
+            predicate,
+            activeLogId: logId);
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/OrderedViewWriterTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/OrderedViewWriterTests.cs
new file mode 100644
index 000000000..d6e680258
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/OrderedViewWriterTests.cs
@@ -0,0 +1,290 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.Channels;
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
+using EventLogExpert.Runtime.LogTable;
+using EventLogExpert.Runtime.LogTable.OrderedView;
+using EventLogExpert.Runtime.Tests.LogTable.TestSupport;
+
+namespace EventLogExpert.Runtime.Tests.LogTable.OrderedView;
+
+public sealed class OrderedViewWriterTests
+{
+    private const int MaxGenerationPollAttempts = 300;
+    private const int MaxRenderPollAttempts = 200;
+    private const int PollDelayMilliseconds = 10;
+
+    private static readonly SortContext s_context = new(ColumnName.RecordId, false, null, false);
+    private static readonly Filter s_emptyFilter = new(null, []);
+    private static readonly TimeSpan s_settleWindow = TimeSpan.FromMilliseconds(500);
+
+    [Fact]
+    public async Task Cadence_RendersLowRateEvents_WithoutExplicitPublish()
+    {
+        EventLogId logId = EventLogId.Create();
+        IEventColumnReader reader = Reader(logId, count: 5, generation: 0, recordIdBase: 0);
+
+        await using var writer = new OrderedViewWriter(publishEvery: 10_000, publishIntervalMs: 8);
+
+        writer.EnqueueReconcile(logId, reader);
+
+        bool rendered = false;
+        for (int attempt = 0; attempt < MaxRenderPollAttempts && !rendered; attempt++)
+        {
+            await Task.Delay(PollDelayMilliseconds, TestContext.Current.CancellationToken);
+            if (writer.Current.Count == 5) { rendered = true; }
+        }
+
+        Assert.True(rendered);
+        Assert.Null(writer.Faulted);
+    }
+
+    [Fact]
+    public async Task Dispose_CancelsAndAwaitsInFlightBuilds_WithoutHanging()
+    {
+        EventLogId logId = EventLogId.Create();
+        IEventColumnReader reader = Reader(logId, count: 40_000, generation: 0, recordIdBase: 0);
+
+        using var entered = new ManualResetEventSlim(false);
+        using var release = new ManualResetEventSlim(false);
+        int examined = 0;
+        int gateArmed = 1;
+
+        bool Predicate(EventLocator locator, IEventColumnReader columnReader)
+        {
+            Interlocked.Increment(ref examined);
+
+            if (Interlocked.Exchange(ref gateArmed, 0) == 1)
+            {
+                entered.Set();
+                release.Wait(OrderedViewTestTimeouts.Default);
+            }
+
+            return true;
+        }
+
+        var writer = new OrderedViewWriter(publishEvery: 5000);
+
+        writer.EnqueueReconcile(logId, reader);
+
+        writer.EnqueueViewRequest(ViewRequests.For(new SortContext(ColumnName.Source, false, null, false), s_emptyFilter, [logId], Predicate));
+
+        Assert.True(entered.Wait(OrderedViewTestTimeouts.Default, TestContext.Current.CancellationToken),
+            "the build never started, so disposal would not have had one to cancel");
+
+        Task disposal = writer.DisposeAsync().AsTask();
+
+        await Task.WhenAny(disposal, Task.Delay(s_settleWindow, TestContext.Current.CancellationToken));
+
+        Assert.False(disposal.IsCompleted, "disposal returned while a build was still running inside its predicate");
+
+        release.Set();
+
+        await disposal.WaitAsync(OrderedViewTestTimeouts.Default, TestContext.Current.CancellationToken);
+
+        Assert.True(Volatile.Read(ref examined) < 40_000,
+            $"the build ran to completion instead of being cancelled: {examined} of 40,000 rows");
+    }
+
+    [Fact]
+    public async Task DrainAsync_AfterDispose_ReturnsWithoutHanging()
+    {
+        EventLogId logId = EventLogId.Create();
+        IEventColumnReader reader = Reader(logId, count: 20, generation: 0, recordIdBase: 0);
+
+        var writer = new OrderedViewWriter(publishEvery: 100);
+        writer.EnqueueReconcile(logId, reader);
+
+        await writer.DisposeAsync();
+
+        OrderedViewSnapshot snapshot =
+            await writer.DrainAsync().WaitAsync(OrderedViewTestTimeouts.Default, TestContext.Current.CancellationToken);
+
+        Assert.NotNull(snapshot);
+    }
+
+    [Fact]
+    public async Task FirstContent_PublishesWithoutWaitingForTheCounterOrTheCadence()
+    {
+        EventLogId logId = EventLogId.Create();
+        IEventColumnReader reader = Reader(logId, count: 256, generation: 0, recordIdBase: 0);
+
+        await using var writer = new OrderedViewWriter(publishEvery: int.MaxValue, publishIntervalMs: 600_000);
+
+        writer.EnqueueReconcile(logId, reader);
+
+        bool rendered = false;
+
+        for (int attempt = 0; attempt < MaxRenderPollAttempts && !rendered; attempt++)
+        {
+            await Task.Delay(PollDelayMilliseconds, TestContext.Current.CancellationToken);
+
+            if (writer.Current.Count == 256) { rendered = true; }
+        }
+
+        Assert.True(rendered);
+        Assert.Null(writer.Faulted);
+    }
+
+    [Fact]
+    public async Task HeldRebuild_FaultingInOffThreadBuild_ClearsHoldSoReconcileResumes()
+    {
+        EventLogId logId = EventLogId.Create();
+
+        await using var writer = new OrderedViewWriter(publishEvery: 1000, publishIntervalMs: 8);
+
+        writer.EnqueueReconcile(logId, Reader(logId, count: 100, generation: 0, recordIdBase: 0));
+
+        writer.EnqueueViewRequest(ViewRequests.For(s_context, s_emptyFilter, [logId], static (_, _) => throw new InvalidOperationException("build boom"), hold: true));
+        OrderedViewSnapshot afterFault =
+            await writer.DrainAsync().WaitAsync(OrderedViewTestTimeouts.Default, TestContext.Current.CancellationToken);
+
+        Assert.IsType<InvalidOperationException>(writer.Faulted);
+
+        writer.EnqueueReconcile(logId, Reader(logId, count: 150, generation: 0, recordIdBase: 0));
+        OrderedViewSnapshot resumed =
+            await writer.DrainAsync().WaitAsync(OrderedViewTestTimeouts.Default, TestContext.Current.CancellationToken);
+
+        Assert.True(resumed.Count > afterFault.Count, $"reconcile stranded: {afterFault.Count} -> {resumed.Count}");
+        Assert.True(resumed.Contains(logId, 0, 149));
+    }
+
+    [Fact]
+    public async Task RebuildFault_SurfacesAndDoesNotHangDrain()
+    {
+        EventLogId logId = EventLogId.Create();
+        IEventColumnReader reader = Reader(logId, count: 2000, generation: 0, recordIdBase: 0);
+
+        await using var writer = new OrderedViewWriter(publishEvery: 1000);
+
+        writer.EnqueueReconcile(logId, reader);
+
+        writer.EnqueueViewRequest(ViewRequests.For(s_context, s_emptyFilter, [logId], static (_, _) => throw new InvalidOperationException("boom")));
+
+        OrderedViewSnapshot snapshot = await writer.DrainAsync().WaitAsync(OrderedViewTestTimeouts.Default, TestContext.Current.CancellationToken);
+
+        Assert.NotNull(snapshot);
+        Assert.IsType<InvalidOperationException>(writer.Faulted);
+    }
+
+    [Fact]
+    public async Task ResetLog_DropsStaleGeneration()
+    {
+        EventLogId logId = EventLogId.Create();
+        IEventColumnReader generation0 = Reader(logId, count: 300, generation: 0, recordIdBase: 0);
+        IEventColumnReader generation1 = Reader(logId, count: 120, generation: 1, recordIdBase: 5000);
+
+        await using var writer = new OrderedViewWriter(publishEvery: 100);
+
+        writer.EnqueueReconcile(logId, generation0);
+
+        writer.EnqueueResetLog(logId, newGeneration: 1);
+        writer.EnqueueReconcile(logId, generation1);
+
+        OrderedViewSnapshot snapshot = await writer.DrainAsync().WaitAsync(OrderedViewTestTimeouts.Default, TestContext.Current.CancellationToken);
+
+        Assert.Equal(120, snapshot.Count);
+        Assert.False(snapshot.Contains(logId, 0, 0));
+        Assert.True(snapshot.Contains(logId, 1, 0));
+        Assert.Null(writer.Faulted);
+    }
+
+    [Fact]
+    public async Task SingleLogInScope_ReflectsTheAdoptedGeneration_AcrossAReset()
+    {
+        EventLogId logId = EventLogId.Create();
+
+        await using var writer = new OrderedViewWriter(publishEvery: 100);
+
+        var gate = new object();
+        var readies = new List<OrderedViewReady>();
+
+        writer.Updated += update =>
+        {
+            if (update is OrderedViewReady ready && ready.SingleLogId == logId)
+            {
+                lock (gate) { readies.Add(ready); }
+            }
+        };
+
+        async Task<OrderedViewReady> WaitForGeneration(int generation)
+        {
+            var key = new LogGeneration(logId, generation);
+
+            for (int attempt = 0; attempt < MaxGenerationPollAttempts; attempt++)
+            {
+                lock (gate)
+                {
+                    var match = readies.LastOrDefault(ready => ready.InScope.Contains(key));
+
+                    if (match is not null) { return match; }
+                }
+
+                await Task.Delay(PollDelayMilliseconds, TestContext.Current.CancellationToken);
+            }
+
+            Assert.Fail($"no single-log publish carried generation {generation}");
+
+            throw new InvalidOperationException("unreachable");
+        }
+
+        writer.EnqueueReconcile(logId, Reader(logId, count: 50, generation: 0, recordIdBase: 0));
+        writer.EnqueueViewRequest(ViewRequests.For(s_context, s_emptyFilter, [logId], static (_, _) => true));
+        await writer.DrainAsync().WaitAsync(OrderedViewTestTimeouts.Default, TestContext.Current.CancellationToken);
+
+        OrderedViewReady gen0 = await WaitForGeneration(0);
+        Assert.Equal(new LogGeneration(logId, 0), Assert.Single(gen0.InScope));
+
+        writer.EnqueueResetLog(logId, newGeneration: 1);
+        writer.EnqueueReconcile(logId, Reader(logId, count: 30, generation: 1, recordIdBase: 5000));
+        writer.EnqueueViewRequest(ViewRequests.For(
+            new SortContext(ColumnName.Source, false, null, false), s_emptyFilter, [logId], static (_, _) => true));
+        await writer.DrainAsync().WaitAsync(OrderedViewTestTimeouts.Default, TestContext.Current.CancellationToken);
+
+        OrderedViewReady gen1 = await WaitForGeneration(1);
+        Assert.Equal(new LogGeneration(logId, 1), Assert.Single(gen1.InScope));
+        Assert.NotSame(gen0.InScope, gen1.InScope);
+        Assert.Null(writer.Faulted);
+    }
+
+    [Fact]
+    public async Task TailReplayFault_DoesNotHangDrain()
+    {
+        EventLogId logId = EventLogId.Create();
+
+        await using var writer = new OrderedViewWriter(publishEvery: 5000);
+
+        writer.EnqueueReconcile(logId, Reader(logId, count: 3000, generation: 0, recordIdBase: 0));
+
+        writer.EnqueueViewRequest(ViewRequests.For(s_context, s_emptyFilter, [logId], static (locator, _) => locator.Index >= 3000 ? throw new InvalidOperationException("tail") : true));
+        writer.EnqueueReconcile(logId, Reader(logId, count: 3200, generation: 0, recordIdBase: 0));
+
+        OrderedViewSnapshot snapshot = await writer.DrainAsync().WaitAsync(OrderedViewTestTimeouts.Default, TestContext.Current.CancellationToken);
+
+        Assert.NotNull(snapshot);
+    }
+
+    private static IEventColumnReader Reader(EventLogId logId, int count, int generation, long recordIdBase)
+    {
+        var clock = new DateTime(2026, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+        string[] sources = ["Provider.A", "Provider.B", "Provider.C"];
+        var events = new List<ResolvedEvent>(count);
+
+        for (int i = 0; i < count; i++)
+        {
+            events.Add(new ResolvedEvent("Log", LogPathType.Channel)
+            {
+                RecordId = recordIdBase + i,
+                TimeCreated = clock.AddMilliseconds(recordIdBase + i),
+                Id = 1000,
+                Level = "Information",
+                Source = sources[i % sources.Length],
+                LogName = "Channel"
+            });
+        }
+
+        return EventColumnStore.Build(events, generation, generation).CreateReader(logId);
+    }
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/ViewContentTokenTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/ViewContentTokenTests.cs
new file mode 100644
index 000000000..d6b51b9e5
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/ViewContentTokenTests.cs
@@ -0,0 +1,138 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.Channels;
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
+using EventLogExpert.Runtime.LogTable;
+using EventLogExpert.Runtime.LogTable.OrderedView;
+
+namespace EventLogExpert.Runtime.Tests.LogTable.OrderedView;
+
+public sealed class ViewContentTokenTests
+{
+    private static readonly EventLogId s_logA = EventLogId.Create();
+    private static readonly EventLogId s_logB = EventLogId.Create();
+
+    [Fact]
+    public void AddingAMember_IsNotEqual()
+    {
+        ViewContentToken single = ViewContentToken.FromStamps(default, [Stamp(s_logA, 1, 3)], 3);
+        ViewContentToken combined = ViewContentToken.FromStamps(default, [Stamp(s_logA, 1, 3), Stamp(s_logB, 2, 4)], 7);
+
+        Assert.NotEqual(single, combined);
+    }
+
+    [Fact]
+    public void DifferentContentVersion_IsNotEqual()
+    {
+        ViewContentToken before = ViewContentToken.FromStamps(default, [Stamp(s_logA, contentVersion: 5, count: 10)], 8);
+        ViewContentToken after = ViewContentToken.FromStamps(default, [Stamp(s_logA, contentVersion: 6, count: 10)], 8);
+
+        Assert.NotEqual(before, after);
+    }
+
+    [Fact]
+    public void DifferentFilter_IsNotEqual()
+    {
+        var enabled = new Filter(new DateFilter { IsEnabled = true }, []);
+        var disabled = new Filter(new DateFilter { IsEnabled = false }, []);
+
+        ViewContentToken filtered = ViewContentToken.FromStamps(enabled, [Stamp(s_logA, 1, 3)], 3);
+        ViewContentToken unfiltered = ViewContentToken.FromStamps(disabled, [Stamp(s_logA, 1, 3)], 3);
+
+        Assert.NotEqual(filtered, unfiltered);
+    }
+
+    [Fact]
+    public void DifferentSurvivorCount_IsNotEqual()
+    {
+        ViewContentToken fewer = ViewContentToken.FromStamps(default, [Stamp(s_logA, contentVersion: 5, count: 10)], 4);
+        ViewContentToken more = ViewContentToken.FromStamps(default, [Stamp(s_logA, contentVersion: 5, count: 10)], 8);
+
+        Assert.NotEqual(fewer, more);
+    }
+
+    [Fact]
+    public void Empty_EqualsEmpty_ButNotContent()
+    {
+        Assert.Equal(ViewContentToken.Empty, ViewContentToken.Empty);
+        Assert.True(default(ViewContentToken) == ViewContentToken.Empty);
+
+        ViewContentToken content = ViewContentToken.FromStamps(default, [Stamp(s_logA, 1, 3)], 3);
+        Assert.NotEqual(ViewContentToken.Empty, content);
+        Assert.True(ViewContentToken.Empty != content);
+    }
+
+    [Fact]
+    public void From_OverARealSnapshot_MatchesTheStampsOfItsInScopeReaders()
+    {
+        EventLogId logId = EventLogId.Create();
+        IEventColumnReader reader = EventColumnStore
+            .Build(BuildEvents(8), generation: 0, contentVersion: 0)
+            .CreateReader(logId);
+
+        var state = new OrderedViewState();
+        state.ReconcileLog(logId, reader);
+        RebuildRequest request = state.BeginRebuild(
+            static (_, _) => true, new SortContext(orderBy: null, isDescending: false, groupBy: null, isGroupDescending: false));
+        Assert.True(state.TryAdoptRebuild(
+            request, OrderedViewState.BuildIndex(request, TestContext.Current.CancellationToken)));
+
+        OrderedViewSnapshot snapshot = state.Current;
+        var filter = new Filter(new DateFilter { IsEnabled = true }, []);
+
+        ViewContentToken fromSnapshot = ViewContentToken.From(filter, state.AdoptedInScope, snapshot);
+        ViewContentToken fromStamps = ViewContentToken.FromStamps(
+            filter,
+            [new ViewContentTokenReaderStamp(logId, reader.Generation, reader.ContentVersion, reader.Count)],
+            snapshot.Count);
+
+        Assert.Equal(fromStamps, fromSnapshot);
+        Assert.NotEqual(ViewContentToken.Empty, fromSnapshot);
+    }
+
+    [Fact]
+    public void MemberOrder_DoesNotMatter()
+    {
+        ViewContentToken oneOrder = ViewContentToken.FromStamps(
+            default, [Stamp(s_logA, 1, 3), Stamp(s_logB, 2, 4)], 7);
+        ViewContentToken otherOrder = ViewContentToken.FromStamps(
+            default, [Stamp(s_logB, 2, 4), Stamp(s_logA, 1, 3)], 7);
+
+        Assert.Equal(oneOrder, otherOrder);
+    }
+
+    [Fact]
+    public void SameStamps_AreEqual()
+    {
+        ViewContentToken first = ViewContentToken.FromStamps(default, [Stamp(s_logA, contentVersion: 5, count: 10)], 8);
+        ViewContentToken second = ViewContentToken.FromStamps(default, [Stamp(s_logA, contentVersion: 5, count: 10)], 8);
+
+        Assert.Equal(first, second);
+        Assert.True(first == second);
+        Assert.Equal(first.GetHashCode(), second.GetHashCode());
+    }
+
+    private static ResolvedEvent[] BuildEvents(int count)
+    {
+        var baseTime = new DateTime(2026, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+        var events = new ResolvedEvent[count];
+
+        for (int i = 0; i < count; i++)
+        {
+            events[i] = new ResolvedEvent("Application", LogPathType.Channel)
+            {
+                RecordId = i + 1,
+                TimeCreated = baseTime.AddSeconds(i),
+                Id = 1000 + i,
+                Source = "Source"
+            };
+        }
+
+        return events;
+    }
+
+    private static ViewContentTokenReaderStamp Stamp(EventLogId logId, long contentVersion, int count) =>
+        new(logId, Generation: 0, contentVersion, count);
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/ViewRequestProtocolTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/ViewRequestProtocolTests.cs
new file mode 100644
index 000000000..0d4fb28ae
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/ViewRequestProtocolTests.cs
@@ -0,0 +1,705 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.Channels;
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
+using EventLogExpert.Filtering.Persistence;
+using EventLogExpert.Runtime.LogTable;
+using EventLogExpert.Runtime.LogTable.OrderedView;
+using EventLogExpert.Runtime.Tests.LogTable.TestSupport;
+
+namespace EventLogExpert.Runtime.Tests.LogTable.OrderedView;
+
+public sealed class ViewRequestProtocolTests
+{
+    private static readonly Filter s_emptyFilter = new(null, []);
+
+    [Fact]
+    public async Task Clear_CancelsAndReleasesInFlightScopeBuild()
+    {
+        const int SampleSize = 40_000;
+        const int MaxPollAttempts = 300;
+        const int PollDelayMilliseconds = 10;
+
+        EventLogId logId = EventLogId.Create();
+        IEventColumnReader reader = LargeReader(logId, SampleSize);
+
+        using var entered = new ManualResetEventSlim(false);
+        using var release = new ManualResetEventSlim(false);
+        int examined = 0;
+        int gateArmed = 1;
+
+        await using var writer = new OrderedViewWriter(publishEvery: 5000, publishIntervalMs: 0);
+
+        writer.EnqueueReconcile(logId, reader);
+        writer.EnqueueViewRequest(ViewRequests.For(
+            new SortContext(ColumnName.RecordId, false, null, false), s_emptyFilter, [logId], Predicate));
+
+        Assert.True(entered.Wait(OrderedViewTestTimeouts.Default, TestContext.Current.CancellationToken));
+
+        writer.EnqueueClear(ViewRequests.Identity(), ViewRequests.NextSequence());
+
+        bool cleared = false;
+        for (int attempt = 0; attempt < MaxPollAttempts && !cleared; attempt++)
+        {
+            if (writer.Current.Count == 0 && writer.Current.Version > 0) { cleared = true; }
+            else { await Task.Delay(PollDelayMilliseconds, TestContext.Current.CancellationToken); }
+        }
+
+        Assert.True(cleared, "the clear was never consumed, so the cancel below would be untested");
+
+        release.Set();
+
+        OrderedViewSnapshot snapshot =
+            await writer.DrainAsync().WaitAsync(OrderedViewTestTimeouts.Default, TestContext.Current.CancellationToken);
+
+        Assert.Null(writer.Faulted);
+        Assert.Equal(0, snapshot.Count);
+        Assert.True(Volatile.Read(ref examined) < SampleSize,
+            $"the build ran to completion after the clear instead of being cancelled: {examined} of {SampleSize} rows");
+
+        Assert.Null(writer.CurrentBuildTask);
+        return;
+
+        bool Predicate(EventLocator locator, IEventColumnReader columnReader)
+        {
+            Interlocked.Increment(ref examined);
+
+            if (Interlocked.Exchange(ref gateArmed, 0) == 1)
+            {
+                entered.Set();
+                release.Wait(OrderedViewTestTimeouts.Default);
+            }
+
+            return true;
+        }
+    }
+
+    [Fact]
+    public async Task Clear_ReportsNoAnswerRatherThanAnEmptyOne()
+    {
+        var sample = new OrderedViewSample(seed: 712, logCount: 1);
+        sample.SeedInterleaved(24);
+        EventLogId logId = sample.LogId(0);
+        CancellationToken cancellationToken = TestContext.Current.CancellationToken;
+
+        await using var writer = new OrderedViewWriter(publishIntervalMs: 0);
+        var captured = new List<OrderedViewUpdate>();
+        Lock gate = new();
+
+        writer.Updated += update =>
+        {
+            lock (gate) { captured.Add(update); }
+        };
+
+        writer.EnqueueViewRequest(RequestFor(logId, ReaderOver(sample, logId, 24)));
+        await DrainTwiceAsync(writer, cancellationToken);
+
+        lock (gate) { Assert.IsType<OrderedViewReady>(captured[^1]); }
+
+        writer.EnqueueClear(ViewRequests.Identity(), ViewRequests.NextSequence());
+        await DrainTwiceAsync(writer, cancellationToken);
+
+        lock (gate) { Assert.IsType<OrderedViewCleared>(captured[^1]); }
+
+        Assert.Null(writer.Faulted);
+    }
+
+    [Fact]
+    public async Task ContentCommands_NeverPromoteTheIdentity_OnlyThePublicationVersion()
+    {
+        var sample = new OrderedViewSample(seed: 701, logCount: 1);
+        sample.SeedInterleaved(60);
+        EventLogId logId = sample.LogId(0);
+        CancellationToken cancellationToken = TestContext.Current.CancellationToken;
+
+        await using var writer = new OrderedViewWriter(publishIntervalMs: 0);
+        var captured = new List<OrderedViewUpdate>();
+        Lock gate = new();
+
+        writer.Updated += update =>
+        {
+            lock (gate) { captured.Add(update); }
+        };
+
+        IEventColumnReader partial = ReaderOver(sample, logId, 30);
+        ViewRequest request = RequestFor(logId, partial);
+
+        writer.EnqueueViewRequest(request);
+        await DrainTwiceAsync(writer, cancellationToken);
+
+        long afterAdopt = LatestVersion(captured, gate);
+
+        writer.EnqueueReconcile(logId, ReaderOver(sample, logId, 60));
+        await DrainTwiceAsync(writer, cancellationToken);
+
+        OrderedViewUpdate[] after;
+
+        lock (gate) { after = [.. captured.Where(update => update.SnapshotVersion > afterAdopt)]; }
+
+        Assert.NotEmpty(after);
+        Assert.All(after, update => Assert.Equal(request.Identity, update.Identity));
+    }
+
+    [Fact]
+    public async Task DelayedLowerSequenceRequest_IsDroppedByTheHighWatermark()
+    {
+        var sample = new OrderedViewSample(seed: 702, logCount: 1);
+        sample.SeedInterleaved(40);
+        EventLogId logId = sample.LogId(0);
+        CancellationToken cancellationToken = TestContext.Current.CancellationToken;
+
+        await using var writer = new OrderedViewWriter(publishIntervalMs: 0);
+        var captured = new List<OrderedViewUpdate>();
+        Lock gate = new();
+
+        writer.Updated += update =>
+        {
+            lock (gate) { captured.Add(update); }
+        };
+
+        IEventColumnReader reader = ReaderOver(sample, logId, 40);
+        ViewRequest current = RequestFor(logId, reader, ColumnName.Source, sequence: 100);
+
+        writer.EnqueueViewRequest(current);
+        await DrainTwiceAsync(writer, cancellationToken);
+
+        ViewRequest straggler = RequestFor(logId, reader, ColumnName.Level, sequence: 99);
+
+        writer.EnqueueViewRequest(straggler);
+        await DrainTwiceAsync(writer, cancellationToken);
+
+        lock (gate)
+        {
+            Assert.DoesNotContain(captured, update => update.Identity == straggler.Identity);
+            Assert.Contains(captured, update => update.Identity == current.Identity);
+        }
+    }
+
+    [Fact]
+    public void Key_DifferentScope_DiffersEvenWhenEverythingElseMatches()
+    {
+        EventLogId logA = EventLogId.Create(), logB = EventLogId.Create();
+
+        Assert.NotEqual(ViewRequests.Identity([logA]), ViewRequests.Identity([logA, logB]));
+    }
+
+    [Fact]
+    public void Key_IsRecomputedForEveryWithProducedState_NotCopiedFromThePredecessor()
+    {
+        EventLogId logId = EventLogId.Create();
+
+        var state = new LogTableState { ActiveEventLogId = logId, EventTables = [new LogView(logId)] };
+
+        ViewIdentity before = state.ViewIdentity;
+
+        LogTableState resorted = state with { RequestedOrderBy = ColumnName.Level };
+
+        Assert.NotEqual(before, resorted.ViewIdentity);
+        Assert.Equal(before, state.ViewIdentity);
+    }
+
+    [Fact]
+    public void Key_OrderingsThatNormalizeToTheSameSortContext_AreStillDifferentIdentities()
+    {
+        var normalized = new SortContext(null, false, ColumnName.Source, false);
+        var explicitly = new SortContext(ColumnName.DateAndTime, false, ColumnName.Source, false);
+
+        Assert.Equal(normalized, explicitly);
+        Assert.NotEqual(
+            ViewRequests.Identity(orderBy: null, groupBy: ColumnName.Source),
+            ViewRequests.Identity(orderBy: ColumnName.DateAndTime, groupBy: ColumnName.Source));
+    }
+
+    [Fact]
+    public void Key_ScopeOrderIsCanonical_SoEnumerationOrderCannotChangeIdentity()
+    {
+        EventLogId logA = EventLogId.Create(), logB = EventLogId.Create();
+
+        Assert.Equal(ViewRequests.Identity([logA, logB]), ViewRequests.Identity([logB, logA]));
+    }
+
+    [Fact]
+    public void Key_SemanticallyEqualFiltersBuiltApart_AreTheSameIdentity()
+    {
+        Assert.Equal(ViewRequests.Identity(filter: LevelErrorFilter()), ViewRequests.Identity(filter: LevelErrorFilter()));
+        Assert.NotEqual(ViewRequests.Identity(filter: LevelErrorFilter()), ViewRequests.Identity(filter: s_emptyFilter));
+    }
+
+    [Fact]
+    public void Key_TwoIndependentlyBuiltEqualStates_ProduceEqualKeys()
+    {
+        EventLogId logA = EventLogId.Create(), logB = EventLogId.Create();
+
+        ViewIdentity left = ViewRequests.Identity([logA, logB], logA, ColumnName.Source, true, filter: LevelErrorFilter());
+        ViewIdentity right = ViewRequests.Identity([logA, logB], logA, ColumnName.Source, true, filter: LevelErrorFilter());
+
+        Assert.NotSame(left, right);
+        Assert.Equal(left, right);
+        Assert.Equal(left.GetHashCode(), right.GetHashCode());
+    }
+
+    [Fact]
+    public void Key_UngroupedTabAndAOneMemberGroupOverTheSameLog_AreDifferentIdentities()
+    {
+        EventLogId logId = EventLogId.Create();
+        var groupId = LogTabGroupId.Create();
+        var header = new LogView(EventLogId.Create()) { GroupId = groupId };
+
+        var ungrouped = new LogTableState { ActiveEventLogId = logId, EventTables = [new LogView(logId)] };
+
+        var grouped = new LogTableState
+        {
+            ActiveEventLogId = header.Id,
+            EventTables = [header, new LogView(logId)],
+            Groups = [new LogTabGroup(groupId, "Group", [logId])]
+        };
+
+        Assert.NotEqual(ungrouped.ViewIdentity, grouped.ViewIdentity);
+        Assert.True(ungrouped.ViewIdentity.CoversSameViewAs(grouped.ViewIdentity));
+    }
+
+    [Fact]
+    public async Task ReissuingTheAdoptedCoverageUnderANewIdentity_RepublishesTheSameRows()
+    {
+        var sample = new OrderedViewSample(seed: 703, logCount: 1);
+        sample.SeedInterleaved(50);
+        EventLogId logId = sample.LogId(0);
+        CancellationToken cancellationToken = TestContext.Current.CancellationToken;
+
+        await using var writer = new OrderedViewWriter(publishIntervalMs: 0);
+        var captured = new List<OrderedViewUpdate>();
+        Lock gate = new();
+
+        writer.Updated += update =>
+        {
+            lock (gate) { captured.Add(update); }
+        };
+
+        IEventColumnReader reader = ReaderOver(sample, logId, 50);
+        ViewRequest first = RequestFor(logId, reader);
+
+        writer.EnqueueViewRequest(first);
+        await DrainTwiceAsync(writer, cancellationToken);
+
+        int rows = writer.Current.Count;
+        long versionAfterFirst = LatestVersion(captured, gate);
+
+        ViewRequest again = RequestFor(logId, reader, activeLogId: EventLogId.Create());
+
+        Assert.True(again.Identity.CoversSameViewAs(first.Identity));
+        Assert.NotEqual(first.Identity, again.Identity);
+
+        writer.EnqueueViewRequest(again);
+        await DrainTwiceAsync(writer, cancellationToken);
+
+        OrderedViewReady[] restamped;
+
+        lock (gate)
+        {
+            restamped = [.. captured.OfType<OrderedViewReady>().Where(update => update.Identity == again.Identity)];
+        }
+
+        Assert.NotEmpty(restamped);
+        Assert.Equal(rows, writer.Current.Count);
+        Assert.True(restamped[^1].SnapshotVersion > versionAfterFirst);
+    }
+
+    [Fact]
+    public async Task ReloadedToEmptyLog_ReportsTheSameFinalEmptyAnswerAsAnInitiallyEmptyLog()
+    {
+        var sample = new OrderedViewSample(seed: 710, logCount: 1);
+        sample.SeedInterleaved(40);
+        EventLogId logId = sample.LogId(0);
+        CancellationToken cancellationToken = TestContext.Current.CancellationToken;
+
+        await using var writer = new OrderedViewWriter(publishIntervalMs: 0);
+        var captured = new List<OrderedViewUpdate>();
+        Lock gate = new();
+
+        writer.Updated += update =>
+        {
+            lock (gate) { captured.Add(update); }
+        };
+
+        writer.EnqueueViewRequest(RequestFor(logId, ReaderOver(sample, logId, 40)));
+        await DrainTwiceAsync(writer, cancellationToken);
+
+        lock (gate) { Assert.IsType<OrderedViewReady>(captured[^1]); }
+
+        writer.EnqueueViewRequest(RequestFor(logId, GenerationReaderOver(sample, logId, 0, generation: 1)));
+        await DrainTwiceAsync(writer, cancellationToken);
+
+        lock (gate)
+        {
+            var ready = Assert.IsType<OrderedViewReady>(captured[^1]);
+            Assert.Equal(0, ready.View.Count);
+            Assert.Empty(ready.InScope);
+        }
+
+        Assert.Null(writer.Faulted);
+    }
+
+    [Fact]
+    public void Restamp_IsRefusedWhileACarriedReaderHasUnreconciledRows()
+    {
+        var sample = new OrderedViewSample(seed: 706, logCount: 1);
+        sample.SeedInterleaved(60);
+        EventLogId logId = sample.LogId(0);
+
+        var state = new OrderedViewState();
+
+        Assert.True(state.TrySetActiveScope([logId], 1));
+        state.ReconcileLog(logId, ReaderOver(sample, logId, 30));
+
+        RebuildRequest request = state.BeginRebuild(static (_, _) => true, new SortContext(ColumnName.RecordId, false, null, false));
+        Assert.True(state.TryAdoptRebuild(request, OrderedViewState.BuildIndex(request, CancellationToken.None)));
+
+        Assert.True(state.CanRestampAdopted([logId], new Dictionary<EventLogId, IEventColumnReader>
+        {
+            [logId] = ReaderOver(sample, logId, 30)
+        }));
+
+        Assert.False(state.CanRestampAdopted([logId], new Dictionary<EventLogId, IEventColumnReader>
+        {
+            [logId] = ReaderOver(sample, logId, 60)
+        }));
+    }
+
+    [Fact]
+    public void Restamp_IsRefusedWhileATransitionHoldIsInForce()
+    {
+        var sample = new OrderedViewSample(seed: 1000, logCount: 1);
+        sample.SeedInterleaved(40);
+        EventLogId logId = sample.LogId(0);
+
+        var state = new OrderedViewState();
+
+        Assert.True(state.TrySetActiveScope([logId], 1));
+        state.ReconcileLog(logId, ReaderOver(sample, logId, 30));
+
+        RebuildRequest adoptedRequest = state.BeginRebuild(
+            static (_, _) => true, new SortContext(ColumnName.RecordId, false, null, false));
+
+        Assert.True(state.TryAdoptRebuild(adoptedRequest, OrderedViewState.BuildIndex(adoptedRequest, CancellationToken.None)));
+
+        var readers = new Dictionary<EventLogId, IEventColumnReader> { [logId] = ReaderOver(sample, logId, 30) };
+
+        Assert.True(state.CanRestampAdopted([logId], readers));
+
+        state.BeginRebuild(static (_, _) => true, new SortContext(ColumnName.Level, false, null, false), hold: true);
+
+        Assert.False(state.CanRestampAdopted([logId], readers));
+    }
+
+    [Fact]
+    public void Restamp_IsRefusedWhileTheLiveScopeHasMovedOn()
+    {
+        var sample = new OrderedViewSample(seed: 705, logCount: 2);
+        sample.SeedInterleaved(40);
+        EventLogId logA = sample.LogId(0), logB = sample.LogId(1);
+
+        var state = new OrderedViewState();
+        IEventColumnReader readerA = sample.Reader(0);
+
+        Assert.True(state.TrySetActiveScope([logA], 1));
+
+        state.ReconcileLog(logA, readerA);
+
+        RebuildRequest request = state.BeginRebuild(static (_, _) => true, new SortContext(ColumnName.RecordId, false, null, false));
+        Assert.True(state.TryAdoptRebuild(request, OrderedViewState.BuildIndex(request, CancellationToken.None)));
+
+        var readers = new Dictionary<EventLogId, IEventColumnReader> { [logA] = readerA };
+
+        Assert.True(state.CanRestampAdopted([logA], readers));
+
+        Assert.True(state.TrySetActiveScope([logB], 2));
+        Assert.False(state.CanRestampAdopted([logA], readers));
+    }
+
+    [Fact]
+    public void Restamp_RestoresTheRequestedConfig_SoALaterLifecycleRebuildCannotInheritTheAbandonedOne()
+    {
+        var sample = new OrderedViewSample(seed: 704, logCount: 2);
+        sample.SeedInterleaved(40);
+        EventLogId logA = sample.LogId(0), logB = sample.LogId(1);
+
+        var state = new OrderedViewState();
+        IEventColumnReader readerA = sample.Reader(0);
+
+        state.ReconcileLog(logA, readerA);
+
+        Assert.True(state.TrySetActiveScope([logA, logB], 1));
+
+        var adopted = new SortContext(ColumnName.RecordId, false, null, false);
+        RebuildRequest adoptedRequest = state.BeginRebuild(static (_, _) => true, adopted);
+        Assert.True(state.TryAdoptRebuild(adoptedRequest, OrderedViewState.BuildIndex(adoptedRequest, CancellationToken.None)));
+
+        var abandoned = new SortContext(ColumnName.Level, true, null, false);
+        state.BeginRebuild(static (_, _) => true, abandoned);
+        state.SupersedeInFlight();
+
+        state.RestoreRequestedFromAdopted();
+
+        RebuildRequest afterClose = state.RemoveLog(logB);
+
+        Assert.Equal(adopted, afterClose.Context);
+    }
+
+    [Fact]
+    public async Task Retag_AfterAHigherGenerationReconcile_SupersedesInsteadOfRidingTheStaleBuild()
+    {
+        var sample = new OrderedViewSample(seed: 712, logCount: 1);
+        sample.SeedInterleaved(60);
+        EventLogId logId = sample.LogId(0);
+
+        using var entered = new ManualResetEventSlim(false);
+        using var release = new ManualResetEventSlim(false);
+        int gateArmed = 1;
+
+        bool Predicate(EventLocator locator, IEventColumnReader reader)
+        {
+            if (Interlocked.Exchange(ref gateArmed, 0) == 1)
+            {
+                entered.Set();
+                release.Wait(OrderedViewTestTimeouts.Default);
+            }
+
+            return true;
+        }
+
+        await using var writer = new OrderedViewWriter(publishIntervalMs: 0);
+
+        var context = new SortContext(ColumnName.RecordId, false, null, false);
+
+        writer.EnqueueViewRequest(ViewRequests.For(
+            context, s_emptyFilter, [logId], Predicate,
+            readers: new Dictionary<EventLogId, IEventColumnReader> { [logId] = ReaderOver(sample, logId, 60) },
+            activeLogId: logId));
+
+        Assert.True(entered.Wait(OrderedViewTestTimeouts.Default, TestContext.Current.CancellationToken));
+
+        writer.EnqueueReconcile(logId, GenerationReaderOver(sample, logId, 25, generation: 1));
+
+        writer.EnqueueViewRequest(ViewRequests.For(
+            context, s_emptyFilter, [logId],
+            readers: new Dictionary<EventLogId, IEventColumnReader> { [logId] = GenerationReaderOver(sample, logId, 25, generation: 1) },
+            activeLogId: logId));
+
+        release.Set();
+
+        OrderedViewSnapshot snapshot = await DrainUntilStableAsync(writer, TestContext.Current.CancellationToken);
+
+        Assert.Null(writer.Faulted);
+
+        Assert.Equal(25, snapshot.Count);
+
+        for (int i = 0; i < snapshot.Count; i++)
+        {
+            EventLocator locator = snapshot.At(i).Locator;
+
+            Assert.Equal(1, locator.Generation);
+            Assert.True(snapshot.TryGetReader(locator, out _));
+        }
+    }
+
+    [Fact]
+    public async Task Retag_HigherGenerationReader_SupersedesInsteadOfMixingGenerations()
+    {
+        var sample = new OrderedViewSample(seed: 708, logCount: 1);
+        sample.SeedInterleaved(60);
+        EventLogId logId = sample.LogId(0);
+
+        using var entered = new ManualResetEventSlim(false);
+        using var release = new ManualResetEventSlim(false);
+        int gateArmed = 1;
+
+        bool Predicate(EventLocator locator, IEventColumnReader reader)
+        {
+            if (Interlocked.Exchange(ref gateArmed, 0) == 1)
+            {
+                entered.Set();
+                release.Wait(OrderedViewTestTimeouts.Default);
+            }
+
+            return true;
+        }
+
+        await using var writer = new OrderedViewWriter(publishIntervalMs: 0);
+
+        var context = new SortContext(ColumnName.RecordId, false, null, false);
+        IEventColumnReader generation0 = ReaderOver(sample, logId, 60);
+        IEventColumnReader generation1 = GenerationReaderOver(sample, logId, 25, generation: 1);
+
+        writer.EnqueueViewRequest(ViewRequests.For(
+            context, s_emptyFilter, [logId], Predicate,
+            readers: new Dictionary<EventLogId, IEventColumnReader> { [logId] = generation0 },
+            activeLogId: logId));
+
+        Assert.True(entered.Wait(OrderedViewTestTimeouts.Default, TestContext.Current.CancellationToken));
+
+        writer.EnqueueViewRequest(ViewRequests.For(
+            context, s_emptyFilter, [logId],
+            readers: new Dictionary<EventLogId, IEventColumnReader> { [logId] = generation1 },
+            activeLogId: logId));
+
+        release.Set();
+
+        OrderedViewSnapshot snapshot = await DrainUntilStableAsync(writer, TestContext.Current.CancellationToken);
+
+        Assert.Null(writer.Faulted);
+
+        Assert.Equal(25, snapshot.Count);
+        for (int i = 0; i < snapshot.Count; i++) { Assert.Equal(1, snapshot.At(i).Locator.Generation); }
+    }
+
+    [Fact]
+    public async Task Retag_NewerReaderMap_IncludesItsSuffixAtAdoption()
+    {
+        var sample = new OrderedViewSample(seed: 709, logCount: 1);
+        sample.SeedInterleaved(80);
+        EventLogId logId = sample.LogId(0);
+
+        using var entered = new ManualResetEventSlim(false);
+        using var release = new ManualResetEventSlim(false);
+        int gateArmed = 1;
+
+        bool Predicate(EventLocator locator, IEventColumnReader reader)
+        {
+            if (Interlocked.Exchange(ref gateArmed, 0) == 1)
+            {
+                entered.Set();
+                release.Wait(OrderedViewTestTimeouts.Default);
+            }
+
+            return true;
+        }
+
+        await using var writer = new OrderedViewWriter(publishIntervalMs: 0);
+
+        var context = new SortContext(ColumnName.RecordId, false, null, false);
+
+        writer.EnqueueViewRequest(ViewRequests.For(
+            context, s_emptyFilter, [logId], Predicate,
+            readers: new Dictionary<EventLogId, IEventColumnReader> { [logId] = ReaderOver(sample, logId, 30) },
+            activeLogId: logId));
+
+        Assert.True(entered.Wait(OrderedViewTestTimeouts.Default, TestContext.Current.CancellationToken));
+
+        writer.EnqueueViewRequest(ViewRequests.For(
+            context, s_emptyFilter, [logId],
+            readers: new Dictionary<EventLogId, IEventColumnReader> { [logId] = ReaderOver(sample, logId, 80) },
+            activeLogId: null));
+
+        release.Set();
+
+        OrderedViewSnapshot snapshot = await DrainUntilStableAsync(writer, TestContext.Current.CancellationToken);
+
+        Assert.Null(writer.Faulted);
+        Assert.Equal(80, snapshot.Count);
+    }
+
+    [Fact]
+    public async Task SingleLogZeroSurvivor_RoutesAsReady()
+    {
+        var sample = new OrderedViewSample(seed: 711, logCount: 1);
+        sample.SeedInterleaved(40);
+        EventLogId logId = sample.LogId(0);
+
+        await using var writer = new OrderedViewWriter(publishIntervalMs: 0);
+        var captured = new List<OrderedViewUpdate>();
+        Lock gate = new();
+
+        writer.Updated += update =>
+        {
+            lock (gate) { captured.Add(update); }
+        };
+
+        writer.EnqueueViewRequest(ViewRequests.For(
+            new SortContext(ColumnName.RecordId, false, null, false),
+            s_emptyFilter,
+            [logId],
+            static (_, _) => false,
+            readers: new Dictionary<EventLogId, IEventColumnReader> { [logId] = ReaderOver(sample, logId, 40) },
+            activeLogId: logId));
+
+        await DrainTwiceAsync(writer, TestContext.Current.CancellationToken);
+
+        lock (gate)
+        {
+            var ready = Assert.IsType<OrderedViewReady>(captured[^1]);
+            Assert.Equal(0, ready.View.Count);
+        }
+
+        Assert.Null(writer.Faulted);
+    }
+
+    private static async Task DrainTwiceAsync(OrderedViewWriter writer, CancellationToken cancellationToken)
+    {
+        await writer.DrainAsync().WaitAsync(OrderedViewTestTimeouts.Default, cancellationToken);
+        await writer.DrainAsync().WaitAsync(OrderedViewTestTimeouts.Default, cancellationToken);
+    }
+
+    private static async Task<OrderedViewSnapshot> DrainUntilStableAsync(OrderedViewWriter writer, CancellationToken cancellationToken)
+    {
+        await writer.DrainAsync().WaitAsync(OrderedViewTestTimeouts.Default, cancellationToken);
+        await writer.DrainAsync().WaitAsync(OrderedViewTestTimeouts.Default, cancellationToken);
+
+        return await writer.DrainAsync().WaitAsync(OrderedViewTestTimeouts.Default, cancellationToken);
+    }
+
+    private static IEventColumnReader GenerationReaderOver(OrderedViewSample sample, EventLogId logId, int count, int generation) =>
+        EventColumnStore.Build([.. sample.Events(0).Take(count)], generation, generation).CreateReader(logId);
+
+    private static IEventColumnReader LargeReader(EventLogId logId, int count)
+    {
+        var clock = new DateTime(2026, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+        var events = new List<ResolvedEvent>(count);
+
+        for (int i = 0; i < count; i++)
+        {
+            events.Add(new ResolvedEvent("Log", LogPathType.Channel)
+            {
+                RecordId = i,
+                TimeCreated = clock.AddMilliseconds(i),
+                Id = 1000,
+                Level = "Information",
+                Source = "Provider.A",
+                LogName = "Channel"
+            });
+        }
+
+        return EventColumnStore.Build(events, generation: 0, contentVersion: 0).CreateReader(logId);
+    }
+
+    private static long LatestVersion(List<OrderedViewUpdate> captured, Lock gate)
+    {
+        lock (gate) { return captured.Count == 0 ? -1 : captured[^1].SnapshotVersion; }
+    }
+
+    private static Filter LevelErrorFilter()
+    {
+        SavedFilter levelError = SavedFilter.TryCreate("Level == \"Error\"") ??
+            throw new InvalidOperationException("Level filter failed to compile.");
+
+        return new Filter(null, [levelError]);
+    }
+
+    private static IEventColumnReader ReaderOver(OrderedViewSample sample, EventLogId logId, int count) =>
+        EventColumnStore.Build([.. sample.Events(0).Take(count)], 0, 0).CreateReader(logId);
+
+    private static ViewRequest RequestFor(
+        EventLogId logId,
+        IEventColumnReader reader,
+        ColumnName orderBy = ColumnName.RecordId,
+        long? sequence = null,
+        EventLogId? activeLogId = null) =>
+        ViewRequests.For(
+            new SortContext(orderBy, false, null, false),
+            s_emptyFilter,
+            [logId],
+            readers: new Dictionary<EventLogId, IEventColumnReader> { [logId] = reader },
+            sequence: sequence,
+            activeLogId: activeLogId ?? logId);
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/ViewRequests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/ViewRequests.cs
new file mode 100644
index 000000000..6aa7e0f95
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedView/ViewRequests.cs
@@ -0,0 +1,83 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
+using EventLogExpert.Runtime.LogTable;
+using EventLogExpert.Runtime.LogTable.OrderedView;
+using System.Collections.Immutable;
+
+namespace EventLogExpert.Runtime.Tests.LogTable.OrderedView;
+
+internal static class ViewRequests
+{
+    private static readonly Filter s_emptyFilter = new(null, []);
+
+    private static long s_sequence;
+
+    internal static Filter EmptyFilter => s_emptyFilter;
+
+    internal static RebuildRequest? AdvanceScope(
+        OrderedViewState state,
+        IReadOnlyCollection<EventLogId> scopeLogs,
+        long scopeVersion) =>
+        state.TrySetActiveScope(scopeLogs, scopeVersion) ? state.CaptureScopeReseed() : null;
+
+    internal static ViewRequest For(
+        SortContext context,
+        Filter filter,
+        IEnumerable<EventLogId> scope,
+        Func<EventLocator, IEventColumnReader, bool>? predicate = null,
+        IReadOnlyDictionary<EventLogId, IEventColumnReader>? readers = null,
+        bool? hold = null,
+        long? sequence = null,
+        EventLogId? activeLogId = null)
+    {
+        EventLogId[] logs = [.. scope];
+
+        return new ViewRequest(
+            Identity(logs,
+                activeLogId,
+                context.OrderBy,
+                context.IsDescending,
+                context.GroupBy,
+                context.IsGroupDescending,
+                filter: filter),
+            sequence ?? NextSequence(),
+            logs,
+            readers ?? new Dictionary<EventLogId, IEventColumnReader>(),
+            context,
+            filter,
+            predicate ?? (static (_, _) => true),
+            hold);
+    }
+
+    internal static ViewIdentity Identity(
+        IEnumerable<EventLogId>? scope = null,
+        EventLogId? activeLogId = null,
+        ColumnName? orderBy = null,
+        bool isDescending = false,
+        ColumnName? groupBy = null,
+        bool isGroupDescending = false,
+        bool timelineVisible = false,
+        bool isMultiLogDisplay = false,
+        Filter? filter = null)
+    {
+        ImmutableArray<EventLogId> logs = scope is null ?
+            [] :
+            [.. scope.OrderBy(static logId => logId.Value)];
+
+        return new ViewIdentity(
+            activeLogId,
+            logs,
+            orderBy,
+            isDescending,
+            groupBy,
+            isGroupDescending,
+            timelineVisible,
+            isMultiLogDisplay,
+            filter ?? s_emptyFilter);
+    }
+
+    internal static long NextSequence() => Interlocked.Increment(ref s_sequence);
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedViewSourceTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedViewSourceTests.cs
new file mode 100644
index 000000000..18dcf0543
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/OrderedViewSourceTests.cs
@@ -0,0 +1,594 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.Channels;
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
+using EventLogExpert.Logging.Abstractions;
+using EventLogExpert.Runtime.Histogram;
+using EventLogExpert.Runtime.LogTable;
+using EventLogExpert.Runtime.LogTable.OrderedView;
+using EventLogExpert.Runtime.Tests.LogTable.TestSupport;
+using EventLogExpert.Runtime.Tests.TestUtils;
+using Fluxor;
+using NSubstitute;
+using System.Collections.Immutable;
+using Reducers = EventLogExpert.Runtime.LogTable.Reducers;
+
+namespace EventLogExpert.Runtime.Tests.LogTable;
+
+public sealed class OrderedViewSourceTests
+{
+    private const string LogName = "TestLog";
+
+    [Fact]
+    public void AChangeOfStateAlone_IsPublished_EvenWhenTheRowsAreTheSameObject()
+    {
+        var harness = new Harness();
+        harness.OpenLogWithEvents(Event(1, "Alpha"));
+
+        int publishedBefore = harness.Published.Count;
+        IEventColumnView rowsBefore = harness.Source.Current.View;
+
+        harness.SetDisplayEnabled(false);
+
+        Assert.Equal(publishedBefore + 1, harness.Published.Count);
+        Assert.Same(rowsBefore, harness.Published[^1].View);
+        Assert.Equal(PresentationState.Faulted, harness.Published[^1].State);
+    }
+
+    [Fact]
+    public void ACollapseOnlyChange_IsPublished_ThoughTheRowsAndTabAreUnchanged()
+    {
+        var harness = new Harness();
+        harness.OpenLogWithEvents(Event(1, "Alpha"));
+
+        int before = harness.Published.Count;
+        IEventColumnView rowsBefore = harness.Source.Current.View;
+
+        harness.Apply(state => state with { GroupCollapseOverrides = state.GroupCollapseOverrides.Add("Alpha") });
+
+        Assert.Equal(before + 1, harness.Published.Count);
+        Assert.Same(rowsBefore, harness.Published[^1].View);
+        Assert.Contains("Alpha", harness.Published[^1].GroupCollapseOverrides);
+    }
+
+    [Fact]
+    public void AColumnLayoutChange_IsPublished_ThoughTheRowsAreUnchanged()
+    {
+        var harness = new Harness();
+        harness.OpenLogWithEvents(Event(1, "Alpha"));
+
+        int before = harness.Published.Count;
+        IEventColumnView rowsBefore = harness.Source.Current.View;
+
+        harness.Apply(state => state with { ColumnWidths = state.ColumnWidths.SetItem(ColumnName.Source, 999) });
+
+        Assert.Equal(before + 1, harness.Published.Count);
+        Assert.Same(rowsBefore, harness.Published[^1].View);
+        Assert.Equal(999, harness.Published[^1].ColumnWidths[ColumnName.Source]);
+    }
+
+    [Fact]
+    public void AColumnOrderChange_IsPublished_ThoughTheRowsAreUnchanged()
+    {
+        var harness = new Harness();
+        harness.OpenLogWithEvents(Event(1, "Alpha"));
+
+        int before = harness.Published.Count;
+        IEventColumnView rowsBefore = harness.Source.Current.View;
+
+        harness.Apply(state => state with { ColumnOrder = state.ColumnOrder.Add(ColumnName.Source) });
+
+        Assert.Equal(before + 1, harness.Published.Count);
+        Assert.Same(rowsBefore, harness.Published[^1].View);
+        Assert.Equal(ColumnName.Source, harness.Published[^1].ColumnOrder[0]);
+    }
+
+    [Fact]
+    public void AColumnVisibilityChange_IsPublished_ThoughTheRowsAreUnchanged()
+    {
+        var harness = new Harness();
+        harness.OpenLogWithEvents(Event(1, "Alpha"));
+
+        int before = harness.Published.Count;
+        IEventColumnView rowsBefore = harness.Source.Current.View;
+
+        harness.Apply(state => state with { Columns = state.Columns.SetItem(ColumnName.Source, true) });
+
+        Assert.Equal(before + 1, harness.Published.Count);
+        Assert.Same(rowsBefore, harness.Published[^1].View);
+        Assert.True(harness.Published[^1].Columns[ColumnName.Source]);
+    }
+
+    [Fact]
+    public void ADefaultCollapseChange_IsPublished_ThoughTheRowsAndTabAreUnchanged()
+    {
+        var harness = new Harness();
+        harness.OpenLogWithEvents(Event(1, "Alpha"));
+
+        int before = harness.Published.Count;
+        IEventColumnView rowsBefore = harness.Source.Current.View;
+
+        harness.Apply(state => state with { GroupsCollapsedByDefault = true });
+
+        Assert.Equal(before + 1, harness.Published.Count);
+        Assert.Same(rowsBefore, harness.Published[^1].View);
+        Assert.True(harness.Published[^1].GroupsCollapsedByDefault);
+    }
+
+    [Fact]
+    public void AFaultCause_IsNeverPublishedBesideAStateThatSaysNothingFailed()
+    {
+        var harness = new Harness();
+        harness.OpenLogWithEvents(Event(1, "Alpha"));
+
+        harness.SetFaultCause("InvalidOperationException: bad predicate");
+
+        Assert.Equal(PresentationState.Faulted, harness.Source.Current.State);
+        Assert.NotNull(harness.Source.Current.FaultCause);
+
+        harness.Apply(state => state with { ActiveEventLogId = null });
+
+        Assert.Equal(PresentationState.Current, harness.Source.Current.State);
+        Assert.Null(harness.Source.Current.FaultCause);
+    }
+
+    [Fact]
+    public void ASecondFailureWithADifferentReason_IsPublished_ThoughNothingElseMoved()
+    {
+        var harness = new Harness();
+        harness.OpenLogWithEvents(Event(1, "Alpha"));
+
+        harness.SetFaultCause("InvalidOperationException: the first reason");
+
+        int publishedBefore = harness.Published.Count;
+
+        Assert.Equal("InvalidOperationException: the first reason", harness.Published[^1].FaultCause);
+
+        harness.SetFaultCause("InvalidOperationException: a different reason");
+
+        Assert.Equal(publishedBefore + 1, harness.Published.Count);
+        Assert.Equal("InvalidOperationException: a different reason", harness.Published[^1].FaultCause);
+    }
+
+    [Fact]
+    public void AThrowingSubscriber_IsIsolatedFromTheStatePipelineAndOtherSubscribers()
+    {
+        var harness = new Harness();
+        var reachedSecond = new List<OrderedViewPresentation>();
+
+        harness.Source.Updated += _ => throw new InvalidOperationException("subscriber blew up");
+        harness.Source.Updated += presentation => reachedSecond.Add(presentation);
+
+        harness.OpenLogWithEvents(Event(1, "Alpha"));
+
+        Assert.Single(reachedSecond);
+    }
+
+    [Fact]
+    public void AnEquivalentCollapseSet_IsNotRepublished()
+    {
+        var harness = new Harness();
+        harness.OpenLogWithEvents(Event(1, "Alpha"));
+        harness.Apply(state => state with { GroupCollapseOverrides = state.GroupCollapseOverrides.Add("Alpha") });
+
+        int afterCollapse = harness.Published.Count;
+
+        harness.Apply(state => state with
+        {
+            GroupCollapseOverrides = ImmutableHashSet.Create(StringComparer.Ordinal, "Alpha")
+        });
+
+        Assert.Equal(afterCollapse, harness.Published.Count);
+    }
+
+    [Fact]
+    public void AnOrderingThatTheRowsHaveNotCaughtUpWith_IsPublished_ThoughNothingElseMoved()
+    {
+        var harness = new Harness();
+        harness.OpenLogWithEvents(Event(1, "Alpha"));
+
+        Assert.False(harness.Source.Current.OrderingIsStale);
+
+        int publishedBefore = harness.Published.Count;
+        DisplayOrdering orderingBefore = harness.Source.Current.Ordering;
+
+        harness.Apply(state =>
+            Reducers.ReduceSetHistogramVisible(state, new SetHistogramVisibleAction(true)));
+
+        Assert.Equal(publishedBefore + 1, harness.Published.Count);
+        Assert.True(harness.Published[^1].OrderingIsStale);
+        Assert.Equal(orderingBefore, harness.Published[^1].Ordering);
+    }
+
+    [Fact]
+    public void Construction_AdoptsAChangeThatLandsBetweenSeedAndSubscribe()
+    {
+        // one-tab state (the reconcile), with no StateChanged raised in between.
+        var logId = EventLogId.Create();
+        var opened = new LogTableState
+        {
+            ActiveEventLogId = logId,
+            EventTables = ImmutableList.Create(new LogView(logId) { LogName = LogName })
+        };
+        var logTableState = Substitute.For<IState<LogTableState>>();
+        logTableState.Value.Returns(new LogTableState(), opened);
+
+        using var source = new OrderedViewSource(logTableState, Substitute.For<ITraceLogger>());
+
+        Assert.Equal(logId, source.Current.ActiveTabId);
+    }
+
+    [Fact]
+    public void Current_CarriesTheCommittedOrderingTheViewWasBuiltUnder()
+    {
+        var harness = new Harness();
+        harness.OpenLogWithEvents(Event(1, "Alpha"), Event(2, "Beta"));
+        harness.SetCommittedOrdering(ColumnName.EventId, isDescending: false, ColumnName.Source, isGroupDescending: true);
+
+        DisplayOrdering ordering = harness.Source.Current.Ordering;
+
+        Assert.Equal(ColumnName.EventId, ordering.OrderBy);
+        Assert.False(ordering.IsDescending);
+        Assert.Equal(ColumnName.Source, ordering.GroupBy);
+        Assert.True(ordering.IsGroupDescending);
+    }
+
+    [Fact]
+    public void Current_MatchesTheSeamForTheActiveTab()
+    {
+        var harness = new Harness();
+        harness.OpenLogWithEvents(Event(1, "Alpha"), Event(2, "Beta"));
+
+        LogTableState state = harness.State;
+
+        Assert.Equal(2, harness.Source.Current.View.Count);
+        Assert.Equal(state.ActiveEventLogId, harness.Source.Current.ActiveTabId);
+    }
+
+    [Fact]
+    public void Dispose_StopsPublishing()
+    {
+        var harness = new Harness();
+        var seen = new List<OrderedViewPresentation>();
+        harness.Source.Updated += presentation => seen.Add(presentation);
+
+        harness.Source.Dispose();
+        harness.OpenLogWithEvents(Event(1, "Alpha"));
+
+        Assert.Empty(seen);
+    }
+
+    [Fact]
+    public void PublicationLog_AcrossALifecycle_DescribesTheDisplayAtEveryStep()
+    {
+        var harness = new Harness();
+
+        var alpha = harness.OpenLog(Event(1, "Alpha"));
+        harness.AppendTo(alpha, Event(1, "Alpha"), Event(2, "Alpha"));
+        var beta = harness.OpenLog(Event(3, "Beta"));
+        harness.SwitchTo(alpha);
+        harness.CloseEverything();
+
+        Assert.Equal(5, harness.Published.Count);
+
+        Assert.Equal(alpha, harness.Published[0].ActiveTabId);
+        Assert.Equal(1, harness.Published[0].View.Count);
+
+        Assert.Equal(alpha, harness.Published[1].ActiveTabId);
+        Assert.Equal(2, harness.Published[1].View.Count);
+
+        Assert.Equal(beta, harness.Published[2].ActiveTabId);
+
+        Assert.Equal(alpha, harness.Published[3].ActiveTabId);
+        Assert.Equal(2, harness.Published[3].View.Count);
+
+        Assert.Null(harness.Published[4].ActiveTabId);
+        Assert.Equal(0, harness.Published[4].View.Count);
+        Assert.Equal(PresentationState.Current, harness.Published[4].State);
+    }
+
+    [Fact]
+    public void PublicationLog_DescribesTheRowsItPublishes_NotAnOrderingStillBeingRequested()
+    {
+        var harness = new Harness();
+        harness.OpenLog(Event(1, "Alpha"), Event(2, "Beta"), Event(3, "Alpha"));
+        harness.SetCommittedOrdering(ColumnName.Source, false, ColumnName.Source, false);
+
+        harness.SetRequestedOrdering(ColumnName.Level, true, ColumnName.Level, true);
+
+        OrderedViewPresentation published = harness.Published[^1];
+
+        Assert.Equal(ColumnName.Source, published.Ordering.GroupBy);
+        Assert.Equal(ColumnName.Source, published.Ordering.OrderBy);
+        Assert.False(IsFragmentedBy(published.View, ColumnName.Source));
+    }
+
+    [Fact]
+    public void PublicationLog_EveryEntryCarriesTheOrderingItsRowsWereBuiltUnder()
+    {
+        var harness = new Harness();
+        var alpha = harness.OpenLog(Event(1, "Alpha"), Event(2, "Beta"), Event(3, "Alpha"));
+
+        Assert.Null(harness.Published[^1].Ordering.GroupBy);
+        Assert.True(IsFragmentedBy(harness.Published[^1].View, ColumnName.Source));
+
+        harness.SetCommittedOrdering(ColumnName.Source, false, ColumnName.Source, false);
+
+        Assert.Equal(ColumnName.Source, harness.Published[^1].Ordering.GroupBy);
+        Assert.Equal(ColumnName.Source, harness.Published[^1].Ordering.OrderBy);
+        Assert.Equal(alpha, harness.Published[^1].ActiveTabId);
+        Assert.False(IsFragmentedBy(harness.Published[^1].View, ColumnName.Source));
+    }
+
+    [Fact]
+    public void PublicationLog_RevisionsStrictlyIncrease()
+    {
+        var harness = new Harness();
+
+        var alpha = harness.OpenLog(Event(1, "Alpha"));
+        harness.AppendTo(alpha, Event(1, "Alpha"), Event(2, "Alpha"));
+        harness.OpenLog(Event(3, "Beta"));
+        harness.SwitchTo(alpha);
+        harness.CloseEverything();
+
+        Assert.NotEmpty(harness.Published);
+
+        for (int index = 1; index < harness.Published.Count; index++)
+        {
+            Assert.True(
+                harness.Published[index].Revision > harness.Published[index - 1].Revision,
+                $"Revision did not advance at publication {index}.");
+        }
+
+        Assert.Equal(harness.Published[^1], harness.Source.Current);
+    }
+
+    [Fact]
+    public void StateChange_RaisesUpdatedWithAnAdvancedRevision()
+    {
+        var harness = new Harness();
+        var seen = new List<OrderedViewPresentation>();
+        harness.Source.Updated += presentation => seen.Add(presentation);
+
+        long before = harness.Source.Current.Revision;
+        harness.OpenLogWithEvents(Event(1, "Alpha"));
+
+        Assert.Single(seen);
+        Assert.True(seen[0].Revision > before);
+        Assert.Same(harness.Source.Current, seen[0]);
+    }
+
+    [Fact]
+    public void StateChange_ThatLeavesTheAnswerUnchanged_DoesNotRaise()
+    {
+        var harness = new Harness();
+        harness.OpenLogWithEvents(Event(1, "Alpha"));
+
+        var seen = new List<OrderedViewPresentation>();
+        harness.Source.Updated += presentation => seen.Add(presentation);
+
+        harness.RaiseUnchanged();
+
+        Assert.Empty(seen);
+    }
+
+    [Fact]
+    public void UnservedTab_ReportsUpdatingRatherThanPassingOffItsRowsAsCurrent()
+    {
+        var harness = new Harness();
+        harness.OpenLogNotYetServed(Event(1, "Alpha"));
+
+        Assert.Equal(PresentationState.Updating, harness.Source.Current.State);
+    }
+
+    [Fact]
+    public void WithNoActiveTab_PublishesAnEmptyViewRatherThanNull()
+    {
+        var harness = new Harness();
+
+        Assert.Equal(0, harness.Source.Current.View.Count);
+        Assert.Null(harness.Source.Current.ActiveTabId);
+        Assert.Equal(PresentationState.Current, harness.Source.Current.State);
+    }
+
+    private static ResolvedEvent Event(int id, string source) =>
+        new(LogName, LogPathType.Channel) { Id = id, RecordId = id, Source = source };
+
+    private static bool IsFragmentedBy(IEventColumnView view, ColumnName groupBy)
+    {
+        var runs = new List<string>();
+
+        for (int index = 0; index < view.Count; index++)
+        {
+            string key = view.GroupKeyAt(view.LocatorAt(index), groupBy);
+
+            if (runs.Count == 0 || !string.Equals(runs[^1], key, StringComparison.Ordinal)) { runs.Add(key); }
+        }
+
+        return runs.Count != runs.Distinct(StringComparer.Ordinal).Count();
+    }
+
+    private sealed class Harness
+    {
+        private readonly IState<LogTableState> _logTableState = Substitute.For<IState<LogTableState>>();
+        private readonly Dictionary<EventLogId, AosReferenceView> _views = [];
+
+        public Harness()
+        {
+            State = new LogTableState();
+            _logTableState.Value.Returns(_ => State);
+            Source = new OrderedViewSource(_logTableState, Substitute.For<ITraceLogger>());
+
+            Source.Updated += presentation => Published.Add(presentation);
+        }
+
+        public List<OrderedViewPresentation> Published { get; } = [];
+
+        public OrderedViewSource Source { get; }
+
+        public LogTableState State { get; private set; }
+
+        public void AppendTo(EventLogId logId, params ResolvedEvent[] events)
+        {
+            _views[logId] = DisplayViewTestFactory.Build(logId, events);
+            State = Serving(WithTab(State, logId), logId);
+
+            PublishStateChange();
+        }
+
+        public void Apply(Func<LogTableState, LogTableState> change)
+        {
+            State = change(State);
+
+            PublishStateChange();
+        }
+
+        public void CloseEverything()
+        {
+            _views.Clear();
+            State = new LogTableState();
+
+            PublishStateChange();
+        }
+
+        public EventLogId OpenLog(params ResolvedEvent[] events)
+        {
+            var logId = EventLogId.Create();
+
+            _views[logId] = DisplayViewTestFactory.Build(logId, events);
+            State = Serving(WithTab(State with { ActiveEventLogId = logId }, logId), logId);
+
+            PublishStateChange();
+
+            return logId;
+        }
+
+        public void OpenLogNotYetServed(params ResolvedEvent[] events)
+        {
+            var logId = EventLogId.Create();
+
+            _views[logId] = DisplayViewTestFactory.Build(logId, events);
+            State = new LogTableState
+            {
+                ActiveEventLogId = logId,
+                EventTables = ImmutableList.Create(new LogView(logId) { LogName = LogName })
+            };
+
+            PublishStateChange();
+        }
+
+        public void OpenLogWithEvents(params ResolvedEvent[] events)
+        {
+            var logId = EventLogId.Create();
+
+            _views[logId] = DisplayViewTestFactory.Build(logId, events);
+            State = new LogTableState
+            {
+                ActiveEventLogId = logId,
+                EventTables = ImmutableList.Create(new LogView(logId) { LogName = LogName })
+            };
+
+            State = Serving(State, logId);
+
+            PublishStateChange();
+        }
+
+        public void RaiseUnchanged() => PublishStateChange();
+
+        public void SetCommittedOrdering(
+            ColumnName? orderBy,
+            bool isDescending,
+            ColumnName? groupBy,
+            bool isGroupDescending)
+        {
+            LogTableState moved = State with
+            {
+                OrderBy = orderBy,
+                IsDescending = isDescending,
+                GroupBy = groupBy,
+                IsGroupDescending = isGroupDescending,
+                CommittedEffectiveOrderBy = ResolvedEventOrdering.ResolveDefaultOrderBy(
+                    orderBy, groupBy, State.DisplayedLogCount, State.TimelineVisible)
+            };
+
+            foreach (var (logId, view) in _views.ToList())
+            {
+                if (!view.HasContext(moved.CommittedSortContext))
+                {
+                    _views[logId] = view.WithContext(moved.CommittedSortContext);
+                }
+            }
+
+            State = moved;
+
+            PublishStateChange();
+        }
+
+        public void SetDisplayEnabled(bool enabled)
+        {
+            State = enabled ?
+                State with { OrderedViewDisplayEnabled = true } :
+                Reducers.ReduceOrderedViewDisplayFaulted(
+                    State, new OrderedViewDisplayFaultedAction(new InvalidOperationException("display disabled")));
+
+            PublishStateChange();
+        }
+
+        public void SetFaultCause(string? cause)
+        {
+            State = Reducers.ReduceOrderedViewDisplayFaulted(
+                State, new OrderedViewDisplayFaultedAction(new InvalidOperationException("faulted")));
+
+            State = State with { FaultCause = cause };
+
+            PublishStateChange();
+        }
+
+        public void SetRequestedOrdering(
+            ColumnName? orderBy,
+            bool isDescending,
+            ColumnName? groupBy,
+            bool isGroupDescending)
+        {
+            State = State with
+            {
+                RequestedOrderBy = orderBy,
+                RequestedIsDescending = isDescending,
+                RequestedGroupBy = groupBy,
+                RequestedIsGroupDescending = isGroupDescending
+            };
+
+            PublishStateChange();
+        }
+
+        public void SwitchTo(EventLogId logId)
+        {
+            State = Serving(State with { ActiveEventLogId = logId }, logId);
+
+            PublishStateChange();
+        }
+
+        private static LogTableState WithTab(LogTableState state, EventLogId logId) =>
+            state.EventTables.Any(table => table.Id == logId) ?
+                state :
+                state with { EventTables = state.EventTables.Add(new LogView(logId) { LogName = LogName }) };
+
+        private void PublishStateChange() => _logTableState.StateChanged += Raise.Event<EventHandler>(_logTableState, EventArgs.Empty);
+
+        private LogTableState Serving(LogTableState state, EventLogId logId) =>
+            state with
+            {
+                ActiveOrderedView = new OrderedViewReady(
+                    SnapshotVersion: 1,
+                    Identity: state.ViewIdentity,
+                    Sequence: state.HighestInvalidationSequence,
+                    SingleLogId: logId,
+                    InScope: [new LogGeneration(logId, 0)],
+                    View: _views[logId],
+                    Config: state.SortContext,
+                    Filter: state.AppliedFilter)
+            };
+    }
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/RetainedViewPerTabTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/RetainedViewPerTabTests.cs
new file mode 100644
index 000000000..f84e48ae8
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/RetainedViewPerTabTests.cs
@@ -0,0 +1,146 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.Channels;
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Runtime.LogTable;
+using EventLogExpert.Runtime.LogTable.OrderedView;
+using EventLogExpert.Runtime.Tests.TestUtils;
+
+namespace EventLogExpert.Runtime.Tests.LogTable;
+
+public sealed class RetainedViewPerTabTests
+{
+    [Fact]
+    public void AServedViewWithNoActiveTab_IsNotRecorded_BecauseThereIsNoTabToComeBackTo()
+    {
+        var tabA = EventLogId.Create();
+        var tabB = EventLogId.Create();
+
+        LogTableState onA = TwoTabs(tabA, tabB, active: tabA);
+        var servedWithoutTab = ServedFor(onA) with { Identity = null };
+
+        Assert.Empty(onA.RetainOnly(servedWithoutTab));
+    }
+
+    [Fact]
+    public void AViewRetainedForOneTab_IsNeverServedToAnother()
+    {
+        var tabA = EventLogId.Create();
+        var tabB = EventLogId.Create();
+
+        LogTableState onA = TwoTabs(tabA, tabB, active: tabA);
+        LogTableState retainingA = onA with { RetainedOrderedViews = onA.RetainOnly(ServedFor(onA)) };
+
+        LogTableState onBWithOnlyAsView = retainingA with { ActiveEventLogId = tabB };
+
+        Assert.False(onBWithOnlyAsView.IsRetainedViewServable(tabB));
+    }
+
+    [Fact]
+    public void EachTabKeepsItsOwnLastServedView_SoReturningToOneStillHasSomethingToShow()
+    {
+        var tabA = EventLogId.Create();
+        var tabB = EventLogId.Create();
+
+        LogTableState onA = TwoTabs(tabA, tabB, active: tabA);
+        LogTableState retainingA = onA with { RetainedOrderedViews = onA.RetainOnly(ServedFor(onA)) };
+
+        Assert.True(retainingA.IsRetainedViewServable(tabA));
+
+        LogTableState onB = retainingA with { ActiveEventLogId = tabB };
+        LogTableState retainingBoth = onB with { RetainedOrderedViews = onB.RetainOnly(ServedFor(onB)) };
+
+        Assert.True(retainingBoth.IsRetainedViewServable(tabB), "the tab just served must be servable");
+
+        LogTableState backOnA = retainingBoth with { ActiveEventLogId = tabA };
+
+        Assert.True(
+            backOnA.IsRetainedViewServable(tabA),
+            "serving another tab must not evict the view this one was last showing");
+    }
+
+    [Fact]
+    public void EntriesForTabsThatAreGone_AreDroppedOnTheNextWrite_RatherThanAccumulating()
+    {
+        var tabA = EventLogId.Create();
+        var tabB = EventLogId.Create();
+
+        LogTableState onA = TwoTabs(tabA, tabB, active: tabA);
+        LogTableState retainingA = onA with { RetainedOrderedViews = onA.RetainOnly(ServedFor(onA)) };
+
+        Assert.True(retainingA.RetainedOrderedViews.ContainsKey(tabA));
+
+        LogTableState afterClose = retainingA with
+        {
+            ActiveEventLogId = tabB, EventTables = [new LogView(tabB) { LogName = "B" }]
+        };
+
+        LogTableState afterNextWrite = afterClose with
+        {
+            RetainedOrderedViews = afterClose.RetainOnly(ServedFor(afterClose))
+        };
+
+        Assert.False(afterNextWrite.RetainedOrderedViews.ContainsKey(tabA), "a closed tab's view must not be kept");
+        Assert.True(afterNextWrite.RetainedOrderedViews.ContainsKey(tabB));
+    }
+
+    [Fact]
+    public void OpeningAThirdLogWhileTheCombinedTabIsActive_RecordsWhatWasOnScreen()
+    {
+        var logA = EventLogId.Create();
+        var logB = EventLogId.Create();
+        var combinedTab = EventLogId.Create();
+
+        var state = new LogTableState
+        {
+            ActiveEventLogId = combinedTab,
+            CommittedEffectiveOrderBy = ColumnName.DateAndTime,
+            EventTables =
+            [
+                new LogView(combinedTab) { GroupId = LogTabGroupId.AllLogs },
+                new LogView(logA) { LogName = "A" },
+                new LogView(logB) { LogName = "B" }
+            ]
+        };
+
+        var served = new OrderedViewReady(
+            SnapshotVersion: 1,
+            Identity: state.ViewIdentity,
+            Sequence: state.HighestInvalidationSequence,
+            SingleLogId: null,
+            InScope: [new LogGeneration(logA, 0), new LogGeneration(logB, 0)],
+            View: LogTableState.EmptyView,
+            Config: state.CommittedSortContext,
+            Filter: state.AppliedFilter);
+
+        LogTableState serving = state with { ActiveOrderedView = served };
+
+        Assert.NotNull(serving.ServingOrderedView);
+
+        LogTableState afterOpen = Reducers.ReduceAddTable(
+            serving,
+            new AddTableAction(new EventLogData("C", LogPathType.Channel)));
+
+        Assert.Null(afterOpen.ServingOrderedView);
+        Assert.Same(served, afterOpen.RetainedFor(served));
+    }
+
+    private static OrderedViewReady ServedFor(LogTableState state) =>
+        new(
+            SnapshotVersion: 1,
+            Identity: state.ViewIdentity,
+            Sequence: state.HighestInvalidationSequence,
+            SingleLogId: state.ActiveEventLogId,
+            InScope: [new LogGeneration(state.ActiveEventLogId!.Value, 0)],
+            View: LogTableState.EmptyView,
+            Config: state.CommittedSortContext,
+            Filter: state.AppliedFilter);
+
+    private static LogTableState TwoTabs(EventLogId tabA, EventLogId tabB, EventLogId active) =>
+        new()
+        {
+            ActiveEventLogId = active,
+            EventTables = [new LogView(tabA) { LogName = "A" }, new LogView(tabB) { LogName = "B" }]
+        };
+}
diff --git a/src/EventLogExpert.Runtime/LogTable/CombinedColumnView.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/TestSupport/AosReferenceCombinedView.cs
similarity index 91%
rename from src/EventLogExpert.Runtime/LogTable/CombinedColumnView.cs
rename to tests/Unit/EventLogExpert.Runtime.Tests/LogTable/TestSupport/AosReferenceCombinedView.cs
index 91da77460..d05b07c50 100644
--- a/src/EventLogExpert.Runtime/LogTable/CombinedColumnView.cs
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/TestSupport/AosReferenceCombinedView.cs
@@ -4,43 +4,39 @@
 using EventLogExpert.Eventing.Common.EventLogs;
 using EventLogExpert.Eventing.Common.Events;
 using EventLogExpert.Filtering.Persistence;
+using EventLogExpert.Runtime.LogTable;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 
-namespace EventLogExpert.Runtime.LogTable;
+namespace EventLogExpert.Runtime.Tests.LogTable.TestSupport;
 
-/// <summary>
-///     The multi-log display facade: a K-way column-direct merge of several per-log <see cref="EventColumnView" />s
-///     into one globally sorted stream, comparing head-to-head off each row's own reader so no event objects are
-///     rehydrated to merge. Cross-log ties are impossible (each sub-view is a distinct log and OwningLog is the comparer's
-///     final tiebreak).
-/// </summary>
-internal sealed class CombinedColumnView : IEventColumnView
+internal sealed class AosReferenceCombinedView : IEventColumnView
 {
-    // Offset scratch is stack-allocated per positional read; cap K so a many-log combined view can't overflow the
-    // stack (heap fallback above the cap).
     private const int MaxStackOffsets = 256;
     private const int Stride = 64;
 
-    private readonly Dictionary<EventLogId, EventColumnView> _byLog;
+    private readonly Dictionary<EventLogId, AosReferenceView> _byLog;
     private readonly ResolvedEventOrdering.CrossComparison _compare;
     private readonly int _count;
     private readonly ConditionalWeakTable<byte[], CombinedHighlightWinners> _highlightWinnerHandles = [];
     private readonly Lock _indexGate = new();
-    private readonly EventColumnView[] _views;
+    private readonly SortContext _mergeContext;
+    private readonly AosReferenceView[] _views;
 
     private int[][]? _index;
 
-    internal CombinedColumnView(IReadOnlyList<EventColumnView> views, SortContext context)
+    internal AosReferenceCombinedView(IReadOnlyList<AosReferenceView> views, SortContext context)
     {
         ArgumentNullException.ThrowIfNull(views);
 
-        _compare = ResolvedEventOrdering.SelectCrossColumnComparer(
+        Comparison<ResolvedEvent> reference = AosReferenceOrdering.Reference(
             context.OrderBy, context.IsDescending, context.GroupBy, context.IsGroupDescending);
+        _compare = (readerA, a, readerB, b) => reference(readerA.GetDetailLean(a), readerB.GetDetailLean(b));
 
+        _mergeContext = context;
         _views = [.. views];
-        _byLog = new Dictionary<EventLogId, EventColumnView>(_views.Length);
+        _byLog = new Dictionary<EventLogId, AosReferenceView>(_views.Length);
 
         int total = 0;
 
@@ -59,7 +55,7 @@ internal CombinedColumnView(IReadOnlyList<EventColumnView> views, SortContext co
 
     public int Count => _count;
 
-    internal static CombinedColumnView Empty { get; } = new([], new SortContext(null, true, null, false));
+    internal static AosReferenceCombinedView Empty { get; } = new([], new SortContext(null, true, null, false));
 
     public void BucketTimeTicksByEventData(
         long minTicks,
@@ -425,6 +421,25 @@ public IEnumerable<ResolvedEvent> EnumerateDetail()
         }
     }
 
+    public IEnumerable<ResolvedEvent> EnumerateDetailLean()
+    {
+        var offsets = new int[_views.Length];
+
+        while (true)
+        {
+            int best = PickBest(offsets);
+
+            if (best < 0) { yield break; }
+
+            var view = _views[best];
+            var locator = view.LocatorAt(offsets[best]);
+
+            yield return view.GetDetailLean(locator);
+
+            offsets[best]++;
+        }
+    }
+
     public ResolvedEvent GetDetail(EventLocator locator) => Route(locator).GetDetail(locator);
 
     public ResolvedEvent GetDetailLean(EventLocator locator) => Route(locator).GetDetailLean(locator);
@@ -564,6 +579,20 @@ public bool TryGetTimeTicksRange(out long minTicks, out long maxTicks, Cancellat
         return any;
     }
 
+    internal bool HasContext(SortContext context)
+    {
+        if (_views.Length == 0) { return true; }
+
+        if (!_mergeContext.Equals(context)) { return false; }
+
+        foreach (var view in _views)
+        {
+            if (view.Count > 1 && !view.HasContext(context)) { return false; }
+        }
+
+        return true;
+    }
+
     private int[][] BuildIndex()
     {
         var checkpoints = new List<int[]>(_count / Stride);
@@ -599,8 +628,7 @@ private int[][] GetIndex()
         }
     }
 
-    // Rows of the sub-view that sort strictly before the target; cross-log compares never tie, so this count is exact.
-    private int LowerBound(EventColumnView view, IEventColumnReader targetReader, EventLocator target)
+    private int LowerBound(AosReferenceView view, IEventColumnReader targetReader, EventLocator target)
     {
         int low = 0;
         int high = view.Count;
@@ -645,7 +673,7 @@ private byte[][] ResolveChildHighlightWinners(byte[] handle) =>
             ? winners.ChildWinners
             : throw new InvalidOperationException("Combined highlight winners must be captured before tie bucketing.");
 
-    private EventColumnView Route(EventLocator locator) =>
+    private AosReferenceView Route(EventLocator locator) =>
         _byLog.TryGetValue(locator.LogId, out var view)
             ? view
             : throw new KeyNotFoundException($"Locator log id '{locator.LogId}' is not a member of this combined view.");
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/TestSupport/AosReferenceOrdering.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/TestSupport/AosReferenceOrdering.cs
index cba6a9332..07296e734 100644
--- a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/TestSupport/AosReferenceOrdering.cs
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/TestSupport/AosReferenceOrdering.cs
@@ -6,40 +6,33 @@
 
 namespace EventLogExpert.Runtime.Tests.LogTable.TestSupport;
 
-/// <summary>
-///     Test-only reference oracle relocated verbatim from the deleted production array-of-structs ordering (
-///     <c>ResolvedEventOrdering.SelectComparer</c> / <c>GetComparer</c> / <c>GetGroupedComparer</c> / <c>CompareColumn</c>
-///     / <c>WithTieBreaker</c> / <c>FallbackTieBreaker</c>). The live columnar sort (<c>SortColumnDirect</c> /
-///     <c>SelectCrossColumnComparer</c>) is validated against this reference; the two are structurally distinct
-///     implementations, so the differential/parity assertions stay non-vacuous.
-/// </summary>
 internal static class AosReferenceOrdering
 {
     private static readonly Comparison<ResolvedEvent> s_ascByLevel =
-        (a, b) => WithTieBreaker(string.Compare(a.Level, b.Level, StringComparison.Ordinal), a, b);
+        (a, b) => WithTieBreaker(CompareText(a.Level, b.Level), a, b);
     private static readonly Comparison<ResolvedEvent> s_ascByDateAndTime =
         (a, b) => WithTieBreaker(a.TimeCreated.CompareTo(b.TimeCreated), a, b);
     private static readonly Comparison<ResolvedEvent> s_ascByActivityId =
         (a, b) => WithTieBreaker(Nullable.Compare(a.ActivityId, b.ActivityId), a, b);
     private static readonly Comparison<ResolvedEvent> s_ascByLog =
-        (a, b) => WithTieBreaker(string.Compare(a.LogName, b.LogName, StringComparison.Ordinal), a, b);
+        (a, b) => WithTieBreaker(CompareText(a.LogName, b.LogName), a, b);
     private static readonly Comparison<ResolvedEvent> s_ascByComputerName =
-        (a, b) => WithTieBreaker(string.Compare(a.ComputerName, b.ComputerName, StringComparison.Ordinal), a, b);
+        (a, b) => WithTieBreaker(CompareText(a.ComputerName, b.ComputerName), a, b);
 
     private static readonly Comparison<ResolvedEvent> s_ascBySource =
-        (a, b) => WithTieBreaker(string.Compare(a.Source, b.Source, StringComparison.Ordinal), a, b);
+        (a, b) => WithTieBreaker(CompareText(a.Source, b.Source), a, b);
     private static readonly Comparison<ResolvedEvent> s_ascByEventId =
         (a, b) => WithTieBreaker(a.Id.CompareTo(b.Id), a, b);
     private static readonly Comparison<ResolvedEvent> s_ascByTaskCategory =
-        (a, b) => WithTieBreaker(string.Compare(a.TaskCategory, b.TaskCategory, StringComparison.Ordinal), a, b);
+        (a, b) => WithTieBreaker(CompareText(a.TaskCategory, b.TaskCategory), a, b);
     private static readonly Comparison<ResolvedEvent> s_ascByKeywords =
-        (a, b) => WithTieBreaker(string.Compare(a.KeywordsDisplayName, b.KeywordsDisplayName, StringComparison.Ordinal), a, b);
+        (a, b) => WithTieBreaker(CompareText(a.KeywordsDisplayName, b.KeywordsDisplayName), a, b);
     private static readonly Comparison<ResolvedEvent> s_ascByProcessId =
         (a, b) => WithTieBreaker(Nullable.Compare(a.ProcessId, b.ProcessId), a, b);
     private static readonly Comparison<ResolvedEvent> s_ascByThreadId =
         (a, b) => WithTieBreaker(Nullable.Compare(a.ThreadId, b.ThreadId), a, b);
     private static readonly Comparison<ResolvedEvent> s_ascByUser =
-        (a, b) => WithTieBreaker(string.Compare(a.UserId?.Value, b.UserId?.Value, StringComparison.Ordinal), a, b);
+        (a, b) => WithTieBreaker(CompareText(a.UserId?.Value, b.UserId?.Value), a, b);
     private static readonly Comparison<ResolvedEvent> s_ascByRecordId =
         (a, b) => WithTieBreaker(Nullable.Compare(a.RecordId, b.RecordId), a, b);
     private static readonly Comparison<ResolvedEvent> s_ascByDefault =
@@ -49,10 +42,9 @@ internal static class AosReferenceOrdering
 
             if (byRecordId != 0) { return byRecordId; }
 
-            // Fall back to timestamp then OwningLog for a total order.
             int byTime = a.TimeCreated.CompareTo(b.TimeCreated);
 
-            return byTime != 0 ? byTime : string.Compare(a.OwningLog, b.OwningLog, StringComparison.Ordinal);
+            return byTime != 0 ? byTime : CompareText(a.OwningLog, b.OwningLog);
         };
 
     private static readonly Comparison<ResolvedEvent> s_descByActivityId = (a, b) => s_ascByActivityId(b, a);
@@ -70,11 +62,6 @@ internal static class AosReferenceOrdering
     private static readonly Comparison<ResolvedEvent> s_descByThreadId = (a, b) => s_ascByThreadId(b, a);
     private static readonly Comparison<ResolvedEvent> s_descByUser = (a, b) => s_ascByUser(b, a);
 
-    /// <summary>
-    ///     Sorts the physical indices <c>0..source.Count-1</c> by <see cref="Reference" /> with a final ascending
-    ///     physical-index tie-break, reproducing the strict total order the live <c>SortColumnDirect</c> produces. Returns a
-    ///     permutation (indices), never sorted events, so value-identical rows stay distinguishable by position.
-    /// </summary>
     internal static int[] Order(
         IReadOnlyList<ResolvedEvent> source,
         ColumnName? orderBy = null,
@@ -99,12 +86,6 @@ internal static int[] Order(
         return order;
     }
 
-    /// <summary>
-    ///     Convenience over <see cref="Order" /> that maps the permutation back to events. Deterministic because it
-    ///     delegates to <see cref="Order" /> (whose final physical-index tie-break is a strict total order), so it is safe
-    ///     only for suites that assert field values against a totally ordered corpus, never permutations of value-identical
-    ///     rows.
-    /// </summary>
     internal static IReadOnlyList<ResolvedEvent> OrderedEvents(
         IEnumerable<ResolvedEvent> source,
         ColumnName? orderBy = null,
@@ -123,10 +104,6 @@ internal static IReadOnlyList<ResolvedEvent> OrderedEvents(
         return ordered;
     }
 
-    /// <summary>
-    ///     The relocated array-of-structs comparer (formerly <c>ResolvedEventOrdering.SelectComparer</c>): ungrouped uses
-    ///     the per-column chain, grouped keeps groups contiguous then orders within group.
-    /// </summary>
     internal static Comparison<ResolvedEvent> Reference(
         ColumnName? orderBy,
         bool isDescending,
@@ -140,24 +117,26 @@ private static int CompareColumn(ResolvedEvent a, ResolvedEvent b, ColumnName co
         column switch
         {
             ColumnName.RecordId => Nullable.Compare(a.RecordId, b.RecordId),
-            ColumnName.Level => string.Compare(a.Level ?? string.Empty, b.Level ?? string.Empty, StringComparison.Ordinal),
+            ColumnName.Level => CompareText(a.Level, b.Level),
             ColumnName.DateAndTime => a.TimeCreated.CompareTo(b.TimeCreated),
             ColumnName.ActivityId => Nullable.Compare(a.ActivityId, b.ActivityId),
-            ColumnName.Log => string.Compare(a.LogName ?? string.Empty, b.LogName ?? string.Empty, StringComparison.Ordinal),
-            ColumnName.ComputerName => string.Compare(a.ComputerName ?? string.Empty, b.ComputerName ?? string.Empty, StringComparison.Ordinal),
-            ColumnName.Source => string.Compare(a.Source ?? string.Empty, b.Source ?? string.Empty, StringComparison.Ordinal),
+            ColumnName.Log => CompareText(a.LogName, b.LogName),
+            ColumnName.ComputerName => CompareText(a.ComputerName, b.ComputerName),
+            ColumnName.Source => CompareText(a.Source, b.Source),
             ColumnName.EventId => a.Id.CompareTo(b.Id),
-            ColumnName.TaskCategory => string.Compare(a.TaskCategory ?? string.Empty, b.TaskCategory ?? string.Empty, StringComparison.Ordinal),
-            ColumnName.Keywords => string.Compare(a.KeywordsDisplayName ?? string.Empty, b.KeywordsDisplayName ?? string.Empty, StringComparison.Ordinal),
+            ColumnName.TaskCategory => CompareText(a.TaskCategory, b.TaskCategory),
+            ColumnName.Keywords => CompareText(a.KeywordsDisplayName, b.KeywordsDisplayName),
             ColumnName.ProcessId => Nullable.Compare(a.ProcessId, b.ProcessId),
             ColumnName.ThreadId => Nullable.Compare(a.ThreadId, b.ThreadId),
-            ColumnName.User => string.Compare(a.UserId?.Value ?? string.Empty, b.UserId?.Value ?? string.Empty, StringComparison.Ordinal),
+            ColumnName.User => CompareText(a.UserId?.Value, b.UserId?.Value),
             _ => 0
         };
 
-    // Falls back to RecordId, then OwningLog (for combined logs) to guarantee a total order for List.Sort stability.
+    private static int CompareText(string? a, string? b) =>
+        string.Compare(a ?? string.Empty, b ?? string.Empty, StringComparison.Ordinal);
+
     private static int FallbackTieBreaker(int recordIdResult, ResolvedEvent a, ResolvedEvent b) =>
-        recordIdResult != 0 ? recordIdResult : string.Compare(a.OwningLog, b.OwningLog, StringComparison.Ordinal);
+        recordIdResult != 0 ? recordIdResult : CompareText(a.OwningLog, b.OwningLog);
 
     private static Comparison<ResolvedEvent> GetComparer(ColumnName? orderBy, bool isDescending) =>
         isDescending
diff --git a/src/EventLogExpert.Runtime/LogTable/EventColumnView.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/TestSupport/AosReferenceView.cs
similarity index 88%
rename from src/EventLogExpert.Runtime/LogTable/EventColumnView.cs
rename to tests/Unit/EventLogExpert.Runtime.Tests/LogTable/TestSupport/AosReferenceView.cs
index 8dd806918..ff314943f 100644
--- a/src/EventLogExpert.Runtime/LogTable/EventColumnView.cs
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/TestSupport/AosReferenceView.cs
@@ -4,11 +4,12 @@
 using EventLogExpert.Eventing.Common.Events;
 using EventLogExpert.Filtering.Compilation;
 using EventLogExpert.Filtering.Persistence;
+using EventLogExpert.Runtime.LogTable;
 using System.Diagnostics.CodeAnalysis;
 
-namespace EventLogExpert.Runtime.LogTable;
+namespace EventLogExpert.Runtime.Tests.LogTable.TestSupport;
 
-internal sealed class EventColumnView : IEventColumnView
+internal sealed class AosReferenceView : IEventColumnView
 {
     private readonly SortContext _context;
     private readonly int[] _order;
@@ -18,7 +19,7 @@ internal sealed class EventColumnView : IEventColumnView
     private Dictionary<ValueKey, int>? _byKey;
     private HighlightWinnerCache? _highlightCache;
 
-    private EventColumnView(IEventColumnReader reader, int[] order, int[] rankByPhysical, SortContext context)
+    private AosReferenceView(IEventColumnReader reader, int[] order, int[] rankByPhysical, SortContext context)
     {
         _reader = reader;
         _order = order;
@@ -32,8 +33,6 @@ private EventColumnView(IEventColumnReader reader, int[] order, int[] rankByPhys
 
     internal IEventColumnReader Reader => _reader;
 
-    // The filter-surviving physical rows, used by WithContext to re-sort in place; the survivor set is order-independent,
-    // so the current display order is a valid re-sort input.
     internal ReadOnlySpan<int> Survivors => _order;
 
     public void BucketTimeTicksByEventData(
@@ -327,6 +326,14 @@ public IEnumerable<ResolvedEvent> EnumerateDetail()
         }
     }
 
+    public IEnumerable<ResolvedEvent> EnumerateDetailLean()
+    {
+        foreach (int physical in _order)
+        {
+            yield return _reader.GetDetailLean(_reader.LocatorAt(physical));
+        }
+    }
+
     public ResolvedEvent GetDetail(EventLocator locator) => _reader.GetDetail(locator);
 
     public ResolvedEvent GetDetailLean(EventLocator locator) => _reader.GetDetailLean(locator);
@@ -352,7 +359,6 @@ public int Rank(EventLocator locator) =>
         {
             byKey = BuildByKey();
 
-            // First writer wins; a racing reader either sees null (and builds its own discarded copy) or a complete map.
             byKey = Interlocked.CompareExchange(ref _byKey, byKey, null) ?? byKey;
         }
 
@@ -411,11 +417,7 @@ public bool TryGetTimeTicks(EventLocator locator, out long ticks)
     public bool TryGetTimeTicksRange(out long minTicks, out long maxTicks, CancellationToken cancellationToken) =>
         _reader.TryGetTimeTicksRange(_rankByPhysical, out minTicks, out maxTicks, cancellationToken);
 
-    /// <summary>
-    ///     Builds a view over the filter-surviving <paramref name="survivors" />, sorted into display order, with the
-    ///     physical-to-display inverse used by <see cref="Rank" />.
-    /// </summary>
-    internal static EventColumnView Create(
+    internal static AosReferenceView Create(
         IEventColumnReader reader,
         ReadOnlySpan<int> survivors,
         ColumnName? orderBy,
@@ -424,16 +426,25 @@ internal static EventColumnView Create(
         bool isGroupDescending) =>
         Create(reader, survivors, new SortContext(orderBy, isDescending, groupBy, isGroupDescending));
 
-    /// <summary>
-    ///     Live-path overload: sorts under <paramref name="context" /> and retains it so the reducers can detect (
-    ///     <see cref="HasContext" />) and repair (<see cref="WithContext" />) a stale sort without re-reading the raw store.
-    /// </summary>
-    internal static EventColumnView Create(IEventColumnReader reader, ReadOnlySpan<int> survivors, SortContext context)
+    internal static AosReferenceView Create(IEventColumnReader reader, ReadOnlySpan<int> survivors, SortContext context)
     {
         ArgumentNullException.ThrowIfNull(reader);
 
-        int[] order = ResolvedEventOrdering.SortColumnDirect(
-            reader, survivors, context.OrderBy, context.IsDescending, context.GroupBy, context.IsGroupDescending);
+        int[] survivorList = survivors.ToArray();
+        Array.Sort(survivorList);
+
+        var events = new ResolvedEvent[survivorList.Length];
+
+        for (int i = 0; i < survivorList.Length; i++)
+        {
+            events[i] = reader.GetDetailLean(reader.LocatorAt(survivorList[i]));
+        }
+
+        int[] permutation = AosReferenceOrdering.Order(
+            events, context.OrderBy, context.IsDescending, context.GroupBy, context.IsGroupDescending);
+        int[] order = new int[permutation.Length];
+
+        for (int i = 0; i < permutation.Length; i++) { order[i] = survivorList[permutation[i]]; }
 
         int[] rankByPhysical = new int[reader.Count];
         Array.Fill(rankByPhysical, -1);
@@ -443,16 +454,14 @@ internal static EventColumnView Create(IEventColumnReader reader, ReadOnlySpan<i
             rankByPhysical[order[display]] = display;
         }
 
-        return new EventColumnView(reader, order, rankByPhysical, context);
+        return new AosReferenceView(reader, order, rankByPhysical, context);
     }
 
     internal bool HasContext(SortContext context) => _context.Equals(context);
 
-    // Re-sorts the same survivor set under a new context without re-reading the raw store (the reducers use this when the
-    // effective default order flips between single- and multi-log).
-    internal EventColumnView WithContext(SortContext context)
+    internal AosReferenceView WithContext(SortContext context)
     {
-        EventColumnView view = Create(_reader, _order, context);
+        AosReferenceView view = Create(_reader, _order, context);
         view._highlightCache = _highlightCache;
 
         return view;
@@ -464,7 +473,6 @@ private Dictionary<ValueKey, int> BuildByKey()
 
         foreach (int physical in _order)
         {
-            // First survivor wins on a duplicate key; null-RecordId rows never produce a key, so they stay unresolvable.
             if (ValueKey.TryCreate(_reader.GetDetailLean(_reader.LocatorAt(physical)), out ValueKey key))
             {
                 map.TryAdd(key, physical);
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/TestSupport/ColumnReaderTestFactory.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/TestSupport/ColumnReaderTestFactory.cs
new file mode 100644
index 000000000..1f3606502
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/TestSupport/ColumnReaderTestFactory.cs
@@ -0,0 +1,13 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
+
+namespace EventLogExpert.Runtime.Tests.LogTable.TestSupport;
+
+internal static class ColumnReaderTestFactory
+{
+    internal static IEventColumnReader ReaderOver(IReadOnlyList<ResolvedEvent> sample) =>
+        EventColumnStore.Build([.. sample], generation: 1, contentVersion: 1).CreateReader(EventLogId.Create());
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/TestSupport/DisplayIndicatorTestFactory.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/TestSupport/DisplayIndicatorTestFactory.cs
new file mode 100644
index 000000000..da3c84c08
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/TestSupport/DisplayIndicatorTestFactory.cs
@@ -0,0 +1,54 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.Channels;
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
+using EventLogExpert.Runtime.LogTable;
+using EventLogExpert.Runtime.Tests.TestUtils;
+
+namespace EventLogExpert.Runtime.Tests.LogTable.TestSupport;
+
+internal static class DisplayIndicatorTestFactory
+{
+    internal static ResolvedEvent Event(int recordId) =>
+        new("TestLog", LogPathType.Channel)
+        {
+            RecordId = recordId,
+            TimeCreated = new DateTime(2026, 1, 1, 0, 0, 0, DateTimeKind.Utc).AddMilliseconds(recordId),
+            Id = 1000,
+            Level = "Information",
+            Source = "Alpha",
+            LogName = "TestLog"
+        };
+
+    internal static OrderedViewPresentation PresentationFor(DisplayIndicatorKind kind, long revision)
+    {
+        var logId = EventLogId.Create();
+
+        (PresentationState state, int rows, bool stale) = kind switch
+        {
+            DisplayIndicatorKind.None => (PresentationState.Current, 1, false),
+            DisplayIndicatorKind.EmptyPending => (PresentationState.Updating, 0, false),
+            DisplayIndicatorKind.ReorderPending => (PresentationState.Updating, 1, true),
+            _ => (PresentationState.Faulted, 1, false)
+        };
+
+        IEventColumnView view = rows == 0 ?
+            LogTableState.EmptyView :
+            DisplayViewTestFactory.Build(logId, [Event(1)]);
+
+        var presentation = new OrderedViewPresentation(
+            view,
+            logId,
+            default,
+            state,
+            revision,
+            FaultCause: state == PresentationState.Faulted ? "InvalidOperationException: bad predicate" : null,
+            OrderingIsStale: stale);
+
+        Assert.Equal(kind, presentation.IndicatorKind);
+
+        return presentation;
+    }
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/TestSupport/DivergenceReport.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/TestSupport/DivergenceReport.cs
new file mode 100644
index 000000000..27908256a
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/TestSupport/DivergenceReport.cs
@@ -0,0 +1,12 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+namespace EventLogExpert.Runtime.Tests.LogTable.TestSupport;
+
+internal static class DivergenceReport
+{
+    private const int MaxReported = 25;
+
+    internal static string Describe(IReadOnlyList<string> failures) =>
+        $"{failures.Count} divergence(s):{Environment.NewLine}{string.Join(Environment.NewLine, failures.Take(MaxReported))}";
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/TestSupport/LegacyEventColumnView.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/TestSupport/LegacyEventColumnView.cs
deleted file mode 100644
index 92037c3ad..000000000
--- a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/TestSupport/LegacyEventColumnView.cs
+++ /dev/null
@@ -1,201 +0,0 @@
-// // Copyright (c) Microsoft Corporation.
-// // Licensed under the MIT License.
-
-using EventLogExpert.Eventing.Common.EventLogs;
-using EventLogExpert.Eventing.Common.Events;
-using EventLogExpert.Filtering.Compilation;
-using EventLogExpert.Filtering.Persistence;
-using EventLogExpert.Runtime.LogTable;
-using System.Diagnostics.CodeAnalysis;
-
-namespace EventLogExpert.Runtime.Tests.LogTable.TestSupport;
-
-internal sealed class LegacyEventColumnView(
-    EventLogId logId,
-    int generation,
-    long contentVersion,
-    IReadOnlyList<ResolvedEvent> events) : IEventColumnView
-{
-    private readonly LegacyEventColumnReader _reader =
-        new LegacyEventColumnReader(logId, generation, contentVersion, events);
-    private byte[]? _highlightWinners;
-    private int _highlightWinnersPlanKey;
-
-    public int Count => _reader.Count;
-
-    public IEventColumnReader Reader => _reader;
-
-    public void BucketTimeTicksByEventData(long minTicks, long bucketSpanTicks, int bucketCount, string fieldName, long[] targetCodes, int[] slotCounts, CancellationToken cancellationToken) =>
-        _reader.BucketTimeTicksByEventData(AllSurvive(), minTicks, bucketSpanTicks, bucketCount, fieldName, targetCodes, slotCounts, cancellationToken);
-
-    public void BucketTimeTicksByEventDataHResult(long minTicks, long bucketSpanTicks, int bucketCount, string fieldName, IReadOnlyCollection<string> eligibleProviders, IReadOnlyList<string> userDataErrorCodePaths, long[] targetCodes, int[] slotCounts, CancellationToken cancellationToken) =>
-        _reader.BucketTimeTicksByEventDataHResult(AllSurvive(), minTicks, bucketSpanTicks, bucketCount, fieldName, eligibleProviders, userDataErrorCodePaths, targetCodes, slotCounts, cancellationToken);
-
-    public void BucketTimeTicksByEventDataHResultWithTie(byte[] highlightWinners, uint[] slotColorMask, long minTicks, long bucketSpanTicks, int bucketCount, string fieldName, IReadOnlyCollection<string> eligibleProviders, IReadOnlyList<string> userDataErrorCodePaths, long[] targetCodes, int[] slotCounts, CancellationToken cancellationToken) =>
-        _reader.BucketTimeTicksByEventDataHResultWithTie(AllSurvive(), highlightWinners, slotColorMask, minTicks, bucketSpanTicks, bucketCount, fieldName, eligibleProviders, userDataErrorCodePaths, targetCodes, slotCounts, cancellationToken);
-
-    public void BucketTimeTicksByEventDataString(long minTicks, long bucketSpanTicks, int bucketCount, string[] candidateFields, IReadOnlyDictionary<string, int> rawValueToSlot, int slotCount, int[] slotCounts, CancellationToken cancellationToken) =>
-        _reader.BucketTimeTicksByEventDataString(AllSurvive(), minTicks, bucketSpanTicks, bucketCount, candidateFields, rawValueToSlot, slotCount, slotCounts, cancellationToken);
-
-    public void BucketTimeTicksByEventDataStringWithTie(byte[] highlightWinners, uint[] slotColorMask, long minTicks, long bucketSpanTicks, int bucketCount, string[] candidateFields, IReadOnlyDictionary<string, int> rawValueToSlot, int slotCount, int[] slotCounts, CancellationToken cancellationToken) =>
-        _reader.BucketTimeTicksByEventDataStringWithTie(AllSurvive(), highlightWinners, slotColorMask, minTicks, bucketSpanTicks, bucketCount, candidateFields, rawValueToSlot, slotCount, slotCounts, cancellationToken);
-
-    public void BucketTimeTicksByEventDataWithTie(byte[] highlightWinners, uint[] slotColorMask, long minTicks, long bucketSpanTicks, int bucketCount, string fieldName, long[] targetCodes, int[] slotCounts, CancellationToken cancellationToken) =>
-        _reader.BucketTimeTicksByEventDataWithTie(AllSurvive(), highlightWinners, slotColorMask, minTicks, bucketSpanTicks, bucketCount, fieldName, targetCodes, slotCounts, cancellationToken);
-
-    public void BucketTimeTicksByEventId(long minTicks, long bucketSpanTicks, int bucketCount, int[] targetIds, int[] slotCounts, CancellationToken cancellationToken) =>
-        _reader.BucketTimeTicksByEventId(AllSurvive(), minTicks, bucketSpanTicks, bucketCount, targetIds, slotCounts, cancellationToken);
-
-    public void BucketTimeTicksByEventIdWithTie(byte[] highlightWinners, uint[] slotColorMask, long minTicks, long bucketSpanTicks, int bucketCount, int[] targetIds, int[] slotCounts, CancellationToken cancellationToken) =>
-        _reader.BucketTimeTicksByEventIdWithTie(AllSurvive(), highlightWinners, slotColorMask, minTicks, bucketSpanTicks, bucketCount, targetIds, slotCounts, cancellationToken);
-
-    public void BucketTimeTicksByField(long minTicks, long bucketSpanTicks, int bucketCount, EventFieldId field, string[] targetValues, int[] slotCounts, CancellationToken cancellationToken) =>
-        _reader.BucketTimeTicksByField(AllSurvive(), minTicks, bucketSpanTicks, bucketCount, field, targetValues, slotCounts, cancellationToken);
-
-    public void BucketTimeTicksByFieldWithTie(byte[] highlightWinners, uint[] slotColorMask, long minTicks, long bucketSpanTicks, int bucketCount, EventFieldId field, string[] targetValues, int[] slotCounts, CancellationToken cancellationToken) =>
-        _reader.BucketTimeTicksByFieldWithTie(AllSurvive(), highlightWinners, slotColorMask, minTicks, bucketSpanTicks, bucketCount, field, targetValues, slotCounts, cancellationToken);
-
-    public void BucketTimeTicksBySeverity(long minTicks, long bucketSpanTicks, int bucketCount, int[] slotCounts, CancellationToken cancellationToken) =>
-        _reader.BucketTimeTicksBySeverity(AllSurvive(), minTicks, bucketSpanTicks, bucketCount, slotCounts, cancellationToken);
-
-    public void BucketTimeTicksBySeverityWithTie(byte[] highlightWinners, uint[] slotColorMask, long minTicks, long bucketSpanTicks, int bucketCount, int[] slotCounts, CancellationToken cancellationToken) =>
-        _reader.BucketTimeTicksBySeverityWithTie(AllSurvive(), highlightWinners, slotColorMask, minTicks, bucketSpanTicks, bucketCount, slotCounts, cancellationToken);
-
-    public void CountEventDataHResults(string fieldName, IReadOnlyCollection<string> eligibleProviders, IReadOnlyList<string> userDataErrorCodePaths, IDictionary<long, int> counts, CancellationToken cancellationToken) =>
-        _reader.CountEventDataHResults(AllSurvive(), fieldName, eligibleProviders, userDataErrorCodePaths, counts, cancellationToken);
-
-    public void CountEventDataStringValues(string[] candidateFields, IDictionary<string, int> counts, CancellationToken cancellationToken) =>
-        _reader.CountEventDataStringValues(AllSurvive(), candidateFields, counts, cancellationToken);
-
-    public void CountEventDataValues(string fieldName, IDictionary<long, int> counts, CancellationToken cancellationToken) =>
-        _reader.CountEventDataValues(AllSurvive(), fieldName, counts, cancellationToken);
-
-    public void CountEventIds(IDictionary<int, int> counts, CancellationToken cancellationToken) =>
-        _reader.CountEventIds(AllSurvive(), counts, cancellationToken);
-
-    public void CountFieldValues(EventFieldId field, IDictionary<string, int> counts, CancellationToken cancellationToken) =>
-        _reader.CountFieldValues(AllSurvive(), field, counts, cancellationToken);
-
-    public byte[] EnsureHighlightWinners(IReadOnlyList<SavedFilter> orderedColoredFilters, int planKey, CancellationToken cancellationToken)
-    {
-        if (_highlightWinnersPlanKey == planKey && _highlightWinners is { Length: var length } && length == _reader.Count)
-        {
-            return _highlightWinners;
-        }
-
-        _highlightWinners = FilterService.ClassifyHighlightWinners(_reader, AllSurvive(), orderedColoredFilters, cancellationToken);
-        _highlightWinnersPlanKey = planKey;
-
-        return _highlightWinners;
-    }
-
-    public IEnumerable<ResolvedEvent> EnumerateDetail()
-    {
-        for (int physical = 0; physical < _reader.Count; physical++)
-        {
-            yield return _reader.GetEvent(_reader.LocatorAt(physical));
-        }
-    }
-
-    public ResolvedEvent GetDetail(EventLocator locator) => _reader.GetEvent(locator);
-
-    public ResolvedEvent GetDetailLean(EventLocator locator) => _reader.GetDetailLean(locator);
-
-    public string GroupKeyAt(EventLocator locator, ColumnName column) =>
-        ResolvedEventGroupKey.For(_reader, locator, column);
-
-    public EventLocator LocatorAt(int index) => _reader.LocatorAt(index);
-
-    public int Rank(EventLocator locator) =>
-        locator.LogId == _reader.LogId
-        && locator.Generation == _reader.Generation
-        && locator.Index >= 0
-        && locator.Index < _reader.Count
-            ? locator.Index
-            : -1;
-
-    public EventLocator? ResolveByKey(ValueKey key)
-    {
-        for (int physical = 0; physical < _reader.Count; physical++)
-        {
-            var locator = _reader.LocatorAt(physical);
-
-            // First match wins; null-RecordId rows never produce a key, so they stay unresolvable, mirroring
-            // EventColumnView.ResolveByKey so differential parity holds.
-            if (ValueKey.TryCreate(_reader.GetDetailLean(locator), out ValueKey candidate) && candidate == key)
-            {
-                return locator;
-            }
-        }
-
-        return null;
-    }
-
-    public IReadOnlyList<DisplayRow> Slice(int start, int count)
-    {
-        if (start < 0) { throw new ArgumentOutOfRangeException(nameof(start)); }
-
-        if (count < 0) { throw new ArgumentOutOfRangeException(nameof(count)); }
-
-        IReadOnlyList<ResolvedEvent> events = _reader.Events;
-        int end = (int)Math.Min((long)start + count, events.Count);
-
-        if (start >= end) { return []; }
-
-        DisplayRow[] rows = new DisplayRow[end - start];
-
-        for (int offset = 0; offset < rows.Length; offset++)
-        {
-            int physical = start + offset;
-            rows[offset] = new DisplayRow(_reader.LocatorAt(physical), events[physical]);
-        }
-
-        return rows;
-    }
-
-    public bool TryGetDetail(EventLocator locator, [NotNullWhen(true)] out ResolvedEvent? detail)
-    {
-        if (locator.LogId == _reader.LogId
-            && locator.Generation == _reader.Generation
-            && locator.Index >= 0
-            && locator.Index < _reader.Count)
-        {
-            detail = _reader.GetEvent(locator);
-
-            return true;
-        }
-
-        detail = null;
-
-        return false;
-    }
-
-    public bool TryGetTimeTicks(EventLocator locator, out long ticks)
-    {
-        if (locator.LogId == _reader.LogId
-            && locator.Generation == _reader.Generation
-            && locator.Index >= 0
-            && locator.Index < _reader.Count)
-        {
-            ticks = _reader.GetEvent(locator).TimeCreated.Ticks;
-
-            return true;
-        }
-
-        ticks = 0;
-
-        return false;
-    }
-
-    public bool TryGetTimeTicksRange(out long minTicks, out long maxTicks, CancellationToken cancellationToken) =>
-        _reader.TryGetTimeTicksRange(AllSurvive(), out minTicks, out maxTicks, cancellationToken);
-
-    private int[] AllSurvive()
-    {
-        int[] ranks = new int[_reader.Count];
-
-        for (int index = 0; index < ranks.Length; index++) { ranks[index] = index; }
-
-        return ranks;
-    }
-}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/TestSupport/OrderedViewTestTimeouts.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/TestSupport/OrderedViewTestTimeouts.cs
new file mode 100644
index 000000000..82f2d290e
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/TestSupport/OrderedViewTestTimeouts.cs
@@ -0,0 +1,9 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+namespace EventLogExpert.Runtime.Tests.LogTable.TestSupport;
+
+internal static class OrderedViewTestTimeouts
+{
+    internal static readonly TimeSpan Default = TimeSpan.FromSeconds(30);
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/TestSupport/SortConfigMatrix.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/TestSupport/SortConfigMatrix.cs
new file mode 100644
index 000000000..3a693b5c8
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/TestSupport/SortConfigMatrix.cs
@@ -0,0 +1,53 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Runtime.LogTable;
+
+namespace EventLogExpert.Runtime.Tests.LogTable.TestSupport;
+
+internal readonly record struct SortConfig(ColumnName? OrderBy, bool IsDescending, ColumnName? GroupBy, bool IsGroupDescending);
+
+internal static class SortConfigMatrix
+{
+    private static readonly ColumnName[] s_allColumns = Enum.GetValues<ColumnName>();
+    private static readonly bool[] s_bools = [false, true];
+
+    internal static IReadOnlyList<SortConfig> All()
+    {
+        var configs = new List<SortConfig>();
+
+        foreach (ColumnName? orderBy in OrderByOptions())
+        {
+            foreach (bool isDescending in s_bools)
+            {
+                configs.Add(new SortConfig(orderBy, isDescending, null, false));
+            }
+        }
+
+        foreach (ColumnName groupBy in s_allColumns)
+        {
+            foreach (bool isGroupDescending in s_bools)
+            {
+                foreach (ColumnName? orderBy in OrderByOptions())
+                {
+                    foreach (bool isDescending in s_bools)
+                    {
+                        configs.Add(new SortConfig(orderBy, isDescending, groupBy, isGroupDescending));
+                    }
+                }
+            }
+        }
+
+        return configs;
+    }
+
+    private static IEnumerable<ColumnName?> OrderByOptions()
+    {
+        yield return null;
+
+        foreach (ColumnName column in s_allColumns)
+        {
+            yield return column;
+        }
+    }
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/TimelineDefaultSortTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/TimelineDefaultSortTests.cs
index 729adafce..69caac131 100644
--- a/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/TimelineDefaultSortTests.cs
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/LogTable/TimelineDefaultSortTests.cs
@@ -6,6 +6,9 @@
 using EventLogExpert.Eventing.Common.Events;
 using EventLogExpert.Runtime.Histogram;
 using EventLogExpert.Runtime.LogTable;
+using EventLogExpert.Runtime.LogTable.OrderedView;
+using EventLogExpert.Runtime.Tests.LogTable.TestSupport;
+using EventLogExpert.Runtime.Tests.TestUtils;
 using Reducers = EventLogExpert.Runtime.LogTable.Reducers;
 
 namespace EventLogExpert.Runtime.Tests.LogTable;
@@ -14,10 +17,103 @@ public sealed class TimelineDefaultSortTests
 {
     private static readonly DateTime s_baseTime = new(2024, 1, 1, 0, 0, 0, DateTimeKind.Utc);
 
+    [Fact]
+    public void ACombinedViewWhoseMembersDisagree_ReportsTheOrderingStale()
+    {
+        var settled = new SortContext(ColumnName.DateAndTime, true, null, false);
+        var stale = new SortContext(ColumnName.EventId, true, null, false);
+
+        var fresh = ViewOver(settled);
+        var behind = ViewOver(stale);
+
+        Assert.True(new AosReferenceCombinedView([fresh], settled).HasContext(settled));
+        Assert.False(new AosReferenceCombinedView([fresh, behind], settled).HasContext(settled));
+
+        Assert.False(new AosReferenceCombinedView([fresh], stale).HasContext(settled));
+    }
+
+    [Fact]
+    public void ClearingASortThatResolvesToTheSameOrder_ReportsNothingStale()
+    {
+        var logId = EventLogId.Create();
+
+        var state = new LogTableState
+        {
+            ActiveEventLogId = logId,
+            EventTables = [new LogView(logId)],
+            TimelineVisible = true,
+            OrderBy = ColumnName.DateAndTime,
+            CommittedEffectiveOrderBy = ColumnName.DateAndTime,
+            RequestedOrderBy = ColumnName.DateAndTime
+        };
+
+        (LogTableState serving, IEventColumnView served) = ServingRetained(state);
+        var cleared = serving with { RequestedOrderBy = null };
+
+        Assert.Same(served, cleared.GetActiveDisplayedEvents());
+        Assert.True(cleared.GetActiveDisplayedEvents().Count > 0);
+
+        Assert.True(cleared.IsRetainedViewServable(logId));
+        Assert.True(cleared.HasPendingSortChange);
+        Assert.False(cleared.OrderingIsStale);
+    }
+
+    [Fact]
+    public void ClearingASortThatResolvesToTheSameOrder_StillCommitsTheRawSelection()
+    {
+        var logId = EventLogId.Create();
+
+        var state = new LogTableState
+        {
+            ActiveEventLogId = logId,
+            EventTables = [new LogView(logId)],
+            TimelineVisible = true,
+            OrderBy = ColumnName.DateAndTime,
+            CommittedEffectiveOrderBy = ColumnName.DateAndTime,
+            RequestedOrderBy = ColumnName.DateAndTime
+        };
+
+        var cleared = state with { RequestedOrderBy = null };
+
+        Assert.True(cleared.HasPendingSortChange);
+        Assert.Equal(cleared.SortContext, cleared.CommittedSortContext);
+
+        var adopted = Reducers.ReduceOrderedViewUpdated(
+            cleared,
+            new OrderedViewUpdatedAction(
+                new OrderedViewReady(
+                    SnapshotVersion: cleared.LastPublishedSnapshotVersion + 1,
+                    Identity: cleared.ViewIdentity,
+                    Sequence: cleared.HighestInvalidationSequence,
+                    SingleLogId: logId,
+                    InScope: [new LogGeneration(logId, 0)],
+                    View: LogTableState.EmptyView,
+                    Config: cleared.SortContext,
+                    Filter: cleared.AppliedFilter)));
+
+        Assert.False(adopted.HasPendingSortChange);
+        Assert.Null(adopted.OrderBy);
+        Assert.Equal(ColumnName.DateAndTime, adopted.CommittedEffectiveOrderBy);
+    }
+
+    [Fact]
+    public void RequestingASortTheRowsAreNotInYet_ReportsTheOrderingStale()
+    {
+        var logId = EventLogId.Create();
+        var state = new LogTableState { ActiveEventLogId = logId, EventTables = [new LogView(logId)] };
+
+        (LogTableState serving, IEventColumnView served) = ServingRetained(state);
+        var sorted = serving with { RequestedOrderBy = ColumnName.EventId };
+
+        Assert.Same(served, sorted.GetActiveDisplayedEvents());
+        Assert.True(sorted.GetActiveDisplayedEvents().Count > 0);
+
+        Assert.True(sorted.OrderingIsStale);
+    }
+
     [Fact]
     public void ResolveDefaultOrderBy_WhenGrouped_IgnoresTimeline()
     {
-        // Grouping short-circuits the default, so the timeline flag cannot force a column sort.
         Assert.Null(
             ResolvedEventOrdering.ResolveDefaultOrderBy(orderBy: null, groupBy: ColumnName.Source, logCount: 1, timelineVisible: true));
     }
@@ -25,16 +121,15 @@ public void ResolveDefaultOrderBy_WhenGrouped_IgnoresTimeline()
     [Fact]
     public void ResolveDefaultOrderBy_WithExplicitSort_IgnoresTimeline()
     {
-        // An explicit column sort always wins over the timeline-driven default, even for a single log.
         Assert.Equal(
             ColumnName.EventId,
             ResolvedEventOrdering.ResolveDefaultOrderBy(orderBy: ColumnName.EventId, groupBy: null, logCount: 1, timelineVisible: true));
     }
 
     [Theory]
-    [InlineData(1, false, null)]                        // one log, timeline hidden -> Record ID (null)
-    [InlineData(1, true, ColumnName.DateAndTime)]       // one log, timeline shown -> Date/Time
-    [InlineData(2, false, ColumnName.DateAndTime)]      // combined view -> Date/Time regardless of the timeline
+    [InlineData(1, false, null)]
+    [InlineData(1, true, ColumnName.DateAndTime)]
+    [InlineData(2, false, ColumnName.DateAndTime)]
     [InlineData(2, true, ColumnName.DateAndTime)]
     public void ResolveDefaultOrderBy_WithoutExplicitSort_FollowsLogCountAndTimeline(
         int logCount,
@@ -47,41 +142,86 @@ public void ResolveDefaultOrderBy_WithoutExplicitSort_FollowsLogCountAndTimeline
     }
 
     [Fact]
-    public void SetHistogramVisible_OnCombinedView_FlipsFlagWithoutBumpingDisplayVersion()
+    public void RevealingTheTimeline_LeavesTheRowsBehindTheOrderTheyAreNowAskedFor()
+    {
+        var logId = EventLogId.Create();
+        (LogTableState state, IEventColumnView served) = ServingRetained(
+            new LogTableState { ActiveEventLogId = logId, EventTables = [new LogView(logId)] });
+
+        Assert.False(state.OrderingIsStale);
+
+        var shown = Reducers.ReduceSetHistogramVisible(state, new SetHistogramVisibleAction(true));
+
+        Assert.Same(served, shown.GetActiveDisplayedEvents());
+        Assert.True(shown.GetActiveDisplayedEvents().Count > 0);
+
+        Assert.False(shown.HasPendingSortChange);
+        Assert.NotEqual(shown.SortContext, shown.CommittedSortContext);
+        Assert.True(shown.OrderingIsStale);
+    }
+
+    [Fact]
+    public void RevealingTheTimeline_ThenAdoptingTheRebuild_AdvancesTheFrozenOrder()
+    {
+        var logId = EventLogId.Create();
+        var state = new LogTableState { ActiveEventLogId = logId, EventTables = [new LogView(logId)] };
+
+        var shown = Reducers.ReduceSetHistogramVisible(state, new SetHistogramVisibleAction(true));
+
+        Assert.False(shown.HasPendingSortChange);
+        Assert.Null(shown.CommittedEffectiveOrderBy);
+
+        var adopted = Reducers.ReduceOrderedViewUpdated(
+            shown,
+            new OrderedViewUpdatedAction(
+                new OrderedViewReady(
+                    SnapshotVersion: shown.LastPublishedSnapshotVersion + 1,
+                    Identity: shown.ViewIdentity,
+                    Sequence: shown.HighestInvalidationSequence,
+                    SingleLogId: logId,
+                    InScope: [new LogGeneration(logId, 0)],
+                    View: LogTableState.EmptyView,
+                    Config: shown.SortContext,
+                    Filter: shown.AppliedFilter)));
+
+        Assert.Equal(ColumnName.DateAndTime, adopted.CommittedEffectiveOrderBy);
+        Assert.Equal(adopted.SortContext, adopted.CommittedSortContext);
+        Assert.False(adopted.OrderingIsStale);
+    }
+
+    [Fact]
+    public void SetHistogramVisible_OnCombinedView_LeavesTheEffectiveOrderAtDateAndTime()
     {
         var log1 = EventLogId.Create();
         var log2 = EventLogId.Create();
-        var state = new LogTableState()
-            .WithLogEvents(log1, LogEvents("Log1"))
-            .WithLogEvents(log2, LogEvents("Log2"));
-        int before = state.DisplayListVersion;
+        var state = new LogTableState { EventTables = [new LogView(log1), new LogView(log2)] };
+
+        Assert.Equal(ColumnName.DateAndTime, state.SortContext.OrderBy);
 
         var shown = Reducers.ReduceSetHistogramVisible(state, new SetHistogramVisibleAction(true));
 
-        // A combined view is Date/Time either way, so no republish follows and the version must not move (it would strand
-        // an in-flight republish carrying the pre-bump version).
         Assert.True(shown.TimelineVisible);
-        Assert.Equal(before, shown.DisplayListVersion);
+        Assert.Equal(ColumnName.DateAndTime, shown.SortContext.OrderBy);
     }
 
     [Fact]
-    public void SetHistogramVisible_OnSingleDefaultLog_FlipsFlagAndBumpsDisplayVersion()
+    public void SetHistogramVisible_OnSingleDefaultLog_FlipsTheEffectiveOrderToDateAndTime()
     {
         var logId = EventLogId.Create();
-        var state = new LogTableState().WithLogEvents(logId, OutOfRecordOrderEvents());
-        int before = state.DisplayListVersion;
+        var state = new LogTableState { EventTables = [new LogView(logId)] };
+
+        Assert.Null(state.SortContext.OrderBy);
 
         var shown = Reducers.ReduceSetHistogramVisible(state, new SetHistogramVisibleAction(true));
 
         Assert.True(shown.TimelineVisible);
-        Assert.Equal(before + 1, shown.DisplayListVersion);
+        Assert.Equal(ColumnName.DateAndTime, shown.SortContext.OrderBy);
     }
 
     [Fact]
     public void SetHistogramVisible_WhenUnchanged_ReturnsSameState()
     {
-        var logId = EventLogId.Create();
-        var state = new LogTableState { TimelineVisible = true }.WithLogEvents(logId, OutOfRecordOrderEvents());
+        var state = new LogTableState { TimelineVisible = true };
 
         var result = Reducers.ReduceSetHistogramVisible(state, new SetHistogramVisibleAction(true));
 
@@ -89,25 +229,24 @@ public void SetHistogramVisible_WhenUnchanged_ReturnsSameState()
     }
 
     [Fact]
-    public void SetHistogramVisible_WithExplicitSort_FlipsFlagWithoutBumpingDisplayVersion()
+    public void SetHistogramVisible_WithExplicitSort_LeavesTheEffectiveOrderOnTheExplicitColumn()
     {
         var logId = EventLogId.Create();
-        var state = new LogTableState { RequestedOrderBy = ColumnName.EventId }
-            .WithLogEvents(logId, OutOfRecordOrderEvents());
-        int before = state.DisplayListVersion;
+        var state = new LogTableState { EventTables = [new LogView(logId)], RequestedOrderBy = ColumnName.EventId };
+
+        Assert.Equal(ColumnName.EventId, state.SortContext.OrderBy);
 
         var shown = Reducers.ReduceSetHistogramVisible(state, new SetHistogramVisibleAction(true));
 
         Assert.True(shown.TimelineVisible);
-        Assert.Equal(before, shown.DisplayListVersion);
+        Assert.Equal(ColumnName.EventId, shown.SortContext.OrderBy);
     }
 
     [Fact]
     public void SingleLog_WithTimelineHidden_OrdersByRecordId()
     {
         var logId = EventLogId.Create();
-        var state = new LogTableState { ActiveEventLogId = logId, TimelineVisible = false }
-            .WithLogEvents(logId, OutOfRecordOrderEvents());
+        var state = new LogTableState { ActiveEventLogId = logId, EventTables = [new LogView(logId)], TimelineVisible = false };
 
         Assert.Null(state.SortContext.OrderBy);
         Assert.Equal(new long?[] { 3, 2, 1 }, DisplayedRecordIds(state));
@@ -117,17 +256,15 @@ public void SingleLog_WithTimelineHidden_OrdersByRecordId()
     public void SingleLog_WithTimelineVisible_OrdersByDateAndTime()
     {
         var logId = EventLogId.Create();
-        var state = new LogTableState { ActiveEventLogId = logId, TimelineVisible = true }
-            .WithLogEvents(logId, OutOfRecordOrderEvents());
+        var state = new LogTableState { ActiveEventLogId = logId, EventTables = [new LogView(logId)], TimelineVisible = true };
 
         Assert.Equal(ColumnName.DateAndTime, state.SortContext.OrderBy);
 
-        // Record IDs 1/2/3 carry times +3/+1/+2, so Date/Time descending is 1, 3, 2 (not the Record ID order 3, 2, 1).
         Assert.Equal(new long?[] { 1, 3, 2 }, DisplayedRecordIds(state));
     }
 
     private static long?[] DisplayedRecordIds(LogTableState state) =>
-        [.. state.DisplayedEvents.EnumerateDetail().Select(resolved => resolved.RecordId)];
+        [.. ViewOver(state.SortContext).EnumerateDetail().Select(resolved => resolved.RecordId)];
 
     private static ResolvedEvent[] LogEvents(string owningLog) =>
     [
@@ -137,4 +274,45 @@ private static ResolvedEvent[] LogEvents(string owningLog) =>
     ];
 
     private static ResolvedEvent[] OutOfRecordOrderEvents() => LogEvents("TestLog");
+
+    private static (LogTableState State, IEventColumnView Served) ServingRetained(LogTableState state)
+    {
+        EventLogId activeLogId = state.ActiveEventLogId!.Value;
+        AosReferenceView servedView = ViewOver(state.CommittedSortContext);
+
+        var served = new OrderedViewReady(
+            SnapshotVersion: 1,
+            Identity: state.ViewIdentity,
+            Sequence: state.HighestInvalidationSequence,
+            SingleLogId: activeLogId,
+            InScope: [new LogGeneration(activeLogId, 0)],
+            View: servedView,
+            Config: state.CommittedSortContext,
+            Filter: state.AppliedFilter);
+
+        EventLogId decoyLogId = EventLogId.Create();
+        LogTableState decoyState = state with { ActiveEventLogId = decoyLogId, EventTables = [new LogView(decoyLogId)] };
+        var decoy = new OrderedViewReady(
+            SnapshotVersion: 1,
+            Identity: decoyState.ViewIdentity,
+            Sequence: decoyState.HighestInvalidationSequence,
+            SingleLogId: decoyLogId,
+            InScope: [new LogGeneration(decoyLogId, 0)],
+            View: ViewOver(decoyState.CommittedSortContext),
+            Config: decoyState.CommittedSortContext,
+            Filter: decoyState.AppliedFilter);
+
+        return (
+            state with { RetainedOrderedViews = RetainedViewTestFactory.RetainedMap(served, decoy) },
+            servedView);
+    }
+
+    private static AosReferenceView ViewOver(SortContext context)
+    {
+        ResolvedEvent[] events = [.. OutOfRecordOrderEvents()];
+        var reader = EventColumnStore.Build(events, generation: 0, contentVersion: 0).CreateReader(EventLogId.Create());
+
+        return AosReferenceView.Create(reader, [.. Enumerable.Range(0, events.Length)], context);
+    }
 }
+
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/Scenarios/Favorites/ScenarioFavoritesSourceTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/Scenarios/Favorites/ScenarioFavoritesSourceTests.cs
new file mode 100644
index 000000000..b831aed11
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/Scenarios/Favorites/ScenarioFavoritesSourceTests.cs
@@ -0,0 +1,111 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Logging.Abstractions;
+using EventLogExpert.Runtime.Scenarios.Favorites;
+using Fluxor;
+using NSubstitute;
+using System.Collections.Immutable;
+
+namespace EventLogExpert.Runtime.Tests.Scenarios.Favorites;
+
+public sealed class ScenarioFavoritesSourceTests
+{
+    [Fact]
+    public void AThrowingSubscriber_IsIsolatedFromOtherSubscribers()
+    {
+        var harness = new Harness("scenario-a");
+        var reachedSecond = 0;
+        harness.Source.Changed += () => throw new InvalidOperationException("subscriber blew up");
+        harness.Source.Changed += () => reachedSecond++;
+
+        harness.SetState(ImmutableHashSet.Create("scenario-a", "scenario-b"));
+
+        Assert.Equal(1, reachedSecond);
+    }
+
+    [Fact]
+    public void Changed_DoesNotFire_WhenAFreshSetHasEqualContent()
+    {
+        var harness = new Harness("scenario-a", "scenario-b");
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.SetState(ImmutableHashSet.Create("scenario-b", "scenario-a"));
+
+        Assert.Equal(0, raised);
+    }
+
+    [Fact]
+    public void Changed_FiresWithLatestFavorites_WhenContentChanges()
+    {
+        var harness = new Harness("scenario-a");
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.SetState(ImmutableHashSet.Create("scenario-a", "scenario-b"));
+
+        Assert.Equal(1, raised);
+        Assert.Contains("scenario-b", harness.Source.FavoriteScenarioIds);
+    }
+
+    [Fact]
+    public void Construction_AdoptsAChangeThatLandsBetweenSeedAndSubscribe()
+    {
+        // populated state (the reconcile), with no StateChanged raised in between.
+        var state = Substitute.For<IState<ScenarioFavoritesState>>();
+        state.Value.Returns(new ScenarioFavoritesState(), WithFavorites("scenario-a"));
+
+        using var source = new ScenarioFavoritesSource(state, Substitute.For<ITraceLogger>());
+
+        Assert.Contains("scenario-a", source.FavoriteScenarioIds);
+    }
+
+    [Fact]
+    public void Dispose_StopsRaising()
+    {
+        var harness = new Harness("scenario-a");
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.Source.Dispose();
+        harness.SetState(ImmutableHashSet.Create("scenario-a", "scenario-b"));
+
+        Assert.Equal(0, raised);
+    }
+
+    [Fact]
+    public void FavoriteScenarioIds_ReflectsTheInitialState()
+    {
+        var harness = new Harness("scenario-a", "scenario-b");
+
+        Assert.Equal(2, harness.Source.FavoriteScenarioIds.Count);
+        Assert.Contains("scenario-a", harness.Source.FavoriteScenarioIds);
+        Assert.Contains("scenario-b", harness.Source.FavoriteScenarioIds);
+    }
+
+    private static ScenarioFavoritesState WithFavorites(params string[] ids) =>
+        new() { FavoriteScenarioIds = [.. ids] };
+
+    private sealed class Harness
+    {
+        private readonly IState<ScenarioFavoritesState> _state = Substitute.For<IState<ScenarioFavoritesState>>();
+
+        public Harness(params string[] ids)
+        {
+            State = WithFavorites(ids);
+            _state.Value.Returns(_ => State);
+            Source = new ScenarioFavoritesSource(_state, Substitute.For<ITraceLogger>());
+        }
+
+        public ScenarioFavoritesSource Source { get; }
+
+        public ScenarioFavoritesState State { get; private set; }
+
+        public void SetState(ImmutableHashSet<string> ids)
+        {
+            State = new ScenarioFavoritesState { FavoriteScenarioIds = ids };
+            _state.StateChanged += Raise.Event<EventHandler>(_state, EventArgs.Empty);
+        }
+    }
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/Scenarios/ScenarioApplyIntegrationTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/Scenarios/ScenarioApplyIntegrationTests.cs
index 51663b0c7..3b70a3cc9 100644
--- a/tests/Unit/EventLogExpert.Runtime.Tests/Scenarios/ScenarioApplyIntegrationTests.cs
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/Scenarios/ScenarioApplyIntegrationTests.cs
@@ -1,6 +1,7 @@
 // // Copyright (c) Microsoft Corporation.
 // // Licensed under the MIT License.
 
+using EventLogExpert.Logging.Abstractions;
 using EventLogExpert.Runtime.EventLog;
 using EventLogExpert.Runtime.FilterLenses;
 using EventLogExpert.Runtime.FilterPane;
@@ -51,7 +52,7 @@ public async Task ReplaceFiltersAction_FromScenario_LandsOnAppliedFilter()
         var lensState = Substitute.For<IState<FilterLensState>>();
         lensState.Value.Returns(new FilterLensState());
 
-        var effects = new FilterPaneEffects(appliedFilter, rawEventStore, paneStateAccessor, lensState);
+        var effects = new FilterPaneEffects(appliedFilter, rawEventStore, paneStateAccessor, lensState, new ClearAllFiltersNotifier(Substitute.For<ITraceLogger>()), new SetFilterDateRangeSucceededNotifier(Substitute.For<ITraceLogger>()));
         var dispatcher = Substitute.For<IDispatcher>();
 
         ApplyFilterAction? captured = null;
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/StatusBar/StatusBarFormatterTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/StatusBar/StatusBarFormatterTests.cs
index ea640f809..1fb837c7c 100644
--- a/tests/Unit/EventLogExpert.Runtime.Tests/StatusBar/StatusBarFormatterTests.cs
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/StatusBar/StatusBarFormatterTests.cs
@@ -28,6 +28,27 @@ public void FilterIndicatorTooltip_PersistentAndLenses_CombinesBoth() =>
     public void FilterIndicatorTooltip_PersistentOnly_ReturnsFilterActive() =>
         Assert.Equal("Filter active", StatusBarFormatter.FilterIndicatorTooltip(persistentActive: true, lensCount: 0));
 
+    [Theory]
+    [InlineData(DisplayIndicatorKind.Fault, true, true, true, "Error: No resolver", "Error: No resolver")]
+    [InlineData(DisplayIndicatorKind.Fault, true, true, true, "", "These events could not be prepared")]
+    [InlineData(DisplayIndicatorKind.EmptyPending, true, false, false, "", "Loading")]
+    [InlineData(DisplayIndicatorKind.EmptyPending, false, false, false, "", "Loading events")]
+    [InlineData(DisplayIndicatorKind.ReorderPending, false, false, false, "", "Reordering events")]
+    [InlineData(DisplayIndicatorKind.ReorderPending, false, false, true, "", "Reordering events")]
+    [InlineData(DisplayIndicatorKind.None, false, false, true, "", "Continuously updating")]
+    [InlineData(DisplayIndicatorKind.None, false, false, false, "", "")]
+    public void FormatActivityAnnouncement_RanksTheDisplaysOwnNewsAgainstTheLogs(
+        DisplayIndicatorKind indicator,
+        bool isLoading,
+        bool bufferFull,
+        bool continuouslyUpdating,
+        string resolverStatus,
+        string expected) =>
+        Assert.Equal(
+            expected,
+            StatusBarFormatter.FormatActivityAnnouncement(
+                isLoading, bufferFull, continuouslyUpdating, resolverStatus, indicator));
+
     [Theory]
     [InlineData(true, false, false, "Error: Failed to load System", "Error: Failed to load System")]
     [InlineData(true, false, false, "", "Loading")]
@@ -41,6 +62,13 @@ public void FormatActivityAnnouncement_SurfacesErrorOverLoading(
             expected,
             StatusBarFormatter.FormatActivityAnnouncement(isLoading, bufferFull, continuouslyUpdating, resolverStatus));
 
+    [Fact]
+    public void FormatActivityAnnouncement_WithoutADisplayIndicator_IsUnchanged() =>
+        Assert.Equal(
+            "Loading",
+            StatusBarFormatter.FormatActivityAnnouncement(
+                isLoading: true, bufferFull: false, continuouslyUpdating: false, resolverStatus: ""));
+
     [Fact]
     public void FormatCounts_Filtered_ShowsShownOfTotal() =>
         Assert.Equal(
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/StatusBar/StatusBarSourceTests.cs b/tests/Unit/EventLogExpert.Runtime.Tests/StatusBar/StatusBarSourceTests.cs
new file mode 100644
index 000000000..fe2a1afea
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/StatusBar/StatusBarSourceTests.cs
@@ -0,0 +1,346 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Logging.Abstractions;
+using EventLogExpert.Runtime.EventLog;
+using EventLogExpert.Runtime.FilterPane;
+using EventLogExpert.Runtime.LogTable;
+using EventLogExpert.Runtime.StatusBar;
+using Fluxor;
+using NSubstitute;
+using System.Collections.Immutable;
+
+namespace EventLogExpert.Runtime.Tests.StatusBar;
+
+public sealed class StatusBarSourceTests
+{
+    private static readonly StatusActivityId Activity = new(Guid.NewGuid());
+    private static readonly EventLogId LogA = EventLogId.Create();
+    private static readonly EventLogId LogB = EventLogId.Create();
+
+    [Fact]
+    public void AThrowingSubscriber_IsIsolatedFromOtherSubscribers()
+    {
+        var harness = new Harness();
+        var reachedSecond = 0;
+        harness.Source.Changed += () => throw new InvalidOperationException("subscriber blew up");
+        harness.Source.Changed += () => reachedSecond++;
+
+        harness.RawCount = new RawEventCountState { ByLog = ImmutableDictionary<EventLogId, int>.Empty.Add(LogA, 5) };
+        harness.RaiseRawCount();
+
+        Assert.Equal(1, reachedSecond);
+    }
+
+    [Fact]
+    public void Changed_DoesNotFire_WhenAnEventLogFacetTheBarDoesNotReadChanges()
+    {
+        var harness = new Harness();
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.EventLog = harness.EventLog with { AppliedFilter = new Filter(new DateFilter { IsEnabled = true }, []) };
+        harness.RaiseEventLog();
+
+        Assert.Equal(0, raised);
+    }
+
+    [Fact]
+    public void Changed_DoesNotFire_WhenEventsLoadingMapIsEquivalent()
+    {
+        var harness = new Harness();
+        harness.StatusBar = harness.StatusBar with
+        {
+            EventsLoading = ImmutableDictionary<StatusActivityId, (int, int)>.Empty.Add(Activity, (12, 3))
+        };
+        harness.RaiseStatusBar();
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.StatusBar = harness.StatusBar with
+        {
+            EventsLoading = ImmutableDictionary.CreateRange([new KeyValuePair<StatusActivityId, (int, int)>(Activity, (12, 3))])
+        };
+        harness.RaiseStatusBar();
+
+        Assert.Equal(0, raised);
+    }
+
+    [Fact]
+    public void Changed_DoesNotFire_WhenRawCountsByLogIsEquivalent()
+    {
+        var harness = new Harness();
+        harness.RawCount = new RawEventCountState { ByLog = ImmutableDictionary<EventLogId, int>.Empty.Add(LogA, 5) };
+        harness.RaiseRawCount();
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.RawCount = new RawEventCountState { ByLog = ImmutableDictionary.CreateRange([new KeyValuePair<EventLogId, int>(LogA, 5)]) };
+        harness.RaiseRawCount();
+
+        Assert.Equal(0, raised);
+    }
+
+    [Fact]
+    public void Changed_Fires_WhenAnEventLogFacetChanges()
+    {
+        var harness = new Harness();
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.EventLog = harness.EventLog with { ContinuouslyUpdate = true };
+        harness.RaiseEventLog();
+
+        Assert.Equal(1, raised);
+        Assert.True(harness.Source.Current.ContinuouslyUpdate);
+    }
+
+    [Fact]
+    public void Changed_Fires_WhenLoadingActivitiesChange_AndProjectsLoadedAndFailed()
+    {
+        var harness = new Harness();
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.StatusBar = harness.StatusBar with
+        {
+            EventsLoading = ImmutableDictionary<StatusActivityId, (int, int)>.Empty.Add(Activity, (12, 3))
+        };
+        harness.RaiseStatusBar();
+
+        Assert.Equal(1, raised);
+        var progress = harness.Source.Current.LoadingActivities[Activity];
+        Assert.Equal(12, progress.Loaded);
+        Assert.Equal(3, progress.Failed);
+    }
+
+    [Fact]
+    public void Changed_Fires_WhenLogTableTopologyChanges()
+    {
+        var harness = new Harness();
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.LogTable = harness.LogTable with { ActiveEventLogId = LogA };
+        harness.RaiseLogTable();
+
+        Assert.Equal(1, raised);
+        Assert.Equal(LogA, harness.Source.Current.ActiveTabId);
+    }
+
+    [Fact]
+    public void Changed_Fires_WhenPersistentFilterChanges()
+    {
+        var harness = new Harness();
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.FilterPane = harness.FilterPane with { FilteredDateRange = new DateFilter { IsEnabled = true } };
+        harness.RaiseFilterPane();
+
+        Assert.Equal(1, raised);
+        Assert.True(harness.Source.Current.IsPersistentFilterActive);
+    }
+
+    [Fact]
+    public void Changed_Fires_WhenRawCountsRedistributeAtTheSameTotal()
+    {
+        var harness = new Harness();
+        harness.RawCount = new RawEventCountState { ByLog = ImmutableDictionary<EventLogId, int>.Empty.Add(LogA, 5) };
+        harness.RaiseRawCount();
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.RawCount = new RawEventCountState
+        {
+            ByLog = ImmutableDictionary<EventLogId, int>.Empty.Add(LogA, 2).Add(LogB, 3)
+        };
+        harness.RaiseRawCount();
+
+        Assert.Equal(1, raised);
+        Assert.Equal(5, harness.Source.Current.RawEventTotal);
+    }
+
+    [Fact]
+    public void Changed_Fires_WhenStatusActivityChanges()
+    {
+        var harness = new Harness();
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.StatusBar = harness.StatusBar with { ResolverStatus = "Providers unavailable" };
+        harness.RaiseStatusBar();
+
+        Assert.Equal(1, raised);
+        Assert.Equal("Providers unavailable", harness.Source.Current.ResolverStatus);
+    }
+
+    [Fact]
+    public void Construction_ReconcilesARawCountChangeBetweenSeedAndSubscribe_SoALaterUnchangedNotificationDoesNotRaise()
+    {
+        var populated = new RawEventCountState { ByLog = ImmutableDictionary<EventLogId, int>.Empty.Add(LogA, 7) };
+        var rawCount = Substitute.For<IState<RawEventCountState>>();
+        rawCount.Value.Returns(new RawEventCountState(), populated);
+        using var source = NewSource(rawCount: rawCount);
+        var raised = 0;
+        source.Changed += () => raised++;
+
+        rawCount.StateChanged += Raise.Event<EventHandler>(rawCount, EventArgs.Empty);
+
+        Assert.Equal(0, raised);
+        Assert.Equal(7, source.Current.RawEventTotal);
+    }
+
+    [Fact]
+    public void Construction_ReconcilesAStatusChangeBetweenSeedAndSubscribe_SoALaterUnchangedNotificationDoesNotRaise()
+    {
+        var late = new StatusBarState { ResolverStatus = "Late" };
+        var statusBar = Substitute.For<IState<StatusBarState>>();
+        statusBar.Value.Returns(new StatusBarState(), late);
+        using var source = NewSource(statusBar: statusBar);
+        var raised = 0;
+        source.Changed += () => raised++;
+
+        statusBar.StateChanged += Raise.Event<EventHandler>(statusBar, EventArgs.Empty);
+
+        Assert.Equal(0, raised);
+        Assert.Equal("Late", source.Current.ResolverStatus);
+    }
+
+    [Fact]
+    public void Current_ReadsEveryBackingStateLive()
+    {
+        var harness = new Harness();
+
+        harness.EventLog = harness.EventLog with { ContinuouslyUpdate = true };
+        harness.FilterPane = harness.FilterPane with { FilteredDateRange = new DateFilter { IsEnabled = true } };
+        harness.RawCount = new RawEventCountState { ByLog = ImmutableDictionary<EventLogId, int>.Empty.Add(LogA, 9) };
+        harness.LogTable = harness.LogTable with { ActiveEventLogId = LogA };
+
+        var current = harness.Source.Current;
+
+        Assert.True(current.ContinuouslyUpdate);
+        Assert.True(current.IsPersistentFilterActive);
+        Assert.Equal(9, current.RawEventTotal);
+        Assert.Equal(LogA, current.ActiveTabId);
+    }
+
+    [Fact]
+    public void Current_ShowsLiveStatusActivity_EvenWithoutAStatusNotification()
+    {
+        var harness = new Harness();
+
+        harness.StatusBar = harness.StatusBar with { ResolverStatus = "Fresh" };
+
+        Assert.Equal("Fresh", harness.Source.Current.ResolverStatus);
+    }
+
+    [Fact]
+    public void Dispose_UnsubscribesFromAllFiveStates()
+    {
+        var eventLog = Substitute.For<IState<EventLogState>>();
+        eventLog.Value.Returns(new EventLogState());
+        var filterPane = Substitute.For<IState<FilterPaneState>>();
+        filterPane.Value.Returns(new FilterPaneState());
+        var rawCount = Substitute.For<IState<RawEventCountState>>();
+        rawCount.Value.Returns(new RawEventCountState());
+        var statusBar = Substitute.For<IState<StatusBarState>>();
+        statusBar.Value.Returns(new StatusBarState());
+        var logTable = Substitute.For<IState<LogTableState>>();
+        logTable.Value.Returns(new LogTableState());
+        var source = new StatusBarSource(eventLog, filterPane, rawCount, statusBar, logTable, Substitute.For<ITraceLogger>());
+
+        source.Dispose();
+
+        eventLog.Received().StateChanged -= Arg.Any<EventHandler>();
+        filterPane.Received().StateChanged -= Arg.Any<EventHandler>();
+        rawCount.Received().StateChanged -= Arg.Any<EventHandler>();
+        statusBar.Received().StateChanged -= Arg.Any<EventHandler>();
+        logTable.Received().StateChanged -= Arg.Any<EventHandler>();
+    }
+
+    [Fact]
+    public void StatusChangeAlone_DoesNotRaiseThroughAnotherInputsNotification()
+    {
+        var harness = new Harness();
+        var raised = 0;
+        harness.Source.Changed += () => raised++;
+
+        harness.StatusBar = harness.StatusBar with { ResolverStatus = "Would-be-leaked" };
+        harness.RaiseRawCount();
+
+        Assert.Equal(0, raised);
+    }
+
+    private static StatusBarSource NewSource(
+        IState<EventLogState>? eventLog = null,
+        IState<FilterPaneState>? filterPane = null,
+        IState<RawEventCountState>? rawCount = null,
+        IState<StatusBarState>? statusBar = null,
+        IState<LogTableState>? logTable = null)
+    {
+        eventLog ??= StateOf(new EventLogState());
+        filterPane ??= StateOf(new FilterPaneState());
+        rawCount ??= StateOf(new RawEventCountState());
+        statusBar ??= StateOf(new StatusBarState());
+        logTable ??= StateOf(new LogTableState());
+
+        return new StatusBarSource(eventLog, filterPane, rawCount, statusBar, logTable, Substitute.For<ITraceLogger>());
+    }
+
+    private static IState<TState> StateOf<TState>(TState value)
+    {
+        var state = Substitute.For<IState<TState>>();
+        state.Value.Returns(value);
+
+        return state;
+    }
+
+    private sealed class Harness
+    {
+        private readonly IState<EventLogState> _eventLog = Substitute.For<IState<EventLogState>>();
+        private readonly IState<FilterPaneState> _filterPane = Substitute.For<IState<FilterPaneState>>();
+        private readonly IState<LogTableState> _logTable = Substitute.For<IState<LogTableState>>();
+        private readonly IState<RawEventCountState> _rawCount = Substitute.For<IState<RawEventCountState>>();
+        private readonly IState<StatusBarState> _statusBar = Substitute.For<IState<StatusBarState>>();
+
+        public Harness()
+        {
+            _eventLog.Value.Returns(_ => EventLog);
+            _filterPane.Value.Returns(_ => FilterPane);
+            _rawCount.Value.Returns(_ => RawCount);
+            _statusBar.Value.Returns(_ => StatusBar);
+            _logTable.Value.Returns(_ => LogTable);
+            Source = new StatusBarSource(
+                _eventLog, _filterPane, _rawCount, _statusBar, _logTable, Substitute.For<ITraceLogger>());
+        }
+
+        public EventLogState EventLog { get; set; } = new();
+
+        public FilterPaneState FilterPane { get; set; } = new();
+
+        public LogTableState LogTable { get; set; } = new();
+
+        public RawEventCountState RawCount { get; set; } = new();
+
+        public StatusBarSource Source { get; }
+
+        public StatusBarState StatusBar { get; set; } = new();
+
+        public void RaiseEventLog() =>
+            _eventLog.StateChanged += Raise.Event<EventHandler>(_eventLog, EventArgs.Empty);
+
+        public void RaiseFilterPane() =>
+            _filterPane.StateChanged += Raise.Event<EventHandler>(_filterPane, EventArgs.Empty);
+
+        public void RaiseLogTable() =>
+            _logTable.StateChanged += Raise.Event<EventHandler>(_logTable, EventArgs.Empty);
+
+        public void RaiseRawCount() =>
+            _rawCount.StateChanged += Raise.Event<EventHandler>(_rawCount, EventArgs.Empty);
+
+        public void RaiseStatusBar() =>
+            _statusBar.StateChanged += Raise.Event<EventHandler>(_statusBar, EventArgs.Empty);
+    }
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/TestUtils/DisplayViewTestFactory.cs b/tests/Unit/EventLogExpert.Runtime.Tests/TestUtils/DisplayViewTestFactory.cs
index d79001bdc..c422d21a2 100644
--- a/tests/Unit/EventLogExpert.Runtime.Tests/TestUtils/DisplayViewTestFactory.cs
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/TestUtils/DisplayViewTestFactory.cs
@@ -4,19 +4,14 @@
 using EventLogExpert.Eventing.Common.EventLogs;
 using EventLogExpert.Eventing.Common.Events;
 using EventLogExpert.Runtime.LogTable;
+using EventLogExpert.Runtime.Tests.LogTable.TestSupport;
 
 namespace EventLogExpert.Runtime.Tests.TestUtils;
 
-/// <summary>
-///     Builds per-log <see cref="EventColumnView" />s over a real <see cref="EventColumnStore" /> for tests that seed
-///     display state, mirroring the production <c>DisplayViewBuilder</c> path so stored views are physically resolvable.
-/// </summary>
 internal static class DisplayViewTestFactory
 {
-    // Builds an unsorted view (physical ingest order). The display reducers re-heal it to the state's sort context on
-    // store, so seeding order does not matter for correctness.
-    internal static EventColumnView Build(EventLogId logId, IReadOnlyList<ResolvedEvent> events) =>
-        EventColumnView.Create(
+    internal static AosReferenceView Build(EventLogId logId, IReadOnlyList<ResolvedEvent> events) =>
+        AosReferenceView.Create(
             Reader(logId, events),
             Survivors(events.Count),
             orderBy: null,
@@ -24,12 +19,11 @@ internal static EventColumnView Build(EventLogId logId, IReadOnlyList<ResolvedEv
             groupBy: null,
             isGroupDescending: false);
 
-    // Builds a view already sorted under the given context, for tests that read the view directly without a reducer.
-    internal static EventColumnView Build(EventLogId logId, IReadOnlyList<ResolvedEvent> events, SortContext context) =>
-        EventColumnView.Create(Reader(logId, events), Survivors(events.Count), context);
+    internal static AosReferenceView Build(EventLogId logId, IReadOnlyList<ResolvedEvent> events, SortContext context) =>
+        AosReferenceView.Create(Reader(logId, events), Survivors(events.Count), context);
 
     private static IEventColumnReader Reader(EventLogId logId, IReadOnlyList<ResolvedEvent> events) =>
         EventColumnStore.Build(events, generation: 0, contentVersion: 0).CreateReader(logId);
 
-    private static int[] Survivors(int count) => Enumerable.Range(0, count).ToArray();
+    private static int[] Survivors(int count) => [.. Enumerable.Range(0, count)];
 }
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/TestUtils/RetainedViewTestFactory.cs b/tests/Unit/EventLogExpert.Runtime.Tests/TestUtils/RetainedViewTestFactory.cs
new file mode 100644
index 000000000..ad83f75ab
--- /dev/null
+++ b/tests/Unit/EventLogExpert.Runtime.Tests/TestUtils/RetainedViewTestFactory.cs
@@ -0,0 +1,31 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Runtime.LogTable;
+using EventLogExpert.Runtime.LogTable.OrderedView;
+using System.Collections.Immutable;
+
+namespace EventLogExpert.Runtime.Tests.TestUtils;
+
+internal static class RetainedViewTestFactory
+{
+    internal static OrderedViewReady? RetainedFor(this LogTableState state, OrderedViewReady view) =>
+        state.RetainedOrderedViews.GetValueOrDefault(TabOf(view));
+
+    internal static ImmutableDictionary<EventLogId, OrderedViewReady> RetainedMap(params OrderedViewReady[] views)
+    {
+        var map = ImmutableDictionary<EventLogId, OrderedViewReady>.Empty;
+
+        foreach (var view in views)
+        {
+            map = map.SetItem(TabOf(view), view);
+        }
+
+        return map;
+    }
+
+    private static EventLogId TabOf(OrderedViewReady view) =>
+        view.Identity?.ActiveLogId ??
+        throw new InvalidOperationException("A retained view must carry the tab it was served for.");
+}
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/Alerts/AlertDialogServiceTests.cs b/tests/Unit/EventLogExpert.UI.Tests/Alerts/AlertDialogServiceTests.cs
similarity index 93%
rename from tests/Unit/EventLogExpert.Runtime.Tests/Alerts/AlertDialogServiceTests.cs
rename to tests/Unit/EventLogExpert.UI.Tests/Alerts/AlertDialogServiceTests.cs
index 71ca4f6f5..f085cd1ee 100644
--- a/tests/Unit/EventLogExpert.Runtime.Tests/Alerts/AlertDialogServiceTests.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/Alerts/AlertDialogServiceTests.cs
@@ -4,17 +4,17 @@
 using EventLogExpert.Runtime.Alerts;
 using EventLogExpert.Runtime.Banner;
 using EventLogExpert.Runtime.Common.Threading;
-using EventLogExpert.Runtime.Modal;
+using EventLogExpert.UI.Alerts;
+using EventLogExpert.UI.Modal;
 using NSubstitute;
 
-namespace EventLogExpert.Runtime.Tests.Alerts;
+namespace EventLogExpert.UI.Tests.Alerts;
 
 public sealed class ModalAlertDialogServiceTests
 {
     [Fact]
     public async Task DisplayPrompt_WhenActiveHost_ShouldRouteInlineAndReturnTypedValue()
     {
-        // Arrange
         var host = Substitute.For<IInlineAlertHost>();
         host.ShowInlineAlertAsync(Arg.Any<InlineAlertRequest>(), Arg.Any<CancellationToken>())
             .Returns(Task.FromResult(new InlineAlertResult(true, "typed-value")));
@@ -34,10 +34,8 @@ public async Task DisplayPrompt_WhenActiveHost_ShouldRouteInlineAndReturnTypedVa
             _ => Task.FromResult(false),
             _ => Task.FromResult(string.Empty));
 
-        // Act
         var result = await sut.DisplayPrompt("Rename", "Enter new name");
 
-        // Assert
         Assert.Equal("typed-value", result);
         await host.Received(1).ShowInlineAlertAsync(
             Arg.Is<InlineAlertRequest>(r => r != null && r.IsPrompt && r.Title == "Rename" && r.Message == "Enter new name"),
@@ -47,7 +45,6 @@ await host.Received(1).ShowInlineAlertAsync(
     [Fact]
     public async Task DisplayPrompt_WhenInlineCancelled_ShouldReturnEmptyString()
     {
-        // Arrange — preserve the existing IsNullOrEmpty-friendly contract on cancel.
         var host = Substitute.For<IInlineAlertHost>();
         host.ShowInlineAlertAsync(Arg.Any<InlineAlertRequest>(), Arg.Any<CancellationToken>())
             .Returns(Task.FromResult(new InlineAlertResult(false, null)));
@@ -67,17 +64,14 @@ public async Task DisplayPrompt_WhenInlineCancelled_ShouldReturnEmptyString()
             _ => Task.FromResult(false),
             _ => Task.FromResult(string.Empty));
 
-        // Act
         var result = await sut.DisplayPrompt("Rename", "Enter new name");
 
-        // Assert
         Assert.Equal(string.Empty, result);
     }
 
     [Fact]
     public async Task DisplayPrompt_WhenNoActiveHost_ShouldCallStandalonePromptOpener()
     {
-        // Arrange
         var coordinator = Substitute.For<IModalCoordinator>();
         coordinator.TryGetInlineAlertHost(out Arg.Any<IInlineAlertHost?>()).Returns(false);
 
@@ -90,10 +84,8 @@ public async Task DisplayPrompt_WhenNoActiveHost_ShouldCallStandalonePromptOpene
             _ => Task.FromResult(false),
             parameters => { capturedPrompt = parameters; return Task.FromResult("user-typed"); });
 
-        // Act
         var result = await sut.DisplayPrompt("Rename", "Enter new name", "old-value");
 
-        // Assert
         Assert.Equal("user-typed", result);
         Assert.NotNull(capturedPrompt);
         Assert.Equal("Rename", capturedPrompt!["Title"]);
@@ -127,7 +119,6 @@ public async Task DisplayPrompt_WhenNoActiveHost_ShouldForwardValidatorToStandal
     [Fact]
     public async Task ShowAlert_ShouldMarshalThroughMainThreadService()
     {
-        // Arrange — capture that MainThread invocation happens before the routing decision runs.
         var coordinator = Substitute.For<IModalCoordinator>();
         coordinator.TryGetInlineAlertHost(out Arg.Any<IInlineAlertHost?>()).Returns(false);
 
@@ -143,17 +134,14 @@ public async Task ShowAlert_ShouldMarshalThroughMainThreadService()
             _ => Task.FromResult(true),
             _ => Task.FromResult(string.Empty));
 
-        // Act
         await sut.ShowAlert("t", "m", "c");
 
-        // Assert
         await mainThread.Received(1).InvokeOnMainThreadAsync(Arg.Any<Func<Task>>());
     }
 
     [Fact]
     public async Task ShowAlertOneButton_BannerPresentation_DoesNotMarshalThroughMainThreadService()
     {
-        // Arrange — banner-routed alerts skip the UI-thread marshal because the banner service is thread-safe.
         var infoBannerService = Substitute.For<IInfoBannerService>();
         var errorBannerService = Substitute.For<IErrorBannerService>();
         var mainThread = Substitute.For<IMainThreadService>();
@@ -166,10 +154,8 @@ public async Task ShowAlertOneButton_BannerPresentation_DoesNotMarshalThroughMai
             _ => Task.FromResult(false),
             _ => Task.FromResult(string.Empty));
 
-        // Act
         await sut.ShowAlert("t", "m", "OK", AlertPresentation.Banner);
 
-        // Assert
         await mainThread.DidNotReceive().InvokeOnMainThreadAsync(Arg.Any<Func<Task>>());
         infoBannerService.Received(1).ReportInfoBanner("t", "m", BannerSeverity.Warning);
         errorBannerService.DidNotReceive().ReportError(
@@ -179,7 +165,6 @@ public async Task ShowAlertOneButton_BannerPresentation_DoesNotMarshalThroughMai
     [Fact]
     public async Task ShowAlertOneButton_BannerPresentation_RoutesToReportInfoBanner_WithWarningSeverity()
     {
-        // Arrange
         var infoBannerService = Substitute.For<IInfoBannerService>();
         var errorBannerService = Substitute.For<IErrorBannerService>();
         var coordinator = Substitute.For<IModalCoordinator>();
@@ -193,10 +178,8 @@ public async Task ShowAlertOneButton_BannerPresentation_RoutesToReportInfoBanner
             _ => { standaloneCalled = true; return Task.FromResult(false); },
             _ => Task.FromResult(string.Empty));
 
-        // Act
         await sut.ShowAlert("Banner Title", "Banner Message", "OK", AlertPresentation.Banner);
 
-        // Assert
         infoBannerService.Received(1).ReportInfoBanner("Banner Title", "Banner Message", BannerSeverity.Warning);
         errorBannerService.DidNotReceive().ReportError(
             Arg.Any<string>(), Arg.Any<string>(), Arg.Any<string?>(), Arg.Any<Func<Task>?>());
@@ -207,7 +190,6 @@ public async Task ShowAlertOneButton_BannerPresentation_RoutesToReportInfoBanner
     [Fact]
     public async Task ShowAlertOneButton_InlineOnlyNoHost_ThrowsInvalidOperationException()
     {
-        // Arrange
         var coordinator = Substitute.For<IModalCoordinator>();
         coordinator.TryGetInlineAlertHost(out Arg.Any<IInlineAlertHost?>()).Returns(false);
 
@@ -219,7 +201,6 @@ public async Task ShowAlertOneButton_InlineOnlyNoHost_ThrowsInvalidOperationExce
             _ => Task.FromResult(false),
             _ => Task.FromResult(string.Empty));
 
-        // Act + Assert
         await Assert.ThrowsAsync<InvalidOperationException>(() =>
             sut.ShowAlert("t", "m", "OK", AlertPresentation.InlineOnly));
     }
@@ -227,7 +208,6 @@ await Assert.ThrowsAsync<InvalidOperationException>(() =>
     [Fact]
     public async Task ShowAlertOneButton_InlineOnlyWithHost_RoutesInline()
     {
-        // Arrange
         var host = Substitute.For<IInlineAlertHost>();
         host.ShowInlineAlertAsync(Arg.Any<InlineAlertRequest>(), Arg.Any<CancellationToken>())
             .Returns(Task.FromResult(new InlineAlertResult(true, null)));
@@ -248,10 +228,8 @@ public async Task ShowAlertOneButton_InlineOnlyWithHost_RoutesInline()
             _ => { standaloneCalled = true; return Task.FromResult(false); },
             _ => Task.FromResult(string.Empty));
 
-        // Act
         await sut.ShowAlert("t", "m", "OK", AlertPresentation.InlineOnly);
 
-        // Assert
         Assert.False(standaloneCalled);
         await host.Received(1).ShowInlineAlertAsync(Arg.Any<InlineAlertRequest>(), Arg.Any<CancellationToken>());
     }
@@ -259,7 +237,6 @@ public async Task ShowAlertOneButton_InlineOnlyWithHost_RoutesInline()
     [Fact]
     public async Task ShowAlertOneButton_PopupOnly_AlwaysOpensStandalone_EvenWithHost()
     {
-        // Arrange
         var host = Substitute.For<IInlineAlertHost>();
         var coordinator = Substitute.For<IModalCoordinator>();
         coordinator.TryGetInlineAlertHost(out Arg.Any<IInlineAlertHost?>()).Returns(call =>
@@ -277,10 +254,8 @@ public async Task ShowAlertOneButton_PopupOnly_AlwaysOpensStandalone_EvenWithHos
             parameters => { capturedAlert = parameters; return Task.FromResult(true); },
             _ => Task.FromResult(string.Empty));
 
-        // Act
         await sut.ShowAlert("t", "m", "Close", AlertPresentation.PopupOnly);
 
-        // Assert
         Assert.NotNull(capturedAlert);
         Assert.Equal("Close", capturedAlert!["CancelLabel"]);
         await host.DidNotReceive().ShowInlineAlertAsync(Arg.Any<InlineAlertRequest>(), Arg.Any<CancellationToken>());
@@ -289,7 +264,6 @@ public async Task ShowAlertOneButton_PopupOnly_AlwaysOpensStandalone_EvenWithHos
     [Fact]
     public async Task ShowAlertOneButton_WhenNoActiveHost_ShouldCallStandaloneOpener()
     {
-        // Arrange
         var coordinator = Substitute.For<IModalCoordinator>();
         coordinator.TryGetInlineAlertHost(out Arg.Any<IInlineAlertHost?>()).Returns(false);
 
@@ -302,10 +276,8 @@ public async Task ShowAlertOneButton_WhenNoActiveHost_ShouldCallStandaloneOpener
             parameters => { capturedAlert = parameters; return Task.FromResult(true); },
             _ => Task.FromResult(string.Empty));
 
-        // Act
         await sut.ShowAlert("My Title", "My Message", "Close");
 
-        // Assert
         Assert.NotNull(capturedAlert);
         Assert.Equal("My Title", capturedAlert!["Title"]);
         Assert.Equal("My Message", capturedAlert["Message"]);
@@ -316,7 +288,6 @@ public async Task ShowAlertOneButton_WhenNoActiveHost_ShouldCallStandaloneOpener
     [Fact]
     public async Task ShowAlertTwoButton_BannerPresentation_ThrowsArgumentException()
     {
-        // Arrange
         var sut = new AlertDialogService(
             Substitute.For<IModalCoordinator>(),
             PassthroughMainThread(),
@@ -325,7 +296,6 @@ public async Task ShowAlertTwoButton_BannerPresentation_ThrowsArgumentException(
             _ => Task.FromResult(false),
             _ => Task.FromResult(string.Empty));
 
-        // Act + Assert — Banner is not valid for accept/cancel pairs.
         var ex = await Assert.ThrowsAsync<ArgumentException>(() =>
             sut.ShowAlert("t", "m", "Yes", "No", AlertPresentation.Banner));
         Assert.Equal("presentation", ex.ParamName);
@@ -334,7 +304,6 @@ public async Task ShowAlertTwoButton_BannerPresentation_ThrowsArgumentException(
     [Fact]
     public async Task ShowAlertTwoButton_InlineOnlyNoHost_ThrowsInvalidOperationException()
     {
-        // Arrange
         var coordinator = Substitute.For<IModalCoordinator>();
         coordinator.TryGetInlineAlertHost(out Arg.Any<IInlineAlertHost?>()).Returns(false);
 
@@ -346,7 +315,6 @@ public async Task ShowAlertTwoButton_InlineOnlyNoHost_ThrowsInvalidOperationExce
             _ => Task.FromResult(false),
             _ => Task.FromResult(string.Empty));
 
-        // Act + Assert
         await Assert.ThrowsAsync<InvalidOperationException>(() =>
             sut.ShowAlert("t", "m", "Yes", "No", AlertPresentation.InlineOnly));
     }
@@ -354,7 +322,6 @@ await Assert.ThrowsAsync<InvalidOperationException>(() =>
     [Fact]
     public async Task ShowAlertTwoButton_PopupOnly_AlwaysOpensStandalone()
     {
-        // Arrange
         var host = Substitute.For<IInlineAlertHost>();
         var coordinator = Substitute.For<IModalCoordinator>();
         coordinator.TryGetInlineAlertHost(out Arg.Any<IInlineAlertHost?>()).Returns(call =>
@@ -372,10 +339,8 @@ public async Task ShowAlertTwoButton_PopupOnly_AlwaysOpensStandalone()
             parameters => { capturedAlert = parameters; return Task.FromResult(true); },
             _ => Task.FromResult(string.Empty));
 
-        // Act
         var result = await sut.ShowAlert("t", "m", "Yes", "No", AlertPresentation.PopupOnly);
 
-        // Assert
         Assert.True(result);
         Assert.NotNull(capturedAlert);
         Assert.Equal("Yes", capturedAlert!["AcceptLabel"]);
@@ -386,7 +351,6 @@ public async Task ShowAlertTwoButton_PopupOnly_AlwaysOpensStandalone()
     [Fact]
     public async Task ShowAlertTwoButton_WhenActiveHost_ShouldRouteToHostInline()
     {
-        // Arrange
         var host = Substitute.For<IInlineAlertHost>();
         host.ShowInlineAlertAsync(Arg.Any<InlineAlertRequest>(), Arg.Any<CancellationToken>())
             .Returns(Task.FromResult(new InlineAlertResult(true, null)));
@@ -407,10 +371,8 @@ public async Task ShowAlertTwoButton_WhenActiveHost_ShouldRouteToHostInline()
             _ => { standaloneCalled = true; return Task.FromResult(false); },
             _ => Task.FromResult(string.Empty));
 
-        // Act
         var result = await sut.ShowAlert("Confirm", "Are you sure?", "Yes", "No");
 
-        // Assert
         Assert.True(result);
         Assert.False(standaloneCalled);
         await host.Received(1).ShowInlineAlertAsync(
@@ -427,7 +389,6 @@ await host.Received(1).ShowInlineAlertAsync(
     [Fact]
     public async Task ShowAlertTwoButton_WhenInlineCancelled_ShouldReturnFalse()
     {
-        // Arrange
         var host = Substitute.For<IInlineAlertHost>();
         host.ShowInlineAlertAsync(Arg.Any<InlineAlertRequest>(), Arg.Any<CancellationToken>())
             .Returns(Task.FromException<InlineAlertResult>(new TaskCanceledException()));
@@ -447,17 +408,14 @@ public async Task ShowAlertTwoButton_WhenInlineCancelled_ShouldReturnFalse()
             _ => Task.FromResult(false),
             _ => Task.FromResult(string.Empty));
 
-        // Act
         var result = await sut.ShowAlert("Confirm", "Sure?", "Yes", "No");
 
-        // Assert
         Assert.False(result);
     }
 
     [Fact]
     public async Task ShowErrorAlert_DoesNotMarshalThroughMainThreadService()
     {
-        // Arrange — error alerts go straight to the thread-safe banner service; no UI marshal needed.
         var errorBannerService = Substitute.For<IErrorBannerService>();
         var infoBannerService = Substitute.For<IInfoBannerService>();
         var mainThread = Substitute.For<IMainThreadService>();
@@ -470,10 +428,8 @@ public async Task ShowErrorAlert_DoesNotMarshalThroughMainThreadService()
             _ => Task.FromResult(false),
             _ => Task.FromResult(string.Empty));
 
-        // Act
         await sut.ShowErrorAlert("t", "m");
 
-        // Assert
         await mainThread.DidNotReceive().InvokeOnMainThreadAsync(Arg.Any<Func<Task>>());
         errorBannerService.Received(1).ReportError("t", "m");
         infoBannerService.DidNotReceive().ReportInfoBanner(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<BannerSeverity>());
@@ -482,7 +438,6 @@ public async Task ShowErrorAlert_DoesNotMarshalThroughMainThreadService()
     [Fact]
     public async Task ShowErrorAlert_RoutesToBannerServiceReportError_WithTitleAndMessage()
     {
-        // Arrange
         var errorBannerService = Substitute.For<IErrorBannerService>();
         var infoBannerService = Substitute.For<IInfoBannerService>();
         var coordinator = Substitute.For<IModalCoordinator>();
@@ -496,10 +451,8 @@ public async Task ShowErrorAlert_RoutesToBannerServiceReportError_WithTitleAndMe
             _ => { standaloneCalled = true; return Task.FromResult(false); },
             _ => Task.FromResult(string.Empty));
 
-        // Act
         await sut.ShowErrorAlert("Error Title", "Error Message");
 
-        // Assert
         errorBannerService.Received(1).ReportError("Error Title", "Error Message");
         infoBannerService.DidNotReceive().ReportInfoBanner(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<BannerSeverity>());
         Assert.False(standaloneCalled);
@@ -509,7 +462,6 @@ public async Task ShowErrorAlert_RoutesToBannerServiceReportError_WithTitleAndMe
     [Fact]
     public async Task ShowErrorAlert_WithActionLabelAndAction_PassesThroughToBannerService()
     {
-        // Arrange
         var errorBannerService = Substitute.For<IErrorBannerService>();
         var infoBannerService = Substitute.For<IInfoBannerService>();
         Func<Task> action = () => Task.CompletedTask;
@@ -522,10 +474,8 @@ public async Task ShowErrorAlert_WithActionLabelAndAction_PassesThroughToBannerS
             _ => Task.FromResult(false),
             _ => Task.FromResult(string.Empty));
 
-        // Act
         await sut.ShowErrorAlert("Error Title", "Error Message", "Resolve", action);
 
-        // Assert
         errorBannerService.Received(1).ReportError("Error Title", "Error Message", "Resolve", action);
         infoBannerService.DidNotReceive().ReportInfoBanner(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<BannerSeverity>());
     }
diff --git a/tests/Unit/EventLogExpert.UI.Tests/Alerts/AlertModalTests.cs b/tests/Unit/EventLogExpert.UI.Tests/Alerts/AlertModalTests.cs
index f6a977bce..eb70cd6f9 100644
--- a/tests/Unit/EventLogExpert.UI.Tests/Alerts/AlertModalTests.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/Alerts/AlertModalTests.cs
@@ -2,10 +2,9 @@
 // // Licensed under the MIT License.
 
 using Bunit;
-using EventLogExpert.Runtime.Modal;
 using EventLogExpert.UI.Alerts;
+using EventLogExpert.UI.Modal;
 using EventLogExpert.UI.Tests.TestUtils;
-using Fluxor;
 using Microsoft.Extensions.DependencyInjection;
 using NSubstitute;
 
@@ -23,8 +22,6 @@ public AlertModalTests()
         Services.AddSingleton(modalService);
         Services.AddSingleton(Substitute.For<IModalCoordinator>());
 
-        Services.AddFluxor(options => options.ScanAssemblies(typeof(AlertModal).Assembly));
-
         JSInterop.Mode = JSRuntimeMode.Loose;
     }
 
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/Alerts/InlineAlertRequestTests.cs b/tests/Unit/EventLogExpert.UI.Tests/Alerts/InlineAlertRequestTests.cs
similarity index 94%
rename from tests/Unit/EventLogExpert.Runtime.Tests/Alerts/InlineAlertRequestTests.cs
rename to tests/Unit/EventLogExpert.UI.Tests/Alerts/InlineAlertRequestTests.cs
index e70c58c6a..d4de8d6e1 100644
--- a/tests/Unit/EventLogExpert.Runtime.Tests/Alerts/InlineAlertRequestTests.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/Alerts/InlineAlertRequestTests.cs
@@ -1,9 +1,9 @@
 // // Copyright (c) Microsoft Corporation.
 // // Licensed under the MIT License.
 
-using EventLogExpert.Runtime.Alerts;
+using EventLogExpert.UI.Alerts;
 
-namespace EventLogExpert.Runtime.Tests.Alerts;
+namespace EventLogExpert.UI.Tests.Alerts;
 
 public sealed class InlineAlertRequestTests
 {
diff --git a/tests/Unit/EventLogExpert.UI.Tests/Alerts/PromptModalTests.cs b/tests/Unit/EventLogExpert.UI.Tests/Alerts/PromptModalTests.cs
index c8c958444..8d00f0262 100644
--- a/tests/Unit/EventLogExpert.UI.Tests/Alerts/PromptModalTests.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/Alerts/PromptModalTests.cs
@@ -2,10 +2,9 @@
 // // Licensed under the MIT License.
 
 using Bunit;
-using EventLogExpert.Runtime.Modal;
 using EventLogExpert.UI.Alerts;
+using EventLogExpert.UI.Modal;
 using EventLogExpert.UI.Tests.TestUtils;
-using Fluxor;
 using Microsoft.Extensions.DependencyInjection;
 using NSubstitute;
 
@@ -24,8 +23,6 @@ public PromptModalTests()
         Services.AddSingleton(_modalService);
         Services.AddSingleton(Substitute.For<IModalCoordinator>());
 
-        Services.AddFluxor(options => options.ScanAssemblies(typeof(PromptModal).Assembly));
-
         JSInterop.Mode = JSRuntimeMode.Loose;
     }
 
diff --git a/tests/Unit/EventLogExpert.UI.Tests/Architecture/UIFluxorBoundaryTests.cs b/tests/Unit/EventLogExpert.UI.Tests/Architecture/UIFluxorBoundaryTests.cs
new file mode 100644
index 000000000..be6a8fe35
--- /dev/null
+++ b/tests/Unit/EventLogExpert.UI.Tests/Architecture/UIFluxorBoundaryTests.cs
@@ -0,0 +1,103 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.UI.Common;
+using EventLogExpert.UI.Dashboard;
+using EventLogExpert.UI.FilterEditor;
+using EventLogExpert.UI.FilterLenses;
+using EventLogExpert.UI.FilterLibrary;
+using EventLogExpert.UI.Layout;
+using EventLogExpert.UI.LogTable;
+using EventLogExpert.UI.Menu;
+using EventLogExpert.UI.Modal;
+using Fluxor;
+using Fluxor.Blazor.Web.Components;
+using System.Reflection;
+using DetailsPaneComponent = EventLogExpert.UI.DetailsPane.DetailsPane;
+using FilterPaneComponent = EventLogExpert.UI.FilterPane.FilterPane;
+using HistogramPaneComponent = EventLogExpert.UI.LogTable.Histogram.HistogramPane;
+using StatusBarComponent = EventLogExpert.UI.StatusBar.StatusBar;
+
+namespace EventLogExpert.UI.Tests.Architecture;
+
+public sealed class UIFluxorBoundaryTests
+{
+    private const BindingFlags DeclaredMembers = BindingFlags.Instance | BindingFlags.Static |
+        BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly;
+
+    // Every concrete modal, discovered by reflection so an omitted modal cannot silently escape the disposal-contract
+    // check below (this is what regressed the DatabaseToolsModal coverage when the modal set was tracked by hand).
+    private static readonly Type[] s_modalTypes = typeof(ModalBase<>).Assembly.GetTypes()
+        .Where(type => type is { IsClass: true, IsAbstract: false } && InheritsModalBase(type))
+        .OrderBy(type => type.Name)
+        .ToArray();
+
+    public static TheoryData<Type> ModalTypes => [.. s_modalTypes];
+
+    public static TheoryData<Type> SourceSurfaceTypes =>
+        [typeof(AppStateComponentBase), typeof(PresentationViewComponentBase), typeof(SourceSubscription), typeof(LensBreadcrumb), typeof(MainContent), typeof(MenuBar), typeof(DetailsPaneComponent), typeof(EmptyStateDashboard), typeof(LogTabBar), typeof(StatusBarComponent), typeof(HistogramPaneComponent), typeof(LogTablePane), typeof(FilterRow), typeof(LibrarySavedTabHeader), typeof(LibraryEntryRow), typeof(FilterLibraryModal), typeof(FilterPaneComponent)];
+
+    [Fact]
+    public void EveryModal_IsCoveredByTheBoundaryEnumeration() =>
+        // Guards the reflection discovery against finding nothing and pins the known modal set; update the count
+        // deliberately when a modal is added or removed (currently the seven built-in modals plus FilterLibraryModal).
+        Assert.Equal(8, s_modalTypes.Length);
+
+    [Theory]
+    [MemberData(nameof(ModalTypes))]
+    public void Modal_IsAsyncDisposableAndNotFluxorComponent(Type modal)
+    {
+        Assert.True(
+            modal.IsAssignableTo(typeof(IAsyncDisposable)),
+            $"{modal.Name} must be IAsyncDisposable so the renderer disposes it through ModalBase's owned contract.");
+        Assert.False(
+            modal.IsAssignableTo(typeof(FluxorComponent)),
+            $"{modal.Name} must not inherit FluxorComponent - the base swap removed that coupling.");
+    }
+
+    [Theory]
+    [MemberData(nameof(SourceSurfaceTypes))]
+    public void SourceSurface_DeclaresNoFluxorStateMembers(Type sourceSurface)
+    {
+        Type[] memberTypes =
+        [
+            .. sourceSurface.GetFields(DeclaredMembers).Select(field => field.FieldType),
+            .. sourceSurface.GetProperties(DeclaredMembers).Select(property => property.PropertyType),
+        ];
+
+        Assert.DoesNotContain(memberTypes, IsFluxorState);
+    }
+
+    [Theory]
+    [MemberData(nameof(SourceSurfaceTypes))]
+    public void SourceSurface_DoesNotImplementActionSubscriber(Type sourceSurface) =>
+        Assert.DoesNotContain(typeof(IActionSubscriber), sourceSurface.GetInterfaces());
+
+    [Theory]
+    [MemberData(nameof(SourceSurfaceTypes))]
+    public void SourceSurface_DoesNotInheritFluxorComponent(Type sourceSurface) =>
+        Assert.False(
+            sourceSurface.IsAssignableTo(typeof(FluxorComponent)),
+            $"{sourceSurface.Name} must not inherit FluxorComponent - it would restore Fluxor's auto-render coupling.");
+
+    private static bool InheritsModalBase(Type type)
+    {
+        for (var current = type.BaseType; current is not null; current = current.BaseType)
+        {
+            if (current.IsGenericType && current.GetGenericTypeDefinition() == typeof(ModalBase<>)) { return true; }
+        }
+
+        return false;
+    }
+
+    private static bool IsFluxorState(Type type)
+    {
+        if (type == typeof(IActionSubscriber)) { return true; }
+
+        if (!type.IsGenericType) { return false; }
+
+        Type definition = type.GetGenericTypeDefinition();
+
+        return definition == typeof(IState<>) || definition == typeof(IStateSelection<,>);
+    }
+}
diff --git a/tests/Unit/EventLogExpert.UI.Tests/Banner/BannerCycleStateServiceTests.cs b/tests/Unit/EventLogExpert.UI.Tests/Banner/BannerCycleStateServiceTests.cs
index 2ad88a2c9..83aba160a 100644
--- a/tests/Unit/EventLogExpert.UI.Tests/Banner/BannerCycleStateServiceTests.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/Banner/BannerCycleStateServiceTests.cs
@@ -4,9 +4,9 @@
 using EventLogExpert.Runtime.Banner;
 using EventLogExpert.Runtime.Database;
 using EventLogExpert.Runtime.Database.Upgrade;
-using EventLogExpert.Runtime.Modal;
 using EventLogExpert.UI.Banner;
 using EventLogExpert.UI.DatabaseTools;
+using EventLogExpert.UI.Modal;
 using NSubstitute;
 
 namespace EventLogExpert.UI.Tests.Banner;
@@ -96,17 +96,13 @@ public void ExportProgress_PriorityStolenSelection_NotClearedByUnrelatedRebuild(
         _infos.InfoBanners.Returns([info0, info1]);
         var service = CreateService();
 
-        // Two infos give a navigable cycle; select the second so it becomes the user-preferred item.
         service.MoveNext();
         Assert.Equal(info1.Id, service.SelectedItem?.EntryId);
 
-        // Export arrives and outranks Info, so it priority-steals the selection.
         _exportProgress.CurrentExport.Returns(MakeExport());
         _exportProgress.StateChanged += Raise.Event<Action>();
         Assert.Equal(BannerView.ExportProgress, service.SelectedItem?.View);
 
-        // An unrelated rebuild must keep the priority-stolen export selected: export is still in the
-        // source fingerprint, so it is neither re-stolen nor cleared back to the user-preferred info.
         _infos.InfoBanners.Returns([info0, info1, MakeInfo()]);
         _infos.StateChanged += Raise.Event<Action>();
         Assert.Equal(BannerView.ExportProgress, service.SelectedItem?.View);
@@ -140,8 +136,6 @@ public void Modal_Open_RemovesAttention_AndModal_Close_RestoresAttentionSelectio
         _attention.AttentionEntries.Returns([MakeAttention("db1.db")]);
 
         var service = CreateService();
-        // Construction yields a single-item cycle; MoveNext is a no-op there. Add an Error to give
-        // a 2-item cycle so we can navigate and set _userPreferredItem.
         _errors.ErrorBanners.Returns([MakeError()]);
         _errors.StateChanged += Raise.Event<Action>();
         Assert.Equal(2, service.Items.Count);
@@ -184,7 +178,6 @@ public void ModalSuppression_PreservesUserPreferredAttention_DoesNotTriggerPrior
         _modalCoordinator.StateChanged += Raise.Event<Action>();
         Assert.Equal(BannerView.Attention, service.SelectedItem?.View);
 
-        // Trigger an unrelated rebuild — Attention must STAY selected (no stale priority steal).
         _infos.InfoBanners.Returns([MakeInfo()]);
         _infos.StateChanged += Raise.Event<Action>();
         Assert.Equal(BannerView.Attention, service.SelectedItem?.View);
@@ -264,7 +257,6 @@ public void MultipleNewItems_HighestPriorityWins()
         _errors.ErrorBanners.Returns([MakeError()]);
         _critical.StateChanged += Raise.Event<Action>();
 
-        // Critical present → BannerViewSelector returns ONLY Critical (exclusive).
         Assert.Equal(BannerView.Critical, service.SelectedItem?.View);
     }
 
@@ -346,8 +338,6 @@ public void PriorityOverride_DoesNotFireOnProgressTickOfExistingBatch()
         var service = CreateService();
         Assert.Equal(BannerView.Attention, service.SelectedItem?.View);
 
-        // Progress tick on the same background batch — fingerprint key (UpgradeProgress, null)
-        // unchanged, so NOT newly-arrived → selection stays.
         _progress.BackgroundProgress.Returns(MakeProgress());
         _progress.StateChanged += Raise.Event<Action>();
 
@@ -370,7 +360,6 @@ public void PriorityOverride_HoldsAgainstStaleUserPreferredItem()
         _critical.StateChanged += Raise.Event<Action>();
         Assert.Equal(BannerView.Critical, service.SelectedItem?.View);
 
-        // Unrelated rebuild — must NOT bounce to info2.
         _critical.StateChanged += Raise.Event<Action>();
         Assert.Equal(BannerView.Critical, service.SelectedItem?.View);
     }
@@ -516,9 +505,6 @@ public void SetModalContentDisplayed_True_TogglesFlag_FiresStateChangedOnce()
     [Fact]
     public void UserExplicitMoveAfterPriorityOverride_ClearsPriorityStolenMarker_AllowsRestoreAfterSuppression()
     {
-        // Uses Error (non-exclusive — stays in the cycle) as the stealer so the user-ack clear is
-        // actually exercised; Critical is exclusive and self-clears from the fingerprint, making
-        // the user-ack code path a no-op for that view.
         _attention.AttentionEntries.Returns([MakeAttention("db1.db")]);
         _infos.InfoBanners.Returns([MakeInfo()]);
         var service = CreateService();
@@ -553,8 +539,6 @@ public void UserPreferredItem_NotUpdatedByRebuild_OnlyByExplicitMove()
 
         _infos.StateChanged += Raise.Event<Action>();
 
-        // Remove info1: if the passive tick had implicitly recorded a preference for info1, the
-        // subsequent rebuild would still land on info2 via clamp — confirming no preference was set.
         _infos.InfoBanners.Returns([info2]);
         _infos.StateChanged += Raise.Event<Action>();
         Assert.Equal(info2.Id, service.SelectedItem?.EntryId);
@@ -574,7 +558,6 @@ public void UserPreferredItem_RemovedFromSource_ClearedFromPreferred()
         _infos.StateChanged += Raise.Event<Action>();
         Assert.Equal(info1.Id, service.SelectedItem?.EntryId);
 
-        // Re-add info2 — should NOT snap back via stale preference.
         _infos.InfoBanners.Returns([info1, info2]);
         _infos.StateChanged += Raise.Event<Action>();
         Assert.Equal(info1.Id, service.SelectedItem?.EntryId);
diff --git a/tests/Unit/EventLogExpert.UI.Tests/Banner/BannerHostTests.cs b/tests/Unit/EventLogExpert.UI.Tests/Banner/BannerHostTests.cs
index 3ea2ac21f..4b437a6cc 100644
--- a/tests/Unit/EventLogExpert.UI.Tests/Banner/BannerHostTests.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/Banner/BannerHostTests.cs
@@ -8,9 +8,9 @@
 using EventLogExpert.Runtime.Common.Restart;
 using EventLogExpert.Runtime.Database;
 using EventLogExpert.Runtime.Menu;
-using EventLogExpert.Runtime.Modal;
 using EventLogExpert.UI.Banner;
 using EventLogExpert.UI.DatabaseTools;
+using EventLogExpert.UI.Modal;
 using EventLogExpert.UI.Tests.TestUtils;
 using Microsoft.AspNetCore.Components.Web;
 using Microsoft.Extensions.DependencyInjection;
@@ -70,7 +70,6 @@ public void BannerHost_AttentionDismissed_DoesNotRenderAttentionBanner()
     [Fact]
     public void BannerHost_CriticalActive_DoesNotRenderCycleNav_EvenWithOtherSlices()
     {
-        // Critical pre-empts the entire cycle — no Prev/Next chevrons should appear.
         _criticalErrorService.CurrentCritical.Returns(new InvalidOperationException("kaboom"));
         _errorBannerService.ErrorBanners.Returns(
             [new ErrorBannerEntry(BannerId.Create(), "E", "m", null, null, DateTime.UtcNow)]);
@@ -164,7 +163,6 @@ public async Task BannerHost_CycleNextAtLast_DisabledAndDoesNotAdvance()
         _attentionBannerService.AttentionEntries.Returns([BuildDatabaseEntry("a.db")]);
 
         var component = Render<BannerHost>();
-        // Advance to last item (index 1).
         await component.Find("button.banner-cycle-next").ClickAsync(new MouseEventArgs());
 
         var next = component.Find("button.banner-cycle-next");
@@ -172,7 +170,6 @@ public async Task BannerHost_CycleNextAtLast_DisabledAndDoesNotAdvance()
 
         await next.ClickAsync(new MouseEventArgs());
 
-        // Index stays at 1.
         Assert.Equal("2 of 2", component.Find(".banner-pagination").TextContent.Trim());
         Assert.Single(component.FindAll("aside.banner-attention"));
     }
@@ -206,7 +203,6 @@ public async Task BannerHost_CyclePrevAtFirst_DisabledAndDoesNotAdvance()
 
         await prev.ClickAsync(new MouseEventArgs());
 
-        // Index stays at 0 — first error still rendered.
         Assert.Equal("1 of 2", component.Find(".banner-pagination").TextContent.Trim());
         Assert.Single(component.FindAll("aside.banner-error"));
     }
@@ -214,23 +210,16 @@ public async Task BannerHost_CyclePrevAtFirst_DisabledAndDoesNotAdvance()
     [Fact]
     public async Task BannerHost_CycleStableSelection_DismissingPrecedingError_StaysOnSameLogicalError()
     {
-        // Regression: an earlier design matched selection by (View, IndexWithinSlice) record equality, which
-        // silently jumped the user to a different error whenever a preceding error was dismissed (e.g., user on
-        // E1 = index 1, then E0 dismissed → new (Error, 1) refers to E2 → user is now reading E2 without any
-        // intent to navigate). BannerCycleItem.EntryId provides stable identity so the user stays on E1.
         var e0 = new ErrorBannerEntry(BannerId.Create(), "First", "first message", null, null, DateTime.UtcNow);
         var e1 = new ErrorBannerEntry(BannerId.Create(), "Second", "second message", null, null, DateTime.UtcNow);
         var e2 = new ErrorBannerEntry(BannerId.Create(), "Third", "third message", null, null, DateTime.UtcNow);
         _errorBannerService.ErrorBanners.Returns([e0, e1, e2]);
 
         var component = Render<BannerHost>();
-        // Advance to e1.
         await component.Find("button.banner-cycle-next").ClickAsync(new MouseEventArgs());
         Assert.Contains("Second: second message", component.Find("aside.banner-error").TextContent);
         Assert.Equal("2 of 3", component.Find(".banner-pagination").TextContent.Trim());
 
-        // Simulate e0 being dismissed externally — IndexWithinSlice for e1/e2 shifts down by one, but EntryId
-        // stays stable so selection-by-EntryId still resolves to e1.
         _errorBannerService.ErrorBanners.Returns([e1, e2]);
         _errorBannerService.StateChanged += Raise.Event<Action>();
 
@@ -240,8 +229,6 @@ public async Task BannerHost_CycleStableSelection_DismissingPrecedingError_Stays
             return pages.Count > 0 && pages[0].TextContent.Trim() == "1 of 2";
         });
 
-        // After rebuild, the user must still see e1 (now at index 0). The bug being prevented: jumping to e2
-        // because the old (Error, 1) tuple matched e2's new (Error, 1) position.
         Assert.Contains("Second: second message", component.Find("aside.banner-error").TextContent);
         Assert.DoesNotContain("Third", component.Find("aside.banner-error").TextContent);
     }
@@ -323,7 +310,6 @@ public async Task BannerHost_OpenDatabasesReturnsFalse_RendersNewErrorBanner_Not
         Assert.Single(component.FindAll("aside.banner-attention"));
 
         await component.Find("aside.banner-attention button.banner-action").ClickAsync(new MouseEventArgs());
-        // Substitute does not raise StateChanged from ReportError; raise manually to trigger re-render.
         _errorBannerService.StateChanged += Raise.Event<Action>();
 
         component.WaitForState(() => component.FindAll("aside.banner-error").Count > 0);
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/Banner/BannerViewSelectorTests.cs b/tests/Unit/EventLogExpert.UI.Tests/Banner/BannerViewSelectorTests.cs
similarity index 96%
rename from tests/Unit/EventLogExpert.Runtime.Tests/Banner/BannerViewSelectorTests.cs
rename to tests/Unit/EventLogExpert.UI.Tests/Banner/BannerViewSelectorTests.cs
index 0d13eb6b7..787171c60 100644
--- a/tests/Unit/EventLogExpert.Runtime.Tests/Banner/BannerViewSelectorTests.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/Banner/BannerViewSelectorTests.cs
@@ -4,8 +4,9 @@
 using EventLogExpert.Runtime.Banner;
 using EventLogExpert.Runtime.Database;
 using EventLogExpert.Runtime.Database.Upgrade;
+using EventLogExpert.UI.Banner;
 
-namespace EventLogExpert.Runtime.Tests.Banner;
+namespace EventLogExpert.UI.Tests.Banner;
 
 public sealed class BannerViewSelectorTests
 {
@@ -14,7 +15,6 @@ public sealed class BannerViewSelectorTests
     [Fact]
     public void BuildCycle_AllEmpty_ReturnsEmpty()
     {
-        // Act
         IReadOnlyList<BannerCycleItem> result = BannerViewSelector
             .BuildCycle(currentCritical: null,
                 errorBanners: [],
@@ -25,21 +25,18 @@ public void BuildCycle_AllEmpty_ReturnsEmpty()
                 exportProgress: null,
                 infoBanners: []);
 
-        // Assert
         Assert.Empty(result);
     }
 
     [Fact]
     public void BuildCycle_AllSlicesActive_OrdersErrorsThenAttentionThenUpgradeProgressThenInfos()
     {
-        // Arrange
         ErrorBannerEntry e0 = BuildError();
         ErrorBannerEntry e1 = BuildError();
         BannerInfoEntry i0 = BuildInfo();
         BannerInfoEntry i1 = BuildInfo();
         BannerInfoEntry i2 = BuildInfo();
 
-        // Act
         IReadOnlyList<BannerCycleItem> result = BannerViewSelector
             .BuildCycle(currentCritical: null,
                 errorBanners: [e0, e1],
@@ -50,7 +47,6 @@ public void BuildCycle_AllSlicesActive_OrdersErrorsThenAttentionThenUpgradeProgr
                 exportProgress: null,
                 infoBanners: [i0, i1, i2]);
 
-        // Assert
         Assert.Equal(7, result.Count);
         Assert.Equal(new BannerCycleItem(BannerView.Error, 0, e0.Id), result[0]);
         Assert.Equal(new BannerCycleItem(BannerView.Error, 1, e1.Id), result[1]);
@@ -64,7 +60,6 @@ public void BuildCycle_AllSlicesActive_OrdersErrorsThenAttentionThenUpgradeProgr
     [Fact]
     public void BuildCycle_AttentionDismissed_AttentionExcluded()
     {
-        // Act
         IReadOnlyList<BannerCycleItem> result = BannerViewSelector
             .BuildCycle(currentCritical: null,
                 errorBanners: [],
@@ -75,7 +70,6 @@ public void BuildCycle_AttentionDismissed_AttentionExcluded()
                 exportProgress: null,
                 infoBanners: []);
 
-        // Assert
         Assert.Empty(result);
     }
 
@@ -113,7 +107,6 @@ public void BuildCycle_AttentionDismissedOrSuppressed_OmitsAttention(
     [Fact]
     public void BuildCycle_AttentionEntriesEmpty_AttentionExcluded_RegardlessOfDismissedFlag()
     {
-        // Act
         IReadOnlyList<BannerCycleItem> result = BannerViewSelector
             .BuildCycle(currentCritical: null,
                 errorBanners: [],
@@ -124,14 +117,12 @@ public void BuildCycle_AttentionEntriesEmpty_AttentionExcluded_RegardlessOfDismi
                 exportProgress: null,
                 infoBanners: []);
 
-        // Assert
         Assert.Empty(result);
     }
 
     [Fact]
     public void BuildCycle_AttentionEntriesNull_Throws()
     {
-        // Act + Assert
         Assert.Throws<ArgumentNullException>(() => BannerViewSelector
             .BuildCycle(currentCritical: null,
                 errorBanners: [],
@@ -184,7 +175,6 @@ public void BuildCycle_AttentionSuppressedByModalContext_OmitsAttentionSlice()
     [Fact]
     public void BuildCycle_CriticalPresent_ReturnsSingleCriticalItem_RegardlessOfOtherSlices()
     {
-        // Act
         IReadOnlyList<BannerCycleItem> result = BannerViewSelector
             .BuildCycle(currentCritical: new InvalidOperationException("boom"),
                 errorBanners: [BuildError(), BuildError()],
@@ -195,7 +185,6 @@ public void BuildCycle_CriticalPresent_ReturnsSingleCriticalItem_RegardlessOfOth
                 exportProgress: null,
                 infoBanners: [BuildInfo()]);
 
-        // Assert
         Assert.Single(result);
         Assert.Equal(BannerView.Critical, result[0].View);
         Assert.Equal(0, result[0].IndexWithinSlice);
@@ -205,7 +194,6 @@ public void BuildCycle_CriticalPresent_ReturnsSingleCriticalItem_RegardlessOfOth
     [Fact]
     public void BuildCycle_ErrorBannersNull_Throws()
     {
-        // Act + Assert
         Assert.Throws<ArgumentNullException>(() => BannerViewSelector
             .BuildCycle(currentCritical: null,
                 errorBanners: null!,
@@ -220,7 +208,6 @@ public void BuildCycle_ErrorBannersNull_Throws()
     [Fact]
     public void BuildCycle_InfoBannersNull_Throws()
     {
-        // Act + Assert
         Assert.Throws<ArgumentNullException>(() => BannerViewSelector
             .BuildCycle(currentCritical: null,
                 errorBanners: [],
@@ -235,7 +222,6 @@ public void BuildCycle_InfoBannersNull_Throws()
     [Fact]
     public void BuildCycle_OnlyAttention_ReturnsSingleAttentionItem()
     {
-        // Act
         IReadOnlyList<BannerCycleItem> result = BannerViewSelector
             .BuildCycle(currentCritical: null,
                 errorBanners: [],
@@ -246,7 +232,6 @@ public void BuildCycle_OnlyAttention_ReturnsSingleAttentionItem()
                 exportProgress: null,
                 infoBanners: []);
 
-        // Assert
         Assert.Single(result);
         Assert.Equal(new BannerCycleItem(BannerView.Attention, 0, null), result[0]);
     }
@@ -254,12 +239,10 @@ public void BuildCycle_OnlyAttention_ReturnsSingleAttentionItem()
     [Fact]
     public void BuildCycle_OnlyErrors_OneItemPerError_StableOrder()
     {
-        // Arrange
         ErrorBannerEntry e0 = BuildError();
         ErrorBannerEntry e1 = BuildError();
         ErrorBannerEntry e2 = BuildError();
 
-        // Act
         IReadOnlyList<BannerCycleItem> result = BannerViewSelector
             .BuildCycle(currentCritical: null,
                 errorBanners: [e0, e1, e2],
@@ -270,7 +253,6 @@ public void BuildCycle_OnlyErrors_OneItemPerError_StableOrder()
                 exportProgress: null,
                 infoBanners: []);
 
-        // Assert
         Assert.Equal(3, result.Count);
         Assert.Equal(new BannerCycleItem(BannerView.Error, 0, e0.Id), result[0]);
         Assert.Equal(new BannerCycleItem(BannerView.Error, 1, e1.Id), result[1]);
@@ -280,7 +262,6 @@ public void BuildCycle_OnlyErrors_OneItemPerError_StableOrder()
     [Fact]
     public void BuildCycle_OnlyExportProgress_ReturnsSingleExportProgressItem()
     {
-        // Act
         IReadOnlyList<BannerCycleItem> result = BannerViewSelector
             .BuildCycle(currentCritical: null,
                 errorBanners: [],
@@ -291,7 +272,6 @@ public void BuildCycle_OnlyExportProgress_ReturnsSingleExportProgressItem()
                 exportProgress: BuildExportProgress(),
                 infoBanners: []);
 
-        // Assert
         Assert.Single(result);
         Assert.Equal(new BannerCycleItem(BannerView.ExportProgress, 0, null), result[0]);
     }
@@ -299,11 +279,9 @@ public void BuildCycle_OnlyExportProgress_ReturnsSingleExportProgressItem()
     [Fact]
     public void BuildCycle_OnlyInfos_OneItemPerInfo_StableOrder()
     {
-        // Arrange
         BannerInfoEntry i0 = BuildInfo();
         BannerInfoEntry i1 = BuildInfo();
 
-        // Act
         IReadOnlyList<BannerCycleItem> result = BannerViewSelector
             .BuildCycle(currentCritical: null,
                 errorBanners: [],
@@ -314,7 +292,6 @@ public void BuildCycle_OnlyInfos_OneItemPerInfo_StableOrder()
                 exportProgress: null,
                 infoBanners: [i0, i1]);
 
-        // Assert
         Assert.Equal(2, result.Count);
         Assert.Equal(new BannerCycleItem(BannerView.Info, 0, i0.Id), result[0]);
         Assert.Equal(new BannerCycleItem(BannerView.Info, 1, i1.Id), result[1]);
@@ -323,7 +300,6 @@ public void BuildCycle_OnlyInfos_OneItemPerInfo_StableOrder()
     [Fact]
     public void BuildCycle_OnlyUpgradeProgress_ReturnsSingleUpgradeProgressItem()
     {
-        // Act
         IReadOnlyList<BannerCycleItem> result = BannerViewSelector
             .BuildCycle(currentCritical: null,
                 errorBanners: [],
@@ -334,7 +310,6 @@ public void BuildCycle_OnlyUpgradeProgress_ReturnsSingleUpgradeProgressItem()
                 exportProgress: null,
                 infoBanners: []);
 
-        // Assert
         Assert.Single(result);
         Assert.Equal(new BannerCycleItem(BannerView.UpgradeProgress, 0, null), result[0]);
     }
@@ -342,12 +317,10 @@ public void BuildCycle_OnlyUpgradeProgress_ReturnsSingleUpgradeProgressItem()
     [Fact]
     public void BuildCycle_RebuildAfterErrorDismissed_PreservesEntryIdOnSurvivingError()
     {
-        // Arrange
         ErrorBannerEntry e0 = BuildError();
         ErrorBannerEntry e1 = BuildError();
         ErrorBannerEntry e2 = BuildError();
 
-        // Act
         IReadOnlyList<BannerCycleItem> before = BannerViewSelector
             .BuildCycle(currentCritical: null,
                 errorBanners: [e0, e1, e2],
@@ -368,7 +341,6 @@ public void BuildCycle_RebuildAfterErrorDismissed_PreservesEntryIdOnSurvivingErr
                 exportProgress: null,
                 infoBanners: []);
 
-        // Assert
         Assert.Equal(3, before.Count);
         Assert.Equal(2, after.Count);
         Assert.Equal(new BannerCycleItem(BannerView.Error, 0, e1.Id), after[0]);
@@ -378,10 +350,8 @@ public void BuildCycle_RebuildAfterErrorDismissed_PreservesEntryIdOnSurvivingErr
     [Fact]
     public void BuildCycle_UpgradeAndExportProgress_OrdersUpgradeBeforeExportBeforeInfos()
     {
-        // Arrange
         BannerInfoEntry info = BuildInfo();
 
-        // Act
         IReadOnlyList<BannerCycleItem> result = BannerViewSelector
             .BuildCycle(currentCritical: null,
                 errorBanners: [],
@@ -392,7 +362,6 @@ public void BuildCycle_UpgradeAndExportProgress_OrdersUpgradeBeforeExportBeforeI
                 exportProgress: BuildExportProgress(),
                 infoBanners: [info]);
 
-        // Assert
         Assert.Equal(3, result.Count);
         Assert.Equal(new BannerCycleItem(BannerView.UpgradeProgress, 0, null), result[0]);
         Assert.Equal(new BannerCycleItem(BannerView.ExportProgress, 0, null), result[1]);
diff --git a/tests/Unit/EventLogExpert.UI.Tests/Common/SourceSubscriptionTests.cs b/tests/Unit/EventLogExpert.UI.Tests/Common/SourceSubscriptionTests.cs
new file mode 100644
index 000000000..db972d239
--- /dev/null
+++ b/tests/Unit/EventLogExpert.UI.Tests/Common/SourceSubscriptionTests.cs
@@ -0,0 +1,70 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.UI.Common;
+
+namespace EventLogExpert.UI.Tests.Common;
+
+public sealed class SourceSubscriptionTests
+{
+    [Fact]
+    public void Changed_AfterDispose_DoesNotRender()
+    {
+        Action? handler = null;
+        var renders = 0;
+        var subscription = new SourceSubscription(
+            subscribe: h => handler = h,
+            unsubscribe: _ => { },
+            render: () => { renders++; return Task.CompletedTask; });
+        subscription.Dispose();
+
+        handler!();
+
+        Assert.Equal(0, renders);
+    }
+
+    [Fact]
+    public void Changed_RendersOncePerRaise()
+    {
+        Action? handler = null;
+        var renders = 0;
+        using var subscription = new SourceSubscription(
+            subscribe: h => handler = h,
+            unsubscribe: _ => { },
+            render: () => { renders++; return Task.CompletedTask; });
+
+        handler!();
+
+        Assert.Equal(1, renders);
+    }
+
+    [Fact]
+    public void Dispose_IsIdempotent()
+    {
+        var unsubscribes = 0;
+        var subscription = new SourceSubscription(
+            subscribe: _ => { },
+            unsubscribe: _ => unsubscribes++,
+            render: () => Task.CompletedTask);
+
+        subscription.Dispose();
+        subscription.Dispose();
+
+        Assert.Equal(1, unsubscribes);
+    }
+
+    [Fact]
+    public void Dispose_Unsubscribes()
+    {
+        var subscribed = false;
+        var subscription = new SourceSubscription(
+            subscribe: _ => subscribed = true,
+            unsubscribe: _ => subscribed = false,
+            render: () => Task.CompletedTask);
+        Assert.True(subscribed);
+
+        subscription.Dispose();
+
+        Assert.False(subscribed);
+    }
+}
diff --git a/tests/Unit/EventLogExpert.UI.Tests/Dashboard/EmptyStateDashboardTests.cs b/tests/Unit/EventLogExpert.UI.Tests/Dashboard/EmptyStateDashboardTests.cs
index 6de254fa5..98ef7977c 100644
--- a/tests/Unit/EventLogExpert.UI.Tests/Dashboard/EmptyStateDashboardTests.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/Dashboard/EmptyStateDashboardTests.cs
@@ -15,7 +15,6 @@
 using EventLogExpert.Runtime.Scenarios.Favorites;
 using EventLogExpert.Scenarios.Catalog;
 using EventLogExpert.UI.Dashboard;
-using Fluxor;
 using Microsoft.Extensions.DependencyInjection;
 using NSubstitute;
 using System.Collections.Immutable;
@@ -36,11 +35,8 @@ public sealed class EmptyStateDashboardTests : BunitContext
     private readonly IChannelEnableService _channelEnable = Substitute.For<IChannelEnableService>();
     private readonly IChannelReadinessService _channelReadinessService = Substitute.For<IChannelReadinessService>();
     private readonly IScenarioFavoriteCommands _favoriteCommands = Substitute.For<IScenarioFavoriteCommands>();
-    private readonly IState<ScenarioFavoritesState> _favorites = Substitute.For<IState<ScenarioFavoritesState>>();
-    private readonly IStateSelection<ScenarioFavoritesState, ImmutableHashSet<string>> _favoritesSelection =
-        Substitute.For<IStateSelection<ScenarioFavoritesState, ImmutableHashSet<string>>>();
-
-    private readonly IStateSelection<EventLogState, bool> _filterApplied = Substitute.For<IStateSelection<EventLogState, bool>>();
+    private readonly IScenarioFavoritesSource _favoritesSource = Substitute.For<IScenarioFavoritesSource>();
+    private readonly IFilterAppliedSource _filterAppliedSource = Substitute.For<IFilterAppliedSource>();
     private readonly IFilterPaneCommands _filterCommands = Substitute.For<IFilterPaneCommands>();
     private readonly IScenarioLaunchService _scenarioLaunch = Substitute.For<IScenarioLaunchService>();
     private readonly IScenarioQueryService _scenarioQuery = Substitute.For<IScenarioQueryService>();
@@ -58,22 +54,19 @@ public EmptyStateDashboardTests()
                     Access = ChannelAccess.Accessible
                 }
             ]);
-        _favorites.Value.Returns(new ScenarioFavoritesState());
-        _favoritesSelection.Value.Returns(ImmutableHashSet<string>.Empty);
+        _favoritesSource.FavoriteScenarioIds.Returns(ImmutableHashSet<string>.Empty);
 
         Services.AddSingleton(_actions);
         Services.AddSingleton(_alertDialog);
         Services.AddSingleton(_announcer);
         Services.AddSingleton(_favoriteCommands);
-        Services.AddSingleton(_favorites);
-        Services.AddSingleton(_favoritesSelection);
-        Services.AddSingleton(_filterApplied);
+        Services.AddSingleton(_favoritesSource);
+        Services.AddSingleton(_filterAppliedSource);
         Services.AddSingleton(_filterCommands);
         Services.AddSingleton(_scenarioLaunch);
         Services.AddSingleton(_scenarioQuery);
         Services.AddSingleton(_channelReadinessService);
         Services.AddSingleton(_channelEnable);
-        Services.AddFluxor(options => options.ScanAssemblies(typeof(EmptyStateDashboard).Assembly));
         JSInterop.Mode = JSRuntimeMode.Loose;
     }
 
@@ -99,10 +92,27 @@ public void Catalog_WhenScenariosLoading_ShowsLoading()
         gate.Set();
     }
 
+    [Fact]
+    public void Chip_TogglesReactively_WhenFilterAppliedSourceRaisesChanged()
+    {
+        _filterAppliedSource.IsFilteringEnabled.Returns(false);
+
+        var cut = Render<EmptyStateDashboard>();
+        Assert.Empty(cut.FindAll(".empty-dashboard__chip"));
+
+        _filterAppliedSource.IsFilteringEnabled.Returns(true);
+        cut.InvokeAsync(() => _filterAppliedSource.Changed += Raise.Event<Action>());
+        cut.WaitForAssertion(() => Assert.Single(cut.FindAll(".empty-dashboard__chip")));
+
+        _filterAppliedSource.IsFilteringEnabled.Returns(false);
+        cut.InvokeAsync(() => _filterAppliedSource.Changed += Raise.Event<Action>());
+        cut.WaitForAssertion(() => Assert.Empty(cut.FindAll(".empty-dashboard__chip")));
+    }
+
     [Fact]
     public void Chip_WhenFilterApplied_ClearInvokesClearAllFilters()
     {
-        _filterApplied.Value.Returns(true);
+        _filterAppliedSource.IsFilteringEnabled.Returns(true);
 
         var cut = Render<EmptyStateDashboard>();
         cut.Find(".empty-dashboard__chip button").Click();
@@ -113,7 +123,7 @@ public void Chip_WhenFilterApplied_ClearInvokesClearAllFilters()
     [Fact]
     public void Chip_WhenNoFilterApplied_NotRendered()
     {
-        _filterApplied.Value.Returns(false);
+        _filterAppliedSource.IsFilteringEnabled.Returns(false);
 
         var cut = Render<EmptyStateDashboard>();
 
@@ -387,6 +397,15 @@ public void DetailStar_TogglesFavorite()
             _favoriteCommands.Received(1).SetFavorite("application-crashes", "Application crashes", true));
     }
 
+    [Fact]
+    public async Task DisposeAsync_CalledTwice_DoesNotThrow()
+    {
+        var cut = Render<EmptyStateDashboard>();
+
+        await cut.Instance.DisposeAsync();
+        await cut.Instance.DisposeAsync();
+    }
+
     [Fact]
     public void EnableChannel_WhenConfirmCancelled_DoesNotInvokeService()
     {
@@ -447,12 +466,26 @@ public void Favoriting_ReactivelyAddsFavoritesTab()
         cut.WaitForAssertion(() => Assert.NotEmpty(cut.FindAll("[role='tab']")));
         Assert.DoesNotContain("Favorites", TabLabels(cut));
 
-        _favorites.Value.Returns(new ScenarioFavoritesState { FavoriteScenarioIds = ["application-crashes"] });
-        RaiseFavoritesChanged(cut, "application-crashes");
+        _favoritesSource.FavoriteScenarioIds.Returns(ImmutableHashSet.Create("application-crashes"));
+        RaiseFavoritesChanged(cut);
 
         cut.WaitForAssertion(() => Assert.Contains("Favorites", TabLabels(cut)));
     }
 
+    [Fact]
+    public void Favoriting_ReactivelyFillsTheActiveDetailStar()
+    {
+        _scenarioQuery.GetSplashScenarios().Returns([Scenario("application-crashes", "Application crashes")]);
+
+        var cut = Render<EmptyStateDashboard>();
+        cut.WaitForAssertion(() => Assert.Equal("false", cut.Find(ActiveDetailStar).GetAttribute("aria-pressed")));
+
+        _favoritesSource.FavoriteScenarioIds.Returns(ImmutableHashSet.Create("application-crashes"));
+        RaiseFavoritesChanged(cut);
+
+        cut.WaitForAssertion(() => Assert.Equal("true", cut.Find(ActiveDetailStar).GetAttribute("aria-pressed")));
+    }
+
     [Fact]
     public void FolderScan_WhenCancelClicked_CancelsTokenAndShowsCancellingWithoutDialog()
     {
@@ -484,7 +517,6 @@ public void FolderScan_WhenCancelClicked_CancelsTokenAndShowsCancellingWithoutDi
         });
         Assert.True(captured.IsCancellationRequested);
 
-        // The service ultimately reports Cancelled; no result dialog is shown for a user cancellation.
         release.SetResult(ScenarioFolderLaunchResult.Cancelled);
         cut.WaitForAssertion(() => Assert.Empty(cut.FindAll(".empty-dashboard__chip--scanning")));
         _alertDialog.DidNotReceive().ShowAlert(Arg.Any<string>(), Arg.Any<string>(), Arg.Any<string>());
@@ -494,9 +526,6 @@ public void FolderScan_WhenCancelClicked_CancelsTokenAndShowsCancellingWithoutDi
     [Fact]
     public async Task FolderScan_WhenLaunchedFromReactiveBannerRetry_GuardsScanAndReenablesButtons()
     {
-        // A live launch that cannot open its channels raises a banner whose retry opens from a folder. That retry runs
-        // outside the dashboard's event loop, so it must route through RunGuardedAsync (setting _isBusy while the scan
-        // runs) AND RunGuardedAsync must render on completion to re-enable the busy-gated controls.
         _scenarioLaunch.LaunchAsync(Arg.Any<ScenarioDefinition>(), Arg.Any<DateFilter?>(), Arg.Any<bool>())
             .Returns(new ScenarioLaunchResult(0, 0, 1)
             {
@@ -518,7 +547,6 @@ public async Task FolderScan_WhenLaunchedFromReactiveBannerRetry_GuardsScanAndRe
             .LaunchFromFolderAsync(Arg.Any<ScenarioDefinition>(), Arg.Any<DateFilter?>(), Arg.Any<CancellationToken>(), Arg.Any<Func<ScenarioFolderPhase, Task>?>())
             .Returns(async ci =>
             {
-                // Simulate the native folder picker being open before any phase is reported.
                 await pickerGate.Task;
                 await ci.Arg<Func<ScenarioFolderPhase, Task>>()!(ScenarioFolderPhase.Scanning);
 
@@ -534,16 +562,12 @@ public async Task FolderScan_WhenLaunchedFromReactiveBannerRetry_GuardsScanAndRe
 
         var retried = cut.InvokeAsync(() => retry!());
 
-        // During the picker (before any phase) the guard must already have disabled the busy-gated controls, even though
-        // the scan chip is not shown yet. If the retry bypassed RunGuardedAsync, or RunGuardedAsync did not render on
-        // _isBusy=true, the open-folder button would still be enabled here.
         cut.WaitForAssertion(() =>
         {
             Assert.Empty(cut.FindAll(".empty-dashboard__chip--scanning"));
             Assert.True(cut.Find(ActiveDetailOpenFolder).HasAttribute("disabled"));
         });
 
-        // The picker returns; Scanning surfaces the chip while the scan runs, controls still disabled.
         pickerGate.SetResult();
         cut.WaitForAssertion(() =>
         {
@@ -554,7 +578,6 @@ public async Task FolderScan_WhenLaunchedFromReactiveBannerRetry_GuardsScanAndRe
         release.SetResult(new ScenarioFolderLaunchResult { Outcome = ScenarioFolderOutcome.NoMatchingLogs });
         await retried;
 
-        // The completion render re-enables the busy-gated control on this non-event-loop path.
         cut.WaitForAssertion(() =>
         {
             Assert.Empty(cut.FindAll(".empty-dashboard__chip--scanning"));
@@ -647,7 +670,6 @@ public void FolderScan_WhenUserReselectsScenario_CancelChipRemainsInMasthead()
         cut.Find(ActiveDetailOpenFolder).Click();
         cut.WaitForAssertion(() => Assert.NotEmpty(cut.FindAll(".empty-dashboard__chip--scanning")));
 
-        // Reselecting a different scenario changes the detail pane but must not hide the masthead scan chip.
         cut.FindAll(ActiveOption).First(option => option.TextContent.Contains("Crash B")).Click();
 
         cut.WaitForAssertion(() =>
@@ -832,7 +854,7 @@ public void Tablist_FavoritesAbsentWhenNoneFavorited()
     [Fact]
     public void Tablist_ListsFavoritesRecommendedAndGroupsInOrder()
     {
-        _favorites.Value.Returns(new ScenarioFavoritesState { FavoriteScenarioIds = ["application-crashes"] });
+        _favoritesSource.FavoriteScenarioIds.Returns(ImmutableHashSet.Create("application-crashes"));
         _scenarioQuery.GetSplashScenarios().Returns(
         [
             Scenario("application-crashes", "Application crashes", group: ScenarioGroup.SystemHealth),
@@ -858,7 +880,7 @@ public void ToSplashCategory_MapsAllScenarioGroups()
     [Fact]
     public void Unfavoriting_LastFavorite_RemovesTabAndReconcilesActive()
     {
-        _favorites.Value.Returns(new ScenarioFavoritesState { FavoriteScenarioIds = ["application-crashes"] });
+        _favoritesSource.FavoriteScenarioIds.Returns(ImmutableHashSet.Create("application-crashes"));
         _scenarioQuery.GetSplashScenarios().Returns([Scenario("application-crashes", "Application crashes")]);
 
         var cut = Render<EmptyStateDashboard>();
@@ -868,7 +890,7 @@ public void Unfavoriting_LastFavorite_RemovesTabAndReconcilesActive()
             Assert.Equal("Favorites", cut.Find("[role='tab'][aria-selected='true']").TextContent.Trim());
         });
 
-        _favorites.Value.Returns(new ScenarioFavoritesState());
+        _favoritesSource.FavoriteScenarioIds.Returns(ImmutableHashSet<string>.Empty);
         RaiseFavoritesChanged(cut);
 
         cut.WaitForAssertion(() =>
@@ -905,7 +927,6 @@ private static ScenarioDefinition Scenario(
     private static IReadOnlyList<string> TabLabels(IRenderedComponent<EmptyStateDashboard> cut) =>
         cut.FindAll("[role='tab']").Select(tab => tab.TextContent.Trim()).ToList();
 
-    private void RaiseFavoritesChanged(IRenderedComponent<EmptyStateDashboard> cut, params string[] favoriteIds) =>
-        cut.InvokeAsync(() => _favoritesSelection.SelectedValueChanged +=
-            Raise.Event<EventHandler<ImmutableHashSet<string>>>(this, favoriteIds.ToImmutableHashSet()));
+    private void RaiseFavoritesChanged(IRenderedComponent<EmptyStateDashboard> cut) =>
+        cut.InvokeAsync(() => _favoritesSource.Changed += Raise.Event<Action>());
 }
diff --git a/tests/Unit/EventLogExpert.UI.Tests/Database/DatabaseEntryRowTests.cs b/tests/Unit/EventLogExpert.UI.Tests/Database/DatabaseEntryRowTests.cs
index 9d5ef604e..1839f0da2 100644
--- a/tests/Unit/EventLogExpert.UI.Tests/Database/DatabaseEntryRowTests.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/Database/DatabaseEntryRowTests.cs
@@ -7,8 +7,8 @@
 using EventLogExpert.Runtime.Banner;
 using EventLogExpert.Runtime.Database;
 using EventLogExpert.Runtime.Database.Upgrade;
-using EventLogExpert.Runtime.Menu;
 using EventLogExpert.UI.Database;
+using EventLogExpert.UI.Menu;
 using Microsoft.AspNetCore.Components;
 using Microsoft.AspNetCore.Components.Web;
 using Microsoft.Extensions.DependencyInjection;
@@ -156,7 +156,6 @@ public async Task ContextMenu_RemoveItem_HasRemoveLabel()
     [Fact]
     public void OsStamp_AboveDisplayCap_RendersOverflowCount()
     {
-        // Overflow uses "9+" because the classifier only reads cap + 1 distinct stamps.
         var entry = MakeEntry(DatabaseStatus.Ready) with { OsStamps = MakeDistinctStamps(10) };
 
         var component = RenderRow(entry);
@@ -436,7 +435,6 @@ public void Render_IsUpgrading_ShowsSpinner_AndHidesBadge()
     [Fact]
     public void Render_ManageUpgrade_TransitionalWindow_RoleStatusPresent()
     {
-        // Covers the manage-upgrade window before first per-file progress arrives.
         var entry = MakeEntry(DatabaseStatus.UpgradeRequired);
 
         var component = RenderRow(entry, isUpgrading: true);
@@ -449,7 +447,6 @@ public void Render_ManageUpgrade_TransitionalWindow_RoleStatusPresent()
     [Fact]
     public void Render_NonReadyEnabledEntry_NoTrashButton()
     {
-        // Non-ready enabled entries are not resolver-loaded, so removal remains safe.
         var entry = MakeEntry(DatabaseStatus.UpgradeFailed, isEnabled: true);
 
         var component = RenderRow(entry);
@@ -504,7 +501,6 @@ public void Render_PendingToggle_AppliesIndicatorClass()
     [Fact]
     public void Render_PendingToggleOnDisabledToggle_DoesNotShowIndicator()
     {
-        // Disabled toggles must suppress pending announcements because the user cannot act on them.
         var entry = MakeEntry(DatabaseStatus.NotClassified, "provider-z.db");
 
         var component = RenderRow(entry, isTogglePending: true);
@@ -568,7 +564,6 @@ public void Render_ReadyEntryWithClassificationPending_ShowsDisabledToggle()
     [InlineData(DatabaseStatus.ObsoleteSchema, "Obsolete")]
     public void Render_TerminalStatus_ShowsBadge_NoTrash(DatabaseStatus status, string expectedLabel)
     {
-        // ClassificationFailed is excluded because it renders the retry classification button.
         var entry = MakeEntry(status);
 
         var component = RenderRow(entry);
@@ -776,7 +771,6 @@ public async Task RestoreButtonClick_WhenIsUpgradeBlocked_DoesNotInvokeOnRestore
     [Fact]
     public async Task RestoreButtonClick_WhenUpgradeProgressMatchesRow_DoesNotInvokeOnRestoreFromBackup()
     {
-        // Backup restore clicks must honor per-row background upgrade progress even without a spinner.
         var entry = MakeEntry(DatabaseStatus.UpgradeRequired, backupExists: true);
         int invocationCount = 0;
         var progress = new BannerProgressEntry(
diff --git a/tests/Unit/EventLogExpert.UI.Tests/Database/DatabaseRecoveryHostTests.cs b/tests/Unit/EventLogExpert.UI.Tests/Database/DatabaseRecoveryHostTests.cs
index 2cc5c070b..7f18b1707 100644
--- a/tests/Unit/EventLogExpert.UI.Tests/Database/DatabaseRecoveryHostTests.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/Database/DatabaseRecoveryHostTests.cs
@@ -6,8 +6,8 @@
 using EventLogExpert.Runtime.Banner;
 using EventLogExpert.Runtime.Common.Threading;
 using EventLogExpert.Runtime.Database;
-using EventLogExpert.Runtime.Modal;
 using EventLogExpert.UI.Database;
+using EventLogExpert.UI.Modal;
 using NSubstitute;
 using NSubstitute.ExceptionExtensions;
 
@@ -55,7 +55,6 @@ public DatabaseRecoveryHostTests()
     [Fact]
     public void DatabaseRecoveryHost_BannerDismissedExternally_DoesNotRepromptForSameSet()
     {
-        // Arrange
         var initialId = BannerId.Create();
         _nextBannerId = initialId;
         _databaseService.Entries.Returns([BuildEntry("a.db", true)]);
@@ -67,13 +66,11 @@ [new ErrorBannerEntry(initialId, "Database upgrade recovery", "...", "Resolve",
         _criticalErrorService.ClearReceivedCalls();
         _errorBannerService.ClearReceivedCalls();
 
-        // Act — banner disappears externally; host observes via StateChanged, then EntriesChanged for the same set.
         _errorBannerService.ErrorBanners.Returns([]);
         _errorBannerService.StateChanged += Raise.Event<Action>();
 
         _databaseService.EntriesChanged += Raise.Event<EventHandler>(_databaseService, EventArgs.Empty);
 
-        // Assert
         _errorBannerService.DidNotReceive().ReportError(
             Arg.Any<string>(),
             Arg.Any<string>(),
@@ -84,7 +81,6 @@ [new ErrorBannerEntry(initialId, "Database upgrade recovery", "...", "Resolve",
     [Fact]
     public void DatabaseRecoveryHost_BannerDismissedExternally_NewBackupEntryAppears_RepromptsWithNewCount()
     {
-        // Arrange
         var initialId = BannerId.Create();
         _nextBannerId = initialId;
         _databaseService.Entries.Returns([BuildEntry("a.db", true)]);
@@ -99,14 +95,12 @@ [new ErrorBannerEntry(initialId, "Database upgrade recovery", "...", "Resolve",
         _errorBannerService.ErrorBanners.Returns([]);
         _errorBannerService.StateChanged += Raise.Event<Action>();
 
-        // Act
         var newId = BannerId.Create();
         _nextBannerId = newId;
         _databaseService.Entries.Returns(
             [BuildEntry("a.db", true), BuildEntry("b.db", true)]);
         _databaseService.EntriesChanged += Raise.Event<EventHandler>(_databaseService, EventArgs.Empty);
 
-        // Assert
         _errorBannerService.Received(1).ReportError(
             "Database upgrade recovery",
             "2 databases need recovery from interrupted upgrade.",
@@ -117,10 +111,8 @@ [new ErrorBannerEntry(initialId, "Database upgrade recovery", "...", "Resolve",
     [Fact]
     public async Task DatabaseRecoveryHost_Ctor_DatabasesAlreadyHaveBackups_ReportsBannerImmediately()
     {
-        // Arrange
         _databaseService.Entries.Returns([BuildEntry("a.db", true)]);
 
-        // Act — construct host; ctor dispatches EvaluateState immediately to catch pre-existing state.
         using var host = CreateHost();
         await Task.Yield();
 
@@ -135,7 +127,6 @@ public async Task DatabaseRecoveryHost_Ctor_DatabasesAlreadyHaveBackups_ReportsB
     [Fact]
     public async Task DatabaseRecoveryHost_DialogOpenFails_ReportsCriticalViaBannerService()
     {
-        // Arrange
         _databaseService.Entries.Returns([BuildEntry("a.db", true)]);
 
         var openFailure = new InvalidOperationException("coordinator unavailable");
@@ -145,34 +136,28 @@ public async Task DatabaseRecoveryHost_DialogOpenFails_ReportsCriticalViaBannerS
         using var host = CreateHost();
         Assert.NotNull(_capturedRecoveryAction);
 
-        // Act
         await _capturedRecoveryAction!();
 
-        // Assert
         _criticalErrorService.Received(1).ReportCritical(openFailure);
     }
 
     [Fact]
     public void DatabaseRecoveryHost_Disposed_DismissesOwnedBanner()
     {
-        // Arrange
         var initialId = BannerId.Create();
         _nextBannerId = initialId;
         _databaseService.Entries.Returns([BuildEntry("a.db", true)]);
 
         var host = CreateHost();
 
-        // Act
         host.Dispose();
 
-        // Assert
         _errorBannerService.Received(1).DismissError(initialId);
     }
 
     [Fact]
     public void DatabaseRecoveryHost_Disposed_NoLongerRespondsToEntriesChanged()
     {
-        // Arrange
         _databaseService.Entries.Returns([BuildEntry("a.db", true)]);
 
         var host = CreateHost();
@@ -181,12 +166,10 @@ public void DatabaseRecoveryHost_Disposed_NoLongerRespondsToEntriesChanged()
         _criticalErrorService.ClearReceivedCalls();
         _errorBannerService.ClearReceivedCalls();
 
-        // Act
         _databaseService.Entries.Returns(
             [BuildEntry("a.db", true), BuildEntry("b.db", true)]);
         _databaseService.EntriesChanged += Raise.Event<EventHandler>(_databaseService, EventArgs.Empty);
 
-        // Assert
         _errorBannerService.DidNotReceive().DismissError(Arg.Any<BannerId>());
         _errorBannerService.DidNotReceive().ReportError(
             Arg.Any<string>(),
@@ -198,40 +181,33 @@ public void DatabaseRecoveryHost_Disposed_NoLongerRespondsToEntriesChanged()
     [Fact]
     public void DatabaseRecoveryHost_Disposed_TwiceIsIdempotent()
     {
-        // Arrange
         var initialId = BannerId.Create();
         _nextBannerId = initialId;
         _databaseService.Entries.Returns([BuildEntry("a.db", true)]);
 
         var host = CreateHost();
 
-        // Act
         host.Dispose();
         host.Dispose();
 
-        // Assert
         _errorBannerService.Received(1).DismissError(initialId);
     }
 
     [Fact]
     public void DatabaseRecoveryHost_Disposed_WithNoOwnedBanner_DoesNotCallDismiss()
     {
-        // Arrange
         _databaseService.Entries.Returns([]);
 
         var host = CreateHost();
 
-        // Act
         host.Dispose();
 
-        // Assert
         _errorBannerService.DidNotReceive().DismissError(Arg.Any<BannerId>());
     }
 
     [Fact]
     public void DatabaseRecoveryHost_EntriesChanged_AllRecovered_DismissesBannerAndDoesNotReprompt()
     {
-        // Arrange
         var initialId = BannerId.Create();
         _nextBannerId = initialId;
         _databaseService.Entries.Returns([BuildEntry("a.db", true)]);
@@ -240,11 +216,9 @@ public void DatabaseRecoveryHost_EntriesChanged_AllRecovered_DismissesBannerAndD
         _criticalErrorService.ClearReceivedCalls();
         _errorBannerService.ClearReceivedCalls();
 
-        // Act
         _databaseService.Entries.Returns([]);
         _databaseService.EntriesChanged += Raise.Event<EventHandler>(_databaseService, EventArgs.Empty);
 
-        // Assert
         _errorBannerService.Received(1).DismissError(initialId);
         _errorBannerService.DidNotReceive().ReportError(
             Arg.Any<string>(),
@@ -256,12 +230,10 @@ public void DatabaseRecoveryHost_EntriesChanged_AllRecovered_DismissesBannerAndD
     [Fact]
     public void DatabaseRecoveryHost_EntriesChanged_DispatchFails_ReportsCritical()
     {
-        // Arrange
         _databaseService.Entries.Returns([BuildEntry("a.db", true)]);
 
         var dispatchFailure = new InvalidOperationException("main thread unavailable");
 
-        // Throw exclusively on the EntriesChanged dispatch (ctor's initial dispatch already used the default path).
         var entriesChangedDispatchCount = 0;
         _mainThreadService.InvokeOnMainThread(Arg.Any<Action>())
             .Returns(call =>
@@ -281,44 +253,37 @@ public void DatabaseRecoveryHost_EntriesChanged_DispatchFails_ReportsCritical()
         _criticalErrorService.ClearReceivedCalls();
         _errorBannerService.ClearReceivedCalls();
 
-        // Act
         _databaseService.EntriesChanged += Raise.Event<EventHandler>(_databaseService, EventArgs.Empty);
 
-        // Assert
         _criticalErrorService.Received(1).ReportCritical(dispatchFailure);
     }
 
     [Fact]
     public void DatabaseRecoveryHost_EntriesChanged_HandlerThrows_ReportsCritical()
     {
-        // Arrange — Entries throws when read inside the handler.
         var handlerFailure = new InvalidOperationException("entries unavailable");
         _databaseService.Entries.Returns(_ => throw handlerFailure);
 
         using var host = CreateHost();
 
-        // Assert — ctor's initial DispatchSafely(EvaluateState) already triggered the handler failure path.
         _criticalErrorService.Received(1).ReportCritical(handlerFailure);
     }
 
     [Fact]
     public void DatabaseRecoveryHost_EntriesChanged_NewBackupExistsEntry_DismissesOldBannerAndRaisesNewWithUpdatedCount()
     {
-        // Arrange
         var initialId = BannerId.Create();
         _nextBannerId = initialId;
         _databaseService.Entries.Returns([BuildEntry("a.db", true)]);
 
         using var host = CreateHost();
 
-        // Act
         var newId = BannerId.Create();
         _nextBannerId = newId;
         _databaseService.Entries.Returns(
             [BuildEntry("a.db", true), BuildEntry("b.db", true)]);
         _databaseService.EntriesChanged += Raise.Event<EventHandler>(_databaseService, EventArgs.Empty);
 
-        // Assert
         _errorBannerService.Received(1).DismissError(initialId);
         _errorBannerService.Received(1).ReportError(
             "Database upgrade recovery",
@@ -330,17 +295,14 @@ public void DatabaseRecoveryHost_EntriesChanged_NewBackupExistsEntry_DismissesOl
     [Fact]
     public void DatabaseRecoveryHost_EntriesChanged_SameBackupSet_DoesNotDismissOrReprompt()
     {
-        // Arrange
         _databaseService.Entries.Returns([BuildEntry("a.db", true)]);
 
         using var host = CreateHost();
         _criticalErrorService.ClearReceivedCalls();
         _errorBannerService.ClearReceivedCalls();
 
-        // Act
         _databaseService.EntriesChanged += Raise.Event<EventHandler>(_databaseService, EventArgs.Empty);
 
-        // Assert
         _errorBannerService.DidNotReceive().DismissError(Arg.Any<BannerId>());
         _errorBannerService.DidNotReceive().ReportError(
             Arg.Any<string>(),
@@ -352,7 +314,6 @@ public void DatabaseRecoveryHost_EntriesChanged_SameBackupSet_DoesNotDismissOrRe
     [Fact]
     public void DatabaseRecoveryHost_EntriesChanged_ShrinkButStillNonEmpty_DismissesOldBannerAndRaisesNewWithUpdatedCount()
     {
-        // Arrange
         var initialId = BannerId.Create();
         _nextBannerId = initialId;
         _databaseService.Entries.Returns(
@@ -360,13 +321,11 @@ public void DatabaseRecoveryHost_EntriesChanged_ShrinkButStillNonEmpty_Dismisses
 
         using var host = CreateHost();
 
-        // Act
         var newId = BannerId.Create();
         _nextBannerId = newId;
         _databaseService.Entries.Returns([BuildEntry("b.db", true)]);
         _databaseService.EntriesChanged += Raise.Event<EventHandler>(_databaseService, EventArgs.Empty);
 
-        // Assert
         _errorBannerService.Received(1).DismissError(initialId);
         _errorBannerService.Received(1).ReportError(
             "Database upgrade recovery",
@@ -378,14 +337,11 @@ public void DatabaseRecoveryHost_EntriesChanged_ShrinkButStillNonEmpty_Dismisses
     [Fact]
     public void DatabaseRecoveryHost_OnInit_MultipleEntries_UsesPluralLabel()
     {
-        // Arrange
         _databaseService.Entries.Returns(
             [BuildEntry("a.db", true), BuildEntry("b.db", true)]);
 
-        // Act
         using var host = CreateHost();
 
-        // Assert
         _errorBannerService.Received(1).ReportError(
             "Database upgrade recovery",
             "2 databases need recovery from interrupted upgrade.",
@@ -396,13 +352,10 @@ public void DatabaseRecoveryHost_OnInit_MultipleEntries_UsesPluralLabel()
     [Fact]
     public void DatabaseRecoveryHost_OnInit_WithBackupExistsEntries_RaisesErrorBanner()
     {
-        // Arrange
         _databaseService.Entries.Returns([BuildEntry("a.db", true)]);
 
-        // Act
         using var host = CreateHost();
 
-        // Assert
         _errorBannerService.Received(1).ReportError(
             "Database upgrade recovery",
             "1 database needs recovery from interrupted upgrade.",
@@ -413,13 +366,10 @@ public void DatabaseRecoveryHost_OnInit_WithBackupExistsEntries_RaisesErrorBanne
     [Fact]
     public void DatabaseRecoveryHost_OnInit_WithNoBackupExistsEntries_DoesNotRaiseBanner()
     {
-        // Arrange
         _databaseService.Entries.Returns([BuildEntry("a.db", false)]);
 
-        // Act
         using var host = CreateHost();
 
-        // Assert
         _errorBannerService.DidNotReceive().ReportError(
             Arg.Any<string>(),
             Arg.Any<string>(),
@@ -430,7 +380,6 @@ public void DatabaseRecoveryHost_OnInit_WithNoBackupExistsEntries_DoesNotRaiseBa
     [Fact]
     public async Task DatabaseRecoveryHost_OpenRecoveryDialogAsync_EmptyEntries_DoesNotCallLauncher()
     {
-        // Arrange — start with backups, then drain them after the banner is reported but before the CTA fires.
         _databaseService.Entries.Returns([BuildEntry("a.db", true)]);
 
         using var host = CreateHost();
@@ -438,10 +387,8 @@ public async Task DatabaseRecoveryHost_OpenRecoveryDialogAsync_EmptyEntries_Does
 
         _databaseService.Entries.Returns([]);
 
-        // Act
         await _capturedRecoveryAction!();
 
-        // Assert
         await _modalCoordinator.DidNotReceive().PushAsync<DatabaseRecoveryModal, bool>(
             Arg.Any<IDictionary<string, object?>?>());
     }
@@ -449,7 +396,6 @@ await _modalCoordinator.DidNotReceive().PushAsync<DatabaseRecoveryModal, bool>(
     [Fact]
     public async Task DatabaseRecoveryHost_ResolveActionClicked_OpensDialogViaCoordinator()
     {
-        // Arrange
         _databaseService.Entries.Returns([BuildEntry("a.db", true)]);
 
         _modalCoordinator.PushAsync<DatabaseRecoveryModal, bool>(Arg.Any<IDictionary<string, object?>?>())
@@ -458,10 +404,8 @@ public async Task DatabaseRecoveryHost_ResolveActionClicked_OpensDialogViaCoordi
         using var host = CreateHost();
         Assert.NotNull(_capturedRecoveryAction);
 
-        // Act
         await _capturedRecoveryAction!();
 
-        // Assert
         await _modalCoordinator.Received(1).PushAsync<DatabaseRecoveryModal, bool>(
             Arg.Any<IDictionary<string, object?>?>());
     }
@@ -469,7 +413,6 @@ await _modalCoordinator.Received(1).PushAsync<DatabaseRecoveryModal, bool>(
     [Fact]
     public async Task DatabaseRecoveryHost_ResolveActionClicked_WhenPreempted_TracesAndDoesNotThrow()
     {
-        // Arrange
         _databaseService.Entries.Returns([BuildEntry("a.db", true)]);
 
         _modalCoordinator.PushAsync<DatabaseRecoveryModal, bool>(Arg.Any<IDictionary<string, object?>?>())
@@ -478,10 +421,8 @@ public async Task DatabaseRecoveryHost_ResolveActionClicked_WhenPreempted_Traces
         using var host = CreateHost();
         Assert.NotNull(_capturedRecoveryAction);
 
-        // Act
         await _capturedRecoveryAction!();
 
-        // Assert
         await _modalCoordinator.Received(1).PushAsync<DatabaseRecoveryModal, bool>(
             Arg.Any<IDictionary<string, object?>?>());
         _traceLogger.Received().Trace(Arg.Any<TraceLogHandler>());
diff --git a/tests/Unit/EventLogExpert.UI.Tests/Database/DatabaseRecoveryModalTests.cs b/tests/Unit/EventLogExpert.UI.Tests/Database/DatabaseRecoveryModalTests.cs
index 74004904c..9abe7d72d 100644
--- a/tests/Unit/EventLogExpert.UI.Tests/Database/DatabaseRecoveryModalTests.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/Database/DatabaseRecoveryModalTests.cs
@@ -5,13 +5,12 @@
 using AngleSharp.Html.Dom;
 using Bunit;
 using EventLogExpert.Logging.Abstractions;
-using EventLogExpert.Runtime.Alerts;
 using EventLogExpert.Runtime.Banner;
 using EventLogExpert.Runtime.Database;
-using EventLogExpert.Runtime.Modal;
+using EventLogExpert.UI.Alerts;
 using EventLogExpert.UI.Database;
+using EventLogExpert.UI.Modal;
 using EventLogExpert.UI.Tests.TestUtils;
-using Fluxor;
 using Microsoft.AspNetCore.Components;
 using Microsoft.AspNetCore.Components.Web;
 using Microsoft.Extensions.DependencyInjection;
@@ -47,7 +46,6 @@ public DatabaseRecoveryModalTests()
         Services.AddSingleton(_modalCoordinator);
         Services.AddSingleton(_modalService);
         Services.AddSingleton(_traceLogger);
-        Services.AddFluxor(options => options.ScanAssemblies(typeof(DatabaseRecoveryModal).Assembly));
 
         JSInterop.Mode = JSRuntimeMode.Loose;
     }
@@ -55,7 +53,6 @@ public DatabaseRecoveryModalTests()
     [Fact]
     public async Task DatabaseRecoveryModal_AllRowsSucceed_AutoCompletesWithFalseWhenEntriesDrain()
     {
-        // Arrange
         var entriesBefore = new[]
         {
             BuildEntry("a.db", true),
@@ -69,13 +66,11 @@ public async Task DatabaseRecoveryModal_AllRowsSucceed_AutoCompletesWithFalseWhe
 
         var component = Render<DatabaseRecoveryModal>();
 
-        // Act
         await component.Find("button:contains('Apply')").ClickAsync(new MouseEventArgs());
 
         _databaseService.Entries.Returns([]);
         _databaseService.EntriesChanged += Raise.Event<EventHandler>(_databaseService, EventArgs.Empty);
 
-        // Assert
         await component.WaitForAssertionAsync(() =>
             _modalService.Received().Complete(_modalId, Arg.Is<object?>(value => Equals(value, false))));
         await _databaseService.Received(1).RestoreFromBackupAsync("a.db", Arg.Any<CancellationToken>());
@@ -85,18 +80,15 @@ await component.WaitForAssertionAsync(() =>
     [Fact]
     public async Task DatabaseRecoveryModal_ApplyDeleteReturnsFalse_SurfacesErrorBannerAndMarksRowFailed()
     {
-        // Arrange
         _databaseService.Entries.Returns([BuildEntry("a.db", true)]);
         _databaseService.DeleteEntryWithBackupAsync("a.db", Arg.Any<CancellationToken>())
             .Returns(Task.FromResult(false));
 
         var component = Render<DatabaseRecoveryModal>();
 
-        // Act
         await component.Find("button.button:contains('Delete all')").ClickAsync(new MouseEventArgs());
         await component.Find("button:contains('Apply')").ClickAsync(new MouseEventArgs());
 
-        // Assert
         _errorBannerService.Received(1).ReportError(
             "Database recovery failed",
             "Failed to delete 'a.db'.");
@@ -109,7 +101,6 @@ public async Task DatabaseRecoveryModal_ApplyDeleteReturnsFalse_SurfacesErrorBan
     [Fact]
     public async Task DatabaseRecoveryModal_ApplyDisablesAllControls_WhilePending()
     {
-        // Arrange
         _databaseService.Entries.Returns([BuildEntry("a.db", true)]);
         var pendingRestore = new TaskCompletionSource<bool>();
         _databaseService.RestoreFromBackupAsync("a.db", Arg.Any<CancellationToken>())
@@ -117,10 +108,8 @@ public async Task DatabaseRecoveryModal_ApplyDisablesAllControls_WhilePending()
 
         var component = Render<DatabaseRecoveryModal>();
 
-        // Act
         var applyClick = component.Find("button:contains('Apply')").ClickAsync(new MouseEventArgs());
 
-        // Assert
         Assert.True(((IHtmlButtonElement)component.Find("button:contains('Apply')")).IsDisabled);
         Assert.True(((IHtmlButtonElement)component.Find("button:contains('Cancel')")).IsDisabled);
         Assert.True(((IHtmlButtonElement)component.Find("button.button:contains('Restore all')")).IsDisabled);
@@ -138,7 +127,6 @@ public async Task DatabaseRecoveryModal_ApplyDisablesAllControls_WhilePending()
     [Fact]
     public async Task DatabaseRecoveryModal_ApplyMixed_CallsBothMethodsForRespectiveRows()
     {
-        // Arrange
         _databaseService.Entries.Returns(
             [BuildEntry("a.db", true), BuildEntry("b.db", true)]);
         _databaseService.RestoreFromBackupAsync("a.db", Arg.Any<CancellationToken>())
@@ -148,14 +136,12 @@ public async Task DatabaseRecoveryModal_ApplyMixed_CallsBothMethodsForRespective
 
         var component = Render<DatabaseRecoveryModal>();
 
-        // Act
         var bRow = component.FindAll("li.recovery-row")[1];
         var bDeleteRadio = bRow.QuerySelectorAll("input[type=radio]")[1];
         await bDeleteRadio.ChangeAsync(new ChangeEventArgs { Value = "on" });
 
         await component.Find("button:contains('Apply')").ClickAsync(new MouseEventArgs());
 
-        // Assert
         await _databaseService.Received(1).RestoreFromBackupAsync("a.db", Arg.Any<CancellationToken>());
         await _databaseService.Received(1).DeleteEntryWithBackupAsync("b.db", Arg.Any<CancellationToken>());
         await _databaseService.DidNotReceive().RestoreFromBackupAsync("b.db", Arg.Any<CancellationToken>());
@@ -165,17 +151,14 @@ public async Task DatabaseRecoveryModal_ApplyMixed_CallsBothMethodsForRespective
     [Fact]
     public async Task DatabaseRecoveryModal_ApplyRestoreReturnsFalse_SurfacesErrorBannerAndMarksRowFailed()
     {
-        // Arrange
         _databaseService.Entries.Returns([BuildEntry("a.db", true)]);
         _databaseService.RestoreFromBackupAsync("a.db", Arg.Any<CancellationToken>())
             .Returns(Task.FromResult(false));
 
         var component = Render<DatabaseRecoveryModal>();
 
-        // Act
         await component.Find("button:contains('Apply')").ClickAsync(new MouseEventArgs());
 
-        // Assert
         _errorBannerService.Received(1).ReportError(
             "Database recovery failed",
             "Failed to restore 'a.db' from backup.");
@@ -188,17 +171,14 @@ public async Task DatabaseRecoveryModal_ApplyRestoreReturnsFalse_SurfacesErrorBa
     [Fact]
     public async Task DatabaseRecoveryModal_ApplyThrowsInvalidOperation_TreatsAsBenignSkipNoErrorBanner()
     {
-        // Arrange
         _databaseService.Entries.Returns([BuildEntry("a.db", true)]);
         _databaseService.RestoreFromBackupAsync("a.db", Arg.Any<CancellationToken>())
             .Returns(Task.FromException<bool>(new InvalidOperationException("entry not found")));
 
         var component = Render<DatabaseRecoveryModal>();
 
-        // Act
         await component.Find("button:contains('Apply')").ClickAsync(new MouseEventArgs());
 
-        // Assert
         _errorBannerService.DidNotReceive().ReportError(
             Arg.Any<string>(),
             Arg.Any<string>(),
@@ -212,17 +192,14 @@ public async Task DatabaseRecoveryModal_ApplyThrowsInvalidOperation_TreatsAsBeni
     [Fact]
     public async Task DatabaseRecoveryModal_ApplyThrowsUnexpected_SurfacesErrorBannerAndMarksRowFailed()
     {
-        // Arrange
         _databaseService.Entries.Returns([BuildEntry("a.db", true)]);
         _databaseService.RestoreFromBackupAsync("a.db", Arg.Any<CancellationToken>())
             .Returns(Task.FromException<bool>(new IOException("disk gone")));
 
         var component = Render<DatabaseRecoveryModal>();
 
-        // Act
         await component.Find("button:contains('Apply')").ClickAsync(new MouseEventArgs());
 
-        // Assert
         _errorBannerService.Received(1).ReportError(
             "Database recovery failed",
             "Failed to restore 'a.db' from backup.");
@@ -234,18 +211,15 @@ public async Task DatabaseRecoveryModal_ApplyThrowsUnexpected_SurfacesErrorBanne
     [Fact]
     public async Task DatabaseRecoveryModal_ApplyWithDelete_CallsDeleteEntryWithBackupAsyncWithFileName()
     {
-        // Arrange
         _databaseService.Entries.Returns([BuildEntry("a.db", true)]);
         _databaseService.DeleteEntryWithBackupAsync("a.db", Arg.Any<CancellationToken>())
             .Returns(Task.FromResult(true));
 
         var component = Render<DatabaseRecoveryModal>();
 
-        // Act
         await component.Find("button.button:contains('Delete all')").ClickAsync(new MouseEventArgs());
         await component.Find("button:contains('Apply')").ClickAsync(new MouseEventArgs());
 
-        // Assert
         await _databaseService.Received(1).DeleteEntryWithBackupAsync(
             Arg.Is<string>(name => name == "a.db"),
             Arg.Any<CancellationToken>());
@@ -257,17 +231,14 @@ await _databaseService.DidNotReceive().RestoreFromBackupAsync(
     [Fact]
     public async Task DatabaseRecoveryModal_ApplyWithRestore_CallsRestoreFromBackupAsyncWithFileName()
     {
-        // Arrange
         _databaseService.Entries.Returns([BuildEntry("a.db", true)]);
         _databaseService.RestoreFromBackupAsync("a.db", Arg.Any<CancellationToken>())
             .Returns(Task.FromResult(true));
 
         var component = Render<DatabaseRecoveryModal>();
 
-        // Act
         await component.Find("button:contains('Apply')").ClickAsync(new MouseEventArgs());
 
-        // Assert
         await _databaseService.Received(1).RestoreFromBackupAsync(
             Arg.Is<string>(name => name == "a.db"),
             Arg.Any<CancellationToken>());
@@ -279,15 +250,12 @@ await _databaseService.DidNotReceive().DeleteEntryWithBackupAsync(
     [Fact]
     public async Task DatabaseRecoveryModal_CancelClicked_RoutesThroughCoordinatorAndDoesNotCallDatabaseService()
     {
-        // Arrange
         _databaseService.Entries.Returns([BuildEntry("a.db", true)]);
 
         var component = Render<DatabaseRecoveryModal>();
 
-        // Act
         await component.Find("button:contains('Cancel')").ClickAsync(new MouseEventArgs());
 
-        // Assert
         await _modalCoordinator.Received(1).RequestCloseActiveAsync(ModalCloseReason.UserDismiss);
         await _databaseService.DidNotReceive().RestoreFromBackupAsync(
             Arg.Any<string>(),
@@ -300,14 +268,11 @@ await _databaseService.DidNotReceive().DeleteEntryWithBackupAsync(
     [Fact]
     public void DatabaseRecoveryModal_DefaultsEachRowToRestore()
     {
-        // Arrange
         _databaseService.Entries.Returns(
             [BuildEntry("a.db", true), BuildEntry("b.db", true)]);
 
-        // Act
         var component = Render<DatabaseRecoveryModal>();
 
-        // Assert
         foreach (var row in component.FindAll("li.recovery-row"))
         {
             var radios = row.QuerySelectorAll("input[type=radio]");
@@ -320,16 +285,13 @@ public void DatabaseRecoveryModal_DefaultsEachRowToRestore()
     [Fact]
     public async Task DatabaseRecoveryModal_DeleteAllClicked_SetsAllRowsToDelete()
     {
-        // Arrange
         _databaseService.Entries.Returns(
             [BuildEntry("a.db", true), BuildEntry("b.db", true)]);
 
         var component = Render<DatabaseRecoveryModal>();
 
-        // Act
         await component.Find("button.button:contains('Delete all')").ClickAsync(new MouseEventArgs());
 
-        // Assert
         foreach (var row in component.FindAll("li.recovery-row"))
         {
             var radios = row.QuerySelectorAll("input[type=radio]");
@@ -341,16 +303,13 @@ public async Task DatabaseRecoveryModal_DeleteAllClicked_SetsAllRowsToDelete()
     [Fact]
     public async Task DatabaseRecoveryModal_EntriesChangedAllResolved_AutoCompletesWithFalse()
     {
-        // Arrange
         _databaseService.Entries.Returns([BuildEntry("a.db", true)]);
 
         var component = Render<DatabaseRecoveryModal>();
 
-        // Act
         _databaseService.Entries.Returns([]);
         _databaseService.EntriesChanged += Raise.Event<EventHandler>(_databaseService, EventArgs.Empty);
 
-        // Assert
         await component.WaitForAssertionAsync(() =>
             _modalService.Received().Complete(_modalId, Arg.Is<object?>(value => Equals(value, false))));
     }
@@ -358,19 +317,16 @@ await component.WaitForAssertionAsync(() =>
     [Fact]
     public async Task DatabaseRecoveryModal_EntriesChangedNewBackupExistsEntry_AddsRowWithRestoreDefault()
     {
-        // Arrange
         _databaseService.Entries.Returns([BuildEntry("a.db", true)]);
 
         var component = Render<DatabaseRecoveryModal>();
 
-        // Act
         _databaseService.Entries.Returns(
             [BuildEntry("a.db", true), BuildEntry("b.db", true)]);
         _databaseService.EntriesChanged += Raise.Event<EventHandler>(_databaseService, EventArgs.Empty);
 
         component.WaitForState(() => component.FindAll("li.recovery-row").Count == 2);
 
-        // Assert
         var newRow = component.FindAll("li.recovery-row")[1];
         Assert.Contains("b.db", newRow.TextContent);
 
@@ -384,7 +340,6 @@ public async Task DatabaseRecoveryModal_EntriesChangedNewBackupExistsEntry_AddsR
     [Fact]
     public async Task DatabaseRecoveryModal_EntriesChangedSubsetResolved_RemovesResolvedRowsKeepsDialogOpen()
     {
-        // Arrange
         _databaseService.Entries.Returns(
             [BuildEntry("a.db", true), BuildEntry("b.db", true)]);
 
@@ -394,13 +349,11 @@ public async Task DatabaseRecoveryModal_EntriesChangedSubsetResolved_RemovesReso
         var bDeleteRadio = bRow.QuerySelectorAll("input[type=radio]")[1];
         await bDeleteRadio.ChangeAsync(new ChangeEventArgs { Value = "on" });
 
-        // Act
         _databaseService.Entries.Returns([BuildEntry("a.db", true)]);
         _databaseService.EntriesChanged += Raise.Event<EventHandler>(_databaseService, EventArgs.Empty);
 
         component.WaitForState(() => component.FindAll("li.recovery-row").Count == 1);
 
-        // Assert
         var remainingRow = component.Find("li.recovery-row");
         Assert.Contains("a.db", remainingRow.TextContent);
 
@@ -413,7 +366,6 @@ public async Task DatabaseRecoveryModal_EntriesChangedSubsetResolved_RemovesReso
     [Fact]
     public async Task DatabaseRecoveryModal_FailedRow_LosesFailureMarkOnNextApplySuccessWhileOthersStayFailed()
     {
-        // Arrange
         _databaseService.Entries.Returns(
             [BuildEntry("a.db", true), BuildEntry("b.db", true)]);
         _databaseService.RestoreFromBackupAsync("a.db", Arg.Any<CancellationToken>())
@@ -432,13 +384,11 @@ public async Task DatabaseRecoveryModal_FailedRow_LosesFailureMarkOnNextApplySuc
             "recovery-row-failed",
             FindRowByFileName(component, "b.db").GetAttribute("class") ?? string.Empty);
 
-        // Act
         _databaseService.RestoreFromBackupAsync("a.db", Arg.Any<CancellationToken>())
             .Returns(Task.FromResult(true));
 
         await component.Find("button:contains('Apply')").ClickAsync(new MouseEventArgs());
 
-        // Assert
         Assert.DoesNotContain(
             "recovery-row-failed",
             FindRowByFileName(component, "a.db").GetAttribute("class") ?? string.Empty);
@@ -450,13 +400,10 @@ public async Task DatabaseRecoveryModal_FailedRow_LosesFailureMarkOnNextApplySuc
     [Fact]
     public async Task DatabaseRecoveryModal_InitialEmptySet_AutoCompletesWithoutShowingModal()
     {
-        // Arrange
         _databaseService.Entries.Returns([]);
 
-        // Act
         var component = Render<DatabaseRecoveryModal>();
 
-        // Assert
         await component.WaitForAssertionAsync(() =>
             _modalService.Received().Complete(_modalId, Arg.Is<object?>(value => Equals(value, false))));
     }
@@ -464,24 +411,20 @@ await component.WaitForAssertionAsync(() =>
     [Fact]
     public async Task DatabaseRecoveryModal_OnRequestCloseAsync_WhenIdle_ReturnsTrue()
     {
-        // Arrange
         _databaseService.Entries.Returns([BuildEntry("a.db", true)]);
 
         Render<DatabaseRecoveryModal>();
         Assert.NotNull(_capturedRegistration);
 
-        // Act
         bool accepted = await _capturedRegistration!.RequestClose(
             new ModalCloseRequest(ModalCloseReason.UserDismiss));
 
-        // Assert
         Assert.True(accepted);
     }
 
     [Fact]
     public async Task DatabaseRecoveryModal_OnRequestCloseAsync_WhileApplying_ReturnsFalse()
     {
-        // Arrange
         _databaseService.Entries.Returns([BuildEntry("a.db", true)]);
         var pendingRestore = new TaskCompletionSource<bool>();
         _databaseService.RestoreFromBackupAsync("a.db", Arg.Any<CancellationToken>())
@@ -490,13 +433,11 @@ public async Task DatabaseRecoveryModal_OnRequestCloseAsync_WhileApplying_Return
         var component = Render<DatabaseRecoveryModal>();
         Assert.NotNull(_capturedRegistration);
 
-        // Act — start Apply (sets _isApplying), then ask the registration whether it can close.
         var applyClick = component.Find("button:contains('Apply')").ClickAsync(new MouseEventArgs());
 
         bool accepted = await _capturedRegistration!.RequestClose(
             new ModalCloseRequest(ModalCloseReason.UserDismiss));
 
-        // Assert
         Assert.False(accepted);
 
         pendingRestore.SetResult(true);
@@ -506,13 +447,10 @@ public async Task DatabaseRecoveryModal_OnRequestCloseAsync_WhileApplying_Return
     [Fact]
     public void DatabaseRecoveryModal_RegistersAsCriticalScope()
     {
-        // Arrange
         _databaseService.Entries.Returns([BuildEntry("a.db", true)]);
 
-        // Act
         Render<DatabaseRecoveryModal>();
 
-        // Assert
         Assert.NotNull(_capturedRegistration);
         Assert.Equal(ModalScope.Critical, _capturedRegistration!.Scope);
     }
@@ -520,7 +458,6 @@ public void DatabaseRecoveryModal_RegistersAsCriticalScope()
     [Fact]
     public void DatabaseRecoveryModal_RendersOneRowPerBackupExistsEntry()
     {
-        // Arrange
         _databaseService.Entries.Returns(
             [
                 BuildEntry("a.db", true),
@@ -528,10 +465,8 @@ public void DatabaseRecoveryModal_RendersOneRowPerBackupExistsEntry()
                 BuildEntry("c.db", false)
             ]);
 
-        // Act
         var component = Render<DatabaseRecoveryModal>();
 
-        // Assert
         var rows = component.FindAll("li.recovery-row");
         Assert.Equal(2, rows.Count);
         Assert.Contains("a.db", rows[0].TextContent);
@@ -541,7 +476,6 @@ public void DatabaseRecoveryModal_RendersOneRowPerBackupExistsEntry()
     [Fact]
     public async Task DatabaseRecoveryModal_RestoreAllClicked_SetsAllRowsToRestore()
     {
-        // Arrange
         _databaseService.Entries.Returns(
             [BuildEntry("a.db", true), BuildEntry("b.db", true)]);
 
@@ -555,10 +489,8 @@ public async Task DatabaseRecoveryModal_RestoreAllClicked_SetsAllRowsToRestore()
             await deleteRadio.ChangeAsync(new ChangeEventArgs { Value = "on" });
         }
 
-        // Act
         await component.Find("button.button:contains('Restore all')").ClickAsync(new MouseEventArgs());
 
-        // Assert
         foreach (var row in component.FindAll("li.recovery-row"))
         {
             var radios = row.QuerySelectorAll("input[type=radio]");
@@ -570,7 +502,6 @@ public async Task DatabaseRecoveryModal_RestoreAllClicked_SetsAllRowsToRestore()
     [Fact]
     public async Task DatabaseRecoveryModal_RowResolvedExternallyMidLoop_DoesNotCallServiceForResolvedRow()
     {
-        // Arrange
         var entriesBefore = new[]
         {
             BuildEntry("a.db", true),
@@ -591,10 +522,8 @@ public async Task DatabaseRecoveryModal_RowResolvedExternallyMidLoop_DoesNotCall
 
         _databaseService.Entries.Returns(entriesAfter);
 
-        // Act
         await component.Find("button:contains('Apply')").ClickAsync(new MouseEventArgs());
 
-        // Assert
         await _databaseService.Received(1).RestoreFromBackupAsync("a.db", Arg.Any<CancellationToken>());
         await _databaseService.DidNotReceive().RestoreFromBackupAsync("b.db", Arg.Any<CancellationToken>());
         _errorBannerService.DidNotReceive().ReportError(
@@ -607,12 +536,10 @@ public async Task DatabaseRecoveryModal_RowResolvedExternallyMidLoop_DoesNotCall
     [Fact]
     public async Task DatabaseRecoveryModal_WhenInlineAlertRequested_ResolvesViaInlineAlertHost()
     {
-        // Arrange
         _databaseService.Entries.Returns([BuildEntry("a.db", true)]);
 
         var component = Render<DatabaseRecoveryModal>();
 
-        // Act
         var alertTask = component.Instance.ShowInlineAlertAsync(
             new InlineAlertRequest(
                 Title: "Test",
@@ -623,13 +550,10 @@ public async Task DatabaseRecoveryModal_WhenInlineAlertRequested_ResolvesViaInli
                 PromptInitialValue: null),
             CancellationToken.None);
 
-        // Scoped under .inline-alert-buttons so it doesn't match the AcceptCancel footer's
-        // Apply button (also class="button button-green").
         var acceptButton = await component.WaitForElementAsync(".inline-alert-buttons button.button-green");
 
         await acceptButton.ClickAsync(new MouseEventArgs());
 
-        // Assert
         InlineAlertResult result = await alertTask;
         Assert.True(result.Accepted);
     }
diff --git a/tests/Unit/EventLogExpert.UI.Tests/DatabaseTools/DatabaseToolsModalTabbingTests.cs b/tests/Unit/EventLogExpert.UI.Tests/DatabaseTools/DatabaseToolsModalTabbingTests.cs
index c3823285a..a6db33685 100644
--- a/tests/Unit/EventLogExpert.UI.Tests/DatabaseTools/DatabaseToolsModalTabbingTests.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/DatabaseTools/DatabaseToolsModalTabbingTests.cs
@@ -14,11 +14,10 @@
 using EventLogExpert.Runtime.DatabaseTools.Elevation;
 using EventLogExpert.Runtime.EventLog;
 using EventLogExpert.Runtime.Menu;
-using EventLogExpert.Runtime.Modal;
 using EventLogExpert.UI.DatabaseTools;
+using EventLogExpert.UI.Modal;
 using EventLogExpert.UI.Tests.DatabaseTools.Tabs;
 using EventLogExpert.UI.Tests.TestUtils;
-using Fluxor;
 using Microsoft.AspNetCore.Components.Web;
 using Microsoft.Extensions.DependencyInjection;
 using NSubstitute;
@@ -68,7 +67,6 @@ public DatabaseToolsModalTabbingTests()
         Services.AddSingleton(Substitute.For<IMenuActionService>());
         Services.AddOperationLogProgressFactoryMock();
 
-        Services.AddFluxor(options => options.ScanAssemblies(typeof(DatabaseToolsModal).Assembly));
     }
 
     [Fact]
diff --git a/tests/Unit/EventLogExpert.UI.Tests/DatabaseTools/DatabaseToolsModalTests.cs b/tests/Unit/EventLogExpert.UI.Tests/DatabaseTools/DatabaseToolsModalTests.cs
index d0a2d682f..3f9a7ee9a 100644
--- a/tests/Unit/EventLogExpert.UI.Tests/DatabaseTools/DatabaseToolsModalTests.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/DatabaseTools/DatabaseToolsModalTests.cs
@@ -9,12 +9,6 @@
 
 namespace EventLogExpert.UI.Tests.DatabaseTools;
 
-/// <summary>
-///     Lifecycle and menu-in-modal infrastructure coverage that goes through the shared <see cref="ModalChrome" />
-///     path. DatabaseToolsModal itself depends on Fluxor + ModalCoordinator plumbing whose isolated coverage already lives
-///     in their respective component tests; the meaningful new contract for #545 is that ANY modal hosted via ModalChrome
-///     now (a) registers an in-dialog MenuHost on open, and (b) unregisters it on dispose.
-/// </summary>
 public sealed class DatabaseToolsModalTests : BunitContext
 {
     public DatabaseToolsModalTests()
@@ -23,8 +17,7 @@ public DatabaseToolsModalTests()
 
         Services.AddBannerHostDependencies();
         Services.AddMenuServiceMock();
-        // Real MenuHostRegistry so the in-dialog MenuHost actually registers itself.
-        Services.AddEventLogUiServices();
+        Services.AddEventLogUIServices();
     }
 
     [Fact]
diff --git a/tests/Unit/EventLogExpert.UI.Tests/DatabaseTools/Tabs/FakeInlineAlertSurface.cs b/tests/Unit/EventLogExpert.UI.Tests/DatabaseTools/Tabs/FakeInlineAlertSurface.cs
index 8ba4bc3ab..4b55d56ed 100644
--- a/tests/Unit/EventLogExpert.UI.Tests/DatabaseTools/Tabs/FakeInlineAlertSurface.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/DatabaseTools/Tabs/FakeInlineAlertSurface.cs
@@ -1,7 +1,7 @@
 // // Copyright (c) Microsoft Corporation.
 // // Licensed under the MIT License.
 
-using EventLogExpert.Runtime.Alerts;
+using EventLogExpert.UI.Alerts;
 using EventLogExpert.UI.DatabaseTools;
 
 namespace EventLogExpert.UI.Tests.DatabaseTools.Tabs;
diff --git a/tests/Unit/EventLogExpert.UI.Tests/DatabaseTools/Tabs/ManageDatabasesTabTests.cs b/tests/Unit/EventLogExpert.UI.Tests/DatabaseTools/Tabs/ManageDatabasesTabTests.cs
index 74c0e9935..8cdeed6d5 100644
--- a/tests/Unit/EventLogExpert.UI.Tests/DatabaseTools/Tabs/ManageDatabasesTabTests.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/DatabaseTools/Tabs/ManageDatabasesTabTests.cs
@@ -3,12 +3,12 @@
 
 using Bunit;
 using EventLogExpert.Logging.Abstractions;
-using EventLogExpert.Runtime.Alerts;
 using EventLogExpert.Runtime.Announcement;
 using EventLogExpert.Runtime.Banner;
 using EventLogExpert.Runtime.Database;
 using EventLogExpert.Runtime.Database.Upgrade;
 using EventLogExpert.Runtime.EventLog;
+using EventLogExpert.UI.Alerts;
 using EventLogExpert.UI.DatabaseTools;
 using EventLogExpert.UI.DatabaseTools.Tabs;
 using EventLogExpert.UI.Tests.TestUtils;
@@ -24,6 +24,11 @@ namespace EventLogExpert.UI.Tests.DatabaseTools.Tabs;
 
 public sealed class ManageDatabasesTabTests : BunitContext
 {
+    private const int LongSettleDelayMilliseconds = 100;
+    private const int ShortSettleDelayMilliseconds = 50;
+
+    private static readonly TimeSpan s_testTimeout = TimeSpan.FromSeconds(2);
+
     private readonly IAnnouncementService _announcementService = Substitute.For<IAnnouncementService>();
     private readonly IDatabaseOperationCoordinator _coordinator = Substitute.For<IDatabaseOperationCoordinator>();
     private readonly FakeDatabaseService _databaseService = new();
@@ -507,7 +512,7 @@ public async Task CancelThenRemove_DuringPreProgressWindow_CancelsActualBatchAnd
 
         var cancelTask = InvokeCancelUpgradesAsync(component, ["b.db"]);
 
-        await Task.Delay(50, TestContext.Current.CancellationToken);
+        await Task.Delay(ShortSettleDelayMilliseconds, TestContext.Current.CancellationToken);
         Assert.True(cancelCalled);
         Assert.False(cancelTask.IsCompleted);
 
@@ -517,7 +522,7 @@ public async Task CancelThenRemove_DuringPreProgressWindow_CancelsActualBatchAnd
                 new UpgradeBatchResult([], ["b.db"], []),
                 wasCancelled: true));
 
-        await cancelTask.WaitAsync(TimeSpan.FromSeconds(2), TestContext.Current.CancellationToken);
+        await cancelTask.WaitAsync(s_testTimeout, TestContext.Current.CancellationToken);
     }
 
     [Fact]
@@ -539,7 +544,7 @@ public async Task CancelThenRemove_FileNotYetReachedInActiveBatch_CancelsBatchAn
 
         var cancelTask = InvokeCancelUpgradesAsync(component, ["c.db"]);
 
-        await Task.Delay(50, TestContext.Current.CancellationToken);
+        await Task.Delay(ShortSettleDelayMilliseconds, TestContext.Current.CancellationToken);
         Assert.True(cancelCalled);
         Assert.False(cancelTask.IsCompleted);
 
@@ -549,7 +554,7 @@ public async Task CancelThenRemove_FileNotYetReachedInActiveBatch_CancelsBatchAn
                 new UpgradeBatchResult([], ["c.db"], []),
                 wasCancelled: true));
 
-        await cancelTask.WaitAsync(TimeSpan.FromSeconds(2), TestContext.Current.CancellationToken);
+        await cancelTask.WaitAsync(s_testTimeout, TestContext.Current.CancellationToken);
     }
 
     [Fact]
@@ -569,7 +574,7 @@ public async Task CancelThenRemove_PreProgressWindow_AwaitsUpgradeBatchCompleted
 
         var cancelTask = InvokeCancelUpgradesAsync(component, ["b.db"]);
 
-        await Task.Delay(100, TestContext.Current.CancellationToken);
+        await Task.Delay(LongSettleDelayMilliseconds, TestContext.Current.CancellationToken);
 
         Assert.False(cancelTask.IsCompleted);
 
@@ -580,10 +585,9 @@ public async Task CancelThenRemove_PreProgressWindow_AwaitsUpgradeBatchCompleted
                 new UpgradeBatchResult([], ["b.db"], []),
                 wasCancelled: true));
 
-        await cancelTask.WaitAsync(TimeSpan.FromSeconds(2), TestContext.Current.CancellationToken);
+        await cancelTask.WaitAsync(s_testTimeout, TestContext.Current.CancellationToken);
         var elapsed = DateTime.UtcNow - beforeRaise;
-        // Must complete well under s_cancelTimeout (30s) — otherwise a hang regression would pass.
-        Assert.True(elapsed < TimeSpan.FromSeconds(2), $"Cancel flow took {elapsed} after batch completion (should be <2s).");
+        Assert.True(elapsed < s_testTimeout, $"Cancel flow took {elapsed} after batch completion (should be <2s).");
     }
 
     [Fact]
@@ -603,7 +607,7 @@ public async Task CancelThenRemove_QueuedBatchFile_AwaitsConsumerPickupAndComple
 
         var cancelTask = InvokeCancelUpgradesAsync(component, ["c.db"]);
 
-        await Task.Delay(100, TestContext.Current.CancellationToken);
+        await Task.Delay(LongSettleDelayMilliseconds, TestContext.Current.CancellationToken);
         Assert.True(cancelCalled);
         Assert.False(cancelTask.IsCompleted);
 
@@ -613,7 +617,7 @@ public async Task CancelThenRemove_QueuedBatchFile_AwaitsConsumerPickupAndComple
                 new UpgradeBatchResult([], ["c.db"], []),
                 wasCancelled: true));
 
-        await cancelTask.WaitAsync(TimeSpan.FromSeconds(2), TestContext.Current.CancellationToken);
+        await cancelTask.WaitAsync(s_testTimeout, TestContext.Current.CancellationToken);
     }
 
     [Fact]
@@ -630,7 +634,6 @@ public async Task ClearSelection_EmptiesSet_HidesBulkStrip()
         await component.InvokeAsync(() => checkboxes[1].ChangeAsync(new ChangeEventArgs { Value = true }));
         Assert.Contains("2 selected", component.Find(".manage-databases-bulk-count").TextContent);
 
-        // Master checkbox in the selection header clears when all are selected.
         var masterBtn = component.Find(".manage-databases-master-btn");
         await component.InvokeAsync(() => masterBtn.Click());
 
@@ -649,7 +652,6 @@ public async Task ClearSelection_UpdatesAriaLiveAnnouncement()
         var liveRegion = component.Find(".manage-databases-tab > span[role='status'][aria-live='polite']");
         Assert.NotEqual(string.Empty, liveRegion.TextContent.Trim());
 
-        // With 1 of 1 selected, master is "all"; clicking clears.
         var masterBtn = component.Find(".manage-databases-master-btn");
         await component.InvokeAsync(() => masterBtn.Click());
 
@@ -780,7 +782,6 @@ public async Task GetUpgradeProgressForEntry_Display_OnlyMatchesCurrentEntryName
     [Fact]
     public void HasDatabaseStateChanged_AfterEnabledEntryRemovedFromActiveSet_True()
     {
-        // Active set was {a}; mutate underlying entries so set becomes {}; flag computed via diff.
         var entry = Entry("a.db", isEnabled: true, status: DatabaseStatus.Ready);
         _databaseService.Entries = [entry];
         var component = Render<ManageDatabasesTab>();
@@ -856,7 +857,6 @@ public void HasDatabaseStateChanged_AfterUpgradeSuccess_True_ViaStickyFlag()
         _databaseService.Entries = [entry];
         var component = Render<ManageDatabasesTab>();
 
-        // Schema migrated in place — entry stays in the active set, but the underlying data changed.
         _databaseService.RaiseUpgradeBatchCompleted(
             new UpgradeBatchCompletedEventArgs(UpgradeBatchId.Create(), new UpgradeBatchResult(["a.db"], [], []), wasCancelled: false));
 
@@ -876,8 +876,6 @@ public void HasDatabaseStateChanged_InitialState_False()
     [Fact]
     public void HasDatabaseStateChanged_PartiallySucceededWasCancelled_True()
     {
-        // Multi-file batch: A succeeds, B is cancelled mid-flight. A's schema is permanently migrated;
-        // flag must fire even though args.WasCancelled is true.
         _databaseService.Entries = [Entry("a.db", isEnabled: true, status: DatabaseStatus.Ready)];
         var component = Render<ManageDatabasesTab>();
 
@@ -893,8 +891,6 @@ public void HasDatabaseStateChanged_PartiallySucceededWasCancelled_True()
     [Fact]
     public void HasDatabaseStateChanged_UpgradeSucceededForDisabledEntry_False()
     {
-        // Background-scope upgrades of disabled (non-active) DBs must not trigger the reload prompt:
-        // the file isn't in the active resolver set, so open logs aren't affected.
         _databaseService.Entries = [Entry("a.db", isEnabled: false, status: DatabaseStatus.Ready)];
         var component = Render<ManageDatabasesTab>();
 
@@ -962,9 +958,6 @@ public async Task MasterCheckbox_ShowsAfterEnteringSelectionMode_BeforeAnySelect
     [Fact]
     public async Task RebaselineActiveSnapshotOnly_PreservesStickyFlags()
     {
-        // Modal opens mid-classification (empty snapshot), user-initiated upgrade succeeds during the
-        // wait (_schemaUpgradeOccurred=true), classification completes. The snapshot rebaselines but
-        // the sticky flag must survive so the close-time reload prompt still fires.
         var tcs = new TaskCompletionSource();
         _databaseService.InitialClassificationTask = tcs.Task;
         _databaseService.Entries = [Entry("a.db", isEnabled: true, status: DatabaseStatus.Ready)];
@@ -976,7 +969,7 @@ public async Task RebaselineActiveSnapshotOnly_PreservesStickyFlags()
         Assert.True(component.Instance.HasDatabaseStateChanged);
 
         tcs.SetResult();
-        await Task.Delay(50, TestContext.Current.CancellationToken);
+        await Task.Delay(ShortSettleDelayMilliseconds, TestContext.Current.CancellationToken);
 
         Assert.True(component.Instance.HasDatabaseStateChanged);
     }
@@ -1148,8 +1141,6 @@ await component.InvokeAsync(() =>
     [Fact]
     public async Task RestoreFromBackup_WhileUpgradeInFlight_DoesNotInvokeService()
     {
-        // Prevents the race where DatabaseRecoveryService.RestoreFromBackupAsync triggers
-        // ClassifyEntriesAsync, deleting a .upgrade.bak that an in-flight upgrade still needs.
         _databaseService.Entries = [Entry("a.db", isEnabled: true, status: DatabaseStatus.UpgradeRequired, backupExists: true)];
         _coordinator.IsAnyUpgradeInFlight.Returns(true);
         var component = Render<ManageDatabasesTab>();
@@ -1224,7 +1215,6 @@ public async Task SelectAll_AddsEveryEntryToSelection()
         var component = Render<ManageDatabasesTab>();
         await EnterSelectionModeAsync(component);
 
-        // Master checkbox: 0 selected → click selects all.
         var masterBtn = component.Find(".manage-databases-master-btn");
         await component.InvokeAsync(() => masterBtn.Click());
 
@@ -1253,6 +1243,43 @@ public async Task SingleRowRemove_DuringCoordinatorUpgrade_DualSignal_Acceptance
         Assert.Contains("upgrade", captured.AcceptLabel ?? string.Empty, StringComparison.OrdinalIgnoreCase);
     }
 
+    [Fact]
+    public async Task ToggleSelectionMode_EntersMode_RevealsCheckboxes_ChangesLabelToDone()
+    {
+        _databaseService.Entries = [Entry("a.db", isEnabled: false, status: DatabaseStatus.Ready)];
+        var component = Render<ManageDatabasesTab>();
+
+        var wrapper = component.Find(".db-entry-checkbox");
+        Assert.DoesNotContain("db-entry-checkbox--visible", wrapper.GetAttribute("class") ?? string.Empty);
+
+        await EnterSelectionModeAsync(component);
+
+        var selectBtn = component.Find("#manage-select-button");
+        Assert.Equal("true", selectBtn.GetAttribute("aria-pressed"));
+        Assert.Contains("Done", selectBtn.TextContent);
+
+        wrapper = component.Find(".db-entry-checkbox");
+        Assert.Contains("db-entry-checkbox--visible", wrapper.GetAttribute("class") ?? string.Empty);
+    }
+
+    [Fact]
+    public async Task ToggleSelectionMode_Exits_ClearsSelection()
+    {
+        _databaseService.Entries = [Entry("a.db", isEnabled: false, status: DatabaseStatus.Ready)];
+        var component = Render<ManageDatabasesTab>();
+
+        await EnterSelectionModeAsync(component);
+        await component.InvokeAsync(() => component.Find(".db-entry-row input[type='checkbox']")
+            .ChangeAsync(new ChangeEventArgs { Value = true }));
+        Assert.True(component.Instance.HasBulkSelection);
+
+        await EnterSelectionModeAsync(component);
+
+        Assert.False(component.Instance.HasBulkSelection);
+        var selectBtn = component.Find("#manage-select-button");
+        Assert.Equal("false", selectBtn.GetAttribute("aria-pressed"));
+    }
+
     [Fact]
     public async Task ToggleSelection_AddsToSelection_RevealsBulkStrip()
     {
@@ -1328,43 +1355,6 @@ public async Task ToggleSelection_UpdatesAriaLiveAnnouncement()
         Assert.Contains("2", liveRegion.TextContent);
     }
 
-    [Fact]
-    public async Task ToggleSelectionMode_EntersMode_RevealsCheckboxes_ChangesLabelToDone()
-    {
-        _databaseService.Entries = [Entry("a.db", isEnabled: false, status: DatabaseStatus.Ready)];
-        var component = Render<ManageDatabasesTab>();
-
-        var wrapper = component.Find(".db-entry-checkbox");
-        Assert.DoesNotContain("db-entry-checkbox--visible", wrapper.GetAttribute("class") ?? string.Empty);
-
-        await EnterSelectionModeAsync(component);
-
-        var selectBtn = component.Find("#manage-select-button");
-        Assert.Equal("true", selectBtn.GetAttribute("aria-pressed"));
-        Assert.Contains("Done", selectBtn.TextContent);
-
-        wrapper = component.Find(".db-entry-checkbox");
-        Assert.Contains("db-entry-checkbox--visible", wrapper.GetAttribute("class") ?? string.Empty);
-    }
-
-    [Fact]
-    public async Task ToggleSelectionMode_Exits_ClearsSelection()
-    {
-        _databaseService.Entries = [Entry("a.db", isEnabled: false, status: DatabaseStatus.Ready)];
-        var component = Render<ManageDatabasesTab>();
-
-        await EnterSelectionModeAsync(component);
-        await component.InvokeAsync(() => component.Find(".db-entry-row input[type='checkbox']")
-            .ChangeAsync(new ChangeEventArgs { Value = true }));
-        Assert.True(component.Instance.HasBulkSelection);
-
-        await EnterSelectionModeAsync(component);
-
-        Assert.False(component.Instance.HasBulkSelection);
-        var selectBtn = component.Find("#manage-select-button");
-        Assert.Equal("false", selectBtn.GetAttribute("aria-pressed"));
-    }
-
     private static async Task EnterSelectionModeAsync(IRenderedComponent<ManageDatabasesTab> component)
     {
         await component.InvokeAsync(() => component.Find("#manage-select-button").Click());
@@ -1377,8 +1367,6 @@ private static Task InvokeCancelUpgradesAsync(
         IRenderedComponent<ManageDatabasesTab> component,
         IReadOnlyList<string> fileNames)
     {
-        // Reflection bypasses the bunit click + alert-surface chain so the test can deterministically
-        // interleave the batch-completion signal with the await on pendingBatches.
         var method = typeof(ManageDatabasesTab).GetMethod(
             "CancelUpgradesAndAwaitCompletionAsync",
             BindingFlags.Instance | BindingFlags.NonPublic);
@@ -1390,8 +1378,6 @@ private static Task InvokeRemoveDatabaseAsync(
         IRenderedComponent<ManageDatabasesTab> component,
         DatabaseEntry entry)
     {
-        // Single-row remove is now triggered via the right-click context menu; invoke
-        // the private path directly to keep tests focused on remove semantics.
         var method = typeof(ManageDatabasesTab).GetMethod(
             "RemoveDatabase",
             BindingFlags.Instance | BindingFlags.NonPublic);
diff --git a/tests/Unit/EventLogExpert.UI.Tests/DebugLog/DebugLogModalTests.cs b/tests/Unit/EventLogExpert.UI.Tests/DebugLog/DebugLogModalTests.cs
index df1f326a6..a61a5a2f5 100644
--- a/tests/Unit/EventLogExpert.UI.Tests/DebugLog/DebugLogModalTests.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/DebugLog/DebugLogModalTests.cs
@@ -7,11 +7,10 @@
 using EventLogExpert.Runtime.Common.Clipboard;
 using EventLogExpert.Runtime.Common.Files;
 using EventLogExpert.Runtime.DebugLog;
-using EventLogExpert.Runtime.Modal;
 using EventLogExpert.UI.DebugLog;
+using EventLogExpert.UI.Modal;
 using EventLogExpert.UI.Tests.TestUtils;
 using EventLogExpert.UI.Tests.TestUtils.Constants;
-using Fluxor;
 using Microsoft.AspNetCore.Components;
 using Microsoft.AspNetCore.Components.Web;
 using Microsoft.Extensions.DependencyInjection;
@@ -42,7 +41,6 @@ public DebugLogModalTests()
         Services.AddSingleton(_fileSaveService);
         Services.AddSingleton(_modalCoordinator);
         Services.AddSingleton(_modalService);
-        Services.AddFluxor(options => options.ScanAssemblies(typeof(DebugLogModal).Assembly));
 
         JSInterop.Mode = JSRuntimeMode.Loose;
     }
@@ -91,8 +89,6 @@ public async Task DebugLogModal_AfterLoad_VirtualizeItemsAreNewestFirstAndPreser
         const string ContinuationLine = "  at MyMethod()";
         var thirdHeader = DebugLogUtils.BuildLine(LogLevel.Information, Constants.DebugLogThirdMessage);
 
-        // The reader yields NEWEST-first, so the mock returns the file's lines reversed; the parser reassembles the
-        // second entry's continuation and the viewer renders newest-first with continuation lines in natural order.
         _debugLogReader.LoadAsync(Arg.Any<CancellationToken>()).Returns(
             DebugLogUtils.ToAsyncEnumerable([thirdHeader, ContinuationLine, secondHeader, firstHeader]));
 
@@ -123,7 +119,6 @@ public async Task DebugLogModal_CancelEditing_EditedChip_RevertsToAppliedForm()
         await component.WaitForAssertionAsync(() =>
             Assert.Equal("2 of 2 entries", component.Find(".debug-log-footer-counter").TextContent.Trim()));
 
-        // Apply A (contains "foo") -> 1 of 2, chip shows "Message contains foo".
         await AddFilterAsync(component);
         await component.Find("input[aria-label='Filter value']").ChangeAsync(new ChangeEventArgs { Value = "foo" });
         await SaveFilterAsync(component);
@@ -131,8 +126,6 @@ await component.WaitForAssertionAsync(() =>
         await component.WaitForAssertionAsync(() =>
             Assert.Equal("1 of 2 entries", component.Find(".debug-log-footer-counter").TextContent.Trim()));
 
-        // Re-open the chip (edit-on-copy) and change the value to "bar", then Cancel. The applied form must be
-        // untouched: the chip still reads "Message contains foo" and the projection stays 1 of 2.
         await component.Find(".debug-log-filter-chip-edit").ClickAsync(new MouseEventArgs());
         await component.Find("input[aria-label='Filter value']").ChangeAsync(new ChangeEventArgs { Value = "bar" });
         await component.Find("button[aria-label='Cancel edit']").ClickAsync(new MouseEventArgs());
@@ -238,8 +231,6 @@ await component.WaitForAssertionAsync(() =>
         await AddFilterAsync(component);
         await SelectOptionAsync(component, "Filter field", "Category");
 
-        // Regression: with nothing selected the value header must be blank, not the "(Uncategorized)" sentinel
-        // label, and nothing is applied yet so all entries remain visible.
         var valueHeader = component.Find("input[aria-label='Filter value']");
         Assert.True(
             string.IsNullOrEmpty(valueHeader.GetAttribute("value")),
@@ -281,7 +272,6 @@ await component.WaitForAssertionAsync(() =>
         await component.WaitForAssertionAsync(() =>
             Assert.Equal("2 of 3 entries", component.Find(".debug-log-footer-counter").TextContent.Trim()));
 
-        // The chip exclude toggle acts on the applied filter, so it re-projects immediately.
         await component.Find("button[aria-label='Filter is included; activate to exclude']").ClickAsync(new MouseEventArgs());
 
         await component.WaitForAssertionAsync(() =>
@@ -304,7 +294,6 @@ public async Task DebugLogModal_ClearFilters_RemovesAllRowsAndShowsAllEntries()
         await component.WaitForAssertionAsync(() =>
             Assert.Equal("2 of 2 entries", component.Find(".debug-log-footer-counter").TextContent.Trim()));
 
-        // Apply two filters (A: contains "foo", B: Level == Error) -> both narrow to 0 of 2 (no line is both).
         await AddFilterAsync(component);
         await component.Find("input[aria-label='Filter value']").ChangeAsync(new ChangeEventArgs { Value = "foo" });
         await SaveFilterAsync(component);
@@ -417,7 +406,6 @@ await component.WaitForAssertionAsync(() =>
         await component.WaitForAssertionAsync(() =>
             Assert.Equal("2 of 2 entries", component.Find(".debug-log-footer-counter").TextContent.Trim()));
 
-        // Editing then saving a disabled filter must not silently re-enable it.
         await component.Find("button[aria-label='Edit filter: Message contains foo']").ClickAsync(new MouseEventArgs());
         await SaveFilterAsync(component);
 
@@ -451,7 +439,6 @@ await component.WaitForAssertionAsync(() =>
         await component.WaitForAssertionAsync(() =>
             Assert.Equal("1 of 2 entries", component.Find(".debug-log-footer-counter").TextContent.Trim()));
 
-        // Disabling the chip drops it from the projection live; re-enabling restores it.
         await component.Find("button[aria-label='Filter is enabled; activate to disable']").ClickAsync(new MouseEventArgs());
 
         await component.WaitForAssertionAsync(() =>
@@ -509,7 +496,6 @@ await component.WaitForAssertionAsync(() =>
 
         await component.Find("input[aria-label='Filter value']").ChangeAsync(new ChangeEventArgs { Value = "foo" });
 
-        // Configuring the value does not change the projection until Save is clicked.
         Assert.Equal("2 of 2 entries", component.Find(".debug-log-footer-counter").TextContent.Trim());
 
         await SaveFilterAsync(component);
@@ -518,32 +504,6 @@ await component.WaitForAssertionAsync(() =>
             Assert.Equal("1 of 2 entries", component.Find(".debug-log-footer-counter").TextContent.Trim()));
     }
 
-    [Fact]
-    public async Task DebugLogModal_MultipleEditorsOpenSimultaneously()
-    {
-        var lines = new[]
-        {
-            DebugLogUtils.BuildLine(LogLevel.Information, "alpha foo"),
-            DebugLogUtils.BuildLine(LogLevel.Information, "bravo bar"),
-        };
-
-        _debugLogReader.LoadAsync(Arg.Any<CancellationToken>()).Returns(DebugLogUtils.ToAsyncEnumerable(lines));
-
-        var component = Render<DebugLogModal>();
-
-        await component.WaitForAssertionAsync(() =>
-            Assert.Equal("2 of 2 entries", component.Find(".debug-log-footer-counter").TextContent.Trim()));
-
-        // Adding a second filter while the first is still being edited keeps both editors open (no block, no
-        // implicit collapse); neither is applied until its own Save.
-        await AddFilterAsync(component);
-        await AddFilterAsync(component);
-
-        Assert.Equal(2, component.FindAll(".debug-log-filter-editor").Count);
-        Assert.Empty(component.FindAll(".debug-log-filter-chip"));
-        Assert.Equal("2 of 2 entries", component.Find(".debug-log-footer-counter").TextContent.Trim());
-    }
-
     [Fact]
     public async Task DebugLogModal_MultiSelectThenSingleOperator_DropsStaleValues()
     {
@@ -571,8 +531,6 @@ await component.WaitForAssertionAsync(() =>
         await component.WaitForAssertionAsync(() =>
             Assert.Equal("2 of 3 entries", component.Find(".debug-log-footer-counter").TextContent.Trim()));
 
-        // Re-open the chip and switch Is Any Of -> Equals; the stale second value is dropped so only Error
-        // (the first value) remains after Save.
         await component.Find(".debug-log-filter-chip-edit").ClickAsync(new MouseEventArgs());
         await SelectOptionAsync(component, "Filter operator", "Equals");
         await SaveFilterAsync(component);
@@ -581,6 +539,30 @@ await component.WaitForAssertionAsync(() =>
             Assert.Equal("1 of 3 entries", component.Find(".debug-log-footer-counter").TextContent.Trim()));
     }
 
+    [Fact]
+    public async Task DebugLogModal_MultipleEditorsOpenSimultaneously()
+    {
+        var lines = new[]
+        {
+            DebugLogUtils.BuildLine(LogLevel.Information, "alpha foo"),
+            DebugLogUtils.BuildLine(LogLevel.Information, "bravo bar"),
+        };
+
+        _debugLogReader.LoadAsync(Arg.Any<CancellationToken>()).Returns(DebugLogUtils.ToAsyncEnumerable(lines));
+
+        var component = Render<DebugLogModal>();
+
+        await component.WaitForAssertionAsync(() =>
+            Assert.Equal("2 of 2 entries", component.Find(".debug-log-footer-counter").TextContent.Trim()));
+
+        await AddFilterAsync(component);
+        await AddFilterAsync(component);
+
+        Assert.Equal(2, component.FindAll(".debug-log-filter-editor").Count);
+        Assert.Empty(component.FindAll(".debug-log-filter-chip"));
+        Assert.Equal("2 of 2 entries", component.Find(".debug-log-footer-counter").TextContent.Trim());
+    }
+
     [Fact]
     public async Task DebugLogModal_ProcessEqualsFilter_NarrowsToSelectedOrigin()
     {
@@ -624,7 +606,6 @@ public async Task DebugLogModal_RefreshWhileEditing_ProjectsAppliedNotEditedCopy
         await component.WaitForAssertionAsync(() =>
             Assert.Equal("3 of 3 entries", component.Find(".debug-log-footer-counter").TextContent.Trim()));
 
-        // Apply A: contains "foo" -> 2 of 3.
         await AddFilterAsync(component);
         await component.Find("input[aria-label='Filter value']").ChangeAsync(new ChangeEventArgs { Value = "foo" });
         await SaveFilterAsync(component);
@@ -632,8 +613,6 @@ await component.WaitForAssertionAsync(() =>
         await component.WaitForAssertionAsync(() =>
             Assert.Equal("2 of 3 entries", component.Find(".debug-log-footer-counter").TextContent.Trim()));
 
-        // Re-open A and edit the copy to "bar" WITHOUT Save, then Refresh. Refresh must project A's applied "foo"
-        // form (2 of 3), not the edited copy "bar" (which would be 1 of 3).
         await component.Find(".debug-log-filter-chip-edit").ClickAsync(new MouseEventArgs());
         await component.Find("input[aria-label='Filter value']").ChangeAsync(new ChangeEventArgs { Value = "bar" });
         await FindButton(component, "Refresh").ClickAsync(new MouseEventArgs());
@@ -665,7 +644,6 @@ await component.WaitForAssertionAsync(() =>
         await component.WaitForAssertionAsync(() =>
             Assert.Equal("1 of 2 entries", component.Find(".debug-log-footer-counter").TextContent.Trim()));
 
-        // Removing the applied chip re-projects live.
         await component.Find(".debug-log-filter-chip-remove").ClickAsync(new MouseEventArgs());
 
         await component.WaitForAssertionAsync(() =>
diff --git a/tests/Unit/EventLogExpert.UI.Tests/DependencyInjection/UIServiceCollectionExtensionsTests.cs b/tests/Unit/EventLogExpert.UI.Tests/DependencyInjection/UIServiceCollectionExtensionsTests.cs
new file mode 100644
index 000000000..bd15d60e4
--- /dev/null
+++ b/tests/Unit/EventLogExpert.UI.Tests/DependencyInjection/UIServiceCollectionExtensionsTests.cs
@@ -0,0 +1,70 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.UI.Menu;
+using EventLogExpert.UI.Modal;
+using Microsoft.Extensions.DependencyInjection;
+using NSubstitute;
+
+namespace EventLogExpert.UI.Tests.DependencyInjection;
+
+public sealed class UIServiceCollectionExtensionsTests
+{
+    public static TheoryData<Type> RelocatedServiceTypes =>
+        [typeof(IMenuService), typeof(IModalCoordinator), typeof(IModalService)];
+
+    [Fact]
+    public void AddEventLogUIServices_KeepsImplementationsTheHostAlreadySupplied()
+    {
+        IMenuService menuService = Substitute.For<IMenuService>();
+        IModalCoordinator modalCoordinator = Substitute.For<IModalCoordinator>();
+        IModalService modalService = Substitute.For<IModalService>();
+
+        ServiceCollection services = new();
+        services.AddSingleton(menuService);
+        services.AddSingleton(modalCoordinator);
+        services.AddSingleton(modalService);
+
+        services.AddEventLogUIServices();
+
+        Assert.Same(menuService, SingleDescriptorFor<IMenuService>(services).ImplementationInstance);
+        Assert.Same(modalCoordinator, SingleDescriptorFor<IModalCoordinator>(services).ImplementationInstance);
+        Assert.Same(modalService, SingleDescriptorFor<IModalService>(services).ImplementationInstance);
+
+        using ServiceProvider provider = services.BuildServiceProvider();
+
+        Assert.Same(menuService, provider.GetRequiredService<IMenuService>());
+        Assert.Same(modalCoordinator, provider.GetRequiredService<IModalCoordinator>());
+        Assert.Same(modalService, provider.GetRequiredService<IModalService>());
+    }
+
+    [Fact]
+    public void AddEventLogUIServices_RegistersMenuAndModalImplementations()
+    {
+        ServiceCollection services = new();
+
+        services.AddEventLogUIServices();
+
+        using ServiceProvider provider = services.BuildServiceProvider();
+
+        Assert.IsType<MenuService>(provider.GetRequiredService<IMenuService>());
+        Assert.IsType<ModalService>(provider.GetRequiredService<IModalService>());
+        Assert.IsType<ModalCoordinator>(provider.GetRequiredService<IModalCoordinator>());
+    }
+
+    [Theory]
+    [MemberData(nameof(RelocatedServiceTypes))]
+    public void AddEventLogUIServices_RegistersRelocatedServicesAsSingletons(Type serviceType)
+    {
+        ServiceCollection services = new();
+
+        services.AddEventLogUIServices();
+
+        ServiceDescriptor descriptor = Assert.Single(services, candidate => candidate.ServiceType == serviceType);
+
+        Assert.Equal(ServiceLifetime.Singleton, descriptor.Lifetime);
+    }
+
+    private static ServiceDescriptor SingleDescriptorFor<TService>(IServiceCollection services) =>
+        Assert.Single(services, candidate => candidate.ServiceType == typeof(TService));
+}
diff --git a/tests/Unit/EventLogExpert.UI.Tests/DetailsPane/DetailsPaneTests.cs b/tests/Unit/EventLogExpert.UI.Tests/DetailsPane/DetailsPaneTests.cs
index b730ccf51..6e96e51a3 100644
--- a/tests/Unit/EventLogExpert.UI.Tests/DetailsPane/DetailsPaneTests.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/DetailsPane/DetailsPaneTests.cs
@@ -19,18 +19,19 @@
 using Fluxor;
 using Microsoft.Extensions.DependencyInjection;
 using NSubstitute;
+using System.Collections.Immutable;
 using DetailsPaneComponent = EventLogExpert.UI.DetailsPane.DetailsPane;
 
 namespace EventLogExpert.UI.Tests.DetailsPane;
 
 public sealed class DetailsPaneTests : BunitContext
 {
-    private readonly IStateSelection<LogTableState, EventLogId?> _activeLog = Substitute.For<IStateSelection<LogTableState, EventLogId?>>();
+    private readonly IActiveEventLogSource _activeEventLog = Substitute.For<IActiveEventLogSource>();
     private readonly IClipboardService _clipboard = Substitute.For<IClipboardService>();
+    private readonly IEventDetailResolver _detailResolver = Substitute.For<IEventDetailResolver>();
+    private readonly IEventFocusSource _eventFocus = Substitute.For<IEventFocusSource>();
     private readonly IFilterLensCommands _filterLensCommands = Substitute.For<IFilterLensCommands>();
-    private readonly IStateSelection<EventLogState, SelectionEntry?> _focus = Substitute.For<IStateSelection<EventLogState, SelectionEntry?>>();
     private readonly EventLogId _logId = EventLogId.Create();
-    private readonly IState<LogTableState> _logTableState = Substitute.For<IState<LogTableState>>();
     private readonly IDetailsPanePreferencesProvider _preferences = Substitute.For<IDetailsPanePreferencesProvider>();
     private readonly ISettingsService _settings = Substitute.For<ISettingsService>();
     private readonly ITraceLogger _traceLogger = Substitute.For<ITraceLogger>();
@@ -42,18 +43,17 @@ public DetailsPaneTests()
         JSInterop.SetupModule("./_content/EventLogExpert.UI/DetailsPane/DetailsPane.razor.js");
 
         _settings.TimeZoneInfo.Returns(TimeZoneInfo.Utc);
-        _focus.Value.Returns((SelectionEntry?)null);
+        _eventFocus.Current.Returns((SelectionEntry?)null);
 
-        Services.AddSingleton(_activeLog);
+        Services.AddSingleton(_activeEventLog);
         Services.AddSingleton(_clipboard);
         Services.AddSingleton(_filterLensCommands);
-        Services.AddSingleton(_focus);
-        Services.AddSingleton(_logTableState);
+        Services.AddSingleton(_eventFocus);
+        Services.AddSingleton(_detailResolver);
         Services.AddSingleton(_preferences);
         Services.AddSingleton(_settings);
         Services.AddSingleton(_traceLogger);
         Services.AddSingleton(_xmlResolver);
-        Services.AddFluxor(options => options.ScanAssemblies(typeof(DetailsPaneComponent).Assembly));
     }
 
     [Fact]
@@ -100,7 +100,6 @@ public void CollapsedPane_StaysCollapsedOnNextSelection_WhenPreferenceOff()
         var @event = EventWithData(("LogonType", 3));
         var cut = SelectAndRender(@event);
 
-        // User collapses the pane, then a later selection arrives: it must respect the collapse.
         cut.Find("#details-header").Click();
         Assert.Equal("false", cut.Find(".details-pane").GetAttribute("data-toggle"));
 
@@ -146,7 +145,6 @@ public void CorrelationButtons_DispatchLensCommandsForSelectedEventAndOwningLog(
 
         Assert.Equal(2, cut.FindAll(".details-correlation-action").Count);
 
-        // Re-issue FindAll before each click: the first click re-renders, which invalidates handler ids captured earlier.
         cut.FindAll(".details-correlation-action")[0].Click();
         cut.FindAll(".details-correlation-action")[1].Click();
 
@@ -165,8 +163,6 @@ public void CorrelationSection_HiddenWhenNoActivityIds()
     [Fact]
     public void CorrelationSection_ShownForGuidEmptyActivityId_MirroringContextMenu()
     {
-        // The log-table context menu enables its lens items on Guid?.HasValue (so a zero-Guid still enables); the pane
-        // mirrors that, keeping the two surfaces consistent.
         ResolvedEvent @event = BaseEvent() with { ActivityId = Guid.Empty };
 
         var cut = SelectAndRender(@event);
@@ -243,12 +239,61 @@ public void PerFieldCopy_UsesTheClickedFieldsValue()
         cut.FindAll(".details-copy")[0].Click();
         cut.FindAll(".details-copy")[1].Click();
 
-        // A shared-variable closure capture would make every field's button emit the last field's value, so asserting
-        // each row copies its OWN value discriminates that regression.
         _clipboard.Received(1).CopyTextAsync("SYSTEM");
         _clipboard.Received(1).CopyTextAsync("ADMIN");
     }
 
+    [Fact]
+    public void Render_WhileFocusLagsItsReaction_BlanksThePriorPayloadButKeepsThePane()
+    {
+        var a = BaseEvent() with { Id = 1001, Xml = "<EventA/>" };
+        var b = BaseEvent() with { Id = 1002, Xml = "<EventB/>" };
+        var handleA = new EventLocator(_logId, 0, 0);
+        var handleB = new EventLocator(_logId, 0, 1);
+        StubResolution(handleA, a);
+        StubResolution(handleB, b);
+
+        _eventFocus.Current.Returns(new SelectionEntry(handleA, handleA, null));
+        var cut = Render<DetailsPaneComponent>();
+        cut.WaitForAssertion(() => Assert.Contains("Event ID 1001", cut.Markup));
+
+        _eventFocus.Current.Returns(new SelectionEntry(handleB, handleB, null));
+
+        int rendersBefore = cut.RenderCount;
+        _activeEventLog.Changed += Raise.Event<Action>();
+        cut.WaitForState(() => cut.RenderCount > rendersBefore);
+
+        Assert.DoesNotContain("Event ID 1001", cut.Markup);
+        Assert.False(cut.Find(".details-pane").HasAttribute("hidden"));
+
+        _eventFocus.Changed += Raise.Event<Action>();
+        cut.WaitForAssertion(() => Assert.Contains("Event ID 1002", cut.Markup));
+    }
+
+    [Fact]
+    public void RetainedFocus_ResolvesThroughTheRawStore_WithNoDisplayViewInPlay()
+    {
+        var @event = BaseEvent();
+        var logId = EventLogId.Create();
+        var rawStore = Substitute.For<IState<RawEventStoreState>>();
+
+        rawStore.Value.Returns(new RawEventStoreState
+        {
+            ByLog = ImmutableDictionary<EventLogId, EventColumnStore>.Empty
+                .Add(logId, EventColumnStore.Build([@event], 0, 0))
+        });
+
+        Services.AddSingleton<IEventDetailResolver>(new EventDetailResolver(rawStore));
+
+        var handle = new EventLocator(logId, 0, 0);
+        ValueKey.TryCreate(@event, out var reloadKey);
+        _eventFocus.Current.Returns(new SelectionEntry(handle, handle, reloadKey));
+
+        var cut = Render<DetailsPaneComponent>();
+
+        Assert.Contains(@event.Id.ToString(), cut.Markup);
+    }
+
     [Fact]
     public void SelectedEvent_DefaultsToReaderTab()
     {
@@ -295,7 +340,6 @@ public void SeverityIcon_ShownWithDistinctShapeForKnownLevels(string level, stri
     [Fact]
     public void ShowMoreToggle_ExposesExpandedStateToAssistiveTech()
     {
-        // A 600-char scalar exceeds the preview length, so the field renders the Show more / Show less toggle.
         var cut = SelectAndRender(EventWithData(("CommandLine", new string('a', 600))));
 
         IElement toggle = cut.Find(".details-show-more");
@@ -325,7 +369,8 @@ public void TabResetsToReader_WhenActiveLogChanges()
         var cut = SelectAndRender(EventWithData(("LogonType", 3)));
         XmlTab(cut).Click();
 
-        _activeLog.SelectedValueChanged += Raise.Event<EventHandler<EventLogId?>>(_activeLog, (EventLogId?)EventLogId.Create());
+        _activeEventLog.Current.Returns(EventLogId.Create());
+        _activeEventLog.Changed += Raise.Event<Action>();
 
         cut.WaitForAssertion(() => Assert.Equal("true", ReaderTab(cut).GetAttribute("aria-selected")));
     }
@@ -335,8 +380,6 @@ public void Tabs_AreLinkedToTheirPanelsViaAria()
     {
         var cut = SelectAndRender(EventWithData(("LogonType", 3)));
 
-        // Both tabpanels stay mounted (only hidden toggles), so every tab's aria-controls resolves to a panel that is
-        // actually in the DOM, and each panel points back at its controlling tab.
         Assert.Equal("details-tabpanel-reader", cut.Find("#details-tab-reader").GetAttribute("aria-controls"));
         Assert.Equal("details-tab-reader", cut.Find("#details-tabpanel-reader").GetAttribute("aria-labelledby"));
         Assert.Equal("details-tabpanel-xml", cut.Find("#details-tab-xml").GetAttribute("aria-controls"));
@@ -357,6 +400,81 @@ public void UserDataIncomplete_ShowsWarning()
         Assert.NotEmpty(cut.FindAll(".details-warn"));
     }
 
+    [Fact]
+    public void Xml_ResolvesAsynchronously_ReplacingTheLoadingSentinel()
+    {
+        var @event = BaseEvent() with { Xml = "" };
+        var handle = new EventLocator(_logId, 0, 0);
+        var resolution = new TaskCompletionSource<string>(TaskCreationOptions.RunContinuationsAsynchronously);
+        StubResolution(handle, @event);
+        _xmlResolver.GetXmlAsync(Arg.Any<ResolvedEvent>(), Arg.Any<CancellationToken>()).Returns(new ValueTask<string>(resolution.Task));
+        _eventFocus.Current.Returns(new SelectionEntry(handle, handle, null));
+
+        var cut = Render<DetailsPaneComponent>();
+        XmlTab(cut).Click();
+        cut.WaitForAssertion(() => Assert.Contains("Resolving XML", cut.Markup));
+
+        resolution.SetResult("<AsyncResolved/>");
+
+        cut.WaitForAssertion(() => Assert.Contains("AsyncResolved", cut.Markup));
+    }
+
+    [Fact]
+    public void Xml_StaleResolution_IsDiscarded_WhenFocusChangesMidFetch()
+    {
+        var first = BaseEvent() with { Id = 1001, Xml = "" };
+        var second = BaseEvent() with { Id = 1002, Xml = "" };
+        var firstHandle = new EventLocator(_logId, 0, 0);
+        var secondHandle = new EventLocator(_logId, 0, 1);
+        var firstFetch = new TaskCompletionSource<string>(TaskCreationOptions.RunContinuationsAsynchronously);
+        var secondFetch = new TaskCompletionSource<string>(TaskCreationOptions.RunContinuationsAsynchronously);
+        StubResolution(firstHandle, first);
+        StubResolution(secondHandle, second);
+        _xmlResolver.GetXmlAsync(Arg.Is<ResolvedEvent>(e => e != null && e.Id == 1001), Arg.Any<CancellationToken>()).Returns(new ValueTask<string>(firstFetch.Task));
+        _xmlResolver.GetXmlAsync(Arg.Is<ResolvedEvent>(e => e != null && e.Id == 1002), Arg.Any<CancellationToken>()).Returns(new ValueTask<string>(secondFetch.Task));
+
+        _eventFocus.Current.Returns(new SelectionEntry(firstHandle, firstHandle, null));
+        var cut = Render<DetailsPaneComponent>();
+        XmlTab(cut).Click();
+        cut.WaitForAssertion(() => Assert.Contains("Resolving XML", cut.Markup));
+
+        _eventFocus.Current.Returns(new SelectionEntry(secondHandle, secondHandle, null));
+        _eventFocus.Changed += Raise.Event<Action>();
+        secondFetch.SetResult("<SecondEventXml/>");
+        cut.WaitForAssertion(() => Assert.Contains("SecondEventXml", cut.Markup));
+
+        var renderCountBeforeStale = cut.RenderCount;
+        firstFetch.SetResult("<FirstEventXml/>");
+        cut.WaitForState(() => cut.RenderCount > renderCountBeforeStale);
+
+        Assert.Contains("SecondEventXml", cut.Markup);
+        Assert.DoesNotContain("FirstEventXml", cut.Markup);
+    }
+
+    [Fact]
+    public void Xml_StaleResolution_IsDiscarded_WhenSourceAdoptsNewFocusBeforeItsReactionRuns()
+    {
+        var @event = BaseEvent() with { Id = 1001, Xml = "" };
+        var handle = new EventLocator(_logId, 0, 0);
+        var otherHandle = new EventLocator(_logId, 0, 1);
+        var fetch = new TaskCompletionSource<string>(TaskCreationOptions.RunContinuationsAsynchronously);
+        StubResolution(handle, @event);
+        _xmlResolver.GetXmlAsync(Arg.Any<ResolvedEvent>(), Arg.Any<CancellationToken>()).Returns(new ValueTask<string>(fetch.Task));
+
+        _eventFocus.Current.Returns(new SelectionEntry(handle, handle, null));
+        var cut = Render<DetailsPaneComponent>();
+        XmlTab(cut).Click();
+        cut.WaitForAssertion(() => Assert.Contains("Resolving XML", cut.Markup));
+
+        _eventFocus.Current.Returns(new SelectionEntry(otherHandle, otherHandle, null));
+
+        var renderCountBefore = cut.RenderCount;
+        fetch.SetResult("<StaleEventXml/>");
+        cut.WaitForState(() => cut.RenderCount > renderCountBefore);
+
+        Assert.DoesNotContain("StaleEventXml", cut.Markup);
+    }
+
     private static ResolvedEvent BaseEvent() =>
         new("Application", LogPathType.Channel)
         {
@@ -380,17 +498,27 @@ private void RaiseFocusChanged(ResolvedEvent @event)
     {
         var handle = new EventLocator(_logId, 0, 0);
         ValueKey.TryCreate(@event, out var reloadKey);
-        _focus.SelectedValueChanged += Raise.Event<EventHandler<SelectionEntry?>>(_focus, new SelectionEntry(handle, handle, reloadKey));
+        StubResolution(handle, @event);
+        _eventFocus.Current.Returns(new SelectionEntry(handle, handle, reloadKey));
+        _eventFocus.Changed += Raise.Event<Action>();
     }
 
     private IRenderedComponent<DetailsPaneComponent> SelectAndRender(ResolvedEvent @event)
     {
-        _logTableState.Value.Returns(new LogTableState { ActiveEventLogId = _logId }.WithLogEvents(_logId, @event));
-
         var handle = new EventLocator(_logId, 0, 0);
         ValueKey.TryCreate(@event, out var reloadKey);
-        _focus.Value.Returns(new SelectionEntry(handle, handle, reloadKey));
+        StubResolution(handle, @event);
+        _eventFocus.Current.Returns(new SelectionEntry(handle, handle, reloadKey));
 
         return Render<DetailsPaneComponent>();
     }
+
+    private void StubResolution(EventLocator handle, ResolvedEvent @event) =>
+        _detailResolver.TryResolve(handle, out Arg.Any<ResolvedEvent?>())
+            .Returns(call =>
+            {
+                call[1] = @event;
+
+                return true;
+            });
 }
diff --git a/tests/Unit/EventLogExpert.UI.Tests/EventLogExpert.UI.Tests.csproj b/tests/Unit/EventLogExpert.UI.Tests/EventLogExpert.UI.Tests.csproj
index cf5c26a43..7cfabfb0b 100644
--- a/tests/Unit/EventLogExpert.UI.Tests/EventLogExpert.UI.Tests.csproj
+++ b/tests/Unit/EventLogExpert.UI.Tests/EventLogExpert.UI.Tests.csproj
@@ -7,6 +7,20 @@
 
   <ItemGroup>
     <PackageReference Include="bunit" />
+    <!-- The UI no longer references Fluxor. The Fluxor-boundary architecture test still names FluxorComponent / IState /
+         IStateSelection / IActionSubscriber to assert their ABSENCE from the converted surfaces, so it needs Fluxor here. -->
+    <PackageReference Include="Fluxor.Blazor.Web" />
+  </ItemGroup>
+
+  <!-- The independent array-of-structs display-view oracles (AosReferenceView / AosReferenceCombinedView) live in
+       EventLogExpert.Runtime.Tests. This project does not reference that test assembly, so link the sources here to
+       compile a private internal copy against the production internals it already sees via InternalsVisibleTo. The
+       oracles derive their display order from AosReferenceOrdering (a test-only reference sort, NOT the production
+       kernel), so that helper is linked alongside the two views. -->
+  <ItemGroup>
+    <Compile Include="..\EventLogExpert.Runtime.Tests\LogTable\TestSupport\AosReferenceView.cs" Link="TestSupport\AosReferenceView.cs" />
+    <Compile Include="..\EventLogExpert.Runtime.Tests\LogTable\TestSupport\AosReferenceCombinedView.cs" Link="TestSupport\AosReferenceCombinedView.cs" />
+    <Compile Include="..\EventLogExpert.Runtime.Tests\LogTable\TestSupport\AosReferenceOrdering.cs" Link="TestSupport\AosReferenceOrdering.cs" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/tests/Unit/EventLogExpert.UI.Tests/FilterEditor/FilterRowCachedOptionsTests.cs b/tests/Unit/EventLogExpert.UI.Tests/FilterEditor/FilterRowCachedOptionsTests.cs
index a18057ecf..a6cdcb4c8 100644
--- a/tests/Unit/EventLogExpert.UI.Tests/FilterEditor/FilterRowCachedOptionsTests.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/FilterEditor/FilterRowCachedOptionsTests.cs
@@ -4,19 +4,12 @@
 using EventLogExpert.Filtering.Persistence;
 using EventLogExpert.Runtime.FilterLibrary;
 using EventLogExpert.UI.FilterEditor;
-using Fluxor;
 using NSubstitute;
 using System.Collections.Immutable;
 using System.Reflection;
 
 namespace EventLogExpert.UI.Tests.FilterEditor;
 
-/// <summary>
-///     Pure-instance unit tests for <see cref="FilterRow.CachedOptions" /> (Δ30 contract): explicit
-///     <c>OfType&lt;LibraryEntrySavedFilter&gt;</c> filtering, favorites-first ordered alphabetically (OrdinalIgnoreCase),
-///     then non-favorite recents ordered by <c>LastUsedUtc</c> descending, with cross-bucket dedupe by
-///     <c>ComparisonText</c> only (legacy quick-pick contract).
-/// </summary>
 public sealed class FilterRowCachedOptionsTests
 {
     [Fact]
@@ -69,27 +62,19 @@ public void CachedOptions_NonFavoriteWithoutLastUsed_IsExcluded()
     [Fact]
     public void CachedOptions_Recomputes_WhenLibraryEntriesReferenceChanges()
     {
-        var stateMock = Substitute.For<IState<FilterLibraryState>>();
-        stateMock.Value.Returns(new FilterLibraryState
-        {
-            IsLoaded = true,
-            Entries = ImmutableList.CreateRange(
-                new LibraryEntry[] { BuildSavedFilter("Fav", filterText: "Level == 4", isFavorite: true) }),
-        });
-        var row = NewRowWithState(stateMock);
+        var source = Substitute.For<ILibraryEntriesSource>();
+        source.Current.Returns(ImmutableList.CreateRange(
+            new LibraryEntry[] { BuildSavedFilter("Fav", filterText: "Level == 4", isFavorite: true) }));
+        var row = NewRowWithSource(source);
 
         var first = row.CachedOptions;
         Assert.Single(first);
 
-        stateMock.Value.Returns(new FilterLibraryState
+        source.Current.Returns(ImmutableList.CreateRange(new LibraryEntry[]
         {
-            IsLoaded = true,
-            Entries = ImmutableList.CreateRange(new LibraryEntry[]
-            {
-                BuildSavedFilter("Fav", filterText: "Level == 4", isFavorite: true),
-                BuildSavedFilter("Fav2", filterText: "Level == 2", isFavorite: true),
-            }),
-        });
+            BuildSavedFilter("Fav", filterText: "Level == 4", isFavorite: true),
+            BuildSavedFilter("Fav2", filterText: "Level == 2", isFavorite: true),
+        }));
 
         var second = row.CachedOptions;
 
@@ -190,22 +175,18 @@ private static LibraryEntrySavedFilter BuildSavedFilter(
 
     private static FilterRow NewRowWithLibraryEntries(params LibraryEntry[] entries)
     {
-        var stateMock = Substitute.For<IState<FilterLibraryState>>();
-        stateMock.Value.Returns(new FilterLibraryState
-        {
-            IsLoaded = true,
-            Entries = ImmutableList.CreateRange(entries),
-        });
-        return NewRowWithState(stateMock);
+        var source = Substitute.For<ILibraryEntriesSource>();
+        source.Current.Returns(ImmutableList.CreateRange(entries));
+        return NewRowWithSource(source);
     }
 
-    private static FilterRow NewRowWithState(IState<FilterLibraryState> stateMock)
+    private static FilterRow NewRowWithSource(ILibraryEntriesSource source)
     {
         var row = new FilterRow();
         var prop = typeof(FilterRow).GetProperty(
-            "FilterLibraryState",
+            "LibraryEntries",
             BindingFlags.NonPublic | BindingFlags.Instance)!;
-        prop.SetValue(row, stateMock);
+        prop.SetValue(row, source);
         return row;
     }
 }
diff --git a/tests/Unit/EventLogExpert.UI.Tests/FilterEditor/FilterRowLifecycleTests.cs b/tests/Unit/EventLogExpert.UI.Tests/FilterEditor/FilterRowLifecycleTests.cs
index 535d7e04f..d61755434 100644
--- a/tests/Unit/EventLogExpert.UI.Tests/FilterEditor/FilterRowLifecycleTests.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/FilterEditor/FilterRowLifecycleTests.cs
@@ -2,8 +2,10 @@
 // // Licensed under the MIT License.
 
 using EventLogExpert.Filtering.Persistence;
-using EventLogExpert.Runtime.FilterPane;
+using EventLogExpert.Runtime.FilterLibrary;
 using EventLogExpert.UI.FilterEditor;
+using NSubstitute;
+using System.Reflection;
 
 namespace EventLogExpert.UI.Tests.FilterEditor;
 
@@ -19,6 +21,8 @@ public void Dispose_InvokesOnDisposedWithFilterId()
             .SetValue(row, filter);
         typeof(FilterRow).GetProperty(nameof(FilterRow.OnDisposed))!
             .SetValue(row, (Action<FilterId>)(id => disposed = id));
+        typeof(FilterRow).GetProperty("LibraryEntries", BindingFlags.NonPublic | BindingFlags.Instance)!
+            .SetValue(row, Substitute.For<ILibraryEntriesSource>());
 
         row.Dispose();
 
diff --git a/tests/Unit/EventLogExpert.UI.Tests/FilterEditor/FilterRowOrderingTests.cs b/tests/Unit/EventLogExpert.UI.Tests/FilterEditor/FilterRowOrderingTests.cs
new file mode 100644
index 000000000..d9bdfc1a2
--- /dev/null
+++ b/tests/Unit/EventLogExpert.UI.Tests/FilterEditor/FilterRowOrderingTests.cs
@@ -0,0 +1,41 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using Bunit;
+using EventLogExpert.Filtering.Persistence;
+using EventLogExpert.Runtime.Alerts;
+using EventLogExpert.Runtime.Announcement;
+using EventLogExpert.Runtime.EventLog;
+using EventLogExpert.Runtime.FilterLibrary;
+using EventLogExpert.Runtime.FilterPane;
+using EventLogExpert.UI.FilterEditor;
+using Microsoft.Extensions.DependencyInjection;
+using NSubstitute;
+using System.Collections.Immutable;
+
+namespace EventLogExpert.UI.Tests.FilterEditor;
+
+public sealed class FilterRowOrderingTests : BunitContext
+{
+    [Fact]
+    public void FilterRow_RepaintsWhenTheLibraryEntriesSourceChanges()
+    {
+        var source = Substitute.For<ILibraryEntriesSource>();
+        source.Current.Returns(ImmutableList<LibraryEntry>.Empty);
+        Services.AddSingleton(source);
+        Services.AddSingleton(Substitute.For<IFilterPaneCommands>());
+        Services.AddSingleton(Substitute.For<IAlertDialogService>());
+        Services.AddSingleton(Substitute.For<IAnnouncementService>());
+        Services.AddSingleton(Substitute.For<IEventLogQueries>());
+        JSInterop.Mode = JSRuntimeMode.Loose;
+
+        var cut = Render<FilterRow>(parameters => parameters.Add(p => p.Value, SavedFilter.TryCreate("Level == 4")!));
+        var rendersBefore = cut.RenderCount;
+
+        source.Current.Returns(ImmutableList.Create<LibraryEntry>(
+            new LibraryEntryFilterSet { Name = "set", CreatedUtc = DateTimeOffset.UnixEpoch, Filters = [] }));
+        cut.InvokeAsync(() => source.Changed += Raise.Event<Action>());
+
+        cut.WaitForAssertion(() => Assert.True(cut.RenderCount > rendersBefore));
+    }
+}
diff --git a/tests/Unit/EventLogExpert.UI.Tests/FilterLenses/LensBreadcrumbTests.cs b/tests/Unit/EventLogExpert.UI.Tests/FilterLenses/LensBreadcrumbTests.cs
index a0ae5167e..61899d7e3 100644
--- a/tests/Unit/EventLogExpert.UI.Tests/FilterLenses/LensBreadcrumbTests.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/FilterLenses/LensBreadcrumbTests.cs
@@ -4,30 +4,43 @@
 using Bunit;
 using EventLogExpert.Runtime.FilterLenses;
 using EventLogExpert.UI.FilterLenses;
-using Fluxor;
 using Microsoft.AspNetCore.Components.Web;
 using Microsoft.Extensions.DependencyInjection;
 using NSubstitute;
+using System.Collections.Immutable;
 
 namespace EventLogExpert.UI.Tests.FilterLenses;
 
 public sealed class LensBreadcrumbTests : BunitContext
 {
     private readonly IFilterLensCommands _commands = Substitute.For<IFilterLensCommands>();
-    private readonly IState<FilterLensState> _lensState = Substitute.For<IState<FilterLensState>>();
+
+    private readonly IFilterLensSource _source = Substitute.For<IFilterLensSource>();
 
     public LensBreadcrumbTests()
     {
         JSInterop.Mode = JSRuntimeMode.Loose;
+        _source.Lenses.Returns(ImmutableList<FilterLensSummary>.Empty);
         Services.AddSingleton(_commands);
-        Services.AddSingleton(_lensState);
-        Services.AddFluxor(options => options.ScanAssemblies(typeof(LensBreadcrumb).Assembly));
+        Services.AddSingleton(_source);
+    }
+
+    [Fact]
+    public void Changed_ReRendersTheBreadcrumb()
+    {
+        var cut = Render<LensBreadcrumb>();
+        Assert.Empty(cut.FindAll(".lens-breadcrumb"));
+
+        _source.Lenses.Returns(ImmutableList.Create(Summary("Activity ID = abc")));
+        _source.Changed += Raise.Event<Action>();
+
+        cut.WaitForAssertion(() => Assert.Contains("Activity ID = abc", cut.Markup));
     }
 
     [Fact]
     public void ClearAllButton_DispatchesClearLenses()
     {
-        _lensState.Value.Returns(new FilterLensState { Lenses = [Lens("x")] });
+        _source.Lenses.Returns(ImmutableList.Create(Summary("x")));
 
         var cut = Render<LensBreadcrumb>();
 
@@ -39,21 +52,21 @@ public void ClearAllButton_DispatchesClearLenses()
     [Fact]
     public void Escape_WithinBreadcrumb_PopsTopLens()
     {
-        var older = Lens("older");
-        var top = Lens("top");
-        _lensState.Value.Returns(new FilterLensState { Lenses = [older, top] });
+        var older = Summary("older");
+        var top = Summary("top");
+        _source.Lenses.Returns(ImmutableList.Create(older, top));
 
         var cut = Render<LensBreadcrumb>();
 
         cut.Find(".lens-breadcrumb").KeyDown(new KeyboardEventArgs { Key = "Escape" });
 
-        _commands.Received(1).RemoveLens(top);
+        _commands.Received(1).RemoveLens(top.Id);
     }
 
     [Fact]
     public void NoLenses_RendersNothing()
     {
-        _lensState.Value.Returns(new FilterLensState());
+        _source.Lenses.Returns(ImmutableList<FilterLensSummary>.Empty);
 
         var cut = Render<LensBreadcrumb>();
 
@@ -61,19 +74,19 @@ public void NoLenses_RendersNothing()
     }
 
     [Fact]
-    public void WithLens_RendersChip_AndRemoveButtonDispatchesRemoveLens()
+    public void WithLens_RendersLabel_AndRemoveButtonDispatchesRemoveLens()
     {
-        var lens = Lens("Activity ID = abc");
-        _lensState.Value.Returns(new FilterLensState { Lenses = [lens] });
+        var lens = Summary("Activity ID = abc");
+        _source.Lenses.Returns(ImmutableList.Create(lens));
 
         var cut = Render<LensBreadcrumb>();
 
         Assert.Contains("Activity ID = abc", cut.Markup);
 
-        cut.Find(".lens-chip-remove").Click();
+        cut.Find(".lens-lens-remove").Click();
 
-        _commands.Received(1).RemoveLens(lens);
+        _commands.Received(1).RemoveLens(lens.Id);
     }
 
-    private static FilterLens Lens(string label) => new() { Label = label, Kind = LensKind.Property };
+    private static FilterLensSummary Summary(string label) => new(FilterLensId.Create(), label);
 }
diff --git a/tests/Unit/EventLogExpert.UI.Tests/FilterLibrary/FilterLibraryModalTests.cs b/tests/Unit/EventLogExpert.UI.Tests/FilterLibrary/FilterLibraryModalTests.cs
index f464ecaec..981d26cc4 100644
--- a/tests/Unit/EventLogExpert.UI.Tests/FilterLibrary/FilterLibraryModalTests.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/FilterLibrary/FilterLibraryModalTests.cs
@@ -9,11 +9,10 @@
 using EventLogExpert.Runtime.Common.Files;
 using EventLogExpert.Runtime.FilterLibrary;
 using EventLogExpert.Runtime.FilterPane;
-using EventLogExpert.Runtime.Modal;
 using EventLogExpert.Runtime.Scenarios;
 using EventLogExpert.UI.FilterLibrary;
+using EventLogExpert.UI.Modal;
 using EventLogExpert.UI.Tests.TestUtils;
-using Fluxor;
 using Microsoft.AspNetCore.Components;
 using Microsoft.AspNetCore.Components.Web;
 using Microsoft.Extensions.DependencyInjection;
@@ -47,17 +46,22 @@ public FilterLibraryModalTests()
         Services.AddSingleton(_filePicker);
         Services.AddSingleton(_exportService);
 
-        var paneState = Substitute.For<IState<FilterPaneState>>();
-        paneState.Value.Returns(new FilterPaneState());
-        Services.AddSingleton(paneState);
+        var defaultLibraryEntries = Substitute.For<ILibraryEntriesSource>();
+        defaultLibraryEntries.Current.Returns(ImmutableList<LibraryEntry>.Empty);
+        Services.AddSingleton(defaultLibraryEntries);
+        var activeFilters = Substitute.For<IActiveFiltersSource>();
+        activeFilters.Current.Returns(ImmutableList<SavedFilter>.Empty);
+        Services.AddSingleton(activeFilters);
+        var defaultLoadStatus = Substitute.For<ILibraryLoadStatusSource>();
+        defaultLoadStatus.Current.Returns(new LibraryLoadStatus(false, false));
+        Services.AddSingleton(defaultLoadStatus);
+        Services.AddSingleton(Substitute.For<ITagBulkUpdateFailedNotifier>());
 
         Services.AddSingleton(Substitute.For<IAlertDialogService>());
         Services.AddSingleton(Substitute.For<IScenarioAuthoringService>());
         Services.AddSingleton(Substitute.For<IClipboardService>());
         Services.AddSingleton(new ScenarioAuthoringOptions(false));
 
-        Services.AddFluxor(options => options.ScanAssemblies(typeof(FilterLibraryModal).Assembly));
-
         JSInterop.Mode = JSRuntimeMode.Loose;
     }
 
@@ -269,6 +273,69 @@ public void FilterLibraryModal_RegistersAsInlineAlertHost()
         _modalCoordinator.Received().RegisterModal(Arg.Is<ModalRegistration>(r => r != null && r.InlineAlertHost == component.Instance));
     }
 
+    [Fact]
+    public async Task LibraryList_RepaintsWhenTheEntriesSourceChanges()
+    {
+        var alpha = BuildSavedFilter("Alpha");
+        var beta = BuildSavedFilter("Beta");
+        var entries = Substitute.For<ILibraryEntriesSource>();
+        entries.Current.Returns(ImmutableList.Create<LibraryEntry>(alpha));
+        Services.AddSingleton(entries);
+        var loadStatus = Substitute.For<ILibraryLoadStatusSource>();
+        loadStatus.Current.Returns(new LibraryLoadStatus(true, false));
+        Services.AddSingleton(loadStatus);
+
+        var component = Render<FilterLibraryModal>();
+        Assert.Contains("Alpha", component.Markup);
+
+        entries.Current.Returns(ImmutableList.Create<LibraryEntry>(beta));
+        await component.InvokeAsync(() => entries.Changed += Raise.Event<Action>());
+
+        component.WaitForAssertion(() =>
+        {
+            Assert.Contains("Beta", component.Markup);
+            Assert.DoesNotContain("Alpha", component.Markup);
+        });
+    }
+
+    [Fact]
+    public async Task LoadError_IsShownWhenTheLoadStatusSourceReportsLoadError()
+    {
+        var entries = Substitute.For<ILibraryEntriesSource>();
+        entries.Current.Returns(ImmutableList<LibraryEntry>.Empty);
+        Services.AddSingleton(entries);
+        var loadStatus = Substitute.For<ILibraryLoadStatusSource>();
+        loadStatus.Current.Returns(new LibraryLoadStatus(false, false));
+        Services.AddSingleton(loadStatus);
+
+        var component = Render<FilterLibraryModal>();
+        Assert.Empty(component.FindAll(".filter-library-error"));
+
+        loadStatus.Current.Returns(new LibraryLoadStatus(true, true));
+        await component.InvokeAsync(() => loadStatus.Changed += Raise.Event<Action>());
+
+        component.WaitForAssertion(() => Assert.NotEmpty(component.FindAll(".filter-library-error")));
+    }
+
+    [Fact]
+    public async Task LoadingSpinner_IsReplacedWhenTheLoadStatusSourceReportsLoaded()
+    {
+        var entries = Substitute.For<ILibraryEntriesSource>();
+        entries.Current.Returns(ImmutableList<LibraryEntry>.Empty);
+        Services.AddSingleton(entries);
+        var loadStatus = Substitute.For<ILibraryLoadStatusSource>();
+        loadStatus.Current.Returns(new LibraryLoadStatus(false, false));
+        Services.AddSingleton(loadStatus);
+
+        var component = Render<FilterLibraryModal>();
+        Assert.NotEmpty(component.FindAll(".filter-library-loading"));
+
+        loadStatus.Current.Returns(new LibraryLoadStatus(true, false));
+        await component.InvokeAsync(() => loadStatus.Changed += Raise.Event<Action>());
+
+        component.WaitForAssertion(() => Assert.Empty(component.FindAll(".filter-library-loading")));
+    }
+
     [Fact]
     public void OnInitialized_DispatchesLoadLibrary_WhenLoadError()
     {
@@ -315,7 +382,7 @@ public async Task PreviouslyUsedTab_ProjectsOnlyWithLastUsedUtc_OrderedDescTop50
     {
         var older = BuildAutoTrackedFilterEntry("Old", DateTimeOffset.UtcNow.AddDays(-2));
         var newer = BuildAutoTrackedFilterEntry("New", DateTimeOffset.UtcNow.AddHours(-1));
-        var saved = BuildSavedFilter("Saved"); // No LastUsedUtc → not in Previously Used
+        var saved = BuildSavedFilter("Saved");
         SetState(new FilterLibraryState { Entries = [older, newer, saved], IsLoaded = true });
 
         var component = Render<FilterLibraryModal>();
@@ -336,8 +403,6 @@ public void PruneStaleRowRefs_RemovesNullRefForLiveEntry()
             .GetField("_rowRefs", BindingFlags.NonPublic | BindingFlags.Instance)!
             .GetValue(component.Instance)!;
 
-        // Blazor cleared a row's @ref (disposed before OnRowDisposed's scan) while the entry id stays
-        // live, so only the value-null check can prune the dangling entry.
         rowRefs[(LibraryTab.Saved, entry.Id)] = null;
 
         typeof(FilterLibraryModal)
@@ -406,7 +471,6 @@ public void Render_HiddenTabpanel_DoesNotRenderRowChildren()
 
         var component = Render<FilterLibraryModal>();
 
-        // Only the active (Saved) tab should render its row; the other two tabpanels are empty.
         Assert.Single(component.FindAll(".library-entry"));
     }
 
@@ -488,7 +552,7 @@ public void Render_TabpanelTabindex_AbsentWhenRowsPresent()
     [Fact]
     public void Render_TabpanelTabindex_ZeroWhenEmpty()
     {
-        SetState(new FilterLibraryState { IsLoaded = true }); // empty
+        SetState(new FilterLibraryState { IsLoaded = true });
         var component = Render<FilterLibraryModal>();
         Assert.Equal("0", component.FindAll("[role='tabpanel']")[0].GetAttribute("tabindex"));
     }
@@ -502,7 +566,6 @@ public void Render_ThreeTabpanelsInDom_InactiveOnesDisplayNone()
 
         var panels = component.FindAll("[role='tabpanel']");
         Assert.Equal(3, panels.Count);
-        // Saved is active by default — its style should not contain display:none
         Assert.DoesNotContain("display: none", panels[0].GetAttribute("style") ?? string.Empty);
         Assert.Contains("display: none", panels[1].GetAttribute("style") ?? string.Empty);
         Assert.Contains("display: none", panels[2].GetAttribute("style") ?? string.Empty);
@@ -614,74 +677,6 @@ public async Task TagDelete_RemovesFromSelectedTagsByTab()
         Assert.DoesNotContain("alpha", selectedAfter, StringComparer.OrdinalIgnoreCase);
     }
 
-    [Fact]
-    public async Task TagFilter_AllTagsSelectedButNoEntryCarriesAll_ShowsFilteredEmptyMessage()
-    {
-        var onlyAlpha = BuildSavedFilter("onlyAlpha") with { Tags = ["alpha"] };
-        var onlyBeta = BuildSavedFilter("onlyBeta") with { Tags = ["beta"] };
-        SetState(new FilterLibraryState { Entries = [onlyAlpha, onlyBeta], IsLoaded = true });
-
-        var component = Render<FilterLibraryModal>();
-
-        var chips = component.Find("[role='tabpanel'].active").QuerySelectorAll(".library-tag-filter-chip");
-        await chips[0].ClickAsync(new MouseEventArgs());
-        await component.Find("[role='tabpanel'].active")
-            .QuerySelectorAll(".library-tag-filter-chip")[1]
-            .ClickAsync(new MouseEventArgs());
-
-        var empty = component.Find("[role='tabpanel'].active .library-empty-state");
-        Assert.Contains("No entries match the selected tags", empty.TextContent);
-    }
-
-    [Fact]
-    public async Task TagFilter_PreviouslyUsedTab_AppliesBeforeTake50()
-    {
-        var entries = new List<LibraryEntry>();
-        var now = DateTimeOffset.UtcNow;
-        for (int i = 0; i < 60; i++)
-        {
-            entries.Add(BuildAutoTrackedFilterEntry($"recent-{i}", now.AddMinutes(-i)));
-        }
-        var oldTagged = BuildAutoTrackedFilterEntry("ancient-tagged", now.AddDays(-30)) with { Tags = ["special"] };
-        entries.Add(oldTagged);
-
-        SetState(new FilterLibraryState { Entries = [.. entries], IsLoaded = true });
-
-        var component = Render<FilterLibraryModal>();
-        await component.FindAll("[role='tab']")[2].ClickAsync(new MouseEventArgs());
-
-        var puPanel = component.Find("[role='tabpanel'].active");
-        var specialChip = puPanel.QuerySelectorAll(".library-tag-filter-chip")
-            .Single(c => c.TextContent.Trim() == "special");
-        await specialChip.ClickAsync(new MouseEventArgs());
-
-        var rows = component.Find("[role='tabpanel'].active").QuerySelectorAll(".library-entry");
-        Assert.Single(rows);
-        Assert.Contains("ancient-tagged", rows[0].TextContent);
-    }
-
-    [Fact]
-    public async Task TagFilter_StaleSelectionAfterUnappliedRename_IsIgnored_EntryStillShown()
-    {
-        var alpha = BuildSavedFilter("a") with { Tags = ["alpha"] };
-        SetState(new FilterLibraryState { Entries = [alpha], IsLoaded = true });
-
-        var component = Render<FilterLibraryModal>();
-        var alphaChip = component.Find("[role='tabpanel'].active .library-tag-filter-chip");
-        await alphaChip.ClickAsync(new MouseEventArgs());
-        Assert.Single(component.Find("[role='tabpanel'].active").QuerySelectorAll(".library-entry"));
-
-        await component.Find(".library-tag-management-trigger").ClickAsync(new MouseEventArgs());
-        var renameButton = component.Find(".library-tag-management-row").QuerySelectorAll(".icon-button")[0];
-        await renameButton.ClickAsync(new MouseEventArgs());
-        var editInput = component.Find(".library-tag-management-row-edit-input");
-        await editInput.InputAsync(new ChangeEventArgs { Value = "renamed" });
-        await component.Find(".library-tag-management-row .button-green").ClickAsync(new MouseEventArgs());
-
-        Assert.Contains("renamed", GetSelectedTagsForTab(component, LibraryTab.Saved), StringComparer.OrdinalIgnoreCase);
-        Assert.Single(component.Find("[role='tabpanel'].active").QuerySelectorAll(".library-entry"));
-    }
-
     [Fact]
     public async Task TagFilterBar_EscWithActiveTags_ClearsTagsAndVetoesClose()
     {
@@ -816,6 +811,74 @@ public async Task TagFilterChip_Selection_NarrowsTabToEntriesCarryingTag()
         Assert.Contains("alphaEntry", visibleRows[0].TextContent);
     }
 
+    [Fact]
+    public async Task TagFilter_AllTagsSelectedButNoEntryCarriesAll_ShowsFilteredEmptyMessage()
+    {
+        var onlyAlpha = BuildSavedFilter("onlyAlpha") with { Tags = ["alpha"] };
+        var onlyBeta = BuildSavedFilter("onlyBeta") with { Tags = ["beta"] };
+        SetState(new FilterLibraryState { Entries = [onlyAlpha, onlyBeta], IsLoaded = true });
+
+        var component = Render<FilterLibraryModal>();
+
+        var chips = component.Find("[role='tabpanel'].active").QuerySelectorAll(".library-tag-filter-chip");
+        await chips[0].ClickAsync(new MouseEventArgs());
+        await component.Find("[role='tabpanel'].active")
+            .QuerySelectorAll(".library-tag-filter-chip")[1]
+            .ClickAsync(new MouseEventArgs());
+
+        var empty = component.Find("[role='tabpanel'].active .library-empty-state");
+        Assert.Contains("No entries match the selected tags", empty.TextContent);
+    }
+
+    [Fact]
+    public async Task TagFilter_PreviouslyUsedTab_AppliesBeforeTake50()
+    {
+        var entries = new List<LibraryEntry>();
+        var now = DateTimeOffset.UtcNow;
+        for (int i = 0; i < 60; i++)
+        {
+            entries.Add(BuildAutoTrackedFilterEntry($"recent-{i}", now.AddMinutes(-i)));
+        }
+        var oldTagged = BuildAutoTrackedFilterEntry("ancient-tagged", now.AddDays(-30)) with { Tags = ["special"] };
+        entries.Add(oldTagged);
+
+        SetState(new FilterLibraryState { Entries = [.. entries], IsLoaded = true });
+
+        var component = Render<FilterLibraryModal>();
+        await component.FindAll("[role='tab']")[2].ClickAsync(new MouseEventArgs());
+
+        var puPanel = component.Find("[role='tabpanel'].active");
+        var specialChip = puPanel.QuerySelectorAll(".library-tag-filter-chip")
+            .Single(c => c.TextContent.Trim() == "special");
+        await specialChip.ClickAsync(new MouseEventArgs());
+
+        var rows = component.Find("[role='tabpanel'].active").QuerySelectorAll(".library-entry");
+        Assert.Single(rows);
+        Assert.Contains("ancient-tagged", rows[0].TextContent);
+    }
+
+    [Fact]
+    public async Task TagFilter_StaleSelectionAfterUnappliedRename_IsIgnored_EntryStillShown()
+    {
+        var alpha = BuildSavedFilter("a") with { Tags = ["alpha"] };
+        SetState(new FilterLibraryState { Entries = [alpha], IsLoaded = true });
+
+        var component = Render<FilterLibraryModal>();
+        var alphaChip = component.Find("[role='tabpanel'].active .library-tag-filter-chip");
+        await alphaChip.ClickAsync(new MouseEventArgs());
+        Assert.Single(component.Find("[role='tabpanel'].active").QuerySelectorAll(".library-entry"));
+
+        await component.Find(".library-tag-management-trigger").ClickAsync(new MouseEventArgs());
+        var renameButton = component.Find(".library-tag-management-row").QuerySelectorAll(".icon-button")[0];
+        await renameButton.ClickAsync(new MouseEventArgs());
+        var editInput = component.Find(".library-tag-management-row-edit-input");
+        await editInput.InputAsync(new ChangeEventArgs { Value = "renamed" });
+        await component.Find(".library-tag-management-row .button-green").ClickAsync(new MouseEventArgs());
+
+        Assert.Contains("renamed", GetSelectedTagsForTab(component, LibraryTab.Saved), StringComparer.OrdinalIgnoreCase);
+        Assert.Single(component.Find("[role='tabpanel'].active").QuerySelectorAll(".library-entry"));
+    }
+
     [Fact]
     public async Task TagManagementAndOverflow_RenderUniqueIdsAcrossTabpanels()
     {
@@ -862,12 +925,18 @@ public async Task TagManagementTrigger_Click_TogglesPanelVisibility()
     }
 
     [Fact]
-    public async Task TagRename_PrunesSelectedTagsByTab()
+    public async Task TagRenameFailure_RollsBackOptimisticSelection()
     {
         var alpha = BuildSavedFilter("a") with { Tags = ["alpha"] };
+        var notifier = Substitute.For<ITagBulkUpdateFailedNotifier>();
+        Services.AddSingleton(notifier);
         SetState(new FilterLibraryState { Entries = [alpha], IsLoaded = true });
 
         var component = Render<FilterLibraryModal>();
+
+        _commands.When(c => c.RenameTag(Arg.Any<string>(), Arg.Any<string>()))
+            .Do(_ => notifier.Failed += Raise.Event<Action>());
+
         var alphaChip = component.Find("[role='tabpanel'].active .library-tag-filter-chip");
         await alphaChip.ClickAsync(new MouseEventArgs());
 
@@ -878,23 +947,21 @@ public async Task TagRename_PrunesSelectedTagsByTab()
         await editInput.InputAsync(new ChangeEventArgs { Value = "renamed" });
         await component.Find(".library-tag-management-row .button-green").ClickAsync(new MouseEventArgs());
 
-        var selectedAfter = GetSelectedTagsForTab(component, LibraryTab.Saved);
-        Assert.DoesNotContain("alpha", selectedAfter, StringComparer.OrdinalIgnoreCase);
-        Assert.Contains("renamed", selectedAfter, StringComparer.OrdinalIgnoreCase);
+        component.WaitForAssertion(() =>
+        {
+            var selection = GetSelectedTagsForTab(component, LibraryTab.Saved);
+            Assert.Contains("alpha", selection, StringComparer.OrdinalIgnoreCase);
+            Assert.DoesNotContain("renamed", selection, StringComparer.OrdinalIgnoreCase);
+        });
     }
 
     [Fact]
-    public async Task TagRenameFailure_RollsBackOptimisticSelection()
+    public async Task TagRename_PrunesSelectedTagsByTab()
     {
         var alpha = BuildSavedFilter("a") with { Tags = ["alpha"] };
         SetState(new FilterLibraryState { Entries = [alpha], IsLoaded = true });
 
         var component = Render<FilterLibraryModal>();
-        await component.InvokeAsync(() => Services.GetRequiredService<IStore>().InitializeAsync());
-        var dispatcher = Services.GetRequiredService<IDispatcher>();
-        _commands.When(c => c.RenameTag(Arg.Any<string>(), Arg.Any<string>()))
-            .Do(_ => dispatcher.Dispatch(new TagBulkUpdateFailedAction()));
-
         var alphaChip = component.Find("[role='tabpanel'].active .library-tag-filter-chip");
         await alphaChip.ClickAsync(new MouseEventArgs());
 
@@ -905,9 +972,9 @@ public async Task TagRenameFailure_RollsBackOptimisticSelection()
         await editInput.InputAsync(new ChangeEventArgs { Value = "renamed" });
         await component.Find(".library-tag-management-row .button-green").ClickAsync(new MouseEventArgs());
 
-        var selection = GetSelectedTagsForTab(component, LibraryTab.Saved);
-        Assert.Contains("alpha", selection, StringComparer.OrdinalIgnoreCase);
-        Assert.DoesNotContain("renamed", selection, StringComparer.OrdinalIgnoreCase);
+        var selectedAfter = GetSelectedTagsForTab(component, LibraryTab.Saved);
+        Assert.DoesNotContain("alpha", selectedAfter, StringComparer.OrdinalIgnoreCase);
+        Assert.Contains("renamed", selectedAfter, StringComparer.OrdinalIgnoreCase);
     }
 
     private static LibraryEntrySavedFilter BuildAutoTrackedFilterEntry(string name, DateTimeOffset? lastUsed = null)
@@ -953,8 +1020,12 @@ private static ImmutableList<string> GetSelectedTagsForTab(IRenderedComponent<Fi
 
     private void SetState(FilterLibraryState state)
     {
-        var stateMock = Substitute.For<IState<FilterLibraryState>>();
-        stateMock.Value.Returns(state);
-        Services.AddSingleton(stateMock);
+        var libraryEntries = Substitute.For<ILibraryEntriesSource>();
+        libraryEntries.Current.Returns(state.Entries);
+        Services.AddSingleton(libraryEntries);
+
+        var loadStatus = Substitute.For<ILibraryLoadStatusSource>();
+        loadStatus.Current.Returns(new LibraryLoadStatus(state.IsLoaded, state.LoadError));
+        Services.AddSingleton(loadStatus);
     }
 }
diff --git a/tests/Unit/EventLogExpert.UI.Tests/FilterLibrary/LibraryEntryRowTests.cs b/tests/Unit/EventLogExpert.UI.Tests/FilterLibrary/LibraryEntryRowTests.cs
index a99bf0679..44229f88e 100644
--- a/tests/Unit/EventLogExpert.UI.Tests/FilterLibrary/LibraryEntryRowTests.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/FilterLibrary/LibraryEntryRowTests.cs
@@ -7,9 +7,8 @@
 using EventLogExpert.Runtime.Announcement;
 using EventLogExpert.Runtime.FilterLibrary;
 using EventLogExpert.Runtime.FilterPane;
-using EventLogExpert.Runtime.Menu;
 using EventLogExpert.UI.FilterLibrary;
-using Fluxor;
+using EventLogExpert.UI.Menu;
 using Microsoft.AspNetCore.Components.Web;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.JSInterop;
@@ -35,13 +34,13 @@ public LibraryEntryRowTests()
         Services.AddSingleton(_commands);
         Services.AddSingleton(_menuService);
 
-        var paneStateMock = Substitute.For<IState<FilterPaneState>>();
-        paneStateMock.Value.Returns(_ => _paneState);
-        Services.AddSingleton(paneStateMock);
+        var activeFilters = Substitute.For<IActiveFiltersSource>();
+        activeFilters.Current.Returns(_ => _paneState.Filters);
+        Services.AddSingleton(activeFilters);
 
-        var libraryStateMock = Substitute.For<IState<FilterLibraryState>>();
-        libraryStateMock.Value.Returns(_ => _libraryState);
-        Services.AddSingleton(libraryStateMock);
+        var libraryEntries = Substitute.For<ILibraryEntriesSource>();
+        libraryEntries.Current.Returns(_ => _libraryState.Entries);
+        Services.AddSingleton(libraryEntries);
 
         JSInterop.Mode = JSRuntimeMode.Loose;
         JSInterop.SetupModule("./_content/EventLogExpert.UI/Menu/MenuAnchor.js")
@@ -59,7 +58,7 @@ public async Task AddToFilterSetSubmenu_WithFilterSets_HasNewSeparatorAndFilterS
         var items = await CapturedMoreMenuItemsAsync(component);
         var sub = items.First(i => i.Label == "Add to filter set...").Children!;
 
-        Assert.Equal(3, sub.Count); // "+ New filter set...", separator, "P1"
+        Assert.Equal(3, sub.Count);
         Assert.Equal("+ New filter set...", sub[0].Label);
         Assert.True(sub[1].IsSeparator);
         Assert.Equal("P1", sub[2].Label);
@@ -270,18 +269,6 @@ public void FilterSetEntry_DoesNotRenderFavoriteButton()
         Assert.Empty(component.FindAll("button.button-yellow"));
     }
 
-    [Fact]
-    public void MoreButton_HasAriaLabel_AriaHaspopup_AriaExpandedFalseInitial()
-    {
-        var entry = BuildSavedFilter("X");
-        var component = RenderRow(entry);
-
-        var more = component.Find("button[aria-label^='More actions for']");
-        Assert.Contains("More actions for X", more.GetAttribute("aria-label"));
-        Assert.Equal("menu", more.GetAttribute("aria-haspopup"));
-        Assert.Equal("false", more.GetAttribute("aria-expanded"));
-    }
-
     [Fact]
     public async Task MoreButtonClick_OpensMenuViaIMenuServiceWithAnchorCoords()
     {
@@ -296,6 +283,18 @@ public async Task MoreButtonClick_OpensMenuViaIMenuServiceWithAnchorCoords()
             Arg.Any<IReadOnlyList<MenuItem>>());
     }
 
+    [Fact]
+    public void MoreButton_HasAriaLabel_AriaHaspopup_AriaExpandedFalseInitial()
+    {
+        var entry = BuildSavedFilter("X");
+        var component = RenderRow(entry);
+
+        var more = component.Find("button[aria-label^='More actions for']");
+        Assert.Contains("More actions for X", more.GetAttribute("aria-label"));
+        Assert.Equal("menu", more.GetAttribute("aria-haspopup"));
+        Assert.Equal("false", more.GetAttribute("aria-expanded"));
+    }
+
     [Fact]
     public async Task MoreMenu_OnAutoTrackedFilter_IncludesSaveToLibraryItem()
     {
diff --git a/tests/Unit/EventLogExpert.UI.Tests/FilterLibrary/LibrarySavedTabHeaderTests.cs b/tests/Unit/EventLogExpert.UI.Tests/FilterLibrary/LibrarySavedTabHeaderTests.cs
index 9771da1bf..b16b32b5f 100644
--- a/tests/Unit/EventLogExpert.UI.Tests/FilterLibrary/LibrarySavedTabHeaderTests.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/FilterLibrary/LibrarySavedTabHeaderTests.cs
@@ -7,7 +7,6 @@
 using EventLogExpert.Runtime.Announcement;
 using EventLogExpert.Runtime.FilterLibrary;
 using EventLogExpert.UI.FilterLibrary;
-using Fluxor;
 using Microsoft.AspNetCore.Components;
 using Microsoft.AspNetCore.Components.Web;
 using Microsoft.Extensions.DependencyInjection;
@@ -27,9 +26,9 @@ public LibrarySavedTabHeaderTests()
         Services.AddSingleton(_commands);
         Services.AddSingleton(Substitute.For<IAlertDialogService>());
 
-        var libraryStateMock = Substitute.For<IState<FilterLibraryState>>();
-        libraryStateMock.Value.Returns(_ => _libraryState);
-        Services.AddSingleton(libraryStateMock);
+        var libraryEntries = Substitute.For<ILibraryEntriesSource>();
+        libraryEntries.Current.Returns(_ => _libraryState.Entries);
+        Services.AddSingleton(libraryEntries);
 
         JSInterop.Mode = JSRuntimeMode.Loose;
     }
diff --git a/tests/Unit/EventLogExpert.UI.Tests/FilterPane/FilterPaneTests.cs b/tests/Unit/EventLogExpert.UI.Tests/FilterPane/FilterPaneTests.cs
index 249145359..91f7e1e23 100644
--- a/tests/Unit/EventLogExpert.UI.Tests/FilterPane/FilterPaneTests.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/FilterPane/FilterPaneTests.cs
@@ -4,7 +4,6 @@
 using AngleSharp.Dom;
 using Bunit;
 using EventLogExpert.Eventing.Common.Channels;
-using EventLogExpert.Eventing.Common.EventLogs;
 using EventLogExpert.Eventing.Common.Events;
 using EventLogExpert.Filtering.Evaluation;
 using EventLogExpert.Filtering.Persistence;
@@ -15,14 +14,13 @@
 using EventLogExpert.Runtime.EventLog;
 using EventLogExpert.Runtime.FilterLibrary;
 using EventLogExpert.Runtime.FilterPane;
-using EventLogExpert.Runtime.FilterProgress;
 using EventLogExpert.Runtime.Menu;
-using EventLogExpert.Runtime.Modal;
 using EventLogExpert.Runtime.Scenarios;
 using EventLogExpert.Runtime.Settings;
 using EventLogExpert.Scenarios.Catalog;
 using EventLogExpert.UI.FilterEditor;
 using EventLogExpert.UI.FilterPane;
+using EventLogExpert.UI.Modal;
 using EventLogExpert.UI.Tests.TestUtils;
 using Fluxor;
 using Microsoft.AspNetCore.Components.Web;
@@ -30,25 +28,32 @@
 using NSubstitute;
 using System.Collections.Immutable;
 using System.Reflection;
-using Reducers = EventLogExpert.Runtime.EventLog.Reducers;
 
 namespace EventLogExpert.UI.Tests.FilterPane;
 
 public sealed class FilterPaneTests : BunitContext
 {
+    private readonly IActiveFiltersSource _activeFilters = Substitute.For<IActiveFiltersSource>();
     private readonly IAnnouncementService _announcements = Substitute.For<IAnnouncementService>();
+    private readonly IClearAllFiltersNotifier _clearAllFiltersNotifier = Substitute.For<IClearAllFiltersNotifier>();
     private readonly IEventLogQueries _eventLogQueries = Substitute.For<IEventLogQueries>();
     private readonly IState<EventLogState> _eventLogStateMock = Substitute.For<IState<EventLogState>>();
     private readonly IFilterLibraryCommands _filterLibraryCommands = Substitute.For<IFilterLibraryCommands>();
     private readonly IFilterPaneCommands _filterPaneCommands = Substitute.For<IFilterPaneCommands>();
+    private readonly IFilteredDateRangeSource _filteredDateRange = Substitute.For<IFilteredDateRangeSource>();
+    private readonly ILibraryEntriesSource _libraryEntries = Substitute.For<ILibraryEntriesSource>();
+    private readonly ILibraryLoadStatusSource _libraryLoadStatus = Substitute.For<ILibraryLoadStatusSource>();
     private readonly IState<FilterLibraryState> _libraryStateMock = Substitute.For<IState<FilterLibraryState>>();
     private readonly IStateSelection<EventLogState, ImmutableHashSet<string>> _loadedLogNames =
         Substitute.For<IStateSelection<EventLogState, ImmutableHashSet<string>>>();
+    private readonly ILoadedLogNamesSource _loadedLogNamesSource = Substitute.For<ILoadedLogNamesSource>();
     private readonly IStateSelection<EventLogState, int> _openLogCount =
         Substitute.For<IStateSelection<EventLogState, int>>();
+    private readonly IOpenLogsPresenceSource _openLogsPresence = Substitute.For<IOpenLogsPresenceSource>();
     private readonly IState<FilterPaneState> _paneStateMock = Substitute.For<IState<FilterPaneState>>();
     private readonly IScenarioApplyService _scenarioApply = Substitute.For<IScenarioApplyService>();
     private readonly IScenarioQueryService _scenarioQuery = Substitute.For<IScenarioQueryService>();
+    private readonly ISetFilterDateRangeSucceededNotifier _setFilterDateRangeSucceededNotifier = Substitute.For<ISetFilterDateRangeSucceededNotifier>();
     private readonly ISettingsService _settings = Substitute.For<ISettingsService>();
 
     public FilterPaneTests()
@@ -60,6 +65,9 @@ public FilterPaneTests()
         Services.AddSingleton(_filterLibraryCommands);
         Services.AddSingleton(_filterPaneCommands);
         Services.AddSingleton(_libraryStateMock);
+
+        _libraryEntries.Current.Returns(_ => _libraryStateMock.Value?.Entries ?? ImmutableList<LibraryEntry>.Empty);
+        Services.AddSingleton(_libraryEntries);
         Services.AddSingleton(_settings);
         Services.AddSingleton(Substitute.For<IAlertDialogService>());
         Services.AddSingleton(Substitute.For<IModalCoordinator>());
@@ -75,10 +83,6 @@ public FilterPaneTests()
         paneState.Value.Returns(new FilterPaneState());
         Services.AddSingleton(paneState);
 
-        var progressState = Substitute.For<IState<FilterProgressState>>();
-        progressState.Value.Returns(new FilterProgressState());
-        Services.AddSingleton(progressState);
-
         _eventLogStateMock.Value.Returns(new EventLogState());
         Services.AddSingleton(_eventLogStateMock);
         Services.AddSingleton(_eventLogQueries);
@@ -90,6 +94,25 @@ public FilterPaneTests()
 
         _settings.TimeZoneInfo.Returns(TimeZoneInfo.Utc);
 
+        _libraryLoadStatus.Current.Returns(_ => new LibraryLoadStatus(
+            _libraryStateMock.Value?.IsLoaded ?? false, _libraryStateMock.Value?.LoadError ?? false));
+        Services.AddSingleton(_libraryLoadStatus);
+
+        _activeFilters.Current.Returns(_ => _paneStateMock.Value?.Filters ?? ImmutableList<SavedFilter>.Empty);
+        Services.AddSingleton(_activeFilters);
+
+        _filteredDateRange.Current.Returns(_ => _paneStateMock.Value?.FilteredDateRange);
+        Services.AddSingleton(_filteredDateRange);
+
+        _openLogsPresence.HasOpenLogs.Returns(_ => _openLogCount.Value > 0);
+        Services.AddSingleton(_openLogsPresence);
+
+        _loadedLogNamesSource.Current.Returns(_ => _loadedLogNames.Value ?? ImmutableHashSet<string>.Empty);
+        Services.AddSingleton(_loadedLogNamesSource);
+
+        Services.AddSingleton(_clearAllFiltersNotifier);
+        Services.AddSingleton(_setFilterDateRangeSucceededNotifier);
+
         Services.AddFluxor(options => options.ScanAssemblies(typeof(UI.FilterPane.FilterPane).Assembly));
 
         JSInterop.Mode = JSRuntimeMode.Loose;
@@ -303,6 +326,19 @@ public async Task CancelScenarioPicker_ResetsSelectedScenarioId()
         Assert.Null(component.Instance.SelectedScenarioId);
     }
 
+    [Fact]
+    public async Task ClearAllFiltersNotifier_ResetsLocalEditorStateAndRepaints()
+    {
+        var component = Render<UI.FilterPane.FilterPane>();
+        component.Instance.EditDateFilter();
+        var before = component.RenderCount;
+
+        await component.InvokeAsync(() => _clearAllFiltersNotifier.Requested += Raise.Event<Action>());
+
+        Assert.False(GetCanEditDate(component));
+        Assert.True(component.RenderCount > before);
+    }
+
     [Fact]
     public async Task CopyScenario_ExportsOnlyEnabledRows()
     {
@@ -327,6 +363,22 @@ public async Task CopyScenario_ExportsOnlyEnabledRows()
             Arg.Any<IReadOnlyList<string>>());
     }
 
+    [Fact]
+    public async Task DirectHandlersAreInertAfterDisposal()
+    {
+        var component = Render<UI.FilterPane.FilterPane>();
+        SetDateModel(component, new DateFilter { After = new DateTime(2020, 6, 1, 12, 0, 0, DateTimeKind.Unspecified) });
+        var appliedBeforeDispose = GetDateModel(component).After;
+
+        await ((IAsyncDisposable)component.Instance).DisposeAsync();
+
+        typeof(UI.FilterPane.FilterPane)
+            .GetMethod("UpdateFilterDateTimeZone", BindingFlags.NonPublic | BindingFlags.Instance)!
+            .Invoke(component.Instance, [null, TimeZoneInfo.CreateCustomTimeZone("probe", TimeSpan.FromHours(5), "probe", "probe")]);
+
+        Assert.Equal(appliedBeforeDispose, GetDateModel(component).After);
+    }
+
     [Fact]
     public void EditButton_OnActiveFilterRow_EntersEditMode()
     {
@@ -336,7 +388,6 @@ public void EditButton_OnActiveFilterRow_EntersEditMode()
 
         var component = Render<UI.FilterPane.FilterPane>();
 
-        // The per-row scenario-copy button must be present for this regression (it sits alongside Edit in the row).
         Assert.Contains(
             component.FindAll("button"),
             b => b.GetAttribute("aria-label")?.Contains("scenario JSON") == true);
@@ -347,7 +398,6 @@ public void EditButton_OnActiveFilterRow_EntersEditMode()
 
         editButton!.Click();
 
-        // Entering edit mode replaces the saved-row actions (including the Edit button) with the edit panel.
         Assert.DoesNotContain(
             component.FindAll("button"),
             b => b.GetAttribute("aria-label")?.StartsWith("Edit ", StringComparison.Ordinal) == true);
@@ -735,15 +785,13 @@ public void PruneStaleRowRefs_RemovesNullRefForLiveFilter()
 
         var pane = new UI.FilterPane.FilterPane();
         typeof(UI.FilterPane.FilterPane)
-            .GetProperty("FilterPaneState", BindingFlags.NonPublic | BindingFlags.Instance)!
-            .SetValue(pane, _paneStateMock);
+            .GetProperty("ActiveFilters", BindingFlags.NonPublic | BindingFlags.Instance)!
+            .SetValue(pane, _activeFilters);
 
         var rowRefs = (Dictionary<FilterId, FilterRow?>)typeof(UI.FilterPane.FilterPane)
             .GetField("_rowRefs", BindingFlags.NonPublic | BindingFlags.Instance)!
             .GetValue(pane)!;
 
-        // Live filter id, but its @ref was cleared to null: only the value-null check can prune it
-        // (the id is still live, and a non-empty filter list skips the clear-all fast path).
         rowRefs[filter.Id] = null;
 
         typeof(UI.FilterPane.FilterPane)
@@ -754,21 +802,16 @@ public void PruneStaleRowRefs_RemovesNullRefForLiveFilter()
     }
 
     [Fact]
-    public async Task RenderIsolation_WhenFileLoadAddsName_ReRendersAndUpdatesScenarioGroups()
+    public async Task RenderIsolation_WhenLoadedLogNamesSourceChanges_ReRendersAndUpdatesScenarioGroups()
     {
-        var initial = Reducers.ReduceOpenLog(
-            new EventLogState(), new OpenLogAction(@"C:\F.evtx", LogPathType.File));
-        var fLog = new EventLogData(@"C:\F.evtx", LogPathType.File) { Id = initial.OpenLogs[@"C:\F.evtx"].Id };
-        initial = Reducers.ReduceLoadEvents(
-            initial, new LoadEventsAction(fLog, [EventWithName("Security")]));
-
+        SetOpenLogCount(1);
+        SetLoadedLogNames("Security");
         SetLibraryState(new FilterLibraryState { IsLoaded = true, Entries = ImmutableList<LibraryEntry>.Empty });
 
         IReadOnlyCollection<string>? capturedNames = null;
         _scenarioQuery.GetInAppScenarios(Arg.Do<IReadOnlyCollection<string>>(names => capturedNames = names))
             .Returns([Scenario("sec", ScenarioGroup.Security)]);
 
-        var feature = WireRealSelections(initial);
         var component = Render<UI.FilterPane.FilterPane>();
         await FindApplyScenarioButton(component)!.ClickAsync(new MouseEventArgs());
 
@@ -776,58 +819,68 @@ public async Task RenderIsolation_WhenFileLoadAddsName_ReRendersAndUpdatesScenar
         Assert.Contains("Security", capturedNames!);
         var renderCountBefore = component.RenderCount;
 
-        var next = Reducers.ReduceLoadEventsPartial(
-            initial, new LoadEventsPartialAction(fLog, [EventWithName("Application")]));
-
-        await component.InvokeAsync(() => feature.Publish(next));
+        SetLoadedLogNames("Security", "Application");
+        await component.InvokeAsync(() => _loadedLogNamesSource.Changed += Raise.Event<Action>());
 
         Assert.True(component.RenderCount > renderCountBefore);
         Assert.Contains("Application", capturedNames!);
     }
 
     [Fact]
-    public async Task RenderIsolation_WhenNamesByLogChangesButLoadedNamesUnionUnchanged_DoesNotReRender()
+    public async Task RenderIsolation_WhenOpenLogPresenceSourceChanges_ReRenders()
     {
-        var initial = Reducers.ReduceOpenLog(
-            new EventLogState(), new OpenLogAction(@"C:\F.evtx", LogPathType.File));
-        initial = Reducers.ReduceOpenLog(
-            initial, new OpenLogAction(@"C:\G.evtx", LogPathType.File));
-        var fLog = new EventLogData(@"C:\F.evtx", LogPathType.File) { Id = initial.OpenLogs[@"C:\F.evtx"].Id };
-        var gLog = new EventLogData(@"C:\G.evtx", LogPathType.File) { Id = initial.OpenLogs[@"C:\G.evtx"].Id };
-        initial = Reducers.ReduceLoadEvents(
-            initial, new LoadEventsAction(fLog, [EventWithName("A"), EventWithName("B")]));
-        initial = Reducers.ReduceLoadEvents(
-            initial, new LoadEventsAction(gLog, [EventWithName("B")]));
-
-        var feature = WireRealSelections(initial);
+        SetOpenLogCount(1);
         var component = Render<UI.FilterPane.FilterPane>();
         var renderCountBefore = component.RenderCount;
 
-        var next = Reducers.ReduceLoadEvents(
-            initial, new LoadEventsAction(fLog, [EventWithName("A")]));
+        SetOpenLogCount(0);
+        await component.InvokeAsync(() => _openLogsPresence.Changed += Raise.Event<Action>());
 
-        Assert.Same(initial.LoadedLogNames, next.LoadedLogNames);
-        await component.InvokeAsync(() => feature.Publish(next));
+        Assert.True(component.RenderCount > renderCountBefore);
+    }
 
-        Assert.Equal(renderCountBefore, component.RenderCount);
+    [Fact]
+    public async Task Repaints_WhenActiveFiltersSourceChanges()
+    {
+        var component = Render<UI.FilterPane.FilterPane>();
+        var before = component.RenderCount;
+
+        await component.InvokeAsync(() => _activeFilters.Changed += Raise.Event<Action>());
+
+        Assert.True(component.RenderCount > before);
     }
 
     [Fact]
-    public async Task RenderIsolation_WhenOpenLogCountChanges_ReRenders()
+    public async Task Repaints_WhenFilteredDateRangeSourceChanges()
     {
-        var initial = Reducers.ReduceOpenLog(
-            new EventLogState(), new OpenLogAction("System", LogPathType.Channel));
+        var component = Render<UI.FilterPane.FilterPane>();
+        var before = component.RenderCount;
+
+        await component.InvokeAsync(() => _filteredDateRange.Changed += Raise.Event<Action>());
 
-        var feature = WireRealSelections(initial);
+        Assert.True(component.RenderCount > before);
+    }
+
+    [Fact]
+    public async Task Repaints_WhenLibraryEntriesSourceChanges()
+    {
         var component = Render<UI.FilterPane.FilterPane>();
-        var renderCountBefore = component.RenderCount;
+        var before = component.RenderCount;
 
-        var closed = Reducers.ReduceCloseLog(
-            initial, new CloseLogAction(initial.OpenLogs["System"].Id, "System"));
+        await component.InvokeAsync(() => _libraryEntries.Changed += Raise.Event<Action>());
 
-        await component.InvokeAsync(() => feature.Publish(closed));
+        Assert.True(component.RenderCount > before);
+    }
 
-        Assert.True(component.RenderCount > renderCountBefore);
+    [Fact]
+    public async Task Repaints_WhenLibraryLoadStatusSourceChanges()
+    {
+        var component = Render<UI.FilterPane.FilterPane>();
+        var before = component.RenderCount;
+
+        await component.InvokeAsync(() => _libraryLoadStatus.Changed += Raise.Event<Action>());
+
+        Assert.True(component.RenderCount > before);
     }
 
     [Fact]
@@ -966,6 +1019,20 @@ public void ScenarioReplaceSelection_InvokesApplyInAppReplace()
         _scenarioApply.Received(1).ApplyInApp(scenario, true);
     }
 
+    [Fact]
+    public async Task SetFilterDateRangeSucceededNotifier_ResyncsTheDateEditorFromTheSource_EvenWhenTheSourceIsSilent()
+    {
+        var applied = new DateFilter { After = DateTimeOffset.UnixEpoch.UtcDateTime, IsEnabled = true };
+        SetPaneState(new FilterPaneState { FilteredDateRange = applied });
+        var component = Render<UI.FilterPane.FilterPane>();
+
+        Assert.Null(GetDateModel(component).After);
+
+        await component.InvokeAsync(() => _setFilterDateRangeSucceededNotifier.Succeeded += Raise.Event<Action>());
+
+        Assert.Equal(applied.After, GetDateModel(component).After);
+    }
+
     [Fact]
     public void SetQuickDateRange_PopulatesEditFieldsWithoutApplyingFilter()
     {
@@ -1015,6 +1082,16 @@ private static ResolvedEvent EventWithName(string logName) =>
     private static IElement? FindApplyScenarioButton(IRenderedComponent<UI.FilterPane.FilterPane> component) =>
         component.FindAll("button").FirstOrDefault(button => button.TextContent.Contains("Apply Scenario"));
 
+    private static bool GetCanEditDate(IRenderedComponent<UI.FilterPane.FilterPane> component) =>
+        (bool)typeof(UI.FilterPane.FilterPane)
+            .GetField("_canEditDate", BindingFlags.NonPublic | BindingFlags.Instance)!
+            .GetValue(component.Instance)!;
+
+    private static DateFilter GetDateModel(IRenderedComponent<UI.FilterPane.FilterPane> component) =>
+        (DateFilter)typeof(UI.FilterPane.FilterPane)
+            .GetField("_model", BindingFlags.NonPublic | BindingFlags.Instance)!
+            .GetValue(component.Instance)!;
+
     private static ScenarioDefinition Scenario(string id, ScenarioGroup group) =>
         new()
         {
@@ -1026,6 +1103,11 @@ private static ScenarioDefinition Scenario(string id, ScenarioGroup group) =>
             Filters = [],
         };
 
+    private static void SetDateModel(IRenderedComponent<UI.FilterPane.FilterPane> component, DateFilter model) =>
+        typeof(UI.FilterPane.FilterPane)
+            .GetField("_model", BindingFlags.NonPublic | BindingFlags.Instance)!
+            .SetValue(component.Instance, model);
+
     private void SetLibraryState(FilterLibraryState state) => _libraryStateMock.Value.Returns(state);
 
     private void SetLoadedLogNames(params string[] names) =>
@@ -1034,34 +1116,4 @@ private void SetLoadedLogNames(params string[] names) =>
     private void SetOpenLogCount(int count) => _openLogCount.Value.Returns(count);
 
     private void SetPaneState(FilterPaneState state) => _paneStateMock.Value.Returns(state);
-
-    private TestEventLogFeature WireRealSelections(EventLogState initial)
-    {
-        var feature = new TestEventLogFeature(initial);
-        Services.AddSingleton<IState<EventLogState>>(new State<EventLogState>(feature));
-        Services.AddSingleton<IStateSelection<EventLogState, ImmutableHashSet<string>>>(
-            new StateSelection<EventLogState, ImmutableHashSet<string>>(feature));
-        Services.AddSingleton<IStateSelection<EventLogState, int>>(
-            new StateSelection<EventLogState, int>(feature));
-
-        return feature;
-    }
-
-    private sealed class TestEventLogFeature : Feature<EventLogState>
-    {
-        private readonly EventLogState _initial;
-
-        public TestEventLogFeature(EventLogState initial)
-        {
-            _initial = initial;
-            MaximumStateChangedNotificationsPerSecond = 0;
-            State = initial;
-        }
-
-        public override string GetName() => "EventLog";
-
-        public void Publish(EventLogState state) => State = state;
-
-        protected override EventLogState GetInitialState() => _initial;
-    }
 }
diff --git a/tests/Unit/EventLogExpert.UI.Tests/Layout/MainContentTests.cs b/tests/Unit/EventLogExpert.UI.Tests/Layout/MainContentTests.cs
index 527637caf..dacdd466c 100644
--- a/tests/Unit/EventLogExpert.UI.Tests/Layout/MainContentTests.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/Layout/MainContentTests.cs
@@ -10,7 +10,6 @@
 using EventLogExpert.UI.Layout;
 using EventLogExpert.UI.LogTable;
 using EventLogExpert.UI.LogTable.Histogram;
-using Fluxor;
 using Microsoft.Extensions.DependencyInjection;
 using NSubstitute;
 using DetailsPaneComponent = EventLogExpert.UI.DetailsPane.DetailsPane;
@@ -20,18 +19,13 @@ namespace EventLogExpert.UI.Tests.Layout;
 
 public sealed class MainContentTests : BunitContext
 {
-    private readonly IStateSelection<EventLogState, bool> _hasActiveLogs =
-        Substitute.For<IStateSelection<EventLogState, bool>>();
-
-    private readonly IStateSelection<HistogramState, bool> _histogramVisible =
-        Substitute.For<IStateSelection<HistogramState, bool>>();
+    private readonly IHistogramVisibilitySource _histogramVisibility = Substitute.For<IHistogramVisibilitySource>();
+    private readonly IOpenLogsPresenceSource _openLogs = Substitute.For<IOpenLogsPresenceSource>();
 
     public MainContentTests()
     {
-        Services.AddSingleton(_hasActiveLogs);
-        Services.AddSingleton(_histogramVisible);
-        Services.AddFluxor(options => options.ScanAssemblies(typeof(MainContent).Assembly));
-        JSInterop.Mode = JSRuntimeMode.Loose;
+        Services.AddSingleton(_openLogs);
+        Services.AddSingleton(_histogramVisibility);
 
         ComponentFactories.AddStub<FilterPaneComponent>();
         ComponentFactories.AddStub<LensBreadcrumb>();
@@ -42,21 +36,41 @@ public MainContentTests()
     }
 
     [Fact]
-    public void Render_WhenLogsActive_RendersPanesNotDashboard()
+    public void HistogramVisibilityChangeAfterRender_TogglesTheHistogramPane_ThroughTheSource()
     {
-        _hasActiveLogs.Value.Returns(true);
+        _openLogs.HasOpenLogs.Returns(true);
+        _histogramVisibility.IsVisible.Returns(false);
+        var cut = Render<MainContent>();
+        Assert.Empty(cut.FindComponents<Stub<HistogramPane>>());
+
+        _histogramVisibility.IsVisible.Returns(true);
+        _histogramVisibility.Changed += Raise.Event<Action>();
+
+        cut.WaitForAssertion(() => Assert.NotEmpty(cut.FindComponents<Stub<HistogramPane>>()));
+    }
 
+    [Fact]
+    public void OpenLogsChangeAfterRender_SwapsTheDashboardForThePanes_ThroughTheSource()
+    {
+        _openLogs.HasOpenLogs.Returns(false);
         var cut = Render<MainContent>();
+        Assert.NotEmpty(cut.FindComponents<Stub<EmptyStateDashboard>>());
 
-        Assert.NotEmpty(cut.FindComponents<Stub<FilterPaneComponent>>());
-        Assert.Empty(cut.FindComponents<Stub<EmptyStateDashboard>>());
+        _openLogs.HasOpenLogs.Returns(true);
+        _openLogs.Changed += Raise.Event<Action>();
+
+        cut.WaitForAssertion(() =>
+        {
+            Assert.NotEmpty(cut.FindComponents<Stub<FilterPaneComponent>>());
+            Assert.Empty(cut.FindComponents<Stub<EmptyStateDashboard>>());
+        });
     }
 
     [Fact]
     public void Render_WhenLogsActiveAndTimelineHidden_DoesNotRenderHistogramPane()
     {
-        _hasActiveLogs.Value.Returns(true);
-        _histogramVisible.Value.Returns(false);
+        _openLogs.HasOpenLogs.Returns(true);
+        _histogramVisibility.IsVisible.Returns(false);
 
         var cut = Render<MainContent>();
 
@@ -66,18 +80,29 @@ public void Render_WhenLogsActiveAndTimelineHidden_DoesNotRenderHistogramPane()
     [Fact]
     public void Render_WhenLogsActiveAndTimelineVisible_RendersHistogramPane()
     {
-        _hasActiveLogs.Value.Returns(true);
-        _histogramVisible.Value.Returns(true);
+        _openLogs.HasOpenLogs.Returns(true);
+        _histogramVisibility.IsVisible.Returns(true);
 
         var cut = Render<MainContent>();
 
         Assert.NotEmpty(cut.FindComponents<Stub<HistogramPane>>());
     }
 
+    [Fact]
+    public void Render_WhenLogsActive_RendersPanesNotDashboard()
+    {
+        _openLogs.HasOpenLogs.Returns(true);
+
+        var cut = Render<MainContent>();
+
+        Assert.NotEmpty(cut.FindComponents<Stub<FilterPaneComponent>>());
+        Assert.Empty(cut.FindComponents<Stub<EmptyStateDashboard>>());
+    }
+
     [Fact]
     public void Render_WhenNoActiveLogs_RendersDashboardNotPanes()
     {
-        _hasActiveLogs.Value.Returns(false);
+        _openLogs.HasOpenLogs.Returns(false);
 
         var cut = Render<MainContent>();
 
diff --git a/tests/Unit/EventLogExpert.UI.Tests/LogTable/Histogram/HistogramPaneTests.cs b/tests/Unit/EventLogExpert.UI.Tests/LogTable/Histogram/HistogramPaneTests.cs
index 6aaa7e3ac..6916130b7 100644
--- a/tests/Unit/EventLogExpert.UI.Tests/LogTable/Histogram/HistogramPaneTests.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/LogTable/Histogram/HistogramPaneTests.cs
@@ -3,6 +3,7 @@
 
 using Bunit;
 using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
 using EventLogExpert.Filtering.Persistence;
 using EventLogExpert.Logging.Abstractions;
 using EventLogExpert.Runtime.EventLog;
@@ -10,45 +11,45 @@
 using EventLogExpert.Runtime.FilterPane;
 using EventLogExpert.Runtime.Histogram;
 using EventLogExpert.Runtime.LogTable;
+using EventLogExpert.Runtime.LogTable.OrderedView;
 using EventLogExpert.Runtime.Settings;
 using EventLogExpert.UI.Inputs;
 using EventLogExpert.UI.LogTable.Find;
 using EventLogExpert.UI.LogTable.Histogram;
-using Fluxor;
 using Microsoft.AspNetCore.Components;
 using Microsoft.Extensions.DependencyInjection;
 using NSubstitute;
 using System.Collections.Immutable;
 using System.Reflection;
+using TestContext = Xunit.TestContext;
 
 namespace EventLogExpert.UI.Tests.LogTable.Histogram;
 
 public sealed class HistogramPaneTests : BunitContext
 {
-    private readonly IStateSelection<LogTableState, EventLogId?> _activeEventLogId =
-        Substitute.For<IStateSelection<LogTableState, EventLogId?>>();
-
-    private readonly IStateSelection<LogTableState, string?> _activeOriginLog =
-        Substitute.For<IStateSelection<LogTableState, string?>>();
-
-    private readonly IStateSelection<LogTableState, IEventColumnView> _activeView =
-        Substitute.For<IStateSelection<LogTableState, IEventColumnView>>();
-
-    private readonly IStateSelection<HistogramState, HistogramDimensionRequest?> _dimensionRequest =
-        Substitute.For<IStateSelection<HistogramState, HistogramDimensionRequest?>>();
-
+    private static readonly TimeSpan s_settleWindow = TimeSpan.FromMilliseconds(500);
+    private static readonly TimeSpan s_testTimeout = TimeSpan.FromSeconds(10);
+
+    private static readonly EventLogId s_tokenLog = EventLogId.Create();
+    private readonly IActiveEventLogSource _activeEventLog = Substitute.For<IActiveEventLogSource>();
+    private readonly IHistogramDimensionRequestSource _dimensionRequest =
+        Substitute.For<IHistogramDimensionRequestSource>();
+    private readonly IEventFocusSource _eventFocus = Substitute.For<IEventFocusSource>();
     private readonly IFilterLensCommands _filterLensCommands = Substitute.For<IFilterLensCommands>();
-    private readonly IStateSelection<FilterPaneState, ImmutableList<SavedFilter>> _filters =
-        Substitute.For<IStateSelection<FilterPaneState, ImmutableList<SavedFilter>>>();
+    private readonly IActiveFiltersSource _filters = Substitute.For<IActiveFiltersSource>();
     private readonly IFindMarkerSource _findMarkers = new FindMarkerSource();
-    private readonly IStateSelection<EventLogState, SelectionEntry?> _focus =
-        Substitute.For<IStateSelection<EventLogState, SelectionEntry?>>();
     private readonly IHighlightSelector _highlightSelector = Substitute.For<IHighlightSelector>();
 
+    private readonly IEventColumnView _scanView = Substitute.For<IEventColumnView>();
     private readonly ISettingsService _settings = Substitute.For<ISettingsService>();
+    private readonly EventLogId _tabId = EventLogId.Create();
     private readonly ITraceLogger _traceLogger = Substitute.For<ITraceLogger>();
+    private readonly IOrderedViewSource _viewSource = Substitute.For<IOrderedViewSource>();
 
     private HistogramDimensionRequest? _dimensionRequestValue;
+    private ImmutableList<SavedFilter> _filtersValue = ImmutableList<SavedFilter>.Empty;
+
+    private OrderedViewPresentation _presentation;
 
     public HistogramPaneTests()
     {
@@ -56,31 +57,33 @@ public HistogramPaneTests()
         JSInterop.SetupModule("./_content/EventLogExpert.UI/Inputs/ValueSelect.razor.js");
         JSInterop.SetupModule("./_content/EventLogExpert.UI/LogTable/Histogram/HistogramPane.razor.js");
 
-        _activeEventLogId.Value.Returns((EventLogId?)null);
-        _activeOriginLog.Value.Returns((string?)null);
-        _activeView.Value.Returns(LogTableState.EmptyView);
-        _dimensionRequest.Value.Returns(_ => _dimensionRequestValue);
-        _filters.Value.Returns(ImmutableList<SavedFilter>.Empty);
-        _focus.Value.Returns((SelectionEntry?)null);
+        _activeEventLog.Current.Returns((EventLogId?)null);
+        _presentation = new OrderedViewPresentation(_scanView, _tabId, default, PresentationState.Current, 1)
+        {
+            ContentToken = Token(1)
+        };
+        _viewSource.Current.Returns(_ => _presentation);
+        _dimensionRequest.Current.Returns(_ => _dimensionRequestValue);
+        _filters.Current.Returns(_ => _filtersValue);
+        _eventFocus.Current.Returns((SelectionEntry?)null);
         _highlightSelector.Select(Arg.Any<ImmutableList<SavedFilter>>()).Returns([]);
         _highlightSelector.ComputePredicatePlanKey(Arg.Any<ImmutableList<SavedFilter>>()).Returns(0);
         _settings.TimeZoneInfo.Returns(TimeZoneInfo.Utc);
 
-        Services.AddSingleton(_activeEventLogId);
-        Services.AddSingleton(_activeOriginLog);
-        Services.AddSingleton(_activeView);
+        Services.AddSingleton(_activeEventLog);
+        Services.AddSingleton(_viewSource);
         Services.AddSingleton(_dimensionRequest);
+        Services.AddSingleton(_eventFocus);
         Services.AddSingleton(_filterLensCommands);
         Services.AddSingleton(_filters);
         Services.AddSingleton(_findMarkers);
-        Services.AddSingleton(_focus);
         Services.AddSingleton(_highlightSelector);
         Services.AddSingleton(_settings);
         Services.AddSingleton(_traceLogger);
-        Services.AddFluxor(options => options.ScanAssemblies(typeof(HistogramPane).Assembly));
     }
 
     public static TheoryData<uint, SavedFilter[], string?, string> GroupHighlightCases()
+
     {
         var lightRed = Filter(HighlightColor.LightRed);
         var anotherLightRed = Filter(HighlightColor.LightRed);
@@ -100,11 +103,118 @@ public HistogramPaneTests()
         };
     }
 
+    [Fact]
+    public void AChartThatHasNotBeenBuiltYet_SaysSo_RatherThanClaimingThereAreNoEvents()
+    {
+        var cut = Render<HistogramPane>();
+
+        Assert.Contains("Building the timeline", cut.Markup);
+        Assert.DoesNotContain("No events to chart", cut.Markup);
+    }
+
+    [Fact]
+    public async Task AFailureAfterAChartHasDrawn_LeavesNothingStaleToActOn()
+    {
+        var cut = Render<HistogramPane>();
+        await cut.InvokeAsync(() => cut.Instance.OnHistogramResized(500, 100));
+
+        cut.WaitForAssertion(() => _scanView.Received().TryGetTimeTicksRange(
+            out Arg.Any<long>(), out Arg.Any<long>(), Arg.Any<CancellationToken>()));
+
+        long start = new DateTime(2026, 1, 1, 0, 0, 0, DateTimeKind.Utc).Ticks;
+        long end = start + TimeSpan.FromMinutes(1).Ticks;
+
+        await cut.InvokeAsync(() => SetPrivateField(
+            cut,
+            "_render",
+            new HistogramRender([new HistogramRenderBin(start, end, 2, [2])], start, end, 2, 2, [2])));
+
+        var rescanView = Substitute.For<IEventColumnView>();
+
+        rescanView
+            .When(view => view.TryGetTimeTicksRange(out Arg.Any<long>(), out Arg.Any<long>(), Arg.Any<CancellationToken>()))
+            .Do(_ => throw new InvalidOperationException("the rescan blew up"));
+
+        _presentation = new OrderedViewPresentation(rescanView, _tabId, default, PresentationState.Current, 2)
+        {
+            ContentToken = Token(2)
+        };
+        await cut.InvokeAsync(() => _viewSource.Updated += Raise.Event<Action<OrderedViewPresentation>>(_presentation));
+
+        cut.WaitForAssertion(() => Assert.Contains("could not be built", cut.Markup));
+
+        await cut.InvokeAsync(() => cut.Instance.OnHistogramScopeBin(0.5));
+
+        _filterLensCommands.DidNotReceive().ShowTimeRange(
+            Arg.Any<DateTime>(), Arg.Any<DateTime>(), Arg.Any<TimeZoneInfo>(), Arg.Any<string?>());
+    }
+
+    [Fact]
+    public async Task AFirstSameViewPublication_DoesNotScheduleARescan()
+    {
+        var cut = Render<HistogramPane>();
+        await cut.InvokeAsync(() => cut.Instance.OnHistogramResized(500, 100));
+
+        int rendersBeforeTheRepublish = cut.RenderCount;
+
+        _presentation = _presentation with { Revision = 2 };
+        await cut.InvokeAsync(() => _viewSource.Updated += Raise.Event<Action<OrderedViewPresentation>>(_presentation));
+
+        cut.WaitForState(() => cut.RenderCount > rendersBeforeTheRepublish);
+
+        Assert.False(GetPrivateField<bool>(cut, "_recomputePending"));
+    }
+
+    [Fact]
+    public async Task AScanThatFindsNothing_ReportsEmptinessAsTheAnswer()
+    {
+        var cut = Render<HistogramPane>();
+        await cut.InvokeAsync(() => cut.Instance.OnHistogramResized(500, 100));
+
+        cut.WaitForAssertion(() => Assert.Contains("No events to chart", cut.Markup));
+
+        Assert.DoesNotContain("Building the timeline", cut.Markup);
+    }
+
+    [Fact]
+    public async Task AScanThatThrows_SaysTheTimelineFailed_RatherThanClaimingThereAreNoEvents()
+    {
+        _scanView
+            .When(view => view.TryGetTimeTicksRange(out Arg.Any<long>(), out Arg.Any<long>(), Arg.Any<CancellationToken>()))
+            .Do(_ => throw new InvalidOperationException("bucketing blew up"));
+
+        var cut = Render<HistogramPane>();
+        await cut.InvokeAsync(() => cut.Instance.OnHistogramResized(500, 100));
+
+        cut.WaitForAssertion(() => Assert.Contains("could not be built", cut.Markup));
+
+        Assert.DoesNotContain("No events to chart", cut.Markup);
+    }
+
+    [Fact]
+    public async Task ActiveLogChange_DropsZoomAndRescansForTheNewTab()
+    {
+        var cut = Render<HistogramPane>();
+        await cut.InvokeAsync(() => cut.Instance.OnHistogramResized(500, 100));
+
+        cut.WaitForAssertion(() => _scanView.Received().TryGetTimeTicksRange(
+            out Arg.Any<long>(), out Arg.Any<long>(), Arg.Any<CancellationToken>()));
+        SetPrivateField(cut, "_isZoomed", true);
+        _scanView.ClearReceivedCalls();
+
+        _activeEventLog.Current.Returns(EventLogId.Create());
+        await cut.InvokeAsync(() => _activeEventLog.Changed += Raise.Event<Action>());
+
+        cut.WaitForAssertion(() => Assert.False(GetPrivateField<bool>(cut, "_isZoomed")));
+        cut.WaitForAssertion(
+            () => _scanView.Received().TryGetTimeTicksRange(
+                out Arg.Any<long>(), out Arg.Any<long>(), Arg.Any<CancellationToken>()),
+            s_testTimeout);
+    }
+
     [Fact]
     public async Task FilterRefresh_WhenColorOnlyEditWithNoActiveCursor_ClearsStaleBinAnnouncement()
     {
-        // Red -> blue keeps the tie armed AND the same predicate-plan key (color is excluded from the plan key), so no
-        // rescan occurs. The non-rescan tail must still drop the stale "Light red" announcement when no cursor is active.
         SavedFilter red = Filter(HighlightColor.LightRed);
         SavedFilter blue = Filter(HighlightColor.LightBlue);
         _highlightSelector.Select(Arg.Any<ImmutableList<SavedFilter>>()).Returns([blue]);
@@ -117,8 +227,7 @@ public async Task FilterRefresh_WhenColorOnlyEditWithNoActiveCursor_ClearsStaleB
         await cut.InvokeAsync(() => { });
         Assert.Contains("Light red", GetPrivateField<string>(cut, "_binAnnouncement"));
 
-        _filters.SelectedValueChanged +=
-            Raise.Event<EventHandler<ImmutableList<SavedFilter>>>(_filters, ImmutableList.Create(blue));
+        _filters.Changed += Raise.Event<Action>();
         await cut.InvokeAsync(() => { });
 
         Assert.Equal(string.Empty, GetPrivateField<string>(cut, "_binAnnouncement"));
@@ -132,15 +241,13 @@ public async Task FilterRefresh_WhenDisarmedWithNoActiveCursor_ClearsStaleBinAnn
         _highlightSelector.ComputePredicatePlanKey(Arg.Any<ImmutableList<SavedFilter>>()).Returns(7);
         var cut = Render<HistogramPane>();
 
-        // A prior armed bin readout was cached, then the cursor was dismissed (Escape) which leaves the text behind.
         SetPrivateField(cut, "_tieHighlightFilters", new[] { red });
         SetPrivateField(cut, "_binCursor", null);
         SetPrivateField(cut, "_binAnnouncement", "2 events (1 Alpha, Light red highlight)");
         await cut.InvokeAsync(() => { });
         Assert.Contains("highlight", GetPrivateField<string>(cut, "_binAnnouncement"));
 
-        _filters.SelectedValueChanged +=
-            Raise.Event<EventHandler<ImmutableList<SavedFilter>>>(_filters, ImmutableList<SavedFilter>.Empty);
+        _filters.Changed += Raise.Event<Action>();
         await cut.InvokeAsync(() => { });
 
         Assert.Equal(string.Empty, GetPrivateField<string>(cut, "_binAnnouncement"));
@@ -149,8 +256,6 @@ public async Task FilterRefresh_WhenDisarmedWithNoActiveCursor_ClearsStaleBinAnn
     [Fact]
     public async Task FilterRefresh_WhenDisarmed_ClearsGroupHighlightMasksSynchronously()
     {
-        // Arm on init, disarm on the filter change. Keep the viewport at 0 (never resize) so StartScan no-ops and cannot
-        // publish mask-free data on its own -- the synchronous mask clear in RefreshTieFilters is the only mutation.
         SavedFilter red = Filter(HighlightColor.LightRed);
         _highlightSelector.Select(Arg.Any<ImmutableList<SavedFilter>>()).Returns([]);
         _highlightSelector.ComputePredicatePlanKey(Arg.Any<ImmutableList<SavedFilter>>()).Returns(7);
@@ -159,21 +264,17 @@ public async Task FilterRefresh_WhenDisarmed_ClearsGroupHighlightMasksSynchronou
         SetPrivateField(cut, "_tieHighlightFilters", new[] { red });
         await PublishBaseDataAsync(cut, ArmedCategoryData());
 
-        // Non-vacuous: the armed legend swatch renders the highlight class.
         cut.WaitForAssertion(() => Assert.Equal("histogram-cat-hl", AlphaSwatchClass(cut)));
 
-        _filters.SelectedValueChanged +=
-            Raise.Event<EventHandler<ImmutableList<SavedFilter>>>(_filters, ImmutableList<SavedFilter>.Empty);
+        _filters.Changed += Raise.Event<Action>();
         await cut.InvokeAsync(() => { });
 
-        // histogram-cat-hl comes only from GroupHighlightMasks; with no scan publishing (viewport 0), its disappearance
-        // proves the synchronous clear ran.
         cut.WaitForAssertion(() => Assert.NotEqual("histogram-cat-hl", AlphaSwatchClass(cut)));
         Assert.Null(GetPrivateField<HistogramData>(cut, "_baseData").GroupHighlightMasks);
     }
 
     [Fact]
-    public async Task FilterRefresh_WhenOnlyHighlightColorChanges_DoesNotReadActiveViewForScan()
+    public async Task FilterRefresh_WhenOnlyHighlightColorChanges_DoesNotRescan()
     {
         SavedFilter red = Filter(HighlightColor.LightRed);
         SavedFilter blue = red with { Color = HighlightColor.LightBlue };
@@ -182,26 +283,18 @@ public async Task FilterRefresh_WhenOnlyHighlightColorChanges_DoesNotReadActiveV
         var cut = Render<HistogramPane>();
         await cut.InvokeAsync(() => cut.Instance.OnHistogramResized(500, 100));
 
-        // The resize starts a background scan that reads ActiveView.Value twice: once synchronously at StartScan (before
-        // this await returns) and once in its post-scan continuation (the "did the view change mid-scan?" check). Wait for
-        // that second read so the continuation's read is not miscounted against the colour-only change under test (it
-        // otherwise races ClearReceivedCalls under load). The markup never reads ActiveView.Value, so the count is exact.
-        cut.WaitForAssertion(() => _ = _activeView.Received(2).Value);
-        _activeView.ClearReceivedCalls();
+        cut.WaitForAssertion(() => _scanView.Received().TryGetTimeTicksRange(out Arg.Any<long>(), out Arg.Any<long>(), Arg.Any<CancellationToken>()));
+        _scanView.ClearReceivedCalls();
 
-        _filters.SelectedValueChanged +=
-            Raise.Event<EventHandler<ImmutableList<SavedFilter>>>(_filters, ImmutableList.Create(blue));
+        _filters.Changed += Raise.Event<Action>();
         await cut.InvokeAsync(() => { });
 
-        _ = _activeView.DidNotReceive().Value;
+        _scanView.DidNotReceive().TryGetTimeTicksRange(out Arg.Any<long>(), out Arg.Any<long>(), Arg.Any<CancellationToken>());
     }
 
     [Fact]
-    public async Task FilterRefresh_WhenPredicatePlanChangesButTieStaysUnarmed_DoesNotReadActiveViewForScan()
+    public async Task FilterRefresh_WhenPredicatePlanChangesButTieStaysUnarmed_DoesNotRescan()
     {
-        // Both filter sets are eligible but uncoloured (HighlightColor.None), so highlight-tie is never armed
-        // and the histogram output is independent of the predicates. A plan-key change (7 -> 8) while tie stays
-        // unarmed must update UI state only - it must not trigger a background rescan (which would read ActiveView).
         SavedFilter firstUncoloured = Filter(HighlightColor.None);
         SavedFilter secondUncoloured = Filter(HighlightColor.None);
         _highlightSelector.Select(Arg.Any<ImmutableList<SavedFilter>>()).Returns([firstUncoloured], [secondUncoloured]);
@@ -209,20 +302,17 @@ public async Task FilterRefresh_WhenPredicatePlanChangesButTieStaysUnarmed_DoesN
         var cut = Render<HistogramPane>();
         await cut.InvokeAsync(() => cut.Instance.OnHistogramResized(500, 100));
 
-        // Wait for the resize scan's two ActiveView.Value reads (sync StartScan + post-scan continuation) to
-        // settle before clearing, so a late continuation read is not miscounted against the change under test.
-        cut.WaitForAssertion(() => _ = _activeView.Received(2).Value);
-        _activeView.ClearReceivedCalls();
+        cut.WaitForAssertion(() => _scanView.Received().TryGetTimeTicksRange(out Arg.Any<long>(), out Arg.Any<long>(), Arg.Any<CancellationToken>()));
+        _scanView.ClearReceivedCalls();
 
-        _filters.SelectedValueChanged +=
-            Raise.Event<EventHandler<ImmutableList<SavedFilter>>>(_filters, ImmutableList.Create(secondUncoloured));
+        _filters.Changed += Raise.Event<Action>();
         await cut.InvokeAsync(() => { });
 
-        _ = _activeView.DidNotReceive().Value;
+        _scanView.DidNotReceive().TryGetTimeTicksRange(out Arg.Any<long>(), out Arg.Any<long>(), Arg.Any<CancellationToken>());
     }
 
     [Fact]
-    public async Task FilterRefresh_WhenPredicatePlanChanges_ReadsActiveViewForScan()
+    public async Task FilterRefresh_WhenPredicatePlanChanges_Rescans()
     {
         SavedFilter red = Filter(HighlightColor.LightRed);
         SavedFilter blue = Filter(HighlightColor.LightBlue);
@@ -231,16 +321,81 @@ public async Task FilterRefresh_WhenPredicatePlanChanges_ReadsActiveViewForScan(
         var cut = Render<HistogramPane>();
         await cut.InvokeAsync(() => cut.Instance.OnHistogramResized(500, 100));
 
-        // Wait for the resize scan's two ActiveView.Value reads (sync StartScan + post-scan continuation) to settle
-        // before clearing, so the continuation's late read is not miscounted against the plan-change rescan under test.
-        cut.WaitForAssertion(() => _ = _activeView.Received(2).Value);
-        _activeView.ClearReceivedCalls();
+        cut.WaitForAssertion(() => _scanView.Received().TryGetTimeTicksRange(out Arg.Any<long>(), out Arg.Any<long>(), Arg.Any<CancellationToken>()));
+        _scanView.ClearReceivedCalls();
+
+        _filters.Changed += Raise.Event<Action>();
+
+        cut.WaitForAssertion(() => _scanView.Received().TryGetTimeTicksRange(out Arg.Any<long>(), out Arg.Any<long>(), Arg.Any<CancellationToken>()));
+    }
+
+    [Fact]
+    public async Task FocusChange_ResolvesTheFocusedTickFromTheView()
+    {
+        var handle = new EventLocator(_tabId, 0, 0);
+        long focusedTicks = new DateTime(2024, 6, 1, 0, 0, 0, DateTimeKind.Utc).Ticks;
+        _scanView.Rank(handle).Returns(0);
+        _scanView.TryGetTimeTicks(handle, out Arg.Any<long>()).Returns(call => { call[1] = focusedTicks; return true; });
+        var cut = Render<HistogramPane>();
+
+        var focusedTicksField = typeof(HistogramPane).GetField(
+            "_focusedTicks", BindingFlags.Instance | BindingFlags.NonPublic)!;
+
+        Assert.Null(focusedTicksField.GetValue(cut.Instance));
+
+        _eventFocus.Current.Returns(new SelectionEntry(handle, handle, null));
+        await cut.InvokeAsync(() => _eventFocus.Changed += Raise.Event<Action>());
+
+        cut.WaitForAssertion(() => Assert.Equal(focusedTicks, (long?)focusedTicksField.GetValue(cut.Instance)));
+    }
+
+    [Fact]
+    public async Task OrderingOnlyPublication_NewViewSameContent_DoesNotRescan()
+    {
+        var cut = Render<HistogramPane>();
+        await cut.InvokeAsync(() => cut.Instance.OnHistogramResized(500, 100));
+        cut.WaitForAssertion(() => _scanView.Received().TryGetTimeTicksRange(
+            out Arg.Any<long>(), out Arg.Any<long>(), Arg.Any<CancellationToken>()));
+
+        int rendersBefore = cut.RenderCount;
+
+        var reordered = Substitute.For<IEventColumnView>();
+        var next = new OrderedViewPresentation(reordered, _tabId, default, PresentationState.Current, 2)
+        {
+            ContentToken = Token(1)
+        };
+        _presentation = next;
+        await cut.InvokeAsync(() => _viewSource.Updated += Raise.Event<Action<OrderedViewPresentation>>(next));
+
+        cut.WaitForState(() => cut.RenderCount > rendersBefore);
+
+        Assert.False(GetPrivateField<bool>(cut, "_recomputePending"));
+        reordered.DidNotReceive().TryGetTimeTicksRange(
+            out Arg.Any<long>(), out Arg.Any<long>(), Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public async Task Publication_ForTheSameTab_RescansAgainstTheNewView()
+    {
+        var cut = Render<HistogramPane>();
+        await cut.InvokeAsync(() => cut.Instance.OnHistogramResized(500, 100));
+
+        cut.WaitForAssertion(() => _scanView.Received().TryGetTimeTicksRange(
+            out Arg.Any<long>(), out Arg.Any<long>(), Arg.Any<CancellationToken>()));
+
+        var appended = Substitute.For<IEventColumnView>();
+        var next = new OrderedViewPresentation(appended, _tabId, default, PresentationState.Current, 2)
+        {
+            ContentToken = Token(2)
+        };
 
-        _filters.SelectedValueChanged +=
-            Raise.Event<EventHandler<ImmutableList<SavedFilter>>>(_filters, ImmutableList.Create(blue));
+        _presentation = next;
+        await cut.InvokeAsync(() => _viewSource.Updated += Raise.Event<Action<OrderedViewPresentation>>(next));
 
-        // The plan-change rescan dispatches via InvokeAsync; wait for its ActiveView.Value read rather than checking eagerly.
-        cut.WaitForAssertion(() => _ = _activeView.Received().Value);
+        cut.WaitForAssertion(
+            () => appended.Received().TryGetTimeTicksRange(
+                out Arg.Any<long>(), out Arg.Any<long>(), Arg.Any<CancellationToken>()),
+            s_testTimeout);
     }
 
     [Fact]
@@ -261,8 +416,7 @@ public void Render_WhenLaterDimensionRequestHasHigherToken_AppliesRequestedDimen
         var cut = Render<HistogramPane>();
 
         _dimensionRequestValue = new HistogramDimensionRequest(HistogramDimension.EventId, 2);
-        _dimensionRequest.SelectedValueChanged +=
-            Raise.Event<EventHandler<HistogramDimensionRequest?>>(_dimensionRequest, _dimensionRequestValue);
+        _dimensionRequest.Changed += Raise.Event<Action>();
 
         cut.WaitForAssertion(() => Assert.Equal(HistogramDimension.EventId, GetDimension(cut)));
     }
@@ -298,8 +452,7 @@ public async Task Render_WhenStaleDimensionRequestArrivesAfterManualChange_DoesN
         var cut = Render<HistogramPane>();
         await SelectDimensionAsync(cut, HistogramDimension.Source);
 
-        _dimensionRequest.SelectedValueChanged +=
-            Raise.Event<EventHandler<HistogramDimensionRequest?>>(_dimensionRequest, _dimensionRequestValue);
+        _dimensionRequest.Changed += Raise.Event<Action>();
 
         cut.WaitForAssertion(() => Assert.Equal(HistogramDimension.Source, GetDimension(cut)));
     }
@@ -343,6 +496,44 @@ public void ResolveGroupHighlight_MapsMasksToCssAndText(
         Assert.Equal(expectedDescription, description);
     }
 
+    [Fact]
+    public async Task ScanThatFinishesAfterItsTabIsLeft_DoesNotPublish()
+    {
+        // because the switch only schedules a THROTTLED rescan, so no supersede has happened yet when this lands.
+        //
+        // The tab moves from inside the scan's own first view read, so no thread is parked waiting for it. Completion
+        // is awaited through a signal rather than WaitForAssertion: a rejected scan renders nothing, and
+        // WaitForAssertion only re-evaluates on render, so it would wait out its whole timeout no matter what happened.
+        var scanRead = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        _scanView.TryGetTimeTicksRange(out Arg.Any<long>(), out Arg.Any<long>(), Arg.Any<CancellationToken>())
+            .Returns(call =>
+            {
+                _presentation = new OrderedViewPresentation(
+                    _scanView, EventLogId.Create(), default, PresentationState.Current, 2);
+
+                call[0] = 0L;
+                call[1] = TimeSpan.TicksPerHour;
+                scanRead.TrySetResult();
+
+                return true;
+            });
+
+        var cut = Render<HistogramPane>();
+
+        var seeded = ArmedCategoryData();
+
+        await PublishBaseDataAsync(cut, seeded);
+        await cut.InvokeAsync(() => cut.Instance.OnHistogramResized(500, 100));
+
+        await scanRead.Task.WaitAsync(s_testTimeout, TestContext.Current.CancellationToken);
+
+        await Task.Delay(s_settleWindow, TestContext.Current.CancellationToken);
+        await cut.InvokeAsync(() => { });
+
+        Assert.Same(seeded, GetPrivateFieldOrNull<HistogramData>(cut, "_baseData"));
+    }
+
     [Fact]
     public void ShouldArmTie_WhenMoreThanThirtyOneFilters_ReturnsFalse()
     {
@@ -378,16 +569,47 @@ public void SourceFiles_DefineExtendedHistogramPaletteAndForcedColorHatches()
     }
 
     [Fact]
-    public async Task StartScan_WhenViewportZero_BumpsScanEpochToSupersedeQueuedPublish()
+    public async Task StartScan_WhenViewportZero_BumpsScanVersionToSupersedeQueuedPublish()
     {
-        // A zero-size viewport makes StartScan bail without launching a scan, but it must still bump the epoch so a prior
-        // scan whose UI publication is already queued is rejected and cannot restore stale (for example, armed) data.
         var cut = Render<HistogramPane>();
-        int before = GetPrivateField<int>(cut, "_scanEpoch");
+        int before = GetPrivateField<int>(cut, "_scanVersion");
 
         await cut.InvokeAsync(() => InvokePrivate(cut, "StartScan"));
 
-        Assert.Equal(before + 1, GetPrivateField<int>(cut, "_scanEpoch"));
+        Assert.Equal(before + 1, GetPrivateField<int>(cut, "_scanVersion"));
+    }
+
+    [Fact]
+    public async Task TabSwitchWithSimultaneousPublication_RescansAgainstTheNewView()
+    {
+        var cut = Render<HistogramPane>();
+        await cut.InvokeAsync(() => cut.Instance.OnHistogramResized(500, 100));
+        cut.WaitForAssertion(() => _scanView.Received().TryGetTimeTicksRange(
+            out Arg.Any<long>(), out Arg.Any<long>(), Arg.Any<CancellationToken>()));
+
+        SetPrivateField(cut, "_isZoomed", true);
+
+        var newTab = EventLogId.Create();
+        var newView = Substitute.For<IEventColumnView>();
+        var newPresentation = new OrderedViewPresentation(newView, newTab, default, PresentationState.Current, 2)
+        {
+            ContentToken = Token(2)
+        };
+        _activeEventLog.Current.Returns(newTab);
+        _presentation = newPresentation;
+
+        await cut.InvokeAsync(() =>
+        {
+            _activeEventLog.Changed += Raise.Event<Action>();
+            _viewSource.Updated += Raise.Event<Action<OrderedViewPresentation>>(newPresentation);
+        });
+
+        cut.WaitForAssertion(() => Assert.False(GetPrivateField<bool>(cut, "_isZoomed")));
+        cut.WaitForAssertion(() => Assert.Equal(Token(2), ScannedToken(cut)));
+        cut.WaitForAssertion(
+            () => newView.Received().TryGetTimeTicksRange(
+                out Arg.Any<long>(), out Arg.Any<long>(), Arg.Any<CancellationToken>()),
+            s_testTimeout);
     }
 
     private static string? AlphaSwatchClass(IRenderedComponent<HistogramPane> cut) =>
@@ -428,6 +650,14 @@ private static T GetPrivateField<T>(IRenderedComponent<HistogramPane> cut, strin
         return Assert.IsType<T>(field.GetValue(cut.Instance));
     }
 
+    private static T? GetPrivateFieldOrNull<T>(IRenderedComponent<HistogramPane> cut, string name)
+        where T : class
+    {
+        var field = typeof(HistogramPane).GetField(name, BindingFlags.Instance | BindingFlags.NonPublic);
+        Assert.NotNull(field);
+        return field.GetValue(cut.Instance) as T;
+    }
+
     private static void InvokePrivate(IRenderedComponent<HistogramPane> cut, string name)
     {
         var method = typeof(HistogramPane).GetMethod(name, BindingFlags.Instance | BindingFlags.NonPublic);
@@ -467,6 +697,11 @@ private static string ResolveRepoPath(params string[] segments)
         return path;
     }
 
+    private static ViewContentToken? ScannedToken(IRenderedComponent<HistogramPane> cut) =>
+        (ViewContentToken?)typeof(HistogramPane)
+            .GetField("_lastScannedToken", BindingFlags.Instance | BindingFlags.NonPublic)!
+            .GetValue(cut.Instance);
+
     private static Task SelectDimensionAsync(IRenderedComponent<HistogramPane> cut, HistogramDimension dimension)
     {
         var select = cut.FindComponent<ValueSelect<HistogramDimension>>();
@@ -480,4 +715,7 @@ private static void SetPrivateField(IRenderedComponent<HistogramPane> cut, strin
         Assert.NotNull(field);
         field.SetValue(cut.Instance, value);
     }
+
+    private static ViewContentToken Token(long contentVersion) =>
+        ViewContentToken.FromStamps(default, [new ViewContentTokenReaderStamp(s_tokenLog, 0, contentVersion, 1)], 1);
 }
diff --git a/tests/Unit/EventLogExpert.UI.Tests/LogTable/LogTabBarTests.cs b/tests/Unit/EventLogExpert.UI.Tests/LogTable/LogTabBarTests.cs
index 294bb64c1..432480deb 100644
--- a/tests/Unit/EventLogExpert.UI.Tests/LogTable/LogTabBarTests.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/LogTable/LogTabBarTests.cs
@@ -7,8 +7,8 @@
 using EventLogExpert.Runtime.Alerts;
 using EventLogExpert.Runtime.EventLog;
 using EventLogExpert.Runtime.LogTable;
-using EventLogExpert.Runtime.Menu;
 using EventLogExpert.UI.LogTable;
+using EventLogExpert.UI.Menu;
 using Fluxor;
 using Microsoft.AspNetCore.Components.Web;
 using Microsoft.Extensions.DependencyInjection;
@@ -24,6 +24,10 @@ public sealed class LogTabBarTests : BunitContext
     private readonly ILogTableCommands _logTableCommands = Substitute.For<ILogTableCommands>();
     private readonly IState<LogTableState> _logTableState = Substitute.For<IState<LogTableState>>();
     private readonly IMenuService _menuService = Substitute.For<IMenuService>();
+    private readonly IState<FilteredLogPresenceState> _presenceState =
+        Substitute.For<IState<FilteredLogPresenceState>>();
+    private readonly ILogTableQueries _queries = Substitute.For<ILogTableQueries>();
+    private readonly ILogTabBarSource _source = Substitute.For<ILogTabBarSource>();
     private readonly ITraceLogger _traceLogger = Substitute.For<ITraceLogger>();
 
     private IReadOnlyList<MenuItem>? _capturedMenu;
@@ -42,13 +46,41 @@ public LogTabBarTests()
                 Arg.Any<bool>()))
             .Do(call => _capturedMenu = call.Arg<IReadOnlyList<MenuItem>>());
 
+        _logTableState.Value.Returns(new LogTableState());
+
+        _presenceState.Value.Returns(new FilteredLogPresenceState());
+
+        _source.Current.Returns(_ => PresentationFrom(_logTableState.Value, _presenceState.Value));
+        _queries.GetTabGroups().Returns(_ => _logTableState.Value.Groups);
+        _queries.HasMultipleIndividualTabs()
+            .Returns(_ => _logTableState.Value.EventTables.Count(table => !table.IsCombined) > 1);
+        _queries.HasOtherTabsInGroup(Arg.Any<LogTabGroupId>(), Arg.Any<EventLogId>()).Returns(call =>
+        {
+            var state = _logTableState.Value;
+
+            if (state.Groups.FirstOrDefault(group => group.Id == call.ArgAt<LogTabGroupId>(0)) is not { } group)
+            {
+                return false;
+            }
+
+            return group.MemberIds.Contains(call.ArgAt<EventLogId>(1)) &&
+                state.EventTables.Count(table => table.GroupId is null && group.MemberIds.Contains(table.Id)) > 1;
+        });
+        _queries.HasTabGroup(Arg.Any<LogTabGroupId>())
+            .Returns(call => _logTableState.Value.Groups.Any(group => group.Id == call.ArgAt<LogTabGroupId>(0)));
+        _queries.IsTabOpen(Arg.Any<EventLogId>())
+            .Returns(call => _logTableState.Value.EventTables.Any(table => table.Id == call.ArgAt<EventLogId>(0)));
+        _queries.IsUngroupedTabOpen(Arg.Any<EventLogId>())
+            .Returns(call => _logTableState.Value.EventTables.Any(
+                table => table.Id == call.ArgAt<EventLogId>(0) && table.GroupId is null));
+
         Services.AddSingleton(_alertDialogService);
         Services.AddSingleton(_eventLogCommands);
         Services.AddSingleton(_logTableCommands);
-        Services.AddSingleton(_logTableState);
         Services.AddSingleton(_menuService);
+        Services.AddSingleton(_queries);
+        Services.AddSingleton(_source);
         Services.AddSingleton(_traceLogger);
-        Services.AddFluxor(options => options.ScanAssemblies(typeof(LogTabBar).Assembly));
     }
 
     [Fact]
@@ -56,7 +88,7 @@ public async Task ActiveTabChange_Rerenders()
     {
         var alpha = EventLogId.Create();
         var beta = EventLogId.Create();
-        var state1 = TwoTabState(alpha, beta, alphaCount: 1, betaCount: 1);
+        var state1 = TwoTabState(alpha, beta);
         _logTableState.Value.Returns(state1);
         var cut = Render<LogTabBar>();
         int before = cut.RenderCount;
@@ -114,18 +146,31 @@ public async Task CloseMenuItem_StaleTab_DoesNotDispatchCloseLog()
     {
         var alpha = EventLogId.Create();
         var beta = EventLogId.Create();
-        _logTableState.Value.Returns(TwoTabState(alpha, beta, alphaCount: 1, betaCount: 1));
+        _logTableState.Value.Returns(TwoTabState(alpha, beta));
         var cut = Render<LogTabBar>();
         var menu = OpenContextMenu(cut, ".tab");
 
-        // Alpha is gone by the time the captured "Close" action runs.
-        _logTableState.Value.Returns(TwoTabState(beta, EventLogId.Create(), alphaCount: 1, betaCount: 1));
+        _logTableState.Value.Returns(TwoTabState(beta, EventLogId.Create()));
 
         await InvokeMenuItemAsync(cut, FindItem(menu, "Close"));
 
         _eventLogCommands.DidNotReceive().CloseLog(Arg.Any<EventLogId>(), Arg.Any<string>());
     }
 
+    [Fact]
+    public void CloseOtherTabs_DisabledWhenNoOtherPerLogTabs()
+    {
+        var allLogsId = EventLogId.Create();
+        var logId = EventLogId.Create();
+        _logTableState.Value.Returns(AllLogsState(allLogsId, logId, "Alpha"));
+        var cut = Render<LogTabBar>();
+        var menu = OpenContextMenuByIndex(cut, 1);
+
+        var item = FindItem(menu, "Close other tabs");
+        Assert.False(item.IsEnabled);
+        Assert.Equal("No other tabs to close", item.DisabledReason);
+    }
+
     [Fact]
     public void CloseOthersInGroup_DisabledForSingleMember()
     {
@@ -140,17 +185,20 @@ public void CloseOthersInGroup_DisabledForSingleMember()
     }
 
     [Fact]
-    public void CloseOtherTabs_DisabledWhenNoOtherPerLogTabs()
+    public async Task CollapseOnlyChange_Rerenders()
     {
-        var allLogsId = EventLogId.Create();
-        var logId = EventLogId.Create();
-        _logTableState.Value.Returns(AllLogsState(allLogsId, logId, "Alpha"));
+        var (state1, _, _, _, _) = GroupedState(collapsed: false, activeIsMember1: false);
+        _logTableState.Value.Returns(state1);
         var cut = Render<LogTabBar>();
-        var menu = OpenContextMenuByIndex(cut, 1);
+        int before = cut.RenderCount;
 
-        var item = FindItem(menu, "Close other tabs");
-        Assert.False(item.IsEnabled);
-        Assert.Equal("No other tabs to close", item.DisabledReason);
+        var state2 = state1 with
+        {
+            Groups = state1.Groups.SetItem(0, state1.Groups[0] with { IsCollapsed = true })
+        };
+        await RaiseStateChange(cut, state2);
+
+        Assert.True(cut.RenderCount > before);
     }
 
     [Fact]
@@ -176,23 +224,6 @@ public void CollapsedGroup_RendersDownChevron()
         Assert.Contains("bi-chevron-down", cut.Markup);
     }
 
-    [Fact]
-    public async Task CollapseOnlyChange_Rerenders()
-    {
-        var (state1, _, _, _, _) = GroupedState(collapsed: false, activeIsMember1: false);
-        _logTableState.Value.Returns(state1);
-        var cut = Render<LogTabBar>();
-        int before = cut.RenderCount;
-
-        var state2 = state1 with
-        {
-            Groups = state1.Groups.SetItem(0, state1.Groups[0] with { IsCollapsed = true })
-        };
-        await RaiseStateChange(cut, state2);
-
-        Assert.True(cut.RenderCount > before);
-    }
-
     [Fact]
     public void CombinedHeader_RendersCombinedLabel()
     {
@@ -203,8 +234,7 @@ public void CombinedHeader_RendersCombinedLabel()
             ActiveEventLogId = allLogsId,
             EventTables = ImmutableList.Create(
                 new LogView(allLogsId) { GroupId = LogTabGroupId.AllLogs },
-                new LogView(logId) { LogName = "Alpha" }),
-            EventCountByLog = ImmutableDictionary<EventLogId, int>.Empty.Add(logId, 1)
+                new LogView(logId) { LogName = "Alpha" })
         };
         _logTableState.Value.Returns(state);
 
@@ -213,56 +243,20 @@ public void CombinedHeader_RendersCombinedLabel()
         Assert.Contains("Combined", cut.Markup);
     }
 
-    [Fact]
-    public async Task EmptinessSwapSameTotal_Rerenders()
-    {
-        var alpha = EventLogId.Create();
-        var beta = EventLogId.Create();
-        var state1 = TwoTabState(alpha, beta, alphaCount: 5, betaCount: 0);
-        _logTableState.Value.Returns(state1);
-        var cut = Render<LogTabBar>();
-        int before = cut.RenderCount;
-
-        var state2 = state1 with
-        {
-            EventCountByLog = ImmutableDictionary<EventLogId, int>.Empty.Add(alpha, 0).Add(beta, 5)
-        };
-        await RaiseStateChange(cut, state2);
-
-        Assert.True(cut.RenderCount > before);
-    }
-
-    [Fact]
-    public async Task EmptyToNonEmpty_Rerenders()
-    {
-        var alpha = EventLogId.Create();
-        var beta = EventLogId.Create();
-        var state1 = TwoTabState(alpha, beta, alphaCount: 0, betaCount: 1);
-        _logTableState.Value.Returns(state1);
-        var cut = Render<LogTabBar>();
-        int before = cut.RenderCount;
-
-        var state2 = state1 with { EventCountByLog = state1.EventCountByLog.SetItem(alpha, 1) };
-        await RaiseStateChange(cut, state2);
-
-        Assert.True(cut.RenderCount > before);
-    }
-
     [Fact]
     public async Task EventTablesChange_Rerenders()
     {
         var alpha = EventLogId.Create();
         var beta = EventLogId.Create();
         var gamma = EventLogId.Create();
-        var state1 = TwoTabState(alpha, beta, alphaCount: 1, betaCount: 1);
+        var state1 = TwoTabState(alpha, beta);
         _logTableState.Value.Returns(state1);
         var cut = Render<LogTabBar>();
         int before = cut.RenderCount;
 
         var state2 = state1 with
         {
-            EventTables = state1.EventTables.Add(new LogView(gamma) { LogName = "Gamma" }),
-            EventCountByLog = state1.EventCountByLog.Add(gamma, 1)
+            EventTables = state1.EventTables.Add(new LogView(gamma) { LogName = "Gamma" })
         };
         await RaiseStateChange(cut, state2);
 
@@ -299,7 +293,7 @@ public void FirstRender_WithPopulatedState_ShowsTabs()
     {
         var alpha = EventLogId.Create();
         var beta = EventLogId.Create();
-        _logTableState.Value.Returns(TwoTabState(alpha, beta, alphaCount: 1, betaCount: 1));
+        _logTableState.Value.Returns(TwoTabState(alpha, beta));
 
         var cut = Render<LogTabBar>();
 
@@ -319,6 +313,18 @@ public void GroupClose_DispatchesCloseGroup()
         _logTableCommands.Received(1).CloseGroup(groupId);
     }
 
+    [Fact]
+    public void GroupHeaderName_MouseDown_DispatchesSetActiveTable()
+    {
+        var (state, _, headerId, _, _) = GroupedState(collapsed: false, activeIsMember1: false);
+        _logTableState.Value.Returns(state);
+        var cut = Render<LogTabBar>();
+
+        cut.Find(".group-header > span").MouseDown();
+
+        _logTableCommands.Received(1).SetActiveTable(headerId);
+    }
+
     [Fact]
     public async Task GroupHeader_Collapse_DispatchesSetTabGroupCollapsed()
     {
@@ -348,6 +354,24 @@ public async Task GroupHeader_Rename_PromptThenDispatches()
         _logTableCommands.Received(1).RenameGroup(groupId, "Renamed");
     }
 
+    [Fact]
+    public async Task GroupHeader_Rename_StaleGroup_DoesNotDispatch()
+    {
+        var (state, _, _, _, _) = GroupedState(collapsed: false, activeIsMember1: false);
+        _logTableState.Value.Returns(state);
+        _alertDialogService
+            .DisplayPrompt("Rename group", Arg.Any<string>(), "MyGroup", Arg.Any<Func<string, string?>?>())
+            .Returns("Renamed");
+        var cut = Render<LogTabBar>();
+        var menu = OpenContextMenu(cut, ".group-header");
+
+        _logTableState.Value.Returns(new LogTableState());
+
+        await InvokeMenuItemAsync(cut, FindItem(menu, "Rename\u2026"));
+
+        _logTableCommands.DidNotReceive().RenameGroup(Arg.Any<LogTabGroupId>(), Arg.Any<string>());
+    }
+
     [Fact]
     public void GroupHeader_RightClick_ShowsExpectedItems()
     {
@@ -362,15 +386,17 @@ public void GroupHeader_RightClick_ShowsExpectedItems()
     }
 
     [Fact]
-    public void GroupHeaderName_MouseDown_DispatchesSetActiveTable()
+    public void KnownEmptyPresence_RendersEmptyPrefix()
     {
-        var (state, _, headerId, _, _) = GroupedState(collapsed: false, activeIsMember1: false);
-        _logTableState.Value.Returns(state);
-        var cut = Render<LogTabBar>();
+        var alpha = EventLogId.Create();
+        var beta = EventLogId.Create();
+        _logTableState.Value.Returns(TwoTabState(alpha, beta));
+        _presenceState.Value.Returns(Presence((alpha, false), (beta, true)));
 
-        cut.Find(".group-header > span").MouseDown();
+        var cut = Render<LogTabBar>();
 
-        _logTableCommands.Received(1).SetActiveTable(headerId);
+        Assert.Contains("(Empty) Alpha", cut.Markup);
+        Assert.DoesNotContain("(Empty) Beta", cut.Markup);
     }
 
     [Fact]
@@ -447,19 +473,30 @@ public void MemberTab_RightClick_ShowsExpectedItems()
     }
 
     [Fact]
-    public async Task NonEmptyTabCountIncrement_DoesNotRerender()
+    public void PendingPresence_DoesNotRenderEmptyPrefix()
     {
         var alpha = EventLogId.Create();
         var beta = EventLogId.Create();
-        var state1 = TwoTabState(alpha, beta, alphaCount: 5, betaCount: 3);
-        _logTableState.Value.Returns(state1);
+        _logTableState.Value.Returns(TwoTabState(alpha, beta));
+        _presenceState.Value.Returns(new FilteredLogPresenceState());
+
         var cut = Render<LogTabBar>();
-        int before = cut.RenderCount;
 
-        var state2 = state1 with { EventCountByLog = state1.EventCountByLog.SetItem(alpha, 6) };
-        await RaiseStateChange(cut, state2);
+        Assert.DoesNotContain("(Empty)", cut.Markup);
+    }
 
-        Assert.Equal(before, cut.RenderCount);
+    [Fact]
+    public async Task PresenceChange_RerendersEmptyLabels()
+    {
+        var alpha = EventLogId.Create();
+        var beta = EventLogId.Create();
+        _logTableState.Value.Returns(TwoTabState(alpha, beta));
+        var cut = Render<LogTabBar>();
+        Assert.DoesNotContain("(Empty) Alpha", cut.Markup);
+
+        await RaisePresenceChange(cut, Presence((alpha, false), (beta, true)));
+
+        Assert.Contains("(Empty) Alpha", cut.Markup);
     }
 
     [Fact]
@@ -467,7 +504,7 @@ public void RightClickMouseDown_DoesNotActivateTab()
     {
         var alpha = EventLogId.Create();
         var beta = EventLogId.Create();
-        _logTableState.Value.Returns(TwoTabState(alpha, beta, alphaCount: 1, betaCount: 1));
+        _logTableState.Value.Returns(TwoTabState(alpha, beta));
         var cut = Render<LogTabBar>();
 
         cut.Find(".tab > span").MouseDown(new MouseEventArgs { Button = 2 });
@@ -480,7 +517,7 @@ public void RightClickMouseDown_OnCloseIcon_DoesNotCloseLog()
     {
         var alpha = EventLogId.Create();
         var beta = EventLogId.Create();
-        _logTableState.Value.Returns(TwoTabState(alpha, beta, alphaCount: 1, betaCount: 1));
+        _logTableState.Value.Returns(TwoTabState(alpha, beta));
         var cut = Render<LogTabBar>();
 
         cut.Find(".tab > i.bi-x").MouseDown(new MouseEventArgs { Button = 2 });
@@ -493,7 +530,7 @@ public async Task StandaloneTab_BlankGroupName_DoesNotDispatch()
     {
         var alpha = EventLogId.Create();
         var beta = EventLogId.Create();
-        _logTableState.Value.Returns(TwoTabState(alpha, beta, alphaCount: 1, betaCount: 1));
+        _logTableState.Value.Returns(TwoTabState(alpha, beta));
         _alertDialogService
             .DisplayPrompt("New group", Arg.Any<string>(), Arg.Any<string>(), Arg.Any<Func<string, string?>?>())
             .Returns("   ");
@@ -506,31 +543,31 @@ public async Task StandaloneTab_BlankGroupName_DoesNotDispatch()
     }
 
     [Fact]
-    public async Task StandaloneTab_Close_DispatchesCloseLog()
+    public async Task StandaloneTab_CloseOtherTabs_DispatchesCloseAllButThis()
     {
         var alpha = EventLogId.Create();
         var beta = EventLogId.Create();
-        _logTableState.Value.Returns(TwoTabState(alpha, beta, alphaCount: 1, betaCount: 1));
+        _logTableState.Value.Returns(TwoTabState(alpha, beta));
         var cut = Render<LogTabBar>();
         var menu = OpenContextMenu(cut, ".tab");
 
-        await InvokeMenuItemAsync(cut, FindItem(menu, "Close"));
+        await InvokeMenuItemAsync(cut, FindItem(menu, "Close other tabs"));
 
-        _eventLogCommands.Received(1).CloseLog(alpha, "Alpha");
+        _logTableCommands.Received(1).CloseAllButThis(alpha);
     }
 
     [Fact]
-    public async Task StandaloneTab_CloseOtherTabs_DispatchesCloseAllButThis()
+    public async Task StandaloneTab_Close_DispatchesCloseLog()
     {
         var alpha = EventLogId.Create();
         var beta = EventLogId.Create();
-        _logTableState.Value.Returns(TwoTabState(alpha, beta, alphaCount: 1, betaCount: 1));
+        _logTableState.Value.Returns(TwoTabState(alpha, beta));
         var cut = Render<LogTabBar>();
         var menu = OpenContextMenu(cut, ".tab");
 
-        await InvokeMenuItemAsync(cut, FindItem(menu, "Close other tabs"));
+        await InvokeMenuItemAsync(cut, FindItem(menu, "Close"));
 
-        _logTableCommands.Received(1).CloseAllButThis(alpha);
+        _eventLogCommands.Received(1).CloseLog(alpha, "Alpha");
     }
 
     [Fact]
@@ -549,40 +586,39 @@ public async Task StandaloneTab_MoveToExistingGroup_Dispatches()
     }
 
     [Fact]
-    public async Task StandaloneTab_NewGroup_StaleTab_DoesNotDispatch()
+    public async Task StandaloneTab_NewGroupFromTab_PromptThenDispatches()
     {
         var alpha = EventLogId.Create();
         var beta = EventLogId.Create();
-        _logTableState.Value.Returns(TwoTabState(alpha, beta, alphaCount: 1, betaCount: 1));
+        _logTableState.Value.Returns(TwoTabState(alpha, beta));
         _alertDialogService
             .DisplayPrompt("New group", Arg.Any<string>(), Arg.Any<string>(), Arg.Any<Func<string, string?>?>())
             .Returns("Diagnostics");
         var cut = Render<LogTabBar>();
         var menu = OpenContextMenu(cut, ".tab");
 
-        // Alpha is closed while the prompt is open -> the captured menu action targets a tab no longer present.
-        _logTableState.Value.Returns(TwoTabState(beta, EventLogId.Create(), alphaCount: 1, betaCount: 1));
-
         await InvokeMenuItemAsync(cut, FindItem(menu, "New group from tab\u2026"));
 
-        _logTableCommands.DidNotReceive().NewGroupFromTab(Arg.Any<EventLogId>(), Arg.Any<string>());
+        _logTableCommands.Received(1).NewGroupFromTab(alpha, "Diagnostics");
     }
 
     [Fact]
-    public async Task StandaloneTab_NewGroupFromTab_PromptThenDispatches()
+    public async Task StandaloneTab_NewGroup_StaleTab_DoesNotDispatch()
     {
         var alpha = EventLogId.Create();
         var beta = EventLogId.Create();
-        _logTableState.Value.Returns(TwoTabState(alpha, beta, alphaCount: 1, betaCount: 1));
+        _logTableState.Value.Returns(TwoTabState(alpha, beta));
         _alertDialogService
             .DisplayPrompt("New group", Arg.Any<string>(), Arg.Any<string>(), Arg.Any<Func<string, string?>?>())
             .Returns("Diagnostics");
         var cut = Render<LogTabBar>();
         var menu = OpenContextMenu(cut, ".tab");
 
+        _logTableState.Value.Returns(TwoTabState(beta, EventLogId.Create()));
+
         await InvokeMenuItemAsync(cut, FindItem(menu, "New group from tab\u2026"));
 
-        _logTableCommands.Received(1).NewGroupFromTab(alpha, "Diagnostics");
+        _logTableCommands.DidNotReceive().NewGroupFromTab(Arg.Any<EventLogId>(), Arg.Any<string>());
     }
 
     [Fact]
@@ -590,7 +626,7 @@ public void StandaloneTab_RightClick_ShowsExpectedItems()
     {
         var alpha = EventLogId.Create();
         var beta = EventLogId.Create();
-        _logTableState.Value.Returns(TwoTabState(alpha, beta, alphaCount: 1, betaCount: 1));
+        _logTableState.Value.Returns(TwoTabState(alpha, beta));
         var cut = Render<LogTabBar>();
 
         var menu = OpenContextMenu(cut, ".tab");
@@ -599,35 +635,39 @@ public void StandaloneTab_RightClick_ShowsExpectedItems()
         Assert.Equal(["New group from tab\u2026", "Move to group", string.Empty, "Close", "Close other tabs"], labels);
     }
 
-    [Fact]
-    public async Task UnrelatedFieldChange_DoesNotRerender()
-    {
-        var alpha = EventLogId.Create();
-        var beta = EventLogId.Create();
-        var state1 = TwoTabState(alpha, beta, alphaCount: 1, betaCount: 1);
-        _logTableState.Value.Returns(state1);
-        var cut = Render<LogTabBar>();
-        int before = cut.RenderCount;
-
-        var state2 = state1 with { OrderBy = ColumnName.Source, IsDescending = false };
-        await RaiseStateChange(cut, state2);
-
-        Assert.Equal(before, cut.RenderCount);
-    }
-
     private static LogTableState AllLogsState(EventLogId allLogsId, EventLogId logId, string logName) =>
         new()
         {
             ActiveEventLogId = allLogsId,
             EventTables = ImmutableList.Create(
                 new LogView(allLogsId) { GroupId = LogTabGroupId.AllLogs },
-                new LogView(logId) { LogName = logName }),
-            EventCountByLog = ImmutableDictionary<EventLogId, int>.Empty.Add(logId, 1)
+                new LogView(logId) { LogName = logName })
         };
 
     private static MenuItem FindItem(IEnumerable<MenuItem> items, string label) =>
         items.First(item => item.Label == label);
 
+    private static (LogTableState State, LogTabGroupId GroupId, EventLogId Standalone) GroupPlusStandaloneState()
+    {
+        var groupId = LogTabGroupId.Create();
+        var headerId = EventLogId.Create();
+        var member = EventLogId.Create();
+        var standalone = EventLogId.Create();
+
+        var state = new LogTableState
+        {
+            ActiveEventLogId = standalone,
+            EventTables = ImmutableList.Create(
+                new LogView(headerId) { GroupId = groupId, LogName = "MyGroup" },
+                new LogView(member) { LogName = "Alpha" },
+                new LogView(standalone) { LogName = "Gamma" }),
+            Groups = ImmutableList.Create(
+                new LogTabGroup(groupId, "MyGroup", ImmutableHashSet.Create(member)))
+        };
+
+        return (state, groupId, standalone);
+    }
+
     private static (LogTableState State, LogTabGroupId GroupId, EventLogId HeaderId, EventLogId Member1, EventLogId Member2)
         GroupedState(bool collapsed, bool activeIsMember1)
     {
@@ -647,33 +687,44 @@ private static (LogTableState State, LogTabGroupId GroupId, EventLogId HeaderId,
                 new LogTabGroup(groupId, "MyGroup", ImmutableHashSet.Create(member1, member2))
                 {
                     IsCollapsed = collapsed
-                }),
-            EventCountByLog = ImmutableDictionary<EventLogId, int>.Empty.Add(member1, 1).Add(member2, 1)
+                })
         };
 
         return (state, groupId, headerId, member1, member2);
     }
 
-    private static (LogTableState State, LogTabGroupId GroupId, EventLogId Standalone) GroupPlusStandaloneState()
+    private static FilteredLogPresenceState Presence(params (EventLogId LogId, bool HasSurvivor)[] verdicts)
     {
-        var groupId = LogTabGroupId.Create();
-        var headerId = EventLogId.Create();
-        var member = EventLogId.Create();
-        var standalone = EventLogId.Create();
+        var byLog = ImmutableDictionary<EventLogId, FilteredLogPresence>.Empty;
 
-        var state = new LogTableState
+        foreach (var (logId, hasSurvivor) in verdicts)
         {
-            ActiveEventLogId = standalone,
-            EventTables = ImmutableList.Create(
-                new LogView(headerId) { GroupId = groupId, LogName = "MyGroup" },
-                new LogView(member) { LogName = "Alpha" },
-                new LogView(standalone) { LogName = "Gamma" }),
-            Groups = ImmutableList.Create(
-                new LogTabGroup(groupId, "MyGroup", ImmutableHashSet.Create(member))),
-            EventCountByLog = ImmutableDictionary<EventLogId, int>.Empty.Add(member, 1).Add(standalone, 1)
-        };
+            byLog = byLog.SetItem(
+                logId,
+                hasSurvivor ? FilteredLogPresence.HasSurvivor : FilteredLogPresence.NoSurvivor);
+        }
 
-        return (state, groupId, standalone);
+        return new FilteredLogPresenceState { ByLog = byLog };
+    }
+
+    private static LogTabBarPresentation PresentationFrom(LogTableState state, FilteredLogPresenceState presence)
+    {
+        var knownEmpty = ImmutableHashSet.CreateBuilder<EventLogId>();
+
+        foreach (var table in state.EventTables)
+        {
+            if (table.IsCombined || table.IsLoading) { continue; }
+
+            if (presence.IsKnownEmpty(table.Id)) { knownEmpty.Add(table.Id); }
+        }
+
+        return new LogTabBarPresentation
+        {
+            Tabs = state.EventTables,
+            Groups = state.Groups,
+            ActiveTabId = state.ActiveEventLogId,
+            KnownEmptyTabIds = knownEmpty.ToImmutable()
+        };
     }
 
     private static (LogTableState State, LogTabGroupId GroupId, EventLogId Member) SingleMemberGroupState()
@@ -689,21 +740,19 @@ private static (LogTableState State, LogTabGroupId GroupId, EventLogId Member) S
                 new LogView(headerId) { GroupId = groupId, LogName = "Solo" },
                 new LogView(member) { LogName = "OnlyMember" }),
             Groups = ImmutableList.Create(
-                new LogTabGroup(groupId, "Solo", ImmutableHashSet.Create(member))),
-            EventCountByLog = ImmutableDictionary<EventLogId, int>.Empty.Add(member, 1)
+                new LogTabGroup(groupId, "Solo", ImmutableHashSet.Create(member)))
         };
 
         return (state, groupId, member);
     }
 
-    private static LogTableState TwoTabState(EventLogId alpha, EventLogId beta, int alphaCount, int betaCount) =>
+    private static LogTableState TwoTabState(EventLogId alpha, EventLogId beta) =>
         new()
         {
             ActiveEventLogId = alpha,
             EventTables = ImmutableList.Create(
                 new LogView(alpha) { LogName = "Alpha" },
-                new LogView(beta) { LogName = "Beta" }),
-            EventCountByLog = ImmutableDictionary<EventLogId, int>.Empty.Add(alpha, alphaCount).Add(beta, betaCount)
+                new LogView(beta) { LogName = "Beta" })
         };
 
     private async Task InvokeMenuItemAsync(IRenderedComponent<LogTabBar> cut, MenuItem item) =>
@@ -725,12 +774,19 @@ private IReadOnlyList<MenuItem> OpenContextMenuByIndex(IRenderedComponent<LogTab
         return _capturedMenu!;
     }
 
+    private async Task RaisePresenceChange(IRenderedComponent<LogTabBar> cut, FilteredLogPresenceState next)
+    {
+        _presenceState.Value.Returns(next);
+
+        await cut.InvokeAsync(() => _source.Changed += Raise.Event<Action>());
+        await cut.InvokeAsync(() => Task.CompletedTask);
+    }
+
     private async Task RaiseStateChange(IRenderedComponent<LogTabBar> cut, LogTableState next)
     {
         _logTableState.Value.Returns(next);
 
-        await cut.InvokeAsync(() =>
-            _logTableState.StateChanged += Raise.Event<EventHandler>(_logTableState, EventArgs.Empty));
+        await cut.InvokeAsync(() => _source.Changed += Raise.Event<Action>());
         await cut.InvokeAsync(() => Task.CompletedTask);
     }
 }
diff --git a/tests/Unit/EventLogExpert.UI.Tests/LogTable/LogTablePaneBusyTests.cs b/tests/Unit/EventLogExpert.UI.Tests/LogTable/LogTablePaneBusyTests.cs
new file mode 100644
index 000000000..3b1af4a85
--- /dev/null
+++ b/tests/Unit/EventLogExpert.UI.Tests/LogTable/LogTablePaneBusyTests.cs
@@ -0,0 +1,254 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using Bunit;
+using EventLogExpert.Eventing.Common.Channels;
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
+using EventLogExpert.Filtering.Persistence;
+using EventLogExpert.Runtime.EventLog;
+using EventLogExpert.Runtime.FilterPane;
+using EventLogExpert.Runtime.LogTable;
+using EventLogExpert.Runtime.Settings;
+using EventLogExpert.UI.LogTable;
+using EventLogExpert.UI.Menu;
+using EventLogExpert.UI.Tests.TestUtils;
+using Fluxor;
+using Microsoft.Extensions.DependencyInjection;
+using NSubstitute;
+using System.Collections.Immutable;
+using System.Globalization;
+
+namespace EventLogExpert.UI.Tests.LogTable;
+
+public sealed class LogTablePaneBusyTests : BunitContext
+{
+    private const string LogName = "Application";
+
+    private readonly ILogTableColumnDefaultsProvider _columnDefaults = Substitute.For<ILogTableColumnDefaultsProvider>();
+    private readonly IEventLogCommands _eventLogCommands = Substitute.For<IEventLogCommands>();
+    private readonly IState<FilterPaneState> _filterPaneState = Substitute.For<IState<FilterPaneState>>();
+    private readonly IHighlightSelector _highlightSelector = Substitute.For<IHighlightSelector>();
+    private readonly EventLogId _logId = EventLogId.Create();
+    private readonly ILogTableCommands _logTableCommands = Substitute.For<ILogTableCommands>();
+    private readonly IState<LogTableState> _logTableState = Substitute.For<IState<LogTableState>>();
+    private readonly IMenuService _menuService = Substitute.For<IMenuService>();
+    private readonly IEventFocusSource _selectedEvent = Substitute.For<IEventFocusSource>();
+    private readonly IEventSelectionSource _selectedEvents = Substitute.For<IEventSelectionSource>();
+    private readonly ISettingsService _settings = Substitute.For<ISettingsService>();
+    private readonly IOrderedViewSource _viewSource = Substitute.For<IOrderedViewSource>();
+
+    public LogTablePaneBusyTests()
+    {
+        CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;
+        JSInterop.Mode = JSRuntimeMode.Loose;
+        JSInterop.SetupModule("./_content/EventLogExpert.UI/LogTable/LogTablePane.razor.js");
+
+        _columnDefaults.ColumnOrder.Returns(ImmutableList.Create(ColumnName.Source));
+        _filterPaneState.Value.Returns(new FilterPaneState());
+        _highlightSelector.Select(Arg.Any<ImmutableList<SavedFilter>>()).Returns([]);
+        _highlightSelector.ComputeHighlightKey(Arg.Any<ImmutableList<SavedFilter>>()).Returns(0);
+        _settings.TimeZoneInfo.Returns(TimeZoneInfo.Utc);
+        _selectedEvent.Current.Returns((SelectionEntry?)null);
+        _selectedEvents.Current.Returns(ImmutableList<SelectionEntry>.Empty);
+
+        Services.AddLogTablePaneDependencies();
+        Services.AddSingleton(_columnDefaults);
+        Services.AddSingleton(_eventLogCommands);
+        Services.AddSingleton(_filterPaneState);
+        Services.AddSingleton(_highlightSelector);
+        Services.AddSingleton(_logTableState);
+        Services.AddSingleton(_selectedEvent);
+        Services.AddSingleton(_selectedEvents);
+        Services.AddSingleton(_settings);
+        Services.AddSingleton(_logTableCommands);
+        Services.AddSingleton(_menuService);
+
+        Services.AddSingleton(_viewSource);
+
+        Services.AddFluxor(options => options.ScanAssemblies(typeof(LogTablePane).Assembly));
+    }
+
+    [Fact]
+    public void AFailedGridWithNoRows_IsNotBusy_BecauseNothingIsComing()
+    {
+        Assert.False(RenderWith(PresentationState.Faulted, rows: 0));
+    }
+
+    [Fact]
+    public void AFailedGridWithRows_IsNotBusy_Either()
+    {
+        Assert.False(RenderWith(PresentationState.Faulted, rows: 3));
+    }
+
+    [Fact]
+    public void AGridWithRowsStillBeingBuilt_DoesNotSuppressTheRowsItAlreadyHas()
+    {
+        Assert.False(RenderWith(PresentationState.Updating, rows: 3));
+    }
+
+    [Fact]
+    public void AGroupedGridEndsTheWaitAtItsOwnPaint_BecauseNothingWillEverRefreshItsViewport()
+    {
+        SetCommittedState(rows: 3);
+        SetCommittedGrouping();
+
+        _viewSource.Current.Returns(Grouped(PresentationState.Updating, rows: 0, revision: 1));
+
+        var cut = Render<LogTablePane>();
+
+        Assert.True(IsBusy(cut), "an empty pending grouped grid must assert it too");
+
+        Publish(cut, Grouped(PresentationState.Current, rows: 3, revision: 2), expectedRows: 4);
+
+        cut.WaitForAssertion(() => Assert.False(IsBusy(cut)));
+    }
+
+    [Fact]
+    public void ALiveTailAppendOverRowsAlreadyOnScreen_NeverAnnouncesAWait()
+    {
+        SetCommittedState(rows: 3);
+
+        _viewSource.Current.Returns(Presentation(PresentationState.Current, rows: 3, revision: 1));
+
+        var cut = Render<LogTablePane>();
+
+        Assert.False(IsBusy(cut), "settled rows must not announce a wait to begin with");
+
+        var busySamples = new List<bool>();
+
+        cut.OnAfterRender += (_, _) => busySamples.Add(IsBusy(cut));
+
+        Publish(cut, Presentation(PresentationState.Current, rows: 4, revision: 2), expectedRows: 4);
+
+        Assert.DoesNotContain(true, busySamples);
+    }
+
+    [Fact]
+    public void ASettledEmptyGrid_IsNotBusy_BecauseTheEmptinessIsTheAnswer()
+    {
+        Assert.False(RenderWith(PresentationState.Current, rows: 0));
+    }
+
+    [Fact]
+    public void ASettledGridWithRows_IsNotBusy()
+    {
+        Assert.False(RenderWith(PresentationState.Current, rows: 3));
+    }
+
+    [Fact]
+    public void AnEmptyGridStillBeingBuilt_TellsAssistiveTechnologyToWait()
+    {
+        Assert.True(RenderWith(PresentationState.Updating, rows: 0));
+    }
+
+    [Fact]
+    public void TheWaitOutlastsTheStateFlip_BecauseTheRowsLagOneRefreshBehindIt()
+    {
+        SetCommittedState(rows: 3);
+
+        var pending = Presentation(PresentationState.Updating, rows: 0, revision: 1);
+
+        _viewSource.Current.Returns(pending);
+
+        var cut = Render<LogTablePane>();
+
+        Assert.True(IsBusy(cut), "an empty pending grid must assert it before anything else happens");
+
+        var busyAfterTheFlip = new List<bool>();
+
+        cut.OnAfterRender += (_, _) => busyAfterTheFlip.Add(IsBusy(cut));
+
+        Publish(cut, Presentation(PresentationState.Current, rows: 3, revision: 2), expectedRows: 3);
+
+        cut.WaitForAssertion(() => Assert.False(IsBusy(cut)));
+
+        Assert.Contains(true, busyAfterTheFlip);
+        Assert.False(busyAfterTheFlip[^1], "and it must end once they are");
+    }
+
+    private static ResolvedEvent Event(long recordId, string source) =>
+        new(LogName, LogPathType.Channel)
+        {
+            RecordId = recordId,
+            TimeCreated = new DateTime(2026, 1, 1, 0, 0, 0, DateTimeKind.Utc).AddMilliseconds(recordId),
+            Id = 1000,
+            Level = "Information",
+            Source = source,
+            LogName = LogName
+        };
+
+    private static ResolvedEvent[] Events(int count) =>
+        [.. Enumerable.Range(1, count).Select(index => Event(index, $"Source{index}"))];
+
+    private static DisplayIndicatorKind ExpectedKind(PresentationState state, int rows) =>
+        state switch
+        {
+            PresentationState.Faulted => DisplayIndicatorKind.Fault,
+            PresentationState.Updating when rows == 0 => DisplayIndicatorKind.EmptyPending,
+            _ => DisplayIndicatorKind.None
+        };
+
+    private static bool IsBusy(IRenderedComponent<LogTablePane> cut) =>
+        cut.Find("#eventTable").GetAttribute("aria-busy") == "true";
+
+    private OrderedViewPresentation Grouped(PresentationState state, int rows, long revision) =>
+        new(
+            DisplayViewTestFactory.Identity(
+                [.. Enumerable.Range(1, rows).Select(index => Event(index, "Alpha"))],
+                ColumnName.Source),
+            _logId,
+            new DisplayOrdering(null, false, ColumnName.Source, false),
+            state,
+            revision,
+            FaultCause: state == PresentationState.Faulted ? "InvalidOperationException: bad predicate" : null);
+
+    private OrderedViewPresentation Presentation(PresentationState state, int rows, long revision) =>
+        new(
+            DisplayViewTestFactory.Identity(Events(rows)),
+            _logId,
+            default,
+            state,
+            revision,
+            FaultCause: state == PresentationState.Faulted ? "InvalidOperationException: bad predicate" : null);
+
+    private void Publish(IRenderedComponent<LogTablePane> cut, OrderedViewPresentation presentation, int expectedRows)
+    {
+        _viewSource.Current.Returns(presentation);
+        _viewSource.Updated += Raise.Event<Action<OrderedViewPresentation>>(presentation);
+
+        cut.WaitForAssertion(() =>
+            Assert.Equal((expectedRows + 1).ToString(), cut.Find("#eventTable").GetAttribute("aria-rowcount")));
+    }
+
+    private bool RenderWith(PresentationState state, int rows)
+    {
+        SetCommittedState(rows);
+
+        _viewSource.Current.Returns(Presentation(state, rows, revision: 1));
+
+        var cut = Render<LogTablePane>();
+
+        Assert.Equal(
+            ExpectedKind(state, rows),
+            _viewSource.Current.IndicatorKind);
+
+        return IsBusy(cut);
+    }
+
+    private void SetCommittedGrouping() =>
+        _logTableState.Value.Returns(_logTableState.Value with { GroupBy = ColumnName.Source });
+
+    private void SetCommittedState(int rows)
+    {
+        var state = new LogTableState
+        {
+            ActiveEventLogId = _logId,
+            EventTables = [new LogView(_logId) { LogName = LogName }],
+            Columns = ImmutableDictionary<ColumnName, bool>.Empty.Add(ColumnName.Source, true),
+            ColumnOrder = ImmutableList.Create(ColumnName.Source)
+        };
+
+        _logTableState.Value.Returns(state);
+    }
+}
diff --git a/tests/Unit/EventLogExpert.UI.Tests/LogTable/LogTablePaneFindTests.cs b/tests/Unit/EventLogExpert.UI.Tests/LogTable/LogTablePaneFindTests.cs
index aa01c0f2a..7293e0947 100644
--- a/tests/Unit/EventLogExpert.UI.Tests/LogTable/LogTablePaneFindTests.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/LogTable/LogTablePaneFindTests.cs
@@ -19,6 +19,7 @@
 using NSubstitute;
 using System.Collections.Immutable;
 using System.Globalization;
+using System.Reflection;
 
 namespace EventLogExpert.UI.Tests.LogTable;
 
@@ -26,15 +27,20 @@ public sealed class LogTablePaneFindTests : BunitContext
 {
     private const string LogName = "Application";
 
+    private static readonly TimeSpan s_testTimeout = TimeSpan.FromSeconds(5);
+
     private readonly ILogTableColumnDefaultsProvider _columnDefaults = Substitute.For<ILogTableColumnDefaultsProvider>();
     private readonly IEventLogCommands _eventLogCommands = Substitute.For<IEventLogCommands>();
     private readonly IState<FilterPaneState> _filterPaneState = Substitute.For<IState<FilterPaneState>>();
     private readonly IHighlightSelector _highlightSelector = Substitute.For<IHighlightSelector>();
     private readonly EventLogId _logId = EventLogId.Create();
     private readonly IState<LogTableState> _logTableState = Substitute.For<IState<LogTableState>>();
-    private readonly IStateSelection<EventLogState, SelectionEntry?> _selectedEvent = Substitute.For<IStateSelection<EventLogState, SelectionEntry?>>();
-    private readonly IStateSelection<EventLogState, ImmutableList<SelectionEntry>> _selectedEvents = Substitute.For<IStateSelection<EventLogState, ImmutableList<SelectionEntry>>>();
+    private readonly IEventFocusSource _selectedEvent = Substitute.For<IEventFocusSource>();
+    private readonly IEventSelectionSource _selectedEvents = Substitute.For<IEventSelectionSource>();
     private readonly ISettingsService _settings = Substitute.For<ISettingsService>();
+    private readonly IOrderedViewSource _viewSource = Substitute.For<IOrderedViewSource>();
+
+    private OrderedViewPresentation? _presentation;
 
     private bool _selectionDispatched;
 
@@ -50,8 +56,8 @@ public LogTablePaneFindTests()
         _highlightSelector.Select(Arg.Any<ImmutableList<SavedFilter>>()).Returns([]);
         _highlightSelector.ComputeHighlightKey(Arg.Any<ImmutableList<SavedFilter>>()).Returns(0);
         _settings.TimeZoneInfo.Returns(TimeZoneInfo.Utc);
-        _selectedEvent.Value.Returns((SelectionEntry?)null);
-        _selectedEvents.Value.Returns(ImmutableList<SelectionEntry>.Empty);
+        _selectedEvent.Current.Returns((SelectionEntry?)null);
+        _selectedEvents.Current.Returns(ImmutableList<SelectionEntry>.Empty);
 
         _eventLogCommands
             .When(c => c.SetSelectedEvents(Arg.Any<IReadOnlyCollection<SelectionEntry>>(), Arg.Any<SelectionEntry?>()))
@@ -66,9 +72,27 @@ public LogTablePaneFindTests()
         Services.AddSingleton(_selectedEvent);
         Services.AddSingleton(_selectedEvents);
         Services.AddSingleton(_settings);
+        _viewSource.Current.Returns(_ => _presentation);
+        Services.AddSingleton(_viewSource);
+
         Services.AddFluxor(options => options.ScanAssemblies(typeof(LogTablePane).Assembly));
     }
 
+    [Fact]
+    public void ABulkCollapseRequest_RelinquishesFindGroupOwnership()
+    {
+        var cut = RenderWithEvents(NewEvent(1, "alpha"), NewEvent(2, "beta"));
+
+        var ownership = FindExpandedGroupKeys(cut);
+        ownership.Add("owned-group");
+        Assert.NotEmpty(ownership);
+
+        var notifier = Services.GetRequiredService<IGroupCollapseNotifier>();
+        cut.InvokeAsync(() => notifier.Requested += Raise.Event<Action>());
+
+        cut.WaitForAssertion(() => Assert.Empty(FindExpandedGroupKeys(cut)));
+    }
+
     [Fact]
     public void ClosingFind_ClearsTheMarkerSource()
     {
@@ -85,26 +109,26 @@ public void ClosingFind_ClearsTheMarkerSource()
     }
 
     [Fact]
-    public void CurrentMatch_RendersInlineMark()
+    public void CurrentMatchRow_HasAriaCurrent()
     {
-        var cut = RenderWithEvents(NewEvent(1, "alpha"), NewEvent(2, "beta match"), NewEvent(3, "gamma match"));
+        var cut = RenderWithEvents(NewEvent(1, "alpha match"), NewEvent(2, "beta match"), NewEvent(3, "gamma"));
 
         OpenFindAndSearch(cut, "match");
 
-        cut.WaitForAssertion(() => Assert.NotEmpty(cut.FindAll("mark.find-mark")));
-        Assert.Equal("match", cut.Find("mark.find-mark").TextContent);
+        cut.WaitForAssertion(() => Assert.Single(cut.FindAll("tr[data-find='current']")));
+        Assert.Equal("true", cut.Find("tr[data-find='current']").GetAttribute("aria-current"));
+        Assert.DoesNotContain(cut.FindAll("tr[data-find='match']"), row => row.HasAttribute("aria-current"));
     }
 
     [Fact]
-    public void CurrentMatchRow_HasAriaCurrent()
+    public void CurrentMatch_RendersInlineMark()
     {
-        var cut = RenderWithEvents(NewEvent(1, "alpha match"), NewEvent(2, "beta match"), NewEvent(3, "gamma"));
+        var cut = RenderWithEvents(NewEvent(1, "alpha"), NewEvent(2, "beta match"), NewEvent(3, "gamma match"));
 
         OpenFindAndSearch(cut, "match");
 
-        cut.WaitForAssertion(() => Assert.Single(cut.FindAll("tr[data-find='current']")));
-        Assert.Equal("true", cut.Find("tr[data-find='current']").GetAttribute("aria-current"));
-        Assert.DoesNotContain(cut.FindAll("tr[data-find='match']"), row => row.HasAttribute("aria-current"));
+        cut.WaitForAssertion(() => Assert.NotEmpty(cut.FindAll("mark.find-mark")));
+        Assert.Equal("match", cut.Find("mark.find-mark").TextContent);
     }
 
     [Fact]
@@ -161,31 +185,31 @@ public void Query_PublishesMatchTimestampsToTheMarkerSource()
     }
 
     [Fact]
-    public void Stepping_ToNextMatch_DoesNotChangeSelection()
+    public void SteppingPastLastMatch_AnnouncesWrap()
     {
         var cut = RenderWithEvents(NewEvent(1, "match one"), NewEvent(2, "match two"), NewEvent(3, "other"));
 
         OpenFindAndSearch(cut, "match");
         cut.WaitForAssertion(() => Assert.Equal(2, cut.FindAll("tr[data-find]").Count));
 
-        _selectionDispatched = false;
+        cut.FindAll(".find-nav")[1].Click();
         cut.FindAll(".find-nav")[1].Click();
 
-        Assert.False(_selectionDispatched);
+        cut.WaitForAssertion(() => Assert.Contains("Wrapped to first", cut.Find(".find-wrap").TextContent));
     }
 
     [Fact]
-    public void SteppingPastLastMatch_AnnouncesWrap()
+    public void Stepping_ToNextMatch_DoesNotChangeSelection()
     {
         var cut = RenderWithEvents(NewEvent(1, "match one"), NewEvent(2, "match two"), NewEvent(3, "other"));
 
         OpenFindAndSearch(cut, "match");
         cut.WaitForAssertion(() => Assert.Equal(2, cut.FindAll("tr[data-find]").Count));
 
-        cut.FindAll(".find-nav")[1].Click();
+        _selectionDispatched = false;
         cut.FindAll(".find-nav")[1].Click();
 
-        cut.WaitForAssertion(() => Assert.Contains("Wrapped to first", cut.Find(".find-wrap").TextContent));
+        Assert.False(_selectionDispatched);
     }
 
     [Fact]
@@ -215,15 +239,19 @@ public void WholeWord_RestrictsMatchesToWordBoundedOccurrences()
     {
         var cut = RenderWithEvents(NewEvent(1, "match"), NewEvent(2, "matches found"), NewEvent(3, "rematch"));
 
-        // Enable whole-word via the tray BEFORE typing so there is a single scan cycle (the tray opens against an empty query, avoiding a scan race).
         OpenFind(cut);
         cut.Find(".find-options-toggle").Click();
         cut.FindAll(".find-options .toggle-input")[1].Change(true);
         cut.Find(".find-input").Input("match");
 
-        cut.WaitForAssertion(() => Assert.Single(cut.FindAll("tr[data-find]")), TimeSpan.FromSeconds(5));
+        cut.WaitForAssertion(() => Assert.Single(cut.FindAll("tr[data-find]")), s_testTimeout);
     }
 
+    private static HashSet<string> FindExpandedGroupKeys(IRenderedComponent<LogTablePane> cut) =>
+        (HashSet<string>)typeof(LogTablePane)
+            .GetField("_findExpandedGroupKeys", BindingFlags.Instance | BindingFlags.NonPublic)!
+            .GetValue(cut.Instance)!;
+
     private static ResolvedEvent NewEvent(int id, string description) =>
         new(LogName, LogPathType.Channel)
         {
@@ -249,14 +277,15 @@ private void OpenFindAndSearch(IRenderedComponent<LogTablePane> cut, string quer
 
     private IRenderedComponent<LogTablePane> RenderWithEvents(params ResolvedEvent[] events)
     {
+        _presentation = DisplayViewTestFactory.Presentation(_logId, events);
+
         _logTableState.Value.Returns(new LogTableState
         {
             ActiveEventLogId = _logId,
             EventTables = ImmutableList.Create(new LogView(_logId) { LogName = LogName }),
-            EventCountByLog = ImmutableDictionary<EventLogId, int>.Empty.Add(_logId, events.Length),
             Columns = ImmutableDictionary<ColumnName, bool>.Empty.Add(ColumnName.Level, true),
             ColumnOrder = ImmutableList.Create(ColumnName.Level)
-        }.WithLogEvents(_logId, events));
+        });
 
         return Render<LogTablePane>();
     }
diff --git a/tests/Unit/EventLogExpert.UI.Tests/LogTable/LogTablePaneGroupingTests.cs b/tests/Unit/EventLogExpert.UI.Tests/LogTable/LogTablePaneGroupingTests.cs
index d7b76a0bf..d4b6c4760 100644
--- a/tests/Unit/EventLogExpert.UI.Tests/LogTable/LogTablePaneGroupingTests.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/LogTable/LogTablePaneGroupingTests.cs
@@ -9,10 +9,10 @@
 using EventLogExpert.Runtime.EventLog;
 using EventLogExpert.Runtime.FilterPane;
 using EventLogExpert.Runtime.LogTable;
-using EventLogExpert.Runtime.Menu;
 using EventLogExpert.Runtime.Settings;
 using EventLogExpert.UI.LogTable;
 using EventLogExpert.UI.LogTable.Grouping;
+using EventLogExpert.UI.Menu;
 using EventLogExpert.UI.Tests.TestUtils;
 using Fluxor;
 using Microsoft.AspNetCore.Components.Web;
@@ -37,9 +37,14 @@ public sealed class LogTablePaneGroupingTests : BunitContext
     private readonly ILogTableCommands _logTableCommands = Substitute.For<ILogTableCommands>();
     private readonly IState<LogTableState> _logTableState = Substitute.For<IState<LogTableState>>();
     private readonly IMenuService _menuService = Substitute.For<IMenuService>();
-    private readonly IStateSelection<EventLogState, SelectionEntry?> _selectedEvent = Substitute.For<IStateSelection<EventLogState, SelectionEntry?>>();
-    private readonly IStateSelection<EventLogState, ImmutableList<SelectionEntry>> _selectedEvents = Substitute.For<IStateSelection<EventLogState, ImmutableList<SelectionEntry>>>();
+    private readonly IEventFocusSource _selectedEvent = Substitute.For<IEventFocusSource>();
+    private readonly IEventSelectionSource _selectedEvents = Substitute.For<IEventSelectionSource>();
     private readonly ISettingsService _settings = Substitute.For<ISettingsService>();
+    private readonly IOrderedViewSource _viewSource = Substitute.For<IOrderedViewSource>();
+
+    private OrderedViewPresentation? _presentation;
+
+    private long _presentationRevision;
 
     public LogTablePaneGroupingTests()
     {
@@ -52,8 +57,8 @@ public LogTablePaneGroupingTests()
         _highlightSelector.Select(Arg.Any<ImmutableList<SavedFilter>>()).Returns([]);
         _highlightSelector.ComputeHighlightKey(Arg.Any<ImmutableList<SavedFilter>>()).Returns(0);
         _settings.TimeZoneInfo.Returns(TimeZoneInfo.Utc);
-        _selectedEvent.Value.Returns((SelectionEntry?)null);
-        _selectedEvents.Value.Returns(ImmutableList<SelectionEntry>.Empty);
+        _selectedEvent.Current.Returns((SelectionEntry?)null);
+        _selectedEvents.Current.Returns(ImmutableList<SelectionEntry>.Empty);
 
         Services.AddLogTablePaneDependencies();
         Services.AddSingleton(_columnDefaults);
@@ -67,17 +72,70 @@ public LogTablePaneGroupingTests()
         Services.AddSingleton(_logTableCommands);
         Services.AddSingleton(_menuService);
 
+        _viewSource.Current.Returns(_ => _presentation);
+        Services.AddSingleton(_viewSource);
+
         Services.AddFluxor(options => options.ScanAssemblies(typeof(LogTablePane).Assembly));
     }
 
+    [Fact]
+    public void GroupedByLog_HeaderShowsLogNameNotRepresentativeOwningLog()
+    {
+        var combinedId = EventLogId.Create();
+        var appId1 = EventLogId.Create();
+        var appId2 = EventLogId.Create();
+        var e1 = LogEvent(1, @"C:\logs\App1.evtx", "Application");
+        var e2 = LogEvent(2, @"C:\logs\App2.evtx", "Application");
+
+        _logTableState.Value.Returns(new LogTableState
+        {
+            ActiveEventLogId = combinedId,
+            EventTables = ImmutableList.Create(
+                new LogView(combinedId) { LogName = "Combined", GroupId = LogTabGroupId.AllLogs },
+                new LogView(appId1) { LogName = "Application" },
+                new LogView(appId2) { LogName = "Application" }),
+            Columns = ImmutableDictionary<ColumnName, bool>.Empty.Add(ColumnName.Log, true),
+            ColumnOrder = ImmutableList.Create(ColumnName.Log),
+            GroupBy = ColumnName.Log,
+            GroupCollapseOverrides = Collapsed()
+        });
+
+        _presentation = DisplayViewTestFactory.CombinedPresentation(
+            combinedId,
+            [(appId1, [e1]), (appId2, [e2])],
+            groupBy: ColumnName.Log,
+            revision: ++_presentationRevision);
+
+        var cut = Render<LogTablePane>();
+        var header = cut.Find("tr.group-header-row");
+
+        Assert.Contains("Application", header.TextContent);
+        Assert.DoesNotContain("App1.evtx", header.TextContent);
+        Assert.DoesNotContain("App2.evtx", header.TextContent);
+    }
+
+    [Fact]
+    public async Task GroupedVirtualize_SetsRowHeightItemSize_SoScrollModelMatchesCss()
+    {
+        _logTableState.Value.Returns(BuildState(ColumnName.Source, Collapsed(), Event(1, "Alpha")));
+
+        var cut = Render<LogTablePane>();
+        await cut.InvokeAsync(() => Services.GetRequiredService<IStore>().InitializeAsync());
+        await cut.InvokeAsync(() =>
+            Services.GetRequiredService<IDispatcher>().Dispatch(new SetActiveTableAction(EventLogId.Create())));
+
+        cut.WaitForAssertion(() =>
+            Assert.Equal(22f, cut.FindComponent<Virtualize<TableRow>>().Instance.ItemSize));
+    }
+
     [Fact]
     public void Grouped_AllCollapsed_ArrowDown_MovesFocusBetweenHeadersWithoutSelecting()
     {
         var cut = RenderGrouped(Collapsed("Alpha", "Beta"), Event(1, "Alpha"), Event(2, "Beta"));
 
-        Press(cut, "Home"); // header Alpha
+        Press(cut, "Home");
         _eventLogCommands.ClearReceivedCalls();
-        Press(cut, "ArrowDown"); // header Beta (visible row 1), focus only
+        Press(cut, "ArrowDown");
 
         _eventLogCommands.DidNotReceive().SetSelectedEvents(
             Arg.Any<IReadOnlyCollection<SelectionEntry>>(), Arg.Any<SelectionEntry?>());
@@ -90,9 +148,9 @@ public void Grouped_AllCollapsed_ShiftArrowDown_IsNoOp()
     {
         var cut = RenderGrouped(Collapsed("Alpha", "Beta"), Event(1, "Alpha"), Event(2, "Beta"));
 
-        Press(cut, "Home"); // header Alpha
+        Press(cut, "Home");
         _eventLogCommands.ClearReceivedCalls();
-        Press(cut, "ArrowDown", shift: true); // no event to extend to
+        Press(cut, "ArrowDown", shift: true);
 
         _eventLogCommands.DidNotReceive().SetSelectedEvents(
             Arg.Any<IReadOnlyCollection<SelectionEntry>>(), Arg.Any<SelectionEntry?>());
@@ -114,7 +172,6 @@ public void Grouped_CollapsedHeader_HasAriaExpandedFalse()
     [Fact]
     public void Grouped_EventBelowCollapsedGroup_HasVisibleRowAriaRowIndex()
     {
-        // Event 2 sits at visible row 2 (Alpha collapsed, Beta header, event 2) -> aria-rowindex 4.
         var cut = RenderGrouped(Collapsed("Alpha"), Event(1, "Alpha"), Event(2, "Beta"));
 
         var eventRow = cut.Find("tbody tr.table-row");
@@ -125,10 +182,8 @@ public void Grouped_EventBelowCollapsedGroup_HasVisibleRowAriaRowIndex()
     [Fact]
     public void Grouped_EventCursorInCollapsedGroup_ReconcilesToHeader()
     {
-        // The selected event sits in a collapsed group, so the cursor must retype to its
-        // header on build, proven by Right expanding the group.
         var alpha1 = Event(1, "Alpha");
-        _selectedEvent.Value.Returns(Focus(alpha1, 0));
+        _selectedEvent.Current.Returns(Focus(alpha1, 0));
         _logTableState.Value.Returns(
             BuildState(ColumnName.Source, Collapsed("Alpha"), alpha1, Event(2, "Beta")));
 
@@ -158,8 +213,8 @@ public void Grouped_ExternalSelectionIntoCollapsedGroup_RetypesCursorWithoutRebu
 
         var cut = Render<LogTablePane>();
 
-        _selectedEvent.Value.Returns(Focus(alpha1, 0));
-        RaiseStateChanged(cut);
+        _selectedEvent.Current.Returns(Focus(alpha1, 0));
+        RaiseDisplayUpdated(cut);
 
         Press(cut, "ArrowRight");
 
@@ -217,7 +272,7 @@ public void Grouped_HeaderEnterKey_TogglesCollapse()
     {
         var cut = RenderGrouped(Collapsed(), Event(1, "Alpha"));
 
-        Press(cut, "Home");  // focus the first header
+        Press(cut, "Home");
         Press(cut, "Enter");
 
         _logTableCommands.Received(1).ToggleGroupCollapsed("Alpha");
@@ -232,12 +287,12 @@ public void Grouped_HeaderGroupVanishes_FallsBackToNearestSurvivingHeader()
         _logTableState.Value.Returns(BuildState(ColumnName.Source, Collapsed(), alpha1, beta2, gamma3));
 
         var cut = Render<LogTablePane>();
-        Press(cut, "Home");      // header Alpha
-        Press(cut, "ArrowDown"); // event 1
-        Press(cut, "ArrowDown"); // header Beta (cursor on the middle header)
+        Press(cut, "Home");
+        Press(cut, "ArrowDown");
+        Press(cut, "ArrowDown");
 
         _logTableState.Value.Returns(BuildState(ColumnName.Source, Collapsed(), alpha1, gamma3));
-        RaiseStateChanged(cut);
+        RaiseDisplayUpdated(cut);
         cut.WaitForAssertion(() => Assert.Equal(2, cut.FindAll("tr.group-header-row").Count));
 
         Press(cut, "Enter");
@@ -298,7 +353,7 @@ public void Grouped_Home_FocusesFirstHeaderWithoutSelecting()
         var cut = RenderGrouped(Collapsed(), Event(1, "Alpha"), Event(2, "Alpha"));
 
         _eventLogCommands.ClearReceivedCalls();
-        Press(cut, "Home"); // first visible row is a header, focus only
+        Press(cut, "Home");
 
         _eventLogCommands.DidNotReceive().SetSelectedEvents(
             Arg.Any<IReadOnlyCollection<SelectionEntry>>(), Arg.Any<SelectionEntry?>());
@@ -310,8 +365,8 @@ public void Grouped_LeftOnCollapsedHeader_DoesNothing()
     {
         var cut = RenderGrouped(Collapsed("Alpha"), Event(1, "Alpha"), Event(2, "Beta"));
 
-        Press(cut, "Home");      // header Alpha (already collapsed)
-        Press(cut, "ArrowLeft"); // no-op
+        Press(cut, "Home");
+        Press(cut, "ArrowLeft");
 
         _logTableCommands.DidNotReceive().ToggleGroupCollapsed(Arg.Any<string>());
     }
@@ -322,9 +377,9 @@ public void Grouped_LeftOnEvent_FocusesParentHeaderWithoutChangingSelection()
         var cut = RenderGrouped(Collapsed(), Event(1, "Alpha"), Event(2, "Alpha"));
 
         Press(cut, "Home");
-        Press(cut, "ArrowDown"); // event 1 selected
+        Press(cut, "ArrowDown");
         _eventLogCommands.ClearReceivedCalls();
-        Press(cut, "ArrowLeft"); // focus parent header (visible row 0); selection unchanged
+        Press(cut, "ArrowLeft");
 
         _eventLogCommands.DidNotReceive().SetSelectedEvents(
             Arg.Any<IReadOnlyCollection<SelectionEntry>>(), Arg.Any<SelectionEntry?>());
@@ -337,8 +392,8 @@ public void Grouped_LeftOnExpandedHeader_Collapses()
     {
         var cut = RenderGrouped(Collapsed(), Event(1, "Alpha"));
 
-        Press(cut, "Home");      // header Alpha (expanded)
-        Press(cut, "ArrowLeft"); // collapse
+        Press(cut, "Home");
+        Press(cut, "ArrowLeft");
 
         _logTableCommands.Received(1).ToggleGroupCollapsed("Alpha");
     }
@@ -347,10 +402,9 @@ public void Grouped_LeftOnExpandedHeader_Collapses()
     public void Grouped_PageDown_MovesToLastVisibleEvent()
     {
         var cut = RenderGrouped(Collapsed(), Event(1, "Alpha"), Event(2, "Beta"));
-        // rows: header Alpha(0), event 1(1), header Beta(2), event 2(3)
         Press(cut, "Home");
         _eventLogCommands.ClearReceivedCalls();
-        Press(cut, "PageDown"); // clamps to the last visible row (event 2)
+        Press(cut, "PageDown");
 
         _eventLogCommands.Received(1).SetSelectedEvents(
             Arg.Is<IReadOnlyCollection<SelectionEntry>>(c => c != null && c.Count == 1),
@@ -363,9 +417,9 @@ public void Grouped_PlainArrowOntoEvent_SelectsEvent()
     {
         var cut = RenderGrouped(Collapsed(), Event(1, "Alpha"), Event(2, "Alpha"));
 
-        Press(cut, "Home");      // focus header (focus-only)
+        Press(cut, "Home");
         _eventLogCommands.ClearReceivedCalls();
-        Press(cut, "ArrowDown"); // land on the first event
+        Press(cut, "ArrowDown");
 
         _eventLogCommands.Received(1).SetSelectedEvents(
             Arg.Is<IReadOnlyCollection<SelectionEntry>>(c => c != null && c.Count == 1),
@@ -377,10 +431,10 @@ public void Grouped_PlainArrowOntoHeader_FocusesOnlyWithoutSelecting()
     {
         var cut = RenderGrouped(Collapsed(), Event(1, "Alpha"), Event(2, "Beta"));
 
-        Press(cut, "Home");      // header Alpha
-        Press(cut, "ArrowDown"); // event 1 (selects it)
+        Press(cut, "Home");
+        Press(cut, "ArrowDown");
         _eventLogCommands.ClearReceivedCalls();
-        Press(cut, "ArrowDown"); // header Beta (visible row 2), focus only
+        Press(cut, "ArrowDown");
 
         _eventLogCommands.DidNotReceive().SetSelectedEvents(
             Arg.Any<IReadOnlyCollection<SelectionEntry>>(), Arg.Any<SelectionEntry?>());
@@ -390,16 +444,14 @@ public void Grouped_PlainArrowOntoHeader_FocusesOnlyWithoutSelecting()
     [Fact]
     public async Task Grouped_ReactiveScroll_TargetsVisibleRowNotEventIndex()
     {
-        // Event 2 is at event index 1 but visible row 3, so a reactive scroll must target 3.
         var alpha1 = Event(1, "Alpha");
         var beta2 = Event(2, "Beta");
-        _selectedEvent.Value.Returns(Focus(beta2, 1));
+        _selectedEvent.Current.Returns(Focus(beta2, 1));
         _logTableState.Value.Returns(BuildState(ColumnName.Source, Collapsed(), alpha1, beta2));
 
         var cut = Render<LogTablePane>();
         await cut.InvokeAsync(() => Services.GetRequiredService<IStore>().InitializeAsync());
-        await cut.InvokeAsync(() =>
-            Services.GetRequiredService<IDispatcher>().Dispatch(new SetActiveTableAction(EventLogId.Create())));
+        RaiseRowsArrived(cut, ColumnName.Source, Collapsed(), descending: false, alpha1, beta2);
 
         cut.WaitForAssertion(() =>
         {
@@ -412,17 +464,14 @@ await cut.InvokeAsync(() =>
     [Fact]
     public async Task Grouped_ReactiveScroll_WhenSelectedEventGroupCollapsed_TargetsGroupHeaderRow()
     {
-        // beta2 lives in the collapsed "Beta" group, so its event row is hidden. A reactive scroll must target the
-        // Beta header (visible row 2), the collapsed group the selection lives in, not the hidden event row.
         var alpha1 = Event(1, "Alpha");
         var beta2 = Event(2, "Beta");
-        _selectedEvent.Value.Returns(Focus(beta2, 1));
+        _selectedEvent.Current.Returns(Focus(beta2, 1));
         _logTableState.Value.Returns(BuildState(ColumnName.Source, Collapsed("Beta"), alpha1, beta2));
 
         var cut = Render<LogTablePane>();
         await cut.InvokeAsync(() => Services.GetRequiredService<IStore>().InitializeAsync());
-        await cut.InvokeAsync(() =>
-            Services.GetRequiredService<IDispatcher>().Dispatch(new SetActiveTableAction(EventLogId.Create())));
+        RaiseRowsArrived(cut, ColumnName.Source, Collapsed("Beta"), descending: false, alpha1, beta2);
 
         cut.WaitForAssertion(() =>
         {
@@ -469,8 +518,8 @@ public void Grouped_RightOnCollapsedHeader_Expands()
     {
         var cut = RenderGrouped(Collapsed("Alpha"), Event(1, "Alpha"), Event(2, "Beta"));
 
-        Press(cut, "Home");       // header Alpha (collapsed)
-        Press(cut, "ArrowRight"); // expand
+        Press(cut, "Home");
+        Press(cut, "ArrowRight");
 
         _logTableCommands.Received(1).ToggleGroupCollapsed("Alpha");
     }
@@ -480,9 +529,9 @@ public void Grouped_RightOnExpandedHeader_SelectsFirstChild()
     {
         var cut = RenderGrouped(Collapsed(), Event(1, "Alpha"), Event(2, "Alpha"));
 
-        Press(cut, "Home"); // header Alpha (expanded)
+        Press(cut, "Home");
         _eventLogCommands.ClearReceivedCalls();
-        Press(cut, "ArrowRight"); // focus + select first child
+        Press(cut, "ArrowRight");
 
         _eventLogCommands.Received(1).SetSelectedEvents(
             Arg.Is<IReadOnlyCollection<SelectionEntry>>(c => c != null && c.Count == 1),
@@ -497,10 +546,10 @@ public void Grouped_ShiftArrowDown_AcrossCollapsedGroup_IncludesHiddenEvents()
             Collapsed("Beta"),
             Event(1, "Alpha"), Event(2, "Beta"), Event(3, "Beta"), Event(4, "Gamma"));
 
-        Press(cut, "Home");      // header Alpha
-        Press(cut, "ArrowDown"); // event 1 (anchor)
+        Press(cut, "Home");
+        Press(cut, "ArrowDown");
         _eventLogCommands.ClearReceivedCalls();
-        Press(cut, "ArrowDown", shift: true); // skips the collapsed Beta header to event 4
+        Press(cut, "ArrowDown", shift: true);
 
         _eventLogCommands.Received(1).SetSelectedEvents(
             Arg.Is<IReadOnlyCollection<SelectionEntry>>(c => c != null && c.Count == 4),
@@ -514,9 +563,9 @@ public void Grouped_ShiftArrowUp_AcrossCollapsedGroup_IncludesHiddenEvents()
             Collapsed("Beta"),
             Event(1, "Alpha"), Event(2, "Beta"), Event(3, "Beta"), Event(4, "Gamma"));
 
-        Press(cut, "End"); // event 4 (anchor)
+        Press(cut, "End");
         _eventLogCommands.ClearReceivedCalls();
-        Press(cut, "ArrowUp", shift: true); // skips the collapsed Beta header to event 1
+        Press(cut, "ArrowUp", shift: true);
 
         _eventLogCommands.Received(1).SetSelectedEvents(
             Arg.Is<IReadOnlyCollection<SelectionEntry>>(c => c != null && c.Count == 4),
@@ -536,22 +585,17 @@ public void Grouped_TableHasTreegridRoleAndAriaLevels()
     [Fact]
     public void Grouped_UngroupWithHeaderCursor_ResumesFromFormerGroupsFirstEvent()
     {
-        // Ungrouped order (by time) differs from grouped order (by Source).
         var alpha = Event(2, "Alpha");
         var beta = Event(1, "Beta");
         _logTableState.Value.Returns(BuildState(ColumnName.Source, Collapsed(), alpha, beta));
 
         var cut = Render<LogTablePane>();
-        Press(cut, "Home");      // header Alpha
-        Press(cut, "ArrowDown"); // event Alpha
-        Press(cut, "ArrowDown"); // header Beta (cursor on a non-first header)
-
-        // Ungroup resorts the DISPLAY order (by time) while the underlying columnar store, and therefore every
-        // event's physical locator, is unchanged: production reuses the same store across a group-by change and only
-        // rebuilds the view's order. Keep the same ingestion order as the grouped state so locators stay stable across
-        // the transition; a stale index (physical treated as display position) would still mispoint.
+        Press(cut, "Home");
+        Press(cut, "ArrowDown");
+        Press(cut, "ArrowDown");
+
         _logTableState.Value.Returns(BuildState(groupBy: null, Collapsed(), alpha, beta));
-        RaiseStateChanged(cut);
+        RaiseDisplayUpdated(cut);
         cut.WaitForAssertion(() => Assert.Empty(cut.FindAll("tr.group-header-row")));
 
         _eventLogCommands.ClearReceivedCalls();
@@ -590,84 +634,79 @@ public void Grouped_WhenGroupCollapsed_HidesOnlyThatGroupsEvents()
     }
 
     [Fact]
-    public void GroupedByLog_HeaderShowsLogNameNotRepresentativeOwningLog()
+    public async Task ReactiveScroll_WhenDisplayOrderChanges_RanksTargetAgainstNewView()
     {
-        var combinedId = EventLogId.Create();
-        var appId1 = EventLogId.Create();
-        var appId2 = EventLogId.Create();
-        var e1 = LogEvent(1, @"C:\logs\App1.evtx", "Application");
-        var e2 = LogEvent(2, @"C:\logs\App2.evtx", "Application");
-
-        _logTableState.Value.Returns(new LogTableState
-        {
-            ActiveEventLogId = combinedId,
-            EventTables = ImmutableList.Create(
-                new LogView(combinedId) { LogName = "Combined", GroupId = LogTabGroupId.AllLogs },
-                new LogView(appId1) { LogName = "Application" },
-                new LogView(appId2) { LogName = "Application" }),
-            EventCountByLog = ImmutableDictionary<EventLogId, int>.Empty.Add(appId1, 1).Add(appId2, 1),
-            Columns = ImmutableDictionary<ColumnName, bool>.Empty.Add(ColumnName.Log, true),
-            ColumnOrder = ImmutableList.Create(ColumnName.Log),
-            GroupBy = ColumnName.Log,
-            GroupCollapseOverrides = Collapsed()
-        }.WithLogEvents(appId1, e1).WithLogEvents(appId2, e2));
+        var alpha1 = Event(1, "Alpha");
+        var beta2 = Event(2, "Beta");
+        var gamma3 = Event(3, "Gamma");
+        _selectedEvent.Current.Returns(Focus(gamma3, 2));
+        _logTableState.Value.Returns(BuildState(groupBy: null, Collapsed(), alpha1, beta2, gamma3));
 
         var cut = Render<LogTablePane>();
-        var header = cut.Find("tr.group-header-row");
+        await cut.InvokeAsync(() => Services.GetRequiredService<IStore>().InitializeAsync());
+        RaiseRowsArrived(cut, groupBy: null, Collapsed(), descending: false, alpha1, beta2, gamma3);
 
-        Assert.Contains("Application", header.TextContent);
-        Assert.DoesNotContain("App1.evtx", header.TextContent);
-        Assert.DoesNotContain("App2.evtx", header.TextContent);
-    }
+        cut.WaitForAssertion(() =>
+        {
+            var scrolls = _jsModule.Invocations["scrollToRow"];
+            Assert.NotEmpty(scrolls);
+            Assert.Equal(2, (int)scrolls.Last().Arguments[0]!);
+        });
 
-    [Fact]
-    public async Task GroupedVirtualize_SetsRowHeightItemSize_SoScrollModelMatchesCss()
-    {
-        // ItemSize must equal the CSS `tr { height: 22px }`; without it Virtualize defaults to 50px and the
-        // row-height-based scrollToRow lands jump-to-selected at the wrong position.
-        _logTableState.Value.Returns(BuildState(ColumnName.Source, Collapsed(), Event(1, "Alpha")));
+        _logTableState.Value.Returns(BuildState(groupBy: null, Collapsed(), descending: true, alpha1, beta2, gamma3));
 
-        var cut = Render<LogTablePane>();
-        await cut.InvokeAsync(() => Services.GetRequiredService<IStore>().InitializeAsync());
-        await cut.InvokeAsync(() =>
-            Services.GetRequiredService<IDispatcher>().Dispatch(new SetActiveTableAction(EventLogId.Create())));
+        RaiseDisplayUpdated(cut);
 
         cut.WaitForAssertion(() =>
-            Assert.Equal(22f, cut.FindComponent<Virtualize<TableRow>>().Instance.ItemSize));
+        {
+            var scrolls = _jsModule.Invocations["scrollToRow"];
+            Assert.Equal(0, (int)scrolls.Last().Arguments[0]!);
+        });
     }
 
     [Fact]
-    public async Task ReactiveScroll_WhenDisplayOrderChanges_RanksTargetAgainstNewView()
+    public async Task ReactiveScroll_WhenOnlyTheStateChanged_LeavesTheViewportWhereTheUserPutIt()
     {
         var alpha1 = Event(1, "Alpha");
         var beta2 = Event(2, "Beta");
         var gamma3 = Event(3, "Gamma");
-        _selectedEvent.Value.Returns(Focus(gamma3, 2));
+        _selectedEvent.Current.Returns(Focus(gamma3, 2));
         _logTableState.Value.Returns(BuildState(groupBy: null, Collapsed(), alpha1, beta2, gamma3));
 
         var cut = Render<LogTablePane>();
         await cut.InvokeAsync(() => Services.GetRequiredService<IStore>().InitializeAsync());
-        await cut.InvokeAsync(() =>
-            Services.GetRequiredService<IDispatcher>().Dispatch(new DisplayReadyAction()));
+        RaiseRowsArrived(cut, groupBy: null, Collapsed(), descending: false, alpha1, beta2, gamma3);
 
-        // Ascending by RecordId: gamma3 (newest) is the last visible row.
-        cut.WaitForAssertion(() =>
+        cut.WaitForAssertion(() => Assert.NotEmpty(_jsModule.Invocations["scrollToRow"]));
+
+        int scrollsAfterTheRowsArrived = _jsModule.Invocations["scrollToRow"].Count;
+
+        _presentation = _presentation! with
         {
-            var scrolls = _jsModule.Invocations["scrollToRow"];
-            Assert.NotEmpty(scrolls);
-            Assert.Equal(2, (int)scrolls.Last().Arguments[0]!);
-        });
+            State = PresentationState.Updating,
+            OrderingIsStale = true,
+            Revision = ++_presentationRevision
+        };
 
-        // Flip to descending (same events, same physical identity): gamma3 becomes the first visible row.
-        _logTableState.Value.Returns(BuildState(groupBy: null, Collapsed(), descending: true, alpha1, beta2, gamma3));
+        RaiseDisplayUpdated(cut);
+
+        cut.WaitForState(() => cut.Instance is not null);
+
+        Assert.Equal(scrollsAfterTheRowsArrived, _jsModule.Invocations["scrollToRow"].Count);
+    }
+
+    [Fact]
+    public async Task UngroupedVirtualize_SetsRowHeightItemSize_SoScrollModelMatchesCss()
+    {
+        _logTableState.Value.Returns(BuildState(groupBy: null, Collapsed(), Event(1, "Alpha")));
+
+        var cut = Render<LogTablePane>();
+        await cut.InvokeAsync(() => Services.GetRequiredService<IStore>().InitializeAsync());
         await cut.InvokeAsync(() =>
-            Services.GetRequiredService<IDispatcher>().Dispatch(new DisplayReadyAction()));
+            Services.GetRequiredService<IDispatcher>().Dispatch(new SetActiveTableAction(EventLogId.Create())));
 
         cut.WaitForAssertion(() =>
-        {
-            var scrolls = _jsModule.Invocations["scrollToRow"];
-            Assert.Equal(0, (int)scrolls.Last().Arguments[0]!);
-        });
+            Assert.Equal(22f, cut.FindComponent<Virtualize<DisplayRow>>().Instance.ItemSize));
     }
 
     [Fact]
@@ -677,9 +716,9 @@ public void Ungrouped_ArrowDown_SelectsNextEvent()
 
         var cut = Render<LogTablePane>();
 
-        Press(cut, "Home");      // flat Home selects the first event
+        Press(cut, "Home");
         _eventLogCommands.ClearReceivedCalls();
-        Press(cut, "ArrowDown"); // selects the next event
+        Press(cut, "ArrowDown");
 
         _eventLogCommands.Received(1).SetSelectedEvents(
             Arg.Is<IReadOnlyCollection<SelectionEntry>>(c => c != null && c.Count == 1),
@@ -708,21 +747,6 @@ public void Ungrouped_TableHasGridRoleAndNoEventAriaLevel()
         Assert.False(cut.Find("tbody tr.table-row").HasAttribute("aria-level"));
     }
 
-    [Fact]
-    public async Task UngroupedVirtualize_SetsRowHeightItemSize_SoScrollModelMatchesCss()
-    {
-        // Same 22px scroll-model requirement for the ungrouped ItemsProvider path (the one the redesign regressed).
-        _logTableState.Value.Returns(BuildState(groupBy: null, Collapsed(), Event(1, "Alpha")));
-
-        var cut = Render<LogTablePane>();
-        await cut.InvokeAsync(() => Services.GetRequiredService<IStore>().InitializeAsync());
-        await cut.InvokeAsync(() =>
-            Services.GetRequiredService<IDispatcher>().Dispatch(new SetActiveTableAction(EventLogId.Create())));
-
-        cut.WaitForAssertion(() =>
-            Assert.Equal(22f, cut.FindComponent<Virtualize<DisplayRow>>().Instance.ItemSize));
-    }
-
     private static ImmutableHashSet<string> Collapsed(params string[] keys) =>
         ImmutableHashSet.Create(StringComparer.Ordinal, keys);
 
@@ -761,17 +785,20 @@ private LogTableState BuildState(
         bool descending,
         params ResolvedEvent[] events)
     {
+        _presentation = DisplayViewTestFactory.Presentation(
+            _logId, events, isDescending: descending, groupBy: groupBy, groupCollapseOverrides: collapsed,
+            revision: ++_presentationRevision);
+
         return new LogTableState
         {
             ActiveEventLogId = _logId,
             EventTables = ImmutableList.Create(new LogView(_logId) { LogName = LogName }),
-            EventCountByLog = ImmutableDictionary<EventLogId, int>.Empty.Add(_logId, events.Length),
             Columns = ImmutableDictionary<ColumnName, bool>.Empty.Add(ColumnName.Source, true),
             ColumnOrder = ImmutableList.Create(ColumnName.Source),
             IsDescending = descending,
             GroupBy = groupBy,
             GroupCollapseOverrides = collapsed
-        }.WithLogEvents(_logId, events);
+        };
     }
 
     private SelectionEntry Focus(ResolvedEvent evt, int physicalIndex)
@@ -781,7 +808,6 @@ private SelectionEntry Focus(ResolvedEvent evt, int physicalIndex)
         return new SelectionEntry(handle, handle, reloadKey);
     }
 
-    // Visible-row index of the most recent programmatic focus (proves DOM focus moved).
     private int LastFocusedRow()
     {
         var invocations = _jsModule.Invocations["focusEventTableRow"];
@@ -791,10 +817,27 @@ private int LastFocusedRow()
         return (int)invocations.Last().Arguments[0]!;
     }
 
-    // Re-render the component against the latest substituted state (after updating a
-    // _logTableState/_selectedEvent return value mid-test).
-    private void RaiseStateChanged(IRenderedComponent<LogTablePane> cut) =>
-        cut.InvokeAsync(() => _logTableState.StateChanged += Raise.Event<EventHandler>(_logTableState, EventArgs.Empty));
+    private void RaiseDisplayUpdated(IRenderedComponent<LogTablePane> cut) =>
+        cut.InvokeAsync(() =>
+        {
+            _logTableState.StateChanged += Raise.Event<EventHandler>(_logTableState, EventArgs.Empty);
+
+            if (_presentation is { } published)
+            {
+                _viewSource.Updated += Raise.Event<Action<OrderedViewPresentation>>(published);
+            }
+        });
+
+    private void RaiseRowsArrived(
+        IRenderedComponent<LogTablePane> cut,
+        ColumnName? groupBy,
+        ImmutableHashSet<string> collapsed,
+        bool descending,
+        params ResolvedEvent[] events)
+    {
+        BuildState(groupBy, collapsed, descending, events);
+        RaiseDisplayUpdated(cut);
+    }
 
     private IRenderedComponent<LogTablePane> RenderGrouped(ImmutableHashSet<string> collapsed, params ResolvedEvent[] events)
     {
@@ -803,3 +846,4 @@ private IRenderedComponent<LogTablePane> RenderGrouped(ImmutableHashSet<string>
         return Render<LogTablePane>();
     }
 }
+
diff --git a/tests/Unit/EventLogExpert.UI.Tests/LogTable/LogTablePaneIndicatorTests.cs b/tests/Unit/EventLogExpert.UI.Tests/LogTable/LogTablePaneIndicatorTests.cs
new file mode 100644
index 000000000..9ad73122f
--- /dev/null
+++ b/tests/Unit/EventLogExpert.UI.Tests/LogTable/LogTablePaneIndicatorTests.cs
@@ -0,0 +1,187 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using Bunit;
+using EventLogExpert.Eventing.Common.Channels;
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
+using EventLogExpert.Filtering.Persistence;
+using EventLogExpert.Runtime.EventLog;
+using EventLogExpert.Runtime.FilterPane;
+using EventLogExpert.Runtime.LogTable;
+using EventLogExpert.Runtime.Settings;
+using EventLogExpert.UI.LogTable;
+using EventLogExpert.UI.Menu;
+using EventLogExpert.UI.Tests.TestUtils;
+using Fluxor;
+using Microsoft.Extensions.DependencyInjection;
+using NSubstitute;
+using System.Collections.Immutable;
+using System.Globalization;
+
+namespace EventLogExpert.UI.Tests.LogTable;
+
+public sealed class LogTablePaneIndicatorTests : BunitContext
+{
+    private const string LogName = "Application";
+
+    private readonly ILogTableColumnDefaultsProvider _columnDefaults = Substitute.For<ILogTableColumnDefaultsProvider>();
+    private readonly ManualDelay _delay = new();
+    private readonly IEventLogCommands _eventLogCommands = Substitute.For<IEventLogCommands>();
+    private readonly IState<FilterPaneState> _filterPaneState = Substitute.For<IState<FilterPaneState>>();
+    private readonly IHighlightSelector _highlightSelector = Substitute.For<IHighlightSelector>();
+    private readonly EventLogId _logId = EventLogId.Create();
+    private readonly ILogTableCommands _logTableCommands = Substitute.For<ILogTableCommands>();
+    private readonly IState<LogTableState> _logTableState = Substitute.For<IState<LogTableState>>();
+    private readonly IMenuService _menuService = Substitute.For<IMenuService>();
+    private readonly IEventFocusSource _selectedEvent = Substitute.For<IEventFocusSource>();
+    private readonly IEventSelectionSource _selectedEvents = Substitute.For<IEventSelectionSource>();
+    private readonly ISettingsService _settings = Substitute.For<ISettingsService>();
+    private readonly IOrderedViewSource _viewSource = Substitute.For<IOrderedViewSource>();
+
+    public LogTablePaneIndicatorTests()
+    {
+        CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;
+        JSInterop.Mode = JSRuntimeMode.Loose;
+        JSInterop.SetupModule("./_content/EventLogExpert.UI/LogTable/LogTablePane.razor.js");
+
+        _columnDefaults.ColumnOrder.Returns(ImmutableList.Create(ColumnName.Source));
+        _filterPaneState.Value.Returns(new FilterPaneState());
+        _highlightSelector.Select(Arg.Any<ImmutableList<SavedFilter>>()).Returns([]);
+        _highlightSelector.ComputeHighlightKey(Arg.Any<ImmutableList<SavedFilter>>()).Returns(0);
+        _settings.TimeZoneInfo.Returns(TimeZoneInfo.Utc);
+        _selectedEvent.Current.Returns((SelectionEntry?)null);
+        _selectedEvents.Current.Returns(ImmutableList<SelectionEntry>.Empty);
+
+        Services.AddLogTablePaneDependencies();
+        Services.AddSingleton(_columnDefaults);
+        Services.AddSingleton(_eventLogCommands);
+        Services.AddSingleton(_filterPaneState);
+        Services.AddSingleton(_highlightSelector);
+        Services.AddSingleton(_logTableState);
+        Services.AddSingleton(_selectedEvent);
+        Services.AddSingleton(_selectedEvents);
+        Services.AddSingleton(_settings);
+        Services.AddSingleton(_logTableCommands);
+        Services.AddSingleton(_menuService);
+        Services.AddSingleton(_viewSource);
+
+        Services.AddSingleton(_ => new DisplayIndicatorGate(_viewSource, _delay.Delay));
+
+        Services.AddFluxor(options => options.ScanAssemblies(typeof(LogTablePane).Assembly));
+    }
+
+    [Fact]
+    public void AFailedView_SaysSo_AndSaysWhy()
+    {
+        SetCommittedState();
+
+        _viewSource.Current.Returns(Presentation(PresentationState.Faulted, rows: 0, revision: 1));
+
+        var cut = Render<LogTablePane>();
+
+        _delay.Elapse();
+
+        cut.WaitForAssertion(() =>
+        {
+            Assert.Contains("could not be prepared", cut.Markup);
+            Assert.Contains("bad predicate", cut.Markup);
+        });
+    }
+
+    [Fact]
+    public void AnEmptyGridThatKeepsTheUserWaiting_SaysWhatItIsDoing()
+    {
+        SetCommittedState();
+
+        _viewSource.Current.Returns(Presentation(PresentationState.Updating, rows: 0, revision: 1));
+
+        var cut = Render<LogTablePane>();
+
+        _delay.Elapse();
+
+        cut.WaitForAssertion(() => Assert.Contains("Loading events", cut.Markup));
+    }
+
+    [Fact]
+    public void AnIndicatorThatHasNotWaitedLongEnough_ShowsNoWordsEvenWhenSomethingIsOwed()
+    {
+        SetCommittedState();
+
+        _viewSource.Current.Returns(Presentation(PresentationState.Faulted, rows: 0, revision: 1));
+
+        var cut = Render<LogTablePane>();
+
+        Assert.DoesNotContain("could not be prepared", cut.Markup);
+    }
+
+    [Fact]
+    public void WorkThatFinishesQuickly_LeavesTheGridUntouched()
+    {
+        SetCommittedState();
+
+        _viewSource.Current.Returns(Presentation(PresentationState.Updating, rows: 0, revision: 1));
+
+        var cut = Render<LogTablePane>();
+
+        Assert.Empty(cut.FindAll(".table-indicator"));
+    }
+
+    private static ResolvedEvent Event(long recordId) =>
+        new(LogName, LogPathType.Channel)
+        {
+            RecordId = recordId,
+            TimeCreated = new DateTime(2026, 1, 1, 0, 0, 0, DateTimeKind.Utc).AddMilliseconds(recordId),
+            Id = 1000,
+            Level = "Information",
+            Source = "Alpha",
+            LogName = LogName
+        };
+
+    private OrderedViewPresentation Presentation(PresentationState state, int rows, long revision) =>
+        new(
+            DisplayViewTestFactory.Identity([.. Enumerable.Range(1, rows).Select(index => Event(index))]),
+            _logId,
+            default,
+            state,
+            revision,
+            FaultCause: state == PresentationState.Faulted ? "InvalidOperationException: bad predicate" : null);
+
+    private void SetCommittedState() =>
+        _logTableState.Value.Returns(new LogTableState
+        {
+            ActiveEventLogId = _logId,
+            EventTables = [new LogView(_logId) { LogName = LogName }],
+            Columns = ImmutableDictionary<ColumnName, bool>.Empty.Add(ColumnName.Source, true),
+            ColumnOrder = ImmutableList.Create(ColumnName.Source)
+        });
+
+    private sealed class ManualDelay
+    {
+        private readonly List<TaskCompletionSource> _pending = [];
+        private readonly Lock _sync = new();
+
+        public Task Delay(TimeSpan duration, CancellationToken token)
+        {
+            var completion = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+
+            lock (_sync) { _pending.Add(completion); }
+
+            return completion.Task;
+        }
+
+        public void Elapse()
+        {
+            TaskCompletionSource[] outstanding;
+
+            lock (_sync)
+            {
+                outstanding = [.. _pending];
+
+                _pending.Clear();
+            }
+
+            foreach (var completion in outstanding) { completion.TrySetResult(); }
+        }
+    }
+}
diff --git a/tests/Unit/EventLogExpert.UI.Tests/LogTable/LogTablePaneSelectionTests.cs b/tests/Unit/EventLogExpert.UI.Tests/LogTable/LogTablePaneSelectionTests.cs
index d777dd445..eca18be8d 100644
--- a/tests/Unit/EventLogExpert.UI.Tests/LogTable/LogTablePaneSelectionTests.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/LogTable/LogTablePaneSelectionTests.cs
@@ -36,13 +36,16 @@ public sealed class LogTablePaneSelectionTests : BunitContext
     private readonly IHighlightSelector _highlightSelector = Substitute.For<IHighlightSelector>();
     private readonly EventLogId _logId = EventLogId.Create();
     private readonly IState<LogTableState> _logTableState = Substitute.For<IState<LogTableState>>();
-    private readonly IStateSelection<EventLogState, SelectionEntry?> _selectedEvent = Substitute.For<IStateSelection<EventLogState, SelectionEntry?>>();
-    private readonly IStateSelection<EventLogState, ImmutableList<SelectionEntry>> _selectedEvents = Substitute.For<IStateSelection<EventLogState, ImmutableList<SelectionEntry>>>();
+    private readonly IEventFocusSource _selectedEvent = Substitute.For<IEventFocusSource>();
+    private readonly IEventSelectionSource _selectedEvents = Substitute.For<IEventSelectionSource>();
     private readonly ISettingsService _settings = Substitute.For<ISettingsService>();
+    private readonly IOrderedViewSource _viewSource = Substitute.For<IOrderedViewSource>();
 
     private SelectionEntry? _dispatchedActive;
     private IReadOnlyCollection<SelectionEntry>? _dispatchedEvents;
 
+    private OrderedViewPresentation? _presentation;
+
     public LogTablePaneSelectionTests()
     {
         CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;
@@ -56,7 +59,7 @@ public LogTablePaneSelectionTests()
         _highlightSelector.ComputeHighlightKey(Arg.Any<ImmutableList<SavedFilter>>()).Returns(0);
         _settings.TimeZoneInfo.Returns(TimeZoneInfo.Utc);
 
-        _selectedEvent.Value.Returns((SelectionEntry?)null);
+        _selectedEvent.Current.Returns((SelectionEntry?)null);
         SetSelection();
 
         _eventLogCommands
@@ -77,6 +80,9 @@ public LogTablePaneSelectionTests()
         Services.AddSingleton(_selectedEvents);
         Services.AddSingleton(_settings);
 
+        _viewSource.Current.Returns(_ => _presentation);
+        Services.AddSingleton(_viewSource);
+
         Services.AddFluxor(options => options.ScanAssemblies(typeof(LogTablePane).Assembly));
     }
 
@@ -167,9 +173,6 @@ public void CtrlShiftClick_DeduplicatesEventsAlreadyInSelection()
     [Fact]
     public void CtrlShiftClick_MergesExistingSelectionWithRange()
     {
-        // Pins SelectEvent's merge formula (current selection + range): the mock doesn't propagate the
-        // first plain click's dispatch, so the store stays frozen at [e3] and the merge yields
-        // [e3] + range[e1,e2] = [e1,e2,e3].
         SetSelection(_event3);
         var rows = RenderRows();
 
@@ -275,31 +278,38 @@ private IRenderedComponent<LogTablePane> RenderAllColumns(
             ColumnName.Keywords, ColumnName.ProcessId, ColumnName.ThreadId, ColumnName.User
         ];
 
+        _presentation = DisplayViewTestFactory.Presentation(
+            _logId, [displayedEvent], orderBy: orderBy, isDescending: isDescending) with
+        {
+            Columns = allColumns.ToImmutableDictionary(column => column, _ => true),
+            ColumnOrder = [.. allColumns]
+        };
+
         _logTableState.Value.Returns(new LogTableState
         {
             ActiveEventLogId = _logId,
             EventTables = ImmutableList.Create(new LogView(_logId) { LogName = LogName }),
-            EventCountByLog = ImmutableDictionary<EventLogId, int>.Empty.Add(_logId, 1),
             Columns = allColumns.ToImmutableDictionary(column => column, _ => true),
             ColumnOrder = [.. allColumns],
             OrderBy = orderBy,
             IsDescending = isDescending
-        }.WithLogEvents(_logId, displayedEvent));
+        });
 
         return Render<LogTablePane>();
     }
 
     private IReadOnlyList<IElement> RenderRows()
     {
+        _presentation = DisplayViewTestFactory.Presentation(_logId, [_event1, _event2, _event3]);
+
         _logTableState.Value.Returns(new LogTableState
         {
             ActiveEventLogId = _logId,
             EventTables = ImmutableList.Create(new LogView(_logId) { LogName = LogName }),
-            EventCountByLog = ImmutableDictionary<EventLogId, int>.Empty.Add(_logId, 3),
             Columns = ImmutableDictionary<ColumnName, bool>.Empty.Add(ColumnName.Level, true),
             ColumnOrder = ImmutableList.Create(ColumnName.Level),
             IsDescending = false
-        }.WithLogEvents(_logId, _event1, _event2, _event3));
+        });
 
         var cut = Render<LogTablePane>();
 
@@ -307,5 +317,5 @@ private IReadOnlyList<IElement> RenderRows()
     }
 
     private void SetSelection(params ResolvedEvent[] selection) =>
-        _selectedEvents.Value.Returns(selection.Select(EntryFor).ToImmutableList());
+        _selectedEvents.Current.Returns(selection.Select(EntryFor).ToImmutableList());
 }
diff --git a/tests/Unit/EventLogExpert.UI.Tests/LogTable/LogTablePaneViewSourceTests.cs b/tests/Unit/EventLogExpert.UI.Tests/LogTable/LogTablePaneViewSourceTests.cs
new file mode 100644
index 000000000..4f860cc93
--- /dev/null
+++ b/tests/Unit/EventLogExpert.UI.Tests/LogTable/LogTablePaneViewSourceTests.cs
@@ -0,0 +1,633 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using Bunit;
+using EventLogExpert.Eventing.Common.Channels;
+using EventLogExpert.Eventing.Common.EventLogs;
+using EventLogExpert.Eventing.Common.Events;
+using EventLogExpert.Filtering.Persistence;
+using EventLogExpert.Runtime.EventLog;
+using EventLogExpert.Runtime.FilterPane;
+using EventLogExpert.Runtime.LogTable;
+using EventLogExpert.Runtime.Settings;
+using EventLogExpert.UI.LogTable;
+using EventLogExpert.UI.Menu;
+using EventLogExpert.UI.Tests.TestUtils;
+using Fluxor;
+using Microsoft.AspNetCore.Components.Web;
+using Microsoft.Extensions.DependencyInjection;
+using NSubstitute;
+using System.Collections.Immutable;
+using System.Globalization;
+
+namespace EventLogExpert.UI.Tests.LogTable;
+
+public sealed class LogTablePaneViewSourceTests : BunitContext
+{
+    private const string LogName = "Application";
+
+    private static readonly ImmutableDictionary<ColumnName, bool> s_dateColumn =
+        ImmutableDictionary<ColumnName, bool>.Empty.Add(ColumnName.DateAndTime, true);
+
+    private static readonly ImmutableDictionary<ColumnName, bool> s_sourceColumn =
+        ImmutableDictionary<ColumnName, bool>.Empty.Add(ColumnName.Source, true);
+
+    private readonly ILogTableColumnDefaultsProvider _columnDefaults = Substitute.For<ILogTableColumnDefaultsProvider>();
+    private readonly IEventLogCommands _eventLogCommands = Substitute.For<IEventLogCommands>();
+    private readonly IState<FilterPaneState> _filterPaneState = Substitute.For<IState<FilterPaneState>>();
+    private readonly IActiveFiltersSource _filterSelection = Substitute.For<IActiveFiltersSource>();
+    private readonly IHighlightSelector _highlightSelector = Substitute.For<IHighlightSelector>();
+    private readonly EventLogId _logId = EventLogId.Create();
+    private readonly ILogTableCommands _logTableCommands = Substitute.For<ILogTableCommands>();
+    private readonly IState<LogTableState> _logTableState = Substitute.For<IState<LogTableState>>();
+    private readonly IMenuService _menuService = Substitute.For<IMenuService>();
+    private readonly IRevealFocusSource _revealFocus = Substitute.For<IRevealFocusSource>();
+    private readonly IEventFocusSource _selectedEvent = Substitute.For<IEventFocusSource>();
+    private readonly IEventSelectionSource _selectedEvents = Substitute.For<IEventSelectionSource>();
+    private readonly ISettingsService _settings = Substitute.For<ISettingsService>();
+    private readonly BunitJSModuleInterop _tableJsModule;
+    private readonly IOrderedViewSource _viewSource = Substitute.For<IOrderedViewSource>();
+
+    public LogTablePaneViewSourceTests()
+    {
+        CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;
+        JSInterop.Mode = JSRuntimeMode.Loose;
+        _tableJsModule = JSInterop.SetupModule("./_content/EventLogExpert.UI/LogTable/LogTablePane.razor.js");
+
+        _columnDefaults.ColumnOrder.Returns(ImmutableList.Create(ColumnName.Source));
+        _filterPaneState.Value.Returns(new FilterPaneState());
+        _filterSelection.Current.Returns(ImmutableList<SavedFilter>.Empty);
+        _highlightSelector.Select(Arg.Any<ImmutableList<SavedFilter>>()).Returns([]);
+        _highlightSelector.ComputeHighlightKey(Arg.Any<ImmutableList<SavedFilter>>()).Returns(0);
+        _settings.TimeZoneInfo.Returns(TimeZoneInfo.Utc);
+        _selectedEvent.Current.Returns((SelectionEntry?)null);
+        _selectedEvents.Current.Returns(ImmutableList<SelectionEntry>.Empty);
+        _revealFocus.Current.Returns((EventLocator?)null);
+
+        _eventLogCommands
+            .When(commands => commands.ConsumeRevealFocus(Arg.Any<EventLocator>()))
+            .Do(call =>
+            {
+                if (_revealFocus.Current == call.Arg<EventLocator>())
+                {
+                    _revealFocus.Current.Returns((EventLocator?)null);
+                }
+            });
+
+        Services.AddLogTablePaneDependencies();
+        Services.AddSingleton(_columnDefaults);
+        Services.AddSingleton(_eventLogCommands);
+        Services.AddSingleton(_filterPaneState);
+        Services.AddSingleton(_filterSelection);
+        Services.AddSingleton(_highlightSelector);
+        Services.AddSingleton(_logTableState);
+        Services.AddSingleton(_selectedEvent);
+        Services.AddSingleton(_selectedEvents);
+        Services.AddSingleton(_settings);
+        Services.AddSingleton(_logTableCommands);
+        Services.AddSingleton(_menuService);
+
+        Services.AddSingleton(_revealFocus);
+
+        Services.AddSingleton(_viewSource);
+
+        Services.AddFluxor(options => options.ScanAssemblies(typeof(LogTablePane).Assembly));
+    }
+
+    [Fact]
+    public async Task ACommittedStateChangeAlone_DoesNotRepaintTheDecoupledGrid()
+    {
+        var otherTabId = EventLogId.Create();
+
+        SetCommittedState(_logId, [_logId, otherTabId], Event(1, "Alpha"));
+        SetPresentation(_logId, Event(1, "Alpha"));
+
+        var cut = Render<LogTablePane>();
+
+        Assert.Contains("Alpha", cut.Markup);
+
+        SetCommittedState(otherTabId, [_logId, otherTabId], Event(9, "Zeta"));
+        await cut.InvokeAsync(() => _logTableState.StateChanged += Raise.Event<EventHandler>(_logTableState, EventArgs.Empty));
+
+        Assert.Contains("Alpha", cut.Markup);
+        Assert.DoesNotContain("Zeta", cut.Markup);
+    }
+
+    [Fact]
+    public void AFirstSameViewPublication_DoesNotRescrollToTheSelection()
+    {
+        SetCommittedState(_logId, [_logId], Event(1, "Alpha"), Event(2, "Beta"));
+
+        var presentation = DisplayViewTestFactory.Presentation(_logId, [Event(1, "Alpha"), Event(2, "Beta")]);
+        _viewSource.Current.Returns(presentation);
+        _selectedEvents.Current.Returns(ImmutableList.Create(EntryFor(Event(2, "Beta"))));
+
+        var cut = Render<LogTablePane>();
+
+        Assert.Single(cut.FindAll("thead th[data-column]"));
+        int scrollsAfterRender = ScrollCount();
+
+        var sameRowsNewColumn = presentation with
+        {
+            Revision = 2,
+            ColumnOrder = ImmutableList.Create(ColumnName.Source, ColumnName.EventId)
+        };
+
+        _viewSource.Current.Returns(sameRowsNewColumn);
+        cut.InvokeAsync(() => _viewSource.Updated += Raise.Event<Action<OrderedViewPresentation>>(sameRowsNewColumn));
+
+        cut.WaitForAssertion(() => Assert.Equal(2, cut.FindAll("thead th[data-column]").Count));
+        Assert.Equal(scrollsAfterRender, ScrollCount());
+    }
+
+    [Fact]
+    public void AFocusChange_RepaintsTheDecoupledPane_MovingTheKeyboardCursor()
+    {
+        SetCommittedState(_logId, [_logId], Event(1, "Alpha"), Event(2, "Beta"), Event(3, "Gamma"));
+        _viewSource.Current.Returns(
+            DisplayViewTestFactory.Presentation(_logId, [Event(1, "Alpha"), Event(2, "Beta"), Event(3, "Gamma")]));
+
+        var cut = Render<LogTablePane>();
+
+        var focusEntry = EntryFor(Event(2, "Beta"));
+        _selectedEvent.Current.Returns(focusEntry);
+        cut.InvokeAsync(() => _selectedEvent.Changed += Raise.Event<Action>());
+
+        _eventLogCommands.ClearReceivedCalls();
+        Press(cut, "ArrowDown");
+
+        _eventLogCommands.Received(1).SetSelectedEvents(
+            Arg.Any<IReadOnlyCollection<SelectionEntry>>(),
+            Arg.Is<SelectionEntry?>(focus => focus!.Value.CurrentHandle!.Value.Index == 2));
+    }
+
+    [Fact]
+    public void AHighlightColourChange_RepaintsRowHighlights_ThoughThePresentationIsUnchanged()
+    {
+        var red = SavedFilter.TryCreate("Id == 1", color: HighlightColor.LightRed, isEnabled: true)!;
+        var blue = red with { Color = HighlightColor.LightBlue };
+
+        _filterSelection.Current.Returns(ImmutableList.Create(red));
+        _highlightSelector.Select(Arg.Any<ImmutableList<SavedFilter>>()).Returns([red]);
+        _highlightSelector.ComputeHighlightKey(Arg.Any<ImmutableList<SavedFilter>>()).Returns(1);
+
+        SetCommittedState(_logId, [_logId], Event(1, "Alpha"));
+        SetPresentation(_logId, Event(1, "Alpha"));
+
+        var cut = Render<LogTablePane>();
+
+        Assert.Equal(HighlightColor.LightRed.ToCssName(), RowHighlight(cut, 0));
+
+        _filterSelection.Current.Returns(ImmutableList.Create(blue));
+        _highlightSelector.Select(Arg.Any<ImmutableList<SavedFilter>>()).Returns([blue]);
+        _highlightSelector.ComputeHighlightKey(Arg.Any<ImmutableList<SavedFilter>>()).Returns(2);
+
+        cut.InvokeAsync(() => _filterSelection.Changed += Raise.Event<Action>());
+
+        cut.WaitForAssertion(() => Assert.Equal(HighlightColor.LightBlue.ToCssName(), RowHighlight(cut, 0)));
+    }
+
+    [Fact]
+    public void APublicationAlone_RepaintsWithoutAnyCommittedStateChange()
+    {
+        SetCommittedState(_logId, [_logId], Event(1, "Alpha"));
+        SetPresentation(_logId, Event(1, "Alpha"));
+
+        var cut = Render<LogTablePane>();
+
+        Assert.DoesNotContain("Delta", cut.Markup);
+
+        var next = Presentation(_logId, revision: 2, Event(1, "Alpha"), Event(4, "Delta"));
+
+        _viewSource.Current.Returns(next);
+        cut.InvokeAsync(() => _viewSource.Updated += Raise.Event<Action<OrderedViewPresentation>>(next));
+
+        cut.WaitForAssertion(() => Assert.Contains("Delta", cut.Markup));
+    }
+
+    [Fact]
+    public void ASelectionChange_RepaintsTheDecoupledPane_ThoughNoPresentationIsPublished()
+    {
+        SetCommittedState(_logId, [_logId], Event(1, "Alpha"), Event(2, "Beta"));
+        _viewSource.Current.Returns(DisplayViewTestFactory.Presentation(_logId, [Event(1, "Alpha"), Event(2, "Beta")]));
+
+        var cut = Render<LogTablePane>();
+
+        Assert.Equal("false", RowSelected(cut, 0));
+
+        _selectedEvents.Current.Returns(ImmutableList.Create(EntryFor(Event(1, "Alpha"))));
+        cut.InvokeAsync(() => _selectedEvents.Changed += Raise.Event<Action>());
+
+        cut.WaitForAssertion(() => Assert.Equal("true", RowSelected(cut, 0)));
+    }
+
+    [Fact]
+    public void ATimeZoneChange_RepaintsTheDateCells_ThoughThePresentationIsUnchanged()
+    {
+        var timedEvent = Event(1, "Alpha") with { TimeCreated = new DateTime(2020, 1, 1, 12, 0, 0, DateTimeKind.Utc) };
+
+        SetCommittedState(_logId, [_logId], timedEvent);
+
+        var presentation = new OrderedViewPresentation(
+            DisplayViewTestFactory.Identity([timedEvent]),
+            _logId,
+            default,
+            PresentationState.Current,
+            Revision: 1)
+        { Columns = s_dateColumn, ColumnOrder = ImmutableList.Create(ColumnName.DateAndTime) };
+
+        _viewSource.Current.Returns(presentation);
+
+        var cut = Render<LogTablePane>();
+
+        string utcText = DateCell(cut);
+
+        var plusFive = TimeZoneInfo.CreateCustomTimeZone("t+5", TimeSpan.FromHours(5), "t+5", "t+5");
+        _settings.TimeZoneInfo.Returns(plusFive);
+
+        cut.InvokeAsync(() => _settings.TimeZoneChanged?.Invoke(_settings, plusFive));
+
+        cut.WaitForAssertion(() => Assert.NotEqual(utcText, DateCell(cut)));
+    }
+
+    [Fact]
+    public void ATransientlyEmptyGroupedView_KeepsTheUsersPlaceToo()
+    {
+        SetCommittedState(_logId, [_logId], Event(1, "Alpha"), Event(2, "Alpha"), Event(3, "Alpha"));
+
+        var served = new OrderedViewPresentation(
+            DisplayViewTestFactory.Identity([Event(1, "Alpha"), Event(2, "Alpha"), Event(3, "Alpha")], ColumnName.Source),
+            _logId,
+            new DisplayOrdering(null, false, ColumnName.Source, false),
+            PresentationState.Current,
+            Revision: 1)
+        { Columns = s_sourceColumn };
+
+        _viewSource.Current.Returns(served);
+
+        var cut = Render<LogTablePane>();
+
+        Press(cut, "Home");
+        Press(cut, "ArrowDown");
+        Press(cut, "ArrowDown");
+
+        Publish(cut, served with { View = DisplayViewTestFactory.Identity([], ColumnName.Source), State = PresentationState.Updating, Revision = 2 }, expectedRows: 0);
+
+        Publish(cut, served with { Revision = 3 }, expectedRows: 4);
+
+        _eventLogCommands.ClearReceivedCalls();
+
+        Press(cut, "ArrowDown");
+
+        _eventLogCommands.Received(1).SetSelectedEvents(
+            Arg.Any<IReadOnlyCollection<SelectionEntry>>(),
+            Arg.Is<SelectionEntry?>(focus => focus!.Value.CurrentHandle!.Value.Index == 2));
+    }
+
+    [Fact]
+    public void ATransientlyEmptyView_KeepsTheUsersPlaceUntilTheAnswerSettles()
+    {
+        SetCommittedState(_logId, [_logId], Event(1, "Alpha"), Event(2, "Beta"), Event(3, "Gamma"));
+
+        var served = Presentation(_logId, revision: 1, Event(1, "Alpha"), Event(2, "Beta"), Event(3, "Gamma"));
+        _viewSource.Current.Returns(served);
+
+        var cut = Render<LogTablePane>();
+
+        Press(cut, "Home");
+        Press(cut, "ArrowDown");
+
+        Publish(cut, EmptyPresentation(revision: 2, PresentationState.Updating), expectedRows: 0);
+
+        Publish(cut, served with { Revision = 3 }, expectedRows: 3);
+
+        _eventLogCommands.ClearReceivedCalls();
+
+        Press(cut, "ArrowDown");
+
+        _eventLogCommands.Received(1).SetSelectedEvents(
+            Arg.Any<IReadOnlyCollection<SelectionEntry>>(),
+            Arg.Is<SelectionEntry?>(focus => focus!.Value.CurrentHandle!.Value.Index == 2));
+    }
+
+    [Fact]
+    public void AnEmptyViewTheEngineHasSettledOn_DropsTheUsersPlace()
+    {
+        // reference, so a drop written inside that guard would never run at all.
+        SetCommittedState(_logId, [_logId], Event(1, "Alpha"), Event(2, "Beta"), Event(3, "Gamma"));
+
+        var served = Presentation(_logId, revision: 1, Event(1, "Alpha"), Event(2, "Beta"), Event(3, "Gamma"));
+        _viewSource.Current.Returns(served);
+
+        var cut = Render<LogTablePane>();
+
+        Press(cut, "Home");
+        Press(cut, "ArrowDown");
+
+        Publish(cut, EmptyPresentation(revision: 2, PresentationState.Updating), expectedRows: 0);
+        Publish(cut, EmptyPresentation(revision: 3, PresentationState.Current), expectedRows: 0);
+        Publish(cut, served with { Revision = 4 }, expectedRows: 3);
+
+        _eventLogCommands.ClearReceivedCalls();
+
+        Press(cut, "ArrowDown");
+
+        _eventLogCommands.Received(1).SetSelectedEvents(
+            Arg.Any<IReadOnlyCollection<SelectionEntry>>(),
+            Arg.Is<SelectionEntry?>(focus => focus!.Value.CurrentHandle!.Value.Index == 1));
+    }
+
+    [Fact]
+    public void ColumnWidth_FollowsThePresentation_NotTheCommittedState()
+    {
+        SetCommittedState(_logId, [_logId], Event(1, "Alpha"));
+
+        var presentation = DisplayViewTestFactory.Presentation(_logId, [Event(1, "Alpha")]) with
+        {
+            Columns = s_sourceColumn,
+            ColumnWidths = ImmutableDictionary<ColumnName, int>.Empty.Add(ColumnName.Source, 321)
+        };
+
+        _viewSource.Current.Returns(presentation);
+
+        var cut = Render<LogTablePane>();
+
+        Assert.Contains("width: 321px", cut.Find("th[data-column='Source']").GetAttribute("style"));
+    }
+
+    [Fact]
+    public void GroupCollapse_FollowsThePresentation_NotTheCommittedState()
+    {
+        SetCommittedState(_logId, [_logId], Event(1, "Alpha"), Event(2, "Beta"));
+
+        var presentation = DisplayViewTestFactory.Presentation(
+            _logId, [Event(1, "Alpha"), Event(2, "Beta")], groupBy: ColumnName.Source, groupsCollapsedByDefault: true);
+
+        _viewSource.Current.Returns(presentation);
+
+        var cut = Render<LogTablePane>();
+
+        var headers = cut.FindAll("tr.group-header-row");
+
+        Assert.NotEmpty(headers);
+        Assert.All(headers, header => Assert.Equal("true", header.GetAttribute("data-collapsed")));
+    }
+
+    [Fact]
+    public void Grouping_FollowsThePresentation_NotTheCommittedColumn()
+    {
+        SetCommittedState(_logId, [_logId], Event(1, "Alpha"), Event(2, "Beta"));
+        SetCommittedGrouping(ColumnName.Level);
+        SetPresentationGrouping(ColumnName.Source, Event(1, "Alpha"), Event(2, "Beta"));
+
+        var cut = Render<LogTablePane>();
+
+        Assert.Equal(2, cut.FindAll("tr.group-header-row").Count);
+        Assert.Contains("Source", cut.Find("span.group-name").TextContent);
+        Assert.Contains("Alpha", cut.FindAll("span.group-value")[0].TextContent);
+    }
+
+    [Fact]
+    public void ReloadRestore_AnOrdinarySelectionChange_DoesNotScroll()
+    {
+        SetCommittedState(_logId, [_logId], Event(1, "Alpha"), Event(2, "Beta"));
+        _viewSource.Current.Returns(DisplayViewTestFactory.Presentation(_logId, [Event(1, "Alpha"), Event(2, "Beta")]));
+
+        var cut = Render<LogTablePane>();
+
+        int scrollsAfterRender = ScrollCount();
+
+        _selectedEvents.Current.Returns(ImmutableList.Create(EntryFor(Event(2, "Beta"))));
+        cut.InvokeAsync(() => _selectedEvents.Changed += Raise.Event<Action>());
+
+        cut.WaitForAssertion(() => Assert.Equal("true", RowSelected(cut, 1)));
+        Assert.Equal(scrollsAfterRender, ScrollCount());
+    }
+
+    [Fact]
+    public void ReloadRestore_WhenARemountedPaneMountsWithAPendingReveal_ScrollsToIt()
+    {
+        var target = new EventLocator(_logId, 0, 1);
+        SetCommittedState(_logId, [_logId], Event(1, "Alpha"), Event(2, "Beta"));
+        _viewSource.Current.Returns(DisplayViewTestFactory.Presentation(_logId, [Event(1, "Alpha"), Event(2, "Beta")]));
+        _selectedEvent.Current.Returns(EntryFor(Event(2, "Beta")));
+        _revealFocus.Current.Returns(target);
+
+        var cut = Render<LogTablePane>();
+
+        cut.WaitForAssertion(() => Assert.Equal(1, ScrollCount()));
+        Assert.Equal(1, LastScrollRow());
+        _eventLogCommands.Received().ConsumeRevealFocus(target);
+    }
+
+    [Fact]
+    public void ReloadRestore_WhenTheFreshViewPublishesBeforeTheSelectionRestore_ScrollsToTheRestoredTarget()
+    {
+        SetCommittedState(_logId, [_logId], Event(1, "Alpha"), Event(2, "Beta"));
+        _viewSource.Current.Returns(DisplayViewTestFactory.Presentation(_logId, [Event(1, "Alpha"), Event(2, "Beta")]));
+
+        var cut = Render<LogTablePane>();
+
+        var reloaded = DisplayViewTestFactory.Presentation(_logId, [Event(1, "Alpha"), Event(2, "Beta")], revision: 2);
+        Publish(cut, reloaded, expectedRows: 2);
+
+        int scrollsAfterReloadPublish = ScrollCount();
+
+        var target = new EventLocator(_logId, 0, 1);
+        _selectedEvent.Current.Returns(EntryFor(Event(2, "Beta")));
+        _revealFocus.Current.Returns(target);
+        cut.InvokeAsync(() => _revealFocus.Changed += Raise.Event<Action>());
+
+        cut.WaitForAssertion(() => Assert.Equal(scrollsAfterReloadPublish + 1, ScrollCount()));
+        Assert.Equal(1, LastScrollRow());
+        _eventLogCommands.Received().ConsumeRevealFocus(target);
+    }
+
+    [Fact]
+    public void ReloadRestore_WhenTheRevealArrivesAfterTheFocusIsAlreadySet_StillScrolls()
+    {
+        var target = new EventLocator(_logId, 0, 1);
+        SetCommittedState(_logId, [_logId], Event(1, "Alpha"), Event(2, "Beta"));
+        _viewSource.Current.Returns(DisplayViewTestFactory.Presentation(_logId, [Event(1, "Alpha"), Event(2, "Beta")]));
+        _selectedEvent.Current.Returns(EntryFor(Event(2, "Beta")));
+
+        var cut = Render<LogTablePane>();
+
+        Assert.Equal(0, ScrollCount());
+
+        _revealFocus.Current.Returns(target);
+        cut.InvokeAsync(() => _revealFocus.Changed += Raise.Event<Action>());
+
+        cut.WaitForAssertion(() => Assert.Equal(1, ScrollCount()));
+        Assert.Equal(1, LastScrollRow());
+        _eventLogCommands.Received().ConsumeRevealFocus(target);
+    }
+
+    [Fact]
+    public void ReloadRestore_WhenTheRevealTargetIsNotYetInTheView_WaitsThenScrollsWhenItAppears()
+    {
+        var target = new EventLocator(_logId, 0, 2);
+        SetCommittedState(_logId, [_logId], Event(1, "Alpha"), Event(2, "Beta"), Event(3, "Gamma"));
+        _viewSource.Current.Returns(DisplayViewTestFactory.Presentation(_logId, [Event(1, "Alpha"), Event(2, "Beta")]));
+        _selectedEvent.Current.Returns(EntryFor(Event(3, "Gamma")));
+        _revealFocus.Current.Returns(target);
+
+        var cut = Render<LogTablePane>();
+
+        Assert.Equal(0, ScrollCount());
+        _eventLogCommands.DidNotReceive().ConsumeRevealFocus(Arg.Any<EventLocator>());
+
+        var withGamma = DisplayViewTestFactory.Presentation(
+            _logId, [Event(1, "Alpha"), Event(2, "Beta"), Event(3, "Gamma")], revision: 2);
+        Publish(cut, withGamma, expectedRows: 3);
+
+        cut.WaitForAssertion(() => Assert.Equal(1, ScrollCount()));
+        Assert.Equal(2, LastScrollRow());
+        _eventLogCommands.Received().ConsumeRevealFocus(target);
+    }
+
+    [Fact]
+    public void ReloadRestore_WhenTheUserHasMovedOffTheRevealTarget_DropsItWithoutScrolling()
+    {
+        var staleTarget = new EventLocator(_logId, 0, 0);
+        SetCommittedState(_logId, [_logId], Event(1, "Alpha"), Event(2, "Beta"));
+        _viewSource.Current.Returns(DisplayViewTestFactory.Presentation(_logId, [Event(1, "Alpha"), Event(2, "Beta")]));
+        _selectedEvent.Current.Returns(EntryFor(Event(2, "Beta")));
+        _revealFocus.Current.Returns(staleTarget);
+
+        var cut = Render<LogTablePane>();
+
+        cut.WaitForAssertion(() => _eventLogCommands.Received().ConsumeRevealFocus(staleTarget));
+        Assert.Equal(0, ScrollCount());
+    }
+
+    [Fact]
+    public void Rows_ComeFromThePresentation_NotTheCommittedState()
+    {
+        SetCommittedState(_logId, [_logId], Event(1, "Alpha"));
+        SetPresentation(_logId, Event(1, "Alpha"), Event(2, "Beta"), Event(3, "Gamma"));
+
+        var cut = Render<LogTablePane>();
+
+        Assert.Contains("Beta", cut.Markup);
+        Assert.Contains("Gamma", cut.Markup);
+    }
+
+    [Fact]
+    public void SortIndicator_DescribesThePresentationsOrder_NotTheRequestedOne()
+    {
+        SetCommittedState(_logId, [_logId], Event(1, "Alpha"), Event(2, "Beta"));
+        SetPresentationOrdering(ColumnName.Source, isDescending: true, Event(1, "Alpha"), Event(2, "Beta"));
+
+        var cut = Render<LogTablePane>();
+
+        var header = cut.Find("th[data-column='Source']");
+
+        Assert.Equal("descending", header.GetAttribute("aria-sort"));
+        Assert.NotEmpty(cut.FindAll("th[data-column='Source'] .menu-toggle"));
+    }
+
+    [Fact]
+    public void ThePane_SubscribesToItsAppStateSources()
+    {
+        SetCommittedState(_logId, [_logId], Event(1, "Alpha"));
+        SetPresentation(_logId, Event(1, "Alpha"));
+
+        Render<LogTablePane>();
+
+        _selectedEvent.Received().Changed += Arg.Any<Action>();
+        _selectedEvents.Received().Changed += Arg.Any<Action>();
+        _filterSelection.Received().Changed += Arg.Any<Action>();
+    }
+
+    private static string DateCell(IRenderedComponent<LogTablePane> cut) =>
+        cut.FindAll("tbody tr[role=row] td")[0].TextContent.Trim();
+
+    private static ResolvedEvent Event(int id, string source) =>
+        new(LogName, LogPathType.Channel) { Id = id, RecordId = id, Source = source };
+
+    private static void Press(IRenderedComponent<LogTablePane> cut, string code) =>
+        cut.Find(".table-container").KeyDown(new KeyboardEventArgs { Code = code, Key = code });
+
+    private static string? RowHighlight(IRenderedComponent<LogTablePane> cut, int index) =>
+        cut.FindAll("tbody tr[role=row]")[index].GetAttribute("data-highlight");
+
+    private static string? RowSelected(IRenderedComponent<LogTablePane> cut, int index) =>
+        cut.FindAll("tbody tr[role=row]")[index].GetAttribute("aria-selected");
+
+    private OrderedViewPresentation EmptyPresentation(long revision, PresentationState state) =>
+        new(DisplayViewTestFactory.Identity([]), _logId, default, state, revision) { Columns = s_sourceColumn };
+
+    private SelectionEntry EntryFor(ResolvedEvent evt)
+    {
+        var handle = new EventLocator(_logId, 0, (int)(evt.RecordId!.Value - 1));
+        ValueKey.TryCreate(evt, out var reloadKey);
+
+        return new SelectionEntry(handle, handle, reloadKey);
+    }
+
+    private int LastScrollRow() => (int)_tableJsModule.Invocations["scrollToRow"][^1].Arguments[0]!;
+
+    private OrderedViewPresentation Presentation(EventLogId tabId, long revision, params ResolvedEvent[] events) =>
+        new(DisplayViewTestFactory.Identity(events), tabId, default, PresentationState.Current, revision) { Columns = s_sourceColumn };
+
+    private void Publish(IRenderedComponent<LogTablePane> cut, OrderedViewPresentation presentation, int expectedRows)
+    {
+        _viewSource.Current.Returns(presentation);
+        _viewSource.Updated += Raise.Event<Action<OrderedViewPresentation>>(presentation);
+
+        cut.WaitForAssertion(() =>
+            Assert.Equal((expectedRows + 1).ToString(), cut.Find("#eventTable").GetAttribute("aria-rowcount")));
+    }
+
+    private int ScrollCount() => _tableJsModule.Invocations["scrollToRow"].Count;
+
+    private void SetCommittedGrouping(ColumnName groupBy) =>
+        _logTableState.Value.Returns(_logTableState.Value with { GroupBy = groupBy });
+
+    private void SetCommittedState(EventLogId activeId, EventLogId[] tabIds, params ResolvedEvent[] events)
+    {
+        var state = new LogTableState
+        {
+            ActiveEventLogId = activeId,
+            EventTables = [.. tabIds.Select(id => new LogView(id) { LogName = LogName })],
+            Columns = ImmutableDictionary<ColumnName, bool>.Empty.Add(ColumnName.Source, true),
+            ColumnOrder = ImmutableList.Create(ColumnName.Source)
+        };
+
+        _logTableState.Value.Returns(state);
+    }
+
+    private void SetPresentation(EventLogId tabId, params ResolvedEvent[] events)
+    {
+        var presentation = Presentation(tabId, revision: 1, events);
+
+        _viewSource.Current.Returns(presentation);
+    }
+
+    private void SetPresentationGrouping(ColumnName groupBy, params ResolvedEvent[] events)
+    {
+        var presentation = new OrderedViewPresentation(
+            DisplayViewTestFactory.Identity(events, groupBy),
+            _logId,
+            new DisplayOrdering(null, false, groupBy, false),
+            PresentationState.Current,
+            Revision: 1)
+        { Columns = s_sourceColumn };
+
+        _viewSource.Current.Returns(presentation);
+    }
+
+    private void SetPresentationOrdering(ColumnName orderBy, bool isDescending, params ResolvedEvent[] events)
+    {
+        var presentation = new OrderedViewPresentation(
+            DisplayViewTestFactory.Identity(events),
+            _logId,
+            new DisplayOrdering(orderBy, isDescending, null, false),
+            PresentationState.Current,
+            Revision: 1)
+        { Columns = s_sourceColumn };
+
+        _viewSource.Current.Returns(presentation);
+    }
+}
diff --git a/tests/Unit/EventLogExpert.UI.Tests/Menu/MenuBarGroupingTests.cs b/tests/Unit/EventLogExpert.UI.Tests/Menu/MenuBarGroupingTests.cs
index 109e34188..7a38df30c 100644
--- a/tests/Unit/EventLogExpert.UI.Tests/Menu/MenuBarGroupingTests.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/Menu/MenuBarGroupingTests.cs
@@ -3,7 +3,6 @@
 
 using Bunit;
 using EventLogExpert.Eventing.Common.Channels;
-using EventLogExpert.Eventing.Common.EventLogs;
 using EventLogExpert.Eventing.Readers;
 using EventLogExpert.Runtime.Alerts;
 using EventLogExpert.Runtime.Common.Versioning;
@@ -15,7 +14,6 @@
 using EventLogExpert.Runtime.Scenarios;
 using EventLogExpert.Runtime.Settings;
 using EventLogExpert.UI.Menu;
-using Fluxor;
 using Microsoft.AspNetCore.Components.Web;
 using Microsoft.Extensions.DependencyInjection;
 using NSubstitute;
@@ -29,32 +27,28 @@ public sealed class MenuBarGroupingTests : BunitContext
 
     private readonly IMenuActionService _actions = Substitute.For<IMenuActionService>();
     private readonly IAlertDialogService _alertDialogService = Substitute.For<IAlertDialogService>();
-    private readonly IStateSelection<EventLogState, bool> _eventLogSelection = Substitute.For<IStateSelection<EventLogState, bool>>();
-    private readonly IStateSelection<FilterPaneState, bool> _filterPaneIsEnabled = Substitute.For<IStateSelection<FilterPaneState, bool>>();
-    private readonly IStateSelection<HistogramState, bool> _histogramVisible = Substitute.For<IStateSelection<HistogramState, bool>>();
-    private readonly List<IStateSelection<LogTableState, bool>> _logTableSelections = [];
+    private readonly IEventLogQueries _eventLogQueries = Substitute.For<IEventLogQueries>();
+    private readonly IFilterPaneQueries _filterPaneQueries = Substitute.For<IFilterPaneQueries>();
+    private readonly IHistogramVisibilitySource _histogramVisibility = Substitute.For<IHistogramVisibilitySource>();
+    private readonly ILogTableQueries _logTableQueries = Substitute.For<ILogTableQueries>();
     private readonly IMenuService _menuService = Substitute.For<IMenuService>();
     private readonly IChannelReadinessService _readinessService = Substitute.For<IChannelReadinessService>();
     private readonly ISettingsService _settings = Substitute.For<ISettingsService>();
     private readonly ICurrentVersionProvider _versionProvider = Substitute.For<ICurrentVersionProvider>();
 
-    private LogTableState _logTableState = new();
-
     public MenuBarGroupingTests()
     {
         Services.AddSingleton(_actions);
         Services.AddSingleton(_alertDialogService);
-        Services.AddSingleton(_eventLogSelection);
-        Services.AddSingleton(_filterPaneIsEnabled);
-        Services.AddSingleton(_histogramVisible);
-        Services.AddTransient<IStateSelection<LogTableState, bool>>(_ => CreateLogTableSelection());
+        Services.AddSingleton(_eventLogQueries);
+        Services.AddSingleton(_filterPaneQueries);
+        Services.AddSingleton(_histogramVisibility);
+        Services.AddSingleton(_logTableQueries);
         Services.AddSingleton(_menuService);
         Services.AddSingleton(_readinessService);
         Services.AddSingleton(_settings);
         Services.AddSingleton(_versionProvider);
 
-        Services.AddFluxor(options => options.ScanAssemblies(typeof(MenuBar).Assembly));
-
         JSInterop.Mode = JSRuntimeMode.Loose;
         JSInterop.SetupModule("./_content/EventLogExpert.UI/Menu/MenuAnchor.js")
             .Setup<MenuAnchorRect>("getMenuElementRect", _ => true)
@@ -67,10 +61,7 @@ public MenuBarGroupingTests()
     [Fact]
     public async Task File_CloseAll_ConfirmAccepted_InvokesCloseAllLogs()
     {
-        _logTableState = new LogTableState
-        {
-            EventTables = [new LogView(new EventLogId(Guid.NewGuid())) { LogName = "Application" }],
-        };
+        _logTableQueries.HasActiveLogs().Returns(true);
         _alertDialogService.ShowAlert("Close all logs", Arg.Any<string>(), "Close all", "Cancel").Returns(true);
         var items = await OpenMenu("File");
 
@@ -82,10 +73,7 @@ public async Task File_CloseAll_ConfirmAccepted_InvokesCloseAllLogs()
     [Fact]
     public async Task File_CloseAll_ConfirmCancelled_DoesNotInvokeCloseAllLogs()
     {
-        _logTableState = new LogTableState
-        {
-            EventTables = [new LogView(new EventLogId(Guid.NewGuid())) { LogName = "Application" }],
-        };
+        _logTableQueries.HasActiveLogs().Returns(true);
         _alertDialogService.ShowAlert("Close all logs", Arg.Any<string>(), "Close all", "Cancel").Returns(false);
         var items = await OpenMenu("File");
 
@@ -147,76 +135,106 @@ public async Task File_OtherLogs_WhenStateRequiresElevation_RendersStatusAndStay
     }
 
     [Fact]
-    public async Task File_WhenActiveLogOpen_CloseAllAndCombineEnabled()
+    public async Task File_WhenActiveLogs_CloseCombineExportEnabled()
     {
-        _logTableState = new LogTableState
-        {
-            EventTables = [new LogView(new EventLogId(Guid.NewGuid())) { LogName = "Application" }],
-        };
+        _logTableQueries.HasActiveLogs().Returns(true);
 
         var items = await OpenMenu("File");
 
         Assert.True(Item(items, "Close All").IsEnabled);
         Assert.True(Item(items, "Combine").IsEnabled);
+        Assert.True(Item(items, "Export to CSV").IsEnabled);
+        Assert.True(Item(items, "Export to JSON").IsEnabled);
     }
 
     [Fact]
-    public async Task File_WhenMultipleLogsWithCombinedView_CloseAllAndCombineEnabled()
+    public async Task File_WhenNoActiveLogs_CloseCombineExportDisabled()
     {
-        _logTableState = new LogTableState
-        {
-            EventTables =
-            [
-                new LogView(new EventLogId(Guid.NewGuid())) { GroupId = LogTabGroupId.AllLogs },
-                new LogView(new EventLogId(Guid.NewGuid())) { LogName = "Application" },
-                new LogView(new EventLogId(Guid.NewGuid())) { LogName = "System" },
-            ],
-        };
+        _logTableQueries.HasActiveLogs().Returns(false);
 
         var items = await OpenMenu("File");
 
-        Assert.True(Item(items, "Close All").IsEnabled);
-        Assert.True(Item(items, "Combine").IsEnabled);
+        Assert.False(Item(items, "Close All").IsEnabled);
+        Assert.False(Item(items, "Combine").IsEnabled);
+        Assert.False(Item(items, "Export to CSV").IsEnabled);
+        Assert.False(Item(items, "Export to JSON").IsEnabled);
     }
 
     [Fact]
-    public async Task File_WhenNoLogsOpen_CloseAllAndCombineDisabled()
+    public void Render_DoesNotRequireFluxorServices()
     {
-        _logTableState = new LogTableState();
+        var cut = Render<MenuBar>();
 
-        var items = await OpenMenu("File");
+        Assert.NotEmpty(cut.FindAll("button.menu-bar-item"));
+    }
 
-        Assert.False(Item(items, "Close All").IsEnabled);
-        Assert.False(Item(items, "Combine").IsEnabled);
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public async Task View_ContinuouslyUpdate_CheckReflectsTheQuery(bool continuouslyUpdating)
+    {
+        _eventLogQueries.IsContinuouslyUpdating().Returns(continuouslyUpdating);
+
+        var item = Item(await OpenViewMenu(), "Continuously Update");
+
+        Assert.Equal(continuouslyUpdating, item.IsChecked);
     }
 
     [Fact]
-    public async Task File_WhenOnlyCombinedView_CloseAllAndCombineDisabled()
+    public async Task View_ReadsQueriesAtEachOpen_NotCachedAtInitialization()
     {
-        _logTableState = new LogTableState
-        {
-            EventTables = [new LogView(new EventLogId(Guid.NewGuid())) { GroupId = LogTabGroupId.AllLogs }],
-        };
+        IReadOnlyList<MenuItem>? items = null;
+        _menuService
+            .When(menu => menu.OpenAt(
+                Arg.Any<double>(), Arg.Any<double>(), Arg.Any<IReadOnlyList<MenuItem>>(),
+                Arg.Any<bool>(), Arg.Any<bool>()))
+            .Do(call => items = call.Arg<IReadOnlyList<MenuItem>>());
+        _menuService.ActiveItems.Returns((IReadOnlyList<MenuItem>?)null);
+        _eventLogQueries.IsContinuouslyUpdating().Returns(false);
 
-        var items = await OpenMenu("File");
+        var cut = Render<MenuBar>();
 
-        Assert.False(Item(items, "Close All").IsEnabled);
-        Assert.False(Item(items, "Combine").IsEnabled);
+        await cut.FindAll("button.menu-bar-item").Single(button => button.TextContent.Trim() == "View")
+            .ClickAsync(new MouseEventArgs());
+        Assert.False(Item(items!, "Continuously Update").IsChecked);
+
+        _eventLogQueries.IsContinuouslyUpdating().Returns(true);
+        await cut.FindAll("button.menu-bar-item").Single(button => button.TextContent.Trim() == "View")
+            .ClickAsync(new MouseEventArgs());
+
+        Assert.True(Item(items!, "Continuously Update").IsChecked);
     }
 
-    [Fact]
-    public void Render_SubscribesAllLogTableSelections()
+    [Theory]
+    [InlineData(true, false)]
+    [InlineData(false, true)]
+    public async Task View_ShowAllEvents_CheckedWhenFilterPaneDisabled(bool filterPaneEnabled, bool expectedChecked)
+    {
+        _filterPaneQueries.IsEnabled().Returns(filterPaneEnabled);
+
+        var item = Item(await OpenViewMenu(), "Show All Events");
+
+        Assert.True(item.IsEnabled);
+        Assert.Equal(expectedChecked, item.IsChecked);
+    }
+
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public async Task View_Timeline_CheckReflectsHistogramVisibility(bool visible)
     {
-        Render<MenuBar>();
+        _histogramVisibility.IsVisible.Returns(visible);
+
+        var item = Item(await OpenViewMenu(), "Timeline");
 
-        Assert.Equal(3, _logTableSelections.Count);
-        Assert.All(_logTableSelections, s => s.Received(1).Select(Arg.Any<Func<LogTableState, bool>>()));
+        Assert.Equal(visible, item.IsChecked);
     }
 
     [Fact]
     public async Task View_WhenGroupingAscending_DescendingEnabledButUnchecked()
     {
-        _logTableState = new LogTableState { GroupBy = ColumnName.Source, IsGroupDescending = false };
+        _logTableQueries.IsGrouping().Returns(true);
+        _logTableQueries.IsGroupDescending().Returns(false);
 
         var descending = Item(await OpenViewMenu(), "Group Descending");
 
@@ -227,7 +245,8 @@ public async Task View_WhenGroupingAscending_DescendingEnabledButUnchecked()
     [Fact]
     public async Task View_WhenGroupingDescending_GroupActionsEnabledAndDescendingChecked()
     {
-        _logTableState = new LogTableState { GroupBy = ColumnName.Source, IsGroupDescending = true };
+        _logTableQueries.IsGrouping().Returns(true);
+        _logTableQueries.IsGroupDescending().Returns(true);
 
         var items = await OpenViewMenu();
 
@@ -242,7 +261,7 @@ public async Task View_WhenGroupingDescending_GroupActionsEnabledAndDescendingCh
     [Fact]
     public async Task View_WhenNotGrouping_GroupActionsDisabledWithReason()
     {
-        _logTableState = new LogTableState { GroupBy = null };
+        _logTableQueries.IsGrouping().Returns(false);
 
         var items = await OpenViewMenu();
 
@@ -265,19 +284,6 @@ private static ImmutableArray<ChannelReadiness> ReadinessFor(IEnumerable<string>
         .. channels.Select(channel => new ChannelReadiness(channel, ChannelPresence.Present, ChannelEnablement.Unknown))
     ];
 
-    // Distinct substitute per selection; Value applies its own projection to _logTableState.
-    private IStateSelection<LogTableState, bool> CreateLogTableSelection()
-    {
-        var selection = Substitute.For<IStateSelection<LogTableState, bool>>();
-        Func<LogTableState, bool>? selector = null;
-        selection.When(s => s.Select(Arg.Any<Func<LogTableState, bool>>()))
-            .Do(call => selector = call.Arg<Func<LogTableState, bool>>());
-        selection.Value.Returns(_ => selector is not null && selector(_logTableState));
-        _logTableSelections.Add(selection);
-
-        return selection;
-    }
-
     private async Task<IReadOnlyList<MenuItem>> OpenMenu(string barLabel)
     {
         IReadOnlyList<MenuItem>? items = null;
diff --git a/tests/Unit/EventLogExpert.UI.Tests/Menu/MenuHostHandoffTests.cs b/tests/Unit/EventLogExpert.UI.Tests/Menu/MenuHostHandoffTests.cs
index d3f6da575..d3beb23f5 100644
--- a/tests/Unit/EventLogExpert.UI.Tests/Menu/MenuHostHandoffTests.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/Menu/MenuHostHandoffTests.cs
@@ -2,7 +2,6 @@
 // // Licensed under the MIT License.
 
 using Bunit;
-using EventLogExpert.Runtime.Menu;
 using EventLogExpert.UI.Menu;
 using EventLogExpert.UI.Modal;
 using EventLogExpert.UI.Tests.TestUtils;
@@ -13,6 +12,10 @@ namespace EventLogExpert.UI.Tests.Menu;
 
 public sealed class MenuHostHandoffTests : BunitContext
 {
+    private const int PollDelayMilliseconds = 25;
+
+    private static readonly TimeSpan s_testTimeout = TimeSpan.FromSeconds(2);
+
     private readonly FakeMenuService _menuService = new();
     private readonly BunitJSModuleInterop _overlayModule;
 
@@ -23,7 +26,7 @@ public MenuHostHandoffTests()
 
         Services.AddBannerHostDependencies();
         Services.AddSingleton<IMenuService>(_menuService);
-        Services.AddEventLogUiServices();
+        Services.AddEventLogUIServices();
     }
 
     [Fact]
@@ -89,11 +92,11 @@ private static IReadOnlyList<MenuItem> MakeItems() =>
 
     private async Task WaitForJsInvocationAsync(string identifier)
     {
-        var deadline = DateTime.UtcNow + TimeSpan.FromSeconds(2);
+        var deadline = DateTime.UtcNow + s_testTimeout;
         while (DateTime.UtcNow < deadline)
         {
             if (_overlayModule.Invocations.Any(i => i.Identifier == identifier)) { return; }
-            await Task.Delay(25, TestContext.Current.CancellationToken);
+            await Task.Delay(PollDelayMilliseconds, TestContext.Current.CancellationToken);
         }
         Assert.Fail($"Expected '{identifier}' JS interop call did not occur within timeout. Observed: [{string.Join(",", _overlayModule.Invocations.Select(i => i.Identifier))}]");
     }
diff --git a/tests/Unit/EventLogExpert.UI.Tests/Menu/MenuHostRegistryTests.cs b/tests/Unit/EventLogExpert.UI.Tests/Menu/MenuHostRegistryTests.cs
index 8efd4d8db..dc93dd609 100644
--- a/tests/Unit/EventLogExpert.UI.Tests/Menu/MenuHostRegistryTests.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/Menu/MenuHostRegistryTests.cs
@@ -2,10 +2,10 @@
 // // Licensed under the MIT License.
 
 using EventLogExpert.Runtime.Menu;
-using EventLogExpert.Runtime.Modal;
 using EventLogExpert.Runtime.Settings;
 using EventLogExpert.UI.Keyboard;
 using EventLogExpert.UI.Menu;
+using EventLogExpert.UI.Modal;
 using Microsoft.Extensions.DependencyInjection;
 using NSubstitute;
 
@@ -38,10 +38,10 @@ public void ActiveHostChanged_FiresOnEachRegisterAndUnregister()
     }
 
     [Fact]
-    public void AddEventLogUiServices_RegistersIMenuHostRegistry()
+    public void AddEventLogUIServices_RegistersIMenuHostRegistry()
     {
         var services = new ServiceCollection();
-        services.AddEventLogUiServices();
+        services.AddEventLogUIServices();
 
         using var provider = services.BuildServiceProvider();
         var registry = provider.GetRequiredService<IMenuHostRegistry>();
@@ -50,13 +50,13 @@ public void AddEventLogUiServices_RegistersIMenuHostRegistry()
     }
 
     [Fact]
-    public async Task AddEventLogUiServices_RegistersKeyboardShortcutService()
+    public async Task AddEventLogUIServices_RegistersKeyboardShortcutService()
     {
         var services = new ServiceCollection();
         services.AddSingleton(Substitute.For<IMenuActionService>());
         services.AddSingleton(Substitute.For<IModalCoordinator>());
         services.AddSingleton(Substitute.For<ISettingsService>());
-        services.AddEventLogUiServices();
+        services.AddEventLogUIServices();
 
         await using var provider = services.BuildServiceProvider();
         var service = provider.GetRequiredService<KeyboardShortcutService>();
diff --git a/tests/Unit/EventLogExpert.UI.Tests/Menu/MenuRendererTests.cs b/tests/Unit/EventLogExpert.UI.Tests/Menu/MenuRendererTests.cs
index d32323611..6509dfbe9 100644
--- a/tests/Unit/EventLogExpert.UI.Tests/Menu/MenuRendererTests.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/Menu/MenuRendererTests.cs
@@ -2,7 +2,6 @@
 // // Licensed under the MIT License.
 
 using Bunit;
-using EventLogExpert.Runtime.Menu;
 using EventLogExpert.UI.Menu;
 using Microsoft.AspNetCore.Components;
 
@@ -12,8 +11,6 @@ public sealed class MenuRendererTests : BunitContext
 {
     public MenuRendererTests()
     {
-        // MenuRenderer issues `JSRuntime.InvokeVoidAsync("focusElement", ...)` after render to move
-        // DOM focus; loose mode no-ops the call so the assertion can run synchronously.
         JSInterop.Mode = JSRuntimeMode.Loose;
     }
 
@@ -53,10 +50,8 @@ public void MenuRenderer_WithDisabledItemAndNoReason_RendersInertEntryThatSkipsR
         Assert.Equal("true", disabled.GetAttribute("aria-disabled"));
         Assert.Null(disabled.GetAttribute("aria-describedby"));
         Assert.Null(disabled.GetAttribute("title"));
-        // Without a reason the item must not steal initial focus from the next focusable entry.
         Assert.Equal("-1", disabled.GetAttribute("tabindex"));
 
-        // Initial focus lands on the next focusable item, not the silently-disabled one.
         var enabled = component.FindAll("li.menu-item")[1];
         Assert.Equal("0", enabled.GetAttribute("tabindex"));
     }
@@ -81,15 +76,11 @@ public void MenuRenderer_WithDisabledItemAndReason_AnnouncesReasonAndParticipate
         Assert.False(string.IsNullOrEmpty(describedBy));
         Assert.StartsWith("menu-item-reason-", describedBy);
 
-        // Hidden span carries the reason text and matches the aria-describedby id so screen readers
-        // announce the explanation when keyboard focus reaches the entry.
         var hiddenSpan = disabled.QuerySelector($"span#{describedBy}");
         Assert.NotNull(hiddenSpan);
         Assert.Contains("visually-hidden", hiddenSpan!.ClassName ?? string.Empty);
         Assert.Equal(reason, hiddenSpan.TextContent);
 
-        // Informative-disabled item is the first focusable entry, so initial focus lands there
-        // (sighted users see the title tooltip; AT users hear "Cached, dimmed, <reason>").
         Assert.Equal("0", disabled.GetAttribute("tabindex"));
         Assert.Equal("-1", component.FindAll("li.menu-item")[1].GetAttribute("tabindex"));
     }
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/Menu/MenuServiceTests.cs b/tests/Unit/EventLogExpert.UI.Tests/Menu/MenuServiceTests.cs
similarity index 72%
rename from tests/Unit/EventLogExpert.Runtime.Tests/Menu/MenuServiceTests.cs
rename to tests/Unit/EventLogExpert.UI.Tests/Menu/MenuServiceTests.cs
index c1aeb8e57..92ae07766 100644
--- a/tests/Unit/EventLogExpert.Runtime.Tests/Menu/MenuServiceTests.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/Menu/MenuServiceTests.cs
@@ -1,39 +1,32 @@
 // // Copyright (c) Microsoft Corporation.
 // // Licensed under the MIT License.
 
-using EventLogExpert.Runtime.Menu;
+using EventLogExpert.UI.Menu;
 
-namespace EventLogExpert.Runtime.Tests.Menu;
+namespace EventLogExpert.UI.Tests.Menu;
 
 public sealed class MenuServiceTests
 {
     [Fact]
     public void Close_ShouldResetCaptureOpenerToDefault()
     {
-        // Arrange
         var service = new MenuService();
         service.OpenAt(0, 0, BuildItems(), true, false);
 
-        // Act
         service.Close();
 
-        // Assert — next open defaults to capturing again so a fresh opener is recorded.
         Assert.True(service.ActiveCaptureOpener);
     }
 
     [Fact]
     public void Close_WhenAlreadyClosed_ShouldNotRaiseStateChanged()
     {
-        // Arrange — fresh service is already closed; closing again should be a no-op so
-        // listeners (MenuHost, MenuBar) don't react to spurious empty transitions.
         var service = new MenuService();
         var stateChangedCount = 0;
         service.StateChanged += () => stateChangedCount++;
 
-        // Act
         service.Close();
 
-        // Assert
         Assert.Equal(0, stateChangedCount);
         Assert.Null(service.ActiveItems);
         Assert.Equal(0, service.ActiveMenuId);
@@ -42,17 +35,14 @@ public void Close_WhenAlreadyClosed_ShouldNotRaiseStateChanged()
     [Fact]
     public void Close_WhenOpen_ShouldClearStateAndRaiseStateChanged()
     {
-        // Arrange
         var service = new MenuService();
         service.OpenAt(10, 20, BuildItems());
 
         var stateChangedCount = 0;
         service.StateChanged += () => stateChangedCount++;
 
-        // Act
         service.Close();
 
-        // Assert
         Assert.Equal(1, stateChangedCount);
         Assert.Null(service.ActiveItems);
         Assert.Equal(0, service.ActiveMenuId);
@@ -64,29 +54,22 @@ public void Close_WhenOpen_ShouldClearStateAndRaiseStateChanged()
     [Fact]
     public void NavigateBar_ShouldForwardDirectionToSubscribers()
     {
-        // Arrange — MenuBar subscribes to NavigateBarRequested so the open popup can ask the
-        // bar to switch to an adjacent top-level menu (ArrowLeft / ArrowRight inside a popup).
         var service = new MenuService();
         var captured = new List<int>();
         service.NavigateBarRequested += direction => captured.Add(direction);
 
-        // Act
         service.NavigateBar(-1);
         service.NavigateBar(+1);
 
-        // Assert
         Assert.Equal([-1, +1], captured);
     }
 
     [Fact]
     public void OpenAt_ShouldIncrementMenuIdEachOpen()
     {
-        // Arrange — ActiveMenuId is used by MenuHost as a render @key so consecutive opens
-        // must produce distinct ids even when they immediately follow each other.
         var service = new MenuService();
         var items = BuildItems();
 
-        // Act
         service.OpenAt(0, 0, items);
         var firstId = service.ActiveMenuId;
 
@@ -97,7 +80,6 @@ public void OpenAt_ShouldIncrementMenuIdEachOpen()
         service.OpenAt(0, 0, items);
         var thirdId = service.ActiveMenuId;
 
-        // Assert
         Assert.True(firstId > 0);
         Assert.True(secondId > firstId);
         Assert.True(thirdId > secondId);
@@ -106,16 +88,13 @@ public void OpenAt_ShouldIncrementMenuIdEachOpen()
     [Fact]
     public void OpenAt_ShouldRaiseStateChangedAndPublishItems()
     {
-        // Arrange
         var service = new MenuService();
         var stateChangedCount = 0;
         service.StateChanged += () => stateChangedCount++;
         var items = BuildItems();
 
-        // Act
         service.OpenAt(50, 75, items, false);
 
-        // Assert
         Assert.Equal(1, stateChangedCount);
         Assert.Same(items, service.ActiveItems);
         Assert.Equal(50, service.PositionX);
@@ -128,25 +107,19 @@ public void OpenAt_ShouldRaiseStateChangedAndPublishItems()
     [Fact]
     public void OpenAt_WhenCaptureOpenerFalse_ShouldExposeFlagToHost()
     {
-        // Arrange — MenuBar passes captureOpener=false during ArrowLeft/ArrowRight bar nav so the
-        // host preserves the original menubar opener instead of capturing a transient menu item.
         var service = new MenuService();
         service.OpenAt(0, 0, BuildItems());
 
-        // Act
         service.OpenAt(0, 0, BuildItems(), true, false);
 
-        // Assert
         Assert.False(service.ActiveCaptureOpener);
     }
 
     [Fact]
     public void OpenAt_WithNullItems_ShouldThrow()
     {
-        // Arrange
         var service = new MenuService();
 
-        // Act / Assert — guard against accidental null callsites that would render an empty popup.
         Assert.Throws<ArgumentNullException>(() => service.OpenAt(0, 0, null!));
     }
 
diff --git a/tests/Unit/EventLogExpert.UI.Tests/Modal/ModalBaseDisposalTests.cs b/tests/Unit/EventLogExpert.UI.Tests/Modal/ModalBaseDisposalTests.cs
new file mode 100644
index 000000000..a168c8025
--- /dev/null
+++ b/tests/Unit/EventLogExpert.UI.Tests/Modal/ModalBaseDisposalTests.cs
@@ -0,0 +1,54 @@
+// // Copyright (c) Microsoft Corporation.
+// // Licensed under the MIT License.
+
+using EventLogExpert.UI.Modal;
+using NSubstitute;
+
+namespace EventLogExpert.UI.Tests.Modal;
+
+public sealed class ModalBaseDisposalTests
+{
+    [Fact]
+    public async Task DisposeAsync_RunsTheCoreExactlyOnce()
+    {
+        var modal = new ProbeModal
+        {
+            ModalCoordinator = Substitute.For<IModalCoordinator>(),
+            ModalService = Substitute.For<IModalService>(),
+        };
+
+        await ((IAsyncDisposable)modal).DisposeAsync();
+        await ((IAsyncDisposable)modal).DisposeAsync();
+
+        Assert.Equal(1, modal.CoreInvocations);
+    }
+
+    [Fact]
+    public async Task DisposeAsync_SetsIsDisposedBeforeDerivedDisposeAsyncCoreRuns()
+    {
+        var modal = new ProbeModal
+        {
+            ModalCoordinator = Substitute.For<IModalCoordinator>(),
+            ModalService = Substitute.For<IModalService>(),
+        };
+
+        await ((IAsyncDisposable)modal).DisposeAsync();
+
+        Assert.True(modal.IsDisposedObservedInCore);
+    }
+
+    private sealed class ProbeModal : ModalBase<bool>
+    {
+        public int CoreInvocations { get; private set; }
+
+        public bool IsDisposedObservedInCore { get; private set; }
+
+        protected override ValueTask DisposeAsyncCore(bool disposing)
+        {
+            CoreInvocations++;
+            IsDisposedObservedInCore = IsDisposed;
+
+            return base.DisposeAsyncCore(disposing);
+        }
+    }
+}
diff --git a/tests/Unit/EventLogExpert.UI.Tests/Modal/ModalChromeTests.cs b/tests/Unit/EventLogExpert.UI.Tests/Modal/ModalChromeTests.cs
index 8865757d3..7fe448485 100644
--- a/tests/Unit/EventLogExpert.UI.Tests/Modal/ModalChromeTests.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/Modal/ModalChromeTests.cs
@@ -2,7 +2,7 @@
 // // Licensed under the MIT License.
 
 using Bunit;
-using EventLogExpert.Runtime.Alerts;
+using EventLogExpert.UI.Alerts;
 using EventLogExpert.UI.Banner;
 using EventLogExpert.UI.Modal;
 using EventLogExpert.UI.Tests.TestUtils;
@@ -56,8 +56,6 @@ public void ClickSecondaryButton_ResolvesWithSecondaryChosen()
     [Fact]
     public void ClickSecondaryButton_WhenPrompt_CarriesTypedPromptValue()
     {
-        // Regression: the secondary action must preserve the typed prompt value in a prompt scenario,
-        // consistent with the Accept path. Previously it hardcoded PromptValue = null, silently losing input.
         InlineAlertResult? captured = null;
         var alert = new InlineAlertRequest(
             Title: "Rename",
diff --git a/tests/Unit/EventLogExpert.UI.Tests/Modal/ModalChromeValidateAsyncTests.cs b/tests/Unit/EventLogExpert.UI.Tests/Modal/ModalChromeValidateAsyncTests.cs
index 24bacd3e1..14ce3734e 100644
--- a/tests/Unit/EventLogExpert.UI.Tests/Modal/ModalChromeValidateAsyncTests.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/Modal/ModalChromeValidateAsyncTests.cs
@@ -2,7 +2,7 @@
 // // Licensed under the MIT License.
 
 using Bunit;
-using EventLogExpert.Runtime.Alerts;
+using EventLogExpert.UI.Alerts;
 using EventLogExpert.UI.Modal;
 using EventLogExpert.UI.Tests.TestUtils;
 
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/Modal/ModalCoordinatorCloseTests.cs b/tests/Unit/EventLogExpert.UI.Tests/Modal/ModalCoordinatorCloseTests.cs
similarity index 82%
rename from tests/Unit/EventLogExpert.Runtime.Tests/Modal/ModalCoordinatorCloseTests.cs
rename to tests/Unit/EventLogExpert.UI.Tests/Modal/ModalCoordinatorCloseTests.cs
index 21c37c8c4..2f287aeb6 100644
--- a/tests/Unit/EventLogExpert.Runtime.Tests/Modal/ModalCoordinatorCloseTests.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/Modal/ModalCoordinatorCloseTests.cs
@@ -1,45 +1,39 @@
 // // Copyright (c) Microsoft Corporation.
 // // Licensed under the MIT License.
 
-using EventLogExpert.Runtime.Alerts;
-using EventLogExpert.Runtime.Modal;
+using EventLogExpert.UI.Alerts;
+using EventLogExpert.UI.Modal;
 using Microsoft.AspNetCore.Components;
 using NSubstitute;
 
-namespace EventLogExpert.Runtime.Tests.Modal;
+namespace EventLogExpert.UI.Tests.Modal;
 
 public sealed class ModalCoordinatorCloseTests
 {
     [Fact]
     public void GetActiveModalScope_CriticalModal_ReturnsCritical()
     {
-        // Arrange
         var service = new ModalService();
         using var sut = new ModalCoordinator(service);
         _ = sut.PushAsync<DummyModal, bool>();
         ModalId id = service.ActiveModalId;
         sut.RegisterModal(TestRegistration(id, scope: ModalScope.Critical));
 
-        // Act + Assert
         Assert.Equal(ModalScope.Critical, sut.GetActiveModalScope());
     }
 
     [Fact]
     public void GetActiveModalScope_NoModal_ReturnsNull()
     {
-        // Arrange
         var service = new ModalService();
         using var sut = new ModalCoordinator(service);
 
-        // Act + Assert
         Assert.Null(sut.GetActiveModalScope());
     }
 
     [Fact]
     public void GetActiveModalScope_StaleRegistrationAfterCancel_ReturnsNull()
     {
-        // Arrange — register a modal, then cancel via the service (ModalService publishes ActiveModalId changes before
-        // firing StateChanged, so a read can race the backstop in OnModalServiceStateChanged).
         var service = new ModalService();
         using var sut = new ModalCoordinator(service);
         _ = sut.PushAsync<DummyModal, bool>();
@@ -47,50 +41,42 @@ public void GetActiveModalScope_StaleRegistrationAfterCancel_ReturnsNull()
         sut.RegisterModal(TestRegistration(id, scope: ModalScope.Critical));
         service.CancelActive();
 
-        // Act
         ModalScope? scope = sut.GetActiveModalScope();
 
-        // Assert
         Assert.Null(scope);
     }
 
     [Fact]
     public void GetActiveModalScope_StandardModal_ReturnsStandard()
     {
-        // Arrange
         var service = new ModalService();
         using var sut = new ModalCoordinator(service);
         _ = sut.PushAsync<DummyModal, bool>();
         ModalId id = service.ActiveModalId;
         sut.RegisterModal(TestRegistration(id, scope: ModalScope.Standard));
 
-        // Act + Assert
         Assert.Equal(ModalScope.Standard, sut.GetActiveModalScope());
     }
 
     [Fact]
     public void ModalRegistration_NullRequestClose_ThrowsArgumentNullException()
     {
-        // Arrange + Act + Assert
         Assert.Throws<ArgumentNullException>(() => new ModalRegistration(new ModalId(1L), null!, ModalScope.Standard, inlineAlertHost: null));
     }
 
     [Fact]
     public async Task PushAsync_ActiveModalAcceptsPreemption_ReturnsOpened()
     {
-        // Arrange
         var service = new ModalService();
         using var sut = new ModalCoordinator(service);
         _ = sut.PushAsync<DummyModal, bool>();
         ModalId firstId = service.ActiveModalId;
         sut.RegisterModal(TestRegistration(firstId, _ => Task.FromResult(true)));
 
-        // Act
         Task<ModalOpenResult<bool>> secondShow = sut.PushAsync<OtherModal, bool>();
         ModalId secondId = service.ActiveModalId;
         sut.ForceCloseActive();
 
-        // Assert
         ModalOpenResult<bool> result = await secondShow;
         Assert.True(result.WasOpened);
         Assert.NotEqual(firstId, secondId);
@@ -99,17 +85,14 @@ public async Task PushAsync_ActiveModalAcceptsPreemption_ReturnsOpened()
     [Fact]
     public async Task PushAsync_ActiveModalVetoesPreemption_ReturnsNotOpened()
     {
-        // Arrange
         var service = new ModalService();
         using var sut = new ModalCoordinator(service);
         _ = sut.PushAsync<DummyModal, bool>();
         ModalId firstId = service.ActiveModalId;
         sut.RegisterModal(TestRegistration(firstId, _ => Task.FromResult(false)));
 
-        // Act
         ModalOpenResult<bool> result = await sut.PushAsync<OtherModal, bool>();
 
-        // Assert
         Assert.False(result.WasOpened);
         Assert.Equal(default, result.Result);
         Assert.Equal(firstId, service.ActiveModalId);
@@ -118,14 +101,11 @@ public async Task PushAsync_ActiveModalVetoesPreemption_ReturnsNotOpened()
     [Fact]
     public void RegisterModal_ModalIdNone_RejectsRegistrationToAvoidGhostState()
     {
-        // Arrange — caller passes a ModalId.None registration (e.g., default-constructed); coordinator must not store it.
         var service = new ModalService();
         using var sut = new ModalCoordinator(service);
 
-        // Act
         sut.RegisterModal(TestRegistration(ModalId.None));
 
-        // Assert
         Assert.Null(sut.GetActiveModalScope());
         Assert.False(sut.TryGetInlineAlertHost(out _));
     }
@@ -133,7 +113,6 @@ public void RegisterModal_ModalIdNone_RejectsRegistrationToAvoidGhostState()
     [Fact]
     public async Task RequestCloseActiveAsync_ConcurrentCalls_ShareResult()
     {
-        // Arrange
         var service = new ModalService();
         using var sut = new ModalCoordinator(service);
         _ = sut.PushAsync<DummyModal, bool>();
@@ -146,53 +125,20 @@ public async Task RequestCloseActiveAsync_ConcurrentCalls_ShareResult()
             return await releaseHandler.Task;
         }));
 
-        // Act — first call enters handler; second call coalesces.
         Task<bool> firstCall = sut.RequestCloseActiveAsync(ModalCloseReason.UserDismiss);
         await handlerReached.Task;
         Task<bool> secondCall = sut.RequestCloseActiveAsync(ModalCloseReason.EscKey);
         releaseHandler.SetResult(true);
 
-        // Assert
         bool firstResult = await firstCall;
         bool secondResult = await secondCall;
         Assert.True(firstResult);
         Assert.True(secondResult);
     }
 
-    [Fact]
-    public async Task RequestCloseActiveAsync_CriticalScope_RejectsOtherModalActivationEvenWithEscInFlight()
-    {
-        // Arrange — scope policy fires per-call BEFORE coalescing, so Critical+OtherModalActivation is rejected
-        // even when an Esc close is already in flight.
-        var service = new ModalService();
-        using var sut = new ModalCoordinator(service);
-        _ = sut.PushAsync<DummyModal, bool>();
-        ModalId id = service.ActiveModalId;
-        var handlerReached = new TaskCompletionSource();
-        var releaseHandler = new TaskCompletionSource<bool>();
-        sut.RegisterModal(TestRegistration(id, async _ =>
-        {
-            handlerReached.SetResult();
-            return await releaseHandler.Task;
-        }, ModalScope.Critical));
-
-        Task<bool> escCall = sut.RequestCloseActiveAsync(ModalCloseReason.EscKey);
-        await handlerReached.Task;
-
-        // Act
-        bool omaResult = await sut.RequestCloseActiveAsync(ModalCloseReason.OtherModalActivation);
-
-        // Assert
-        Assert.False(omaResult);
-
-        releaseHandler.SetResult(true);
-        await escCall;
-    }
-
     [Fact]
     public async Task RequestCloseActiveAsync_CriticalScopeAndOtherModalActivation_RejectsWithoutCallingHandler()
     {
-        // Arrange
         var service = new ModalService();
         using var sut = new ModalCoordinator(service);
         _ = sut.PushAsync<DummyModal, bool>();
@@ -204,10 +150,8 @@ public async Task RequestCloseActiveAsync_CriticalScopeAndOtherModalActivation_R
             return Task.FromResult(true);
         }, ModalScope.Critical));
 
-        // Act
         bool result = await sut.RequestCloseActiveAsync(ModalCloseReason.OtherModalActivation);
 
-        // Assert
         Assert.False(result);
         Assert.Equal(0, handlerCallCount);
     }
@@ -215,7 +159,6 @@ public async Task RequestCloseActiveAsync_CriticalScopeAndOtherModalActivation_R
     [Fact]
     public async Task RequestCloseActiveAsync_CriticalScopeAndUserDismiss_DelegatesToHandler()
     {
-        // Arrange — Critical scope only blocks OtherModalActivation; user gestures still delegate.
         var service = new ModalService();
         using var sut = new ModalCoordinator(service);
         _ = sut.PushAsync<DummyModal, bool>();
@@ -227,53 +170,69 @@ public async Task RequestCloseActiveAsync_CriticalScopeAndUserDismiss_DelegatesT
             return Task.FromResult(true);
         }, ModalScope.Critical));
 
-        // Act
         bool result = await sut.RequestCloseActiveAsync(ModalCloseReason.UserDismiss);
 
-        // Assert
         Assert.True(result);
         Assert.Equal(1, handlerCallCount);
     }
 
+    [Fact]
+    public async Task RequestCloseActiveAsync_CriticalScope_RejectsOtherModalActivationEvenWithEscInFlight()
+    {
+        var service = new ModalService();
+        using var sut = new ModalCoordinator(service);
+        _ = sut.PushAsync<DummyModal, bool>();
+        ModalId id = service.ActiveModalId;
+        var handlerReached = new TaskCompletionSource();
+        var releaseHandler = new TaskCompletionSource<bool>();
+        sut.RegisterModal(TestRegistration(id, async _ =>
+        {
+            handlerReached.SetResult();
+            return await releaseHandler.Task;
+        }, ModalScope.Critical));
+
+        Task<bool> escCall = sut.RequestCloseActiveAsync(ModalCloseReason.EscKey);
+        await handlerReached.Task;
+
+        bool omaResult = await sut.RequestCloseActiveAsync(ModalCloseReason.OtherModalActivation);
+
+        Assert.False(omaResult);
+
+        releaseHandler.SetResult(true);
+        await escCall;
+    }
+
     [Fact]
     public async Task RequestCloseActiveAsync_HandlerAccepts_ReturnsTrue()
     {
-        // Arrange
         var service = new ModalService();
         using var sut = new ModalCoordinator(service);
         _ = sut.PushAsync<DummyModal, bool>();
         ModalId id = service.ActiveModalId;
         sut.RegisterModal(TestRegistration(id, _ => Task.FromResult(true)));
 
-        // Act
         bool result = await sut.RequestCloseActiveAsync(ModalCloseReason.UserDismiss);
 
-        // Assert
         Assert.True(result);
     }
 
     [Fact]
     public async Task RequestCloseActiveAsync_HandlerCanceled_AwaitersReceiveAccepted()
     {
-        // Arrange — OperationCanceledException from a force-close race is treated as accepted=true so
-        // coalesced PushAsync callers don't blow up with unhandled OCE.
         var service = new ModalService();
         using var sut = new ModalCoordinator(service);
         _ = sut.PushAsync<DummyModal, bool>();
         ModalId id = service.ActiveModalId;
         sut.RegisterModal(TestRegistration(id, _ => throw new OperationCanceledException()));
 
-        // Act
         bool result = await sut.RequestCloseActiveAsync(ModalCloseReason.UserDismiss);
 
-        // Assert
         Assert.True(result);
     }
 
     [Fact]
     public async Task RequestCloseActiveAsync_HandlerThrows_CoalescedAwaitersSeeException()
     {
-        // Arrange
         var service = new ModalService();
         using var sut = new ModalCoordinator(service);
         _ = sut.PushAsync<DummyModal, bool>();
@@ -291,10 +250,8 @@ public async Task RequestCloseActiveAsync_HandlerThrows_CoalescedAwaitersSeeExce
         await handlerReached.Task;
         Task<bool> secondCall = sut.RequestCloseActiveAsync(ModalCloseReason.EscKey);
 
-        // Act
         releaseHandler.SetResult(true);
 
-        // Assert
         await Assert.ThrowsAsync<InvalidOperationException>(() => firstCall);
         await Assert.ThrowsAsync<InvalidOperationException>(() => secondCall);
     }
@@ -302,21 +259,17 @@ public async Task RequestCloseActiveAsync_HandlerThrows_CoalescedAwaitersSeeExce
     [Fact]
     public async Task RequestCloseActiveAsync_HandlerThrows_PropagatesException()
     {
-        // Arrange
         var service = new ModalService();
         using var sut = new ModalCoordinator(service);
         _ = sut.PushAsync<DummyModal, bool>();
         ModalId id = service.ActiveModalId;
         sut.RegisterModal(TestRegistration(id, _ => throw new InvalidOperationException("handler failure")));
 
-        // Act
         var ex = await Assert.ThrowsAsync<InvalidOperationException>(
             () => sut.RequestCloseActiveAsync(ModalCloseReason.UserDismiss));
 
-        // Assert
         Assert.Equal("handler failure", ex.Message);
 
-        // Subsequent call should not be stuck on the previous TCS — _inFlightCloseTcs cleared in finally.
         sut.UnregisterModal(id);
         bool followup = await sut.RequestCloseActiveAsync(ModalCloseReason.UserDismiss);
         Assert.True(followup);
@@ -325,17 +278,14 @@ public async Task RequestCloseActiveAsync_HandlerThrows_PropagatesException()
     [Fact]
     public async Task RequestCloseActiveAsync_HandlerVetoes_ReturnsFalse()
     {
-        // Arrange
         var service = new ModalService();
         using var sut = new ModalCoordinator(service);
         _ = sut.PushAsync<DummyModal, bool>();
         ModalId id = service.ActiveModalId;
         sut.RegisterModal(TestRegistration(id, _ => Task.FromResult(false)));
 
-        // Act
         bool result = await sut.RequestCloseActiveAsync(ModalCloseReason.UserDismiss);
 
-        // Assert
         Assert.False(result);
         Assert.NotNull(sut.ActiveSession);
     }
@@ -343,8 +293,6 @@ public async Task RequestCloseActiveAsync_HandlerVetoes_ReturnsFalse()
     [Fact]
     public async Task RequestCloseActiveAsync_HandlerVetoes_SecondCallCanSucceedAfterHandlerSwitches()
     {
-        // Arrange — first call vetoed; the captured flag toggles to accept and the next call should succeed
-        // (verifies _inFlightCloseTcs is cleared in finally after a veto, not stuck holding the false result).
         var service = new ModalService();
         using var sut = new ModalCoordinator(service);
         _ = sut.PushAsync<DummyModal, bool>();
@@ -352,12 +300,10 @@ public async Task RequestCloseActiveAsync_HandlerVetoes_SecondCallCanSucceedAfte
         bool acceptNext = false;
         sut.RegisterModal(TestRegistration(id, _ => Task.FromResult(acceptNext)));
 
-        // Act
         bool first = await sut.RequestCloseActiveAsync(ModalCloseReason.UserDismiss);
         acceptNext = true;
         bool second = await sut.RequestCloseActiveAsync(ModalCloseReason.UserDismiss);
 
-        // Assert
         Assert.False(first);
         Assert.True(second);
     }
@@ -365,57 +311,45 @@ public async Task RequestCloseActiveAsync_HandlerVetoes_SecondCallCanSucceedAfte
     [Fact]
     public async Task RequestCloseActiveAsync_InitWindowOtherModalActivation_RejectsToProtectScopePolicy()
     {
-        // Arrange — service has ActiveModalId published but RegisterModal hasn't fired yet (OnInitialized gap).
-        // OtherModalActivation must be rejected so a not-yet-registered Critical modal can't be preempted.
         var service = new ModalService();
         using var sut = new ModalCoordinator(service);
         _ = sut.PushAsync<DummyModal, bool>();
         Assert.NotEqual(ModalId.None, service.ActiveModalId);
         Assert.Null(sut.GetActiveModalScope());
 
-        // Act
         bool result = await sut.RequestCloseActiveAsync(ModalCloseReason.OtherModalActivation);
 
-        // Assert
         Assert.False(result);
     }
 
     [Fact]
     public async Task RequestCloseActiveAsync_InitWindowUserDismiss_ReturnsTrue()
     {
-        // Arrange — non-preemption reasons during init window still return true (idempotent no-op equivalent).
         var service = new ModalService();
         using var sut = new ModalCoordinator(service);
         _ = sut.PushAsync<DummyModal, bool>();
         Assert.NotEqual(ModalId.None, service.ActiveModalId);
         Assert.Null(sut.GetActiveModalScope());
 
-        // Act
         bool result = await sut.RequestCloseActiveAsync(ModalCloseReason.UserDismiss);
 
-        // Assert
         Assert.True(result);
     }
 
     [Fact]
     public async Task RequestCloseActiveAsync_NoActiveModal_ReturnsTrue()
     {
-        // Arrange
         var service = new ModalService();
         using var sut = new ModalCoordinator(service);
 
-        // Act
         bool result = await sut.RequestCloseActiveAsync(ModalCloseReason.UserDismiss);
 
-        // Assert
         Assert.True(result);
     }
 
     [Fact]
     public async Task RequestCloseActiveAsync_StaleCriticalRegistrationAfterCancel_DoesNotVetoOtherModalActivation()
     {
-        // Arrange — register a Critical modal, then cancel via the service. A subsequent OtherModalActivation must
-        // NOT see the stale Critical scope (which would incorrectly veto a legitimate preemption).
         var service = new ModalService();
         using var sut = new ModalCoordinator(service);
         _ = sut.PushAsync<DummyModal, bool>();
@@ -428,18 +362,58 @@ public async Task RequestCloseActiveAsync_StaleCriticalRegistrationAfterCancel_D
         }, ModalScope.Critical));
         service.CancelActive();
 
-        // Act — service has no active modal anymore; OMA should fall through, not be vetoed by stale Critical scope.
         bool result = await sut.RequestCloseActiveAsync(ModalCloseReason.OtherModalActivation);
 
-        // Assert
         Assert.True(result);
         Assert.Equal(0, handlerCallCount);
     }
 
+    [Fact]
+    public async Task RequestCloseActiveAsync_StaleInFlightCloseFromForceClosedModal_RunsNewModalsOwnVeto()
+    {
+        var service = new ModalService();
+        using var sut = new ModalCoordinator(service);
+
+        // Modal A opens and its close handler blocks in-flight.
+        _ = sut.PushAsync<DummyModal, bool>();
+        ModalId idA = service.ActiveModalId;
+        var aHandlerReached = new TaskCompletionSource();
+        var releaseA = new TaskCompletionSource<bool>();
+        sut.RegisterModal(TestRegistration(idA, async _ =>
+        {
+            aHandlerReached.SetResult();
+            return await releaseA.Task;
+        }));
+
+        Task<bool> closeA = sut.RequestCloseActiveAsync(ModalCloseReason.UserDismiss);
+        await aHandlerReached.Task;
+
+        // A is force-closed while its close is still in-flight; B opens in its place.
+        sut.ForceCloseActive();
+        _ = sut.PushAsync<OtherModal, bool>();
+        ModalId idB = service.ActiveModalId;
+        Assert.NotEqual(idA, idB);
+
+        int bHandlerCalls = 0;
+        sut.RegisterModal(TestRegistration(idB, _ =>
+        {
+            bHandlerCalls++;
+            return Task.FromResult(false);
+        }));
+
+        // B's close must invoke B's own veto, not coalesce onto A's stale in-flight close.
+        bool bClose = await sut.RequestCloseActiveAsync(ModalCloseReason.UserDismiss);
+
+        Assert.Equal(1, bHandlerCalls);
+        Assert.False(bClose);
+
+        releaseA.SetResult(true);
+        await closeA;
+    }
+
     [Fact]
     public void TryGetInlineAlertHost_StaleRegistrationAfterCancel_ReturnsFalse()
     {
-        // Arrange — register a modal with an inline-alert host, then cancel; the stored host must not be returned.
         var service = new ModalService();
         using var sut = new ModalCoordinator(service);
         _ = sut.PushAsync<DummyModal, bool>();
@@ -448,10 +422,8 @@ public void TryGetInlineAlertHost_StaleRegistrationAfterCancel_ReturnsFalse()
         sut.RegisterModal(new ModalRegistration(id, _ => Task.FromResult(true), ModalScope.Standard, host));
         service.CancelActive();
 
-        // Act
         bool found = sut.TryGetInlineAlertHost(out IInlineAlertHost? resolved);
 
-        // Assert
         Assert.False(found);
         Assert.Null(resolved);
     }
diff --git a/tests/Unit/EventLogExpert.UI.Tests/Modal/ModalCoordinatorLaunchersTests.cs b/tests/Unit/EventLogExpert.UI.Tests/Modal/ModalCoordinatorLaunchersTests.cs
index cefbee9e8..82136fa92 100644
--- a/tests/Unit/EventLogExpert.UI.Tests/Modal/ModalCoordinatorLaunchersTests.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/Modal/ModalCoordinatorLaunchersTests.cs
@@ -1,7 +1,6 @@
 // // Copyright (c) Microsoft Corporation.
 // // Licensed under the MIT License.
 
-using EventLogExpert.Runtime.Modal;
 using EventLogExpert.Runtime.Update.ReleaseNotes;
 using EventLogExpert.UI.Database;
 using EventLogExpert.UI.DatabaseTools;
@@ -19,75 +18,60 @@ public sealed class ModalCoordinatorLaunchersTests
     [Fact]
     public async Task OpenDatabaseRecoveryAsync_DelegatesToPushAsync()
     {
-        // Arrange
         var coordinator = Substitute.For<IModalCoordinator>();
         coordinator.PushAsync<DatabaseRecoveryModal, bool>(Arg.Any<IDictionary<string, object?>?>())
             .Returns(new ModalOpenResult<bool>(false, WasOpened: true));
 
-        // Act
         await coordinator.OpenDatabaseRecoveryAsync();
 
-        // Assert
         await coordinator.Received(1).PushAsync<DatabaseRecoveryModal, bool>(Arg.Any<IDictionary<string, object?>?>());
     }
 
     [Fact]
     public async Task OpenDatabaseToolsAsync_DelegatesToPushAsync()
     {
-        // Arrange
         var coordinator = Substitute.For<IModalCoordinator>();
         coordinator.PushAsync<DatabaseToolsModal, bool>(Arg.Any<IDictionary<string, object?>?>())
             .Returns(new ModalOpenResult<bool>(false, WasOpened: true));
 
-        // Act
         await coordinator.OpenDatabaseToolsAsync();
 
-        // Assert
         await coordinator.Received(1).PushAsync<DatabaseToolsModal, bool>(Arg.Any<IDictionary<string, object?>?>());
     }
 
     [Fact]
     public async Task OpenDebugLogsAsync_DelegatesToPushAsync()
     {
-        // Arrange
         var coordinator = Substitute.For<IModalCoordinator>();
         coordinator.PushAsync<DebugLogModal, bool>(Arg.Any<IDictionary<string, object?>?>())
             .Returns(new ModalOpenResult<bool>(false, WasOpened: true));
 
-        // Act
         await coordinator.OpenDebugLogsAsync();
 
-        // Assert
         await coordinator.Received(1).PushAsync<DebugLogModal, bool>(Arg.Any<IDictionary<string, object?>?>());
     }
 
     [Fact]
     public async Task OpenFilterLibraryAsync_DelegatesToPushAsync()
     {
-        // Arrange
         var coordinator = Substitute.For<IModalCoordinator>();
         coordinator.PushAsync<FilterLibraryModal, bool>(Arg.Any<IDictionary<string, object?>?>())
             .Returns(new ModalOpenResult<bool>(false, WasOpened: true));
 
-        // Act
         await coordinator.OpenFilterLibraryAsync();
 
-        // Assert
         await coordinator.Received(1).PushAsync<FilterLibraryModal, bool>(Arg.Any<IDictionary<string, object?>?>());
     }
 
     [Fact]
     public async Task OpenFilterLibraryAsync_WithInitialTab_PassesTabViaParameters()
     {
-        // Arrange
         var coordinator = Substitute.For<IModalCoordinator>();
         coordinator.PushAsync<FilterLibraryModal, bool>(Arg.Any<IDictionary<string, object?>?>())
             .Returns(new ModalOpenResult<bool>(false, WasOpened: true));
 
-        // Act
         await coordinator.OpenFilterLibraryAsync(LibraryTab.Favorites);
 
-        // Assert
         await coordinator.Received(1).PushAsync<FilterLibraryModal, bool>(
             Arg.Is<IDictionary<string, object?>?>(p =>
                 p != null
@@ -98,16 +82,13 @@ await coordinator.Received(1).PushAsync<FilterLibraryModal, bool>(
     [Fact]
     public async Task OpenReleaseNotesAsync_PassesContentParameter()
     {
-        // Arrange
         var coordinator = Substitute.For<IModalCoordinator>();
         coordinator.PushAsync<ReleaseNotesModal, bool>(Arg.Any<IDictionary<string, object?>?>())
             .Returns(new ModalOpenResult<bool>(false, WasOpened: true));
         var content = new ReleaseNotesContent("v1.0", "## Notes");
 
-        // Act
         await coordinator.OpenReleaseNotesAsync(content);
 
-        // Assert
         await coordinator.Received(1).PushAsync<ReleaseNotesModal, bool>(
             Arg.Is<IDictionary<string, object?>?>(d => d != null && d.ContainsKey(nameof(ReleaseNotesModal.Content)) && content.Equals((ReleaseNotesContent)d[nameof(ReleaseNotesModal.Content)]!)));
     }
@@ -115,38 +96,30 @@ await coordinator.Received(1).PushAsync<ReleaseNotesModal, bool>(
     [Fact]
     public async Task OpenSettingsAsync_DelegatesToPushAsync()
     {
-        // Arrange
         var coordinator = Substitute.For<IModalCoordinator>();
         coordinator.PushAsync<SettingsModal, bool>(Arg.Any<IDictionary<string, object?>?>())
             .Returns(new ModalOpenResult<bool>(false, WasOpened: true));
 
-        // Act
         await coordinator.OpenSettingsAsync();
 
-        // Assert
         await coordinator.Received(1).PushAsync<SettingsModal, bool>(Arg.Any<IDictionary<string, object?>?>());
     }
 
     [Fact]
     public void OpenSettingsAsync_NullCoordinator_ThrowsArgumentNullException()
     {
-        // Arrange + Act + Assert — discard the Task to avoid xUnit2014; the throw happens synchronously in the guard.
         Assert.Throws<ArgumentNullException>(static () => { _ = ModalCoordinatorLaunchers.OpenSettingsAsync(coordinator: null!); });
     }
 
     [Fact]
     public async Task OpenSettingsAsync_WhenActiveModalVetoesPreemption_ReturnsNotOpened()
     {
-        // Arrange — simulates PR 4's veto-preempt path: PushAsync returns WasOpened=false when the existing modal
-        // vetoes via OnRequestCloseAsync (e.g., SettingsModal IsCloseBlocked, DatabaseToolsModal AnyTabIsRunning).
         var coordinator = Substitute.For<IModalCoordinator>();
         coordinator.PushAsync<SettingsModal, bool>(Arg.Any<IDictionary<string, object?>?>())
             .Returns(new ModalOpenResult<bool>(false, WasOpened: false));
 
-        // Act
         ModalOpenResult<bool> result = await coordinator.OpenSettingsAsync();
 
-        // Assert
         Assert.False(result.WasOpened);
     }
 }
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/Modal/ModalCoordinatorTests.cs b/tests/Unit/EventLogExpert.UI.Tests/Modal/ModalCoordinatorTests.cs
similarity index 84%
rename from tests/Unit/EventLogExpert.Runtime.Tests/Modal/ModalCoordinatorTests.cs
rename to tests/Unit/EventLogExpert.UI.Tests/Modal/ModalCoordinatorTests.cs
index 40427d2ef..5f615192d 100644
--- a/tests/Unit/EventLogExpert.Runtime.Tests/Modal/ModalCoordinatorTests.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/Modal/ModalCoordinatorTests.cs
@@ -1,28 +1,24 @@
 // // Copyright (c) Microsoft Corporation.
 // // Licensed under the MIT License.
 
-using EventLogExpert.Runtime.Alerts;
-using EventLogExpert.Runtime.Modal;
+using EventLogExpert.UI.Alerts;
+using EventLogExpert.UI.Modal;
 using Microsoft.AspNetCore.Components;
 using NSubstitute;
 
-namespace EventLogExpert.Runtime.Tests.Modal;
+namespace EventLogExpert.UI.Tests.Modal;
 
 public sealed class ModalCoordinatorTests
 {
     [Fact]
     public async Task ActiveSession_AfterComplete_IsNullBeforeAwaiterResumes()
     {
-        // Arrange
         var service = new ModalService();
         using var sut = new ModalCoordinator(service);
         Task<ModalOpenResult<bool>> showTask = sut.PushAsync<DummyModal, bool>();
         ModalId activeId = service.ActiveModalId;
         Assert.NotNull(sut.ActiveSession);
 
-        // Capture ActiveSession at the moment the awaiter resumes — proves the publication-before-resume
-        // invariant: ModalService must fire StateChanged (clearing the coordinator's mirror) BEFORE
-        // TrySetResult resumes the awaiter. Without the invariant, sessionAtResume would be non-null.
         var resumeSnapshot = new TaskCompletionSource<ModalSession?>();
         Task observer = Task.Run(async () =>
         {
@@ -30,10 +26,8 @@ public async Task ActiveSession_AfterComplete_IsNullBeforeAwaiterResumes()
             resumeSnapshot.SetResult(sut.ActiveSession);
         }, TestContext.Current.CancellationToken);
 
-        // Act
         service.Complete(activeId, true);
 
-        // Assert
         ModalSession? sessionAtResume = await resumeSnapshot.Task;
         Assert.Null(sessionAtResume);
         await observer;
@@ -46,14 +40,11 @@ public async Task ActiveSession_AfterComplete_IsNullBeforeAwaiterResumes()
     [Fact]
     public async Task ActiveSession_AfterPush_ReflectsService()
     {
-        // Arrange
         var service = new ModalService();
         using var sut = new ModalCoordinator(service);
 
-        // Act
         _ = sut.PushAsync<DummyModal, bool>();
 
-        // Assert
         Assert.NotNull(sut.ActiveSession);
         Assert.Equal(service.ActiveModalId, sut.ActiveSession.Id);
         Assert.Equal(typeof(DummyModal), sut.ActiveSession.ComponentType);
@@ -64,27 +55,22 @@ public async Task ActiveSession_AfterPush_ReflectsService()
     [Fact]
     public void ActiveSession_NoActiveModal_ReturnsNull()
     {
-        // Arrange
         var service = new ModalService();
         using var sut = new ModalCoordinator(service);
 
-        // Assert
         Assert.Null(sut.ActiveSession);
     }
 
     [Fact]
     public void Complete_StaleId_NoOps_StackUnchanged()
     {
-        // Arrange
         var service = new ModalService();
         using var sut = new ModalCoordinator(service);
         _ = sut.PushAsync<DummyModal, bool>();
         long activeId = service.ActiveModalId.Value;
 
-        // Act
         sut.Complete(new ModalId(activeId + 99), true);
 
-        // Assert
         Assert.NotNull(sut.ActiveSession);
         Assert.Equal(new ModalId(activeId), sut.ActiveSession.Id);
     }
@@ -92,17 +78,14 @@ public void Complete_StaleId_NoOps_StackUnchanged()
     [Fact]
     public void Dispose_UnhooksServiceStateChanged_NoLeak()
     {
-        // Arrange
         var service = new ModalService();
         var sut = new ModalCoordinator(service);
         int fireCount = 0;
         sut.StateChanged += () => fireCount++;
 
-        // Act
         sut.Dispose();
         _ = service.Show<DummyModal, bool>();
 
-        // Assert — disposed coordinator must not propagate service state changes.
         Assert.Equal(0, fireCount);
         service.CancelActive();
     }
@@ -110,31 +93,25 @@ public void Dispose_UnhooksServiceStateChanged_NoLeak()
     [Fact]
     public void Dispose_WhenCalledTwice_IsIdempotent()
     {
-        // Arrange
         var sut = new ModalCoordinator(new ModalService());
 
-        // Act
         sut.Dispose();
         sut.Dispose();
 
-        // Assert — no exception thrown.
     }
 
     [Fact]
     public async Task PushAsync_PreemptsPriorModal_CoordinatorMirrorsLatest()
     {
-        // Arrange
         var service = new ModalService();
         using var sut = new ModalCoordinator(service);
 
-        // Act
         Task<ModalOpenResult<bool>> firstShow = sut.PushAsync<DummyModal, bool>();
         ModalId firstId = service.ActiveModalId;
         sut.RegisterModal(TestRegistration(firstId, _ => Task.FromResult(true)));
         Task<ModalOpenResult<bool>> secondShow = sut.PushAsync<OtherModal, bool>();
         ModalId secondId = service.ActiveModalId;
 
-        // Assert
         Assert.NotEqual(firstId, secondId);
         Assert.NotNull(sut.ActiveSession);
         Assert.Equal(secondId, sut.ActiveSession.Id);
@@ -152,24 +129,19 @@ public async Task PushAsync_PreemptsPriorModal_CoordinatorMirrorsLatest()
     [Fact]
     public async Task PushAsync_WhenCriticalModalActive_RejectsReplacement()
     {
-        // Arrange
         var service = new ModalService();
         using var sut = new ModalCoordinator(service);
 
         Task<ModalOpenResult<bool>> firstShow = sut.PushAsync<DummyModal, bool>();
         ModalId firstId = service.ActiveModalId;
 
-        // Lambda return value is irrelevant for this test path; the Critical-scope policy short-circuits before the registered handler is called.
         sut.RegisterModal(TestRegistration(firstId, _ => Task.FromResult(true), ModalScope.Critical));
 
-        // Act
         Task<ModalOpenResult<bool>> secondShow = sut.PushAsync<OtherModal, bool>();
         ModalOpenResult<bool> secondResult = await secondShow;
 
-        // Assert
         Assert.False(secondResult.WasOpened);
 
-        // Cleanup — force-close T1 so firstShow doesn't leak past the using block.
         sut.ForceCloseActive();
         ModalOpenResult<bool> firstResult = await firstShow;
         Assert.True(firstResult.WasOpened);
@@ -179,17 +151,14 @@ public async Task PushAsync_WhenCriticalModalActive_RejectsReplacement()
     [Fact]
     public void RegisterModal_ActiveId_RegistersAndInlineAlertHostIsReadable()
     {
-        // Arrange
         var service = new ModalService();
         using var sut = new ModalCoordinator(service);
         _ = sut.PushAsync<DummyModal, bool>();
         ModalId id = service.ActiveModalId;
         var host = Substitute.For<IInlineAlertHost>();
 
-        // Act
         sut.RegisterModal(TestRegistration(id, host));
 
-        // Assert
         Assert.True(sut.TryGetInlineAlertHost(out var resolved));
         Assert.Same(host, resolved);
     }
@@ -197,22 +166,18 @@ public void RegisterModal_ActiveId_RegistersAndInlineAlertHostIsReadable()
     [Fact]
     public void RegisterModal_StaleId_IsNoOp()
     {
-        // Arrange
         var service = new ModalService();
         using var sut = new ModalCoordinator(service);
         var host = Substitute.For<IInlineAlertHost>();
 
-        // Act
         sut.RegisterModal(TestRegistration(new ModalId(999L), host));
 
-        // Assert
         Assert.False(sut.TryGetInlineAlertHost(out _));
     }
 
     [Fact]
     public void StateChanged_OnPush_FiresAfterMirrorUpdate()
     {
-        // Arrange
         var service = new ModalService();
         using var sut = new ModalCoordinator(service);
         int fireCount = 0;
@@ -223,10 +188,8 @@ public void StateChanged_OnPush_FiresAfterMirrorUpdate()
             observedAtFire = sut.ActiveSession;
         };
 
-        // Act
         _ = sut.PushAsync<DummyModal, bool>();
 
-        // Assert — subscriber must observe the new active session, not null and not stale.
         Assert.Equal(1, fireCount);
         Assert.NotNull(observedAtFire);
         Assert.Equal(service.ActiveModalId, observedAtFire.Id);
@@ -235,7 +198,6 @@ public void StateChanged_OnPush_FiresAfterMirrorUpdate()
     [Fact]
     public void TryGetInlineAlertHost_AfterPushPreemptsPrior_ReturnsFalseAndClearsStaleHost()
     {
-        // Arrange
         var service = new ModalService();
         using var sut = new ModalCoordinator(service);
         _ = sut.PushAsync<DummyModal, bool>();
@@ -244,10 +206,8 @@ public void TryGetInlineAlertHost_AfterPushPreemptsPrior_ReturnsFalseAndClearsSt
         sut.RegisterModal(TestRegistration(firstId, host));
         Assert.True(sut.TryGetInlineAlertHost(out _));
 
-        // Act — successor preempts prior; the host is now stale.
         _ = sut.PushAsync<OtherModal, bool>();
 
-        // Assert
         Assert.False(sut.TryGetInlineAlertHost(out _));
 
         sut.ForceCloseActive();
@@ -256,17 +216,14 @@ public void TryGetInlineAlertHost_AfterPushPreemptsPrior_ReturnsFalseAndClearsSt
     [Fact]
     public void UnregisterModal_MatchingId_ClearsRegistration()
     {
-        // Arrange
         var service = new ModalService();
         using var sut = new ModalCoordinator(service);
         _ = sut.PushAsync<DummyModal, bool>();
         ModalId id = service.ActiveModalId;
         sut.RegisterModal(TestRegistration(id, Substitute.For<IInlineAlertHost>()));
 
-        // Act
         sut.UnregisterModal(id);
 
-        // Assert
         Assert.False(sut.TryGetInlineAlertHost(out _));
         Assert.Null(sut.GetActiveModalScope());
     }
@@ -274,7 +231,6 @@ public void UnregisterModal_MatchingId_ClearsRegistration()
     [Fact]
     public void UnregisterModal_StaleId_IsNoOp()
     {
-        // Arrange
         var service = new ModalService();
         using var sut = new ModalCoordinator(service);
         _ = sut.PushAsync<DummyModal, bool>();
@@ -282,10 +238,8 @@ public void UnregisterModal_StaleId_IsNoOp()
         var host = Substitute.For<IInlineAlertHost>();
         sut.RegisterModal(TestRegistration(id, host));
 
-        // Act
         sut.UnregisterModal(new ModalId(id.Value + 99));
 
-        // Assert
         Assert.True(sut.TryGetInlineAlertHost(out var resolved));
         Assert.Same(host, resolved);
     }
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/Modal/ModalServiceCompletionOrderingTests.cs b/tests/Unit/EventLogExpert.UI.Tests/Modal/ModalServiceCompletionOrderingTests.cs
similarity index 81%
rename from tests/Unit/EventLogExpert.Runtime.Tests/Modal/ModalServiceCompletionOrderingTests.cs
rename to tests/Unit/EventLogExpert.UI.Tests/Modal/ModalServiceCompletionOrderingTests.cs
index 94ec4cab1..fdce90593 100644
--- a/tests/Unit/EventLogExpert.Runtime.Tests/Modal/ModalServiceCompletionOrderingTests.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/Modal/ModalServiceCompletionOrderingTests.cs
@@ -1,26 +1,22 @@
 // // Copyright (c) Microsoft Corporation.
 // // Licensed under the MIT License.
 
-using EventLogExpert.Runtime.Modal;
+using EventLogExpert.UI.Modal;
 using Microsoft.AspNetCore.Components;
 
-namespace EventLogExpert.Runtime.Tests.Modal;
+namespace EventLogExpert.UI.Tests.Modal;
 
-/// <summary>Verifies StateChanged fires before awaiter resumption on Complete/CancelActive/Show preempt.</summary>
 public sealed class ModalServiceCompletionOrderingTests
 {
     [Fact]
     public async Task CancelActive_FiresStateChangedBeforeAwaiterResumes()
     {
-        // Arrange
         var sut = new ModalService();
         bool stateChangedFiredBeforeAwaiter = false;
         bool awaiterResumed = false;
 
         Task<bool> showTask = sut.Show<DummyModal, bool>();
 
-        // Subscribe AFTER Show so the initial Show event doesn't satisfy the assertion before
-        // CancelActive runs; we only want to observe the CancelActive-fired StateChanged.
         sut.StateChanged += () =>
         {
             if (!awaiterResumed) { stateChangedFiredBeforeAwaiter = true; }
@@ -35,27 +31,22 @@ public async Task CancelActive_FiresStateChangedBeforeAwaiterResumes()
             awaiterReached.SetResult();
         }, TestContext.Current.CancellationToken);
 
-        // Act
         sut.CancelActive();
         await awaiterReached.Task;
         await observer;
 
-        // Assert
         Assert.True(stateChangedFiredBeforeAwaiter);
     }
 
     [Fact]
     public async Task CancelActive_StateChangedSubscriberThrows_AwaiterStillResumes()
     {
-        // Arrange
         var sut = new ModalService();
         Task<bool> showTask = sut.Show<DummyModal, bool>();
         sut.StateChanged += () => throw new InvalidOperationException("subscriber misbehavior");
 
-        // Act
         Exception? thrown = Record.Exception(sut.CancelActive);
 
-        // Assert
         Assert.NotNull(thrown);
         bool result = await showTask;
         Assert.False(result);
@@ -64,7 +55,6 @@ public async Task CancelActive_StateChangedSubscriberThrows_AwaiterStillResumes(
     [Fact]
     public async Task Complete_FiresStateChangedBeforeAwaiterResumes()
     {
-        // Arrange
         var sut = new ModalService();
         bool stateChangedFiredBeforeAwaiter = false;
         bool awaiterResumed = false;
@@ -72,8 +62,6 @@ public async Task Complete_FiresStateChangedBeforeAwaiterResumes()
         Task<bool> showTask = sut.Show<DummyModal, bool>();
         long id = sut.ActiveModalId.Value;
 
-        // Subscribe AFTER Show so the initial Show event doesn't satisfy the assertion before
-        // Complete runs; we only want to observe the Complete-fired StateChanged.
         sut.StateChanged += () =>
         {
             if (!awaiterResumed) { stateChangedFiredBeforeAwaiter = true; }
@@ -88,30 +76,24 @@ public async Task Complete_FiresStateChangedBeforeAwaiterResumes()
             awaiterReached.SetResult();
         }, TestContext.Current.CancellationToken);
 
-        // Act
         sut.Complete(new ModalId(id), true);
         await awaiterReached.Task;
         await observer;
 
-        // Assert
         Assert.True(stateChangedFiredBeforeAwaiter);
     }
 
     [Fact]
     public async Task Complete_StateChangedSubscriberThrows_AwaiterStillResumes()
     {
-        // Arrange
         var sut = new ModalService();
         Task<bool> showTask = sut.Show<DummyModal, bool>();
         long id = sut.ActiveModalId.Value;
 
-        // Subscribe AFTER Show so the throw only fires on the Complete-triggered StateChanged.
         sut.StateChanged += () => throw new InvalidOperationException("subscriber misbehavior");
 
-        // Act
         Exception? thrown = Record.Exception(() => sut.Complete(new ModalId(id), true));
 
-        // Assert
         Assert.NotNull(thrown);
         bool result = await showTask;
         Assert.True(result);
@@ -120,7 +102,6 @@ public async Task Complete_StateChangedSubscriberThrows_AwaiterStillResumes()
     [Fact]
     public async Task Show_PreemptingPrior_FiresStateChangedBeforePriorAwaiterResumes()
     {
-        // Arrange
         var sut = new ModalService();
         bool stateChangedFiredBeforePriorAwaiter = false;
         bool priorAwaiterResumed = false;
@@ -140,13 +121,10 @@ public async Task Show_PreemptingPrior_FiresStateChangedBeforePriorAwaiterResume
             if (!priorAwaiterResumed) { stateChangedFiredBeforePriorAwaiter = true; }
         };
 
-        // Act — second Show pre-empts; StateChanged announcing the NEW modal must fire before
-        // the prior modal's awaiter resumes.
         Task<bool> secondShow = sut.Show<OtherModal, bool>();
         await priorAwaiterReached.Task;
         await priorObserver;
 
-        // Assert
         Assert.True(stateChangedFiredBeforePriorAwaiter);
 
         sut.CancelActive();
@@ -156,15 +134,12 @@ public async Task Show_PreemptingPrior_FiresStateChangedBeforePriorAwaiterResume
     [Fact]
     public async Task Show_PreemptingWhenStateChangedThrows_PriorAwaiterStillResumes()
     {
-        // Arrange
         var sut = new ModalService();
         Task<bool> firstShow = sut.Show<DummyModal, bool>();
         sut.StateChanged += () => throw new InvalidOperationException("subscriber misbehavior");
 
-        // Act
         Exception? thrown = Record.Exception(() => { _ = sut.Show<OtherModal, bool>(); });
 
-        // Assert
         Assert.NotNull(thrown);
         bool firstResult = await firstShow;
         Assert.False(firstResult);
diff --git a/tests/Unit/EventLogExpert.Runtime.Tests/Modal/ModalServiceTests.cs b/tests/Unit/EventLogExpert.UI.Tests/Modal/ModalServiceTests.cs
similarity index 80%
rename from tests/Unit/EventLogExpert.Runtime.Tests/Modal/ModalServiceTests.cs
rename to tests/Unit/EventLogExpert.UI.Tests/Modal/ModalServiceTests.cs
index d2c2cc7be..9cd10f09f 100644
--- a/tests/Unit/EventLogExpert.Runtime.Tests/Modal/ModalServiceTests.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/Modal/ModalServiceTests.cs
@@ -1,27 +1,24 @@
 // // Copyright (c) Microsoft Corporation.
 // // Licensed under the MIT License.
 
-using EventLogExpert.Runtime.Modal;
+using EventLogExpert.UI.Modal;
 using Microsoft.AspNetCore.Components;
 
-namespace EventLogExpert.Runtime.Tests.Modal;
+namespace EventLogExpert.UI.Tests.Modal;
 
 public sealed class ModalServiceTests
 {
     [Fact]
     public async Task CancelActive_WhenModalIsOpen_ShouldCompleteWithDefaultAndClearState()
     {
-        // Arrange
         var service = new ModalService();
         var stateChangedCount = 0;
         service.StateChanged += () => stateChangedCount++;
 
         var task = service.Show<FakeModalA, bool>();
 
-        // Act
         service.CancelActive();
 
-        // Assert
         var result = await task;
         Assert.False(result);
         Assert.Null(service.ActiveModalType);
@@ -31,15 +28,12 @@ public async Task CancelActive_WhenModalIsOpen_ShouldCompleteWithDefaultAndClear
     [Fact]
     public void CancelActive_WhenNoModalIsOpen_ShouldBeNoOp()
     {
-        // Arrange
         var service = new ModalService();
         var stateChangedCount = 0;
         service.StateChanged += () => stateChangedCount++;
 
-        // Act
         var exception = Record.Exception(service.CancelActive);
 
-        // Assert
         Assert.Null(exception);
         Assert.Equal(0, stateChangedCount);
     }
@@ -47,24 +41,20 @@ public void CancelActive_WhenNoModalIsOpen_ShouldBeNoOp()
     [Fact]
     public void Complete_CalledTwiceWithSameId_ShouldBeIdempotent()
     {
-        // Arrange
         var service = new ModalService();
         _ = service.Show<FakeModalA, bool>();
         var modalId = service.ActiveModalId;
 
         service.Complete(modalId, true);
 
-        // Act — second call uses an id that no longer matches ActiveModalId (cleared above).
         var exception = Record.Exception(() => service.Complete(modalId, false));
 
-        // Assert
         Assert.Null(exception);
     }
 
     [Fact]
     public async Task Complete_WithCurrentId_ShouldCompleteTaskAndClearState()
     {
-        // Arrange
         var service = new ModalService();
         var stateChangedCount = 0;
         service.StateChanged += () => stateChangedCount++;
@@ -72,34 +62,27 @@ public async Task Complete_WithCurrentId_ShouldCompleteTaskAndClearState()
         var task = service.Show<FakeModalA, bool>();
         var modalId = service.ActiveModalId;
 
-        // Act
         service.Complete(modalId, true);
 
-        // Assert
         var result = await task;
         Assert.True(result);
         Assert.Null(service.ActiveModalType);
         Assert.Null(service.ActiveModalParameters);
-        Assert.Equal(2, stateChangedCount); // Once for Show, once for Complete.
+        Assert.Equal(2, stateChangedCount);
     }
 
     [Fact]
     public async Task Complete_WithMismatchedResultType_ShouldNotStrandAwaiter()
     {
-        // Arrange — guards the dynamic-cast inside Complete{TResult}. A wrong TResult MUST be a
-        // no-op so the real awaiter (with the correct type) can still complete.
         var service = new ModalService();
         var task = service.Show<FakeModalA, bool>();
         var modalId = service.ActiveModalId;
 
-        // Act — wrong TResult type for the in-flight task.
         service.Complete(modalId, "wrong-type");
 
-        // Assert — task still pending, state still active.
         Assert.False(task.IsCompleted);
         Assert.Equal(typeof(FakeModalA), service.ActiveModalType);
 
-        // Correct-typed call still completes the task and clears state.
         service.Complete(modalId, true);
         var result = await task;
         Assert.True(result);
@@ -109,20 +92,16 @@ public async Task Complete_WithMismatchedResultType_ShouldNotStrandAwaiter()
     [Fact]
     public async Task Complete_WithStaleId_ShouldNotCompleteCurrentModalsTask()
     {
-        // Arrange — modal A is replaced by modal B; A's late callback must not complete B.
         var service = new ModalService();
         var firstTask = service.Show<FakeModalA, bool>();
         var staleId = service.ActiveModalId;
 
         var secondTask = service.Show<FakeModalB, bool>();
 
-        // First modal's auto-cancel completes its own task as default.
         await firstTask;
 
-        // Act — simulate a delayed callback from modal A using its captured (now stale) id.
         service.Complete(staleId, true);
 
-        // Assert — modal B's task is still pending.
         Assert.False(secondTask.IsCompleted);
         Assert.Equal(typeof(FakeModalB), service.ActiveModalType);
     }
@@ -130,14 +109,11 @@ public async Task Complete_WithStaleId_ShouldNotCompleteCurrentModalsTask()
     [Fact]
     public async Task Show_WhenAnotherModalIsActive_ShouldCompleteFirstWithDefault()
     {
-        // Arrange
         var service = new ModalService();
         var firstTask = service.Show<FakeModalA, bool>();
 
-        // Act
         var secondTask = service.Show<FakeModalB, bool>();
 
-        // Assert
         var firstResult = await firstTask;
         Assert.False(firstResult);
         Assert.False(secondTask.IsCompleted);
@@ -147,33 +123,27 @@ public async Task Show_WhenAnotherModalIsActive_ShouldCompleteFirstWithDefault()
     [Fact]
     public void Show_WhenCalledTwice_ShouldAssignDifferentActiveModalIds()
     {
-        // Arrange
         var service = new ModalService();
 
-        // Act
         _ = service.Show<FakeModalA, bool>();
         var firstId = service.ActiveModalId;
         _ = service.Show<FakeModalA, bool>();
         var secondId = service.ActiveModalId;
 
-        // Assert
         Assert.NotEqual(firstId, secondId);
     }
 
     [Fact]
     public void Show_WhenCalled_ShouldSetActiveStateAndRaiseStateChanged()
     {
-        // Arrange
         var service = new ModalService();
         var stateChangedCount = 0;
         service.StateChanged += () => stateChangedCount++;
 
         var parameters = new Dictionary<string, object?> { ["Foo"] = 42 };
 
-        // Act
         var task = service.Show<FakeModalA, bool>(parameters);
 
-        // Assert
         Assert.Equal(typeof(FakeModalA), service.ActiveModalType);
         Assert.Same(parameters, service.ActiveModalParameters);
         Assert.NotEqual(ModalId.None, service.ActiveModalId);
@@ -184,7 +154,6 @@ public void Show_WhenCalled_ShouldSetActiveStateAndRaiseStateChanged()
     [Fact]
     public async Task Show_WhenSameTypeReopened_ShouldCreateFreshTaskWithNewId()
     {
-        // Arrange
         var service = new ModalService();
 
         var firstTask = service.Show<FakeModalA, bool>();
@@ -192,11 +161,9 @@ public async Task Show_WhenSameTypeReopened_ShouldCreateFreshTaskWithNewId()
         service.Complete(firstId, true);
         var firstResult = await firstTask;
 
-        // Act
         var secondTask = service.Show<FakeModalA, bool>();
         var secondId = service.ActiveModalId;
 
-        // Assert
         Assert.True(firstResult);
         Assert.NotEqual(firstId, secondId);
         Assert.False(secondTask.IsCompleted);
diff --git a/tests/Unit/EventLogExpert.UI.Tests/Settings/SettingsModalTests.cs b/tests/Unit/EventLogExpert.UI.Tests/Settings/SettingsModalTests.cs
index 5221431b1..bedbeec46 100644
--- a/tests/Unit/EventLogExpert.UI.Tests/Settings/SettingsModalTests.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/Settings/SettingsModalTests.cs
@@ -4,11 +4,10 @@
 using Bunit;
 using EventLogExpert.Runtime.Announcement;
 using EventLogExpert.Runtime.DetailsPane;
-using EventLogExpert.Runtime.Modal;
 using EventLogExpert.Runtime.Settings;
+using EventLogExpert.UI.Modal;
 using EventLogExpert.UI.Settings;
 using EventLogExpert.UI.Tests.TestUtils;
-using Fluxor;
 using Microsoft.Extensions.DependencyInjection;
 using NSubstitute;
 
@@ -36,7 +35,6 @@ public SettingsModalTests()
         Services.AddSingleton(_modalCoordinator);
         Services.AddSingleton(_modalService);
         Services.AddSingleton(_settings);
-        Services.AddFluxor(options => options.ScanAssemblies(typeof(SettingsModal).Assembly));
 
         JSInterop.Mode = JSRuntimeMode.Loose;
     }
@@ -52,25 +50,24 @@ public void SettingsModal_LoadsVerboseResolutionFromSettings()
     }
 
     [Fact]
-    public async Task SettingsModal_OnSave_PersistsStagedVerboseResolution()
+    public async Task SettingsModal_OnSaveSuccess_AnnouncesSettingsSaved()
     {
-        _settings.VerboseResolution.Returns(false);
         var component = Render<SettingsModal>();
-        component.Find("#settings-verbose-resolution").Change(true);
-
         await component.InvokeAsync(() => component.Instance.InvokeOnSaveAsyncForTests());
 
-        _settings.Received().VerboseResolution = true;
+        _announcementService.Received(1).Announce("Settings saved");
     }
 
     [Fact]
-    public async Task SettingsModal_OnSaveSuccess_AnnouncesSettingsSaved()
+    public async Task SettingsModal_OnSave_PersistsStagedVerboseResolution()
     {
+        _settings.VerboseResolution.Returns(false);
         var component = Render<SettingsModal>();
-        // Internal test-only forwarder bypasses ModalChrome footer markup coupling.
+        component.Find("#settings-verbose-resolution").Change(true);
+
         await component.InvokeAsync(() => component.Instance.InvokeOnSaveAsyncForTests());
 
-        _announcementService.Received(1).Announce("Settings saved");
+        _settings.Received().VerboseResolution = true;
     }
 
     [Fact]
diff --git a/tests/Unit/EventLogExpert.UI.Tests/StatusBar/StatusBarTests.cs b/tests/Unit/EventLogExpert.UI.Tests/StatusBar/StatusBarTests.cs
index 3be331dc2..f3e8f8e84 100644
--- a/tests/Unit/EventLogExpert.UI.Tests/StatusBar/StatusBarTests.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/StatusBar/StatusBarTests.cs
@@ -7,10 +7,8 @@
 using EventLogExpert.Filtering.Evaluation;
 using EventLogExpert.Runtime.EventLog;
 using EventLogExpert.Runtime.FilterLenses;
-using EventLogExpert.Runtime.FilterPane;
 using EventLogExpert.Runtime.LogTable;
 using EventLogExpert.Runtime.StatusBar;
-using Fluxor;
 using Microsoft.Extensions.DependencyInjection;
 using NSubstitute;
 using System.Collections.Immutable;
@@ -19,60 +17,121 @@ namespace EventLogExpert.UI.Tests.StatusBar;
 
 public sealed class StatusBarTests : BunitContext
 {
-    private readonly IStateSelection<EventLogState, (Filter, bool, int, bool, int)> _eventLog =
-        Substitute.For<IStateSelection<EventLogState, (Filter, bool, int, bool, int)>>();
+    private readonly IFilterAppliedSource _filterApplied = Substitute.For<IFilterAppliedSource>();
+    private readonly IFilterLensSource _lensSource = Substitute.For<IFilterLensSource>();
+    private readonly IStatusBarSource _statusBarSource = Substitute.For<IStatusBarSource>();
+    private readonly IOrderedViewSource _viewSource = Substitute.For<IOrderedViewSource>();
 
-    private readonly IStateSelection<FilterPaneState, bool> _filterActive =
-        Substitute.For<IStateSelection<FilterPaneState, bool>>();
-
-    private readonly IStateSelection<FilterLensState, int> _lensCount =
-        Substitute.For<IStateSelection<FilterLensState, int>>();
-
-    private readonly IStateSelection<LogTableState, (
-        EventLogId?, ImmutableList<LogView>, int, ImmutableDictionary<EventLogId, int>, ImmutableList<LogTabGroup>)> _logTable =
-        Substitute.For<IStateSelection<LogTableState, (
-            EventLogId?, ImmutableList<LogView>, int, ImmutableDictionary<EventLogId, int>, ImmutableList<LogTabGroup>)>>();
-
-    private readonly IStateSelection<RawEventCountState, (int, ImmutableDictionary<EventLogId, int>)> _rawCount =
-        Substitute.For<IStateSelection<RawEventCountState, (int, ImmutableDictionary<EventLogId, int>)>>();
-
-    private readonly IStateSelection<StatusBarState, (ImmutableDictionary<StatusActivityId, (int, int)>, string)> _statusBar =
-        Substitute.For<IStateSelection<StatusBarState, (ImmutableDictionary<StatusActivityId, (int, int)>, string)>>();
+    private EventLogId _activeLogId;
+    private StatusBarPresentation _status = new();
 
     public StatusBarTests()
     {
         JSInterop.Mode = JSRuntimeMode.Loose;
 
-        Services.AddFluxor(options => options.ScanAssemblies(typeof(UI.StatusBar.StatusBar).Assembly));
-        Services.AddSingleton(_eventLog);
-        Services.AddSingleton(_logTable);
-        Services.AddSingleton(_rawCount);
-        Services.AddSingleton(_statusBar);
-        Services.AddSingleton(_filterActive);
-        Services.AddSingleton(_lensCount);
+        Services.AddSingleton(_filterApplied);
+        Services.AddSingleton(_lensSource);
+        Services.AddSingleton(_statusBarSource);
+        Services.AddSingleton(_viewSource);
+
+        Services.AddSingleton(provider => new DisplayIndicatorGate(provider.GetRequiredService<IOrderedViewSource>()));
+
+        _statusBarSource.Current.Returns(_ => _status);
+        _filterApplied.IsFilteringEnabled.Returns(false);
+        _lensSource.Lenses.Returns(ImmutableList<FilterLensSummary>.Empty);
+
+        var emptyPresentation = PresentationWithCount(0, EventLogId.Create());
 
-        _eventLog.Value.Returns((Unfiltered, false, 0, false, 0));
-        _logTable.Value.Returns((null, ImmutableList<LogView>.Empty, 0,
-            ImmutableDictionary<EventLogId, int>.Empty, ImmutableList<LogTabGroup>.Empty));
-        _rawCount.Value.Returns((0, ImmutableDictionary<EventLogId, int>.Empty));
-        _statusBar.Value.Returns((ImmutableDictionary<StatusActivityId, (int, int)>.Empty, string.Empty));
-        _filterActive.Value.Returns(false);
-        _lensCount.Value.Returns(0);
+        _viewSource.Current.Returns(emptyPresentation);
     }
 
     private static Filter Filtered => new(new DateFilter { IsEnabled = true }, []);
 
     private static Filter Unfiltered => new(null, []);
 
+    [Fact]
+    public void ACountFromASettledView_IsStillReportedAsAFilteredResult()
+    {
+        SetActiveLog(total: 1500, shown: 0, filter: Filtered, selected: 0);
+
+        var cut = Render<UI.StatusBar.StatusBar>();
+
+        Assert.Contains($"0 of {1500:N0} shown", cut.Markup);
+    }
+
+    [Fact]
+    public void ACountFromAViewStillBeingBuilt_IsNotPassedOffAsAFilteredResult()
+    {
+        SetActiveLog(total: 1500, shown: 0, filter: Filtered, selected: 0);
+
+        _viewSource.Current.Returns(new OrderedViewPresentation(
+            LogTableState.EmptyView, _activeLogId, default, PresentationState.Updating, Revision: 2));
+
+        var cut = Render<UI.StatusBar.StatusBar>();
+
+        Assert.DoesNotContain("0 of", cut.Markup);
+        Assert.Contains($"{1500:N0} events", cut.Markup);
+    }
+
+    [Fact]
+    public void ADisplayThatKeepsTheUserWaiting_IsAnnouncedThroughTheOneLiveRegion()
+    {
+        var delay = new ManualDelay();
+
+        Services.AddSingleton(_ => new DisplayIndicatorGate(_viewSource, delay.Delay));
+
+        var id = EventLogId.Create();
+        _activeLogId = id;
+
+        var pending = new OrderedViewPresentation(
+            LogTableState.EmptyView, id, default, PresentationState.Updating, Revision: 1);
+
+        _status = new StatusBarPresentation
+        {
+            Tabs = ImmutableList.Create(new LogView(id) { LogName = "Application", LogPathType = LogPathType.Channel }),
+            ActiveTabId = id,
+            RawEventCountsByLog = ImmutableDictionary<EventLogId, int>.Empty.Add(id, 0)
+        };
+        _viewSource.Current.Returns(pending);
+
+        var cut = Render<UI.StatusBar.StatusBar>();
+
+        Assert.DoesNotContain("Loading events", cut.Find(".status-bar-announce").TextContent);
+
+        delay.Elapse();
+
+        cut.WaitForAssertion(() =>
+            Assert.Contains("Loading events", cut.Find(".status-bar-announce").TextContent));
+    }
+
+    [Fact]
+    public void ALensChangeAfterRender_RepaintsTheLensTooltip_ThroughTheSource()
+    {
+        _lensSource.Lenses.Returns(LensSummaries(2));
+        SetActiveLog(total: 1500, shown: 300, filter: Filtered, selected: 0);
+
+        var cut = Render<UI.StatusBar.StatusBar>();
+
+        Assert.Equal("2 lenses", cut.Find(".status-bar-filter").GetAttribute("title"));
+
+        _lensSource.Lenses.Returns(LensSummaries(3));
+        cut.InvokeAsync(() => _lensSource.Changed += Raise.Event<Action>());
+
+        cut.WaitForAssertion(() => Assert.Equal("3 lenses", cut.Find(".status-bar-filter").GetAttribute("title")));
+    }
+
     [Fact]
     public void ChannelNewEventsCounter_IsNotAnnounced()
     {
         var id = EventLogId.Create();
         var channel = new LogView(id) { LogName = "Application", LogPathType = LogPathType.Channel };
-        _logTable.Value.Returns((id, ImmutableList.Create(channel), 0,
-            ImmutableDictionary<EventLogId, int>.Empty.Add(id, 0), ImmutableList<LogTabGroup>.Empty));
-        _rawCount.Value.Returns((0, ImmutableDictionary<EventLogId, int>.Empty.Add(id, 0)));
-        _eventLog.Value.Returns((Unfiltered, false, 42, false, 0));
+        _status = new StatusBarPresentation
+        {
+            Tabs = ImmutableList.Create(channel),
+            ActiveTabId = id,
+            RawEventCountsByLog = ImmutableDictionary<EventLogId, int>.Empty.Add(id, 0),
+            NewEventBufferCount = 42
+        };
 
         var cut = Render<UI.StatusBar.StatusBar>();
 
@@ -80,11 +139,26 @@ public void ChannelNewEventsCounter_IsNotAnnounced()
         Assert.Equal("off", newEvents.GetAttribute("aria-live"));
     }
 
+    [Fact]
+    public async Task Disposal_UnsubscribesFromTheSource()
+    {
+        SetActiveLog(total: 500, shown: 500, filter: Unfiltered, selected: 0);
+
+        var cut = Render<UI.StatusBar.StatusBar>();
+
+        await cut.Instance.DisposeAsync();
+
+        _viewSource.Received(1).Updated -= Arg.Any<Action<OrderedViewPresentation>>();
+        _statusBarSource.Received(1).Changed -= Arg.Any<Action>();
+        _filterApplied.Received(1).Changed -= Arg.Any<Action>();
+        _lensSource.Received(1).Changed -= Arg.Any<Action>();
+    }
+
     [Fact]
     public void Filtered_ShowsShownOfTotal_AndFilteredIndicator()
     {
-        _filterActive.Value.Returns(true);
         SetActiveLog(total: 1500, shown: 200, filter: Filtered, selected: 0);
+        _status = _status with { IsPersistentFilterActive = true };
 
         var cut = Render<UI.StatusBar.StatusBar>();
 
@@ -97,10 +171,7 @@ public void Filtered_ShowsShownOfTotal_AndFilteredIndicator()
     [Fact]
     public void LensOnlyNarrowing_ShowsShown_AndLensTooltip()
     {
-        // Persistent filter off, but lenses narrow the composed AppliedFilter - the "shown" count and funnel must still
-        // appear (the corrected lens-awareness), and the tooltip names the lens mechanism.
-        _filterActive.Value.Returns(false);
-        _lensCount.Value.Returns(2);
+        _lensSource.Lenses.Returns(LensSummaries(2));
         SetActiveLog(total: 1500, shown: 300, filter: Filtered, selected: 0);
 
         var cut = Render<UI.StatusBar.StatusBar>();
@@ -109,13 +180,28 @@ public void LensOnlyNarrowing_ShowsShown_AndLensTooltip()
         Assert.Equal("2 lenses", cut.Find(".status-bar-filter").GetAttribute("title"));
     }
 
+    [Fact]
+    public void LoadingActivity_RendersLoadedAndFailedCounts()
+    {
+        _status = new StatusBarPresentation
+        {
+            LoadingActivities = ImmutableDictionary<StatusActivityId, LoadingProgress>.Empty
+                .Add(new StatusActivityId(Guid.NewGuid()), new LoadingProgress(12, 3))
+        };
+
+        var cut = Render<UI.StatusBar.StatusBar>();
+
+        Assert.Contains("Loading: 12", cut.Markup);
+        Assert.Contains("Failed: 3", cut.Markup);
+    }
+
     [Fact]
     public void MultiSelect_ShowsSelectedSuffix_SingleSelectDoesNot()
     {
         SetActiveLog(total: 500, shown: 500, filter: Unfiltered, selected: 3);
         Assert.Contains("3 selected", Render<UI.StatusBar.StatusBar>().Markup);
 
-        _eventLog.Value.Returns((Unfiltered, false, 0, false, 1));
+        _status = _status with { SelectionCount = 1 };
         Assert.DoesNotContain("selected", Render<UI.StatusBar.StatusBar>().Markup);
     }
 
@@ -128,6 +214,40 @@ public void NoActiveLog_ShowsNoLogOpen_AndNoCounts()
         Assert.Empty(cut.FindAll(".status-bar-counts"));
     }
 
+    [Fact]
+    public void PresentationForADifferentTab_NeverPairsThisTabsTotalWithThatTabsCount()
+    {
+        SetActiveLog(total: 1500, shown: 200, filter: Filtered, selected: 0);
+
+        var otherTab = PresentationWithCount(200, EventLogId.Create());
+
+        _viewSource.Current.Returns(otherTab);
+
+        var cut = Render<UI.StatusBar.StatusBar>();
+
+        Assert.DoesNotContain($"{200:N0} of {1500:N0} shown", cut.Markup);
+        Assert.DoesNotContain("shown", cut.Markup);
+
+        Assert.Contains($"{1500:N0} events", cut.Markup);
+    }
+
+    [Fact]
+    public void PublishedPresentation_RendersTheNewCount()
+    {
+        SetActiveLog(total: 1500, shown: 200, filter: Filtered, selected: 0);
+
+        var cut = Render<UI.StatusBar.StatusBar>();
+
+        Assert.Contains($"{200:N0} of {1500:N0} shown", cut.Markup);
+
+        var grown = PresentationWithCount(275, _activeLogId);
+
+        _viewSource.Current.Returns(grown);
+        _viewSource.Updated += Raise.Event<Action<OrderedViewPresentation>>(grown);
+
+        cut.WaitForAssertion(() => Assert.Contains($"{275:N0} of {1500:N0} shown", cut.Markup));
+    }
+
     [Fact]
     public void Root_HasNoLiveRegion_ButAnnounceRegionIsPoliteStatus()
     {
@@ -156,14 +276,67 @@ public void Unfiltered_ShowsTotalEvents_WithoutFilteredIndicator()
         Assert.Empty(cut.FindAll(".status-bar-filter"));
     }
 
+    private static ImmutableList<FilterLensSummary> LensSummaries(int count) =>
+        [.. Enumerable.Range(0, count).Select(index => new FilterLensSummary(FilterLensId.Create(), $"lens {index + 1}"))];
+
+    private static OrderedViewPresentation PresentationWithCount(int count, EventLogId tabId)
+    {
+        var view = Substitute.For<IEventColumnView>();
+        view.Count.Returns(count);
+
+        return new OrderedViewPresentation(
+            view,
+            tabId,
+            default,
+            PresentationState.Current,
+            Revision: 1);
+    }
+
     private void SetActiveLog(int total, int shown, Filter filter, int selected)
     {
         var id = EventLogId.Create();
+        _activeLogId = id;
         var log = new LogView(id) { LogName = "Application", LogPathType = LogPathType.Channel };
+        var presentation = PresentationWithCount(shown, id);
+
+        _viewSource.Current.Returns(presentation);
+        _filterApplied.IsFilteringEnabled.Returns(filter.IsFilteringEnabled);
+        _status = new StatusBarPresentation
+        {
+            Tabs = ImmutableList.Create(log),
+            ActiveTabId = id,
+            RawEventTotal = total,
+            RawEventCountsByLog = ImmutableDictionary<EventLogId, int>.Empty.Add(id, total),
+            SelectionCount = selected
+        };
+    }
+
+    private sealed class ManualDelay
+    {
+        private readonly List<TaskCompletionSource> _pending = [];
+        private readonly Lock _sync = new();
+
+        public Task Delay(TimeSpan duration, CancellationToken token)
+        {
+            var completion = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
+
+            lock (_sync) { _pending.Add(completion); }
+
+            return completion.Task;
+        }
+
+        public void Elapse()
+        {
+            TaskCompletionSource[] outstanding;
+
+            lock (_sync)
+            {
+                outstanding = [.. _pending];
+
+                _pending.Clear();
+            }
 
-        _logTable.Value.Returns((id, ImmutableList.Create(log), shown,
-            ImmutableDictionary<EventLogId, int>.Empty.Add(id, shown), ImmutableList<LogTabGroup>.Empty));
-        _rawCount.Value.Returns((total, ImmutableDictionary<EventLogId, int>.Empty.Add(id, total)));
-        _eventLog.Value.Returns((filter, false, 0, false, selected));
+            foreach (var completion in outstanding) { completion.TrySetResult(); }
+        }
     }
 }
diff --git a/tests/Unit/EventLogExpert.UI.Tests/TestUtils/BannerHostDependenciesExtensions.cs b/tests/Unit/EventLogExpert.UI.Tests/TestUtils/BannerHostDependenciesExtensions.cs
index 18b9469cd..0b5e848a1 100644
--- a/tests/Unit/EventLogExpert.UI.Tests/TestUtils/BannerHostDependenciesExtensions.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/TestUtils/BannerHostDependenciesExtensions.cs
@@ -2,8 +2,8 @@
 // // Licensed under the MIT License.
 
 using EventLogExpert.Runtime.Banner;
-using EventLogExpert.Runtime.Modal;
 using EventLogExpert.UI.Banner;
+using EventLogExpert.UI.Modal;
 using Microsoft.Extensions.DependencyInjection;
 using NSubstitute;
 
diff --git a/tests/Unit/EventLogExpert.UI.Tests/TestUtils/DisplayViewTestFactory.cs b/tests/Unit/EventLogExpert.UI.Tests/TestUtils/DisplayViewTestFactory.cs
index 45961d03d..d82e59c5d 100644
--- a/tests/Unit/EventLogExpert.UI.Tests/TestUtils/DisplayViewTestFactory.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/TestUtils/DisplayViewTestFactory.cs
@@ -4,12 +4,53 @@
 using EventLogExpert.Eventing.Common.EventLogs;
 using EventLogExpert.Eventing.Common.Events;
 using EventLogExpert.Runtime.LogTable;
+using EventLogExpert.Runtime.Tests.LogTable.TestSupport;
+using System.Collections.Immutable;
 
 namespace EventLogExpert.UI.Tests.TestUtils;
 
 internal static class DisplayViewTestFactory
 {
-    // Identity-ordered, unfiltered view over the given events (generation 0, physical index == list position).
+    internal static readonly ImmutableDictionary<ColumnName, bool> DefaultColumns = new[]
+    {
+        ColumnName.Level,
+        ColumnName.DateAndTime,
+        ColumnName.Source,
+        ColumnName.EventId,
+        ColumnName.TaskCategory
+    }.ToImmutableDictionary(column => column, _ => true);
+
+    internal static OrderedViewPresentation CombinedPresentation(
+        EventLogId tabId,
+        IReadOnlyList<(EventLogId LogId, IReadOnlyList<ResolvedEvent> Events)> members,
+        ColumnName? orderBy = null,
+        bool isDescending = false,
+        ColumnName? groupBy = null,
+        bool isGroupDescending = false,
+        ImmutableHashSet<string>? groupCollapseOverrides = null,
+        bool groupsCollapsedByDefault = false,
+        long revision = 1)
+    {
+        var views = new List<AosReferenceView>(members.Count);
+
+        foreach (var (logId, events) in members)
+        {
+            views.Add((AosReferenceView)IdentityFor(logId, events, groupBy, isGroupDescending, isDescending));
+        }
+
+        return new OrderedViewPresentation(
+            new AosReferenceCombinedView(views, views[0].Context),
+            tabId,
+            new DisplayOrdering(orderBy, isDescending, groupBy, isGroupDescending),
+            PresentationState.Current,
+            revision)
+        {
+            Columns = DefaultColumns,
+            GroupsCollapsedByDefault = groupsCollapsedByDefault,
+            GroupCollapseOverrides = groupCollapseOverrides ?? ImmutableHashSet.Create<string>(StringComparer.Ordinal)
+        };
+    }
+
     internal static IEventColumnView Identity(IReadOnlyList<ResolvedEvent> events, ColumnName? groupBy = null)
     {
         var reader = EventColumnStore.Build(events, 0, 0).CreateReader(EventLogId.Create());
@@ -17,6 +58,42 @@ internal static IEventColumnView Identity(IReadOnlyList<ResolvedEvent> events, C
 
         for (int i = 0; i < survivors.Length; i++) { survivors[i] = i; }
 
-        return EventColumnView.Create(reader, survivors, orderBy: null, isDescending: false, groupBy: groupBy, isGroupDescending: false);
+        return AosReferenceView.Create(reader, survivors, orderBy: null, isDescending: false, groupBy: groupBy, isGroupDescending: false);
     }
+
+    internal static IEventColumnView IdentityFor(
+        EventLogId logId,
+        IReadOnlyList<ResolvedEvent> events,
+        ColumnName? groupBy = null,
+        bool isGroupDescending = false,
+        bool isDescending = false)
+    {
+        var reader = EventColumnStore.Build(events, 0, 0).CreateReader(logId);
+        int[] survivors = new int[reader.Count];
+
+        for (int i = 0; i < survivors.Length; i++) { survivors[i] = i; }
+
+        return AosReferenceView.Create(reader, survivors, orderBy: null, isDescending, groupBy, isGroupDescending);
+    }
+
+    internal static OrderedViewPresentation Presentation(
+        EventLogId tabId,
+        IReadOnlyList<ResolvedEvent> events,
+        ColumnName? orderBy = null,
+        bool isDescending = false,
+        ColumnName? groupBy = null,
+        bool isGroupDescending = false,
+        ImmutableHashSet<string>? groupCollapseOverrides = null,
+        bool groupsCollapsedByDefault = false,
+        long revision = 1) =>
+        new(IdentityFor(tabId, events, groupBy, isGroupDescending, isDescending),
+            tabId,
+            new DisplayOrdering(orderBy, isDescending, groupBy, isGroupDescending),
+            PresentationState.Current,
+            revision)
+        {
+            Columns = DefaultColumns,
+            GroupsCollapsedByDefault = groupsCollapsedByDefault,
+            GroupCollapseOverrides = groupCollapseOverrides ?? ImmutableHashSet.Create<string>(StringComparer.Ordinal)
+        };
 }
diff --git a/tests/Unit/EventLogExpert.UI.Tests/TestUtils/LogTablePaneDependenciesExtensions.cs b/tests/Unit/EventLogExpert.UI.Tests/TestUtils/LogTablePaneDependenciesExtensions.cs
index 050715bf0..c27a65a62 100644
--- a/tests/Unit/EventLogExpert.UI.Tests/TestUtils/LogTablePaneDependenciesExtensions.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/TestUtils/LogTablePaneDependenciesExtensions.cs
@@ -1,17 +1,22 @@
 // // Copyright (c) Microsoft Corporation.
 // // Licensed under the MIT License.
 
+using EventLogExpert.Eventing.Common.Events;
 using EventLogExpert.Filtering.Compilation;
+using EventLogExpert.Filtering.Persistence;
 using EventLogExpert.Logging.Abstractions;
 using EventLogExpert.Runtime.Alerts;
 using EventLogExpert.Runtime.Common.Clipboard;
+using EventLogExpert.Runtime.EventLog;
 using EventLogExpert.Runtime.FilterLenses;
 using EventLogExpert.Runtime.FilterPane;
 using EventLogExpert.Runtime.LogTable;
-using EventLogExpert.Runtime.Menu;
 using EventLogExpert.UI.LogTable.Find;
+using EventLogExpert.UI.Menu;
+using Fluxor;
 using Microsoft.Extensions.DependencyInjection;
 using NSubstitute;
+using System.Collections.Immutable;
 
 namespace EventLogExpert.UI.Tests.TestUtils;
 
@@ -32,6 +37,35 @@ public IServiceCollection AddLogTablePaneDependencies()
             services.AddSingleton(Substitute.For<IMenuService>());
             services.AddSingleton(Substitute.For<ITraceLogger>());
 
+            services.AddKeyedSingleton(LogCategories.EventLog, Substitute.For<ITraceLogger>());
+            services.AddSingleton<IOrderedViewSource, OrderedViewSource>();
+            services.AddSingleton<DisplayIndicatorGate>();
+
+            services.AddSingleton<ILogTableQueries, LogTableQueries>();
+            services.AddSingleton<ILogTabBarSource, LogTabBarSource>();
+
+            var activeFilters = Substitute.For<IActiveFiltersSource>();
+            activeFilters.Current.Returns(ImmutableList<SavedFilter>.Empty);
+            services.AddSingleton(activeFilters);
+
+            var eventFocus = Substitute.For<IEventFocusSource>();
+            eventFocus.Current.Returns((SelectionEntry?)null);
+            services.AddSingleton(eventFocus);
+
+            var eventSelection = Substitute.For<IEventSelectionSource>();
+            eventSelection.Current.Returns(ImmutableList<SelectionEntry>.Empty);
+            services.AddSingleton(eventSelection);
+
+            services.AddSingleton(Substitute.For<IGroupCollapseNotifier>());
+
+            var revealFocus = Substitute.For<IRevealFocusSource>();
+            revealFocus.Current.Returns((EventLocator?)null);
+            services.AddSingleton(revealFocus);
+
+            var presenceState = Substitute.For<IState<FilteredLogPresenceState>>();
+            presenceState.Value.Returns(new FilteredLogPresenceState());
+            services.AddSingleton(presenceState);
+
             return services;
         }
     }
diff --git a/tests/Unit/EventLogExpert.UI.Tests/TestUtils/MenuHostDependenciesExtensions.cs b/tests/Unit/EventLogExpert.UI.Tests/TestUtils/MenuHostDependenciesExtensions.cs
index 79c788e2c..d552b404d 100644
--- a/tests/Unit/EventLogExpert.UI.Tests/TestUtils/MenuHostDependenciesExtensions.cs
+++ b/tests/Unit/EventLogExpert.UI.Tests/TestUtils/MenuHostDependenciesExtensions.cs
@@ -1,7 +1,6 @@
 // // Copyright (c) Microsoft Corporation.
 // // Licensed under the MIT License.
 
-using EventLogExpert.Runtime.Menu;
 using EventLogExpert.UI.Menu;
 using Microsoft.Extensions.DependencyInjection;
 using NSubstitute;
diff --git a/tests/Unit/EventLogExpert.Windows.Tests/Elevation/ElevatedHelperProcessHostTests.cs b/tests/Unit/EventLogExpert.Windows.Tests/Elevation/ElevatedHelperProcessHostTests.cs
index 703d7652b..ce02b6da4 100644
--- a/tests/Unit/EventLogExpert.Windows.Tests/Elevation/ElevatedHelperProcessHostTests.cs
+++ b/tests/Unit/EventLogExpert.Windows.Tests/Elevation/ElevatedHelperProcessHostTests.cs
@@ -11,6 +11,10 @@ namespace EventLogExpert.Windows.Tests.Elevation;
 
 public sealed class ElevatedHelperProcessHostTests
 {
+    private const int LoopSettleDelayMilliseconds = 50;
+
+    private static readonly TimeSpan s_testTimeout = TimeSpan.FromSeconds(5);
+
     [Fact]
     public async Task AcceptAndVerifyClientPidAsync_WhenClientPidMatches_ReturnsWithoutError()
     {
@@ -39,7 +43,7 @@ public async Task AcceptAndVerifyClientPidAsync_WhenClientPidMatches_ReturnsWith
 
         await client.ConnectAsync(ct);
 
-        await acceptTask.WaitAsync(TimeSpan.FromSeconds(5), ct);
+        await acceptTask.WaitAsync(s_testTimeout, ct);
 
         Assert.True(server.IsConnected);
     }
@@ -60,8 +64,6 @@ public async Task AcceptAndVerifyClientPidAsync_WhenClientPidMismatches_Disconne
 
         using var loopCts = CancellationTokenSource.CreateLinkedTokenSource(ct);
 
-        // Expected PID = 0 never matches a real process; loop should disconnect after each connection and keep
-        // waiting until the deadline cancels the loop.
         var acceptTask = ElevatedHelperProcessHost.AcceptAndVerifyClientPidAsync(
             server,
             expectedPid: 0,
@@ -73,7 +75,7 @@ public async Task AcceptAndVerifyClientPidAsync_WhenClientPidMismatches_Disconne
             await client1.ConnectAsync(ct);
         }
 
-        await Task.Delay(50, ct);
+        await Task.Delay(LoopSettleDelayMilliseconds, ct);
         loopCts.Cancel();
 
         await Assert.ThrowsAnyAsync<OperationCanceledException>(() => acceptTask);