Fix inline-mode click-to-jump jiggle via predicted-settle ghost

In inline mode the editor's ExtentHeight covers the inline document
(including deletion lines), but the overview bar paints the viewport
band from the right/left source-line counts. Sending raction *
ExtentHeight to the editor and pinning the ghost at the cursor's bar
position therefore landed at two different coordinate systems: the
editor settled at one inline line, while the bar's band repainted at
the corresponding RightFirstLine, which could be 25-30 px off the
cursor in a mid-sized file with deletions interleaved.

Add DiffPaneViewModel.PredictBandTopFractionForScroll, which walks
InlineLineToSourceLines forward from the predicted first inline line
to find what (LeftFirstLine, RightFirstLine) the bar will paint after
settle, and returns min(leftFrac, rightFrac) to match how the
geometry layer's GetBandTopY picks the band's top. The bar uses this
prediction to place the ghost where the band will actually settle,
so MouseDown -> MouseUp -> editor settle all land on the same pixel.
In side-by-side mode the prediction is identity and behaviour is
unchanged.

Remove the deferred ghost-clear scaffolding (_ghostClearPending,
_ghostClearTimer, GhostClearTimeout, EnsureGhostClearTimer,
OnGhostClearTimerTick, the pending-clear branch in
OnMouseLeftButtonDown, the deferred-clear path in ResetInteraction):
it was a 250 ms timer-based workaround for this same root cause and
is dead weight now that the ghost and settled positions coincide.
Restore the empty-space click path to set the ghost via
EmitDragScroll, replacing the previous skip-ghost workaround
(ef8757e) that pre-emptively hid the band on click to mask the same
jiggle.

Four new unit tests cover the prediction directly via the internal
static helper: side-by-side identity, empty-map passthrough, the
pure-delete-in-middle case (validating min(leftFrac, rightFrac)),
walking past a leading delete to find the first non-null newLine,
and NaN / out-of-range input normalization.

AI-Local-Session: b53d5fe5-38cc-41dd-b987-3def5ef3f0d3
AI-Cloud-Session: 744dd836-01e5-48af-91db-daa8241a01d7
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: geevensingh

CHANGELOG.md

@@ -41,12 +41,14 @@ body. Keep section headings exact and write notes in Markdown.
   indicator) recenters the indicator on the cursor and starts a
   drag in the same gesture — minimap-style "click anywhere to jump
   there", and a press-and-drag from empty space scrubs without
-  needing a second click. Empty-space clicks land the indicator at
-  its actual line-snapped position immediately rather than locking
-  to the cursor on press and snapping on release — no more jiggle
-  when the press and release land at the same cursor position but
-  the editor's per-line scroll granularity doesn't divide the bar's
-  pixel height evenly.
+  needing a second click. The indicator lands at the editor's
+  natural settle position for the click — in side-by-side mode that
+  always equals the cursor position, in inline mode it can be
+  slightly offset because the inline document interleaves
+  deletion lines (which advance the editor's scroll but not the
+  right-side line count); picking the post-settle position up
+  front keeps the indicator stable across MouseUp instead of
+  visibly jumping when the editor's viewport catches up.
 - Language-aware syntax highlighting for TypeScript (`.ts`, `.tsx`),
   YAML (`.yaml`, `.yml`), Go (`.go`), Rust (`.rs`), Ruby (`.rb`),
   Bash / shell (`.sh`, `.bash`, `.zsh`), and TOML (`.toml`). Combined

DiffViewer.Tests/ViewModels/DiffPaneViewModelTests.cs

@@ -1735,4 +1735,117 @@ public ImageDecodeResult Decode(byte[] bytes, string? path)
             return DecodeFunc(bytes, path);
         }
     }
