From c2f869aeab642c1bf7e3c89016bf3d00533ae961 Mon Sep 17 00:00:00 2001
From: Hirogen <hirogenat@gmail.com>
Date: Sat, 26 Sep 2026 18:28:50 +0200
Subject: [PATCH 01/11] Add hide-line flag and Core line visibility map/tracker
 (#338)

HighlightEntry.IsHideLine (default false, cloned, serialized),
HighlightEvaluator.IsHidden, an immutable row<->original-line map with
append-only shared storage, and a tracker that rebuilds the map on a
cancellable background scan with generation-tagged results.
---
 .../Classes/Highlight/HighlightEntry.cs       |   7 +
 .../Classes/Highlight/HighlightEvaluator.cs   |  12 +
 .../Classes/Highlight/LineVisibilityMap.cs    | 234 ++++++++++++
 .../Highlight/LineVisibilityTracker.cs        | 349 ++++++++++++++++++
 .../Highlight/HideLineRuleTests.cs            | 113 ++++++
 .../Highlight/LineVisibilityMapTests.cs       | 142 +++++++
 .../Highlight/LineVisibilityTrackerTests.cs   | 285 ++++++++++++++
 7 files changed, 1142 insertions(+)
 create mode 100644 src/LogExpert.Core/Classes/Highlight/LineVisibilityMap.cs
 create mode 100644 src/LogExpert.Core/Classes/Highlight/LineVisibilityTracker.cs
 create mode 100644 src/LogExpert.Tests/Highlight/HideLineRuleTests.cs
 create mode 100644 src/LogExpert.Tests/Highlight/LineVisibilityMapTests.cs
 create mode 100644 src/LogExpert.Tests/Highlight/LineVisibilityTrackerTests.cs

diff --git a/src/LogExpert.Core/Classes/Highlight/HighlightEntry.cs b/src/LogExpert.Core/Classes/Highlight/HighlightEntry.cs
index 976e772a..16fcbb29 100644
--- a/src/LogExpert.Core/Classes/Highlight/HighlightEntry.cs
+++ b/src/LogExpert.Core/Classes/Highlight/HighlightEntry.cs
@@ -97,6 +97,12 @@ public Regex Regex
 
     public bool NoBackground { get; set; }
 
+    /// <summary>
+    /// When true, lines matching this entry are removed from the Log Window's main grid. Display state only:
+    /// the lines stay in the reader and remain eligible for search, filtering and triggers.
+    /// </summary>
+    public bool IsHideLine { get; set; }
+
     public object Clone ()
     {
         var highLightEntry = new HighlightEntry
@@ -118,6 +124,7 @@ public object Clone ()
             CooldownSeconds = CooldownSeconds,
             BookmarkComment = BookmarkComment,
             NoBackground = NoBackground,
+            IsHideLine = IsHideLine,
             IsSearchHit = IsSearchHit
         };
 
diff --git a/src/LogExpert.Core/Classes/Highlight/HighlightEvaluator.cs b/src/LogExpert.Core/Classes/Highlight/HighlightEvaluator.cs
index 6f24ec38..f29de37a 100644
--- a/src/LogExpert.Core/Classes/Highlight/HighlightEvaluator.cs
+++ b/src/LogExpert.Core/Classes/Highlight/HighlightEvaluator.cs
@@ -59,6 +59,18 @@ public static IList<HighlightEntry> FindMatchingEntries (IEnumerable<HighlightEn
         return result;
     }
 
+    /// <summary>
+    /// Returns whether any hide-line entry matches the line. Other matching entries cannot cancel the decision,
+    /// whatever their order. Temporary search-hit entries never hide.
+    /// </summary>
+    public static bool IsHidden (IEnumerable<HighlightEntry> entries, ITextValueMemory line)
+    {
+        ArgumentNullException.ThrowIfNull(entries);
+        ArgumentNullException.ThrowIfNull(line);
+
+        return entries.Any(e => e.IsHideLine && !e.IsSearchHit && IsMatch(e, line));
+    }
+
     /// <summary>
     /// Classifies the non-plugin trigger actions implied by a set of matching entries: whether to
     /// suppress the dirty LED, stop tailing, set a bookmark, and the concatenated bookmark comment.
diff --git a/src/LogExpert.Core/Classes/Highlight/LineVisibilityMap.cs b/src/LogExpert.Core/Classes/Highlight/LineVisibilityMap.cs
new file mode 100644
index 00000000..4c0af88f
--- /dev/null
+++ b/src/LogExpert.Core/Classes/Highlight/LineVisibilityMap.cs
@@ -0,0 +1,234 @@
+namespace LogExpert.Core.Classes.Highlight;
+
+/// <summary>
+/// Immutable mapping between the rows of a Log Window's main grid and the original logical lines of its
+/// Logfile Reader, after highlight-based hiding. Memory is proportional to the number of hidden lines.
+/// <para>
+/// <see cref="Append"/> shares storage with the map it extends, so appending tail lines is cheap. The storage is
+/// append-only: a map only ever reads the prefix it was created with, so an older map stays valid.
+/// </para>
+/// </summary>
+public sealed class LineVisibilityMap
+{
+    private readonly HiddenLineStore _store;
+
+    private LineVisibilityMap (HiddenLineStore store, int lineCount, int hiddenCount)
+    {
+        _store = store;
+        LineCount = lineCount;
+        HiddenCount = hiddenCount;
+    }
+
+    /// <summary>A new map covering no lines. Not a shared instance, so unrelated appends never share storage.</summary>
+    public static LineVisibilityMap Empty => Identity(0);
+
+    /// <summary>Total number of original logical lines covered by the map.</summary>
+    public int LineCount { get; }
+
+    public int HiddenCount { get; }
+
+    public int VisibleCount => LineCount - HiddenCount;
+
+    /// <summary>A map in which every line is visible.</summary>
+    public static LineVisibilityMap Identity (int lineCount)
+    {
+        ArgumentOutOfRangeException.ThrowIfNegative(lineCount);
+        return new LineVisibilityMap(new HiddenLineStore([], 0, lineCount), lineCount, 0);
+    }
+
+    /// <summary>Returns the original line displayed in <paramref name="row"/>, or -1 when there is no such row.</summary>
+    public int RowToLine (int row)
+    {
+        if (row < 0 || row >= VisibleCount)
+        {
+            return -1;
+        }
+
+        if (HiddenCount == 0)
+        {
+            return row;
+        }
+
+        // hidden[i] - i is non-decreasing: count the hidden lines that lie before the row's line.
+        var items = _store.Items;
+        int low = 0, high = HiddenCount;
+        while (low < high)
+        {
+            var mid = (low + high) >>> 1;
+            if (items[mid] - mid <= row)
+            {
+                low = mid + 1;
+            }
+            else
+            {
+                high = mid;
+            }
+        }
+
+        return row + low;
+    }
+
+    /// <summary>Returns the row displaying <paramref name="line"/>, or -1 when the line is hidden or out of range.</summary>
+    public int LineToRow (int line)
+    {
+        if (line < 0 || line >= LineCount)
+        {
+            return -1;
+        }
+
+        var index = Array.BinarySearch(_store.Items, 0, HiddenCount, line);
+        return index >= 0 ? -1 : line - ~index;
+    }
+
+    public bool IsHidden (int line)
+    {
+        return line >= 0 && line < LineCount && Array.BinarySearch(_store.Items, 0, HiddenCount, line) >= 0;
+    }
+
+    /// <summary>
+    /// Returns the row of <paramref name="line"/> when it is visible; otherwise the row of the next visible line,
+    /// falling back to the previous one. Returns -1 when no line is visible.
+    /// </summary>
+    public int NearestRow (int line)
+    {
+        if (VisibleCount == 0)
+        {
+            return -1;
+        }
+
+        if (line >= LineCount)
+        {
+            return VisibleCount - 1;
+        }
+
+        line = Math.Max(line, 0);
+        var index = Array.BinarySearch(_store.Items, 0, HiddenCount, line);
+        var hiddenBefore = index >= 0 ? index : ~index;
+
+        // For a hidden line, line - hiddenBefore is the row of the next visible line, if there is one.
+        return Math.Min(line - hiddenBefore, VisibleCount - 1);
+    }
+
+    /// <summary>
+    /// Returns a map covering <paramref name="lineCount"/> lines, in which <paramref name="hiddenLines"/>
+    /// (ascending, all within the appended range) are hidden in addition to this map's hidden lines.
+    /// </summary>
+    public LineVisibilityMap Append (int lineCount, IReadOnlyList<int> hiddenLines)
+    {
+        ArgumentNullException.ThrowIfNull(hiddenLines);
+        ArgumentOutOfRangeException.ThrowIfLessThan(lineCount, LineCount);
+
+        var previous = LineCount - 1;
+        foreach (var line in hiddenLines)
+        {
+            if (line <= previous || line >= lineCount)
+            {
+                throw new ArgumentOutOfRangeException(nameof(hiddenLines), line, "Hidden lines must be ascending and within the appended range.");
+            }
+
+            previous = line;
+        }
+
+        var store = _store.TryAppend(LineCount, HiddenCount, lineCount, hiddenLines)
+            ?? HiddenLineStore.CopyAppend(_store.Items, HiddenCount, lineCount, hiddenLines);
+
+        return new LineVisibilityMap(store, lineCount, HiddenCount + hiddenLines.Count);
+    }
+
+    /// <summary>Drops the first <paramref name="offset"/> lines (rollover) and renumbers the rest.</summary>
+    public LineVisibilityMap Shift (int offset)
+    {
+        ArgumentOutOfRangeException.ThrowIfNegative(offset);
+
+        var items = _store.Items;
+        var first = Array.BinarySearch(items, 0, HiddenCount, offset);
+        first = first >= 0 ? first : ~first;
+
+        var shifted = new int[HiddenCount - first];
+        for (var i = 0; i < shifted.Length; i++)
+        {
+            shifted[i] = items[first + i] - offset;
+        }
+
+        var lineCount = Math.Max(0, LineCount - offset);
+        return new LineVisibilityMap(new HiddenLineStore(shifted, shifted.Length, lineCount), lineCount, shifted.Length);
+    }
+
+    /// <summary>Keeps only the first <paramref name="lineCount"/> lines.</summary>
+    public LineVisibilityMap Truncate (int lineCount)
+    {
+        ArgumentOutOfRangeException.ThrowIfNegative(lineCount);
+
+        lineCount = Math.Min(lineCount, LineCount);
+        var kept = Array.BinarySearch(_store.Items, 0, HiddenCount, lineCount);
+        kept = kept >= 0 ? kept : ~kept;
+
+        var items = _store.Items.AsSpan(0, kept).ToArray();
+        return new LineVisibilityMap(new HiddenLineStore(items, kept, lineCount), lineCount, kept);
+    }
+
+    /// <summary>
+    /// True when this map extends <paramref name="other"/> without changing any of its lines, so rows that
+    /// <paramref name="other"/> displays keep their row index.
+    /// </summary>
+    public bool IsAppendOf (LineVisibilityMap other)
+    {
+        ArgumentNullException.ThrowIfNull(other);
+        return ReferenceEquals(_store, other._store) && other.LineCount <= LineCount && other.HiddenCount <= HiddenCount;
+    }
+
+    /// <summary>
+    /// Append-only storage of hidden line numbers shared by a chain of appended maps. It is only extended in place
+    /// by the map at its committed end; any other append copies, so no map ever observes a changed prefix.
+    /// </summary>
+    private sealed class HiddenLineStore (int[] items, int committedHidden, int committedLines)
+    {
+        private readonly Lock _lock = new();
+        private int _committedHidden = committedHidden;
+        private int _committedLines = committedLines;
+        private volatile int[] _items = items;
+
+        public int[] Items => _items;
+
+        public HiddenLineStore? TryAppend (int fromLines, int fromHidden, int lineCount, IReadOnlyList<int> hiddenLines)
+        {
+            lock (_lock)
+            {
+                if (_committedLines != fromLines || _committedHidden != fromHidden)
+                {
+                    return null;
+                }
+
+                var required = fromHidden + hiddenLines.Count;
+                var target = _items;
+                if (required > target.Length)
+                {
+                    target = new int[Math.Max(required, Math.Max(16, target.Length * 2))];
+                    Array.Copy(_items, target, fromHidden);
+                }
+
+                for (var i = 0; i < hiddenLines.Count; i++)
+                {
+                    target[fromHidden + i] = hiddenLines[i];
+                }
+
+                _items = target;
+                _committedHidden = required;
+                _committedLines = lineCount;
+                return this;
+            }
+        }
+
+        public static HiddenLineStore CopyAppend (int[] items, int hiddenCount, int lineCount, IReadOnlyList<int> hiddenLines)
+        {
+            var copy = new int[hiddenCount + hiddenLines.Count];
+            Array.Copy(items, copy, hiddenCount);
+            for (var i = 0; i < hiddenLines.Count; i++)
+            {
+                copy[hiddenCount + i] = hiddenLines[i];
+            }
+
+            return new HiddenLineStore(copy, copy.Length, lineCount);
+        }
+    }
+}
diff --git a/src/LogExpert.Core/Classes/Highlight/LineVisibilityTracker.cs b/src/LogExpert.Core/Classes/Highlight/LineVisibilityTracker.cs
new file mode 100644
index 00000000..4199c106
--- /dev/null
+++ b/src/LogExpert.Core/Classes/Highlight/LineVisibilityTracker.cs
@@ -0,0 +1,349 @@
+using ColumnizerLib;
+
+namespace LogExpert.Core.Classes.Highlight;
+
+/// <summary>
+/// Owns a Log Window's <see cref="LineVisibilityMap"/>: which original lines the hide-line Highlight Entries of the
+/// active Highlight Group remove from the main grid.
+/// <para>
+/// Full scans (new content, changed rules) run on a cancellable background task against a cloned rule snapshot; the
+/// previous map stays current until the scan's result replaces it in one step. Every structural change bumps a
+/// generation, so a scan that finishes against outdated content or rules is discarded. Appended tail lines are
+/// evaluated synchronously by the caller's thread. Evaluation uses <see cref="HighlightEvaluator.IsHidden"/> only,
+/// so it can never fire a trigger.
+/// </para>
+/// </summary>
+public sealed class LineVisibilityTracker : IDisposable
+{
+    private readonly Func<int, ITextValueMemory?> _getLine;
+    private readonly Lock _lock = new();
+
+    private volatile LineVisibilityMap _map = LineVisibilityMap.Empty;
+    private HighlightEntry[] _rules = [];
+    private HighlightEntry[]? _pendingRules;
+    private CancellationTokenSource? _scanCts;
+    private Task _scanTask = Task.CompletedTask;
+    private int _generation;
+    private bool _disposed;
+
+    /// <param name="getLine">Reads an original line; read live, since the reader is replaced on reload.</param>
+    public LineVisibilityTracker (Func<int, ITextValueMemory?> getLine)
+    {
+        ArgumentNullException.ThrowIfNull(getLine);
+        _getLine = getLine;
+    }
+
+    /// <summary>
+    /// Raised on a worker thread when a background scan replaces the map, or when evaluation failed and every line
+    /// was made visible (<see cref="LineVisibilityChangedEventArgs.Error"/> set).
+    /// </summary>
+    public event EventHandler<LineVisibilityChangedEventArgs>? Changed;
+
+    public LineVisibilityMap Map => _map;
+
+    public bool IsScanning
+    {
+        get
+        {
+            lock (_lock)
+            {
+                return _pendingRules != null;
+            }
+        }
+    }
+
+    /// <summary>New content was loaded: every line is visible until the scan with <paramref name="entries"/> completes.</summary>
+    public void Load (int lineCount, IEnumerable<HighlightEntry> entries)
+    {
+        var rules = Snapshot(entries);
+        lock (_lock)
+        {
+            if (_disposed)
+            {
+                return;
+            }
+
+            _rules = [];
+            _map = LineVisibilityMap.Identity(lineCount);
+            StartOrStopScanLocked(rules);
+        }
+    }
+
+    /// <summary>The Highlight Group or its entries changed. Unchanged hide rules keep the current map.</summary>
+    public void Rebuild (IEnumerable<HighlightEntry> entries)
+    {
+        var rules = Snapshot(entries);
+        LineVisibilityMap? cleared = null;
+        lock (_lock)
+        {
+            if (_disposed || SameRules(_pendingRules ?? _rules, rules))
+            {
+                return;
+            }
+
+            StartOrStopScanLocked(rules);
+            if (rules.Length == 0 && _map.HiddenCount > 0)
+            {
+                _rules = [];
+                _map = cleared = LineVisibilityMap.Identity(_map.LineCount);
+            }
+        }
+
+        if (cleared != null)
+        {
+            Changed?.Invoke(this, new LineVisibilityChangedEventArgs(cleared, null));
+        }
+    }
+
+    /// <summary>Tail path: evaluates lines appended up to <paramref name="lineCount"/> and returns the current map.</summary>
+    public LineVisibilityMap Extend (int lineCount)
+    {
+        Exception? error;
+        LineVisibilityMap map;
+        lock (_lock)
+        {
+            if (_disposed || lineCount <= _map.LineCount)
+            {
+                return _map;
+            }
+
+            (map, error) = EvaluateLocked(_map, lineCount);
+        }
+
+        RaiseFailure(map, error);
+        return map;
+    }
+
+    /// <summary>Tail path, rollover: the first <paramref name="offset"/> lines were dropped.</summary>
+    public LineVisibilityMap Shift (int offset)
+    {
+        lock (_lock)
+        {
+            if (!_disposed)
+            {
+                _map = _map.Shift(offset);
+                RestartPendingScanLocked();
+            }
+
+            return _map;
+        }
+    }
+
+    /// <summary>Tail path, truncation: the content was replaced and is re-evaluated up to <paramref name="lineCount"/>.</summary>
+    public LineVisibilityMap Replace (int lineCount)
+    {
+        Exception? error;
+        LineVisibilityMap map;
+        lock (_lock)
+        {
+            if (_disposed)
+            {
+                return _map;
+            }
+
+            (map, error) = EvaluateLocked(LineVisibilityMap.Empty, lineCount);
+            RestartPendingScanLocked();
+        }
+
+        RaiseFailure(map, error);
+        return map;
+    }
+
+    /// <summary>Completes once no scan is running (including scans restarted meanwhile).</summary>
+    public async Task WhenIdle ()
+    {
+        while (true)
+        {
+            Task task;
+            lock (_lock)
+            {
+                task = _scanTask;
+            }
+
+            await task.ConfigureAwait(false);
+
+            lock (_lock)
+            {
+                if (task == _scanTask)
+                {
+                    return;
+                }
+            }
+        }
+    }
+
+    public void Dispose ()
+    {
+        lock (_lock)
+        {
+            if (_disposed)
+            {
+                return;
+            }
+
+            _disposed = true;
+            _generation++;
+            _pendingRules = null;
+            _scanCts?.Cancel();
+            _scanCts?.Dispose();
+            _scanCts = null;
+        }
+    }
+
+    private void StartOrStopScanLocked (HighlightEntry[] rules)
+    {
+        _generation++;
+        _scanCts?.Cancel();
+        _scanCts?.Dispose();
+        _scanCts = null;
+        _pendingRules = null;
+
+        if (rules.Length == 0)
+        {
+            return;
+        }
+
+        var cts = new CancellationTokenSource();
+        var generation = _generation;
+        var lineCount = _map.LineCount;
+        _scanCts = cts;
+        _pendingRules = rules;
+        _scanTask = Task.Run(() => Scan(rules, lineCount, generation, cts.Token), CancellationToken.None);
+    }
+
+    private void RestartPendingScanLocked ()
+    {
+        if (_pendingRules != null)
+        {
+            StartOrStopScanLocked(_pendingRules);
+        }
+    }
+
+    private void Scan (HighlightEntry[] rules, int lineCount, int generation, CancellationToken token)
+    {
+        LineVisibilityMap map;
+        Exception? error = null;
+        try
+        {
+            List<int> hidden = [];
+            for (var i = 0; i < lineCount; i++)
+            {
+                token.ThrowIfCancellationRequested();
+                if (IsHiddenLine(rules, i))
+                {
+                    hidden.Add(i);
+                }
+            }
+
+            lock (_lock)
+            {
+                if (generation != _generation)
+                {
+                    return;
+                }
+
+                // Catch up with lines the tail appended while the scan ran.
+                map = Evaluate(LineVisibilityMap.Empty.Append(lineCount, hidden), rules, _map.LineCount);
+                _map = map;
+                _rules = rules;
+                _pendingRules = null;
+            }
+        }
+        catch (OperationCanceledException)
+        {
+            return;
+        }
+        catch (Exception ex)
+        {
+            lock (_lock)
+            {
+                if (generation != _generation)
+                {
+                    return;
+                }
+
+                _map = map = LineVisibilityMap.Identity(_map.LineCount);
+                _rules = [];
+                _pendingRules = null;
+                error = ex;
+            }
+        }
+
+        Changed?.Invoke(this, new LineVisibilityChangedEventArgs(map, error));
+    }
+
+    private (LineVisibilityMap Map, Exception? Error) EvaluateLocked (LineVisibilityMap from, int lineCount)
+    {
+        try
+        {
+            _map = Evaluate(from, _rules, lineCount);
+            return (_map, null);
+        }
+        catch (Exception ex) when (ex is not OperationCanceledException)
+        {
+            // Never publish a partial state: fall back to showing every line.
+            _rules = [];
+            _map = LineVisibilityMap.Identity(lineCount);
+            return (_map, ex);
+        }
+    }
+
+    private LineVisibilityMap Evaluate (LineVisibilityMap from, HighlightEntry[] rules, int lineCount)
+    {
+        if (lineCount <= from.LineCount)
+        {
+            return from;
+        }
+
+        List<int> hidden = [];
+        if (rules.Length > 0)
+        {
+            for (var i = from.LineCount; i < lineCount; i++)
+            {
+                if (IsHiddenLine(rules, i))
+                {
+                    hidden.Add(i);
+                }
+            }
+        }
+
+        return from.Append(lineCount, hidden);
+    }
+
+    private bool IsHiddenLine (HighlightEntry[] rules, int lineNum)
+    {
+        // An unreadable line cannot be classified; it stays visible.
+        var line = _getLine(lineNum);
+        return line != null && HighlightEvaluator.IsHidden(rules, line);
+    }
+
+    private void RaiseFailure (LineVisibilityMap map, Exception? error)
+    {
+        if (error != null)
+        {
+            Changed?.Invoke(this, new LineVisibilityChangedEventArgs(map, error));
+        }
+    }
+
+    private static HighlightEntry[] Snapshot (IEnumerable<HighlightEntry> entries)
+    {
+        ArgumentNullException.ThrowIfNull(entries);
+        return [.. entries.Where(e => e.IsHideLine && !e.IsSearchHit).Select(e => (HighlightEntry)e.Clone())];
+    }
+
+    private static bool SameRules (HighlightEntry[] current, HighlightEntry[] next)
+    {
+        return current.Length == next.Length
+            && current.Zip(next).All(pair => string.Equals(pair.First.SearchText, pair.Second.SearchText, StringComparison.Ordinal)
+                && pair.First.IsRegex == pair.Second.IsRegex
+                && pair.First.IsCaseSensitive == pair.Second.IsCaseSensitive);
+    }
+}
+
+public sealed class LineVisibilityChangedEventArgs (LineVisibilityMap map, Exception? error) : EventArgs
+{
+    public LineVisibilityMap Map { get; } = map;
+
+    /// <summary>Set when evaluation failed; the map then shows every line.</summary>
+    public Exception? Error { get; } = error;
+}
diff --git a/src/LogExpert.Tests/Highlight/HideLineRuleTests.cs b/src/LogExpert.Tests/Highlight/HideLineRuleTests.cs
new file mode 100644
index 00000000..94e99982
--- /dev/null
+++ b/src/LogExpert.Tests/Highlight/HideLineRuleTests.cs
@@ -0,0 +1,113 @@
+using ColumnizerLib;
+
+using LogExpert.Core.Classes.Highlight;
+using LogExpert.Core.Entities;
+
+using Newtonsoft.Json;
+
+using NUnit.Framework;
+
+namespace LogExpert.Tests.Highlight;
+
+[TestFixture]
+public class HideLineRuleTests
+{
+    private sealed class TestLine (string text) : ITextValueMemory
+    {
+        public ReadOnlyMemory<char> Text => text.AsMemory();
+    }
+
+    private static ITextValueMemory Line (string text) => new TestLine(text);
+
+    [Test]
+    public void IsHideLine_DefaultsToFalse ()
+    {
+        Assert.That(new HighlightEntry().IsHideLine, Is.False);
+    }
+
+    [Test]
+    public void Clone_PreservesIsHideLine ()
+    {
+        var clone = (HighlightEntry)new HighlightEntry { SearchText = "DEBUG", IsHideLine = true }.Clone();
+
+        Assert.That(clone.IsHideLine, Is.True);
+    }
+
+    [Test]
+    public void Json_RoundTripsIsHideLine ()
+    {
+        var groups = new List<HighlightGroup>
+        {
+            new() { GroupName = "g", HighlightEntryList = [new HighlightEntry { SearchText = "DEBUG", IsHideLine = true }] }
+        };
+
+        var restored = JsonConvert.DeserializeObject<List<HighlightGroup>>(JsonConvert.SerializeObject(groups));
+
+        Assert.That(restored[0].HighlightEntryList[0].IsHideLine, Is.True);
+    }
+
+    [Test]
+    public void Json_LegacyEntryWithoutTheFlag_ReadsAsNotHidden ()
+    {
+        const string legacy = """[{"GroupName":"g","HighlightEntryList":[{"SearchText":"DEBUG","IsStopTail":false}]}]""";
+
+        var restored = JsonConvert.DeserializeObject<List<HighlightGroup>>(legacy);
+
+        Assert.That(restored[0].HighlightEntryList[0].IsHideLine, Is.False);
+    }
+
+    [Test]
+    public void IsHidden_MatchingHideRule_HidesLine ()
+    {
+        HighlightEntry[] entries = [new HighlightEntry { SearchText = "debug", IsHideLine = true }];
+
+        Assert.That(HighlightEvaluator.IsHidden(entries, Line("2026 DEBUG noise")), Is.True);
+        Assert.That(HighlightEvaluator.IsHidden(entries, Line("2026 INFO start")), Is.False);
+    }
+
+    [Test]
+    public void IsHidden_OnlyColoringRulesMatch_LineStaysVisible ()
+    {
+        HighlightEntry[] entries = [new HighlightEntry { SearchText = "ERROR", BackgroundColor = Color.Red }];
+
+        Assert.That(HighlightEvaluator.IsHidden(entries, Line("ERROR boom")), Is.False);
+    }
+
+    [Test]
+    public void IsHidden_EarlierColoringRuleMatches_CannotCancelLaterHideRule ()
+    {
+        HighlightEntry[] entries =
+        [
+            new HighlightEntry { SearchText = "heartbeat", BackgroundColor = Color.Yellow },
+            new HighlightEntry { SearchText = "heart", IsHideLine = true }
+        ];
+
+        Assert.That(HighlightEvaluator.IsHidden(entries, Line("heartbeat ok")), Is.True);
+    }
+
+    [Test]
+    public void IsHidden_WordMatchHideRule_HidesTheWholeLine ()
+    {
+        HighlightEntry[] entries = [new HighlightEntry { SearchText = "ping", IsWordMatch = true, IsHideLine = true }];
+
+        Assert.That(HighlightEvaluator.IsHidden(entries, Line("host ping 3ms")), Is.True);
+    }
+
+    [Test]
+    public void IsHidden_RegexAndCaseSensitivity_UseHighlightSemantics ()
+    {
+        HighlightEntry[] entries = [new HighlightEntry { SearchText = "^TRACE\\b", IsRegex = true, IsCaseSensitive = true, IsHideLine = true }];
+
+        Assert.That(HighlightEvaluator.IsHidden(entries, Line("TRACE enter")), Is.True);
+        Assert.That(HighlightEvaluator.IsHidden(entries, Line("trace enter")), Is.False);
+        Assert.That(HighlightEvaluator.IsHidden(entries, Line("x TRACE")), Is.False);
+    }
+
+    [Test]
+    public void IsHidden_SearchHitEntries_NeverHide ()
+    {
+        HighlightEntry[] entries = [new HighlightEntry { SearchText = "x", IsHideLine = true, IsSearchHit = true }];
+
+        Assert.That(HighlightEvaluator.IsHidden(entries, Line("x")), Is.False);
+    }
+}
diff --git a/src/LogExpert.Tests/Highlight/LineVisibilityMapTests.cs b/src/LogExpert.Tests/Highlight/LineVisibilityMapTests.cs
new file mode 100644
index 00000000..51d40b66
--- /dev/null
+++ b/src/LogExpert.Tests/Highlight/LineVisibilityMapTests.cs
@@ -0,0 +1,142 @@
+using LogExpert.Core.Classes.Highlight;
+
+using NUnit.Framework;
+
+namespace LogExpert.Tests.Highlight;
+
+[TestFixture]
+public class LineVisibilityMapTests
+{
+    private static LineVisibilityMap Map (int lineCount, params int[] hidden)
+    {
+        return LineVisibilityMap.Empty.Append(lineCount, hidden);
+    }
+
+    [Test]
+    public void RowToLine_SkipsHiddenLines ()
+    {
+        var map = Map(6, 1, 2, 4);
+
+        Assert.That(map.VisibleCount, Is.EqualTo(3));
+        Assert.That(map.HiddenCount, Is.EqualTo(3));
+        Assert.That(Enumerable.Range(0, 3).Select(map.RowToLine), Is.EqualTo(new[] { 0, 3, 5 }));
+    }
+
+    [Test]
+    public void LineToRow_VisibleLine_ReturnsItsRow_HiddenLine_ReturnsMinusOne ()
+    {
+        var map = Map(6, 1, 2, 4);
+
+        Assert.That(map.LineToRow(0), Is.EqualTo(0));
+        Assert.That(map.LineToRow(3), Is.EqualTo(1));
+        Assert.That(map.LineToRow(5), Is.EqualTo(2));
+        Assert.That(map.LineToRow(1), Is.EqualTo(-1));
+        Assert.That(map.LineToRow(4), Is.EqualTo(-1));
+    }
+
+    [TestCase(-1)]
+    [TestCase(6)]
+    public void OutOfRange_ReturnsMinusOne (int index)
+    {
+        var map = Map(6, 1);
+
+        Assert.That(map.LineToRow(index), Is.EqualTo(-1));
+        Assert.That(map.RowToLine(index), Is.EqualTo(-1));
+    }
+
+    [Test]
+    public void HiddenAtStartAndEnd_MapsMiddleOnly ()
+    {
+        var map = Map(5, 0, 1, 4);
+
+        Assert.That(map.VisibleCount, Is.EqualTo(2));
+        Assert.That(map.RowToLine(0), Is.EqualTo(2));
+        Assert.That(map.RowToLine(1), Is.EqualTo(3));
+        Assert.That(map.RowToLine(2), Is.EqualTo(-1));
+    }
+
+    [Test]
+    public void AllLinesHidden_HasNoRows ()
+    {
+        var map = Map(3, 0, 1, 2);
+
+        Assert.That(map.VisibleCount, Is.Zero);
+        Assert.That(map.RowToLine(0), Is.EqualTo(-1));
+        Assert.That(map.NearestRow(1), Is.EqualTo(-1));
+    }
+
+    [Test]
+    public void Identity_MapsEveryLineToItself ()
+    {
+        var map = LineVisibilityMap.Identity(4);
+
+        Assert.That(map.VisibleCount, Is.EqualTo(4));
+        Assert.That(map.HiddenCount, Is.Zero);
+        Assert.That(map.RowToLine(3), Is.EqualTo(3));
+        Assert.That(map.LineToRow(2), Is.EqualTo(2));
+    }
+
+    [Test]
+    public void NearestRow_HiddenLine_PrefersNextVisible_ThenPrevious ()
+    {
+        var map = Map(8, 2, 3, 6, 7);
+
+        Assert.That(map.NearestRow(4), Is.EqualTo(2), "visible line keeps its own row");
+        Assert.That(map.NearestRow(2), Is.EqualTo(2), "hidden line → next visible line 4");
+        Assert.That(map.NearestRow(6), Is.EqualTo(3), "no later visible line → previous visible line 5");
+        Assert.That(map.NearestRow(100), Is.EqualTo(3), "beyond the end → last visible row");
+    }
+
+    [Test]
+    public void Append_ExtendsWithNewHiddenLines_AndKeepsOldMapUnchanged ()
+    {
+        var before = Map(4, 1);
+
+        var after = before.Append(7, [4, 6]);
+
+        Assert.That(before.LineCount, Is.EqualTo(4));
+        Assert.That(before.VisibleCount, Is.EqualTo(3));
+        Assert.That(after.LineCount, Is.EqualTo(7));
+        Assert.That(Enumerable.Range(0, after.VisibleCount).Select(after.RowToLine), Is.EqualTo(new[] { 0, 2, 3, 5 }));
+        Assert.That(after.IsAppendOf(before), Is.True);
+    }
+
+    [Test]
+    public void Append_TwiceFromSameBase_DoesNotCorruptEitherBranch ()
+    {
+        var baseMap = Map(2);
+        var first = baseMap.Append(4, [2]);
+        var second = baseMap.Append(4, [3]);
+
+        Assert.That(first.IsHidden(2), Is.True);
+        Assert.That(first.IsHidden(3), Is.False);
+        Assert.That(second.IsHidden(2), Is.False);
+        Assert.That(second.IsHidden(3), Is.True);
+    }
+
+    [Test]
+    public void Shift_DropsLeadingLines_AndRenumbersTheRest ()
+    {
+        var map = Map(10, 1, 5, 8);
+
+        var shifted = map.Shift(3);
+
+        Assert.That(shifted.LineCount, Is.EqualTo(7));
+        Assert.That(shifted.IsHidden(2), Is.True, "old line 5");
+        Assert.That(shifted.IsHidden(5), Is.True, "old line 8");
+        Assert.That(shifted.HiddenCount, Is.EqualTo(2));
+        Assert.That(shifted.IsAppendOf(map), Is.False);
+    }
+
+    [Test]
+    public void Truncate_DropsTrailingLines ()
+    {
+        var map = Map(10, 1, 5, 8);
+
+        var truncated = map.Truncate(6);
+
+        Assert.That(truncated.LineCount, Is.EqualTo(6));
+        Assert.That(truncated.HiddenCount, Is.EqualTo(2));
+        Assert.That(truncated.VisibleCount, Is.EqualTo(4));
+    }
+}
diff --git a/src/LogExpert.Tests/Highlight/LineVisibilityTrackerTests.cs b/src/LogExpert.Tests/Highlight/LineVisibilityTrackerTests.cs
new file mode 100644
index 00000000..83eb8b83
--- /dev/null
+++ b/src/LogExpert.Tests/Highlight/LineVisibilityTrackerTests.cs
@@ -0,0 +1,285 @@
+using ColumnizerLib;
+
+using LogExpert.Core.Classes.Highlight;
+
+using NUnit.Framework;
+
+namespace LogExpert.Tests.Highlight;
+
+[TestFixture]
+public class LineVisibilityTrackerTests
+{
+    private static readonly TimeSpan Timeout = TimeSpan.FromSeconds(10);
+
+    private static readonly HighlightEntry[] HideDebug = [new HighlightEntry { SearchText = "DEBUG", IsHideLine = true }];
+
+    private List<string> _lines = null!;
+    private ManualResetEventSlim _gate = null!;
+    private LineVisibilityTracker _tracker = null!;
+    private int _changedCount;
+
+    [SetUp]
+    public void SetUp ()
+    {
+        _lines = ["INFO a", "DEBUG b", "INFO c", "DEBUG d", "INFO e"];
+        _gate = new ManualResetEventSlim(true);
+        _changedCount = 0;
+        _tracker = new LineVisibilityTracker(GetLine);
+        _tracker.Changed += (_, _) => Interlocked.Increment(ref _changedCount);
+    }
+
+    [TearDown]
+    public void TearDown ()
+    {
+        _gate.Set();
+        _tracker.Dispose();
+        _gate.Dispose();
+    }
+
+    private ITextValueMemory? GetLine (int lineNum)
+    {
+        _ = _gate.Wait(Timeout);
+        lock (_lines)
+        {
+            return lineNum < _lines.Count ? new LogLine(_lines[lineNum], lineNum) : null;
+        }
+    }
+
+    private void Idle ()
+    {
+        Assert.That(_tracker.WhenIdle().Wait(Timeout), Is.True, "scan did not finish");
+    }
+
+    private static int[] VisibleLines (LineVisibilityMap map)
+    {
+        return [.. Enumerable.Range(0, map.VisibleCount).Select(map.RowToLine)];
+    }
+
+    [Test]
+    public void Load_WithHideRule_PublishesMapHidingMatchingLines ()
+    {
+        _tracker.Load(_lines.Count, HideDebug);
+        Idle();
+
+        Assert.That(VisibleLines(_tracker.Map), Is.EqualTo(new[] { 0, 2, 4 }));
+        Assert.That(_tracker.Map.HiddenCount, Is.EqualTo(2));
+        Assert.That(_changedCount, Is.EqualTo(1));
+    }
+
+    [Test]
+    public void Load_UntilScanCompletes_EveryLineStaysVisible ()
+    {
+        _gate.Reset();
+
+        _tracker.Load(_lines.Count, HideDebug);
+
+        Assert.That(_tracker.Map.VisibleCount, Is.EqualTo(5));
+        Assert.That(_tracker.IsScanning, Is.True);
+        _gate.Set();
+        Idle();
+        Assert.That(_tracker.Map.VisibleCount, Is.EqualTo(3));
+    }
+
+    [Test]
+    public void Load_WithoutHideRules_IsImmediatelyComplete ()
+    {
+        _tracker.Load(_lines.Count, [new HighlightEntry { SearchText = "DEBUG" }]);
+
+        Assert.That(_tracker.IsScanning, Is.False);
+        Assert.That(_tracker.Map.VisibleCount, Is.EqualTo(5));
+    }
+
+    [Test]
+    public void Extend_EvaluatesAppendedLines_AsAnAppendOfTheCurrentMap ()
+    {
+        _tracker.Load(_lines.Count, HideDebug);
+        Idle();
+        var before = _tracker.Map;
+        _lines.AddRange(["DEBUG f", "INFO g"]);
+
+        var after = _tracker.Extend(7);
+
+        Assert.That(VisibleLines(after), Is.EqualTo(new[] { 0, 2, 4, 6 }));
+        Assert.That(after.IsAppendOf(before), Is.True);
+        Assert.That(_tracker.Map, Is.SameAs(after));
+    }
+
+    [Test]
+    public void Extend_ToAKnownLineCount_ChangesNothing ()
+    {
+        _tracker.Load(_lines.Count, HideDebug);
+        Idle();
+        var before = _tracker.Map;
+
+        Assert.That(_tracker.Extend(3), Is.SameAs(before));
+    }
+
+    [Test]
+    public void Extend_WhileScanPending_LinesAreCoveredByThePublishedMap ()
+    {
+        _gate.Reset();
+        _tracker.Load(_lines.Count, HideDebug);
+        _lines.Add("DEBUG f");
+
+        var interim = Task.Run(() => _tracker.Extend(6));
+        _gate.Set();
+        Assert.That(interim.Wait(Timeout), Is.True);
+        Idle();
+
+        Assert.That(_tracker.Map.LineCount, Is.EqualTo(6));
+        Assert.That(VisibleLines(_tracker.Map), Is.EqualTo(new[] { 0, 2, 4 }));
+    }
+
+    [Test]
+    public void Rebuild_WhileScanPending_OnlyTheLatestRulesArePublished ()
+    {
+        _gate.Reset();
+        _tracker.Load(_lines.Count, HideDebug);
+
+        _tracker.Rebuild([new HighlightEntry { SearchText = "INFO", IsHideLine = true }]);
+        _gate.Set();
+        Idle();
+
+        Assert.That(VisibleLines(_tracker.Map), Is.EqualTo(new[] { 1, 3 }));
+    }
+
+    [Test]
+    public void Rebuild_RemovingAllHideRules_ShowsEveryLine ()
+    {
+        _tracker.Load(_lines.Count, HideDebug);
+        Idle();
+
+        _tracker.Rebuild([]);
+        Idle();
+
+        Assert.That(_tracker.Map.HiddenCount, Is.Zero);
+        Assert.That(_tracker.Map.VisibleCount, Is.EqualTo(5));
+    }
+
+    [Test]
+    public void Rebuild_WithUnchangedHideRules_DoesNotRescan ()
+    {
+        _tracker.Load(_lines.Count, HideDebug);
+        Idle();
+        var before = _tracker.Map;
+
+        _tracker.Rebuild([new HighlightEntry { SearchText = "DEBUG", IsHideLine = true, BackgroundColor = Color.Red }]);
+
+        Assert.That(_tracker.IsScanning, Is.False);
+        Assert.That(_tracker.Map, Is.SameAs(before));
+        Assert.That(_changedCount, Is.EqualTo(1));
+    }
+
+    [Test]
+    public void Rebuild_SnapshotsRules_LaterEditsDoNotLeakIntoTheScan ()
+    {
+        var rule = new HighlightEntry { SearchText = "DEBUG", IsHideLine = true };
+        _gate.Reset();
+        _tracker.Load(_lines.Count, [rule]);
+
+        rule.SearchText = "INFO";
+        _gate.Set();
+        Idle();
+
+        Assert.That(VisibleLines(_tracker.Map), Is.EqualTo(new[] { 0, 2, 4 }));
+    }
+
+    [Test]
+    public void Shift_RenumbersTheCurrentMap ()
+    {
+        _tracker.Load(_lines.Count, HideDebug);
+        Idle();
+
+        var shifted = _tracker.Shift(2);
+
+        Assert.That(shifted.LineCount, Is.EqualTo(3));
+        Assert.That(VisibleLines(shifted), Is.EqualTo(new[] { 0, 2 }));
+    }
+
+    [Test]
+    public void Shift_WhileScanPending_RestartsTheScanOnTheNewNumbering ()
+    {
+        _gate.Reset();
+        _tracker.Load(_lines.Count, HideDebug);
+        lock (_lines)
+        {
+            _lines.RemoveRange(0, 2);
+        }
+
+        _ = _tracker.Shift(2);
+        _gate.Set();
+        Idle();
+
+        Assert.That(_tracker.Map.LineCount, Is.EqualTo(3));
+        Assert.That(VisibleLines(_tracker.Map), Is.EqualTo(new[] { 0, 2 }));
+    }
+
+    [Test]
+    public void Replace_ReevaluatesEveryLineOfTheNewContent ()
+    {
+        _tracker.Load(_lines.Count, HideDebug);
+        Idle();
+        lock (_lines)
+        {
+            _lines.Clear();
+            _lines.AddRange(["DEBUG x", "INFO y"]);
+        }
+
+        var replaced = _tracker.Replace(2);
+
+        Assert.That(VisibleLines(replaced), Is.EqualTo(new[] { 1 }));
+    }
+
+    [Test]
+    public void UnreadableLine_StaysVisible ()
+    {
+        _tracker.Load(7, HideDebug);
+        Idle();
+
+        Assert.That(_tracker.Map.LineCount, Is.EqualTo(7));
+        Assert.That(VisibleLines(_tracker.Map), Is.EqualTo(new[] { 0, 2, 4, 5, 6 }));
+    }
+
+    [Test]
+    public void ScanFailure_PublishesAllVisible_AndReportsTheError ()
+    {
+        LineVisibilityChangedEventArgs? reported = null;
+        using var tracker = new LineVisibilityTracker(i => i == 3 ? throw new InvalidOperationException("boom") : new LogLine("DEBUG", i));
+        tracker.Changed += (_, e) => reported = e;
+
+        tracker.Load(5, HideDebug);
+        Assert.That(tracker.WhenIdle().Wait(Timeout), Is.True);
+
+        Assert.That(tracker.Map.HiddenCount, Is.Zero);
+        Assert.That(tracker.Map.VisibleCount, Is.EqualTo(5));
+        Assert.That(reported?.Error, Is.InstanceOf<InvalidOperationException>());
+    }
+
+    [Test]
+    public void TailFailure_FallsBackToAllVisible ()
+    {
+        var fail = false;
+        using var tracker = new LineVisibilityTracker(i => fail ? throw new InvalidOperationException("boom") : new LogLine(i % 2 == 0 ? "DEBUG" : "INFO", i));
+        tracker.Load(4, HideDebug);
+        Assert.That(tracker.WhenIdle().Wait(Timeout), Is.True);
+        fail = true;
+
+        var map = tracker.Extend(6);
+
+        Assert.That(map.LineCount, Is.EqualTo(6));
+        Assert.That(map.HiddenCount, Is.Zero);
+    }
+
+    [Test]
+    public void Dispose_CancelsAPendingScan_WithoutPublishing ()
+    {
+        _gate.Reset();
+        _tracker.Load(_lines.Count, HideDebug);
+
+        _tracker.Dispose();
+        _gate.Set();
+
+        Assert.That(_tracker.WhenIdle().Wait(Timeout), Is.True);
+        Assert.That(_changedCount, Is.Zero);
+    }
+}

From 6c62deb513173073f588b55533632c4b0fa81f73 Mon Sep 17 00:00:00 2001
From: Hirogen <hirogenat@gmail.com>
Date: Sat, 26 Sep 2026 18:53:45 +0200
Subject: [PATCH 02/11] Hide matching lines in the Log Window main grid (#338)

The main grid now displays the rows of a LineVisibilityMap; reader,
bookmark, timestamp, search, session and row-height code keeps using
original logical lines. Explicit navigation to a hidden line turns on
the per-window 'Show hidden lines' override; tail follow tracks the last
visible row. A notice bar shows the hidden-line count and the override,
and the Highlight Entry dialog gets a 'Hide line' checkbox.
---
 src/LogExpert.Resources/Resources.Designer.cs |  80 +++-
 src/LogExpert.Resources/Resources.de.resx     |  12 +
 src/LogExpert.Resources/Resources.resx        |  12 +
 src/LogExpert.Resources/Resources.zh-CN.resx  |  12 +
 .../HighlightEntryDialogHideLineTests.cs      |  40 ++
 .../HiddenLinesWindowTests.cs                 | 443 ++++++++++++++++++
 .../Controls/LogWindow/ColumnCache.cs         |  87 +++-
 .../LogWindow/LogWindow.LineVisibility.cs     | 312 ++++++++++++
 .../Controls/LogWindow/LogWindow.cs           | 361 +++++++-------
 .../HighlightEntryDialog.Designer.cs          |  13 +
 .../Dialogs/Highlight/HighlightEntryDialog.cs |   3 +
 .../Interface/ILogPaintContextUI.cs           |   2 +-
 12 files changed, 1187 insertions(+), 190 deletions(-)
 create mode 100644 src/LogExpert.UI.Tests/Dialogs/HighlightEntryDialogHideLineTests.cs
 create mode 100644 src/LogExpert.UI.Tests/HiddenLinesWindowTests.cs
 create mode 100644 src/LogExpert.UI/Controls/LogWindow/LogWindow.LineVisibility.cs

diff --git a/src/LogExpert.Resources/Resources.Designer.cs b/src/LogExpert.Resources/Resources.Designer.cs
index a97e02a2..af6c275f 100644
--- a/src/LogExpert.Resources/Resources.Designer.cs
+++ b/src/LogExpert.Resources/Resources.Designer.cs
@@ -416,7 +416,7 @@ public static string Columnizer_SnapshotUnavailable {
                 return ResourceManager.GetString("Columnizer_SnapshotUnavailable", resourceCulture);
             }
         }
-
+        
         /// <summary>
         ///   Looks up a localized string similar to Timestamp selector.
         /// </summary>
@@ -1126,6 +1126,15 @@ public static string HighlightDialog_UI_CheckBox_DontDirtyLed {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Hide line.
+        /// </summary>
+        public static string HighlightDialog_UI_CheckBox_HideLine {
+            get {
+                return ResourceManager.GetString("HighlightDialog_UI_CheckBox_HideLine", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to No Background.
         /// </summary>
@@ -3267,6 +3276,15 @@ public static string LogWindow_UI_CheckBox_RangeSearch {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Show hidden lines.
+        /// </summary>
+        public static string LogWindow_UI_CheckBox_ShowHiddenLines {
+            get {
+                return ResourceManager.GetString("LogWindow_UI_CheckBox_ShowHiddenLines", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Hides the filter list after loading a filter.
         /// </summary>
@@ -3521,6 +3539,15 @@ public static string LogWindow_UI_Label_Fuzzyness {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to {0:N0} lines hidden by highlight rules.
+        /// </summary>
+        public static string LogWindow_UI_Label_HiddenLines {
+            get {
+                return ResourceManager.GetString("LogWindow_UI_Label_HiddenLines", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Text &amp;filter:.
         /// </summary>
@@ -3576,6 +3603,15 @@ public static string LogWindow_UI_StatusLineError_FilterFailed {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Hide rules could not be applied, all lines are shown: {0}.
+        /// </summary>
+        public static string LogWindow_UI_StatusLineError_HideRulesFailed {
+            get {
+                return ResourceManager.GetString("LogWindow_UI_StatusLineError_HideRulesFailed", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Invalid regular expression.
         /// </summary>
@@ -4163,7 +4199,7 @@ public static string MarkerBar_Bookmarks {
                 return ResourceManager.GetString("MarkerBar_Bookmarks", resourceCulture);
             }
         }
-
+        
         /// <summary>
         ///   Looks up a localized string similar to Clear search.
         /// </summary>
@@ -4172,7 +4208,7 @@ public static string MarkerBar_ClearSearch {
                 return ResourceManager.GetString("MarkerBar_ClearSearch", resourceCulture);
             }
         }
-
+        
         /// <summary>
         ///   Looks up a localized string similar to Discovering markers….
         /// </summary>
@@ -4181,7 +4217,7 @@ public static string MarkerBar_Discovering {
                 return ResourceManager.GetString("MarkerBar_Discovering", resourceCulture);
             }
         }
-
+        
         /// <summary>
         ///   Looks up a localized string similar to Filter hits.
         /// </summary>
@@ -4190,7 +4226,7 @@ public static string MarkerBar_FilterHits {
                 return ResourceManager.GetString("MarkerBar_FilterHits", resourceCulture);
             }
         }
-
+        
         /// <summary>
         ///   Looks up a localized string similar to Highlights.
         /// </summary>
@@ -4199,7 +4235,7 @@ public static string MarkerBar_Highlights {
                 return ResourceManager.GetString("MarkerBar_Highlights", resourceCulture);
             }
         }
-
+        
         /// <summary>
         ///   Looks up a localized string similar to Could not read log line {0} while discovering markers..
         /// </summary>
@@ -4208,7 +4244,7 @@ public static string MarkerBar_LineUnavailable {
                 return ResourceManager.GetString("MarkerBar_LineUnavailable", resourceCulture);
             }
         }
-
+        
         /// <summary>
         ///   Looks up a localized string similar to Marker discovery failed: {0}.
         /// </summary>
@@ -4217,7 +4253,7 @@ public static string MarkerBar_ScanFailed {
                 return ResourceManager.GetString("MarkerBar_ScanFailed", resourceCulture);
             }
         }
-
+        
         /// <summary>
         ///   Looks up a localized string similar to Search hits.
         /// </summary>
@@ -4226,7 +4262,7 @@ public static string MarkerBar_SearchHits {
                 return ResourceManager.GetString("MarkerBar_SearchHits", resourceCulture);
             }
         }
-
+        
         /// <summary>
         ///   Looks up a localized string similar to Marker bar.
         /// </summary>
@@ -4235,7 +4271,7 @@ public static string MarkerBar_Title {
                 return ResourceManager.GetString("MarkerBar_Title", resourceCulture);
             }
         }
-
+        
         /// <summary>
         ///   Looks up a localized string similar to {0}: lines {1}–{2}, {3} matching lines.
         /// </summary>
@@ -4244,7 +4280,7 @@ public static string MarkerBar_ToolTip {
                 return ResourceManager.GetString("MarkerBar_ToolTip", resourceCulture);
             }
         }
-
+        
         /// <summary>
         ///   Looks up a localized string similar to Close existing tabs.
         /// </summary>
@@ -4411,12 +4447,16 @@ public static string MultiFileMaskDialog_UI_Label_SettingsFor {
         ///   Looks up a localized string similar to Pattern syntax:
         ///
         ///* = any characters (wildcard)
-        ///$D(&amp;lt;date&amp;gt;) = Date pattern
+        ///$D(&lt;date&gt;) = Date pattern
         ///$I = File index number
         ///$J = File index number, hidden when zero
-        ///$J(&amp;lt;prefix&amp;gt;) = Like $J, but adding &amp;lt;prefix&amp;gt; when non-zero
+        ///$J(&lt;prefix&gt;) = Like $J, but adding &lt;prefix&gt; when non-zero
+        ///
+        ///Examples:
+        ///*$J(.) → app.log, app.log.1, app.log.2
+        ///*$J(.).log → app.log, app.1.log, app.2.log
         ///
-        ///&amp;lt;date&amp;gt;:
+        ///&lt;date&gt;:
         ///DD = day
         ///MM = month
         ///YY[YY] = year
@@ -5588,7 +5628,7 @@ public static string SettingsDialog_UI_CheckBox_checkBoxShowBookmarkMarkers {
                 return ResourceManager.GetString("SettingsDialog_UI_CheckBox_checkBoxShowBookmarkMarkers", resourceCulture);
             }
         }
-
+        
         /// <summary>
         ///   Looks up a localized string similar to Show Error Message?.
         /// </summary>
@@ -5606,7 +5646,7 @@ public static string SettingsDialog_UI_CheckBox_checkBoxShowFilterMarkers {
                 return ResourceManager.GetString("SettingsDialog_UI_CheckBox_checkBoxShowFilterMarkers", resourceCulture);
             }
         }
-
+        
         /// <summary>
         ///   Looks up a localized string similar to Show highlight markers.
         /// </summary>
@@ -5615,7 +5655,7 @@ public static string SettingsDialog_UI_CheckBox_checkBoxShowHighlightMarkers {
                 return ResourceManager.GetString("SettingsDialog_UI_CheckBox_checkBoxShowHighlightMarkers", resourceCulture);
             }
         }
-
+        
         /// <summary>
         ///   Looks up a localized string similar to Show marker bar.
         /// </summary>
@@ -5624,7 +5664,7 @@ public static string SettingsDialog_UI_CheckBox_checkBoxShowMarkerBar {
                 return ResourceManager.GetString("SettingsDialog_UI_CheckBox_checkBoxShowMarkerBar", resourceCulture);
             }
         }
-
+        
         /// <summary>
         ///   Looks up a localized string similar to Show search markers.
         /// </summary>
@@ -5633,7 +5673,7 @@ public static string SettingsDialog_UI_CheckBox_checkBoxShowSearchMarkers {
                 return ResourceManager.GetString("SettingsDialog_UI_CheckBox_checkBoxShowSearchMarkers", resourceCulture);
             }
         }
-
+        
         /// <summary>
         ///   Looks up a localized string similar to Allow only 1 Instance.
         /// </summary>
@@ -6552,7 +6592,7 @@ public static string SettingsDialog_UI_TabPage_tabPageMarkerBar {
                 return ResourceManager.GetString("SettingsDialog_UI_TabPage_tabPageMarkerBar", resourceCulture);
             }
         }
-
+        
         /// <summary>
         ///   Looks up a localized string similar to Memory/CPU.
         /// </summary>
diff --git a/src/LogExpert.Resources/Resources.de.resx b/src/LogExpert.Resources/Resources.de.resx
index e203113f..acf8879f 100644
--- a/src/LogExpert.Resources/Resources.de.resx
+++ b/src/LogExpert.Resources/Resources.de.resx
@@ -2352,4 +2352,16 @@ LogExpert neu starten, um die Änderungen zu übernehmen?</value>
   <data name="MarkerBar_Title" xml:space="preserve">
     <value>Markierungsleiste</value>
   </data>
+  <data name="HighlightDialog_UI_CheckBox_HideLine" xml:space="preserve">
+    <value>Zeile ausblenden</value>
+  </data>
+  <data name="LogWindow_UI_Label_HiddenLines" xml:space="preserve">
+    <value>{0:N0} Zeilen durch Hervorhebungsregeln ausgeblendet</value>
+  </data>
+  <data name="LogWindow_UI_CheckBox_ShowHiddenLines" xml:space="preserve">
+    <value>Ausgeblendete Zeilen anzeigen</value>
+  </data>
+  <data name="LogWindow_UI_StatusLineError_HideRulesFailed" xml:space="preserve">
+    <value>Ausblendregeln konnten nicht angewendet werden, alle Zeilen werden angezeigt: {0}</value>
+  </data>
 </root>
diff --git a/src/LogExpert.Resources/Resources.resx b/src/LogExpert.Resources/Resources.resx
index 6521310d..10f5d9a9 100644
--- a/src/LogExpert.Resources/Resources.resx
+++ b/src/LogExpert.Resources/Resources.resx
@@ -2368,4 +2368,16 @@ Restart LogExpert to apply changes?</value>
   <data name="MarkerBar_ToolTip" xml:space="preserve"><value>{0}: lines {1}–{2}, {3} matching lines</value></data>
   <data name="MarkerBar_ScanFailed" xml:space="preserve"><value>Marker discovery failed: {0}</value></data>
   <data name="MarkerBar_Title" xml:space="preserve"><value>Marker bar</value></data>
+  <data name="HighlightDialog_UI_CheckBox_HideLine" xml:space="preserve">
+    <value>Hide line</value>
+  </data>
+  <data name="LogWindow_UI_Label_HiddenLines" xml:space="preserve">
+    <value>{0:N0} lines hidden by highlight rules</value>
+  </data>
+  <data name="LogWindow_UI_CheckBox_ShowHiddenLines" xml:space="preserve">
+    <value>Show hidden lines</value>
+  </data>
+  <data name="LogWindow_UI_StatusLineError_HideRulesFailed" xml:space="preserve">
+    <value>Hide rules could not be applied, all lines are shown: {0}</value>
+  </data>
 </root>
diff --git a/src/LogExpert.Resources/Resources.zh-CN.resx b/src/LogExpert.Resources/Resources.zh-CN.resx
index c94a9515..d8127cc8 100644
--- a/src/LogExpert.Resources/Resources.zh-CN.resx
+++ b/src/LogExpert.Resources/Resources.zh-CN.resx
@@ -2246,4 +2246,16 @@ YY[YY] = 年
   <data name="MarkerBar_Title" xml:space="preserve">
     <value>标记栏</value>
   </data>
+  <data name="HighlightDialog_UI_CheckBox_HideLine" xml:space="preserve">
+    <value>隐藏行</value>
+  </data>
+  <data name="LogWindow_UI_Label_HiddenLines" xml:space="preserve">
+    <value>{0:N0} 行已被高亮规则隐藏</value>
+  </data>
+  <data name="LogWindow_UI_CheckBox_ShowHiddenLines" xml:space="preserve">
+    <value>显示隐藏的行</value>
+  </data>
+  <data name="LogWindow_UI_StatusLineError_HideRulesFailed" xml:space="preserve">
+    <value>无法应用隐藏规则，显示所有行：{0}</value>
+  </data>
 </root>
\ No newline at end of file
diff --git a/src/LogExpert.UI.Tests/Dialogs/HighlightEntryDialogHideLineTests.cs b/src/LogExpert.UI.Tests/Dialogs/HighlightEntryDialogHideLineTests.cs
new file mode 100644
index 00000000..c146c31f
--- /dev/null
+++ b/src/LogExpert.UI.Tests/Dialogs/HighlightEntryDialogHideLineTests.cs
@@ -0,0 +1,40 @@
+using System.Reflection;
+
+using LogExpert.Core.Classes.Highlight;
+using LogExpert.UI.Dialogs.Highlight;
+
+using NUnit.Framework;
+
+namespace LogExpert.UI.Tests.Dialogs;
+
+[TestFixture]
+[Apartment(ApartmentState.STA)]
+public class HighlightEntryDialogHideLineTests
+{
+    [TestCase(true)]
+    [TestCase(false)]
+    public void Load_ShowsTheEntrysHideFlag (bool hidden)
+    {
+        using var dialog = new HighlightEntryDialog(new HighlightEntry { SearchText = "DEBUG", IsHideLine = hidden }, [], false);
+
+        Assert.That(HideCheckBox(dialog).Checked, Is.EqualTo(hidden));
+    }
+
+    [Test]
+    public void Ok_SavesTheHideFlag ()
+    {
+        var entry = new HighlightEntry { SearchText = "DEBUG" };
+        using var dialog = new HighlightEntryDialog(entry, [], false);
+        HideCheckBox(dialog).Checked = true;
+
+        _ = typeof(HighlightEntryDialog).GetMethod("OnOkClick", BindingFlags.Instance | BindingFlags.NonPublic)!
+            .Invoke(dialog, [dialog, EventArgs.Empty]);
+
+        Assert.That(entry.IsHideLine, Is.True);
+    }
+
+    private static CheckBox HideCheckBox (Form dialog)
+    {
+        return (CheckBox)dialog.Controls.Find("_checkBoxHideLine", true).Single();
+    }
+}
diff --git a/src/LogExpert.UI.Tests/HiddenLinesWindowTests.cs b/src/LogExpert.UI.Tests/HiddenLinesWindowTests.cs
new file mode 100644
index 00000000..dcd371d9
--- /dev/null
+++ b/src/LogExpert.UI.Tests/HiddenLinesWindowTests.cs
@@ -0,0 +1,443 @@
+using System.Diagnostics;
+using System.Runtime.ExceptionServices;
+using System.Runtime.Versioning;
+
+using ColumnizerLib;
+
+using LogExpert.Core.Classes.Highlight;
+using LogExpert.Core.Config;
+using LogExpert.Core.Entities;
+using LogExpert.Core.Interfaces;
+using LogExpert.UI.Controls.LogTabWindow;
+using LogExpert.UI.Controls.LogWindow;
+
+using Moq;
+
+using NUnit.Framework;
+
+namespace LogExpert.UI.Tests;
+
+/// <summary>Hide-line highlight rules (#338) in a real Log Window: odd lines are "DEBUG" and hidden.</summary>
+[TestFixture]
+[Apartment(ApartmentState.STA)]
+[NonParallelizable]
+[SupportedOSPlatform("windows")]
+public sealed class HiddenLinesWindowTests : IDisposable
+{
+    private const int LINE_COUNT = 20;
+
+    private string _directory = null!;
+    private string _fileName = null!;
+    private Settings _settings = null!;
+    private Mock<IConfigManager> _config = null!;
+    private LogTabWindow? _window;
+    private Exception? _uiException;
+
+    private HighlightEntry HideRule => _settings.Preferences.HighlightGroupList[0].HighlightEntryList[0];
+
+    [SetUp]
+    public void SetUp ()
+    {
+        _uiException = null;
+        _directory = Path.Join(Path.GetTempPath(), "LogExpertHiddenLinesTests", Guid.NewGuid().ToString("N"));
+        _ = Directory.CreateDirectory(_directory);
+        _fileName = Path.Join(_directory, "hidden.log");
+        File.WriteAllLines(_fileName, Enumerable.Range(0, LINE_COUNT).Select(Text));
+        _settings = new Settings();
+        _settings.Preferences.MultiFileOptions = new MultiFileOptions();
+        _settings.Preferences.FollowTail = false;
+        _settings.Preferences.AskForClose = false;
+        _settings.Preferences.AutoPick = false;
+        _settings.Preferences.OpenLastFiles = false;
+        _settings.Preferences.SaveSessions = false;
+        _settings.Preferences.SaveLocation = SessionSaveLocation.SameDir;
+        _settings.Preferences.HighlightGroupList = [new HighlightGroup
+        {
+            GroupName = "hide",
+            HighlightEntryList =
+            [
+                new HighlightEntry { SearchText = "DEBUG", IsHideLine = true },
+                new HighlightEntry { SearchText = "INFO", BackgroundColor = Color.LightGreen }
+            ]
+        }];
+        _config = new Mock<IConfigManager>();
+        _ = _config.Setup(config => config.Settings).Returns(_settings);
+        _ = _config.Setup(config => config.ActiveConfigDir).Returns(_directory);
+        _ = _config.Setup(config => config.ActiveSessionDir).Returns(_directory);
+        _ = PluginRegistry.PluginRegistry.Create(_directory, 50);
+        Application.ThreadException += OnUiException;
+    }
+
+    [TearDown]
+    public void TearDown ()
+    {
+        _settings.Preferences.SaveSessions = false;
+        try
+        {
+            if (_window != null)
+            {
+                _window.LogExpertProxy = null;
+                _window.Close();
+                _window.Dispose();
+                _window = null;
+            }
+        }
+        finally
+        {
+            Application.ThreadException -= OnUiException;
+        }
+
+        Directory.Delete(_directory, true);
+    }
+
+    public void Dispose ()
+    {
+        _window?.Dispose();
+    }
+
+    private static string Text (int line) => line % 2 == 1 ? $"DEBUG {line}" : $"INFO {line}";
+
+    [Test]
+    public void Load_HideRule_RemovesMatchingRows_AndKeepsOriginalLineNumbers ()
+    {
+        var log = Open();
+        var grid = Grid(log);
+
+        Assert.That(grid.RowCount, Is.EqualTo(LINE_COUNT / 2));
+        Assert.That(DisplayedLineNumber(grid, 0), Is.EqualTo("1"));
+        Assert.That(DisplayedLineNumber(grid, 1), Is.EqualTo("3"));
+        Assert.That(log.HiddenLineCount, Is.EqualTo(LINE_COUNT / 2));
+        Assert.That(Find<Label>(log, "hiddenLinesLabel").Text, Does.Contain("10"));
+        Assert.That(Find<Panel>(log, "hiddenLinesBar").Visible, Is.True);
+    }
+
+    [Test]
+    public void ShowHiddenLines_ShowsEveryLine_WithoutChangingTheRules ()
+    {
+        var log = Open();
+        var grid = Grid(log);
+
+        Find<CheckBox>(log, "showHiddenLinesCheckBox").Checked = true;
+        Assert.That(grid.RowCount, Is.EqualTo(LINE_COUNT));
+        Assert.That(DisplayedLineNumber(grid, 1), Is.EqualTo("2"));
+        Assert.That(HideRule.IsHideLine, Is.True);
+        Assert.That(log.HiddenLineCount, Is.EqualTo(LINE_COUNT / 2));
+
+        Find<CheckBox>(log, "showHiddenLinesCheckBox").Checked = false;
+        Assert.That(grid.RowCount, Is.EqualTo(LINE_COUNT / 2));
+    }
+
+    [Test]
+    public void GotoLine_HiddenTarget_RevealsAndSelectsThatExactLine ()
+    {
+        var log = Open();
+
+        log.GotoLine(5);
+
+        Assert.That(log.ShowHiddenLines, Is.True);
+        Assert.That(log.CurrentLineNum, Is.EqualTo(5));
+        Assert.That(Find<CheckBox>(log, "showHiddenLinesCheckBox").Checked, Is.True);
+    }
+
+    [Test]
+    public void GotoLine_VisibleTarget_KeepsLinesHidden ()
+    {
+        var log = Open();
+
+        log.GotoLine(6);
+
+        Assert.That(log.ShowHiddenLines, Is.False);
+        Assert.That(log.CurrentLineNum, Is.EqualTo(6));
+        Assert.That(Grid(log).CurrentCellAddress.Y, Is.EqualTo(3));
+    }
+
+    [Test]
+    public void TurningTheOverrideOff_WhileOnAHiddenLine_SelectsTheNextVisibleLine ()
+    {
+        var log = Open();
+        log.GotoLine(5);
+
+        log.ShowHiddenLines = false;
+
+        Assert.That(log.CurrentLineNum, Is.EqualTo(6));
+    }
+
+    [Test]
+    public void RuleChange_SelectedLineStaysVisible_KeepsItsSelection ()
+    {
+        var log = Open();
+        log.GotoLine(8);
+
+        HideRule.SearchText = "INFO 4";
+        log.SetCurrentHighlightGroup("hide");
+        WaitForVisibility(log);
+
+        Assert.That(Grid(log).RowCount, Is.EqualTo(LINE_COUNT - 1));
+        Assert.That(log.CurrentLineNum, Is.EqualTo(8));
+    }
+
+    [Test]
+    public void RuleChange_SelectedLineBecomesHidden_SelectsTheNextVisibleLine ()
+    {
+        var log = Open();
+        log.GotoLine(4);
+
+        HideRule.SearchText = "INFO 4";
+        log.SetCurrentHighlightGroup("hide");
+        WaitForVisibility(log);
+
+        Assert.That(log.CurrentLineNum, Is.EqualTo(5));
+    }
+
+    [Test]
+    public void RuleChange_LastLineBecomesHidden_SelectsThePreviousVisibleLine ()
+    {
+        var log = Open();
+        log.GotoLine(18);
+
+        HideRule.SearchText = "8";
+        log.SetCurrentHighlightGroup("hide");
+        WaitForVisibility(log);
+
+        Assert.That(log.CurrentLineNum, Is.EqualTo(19));
+        HideRule.SearchText = "9";
+        log.SetCurrentHighlightGroup("hide");
+        WaitForVisibility(log);
+
+        Assert.That(log.CurrentLineNum, Is.EqualTo(18));
+    }
+
+    [Test]
+    public void RemovingTheHideFlag_ShowsEveryLine_AndHidesTheNoticeBar ()
+    {
+        var log = Open();
+
+        HideRule.IsHideLine = false;
+        log.SetCurrentHighlightGroup("hide");
+        WaitForVisibility(log);
+
+        Assert.That(Grid(log).RowCount, Is.EqualTo(LINE_COUNT));
+        Assert.That(Find<Panel>(log, "hiddenLinesBar").Visible, Is.False);
+    }
+
+    [Test]
+    public void AllLinesHidden_LeavesAnEmptySelection_AndNavigationStillReveals ()
+    {
+        var log = Open();
+
+        HideRule.SearchText = " ";
+        log.SetCurrentHighlightGroup("hide");
+        WaitForVisibility(log);
+
+        Assert.That(Grid(log).RowCount, Is.Zero);
+        Assert.That(log.CurrentLineNum, Is.EqualTo(-1));
+        Assert.That(log.HiddenLineCount, Is.EqualTo(LINE_COUNT));
+
+        log.GotoLine(3);
+        Assert.That(log.CurrentLineNum, Is.EqualTo(3));
+    }
+
+    [Test]
+    public void FollowTail_TracksTheLastVisibleLine_WithoutRevealingAppendedHiddenLines ()
+    {
+        var log = Open();
+        var grid = Grid(log);
+        log.FollowTailChanged(true, false);
+
+        File.AppendAllLines(_fileName, [Text(20), Text(21), Text(22), Text(23)]);
+        PumpUntil(() => log.GatherSessionSnapshot().LineCount == 24);
+        PumpUntil(() => grid.RowCount == 12);
+
+        Assert.That(log.ShowHiddenLines, Is.False);
+        Assert.That(DisplayedLineNumber(grid, 11), Is.EqualTo("23"));
+        Assert.That(grid.FirstDisplayedScrollingRowIndex + grid.DisplayedRowCount(false), Is.GreaterThanOrEqualTo(grid.RowCount));
+    }
+
+    [Test]
+    public void CopySelectedRows_CopiesOnlyTheSelectedVisibleLines ()
+    {
+        var log = Open();
+        var grid = Grid(log);
+        grid.ClearSelection();
+        grid.Rows[0].Selected = true;
+        grid.Rows[1].Selected = true;
+        Clipboard.Clear();
+
+        _ = typeof(LogWindow).GetMethod("CopyMarkedLinesToClipboard", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic)!.Invoke(log, null);
+
+        var text = Clipboard.GetText();
+        Assert.That(text, Does.Contain("INFO 0"));
+        Assert.That(text, Does.Contain("INFO 2"));
+        Assert.That(text, Does.Not.Contain("DEBUG 1"));
+    }
+
+    [Test]
+    public void SessionSnapshot_StoresOriginalLines ()
+    {
+        var log = Open();
+
+        log.GotoLine(12);
+        var snapshot = log.GatherSessionSnapshot();
+
+        Assert.That(snapshot.CurrentLine, Is.EqualTo(12));
+        Assert.That(snapshot.FirstDisplayedLine, Is.GreaterThanOrEqualTo(0).And.LessThanOrEqualTo(12));
+        Assert.That(snapshot.FirstDisplayedLine % 2, Is.Zero, "first displayed line must be a visible original line");
+    }
+
+    [Test]
+    public void LogSearch_HitOnHiddenLine_RevealsIt ()
+    {
+        var log = Open();
+
+        _window!.SearchParams.SearchText = "DEBUG 7";
+        _window.SearchParams.IsFindNext = false;
+        log.StartSearch();
+        PumpUntil(() => log.CurrentLineNum == 7);
+
+        Assert.That(log.ShowHiddenLines, Is.True);
+    }
+
+    [Test]
+    public void ToggleBookmark_BookmarksTheOriginalLineOfTheCurrentRow ()
+    {
+        var log = Open();
+        log.GotoLine(8);
+
+        log.ToggleBookmark();
+
+        Assert.That(log.BookmarkData.IsBookmarkAtLine(8), Is.True);
+        Assert.That(log.BookmarkData.IsBookmarkAtLine(4), Is.False);
+    }
+
+    [Test]
+    public void JumpNextBookmark_ToHiddenLine_RevealsIt ()
+    {
+        var log = Open();
+        log.ToggleBookmark(9);
+        log.GotoLine(2);
+
+        log.JumpNextBookmark();
+
+        Assert.That(log.CurrentLineNum, Is.EqualTo(9));
+        Assert.That(log.ShowHiddenLines, Is.True);
+    }
+
+    [Test]
+    public void WindowFilter_StillFindsHiddenLines ()
+    {
+        var log = Open();
+        if (!Find<Button>(log, "filterSearchButton").Visible)
+        {
+            log.ToggleFilterPanel();
+        }
+
+        PumpUntil(() => Find<Button>(log, "filterSearchButton").Visible && Find<Button>(log, "filterSearchButton").Enabled);
+        Find<ComboBox>(log, "filterComboBox").Text = "DEBUG";
+        Find<Button>(log, "filterSearchButton").PerformClick();
+
+        var filterGrid = Find<DataGridView>(log, "filterGridView");
+        PumpUntil(() => filterGrid.RowCount == LINE_COUNT / 2);
+        Assert.That(Grid(log).RowCount, Is.EqualTo(LINE_COUNT / 2));
+    }
+
+    [Test]
+    public void CommandLineTarget_OnHiddenLine_RevealsItAfterVisibilityInitialization ()
+    {
+        _window = new LogTabWindow([_fileName], 1, false, _config.Object, 8) { ShowInTaskbar = false, Opacity = 0 };
+        Find<WeifenLuo.WinFormsUI.Docking.DockPanel>(_window, "dockPanel").ShowDocumentIcon = false;
+        _window.Show();
+        PumpUntil(() => _window.CurrentLogWindow != null);
+        var log = _window.CurrentLogWindow;
+
+        PumpUntil(() => log.CurrentLineNum == 7);
+
+        Assert.That(log.ShowHiddenLines, Is.True);
+        Assert.That(log.GatherSessionSnapshot().FollowTail, Is.False);
+    }
+
+    [Test]
+    public void CommandLineTarget_OnVisibleLine_KeepsLinesHidden ()
+    {
+        _window = new LogTabWindow([_fileName], 1, false, _config.Object, 7) { ShowInTaskbar = false, Opacity = 0 };
+        Find<WeifenLuo.WinFormsUI.Docking.DockPanel>(_window, "dockPanel").ShowDocumentIcon = false;
+        _window.Show();
+        PumpUntil(() => _window.CurrentLogWindow != null);
+        var log = _window.CurrentLogWindow;
+
+        PumpUntil(() => log.CurrentLineNum == 6);
+        PumpUntil(() => Grid(log).RowCount == LINE_COUNT / 2);
+
+        Assert.That(log.ShowHiddenLines, Is.False);
+        Assert.That(log.CurrentLineNum, Is.EqualTo(6));
+    }
+
+    private LogWindow Open ()
+    {
+        _window = new LogTabWindow([_fileName], 1, false, _config.Object) { ShowInTaskbar = false, Opacity = 0 };
+        Find<WeifenLuo.WinFormsUI.Docking.DockPanel>(_window, "dockPanel").ShowDocumentIcon = false;
+        _window.Show();
+        PumpUntil(() => _window.CurrentLogWindow != null);
+        var log = _window.CurrentLogWindow;
+        var loaded = Task.Run(log.WaitForLoadingFinished);
+        PumpUntil(() => loaded.IsCompleted);
+        loaded.GetAwaiter().GetResult();
+        log.SetCurrentHighlightGroup("hide");
+        WaitForVisibility(log);
+        return log;
+    }
+
+    private void WaitForVisibility (LogWindow log)
+    {
+        var idle = log.WhenLineVisibilityIdle();
+        PumpUntil(() => idle.IsCompleted);
+        PumpFor(TimeSpan.FromMilliseconds(50));
+    }
+
+    private static DataGridView Grid (LogWindow log) => Find<DataGridView>(log, "dataGridView");
+
+    private static string DisplayedLineNumber (DataGridView grid, int row)
+    {
+        return ((IColumnMemory)grid.Rows[row].Cells[1].Value).FullValue.ToString();
+    }
+
+    private static TControl Find<TControl> (Control parent, string name) where TControl : Control
+    {
+        return (TControl)parent.Controls.Find(name, true).Single();
+    }
+
+    private void OnUiException (object sender, ThreadExceptionEventArgs eventArgs)
+    {
+        _uiException = eventArgs.Exception;
+    }
+
+    private void PumpOnce ()
+    {
+        Application.DoEvents();
+        if (_uiException != null)
+        {
+            ExceptionDispatchInfo.Throw(_uiException);
+        }
+    }
+
+    private void PumpFor (TimeSpan duration)
+    {
+        var timer = Stopwatch.StartNew();
+        while (timer.Elapsed < duration)
+        {
+            PumpOnce();
+            Thread.Sleep(1);
+        }
+    }
+
+    private void PumpUntil (Func<bool> condition)
+    {
+        var timer = Stopwatch.StartNew();
+        while (!condition() && timer.Elapsed < TimeSpan.FromSeconds(30))
+        {
+            PumpOnce();
+            Thread.Sleep(1);
+        }
+
+        Assert.That(condition(), Is.True, "Timed out waiting for the Log Window.");
+    }
+}
diff --git a/src/LogExpert.UI/Controls/LogWindow/ColumnCache.cs b/src/LogExpert.UI/Controls/LogWindow/ColumnCache.cs
index dea6b609..44b11da5 100644
--- a/src/LogExpert.UI/Controls/LogWindow/ColumnCache.cs
+++ b/src/LogExpert.UI/Controls/LogWindow/ColumnCache.cs
@@ -20,6 +20,11 @@ internal class ColumnCache
     private int _prefetchCount;
     private PinHandle? _pinHandle;
 
+    // Sparse prefetch state (PrefetchLines)
+    private Dictionary<int, ILogLineMemory>? _sparseLines;
+    private int[] _sparseKey = [];
+    private List<PinHandle> _sparsePinHandles = [];
+
     #endregion
 
     #region Internals
@@ -48,14 +53,70 @@ internal void Prefetch (ILogfileReader logFileReader, int startLine, int count)
         var newLines = logFileReader.GetLogLineMemories(startLine, count);
 
         //Atomic swap: old handle released AFTER new is in place
+        var oldHandles = _sparsePinHandles;
         var oldHandle = _pinHandle;
         _pinHandle = newHandle;
+        _sparsePinHandles = [];
+        _sparseLines = null;
         _prefetchedLines = newLines;
         _prefetchStartLine = startLine;
         _prefetchCount = newLines.Length;
 
         // Now safe to release old pins — new pins cover the new visible range
         oldHandle?.Dispose();
+        DisposeAll(oldHandles);
+    }
+
+    /// <summary>
+    /// Prefetch the given ascending, possibly non-contiguous lines (visible rows when hide-line rules skip lines).
+    /// Each contiguous run is pinned before it is read, like <see cref="Prefetch"/>, so only buffers holding
+    /// displayed lines are pinned.
+    /// </summary>
+    internal void PrefetchLines (ILogfileReader logFileReader, int[] lines)
+    {
+        if (_sparseLines != null && _prefetchStartLine == -1 && _sparseKey.AsSpan().SequenceEqual(lines))
+        {
+            return; // already prefetched these exact lines
+        }
+
+        List<PinHandle> newHandles = [];
+        Dictionary<int, ILogLineMemory> newLines = new(lines.Length);
+        var runStart = 0;
+        for (var i = 1; i <= lines.Length; i++)
+        {
+            if (i < lines.Length && lines[i] == lines[i - 1] + 1)
+            {
+                continue;
+            }
+
+            var first = lines[runStart];
+            var count = lines[i - 1] - first + 1;
+            if (logFileReader is IBufferPinning pinning)
+            {
+                newHandles.Add(pinning.PinRange(first, first + count - 1));
+            }
+
+            var runLines = logFileReader.GetLogLineMemories(first, count);
+            for (var j = 0; j < runLines.Length; j++)
+            {
+                newLines[first + j] = runLines[j];
+            }
+
+            runStart = i;
+        }
+
+        var oldHandle = _pinHandle;
+        var oldHandles = _sparsePinHandles;
+        _pinHandle = null;
+        _sparsePinHandles = newHandles;
+        _sparseLines = newLines;
+        _sparseKey = lines;
+        _prefetchedLines = null;
+        _prefetchStartLine = -1;
+        _prefetchCount = 0;
+
+        oldHandle?.Dispose();
+        DisposeAll(oldHandles);
     }
 
     /// <summary>
@@ -64,6 +125,11 @@ internal void Prefetch (ILogfileReader logFileReader, int startLine, int count)
     /// </summary>
     internal ILogLineMemory? GetPrefetchedLine (int lineNumber)
     {
+        if (_sparseLines != null)
+        {
+            return _sparseLines.GetValueOrDefault(lineNumber);
+        }
+
         return _prefetchedLines != null
             && lineNumber >= _prefetchStartLine
             && lineNumber < _prefetchStartLine + _prefetchCount
@@ -71,6 +137,14 @@ internal void Prefetch (ILogfileReader logFileReader, int startLine, int count)
                 : null;
     }
 
+    private static void DisposeAll (List<PinHandle> handles)
+    {
+        foreach (var handle in handles)
+        {
+            handle.Dispose();
+        }
+    }
+
     /// <summary>
     /// Invalidates the prefetch cache. Call on scroll, data change, or columnizer change.
     /// </summary>
@@ -78,6 +152,9 @@ internal void InvalidatePrefetch ()
     {
         _pinHandle?.Dispose();
         _pinHandle = null;
+        DisposeAll(_sparsePinHandles);
+        _sparsePinHandles = [];
+        _sparseLines = null;
 
         _prefetchedLines = null;
         _prefetchStartLine = -1;
@@ -92,6 +169,7 @@ internal void InvalidatePrefetch ()
     /// </summary>
     internal void MarkPrefetchStale ()
     {
+        _sparseLines = null;
         _prefetchStartLine = -1;
         _prefetchCount = 0;
         _lastLineNumber = -1;
@@ -117,14 +195,7 @@ internal IColumnizedLogLineMemory GetColumnsForLine (ILogfileReader logFileReade
             _lastColumnizer = columnizer;
             _lastLineNumber = lineNumber;
 
-            ILogLineMemory line = null;
-
-            if (_prefetchedLines != null
-                && lineNumber >= _prefetchStartLine
-                && lineNumber < _prefetchStartLine + _prefetchCount)
-            {
-                line = _prefetchedLines[lineNumber - _prefetchStartLine];
-            }
+            var line = GetPrefetchedLine(lineNumber);
 
             // Fallback: read directly. This is safe because the caller (CellValueNeeded)
             // has already called Prefetch/PrefetchFilterVisibleLines which pins the relevant
diff --git a/src/LogExpert.UI/Controls/LogWindow/LogWindow.LineVisibility.cs b/src/LogExpert.UI/Controls/LogWindow/LogWindow.LineVisibility.cs
new file mode 100644
index 00000000..345df2d6
--- /dev/null
+++ b/src/LogExpert.UI/Controls/LogWindow/LogWindow.LineVisibility.cs
@@ -0,0 +1,312 @@
+using System.Globalization;
+
+using LogExpert.Core.Classes.Highlight;
+
+namespace LogExpert.UI.Controls.LogWindow;
+
+/// <summary>
+/// Hide-line highlight rules (#338). The main grid shows the rows of <see cref="_rowMap"/>; everything that talks
+/// to the reader, bookmarks, timestamps or sessions uses original logical lines, converted with
+/// <see cref="RowToLine"/> / <see cref="LineToRow"/>. The Window Filter grid is unaffected.
+/// </summary>
+internal partial class LogWindow
+{
+    private const int COLUMN_FINDER_HEIGHT = 28;
+    private const int HIDDEN_LINES_BAR_HEIGHT = 24;
+
+    private readonly Panel _hiddenLinesBar = new() { Name = "hiddenLinesBar", Dock = DockStyle.Top, Visible = false };
+    private readonly Label _hiddenLinesLabel = new() { Name = "hiddenLinesLabel", AutoSize = true, Dock = DockStyle.Left, TextAlign = ContentAlignment.MiddleLeft };
+    private readonly CheckBox _showHiddenLinesCheckBox = new() { Name = "showHiddenLinesCheckBox", AutoSize = true, Dock = DockStyle.Left };
+
+    private LineVisibilityTracker _lineVisibility;
+
+    // Only touched on the UI thread; worker threads read it once into a local.
+    private volatile LineVisibilityMap _rowMap = LineVisibilityMap.Empty;
+    private LineVisibilityMap _appliedTrackedMap = LineVisibilityMap.Empty;
+    private bool _showHiddenLines;
+    private bool _isLoadComplete;
+
+    /// <summary>Number of lines the active hide rules remove, whether or not the override shows them.</summary>
+    internal int HiddenLineCount => _lineVisibility.Map.HiddenCount;
+
+    /// <summary>The per-window "Show hidden lines" override. Transient: not saved in the Session File.</summary>
+    internal bool ShowHiddenLines
+    {
+        get => _showHiddenLines;
+        set
+        {
+            if (_showHiddenLines == value)
+            {
+                return;
+            }
+
+            _showHiddenLines = value;
+            ApplyLineVisibility();
+        }
+    }
+
+    internal Task WhenLineVisibilityIdle ()
+    {
+        return _lineVisibility.WhenIdle();
+    }
+
+    private void InitializeLineVisibility ()
+    {
+        _lineVisibility = new LineVisibilityTracker(line => _logFileReader?.GetLogLineMemory(line));
+        _lineVisibility.Changed += OnLineVisibilityChanged;
+
+        _showHiddenLinesCheckBox.Text = Resources.LogWindow_UI_CheckBox_ShowHiddenLines;
+        _showHiddenLinesCheckBox.CheckedChanged += (_, _) => ShowHiddenLines = _showHiddenLinesCheckBox.Checked;
+        _hiddenLinesBar.Padding = new Padding(4, 0, 4, 0);
+        _hiddenLinesBar.Controls.Add(_showHiddenLinesCheckBox);
+        _hiddenLinesBar.Controls.Add(_hiddenLinesLabel);
+
+        // Row 0 hosts the column finder; the notice bar stacks above it.
+        tableLayoutPanel1.Controls.Remove(columnFinderPanel);
+        var topRow = new Panel { Dock = DockStyle.Fill, Margin = new Padding(0) };
+        columnFinderPanel.Dock = DockStyle.Fill;
+        topRow.Controls.Add(columnFinderPanel);
+        topRow.Controls.Add(_hiddenLinesBar);
+        tableLayoutPanel1.Controls.Add(topRow, 0, 0);
+    }
+
+    /// <summary>The content is gone (loading, dead file): no rows, no scan, until the next load publishes.</summary>
+    private void ResetLineVisibility ()
+    {
+        _isLoadComplete = false;
+        _lineVisibility.Load(0, []);
+        _rowMap = LineVisibilityMap.Empty;
+        _appliedTrackedMap = _lineVisibility.Map;
+        UpdateHiddenLinesBar();
+    }
+
+    private void UpdateTopRowHeight ()
+    {
+        var height = _guiStateArgs.ColumnFinderVisible ? COLUMN_FINDER_HEIGHT : 0;
+        if (_hiddenLinesBar.Visible)
+        {
+            _hiddenLinesBar.Height = LogicalToDeviceUnits(HIDDEN_LINES_BAR_HEIGHT);
+            height += _hiddenLinesBar.Height;
+        }
+
+        columnFinderPanel.Visible = _guiStateArgs.ColumnFinderVisible;
+        tableLayoutPanel1.RowStyles[0].Height = height;
+    }
+
+    private void UpdateHiddenLinesBar ()
+    {
+        var hidden = _lineVisibility.Map.HiddenCount;
+        _hiddenLinesLabel.Text = string.Format(CultureInfo.CurrentCulture, Resources.LogWindow_UI_Label_HiddenLines, hidden);
+        _showHiddenLinesCheckBox.Checked = _showHiddenLines;
+
+        var visible = hidden > 0 || _showHiddenLines;
+        if (_hiddenLinesBar.Visible != visible)
+        {
+            _hiddenLinesBar.Visible = visible;
+            UpdateTopRowHeight();
+        }
+    }
+
+    private List<Core.Classes.Highlight.HighlightEntry> CurrentHighlightEntries ()
+    {
+        lock (_currentHighlightGroupLock)
+        {
+            return [.. _currentHighlightGroup.HighlightEntryList];
+        }
+    }
+
+    private void RebuildLineVisibility ()
+    {
+        if (!_isLoading && _logFileReader != null)
+        {
+            _lineVisibility.Rebuild(CurrentHighlightEntries());
+        }
+    }
+
+    private void OnLineVisibilityChanged (object sender, LineVisibilityChangedEventArgs e)
+    {
+        if (_isClosing || IsDisposed || Disposing)
+        {
+            return;
+        }
+
+        try
+        {
+            // Marshals through a parent's handle when this (background) tab has none yet.
+            _ = BeginInvoke(() =>
+            {
+                if (e.Error != null)
+                {
+                    _logger.Warn(e.Error, "Hide rules failed");
+                    StatusLineError(string.Format(CultureInfo.CurrentCulture, Resources.LogWindow_UI_StatusLineError_HideRulesFailed, e.Error.Message));
+                }
+
+                ApplyLineVisibility();
+            });
+        }
+        catch (InvalidOperationException)
+        {
+            // No handle anywhere up the chain yet: OnHandleCreated applies the current map.
+        }
+    }
+
+    protected override void OnHandleCreated (EventArgs e)
+    {
+        base.OnHandleCreated(e);
+        if (_lineVisibility != null && !ReferenceEquals(_appliedTrackedMap, _lineVisibility.Map))
+        {
+            _ = BeginInvoke(ApplyLineVisibility);
+        }
+    }
+
+    /// <summary>
+    /// The map the grid should display for <paramref name="tracked"/>: the tracked map itself, or, with the
+    /// override on, an identity map that keeps growing in place so tail appends stay appends.
+    /// </summary>
+    private LineVisibilityMap EffectiveMap (LineVisibilityMap tracked)
+    {
+        if (!_showHiddenLines)
+        {
+            return tracked;
+        }
+
+        var current = _rowMap;
+        return current.HiddenCount == 0 && current.LineCount <= tracked.LineCount && tracked.IsAppendOf(_appliedTrackedMap)
+            ? current.Append(tracked.LineCount, [])
+            : LineVisibilityMap.Identity(tracked.LineCount);
+    }
+
+    /// <summary>
+    /// Publishes the tracker's current map to the grid (UI thread). Row count and mapping change together; the
+    /// selected original line is kept, or moved to the next (else previous) visible line.
+    /// </summary>
+    private void ApplyLineVisibility ()
+    {
+        if (_isLoading || _isClosing || _logFileReader == null || IsDisposed)
+        {
+            UpdateHiddenLinesBar();
+            return;
+        }
+
+        var tracked = _lineVisibility.Map;
+        var newMap = EffectiveMap(tracked);
+        _appliedTrackedMap = tracked;
+
+        if (!ReferenceEquals(newMap, _rowMap))
+        {
+            SetRowMap(newMap, 0);
+            if (_guiStateArgs.FollowTail && dataGridView.RowCount > 0)
+            {
+                _columnCache.MarkPrefetchStale();
+                dataGridView.FirstDisplayedScrollingRowIndex = dataGridView.RowCount - 1;
+            }
+
+            dataGridView.Invalidate();
+        }
+
+        UpdateHiddenLinesBar();
+        UpdateLineNavigationReadiness();
+    }
+
+    /// <summary>
+    /// Switches the grid to <paramref name="newMap"/>. An append only grows the row count; any other change
+    /// rebuilds the rows and restores the selection and scroll position by original line, after moving those
+    /// lines up by <paramref name="rolloverOffset"/>.
+    /// </summary>
+    private void SetRowMap (LineVisibilityMap newMap, int rolloverOffset)
+    {
+        var oldMap = _rowMap;
+        if (newMap.IsAppendOf(oldMap) && rolloverOffset == 0)
+        {
+            _rowMap = newMap;
+            dataGridView.RowCount = newMap.VisibleCount;
+            return;
+        }
+
+        var currentLine = oldMap.RowToLine(dataGridView.CurrentCellAddress.Y);
+        var firstLine = oldMap.RowToLine(dataGridView.FirstDisplayedScrollingRowIndex);
+        var hadCurrentLine = currentLine >= 0;
+
+        dataGridView.RowCount = 0;
+        _columnCache.MarkPrefetchStale();
+        _rowMap = newMap;
+        dataGridView.RowCount = newMap.VisibleCount;
+        if (_rowHeightList.Count > 0 && dataGridView.RowCount > 0)
+        {
+            dataGridView.UpdateRowHeightInfo(0, true);
+        }
+
+        if (dataGridView.RowCount == 0)
+        {
+            return;
+        }
+
+        if (firstLine >= 0)
+        {
+            var firstRow = newMap.NearestRow(Math.Max(0, firstLine - rolloverOffset));
+            if (firstRow >= 0)
+            {
+                dataGridView.FirstDisplayedScrollingRowIndex = firstRow;
+            }
+        }
+
+        if (hadCurrentLine && !_guiStateArgs.FollowTail)
+        {
+            var row = newMap.NearestRow(Math.Max(0, currentLine - rolloverOffset));
+            if (row >= 0)
+            {
+                dataGridView.CurrentCell = dataGridView.Rows[row].Cells[0];
+                dataGridView.Rows[row].Selected = true;
+            }
+        }
+    }
+
+    /// <summary>Original line displayed in a main-grid row, or -1.</summary>
+    private int RowToLine (int row)
+    {
+        return _rowMap.RowToLine(row);
+    }
+
+    /// <summary>Main-grid row of an original line, or -1 when it is hidden or out of range.</summary>
+    private int LineToRow (int line)
+    {
+        return _rowMap.LineToRow(line);
+    }
+
+    /// <summary>Original line of the current main-grid row, or -1.</summary>
+    private int CurrentLogicalLine => RowToLine(dataGridView.CurrentCellAddress.Y);
+
+    /// <summary>
+    /// Explicit navigation to an original line: a line beyond the end resolves to the last row; a hidden line turns
+    /// on "Show hidden lines" so that exact line can be selected. Returns the row, or -1.
+    /// </summary>
+    private int RevealLine (int line)
+    {
+        if (line < 0)
+        {
+            return -1;
+        }
+
+        if (line >= _rowMap.LineCount)
+        {
+            return dataGridView.RowCount - 1;
+        }
+
+        if (_rowMap.IsHidden(line))
+        {
+            ShowHiddenLines = true;
+        }
+
+        return LineToRow(line);
+    }
+
+    /// <summary>Line navigation may run once the file is loaded and the first visibility scan is published.</summary>
+    private void UpdateLineNavigationReadiness ()
+    {
+        if (_isLoadComplete && !_isReadyForLineNavigation && !_lineVisibility.IsScanning)
+        {
+            _isReadyForLineNavigation = true;
+            ApplyPendingLineNavigation();
+        }
+    }
+}
diff --git a/src/LogExpert.UI/Controls/LogWindow/LogWindow.cs b/src/LogExpert.UI/Controls/LogWindow/LogWindow.cs
index bd0afb94..0c7bf742 100644
--- a/src/LogExpert.UI/Controls/LogWindow/LogWindow.cs
+++ b/src/LogExpert.UI/Controls/LogWindow/LogWindow.cs
@@ -219,6 +219,7 @@ public LogWindow (ILogWindowCoordinator logWindowCoordinator, string fileName, b
         tableLayoutPanel1.ColumnStyles[0].SizeType = SizeType.Percent;
         tableLayoutPanel1.ColumnStyles[0].Width = 100;
         InitializeMarkerBar();
+        InitializeLineVisibility();
 
         _logWindowCoordinator.HighlightSettingsChanged += OnParentHighlightSettingsChanged;
         SetColumnizer(_pluginRegistry.RegisteredColumnizers[0]);
@@ -377,9 +378,10 @@ public bool ShowBookmarkBubbles
         }
     }
 
+    /// <summary>Original logical line of the current row, or -1.</summary>
     public int CurrentLineNum => dataGridView.CurrentRow == null
             ? -1
-            : dataGridView.CurrentRow.Index;
+            : RowToLine(dataGridView.CurrentRow.Index);
 
     public string FileName { get; private set; }
 
@@ -653,7 +655,7 @@ internal void ToggleColumnFinder (bool show, bool setFocus)
             _ = dataGridView.Focus();
         }
 
-        tableLayoutPanel1.RowStyles[0].Height = show ? 28 : 0;
+        UpdateTopRowHeight();
     }
 
     #endregion
@@ -703,8 +705,7 @@ private void OnButtonSizeChanged (object sender, EventArgs e)
     [SupportedOSPlatform("windows")]
     internal void DumpBufferInfo ()
     {
-        var currentLineNum = dataGridView.CurrentCellAddress.Y;
-        _logFileReader.LogBufferInfoForLine(currentLineNum);
+        _logFileReader.LogBufferInfoForLine(CurrentLogicalLine);
     }
 
     internal void DumpBufferDiagnostic ()
@@ -771,6 +772,7 @@ protected void OnFilterListChanged (LogWindow source)
     protected void OnCurrentHighlightListChanged ()
     {
         InvalidateMarkerCriteria(MarkerScanSource.Highlights);
+        RebuildLineVisibility();
         CurrentHighlightGroupChanged?.Invoke(this, new CurrentHighlightGroupChangedEventArgs(this, _currentHighlightGroup));
     }
 
@@ -821,6 +823,7 @@ private void OnLogWindowLoad (object sender, EventArgs e)
     private void OnLogWindowDisposed (object sender, EventArgs e)
     {
         DisposeMarkers();
+        _lineVisibility.Dispose();
         _waitingForClose = true;
         CancelPendingLineNavigation();
         _logWindowCoordinator.HighlightSettingsChanged -= OnParentHighlightSettingsChanged;
@@ -867,8 +870,8 @@ private void OnLogFileReaderFinishedLoading (object sender, EventArgs e)
             Invoke(() =>
             {
                 InvalidateMarkerCriteria(MarkerScanSource.All);
-                _isReadyForLineNavigation = true;
-                ApplyPendingLineNavigation();
+                _isLoadComplete = true;
+                UpdateLineNavigationReadiness();
             });
             _ = _externaLoadingFinishedEvent.Set();
         }
@@ -958,7 +961,10 @@ private void OnDataGridViewCellValueNeeded (object sender, DataGridViewCellValue
         PrefetchVisibleLines();
 
         var startCount = CurrentColumnizer?.GetColumnCount() ?? 0;
-        e.Value = GetCellValue(e.RowIndex, e.ColumnIndex);
+        var lineNum = RowToLine(e.RowIndex);
+        e.Value = lineNum < 0
+            ? Column.EmptyColumn
+            : GetCellValue(lineNum, e.ColumnIndex);
 
         // The new column could be find dynamically.
         // Only support add new columns for now.
@@ -983,10 +989,27 @@ private void PrefetchVisibleLines ()
         var firstVisible = dataGridView.FirstDisplayedScrollingRowIndex;
         var visibleCount = dataGridView.DisplayedRowCount(includePartialRow: true);
 
-        if (firstVisible >= 0 && visibleCount > 0)
+        if (firstVisible < 0 || visibleCount <= 0)
+        {
+            return;
+        }
+
+        var map = _rowMap;
+        if (map.HiddenCount == 0)
         {
             _columnCache.Prefetch(_logFileReader, firstVisible, visibleCount);
+            return;
+        }
+
+        // Visible rows may be far apart in the file: pin only the lines they display.
+        var endRow = Math.Min(firstVisible + visibleCount, map.VisibleCount);
+        var lines = new int[Math.Max(0, endRow - firstVisible)];
+        for (var i = 0; i < lines.Length; i++)
+        {
+            lines[i] = map.RowToLine(firstVisible + i);
         }
+
+        _columnCache.PrefetchLines(_logFileReader, lines);
     }
 
     private void PrefetchFilterVisibleLines ()
@@ -1040,10 +1063,16 @@ private void OnDataGridViewCellValuePushed (object sender, DataGridViewCellValue
             return;
         }
 
-        var line = _logFileReader.GetLogLineMemory(e.RowIndex);
+        var lineNum = RowToLine(e.RowIndex);
+        if (lineNum < 0)
+        {
+            return;
+        }
+
+        var line = _logFileReader.GetLogLineMemory(lineNum);
         var offset = CurrentColumnizer.GetTimeOffset();
         CurrentColumnizer.SetTimeOffset(0);
-        ColumnizerCallbackObject.SetLineNum(e.RowIndex);
+        ColumnizerCallbackObject.SetLineNum(lineNum);
         var cols = CurrentColumnizer.SplitLine(ColumnizerCallbackObject, line);
         CurrentColumnizer.SetTimeOffset(offset);
         if (cols.ColumnValues.Length <= e.ColumnIndex - 2)
@@ -1081,7 +1110,7 @@ private void OnDataGridViewCurrentCellChanged (object sender, EventArgs e)
     {
         if (dataGridView.CurrentRow != null)
         {
-            _statusEventArgs.CurrentLineNum = dataGridView.CurrentRow.Index + 1;
+            _statusEventArgs.CurrentLineNum = RowToLine(dataGridView.CurrentRow.Index) + 1;
             SendStatusLineUpdate();
             if (syncFilterCheckBox.Checked)
             {
@@ -1469,7 +1498,7 @@ private void OnDataGridContextMenuStripOpening (object sender, CancelEventArgs e
         var lineNum = -1;
         if (dataGridView.CurrentRow != null)
         {
-            lineNum = dataGridView.CurrentRow.Index;
+            lineNum = RowToLine(dataGridView.CurrentRow.Index);
         }
 
         if (lineNum == -1)
@@ -1636,8 +1665,8 @@ private void OnScrollAllTabsToTimestampToolStripMenuItemClick (object sender, Ev
     {
         if (CurrentColumnizer.IsTimeshiftImplemented())
         {
-            var currentLine = dataGridView.CurrentCellAddress.Y;
-            if (currentLine > 0 && currentLine < dataGridView.RowCount)
+            var currentLine = CurrentLogicalLine;
+            if (currentLine > 0)
             {
                 var (timeStamp, _) = GetTimestampForLine(currentLine, false);
                 if (timeStamp.Equals(DateTime.MinValue)) // means: invalid
@@ -1655,7 +1684,7 @@ private void OnLocateLineInOriginalFileToolStripMenuItemClick (object sender, Ev
     {
         if (dataGridView.CurrentRow != null && FilterPipe != null)
         {
-            var lineNum = FilterPipe.GetOriginalLineNum(dataGridView.CurrentRow.Index);
+            var lineNum = FilterPipe.GetOriginalLineNum(RowToLine(dataGridView.CurrentRow.Index));
             if (lineNum != -1)
             {
                 FilterPipe.OriginWindow.SelectLine(lineNum, false, true);
@@ -1725,7 +1754,7 @@ private void OnDataGridViewCellContextMenuStripNeeded (object sender, DataGridVi
     {
         if (e.RowIndex >= 0 && e.RowIndex < dataGridView.RowCount && !dataGridView.Rows[e.RowIndex].Selected)
         {
-            SelectLine(e.RowIndex, false, true);
+            SelectRow(e.RowIndex, false, true);
         }
         else if (e.RowIndex < 0)
         {
@@ -2642,23 +2671,25 @@ private void LoadPersistenceData ()
             _rowHeightList = snapshot.RowHeightList;
             try
             {
-                if (snapshot.CurrentLine >= 0 && snapshot.CurrentLine < dataGridView.RowCount)
+                // Saved positions are original lines; a hidden one resolves to the nearest visible line.
+                if (snapshot.CurrentLine >= 0 && snapshot.CurrentLine < _logFileReader.LineCount)
                 {
-                    SelectLine(snapshot.CurrentLine, false, true);
+                    SelectNearestLine(snapshot.CurrentLine, false, true);
                 }
                 else
                 {
-                    if (_logFileReader.LineCount > 0)
+                    if (dataGridView.RowCount > 0)
                     {
-                        dataGridView.FirstDisplayedScrollingRowIndex = _logFileReader.LineCount - 1;
-                        SelectLine(_logFileReader.LineCount - 1, false, true);
+                        dataGridView.FirstDisplayedScrollingRowIndex = dataGridView.RowCount - 1;
+                        SelectRow(dataGridView.RowCount - 1, false, true);
                     }
                 }
 
                 if (snapshot.FirstDisplayedLine >= 0 &&
-                    snapshot.FirstDisplayedLine < dataGridView.RowCount)
+                    snapshot.FirstDisplayedLine < _logFileReader.LineCount &&
+                    _rowMap.NearestRow(snapshot.FirstDisplayedLine) >= 0)
                 {
-                    dataGridView.FirstDisplayedScrollingRowIndex = snapshot.FirstDisplayedLine;
+                    dataGridView.FirstDisplayedScrollingRowIndex = _rowMap.NearestRow(snapshot.FirstDisplayedLine);
                 }
 
                 // Applied once, here (was double-applied: always pre-load, here only when true).
@@ -2787,19 +2818,27 @@ private void EnterLoadFileStatus ()
         ClearBookmarkList();
         dataGridView.ClearSelection();
         dataGridView.RowCount = 0;
+        ResetLineVisibility();
     }
 
     [SupportedOSPlatform("windows")]
     private void PositionAfterReload (ReloadMemento reloadMemento)
     {
-        if (_reloadMemento.CurrentLine < dataGridView.RowCount && _reloadMemento.CurrentLine >= 0)
+        // The memento holds original lines; hidden ones resolve to the nearest visible row.
+        var currentRow = _reloadMemento.CurrentLine >= 0 && _reloadMemento.CurrentLine < _rowMap.LineCount
+            ? _rowMap.NearestRow(_reloadMemento.CurrentLine)
+            : -1;
+        if (currentRow >= 0)
         {
-            dataGridView.CurrentCell = dataGridView.Rows[_reloadMemento.CurrentLine].Cells[0];
+            dataGridView.CurrentCell = dataGridView.Rows[currentRow].Cells[0];
         }
 
-        if (_reloadMemento.FirstDisplayedLine < dataGridView.RowCount && _reloadMemento.FirstDisplayedLine >= 0)
+        var firstRow = _reloadMemento.FirstDisplayedLine >= 0 && _reloadMemento.FirstDisplayedLine < _rowMap.LineCount
+            ? _rowMap.NearestRow(_reloadMemento.FirstDisplayedLine)
+            : -1;
+        if (firstRow >= 0)
         {
-            dataGridView.FirstDisplayedScrollingRowIndex = _reloadMemento.FirstDisplayedLine;
+            dataGridView.FirstDisplayedScrollingRowIndex = firstRow;
         }
     }
 
@@ -2817,6 +2856,7 @@ private void LogfileDead ()
 
         dataGridView.Enabled = false;
         dataGridView.RowCount = 0;
+        ResetLineVisibility();
         _progressEventArgs.Visible = false;
         _progressEventArgs.Value = _progressEventArgs.MaxValue;
         SendProgressBarUpdate();
@@ -3018,7 +3058,8 @@ private void LoadingFinished ()
         _logFileReader.FileSizeChanged += OnFileSizeChanged;
         _isLoading = false;
         dataGridView.SuspendLayout();
-        dataGridView.RowCount = _logFileReader.LineCount;
+        _lineVisibility.Load(_logFileReader.LineCount, CurrentHighlightEntries());
+        ApplyLineVisibility();
         dataGridView.CurrentCellChanged += OnDataGridViewCurrentCellChanged;
         dataGridView.Enabled = true;
         dataGridView.AutoResizeColumns(DataGridViewAutoSizeColumnsMode.DisplayedCells);
@@ -3054,12 +3095,17 @@ void ITailFollowSink.OnRolloverShift (int rolloverOffset)
         ShiftBookmarks(rolloverOffset);
         ShiftRowHeightList(rolloverOffset);
         ShiftFilterPipes(rolloverOffset);
+        _ = _lineVisibility.Shift(rolloverOffset);
     }
 
     void ITailFollowSink.OnTailLines (LogEventArgs e)
     {
         try
         {
+            // Evaluate hide rules for the new lines here, off the UI thread, before the grid shows them.
+            _ = !e.IsRollover && e.LineCount < e.PrevLineCount
+                ? _lineVisibility.Replace(e.LineCount)
+                : _lineVisibility.Extend(e.LineCount);
             _ = BeginInvoke(UpdateGrid, [e]);
             CheckFilterAndHighlight(e);
         }
@@ -3105,63 +3151,21 @@ private void OnFileSizeChanged (LogEventArgs logEventArgs)
     private void UpdateGrid (LogEventArgs logEventArgs)
     {
         var oldRowCount = dataGridView.RowCount;
-        var firstDisplayedLine = dataGridView.FirstDisplayedScrollingRowIndex;
-
-        if (dataGridView.CurrentCellAddress.Y >= logEventArgs.LineCount)
-        {
-            //this.dataGridView.Rows[this.dataGridView.CurrentCellAddress.Y].Selected = false;
-            //this.dataGridView.CurrentCell = this.dataGridView.Rows[0].Cells[0];
-        }
 
         try
         {
-            if (dataGridView.RowCount > logEventArgs.LineCount)
+            // The engine thread already applied this event to the tracker (OnRolloverShift / OnTailLines). An append
+            // only grows the rows; a rollover or truncation rebuilds them and, without follow-tail, keeps the
+            // selected and first displayed original lines (moved up by the rollover offset).
+            var tracked = _lineVisibility.Map;
+            var newMap = EffectiveMap(tracked);
+            _appliedTrackedMap = tracked;
+            if (!ReferenceEquals(newMap, _rowMap))
             {
-                var currentLineNum = dataGridView.CurrentCellAddress.Y;
-                dataGridView.RowCount = 0;
-                dataGridView.RowCount = logEventArgs.LineCount;
-                if (!_guiStateArgs.FollowTail)
-                {
-                    if (currentLineNum >= dataGridView.RowCount)
-                    {
-                        currentLineNum = dataGridView.RowCount - 1;
-                    }
-
-                    dataGridView.CurrentCell = dataGridView.Rows[currentLineNum].Cells[0];
-                }
-            }
-            else
-            {
-                dataGridView.RowCount = logEventArgs.LineCount;
+                SetRowMap(newMap, logEventArgs.IsRollover ? logEventArgs.RolloverOffset : 0);
             }
 
-            //_logger.Debug($"UpdateGrid(): new RowCount={dataGridView.RowCount}");
-
-            if (logEventArgs.IsRollover)
-            {
-                // Multifile rollover
-                // keep selection and view range, if no follow tail mode
-                if (!_guiStateArgs.FollowTail)
-                {
-                    var currentLineNum = dataGridView.CurrentCellAddress.Y;
-                    currentLineNum -= logEventArgs.RolloverOffset;
-                    if (currentLineNum < 0)
-                    {
-                        currentLineNum = 0;
-                    }
-
-                    //_logger.Debug($"UpdateGrid(): Rollover=true, Rollover offset={logEventArgs.RolloverOffset}, currLineNum was {dataGridView.CurrentCellAddress.Y}, new currLineNum={currentLineNum}");
-                    firstDisplayedLine -= logEventArgs.RolloverOffset;
-                    if (firstDisplayedLine < 0)
-                    {
-                        firstDisplayedLine = 0;
-                    }
-
-                    dataGridView.FirstDisplayedScrollingRowIndex = firstDisplayedLine;
-                    dataGridView.CurrentCell = dataGridView.Rows[currentLineNum].Cells[0];
-                    dataGridView.Rows[currentLineNum].Selected = true;
-                }
-            }
+            UpdateHiddenLinesBar();
 
             _statusEventArgs.LineCount = logEventArgs.LineCount;
             StatusLineFileSize(logEventArgs.FileSize);
@@ -3263,7 +3267,8 @@ private void CheckFilterAndHighlight (LogEventArgs e)
                 if (firstStopTail)
                 {
                     var capturedLineNum = i;
-                    _ = BeginInvoke(() => SelectAndEnsureVisible(capturedLineNum, false));
+                    // Not explicit navigation: a hidden trigger line is not revealed.
+                    _ = BeginInvoke(() => SelectAndEnsureVisibleRow(_rowMap.NearestRow(capturedLineNum), false));
                     firstStopTail = false;
                 }
             }
@@ -3421,7 +3426,7 @@ private void SetColumnizerInternal (ILogLineMemoryColumnizer columnizer)
 
         if (_logFileReader != null)
         {
-            dataGridView.RowCount = _logFileReader.LineCount;
+            dataGridView.RowCount = _rowMap.VisibleCount;
         }
 
         if (_filterResultList != null)
@@ -3917,7 +3922,7 @@ private void SyncTimestampDisplay ()
         {
             if (dataGridView.CurrentRow != null)
             {
-                SyncTimestampDisplay(dataGridView.CurrentRow.Index);
+                SyncTimestampDisplay(RowToLine(dataGridView.CurrentRow.Index));
             }
         }
     }
@@ -3958,7 +3963,7 @@ private void SyncTimestampDisplayWorker ()
 
             // timeout with no new Trigger -> update display
             var lineNum = _timeShiftSyncLine;
-            if (lineNum >= 0 && lineNum < dataGridView.RowCount)
+            if (lineNum >= 0 && lineNum < _rowMap.LineCount)
             {
                 var (timeStamp, lineNumber) = GetTimestampForLine(lineNum, true);
                 lineNum = lineNumber;
@@ -3978,8 +3983,8 @@ private void SyncTimestampDisplayWorker ()
             // show time difference between 2 selected lines
             if (dataGridView.SelectedRows.Count == 2)
             {
-                var row1 = dataGridView.SelectedRows[0].Index;
-                var row2 = dataGridView.SelectedRows[1].Index;
+                var row1 = RowToLine(dataGridView.SelectedRows[0].Index);
+                var row2 = RowToLine(dataGridView.SelectedRows[1].Index);
                 if (row1 > row2)
                 {
                     (row2, row1) = (row1, row2);
@@ -4011,7 +4016,7 @@ private void SyncFilterGridPos ()
         {
             if (_filterResultList.Count > 0)
             {
-                var index = _filterResultList.BinarySearch(dataGridView.CurrentRow.Index);
+                var index = _filterResultList.BinarySearch(RowToLine(dataGridView.CurrentRow.Index));
                 if (index < 0)
                 {
                     index = ~index;
@@ -4084,29 +4089,48 @@ private void ResetProgressBar ()
         SendProgressBarUpdate();
     }
 
+    /// <summary>
+    /// Explicit navigation to an original line (Go to Line, bookmarks, Log Search, filter results, time sync, …).
+    /// A hidden target turns on "Show hidden lines" so that exact line is selected.
+    /// </summary>
     [SupportedOSPlatform("windows")]
     private void SelectLine (int lineNum, bool triggerSyncCall, bool shouldScroll)
+    {
+        _shouldCallTimeSync = triggerSyncCall;
+        SelectRow(RevealLine(lineNum), triggerSyncCall, shouldScroll);
+    }
+
+    /// <summary>Selects an original line, or the next (else previous) visible line when it is hidden.</summary>
+    [SupportedOSPlatform("windows")]
+    private void SelectNearestLine (int lineNum, bool triggerSyncCall, bool shouldScroll)
+    {
+        _shouldCallTimeSync = triggerSyncCall;
+        SelectRow(lineNum < 0 ? -1 : _rowMap.NearestRow(lineNum), triggerSyncCall, shouldScroll);
+    }
+
+    [SupportedOSPlatform("windows")]
+    private void SelectRow (int rowNum, bool triggerSyncCall, bool shouldScroll)
     {
         try
         {
             _shouldCallTimeSync = triggerSyncCall;
 
-            if (lineNum < 0)
+            if (rowNum < 0)
             {
                 return;
             }
 
             // Prevent ArgumentOutOfRangeException
-            if (lineNum >= dataGridView.Rows.GetRowCount(DataGridViewElementStates.None))
+            if (rowNum >= dataGridView.Rows.GetRowCount(DataGridViewElementStates.None))
             {
-                lineNum = dataGridView.Rows.GetRowCount(DataGridViewElementStates.None) - 1;
+                rowNum = dataGridView.Rows.GetRowCount(DataGridViewElementStates.None) - 1;
             }
 
-            dataGridView.Rows[lineNum].Selected = true;
+            dataGridView.Rows[rowNum].Selected = true;
 
             if (shouldScroll)
             {
-                dataGridView.CurrentCell = dataGridView.Rows[lineNum].Cells[0];
+                dataGridView.CurrentCell = dataGridView.Rows[rowNum].Cells[0];
                 _ = dataGridView.Focus();
             }
         }
@@ -4161,11 +4185,11 @@ private void UpdateEditColumnDisplay (DataGridViewTextBoxEditingControl editCont
     [SupportedOSPlatform("windows")]
     private void SelectPrevHighlightLine ()
     {
-        var lineNum = dataGridView.CurrentCellAddress.Y;
+        var lineNum = CurrentLogicalLine;
         while (lineNum > 0)
         {
             lineNum--;
-            var line = _logFileReader.GetLogLineMemory(lineNum);
+            var line = _rowMap.IsHidden(lineNum) ? null : _logFileReader.GetLogLineMemory(lineNum);
             if (line != null)
             {
                 var entry = FindHighlightEntry(line);
@@ -4181,11 +4205,11 @@ private void SelectPrevHighlightLine ()
     [SupportedOSPlatform("windows")]
     private void SelectNextHighlightLine ()
     {
-        var lineNum = dataGridView.CurrentCellAddress.Y;
+        var lineNum = CurrentLogicalLine;
         while (lineNum < _logFileReader.LineCount)
         {
             lineNum++;
-            var line = _logFileReader.GetLogLineMemory(lineNum);
+            var line = _rowMap.IsHidden(lineNum) ? null : _logFileReader.GetLogLineMemory(lineNum);
             if (line != null)
             {
                 var entry = FindHighlightEntry(line);
@@ -4201,7 +4225,7 @@ private void SelectNextHighlightLine ()
     [SupportedOSPlatform("windows")]
     private int FindNextBookmarkIndex (int lineNum)
     {
-        if (lineNum >= dataGridView.RowCount)
+        if (lineNum >= _rowMap.LineCount)
         {
             lineNum = 0;
         }
@@ -4218,7 +4242,7 @@ private int FindPrevBookmarkIndex (int lineNum)
     {
         if (lineNum <= 0)
         {
-            lineNum = dataGridView.RowCount - 1;
+            lineNum = _rowMap.LineCount - 1;
         }
         else
         {
@@ -4277,7 +4301,7 @@ private void LoadFilterPipes ()
 
         if (_filterPipeList.Count > 0)
         {
-            for (var i = 0; i < dataGridView.RowCount; ++i)
+            for (var i = 0; i < _logFileReader.LineCount; ++i)
             {
                 ProcessFilterPipes(i);
             }
@@ -4418,7 +4442,7 @@ private async void FilterSearch (string text)
         ClearFilterList();
 
         _progressEventArgs.MinValue = 0;
-        _progressEventArgs.MaxValue = dataGridView.RowCount;
+        _progressEventArgs.MaxValue = _logFileReader.LineCount;
         _progressEventArgs.Value = 0;
         _progressEventArgs.Visible = true;
         SendProgressBarUpdate();
@@ -4826,7 +4850,7 @@ private void DisplayCurrentFileOnStatusline ()
             {
                 if (dataGridView.CurrentRow != null && dataGridView.CurrentRow.Index > -1)
                 {
-                    var fileName = _logFileReader.GetLogFileNameForLine(dataGridView.CurrentRow.Index);
+                    var fileName = _logFileReader.GetLogFileNameForLine(RowToLine(dataGridView.CurrentRow.Index));
                     if (fileName != null)
                     {
                         StatusLineText(Util.GetNameFromPath(fileName));
@@ -5181,7 +5205,7 @@ private void CopyMarkedLinesToClipboard ()
             {
                 if (row.Index != -1)
                 {
-                    lineNumList.Add(row.Index);
+                    lineNumList.Add(RowToLine(row.Index));
                 }
             }
 
@@ -5269,7 +5293,7 @@ private List<int> GetSelectedContent ()
             {
                 if (row.Index != -1)
                 {
-                    lineNumList.Add(row.Index);
+                    lineNumList.Add(RowToLine(row.Index));
                 }
             }
 
@@ -5293,7 +5317,7 @@ private void SetTimestampLimits ()
         }
 
         (_guiStateArgs.MinTimestamp, _) = _timestampLocator.FindForward(0, _logFileReader.LineCount, true);
-        (_guiStateArgs.MaxTimestamp, _) = GetTimestampForLine(dataGridView.RowCount - 1, true);
+        (_guiStateArgs.MaxTimestamp, _) = GetTimestampForLine(_logFileReader.LineCount - 1, true);
         SendGuiStateUpdate();
     }
 
@@ -5398,9 +5422,11 @@ private void ChangeRowHeight (bool decrease)
             return;
         }
 
+        var lineNum = RowToLine(rowNum);
+
         if (decrease)
         {
-            if (!_rowHeightList.TryGetValue(rowNum, out var entry))
+            if (!_rowHeightList.TryGetValue(lineNum, out var entry))
             {
                 return;
             }
@@ -5409,22 +5435,22 @@ private void ChangeRowHeight (bool decrease)
                 entry.Height -= _lineHeight;
                 if (entry.Height <= _lineHeight)
                 {
-                    _ = _rowHeightList.Remove(rowNum);
+                    _ = _rowHeightList.Remove(lineNum);
                 }
             }
         }
         else
         {
             RowHeightEntry entry;
-            if (!_rowHeightList.TryGetValue(rowNum, out var value))
+            if (!_rowHeightList.TryGetValue(lineNum, out var value))
             {
                 entry = new RowHeightEntry
                 {
-                    LineNum = rowNum,
+                    LineNum = lineNum,
                     Height = _lineHeight
                 };
 
-                _rowHeightList[rowNum] = entry;
+                _rowHeightList[lineNum] = entry;
             }
             else
             {
@@ -5445,7 +5471,8 @@ private void ChangeRowHeight (bool decrease)
 
     private int GetRowHeight (int rowNum)
     {
-        return _rowHeightList.TryGetValue(rowNum, out var value)
+        // _rowHeightList is keyed by original line (it is saved in the Session File).
+        return _rowHeightList.TryGetValue(RowToLine(rowNum), out var value)
             ? value.Height
             : _lineHeight;
     }
@@ -5461,7 +5488,7 @@ private void AddBookmarkAtLineSilently (int lineNum)
     [SupportedOSPlatform("windows")]
     private void AddBookmarkAndEditComment ()
     {
-        var lineNum = dataGridView.CurrentCellAddress.Y;
+        var lineNum = CurrentLogicalLine;
         if (!_bookmarkProvider.IsBookmarkAtLine(lineNum))
         {
             ToggleBookmark();
@@ -5473,7 +5500,7 @@ private void AddBookmarkAndEditComment ()
     [SupportedOSPlatform("windows")]
     private void AddBookmarkComment (string text)
     {
-        var lineNum = dataGridView.CurrentCellAddress.Y;
+        var lineNum = CurrentLogicalLine;
         Bookmark bookmark;
 
         if (!_bookmarkProvider.IsBookmarkAtLine(lineNum))
@@ -5497,14 +5524,18 @@ private void MarkCurrentFilterRange ()
         _filterParams.RangeSearchText = filterRangeComboBox.Text;
         ColumnizerCallback callback = new(this);
         RangeFinder rangeFinder = new(_filterParams, callback);
-        var range = rangeFinder.FindRange(dataGridView.CurrentCellAddress.Y);
+        var range = rangeFinder.FindRange(CurrentLogicalLine);
         if (range != null)
         {
             SetCellSelectionMode(false);
             _noSelectionUpdates = true;
             for (var i = range.StartLine; i <= range.EndLine; ++i)
             {
-                dataGridView.Rows[i].Selected = true;
+                var row = LineToRow(i);
+                if (row >= 0)
+                {
+                    dataGridView.Rows[row].Selected = true;
+                }
             }
 
             _noSelectionUpdates = false;
@@ -5600,7 +5631,7 @@ private void AddSlaveToTimesync (LogWindow slave)
                     TimeSyncList = slave.TimeSyncList;
                 }
 
-                var currentLineNum = dataGridView.CurrentCellAddress.Y;
+                var currentLineNum = CurrentLogicalLine;
                 var (timeStamp, _) = GetTimestampForLine(currentLineNum, true);
                 if (!timeStamp.Equals(DateTime.MinValue) && !_shouldTimestampDisplaySyncingCancel)
                 {
@@ -5937,8 +5968,8 @@ public SessionSnapshot GatherSessionSnapshot ()
             MultiFile = IsMultiFile,
             MultiFilePattern = _multiFileOptions.FormatPattern,
             MultiFileMaxDays = _multiFileOptions.MaxDayTry,
-            CurrentLine = dataGridView.CurrentCellAddress.Y,
-            FirstDisplayedLine = dataGridView.FirstDisplayedScrollingRowIndex,
+            CurrentLine = CurrentLogicalLine,
+            FirstDisplayedLine = RowToLine(dataGridView.FirstDisplayedScrollingRowIndex),
             FilterVisible = !splitContainerLogWindow.Panel2Collapsed,
             FilterAdvanced = !advancedFilterSplitContainer.Panel1Collapsed,
             FilterPosition = splitContainerLogWindow.SplitterDistance,
@@ -6097,13 +6128,13 @@ public void SetColumnizer (ILogLineMemoryColumnizer columnizer, BufferedDataGrid
         ApplyFrozenState(gridView);
     }
 
-    public IColumnMemory GetCellValue (int rowIndex, int columnIndex)
+    public IColumnMemory GetCellValue (int lineNum, int columnIndex)
     {
         if (columnIndex == 1)
         {
             return new Column
             {
-                FullValue = $"{rowIndex + 1}".AsMemory() // line number
+                FullValue = $"{lineNum + 1}".AsMemory() // line number
             };
         }
 
@@ -6114,7 +6145,7 @@ public IColumnMemory GetCellValue (int rowIndex, int columnIndex)
 
         try
         {
-            var cols = _columnCache.GetColumnsForLine(_logFileReader, rowIndex, CurrentColumnizer, ColumnizerCallbackObject);
+            var cols = _columnCache.GetColumnsForLine(_logFileReader, lineNum, CurrentColumnizer, ColumnizerCallbackObject);
             if (cols != null && cols.ColumnValues != null)
             {
                 if (columnIndex <= cols.ColumnValues.Length + 1)
@@ -6135,7 +6166,7 @@ public IColumnMemory GetCellValue (int rowIndex, int columnIndex)
         catch (IndexOutOfRangeException ex)
         {
 
-            _logger.Warn(ex, "Failed to get cell value due to index error. rowIndex={RowIndex}, columnIndex={ColumnIndex}", rowIndex, columnIndex);
+            _logger.Warn(ex, "Failed to get cell value due to index error. lineNum={LineNum}, columnIndex={ColumnIndex}", lineNum, columnIndex);
             return Column.EmptyColumn;
         }
 #else
@@ -6149,7 +6180,7 @@ public IColumnMemory GetCellValue (int rowIndex, int columnIndex)
         catch (ArgumentOutOfRangeException ex)
         {
 
-            _logger.Warn(ex, "Failed to get cell value due to argument range error. rowIndex={RowIndex}, columnIndex={ColumnIndex}", rowIndex, columnIndex);
+            _logger.Warn(ex, "Failed to get cell value due to argument range error. lineNum={LineNum}, columnIndex={ColumnIndex}", lineNum, columnIndex);
             return Column.EmptyColumn;
         }
 #else
@@ -6162,7 +6193,7 @@ public IColumnMemory GetCellValue (int rowIndex, int columnIndex)
         catch (NullReferenceException ex)
         {
 
-            _logger.Warn(ex, "Failed to get cell value due to null state. rowIndex={RowIndex}, columnIndex={ColumnIndex}", rowIndex, columnIndex);
+            _logger.Warn(ex, "Failed to get cell value due to null state. lineNum={LineNum}, columnIndex={ColumnIndex}", lineNum, columnIndex);
             return Column.EmptyColumn;
         }
 #else
@@ -6262,9 +6293,14 @@ public void CellPainting (bool focused, int rowIndex, int columnIndex, bool isFi
             return;
         }
 
-        if (isFilteredGridView)
+        rowIndex = isFilteredGridView
+            ? _filterResultList[rowIndex]
+            : RowToLine(rowIndex);
+
+        if (rowIndex < 0)
         {
-            rowIndex = _filterResultList[rowIndex];
+            e.Handled = false;
+            return;
         }
 
         // Ensure prefetch is current — CellPainting fires BEFORE CellValueNeeded on scroll jumps,
@@ -6442,12 +6478,13 @@ public void FollowTailChanged (bool isChecked, bool byTrigger)
 
         if (_guiStateArgs.FollowTail && _logFileReader != null)
         {
-            if (dataGridView.RowCount >= _logFileReader.LineCount && _logFileReader.LineCount > 0)
+            // Follow the last visible row; hidden lines are never revealed by tailing.
+            if (_rowMap.LineCount >= _logFileReader.LineCount && dataGridView.RowCount > 0)
             {
                 // Mark stale instead of invalidating — keeps old buffers pinned until
                 // the next Prefetch atomically swaps in new pins.
                 _columnCache.MarkPrefetchStale();
-                dataGridView.FirstDisplayedScrollingRowIndex = _logFileReader.LineCount - 1;
+                dataGridView.FirstDisplayedScrollingRowIndex = dataGridView.RowCount - 1;
             }
         }
 
@@ -6507,7 +6544,7 @@ private void ApplyPendingLineNavigation ()
         }
 
         FollowTailChanged(false, false);
-        if (dataGridView.RowCount > 0)
+        if (_rowMap.LineCount > 0)
         {
             dataGridView.ClearSelection();
             GotoLine(targetLine.Value - 1);
@@ -6526,14 +6563,8 @@ public void GotoLine (int line)
     {
         if (line >= 0)
         {
-            if (line < dataGridView.RowCount)
-            {
-                SelectLine(line, false, true);
-            }
-            else
-            {
-                SelectLine(dataGridView.RowCount - 1, false, true);
-            }
+            // An original line; beyond the end selects the last line, a hidden one is revealed.
+            SelectLine(Math.Min(line, _rowMap.LineCount - 1), false, true);
 
             _ = dataGridView.Focus();
         }
@@ -6546,8 +6577,8 @@ public void StartSearch ()
         var searchParams = _logWindowCoordinator.SearchParams;
 
         searchParams.CurrentLine = LogSearcher.ResolveDirection(searchParams) == SearchDirection.Forward
-            ? dataGridView.CurrentCellAddress.Y + 1
-            : dataGridView.CurrentCellAddress.Y - 1;
+            ? CurrentLogicalLine + 1
+            : CurrentLogicalLine - 1;
 
         _currentSearchParams = searchParams; // remember for async "not found" messages
         TrackMarkerSearch(searchParams);
@@ -6556,7 +6587,7 @@ public void StartSearch ()
         StatusLineText(Resources.LogWindow_UI_StatusLineText_SearchingPressESCToCancel);
 
         _progressEventArgs.MinValue = 0;
-        _progressEventArgs.MaxValue = dataGridView.RowCount;
+        _progressEventArgs.MaxValue = _logFileReader.LineCount;
         _progressEventArgs.Value = 0;
         _progressEventArgs.Visible = true;
         SendProgressBarUpdate();
@@ -6625,28 +6656,34 @@ public void SelectLogLine (int lineNumber)
         _ = Invoke(new SelectLineFx((line1, triggerSyncCall) => SelectLine(line1, triggerSyncCall, true)), lineNumber, true);
     }
 
+    /// <summary>Explicit navigation to an original line; a hidden line is revealed (see <see cref="SelectLine"/>).</summary>
     public void SelectAndEnsureVisible (int line, bool triggerSyncCall)
+    {
+        SelectAndEnsureVisibleRow(RevealLine(line), triggerSyncCall);
+    }
+
+    private void SelectAndEnsureVisibleRow (int row, bool triggerSyncCall)
     {
         try
         {
-            SelectLine(line, triggerSyncCall, false);
+            SelectRow(row, triggerSyncCall, false);
 
             //if (!this.dataGridView.CurrentRow.Displayed)
-            if (line < dataGridView.FirstDisplayedScrollingRowIndex || line > dataGridView.FirstDisplayedScrollingRowIndex + dataGridView.DisplayedRowCount(false))
+            if (row < dataGridView.FirstDisplayedScrollingRowIndex || row > dataGridView.FirstDisplayedScrollingRowIndex + dataGridView.DisplayedRowCount(false))
             {
-                dataGridView.FirstDisplayedScrollingRowIndex = line;
-                for (var i = 0; i < 8 && dataGridView.FirstDisplayedScrollingRowIndex > 0 && line < dataGridView.FirstDisplayedScrollingRowIndex + dataGridView.DisplayedRowCount(false); ++i)
+                dataGridView.FirstDisplayedScrollingRowIndex = row;
+                for (var i = 0; i < 8 && dataGridView.FirstDisplayedScrollingRowIndex > 0 && row < dataGridView.FirstDisplayedScrollingRowIndex + dataGridView.DisplayedRowCount(false); ++i)
                 {
                     dataGridView.FirstDisplayedScrollingRowIndex -= 1;
                 }
 
-                if (line >= dataGridView.FirstDisplayedScrollingRowIndex + dataGridView.DisplayedRowCount(false))
+                if (row >= dataGridView.FirstDisplayedScrollingRowIndex + dataGridView.DisplayedRowCount(false))
                 {
                     dataGridView.FirstDisplayedScrollingRowIndex += 1;
                 }
             }
 
-            dataGridView.CurrentCell = dataGridView.Rows[line].Cells[0];
+            dataGridView.CurrentCell = dataGridView.Rows[row].Cells[0];
         }
         catch (Exception e)
         {
@@ -6699,11 +6736,11 @@ public void OnLogWindowKeyDown (object sender, KeyEventArgs e)
                 }
             case Keys.Down when e.Modifiers == Keys.Alt:
                 {
-                    var newLine = _logFileReader.GetNextMultiFileLine(dataGridView.CurrentCellAddress.Y);
+                    var newLine = _logFileReader.GetNextMultiFileLine(CurrentLogicalLine);
 
                     if (newLine != -1)
                     {
-                        SelectLine(newLine, false, true);
+                        SelectNearestLine(newLine, false, true);
                     }
 
                     e.Handled = true;
@@ -6712,11 +6749,11 @@ public void OnLogWindowKeyDown (object sender, KeyEventArgs e)
                 }
             case Keys.Up when e.Modifiers == Keys.Alt:
                 {
-                    var newLine = _logFileReader.GetPrevMultiFileLine(dataGridView.CurrentCellAddress.Y);
+                    var newLine = _logFileReader.GetPrevMultiFileLine(CurrentLogicalLine);
 
                     if (newLine != -1)
                     {
-                        SelectLine(newLine - 1, false, true);
+                        SelectNearestLine(newLine - 1, false, true);
                     }
 
                     e.Handled = true;
@@ -6785,9 +6822,10 @@ public void AddBookmarkOverlays ()
                 }
             }
 
-            if (_bookmarkProvider.IsBookmarkAtLine(i))
+            var lineNum = RowToLine(i);
+            if (_bookmarkProvider.IsBookmarkAtLine(lineNum))
             {
-                var bookmark = _bookmarkProvider.GetBookmarkForLine(i);
+                var bookmark = _bookmarkProvider.GetBookmarkForLine(lineNum);
                 if (bookmark.Text.Length > 0)
                 {
                     //BookmarkOverlay overlay = new BookmarkOverlay();
@@ -6865,7 +6903,7 @@ public void ToggleBookmark ()
                 return;
             }
 
-            lineNum = dataGridView.CurrentCellAddress.Y;
+            lineNum = CurrentLogicalLine;
         }
 
         ToggleBookmark(lineNum);
@@ -7158,7 +7196,7 @@ public void JumpNextBookmark ()
             }
             else
             {
-                var index = FindNextBookmarkIndex(dataGridView.CurrentCellAddress.Y);
+                var index = FindNextBookmarkIndex(CurrentLogicalLine);
                 if (index > _bookmarkProvider.Bookmarks.Count - 1)
                 {
                     index = 0;
@@ -7217,7 +7255,7 @@ public void JumpPrevBookmark ()
             }
             else
             {
-                var index = FindPrevBookmarkIndex(dataGridView.CurrentCellAddress.Y);
+                var index = FindPrevBookmarkIndex(CurrentLogicalLine);
                 if (index < 0)
                 {
                     index = _bookmarkProvider.Bookmarks.Count - 1;
@@ -7373,7 +7411,7 @@ public void CopyMarkedLinesToTab ()
             {
                 if (row.Index != -1)
                 {
-                    lineNumList.Add(row.Index);
+                    lineNumList.Add(RowToLine(row.Index));
                 }
             }
 
@@ -7434,8 +7472,8 @@ public void Reload ()
 
         _reloadMemento = new ReloadMemento
         {
-            CurrentLine = dataGridView.CurrentCellAddress.Y,
-            FirstDisplayedLine = dataGridView.FirstDisplayedScrollingRowIndex
+            CurrentLine = CurrentLogicalLine,
+            FirstDisplayedLine = RowToLine(dataGridView.FirstDisplayedScrollingRowIndex)
         };
 
         _forcedColumnizerForLoading = CurrentColumnizer;
@@ -7533,14 +7571,14 @@ public bool ScrollToTimestamp (DateTime timestamp, bool roundToSeconds, bool tri
     public bool ScrollToTimestampWorker (DateTime timestamp, bool roundToSeconds, bool triggerSyncCall)
     {
         var hasScrolled = false;
-        if (!CurrentColumnizer.IsTimeshiftImplemented() || dataGridView.RowCount == 0)
+        if (!CurrentColumnizer.IsTimeshiftImplemented() || _rowMap.LineCount == 0)
         {
             return false;
         }
 
         //this.Cursor = Cursors.WaitCursor;
-        var currentLine = dataGridView.CurrentCellAddress.Y;
-        if (currentLine < 0 || currentLine >= dataGridView.RowCount)
+        var currentLine = CurrentLogicalLine;
+        if (currentLine < 0)
         {
             currentLine = 0;
         }
@@ -7588,7 +7626,7 @@ public void AppFocusGained ()
     public ILogLineMemory GetCurrentLine ()
     {
         return dataGridView.CurrentRow != null && dataGridView.CurrentRow.Index != -1
-            ? _logFileReader.GetLogLineMemory(dataGridView.CurrentRow.Index)
+            ? _logFileReader.GetLogLineMemory(RowToLine(dataGridView.CurrentRow.Index))
             : null;
     }
 
@@ -7610,7 +7648,7 @@ public int GetRealLineNum ()
     public ILogFileInfo GetCurrentFileInfo ()
     {
         return dataGridView.CurrentRow != null && dataGridView.CurrentRow.Index != -1
-            ? _logFileReader.GetLogFileInfoForLine(dataGridView.CurrentRow.Index)
+            ? _logFileReader.GetLogFileInfoForLine(RowToLine(dataGridView.CurrentRow.Index))
             : null;
     }
 
@@ -7759,6 +7797,7 @@ public void SetCurrentHighlightGroup (string groupName)
         }
 
         InvalidateMarkerCriteria(MarkerScanSource.Highlights);
+        RebuildLineVisibility();
 
         SendGuiStateUpdate();
 
diff --git a/src/LogExpert.UI/Dialogs/Highlight/HighlightEntryDialog.Designer.cs b/src/LogExpert.UI/Dialogs/Highlight/HighlightEntryDialog.Designer.cs
index f660de5b..0454d00e 100644
--- a/src/LogExpert.UI/Dialogs/Highlight/HighlightEntryDialog.Designer.cs
+++ b/src/LogExpert.UI/Dialogs/Highlight/HighlightEntryDialog.Designer.cs
@@ -54,6 +54,7 @@ private void InitializeComponent ()
         _btnBookmarkComment = new Button();
         _checkBoxStopTail = new CheckBox();
         _checkBoxDontDirtyLed = new CheckBox();
+        _checkBoxHideLine = new CheckBox();
         _checkBoxPlugin = new CheckBox();
         _btnSelectPlugin = new Button();
         _checkBoxAlertOnHit = new CheckBox();
@@ -280,6 +281,7 @@ private void InitializeComponent ()
         _tabActions.Controls.Add(_labelCooldown);
         _tabActions.Controls.Add(_numericCooldownSeconds);
         _tabActions.Controls.Add(_labelCooldownSeconds);
+        _tabActions.Controls.Add(_checkBoxHideLine);
         _tabActions.Location = new Point(4, 24);
         _tabActions.Name = "_tabActions";
         _tabActions.Padding = new Padding(8);
@@ -329,6 +331,16 @@ private void InitializeComponent ()
         _checkBoxDontDirtyLed.Text = "Dont Dirty Led";
         _checkBoxDontDirtyLed.UseVisualStyleBackColor = true;
         // 
+        // _checkBoxHideLine
+        // 
+        _checkBoxHideLine.AutoSize = true;
+        _checkBoxHideLine.Location = new Point(12, 250);
+        _checkBoxHideLine.Name = "_checkBoxHideLine";
+        _checkBoxHideLine.Size = new Size(74, 19);
+        _checkBoxHideLine.TabIndex = 13;
+        _checkBoxHideLine.Text = "Hide line";
+        _checkBoxHideLine.UseVisualStyleBackColor = true;
+        // 
         // _checkBoxPlugin
         // 
         _checkBoxPlugin.AutoSize = true;
@@ -485,6 +497,7 @@ private void InitializeComponent ()
     private System.Windows.Forms.Button _btnBookmarkComment;
     private System.Windows.Forms.CheckBox _checkBoxStopTail;
     private System.Windows.Forms.CheckBox _checkBoxDontDirtyLed;
+    private System.Windows.Forms.CheckBox _checkBoxHideLine;
     private System.Windows.Forms.CheckBox _checkBoxPlugin;
     private System.Windows.Forms.Button _btnSelectPlugin;
     private System.Windows.Forms.CheckBox _checkBoxAlertOnHit;
diff --git a/src/LogExpert.UI/Dialogs/Highlight/HighlightEntryDialog.cs b/src/LogExpert.UI/Dialogs/Highlight/HighlightEntryDialog.cs
index ad5ecd30..aa667d2c 100644
--- a/src/LogExpert.UI/Dialogs/Highlight/HighlightEntryDialog.cs
+++ b/src/LogExpert.UI/Dialogs/Highlight/HighlightEntryDialog.cs
@@ -69,6 +69,7 @@ private void ApplyResources ()
         _btnBookmarkComment.Text = Resources.HighlightDialog_UI_Button_BookmarkComment;
         _checkBoxStopTail.Text = Resources.HighlightDialog_UI_CheckBox_StopTail;
         _checkBoxDontDirtyLed.Text = Resources.HighlightDialog_UI_CheckBox_DontDirtyLed;
+        _checkBoxHideLine.Text = Resources.HighlightDialog_UI_CheckBox_HideLine;
         _checkBoxPlugin.Text = Resources.HighlightDialog_UI_CheckBox_Plugin;
         _btnSelectPlugin.Text = Resources.HighlightDialog_UI_Button_SelectPlugin;
         _checkBoxAlertOnHit.Text = Resources.HighlightDialog_UI_CheckBox_AlertOnHit;
@@ -97,6 +98,7 @@ private void LoadFromEntry ()
         _checkBoxBookmark.Checked = _entry.IsSetBookmark;
         _checkBoxStopTail.Checked = _entry.IsStopTail;
         _checkBoxDontDirtyLed.Checked = _entry.IsLedSwitch;
+        _checkBoxHideLine.Checked = _entry.IsHideLine;
         _checkBoxPlugin.Checked = _entry.IsActionEntry;
 
         _checkBoxAlertOnHit.Checked = _entry.AlertOnHit;
@@ -145,6 +147,7 @@ private void SaveToEntry ()
         _entry.BookmarkComment = _bookmarkComment;
         _entry.IsStopTail = _checkBoxStopTail.Checked;
         _entry.IsLedSwitch = _checkBoxDontDirtyLed.Checked;
+        _entry.IsHideLine = _checkBoxHideLine.Checked;
         _entry.IsActionEntry = _checkBoxPlugin.Checked;
         _entry.ActionEntry = (ActionEntry)_currentActionEntry.Clone();
 
diff --git a/src/LogExpert.UI/Interface/ILogPaintContextUI.cs b/src/LogExpert.UI/Interface/ILogPaintContextUI.cs
index 3c11641e..2b4be6f8 100644
--- a/src/LogExpert.UI/Interface/ILogPaintContextUI.cs
+++ b/src/LogExpert.UI/Interface/ILogPaintContextUI.cs
@@ -31,7 +31,7 @@ internal interface ILogPaintContextUI : ILogLineSource
 
     ILogLineMemory GetLogLineMemory (int lineNum);
 
-    IColumnMemory GetCellValue (int rowIndex, int columnIndex);
+    IColumnMemory GetCellValue (int lineNum, int columnIndex);
 
     Bookmark GetBookmarkForLine (int lineNum);
 

From 5690c21c9b8f608c1eed1fc5980cb255e47ed0e8 Mon Sep 17 00:00:00 2001
From: Hirogen <hirogenat@gmail.com>
Date: Sat, 26 Sep 2026 19:55:14 +0200
Subject: [PATCH 03/11] Never read lines under the visibility tracker lock
 (#338)

The UI thread takes the tracker lock (Load/Rebuild/IsScanning) while a
reader call made under it could wait for the UI thread, which could hang
the window. Tail/scan evaluation now reads outside the lock and commits
only if the state is unchanged. Also cancels the scan when the window
closes, fixes marker navigation to lines beyond the visible row count,
adds lifecycle/trigger/marker/perf tests and the CONTEXT.md glossary.
---
 CONTEXT.md                                    |  26 +++
 .../Classes/Highlight/LineVisibilityMap.cs    |   3 +-
 .../Highlight/LineVisibilityTracker.cs        | 165 +++++++++++-------
 .../Controls/ColumnCacheTests.cs              |  38 ++++
 .../Highlight/LineVisibilityTrackerTests.cs   |  26 +++
 .../HiddenLinesWindowTests.cs                 |  94 ++++++++++
 .../LogWindow/LogWindow.LineVisibility.cs     |   2 +
 .../Controls/LogWindow/LogWindow.MarkerBar.cs |   2 +-
 .../Controls/LogWindow/LogWindow.cs           |   1 +
 9 files changed, 294 insertions(+), 63 deletions(-)

diff --git a/CONTEXT.md b/CONTEXT.md
index f203b80b..e657f23a 100644
--- a/CONTEXT.md
+++ b/CONTEXT.md
@@ -23,6 +23,32 @@ meaning; do not redefine them locally.
   construction, since the bulk `HighlightBookmarkScanner` has no access to
   the side-effecting triggers.
 
+## Line hiding
+
+- **Hide-line rule** — A Highlight Entry with `IsHideLine` set. A line is a
+  **Hidden Line** when any matching hide-line rule of the active Highlight Group
+  matches it (`HighlightEvaluator.IsHidden`); no other entry can cancel that,
+  whatever the order. Display state only: hidden lines stay in the reader and
+  remain eligible for Log Search, the Window Filter, Filter Pipes and triggers.
+  Temporary search-hit entries never hide.
+- **Original logical line** — A line index of the Logfile Reader, before hiding.
+  Reader access, bookmarks, timestamps, row heights, sessions and markers use it.
+- **Visible row** — A row of the Log Window's main grid after hiding. Only grid
+  code deals in rows; convert with `RowToLine` / `LineToRow`.
+- **Line Visibility Map** (`LineVisibilityMap`) — The immutable mapping between
+  visible rows and original logical lines, owned by the **Line Visibility
+  Tracker** (`LineVisibilityTracker`), which rebuilds it on a cancellable
+  background scan and extends it on the tail path. Visibility scans never fire
+  triggers.
+- **Show hidden lines** — The per-window, transient override that displays
+  hidden lines without changing any rule. Explicit navigation to a hidden line
+  (Go to Line, bookmarks, Log Search, filter results, time sync, markers, the
+  command-line target) turns it on; tailing and restoring saved positions never
+  do — they select the nearest visible line instead.
+
+*Avoid*: "filtered out" for hidden lines (filtering is the **Window Filter**),
+"row" when an original logical line is meant.
+
 ## Marker Bar
 
 - **Marker Bar** — A compact overview beside a Log Window that shows where
diff --git a/src/LogExpert.Core/Classes/Highlight/LineVisibilityMap.cs b/src/LogExpert.Core/Classes/Highlight/LineVisibilityMap.cs
index 4c0af88f..68ad2437 100644
--- a/src/LogExpert.Core/Classes/Highlight/LineVisibilityMap.cs
+++ b/src/LogExpert.Core/Classes/Highlight/LineVisibilityMap.cs
@@ -119,11 +119,12 @@ public LineVisibilityMap Append (int lineCount, IReadOnlyList<int> hiddenLines)
         ArgumentOutOfRangeException.ThrowIfLessThan(lineCount, LineCount);
 
         var previous = LineCount - 1;
+        // Hidden lines must be ascending and within the appended range.
         foreach (var line in hiddenLines)
         {
             if (line <= previous || line >= lineCount)
             {
-                throw new ArgumentOutOfRangeException(nameof(hiddenLines), line, "Hidden lines must be ascending and within the appended range.");
+                throw new ArgumentOutOfRangeException(nameof(hiddenLines), line, null);
             }
 
             previous = line;
diff --git a/src/LogExpert.Core/Classes/Highlight/LineVisibilityTracker.cs b/src/LogExpert.Core/Classes/Highlight/LineVisibilityTracker.cs
index 4199c106..e285a0f3 100644
--- a/src/LogExpert.Core/Classes/Highlight/LineVisibilityTracker.cs
+++ b/src/LogExpert.Core/Classes/Highlight/LineVisibilityTracker.cs
@@ -12,6 +12,11 @@ namespace LogExpert.Core.Classes.Highlight;
 /// evaluated synchronously by the caller's thread. Evaluation uses <see cref="HighlightEvaluator.IsHidden"/> only,
 /// so it can never fire a trigger.
 /// </para>
+/// <para>
+/// Lines are never read while the lock is held: the UI thread takes the lock too, and a reader call may wait for the
+/// UI thread. Evaluations run against a state snapshot and commit only if the state (<see cref="_version"/>) is
+/// unchanged, retrying otherwise.
+/// </para>
 /// </summary>
 public sealed class LineVisibilityTracker : IDisposable
 {
@@ -19,11 +24,12 @@ public sealed class LineVisibilityTracker : IDisposable
     private readonly Lock _lock = new();
 
     private volatile LineVisibilityMap _map = LineVisibilityMap.Empty;
+    private volatile HighlightEntry[]? _pendingRules;
     private HighlightEntry[] _rules = [];
-    private HighlightEntry[]? _pendingRules;
     private CancellationTokenSource? _scanCts;
     private Task _scanTask = Task.CompletedTask;
     private int _generation;
+    private int _version;
     private bool _disposed;
 
     /// <param name="getLine">Reads an original line; read live, since the reader is replaced on reload.</param>
@@ -41,16 +47,7 @@ public LineVisibilityTracker (Func<int, ITextValueMemory?> getLine)
 
     public LineVisibilityMap Map => _map;
 
-    public bool IsScanning
-    {
-        get
-        {
-            lock (_lock)
-            {
-                return _pendingRules != null;
-            }
-        }
-    }
+    public bool IsScanning => _pendingRules != null;
 
     /// <summary>New content was loaded: every line is visible until the scan with <paramref name="entries"/> completes.</summary>
     public void Load (int lineCount, IEnumerable<HighlightEntry> entries)
@@ -63,8 +60,7 @@ public void Load (int lineCount, IEnumerable<HighlightEntry> entries)
                 return;
             }
 
-            _rules = [];
-            _map = LineVisibilityMap.Identity(lineCount);
+            SetStateLocked(LineVisibilityMap.Identity(lineCount), []);
             StartOrStopScanLocked(rules);
         }
     }
@@ -84,8 +80,8 @@ public void Rebuild (IEnumerable<HighlightEntry> entries)
             StartOrStopScanLocked(rules);
             if (rules.Length == 0 && _map.HiddenCount > 0)
             {
-                _rules = [];
-                _map = cleared = LineVisibilityMap.Identity(_map.LineCount);
+                cleared = LineVisibilityMap.Identity(_map.LineCount);
+                SetStateLocked(cleared, []);
             }
         }
 
@@ -98,20 +94,40 @@ public void Rebuild (IEnumerable<HighlightEntry> entries)
     /// <summary>Tail path: evaluates lines appended up to <paramref name="lineCount"/> and returns the current map.</summary>
     public LineVisibilityMap Extend (int lineCount)
     {
-        Exception? error;
-        LineVisibilityMap map;
-        lock (_lock)
+        while (true)
         {
-            if (_disposed || lineCount <= _map.LineCount)
+            LineVisibilityMap from;
+            HighlightEntry[] rules;
+            int version;
+            lock (_lock)
             {
-                return _map;
+                if (_disposed || lineCount <= _map.LineCount)
+                {
+                    return _map;
+                }
+
+                (from, rules, version) = (_map, _rules, _version);
             }
 
-            (map, error) = EvaluateLocked(_map, lineCount);
-        }
+            var (map, error) = TryEvaluate(from, rules, lineCount);
+            lock (_lock)
+            {
+                if (_disposed)
+                {
+                    return _map;
+                }
+
+                if (version != _version)
+                {
+                    continue;
+                }
 
-        RaiseFailure(map, error);
-        return map;
+                SetStateLocked(map, error == null ? rules : []);
+            }
+
+            RaiseFailure(map, error);
+            return map;
+        }
     }
 
     /// <summary>Tail path, rollover: the first <paramref name="offset"/> lines were dropped.</summary>
@@ -121,7 +137,7 @@ public LineVisibilityMap Shift (int offset)
         {
             if (!_disposed)
             {
-                _map = _map.Shift(offset);
+                SetStateLocked(_map.Shift(offset), _rules);
                 RestartPendingScanLocked();
             }
 
@@ -132,21 +148,40 @@ public LineVisibilityMap Shift (int offset)
     /// <summary>Tail path, truncation: the content was replaced and is re-evaluated up to <paramref name="lineCount"/>.</summary>
     public LineVisibilityMap Replace (int lineCount)
     {
-        Exception? error;
-        LineVisibilityMap map;
-        lock (_lock)
+        while (true)
         {
-            if (_disposed)
+            HighlightEntry[] rules;
+            int version;
+            lock (_lock)
             {
-                return _map;
+                if (_disposed)
+                {
+                    return _map;
+                }
+
+                (rules, version) = (_rules, _version);
             }
 
-            (map, error) = EvaluateLocked(LineVisibilityMap.Empty, lineCount);
-            RestartPendingScanLocked();
-        }
+            var (map, error) = TryEvaluate(LineVisibilityMap.Empty, rules, lineCount);
+            lock (_lock)
+            {
+                if (_disposed)
+                {
+                    return _map;
+                }
+
+                if (version != _version)
+                {
+                    continue;
+                }
 
-        RaiseFailure(map, error);
-        return map;
+                SetStateLocked(map, error == null ? rules : []);
+                RestartPendingScanLocked();
+            }
+
+            RaiseFailure(map, error);
+            return map;
+        }
     }
 
     /// <summary>Completes once no scan is running (including scans restarted meanwhile).</summary>
@@ -183,6 +218,7 @@ public void Dispose ()
 
             _disposed = true;
             _generation++;
+            _version++;
             _pendingRules = null;
             _scanCts?.Cancel();
             _scanCts?.Dispose();
@@ -190,6 +226,13 @@ public void Dispose ()
         }
     }
 
+    private void SetStateLocked (LineVisibilityMap map, HighlightEntry[] rules)
+    {
+        _map = map;
+        _rules = rules;
+        _version++;
+    }
+
     private void StartOrStopScanLocked (HighlightEntry[] rules)
     {
         _generation++;
@@ -219,34 +262,36 @@ private void RestartPendingScanLocked ()
         }
     }
 
+    [System.Diagnostics.CodeAnalysis.SuppressMessage("Design", "CA1031:Do not catch general exception types", Justification = "Any evaluation failure falls back to showing every line and is reported")]
     private void Scan (HighlightEntry[] rules, int lineCount, int generation, CancellationToken token)
     {
         LineVisibilityMap map;
         Exception? error = null;
         try
         {
-            List<int> hidden = [];
-            for (var i = 0; i < lineCount; i++)
-            {
-                token.ThrowIfCancellationRequested();
-                if (IsHiddenLine(rules, i))
-                {
-                    hidden.Add(i);
-                }
-            }
+            map = Evaluate(LineVisibilityMap.Empty, rules, lineCount, token);
 
-            lock (_lock)
+            // Catch up with lines the tail appended while the scan ran, outside the lock, until none are left.
+            while (true)
             {
-                if (generation != _generation)
+                int known;
+                lock (_lock)
                 {
-                    return;
+                    if (generation != _generation)
+                    {
+                        return;
+                    }
+
+                    known = _map.LineCount;
+                    if (known <= map.LineCount)
+                    {
+                        SetStateLocked(map, rules);
+                        _pendingRules = null;
+                        break;
+                    }
                 }
 
-                // Catch up with lines the tail appended while the scan ran.
-                map = Evaluate(LineVisibilityMap.Empty.Append(lineCount, hidden), rules, _map.LineCount);
-                _map = map;
-                _rules = rules;
-                _pendingRules = null;
+                map = Evaluate(map, rules, known, token);
             }
         }
         catch (OperationCanceledException)
@@ -262,8 +307,8 @@ private void Scan (HighlightEntry[] rules, int lineCount, int generation, Cancel
                     return;
                 }
 
-                _map = map = LineVisibilityMap.Identity(_map.LineCount);
-                _rules = [];
+                map = LineVisibilityMap.Identity(_map.LineCount);
+                SetStateLocked(map, []);
                 _pendingRules = null;
                 error = ex;
             }
@@ -272,23 +317,20 @@ private void Scan (HighlightEntry[] rules, int lineCount, int generation, Cancel
         Changed?.Invoke(this, new LineVisibilityChangedEventArgs(map, error));
     }
 
-    private (LineVisibilityMap Map, Exception? Error) EvaluateLocked (LineVisibilityMap from, int lineCount)
+    private (LineVisibilityMap Map, Exception? Error) TryEvaluate (LineVisibilityMap from, HighlightEntry[] rules, int lineCount)
     {
         try
         {
-            _map = Evaluate(from, _rules, lineCount);
-            return (_map, null);
+            return (Evaluate(from, rules, lineCount, CancellationToken.None), null);
         }
         catch (Exception ex) when (ex is not OperationCanceledException)
         {
             // Never publish a partial state: fall back to showing every line.
-            _rules = [];
-            _map = LineVisibilityMap.Identity(lineCount);
-            return (_map, ex);
+            return (LineVisibilityMap.Identity(lineCount), ex);
         }
     }
 
-    private LineVisibilityMap Evaluate (LineVisibilityMap from, HighlightEntry[] rules, int lineCount)
+    private LineVisibilityMap Evaluate (LineVisibilityMap from, HighlightEntry[] rules, int lineCount, CancellationToken token)
     {
         if (lineCount <= from.LineCount)
         {
@@ -300,6 +342,7 @@ private LineVisibilityMap Evaluate (LineVisibilityMap from, HighlightEntry[] rul
         {
             for (var i = from.LineCount; i < lineCount; i++)
             {
+                token.ThrowIfCancellationRequested();
                 if (IsHiddenLine(rules, i))
                 {
                     hidden.Add(i);
diff --git a/src/LogExpert.Tests/Controls/ColumnCacheTests.cs b/src/LogExpert.Tests/Controls/ColumnCacheTests.cs
index 55270c2c..b1e6c564 100644
--- a/src/LogExpert.Tests/Controls/ColumnCacheTests.cs
+++ b/src/LogExpert.Tests/Controls/ColumnCacheTests.cs
@@ -140,4 +140,42 @@ public void MarkPrefetchStale_KeepsBuffersPinned_While_InvalidateReleasesThem ()
         cache.InvalidatePrefetch();
         Assert.That(buffer.IsPinned, Is.False, "InvalidatePrefetch must release the pins.");
     }
+
+    /// <summary>
+    /// Hide-line rules (#338) make visible rows non-contiguous: only the runs of displayed lines are pinned and read,
+    /// never the gap between them, and replacing the prefetch releases the previous pins.
+    /// </summary>
+    [Test]
+    public void PrefetchLines_PinsAndReadsOnlyTheRunsOfDisplayedLines ()
+    {
+        var fileInfo = new Mock<ILogFileInfo>();
+        _ = fileInfo.Setup(f => f.FullName).Returns("fake.log");
+        var buffers = new List<LogBuffer>();
+        var readerMock = new Mock<ILogfileReader>();
+        _ = readerMock.Setup(r => r.GetLogLineMemories(It.IsAny<int>(), It.IsAny<int>()))
+            .Returns((int start, int count) => [.. Enumerable.Range(start, count).Select(i => (ILogLineMemory)new LogLine($"line {i}", i))]);
+        _ = readerMock.As<IBufferPinning>()
+            .Setup(p => p.PinRange(It.IsAny<int>(), It.IsAny<int>()))
+            .Returns((int start, int _) =>
+            {
+                var buffer = new LogBuffer(fileInfo.Object, 10) { StartLine = start };
+                buffer.Pin();
+                buffers.Add(buffer);
+                return new PinHandle([buffer]);
+            });
+        var cache = new ColumnCache();
+
+        cache.PrefetchLines(readerMock.Object, [2, 3, 1000, 1001, 1002]);
+
+        readerMock.As<IBufferPinning>().Verify(p => p.PinRange(2, 3), Times.Once);
+        readerMock.As<IBufferPinning>().Verify(p => p.PinRange(1000, 1002), Times.Once);
+        readerMock.Verify(r => r.GetLogLineMemories(2, 2), Times.Once);
+        readerMock.Verify(r => r.GetLogLineMemories(1000, 3), Times.Once);
+        Assert.That(cache.GetPrefetchedLine(1001)?.FullLine.ToString(), Is.EqualTo("line 1001"));
+        Assert.That(cache.GetPrefetchedLine(500), Is.Null);
+
+        cache.Prefetch(readerMock.Object, 0, 1);
+        Assert.That(buffers.Take(2).All(b => !b.IsPinned), Is.True, "the sparse pins must be released once replaced");
+        Assert.That(cache.GetPrefetchedLine(1001), Is.Null);
+    }
 }
diff --git a/src/LogExpert.Tests/Highlight/LineVisibilityTrackerTests.cs b/src/LogExpert.Tests/Highlight/LineVisibilityTrackerTests.cs
index 83eb8b83..03c4aff7 100644
--- a/src/LogExpert.Tests/Highlight/LineVisibilityTrackerTests.cs
+++ b/src/LogExpert.Tests/Highlight/LineVisibilityTrackerTests.cs
@@ -270,6 +270,32 @@ public void TailFailure_FallsBackToAllVisible ()
         Assert.That(map.HiddenCount, Is.Zero);
     }
 
+    [Test]
+    public void ReaderCallInProgress_NeverBlocksTheOtherCallers ()
+    {
+        _tracker.Load(_lines.Count, HideDebug);
+        Idle();
+        _lines.Add("DEBUG f");
+        _gate.Reset();
+        var extend = Task.Run(() => _tracker.Extend(6));
+        Thread.Sleep(50);
+
+        // The UI thread calls these; a reader call may itself wait for the UI thread, so none may wait for it.
+        var others = Task.Run(() =>
+        {
+            _ = _tracker.IsScanning;
+            _tracker.Rebuild([new HighlightEntry { SearchText = "INFO", IsHideLine = true }]);
+            _ = _tracker.Shift(0);
+            _tracker.Load(_lines.Count, HideDebug);
+        });
+
+        Assert.That(others.Wait(TimeSpan.FromSeconds(2)), Is.True, "a caller waited for a blocked reader call");
+        _gate.Set();
+        Assert.That(extend.Wait(Timeout), Is.True);
+        Idle();
+        Assert.That(VisibleLines(_tracker.Map), Is.EqualTo(new[] { 0, 2, 4 }));
+    }
+
     [Test]
     public void Dispose_CancelsAPendingScan_WithoutPublishing ()
     {
diff --git a/src/LogExpert.UI.Tests/HiddenLinesWindowTests.cs b/src/LogExpert.UI.Tests/HiddenLinesWindowTests.cs
index dcd371d9..9cd02705 100644
--- a/src/LogExpert.UI.Tests/HiddenLinesWindowTests.cs
+++ b/src/LogExpert.UI.Tests/HiddenLinesWindowTests.cs
@@ -253,6 +253,41 @@ public void FollowTail_TracksTheLastVisibleLine_WithoutRevealingAppendedHiddenLi
         Assert.That(grid.FirstDisplayedScrollingRowIndex + grid.DisplayedRowCount(false), Is.GreaterThanOrEqualTo(grid.RowCount));
     }
 
+    [Test]
+    public void Reload_KeepsTheSelectedOriginalLine_AndHidesAgain ()
+    {
+        var log = Open();
+        log.GotoLine(14);
+        var finished = false;
+        log.ProgressBarUpdate += (_, progress) => finished |= !progress.Visible;
+
+        log.Reload();
+        PumpUntil(() => finished);
+        var loaded = Task.Run(log.WaitForLoadingFinished);
+        PumpUntil(() => loaded.IsCompleted);
+        WaitForVisibility(log);
+
+        Assert.That(Grid(log).RowCount, Is.EqualTo(LINE_COUNT / 2));
+        Assert.That(log.CurrentLineNum, Is.EqualTo(14));
+    }
+
+    [Test]
+    public void TailTriggers_StillFireOnHiddenLines_WithoutRevealingThem ()
+    {
+        _settings.Preferences.HighlightGroupList[0].HighlightEntryList.Add(new HighlightEntry { SearchText = "DEBUG 21", IsStopTail = true, IsSetBookmark = true });
+        var log = Open();
+        log.FollowTailChanged(true, false);
+
+        File.AppendAllLines(_fileName, [Text(20), Text(21), Text(22)]);
+        PumpUntil(() => log.GatherSessionSnapshot().LineCount == 23);
+        PumpUntil(() => log.BookmarkData.IsBookmarkAtLine(21));
+        PumpFor(TimeSpan.FromMilliseconds(100));
+
+        Assert.That(log.GatherSessionSnapshot().FollowTail, Is.False);
+        Assert.That(log.ShowHiddenLines, Is.False);
+        Assert.That(log.CurrentLineNum, Is.EqualTo(22), "stop-tail scrolls to the next visible line");
+    }
+
     [Test]
     public void CopySelectedRows_CopiesOnlyTheSelectedVisibleLines ()
     {
@@ -340,6 +375,23 @@ public void WindowFilter_StillFindsHiddenLines ()
         Assert.That(Grid(log).RowCount, Is.EqualTo(LINE_COUNT / 2));
     }
 
+    [Test]
+    public void MarkerClick_OnHiddenLine_RevealsIt ()
+    {
+        _settings.Preferences.ShowMarkerBar = true;
+        var log = Open();
+        log.ToggleBookmark(11);
+        PumpFor(TimeSpan.FromMilliseconds(600));
+        var bar = Find<MarkerBar>(log, "markerBar");
+
+        // The bar raises LineSelected with the original line of the clicked marker; 11 is beyond the 10 visible rows.
+        _ = typeof(LogWindow).GetMethod("OnMarkerLineSelected", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic)!
+            .Invoke(log, [bar, new Core.EventArguments.SelectLineEventArgs(11)]);
+
+        Assert.That(log.CurrentLineNum, Is.EqualTo(11));
+        Assert.That(log.ShowHiddenLines, Is.True);
+    }
+
     [Test]
     public void CommandLineTarget_OnHiddenLine_RevealsItAfterVisibilityInitialization ()
     {
@@ -371,6 +423,48 @@ public void CommandLineTarget_OnVisibleLine_KeepsLinesHidden ()
         Assert.That(log.CurrentLineNum, Is.EqualTo(6));
     }
 
+    [Test, Explicit("Real-file hide-line scan duration, memory and UI responsiveness experiment")]
+    public void LargeFile_ReportsScanDurationMemoryAndUiResponsiveness ()
+    {
+        const int LARGE_LINE_COUNT = 1_000_000;
+        File.WriteAllLines(_fileName, Enumerable.Range(0, LARGE_LINE_COUNT)
+            .Select(i => $"2026-09-26 12:34:56.{i % 1000:D3} {(i % 2 == 1 ? "DEBUG" : "INFO")} worker-{i % 16} message number {i}"));
+        HideRule.IsHideLine = false;
+        var log = Open();
+        var grid = Grid(log);
+        var memoryBefore = GC.GetTotalMemory(true);
+
+        HideRule.IsHideLine = true;
+        var elapsed = Stopwatch.StartNew();
+        log.SetCurrentHighlightGroup("hide");
+        var pump = Stopwatch.StartNew();
+        var maximumPump = TimeSpan.Zero;
+        while (grid.RowCount != LARGE_LINE_COUNT / 2 && elapsed.Elapsed < TimeSpan.FromSeconds(120))
+        {
+            pump.Restart();
+            PumpOnce();
+            maximumPump = maximumPump > pump.Elapsed ? maximumPump : pump.Elapsed;
+            Thread.Sleep(1);
+        }
+
+        var scan = elapsed.Elapsed;
+        Assert.That(grid.RowCount, Is.EqualTo(LARGE_LINE_COUNT / 2));
+        var memoryAfter = GC.GetTotalMemory(true);
+
+        elapsed.Restart();
+        log.GotoLine(LARGE_LINE_COUNT - 1);
+        var reveal = elapsed.Elapsed;
+        elapsed.Restart();
+        log.ShowHiddenLines = false;
+        grid.FirstDisplayedScrollingRowIndex = grid.RowCount / 2;
+        PumpOnce();
+        var scroll = elapsed.Elapsed;
+
+        TestContext.Progress.WriteLine($"Hide-line scan: {new FileInfo(_fileName).Length} bytes, {LARGE_LINE_COUNT} lines, {log.HiddenLineCount} hidden; " +
+            $"scan {scan.TotalMilliseconds:F0} ms; managed delta {memoryAfter - memoryBefore} bytes; maximum UI pump during scan {maximumPump.TotalMilliseconds:F1} ms; " +
+            $"reveal hidden last line {reveal.TotalMilliseconds:F0} ms; override off + mid-file scroll {scroll.TotalMilliseconds:F0} ms.");
+    }
+
     private LogWindow Open ()
     {
         _window = new LogTabWindow([_fileName], 1, false, _config.Object) { ShowInTaskbar = false, Opacity = 0 };
diff --git a/src/LogExpert.UI/Controls/LogWindow/LogWindow.LineVisibility.cs b/src/LogExpert.UI/Controls/LogWindow/LogWindow.LineVisibility.cs
index 345df2d6..286edf53 100644
--- a/src/LogExpert.UI/Controls/LogWindow/LogWindow.LineVisibility.cs
+++ b/src/LogExpert.UI/Controls/LogWindow/LogWindow.LineVisibility.cs
@@ -1,3 +1,4 @@
+using System.ComponentModel;
 using System.Globalization;
 
 using LogExpert.Core.Classes.Highlight;
@@ -30,6 +31,7 @@ internal partial class LogWindow
     internal int HiddenLineCount => _lineVisibility.Map.HiddenCount;
 
     /// <summary>The per-window "Show hidden lines" override. Transient: not saved in the Session File.</summary>
+    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
     internal bool ShowHiddenLines
     {
         get => _showHiddenLines;
diff --git a/src/LogExpert.UI/Controls/LogWindow/LogWindow.MarkerBar.cs b/src/LogExpert.UI/Controls/LogWindow/LogWindow.MarkerBar.cs
index b5a9db3f..1506825f 100644
--- a/src/LogExpert.UI/Controls/LogWindow/LogWindow.MarkerBar.cs
+++ b/src/LogExpert.UI/Controls/LogWindow/LogWindow.MarkerBar.cs
@@ -336,7 +336,7 @@ private void ReportMarkerError (MarkerSnapshot snapshot, ref MarkerSnapshot? rep
     private void OnMarkerLineSelected (object? sender, SelectLineEventArgs eventArgs)
     {
         if (_markerFrame?.Generation == Volatile.Read(ref _markerGeneration)
-            && eventArgs.Line >= 0 && eventArgs.Line < dataGridView.RowCount)
+            && eventArgs.Line >= 0 && eventArgs.Line < _rowMap.LineCount)
         {
             RequestGotoLine(eventArgs.Line + 1);
         }
diff --git a/src/LogExpert.UI/Controls/LogWindow/LogWindow.cs b/src/LogExpert.UI/Controls/LogWindow/LogWindow.cs
index 0c7bf742..c034d0ee 100644
--- a/src/LogExpert.UI/Controls/LogWindow/LogWindow.cs
+++ b/src/LogExpert.UI/Controls/LogWindow/LogWindow.cs
@@ -6028,6 +6028,7 @@ public void CloseLogWindow ()
         CancelPendingLineNavigation();
 
         CancelHighlightBookmarkScan();
+        _lineVisibility.Dispose();
         StopTimespreadThread();
         StopTimestampSyncThread();
         _tailFollowEngine.Stop();

From 4e0bd6b772bed0c8af34d47c0aa2638f802fb4be Mon Sep 17 00:00:00 2001
From: Hirogen <hirogenat@gmail.com>
Date: Sat, 26 Sep 2026 20:47:08 +0200
Subject: [PATCH 04/11] Show no rows until the first hide scan; time-sync
 followers stay hidden (#338)

- While a load's first visibility scan runs the grid shows no rows, and
  saved/reload positions are applied once it has published.
- Windows following a time sync select the nearest visible line; only the
  window the user navigates in reveals a hidden line.
- Review fixes: shared evaluate-and-commit loop in the tracker, one
  publish path for the grid, CurrentLineNum instead of a duplicate
  property, line/row naming, unsubscribe on close, drop unused Truncate.
---
 .../Classes/Highlight/LineVisibilityMap.cs    |  13 --
 .../Highlight/LineVisibilityTracker.cs        |  79 +++++------
 .../Highlight/LineVisibilityMapTests.cs       |  12 --
 .../Highlight/LineVisibilityTrackerTests.cs   |  29 ++++
 .../HiddenLinesWindowTests.cs                 |  72 ++++++++++
 .../LogWindow/LogWindow.LineVisibility.cs     |  88 +++++++++---
 .../Controls/LogWindow/LogWindow.cs           | 133 +++++++-----------
 7 files changed, 254 insertions(+), 172 deletions(-)

diff --git a/src/LogExpert.Core/Classes/Highlight/LineVisibilityMap.cs b/src/LogExpert.Core/Classes/Highlight/LineVisibilityMap.cs
index 68ad2437..79d65876 100644
--- a/src/LogExpert.Core/Classes/Highlight/LineVisibilityMap.cs
+++ b/src/LogExpert.Core/Classes/Highlight/LineVisibilityMap.cs
@@ -155,19 +155,6 @@ public LineVisibilityMap Shift (int offset)
         return new LineVisibilityMap(new HiddenLineStore(shifted, shifted.Length, lineCount), lineCount, shifted.Length);
     }
 
-    /// <summary>Keeps only the first <paramref name="lineCount"/> lines.</summary>
-    public LineVisibilityMap Truncate (int lineCount)
-    {
-        ArgumentOutOfRangeException.ThrowIfNegative(lineCount);
-
-        lineCount = Math.Min(lineCount, LineCount);
-        var kept = Array.BinarySearch(_store.Items, 0, HiddenCount, lineCount);
-        kept = kept >= 0 ? kept : ~kept;
-
-        var items = _store.Items.AsSpan(0, kept).ToArray();
-        return new LineVisibilityMap(new HiddenLineStore(items, kept, lineCount), lineCount, kept);
-    }
-
     /// <summary>
     /// True when this map extends <paramref name="other"/> without changing any of its lines, so rows that
     /// <paramref name="other"/> displays keep their row index.
diff --git a/src/LogExpert.Core/Classes/Highlight/LineVisibilityTracker.cs b/src/LogExpert.Core/Classes/Highlight/LineVisibilityTracker.cs
index e285a0f3..b365ccac 100644
--- a/src/LogExpert.Core/Classes/Highlight/LineVisibilityTracker.cs
+++ b/src/LogExpert.Core/Classes/Highlight/LineVisibilityTracker.cs
@@ -25,6 +25,7 @@ public sealed class LineVisibilityTracker : IDisposable
 
     private volatile LineVisibilityMap _map = LineVisibilityMap.Empty;
     private volatile HighlightEntry[]? _pendingRules;
+    private volatile bool _loadPending;
     private HighlightEntry[] _rules = [];
     private CancellationTokenSource? _scanCts;
     private Task _scanTask = Task.CompletedTask;
@@ -49,6 +50,9 @@ public LineVisibilityTracker (Func<int, ITextValueMemory?> getLine)
 
     public bool IsScanning => _pendingRules != null;
 
+    /// <summary>The scan started by <see cref="Load"/> has not finished: the map does not reflect the rules yet.</summary>
+    public bool IsLoadPending => _loadPending;
+
     /// <summary>New content was loaded: every line is visible until the scan with <paramref name="entries"/> completes.</summary>
     public void Load (int lineCount, IEnumerable<HighlightEntry> entries)
     {
@@ -62,6 +66,7 @@ public void Load (int lineCount, IEnumerable<HighlightEntry> entries)
 
             SetStateLocked(LineVisibilityMap.Identity(lineCount), []);
             StartOrStopScanLocked(rules);
+            _loadPending = rules.Length > 0;
         }
     }
 
@@ -94,40 +99,7 @@ public void Rebuild (IEnumerable<HighlightEntry> entries)
     /// <summary>Tail path: evaluates lines appended up to <paramref name="lineCount"/> and returns the current map.</summary>
     public LineVisibilityMap Extend (int lineCount)
     {
-        while (true)
-        {
-            LineVisibilityMap from;
-            HighlightEntry[] rules;
-            int version;
-            lock (_lock)
-            {
-                if (_disposed || lineCount <= _map.LineCount)
-                {
-                    return _map;
-                }
-
-                (from, rules, version) = (_map, _rules, _version);
-            }
-
-            var (map, error) = TryEvaluate(from, rules, lineCount);
-            lock (_lock)
-            {
-                if (_disposed)
-                {
-                    return _map;
-                }
-
-                if (version != _version)
-                {
-                    continue;
-                }
-
-                SetStateLocked(map, error == null ? rules : []);
-            }
-
-            RaiseFailure(map, error);
-            return map;
-        }
+        return EvaluateAndCommit(lineCount, replace: false);
     }
 
     /// <summary>Tail path, rollover: the first <paramref name="offset"/> lines were dropped.</summary>
@@ -147,22 +119,32 @@ public LineVisibilityMap Shift (int offset)
 
     /// <summary>Tail path, truncation: the content was replaced and is re-evaluated up to <paramref name="lineCount"/>.</summary>
     public LineVisibilityMap Replace (int lineCount)
+    {
+        return EvaluateAndCommit(lineCount, replace: true);
+    }
+
+    /// <summary>
+    /// Evaluates against a snapshot outside the lock, then commits only if the state is unchanged, retrying otherwise.
+    /// <paramref name="replace"/> re-evaluates from the first line and restarts a pending scan on the new content.
+    /// </summary>
+    private LineVisibilityMap EvaluateAndCommit (int lineCount, bool replace)
     {
         while (true)
         {
+            LineVisibilityMap from;
             HighlightEntry[] rules;
             int version;
             lock (_lock)
             {
-                if (_disposed)
+                if (_disposed || (!replace && lineCount <= _map.LineCount))
                 {
                     return _map;
                 }
 
-                (rules, version) = (_rules, _version);
+                (from, rules, version) = (replace ? LineVisibilityMap.Empty : _map, _rules, _version);
             }
 
-            var (map, error) = TryEvaluate(LineVisibilityMap.Empty, rules, lineCount);
+            var (map, error) = TryEvaluate(from, rules, lineCount);
             lock (_lock)
             {
                 if (_disposed)
@@ -176,10 +158,17 @@ public LineVisibilityMap Replace (int lineCount)
                 }
 
                 SetStateLocked(map, error == null ? rules : []);
-                RestartPendingScanLocked();
+                if (replace)
+                {
+                    RestartPendingScanLocked();
+                }
+            }
+
+            if (error != null)
+            {
+                Changed?.Invoke(this, new LineVisibilityChangedEventArgs(map, error));
             }
 
-            RaiseFailure(map, error);
             return map;
         }
     }
@@ -220,6 +209,7 @@ public void Dispose ()
             _generation++;
             _version++;
             _pendingRules = null;
+            _loadPending = false;
             _scanCts?.Cancel();
             _scanCts?.Dispose();
             _scanCts = null;
@@ -243,6 +233,7 @@ private void StartOrStopScanLocked (HighlightEntry[] rules)
 
         if (rules.Length == 0)
         {
+            _loadPending = false;
             return;
         }
 
@@ -287,6 +278,7 @@ private void Scan (HighlightEntry[] rules, int lineCount, int generation, Cancel
                     {
                         SetStateLocked(map, rules);
                         _pendingRules = null;
+                        _loadPending = false;
                         break;
                     }
                 }
@@ -310,6 +302,7 @@ private void Scan (HighlightEntry[] rules, int lineCount, int generation, Cancel
                 map = LineVisibilityMap.Identity(_map.LineCount);
                 SetStateLocked(map, []);
                 _pendingRules = null;
+                _loadPending = false;
                 error = ex;
             }
         }
@@ -360,14 +353,6 @@ private bool IsHiddenLine (HighlightEntry[] rules, int lineNum)
         return line != null && HighlightEvaluator.IsHidden(rules, line);
     }
 
-    private void RaiseFailure (LineVisibilityMap map, Exception? error)
-    {
-        if (error != null)
-        {
-            Changed?.Invoke(this, new LineVisibilityChangedEventArgs(map, error));
-        }
-    }
-
     private static HighlightEntry[] Snapshot (IEnumerable<HighlightEntry> entries)
     {
         ArgumentNullException.ThrowIfNull(entries);
diff --git a/src/LogExpert.Tests/Highlight/LineVisibilityMapTests.cs b/src/LogExpert.Tests/Highlight/LineVisibilityMapTests.cs
index 51d40b66..b4f0bd14 100644
--- a/src/LogExpert.Tests/Highlight/LineVisibilityMapTests.cs
+++ b/src/LogExpert.Tests/Highlight/LineVisibilityMapTests.cs
@@ -127,16 +127,4 @@ public void Shift_DropsLeadingLines_AndRenumbersTheRest ()
         Assert.That(shifted.HiddenCount, Is.EqualTo(2));
         Assert.That(shifted.IsAppendOf(map), Is.False);
     }
-
-    [Test]
-    public void Truncate_DropsTrailingLines ()
-    {
-        var map = Map(10, 1, 5, 8);
-
-        var truncated = map.Truncate(6);
-
-        Assert.That(truncated.LineCount, Is.EqualTo(6));
-        Assert.That(truncated.HiddenCount, Is.EqualTo(2));
-        Assert.That(truncated.VisibleCount, Is.EqualTo(4));
-    }
 }
diff --git a/src/LogExpert.Tests/Highlight/LineVisibilityTrackerTests.cs b/src/LogExpert.Tests/Highlight/LineVisibilityTrackerTests.cs
index 03c4aff7..726cab18 100644
--- a/src/LogExpert.Tests/Highlight/LineVisibilityTrackerTests.cs
+++ b/src/LogExpert.Tests/Highlight/LineVisibilityTrackerTests.cs
@@ -80,11 +80,40 @@ public void Load_UntilScanCompletes_EveryLineStaysVisible ()
         Assert.That(_tracker.Map.VisibleCount, Is.EqualTo(3));
     }
 
+    [Test]
+    public void Load_IsPendingUntilItsScanCompletes_ButARuleRebuildIsNot ()
+    {
+        _gate.Reset();
+        _tracker.Load(_lines.Count, HideDebug);
+
+        Assert.That(_tracker.IsLoadPending, Is.True);
+        _gate.Set();
+        Idle();
+        Assert.That(_tracker.IsLoadPending, Is.False);
+
+        _gate.Reset();
+        _tracker.Rebuild([new HighlightEntry { SearchText = "INFO", IsHideLine = true }]);
+        Assert.That(_tracker.IsScanning, Is.True);
+        Assert.That(_tracker.IsLoadPending, Is.False, "a rule change keeps showing the previous map");
+    }
+
+    [Test]
+    public void Load_RulesRemovedWhilePending_IsNoLongerPending ()
+    {
+        _gate.Reset();
+        _tracker.Load(_lines.Count, HideDebug);
+
+        _tracker.Rebuild([]);
+
+        Assert.That(_tracker.IsLoadPending, Is.False);
+    }
+
     [Test]
     public void Load_WithoutHideRules_IsImmediatelyComplete ()
     {
         _tracker.Load(_lines.Count, [new HighlightEntry { SearchText = "DEBUG" }]);
 
+        Assert.That(_tracker.IsLoadPending, Is.False);
         Assert.That(_tracker.IsScanning, Is.False);
         Assert.That(_tracker.Map.VisibleCount, Is.EqualTo(5));
     }
diff --git a/src/LogExpert.UI.Tests/HiddenLinesWindowTests.cs b/src/LogExpert.UI.Tests/HiddenLinesWindowTests.cs
index 9cd02705..0bcfd6ca 100644
--- a/src/LogExpert.UI.Tests/HiddenLinesWindowTests.cs
+++ b/src/LogExpert.UI.Tests/HiddenLinesWindowTests.cs
@@ -4,7 +4,9 @@
 
 using ColumnizerLib;
 
+using LogExpert.Core.Classes.Columnizer;
 using LogExpert.Core.Classes.Highlight;
+using LogExpert.Core.Classes.Persister;
 using LogExpert.Core.Config;
 using LogExpert.Core.Entities;
 using LogExpert.Core.Interfaces;
@@ -111,6 +113,67 @@ public void Load_HideRule_RemovesMatchingRows_AndKeepsOriginalLineNumbers ()
         Assert.That(Find<Panel>(log, "hiddenLinesBar").Visible, Is.True);
     }
 
+    [Test]
+    public void Load_ShowsNoRowsUntilTheFirstScanHasFinished ()
+    {
+        File.WriteAllLines(_fileName, Enumerable.Range(0, 20_000).Select(Text));
+        _window = new LogTabWindow([_fileName], 1, false, _config.Object) { ShowInTaskbar = false, Opacity = 0 };
+        Find<WeifenLuo.WinFormsUI.Docking.DockPanel>(_window, "dockPanel").ShowDocumentIcon = false;
+        _window.Show();
+        PumpUntil(() => _window.CurrentLogWindow != null);
+        var log = _window.CurrentLogWindow;
+        var grid = Grid(log);
+        var largest = 0;
+        grid.RowsAdded += (_, _) => largest = Math.Max(largest, grid.RowCount);
+
+        PumpUntil(() => grid.RowCount == 10_000 && log.WhenLineVisibilityIdle().IsCompleted);
+
+        Assert.That(largest, Is.EqualTo(10_000), "hidden lines must never be shown while the first scan runs");
+    }
+
+    [TestCase(12, 12)]
+    [TestCase(13, 14)]
+    public void SavedPosition_IsRestoredOnceTheFirstScanHasFinished (int savedLine, int expectedLine)
+    {
+        _settings.Preferences.SaveSessions = true;
+        _ = Persister.SavePersistenceData(_fileName, new PersistenceData
+        {
+            FileName = _fileName,
+            CurrentLine = savedLine,
+            FirstDisplayedLine = savedLine,
+            FollowTail = false,
+            HighlightGroupName = "hide",
+            LineCount = LINE_COUNT
+        }, _settings.Preferences, _directory);
+
+        var log = Open();
+
+        Assert.That(log.CurrentLineNum, Is.EqualTo(expectedLine));
+        Assert.That(log.ShowHiddenLines, Is.False);
+    }
+
+    [Test]
+    public void TimeSync_FollowerOnHiddenLine_SelectsTheNearestVisibleLine ()
+    {
+        var log = OpenTimestamped();
+
+        _ = log.ScrollToTimestamp(new DateTime(2026, 1, 1, 10, 0, 5), false, false);
+
+        Assert.That(log.ShowHiddenLines, Is.False);
+        Assert.That(log.CurrentLineNum, Is.EqualTo(6));
+    }
+
+    [Test]
+    public void TimestampNavigation_InTheOriginWindow_RevealsTheHiddenLine ()
+    {
+        var log = OpenTimestamped();
+
+        _ = log.ScrollToTimestamp(new DateTime(2026, 1, 1, 10, 0, 5), false, true);
+
+        Assert.That(log.ShowHiddenLines, Is.True);
+        Assert.That(log.CurrentLineNum, Is.EqualTo(5));
+    }
+
     [Test]
     public void ShowHiddenLines_ShowsEveryLine_WithoutChangingTheRules ()
     {
@@ -480,6 +543,15 @@ private LogWindow Open ()
         return log;
     }
 
+    private LogWindow OpenTimestamped ()
+    {
+        File.WriteAllLines(_fileName, Enumerable.Range(0, LINE_COUNT).Select(i => $"2026-01-01 10:00:{i:D2}.000 {Text(i)}"));
+        var log = Open();
+        log.ForceColumnizer(new TimestampColumnizer());
+        WaitForVisibility(log);
+        return log;
+    }
+
     private void WaitForVisibility (LogWindow log)
     {
         var idle = log.WhenLineVisibilityIdle();
diff --git a/src/LogExpert.UI/Controls/LogWindow/LogWindow.LineVisibility.cs b/src/LogExpert.UI/Controls/LogWindow/LogWindow.LineVisibility.cs
index 286edf53..ef75f5f2 100644
--- a/src/LogExpert.UI/Controls/LogWindow/LogWindow.LineVisibility.cs
+++ b/src/LogExpert.UI/Controls/LogWindow/LogWindow.LineVisibility.cs
@@ -6,7 +6,7 @@
 namespace LogExpert.UI.Controls.LogWindow;
 
 /// <summary>
-/// Hide-line highlight rules (#338). The main grid shows the rows of <see cref="_rowMap"/>; everything that talks
+/// Hide-line highlight rules. The main grid shows the rows of <see cref="_rowMap"/>; everything that talks
 /// to the reader, bookmarks, timestamps or sessions uses original logical lines, converted with
 /// <see cref="RowToLine"/> / <see cref="LineToRow"/>. The Window Filter grid is unaffected.
 /// </summary>
@@ -27,6 +27,9 @@ internal partial class LogWindow
     private bool _showHiddenLines;
     private bool _isLoadComplete;
 
+    // A saved or reload position (original lines) waiting for the load's first scan.
+    private (int CurrentLine, int FirstDisplayedLine)? _pendingPosition;
+
     /// <summary>Number of lines the active hide rules remove, whether or not the override shows them.</summary>
     internal int HiddenLineCount => _lineVisibility.Map.HiddenCount;
 
@@ -76,6 +79,7 @@ private void InitializeLineVisibility ()
     private void ResetLineVisibility ()
     {
         _isLoadComplete = false;
+        _pendingPosition = null;
         _lineVisibility.Load(0, []);
         _rowMap = LineVisibilityMap.Empty;
         _appliedTrackedMap = _lineVisibility.Map;
@@ -97,7 +101,7 @@ private void UpdateTopRowHeight ()
 
     private void UpdateHiddenLinesBar ()
     {
-        var hidden = _lineVisibility.Map.HiddenCount;
+        var hidden = HiddenLineCount;
         _hiddenLinesLabel.Text = string.Format(CultureInfo.CurrentCulture, Resources.LogWindow_UI_Label_HiddenLines, hidden);
         _showHiddenLinesCheckBox.Checked = _showHiddenLines;
 
@@ -125,7 +129,7 @@ private void RebuildLineVisibility ()
         }
     }
 
-    private void OnLineVisibilityChanged (object sender, LineVisibilityChangedEventArgs e)
+    private void OnLineVisibilityChanged (object? sender, LineVisibilityChangedEventArgs e)
     {
         if (_isClosing || IsDisposed || Disposing)
         {
@@ -162,17 +166,23 @@ protected override void OnHandleCreated (EventArgs e)
     }
 
     /// <summary>
-    /// The map the grid should display for <paramref name="tracked"/>: the tracked map itself, or, with the
-    /// override on, an identity map that keeps growing in place so tail appends stay appends.
+    /// The map the grid should display for <paramref name="tracked"/>: no rows while the load's first scan runs, the
+    /// tracked map itself, or, with the override on, an identity map that keeps growing in place so tail appends
+    /// stay appends.
     /// </summary>
     private LineVisibilityMap EffectiveMap (LineVisibilityMap tracked)
     {
+        var current = _rowMap;
         if (!_showHiddenLines)
         {
-            return tracked;
+            if (!_lineVisibility.IsLoadPending)
+            {
+                return tracked;
+            }
+
+            return current.LineCount == 0 ? current : LineVisibilityMap.Empty;
         }
 
-        var current = _rowMap;
         return current.HiddenCount == 0 && current.LineCount <= tracked.LineCount && tracked.IsAppendOf(_appliedTrackedMap)
             ? current.Append(tracked.LineCount, [])
             : LineVisibilityMap.Identity(tracked.LineCount);
@@ -190,24 +200,67 @@ private void ApplyLineVisibility ()
             return;
         }
 
+        if (PublishTrackedMap(0) && _guiStateArgs.FollowTail && dataGridView.RowCount > 0)
+        {
+            _columnCache.MarkPrefetchStale();
+            dataGridView.FirstDisplayedScrollingRowIndex = dataGridView.RowCount - 1;
+        }
+
+        dataGridView.Invalidate();
+        UpdateLineNavigationReadiness();
+    }
+
+    /// <summary>Switches the grid to the tracker's current map; returns whether the displayed map changed.</summary>
+    private bool PublishTrackedMap (int rolloverOffset)
+    {
         var tracked = _lineVisibility.Map;
         var newMap = EffectiveMap(tracked);
         _appliedTrackedMap = tracked;
 
-        if (!ReferenceEquals(newMap, _rowMap))
+        var changed = !ReferenceEquals(newMap, _rowMap);
+        if (changed)
         {
-            SetRowMap(newMap, 0);
-            if (_guiStateArgs.FollowTail && dataGridView.RowCount > 0)
-            {
-                _columnCache.MarkPrefetchStale();
-                dataGridView.FirstDisplayedScrollingRowIndex = dataGridView.RowCount - 1;
-            }
+            SetRowMap(newMap, rolloverOffset);
+        }
 
-            dataGridView.Invalidate();
+        if (_pendingPosition is { } position && !_lineVisibility.IsLoadPending)
+        {
+            _pendingPosition = null;
+            ApplyPosition(position.CurrentLine, position.FirstDisplayedLine);
         }
 
         UpdateHiddenLinesBar();
-        UpdateLineNavigationReadiness();
+        return changed;
+    }
+
+    /// <summary>
+    /// Restores a saved or reload position (original lines; a hidden one resolves to the nearest visible line),
+    /// deferred until the load's first scan has published the rows.
+    /// </summary>
+    private void RestorePosition (int currentLine, int firstDisplayedLine)
+    {
+        if (_lineVisibility.IsLoadPending && !_showHiddenLines)
+        {
+            _pendingPosition = (currentLine, firstDisplayedLine);
+            return;
+        }
+
+        ApplyPosition(currentLine, firstDisplayedLine);
+    }
+
+    private void ApplyPosition (int currentLine, int firstDisplayedLine)
+    {
+        var currentRow = currentLine >= 0 ? _rowMap.NearestRow(currentLine) : -1;
+        if (currentRow >= 0)
+        {
+            SelectRow(currentRow, false, true);
+        }
+
+        var firstRow = firstDisplayedLine >= 0 ? _rowMap.NearestRow(firstDisplayedLine) : -1;
+        if (firstRow >= 0)
+        {
+            dataGridView.FirstDisplayedScrollingRowIndex = firstRow;
+        }
     }
 
     /// <summary>
@@ -275,9 +328,6 @@ private int LineToRow (int line)
         return _rowMap.LineToRow(line);
     }
 
-    /// <summary>Original line of the current main-grid row, or -1.</summary>
-    private int CurrentLogicalLine => RowToLine(dataGridView.CurrentCellAddress.Y);
-
     /// <summary>
     /// Explicit navigation to an original line: a line beyond the end resolves to the last row; a hidden line turns
     /// on "Show hidden lines" so that exact line can be selected. Returns the row, or -1.
diff --git a/src/LogExpert.UI/Controls/LogWindow/LogWindow.cs b/src/LogExpert.UI/Controls/LogWindow/LogWindow.cs
index c034d0ee..82dc995a 100644
--- a/src/LogExpert.UI/Controls/LogWindow/LogWindow.cs
+++ b/src/LogExpert.UI/Controls/LogWindow/LogWindow.cs
@@ -705,7 +705,7 @@ private void OnButtonSizeChanged (object sender, EventArgs e)
     [SupportedOSPlatform("windows")]
     internal void DumpBufferInfo ()
     {
-        _logFileReader.LogBufferInfoForLine(CurrentLogicalLine);
+        _logFileReader.LogBufferInfoForLine(CurrentLineNum);
     }
 
     internal void DumpBufferDiagnostic ()
@@ -1665,7 +1665,7 @@ private void OnScrollAllTabsToTimestampToolStripMenuItemClick (object sender, Ev
     {
         if (CurrentColumnizer.IsTimeshiftImplemented())
         {
-            var currentLine = CurrentLogicalLine;
+            var currentLine = CurrentLineNum;
             if (currentLine > 0)
             {
                 var (timeStamp, _) = GetTimestampForLine(currentLine, false);
@@ -2671,26 +2671,15 @@ private void LoadPersistenceData ()
             _rowHeightList = snapshot.RowHeightList;
             try
             {
-                // Saved positions are original lines; a hidden one resolves to the nearest visible line.
-                if (snapshot.CurrentLine >= 0 && snapshot.CurrentLine < _logFileReader.LineCount)
-                {
-                    SelectNearestLine(snapshot.CurrentLine, false, true);
-                }
-                else
-                {
-                    if (dataGridView.RowCount > 0)
-                    {
-                        dataGridView.FirstDisplayedScrollingRowIndex = dataGridView.RowCount - 1;
-                        SelectRow(dataGridView.RowCount - 1, false, true);
-                    }
-                }
-
-                if (snapshot.FirstDisplayedLine >= 0 &&
-                    snapshot.FirstDisplayedLine < _logFileReader.LineCount &&
-                    _rowMap.NearestRow(snapshot.FirstDisplayedLine) >= 0)
-                {
-                    dataGridView.FirstDisplayedScrollingRowIndex = _rowMap.NearestRow(snapshot.FirstDisplayedLine);
-                }
+                // Saved positions are original lines; without a valid one, the last line is selected.
+                var lineCount = _logFileReader.LineCount;
+                var currentLine = snapshot.CurrentLine >= 0 && snapshot.CurrentLine < lineCount
+                    ? snapshot.CurrentLine
+                    : lineCount - 1;
+                var firstLine = snapshot.FirstDisplayedLine >= 0 && snapshot.FirstDisplayedLine < lineCount
+                    ? snapshot.FirstDisplayedLine
+                    : currentLine;
+                RestorePosition(currentLine, firstLine);
 
                 // Applied once, here (was double-applied: always pre-load, here only when true).
                 // Applying true after positioning keeps the jump-to-tail semantics.
@@ -2824,22 +2813,11 @@ private void EnterLoadFileStatus ()
     [SupportedOSPlatform("windows")]
     private void PositionAfterReload (ReloadMemento reloadMemento)
     {
-        // The memento holds original lines; hidden ones resolve to the nearest visible row.
-        var currentRow = _reloadMemento.CurrentLine >= 0 && _reloadMemento.CurrentLine < _rowMap.LineCount
-            ? _rowMap.NearestRow(_reloadMemento.CurrentLine)
-            : -1;
-        if (currentRow >= 0)
-        {
-            dataGridView.CurrentCell = dataGridView.Rows[currentRow].Cells[0];
-        }
-
-        var firstRow = _reloadMemento.FirstDisplayedLine >= 0 && _reloadMemento.FirstDisplayedLine < _rowMap.LineCount
-            ? _rowMap.NearestRow(_reloadMemento.FirstDisplayedLine)
-            : -1;
-        if (firstRow >= 0)
-        {
-            dataGridView.FirstDisplayedScrollingRowIndex = firstRow;
-        }
+        // The memento holds original lines; ones beyond the reloaded content are ignored.
+        var lineCount = _logFileReader.LineCount;
+        RestorePosition(
+            _reloadMemento.CurrentLine < lineCount ? _reloadMemento.CurrentLine : -1,
+            _reloadMemento.FirstDisplayedLine < lineCount ? _reloadMemento.FirstDisplayedLine : -1);
     }
 
     [SupportedOSPlatform("windows")]
@@ -3157,15 +3135,7 @@ private void UpdateGrid (LogEventArgs logEventArgs)
             // The engine thread already applied this event to the tracker (OnRolloverShift / OnTailLines). An append
             // only grows the rows; a rollover or truncation rebuilds them and, without follow-tail, keeps the
             // selected and first displayed original lines (moved up by the rollover offset).
-            var tracked = _lineVisibility.Map;
-            var newMap = EffectiveMap(tracked);
-            _appliedTrackedMap = tracked;
-            if (!ReferenceEquals(newMap, _rowMap))
-            {
-                SetRowMap(newMap, logEventArgs.IsRollover ? logEventArgs.RolloverOffset : 0);
-            }
-
-            UpdateHiddenLinesBar();
+            _ = PublishTrackedMap(logEventArgs.IsRollover ? logEventArgs.RolloverOffset : 0);
 
             _statusEventArgs.LineCount = logEventArgs.LineCount;
             StatusLineFileSize(logEventArgs.FileSize);
@@ -3983,15 +3953,15 @@ private void SyncTimestampDisplayWorker ()
             // show time difference between 2 selected lines
             if (dataGridView.SelectedRows.Count == 2)
             {
-                var row1 = RowToLine(dataGridView.SelectedRows[0].Index);
-                var row2 = RowToLine(dataGridView.SelectedRows[1].Index);
-                if (row1 > row2)
+                var line1 = RowToLine(dataGridView.SelectedRows[0].Index);
+                var line2 = RowToLine(dataGridView.SelectedRows[1].Index);
+                if (line1 > line2)
                 {
-                    (row2, row1) = (row1, row2);
+                    (line2, line1) = (line1, line2);
                 }
 
-                var (timeStamp1, _) = GetTimestampForLine(row1, false);
-                var (timeStamp2, _) = GetTimestampForLine(row2, false);
+                var (timeStamp1, _) = GetTimestampForLine(line1, false);
+                var (timeStamp2, _) = GetTimestampForLine(line2, false);
                 //TimeSpan span = TimeSpan.FromTicks(timeStamp2.Ticks - timeStamp1.Ticks);
                 var diff = timeStamp1.Ticks > timeStamp2.Ticks
                     ? new DateTime(timeStamp1.Ticks - timeStamp2.Ticks)
@@ -4096,7 +4066,6 @@ private void ResetProgressBar ()
     [SupportedOSPlatform("windows")]
     private void SelectLine (int lineNum, bool triggerSyncCall, bool shouldScroll)
     {
-        _shouldCallTimeSync = triggerSyncCall;
         SelectRow(RevealLine(lineNum), triggerSyncCall, shouldScroll);
     }
 
@@ -4104,7 +4073,6 @@ private void SelectLine (int lineNum, bool triggerSyncCall, bool shouldScroll)
     [SupportedOSPlatform("windows")]
     private void SelectNearestLine (int lineNum, bool triggerSyncCall, bool shouldScroll)
     {
-        _shouldCallTimeSync = triggerSyncCall;
         SelectRow(lineNum < 0 ? -1 : _rowMap.NearestRow(lineNum), triggerSyncCall, shouldScroll);
     }
 
@@ -4185,7 +4153,7 @@ private void UpdateEditColumnDisplay (DataGridViewTextBoxEditingControl editCont
     [SupportedOSPlatform("windows")]
     private void SelectPrevHighlightLine ()
     {
-        var lineNum = CurrentLogicalLine;
+        var lineNum = CurrentLineNum;
         while (lineNum > 0)
         {
             lineNum--;
@@ -4205,7 +4173,7 @@ private void SelectPrevHighlightLine ()
     [SupportedOSPlatform("windows")]
     private void SelectNextHighlightLine ()
     {
-        var lineNum = CurrentLogicalLine;
+        var lineNum = CurrentLineNum;
         while (lineNum < _logFileReader.LineCount)
         {
             lineNum++;
@@ -5488,7 +5456,7 @@ private void AddBookmarkAtLineSilently (int lineNum)
     [SupportedOSPlatform("windows")]
     private void AddBookmarkAndEditComment ()
     {
-        var lineNum = CurrentLogicalLine;
+        var lineNum = CurrentLineNum;
         if (!_bookmarkProvider.IsBookmarkAtLine(lineNum))
         {
             ToggleBookmark();
@@ -5500,7 +5468,7 @@ private void AddBookmarkAndEditComment ()
     [SupportedOSPlatform("windows")]
     private void AddBookmarkComment (string text)
     {
-        var lineNum = CurrentLogicalLine;
+        var lineNum = CurrentLineNum;
         Bookmark bookmark;
 
         if (!_bookmarkProvider.IsBookmarkAtLine(lineNum))
@@ -5524,7 +5492,7 @@ private void MarkCurrentFilterRange ()
         _filterParams.RangeSearchText = filterRangeComboBox.Text;
         ColumnizerCallback callback = new(this);
         RangeFinder rangeFinder = new(_filterParams, callback);
-        var range = rangeFinder.FindRange(CurrentLogicalLine);
+        var range = rangeFinder.FindRange(CurrentLineNum);
         if (range != null)
         {
             SetCellSelectionMode(false);
@@ -5631,7 +5599,7 @@ private void AddSlaveToTimesync (LogWindow slave)
                     TimeSyncList = slave.TimeSyncList;
                 }
 
-                var currentLineNum = CurrentLogicalLine;
+                var currentLineNum = CurrentLineNum;
                 var (timeStamp, _) = GetTimestampForLine(currentLineNum, true);
                 if (!timeStamp.Equals(DateTime.MinValue) && !_shouldTimestampDisplaySyncingCancel)
                 {
@@ -5968,7 +5936,7 @@ public SessionSnapshot GatherSessionSnapshot ()
             MultiFile = IsMultiFile,
             MultiFilePattern = _multiFileOptions.FormatPattern,
             MultiFileMaxDays = _multiFileOptions.MaxDayTry,
-            CurrentLine = CurrentLogicalLine,
+            CurrentLine = CurrentLineNum,
             FirstDisplayedLine = RowToLine(dataGridView.FirstDisplayedScrollingRowIndex),
             FilterVisible = !splitContainerLogWindow.Panel2Collapsed,
             FilterAdvanced = !advancedFilterSplitContainer.Panel1Collapsed,
@@ -6028,6 +5996,7 @@ public void CloseLogWindow ()
         CancelPendingLineNavigation();
 
         CancelHighlightBookmarkScan();
+        _lineVisibility.Changed -= OnLineVisibilityChanged;
         _lineVisibility.Dispose();
         StopTimespreadThread();
         StopTimestampSyncThread();
@@ -6294,11 +6263,11 @@ public void CellPainting (bool focused, int rowIndex, int columnIndex, bool isFi
             return;
         }
 
-        rowIndex = isFilteredGridView
+        var lineNum = isFilteredGridView
             ? _filterResultList[rowIndex]
             : RowToLine(rowIndex);
 
-        if (rowIndex < 0)
+        if (lineNum < 0)
         {
             e.Handled = false;
             return;
@@ -6319,8 +6288,8 @@ public void CellPainting (bool focused, int rowIndex, int columnIndex, bool isFi
 
         // Use only prefetched (pinned) data — no unprotected fallback
         ILogLineMemory line = !isFilteredGridView
-            ? _columnCache.GetPrefetchedLine(rowIndex)
-            : _filterColumnCache.GetPrefetchedLine(rowIndex);
+            ? _columnCache.GetPrefetchedLine(lineNum)
+            : _filterColumnCache.GetPrefetchedLine(lineNum);
 
         if (line == null)
         {
@@ -6330,13 +6299,13 @@ public void CellPainting (bool focused, int rowIndex, int columnIndex, bool isFi
             // very small files with only one visible row), and PrefetchVisibleLines
             // therefore short-circuits without pinning anything.
             var targetCache = !isFilteredGridView ? _columnCache : _filterColumnCache;
-            targetCache.Prefetch(_logFileReader, rowIndex, 1);
-            line = targetCache.GetPrefetchedLine(rowIndex);
+            targetCache.Prefetch(_logFileReader, lineNum, 1);
+            line = targetCache.GetPrefetchedLine(lineNum);
         }
 
         if (line == null)
         {
-            _logger.Warn("CellPainting: null line for rowIndex={0}, isFilteredGridView={1}", rowIndex, isFilteredGridView);
+            _logger.Warn("CellPainting: null line for lineNum={0}, isFilteredGridView={1}", lineNum, isFilteredGridView);
 
             // Paint an empty cell with proper colors to prevent white-on-white default rendering
             e.Graphics.SetClip(e.CellBounds);
@@ -6374,13 +6343,13 @@ public void CellPainting (bool focused, int rowIndex, int columnIndex, bool isFi
 
             if (columnIndex == 0)
             {
-                if (_bookmarkProvider.IsBookmarkAtLine(rowIndex))
+                if (_bookmarkProvider.IsBookmarkAtLine(lineNum))
                 {
                     //keeping this comment, because it's the original code
                     // = new Rectangle(e.CellBounds.Left + 2, e.CellBounds.Top + 2, 6, 6);
                     var rect = e.CellBounds;
                     rect.Inflate(-2, -2);
-                    var bookmark = _bookmarkProvider.GetBookmarkForLine(rowIndex);
+                    var bookmark = _bookmarkProvider.GetBookmarkForLine(lineNum);
                     var bookmarkColor = bookmark.IsAutoGenerated ? AutoBookmarkColor : BookmarkColor;
                     using var brush = new SolidBrush(bookmarkColor);
                     e.Graphics.FillRectangle(brush, rect);
@@ -6578,8 +6547,8 @@ public void StartSearch ()
         var searchParams = _logWindowCoordinator.SearchParams;
 
         searchParams.CurrentLine = LogSearcher.ResolveDirection(searchParams) == SearchDirection.Forward
-            ? CurrentLogicalLine + 1
-            : CurrentLogicalLine - 1;
+            ? CurrentLineNum + 1
+            : CurrentLineNum - 1;
 
         _currentSearchParams = searchParams; // remember for async "not found" messages
         TrackMarkerSearch(searchParams);
@@ -6737,7 +6706,7 @@ public void OnLogWindowKeyDown (object sender, KeyEventArgs e)
                 }
             case Keys.Down when e.Modifiers == Keys.Alt:
                 {
-                    var newLine = _logFileReader.GetNextMultiFileLine(CurrentLogicalLine);
+                    var newLine = _logFileReader.GetNextMultiFileLine(CurrentLineNum);
 
                     if (newLine != -1)
                     {
@@ -6750,7 +6719,7 @@ public void OnLogWindowKeyDown (object sender, KeyEventArgs e)
                 }
             case Keys.Up when e.Modifiers == Keys.Alt:
                 {
-                    var newLine = _logFileReader.GetPrevMultiFileLine(CurrentLogicalLine);
+                    var newLine = _logFileReader.GetPrevMultiFileLine(CurrentLineNum);
 
                     if (newLine != -1)
                     {
@@ -6904,7 +6873,7 @@ public void ToggleBookmark ()
                 return;
             }
 
-            lineNum = CurrentLogicalLine;
+            lineNum = CurrentLineNum;
         }
 
         ToggleBookmark(lineNum);
@@ -7197,7 +7166,7 @@ public void JumpNextBookmark ()
             }
             else
             {
-                var index = FindNextBookmarkIndex(CurrentLogicalLine);
+                var index = FindNextBookmarkIndex(CurrentLineNum);
                 if (index > _bookmarkProvider.Bookmarks.Count - 1)
                 {
                     index = 0;
@@ -7256,7 +7225,7 @@ public void JumpPrevBookmark ()
             }
             else
             {
-                var index = FindPrevBookmarkIndex(CurrentLogicalLine);
+                var index = FindPrevBookmarkIndex(CurrentLineNum);
                 if (index < 0)
                 {
                     index = _bookmarkProvider.Bookmarks.Count - 1;
@@ -7473,7 +7442,7 @@ public void Reload ()
 
         _reloadMemento = new ReloadMemento
         {
-            CurrentLine = CurrentLogicalLine,
+            CurrentLine = CurrentLineNum,
             FirstDisplayedLine = RowToLine(dataGridView.FirstDisplayedScrollingRowIndex)
         };
 
@@ -7578,7 +7547,7 @@ public bool ScrollToTimestampWorker (DateTime timestamp, bool roundToSeconds, bo
         }
 
         //this.Cursor = Cursors.WaitCursor;
-        var currentLine = CurrentLogicalLine;
+        var currentLine = CurrentLineNum;
         if (currentLine < 0)
         {
             currentLine = 0;
@@ -7587,7 +7556,9 @@ public bool ScrollToTimestampWorker (DateTime timestamp, bool roundToSeconds, bo
         var foundLine = _timestampLocator.FindLine(timestamp, currentLine, _logFileReader.LineCount, roundToSeconds, _cts.Token);
         if (foundLine >= 0)
         {
-            SelectAndEnsureVisible(foundLine, triggerSyncCall);
+            // The window the user navigates in reveals a hidden line; windows following a time sync select the
+            // nearest visible line instead.
+            SelectAndEnsureVisibleRow(triggerSyncCall ? RevealLine(foundLine) : _rowMap.NearestRow(foundLine), triggerSyncCall);
             hasScrolled = true;
         }
 

From 12102287c61a639c2ce5065f5dcab64118b2b8c1 Mon Sep 17 00:00:00 2001
From: Hirogen <hirogenat@gmail.com>
Date: Sat, 26 Sep 2026 21:33:45 +0200
Subject: [PATCH 05/11] Center the hidden-line count beside the Show hidden
 lines check box (#338)

---
 Temp/Statusbar.png                            | Bin 0 -> 18887 bytes
 .../HiddenLinesWindowTests.cs                 |  22 ++++++++++++++++++
 .../LogWindow/LogWindow.LineVisibility.cs     |   4 +++-
 3 files changed, 25 insertions(+), 1 deletion(-)
 create mode 100644 Temp/Statusbar.png

diff --git a/Temp/Statusbar.png b/Temp/Statusbar.png
new file mode 100644
index 0000000000000000000000000000000000000000..c254b0d70ab974a8f0a218f06beb1262d3bda76e
GIT binary patch
literal 18887
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

literal 0
HcmV?d00001

diff --git a/src/LogExpert.UI.Tests/HiddenLinesWindowTests.cs b/src/LogExpert.UI.Tests/HiddenLinesWindowTests.cs
index 0bcfd6ca..87985173 100644
--- a/src/LogExpert.UI.Tests/HiddenLinesWindowTests.cs
+++ b/src/LogExpert.UI.Tests/HiddenLinesWindowTests.cs
@@ -174,6 +174,28 @@ public void TimestampNavigation_InTheOriginWindow_RevealsTheHiddenLine ()
         Assert.That(log.CurrentLineNum, Is.EqualTo(5));
     }
 
+    [Test]
+    public void NoticeBar_CentersTheCountBesideTheCheckBox ()
+    {
+        var log = Open();
+        var bar = Find<Panel>(log, "hiddenLinesBar");
+        var label = Find<Label>(log, "hiddenLinesLabel");
+        var checkBox = Find<CheckBox>(log, "showHiddenLinesCheckBox");
+        bar.PerformLayout();
+
+        Assert.That(label.Height, Is.EqualTo(bar.ClientSize.Height - bar.Padding.Vertical));
+        Assert.That(label.TextAlign, Is.EqualTo(ContentAlignment.MiddleLeft));
+        Assert.That(label.Top + (label.Height / 2), Is.EqualTo(checkBox.Top + (checkBox.Height / 2)).Within(1));
+        Assert.That(label.Right, Is.LessThanOrEqualTo(checkBox.Left));
+        Assert.That(label.PreferredWidth, Is.LessThan(label.Width), "the count must not run into the check box");
+
+        using var image = new Bitmap(bar.Width, bar.Height);
+        bar.DrawToBitmap(image, bar.ClientRectangle);
+        var path = Path.Join(TestContext.CurrentContext.WorkDirectory, "hidden-lines-bar.png");
+        image.Save(path);
+        TestContext.AddTestAttachment(path);
+    }
+
     [Test]
     public void ShowHiddenLines_ShowsEveryLine_WithoutChangingTheRules ()
     {
diff --git a/src/LogExpert.UI/Controls/LogWindow/LogWindow.LineVisibility.cs b/src/LogExpert.UI/Controls/LogWindow/LogWindow.LineVisibility.cs
index ef75f5f2..97d3d969 100644
--- a/src/LogExpert.UI/Controls/LogWindow/LogWindow.LineVisibility.cs
+++ b/src/LogExpert.UI/Controls/LogWindow/LogWindow.LineVisibility.cs
@@ -16,7 +16,8 @@ internal partial class LogWindow
     private const int HIDDEN_LINES_BAR_HEIGHT = 24;
 
     private readonly Panel _hiddenLinesBar = new() { Name = "hiddenLinesBar", Dock = DockStyle.Top, Visible = false };
-    private readonly Label _hiddenLinesLabel = new() { Name = "hiddenLinesLabel", AutoSize = true, Dock = DockStyle.Left, TextAlign = ContentAlignment.MiddleLeft };
+    // Not AutoSize: an auto-sized label keeps its text height and sits at the top instead of centering beside the check box.
+    private readonly Label _hiddenLinesLabel = new() { Name = "hiddenLinesLabel", AutoSize = false, Dock = DockStyle.Left, TextAlign = ContentAlignment.MiddleLeft };
     private readonly CheckBox _showHiddenLinesCheckBox = new() { Name = "showHiddenLinesCheckBox", AutoSize = true, Dock = DockStyle.Left };
 
     private LineVisibilityTracker _lineVisibility;
@@ -103,6 +104,7 @@ private void UpdateHiddenLinesBar ()
     {
         var hidden = HiddenLineCount;
         _hiddenLinesLabel.Text = string.Format(CultureInfo.CurrentCulture, Resources.LogWindow_UI_Label_HiddenLines, hidden);
+        _hiddenLinesLabel.Width = _hiddenLinesLabel.PreferredWidth + LogicalToDeviceUnits(12);
         _showHiddenLinesCheckBox.Checked = _showHiddenLines;
 
         var visible = hidden > 0 || _showHiddenLines;

From 9fec3cddc6b6080e0f45d3301fd508c7ed23efd9 Mon Sep 17 00:00:00 2001
From: Hirogen <hirogenat@gmail.com>
Date: Sun, 27 Sep 2026 18:11:56 +0200
Subject: [PATCH 06/11] Address review of hide-line PR (#338)

- Remove stray Temp/Statusbar.png and unrelated Resources.Designer.cs whitespace
- Queue explicit navigation (Go to Line, bookmark window, marker clicks) until the first visibility scan finishes
- Pin line buffers in batches while the tracker reads, like the marker scan
- One reveal-or-nearest decision (NavigationRow); rename SelectLine to RevealAndSelectLine
- GridPosition replaces the loose current/first line pair; one ApplyPosition for restore and map changes
- Share the hide-rule predicate; tracker tail methods return nothing; trim comments
- Record reveal and matching policy in CONTEXT.md
- Tests: truncation and rollover in a Log Window, Filter Pipe hiding and locate, highlight export/import, hide-rule markers, pinned reads, navigation during the first scan
---
 CONTEXT.md                                    |  11 +-
 Temp/Statusbar.png                            | Bin 18887 -> 0 bytes
 .../Classes/Highlight/HighlightEvaluator.cs   |  11 +-
 .../Highlight/LineVisibilityTracker.cs        |  60 ++++-----
 src/LogExpert.Resources/Resources.Designer.cs |  44 +++----
 .../ConfigManagerTests/ConfigManagerTest.cs   |  45 +++++++
 .../Highlight/LineVisibilityTrackerTests.cs   |  56 ++++++--
 .../Marker/MarkerCriteriaTests.cs             |  22 ++++
 .../HiddenLinesWindowTests.cs                 | 122 ++++++++++++++++++
 .../LogWindow/LogWindow.LineVisibility.cs     |  98 +++++++-------
 .../Controls/LogWindow/LogWindow.MarkerBar.cs |   2 +-
 .../Controls/LogWindow/LogWindow.cs           |  95 +++++++-------
 12 files changed, 396 insertions(+), 170 deletions(-)
 delete mode 100644 Temp/Statusbar.png

diff --git a/CONTEXT.md b/CONTEXT.md
index e657f23a..481992c7 100644
--- a/CONTEXT.md
+++ b/CONTEXT.md
@@ -30,7 +30,8 @@ meaning; do not redefine them locally.
   matches it (`HighlightEvaluator.IsHidden`); no other entry can cancel that,
   whatever the order. Display state only: hidden lines stay in the reader and
   remain eligible for Log Search, the Window Filter, Filter Pipes and triggers.
-  Temporary search-hit entries never hide.
+  Temporary search-hit entries never hide. Rules match the whole line, as for
+  triggers, even when word mode paints only matches inside columns.
 - **Original logical line** — A line index of the Logfile Reader, before hiding.
   Reader access, bookmarks, timestamps, row heights, sessions and markers use it.
 - **Visible row** — A row of the Log Window's main grid after hiding. Only grid
@@ -42,9 +43,11 @@ meaning; do not redefine them locally.
   triggers.
 - **Show hidden lines** — The per-window, transient override that displays
   hidden lines without changing any rule. Explicit navigation to a hidden line
-  (Go to Line, bookmarks, Log Search, filter results, time sync, markers, the
-  command-line target) turns it on; tailing and restoring saved positions never
-  do — they select the nearest visible line instead.
+  (Go to Line, bookmarks, Log Search, filter results, markers, the command-line
+  target, the window a time sync starts from) turns it on; tailing, Stop Tail,
+  windows following a time sync and restoring saved positions never do — they
+  select the nearest visible line instead. Explicit navigation made before the
+  load's first visibility scan finishes waits for it.
 
 *Avoid*: "filtered out" for hidden lines (filtering is the **Window Filter**),
 "row" when an original logical line is meant.
diff --git a/Temp/Statusbar.png b/Temp/Statusbar.png
deleted file mode 100644
index c254b0d70ab974a8f0a218f06beb1262d3bda76e..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 18887
zcmb5V1ymft^DeqL3GM`kAi>=&NFYFPcXx;28l2!B+}$BKEbgw06Wncaf6MQG?>q1R
z?mbWT!1nf>ndzG9>Z-4*zX?~6lSKJQ@DTt2ph$feR{{W_H6XuN5#b@<6^k4EkOs<G
zNm3M0H9>R;>A;$c$cg{}wJ}J~hH#Mn2Z!&P&Hw-|)%!n`loI6y03f9!B`%`ku6MfT
z_mfaPll!$PYlhlRW~+-f_jHD_F_9_ykjs$NmM&QA*J8Ns;vj9f=0w(ct#(P`UmHf>
z<~jKnBA~x!%Kf35G<o=1=)!uv7l3AtSJ#G0&8-Qk;e*!q)>31xxC-2R(d?Ocp4?I~
zznpVY_Rr(1sc~jIaa2p^Al^I5td`bRXLF9ngY|NH(1W_ZOkl|>&NiJ(IAK_ZV&tgH
z<t3b`N#?8Sd0Kk<tbO6{9jD8X?<%GDk5pP(uj$Rd!XO{q5GY&>42-y5d;>^>!5jJi
zr)#4KQ=w5pFdy|4hv|lnk<_BGZ&hKp*mQEHkCj<oV>K!?_M1OBZplZx#!8ijx{p|#
z7n{VOU$msEit9%%KA@ncv$hVp?EMz=<b8d_pIC#+$`y%!CtcqwJrUO5s7wS}3K|{g
zbP%9CMc&~u1^b|kUZK!rzYn9wSRi**Ze^If;lW~~FMBk0Nubw5%~xwRk9)!%5oC5}
zI9jH9pfjQv;2l|xJcBzMLQWUm1H%CD$MYH7XW=fE-Gpb=H?^=h1h53L*0(v^Ad3O`
zw4^=!X^DuVdRN?-IU2&;J{zf>|E7Wq{T3mck-QulGGAV6Tmln1kv;hEgYOqGl~|*r
z6$&ZBnZ82scL8~x)e4r+1@r+=f!%r7ZG*^YBpzB;vp*8v+#&kHMkiExvZue4sp&5$
zH73qQLDtZg@U;>Qx1{nA+@An^w(uGwV~7Z3{pwVFz&XXpfsRF>>PrRj!2uw|m0^$O
zj$oCTKjx~oEyC@&6xOWI)|5VE0%a}Cjfl-XFlG5jL6T^V5Z56ZdBqrG0!FdlT70Jm
zj;IyJ-CHtRPly5mhqbFr93_^ob^v)D);M;nJUQN%FZ%RUqCFp}E!b@~`9kEU0V030
z*PTRo!R=``I-kQABVQK|anxKGvBmltI|d3m1>+s`v#&&V=ce4aIQoh(3^EDJ%1_fJ
zS-nZjesQU&SOWtru*{EV<G^18B>K_Y!%3Zvou1_aoib@-MHFxz17e9N2Paq1VqOf$
zV#8OiKlTt)<@e?%?pP;iP>fAS?Ye-8(*i6=E{ju9JpQ@Fk1rz*I(xOPo(x6U(UAkc
zqGNVH00}Q@QOSfnDV0HUKzNUdSfJosXnMI|<YeHq4wcWj=3cF+7s2?_Y?At3cY75O
zez3YGL0$H)nav(cY^%Lc0BgA(3us<zAK{v%{D9WUnYW7yh>5YJsnE8Ax%|_=&f?Ko
zMLyOjpQFsKZi93?F1^BIUIE78>>8nOAdMny`vu$vKUZ!ah;efrK}UQuVf%qkNC@4&
zlKUwYYnL}GBpD*z@BFg6s<~;!KBzv)n6h;;b4R`^v;w84C)S<QK)Qk1k`^z3&pJ<Q
z;3Kzolm=}6ihRjl1(E3BRP<Q7Rqr5Q<o?gXXaf$^pR49<L`m<K$Imk7_+9nZho{33
zA*8SU;Rv1ekAD6&YT<3Jp&0j6vA`?r<5Uz1m6vnEM9N)}mSd>gsjMEEuU4}Mn&IFP
z8B1)Y<j=gxh+N_&GJ12bgYQtM(WyciLx0abh>q}kQ1d+uF70d(p<$%g#fZb)>=oeL
zl`e`I&(Zn*7A9iw58BgIYZW$xhcEdo)@}O!>&61>6k@rf-x&uop`!~%6PE{ceRa*6
z4M*sJ7~BJbW&^iJ10h4xuW448JNqvef6U)kB(eK*v{+e-(aa0jk(F7s01jTm@uxjD
z@Y|Q$sXx+&Z&h}E{HR70?CYw5Yr4c;3c?)3d=X_(ceftFhN7kWLv23gjs{Q~{8^AC
zLl&*58pP?v7aa{0a-X+vtz|_v-Sec~89wDbRtRiEc>KrtF?x=GB5bXa>Dz&(<$-uM
z9{%I6#@M+y#l8-o0}c=Um~X8Zcek5Cdr_TG7`!Y~L+S|1v?oZ?&Y5*F)!l1%E*d8t
z^w1u5Dw%`NV>`2sU*KJw=T?b(b5RW}<g*NxzE(IRgtYtckdKX8g=NG-JFN9@e%tV;
zt3G=kh3cfPvHRM`(M8YrALXgFG)fWO*-zclna+efVSsir`+@&n!ZsWc<<}~`c}n`%
z?$)3LfHda<h5V?3!DGFEx%HPsjzP;9&2xEP-ryYuo2Fk0g95d8zI`2NTjB+Z4GkD^
zSZGJ*DJpTe_y(W6Bc_fD&gT?Mxy6aj$~r#i^*Jt|%^&5YRjzERqG65n1}=y1Ldy((
z9>4r;j>;5LOU`V!d?b;1^q@5SsmlwC<AppVVFhJwHR_2$)*XZ@bvpHvb>3jbm6_!l
zMmF}-VRUbsPx|mf)Fy%$%ewxyNM<w2kTL?6H1qPHQ-ibR80ATb=x@}pP?*{EDsQI@
zgx;%<U2ViG9I4j-N?}+MVguW>R(Ie+Tz8J9Y4Kd6H{|pbTN=Zsxes<IfsT_T{aB9w
zqH%8s+vh<u#OS0U0o6-N8fb2nYg`WCKQt`2JpVd;%5R0x01b8(cuk7mv<&<k9K`s8
zNot~I1QO!QmVTeEpRnW>Zi;9Ew=FFWhi;?$2UvF2qANL-{&6P!NWE1_m9^uJw`XhM
zur~=b3p<NtX;iG2{m90iiC;@<fJoddKYOggL+>&~#f~N=1%57wkA)es`DbINMj$h{
zp@JtBHOMnJF8jhb^fAlY<m%peUzg7od>`#Cs4EjOZSBy~0L2&`kDx(}aC2;t<jYt|
zV3S0_(8qv+X0|JswVck@VO(3A`=bSgk$6Ucp*O2cCt)S(JJ$O4n#fD>@tn}fr}(`~
zi_imDY56|_;y6#;vB6TSxSEw>sLL)fb)_7iIc6@3JnTa$)MJLXzEfQz32G#1`W=ar
zwu|v2(=4R$Lkx}TT*)GVANA9<t8O!3d}v;YwGGV+*)uv>m2fJLR@a~E8Z#+<jKy%M
z=Yq_JC?><6x`otOtjx*UK7bqIwIt;~GhHX|rmxyj@^AXYbT3QgVMngZ6bzr`^I)!o
z3X17nr^*7M*~F+roJ)*^r{tYLtW|+><6Nbg!4HOoMb`v-TGXExT6zoc9N-_Pzm;$N
zz}`(8RkKJ9NNdC3r_?8Wq@iVfUl8^rrfbyHR!v*3%oq0><m`Wwcz;;c^Uy^#<qB+L
zdH|E|M3BE=mD)7?N;0kr_7e10mNFbtNUKkw+F;J+DI?X&z~834qssdUrDg_wFZWRF
zg3TJlAfL!gL1jQt$0uNM<6f{{dw=l7Y;JeKrr*_`Xl-ptk1_l**3fq(=&rf3T$^M<
z3E@la1j+%|5t=>3J#a@)3+9I%?;VEigzq_Su6URFSfJCWYgPtk$n!TzrA`6GG^PbY
zCgN{Nh7ul7yjXYaGf+IH-9&YQuxC=f1;KqUyhUG_XR|@;2$4ICKqU<F#80-ALe3QZ
zho8{81=hhTG~B;G-I*_|;9@QMvA0g{jbsO%Su~3MWvkgQ@V4oJnveV6>pd}#O7xmg
z{ZozUJp5`5g5y?cn`(!;>vGpJD|h26RNuLzYiXtC$qI!pyMpg}^M!5yyHgI_oL5rp
z0U&)9!*@pD5Au-V|HTx6wHqN#LLGFoDN;VDT<^l)e#w(V%l+i-V&`&~G##7!4a}0A
zOotx3&wSc)7&QD$W0_|!K*Ft`CQ?ZrPfVw{Cjs{hY7GRcT*!sO@E8V+6QzV8PLLj<
z?-`x~D&}hcSe;3nJbMt89S^|YJlBlru%B|n)$=(V^vN#fdq!S6^Bb|4&5-0lCSN(Z
zN+E@JHWaIsjZrCExv;`XS8#pea%GsltbmJk7QZ`K%ni{wwg9Ab<`Llb9aLepJ`+87
z-j$0K$9B-cc2B(<LgVlhj?|p<p~@tArE80oTY^nS?fV1QziS_wi=6xUu7R-Y{=h*u
zlWcB8WF4L${-6q#R2^q$XG_P=Nih(Z$?u5nj7weEqQm5<oEnzve1rN=p>*$iQZ)of
z*c?=`BNkb-&~AXL7fyhTiw<v|J_aJFsbBZYh`Y!qpvr$1o_6Q0Dm_ixTRVBB{(b?7
zUG((uWr&N9uJqxP?7uik8ThMCSh*VK?QE3%WooDvdBdWwm8)21g|*-CAHKlHm<F@A
z*+;zYJG=wc!R-qno*d1oL^>=O2B#n6ji>%>!r!I%&8FP)E_U(5!jkirE1Mv}b7}%-
z#qlEqN#<y&X3>4xH((@BVharnyZ#T7Ukv;vE-t>q0<QsS#8Hj?|6A9&<6$p7V@FP0
zJi5hU6I##v@>~1Og7y{@#R^l~37d}BX@f?C6^@?QDW{{`lF|Fc(R@CS9Cq!O5*0cv
zN~_;YRtjZOE_#rd{}rX%K?B+$_j7-_0rlIM4&Dq9+Ou>~Xi=uTRnKk}#k+4?&qVz$
z!S{W=$~Jy^yxB6#3&`Yi`FQTN@x<mgIXP*4oAMbVXT$;c&82mxTb6h3S27p8#tsK-
zmnY<&qrQk~39I2@VI_HqUJk)dNHxCqy`;a>hX5<3b%{?8ba#)69@{r!g%^XuuZpWG
zuCLmBnG#jkF>m)V&ClRb=b~!goATB{oOr-LTYIl`JN^W&+Dtn7(n&nPny*V8*t0(V
z{YiC~jvmAO@SFrYE=B|zpU=0O_tr_bz?07rr`O^3FEo1Yrh4j3%BEEL$Dt+ob0CfW
zI|ISTgZ$?0X#T!&KK-X<&_zSFkL+sufrO;wWjC5Hy59@PFG?nbDZDMEgTAVn!W{FH
zZT?p6qi4O*&C&c8wdBi|Tgt^o=OgL;-5XzM3uqnPO&h!ut`0dyFv#pX2%^JSQpSKv
zzPA+5JZsq}0d$eRULedC+%JQGjsLP3f|~{PwIDN9)x7o58=R2cC+`c!61eQcO0`83
zey(BaOgJ<qefq<sKua0EyC)s|cUDsPae8cfEG&j~S#9ik=yS|LBcm(bj`xnt(e3zr
zk(!>pnsU`X#$D;LIj7I2m-$E3in%>KFRW}|8wqtG<z33)X)X$y((2mZh&6pENYg7T
zZ3lvy^lBAD*J`>xH}m(KXntYmzISb@FZz!&DGt3T+$AKN6@IV#ez@FAw@KCB-&S{;
zNnZ{mzh-ftD{0jl!2vIVng6A4JQp=bj7%la=wWc<ob0^al{H%`61AAasd*n@jHNy6
z9wskeqL->Z6G5JO?Msa4hq^v*wRq80yX30Yqp~q$Cf(K`bv+L_y=uJ5%F5=Shf35J
zo`;1g7bEo52PEezS_ck0DZpzg-P9JyRax{)9%H|8=xdDnKYm5^PNdv(rlXyN1L)uP
z;7Knhm=<SNP`jkIjBt6Lovt(;gEgg$cw25i3EBg93Lx_|mt_AZdbP5JWd88%GyKC9
z<xr^Mt($2fCCNi9wgT0zZG?-!$9!9HIVFAL(JBNPh@K+W*YzChx7WR|WWS<TjkQ0P
zT_4^*9#`YJ@zSXiJJDV{_7|YaCB5O5XGzct`dvooo5<t(7Zp)Q#>8wt>}MnFG>#-?
z`P^#OhEZ8yz223caF!O>+u~fQmgP5_?@F&atE>WHiI###ncBw4PJ1v|nH5P!xw-;~
zOmJp@!5{#Te$B3|-*P!BPcITPF{n)`(MAT8>pySd0RkBSUpWZ+cXlY(pVsf7MQf}R
z?OJwmYZ1#h>OW*)HfbtFObYpYNXdF-u<F+}-BlCt-eYXPN#-N&;$kI)j6%_cX%CjB
zYkYn6%^6!Tu(YsXK_-YCn@D~e3p2`+bm1?}Ha}f%K(12(zTQ+vq|+@ha#!?(SFh9A
zQB%}aQb02}3anWW>8{#Q;edJgC+{ZQfLH*A@ya^oGtt===Y6(G^P<K^T#&9?=2@*;
z!u$N;fd3d#xj1kNGgk%{RBg1a-!Qd9Jd!_=3FBS{gNtB>^bwnL5~ENPoA@8;!r0^$
zMs?5IC38;G@ZI!NtZa~U-ElIZn&I`jw!`2X>sdC&D7W0g6-kSvO}3YV_!v!+*=tjO
zUG!=_CcXXWgpYLb>~|W{Zd-cwtwzcCvbuQpoyH^$k4cO*XOj`lw{Ju+7pHIJ!s^u3
z&l)a*K~6t!Sa?Z_6Q+47mAucKvwN%kUaTGK2aIC`LoP2J9qXeX3ChEy&bC6NFVWsE
z&;b6O&!e5#Zb>>o(%g)!EL`rS!m=_t$Jv0=(Xn|sYf#lVtfsE6ZuFgrs;a8#-i7AP
zbd2xZrRNTtkWkepij3^+$<){9$u}K_Jccjb^S2$7TTA+S=x+QcUxc((gBO%v{-`yK
zZ_4`-R;rQ?aND{NY13OD4+^6YJqhKN)tTpS46*_SfuyQF5zOIleDL0n+XGkwjlRw#
zSF<mRu>WR5clV!)GVTs~?_X((RQI1)gkDb7ycgG@k~%)OG4-0J-x;Z;RyTMsn>pKn
z1ehk<t8`2cNIGS_IdH7@Co-GQflogID<nyMuxDpy?}sFXD9%R01vTJToT>OHo9x#3
zWFF@2!?u7%MfK*BW?AZtppPs6W2PVR9alt^)Ya9CNR0UL=g)P|J=M(u+|<=ms@g>p
zlwz7XUryb(qqsSqB9G#dK^W<2X>=tdM{H3eTqDH=kaedkL@&ia0}{&LA5V$QxIe0F
z-VJH8Zq!7n>I0)-%>bfv%Yh$NRm-k7ZK}toy|gY*WxXy|JJ$mV=8XwSJy5;4h{Zq~
zq~j!F1PXT-VSd_7<(J#dSc4ZYmp1mQ;Qc{|{Vc)7pC|iEB!&6%TPw|2r1l&<T&nTb
zxohk9h_5$U1oMp&-p_LX7Vidw?NQ1`FkYF|*!V(`z}u6CYny78z6<PkX8Vbs?1Te!
zQ*=X;4?`U#IIFEsswAhKmds9Yw&is{)i1VbdOzczVUkD$Up;s??`L@-|CdIE-yS9}
z-Tdy{G%O80quwnGAhW6<<$AXI0niK{q3_oP_}lwEt)z0#g7my(S9Mh+@J5Y5xvM8j
z^$6K7C+4;dy~_>Om(N#|E1o}uqy+&6^JS_YUUiK&O97>&v<7jLhB7ipdD9luL+z0J
zxs+zCUi!&F77t1)*{GF+=_K`u#~Ek)Z5rK6Ia{q4w7d|!O>4)nL7p39n%xGhz%3<p
zpKi!W;(S<VD;CeK{z%&cY?ikT)@y|&@zDi-R${ip?HF>+;Uw}%y%p}p^Y`1;CL!vx
zYFOcc{e|6Q##SU_gvg?f<0jIj`2b0KAAIw<U-<sE2owJ{wf!O|Z}#c=f2ESbxZRYH
zcA_94XJ>yj#Wq<&sS+om_<OjZeJbluOhPi@Eu-MQ-2##SvdQnMDYbp~*6c63>q=<`
zL=BRwi6Dpy`el*KIES1ln(3~+qoSfVQ_Zu6kuj_SKJxPBPCbTaz3jr-Y&<bYoUi%c
zj)U;Xo3;KdySQu>1%#V&zRqVZ`CD&E2{azMa?DHr0*$3=0_wwr9LFdPM(wxi)wf3I
zH)3e){Ft22&^BoI=uo^sG2Kmw{RVpreC~g>DO*n^9qtwXEi~c=a#enlS*h&G4{Z<&
zZe<fFX~S{<+n>`EK~#uZN8)?G2?wXHaV8do$E-JJ3&Ah-yg{z7&mPY!oiFKoIde>U
z?SCHLlGOD|y}VfyzOQ!1nlxp8EDc<HMv@Aiv(G&w+_(>+9`f9dI+5=zn6;F3P(8S*
zpxpJ|<&(H^rnl@3L1~2qR}DF!Pq3am1=Y}_pSHCvoVwA&0BypOL3XR&<LTi~f?;;{
z<$cU-?fVrqO-{cMS$AZ464~v8gc!rw(-nmTx%|y-x2;7iMal$40Y@7wyNx1}J$C6-
zX_F?Z&Ts@$m@}e|Fh4~!tdBS2Pi`0q?k|af%Pu!t)G!Urcd1P*t|?{avY>nkImLjA
zmX?-)0QwtFH3%AN&c*cT(9>ympJow3teY$E#3~JBxIv@j=HRdhpszcF_`NQ#&U>-Z
z?j+|O4=H&f)_adXnnWI3_zwGn(_hZmOzJC^ZJT|tSQ74WUmt2^n|;z(i<O?tAuIR;
z5ieMu2Qq<Q((&wYKhO?*#;P~3@JqE=fokDC9qVnrnZ{kC^mK}z-0xKff^k;5lPs3t
zHPm%ol9-YR0vU{Ve@07xBQ~LxCe{hBCT+89u|huWE;7E`+>7y*xq|1tY~tPq8oL=?
zV_0wE*rcdN*f!bs)Y4>iMe@a#t%a;`6ZiVuNp)y>Y?o`H9RbEDRVKgKd!1z0*AEu(
znbb4LuS|L3U2Mm(1{zr48h;jsKeK9R3bQ=za5p<)`ZxF)e-=;L)MRP0+jHY-z4%ay
zjuT!p9^wMW32VV(QzMNjdY)45eKY3RCP_!FsuK~5gx1_Rvqxq9Pr<O-R_EQFIs)N>
z&1l@^&=aTZUJl@`&$wRICS0RsYp(oU#Qg9U(6qD{(Efb#>lYutekS?Ufi-y6rs)an
z%#3Z!Tn&_sv7MaTB=mE|%r|92C{Jv35scLKd*-c}Wn8I2&3>xo$z2=5IKd2ojroq%
zHf6N?Q*l^D6fOC9UR|G)n5Faas2pnk{6W*@W?p?8f{q5?<EFa+Nd}Lj=$Mkyh-0q5
zalP1!z!$Ld?&k$K>Klx!PrI}sqSc(mK8G^;Jx#!y%DnmQqjkIstI4P>GXvJ@Q6iU`
zGTLV%-$Wi}JEoz*x97}zxqm)eW@QGYDj$zQ)gU{8I;4~afwDE~HtQ2cqDAUT$$7TQ
zH?^E4*I|ZRJH61!7mbGDf9b&krbOLUqgpwoN!`Y!*K(PB!D(q}V;h(5M1Gfee!0WS
zcE52AIv~%`d^tdP2?3t}I?jEVv%JoDS+%8TU38cdom*T_wPb{6l@D5qSDoOvBj)#7
zjtu6Rece6)f##0B>-Q@uYL!)<ghj3P-Pu5A!z<R3c6>;BghU3fF&Ir82s)nMq2;dH
zczeAof?DX0z`Hzi>(pMgIlAk76C`8)SMvN8LTK0Zj+y+h7|re99+@wm5MEVQkrAuY
zjYd=v_<cQY(e7t*_b&qzI<ee#8(NQSn;+z>dVakP1`@8<imuAyoI&uWx&OClK9?gE
zvtfdvE0a@3jJkU#h#Wf%#R2KTUqbn&W(EKe8PxC^kc=Xx#^cINHp?l&nV5l^n%W!-
z*HSl6r<CZZ>+fGIMb?t)TIoMKdUN&|nD5(3m6*^BpkO4td&fYFxQfR%{om=*TRm^>
zBCFy%fAI9&e~AU{lqeU=Z4MCD>rZ$bl@`~Sj^aXY-wTKc3nS|PuVE!)NctBlwK+XT
zqK=;*u8?cO!iHEoALpwt*6)CB-NK=wuz(aM-JYvS;h4MjeZf@QX$$P}@$oe8-T!QF
z@g6mR^u#FQx{j+mna(KcPJh!^`44V)L%ik(fJ2LpQF2`$xhMtX6WTJ7W%^$kG$qsQ
z*Z+sa`hVuxc(42N4~(J|SmvG0a;uOF67jqs@<D`$=nT>f8A8OxPP#ls5*Js2`d@b0
zrsHe3Y?<24Z*ZC))>JRro#7T#bg9jt02QUJ$XRYxUE}9fJzi@1zi{lg7s((REgws^
z)Cjz+2IYL%NB1TR7IEYTtm*__(}2RX<GelLvlhMg?Dcy+f2?!a>qU2gYDjv&TaIW<
z6x?d3u3dm5E<*hRX<euRUvYYJ`F`r<Kl^-$>nKL|luEZ|eHY{YI2~jlb4oXs^#YT{
z!x>s^#vHa(Q|O9gr>`Hi>{ijGT#t9Lmau<OepM~wToa@YlVV9mkte!?Qd8xA$=iOl
zg#_>i>8k(xeSMt#_SRNz*LMs83M;GWaf8TS;^-)=HN*Svd_(pUjNqxd%4UG!)g7qe
zUe&=~)Nml-Oc)zDjU|8x@=P+l&&seZEbCA_jFE0zKBdUQ@1~ZEs&b}5ng#Xk$?D3U
zLhhOS*HYf+6K*_5yI00{g^@O&(RmyBaH{E@_4omKV$QSEdhMBkzl7UU&Hhu`80Hth
zpNL@2F`ciTt~&x<6cqYZzUqG%t0)z{|7;yAkR<wsJarv+{12=CkH;amh2JBlf*Wy<
zb${j_wBHp}L1)#O5BXOs`A%w<OvwX&W(tq-hJzN~^l^|w=G@8`1a$xljtn^%EdA4N
z`i>2Eg>?PLw)(z4r1aJ~SkF9Ryt~V^3Ir1PJ<zCc?zyRNGQaK6tui5~PeOz(HuH<o
z&-By%SoLl_iQHXU9M+(m-830|e%_ew{Rt>gg-Cjof#uN-FJ&#}F@tc?M;E8+q~l+o
z#Px9RnDv!uCJ#fQ_0uGw{mpHY+H*hJ9;-vM?+20ectmEj!p>ESe69Dn{L#q~<Cpp(
z_<GgvF$Xk;6VkbI<*3$<LIbrEH=Jwydh=FX7Jk9>q7M%%;Q_;IbhaHyMCvw^7~@q*
z_E5c8-@LsaspU}yrh~d(z`T*|u>W>=#cMGcx#{iqa4U2_G&M68dj$0eYhT3X%pny?
z`+dG%t>{4gaPu15XwG!O4Q@=gW_#)#;ZhZn!s#J5)Q8$V9&IqN#Ss8trskMXE$G5f
z`gutWA^zy#V1}zn4%FS3?W9C`6Xf)QYSQtddVSpEY~Ed_znnXP^M0En3Z$o?pet*K
zT7cLYDRZlEG~OEN;JH=P@?+=CgSz#U^NKX3Jgp$j{?yYoRkMBDf)jHXB$@Vi=CR?h
zFaJ_tVE!)+Z`1Fexr5*Zdo#&*^0EnvNtE7McJS*baR)}~ezKD^Yu1NXXQiwQdvwn;
zA~NJbC~0O=^cQsx5|v-O$DYLu7i;bCb}mmx&{g280n*v~HEa8=C}C+a|E&#(OX!b>
zOeQvWwFp+hrbsZyP7{2kQLN$49>I_GM$GB+-Snw5%2EUxtP=oWBA1t)wDjYqycE`X
zeTT^v;>$5_V2jbR#}A$d3JPWz*>e!Qv=Z}1#DQRVaFTt>DsZ@1U#IU@_fLbmezf+w
zZg6MwD_y(yC5ph^jDQ~S9{zRfvD{&_t-R*;XtX~R9pXZY7@#Y<o<M++i=3@OXMA=<
zHcI+wk7_H8lLXbU6V8VP!)cwK)RbRE@>Sef8r9caf;6yP%(^p^I9?B!MXG)Tlg5~y
z54b8omtUO^fSGI^WyOse9c7nKTsqo?sm`3PkL_l13nA9!KS09}pQ=^DhFG(Z(;!DO
zpfpLP1Y9dVj{4QU5YNVN2T`}iGZj=KuTJ+T)fyVqaVU$&0v5^Rb!*0PoY|Xy5UtAc
zg!+;X(f)mYUNCq*Chhu~Ik%96sRPx8P}TO)?*?c!o>6|DB~YB2aHD=+J^(o??fnHp
zX!tBmVqgk9%Knh7VtF3%eL3?4I0XMDr3z{#Sfd0V+#yFFLm_q8GQUXF>wNq7VvP)}
zZSn^@$Ag+YAHLm>2dKA%vOZPzFl;Q-`NZr{Xh0sXajvQd;(YRtobd9@C$`&YCO4b#
zHUNO<+bzQTvtj43EZ&&1QQiB#M=P6BUAS8lh#0fdL<Xro^ZL}C;ccL5+LLtqh{M8-
zt}DTLFeYy(PvtO!y5p70L0MbSkaF4PSA-F6tb0Na&X)|Vt$kKwce?`Tw3nWqEsvK<
z4qvZJl;?|J^~;^f$>W6<rRszm$gk~C=JwwkdfqVAo&8ehkV0_947`TfRT$fj)Cw1<
zPm9Q!g$enC)qXrJ)`T@nRcc8m{I*((^na|WT6|PeMMlGfM*&D~IkYembldGGP3{?W
zs~rIhA%Fx2k`e5b<e@vaO(x*0WX5yn)&0b9J$@#u{%^y_LXXIau}yxO$*rBY%)x%p
z+ZQu($YjUH!)yFv1X*=H+KcO9mDeP7gABg1SC6K0gCqGoY-xE>bUr^Pjtyh$Z1B^J
zC6qyNYzT~fOFKCOniXEyep?C{<=zKY%B|Ryf$Oo(CvzWuVds^({?YN1(}2qg3$u6_
ze$oySABFdeh=q8`c;T+ceuj(Drh>O>cclA30rJI>H~VJf`&q5SH}T!*cQy+zrJw&z
zK6_V;5Y@|D2q{$ObI#41-vxgc0{sn&^ec5{v!<HVv8W|u?Y2`mA#M*`K?5_wdo^7J
z5%SFoDR94sH?*3tWY+)l=zFD|{*Vm?(u&K(9TyK`9l|^T$?a$$_MQiA3SBXt&K>de
z4g*R6X@K&E2Gv#h_j9=%QUAAe8(dt2!rRYt8c|19w45PE-z{Ca&2BA~wtZ!R-n%==
zJ+A{+DxpSOs0Fv7Q-3_xC4z4E>E_#s7<u*g@cTMt7(*0XfZH`{`~O9y*`XVjCNbCG
ztrFFs1!;L%;wV+!H{qydnX_Umxl!a5mR|t=i^;%R|3Vf$Ic|7%FEWR6+9z=-aekU`
zTRz)oH@C<*C~oz}^mDMkQpusI)(d_GjU*-O>fUwir@eT-RII5Q>N{^p7Y;$Awqq^K
z>&d~uEfAYwp5x!T5Hkx$^5OU&!AxPJTBYdHIo}hu$lpebE5xBq=Kxpkp<JDDJEDUt
ziuDe4{VGddwK;>kAasu84(SSKT1GW5oO6$Y^_~6$OG*lgcfJq{7p!}e{d_yd+(}l~
zst!I%nQe*lzI%O*Vzk`HCpQ-uAB5?B95*Ufn4AgQ*D+1r5l!S$e4|=?Biik(hTjb;
zF%c*9Jq-@GCy+g}CNwmG3xE)$in1aXBmBxUktIlvD+58JJ<t_D05B(Lru&+f`*MY`
z8Bi><_ClQ_O1uLF<Q=F#Ppfd;pg7xDS-C@Ns6}Nq4@!V3bmqLtVb1c2ysS?c%9Bvm
z$mB&rB`QCxQgmM+ln}AEs;H7GyC5@Ib{w%1MgEvdMTS8Yw!y0im*ghPiEdv?_9vU2
zVJ{ur6`IgLt*B8?yLzAUjYk@E|JK}=*&z>uS{7vz%XJhTvuJS31_sV}{K-!$s<?=$
zL)nU}9EFWo3oFo#z`R(bDQ>U2>(;q7*3XdghWkNo=)X(%i(O{FPjTP-)I2Y`5jG+H
zDKRwGA&R^_T86GP!FP5|W}AO9449}`sLSDO&h;-*?7m*OhfPvG1=^tt(HLknsc@_o
ze7lzJ^8;#EgKI9z_wT>1RieGU=zKJ>#TFUPR1c6G@;q_hY9DORCJQz7o<q&&=(DI1
zLN(;vD1KHIP+?lHE71z)?oRC0!#CO!`_-_s)KeaJ9nUHl#;yYeC=W16%9z@VO2{Lt
zYr-n^Aes?>Yi+%wuu@6)!l~Xni6)KvA|F2rhFI4lWX)z?aszj;&8{a>$hS$eYAAKz
z5^-|VJsa;U0_w!Lp^@7}GGJ@%K%UMN=W)5li4og1id4uOUshIjvC)>WtgNhW%>z<U
z-4r8zL>IcwMcd@xc!+LJ4;#V=hSR8v4#aBZmBT+u5zaN+Pxzv#P)~@3z^~#_k@z`2
z<a&!3A(({Dc_!$N=ih1Xud(!q7blxTp0E$5dYXIVZyaV&WQ}-hj?8>oR&mmWY^9Bb
zXnM$o3?V<xvs~w928c3sCYgVqerqBMGLaMOwfpIU9ZxgqNP99TUzv|&IPcv7VY_^7
zC-gG@I)29VU(A*yKEB^Pd{gn~L@T8+NsS7NwCaB~CO<1phBG84S?6|HdwY5k=$-cr
zUfH*uay{>HcVcj3VelG>KqZ%$9lN??3?AyZ-7Ker_l8xY*$UjIj8w3ZOasfe%hDUy
zoH7!nCjeo_C4P9Wr%Hvdie1NW@w7Q++^u}=VQ8m)14mXW++2CAe@UO5qcX9-m&M?5
z@8VN6WI?3nt-PgnhZ>_)1`tfmywjV^JU_-nL%3PV&|Zd-nwCg33=3D-frZwFP#|}5
zLG?UHaeHiXG9o=nlVF4)g^JyvmPtZv#?vD-fN{?;M8o{jJ`b#@;a}*X%#MMS+uBON
ztG}T(GOe(uDCI0wK)5Dh=@Fcp*>hEhj-+b5A1l;cr!H6PKJ8`zjfM4yo$R$l(1SHo
zGu0h<u%d@B_A}pWU&7KiN<(L9$WNz#j_jMp42$8>7m01X>$PJO_iqckow#&c1Tn!1
z9gZ|+jn<)TZH<!#`vd*W>gbA8bPQc(OCK#;BW9GzrjZ9Z{^s<OxyOTtvPUWt^U2Xj
zP3)Y&-dNQf;%vofizG<4eG}xCZCvjnvCcIg1M*2)=X`@ipIorKtqBNfyqY*dP0tJv
z(D6c6aEJa1(IJf(JLyFKfvmrF2)j?H7v(N*l2Gz){ZBjWkn5MW3?t7BRPBm=TKL)4
zbRDFA-~due&+99Bpy4b5$B7WYl1r@cHfx78n$b^Y6W^i~BCV*b+1V(QX<nj$p#Xol
zj@BgIdIvpw3LTCzn8^PcYC)P8?k807ZNA@ky&aDBt`^GvDTnIKDBi{<LNT%8Uj(XX
zIk)ucVNobhA>I4X2S*8_Hh%foIZR(-#GQ4JIOnp7MWy?9xP@KNsV0R9jza&+w84gb
z{yCTmIq!SxUdGP-)fhI9w01-~2Wb%UM8|h^H>u&O%V0JgJ2ON3vr-BMeMQ%i7yQu<
zUzO>P$Ta|tAjf9|(jy6OX)zl@Nkx#G&J{{w+8P$mx_anz)C|k&K<1->+DNU;5mW*Y
zr9qL?TvWOT)F+b%--bpcj?h|L+lrB^fEX1uzsS4uZNu?FTN}lYNO<wrr$XHw!?D*?
zR3a5HPZ4|@4Qd`*zLS@&_}d}VwI#K(_E^GsGwz6X=<Lf#LmgJW%Oi=jDXKmZ@qt#C
zi;0{~gf4z>$3Vg)USG?8>C##-DugmZcr`xCnkQ5(Er|NhV8T<Q85j44fH@Jf=3Ly^
zqO+gd=!%LRa0p{iQcFNMKdR0Vvhx%_jW9yA0-o?1QN>Gex?=1%qLN>y;=={%M2HK(
zN9^uZX2;WPwDVIqS7npP7oeRy!E@QKM=mU=Ir@2gKb73p<EH-2Yo|^JiDC5sE9+?m
z<w%1ZacNH-Fc{tifwd_N^n*bqDwBQ7TX>&w;fiNq(|YqN`%Qo%F08qQEHg9n{;BiL
z%dws;Si>TPBU^d%CePRl?`$5KZ~(n*{X^;1bB;j47ySr@iIj}u?VK_<-E@Q}!rEHG
z1AZa$o9j_w8r)FsHd)o^OHR8&raeDW0Wu$FPMnn(UH&!<Nr<xzo;IL~xp++2>!b6i
zn41jyBl)}{-NJR0vMull6!WG0f~4YGLeHyiehGc~B{af3M^0{TcN}+Cozl#9TK^%>
zRBZ_;vc0BiQz1S9_t=9-WyZSu1LxB4{UBOibv2A$AM0F)@=+#MTdWgfDh6RMdVw|j
z3c*q-rkC-fy(0aUT8G{|CS{qE6GX#tNv0wU`@{9(p*?ahCqt@LNsl<qL5Oi$aIhNh
zBwNKfsr|o+1?WhpeX&hw-=4q*R>B0q`a}x2b>mMV=7UCpXqsxu`Du}U&t!b)gHsdU
zy+1XJWb8{i6&d{=%)fgUr=$=Z_WU|s9~0myB{JVHO<j=f_skNI`I#77_{eDR0fXWj
zWGr#qcV6>)SSC9$kH(mMDg-GwwxhYQgU6d%2_T%&=)l3u7qS|SNwHu>-#_b)Bkk3!
zeTn)M7M8J|ja&IVX>=2hb`v9=;*yrT)%xEU$VE+~pl}(9Q4B4Iqr$)aA=9lVG#pnV
z#X>aqt?LqrxDhb<arSKv1!lxdp76ykj(2vKekU76**8azfI6dlQExt;lT*8Pjd1W_
zy(2YeRI12DSyO=|0b+>hYmZ6im=r2!@71W((zrc5lv5k=FUd3BD{`7;Jqz}!bffB#
zrG8UFZ3}8<8rrBuAt7^us!Ee;-WEe9nO$%*jFpBpM3N#Nl+jF}I&`%obt#!Jh5xWe
z62-*aQ3uf$42%3ytd>%u4oEA-vQIac2~LEjLZeeN7Z*zy^lLHJ4!&+c-PAM+{P^<2
zB*n8)0g@OyYN96;YE<kDH;GG1X_ov)2fI~l$&m6=yx>I_%sn`zv;E)3XUP8N;LF{H
zy<uv|*7riAKbdd}E3pp}>+#zcn8eZa5RS+<V>Db0)x_hfHdJ}xm%q(RjoHsTG$qy5
zc-+j8A}$zbD~qaNHRa&Tf6j#zhH!S3vmdcvUpC%|As2A$?eF)md5lj^ekO>bAc(31
zWrh6?5epJmafG17h~7{%V^2@5)g;hJ61^jYwzB<x@%m-7TUc9o7*Y5CDEkpnK;SEd
z6Fv+Bq@f69g`^SxpSza01XPf-^MYq#H6{hFBAflXf2*D;b>EiS2>2BY9RCW#ZUr3Y
zhLT`jVV@xB-$TDU5D0l8qAl!H`O^LMdlU!;qx2KJ#@i*>)Cd^heb<fte#-5wt0Nv%
zGej|qLO7B8F>~&M=y3!zEm;5W)c*<_=n9iQv=sWVl4h~b;b9waDZ&8-&DP-w%Y%jT
zzQO@<U*bnAMd(7j$A9n3{&+=<AH9Fnv&$3NT}@xRQUS?M@gQI%HPwBn8Tt(vn6)fW
zrDYX}Tu9Y(7x29h(urO@$WY0yhwTvp09i1PoOzc%G~Fv`!NWT)9=N0v^$sOA$A!^J
zL690a9cLqwZPkuD4W2p<5hiflSKP+cN8^~cpuhXrOY;&A{Q@cw9z)H^238sDOHuX%
z2iJg6f$g^i$L|A7B6(-GTQYyz$Vgsy8=2;gWR$F4Hnq?NE>adB34BaBBO8;Cz(%z>
z%f@n*Esx4RJ}kzskTJK2lD-5m;pucE=Eadcr#>)<h|gDVnqZ4`B30e$5kXL9$0<p(
z&aIc%NIHUxkb#v6gIB$rM8US&_{}9k{gqdq2%bPLEg;aswdJ2Wfr;i{bzaPB`-gJ_
zY^m`Z##4ETU~4^P>`6nai@$%nxjCW7_w#n}C5pT)tS?Kr=$;rdK<|UOP84liWc^{5
zKYI$z_z;&<M&zg98+qjUSIIn&s-y>+0V|OFIuECJga{8guSNHUdVW2!`_Zw0hK7}e
z#eaC1V*o}O(Ia_g>JQ=Z(Y&7|#&r;ju5ec7aRR>Nivc2uN1fX2SAy^wX7(oQy4jA%
z<?;Yzu6*4VAl5eGkKlioPt(2{&3o(#7w)L^A#HHBLbj9j90H3WxNAJMNmm5lre-0-
zk<1fy!Y*^%iI;mgZ3q{j0Z4+1R#>uP_k(Wd47J$Z#-uaDlZy&54B!S>mzF3ewH@;d
z#}R&vlR*KdeS?a;5&wF|{-9<bo+SvGv<Wzjp9=c*lOO>`x((pKoy!RbB>#|Px}s<L
z!^fwsFiScIr8m`?9sxAsvCCUQHuFNaa#ewh)_AbLsmWVC%>D;HC$p7m?6f|9aOCCl
za?BJq`oW=iLdNjgTzHm07!ct?t(BK7;h!W19^>$*MZRs!@6b*1lmuj>@fZ_Wsr;dw
z_z{tw7Y6%sQQrEHju3|;gu;-0s}-<wHR7zHxq4*SGj@@~)L!SRx0ZSE;hu$a5jjRi
zYoMPrk}QwpsXiXz;ha>-$Ge0be^^DMjC~rjVF!jG9Bp$`>WAFX?APK~3AI$rKdAvn
z3Dq3P=xKIhlMb%D{*E`rGRmX59m#xIy}xq_s5wYURCa``WnmI#9M<l6dTejHej?_Y
z#h7L3y$T?;_=SN%sTQ<aV5np-T|s}^u`pe(VZ?y$FjpmWI2j2~R>XOljRQmEp3n=2
z#;5h)yEA$+pC%0p6+=Ei$c$V98eJYP+?=`f%4t`LBxnHTM{?d-0o*gvq8mllabt*a
z6`BkqXjmMHE+Qb`T6Ml)o}w8#IKYRv)qRXlY`YXBCu0%%aEc&$v$I4QA4leiF#m)z
zyOi}vwXQb`J!#k<7xDpt)q+g`QA415noNfYFJQSEhr-hx{VSkS7WWDO(NXIoCB}HV
zWRG=Rav&R0O~EeooIcWow_x+X^Xt}WUV&(U=tc80B7ES*ldc8HHF*a9*F8NYjO){F
z%k%ypx@ef;QphD}MV5f@O8`1}$YW(%X!bW(Zp6mgQlP*6NAehO0+CE<M>0J`q1$#M
z>1bakHbs#3RejgwW4=^-;ps4;c^1RqGn2iqEyB!%ZA4@7w9#FwLBpSxG%ebtkeS<k
zJiHWt>;l>wT<wj!@1>f*XVja*dcYrJ>apiS_&s~$>C@}$OlNdaCfL)kfEWZ>yV<tI
zycUSN9Vzz_H(k)%EjpPbbw|aU&C^3O_14Q5!AmRd{T|l&U17k5nl6OxxSNj64GXf-
zc)!*7`&9M89W|w>POuu>lzI$0lzba$oDlD?ZHI<L6ekHb=+03%KbEvq{iMjhGS<eX
zG)@?d+W*-b6LO=W#xk6fA3e5g(E+E}VlF@Ah>v2wM<Tk&HY}KgC6~IHLn-7xmB(NI
zj=dMS{x6Z~Fxk>Ut9C?}Zc!*H>VJd?Q7i)-<Co;k&CR^THkBG5I>JfP(o0V=3b;^2
z2wn5P?REWcx@vU*`cEi5%x~=hqq~wUdCzG{d<oau>PjT6a2PmO+KlSxQLvkL=A*a!
z?va`8sgDRzR%tSr(>cOk6|ZCz)2owM*Ypq0#Pyj@r#lV9Rz3+*r5(0elg~CJ+HAkS
zPobrZqK(Si@3XpswM^?z<BisJP7Omdjq4LYA);p=T=m+HyaJr_5cyV73mV&3xIZbb
zy{XXdKczB`w)x-`eyGV4aZf9r=E{oo(=)`^J>UjjKJ=7j8^+GMe;uQ$Rc0d7h4sbr
zG}mGk$YAuVn>{EdIoW~pr=&O~@7l+5+ldqJI~QU0jE&9yJgpoWXNHD+elv{teEJo%
zW3pFFr)9p30$!#C$?2ur%yA!F=HON0t4(<2A>dy!Tu>WqFUBjvzWClhO&aK`qy4Dj
zW8{yiO#tC~*``F^Z>B2l6HDk;PxIDxPt-0ATc@0QLEE&u-rT{O&l_hho%YvJQk0<u
zrR|`JVoB~lf2A)R<BX%P7B2BHp6^H<4HggV+2+8@xF#RUejwWm5XKi_BM2HLRovA^
zq*-nXfE!>xH-6Zd{8&4-f(P*R6o`8rGZ#uAAs~>(3sh{`hAM#B-dgzSDS-Z+&}Km@
z$j1^N+n{<?obTl7(;lckK|LPvY33q$HvH1xP#355_7mFom|44|M#4m_+lLuLpS_=7
z8G7YfT*1pGEkHBO&A*dYdY|D)SKRpkK5H)f^1b)011CF-v4$(D0@bT>6D%I6Vy@sl
z^YbjS+S_GLAk7Yt<OE+H!9Y*4Z2;!`Q=f$FcUwl1z)Ne6Ow^}qTgyaljN3x;1zq56
z<iV)wvYNJokwC^R6sm5@M5BEns~4Kf1lUgho0MnG#E&P1eT*jPE;7{pm${6-#UX5O
zc(_G6?&TN-pO^-HpQZ%7nc}uvbaaxlpi=<Q5^yM$Fesai!6nYhZhB4I9mp4H@Z;rh
z?mv%Xln?Az`fIGspi~`x9j@12f@Jzr4lq}Z)im^5F?6fOMczLORJG<M%Im~!NH!gE
zxJOpee!Vasp&i-6PlIur`nMWx_&dMEa)^sC!KvL*U%}D=oZ=@sDgTBl-;eAc9O)g*
z2>u8q>=$OeqaQR|#>bWHOsD)%1Plw?nTbjC)<&dZq^|^eh-ken>kE_=9f63~KR>2V
z8fdkB+k-b)#nqzTC8$dP^@$#*M^Y@3Krd@Kbv`WZb=5Kw^jeS$&o)|%s=E_(^z;)6
z3Pd@iXkIHA5KDJW2tsk`wVB-o{oXzkPq#;Zq3%{-+nPjP<3uT7giVwZ|Lhw{hCDk;
zQ%pG^Vc_nEP)8a&1Qj@*My}N<oJY)71V=CBKR-v%Wl%57Ud!_-itND65LW2Nr!^GS
zc;nB1zzv_)0k$b#8d=$Kv4c6G+P{1gx`wUREzomI0U=Rz8t9f2Q{T0FddA05`FGRy
z=g0HW<EJx7+t?;IEeC#Ti*m~w7`m_sH-dKtx(WpJdqjh;8i)bS{GroavrLn2aeE!t
z3pe<{0m|DW1?fh}>ep|RxC{FDw@MG0s~8>p9TY{wQMhbJnXWEP!V&8KNWvQ1L}xfN
zDl6yYM(1o$Z`o`P-*Ji|(~)W-D+SHKfkMWr7ZYa|b4_7K0_BN`Zx^^ZrJpPyu(&{R
z7Q6W6Zj6J4hbPLxi0w&Y%TCl>ome6$#(CjN0>g$x+`v1hD?Q@N@0?EJ&(!vj!S%{^
zXYH~u%Xp=KB1w!>z(nDFJV%lOt%jvN$FWa~$pPNB2!QDv1op~=KN%U~e2g#rk?R7#
zEQ4#j<!kPiIooI$P=tbZb67EM56?2SmfEGIDLwu5wwYD1DGB~Q<c5FTv?KURC|U#&
zUf&X$;lV`COfNA3-@?fl0&H(ugj#p-NmMi#-E;*3`B^o6$bFMG$yXy{27%*c=^|G-
zb2!#_>CD4lo?rEH%om@>H#$%UW+~$Tq_U-Y85QaTXSS<hE9v7jwS9m|`0!Wu?#K)E
z)ah|?B*Sur>hl3Ha*k>k$||F6*U%qV<KViV@-+|3oE<bOIqb7jYos`56T>IRp9%i{
zwFzEX3;MOmf_}uUBTd7N=5J}iH<t!q2es-BxCl<^w{FC)n5h43Esbk%C?4oBc<PLT
zmc~ZgR7#J$F&DN;*l-^{?xg2dd?ZoTN)9_<J5KmrBJje?bDE2x<I^8&QR^-PHcKbu
zSs+)KW66!v>2AY>p3nHF$@1DVo<TL*pho9vv5sm~UOiWtm}$Z8J!@`|U~V4eXZ+NU
z2WK%zX4i&RRs#n2QqK;%64nMEKSzM0@Mfg9E(~7LT1|8<p(_e*`x7GJH_zcb$AD{8
zqr3u$>AS7`(^!8*zjN+oL`wWS&s?~RT^ertIvhrN+VM5U^8gB5EEy<2Bdcrp<E{);
zFGVpU6!1uL%DVC%7uqTo)IFIDp{5Er^yw&pyvqt>#@a-<z;5&M)3hlqVG0I@H1WUs
zd^7_LbGZi$3*8ff-KYs(qTi$-W=1N~(Ql}D93OU{&Wdj_4u5tgcMS`_d0D=HPl<uj
zXv~t6c@E-WiGGZ8?d`WqFpun{7UL2ROzjV<Z!$c5CCft6%9*JM+?9cejh{?G4PvZF
zjzcW=@mLtF)wdIM|3N1C;0mU@NxIt8X!~Z9ed&M1YQ#qSS&&3QFva%;pEg3ogL-#)
zSQ{PbMz(nNP~1p>_@Z=~2>6$orAohd1m0_qD+@KuL&fC-&Gr7|i1EkKa)?9sR)V}A
z>|%4$xaPiSewgvSV(vfjt-MAl6cVx*-WM(G%Z<X9;sp%pf?g;7!+7S{g$%RH=BW6Y
z1rP8e^p>Y}{AJB;gT1fpM_c-Rw4ibD%C5?j+L!#Nz$8$J>1ex;>3=J*L6TqASFM`=
z4q|xS1jR9a5=&Tn8hD^=FcCD`JJ$Lr){%=sAW<IG``hq}OO`!dY;V{4IyM_yMo$6n
zTZ$NQSN{u>2XgfP=j-$T^Idz0nN#J9-0Lzm>p=c|VLwZ;BE?3QfWv6RO8#tEwFFpD
zB6bREHwq6LJMA&%00-j3;9r&o9|Ob0$B%<dU`0CPg+c#iNa+;|+^LDn{Iemv;ANvL
z2(l0l@P*t{!`Jgapn@*lHU;}?&kBwIgeX0;oeSGZeyBY;@Ik-fe}|AjUfF{GH-z*R
z^1=<DU?kHugjVWp$Qwf!h0v#i$-fId^X;Eou3HgKZ|@SAhJVdS;@IPK4y1sI(TUJ;
zAR_APomY(dd7K1){Wt;Re&tuyu++l?^)%nCT`cIo;6Xl6BnF|wqQ7P)I-JCyuf8kY
zKgw7}0^|B=^ISO4MOU!qC+?}hfSjK8NrNuiR;al|rW?LXhs1s#JpZ5>O|@?0`G?r5
zxLfppSK<7yk6r=wN3|0NY9=z681o3CvS5VV@O)?AuZc=~X+udM(z*89qxG>}(L9k&
z$226lNA#UZZ*=EwNZtlPs=F~IV8$S<Q|)f(?bbWGwWp;3hO1jR|Mz;W@Kx$$L1;+G
zOuvE3nLFUHtGSsolLQTR20q;d(@>uP0x9UZ<4~WxLmqBUcIMg3?Uze@24F1jdk%wK
z%m1$BMAkr7*)e-DjL|38k%j~i_2>;}0%XCdT@ldUFAmH?9UNEj`w<Mpu$s}>|3Y4w
z*zwqPbqX1F#;;4@7WTS>m7+LFsEW$~1wk^eyBmW+2$s6yTjnJBx=h1mC2D1Ti65z-
zfB18;*j^^T9g@wX)SiJG%*FMqW*V0Ru(mh<qB$J2{%rK2m#w;^G-o)!RZT2FI3D|p
z=0f5~4?x~>SeGA{ij4ZvZLZ*7>6HJ1IDco5BeiJPC#Oez^+;ev@YS;pE9BSP^(R9y
zY<6XdY)pZYUc`a9Y`N1!Ynp0Ct|M)RZ~Tq@6gO$#vk&?sS`{SrVZXlcIYw0AyL>^_
zzJvWP$bL#rCSc<f^#%8*{1>b<YGle~mNlaPqnmsGXL^t00B(+hVKkRwbJ>U$IvLuI
zyIhvLQc_zkvtbS^<uXJ>NOWB0E<!G+#6~U3u~<EHCTcU14G}73id-Ht=bUdn&R=o<
zg3sgg!{_mOzCMq~`+cRfeEL!H`8+i3{a%heeS?M2ihSlKGLx;kAJGR?c6Y)pkV}()
zu~byxj(WK2+mkau`lcGa^t7|eF50gr#IJQZ*eu{wRP=em#+sYRIO?9_0MwDxHc$N#
zo2!n#EzB*YW)^{bR%(D+ALiGNv`O+dz0c<E%Mc^$+6*_VZ&H=DMGffu-K!SV9;3Ld
z7QV@uA^sDAJgw4I<>y!RGE0+cQf|(fv&4D$esmA&gf<N&Ov(I!1!osS)51TrM<S@m
zIxl_L3Q2}o5oB*=h{i~N-ENYAa<$D~-_>eZ-!>2;NqA<l%qj0SkP>FwLM@NZm(RGg
z2RHMigg<rE&<c~WKe&1p!b^CVv#_NFPEtzl)&LH;u{7_`^$(6}v~o6}f)%k?o28Pd
z+5l{UlN&Df($b)9PK%a+3ZAmPoHf=jc|Ayn|3qI+0V`^}7*CLzS=Pphyn1ZkxK?eB
z5XR|qRjhy<zs`8ytFq84g^<^hK34uRSc4MSs~PQsoG)sJ`%*kuQ*IbWi7iDLv~CxQ
zIOor4EC)sjmruOw3m3$^R7w^ZlqFkmtAMLeV2+`G>H^Pu(RI>RdTp=SWVWqy<Z29o
zkk{=TdTY``&^I$<$;ss|!E<}SHG%P(Q2Q4X+}6?-c9JV}t&8+@{(47D!r*XCSES>%
zz6PC7TJozkC<4Bvt{%af`X}mK&=dI;GQ?5{*jh+)yegeecWY@%%i&j}%-VL9eFh(s
zsg{Fk>M_+dE2h-SWc4@~cop*7ahpDE(LsiWs&<Zyl|9A^st}=s=aLnJh15Zif@!Z#
zh9#&h#T;dEaL`@J@*x^yp7rgFUZAN`*XjR^)bzth39G-I`h#(stbQr&AkQND?{}Yr
z<mMuw?n7RcLv|g0?Hr#V6NTH1Yu{PJl@T^y{JNq2ZegvX)JpKc6UVdBbZp%P?<NS-
zi_qc$g|Nk1gi5dqrgi$SYPlw&dgi&d%4s!YUS%Yp4+YwL^2Rz8g2zALh|hBRVl?H~
zMW?E8vmi5wcMe|Qh)IX5NU^_kCJvWnj3p(Iy}8n+H59YY-KmG4P>mKa@maIgFm%eT
z-3~xqY(05270D3IExL-BYvCd7;5JYuw~>qX+7==P;$J;ym5*CrTt5_H%NV%xR-4eY
zOZcK!d7W)NpEz;A4oF~Hi?RIi-b%Rv$a~5BBh-l!vW&rT(A3WP{(O5c?_o_Phg`k(
zNeaY^NIu41al*T6>kj>Mxcsh(cY5h4JF%FLkO2Cb=;|RS<%pI_J}tZWhA1G%Dq_uH
zmmkycZ|2A-hR5_bm>W()0W>x0tWxM;2TLhF`%!`PD4@62TeWBdI=V?InD`MAVJ!AY
zELbt!sA<a&xiZYp4%HRCWqyI!6R6`?UVVcSiTu3{J0n);@Oov}hz{ihfd3VfYQ`Ss
z*Fv`CKORud!<V}}eUsns7=?+U(Hc-@@&&<m&rrD(rcNeEobtH&^7+w%`|w{9s%=S<
zLt33k*pR8wjb4c7rrgRIo^)xrj%hF~y(EPlhlnP!@?CxvKfh=H`_2V54oTW-u!}y9
zPZh|DEp!W?V?Dw@J<gYFTqmYm)&)D@21Ae5x&u9U_fw}-!D5_s(RTyg!Q>niE9QS1
zXLj~acU%V|LDxT!1K!!Xw_3qj1=fUsZk9YNC+Wa@s94>N)7B_elXzxqG{CXDqxFRs
oGggKEV~1&h`_}$PR{A>)vPo8t2%Gi+mM=-UyZX4aJB4KY3*Z&;5C8xG

diff --git a/src/LogExpert.Core/Classes/Highlight/HighlightEvaluator.cs b/src/LogExpert.Core/Classes/Highlight/HighlightEvaluator.cs
index f29de37a..90daf076 100644
--- a/src/LogExpert.Core/Classes/Highlight/HighlightEvaluator.cs
+++ b/src/LogExpert.Core/Classes/Highlight/HighlightEvaluator.cs
@@ -61,14 +61,21 @@ public static IList<HighlightEntry> FindMatchingEntries (IEnumerable<HighlightEn
 
     /// <summary>
     /// Returns whether any hide-line entry matches the line. Other matching entries cannot cancel the decision,
-    /// whatever their order. Temporary search-hit entries never hide.
+    /// whatever their order.
     /// </summary>
     public static bool IsHidden (IEnumerable<HighlightEntry> entries, ITextValueMemory line)
     {
         ArgumentNullException.ThrowIfNull(entries);
         ArgumentNullException.ThrowIfNull(line);
 
-        return entries.Any(e => e.IsHideLine && !e.IsSearchHit && IsMatch(e, line));
+        return entries.Any(e => IsHideRule(e) && IsMatch(e, line));
+    }
+
+    /// <summary>Temporary search-hit entries never hide.</summary>
+    public static bool IsHideRule (HighlightEntry entry)
+    {
+        ArgumentNullException.ThrowIfNull(entry);
+        return entry.IsHideLine && !entry.IsSearchHit;
     }
 
     /// <summary>
diff --git a/src/LogExpert.Core/Classes/Highlight/LineVisibilityTracker.cs b/src/LogExpert.Core/Classes/Highlight/LineVisibilityTracker.cs
index b365ccac..4ad9575e 100644
--- a/src/LogExpert.Core/Classes/Highlight/LineVisibilityTracker.cs
+++ b/src/LogExpert.Core/Classes/Highlight/LineVisibilityTracker.cs
@@ -3,24 +3,15 @@
 namespace LogExpert.Core.Classes.Highlight;
 
 /// <summary>
-/// Owns a Log Window's <see cref="LineVisibilityMap"/>: which original lines the hide-line Highlight Entries of the
-/// active Highlight Group remove from the main grid.
-/// <para>
-/// Full scans (new content, changed rules) run on a cancellable background task against a cloned rule snapshot; the
-/// previous map stays current until the scan's result replaces it in one step. Every structural change bumps a
-/// generation, so a scan that finishes against outdated content or rules is discarded. Appended tail lines are
-/// evaluated synchronously by the caller's thread. Evaluation uses <see cref="HighlightEvaluator.IsHidden"/> only,
-/// so it can never fire a trigger.
-/// </para>
-/// <para>
-/// Lines are never read while the lock is held: the UI thread takes the lock too, and a reader call may wait for the
-/// UI thread. Evaluations run against a state snapshot and commit only if the state (<see cref="_version"/>) is
-/// unchanged, retrying otherwise.
-/// </para>
+/// Keeps a Log Window's <see cref="LineVisibilityMap"/> up to date with the hide-line rules of its Highlight Group.
+/// Lines are never read while the lock is held: a reader call may wait for the UI thread, which takes the lock too.
 /// </summary>
 public sealed class LineVisibilityTracker : IDisposable
 {
+    private const int READ_BATCH_SIZE = 256;
+
     private readonly Func<int, ITextValueMemory?> _getLine;
+    private readonly Func<int, int, IDisposable?>? _pinRange;
     private readonly Lock _lock = new();
 
     private volatile LineVisibilityMap _map = LineVisibilityMap.Empty;
@@ -34,10 +25,12 @@ public sealed class LineVisibilityTracker : IDisposable
     private bool _disposed;
 
     /// <param name="getLine">Reads an original line; read live, since the reader is replaced on reload.</param>
-    public LineVisibilityTracker (Func<int, ITextValueMemory?> getLine)
+    /// <param name="pinRange">Pins the buffers of an inclusive line range before it is read, so they can't be evicted mid-read.</param>
+    public LineVisibilityTracker (Func<int, ITextValueMemory?> getLine, Func<int, int, IDisposable?>? pinRange = null)
     {
         ArgumentNullException.ThrowIfNull(getLine);
         _getLine = getLine;
+        _pinRange = pinRange;
     }
 
     /// <summary>
@@ -96,14 +89,14 @@ public void Rebuild (IEnumerable<HighlightEntry> entries)
         }
     }
 
-    /// <summary>Tail path: evaluates lines appended up to <paramref name="lineCount"/> and returns the current map.</summary>
-    public LineVisibilityMap Extend (int lineCount)
+    /// <summary>Tail path: evaluates lines appended up to <paramref name="lineCount"/>.</summary>
+    public void Extend (int lineCount)
     {
-        return EvaluateAndCommit(lineCount, replace: false);
+        EvaluateAndCommit(lineCount, replace: false);
     }
 
     /// <summary>Tail path, rollover: the first <paramref name="offset"/> lines were dropped.</summary>
-    public LineVisibilityMap Shift (int offset)
+    public void Shift (int offset)
     {
         lock (_lock)
         {
@@ -112,22 +105,20 @@ public LineVisibilityMap Shift (int offset)
                 SetStateLocked(_map.Shift(offset), _rules);
                 RestartPendingScanLocked();
             }
-
-            return _map;
         }
     }
 
     /// <summary>Tail path, truncation: the content was replaced and is re-evaluated up to <paramref name="lineCount"/>.</summary>
-    public LineVisibilityMap Replace (int lineCount)
+    public void Replace (int lineCount)
     {
-        return EvaluateAndCommit(lineCount, replace: true);
+        EvaluateAndCommit(lineCount, replace: true);
     }
 
     /// <summary>
     /// Evaluates against a snapshot outside the lock, then commits only if the state is unchanged, retrying otherwise.
     /// <paramref name="replace"/> re-evaluates from the first line and restarts a pending scan on the new content.
     /// </summary>
-    private LineVisibilityMap EvaluateAndCommit (int lineCount, bool replace)
+    private void EvaluateAndCommit (int lineCount, bool replace)
     {
         while (true)
         {
@@ -138,7 +129,7 @@ private LineVisibilityMap EvaluateAndCommit (int lineCount, bool replace)
             {
                 if (_disposed || (!replace && lineCount <= _map.LineCount))
                 {
-                    return _map;
+                    return;
                 }
 
                 (from, rules, version) = (replace ? LineVisibilityMap.Empty : _map, _rules, _version);
@@ -149,7 +140,7 @@ private LineVisibilityMap EvaluateAndCommit (int lineCount, bool replace)
             {
                 if (_disposed)
                 {
-                    return _map;
+                    return;
                 }
 
                 if (version != _version)
@@ -169,7 +160,7 @@ private LineVisibilityMap EvaluateAndCommit (int lineCount, bool replace)
                 Changed?.Invoke(this, new LineVisibilityChangedEventArgs(map, error));
             }
 
-            return map;
+            return;
         }
     }
 
@@ -333,12 +324,17 @@ private LineVisibilityMap Evaluate (LineVisibilityMap from, HighlightEntry[] rul
         List<int> hidden = [];
         if (rules.Length > 0)
         {
-            for (var i = from.LineCount; i < lineCount; i++)
+            for (var batchStart = from.LineCount; batchStart < lineCount; batchStart += READ_BATCH_SIZE)
             {
-                token.ThrowIfCancellationRequested();
-                if (IsHiddenLine(rules, i))
+                var batchEnd = Math.Min(batchStart + READ_BATCH_SIZE, lineCount);
+                using var pin = _pinRange?.Invoke(batchStart, batchEnd - 1);
+                for (var i = batchStart; i < batchEnd; i++)
                 {
-                    hidden.Add(i);
+                    token.ThrowIfCancellationRequested();
+                    if (IsHiddenLine(rules, i))
+                    {
+                        hidden.Add(i);
+                    }
                 }
             }
         }
@@ -356,7 +352,7 @@ private bool IsHiddenLine (HighlightEntry[] rules, int lineNum)
     private static HighlightEntry[] Snapshot (IEnumerable<HighlightEntry> entries)
     {
         ArgumentNullException.ThrowIfNull(entries);
-        return [.. entries.Where(e => e.IsHideLine && !e.IsSearchHit).Select(e => (HighlightEntry)e.Clone())];
+        return [.. entries.Where(HighlightEvaluator.IsHideRule).Select(e => (HighlightEntry)e.Clone())];
     }
 
     private static bool SameRules (HighlightEntry[] current, HighlightEntry[] next)
diff --git a/src/LogExpert.Resources/Resources.Designer.cs b/src/LogExpert.Resources/Resources.Designer.cs
index af6c275f..ee588c9a 100644
--- a/src/LogExpert.Resources/Resources.Designer.cs
+++ b/src/LogExpert.Resources/Resources.Designer.cs
@@ -416,7 +416,7 @@ public static string Columnizer_SnapshotUnavailable {
                 return ResourceManager.GetString("Columnizer_SnapshotUnavailable", resourceCulture);
             }
         }
-        
+
         /// <summary>
         ///   Looks up a localized string similar to Timestamp selector.
         /// </summary>
@@ -4199,7 +4199,7 @@ public static string MarkerBar_Bookmarks {
                 return ResourceManager.GetString("MarkerBar_Bookmarks", resourceCulture);
             }
         }
-        
+
         /// <summary>
         ///   Looks up a localized string similar to Clear search.
         /// </summary>
@@ -4208,7 +4208,7 @@ public static string MarkerBar_ClearSearch {
                 return ResourceManager.GetString("MarkerBar_ClearSearch", resourceCulture);
             }
         }
-        
+
         /// <summary>
         ///   Looks up a localized string similar to Discovering markers….
         /// </summary>
@@ -4217,7 +4217,7 @@ public static string MarkerBar_Discovering {
                 return ResourceManager.GetString("MarkerBar_Discovering", resourceCulture);
             }
         }
-        
+
         /// <summary>
         ///   Looks up a localized string similar to Filter hits.
         /// </summary>
@@ -4226,7 +4226,7 @@ public static string MarkerBar_FilterHits {
                 return ResourceManager.GetString("MarkerBar_FilterHits", resourceCulture);
             }
         }
-        
+
         /// <summary>
         ///   Looks up a localized string similar to Highlights.
         /// </summary>
@@ -4235,7 +4235,7 @@ public static string MarkerBar_Highlights {
                 return ResourceManager.GetString("MarkerBar_Highlights", resourceCulture);
             }
         }
-        
+
         /// <summary>
         ///   Looks up a localized string similar to Could not read log line {0} while discovering markers..
         /// </summary>
@@ -4244,7 +4244,7 @@ public static string MarkerBar_LineUnavailable {
                 return ResourceManager.GetString("MarkerBar_LineUnavailable", resourceCulture);
             }
         }
-        
+
         /// <summary>
         ///   Looks up a localized string similar to Marker discovery failed: {0}.
         /// </summary>
@@ -4253,7 +4253,7 @@ public static string MarkerBar_ScanFailed {
                 return ResourceManager.GetString("MarkerBar_ScanFailed", resourceCulture);
             }
         }
-        
+
         /// <summary>
         ///   Looks up a localized string similar to Search hits.
         /// </summary>
@@ -4262,7 +4262,7 @@ public static string MarkerBar_SearchHits {
                 return ResourceManager.GetString("MarkerBar_SearchHits", resourceCulture);
             }
         }
-        
+
         /// <summary>
         ///   Looks up a localized string similar to Marker bar.
         /// </summary>
@@ -4271,7 +4271,7 @@ public static string MarkerBar_Title {
                 return ResourceManager.GetString("MarkerBar_Title", resourceCulture);
             }
         }
-        
+
         /// <summary>
         ///   Looks up a localized string similar to {0}: lines {1}–{2}, {3} matching lines.
         /// </summary>
@@ -4280,7 +4280,7 @@ public static string MarkerBar_ToolTip {
                 return ResourceManager.GetString("MarkerBar_ToolTip", resourceCulture);
             }
         }
-        
+
         /// <summary>
         ///   Looks up a localized string similar to Close existing tabs.
         /// </summary>
@@ -4447,16 +4447,12 @@ public static string MultiFileMaskDialog_UI_Label_SettingsFor {
         ///   Looks up a localized string similar to Pattern syntax:
         ///
         ///* = any characters (wildcard)
-        ///$D(&lt;date&gt;) = Date pattern
+        ///$D(&amp;lt;date&amp;gt;) = Date pattern
         ///$I = File index number
         ///$J = File index number, hidden when zero
-        ///$J(&lt;prefix&gt;) = Like $J, but adding &lt;prefix&gt; when non-zero
-        ///
-        ///Examples:
-        ///*$J(.) → app.log, app.log.1, app.log.2
-        ///*$J(.).log → app.log, app.1.log, app.2.log
+        ///$J(&amp;lt;prefix&amp;gt;) = Like $J, but adding &amp;lt;prefix&amp;gt; when non-zero
         ///
-        ///&lt;date&gt;:
+        ///&amp;lt;date&amp;gt;:
         ///DD = day
         ///MM = month
         ///YY[YY] = year
@@ -5628,7 +5624,7 @@ public static string SettingsDialog_UI_CheckBox_checkBoxShowBookmarkMarkers {
                 return ResourceManager.GetString("SettingsDialog_UI_CheckBox_checkBoxShowBookmarkMarkers", resourceCulture);
             }
         }
-        
+
         /// <summary>
         ///   Looks up a localized string similar to Show Error Message?.
         /// </summary>
@@ -5646,7 +5642,7 @@ public static string SettingsDialog_UI_CheckBox_checkBoxShowFilterMarkers {
                 return ResourceManager.GetString("SettingsDialog_UI_CheckBox_checkBoxShowFilterMarkers", resourceCulture);
             }
         }
-        
+
         /// <summary>
         ///   Looks up a localized string similar to Show highlight markers.
         /// </summary>
@@ -5655,7 +5651,7 @@ public static string SettingsDialog_UI_CheckBox_checkBoxShowHighlightMarkers {
                 return ResourceManager.GetString("SettingsDialog_UI_CheckBox_checkBoxShowHighlightMarkers", resourceCulture);
             }
         }
-        
+
         /// <summary>
         ///   Looks up a localized string similar to Show marker bar.
         /// </summary>
@@ -5664,7 +5660,7 @@ public static string SettingsDialog_UI_CheckBox_checkBoxShowMarkerBar {
                 return ResourceManager.GetString("SettingsDialog_UI_CheckBox_checkBoxShowMarkerBar", resourceCulture);
             }
         }
-        
+
         /// <summary>
         ///   Looks up a localized string similar to Show search markers.
         /// </summary>
@@ -5673,7 +5669,7 @@ public static string SettingsDialog_UI_CheckBox_checkBoxShowSearchMarkers {
                 return ResourceManager.GetString("SettingsDialog_UI_CheckBox_checkBoxShowSearchMarkers", resourceCulture);
             }
         }
-        
+
         /// <summary>
         ///   Looks up a localized string similar to Allow only 1 Instance.
         /// </summary>
@@ -6592,7 +6588,7 @@ public static string SettingsDialog_UI_TabPage_tabPageMarkerBar {
                 return ResourceManager.GetString("SettingsDialog_UI_TabPage_tabPageMarkerBar", resourceCulture);
             }
         }
-        
+
         /// <summary>
         ///   Looks up a localized string similar to Memory/CPU.
         /// </summary>
diff --git a/src/LogExpert.Tests/ConfigManagerTests/ConfigManagerTest.cs b/src/LogExpert.Tests/ConfigManagerTests/ConfigManagerTest.cs
index a4fa4cb7..a6ffa31e 100644
--- a/src/LogExpert.Tests/ConfigManagerTests/ConfigManagerTest.cs
+++ b/src/LogExpert.Tests/ConfigManagerTests/ConfigManagerTest.cs
@@ -1,6 +1,7 @@
 using System.Reflection;
 
 using LogExpert.Core.Classes.Filter;
+using LogExpert.Core.Classes.Highlight;
 using LogExpert.Core.Config;
 using LogExpert.Core.Entities;
 
@@ -1061,5 +1062,49 @@ public void LoadOrCreateNew_BothPropertiesInJSON_NoDuplicates ()
         Assert.That(loadResult.Settings.Preferences.HighlightGroupList[0].GroupName, Is.EqualTo("Group1"));
     }
 
+    [Test]
+    [Category("BackwardCompatibility")]
+    public void HighlightExportImport_KeepsHideLineFlag ()
+    {
+        FileInfo exportFile = new(Path.Join(_testDir, "highlights.json"));
+        _configManager.Settings.Preferences.HighlightGroupList =
+        [
+            new HighlightGroup
+            {
+                GroupName = "HideGroup",
+                HighlightEntryList = [new HighlightEntry { SearchText = "DEBUG", IsHideLine = true }, new HighlightEntry { SearchText = "INFO" }]
+            }
+        ];
+
+        _configManager.Export(exportFile, SettingsFlags.HighlightSettings);
+        _configManager.Settings.Preferences.HighlightGroupList.Clear();
+        _configManager.ImportHighlightSettings(exportFile, ExportImportFlags.HighlightSettings);
+
+        var entries = _configManager.Settings.Preferences.HighlightGroupList.Single(group => group.GroupName == "HideGroup").HighlightEntryList;
+        Assert.That(entries.Select(entry => entry.IsHideLine), Is.EqualTo(new[] { true, false }));
+    }
+
+    [Test]
+    [Category("BackwardCompatibility")]
+    public void HighlightImport_LegacyFileWithoutHideLine_LoadsAsNotHidden ()
+    {
+        string legacyJson = @"[
+  {
+    ""GroupName"": ""LegacyGroup"",
+    ""HighlightEntryList"": [
+      { ""SearchText"": ""DEBUG"", ""IsRegex"": false, ""IsSetBookmark"": true }
+    ]
+  }
+]";
+        FileInfo importFile = new(Path.Join(_testDir, "legacy_highlights.json"));
+        File.WriteAllText(importFile.FullName, legacyJson);
+
+        _configManager.ImportHighlightSettings(importFile, ExportImportFlags.HighlightSettings);
+
+        var entry = _configManager.Settings.Preferences.HighlightGroupList.Single(group => group.GroupName == "LegacyGroup").HighlightEntryList.Single();
+        Assert.That(entry.IsSetBookmark, Is.True);
+        Assert.That(entry.IsHideLine, Is.False);
+    }
+
     #endregion
 }
diff --git a/src/LogExpert.Tests/Highlight/LineVisibilityTrackerTests.cs b/src/LogExpert.Tests/Highlight/LineVisibilityTrackerTests.cs
index 726cab18..baa672f1 100644
--- a/src/LogExpert.Tests/Highlight/LineVisibilityTrackerTests.cs
+++ b/src/LogExpert.Tests/Highlight/LineVisibilityTrackerTests.cs
@@ -126,11 +126,11 @@ public void Extend_EvaluatesAppendedLines_AsAnAppendOfTheCurrentMap ()
         var before = _tracker.Map;
         _lines.AddRange(["DEBUG f", "INFO g"]);
 
-        var after = _tracker.Extend(7);
+        _tracker.Extend(7);
+        var after = _tracker.Map;
 
         Assert.That(VisibleLines(after), Is.EqualTo(new[] { 0, 2, 4, 6 }));
         Assert.That(after.IsAppendOf(before), Is.True);
-        Assert.That(_tracker.Map, Is.SameAs(after));
     }
 
     [Test]
@@ -140,7 +140,9 @@ public void Extend_ToAKnownLineCount_ChangesNothing ()
         Idle();
         var before = _tracker.Map;
 
-        Assert.That(_tracker.Extend(3), Is.SameAs(before));
+        _tracker.Extend(3);
+
+        Assert.That(_tracker.Map, Is.SameAs(before));
     }
 
     [Test]
@@ -219,7 +221,8 @@ public void Shift_RenumbersTheCurrentMap ()
         _tracker.Load(_lines.Count, HideDebug);
         Idle();
 
-        var shifted = _tracker.Shift(2);
+        _tracker.Shift(2);
+        var shifted = _tracker.Map;
 
         Assert.That(shifted.LineCount, Is.EqualTo(3));
         Assert.That(VisibleLines(shifted), Is.EqualTo(new[] { 0, 2 }));
@@ -235,7 +238,7 @@ public void Shift_WhileScanPending_RestartsTheScanOnTheNewNumbering ()
             _lines.RemoveRange(0, 2);
         }
 
-        _ = _tracker.Shift(2);
+        _tracker.Shift(2);
         _gate.Set();
         Idle();
 
@@ -254,9 +257,43 @@ public void Replace_ReevaluatesEveryLineOfTheNewContent ()
             _lines.AddRange(["DEBUG x", "INFO y"]);
         }
 
-        var replaced = _tracker.Replace(2);
+        _tracker.Replace(2);
+
+        Assert.That(VisibleLines(_tracker.Map), Is.EqualTo(new[] { 1 }));
+    }
 
-        Assert.That(VisibleLines(replaced), Is.EqualTo(new[] { 1 }));
+    [Test]
+    public void EveryLine_IsReadWhileItsBufferIsPinned ()
+    {
+        var pinned = (First: -1, Last: -1);
+        var unpinnedReads = new List<int>();
+        using var tracker = new LineVisibilityTracker(
+            i =>
+            {
+                if (i < pinned.First || i > pinned.Last)
+                {
+                    unpinnedReads.Add(i);
+                }
+
+                return new LogLine(i % 2 == 0 ? "DEBUG" : "INFO", i);
+            },
+            (first, last) =>
+            {
+                pinned = (first, last);
+                return new ActionDisposable(() => pinned = (-1, -1));
+            });
+
+        tracker.Load(1000, HideDebug);
+        Assert.That(tracker.WhenIdle().Wait(Timeout), Is.True);
+        tracker.Extend(1100);
+
+        Assert.That(unpinnedReads, Is.Empty);
+        Assert.That(tracker.Map.HiddenCount, Is.EqualTo(550));
+    }
+
+    private sealed class ActionDisposable (Action dispose) : IDisposable
+    {
+        public void Dispose () => dispose();
     }
 
     [Test]
@@ -293,7 +330,8 @@ public void TailFailure_FallsBackToAllVisible ()
         Assert.That(tracker.WhenIdle().Wait(Timeout), Is.True);
         fail = true;
 
-        var map = tracker.Extend(6);
+        tracker.Extend(6);
+        var map = tracker.Map;
 
         Assert.That(map.LineCount, Is.EqualTo(6));
         Assert.That(map.HiddenCount, Is.Zero);
@@ -314,7 +352,7 @@ public void ReaderCallInProgress_NeverBlocksTheOtherCallers ()
         {
             _ = _tracker.IsScanning;
             _tracker.Rebuild([new HighlightEntry { SearchText = "INFO", IsHideLine = true }]);
-            _ = _tracker.Shift(0);
+            _tracker.Shift(0);
             _tracker.Load(_lines.Count, HideDebug);
         });
 
diff --git a/src/LogExpert.Tests/Marker/MarkerCriteriaTests.cs b/src/LogExpert.Tests/Marker/MarkerCriteriaTests.cs
index 2e297f43..509289ac 100644
--- a/src/LogExpert.Tests/Marker/MarkerCriteriaTests.cs
+++ b/src/LogExpert.Tests/Marker/MarkerCriteriaTests.cs
@@ -63,4 +63,26 @@ public void Highlights_FirstVisualRuleWinsAndCriteriaAreSnapshotted ()
 
         Assert.That(match, Is.EqualTo(new MarkerLine(7, Color.Red.ToArgb(), 1)));
     }
+
+    [Test]
+    public void Highlights_HideRuleWithColors_StillProducesAMarker ()
+    {
+        var criteria = MarkerCriteria.ForHighlights([
+            new HighlightEntry { SearchText = "DEBUG", IsHideLine = true, BackgroundColor = Color.Orange }
+        ]);
+
+        Assert.That(criteria.IsEmpty, Is.False);
+        Assert.That(criteria.Match(4, new LogLine("DEBUG 4", 4)), Is.EqualTo(new MarkerLine(4, Color.Orange.ToArgb(), 0)));
+    }
+
+    [Test]
+    public void Highlights_HideRuleWithoutVisualAttributes_ProducesNoMarker ()
+    {
+        var criteria = MarkerCriteria.ForHighlights([
+            new HighlightEntry { SearchText = "DEBUG", IsHideLine = true }
+        ]);
+
+        Assert.That(criteria.IsEmpty, Is.True);
+        Assert.That(criteria.Match(4, new LogLine("DEBUG 4", 4)), Is.Null);
+    }
 }
\ No newline at end of file
diff --git a/src/LogExpert.UI.Tests/HiddenLinesWindowTests.cs b/src/LogExpert.UI.Tests/HiddenLinesWindowTests.cs
index 87985173..478d1b5e 100644
--- a/src/LogExpert.UI.Tests/HiddenLinesWindowTests.cs
+++ b/src/LogExpert.UI.Tests/HiddenLinesWindowTests.cs
@@ -131,6 +131,22 @@ public void Load_ShowsNoRowsUntilTheFirstScanHasFinished ()
         Assert.That(largest, Is.EqualTo(10_000), "hidden lines must never be shown while the first scan runs");
     }
 
+    [Test]
+    public void GotoLine_BeforeTheFirstScanHasFinished_IsAppliedOnceItHas ()
+    {
+        File.WriteAllLines(_fileName, Enumerable.Range(0, 20_000).Select(Text));
+        _window = new LogTabWindow([_fileName], 1, false, _config.Object) { ShowInTaskbar = false, Opacity = 0 };
+        Find<WeifenLuo.WinFormsUI.Docking.DockPanel>(_window, "dockPanel").ShowDocumentIcon = false;
+        _window.Show();
+        PumpUntil(() => _window.CurrentLogWindow != null);
+        var log = _window.CurrentLogWindow;
+
+        log.GotoLine(12_345);
+        PumpUntil(() => log.CurrentLineNum == 12_345);
+
+        Assert.That(log.ShowHiddenLines, Is.True);
+    }
+
     [TestCase(12, 12)]
     [TestCase(13, 14)]
     public void SavedPosition_IsRestoredOnceTheFirstScanHasFinished (int savedLine, int expectedLine)
@@ -460,6 +476,102 @@ public void WindowFilter_StillFindsHiddenLines ()
         Assert.That(Grid(log).RowCount, Is.EqualTo(LINE_COUNT / 2));
     }
 
+    [Test]
+    public void FilterTab_HidesLinesThroughItsOwnGroup_AndLocateRevealsTheHiddenOriginalLine ()
+    {
+        _settings.Preferences.HighlightGroupList.Add(new HighlightGroup
+        {
+            GroupName = "hide-some",
+            HighlightEntryList = [new HighlightEntry { SearchText = "DEBUG (3|7|11|15|19)$", IsRegex = true, IsHideLine = true }]
+        });
+        var origin = Open();
+        if (!Find<Button>(origin, "filterSearchButton").Visible)
+        {
+            origin.ToggleFilterPanel();
+        }
+
+        PumpUntil(() => Find<Button>(origin, "filterSearchButton").Visible && Find<Button>(origin, "filterSearchButton").Enabled);
+        Find<ComboBox>(origin, "filterComboBox").Text = "DEBUG";
+        Find<Button>(origin, "filterSearchButton").PerformClick();
+        var filterGrid = Find<DataGridView>(origin, "filterGridView");
+        PumpUntil(() => filterGrid.RowCount == LINE_COUNT / 2 && Find<Button>(origin, "filterSearchButton").Enabled);
+
+        MenuItem(origin, "filterToTabToolStripMenuItem").PerformClick();
+        PumpUntil(() => _window!.CurrentLogWindow is { FilterPipe: not null });
+        var tab = _window!.CurrentLogWindow;
+        var loaded = Task.Run(tab.WaitForLoadingFinished);
+        PumpUntil(() => loaded.IsCompleted);
+        tab.SetCurrentHighlightGroup("hide-some");
+        WaitForVisibility(tab);
+
+        var tabGrid = Grid(tab);
+        Assert.That(tabGrid.RowCount, Is.EqualTo(5));
+        Assert.That(DisplayedLineNumber(tabGrid, 0), Is.EqualTo("1"));
+        Assert.That(DisplayedLineNumber(tabGrid, 1), Is.EqualTo("3"));
+        Assert.That(tab.HiddenLineCount, Is.EqualTo(5));
+
+        tab.GotoLine(2);
+        var locate = MenuItem(tab, "locateLineInOriginalFileToolStripMenuItem");
+        locate.Enabled = true;
+        locate.PerformClick();
+        PumpUntil(() => _window.CurrentLogWindow == origin);
+
+        Assert.That(origin.ShowHiddenLines, Is.True);
+        Assert.That(origin.CurrentLineNum, Is.EqualTo(5));
+    }
+
+    [Test]
+    public void Truncation_WhileTailing_RecomputesHiddenLinesForTheNewContent ()
+    {
+        var log = Open();
+        var grid = Grid(log);
+        log.GotoLine(14);
+
+        File.WriteAllLines(_fileName, ["DEBUG a", "INFO b", "INFO c", "DEBUG d", "INFO e", "DEBUG f", "DEBUG g"]);
+        PumpUntil(() => log.GatherSessionSnapshot().LineCount == 7);
+        WaitForVisibility(log);
+        PumpUntil(() => grid.RowCount == 3);
+
+        Assert.That(log.HiddenLineCount, Is.EqualTo(4));
+        Assert.That(DisplayedLineNumber(grid, 0), Is.EqualTo("2"));
+        Assert.That(DisplayedLineNumber(grid, 1), Is.EqualTo("3"));
+        Assert.That(DisplayedLineNumber(grid, 2), Is.EqualTo("5"));
+        Assert.That(log.ShowHiddenLines, Is.False);
+        Assert.That(log.CurrentLineNum, Is.AnyOf(1, 2, 4));
+        Assert.That(grid.CurrentCellAddress.Y, Is.LessThan(grid.RowCount));
+    }
+
+    [Test]
+    public void MultiFileRollover_ShiftsHiddenLinesWithTheDroppedFile ()
+    {
+        File.WriteAllLines(_fileName + ".1", Enumerable.Range(0, 9).Select(Text));
+        File.WriteAllLines(_fileName, Enumerable.Range(9, 10).Select(Text));
+        var log = Open();
+        var finished = false;
+        log.ProgressBarUpdate += (_, progress) => finished |= !progress.Visible;
+        log.SwitchMultiFile(true);
+        PumpUntil(() => finished);
+        var loaded = Task.Run(log.WaitForLoadingFinished);
+        PumpUntil(() => loaded.IsCompleted);
+        WaitForVisibility(log);
+        var grid = Grid(log);
+        PumpUntil(() => log.GatherSessionSnapshot().LineCount == 19 && grid.RowCount == 10);
+
+        var next = Path.Join(_directory, "next.tmp");
+        File.WriteAllLines(next, Enumerable.Range(19, 3).Select(Text));
+        File.Delete(_fileName + ".1");
+        File.Move(_fileName, _fileName + ".1");
+        File.Move(next, _fileName);
+        PumpUntil(() => log.GatherSessionSnapshot().LineCount == 13);
+        WaitForVisibility(log);
+        PumpUntil(() => grid.RowCount == 6);
+
+        Assert.That(log.HiddenLineCount, Is.EqualTo(7));
+        Assert.That(Enumerable.Range(0, 6).Select(row => DisplayedLineNumber(grid, row)), Is.EqualTo(new[] { "2", "4", "6", "8", "10", "12" }));
+        Assert.That(DisplayedText(grid, 0), Is.EqualTo("INFO 10"));
+        Assert.That(DisplayedText(grid, 5), Is.EqualTo("INFO 20"));
+    }
+
     [Test]
     public void MarkerClick_OnHiddenLine_RevealsIt ()
     {
@@ -588,6 +700,16 @@ private static string DisplayedLineNumber (DataGridView grid, int row)
         return ((IColumnMemory)grid.Rows[row].Cells[1].Value).FullValue.ToString();
     }
 
+    private static ToolStripMenuItem MenuItem (LogWindow log, string name)
+    {
+        return (ToolStripMenuItem)typeof(LogWindow).GetField(name, System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic)!.GetValue(log)!;
+    }
+
+    private static string DisplayedText (DataGridView grid, int row)
+    {
+        return ((IColumnMemory)grid.Rows[row].Cells[grid.ColumnCount - 1].Value).FullValue.ToString();
+    }
+
     private static TControl Find<TControl> (Control parent, string name) where TControl : Control
     {
         return (TControl)parent.Controls.Find(name, true).Single();
diff --git a/src/LogExpert.UI/Controls/LogWindow/LogWindow.LineVisibility.cs b/src/LogExpert.UI/Controls/LogWindow/LogWindow.LineVisibility.cs
index 97d3d969..1cffd64c 100644
--- a/src/LogExpert.UI/Controls/LogWindow/LogWindow.LineVisibility.cs
+++ b/src/LogExpert.UI/Controls/LogWindow/LogWindow.LineVisibility.cs
@@ -2,6 +2,7 @@
 using System.Globalization;
 
 using LogExpert.Core.Classes.Highlight;
+using LogExpert.Core.Interfaces;
 
 namespace LogExpert.UI.Controls.LogWindow;
 
@@ -22,14 +23,17 @@ internal partial class LogWindow
 
     private LineVisibilityTracker _lineVisibility;
 
-    // Only touched on the UI thread; worker threads read it once into a local.
+    // Written only on the UI thread; other threads read it once into a local.
     private volatile LineVisibilityMap _rowMap = LineVisibilityMap.Empty;
     private LineVisibilityMap _appliedTrackedMap = LineVisibilityMap.Empty;
     private bool _showHiddenLines;
     private bool _isLoadComplete;
 
-    // A saved or reload position (original lines) waiting for the load's first scan.
-    private (int CurrentLine, int FirstDisplayedLine)? _pendingPosition;
+    // A saved or reload position waiting for the load's first scan.
+    private GridPosition? _pendingPosition;
+
+    /// <summary>The selected and first displayed original lines of the main grid; -1 when there is none.</summary>
+    private readonly record struct GridPosition (int CurrentLine, int FirstDisplayedLine);
 
     /// <summary>Number of lines the active hide rules remove, whether or not the override shows them.</summary>
     internal int HiddenLineCount => _lineVisibility.Map.HiddenCount;
@@ -58,7 +62,9 @@ internal Task WhenLineVisibilityIdle ()
 
     private void InitializeLineVisibility ()
     {
-        _lineVisibility = new LineVisibilityTracker(line => _logFileReader?.GetLogLineMemory(line));
+        _lineVisibility = new LineVisibilityTracker(
+            line => _logFileReader?.GetLogLineMemory(line),
+            (first, last) => (_logFileReader as IBufferPinning)?.PinRange(first, last));
         _lineVisibility.Changed += OnLineVisibilityChanged;
 
         _showHiddenLinesCheckBox.Text = Resources.LogWindow_UI_CheckBox_ShowHiddenLines;
@@ -228,37 +234,41 @@ private bool PublishTrackedMap (int rolloverOffset)
         if (_pendingPosition is { } position && !_lineVisibility.IsLoadPending)
         {
             _pendingPosition = null;
-            ApplyPosition(position.CurrentLine, position.FirstDisplayedLine);
+            ApplyPosition(position, true);
         }
 
         UpdateHiddenLinesBar();
         return changed;
     }
 
-    /// <summary>
-    /// Restores a saved or reload position (original lines; a hidden one resolves to the nearest visible line),
-    /// deferred until the load's first scan has published the rows.
-    /// </summary>
-    private void RestorePosition (int currentLine, int firstDisplayedLine)
+    private GridPosition CurrentGridPosition ()
+    {
+        return new GridPosition(CurrentLineNum, RowToLine(dataGridView.FirstDisplayedScrollingRowIndex));
+    }
+
+    /// <summary>Restores a saved or reload position, deferred until the load's first scan has published the rows.</summary>
+    private void RestorePosition (GridPosition position)
     {
         if (_lineVisibility.IsLoadPending && !_showHiddenLines)
         {
-            _pendingPosition = (currentLine, firstDisplayedLine);
+            _pendingPosition = position;
             return;
         }
 
-        ApplyPosition(currentLine, firstDisplayedLine);
+        ApplyPosition(position, true);
     }
 
-    private void ApplyPosition (int currentLine, int firstDisplayedLine)
+    /// <summary>Scrolls to and optionally selects a position; a hidden line resolves to the nearest visible row.</summary>
+    private void ApplyPosition (GridPosition position, bool select)
     {
-        var currentRow = currentLine >= 0 ? _rowMap.NearestRow(currentLine) : -1;
-        if (currentRow >= 0)
+        var currentRow = position.CurrentLine >= 0 ? _rowMap.NearestRow(position.CurrentLine) : -1;
+        if (select && currentRow >= 0)
         {
-            SelectRow(currentRow, false, true);
+            dataGridView.CurrentCell = dataGridView.Rows[currentRow].Cells[0];
+            dataGridView.Rows[currentRow].Selected = true;
         }
 
-        var firstRow = firstDisplayedLine >= 0 ? _rowMap.NearestRow(firstDisplayedLine) : -1;
+        var firstRow = position.FirstDisplayedLine >= 0 ? _rowMap.NearestRow(position.FirstDisplayedLine) : -1;
         if (firstRow >= 0)
         {
             dataGridView.FirstDisplayedScrollingRowIndex = firstRow;
@@ -267,22 +277,18 @@ private void ApplyPosition (int currentLine, int firstDisplayedLine)
 
     /// <summary>
     /// Switches the grid to <paramref name="newMap"/>. An append only grows the row count; any other change
-    /// rebuilds the rows and restores the selection and scroll position by original line, after moving those
-    /// lines up by <paramref name="rolloverOffset"/>.
+    /// rebuilds the rows and keeps the position by original line, moved up by <paramref name="rolloverOffset"/>.
     /// </summary>
     private void SetRowMap (LineVisibilityMap newMap, int rolloverOffset)
     {
-        var oldMap = _rowMap;
-        if (newMap.IsAppendOf(oldMap) && rolloverOffset == 0)
+        if (newMap.IsAppendOf(_rowMap) && rolloverOffset == 0)
         {
             _rowMap = newMap;
             dataGridView.RowCount = newMap.VisibleCount;
             return;
         }
 
-        var currentLine = oldMap.RowToLine(dataGridView.CurrentCellAddress.Y);
-        var firstLine = oldMap.RowToLine(dataGridView.FirstDisplayedScrollingRowIndex);
-        var hadCurrentLine = currentLine >= 0;
+        var position = CurrentGridPosition();
 
         dataGridView.RowCount = 0;
         _columnCache.MarkPrefetchStale();
@@ -293,29 +299,17 @@ private void SetRowMap (LineVisibilityMap newMap, int rolloverOffset)
             dataGridView.UpdateRowHeightInfo(0, true);
         }
 
-        if (dataGridView.RowCount == 0)
+        if (dataGridView.RowCount > 0)
         {
-            return;
-        }
-
-        if (firstLine >= 0)
-        {
-            var firstRow = newMap.NearestRow(Math.Max(0, firstLine - rolloverOffset));
-            if (firstRow >= 0)
-            {
-                dataGridView.FirstDisplayedScrollingRowIndex = firstRow;
-            }
+            ApplyPosition(Shifted(position, rolloverOffset), !_guiStateArgs.FollowTail);
         }
+    }
 
-        if (hadCurrentLine && !_guiStateArgs.FollowTail)
-        {
-            var row = newMap.NearestRow(Math.Max(0, currentLine - rolloverOffset));
-            if (row >= 0)
-            {
-                dataGridView.CurrentCell = dataGridView.Rows[row].Cells[0];
-                dataGridView.Rows[row].Selected = true;
-            }
-        }
+    private static GridPosition Shifted (GridPosition position, int offset)
+    {
+        return new GridPosition(
+            position.CurrentLine < 0 ? -1 : Math.Max(0, position.CurrentLine - offset),
+            position.FirstDisplayedLine < 0 ? -1 : Math.Max(0, position.FirstDisplayedLine - offset));
     }
 
     /// <summary>Original line displayed in a main-grid row, or -1.</summary>
@@ -331,27 +325,29 @@ private int LineToRow (int line)
     }
 
     /// <summary>
-    /// Explicit navigation to an original line: a line beyond the end resolves to the last row; a hidden line turns
-    /// on "Show hidden lines" so that exact line can be selected. Returns the row, or -1.
+    /// The row to select for an original line, or -1. A line beyond the end resolves to the last row. A hidden line
+    /// turns on "Show hidden lines" when <paramref name="reveal"/> (explicit navigation), else resolves to the nearest
+    /// visible row. Explicit navigation before the first scan is published waits for it, like <see cref="RequestGotoLine"/>.
     /// </summary>
-    private int RevealLine (int line)
+    private int NavigationRow (int line, bool reveal)
     {
         if (line < 0)
         {
             return -1;
         }
 
-        if (line >= _rowMap.LineCount)
+        if (reveal && !_isReadyForLineNavigation)
         {
-            return dataGridView.RowCount - 1;
+            RequestGotoLine(line + 1);
+            return -1;
         }
 
-        if (_rowMap.IsHidden(line))
+        if (reveal && _rowMap.IsHidden(line))
         {
             ShowHiddenLines = true;
         }
 
-        return LineToRow(line);
+        return _rowMap.NearestRow(line);
     }
 
     /// <summary>Line navigation may run once the file is loaded and the first visibility scan is published.</summary>
diff --git a/src/LogExpert.UI/Controls/LogWindow/LogWindow.MarkerBar.cs b/src/LogExpert.UI/Controls/LogWindow/LogWindow.MarkerBar.cs
index 1506825f..26d16393 100644
--- a/src/LogExpert.UI/Controls/LogWindow/LogWindow.MarkerBar.cs
+++ b/src/LogExpert.UI/Controls/LogWindow/LogWindow.MarkerBar.cs
@@ -336,7 +336,7 @@ private void ReportMarkerError (MarkerSnapshot snapshot, ref MarkerSnapshot? rep
     private void OnMarkerLineSelected (object? sender, SelectLineEventArgs eventArgs)
     {
         if (_markerFrame?.Generation == Volatile.Read(ref _markerGeneration)
-            && eventArgs.Line >= 0 && eventArgs.Line < _rowMap.LineCount)
+            && eventArgs.Line >= 0 && eventArgs.Line < _lineVisibility.Map.LineCount)
         {
             RequestGotoLine(eventArgs.Line + 1);
         }
diff --git a/src/LogExpert.UI/Controls/LogWindow/LogWindow.cs b/src/LogExpert.UI/Controls/LogWindow/LogWindow.cs
index 82dc995a..f1cfdc23 100644
--- a/src/LogExpert.UI/Controls/LogWindow/LogWindow.cs
+++ b/src/LogExpert.UI/Controls/LogWindow/LogWindow.cs
@@ -717,7 +717,7 @@ internal void DumpBufferDiagnostic ()
     [SupportedOSPlatform("windows")]
     void ILineSelectable.SelectLine (int lineNum, bool triggerSyncCall, bool shouldScroll)
     {
-        SelectLine(lineNum, triggerSyncCall, shouldScroll);
+        RevealAndSelectLine(lineNum, triggerSyncCall, shouldScroll);
     }
 
     #region Event Handlers
@@ -1110,7 +1110,7 @@ private void OnDataGridViewCurrentCellChanged (object sender, EventArgs e)
     {
         if (dataGridView.CurrentRow != null)
         {
-            _statusEventArgs.CurrentLineNum = RowToLine(dataGridView.CurrentRow.Index) + 1;
+            _statusEventArgs.CurrentLineNum = CurrentLineNum + 1;
             SendStatusLineUpdate();
             if (syncFilterCheckBox.Checked)
             {
@@ -1279,7 +1279,7 @@ private void OnFilterGridViewKeyDown (object sender, KeyEventArgs e)
                     if (filterGridView.CurrentCellAddress.Y >= 0 && filterGridView.CurrentCellAddress.Y < _filterResultList.Count)
                     {
                         var lineNum = _filterResultList[filterGridView.CurrentCellAddress.Y];
-                        SelectLine(lineNum, false, true);
+                        RevealAndSelectLine(lineNum, false, true);
                         e.Handled = true;
                     }
 
@@ -1498,7 +1498,7 @@ private void OnDataGridContextMenuStripOpening (object sender, CancelEventArgs e
         var lineNum = -1;
         if (dataGridView.CurrentRow != null)
         {
-            lineNum = RowToLine(dataGridView.CurrentRow.Index);
+            lineNum = CurrentLineNum;
         }
 
         if (lineNum == -1)
@@ -1684,7 +1684,7 @@ private void OnLocateLineInOriginalFileToolStripMenuItemClick (object sender, Ev
     {
         if (dataGridView.CurrentRow != null && FilterPipe != null)
         {
-            var lineNum = FilterPipe.GetOriginalLineNum(RowToLine(dataGridView.CurrentRow.Index));
+            var lineNum = FilterPipe.GetOriginalLineNum(CurrentLineNum);
             if (lineNum != -1)
             {
                 FilterPipe.OriginWindow.SelectLine(lineNum, false, true);
@@ -1934,7 +1934,7 @@ private void OnRestoreColumnsToolStripMenuItemClick (object sender, EventArgs e)
     [SupportedOSPlatform("windows")]
     private void OnTimeSpreadingControlLineSelected (object sender, SelectLineEventArgs e)
     {
-        SelectLine(e.Line, false, true);
+        RevealAndSelectLine(e.Line, false, true);
     }
 
     [SupportedOSPlatform("windows")]
@@ -2671,7 +2671,6 @@ private void LoadPersistenceData ()
             _rowHeightList = snapshot.RowHeightList;
             try
             {
-                // Saved positions are original lines; without a valid one, the last line is selected.
                 var lineCount = _logFileReader.LineCount;
                 var currentLine = snapshot.CurrentLine >= 0 && snapshot.CurrentLine < lineCount
                     ? snapshot.CurrentLine
@@ -2679,7 +2678,7 @@ private void LoadPersistenceData ()
                 var firstLine = snapshot.FirstDisplayedLine >= 0 && snapshot.FirstDisplayedLine < lineCount
                     ? snapshot.FirstDisplayedLine
                     : currentLine;
-                RestorePosition(currentLine, firstLine);
+                RestorePosition(new GridPosition(currentLine, firstLine));
 
                 // Applied once, here (was double-applied: always pre-load, here only when true).
                 // Applying true after positioning keeps the jump-to-tail semantics.
@@ -2813,11 +2812,10 @@ private void EnterLoadFileStatus ()
     [SupportedOSPlatform("windows")]
     private void PositionAfterReload (ReloadMemento reloadMemento)
     {
-        // The memento holds original lines; ones beyond the reloaded content are ignored.
         var lineCount = _logFileReader.LineCount;
-        RestorePosition(
+        RestorePosition(new GridPosition(
             _reloadMemento.CurrentLine < lineCount ? _reloadMemento.CurrentLine : -1,
-            _reloadMemento.FirstDisplayedLine < lineCount ? _reloadMemento.FirstDisplayedLine : -1);
+            _reloadMemento.FirstDisplayedLine < lineCount ? _reloadMemento.FirstDisplayedLine : -1));
     }
 
     [SupportedOSPlatform("windows")]
@@ -3073,17 +3071,23 @@ void ITailFollowSink.OnRolloverShift (int rolloverOffset)
         ShiftBookmarks(rolloverOffset);
         ShiftRowHeightList(rolloverOffset);
         ShiftFilterPipes(rolloverOffset);
-        _ = _lineVisibility.Shift(rolloverOffset);
+        _lineVisibility.Shift(rolloverOffset);
     }
 
     void ITailFollowSink.OnTailLines (LogEventArgs e)
     {
         try
         {
-            // Evaluate hide rules for the new lines here, off the UI thread, before the grid shows them.
-            _ = !e.IsRollover && e.LineCount < e.PrevLineCount
-                ? _lineVisibility.Replace(e.LineCount)
-                : _lineVisibility.Extend(e.LineCount);
+            // Off the UI thread, before the grid shows the new lines.
+            if (!e.IsRollover && e.LineCount < e.PrevLineCount)
+            {
+                _lineVisibility.Replace(e.LineCount);
+            }
+            else
+            {
+                _lineVisibility.Extend(e.LineCount);
+            }
+
             _ = BeginInvoke(UpdateGrid, [e]);
             CheckFilterAndHighlight(e);
         }
@@ -3132,9 +3136,7 @@ private void UpdateGrid (LogEventArgs logEventArgs)
 
         try
         {
-            // The engine thread already applied this event to the tracker (OnRolloverShift / OnTailLines). An append
-            // only grows the rows; a rollover or truncation rebuilds them and, without follow-tail, keeps the
-            // selected and first displayed original lines (moved up by the rollover offset).
+            // The tail thread already applied this event to the tracker.
             _ = PublishTrackedMap(logEventArgs.IsRollover ? logEventArgs.RolloverOffset : 0);
 
             _statusEventArgs.LineCount = logEventArgs.LineCount;
@@ -3237,8 +3239,7 @@ private void CheckFilterAndHighlight (LogEventArgs e)
                 if (firstStopTail)
                 {
                     var capturedLineNum = i;
-                    // Not explicit navigation: a hidden trigger line is not revealed.
-                    _ = BeginInvoke(() => SelectAndEnsureVisibleRow(_rowMap.NearestRow(capturedLineNum), false));
+                    _ = BeginInvoke(() => SelectAndEnsureVisibleRow(NavigationRow(capturedLineNum, reveal: false), false));
                     firstStopTail = false;
                 }
             }
@@ -3892,7 +3893,7 @@ private void SyncTimestampDisplay ()
         {
             if (dataGridView.CurrentRow != null)
             {
-                SyncTimestampDisplay(RowToLine(dataGridView.CurrentRow.Index));
+                SyncTimestampDisplay(CurrentLineNum);
             }
         }
     }
@@ -3986,7 +3987,7 @@ private void SyncFilterGridPos ()
         {
             if (_filterResultList.Count > 0)
             {
-                var index = _filterResultList.BinarySearch(RowToLine(dataGridView.CurrentRow.Index));
+                var index = _filterResultList.BinarySearch(CurrentLineNum);
                 if (index < 0)
                 {
                     index = ~index;
@@ -4059,21 +4060,18 @@ private void ResetProgressBar ()
         SendProgressBarUpdate();
     }
 
-    /// <summary>
-    /// Explicit navigation to an original line (Go to Line, bookmarks, Log Search, filter results, time sync, …).
-    /// A hidden target turns on "Show hidden lines" so that exact line is selected.
-    /// </summary>
+    /// <summary>Explicit navigation to an original line; a hidden line turns on "Show hidden lines".</summary>
     [SupportedOSPlatform("windows")]
-    private void SelectLine (int lineNum, bool triggerSyncCall, bool shouldScroll)
+    private void RevealAndSelectLine (int lineNum, bool triggerSyncCall, bool shouldScroll)
     {
-        SelectRow(RevealLine(lineNum), triggerSyncCall, shouldScroll);
+        SelectRow(NavigationRow(lineNum, reveal: true), triggerSyncCall, shouldScroll);
     }
 
-    /// <summary>Selects an original line, or the next (else previous) visible line when it is hidden.</summary>
+    /// <summary>Selects an original line, or the nearest visible line when it is hidden.</summary>
     [SupportedOSPlatform("windows")]
     private void SelectNearestLine (int lineNum, bool triggerSyncCall, bool shouldScroll)
     {
-        SelectRow(lineNum < 0 ? -1 : _rowMap.NearestRow(lineNum), triggerSyncCall, shouldScroll);
+        SelectRow(NavigationRow(lineNum, reveal: false), triggerSyncCall, shouldScroll);
     }
 
     [SupportedOSPlatform("windows")]
@@ -4163,7 +4161,7 @@ private void SelectPrevHighlightLine ()
                 var entry = FindHighlightEntry(line);
                 if (entry != null)
                 {
-                    SelectLine(lineNum, false, true);
+                    RevealAndSelectLine(lineNum, false, true);
                     break;
                 }
             }
@@ -4183,7 +4181,7 @@ private void SelectNextHighlightLine ()
                 var entry = FindHighlightEntry(line);
                 if (entry != null)
                 {
-                    SelectLine(lineNum, false, true);
+                    RevealAndSelectLine(lineNum, false, true);
                     break;
                 }
             }
@@ -4818,7 +4816,7 @@ private void DisplayCurrentFileOnStatusline ()
             {
                 if (dataGridView.CurrentRow != null && dataGridView.CurrentRow.Index > -1)
                 {
-                    var fileName = _logFileReader.GetLogFileNameForLine(RowToLine(dataGridView.CurrentRow.Index));
+                    var fileName = _logFileReader.GetLogFileNameForLine(CurrentLineNum);
                     if (fileName != null)
                     {
                         StatusLineText(Util.GetNameFromPath(fileName));
@@ -6533,8 +6531,7 @@ public void GotoLine (int line)
     {
         if (line >= 0)
         {
-            // An original line; beyond the end selects the last line, a hidden one is revealed.
-            SelectLine(Math.Min(line, _rowMap.LineCount - 1), false, true);
+            RevealAndSelectLine(line, false, true);
 
             _ = dataGridView.Focus();
         }
@@ -6599,7 +6596,7 @@ private void SearchComplete (Task<SearchResult> task)
             {
                 case SearchOutcome.Found:
                     StatusLineText(string.Empty);
-                    _ = dataGridView.Invoke(new SelectLineFx((line1, triggerSyncCall) => SelectLine(line1, triggerSyncCall, true)), result.LineNumber, true);
+                    _ = dataGridView.Invoke(new SelectLineFx((line1, triggerSyncCall) => RevealAndSelectLine(line1, triggerSyncCall, true)), result.LineNumber, true);
                     break;
 
                 case SearchOutcome.NotFound:
@@ -6623,17 +6620,22 @@ private void SearchComplete (Task<SearchResult> task)
 
     public void SelectLogLine (int lineNumber)
     {
-        _ = Invoke(new SelectLineFx((line1, triggerSyncCall) => SelectLine(line1, triggerSyncCall, true)), lineNumber, true);
+        _ = Invoke(new SelectLineFx((line1, triggerSyncCall) => RevealAndSelectLine(line1, triggerSyncCall, true)), lineNumber, true);
     }
 
-    /// <summary>Explicit navigation to an original line; a hidden line is revealed (see <see cref="SelectLine"/>).</summary>
+    /// <summary>Explicit navigation to an original line; a hidden line turns on "Show hidden lines".</summary>
     public void SelectAndEnsureVisible (int line, bool triggerSyncCall)
     {
-        SelectAndEnsureVisibleRow(RevealLine(line), triggerSyncCall);
+        SelectAndEnsureVisibleRow(NavigationRow(line, reveal: true), triggerSyncCall);
     }
 
     private void SelectAndEnsureVisibleRow (int row, bool triggerSyncCall)
     {
+        if (row < 0)
+        {
+            return;
+        }
+
         try
         {
             SelectRow(row, triggerSyncCall, false);
@@ -7173,7 +7175,7 @@ public void JumpNextBookmark ()
                 }
 
                 var lineNum = _bookmarkProvider.Bookmarks[index].LineNum;
-                SelectLine(lineNum, true, true);
+                RevealAndSelectLine(lineNum, true, true);
             }
         }
     }
@@ -7232,7 +7234,7 @@ public void JumpPrevBookmark ()
                 }
 
                 var lineNum = _bookmarkProvider.Bookmarks[index].LineNum;
-                SelectLine(lineNum, false, true);
+                RevealAndSelectLine(lineNum, false, true);
             }
         }
     }
@@ -7556,9 +7558,8 @@ public bool ScrollToTimestampWorker (DateTime timestamp, bool roundToSeconds, bo
         var foundLine = _timestampLocator.FindLine(timestamp, currentLine, _logFileReader.LineCount, roundToSeconds, _cts.Token);
         if (foundLine >= 0)
         {
-            // The window the user navigates in reveals a hidden line; windows following a time sync select the
-            // nearest visible line instead.
-            SelectAndEnsureVisibleRow(triggerSyncCall ? RevealLine(foundLine) : _rowMap.NearestRow(foundLine), triggerSyncCall);
+            // Windows following a time sync don't reveal hidden lines.
+            SelectAndEnsureVisibleRow(NavigationRow(foundLine, reveal: triggerSyncCall), triggerSyncCall);
             hasScrolled = true;
         }
 
@@ -7598,7 +7599,7 @@ public void AppFocusGained ()
     public ILogLineMemory GetCurrentLine ()
     {
         return dataGridView.CurrentRow != null && dataGridView.CurrentRow.Index != -1
-            ? _logFileReader.GetLogLineMemory(RowToLine(dataGridView.CurrentRow.Index))
+            ? _logFileReader.GetLogLineMemory(CurrentLineNum)
             : null;
     }
 
@@ -7620,7 +7621,7 @@ public int GetRealLineNum ()
     public ILogFileInfo GetCurrentFileInfo ()
     {
         return dataGridView.CurrentRow != null && dataGridView.CurrentRow.Index != -1
-            ? _logFileReader.GetLogFileInfoForLine(RowToLine(dataGridView.CurrentRow.Index))
+            ? _logFileReader.GetLogFileInfoForLine(CurrentLineNum)
             : null;
     }
 

From 70655b8ed811af29c1b12c468e788d0cd85578ef Mon Sep 17 00:00:00 2001
From: Hirogen <hirogenat@gmail.com>
Date: Sun, 27 Sep 2026 18:23:07 +0200
Subject: [PATCH 07/11] Extract hide-line grid logic out of the LogWindow
 partial (#338)

- HiddenLinesBar: the notice bar control (count and Show hidden lines check box)
- VisibleRows: the displayed Line Visibility Map, publishing it to the grid and keeping the position by original line
- The remaining wiring moves into LogWindow.cs; LogWindow.LineVisibility.cs is removed
---
 .../Controls/LogWindow/HiddenLinesBar.cs      |  48 +++
 .../LogWindow/LogWindow.LineVisibility.cs     | 362 ------------------
 .../Controls/LogWindow/LogWindow.cs           | 233 ++++++++++-
 .../Controls/LogWindow/VisibleRows.cs         | 153 ++++++++
 4 files changed, 422 insertions(+), 374 deletions(-)
 create mode 100644 src/LogExpert.UI/Controls/LogWindow/HiddenLinesBar.cs
 delete mode 100644 src/LogExpert.UI/Controls/LogWindow/LogWindow.LineVisibility.cs
 create mode 100644 src/LogExpert.UI/Controls/LogWindow/VisibleRows.cs

diff --git a/src/LogExpert.UI/Controls/LogWindow/HiddenLinesBar.cs b/src/LogExpert.UI/Controls/LogWindow/HiddenLinesBar.cs
new file mode 100644
index 00000000..185b453d
--- /dev/null
+++ b/src/LogExpert.UI/Controls/LogWindow/HiddenLinesBar.cs
@@ -0,0 +1,48 @@
+using System.Globalization;
+
+namespace LogExpert.UI.Controls.LogWindow;
+
+/// <summary>The notice above the main grid: how many lines hide-line rules remove, and the "Show hidden lines" override.</summary>
+internal sealed class HiddenLinesBar : Panel
+{
+    private const int BAR_HEIGHT = 24;
+
+    // Not AutoSize: an auto-sized label keeps its text height and sits at the top instead of centering beside the check box.
+    private readonly Label _label = new() { Name = "hiddenLinesLabel", AutoSize = false, Dock = DockStyle.Left, TextAlign = ContentAlignment.MiddleLeft };
+    private readonly CheckBox _checkBox = new() { Name = "showHiddenLinesCheckBox", AutoSize = true, Dock = DockStyle.Left };
+
+    public HiddenLinesBar ()
+    {
+        Name = "hiddenLinesBar";
+        Dock = DockStyle.Top;
+        Visible = false;
+        Padding = new Padding(4, 0, 4, 0);
+        _checkBox.Text = Resources.LogWindow_UI_CheckBox_ShowHiddenLines;
+        _checkBox.CheckedChanged += (_, _) => ShowHiddenLinesChanged?.Invoke(this, EventArgs.Empty);
+        Controls.Add(_checkBox);
+        Controls.Add(_label);
+    }
+
+    public event EventHandler? ShowHiddenLinesChanged;
+
+    public bool ShowHiddenLines => _checkBox.Checked;
+
+    public int BarHeight => LogicalToDeviceUnits(BAR_HEIGHT);
+
+    /// <summary>Shows the count and the override; the bar is visible while lines are hidden or the override is on. Returns whether its visibility changed.</summary>
+    public bool SetState (int hiddenCount, bool showHiddenLines)
+    {
+        _label.Text = string.Format(CultureInfo.CurrentCulture, Resources.LogWindow_UI_Label_HiddenLines, hiddenCount);
+        _label.Width = _label.PreferredWidth + LogicalToDeviceUnits(12);
+        _checkBox.Checked = showHiddenLines;
+
+        var visible = hiddenCount > 0 || showHiddenLines;
+        if (Visible == visible)
+        {
+            return false;
+        }
+
+        Visible = visible;
+        return true;
+    }
+}
diff --git a/src/LogExpert.UI/Controls/LogWindow/LogWindow.LineVisibility.cs b/src/LogExpert.UI/Controls/LogWindow/LogWindow.LineVisibility.cs
deleted file mode 100644
index 1cffd64c..00000000
--- a/src/LogExpert.UI/Controls/LogWindow/LogWindow.LineVisibility.cs
+++ /dev/null
@@ -1,362 +0,0 @@
-using System.ComponentModel;
-using System.Globalization;
-
-using LogExpert.Core.Classes.Highlight;
-using LogExpert.Core.Interfaces;
-
-namespace LogExpert.UI.Controls.LogWindow;
-
-/// <summary>
-/// Hide-line highlight rules. The main grid shows the rows of <see cref="_rowMap"/>; everything that talks
-/// to the reader, bookmarks, timestamps or sessions uses original logical lines, converted with
-/// <see cref="RowToLine"/> / <see cref="LineToRow"/>. The Window Filter grid is unaffected.
-/// </summary>
-internal partial class LogWindow
-{
-    private const int COLUMN_FINDER_HEIGHT = 28;
-    private const int HIDDEN_LINES_BAR_HEIGHT = 24;
-
-    private readonly Panel _hiddenLinesBar = new() { Name = "hiddenLinesBar", Dock = DockStyle.Top, Visible = false };
-    // Not AutoSize: an auto-sized label keeps its text height and sits at the top instead of centering beside the check box.
-    private readonly Label _hiddenLinesLabel = new() { Name = "hiddenLinesLabel", AutoSize = false, Dock = DockStyle.Left, TextAlign = ContentAlignment.MiddleLeft };
-    private readonly CheckBox _showHiddenLinesCheckBox = new() { Name = "showHiddenLinesCheckBox", AutoSize = true, Dock = DockStyle.Left };
-
-    private LineVisibilityTracker _lineVisibility;
-
-    // Written only on the UI thread; other threads read it once into a local.
-    private volatile LineVisibilityMap _rowMap = LineVisibilityMap.Empty;
-    private LineVisibilityMap _appliedTrackedMap = LineVisibilityMap.Empty;
-    private bool _showHiddenLines;
-    private bool _isLoadComplete;
-
-    // A saved or reload position waiting for the load's first scan.
-    private GridPosition? _pendingPosition;
-
-    /// <summary>The selected and first displayed original lines of the main grid; -1 when there is none.</summary>
-    private readonly record struct GridPosition (int CurrentLine, int FirstDisplayedLine);
-
-    /// <summary>Number of lines the active hide rules remove, whether or not the override shows them.</summary>
-    internal int HiddenLineCount => _lineVisibility.Map.HiddenCount;
-
-    /// <summary>The per-window "Show hidden lines" override. Transient: not saved in the Session File.</summary>
-    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
-    internal bool ShowHiddenLines
-    {
-        get => _showHiddenLines;
-        set
-        {
-            if (_showHiddenLines == value)
-            {
-                return;
-            }
-
-            _showHiddenLines = value;
-            ApplyLineVisibility();
-        }
-    }
-
-    internal Task WhenLineVisibilityIdle ()
-    {
-        return _lineVisibility.WhenIdle();
-    }
-
-    private void InitializeLineVisibility ()
-    {
-        _lineVisibility = new LineVisibilityTracker(
-            line => _logFileReader?.GetLogLineMemory(line),
-            (first, last) => (_logFileReader as IBufferPinning)?.PinRange(first, last));
-        _lineVisibility.Changed += OnLineVisibilityChanged;
-
-        _showHiddenLinesCheckBox.Text = Resources.LogWindow_UI_CheckBox_ShowHiddenLines;
-        _showHiddenLinesCheckBox.CheckedChanged += (_, _) => ShowHiddenLines = _showHiddenLinesCheckBox.Checked;
-        _hiddenLinesBar.Padding = new Padding(4, 0, 4, 0);
-        _hiddenLinesBar.Controls.Add(_showHiddenLinesCheckBox);
-        _hiddenLinesBar.Controls.Add(_hiddenLinesLabel);
-
-        // Row 0 hosts the column finder; the notice bar stacks above it.
-        tableLayoutPanel1.Controls.Remove(columnFinderPanel);
-        var topRow = new Panel { Dock = DockStyle.Fill, Margin = new Padding(0) };
-        columnFinderPanel.Dock = DockStyle.Fill;
-        topRow.Controls.Add(columnFinderPanel);
-        topRow.Controls.Add(_hiddenLinesBar);
-        tableLayoutPanel1.Controls.Add(topRow, 0, 0);
-    }
-
-    /// <summary>The content is gone (loading, dead file): no rows, no scan, until the next load publishes.</summary>
-    private void ResetLineVisibility ()
-    {
-        _isLoadComplete = false;
-        _pendingPosition = null;
-        _lineVisibility.Load(0, []);
-        _rowMap = LineVisibilityMap.Empty;
-        _appliedTrackedMap = _lineVisibility.Map;
-        UpdateHiddenLinesBar();
-    }
-
-    private void UpdateTopRowHeight ()
-    {
-        var height = _guiStateArgs.ColumnFinderVisible ? COLUMN_FINDER_HEIGHT : 0;
-        if (_hiddenLinesBar.Visible)
-        {
-            _hiddenLinesBar.Height = LogicalToDeviceUnits(HIDDEN_LINES_BAR_HEIGHT);
-            height += _hiddenLinesBar.Height;
-        }
-
-        columnFinderPanel.Visible = _guiStateArgs.ColumnFinderVisible;
-        tableLayoutPanel1.RowStyles[0].Height = height;
-    }
-
-    private void UpdateHiddenLinesBar ()
-    {
-        var hidden = HiddenLineCount;
-        _hiddenLinesLabel.Text = string.Format(CultureInfo.CurrentCulture, Resources.LogWindow_UI_Label_HiddenLines, hidden);
-        _hiddenLinesLabel.Width = _hiddenLinesLabel.PreferredWidth + LogicalToDeviceUnits(12);
-        _showHiddenLinesCheckBox.Checked = _showHiddenLines;
-
-        var visible = hidden > 0 || _showHiddenLines;
-        if (_hiddenLinesBar.Visible != visible)
-        {
-            _hiddenLinesBar.Visible = visible;
-            UpdateTopRowHeight();
-        }
-    }
-
-    private List<Core.Classes.Highlight.HighlightEntry> CurrentHighlightEntries ()
-    {
-        lock (_currentHighlightGroupLock)
-        {
-            return [.. _currentHighlightGroup.HighlightEntryList];
-        }
-    }
-
-    private void RebuildLineVisibility ()
-    {
-        if (!_isLoading && _logFileReader != null)
-        {
-            _lineVisibility.Rebuild(CurrentHighlightEntries());
-        }
-    }
-
-    private void OnLineVisibilityChanged (object? sender, LineVisibilityChangedEventArgs e)
-    {
-        if (_isClosing || IsDisposed || Disposing)
-        {
-            return;
-        }
-
-        try
-        {
-            // Marshals through a parent's handle when this (background) tab has none yet.
-            _ = BeginInvoke(() =>
-            {
-                if (e.Error != null)
-                {
-                    _logger.Warn(e.Error, "Hide rules failed");
-                    StatusLineError(string.Format(CultureInfo.CurrentCulture, Resources.LogWindow_UI_StatusLineError_HideRulesFailed, e.Error.Message));
-                }
-
-                ApplyLineVisibility();
-            });
-        }
-        catch (InvalidOperationException)
-        {
-            // No handle anywhere up the chain yet: OnHandleCreated applies the current map.
-        }
-    }
-
-    protected override void OnHandleCreated (EventArgs e)
-    {
-        base.OnHandleCreated(e);
-        if (_lineVisibility != null && !ReferenceEquals(_appliedTrackedMap, _lineVisibility.Map))
-        {
-            _ = BeginInvoke(ApplyLineVisibility);
-        }
-    }
-
-    /// <summary>
-    /// The map the grid should display for <paramref name="tracked"/>: no rows while the load's first scan runs, the
-    /// tracked map itself, or, with the override on, an identity map that keeps growing in place so tail appends
-    /// stay appends.
-    /// </summary>
-    private LineVisibilityMap EffectiveMap (LineVisibilityMap tracked)
-    {
-        var current = _rowMap;
-        if (!_showHiddenLines)
-        {
-            if (!_lineVisibility.IsLoadPending)
-            {
-                return tracked;
-            }
-
-            return current.LineCount == 0 ? current : LineVisibilityMap.Empty;
-        }
-
-        return current.HiddenCount == 0 && current.LineCount <= tracked.LineCount && tracked.IsAppendOf(_appliedTrackedMap)
-            ? current.Append(tracked.LineCount, [])
-            : LineVisibilityMap.Identity(tracked.LineCount);
-    }
-
-    /// <summary>
-    /// Publishes the tracker's current map to the grid (UI thread). Row count and mapping change together; the
-    /// selected original line is kept, or moved to the next (else previous) visible line.
-    /// </summary>
-    private void ApplyLineVisibility ()
-    {
-        if (_isLoading || _isClosing || _logFileReader == null || IsDisposed)
-        {
-            UpdateHiddenLinesBar();
-            return;
-        }
-
-        if (PublishTrackedMap(0) && _guiStateArgs.FollowTail && dataGridView.RowCount > 0)
-        {
-            _columnCache.MarkPrefetchStale();
-            dataGridView.FirstDisplayedScrollingRowIndex = dataGridView.RowCount - 1;
-        }
-
-        dataGridView.Invalidate();
-        UpdateLineNavigationReadiness();
-    }
-
-    /// <summary>Switches the grid to the tracker's current map; returns whether the displayed map changed.</summary>
-    private bool PublishTrackedMap (int rolloverOffset)
-    {
-        var tracked = _lineVisibility.Map;
-        var newMap = EffectiveMap(tracked);
-        _appliedTrackedMap = tracked;
-
-        var changed = !ReferenceEquals(newMap, _rowMap);
-        if (changed)
-        {
-            SetRowMap(newMap, rolloverOffset);
-        }
-
-        if (_pendingPosition is { } position && !_lineVisibility.IsLoadPending)
-        {
-            _pendingPosition = null;
-            ApplyPosition(position, true);
-        }
-
-        UpdateHiddenLinesBar();
-        return changed;
-    }
-
-    private GridPosition CurrentGridPosition ()
-    {
-        return new GridPosition(CurrentLineNum, RowToLine(dataGridView.FirstDisplayedScrollingRowIndex));
-    }
-
-    /// <summary>Restores a saved or reload position, deferred until the load's first scan has published the rows.</summary>
-    private void RestorePosition (GridPosition position)
-    {
-        if (_lineVisibility.IsLoadPending && !_showHiddenLines)
-        {
-            _pendingPosition = position;
-            return;
-        }
-
-        ApplyPosition(position, true);
-    }
-
-    /// <summary>Scrolls to and optionally selects a position; a hidden line resolves to the nearest visible row.</summary>
-    private void ApplyPosition (GridPosition position, bool select)
-    {
-        var currentRow = position.CurrentLine >= 0 ? _rowMap.NearestRow(position.CurrentLine) : -1;
-        if (select && currentRow >= 0)
-        {
-            dataGridView.CurrentCell = dataGridView.Rows[currentRow].Cells[0];
-            dataGridView.Rows[currentRow].Selected = true;
-        }
-
-        var firstRow = position.FirstDisplayedLine >= 0 ? _rowMap.NearestRow(position.FirstDisplayedLine) : -1;
-        if (firstRow >= 0)
-        {
-            dataGridView.FirstDisplayedScrollingRowIndex = firstRow;
-        }
-    }
-
-    /// <summary>
-    /// Switches the grid to <paramref name="newMap"/>. An append only grows the row count; any other change
-    /// rebuilds the rows and keeps the position by original line, moved up by <paramref name="rolloverOffset"/>.
-    /// </summary>
-    private void SetRowMap (LineVisibilityMap newMap, int rolloverOffset)
-    {
-        if (newMap.IsAppendOf(_rowMap) && rolloverOffset == 0)
-        {
-            _rowMap = newMap;
-            dataGridView.RowCount = newMap.VisibleCount;
-            return;
-        }
-
-        var position = CurrentGridPosition();
-
-        dataGridView.RowCount = 0;
-        _columnCache.MarkPrefetchStale();
-        _rowMap = newMap;
-        dataGridView.RowCount = newMap.VisibleCount;
-        if (_rowHeightList.Count > 0 && dataGridView.RowCount > 0)
-        {
-            dataGridView.UpdateRowHeightInfo(0, true);
-        }
-
-        if (dataGridView.RowCount > 0)
-        {
-            ApplyPosition(Shifted(position, rolloverOffset), !_guiStateArgs.FollowTail);
-        }
-    }
-
-    private static GridPosition Shifted (GridPosition position, int offset)
-    {
-        return new GridPosition(
-            position.CurrentLine < 0 ? -1 : Math.Max(0, position.CurrentLine - offset),
-            position.FirstDisplayedLine < 0 ? -1 : Math.Max(0, position.FirstDisplayedLine - offset));
-    }
-
-    /// <summary>Original line displayed in a main-grid row, or -1.</summary>
-    private int RowToLine (int row)
-    {
-        return _rowMap.RowToLine(row);
-    }
-
-    /// <summary>Main-grid row of an original line, or -1 when it is hidden or out of range.</summary>
-    private int LineToRow (int line)
-    {
-        return _rowMap.LineToRow(line);
-    }
-
-    /// <summary>
-    /// The row to select for an original line, or -1. A line beyond the end resolves to the last row. A hidden line
-    /// turns on "Show hidden lines" when <paramref name="reveal"/> (explicit navigation), else resolves to the nearest
-    /// visible row. Explicit navigation before the first scan is published waits for it, like <see cref="RequestGotoLine"/>.
-    /// </summary>
-    private int NavigationRow (int line, bool reveal)
-    {
-        if (line < 0)
-        {
-            return -1;
-        }
-
-        if (reveal && !_isReadyForLineNavigation)
-        {
-            RequestGotoLine(line + 1);
-            return -1;
-        }
-
-        if (reveal && _rowMap.IsHidden(line))
-        {
-            ShowHiddenLines = true;
-        }
-
-        return _rowMap.NearestRow(line);
-    }
-
-    /// <summary>Line navigation may run once the file is loaded and the first visibility scan is published.</summary>
-    private void UpdateLineNavigationReadiness ()
-    {
-        if (_isLoadComplete && !_isReadyForLineNavigation && !_lineVisibility.IsScanning)
-        {
-            _isReadyForLineNavigation = true;
-            ApplyPendingLineNavigation();
-        }
-    }
-}
diff --git a/src/LogExpert.UI/Controls/LogWindow/LogWindow.cs b/src/LogExpert.UI/Controls/LogWindow/LogWindow.cs
index f1cfdc23..ff1714ae 100644
--- a/src/LogExpert.UI/Controls/LogWindow/LogWindow.cs
+++ b/src/LogExpert.UI/Controls/LogWindow/LogWindow.cs
@@ -51,6 +51,7 @@ internal partial class LogWindow : DockContent, ILogPaintContextUI, ILogView, IL
     private const int FILTER_PANEL2_CONTROL_GAP = 6;
     private const int WAIT_TIME = 500;
     private const int OVERSCAN = 20;
+    private const int COLUMN_FINDER_HEIGHT = 28;
     private const int WORKER_SHUTDOWN_TIMEOUT = 2000; // ms to wait for a worker task to drain during teardown before giving up
     private const string FONT_COURIER_NEW = "Courier New";
     private const string FONT_VERDANA = "Verdana";
@@ -133,6 +134,10 @@ internal partial class LogWindow : DockContent, ILogPaintContextUI, ILogView, IL
     private bool _isLoadError;
     private bool _isLoading;
     private bool _isReadyForLineNavigation;
+    private bool _isLoadComplete;
+    private readonly HiddenLinesBar _hiddenLinesBar = new();
+    private LineVisibilityTracker _lineVisibility;
+    private VisibleRows _visibleRows;
     private int? _pendingTargetLine;
     private bool _isSearching;
 
@@ -994,7 +999,7 @@ private void PrefetchVisibleLines ()
             return;
         }
 
-        var map = _rowMap;
+        var map = _visibleRows.Map;
         if (map.HiddenCount == 0)
         {
             _columnCache.Prefetch(_logFileReader, firstVisible, visibleCount);
@@ -2451,6 +2456,210 @@ private void MeasureItem (object sender, MeasureItemEventArgs e)
 
     #endregion
 
+    #region Line Visibility
+
+    /// <summary>Number of lines the active hide rules remove, whether or not the override shows them.</summary>
+    internal int HiddenLineCount => _lineVisibility.Map.HiddenCount;
+
+    /// <summary>The per-window "Show hidden lines" override. Transient: not saved in the Session File.</summary>
+    [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
+    internal bool ShowHiddenLines
+    {
+        get => _visibleRows.ShowHiddenLines;
+        set
+        {
+            if (_visibleRows.ShowHiddenLines == value)
+            {
+                return;
+            }
+
+            _visibleRows.ShowHiddenLines = value;
+            ApplyLineVisibility();
+        }
+    }
+
+    internal Task WhenLineVisibilityIdle ()
+    {
+        return _lineVisibility.WhenIdle();
+    }
+
+    private void InitializeLineVisibility ()
+    {
+        _lineVisibility = new LineVisibilityTracker(
+            line => _logFileReader?.GetLogLineMemory(line),
+            (first, last) => (_logFileReader as IBufferPinning)?.PinRange(first, last));
+        _lineVisibility.Changed += OnLineVisibilityChanged;
+        _visibleRows = new VisibleRows(dataGridView, _lineVisibility, () => _guiStateArgs.FollowTail, () => _columnCache.MarkPrefetchStale(), () => _rowHeightList.Count > 0);
+        _hiddenLinesBar.ShowHiddenLinesChanged += (_, _) => ShowHiddenLines = _hiddenLinesBar.ShowHiddenLines;
+
+        // Row 0 hosts the column finder; the notice bar stacks above it.
+        tableLayoutPanel1.Controls.Remove(columnFinderPanel);
+        var topRow = new Panel { Dock = DockStyle.Fill, Margin = new Padding(0) };
+        columnFinderPanel.Dock = DockStyle.Fill;
+        topRow.Controls.Add(columnFinderPanel);
+        topRow.Controls.Add(_hiddenLinesBar);
+        tableLayoutPanel1.Controls.Add(topRow, 0, 0);
+    }
+
+    /// <summary>The content is gone (loading, dead file): no rows, no scan, until the next load publishes.</summary>
+    private void ResetLineVisibility ()
+    {
+        _isLoadComplete = false;
+        _lineVisibility.Load(0, []);
+        _visibleRows.Reset();
+        UpdateHiddenLinesBar();
+    }
+
+    private void UpdateTopRowHeight ()
+    {
+        var height = _guiStateArgs.ColumnFinderVisible ? COLUMN_FINDER_HEIGHT : 0;
+        if (_hiddenLinesBar.Visible)
+        {
+            _hiddenLinesBar.Height = _hiddenLinesBar.BarHeight;
+            height += _hiddenLinesBar.Height;
+        }
+
+        columnFinderPanel.Visible = _guiStateArgs.ColumnFinderVisible;
+        tableLayoutPanel1.RowStyles[0].Height = height;
+    }
+
+    private void UpdateHiddenLinesBar ()
+    {
+        if (_hiddenLinesBar.SetState(HiddenLineCount, ShowHiddenLines))
+        {
+            UpdateTopRowHeight();
+        }
+    }
+
+    private List<HighlightEntry> CurrentHighlightEntries ()
+    {
+        lock (_currentHighlightGroupLock)
+        {
+            return [.. _currentHighlightGroup.HighlightEntryList];
+        }
+    }
+
+    private void RebuildLineVisibility ()
+    {
+        if (!_isLoading && _logFileReader != null)
+        {
+            _lineVisibility.Rebuild(CurrentHighlightEntries());
+        }
+    }
+
+    private void OnLineVisibilityChanged (object? sender, LineVisibilityChangedEventArgs e)
+    {
+        if (_isClosing || IsDisposed || Disposing)
+        {
+            return;
+        }
+
+        try
+        {
+            // Marshals through a parent's handle when this (background) tab has none yet.
+            _ = BeginInvoke(() =>
+            {
+                if (e.Error != null)
+                {
+                    _logger.Warn(e.Error, "Hide rules failed");
+                    StatusLineError(string.Format(CultureInfo.CurrentCulture, Resources.LogWindow_UI_StatusLineError_HideRulesFailed, e.Error.Message));
+                }
+
+                ApplyLineVisibility();
+            });
+        }
+        catch (InvalidOperationException)
+        {
+            // No handle anywhere up the chain yet: OnHandleCreated applies the current map.
+        }
+    }
+
+    protected override void OnHandleCreated (EventArgs e)
+    {
+        base.OnHandleCreated(e);
+        if (_visibleRows != null && !_visibleRows.IsUpToDate)
+        {
+            _ = BeginInvoke(ApplyLineVisibility);
+        }
+    }
+
+    /// <summary>Publishes the tracker's current map to the grid (UI thread).</summary>
+    private void ApplyLineVisibility ()
+    {
+        if (_isLoading || _isClosing || _logFileReader == null || IsDisposed)
+        {
+            UpdateHiddenLinesBar();
+            return;
+        }
+
+        if (PublishTrackedMap(0) && _guiStateArgs.FollowTail && dataGridView.RowCount > 0)
+        {
+            _columnCache.MarkPrefetchStale();
+            dataGridView.FirstDisplayedScrollingRowIndex = dataGridView.RowCount - 1;
+        }
+
+        dataGridView.Invalidate();
+        UpdateLineNavigationReadiness();
+    }
+
+    /// <summary>Returns whether the displayed map changed.</summary>
+    private bool PublishTrackedMap (int rolloverOffset)
+    {
+        var changed = _visibleRows.Publish(rolloverOffset);
+        UpdateHiddenLinesBar();
+        return changed;
+    }
+
+    /// <summary>Original line displayed in a main-grid row, or -1.</summary>
+    private int RowToLine (int row)
+    {
+        return _visibleRows.Map.RowToLine(row);
+    }
+
+    /// <summary>Main-grid row of an original line, or -1 when it is hidden or out of range.</summary>
+    private int LineToRow (int line)
+    {
+        return _visibleRows.Map.LineToRow(line);
+    }
+
+    /// <summary>
+    /// The row to select for an original line, or -1. A line beyond the end resolves to the last row. A hidden line
+    /// turns on "Show hidden lines" when <paramref name="reveal"/> (explicit navigation), else resolves to the nearest
+    /// visible row. Explicit navigation before the first scan is published waits for it, like <see cref="RequestGotoLine"/>.
+    /// </summary>
+    private int NavigationRow (int line, bool reveal)
+    {
+        if (line < 0)
+        {
+            return -1;
+        }
+
+        if (reveal && !_isReadyForLineNavigation)
+        {
+            RequestGotoLine(line + 1);
+            return -1;
+        }
+
+        if (reveal && _visibleRows.Map.IsHidden(line))
+        {
+            ShowHiddenLines = true;
+        }
+
+        return _visibleRows.Map.NearestRow(line);
+    }
+
+    /// <summary>Line navigation may run once the file is loaded and the first visibility scan is published.</summary>
+    private void UpdateLineNavigationReadiness ()
+    {
+        if (_isLoadComplete && !_isReadyForLineNavigation && !_lineVisibility.IsScanning)
+        {
+            _isReadyForLineNavigation = true;
+            ApplyPendingLineNavigation();
+        }
+    }
+
+    #endregion
+
     #region Private Methods
 
     [SupportedOSPlatform("windows")]
@@ -2678,7 +2887,7 @@ private void LoadPersistenceData ()
                 var firstLine = snapshot.FirstDisplayedLine >= 0 && snapshot.FirstDisplayedLine < lineCount
                     ? snapshot.FirstDisplayedLine
                     : currentLine;
-                RestorePosition(new GridPosition(currentLine, firstLine));
+                _visibleRows.RestorePosition(new GridPosition(currentLine, firstLine));
 
                 // Applied once, here (was double-applied: always pre-load, here only when true).
                 // Applying true after positioning keeps the jump-to-tail semantics.
@@ -2813,7 +3022,7 @@ private void EnterLoadFileStatus ()
     private void PositionAfterReload (ReloadMemento reloadMemento)
     {
         var lineCount = _logFileReader.LineCount;
-        RestorePosition(new GridPosition(
+        _visibleRows.RestorePosition(new GridPosition(
             _reloadMemento.CurrentLine < lineCount ? _reloadMemento.CurrentLine : -1,
             _reloadMemento.FirstDisplayedLine < lineCount ? _reloadMemento.FirstDisplayedLine : -1));
     }
@@ -3397,7 +3606,7 @@ private void SetColumnizerInternal (ILogLineMemoryColumnizer columnizer)
 
         if (_logFileReader != null)
         {
-            dataGridView.RowCount = _rowMap.VisibleCount;
+            dataGridView.RowCount = _visibleRows.Map.VisibleCount;
         }
 
         if (_filterResultList != null)
@@ -3934,7 +4143,7 @@ private void SyncTimestampDisplayWorker ()
 
             // timeout with no new Trigger -> update display
             var lineNum = _timeShiftSyncLine;
-            if (lineNum >= 0 && lineNum < _rowMap.LineCount)
+            if (lineNum >= 0 && lineNum < _visibleRows.Map.LineCount)
             {
                 var (timeStamp, lineNumber) = GetTimestampForLine(lineNum, true);
                 lineNum = lineNumber;
@@ -4155,7 +4364,7 @@ private void SelectPrevHighlightLine ()
         while (lineNum > 0)
         {
             lineNum--;
-            var line = _rowMap.IsHidden(lineNum) ? null : _logFileReader.GetLogLineMemory(lineNum);
+            var line = _visibleRows.Map.IsHidden(lineNum) ? null : _logFileReader.GetLogLineMemory(lineNum);
             if (line != null)
             {
                 var entry = FindHighlightEntry(line);
@@ -4175,7 +4384,7 @@ private void SelectNextHighlightLine ()
         while (lineNum < _logFileReader.LineCount)
         {
             lineNum++;
-            var line = _rowMap.IsHidden(lineNum) ? null : _logFileReader.GetLogLineMemory(lineNum);
+            var line = _visibleRows.Map.IsHidden(lineNum) ? null : _logFileReader.GetLogLineMemory(lineNum);
             if (line != null)
             {
                 var entry = FindHighlightEntry(line);
@@ -4191,7 +4400,7 @@ private void SelectNextHighlightLine ()
     [SupportedOSPlatform("windows")]
     private int FindNextBookmarkIndex (int lineNum)
     {
-        if (lineNum >= _rowMap.LineCount)
+        if (lineNum >= _visibleRows.Map.LineCount)
         {
             lineNum = 0;
         }
@@ -4208,7 +4417,7 @@ private int FindPrevBookmarkIndex (int lineNum)
     {
         if (lineNum <= 0)
         {
-            lineNum = _rowMap.LineCount - 1;
+            lineNum = _visibleRows.Map.LineCount - 1;
         }
         else
         {
@@ -6447,7 +6656,7 @@ public void FollowTailChanged (bool isChecked, bool byTrigger)
         if (_guiStateArgs.FollowTail && _logFileReader != null)
         {
             // Follow the last visible row; hidden lines are never revealed by tailing.
-            if (_rowMap.LineCount >= _logFileReader.LineCount && dataGridView.RowCount > 0)
+            if (_visibleRows.Map.LineCount >= _logFileReader.LineCount && dataGridView.RowCount > 0)
             {
                 // Mark stale instead of invalidating — keeps old buffers pinned until
                 // the next Prefetch atomically swaps in new pins.
@@ -6512,7 +6721,7 @@ private void ApplyPendingLineNavigation ()
         }
 
         FollowTailChanged(false, false);
-        if (_rowMap.LineCount > 0)
+        if (_visibleRows.Map.LineCount > 0)
         {
             dataGridView.ClearSelection();
             GotoLine(targetLine.Value - 1);
@@ -7543,7 +7752,7 @@ public bool ScrollToTimestamp (DateTime timestamp, bool roundToSeconds, bool tri
     public bool ScrollToTimestampWorker (DateTime timestamp, bool roundToSeconds, bool triggerSyncCall)
     {
         var hasScrolled = false;
-        if (!CurrentColumnizer.IsTimeshiftImplemented() || _rowMap.LineCount == 0)
+        if (!CurrentColumnizer.IsTimeshiftImplemented() || _visibleRows.Map.LineCount == 0)
         {
             return false;
         }
diff --git a/src/LogExpert.UI/Controls/LogWindow/VisibleRows.cs b/src/LogExpert.UI/Controls/LogWindow/VisibleRows.cs
new file mode 100644
index 00000000..48116a82
--- /dev/null
+++ b/src/LogExpert.UI/Controls/LogWindow/VisibleRows.cs
@@ -0,0 +1,153 @@
+using LogExpert.Core.Classes.Highlight;
+
+namespace LogExpert.UI.Controls.LogWindow;
+
+/// <summary>The selected and first displayed original lines of the main grid; -1 when there is none.</summary>
+internal readonly record struct GridPosition (int CurrentLine, int FirstDisplayedLine);
+
+/// <summary>
+/// The rows of a Log Window's main grid after hiding: publishes a <see cref="LineVisibilityTracker"/>'s map to the grid
+/// and keeps the selection and scroll position by original line. UI thread only, except <see cref="Map"/>.
+/// </summary>
+internal sealed class VisibleRows (DataGridView grid, LineVisibilityTracker tracker, Func<bool> isFollowTail, Action markPrefetchStale, Func<bool> hasRowHeights)
+{
+    // Other threads read it once into a local.
+    private volatile LineVisibilityMap _map = LineVisibilityMap.Empty;
+    private LineVisibilityMap _appliedTrackedMap = LineVisibilityMap.Empty;
+    private GridPosition? _pendingPosition;
+
+    /// <summary>The map the grid displays.</summary>
+    public LineVisibilityMap Map => _map;
+
+    /// <summary>The per-window "Show hidden lines" override; takes effect on the next <see cref="Publish"/>.</summary>
+    public bool ShowHiddenLines { get; set; }
+
+    public bool IsUpToDate => ReferenceEquals(_appliedTrackedMap, tracker.Map);
+
+    /// <summary>The content is gone: no rows until the next load publishes.</summary>
+    public void Reset ()
+    {
+        _pendingPosition = null;
+        _map = LineVisibilityMap.Empty;
+        _appliedTrackedMap = tracker.Map;
+    }
+
+    /// <summary>
+    /// Switches the grid to the tracker's current map, with selected and first displayed lines moved up by
+    /// <paramref name="rolloverOffset"/>; returns whether the displayed map changed.
+    /// </summary>
+    public bool Publish (int rolloverOffset)
+    {
+        var tracked = tracker.Map;
+        var newMap = EffectiveMap(tracked);
+        _appliedTrackedMap = tracked;
+
+        var changed = !ReferenceEquals(newMap, _map);
+        if (changed)
+        {
+            SetMap(newMap, rolloverOffset);
+        }
+
+        if (_pendingPosition is { } position && !tracker.IsLoadPending)
+        {
+            _pendingPosition = null;
+            ApplyPosition(position, true);
+        }
+
+        return changed;
+    }
+
+    public GridPosition CurrentPosition ()
+    {
+        return new GridPosition(
+            grid.CurrentRow == null ? -1 : _map.RowToLine(grid.CurrentRow.Index),
+            _map.RowToLine(grid.FirstDisplayedScrollingRowIndex));
+    }
+
+    /// <summary>Restores a saved or reload position, deferred until the load's first scan has published the rows.</summary>
+    public void RestorePosition (GridPosition position)
+    {
+        if (tracker.IsLoadPending && !ShowHiddenLines)
+        {
+            _pendingPosition = position;
+            return;
+        }
+
+        ApplyPosition(position, true);
+    }
+
+    /// <summary>
+    /// No rows while the load's first scan runs, the tracked map itself, or, with the override on, an identity map
+    /// that keeps growing in place so tail appends stay appends.
+    /// </summary>
+    private LineVisibilityMap EffectiveMap (LineVisibilityMap tracked)
+    {
+        var current = _map;
+        if (!ShowHiddenLines)
+        {
+            if (!tracker.IsLoadPending)
+            {
+                return tracked;
+            }
+
+            return current.LineCount == 0 ? current : LineVisibilityMap.Empty;
+        }
+
+        return current.HiddenCount == 0 && current.LineCount <= tracked.LineCount && tracked.IsAppendOf(_appliedTrackedMap)
+            ? current.Append(tracked.LineCount, [])
+            : LineVisibilityMap.Identity(tracked.LineCount);
+    }
+
+    /// <summary>An append only grows the row count; any other change rebuilds the rows and keeps the position.</summary>
+    private void SetMap (LineVisibilityMap newMap, int rolloverOffset)
+    {
+        if (newMap.IsAppendOf(_map) && rolloverOffset == 0)
+        {
+            _map = newMap;
+            grid.RowCount = newMap.VisibleCount;
+            return;
+        }
+
+        var position = CurrentPosition();
+
+        grid.RowCount = 0;
+        markPrefetchStale();
+        _map = newMap;
+        grid.RowCount = newMap.VisibleCount;
+        if (grid.RowCount == 0)
+        {
+            return;
+        }
+
+        if (hasRowHeights())
+        {
+            grid.UpdateRowHeightInfo(0, true);
+        }
+
+        ApplyPosition(Shifted(position, rolloverOffset), !isFollowTail());
+    }
+
+    /// <summary>Scrolls to and optionally selects a position; a hidden line resolves to the nearest visible row.</summary>
+    private void ApplyPosition (GridPosition position, bool select)
+    {
+        var currentRow = position.CurrentLine >= 0 ? _map.NearestRow(position.CurrentLine) : -1;
+        if (select && currentRow >= 0)
+        {
+            grid.CurrentCell = grid.Rows[currentRow].Cells[0];
+            grid.Rows[currentRow].Selected = true;
+        }
+
+        var firstRow = position.FirstDisplayedLine >= 0 ? _map.NearestRow(position.FirstDisplayedLine) : -1;
+        if (firstRow >= 0)
+        {
+            grid.FirstDisplayedScrollingRowIndex = firstRow;
+        }
+    }
+
+    private static GridPosition Shifted (GridPosition position, int offset)
+    {
+        return new GridPosition(
+            position.CurrentLine < 0 ? -1 : Math.Max(0, position.CurrentLine - offset),
+            position.FirstDisplayedLine < 0 ? -1 : Math.Max(0, position.FirstDisplayedLine - offset));
+    }
+}

From 3cf4f8f23bd6d3df3a1fb3e62033368918d885ef Mon Sep 17 00:00:00 2001
From: Hirogen <hirogenat@gmail.com>
Date: Sun, 27 Sep 2026 19:28:49 +0200
Subject: [PATCH 08/11] Address second review of hide-line PR (#338)

- Queue explicit navigation made before the first scan as the call itself, keeping its time-sync flag and follow-tail state; timestamp navigation from the sync origin is queued too and reports it did not scroll
- Drop queued navigation when a reload replaces loaded content
- Restoring a saved or reload position selects through SelectRow again (clears a pending time sync, focuses the grid)
- VisibleRows takes an IVisibleRowsHost instead of three callbacks and owns the current-line lookup
- Rename NavigationRow to RevealOrNearestRow; the pin delegate is required; comment fixes
- Tests: bookmark window and timestamp navigation during the first scan
---
 .../Classes/Highlight/HighlightEvaluator.cs   |  2 +-
 .../Highlight/LineVisibilityTracker.cs        |  7 +-
 .../Highlight/LineVisibilityTrackerTests.cs   |  8 +-
 .../HiddenLinesWindowTests.cs                 | 43 +++++++--
 .../Controls/LogWindow/LogWindow.MarkerBar.cs |  1 +
 .../Controls/LogWindow/LogWindow.cs           | 89 ++++++++++++++-----
 .../Controls/LogWindow/VisibleRows.cs         | 52 +++++++----
 7 files changed, 149 insertions(+), 53 deletions(-)

diff --git a/src/LogExpert.Core/Classes/Highlight/HighlightEvaluator.cs b/src/LogExpert.Core/Classes/Highlight/HighlightEvaluator.cs
index 90daf076..94971dd7 100644
--- a/src/LogExpert.Core/Classes/Highlight/HighlightEvaluator.cs
+++ b/src/LogExpert.Core/Classes/Highlight/HighlightEvaluator.cs
@@ -71,7 +71,7 @@ public static bool IsHidden (IEnumerable<HighlightEntry> entries, ITextValueMemo
         return entries.Any(e => IsHideRule(e) && IsMatch(e, line));
     }
 
-    /// <summary>Temporary search-hit entries never hide.</summary>
+    /// <summary>Returns whether the entry hides the lines it matches; temporary search-hit entries never do.</summary>
     public static bool IsHideRule (HighlightEntry entry)
     {
         ArgumentNullException.ThrowIfNull(entry);
diff --git a/src/LogExpert.Core/Classes/Highlight/LineVisibilityTracker.cs b/src/LogExpert.Core/Classes/Highlight/LineVisibilityTracker.cs
index 4ad9575e..1650f7d6 100644
--- a/src/LogExpert.Core/Classes/Highlight/LineVisibilityTracker.cs
+++ b/src/LogExpert.Core/Classes/Highlight/LineVisibilityTracker.cs
@@ -11,7 +11,7 @@ public sealed class LineVisibilityTracker : IDisposable
     private const int READ_BATCH_SIZE = 256;
 
     private readonly Func<int, ITextValueMemory?> _getLine;
-    private readonly Func<int, int, IDisposable?>? _pinRange;
+    private readonly Func<int, int, IDisposable?> _pinRange;
     private readonly Lock _lock = new();
 
     private volatile LineVisibilityMap _map = LineVisibilityMap.Empty;
@@ -26,9 +26,10 @@ public sealed class LineVisibilityTracker : IDisposable
 
     /// <param name="getLine">Reads an original line; read live, since the reader is replaced on reload.</param>
     /// <param name="pinRange">Pins the buffers of an inclusive line range before it is read, so they can't be evicted mid-read.</param>
-    public LineVisibilityTracker (Func<int, ITextValueMemory?> getLine, Func<int, int, IDisposable?>? pinRange = null)
+    public LineVisibilityTracker (Func<int, ITextValueMemory?> getLine, Func<int, int, IDisposable?> pinRange)
     {
         ArgumentNullException.ThrowIfNull(getLine);
+        ArgumentNullException.ThrowIfNull(pinRange);
         _getLine = getLine;
         _pinRange = pinRange;
     }
@@ -327,7 +328,7 @@ private LineVisibilityMap Evaluate (LineVisibilityMap from, HighlightEntry[] rul
             for (var batchStart = from.LineCount; batchStart < lineCount; batchStart += READ_BATCH_SIZE)
             {
                 var batchEnd = Math.Min(batchStart + READ_BATCH_SIZE, lineCount);
-                using var pin = _pinRange?.Invoke(batchStart, batchEnd - 1);
+                using var pin = _pinRange(batchStart, batchEnd - 1);
                 for (var i = batchStart; i < batchEnd; i++)
                 {
                     token.ThrowIfCancellationRequested();
diff --git a/src/LogExpert.Tests/Highlight/LineVisibilityTrackerTests.cs b/src/LogExpert.Tests/Highlight/LineVisibilityTrackerTests.cs
index baa672f1..e8c6aa08 100644
--- a/src/LogExpert.Tests/Highlight/LineVisibilityTrackerTests.cs
+++ b/src/LogExpert.Tests/Highlight/LineVisibilityTrackerTests.cs
@@ -24,7 +24,7 @@ public void SetUp ()
         _lines = ["INFO a", "DEBUG b", "INFO c", "DEBUG d", "INFO e"];
         _gate = new ManualResetEventSlim(true);
         _changedCount = 0;
-        _tracker = new LineVisibilityTracker(GetLine);
+        _tracker = new LineVisibilityTracker(GetLine, NoPin);
         _tracker.Changed += (_, _) => Interlocked.Increment(ref _changedCount);
     }
 
@@ -36,6 +36,8 @@ public void TearDown ()
         _gate.Dispose();
     }
 
+    private static IDisposable? NoPin (int first, int last) => null;
+
     private ITextValueMemory? GetLine (int lineNum)
     {
         _ = _gate.Wait(Timeout);
@@ -310,7 +312,7 @@ public void UnreadableLine_StaysVisible ()
     public void ScanFailure_PublishesAllVisible_AndReportsTheError ()
     {
         LineVisibilityChangedEventArgs? reported = null;
-        using var tracker = new LineVisibilityTracker(i => i == 3 ? throw new InvalidOperationException("boom") : new LogLine("DEBUG", i));
+        using var tracker = new LineVisibilityTracker(i => i == 3 ? throw new InvalidOperationException("boom") : new LogLine("DEBUG", i), NoPin);
         tracker.Changed += (_, e) => reported = e;
 
         tracker.Load(5, HideDebug);
@@ -325,7 +327,7 @@ public void ScanFailure_PublishesAllVisible_AndReportsTheError ()
     public void TailFailure_FallsBackToAllVisible ()
     {
         var fail = false;
-        using var tracker = new LineVisibilityTracker(i => fail ? throw new InvalidOperationException("boom") : new LogLine(i % 2 == 0 ? "DEBUG" : "INFO", i));
+        using var tracker = new LineVisibilityTracker(i => fail ? throw new InvalidOperationException("boom") : new LogLine(i % 2 == 0 ? "DEBUG" : "INFO", i), NoPin);
         tracker.Load(4, HideDebug);
         Assert.That(tracker.WhenIdle().Wait(Timeout), Is.True);
         fail = true;
diff --git a/src/LogExpert.UI.Tests/HiddenLinesWindowTests.cs b/src/LogExpert.UI.Tests/HiddenLinesWindowTests.cs
index 478d1b5e..4426a7cf 100644
--- a/src/LogExpert.UI.Tests/HiddenLinesWindowTests.cs
+++ b/src/LogExpert.UI.Tests/HiddenLinesWindowTests.cs
@@ -134,12 +134,7 @@ public void Load_ShowsNoRowsUntilTheFirstScanHasFinished ()
     [Test]
     public void GotoLine_BeforeTheFirstScanHasFinished_IsAppliedOnceItHas ()
     {
-        File.WriteAllLines(_fileName, Enumerable.Range(0, 20_000).Select(Text));
-        _window = new LogTabWindow([_fileName], 1, false, _config.Object) { ShowInTaskbar = false, Opacity = 0 };
-        Find<WeifenLuo.WinFormsUI.Docking.DockPanel>(_window, "dockPanel").ShowDocumentIcon = false;
-        _window.Show();
-        PumpUntil(() => _window.CurrentLogWindow != null);
-        var log = _window.CurrentLogWindow;
+        var log = OpenBeforeTheFirstScan(Text);
 
         log.GotoLine(12_345);
         PumpUntil(() => log.CurrentLineNum == 12_345);
@@ -147,6 +142,31 @@ public void GotoLine_BeforeTheFirstScanHasFinished_IsAppliedOnceItHas ()
         Assert.That(log.ShowHiddenLines, Is.True);
     }
 
+    [Test]
+    public void BookmarkWindowNavigation_BeforeTheFirstScanHasFinished_IsAppliedOnceItHas ()
+    {
+        var log = OpenBeforeTheFirstScan(Text);
+
+        log.SelectAndEnsureVisible(12_345, false);
+        PumpUntil(() => log.CurrentLineNum == 12_345);
+
+        Assert.That(log.ShowHiddenLines, Is.True);
+    }
+
+    [Test]
+    public void TimestampNavigation_BeforeTheFirstScanHasFinished_IsAppliedOnceItHas ()
+    {
+        var start = new DateTime(2026, 1, 1, 10, 0, 0);
+        _settings.Preferences.ColumnizerMaskList = [new ColumnizerMaskEntry { Mask = "hidden.log", ColumnizerName = new TimestampColumnizer().GetName() }];
+        var log = OpenBeforeTheFirstScan(i => $"{start.AddSeconds(i):yyyy-MM-dd HH:mm:ss}.000 {Text(i)}");
+
+        var scrolled = log.ScrollToTimestamp(start.AddSeconds(12_345), false, true);
+        PumpUntil(() => log.CurrentLineNum == 12_345);
+
+        Assert.That(scrolled, Is.False, "the navigation was only queued");
+        Assert.That(log.ShowHiddenLines, Is.True);
+    }
+
     [TestCase(12, 12)]
     [TestCase(13, 14)]
     public void SavedPosition_IsRestoredOnceTheFirstScanHasFinished (int savedLine, int expectedLine)
@@ -677,6 +697,17 @@ private LogWindow Open ()
         return log;
     }
 
+    /// <summary>Opens a 20,000-line file and returns as soon as the Log Window exists, while it still loads and scans.</summary>
+    private LogWindow OpenBeforeTheFirstScan (Func<int, string> text)
+    {
+        File.WriteAllLines(_fileName, Enumerable.Range(0, 20_000).Select(text));
+        _window = new LogTabWindow([_fileName], 1, false, _config.Object) { ShowInTaskbar = false, Opacity = 0 };
+        Find<WeifenLuo.WinFormsUI.Docking.DockPanel>(_window, "dockPanel").ShowDocumentIcon = false;
+        _window.Show();
+        PumpUntil(() => _window.CurrentLogWindow != null);
+        return _window.CurrentLogWindow;
+    }
+
     private LogWindow OpenTimestamped ()
     {
         File.WriteAllLines(_fileName, Enumerable.Range(0, LINE_COUNT).Select(i => $"2026-01-01 10:00:{i:D2}.000 {Text(i)}"));
diff --git a/src/LogExpert.UI/Controls/LogWindow/LogWindow.MarkerBar.cs b/src/LogExpert.UI/Controls/LogWindow/LogWindow.MarkerBar.cs
index 26d16393..5a900400 100644
--- a/src/LogExpert.UI/Controls/LogWindow/LogWindow.MarkerBar.cs
+++ b/src/LogExpert.UI/Controls/LogWindow/LogWindow.MarkerBar.cs
@@ -335,6 +335,7 @@ private void ReportMarkerError (MarkerSnapshot snapshot, ref MarkerSnapshot? rep
 
     private void OnMarkerLineSelected (object? sender, SelectLineEventArgs eventArgs)
     {
+        // The tracker's map, not the displayed one: that is empty during the first scan, when clicks must be queued.
         if (_markerFrame?.Generation == Volatile.Read(ref _markerGeneration)
             && eventArgs.Line >= 0 && eventArgs.Line < _lineVisibility.Map.LineCount)
         {
diff --git a/src/LogExpert.UI/Controls/LogWindow/LogWindow.cs b/src/LogExpert.UI/Controls/LogWindow/LogWindow.cs
index ff1714ae..57a6a98c 100644
--- a/src/LogExpert.UI/Controls/LogWindow/LogWindow.cs
+++ b/src/LogExpert.UI/Controls/LogWindow/LogWindow.cs
@@ -42,7 +42,7 @@
 namespace LogExpert.UI.Controls.LogWindow;
 
 [SupportedOSPlatform("windows")]
-internal partial class LogWindow : DockContent, ILogPaintContextUI, ILogView, ILogWindow, ITimestampSource, ITailFollowSink
+internal partial class LogWindow : DockContent, ILogPaintContextUI, ILogView, ILogWindow, ITimestampSource, ITailFollowSink, IVisibleRowsHost
 {
     #region Fields
 
@@ -139,6 +139,7 @@ internal partial class LogWindow : DockContent, ILogPaintContextUI, ILogView, IL
     private LineVisibilityTracker _lineVisibility;
     private VisibleRows _visibleRows;
     private int? _pendingTargetLine;
+    private Action? _pendingNavigation;
     private bool _isSearching;
 
     private List<int> _lastFilterLinesList = [];
@@ -384,9 +385,7 @@ public bool ShowBookmarkBubbles
     }
 
     /// <summary>Original logical line of the current row, or -1.</summary>
-    public int CurrentLineNum => dataGridView.CurrentRow == null
-            ? -1
-            : RowToLine(dataGridView.CurrentRow.Index);
+    public int CurrentLineNum => _visibleRows.CurrentLine;
 
     public string FileName { get; private set; }
 
@@ -2489,7 +2488,7 @@ private void InitializeLineVisibility ()
             line => _logFileReader?.GetLogLineMemory(line),
             (first, last) => (_logFileReader as IBufferPinning)?.PinRange(first, last));
         _lineVisibility.Changed += OnLineVisibilityChanged;
-        _visibleRows = new VisibleRows(dataGridView, _lineVisibility, () => _guiStateArgs.FollowTail, () => _columnCache.MarkPrefetchStale(), () => _rowHeightList.Count > 0);
+        _visibleRows = new VisibleRows(dataGridView, _lineVisibility, this);
         _hiddenLinesBar.ShowHiddenLinesChanged += (_, _) => ShowHiddenLines = _hiddenLinesBar.ShowHiddenLines;
 
         // Row 0 hosts the column finder; the notice bar stacks above it.
@@ -2625,21 +2624,15 @@ private int LineToRow (int line)
     /// <summary>
     /// The row to select for an original line, or -1. A line beyond the end resolves to the last row. A hidden line
     /// turns on "Show hidden lines" when <paramref name="reveal"/> (explicit navigation), else resolves to the nearest
-    /// visible row. Explicit navigation before the first scan is published waits for it, like <see cref="RequestGotoLine"/>.
+    /// visible row.
     /// </summary>
-    private int NavigationRow (int line, bool reveal)
+    private int RevealOrNearestRow (int line, bool reveal)
     {
         if (line < 0)
         {
             return -1;
         }
 
-        if (reveal && !_isReadyForLineNavigation)
-        {
-            RequestGotoLine(line + 1);
-            return -1;
-        }
-
         if (reveal && _visibleRows.Map.IsHidden(line))
         {
             ShowHiddenLines = true;
@@ -2658,6 +2651,36 @@ private void UpdateLineNavigationReadiness ()
         }
     }
 
+    /// <summary>
+    /// Explicit navigation before the load's first visibility scan is published waits for it, then runs as requested.
+    /// A newer request replaces a pending one. Returns whether <paramref name="navigate"/> was deferred.
+    /// </summary>
+    private bool DeferNavigation (Action navigate)
+    {
+        if (_isReadyForLineNavigation)
+        {
+            return false;
+        }
+
+        _pendingTargetLine = null;
+        _pendingNavigation = navigate;
+        return true;
+    }
+
+    bool IVisibleRowsHost.IsFollowTail => _guiStateArgs.FollowTail;
+
+    bool IVisibleRowsHost.HasRowHeights => _rowHeightList.Count > 0;
+
+    void IVisibleRowsHost.MarkPrefetchStale ()
+    {
+        _columnCache.MarkPrefetchStale();
+    }
+
+    void IVisibleRowsHost.SelectRestoredRow (int row)
+    {
+        SelectRow(row, false, true);
+    }
+
     #endregion
 
     #region Private Methods
@@ -3005,6 +3028,12 @@ private void EnterLoadFileStatus ()
         _progressEventArgs.Visible = true;
         SendProgressBarUpdate();
 
+        if (_isLoadComplete)
+        {
+            // Navigation queued against content that is now being replaced.
+            _pendingNavigation = null;
+        }
+
         _isReadyForLineNavigation = false;
         _isLoading = true;
         InvalidateMarkerCriteria(MarkerScanSource.All);
@@ -3345,7 +3374,7 @@ private void UpdateGrid (LogEventArgs logEventArgs)
 
         try
         {
-            // The tail thread already applied this event to the tracker.
+            // The engine's worker thread already applied this event to the tracker.
             _ = PublishTrackedMap(logEventArgs.IsRollover ? logEventArgs.RolloverOffset : 0);
 
             _statusEventArgs.LineCount = logEventArgs.LineCount;
@@ -3448,7 +3477,7 @@ private void CheckFilterAndHighlight (LogEventArgs e)
                 if (firstStopTail)
                 {
                     var capturedLineNum = i;
-                    _ = BeginInvoke(() => SelectAndEnsureVisibleRow(NavigationRow(capturedLineNum, reveal: false), false));
+                    _ = BeginInvoke(() => SelectAndEnsureVisibleRow(RevealOrNearestRow(capturedLineNum, reveal: false), false));
                     firstStopTail = false;
                 }
             }
@@ -4273,14 +4302,17 @@ private void ResetProgressBar ()
     [SupportedOSPlatform("windows")]
     private void RevealAndSelectLine (int lineNum, bool triggerSyncCall, bool shouldScroll)
     {
-        SelectRow(NavigationRow(lineNum, reveal: true), triggerSyncCall, shouldScroll);
+        if (!DeferNavigation(() => RevealAndSelectLine(lineNum, triggerSyncCall, shouldScroll)))
+        {
+            SelectRow(RevealOrNearestRow(lineNum, reveal: true), triggerSyncCall, shouldScroll);
+        }
     }
 
     /// <summary>Selects an original line, or the nearest visible line when it is hidden.</summary>
     [SupportedOSPlatform("windows")]
     private void SelectNearestLine (int lineNum, bool triggerSyncCall, bool shouldScroll)
     {
-        SelectRow(NavigationRow(lineNum, reveal: false), triggerSyncCall, shouldScroll);
+        SelectRow(RevealOrNearestRow(lineNum, reveal: false), triggerSyncCall, shouldScroll);
     }
 
     [SupportedOSPlatform("windows")]
@@ -6705,6 +6737,7 @@ public void RequestGotoLine (int targetLine)
         }
 
         _pendingTargetLine = targetLine;
+        _pendingNavigation = null;
         if (_isReadyForLineNavigation)
         {
             ApplyPendingLineNavigation();
@@ -6714,8 +6747,16 @@ public void RequestGotoLine (int targetLine)
     private void ApplyPendingLineNavigation ()
     {
         var targetLine = _pendingTargetLine;
+        var navigate = _pendingNavigation;
         _pendingTargetLine = null;
-        if (!targetLine.HasValue || IsDisposed || Disposing || _waitingForClose || _isClosing || _isDeadFile || _isLoadError)
+        _pendingNavigation = null;
+        if (IsDisposed || Disposing || _waitingForClose || _isClosing || _isDeadFile || _isLoadError)
+        {
+            return;
+        }
+
+        navigate?.Invoke();
+        if (!targetLine.HasValue)
         {
             return;
         }
@@ -6733,6 +6774,7 @@ private void ApplyPendingLineNavigation ()
     private void CancelPendingLineNavigation ()
     {
         _pendingTargetLine = null;
+        _pendingNavigation = null;
         _isReadyForLineNavigation = false;
     }
 
@@ -6835,7 +6877,10 @@ public void SelectLogLine (int lineNumber)
     /// <summary>Explicit navigation to an original line; a hidden line turns on "Show hidden lines".</summary>
     public void SelectAndEnsureVisible (int line, bool triggerSyncCall)
     {
-        SelectAndEnsureVisibleRow(NavigationRow(line, reveal: true), triggerSyncCall);
+        if (!DeferNavigation(() => SelectAndEnsureVisible(line, triggerSyncCall)))
+        {
+            SelectAndEnsureVisibleRow(RevealOrNearestRow(line, reveal: true), triggerSyncCall);
+        }
     }
 
     private void SelectAndEnsureVisibleRow (int row, bool triggerSyncCall)
@@ -7752,7 +7797,9 @@ public bool ScrollToTimestamp (DateTime timestamp, bool roundToSeconds, bool tri
     public bool ScrollToTimestampWorker (DateTime timestamp, bool roundToSeconds, bool triggerSyncCall)
     {
         var hasScrolled = false;
-        if (!CurrentColumnizer.IsTimeshiftImplemented() || _visibleRows.Map.LineCount == 0)
+        if ((triggerSyncCall && DeferNavigation(() => ScrollToTimestampWorker(timestamp, roundToSeconds, true)))
+            || !CurrentColumnizer.IsTimeshiftImplemented()
+            || _visibleRows.Map.LineCount == 0)
         {
             return false;
         }
@@ -7768,7 +7815,7 @@ public bool ScrollToTimestampWorker (DateTime timestamp, bool roundToSeconds, bo
         if (foundLine >= 0)
         {
             // Windows following a time sync don't reveal hidden lines.
-            SelectAndEnsureVisibleRow(NavigationRow(foundLine, reveal: triggerSyncCall), triggerSyncCall);
+            SelectAndEnsureVisibleRow(RevealOrNearestRow(foundLine, reveal: triggerSyncCall), triggerSyncCall);
             hasScrolled = true;
         }
 
diff --git a/src/LogExpert.UI/Controls/LogWindow/VisibleRows.cs b/src/LogExpert.UI/Controls/LogWindow/VisibleRows.cs
index 48116a82..4023d34b 100644
--- a/src/LogExpert.UI/Controls/LogWindow/VisibleRows.cs
+++ b/src/LogExpert.UI/Controls/LogWindow/VisibleRows.cs
@@ -5,11 +5,24 @@ namespace LogExpert.UI.Controls.LogWindow;
 /// <summary>The selected and first displayed original lines of the main grid; -1 when there is none.</summary>
 internal readonly record struct GridPosition (int CurrentLine, int FirstDisplayedLine);
 
+/// <summary>What <see cref="VisibleRows"/> needs from the Log Window that owns the grid.</summary>
+internal interface IVisibleRowsHost
+{
+    bool IsFollowTail { get; }
+
+    bool HasRowHeights { get; }
+
+    void MarkPrefetchStale ();
+
+    /// <summary>Selects the row of a restored saved or reload position, as explicit selection does.</summary>
+    void SelectRestoredRow (int row);
+}
+
 /// <summary>
 /// The rows of a Log Window's main grid after hiding: publishes a <see cref="LineVisibilityTracker"/>'s map to the grid
 /// and keeps the selection and scroll position by original line. UI thread only, except <see cref="Map"/>.
 /// </summary>
-internal sealed class VisibleRows (DataGridView grid, LineVisibilityTracker tracker, Func<bool> isFollowTail, Action markPrefetchStale, Func<bool> hasRowHeights)
+internal sealed class VisibleRows (DataGridView grid, LineVisibilityTracker tracker, IVisibleRowsHost host)
 {
     // Other threads read it once into a local.
     private volatile LineVisibilityMap _map = LineVisibilityMap.Empty;
@@ -24,6 +37,9 @@ internal sealed class VisibleRows (DataGridView grid, LineVisibilityTracker trac
 
     public bool IsUpToDate => ReferenceEquals(_appliedTrackedMap, tracker.Map);
 
+    /// <summary>Original line of the current row, or -1.</summary>
+    public int CurrentLine => grid.CurrentRow == null ? -1 : _map.RowToLine(grid.CurrentRow.Index);
+
     /// <summary>The content is gone: no rows until the next load publishes.</summary>
     public void Reset ()
     {
@@ -51,19 +67,12 @@ public bool Publish (int rolloverOffset)
         if (_pendingPosition is { } position && !tracker.IsLoadPending)
         {
             _pendingPosition = null;
-            ApplyPosition(position, true);
+            ApplyPosition(position, host.SelectRestoredRow);
         }
 
         return changed;
     }
 
-    public GridPosition CurrentPosition ()
-    {
-        return new GridPosition(
-            grid.CurrentRow == null ? -1 : _map.RowToLine(grid.CurrentRow.Index),
-            _map.RowToLine(grid.FirstDisplayedScrollingRowIndex));
-    }
-
     /// <summary>Restores a saved or reload position, deferred until the load's first scan has published the rows.</summary>
     public void RestorePosition (GridPosition position)
     {
@@ -73,7 +82,7 @@ public void RestorePosition (GridPosition position)
             return;
         }
 
-        ApplyPosition(position, true);
+        ApplyPosition(position, host.SelectRestoredRow);
     }
 
     /// <summary>
@@ -108,10 +117,10 @@ private void SetMap (LineVisibilityMap newMap, int rolloverOffset)
             return;
         }
 
-        var position = CurrentPosition();
+        var position = new GridPosition(CurrentLine, _map.RowToLine(grid.FirstDisplayedScrollingRowIndex));
 
         grid.RowCount = 0;
-        markPrefetchStale();
+        host.MarkPrefetchStale();
         _map = newMap;
         grid.RowCount = newMap.VisibleCount;
         if (grid.RowCount == 0)
@@ -119,22 +128,27 @@ private void SetMap (LineVisibilityMap newMap, int rolloverOffset)
             return;
         }
 
-        if (hasRowHeights())
+        if (host.HasRowHeights)
         {
             grid.UpdateRowHeightInfo(0, true);
         }
 
-        ApplyPosition(Shifted(position, rolloverOffset), !isFollowTail());
+        ApplyPosition(Shifted(position, rolloverOffset), host.IsFollowTail ? null : SelectRow);
+    }
+
+    private void SelectRow (int row)
+    {
+        grid.CurrentCell = grid.Rows[row].Cells[0];
+        grid.Rows[row].Selected = true;
     }
 
-    /// <summary>Scrolls to and optionally selects a position; a hidden line resolves to the nearest visible row.</summary>
-    private void ApplyPosition (GridPosition position, bool select)
+    /// <summary>Selects (unless <paramref name="select"/> is null) and scrolls to a position; a hidden line resolves to the nearest visible row.</summary>
+    private void ApplyPosition (GridPosition position, Action<int>? select)
     {
         var currentRow = position.CurrentLine >= 0 ? _map.NearestRow(position.CurrentLine) : -1;
-        if (select && currentRow >= 0)
+        if (select != null && currentRow >= 0)
         {
-            grid.CurrentCell = grid.Rows[currentRow].Cells[0];
-            grid.Rows[currentRow].Selected = true;
+            select(currentRow);
         }
 
         var firstRow = position.FirstDisplayedLine >= 0 ? _map.NearestRow(position.FirstDisplayedLine) : -1;

From 7d74fd55eb0d1292cf33ba8250a18415eaef03f7 Mon Sep 17 00:00:00 2001
From: Hirogen <hirogenat@gmail.com>
Date: Sun, 27 Sep 2026 20:07:36 +0200
Subject: [PATCH 09/11] Address third review of hide-line PR (#338)

- One pending navigation (an Action) replaces the target line and the queued call; RunWhenNavigable runs it now or once navigable
- Windows following a time sync queue during their first scan too, and move to the nearest visible line
- Every reload after the first load drops queued navigation, the -line target included
- A reload restores its position without taking focus; session restore still focuses; both clear a pending time sync
- VisibleRows splits select-and-scroll from scroll-only; SameRules says why three fields suffice
- Tests: time-sync follower during the first scan; timestamp tests skip instead of racing the scan
---
 .../Highlight/LineVisibilityTracker.cs        |   1 +
 .../HiddenLinesWindowTests.cs                 |  27 ++++-
 .../Controls/LogWindow/LogWindow.cs           | 100 ++++++++----------
 .../Controls/LogWindow/VisibleRows.cs         |  48 +++++----
 4 files changed, 100 insertions(+), 76 deletions(-)

diff --git a/src/LogExpert.Core/Classes/Highlight/LineVisibilityTracker.cs b/src/LogExpert.Core/Classes/Highlight/LineVisibilityTracker.cs
index 1650f7d6..1d736e3f 100644
--- a/src/LogExpert.Core/Classes/Highlight/LineVisibilityTracker.cs
+++ b/src/LogExpert.Core/Classes/Highlight/LineVisibilityTracker.cs
@@ -356,6 +356,7 @@ private static HighlightEntry[] Snapshot (IEnumerable<HighlightEntry> entries)
         return [.. entries.Where(HighlightEvaluator.IsHideRule).Select(e => (HighlightEntry)e.Clone())];
     }
 
+    // Matching depends only on these fields (see HighlightEvaluator.IsMatch and HighlightEntry.Regex).
     private static bool SameRules (HighlightEntry[] current, HighlightEntry[] next)
     {
         return current.Length == next.Length
diff --git a/src/LogExpert.UI.Tests/HiddenLinesWindowTests.cs b/src/LogExpert.UI.Tests/HiddenLinesWindowTests.cs
index 4426a7cf..2b3202fe 100644
--- a/src/LogExpert.UI.Tests/HiddenLinesWindowTests.cs
+++ b/src/LogExpert.UI.Tests/HiddenLinesWindowTests.cs
@@ -27,6 +27,7 @@ namespace LogExpert.UI.Tests;
 public sealed class HiddenLinesWindowTests : IDisposable
 {
     private const int LINE_COUNT = 20;
+    private static readonly DateTime SyncStart = new(2026, 1, 1, 10, 0, 0);
 
     private string _directory = null!;
     private string _fileName = null!;
@@ -156,17 +157,26 @@ public void BookmarkWindowNavigation_BeforeTheFirstScanHasFinished_IsAppliedOnce
     [Test]
     public void TimestampNavigation_BeforeTheFirstScanHasFinished_IsAppliedOnceItHas ()
     {
-        var start = new DateTime(2026, 1, 1, 10, 0, 0);
-        _settings.Preferences.ColumnizerMaskList = [new ColumnizerMaskEntry { Mask = "hidden.log", ColumnizerName = new TimestampColumnizer().GetName() }];
-        var log = OpenBeforeTheFirstScan(i => $"{start.AddSeconds(i):yyyy-MM-dd HH:mm:ss}.000 {Text(i)}");
+        var log = OpenTimestampedBeforeTheFirstScan();
 
-        var scrolled = log.ScrollToTimestamp(start.AddSeconds(12_345), false, true);
+        var scrolled = log.ScrollToTimestamp(SyncStart.AddSeconds(12_345), false, true);
         PumpUntil(() => log.CurrentLineNum == 12_345);
 
         Assert.That(scrolled, Is.False, "the navigation was only queued");
         Assert.That(log.ShowHiddenLines, Is.True);
     }
 
+    [Test]
+    public void TimeSyncFollower_BeforeTheFirstScanHasFinished_SelectsTheNearestVisibleLineOnceItHas ()
+    {
+        var log = OpenTimestampedBeforeTheFirstScan();
+
+        _ = log.ScrollToTimestamp(SyncStart.AddSeconds(12_345), false, false);
+        PumpUntil(() => log.CurrentLineNum == 12_346);
+
+        Assert.That(log.ShowHiddenLines, Is.False);
+    }
+
     [TestCase(12, 12)]
     [TestCase(13, 14)]
     public void SavedPosition_IsRestoredOnceTheFirstScanHasFinished (int savedLine, int expectedLine)
@@ -708,6 +718,15 @@ private LogWindow OpenBeforeTheFirstScan (Func<int, string> text)
         return _window.CurrentLogWindow;
     }
 
+    private LogWindow OpenTimestampedBeforeTheFirstScan ()
+    {
+        _settings.Preferences.ColumnizerMaskList = [new ColumnizerMaskEntry { Mask = "hidden.log", ColumnizerName = new TimestampColumnizer().GetName() }];
+        var log = OpenBeforeTheFirstScan(i => $"{SyncStart.AddSeconds(i):yyyy-MM-dd HH:mm:ss}.000 {Text(i)}");
+        // Nothing is hidden until the first scan has published, so the window can't be navigable yet.
+        Assume.That(log.HiddenLineCount, Is.Zero, "the first scan finished before the test could navigate");
+        return log;
+    }
+
     private LogWindow OpenTimestamped ()
     {
         File.WriteAllLines(_fileName, Enumerable.Range(0, LINE_COUNT).Select(i => $"2026-01-01 10:00:{i:D2}.000 {Text(i)}"));
diff --git a/src/LogExpert.UI/Controls/LogWindow/LogWindow.cs b/src/LogExpert.UI/Controls/LogWindow/LogWindow.cs
index 57a6a98c..d86b602e 100644
--- a/src/LogExpert.UI/Controls/LogWindow/LogWindow.cs
+++ b/src/LogExpert.UI/Controls/LogWindow/LogWindow.cs
@@ -138,7 +138,7 @@ internal partial class LogWindow : DockContent, ILogPaintContextUI, ILogView, IL
     private readonly HiddenLinesBar _hiddenLinesBar = new();
     private LineVisibilityTracker _lineVisibility;
     private VisibleRows _visibleRows;
-    private int? _pendingTargetLine;
+    private bool _hasEnteredLoad;
     private Action? _pendingNavigation;
     private bool _isSearching;
 
@@ -2651,20 +2651,11 @@ private void UpdateLineNavigationReadiness ()
         }
     }
 
-    /// <summary>
-    /// Explicit navigation before the load's first visibility scan is published waits for it, then runs as requested.
-    /// A newer request replaces a pending one. Returns whether <paramref name="navigate"/> was deferred.
-    /// </summary>
-    private bool DeferNavigation (Action navigate)
+    /// <summary>Restores a saved or reload position without firing a leftover time sync.</summary>
+    private void RestorePosition (GridPosition position)
     {
-        if (_isReadyForLineNavigation)
-        {
-            return false;
-        }
-
-        _pendingTargetLine = null;
-        _pendingNavigation = navigate;
-        return true;
+        _shouldCallTimeSync = false;
+        _visibleRows.RestorePosition(position);
     }
 
     bool IVisibleRowsHost.IsFollowTail => _guiStateArgs.FollowTail;
@@ -2676,11 +2667,6 @@ void IVisibleRowsHost.MarkPrefetchStale ()
         _columnCache.MarkPrefetchStale();
     }
 
-    void IVisibleRowsHost.SelectRestoredRow (int row)
-    {
-        SelectRow(row, false, true);
-    }
-
     #endregion
 
     #region Private Methods
@@ -2910,7 +2896,8 @@ private void LoadPersistenceData ()
                 var firstLine = snapshot.FirstDisplayedLine >= 0 && snapshot.FirstDisplayedLine < lineCount
                     ? snapshot.FirstDisplayedLine
                     : currentLine;
-                _visibleRows.RestorePosition(new GridPosition(currentLine, firstLine));
+                RestorePosition(new GridPosition(currentLine, firstLine));
+                _ = dataGridView.Focus();
 
                 // Applied once, here (was double-applied: always pre-load, here only when true).
                 // Applying true after positioning keeps the jump-to-tail semantics.
@@ -3028,12 +3015,14 @@ private void EnterLoadFileStatus ()
         _progressEventArgs.Visible = true;
         SendProgressBarUpdate();
 
-        if (_isLoadComplete)
+        if (_hasEnteredLoad)
         {
-            // Navigation queued against content that is now being replaced.
+            // A reload: navigation queued so far targets the content being replaced.
             _pendingNavigation = null;
         }
 
+        _hasEnteredLoad = true;
+
         _isReadyForLineNavigation = false;
         _isLoading = true;
         InvalidateMarkerCriteria(MarkerScanSource.All);
@@ -3051,7 +3040,7 @@ private void EnterLoadFileStatus ()
     private void PositionAfterReload (ReloadMemento reloadMemento)
     {
         var lineCount = _logFileReader.LineCount;
-        _visibleRows.RestorePosition(new GridPosition(
+        RestorePosition(new GridPosition(
             _reloadMemento.CurrentLine < lineCount ? _reloadMemento.CurrentLine : -1,
             _reloadMemento.FirstDisplayedLine < lineCount ? _reloadMemento.FirstDisplayedLine : -1));
     }
@@ -4302,10 +4291,7 @@ private void ResetProgressBar ()
     [SupportedOSPlatform("windows")]
     private void RevealAndSelectLine (int lineNum, bool triggerSyncCall, bool shouldScroll)
     {
-        if (!DeferNavigation(() => RevealAndSelectLine(lineNum, triggerSyncCall, shouldScroll)))
-        {
-            SelectRow(RevealOrNearestRow(lineNum, reveal: true), triggerSyncCall, shouldScroll);
-        }
+        RunWhenNavigable(() => SelectRow(RevealOrNearestRow(lineNum, reveal: true), triggerSyncCall, shouldScroll));
     }
 
     /// <summary>Selects an original line, or the nearest visible line when it is hidden.</summary>
@@ -6736,19 +6722,40 @@ public void RequestGotoLine (int targetLine)
             return;
         }
 
-        _pendingTargetLine = targetLine;
-        _pendingNavigation = null;
+        RunWhenNavigable(() => GoToTargetLine(targetLine));
+    }
+
+    private void GoToTargetLine (int targetLine)
+    {
+        FollowTailChanged(false, false);
+        if (_visibleRows.Map.LineCount > 0)
+        {
+            dataGridView.ClearSelection();
+            GotoLine(targetLine - 1);
+            // Scrolling to the last row can automatically turn follow-tail back on.
+            FollowTailChanged(false, false);
+        }
+    }
+
+    /// <summary>
+    /// Runs line navigation now, or once the load and its first visibility scan are done. A newer request replaces
+    /// a pending one.
+    /// </summary>
+    private void RunWhenNavigable (Action navigate)
+    {
         if (_isReadyForLineNavigation)
         {
-            ApplyPendingLineNavigation();
+            navigate();
+        }
+        else
+        {
+            _pendingNavigation = navigate;
         }
     }
 
     private void ApplyPendingLineNavigation ()
     {
-        var targetLine = _pendingTargetLine;
         var navigate = _pendingNavigation;
-        _pendingTargetLine = null;
         _pendingNavigation = null;
         if (IsDisposed || Disposing || _waitingForClose || _isClosing || _isDeadFile || _isLoadError)
         {
@@ -6756,24 +6763,10 @@ private void ApplyPendingLineNavigation ()
         }
 
         navigate?.Invoke();
-        if (!targetLine.HasValue)
-        {
-            return;
-        }
-
-        FollowTailChanged(false, false);
-        if (_visibleRows.Map.LineCount > 0)
-        {
-            dataGridView.ClearSelection();
-            GotoLine(targetLine.Value - 1);
-            // Scrolling to the last row can automatically turn follow-tail back on.
-            FollowTailChanged(false, false);
-        }
     }
 
     private void CancelPendingLineNavigation ()
     {
-        _pendingTargetLine = null;
         _pendingNavigation = null;
         _isReadyForLineNavigation = false;
     }
@@ -6877,10 +6870,7 @@ public void SelectLogLine (int lineNumber)
     /// <summary>Explicit navigation to an original line; a hidden line turns on "Show hidden lines".</summary>
     public void SelectAndEnsureVisible (int line, bool triggerSyncCall)
     {
-        if (!DeferNavigation(() => SelectAndEnsureVisible(line, triggerSyncCall)))
-        {
-            SelectAndEnsureVisibleRow(RevealOrNearestRow(line, reveal: true), triggerSyncCall);
-        }
+        RunWhenNavigable(() => SelectAndEnsureVisibleRow(RevealOrNearestRow(line, reveal: true), triggerSyncCall));
     }
 
     private void SelectAndEnsureVisibleRow (int row, bool triggerSyncCall)
@@ -7796,10 +7786,14 @@ public bool ScrollToTimestamp (DateTime timestamp, bool roundToSeconds, bool tri
 
     public bool ScrollToTimestampWorker (DateTime timestamp, bool roundToSeconds, bool triggerSyncCall)
     {
+        if (!_isReadyForLineNavigation)
+        {
+            _pendingNavigation = () => ScrollToTimestampWorker(timestamp, roundToSeconds, triggerSyncCall);
+            return false;
+        }
+
         var hasScrolled = false;
-        if ((triggerSyncCall && DeferNavigation(() => ScrollToTimestampWorker(timestamp, roundToSeconds, true)))
-            || !CurrentColumnizer.IsTimeshiftImplemented()
-            || _visibleRows.Map.LineCount == 0)
+        if (!CurrentColumnizer.IsTimeshiftImplemented() || _visibleRows.Map.LineCount == 0)
         {
             return false;
         }
diff --git a/src/LogExpert.UI/Controls/LogWindow/VisibleRows.cs b/src/LogExpert.UI/Controls/LogWindow/VisibleRows.cs
index 4023d34b..ceb26ca6 100644
--- a/src/LogExpert.UI/Controls/LogWindow/VisibleRows.cs
+++ b/src/LogExpert.UI/Controls/LogWindow/VisibleRows.cs
@@ -13,9 +13,6 @@ internal interface IVisibleRowsHost
     bool HasRowHeights { get; }
 
     void MarkPrefetchStale ();
-
-    /// <summary>Selects the row of a restored saved or reload position, as explicit selection does.</summary>
-    void SelectRestoredRow (int row);
 }
 
 /// <summary>
@@ -67,7 +64,7 @@ public bool Publish (int rolloverOffset)
         if (_pendingPosition is { } position && !tracker.IsLoadPending)
         {
             _pendingPosition = null;
-            ApplyPosition(position, host.SelectRestoredRow);
+            SelectAndScrollTo(position);
         }
 
         return changed;
@@ -82,7 +79,7 @@ public void RestorePosition (GridPosition position)
             return;
         }
 
-        ApplyPosition(position, host.SelectRestoredRow);
+        SelectAndScrollTo(position);
     }
 
     /// <summary>
@@ -133,29 +130,42 @@ private void SetMap (LineVisibilityMap newMap, int rolloverOffset)
             grid.UpdateRowHeightInfo(0, true);
         }
 
-        ApplyPosition(Shifted(position, rolloverOffset), host.IsFollowTail ? null : SelectRow);
+        var shifted = Shifted(position, rolloverOffset);
+        if (host.IsFollowTail)
+        {
+            ScrollTo(shifted);
+        }
+        else
+        {
+            SelectAndScrollTo(shifted);
+        }
     }
 
-    private void SelectRow (int row)
+    /// <summary>Selects and scrolls to a position; a hidden line resolves to the nearest visible row.</summary>
+    private void SelectAndScrollTo (GridPosition position)
     {
-        grid.CurrentCell = grid.Rows[row].Cells[0];
-        grid.Rows[row].Selected = true;
+        var row = NearestRow(position.CurrentLine);
+        if (row >= 0)
+        {
+            grid.CurrentCell = grid.Rows[row].Cells[0];
+            grid.Rows[row].Selected = true;
+        }
+
+        ScrollTo(position);
     }
 
-    /// <summary>Selects (unless <paramref name="select"/> is null) and scrolls to a position; a hidden line resolves to the nearest visible row.</summary>
-    private void ApplyPosition (GridPosition position, Action<int>? select)
+    private void ScrollTo (GridPosition position)
     {
-        var currentRow = position.CurrentLine >= 0 ? _map.NearestRow(position.CurrentLine) : -1;
-        if (select != null && currentRow >= 0)
+        var row = NearestRow(position.FirstDisplayedLine);
+        if (row >= 0)
         {
-            select(currentRow);
+            grid.FirstDisplayedScrollingRowIndex = row;
         }
+    }
 
-        var firstRow = position.FirstDisplayedLine >= 0 ? _map.NearestRow(position.FirstDisplayedLine) : -1;
-        if (firstRow >= 0)
-        {
-            grid.FirstDisplayedScrollingRowIndex = firstRow;
-        }
+    private int NearestRow (int line)
+    {
+        return line >= 0 ? _map.NearestRow(line) : -1;
     }
 
     private static GridPosition Shifted (GridPosition position, int offset)

From 9115a10f858d527e3984e6e7fdf3824452073053 Mon Sep 17 00:00:00 2001
From: Hirogen <hirogenat@gmail.com>
Date: Sun, 27 Sep 2026 20:39:13 +0200
Subject: [PATCH 10/11] Address fourth review of hide-line PR (#338)

- Automatic reloads (ReloadNewFile) drop queued navigation where they start, like Reload(); entering the load status no longer does, so a multi-file session keeps its -line target
- Queued time-sync following never replaces the user's own queued navigation (PendingNavigation)
- Rename GoToTargetLine to GotoRequestedLine; inline the time-sync reset at the two restores; document ScrollToTimestampWorker's result
- Test: a time sync during the first scan doesn't replace a queued Go to Line
---
 .../HiddenLinesWindowTests.cs                 | 12 ++++
 .../Controls/LogWindow/LogWindow.cs           | 55 +++++++++----------
 2 files changed, 38 insertions(+), 29 deletions(-)

diff --git a/src/LogExpert.UI.Tests/HiddenLinesWindowTests.cs b/src/LogExpert.UI.Tests/HiddenLinesWindowTests.cs
index 2b3202fe..cbdaf137 100644
--- a/src/LogExpert.UI.Tests/HiddenLinesWindowTests.cs
+++ b/src/LogExpert.UI.Tests/HiddenLinesWindowTests.cs
@@ -634,6 +634,18 @@ public void CommandLineTarget_OnHiddenLine_RevealsItAfterVisibilityInitializatio
         Assert.That(log.GatherSessionSnapshot().FollowTail, Is.False);
     }
 
+    [Test]
+    public void TimeSync_BeforeTheFirstScanHasFinished_DoesNotReplaceTheUsersQueuedNavigation ()
+    {
+        var log = OpenTimestampedBeforeTheFirstScan();
+
+        log.GotoLine(12_345);
+        _ = log.ScrollToTimestamp(SyncStart.AddSeconds(100), false, false);
+        PumpUntil(() => log.CurrentLineNum == 12_345);
+
+        Assert.That(log.ShowHiddenLines, Is.True);
+    }
+
     [Test]
     public void CommandLineTarget_OnVisibleLine_KeepsLinesHidden ()
     {
diff --git a/src/LogExpert.UI/Controls/LogWindow/LogWindow.cs b/src/LogExpert.UI/Controls/LogWindow/LogWindow.cs
index d86b602e..c190d91c 100644
--- a/src/LogExpert.UI/Controls/LogWindow/LogWindow.cs
+++ b/src/LogExpert.UI/Controls/LogWindow/LogWindow.cs
@@ -138,8 +138,7 @@ internal partial class LogWindow : DockContent, ILogPaintContextUI, ILogView, IL
     private readonly HiddenLinesBar _hiddenLinesBar = new();
     private LineVisibilityTracker _lineVisibility;
     private VisibleRows _visibleRows;
-    private bool _hasEnteredLoad;
-    private Action? _pendingNavigation;
+    private PendingNavigation? _pendingNavigation;
     private bool _isSearching;
 
     private List<int> _lastFilterLinesList = [];
@@ -2651,13 +2650,6 @@ private void UpdateLineNavigationReadiness ()
         }
     }
 
-    /// <summary>Restores a saved or reload position without firing a leftover time sync.</summary>
-    private void RestorePosition (GridPosition position)
-    {
-        _shouldCallTimeSync = false;
-        _visibleRows.RestorePosition(position);
-    }
-
     bool IVisibleRowsHost.IsFollowTail => _guiStateArgs.FollowTail;
 
     bool IVisibleRowsHost.HasRowHeights => _rowHeightList.Count > 0;
@@ -2896,7 +2888,8 @@ private void LoadPersistenceData ()
                 var firstLine = snapshot.FirstDisplayedLine >= 0 && snapshot.FirstDisplayedLine < lineCount
                     ? snapshot.FirstDisplayedLine
                     : currentLine;
-                RestorePosition(new GridPosition(currentLine, firstLine));
+                _shouldCallTimeSync = false;
+                _visibleRows.RestorePosition(new GridPosition(currentLine, firstLine));
                 _ = dataGridView.Focus();
 
                 // Applied once, here (was double-applied: always pre-load, here only when true).
@@ -3015,14 +3008,6 @@ private void EnterLoadFileStatus ()
         _progressEventArgs.Visible = true;
         SendProgressBarUpdate();
 
-        if (_hasEnteredLoad)
-        {
-            // A reload: navigation queued so far targets the content being replaced.
-            _pendingNavigation = null;
-        }
-
-        _hasEnteredLoad = true;
-
         _isReadyForLineNavigation = false;
         _isLoading = true;
         InvalidateMarkerCriteria(MarkerScanSource.All);
@@ -3040,7 +3025,8 @@ private void EnterLoadFileStatus ()
     private void PositionAfterReload (ReloadMemento reloadMemento)
     {
         var lineCount = _logFileReader.LineCount;
-        RestorePosition(new GridPosition(
+        _shouldCallTimeSync = false;
+        _visibleRows.RestorePosition(new GridPosition(
             _reloadMemento.CurrentLine < lineCount ? _reloadMemento.CurrentLine : -1,
             _reloadMemento.FirstDisplayedLine < lineCount ? _reloadMemento.FirstDisplayedLine : -1));
     }
@@ -3164,6 +3150,7 @@ private ILogLineMemoryColumnizer FindColumnizer ()
 
     private void ReloadNewFile ()
     {
+        CancelPendingLineNavigation();
         // prevent "overloads". May occur on very fast rollovers (next rollover before the file is reloaded)
         lock (_reloadLock)
         {
@@ -6722,10 +6709,10 @@ public void RequestGotoLine (int targetLine)
             return;
         }
 
-        RunWhenNavigable(() => GoToTargetLine(targetLine));
+        RunWhenNavigable(() => GotoRequestedLine(targetLine));
     }
 
-    private void GoToTargetLine (int targetLine)
+    private void GotoRequestedLine (int targetLine)
     {
         FollowTailChanged(false, false);
         if (_visibleRows.Map.LineCount > 0)
@@ -6737,10 +6724,7 @@ private void GoToTargetLine (int targetLine)
         }
     }
 
-    /// <summary>
-    /// Runs line navigation now, or once the load and its first visibility scan are done. A newer request replaces
-    /// a pending one.
-    /// </summary>
+    /// <summary>Runs the user's line navigation now, or once the load and its first visibility scan are done.</summary>
     private void RunWhenNavigable (Action navigate)
     {
         if (_isReadyForLineNavigation)
@@ -6749,22 +6733,34 @@ private void RunWhenNavigable (Action navigate)
         }
         else
         {
-            _pendingNavigation = navigate;
+            Queue(new PendingNavigation(navigate, IsTimeSyncFollow: false));
+        }
+    }
+
+    /// <summary>A newer request replaces a pending one, except that following a time sync never replaces the user's own.</summary>
+    private void Queue (PendingNavigation navigation)
+    {
+        if (!navigation.IsTimeSyncFollow || _pendingNavigation is not { IsTimeSyncFollow: false })
+        {
+            _pendingNavigation = navigation;
         }
     }
 
     private void ApplyPendingLineNavigation ()
     {
-        var navigate = _pendingNavigation;
+        var navigation = _pendingNavigation;
         _pendingNavigation = null;
         if (IsDisposed || Disposing || _waitingForClose || _isClosing || _isDeadFile || _isLoadError)
         {
             return;
         }
 
-        navigate?.Invoke();
+        navigation?.Run();
     }
 
+    /// <summary>Line navigation waiting for the load's first visibility scan.</summary>
+    private readonly record struct PendingNavigation (Action Run, bool IsTimeSyncFollow);
+
     private void CancelPendingLineNavigation ()
     {
         _pendingNavigation = null;
@@ -7784,11 +7780,12 @@ public bool ScrollToTimestamp (DateTime timestamp, bool roundToSeconds, bool tri
         return ScrollToTimestampWorker(timestamp, roundToSeconds, triggerSyncCall);
     }
 
+    /// <returns>Whether it scrolled; false also when the navigation waits for the load's first scan.</returns>
     public bool ScrollToTimestampWorker (DateTime timestamp, bool roundToSeconds, bool triggerSyncCall)
     {
         if (!_isReadyForLineNavigation)
         {
-            _pendingNavigation = () => ScrollToTimestampWorker(timestamp, roundToSeconds, triggerSyncCall);
+            Queue(new PendingNavigation(() => ScrollToTimestampWorker(timestamp, roundToSeconds, triggerSyncCall), IsTimeSyncFollow: !triggerSyncCall));
             return false;
         }
 

From 3a7972a299e406b440d06035af177b43ff339c14 Mon Sep 17 00:00:00 2001
From: Hirogen <hirogenat@gmail.com>
Date: Sun, 27 Sep 2026 20:52:34 +0200
Subject: [PATCH 11/11] Tidy hide-line navigation queue after fifth review
 (#338)

- RestorePositionWithoutTimeSync replaces the two inlined copies
- Queue -> SetPendingNavigation, PendingNavigation.Run -> Navigate, record moved out of the methods
- Name the time-sync-follow condition in ScrollToTimestampWorker
- ReloadNewFile drops queued navigation only for the reload it actually starts
---
 .../Controls/LogWindow/LogWindow.cs           | 30 +++++++++++--------
 1 file changed, 18 insertions(+), 12 deletions(-)

diff --git a/src/LogExpert.UI/Controls/LogWindow/LogWindow.cs b/src/LogExpert.UI/Controls/LogWindow/LogWindow.cs
index c190d91c..6cf91223 100644
--- a/src/LogExpert.UI/Controls/LogWindow/LogWindow.cs
+++ b/src/LogExpert.UI/Controls/LogWindow/LogWindow.cs
@@ -2650,6 +2650,12 @@ private void UpdateLineNavigationReadiness ()
         }
     }
 
+    private void RestorePositionWithoutTimeSync (GridPosition position)
+    {
+        _shouldCallTimeSync = false;
+        _visibleRows.RestorePosition(position);
+    }
+
     bool IVisibleRowsHost.IsFollowTail => _guiStateArgs.FollowTail;
 
     bool IVisibleRowsHost.HasRowHeights => _rowHeightList.Count > 0;
@@ -2888,8 +2894,7 @@ private void LoadPersistenceData ()
                 var firstLine = snapshot.FirstDisplayedLine >= 0 && snapshot.FirstDisplayedLine < lineCount
                     ? snapshot.FirstDisplayedLine
                     : currentLine;
-                _shouldCallTimeSync = false;
-                _visibleRows.RestorePosition(new GridPosition(currentLine, firstLine));
+                RestorePositionWithoutTimeSync(new GridPosition(currentLine, firstLine));
                 _ = dataGridView.Focus();
 
                 // Applied once, here (was double-applied: always pre-load, here only when true).
@@ -3025,8 +3030,7 @@ private void EnterLoadFileStatus ()
     private void PositionAfterReload (ReloadMemento reloadMemento)
     {
         var lineCount = _logFileReader.LineCount;
-        _shouldCallTimeSync = false;
-        _visibleRows.RestorePosition(new GridPosition(
+        RestorePositionWithoutTimeSync(new GridPosition(
             _reloadMemento.CurrentLine < lineCount ? _reloadMemento.CurrentLine : -1,
             _reloadMemento.FirstDisplayedLine < lineCount ? _reloadMemento.FirstDisplayedLine : -1));
     }
@@ -3150,7 +3154,6 @@ private ILogLineMemoryColumnizer FindColumnizer ()
 
     private void ReloadNewFile ()
     {
-        CancelPendingLineNavigation();
         // prevent "overloads". May occur on very fast rollovers (next rollover before the file is reloaded)
         lock (_reloadLock)
         {
@@ -3158,6 +3161,7 @@ private void ReloadNewFile ()
             //_logger.Info($"ReloadNewFile(): counter = {_reloadOverloadCounter}");
             if (_reloadOverloadCounter <= 1)
             {
+                CancelPendingLineNavigation();
                 SavePersistenceData(false);
                 _ = _loadingFinishedEvent.Reset();
                 _ = _externaLoadingFinishedEvent.Reset();
@@ -6733,12 +6737,12 @@ private void RunWhenNavigable (Action navigate)
         }
         else
         {
-            Queue(new PendingNavigation(navigate, IsTimeSyncFollow: false));
+            SetPendingNavigation(new PendingNavigation(navigate, IsTimeSyncFollow: false));
         }
     }
 
     /// <summary>A newer request replaces a pending one, except that following a time sync never replaces the user's own.</summary>
-    private void Queue (PendingNavigation navigation)
+    private void SetPendingNavigation (PendingNavigation navigation)
     {
         if (!navigation.IsTimeSyncFollow || _pendingNavigation is not { IsTimeSyncFollow: false })
         {
@@ -6755,12 +6759,9 @@ private void ApplyPendingLineNavigation ()
             return;
         }
 
-        navigation?.Run();
+        navigation?.Navigate();
     }
 
-    /// <summary>Line navigation waiting for the load's first visibility scan.</summary>
-    private readonly record struct PendingNavigation (Action Run, bool IsTimeSyncFollow);
-
     private void CancelPendingLineNavigation ()
     {
         _pendingNavigation = null;
@@ -7785,7 +7786,9 @@ public bool ScrollToTimestampWorker (DateTime timestamp, bool roundToSeconds, bo
     {
         if (!_isReadyForLineNavigation)
         {
-            Queue(new PendingNavigation(() => ScrollToTimestampWorker(timestamp, roundToSeconds, triggerSyncCall), IsTimeSyncFollow: !triggerSyncCall));
+            // A window that doesn't start the sync is following one.
+            var isTimeSyncFollow = !triggerSyncCall;
+            SetPendingNavigation(new PendingNavigation(() => ScrollToTimestampWorker(timestamp, roundToSeconds, triggerSyncCall), isTimeSyncFollow));
             return false;
         }
 
@@ -8104,4 +8107,7 @@ public void RefreshLogView ()
     }
 
     #endregion
+
+    /// <summary>Line navigation waiting for the load's first visibility scan.</summary>
+    private readonly record struct PendingNavigation (Action Navigate, bool IsTimeSyncFollow);
 }