+
+    [Fact]
+    public void PredictBandTopFraction_SideBySide_ReturnsScrollFractionVerbatim()
+    {
+        // In side-by-side mode the right editor's ExtentHeight maps 1:1
+        // to RightDocument.LineCount * lineHeight, so the predicted
+        // band-top fraction equals the scroll fraction. The inline map
+        // is irrelevant for this mode.
+        var emptyMap = Array.Empty<(int?, int?)>();
+        DiffPaneViewModel.PredictBandTopFraction(
+            scrollFraction: 0.42,
+            map: emptyMap,
+            leftTotal: 100,
+            rightTotal: 100,
+            isSideBySide: true)
+            .Should().Be(0.42);
+    }
+
+    [Fact]
+    public void PredictBandTopFraction_Inline_EmptyMap_ReturnsScrollFractionVerbatim()
+    {
+        // Before the inline diff is built (e.g. during initial load) the
+        // map is empty and there's nothing to project through; pass the
+        // scroll fraction through so the bar still has a sensible ghost
+        // position instead of collapsing to 0 or 1.
+        DiffPaneViewModel.PredictBandTopFraction(
+            scrollFraction: 0.7,
+            map: Array.Empty<(int?, int?)>(),
+            leftTotal: 50,
+            rightTotal: 50,
+            isSideBySide: false)
+            .Should().Be(0.7);
+    }
+
+    [Fact]
+    public void PredictBandTopFraction_Inline_PureDeleteInMiddle_ShiftsAwayFromCursor()
+    {
+        // Left:  a b c d e   (5 lines)   Right: a c d e (4 lines)
+        // Inline mapping (1-indexed inline line):
+        //   1: a       (1, 1)
+        //   2: -b      (2, null)
+        //   3: c       (3, 2)
+        //   4: d       (4, 3)
+        //   5: e       (5, 4)
+        // Scroll fraction 0.4 of inlineTotal=5 -> firstInlineIndex=2,
+        // i.e. inline line 3 ("c") at top. That maps to leftLine=3,
+        // rightLine=2, so leftFrac=2/5=0.4, rightFrac=1/4=0.25, and
+        // the predicted band-top fraction is min(0.4, 0.25) = 0.25.
+        // (Without this prediction the bar would ghost at 0.4 and then
+        // visibly jump down to 0.25 on settle — the inline-mode jiggle.)
+        var map = new (int? OldLine, int? NewLine)[]
+        {
+            (1, 1),
+            (2, null),
+            (3, 2),
+            (4, 3),
+            (5, 4),
+        };
+        DiffPaneViewModel.PredictBandTopFraction(
+            scrollFraction: 0.4,
+            map: map,
+            leftTotal: 5,
+            rightTotal: 4,
+            isSideBySide: false)
+            .Should().BeApproximately(0.25, 1e-9);
+    }
+
+    [Fact]
+    public void PredictBandTopFraction_Inline_FirstInlineLineIsDelete_WalksPastIt()
+    {
+        // Inline line 1 is a pure delete (oldLine present, newLine null).
+        // The prediction must walk forward to find the first non-null
+        // newLine — otherwise rightFrac would default to 1.0 (the
+        // "missing" sentinel) and the predicted band-top would collapse
+        // to leftFrac, which would visibly skew the ghost.
+        var map = new (int? OldLine, int? NewLine)[]
+        {
+            (1, null),  // pure delete at the top of the inline doc
+            (2, 1),     // first context line: leftLine=2, rightLine=1
+            (3, 2),
+            (4, 3),
+        };
+        // scrollFraction=0 -> firstInlineIndex=0. Walk: map[0] gives
+        // predictedLeft=1, predictedRight=null. map[1] gives
+        // predictedRight=1. leftFrac=(1-1)/4=0, rightFrac=(1-1)/3=0.
+        // min(0,0) = 0.
+        DiffPaneViewModel.PredictBandTopFraction(
+            scrollFraction: 0.0,
+            map: map,
+            leftTotal: 4,
+            rightTotal: 3,
+            isSideBySide: false)
+            .Should().Be(0.0);
+    }
+
+    [Theory]
+    [InlineData(double.NaN, 0.0)]
+    [InlineData(-0.5, 0.0)]
+    [InlineData(1.5, 1.0)]
+    public void PredictBandTopFraction_ClampsAndNormalizesInput(
+        double scrollFraction, double expectedNormalized)
+    {
+        // Out-of-range / NaN inputs are normalized before any further
+        // logic. In side-by-side mode that normalized value is returned
+        // verbatim, giving us a tidy way to assert the normalization.
+        DiffPaneViewModel.PredictBandTopFraction(
+            scrollFraction: scrollFraction,
+            map: Array.Empty<(int?, int?)>(),
+            leftTotal: 10,
+            rightTotal: 10,
+            isSideBySide: true)
+            .Should().Be(expectedNormalized);
+    }
 }

DiffViewer/Rendering/HunkOverviewBar.cs

@@ -98,15 +98,24 @@ private enum BarInteractionState
 
     /// <summary>
     /// Optimistic band-top Y while a drag is active, in bar coords.
-    /// Set on every MouseMove from the cursor position; cleared on drag
-    /// end. When set, <see cref="OnRender"/> translates the computed
-    /// viewport band so its top sits here — decouples the band's
-    /// painted position from the editor's actual scroll, which trails
-    /// MouseMove by a layout pass and can fall many frames behind
-    /// under fast drag. The editor scroll still catches up via the
-    /// normal <see cref="DiffPaneViewModel.RequestScrollByVerticalFraction"/>
+    /// Set on every MouseMove (and on empty-space MouseDown) to the
+    /// predicted post-settle position for the requested scroll; cleared
+    /// on drag end. When set, <see cref="OnRender"/> translates the
+    /// computed viewport band so its top sits here — decouples the
+    /// band's painted position from the editor's actual scroll, which
+    /// trails MouseMove by a layout pass and can fall many frames
+    /// behind under fast drag. The editor scroll still catches up via
+    /// the normal <see cref="DiffPaneViewModel.RequestScrollByVerticalFraction"/>
     /// path; the ghost just makes the bar's visual feedback frame-
     /// instant so the band feels truly stuck to the cursor.
+    /// <para>The "predicted" qualifier matters in inline mode, where
+    /// the editor's <c>ExtentHeight</c> covers the inline document
+    /// (including deletion lines) but the bar paints from the right/
+    /// left source line counts. The ghost uses
+    /// <see cref="DiffPaneViewModel.PredictBandTopFractionForScroll"/>
+    /// so it lands at the same position the band will paint after
+    /// settle, eliminating the visible snap when the ghost is later
+    /// cleared.</para>
     /// </summary>
     private double? _dragGhostBandTop;
 
@@ -363,26 +372,13 @@ protected override void OnMouseLeftButtonDown(MouseButtonEventArgs e)
         bool inBand = band is not null && HunkOverviewBarGeometry.IsInsideBand(band, p);
 
         // Empty press: minimap-style "click anywhere to jump there".
-        // Send the scroll request immediately so the band lands at the
-        // cursor, but do NOT set the optimistic ghost band — let the
-        // natural ViewportState propagation paint the band at its
-        // actual settled (line-snapped) position on the next frame.
-        // Using the ghost path here would lock the band visually to
-        // the cursor's exact Y, then snap to the line-snapped position
-        // on MouseUp when the ghost clears — visible as a jiggle on
-        // smaller files where one line of editor scroll spans several
-        // bar pixels. The ghost's value-add is smoothing fast drag
-        // (decoupling the bar paint from editor scroll lag); a
-        // stationary click has nothing to smooth.
-        //
-        // If the user follows up with motion, the first MouseMove
-        // activates the ghost via EmitDragScroll and we're back on
-        // the smooth-drag path. The transition is a small one-time
-        // snap to cursor, masked by the motion that caused it.
-        //
-        // Still go directly into Dragging (skipping PendingClick) so
-        // MouseUp doesn't try to fire a JumpToHunk — there's no hunk
-        // to commit to, and the scroll has already been sent.
+        // Set the ghost at the predicted post-settle position so the
+        // band feels stuck to the press, send the scroll request, and
+        // enter Dragging so the same gesture can scrub by moving the
+        // cursor. ResetInteraction clears the ghost on MouseUp; since
+        // the ghost is at the predicted-settle position (not the raw
+        // cursor), the clear lands on the same frame the natural band
+        // repaints at that same position — no visible snap.
         if (idx < 0 && !inBand)
         {
             if (band is null) return;
@@ -393,9 +389,7 @@ protected override void OnMouseLeftButtonDown(MouseButtonEventArgs e)
             _interaction = BarInteractionState.Dragging;
             ToolTip = null;
             CaptureMouse();
-            double targetBandTopY = p.Y - _bandDragOffsetFromTop;
-            double fraction = ActualHeight <= 0 ? 0 : targetBandTopY / ActualHeight;
-            _vm.RequestScrollByVerticalFraction(fraction);
+            EmitDragScroll(p);
             e.Handled = true;
             return;
         }
@@ -459,10 +453,6 @@ private void ResetInteraction()
         if (IsMouseCaptured) ReleaseMouseCapture();
         if (_dragGhostBandTop is not null)
         {
-            // Clear the ghost first, then invalidate so the next paint
-            // shows the band where the editor actually settled. If the
-            // editor hasn't quite caught up yet, the band may snap by a
-            // pixel or two — fine, drag is over.
             _dragGhostBandTop = null;
             InvalidateVisual();
         }
@@ -578,20 +568,33 @@ private void EmitDragScroll(Point p)
         if (_vm is null) return;
         double targetBandTopY = p.Y - _bandDragOffsetFromTop;
 
-        // Paint the band at the cursor on the very next render tick,
-        // without waiting for the editor's scroll → layout → ScrollChanged
-        // → ViewportState → PropertyChanged round-trip. Without this
-        // decoupling, the band visibly trails the cursor by however long
-        // the editor takes to settle its layout pass; on large files
-        // that's enough to drop the band several frames behind a fast
-        // drag, which reads as the band "sticking" to lower-than-cursor
-        // positions. The editor still catches up via the normal scroll
-        // path below; the ghost just makes the bar's visual frame-instant.
-        _dragGhostBandTop = ClampGhostTop(targetBandTopY);
+        // Paint the band at the predicted post-settle position on the
+        // very next render tick, without waiting for the editor's scroll
+        // → layout → ScrollChanged → ViewportState → PropertyChanged
+        // round-trip. Without this decoupling, the band visibly trails
+        // the cursor by however long the editor takes to settle its
+        // layout pass; on large files that's enough to drop the band
+        // several frames behind a fast drag, which reads as the band
+        // "sticking" to lower-than-cursor positions.
+        //
+        // In side-by-side mode the editor's scroll fraction maps 1:1 to
+        // the bar's band-top fraction, so the predicted position equals
+        // <c>targetBandTopY</c> and the band lands under the cursor.
+        // In inline mode the editor's extent is the inline document
+        // (which includes deletion lines) while the bar paints from the
+        // right/left source line counts; the prediction (via the VM's
+        // <see cref="DiffPaneViewModel.PredictBandTopFractionForScroll"/>)
+        // walks the inline-to-source map to find where the band will
+        // actually settle. Setting the ghost to the predicted position
+        // (instead of the cursor) ensures there's no visible jump when
+        // the editor's Viewport state catches up.
+        double rawFraction = ActualHeight <= 0 ? 0 : targetBandTopY / ActualHeight;
+        double predictedFraction = _vm.PredictBandTopFractionForScroll(rawFraction);
+        double predictedBandTopY = predictedFraction * ActualHeight;
+        _dragGhostBandTop = ClampGhostTop(predictedBandTopY);
         InvalidateVisual();
 
-        double fraction = ActualHeight <= 0 ? 0 : targetBandTopY / ActualHeight;
-        _vm.RequestScrollByVerticalFraction(fraction);
+        _vm.RequestScrollByVerticalFraction(rawFraction);
     }
 
     /// <summary>

DiffViewer/ViewModels/DiffPaneViewModel.cs

@@ -1198,6 +1198,90 @@ public void RequestScrollByVerticalFraction(double fraction)
             this, new ScrollByVerticalFractionRequestedEventArgs(fraction));
     }
 
+    /// <summary>
+    /// Predict the viewport-band top fraction (0..1 of bar height) the
+    /// overview bar will paint at after the editor settles at
+    /// <paramref name="scrollFraction"/>. Used by the bar to position the
+    /// sticky-thumb ghost so it lands at the post-settle position rather
+    /// than the raw cursor position — without this prediction, inline
+    /// mode produces a visible "jiggle" on click-to-jump because the
+    /// editor's ExtentHeight is based on the inline document (which
+    /// includes deletion lines) while the bar paints the band based on
+    /// <c>(RightFirstLine − 1) / RightTotalLines × barHeight</c>. The two
+    /// coordinate systems coincide only in side-by-side mode.
+    ///
+    /// <para>In side-by-side mode the right editor's extent maps 1:1 to
+    /// the right document's line count, so the prediction is identity.
+    /// In inline mode the prediction walks
+    /// <see cref="InlineLineToSourceLines"/> forward from the predicted
+    /// first inline line to find what
+    /// <c>(LeftFirstLine, RightFirstLine)</c> will be after settle, then
+    /// returns <c>min(leftFrac, rightFrac)</c> to match how
+    /// <c>HunkOverviewBarGeometry.GetBandTopY</c> picks the band's top.
+    /// </para>
+    /// </summary>
+    public double PredictBandTopFractionForScroll(double scrollFraction) =>
+        PredictBandTopFraction(
+            scrollFraction,
+            InlineLineToSourceLines,
+            LeftDocument.LineCount,
+            RightDocument.LineCount,
+            IsSideBySide);
+
+    /// <summary>
+    /// Pure-function core of <see cref="PredictBandTopFractionForScroll"/>
+    /// for unit-testing without spinning up an editor or loading a real
+    /// diff. NaN and out-of-range inputs are normalized to <c>[0, 1]</c>.
+    /// Returns <paramref name="scrollFraction"/> verbatim when the map
+    /// is empty (no inline diff loaded yet) or when
+    /// <paramref name="isSideBySide"/> is true.
+    /// </summary>
+    internal static double PredictBandTopFraction(
+        double scrollFraction,
+        IReadOnlyList<(int? OldLine, int? NewLine)> map,
+        int leftTotal,
+        int rightTotal,
+        bool isSideBySide)
+    {
+        if (double.IsNaN(scrollFraction)) scrollFraction = 0;
+        if (scrollFraction < 0) scrollFraction = 0;
+        if (scrollFraction > 1) scrollFraction = 1;
+
+        if (isSideBySide) return scrollFraction;
+        if (map is null || map.Count == 0) return scrollFraction;
+
+        int safeLeftTotal = Math.Max(1, leftTotal);
+        int safeRightTotal = Math.Max(1, rightTotal);
+        int inlineTotal = map.Count;
+
+        int firstInlineIndex = (int)Math.Floor(scrollFraction * inlineTotal);
+        if (firstInlineIndex < 0) firstInlineIndex = 0;
+        if (firstInlineIndex >= inlineTotal) firstInlineIndex = inlineTotal - 1;
+
+        int? predictedLeft = null;
+        int? predictedRight = null;
+        for (int i = firstInlineIndex; i < inlineTotal; i++)
+        {
+            var (oldLn, newLn) = map[i];
+            if (predictedLeft is null && oldLn is int o) predictedLeft = o;
+            if (predictedRight is null && newLn is int n) predictedRight = n;
+            if (predictedLeft is not null && predictedRight is not null) break;
+        }
+
+        if (predictedLeft is null && predictedRight is null)
+        {
+            return scrollFraction;
+        }
+
+        double leftFrac = predictedLeft is int pl
+            ? (double)(pl - 1) / safeLeftTotal
+            : 1.0;
+        double rightFrac = predictedRight is int pr
+            ? (double)(pr - 1) / safeRightTotal
+            : 1.0;
+        return Math.Min(leftFrac, rightFrac);
+    }
+
     public void Dispose()
     {
         if (_settingsService is not null)