Merge pull request #5256 from gui-cs/release/v2.1.0-rc.3

Release v2.1.0-rc.3

Author: tig

.github/workflows/build-validation.yml

@@ -15,7 +15,7 @@ jobs:
     name: Build All Configurations
     runs-on: ubuntu-latest
 
-    timeout-minutes: 15
+    timeout-minutes: 20
     steps:
 
     - name: Checkout code
@@ -57,7 +57,14 @@ jobs:
         dotnet build ./Examples/SelfContained/SelfContained.csproj --configuration Release -property:NoWarn=0618%3B0612
 
     - name: AOT Publish (catches trimming and reflection errors)
-      run: dotnet publish ./Examples/NativeAot/NativeAot.csproj --configuration Release -property:NoWarn=0618%3B0612
+      run: dotnet publish ./Examples/NativeAot/NativeAot.csproj --configuration Release --output ./aot-publish -property:NoWarn=0618%3B0612
+
+    - name: AOT Smoke Test (run the published AOT binary)
+      env:
+        DisableRealDriverIO: "1"
+      run: |
+        chmod +x ./aot-publish/NativeAot
+        ./aot-publish/NativeAot --smoke-test
 
     - name: Build Release Solution
       run: dotnet build --configuration Release --no-restore -property:NoWarn=0618%3B0612

Examples/NativeAot/Program.cs

@@ -18,17 +18,19 @@ namespace NativeAot;
 
 public static class Program
 {
-    private static void Main ()
+    private static async Task Main (string [] args)
     {
 #pragma warning disable IL2026, IL3050
-        Run ();
+        await RunAsync (args);
 #pragma warning restore IL2026, IL3050
     }
 
     [RequiresUnreferencedCode ("Calls Terminal.Gui.Application.Init(IDriver, String)")]
     [RequiresDynamicCode ("Calls Terminal.Gui.Application.Init(IDriver, String)")]
-    private static void Run ()
+    private static async Task RunAsync (string [] args)
     {
+        bool smokeTest = args.Length > 0 && args [0] == "--smoke-test";
+
         ConfigurationManager.Enable (ConfigLocations.All);
 
         IApplication app = Application.Create ().Init ();
@@ -47,6 +49,17 @@ private static void Run ()
 
         #endregion
 
+        if (smokeTest)
+        {
+            // CI smoke test: run the full app lifecycle with a timeout
+            using CancellationTokenSource cts = new (TimeSpan.FromSeconds (5));
+            await app.RunAsync<AotAllViewsWindow> (cts.Token);
+            app.Dispose ();
+            Console.WriteLine ("AOT smoke test passed: full app lifecycle completed successfully.");
+
+            return;
+        }
+
         app.Run<AotAllViewsWindow> ();
         app.Dispose ();
     }

Terminal.Gui/Drivers/Output/OutputBase.cs

@@ -170,31 +170,36 @@ public virtual void Write (IOutputBuffer buffer)
                 }
             }
 
-            // Flush buffered output for row
-            if (outputStringBuilder.Length <= 0)
+            // Flush buffered output for row. Even when nothing remains buffered, an OSC 8 hyperlink
+            // may still be open in the terminal because it was started in a prior batch flushed by
+            // WriteToConsole and the row ended (or only clean cells followed) before any cell with
+            // a different URL closed it. Emit the close so the link does not bleed into later rows.
+            if (outputStringBuilder.Length <= 0 && _lastUrl is null)
             {
                 continue;
             }
 
             if (IsLegacyConsole)
             {
-                Write (outputStringBuilder);
-            }
-            else
-            {
-                SetCursorPositionImpl (lastCol, row);
-
-                // Close any open hyperlink before processing URLs
-                if (_lastUrl is { })
+                if (outputStringBuilder.Length > 0)
                 {
-                    outputStringBuilder.Append (EscSeqUtils.OSC_EndHyperlink ());
-                    _lastUrl = null;
+                    Write (outputStringBuilder);
                 }
 
-                // Wrap URLs with OSC 8 hyperlink sequences
-                StringBuilder processed = Osc8UrlLinker.WrapOsc8 (outputStringBuilder);
-                Write (processed);
+                continue;
             }
+
+            if (_lastUrl is { })
+            {
+                outputStringBuilder.Append (EscSeqUtils.OSC_EndHyperlink ());
+                _lastUrl = null;
+            }
+
+            SetCursorPositionImpl (lastCol, row);
+
+            // Wrap URLs with OSC 8 hyperlink sequences
+            StringBuilder processed = Osc8UrlLinker.WrapOsc8 (outputStringBuilder);
+            Write (processed);
         }
 
         if (IsLegacyConsole)

Terminal.Gui/Drivers/Output/OutputBufferImpl.cs

@@ -409,11 +409,16 @@ private void SetAttributeAndDirty (int col, int row)
         Contents! [row, col].Attribute = CurrentAttribute;
         Contents [row, col].IsDirty = true;
 
-        // If CurrentUrl is set, store it in the URL map
+        // Update the URL map: store CurrentUrl, or clear any stale entry so cells
+        // overdrawn by non-link content are not wrapped in OSC 8 sequences.
         if (!string.IsNullOrEmpty (CurrentUrl))
         {
             SetCellUrl (col, row, CurrentUrl);
         }
+        else
+        {
+            _urlMap?.Remove (new Point (col, row));
+        }
     }
 
     /// <summary>

Tests/UnitTestsParallelizable/Drivers/Output/OutputBaseTests.cs

@@ -444,4 +444,109 @@ public void Write_EmitsSixelDataAndPositionsCursor (bool isLegacyConsole)
 
         app.Dispose ();
     }
+
+    // Claude - Opus 4.7
+    // Regression test for https://github.com/gui-cs/Terminal.Gui/issues/4892
+    // When dirty cells with a URL are flushed mid-row because a clean cell follows,
+    // the OSC 8 hyperlink remains open in the terminal. If no more dirty cells appear
+    // on the row, the end-of-row code must still emit the OSC 8 close sequence so the
+    // hyperlink does not bleed into the next row.
+    [Fact]
+    public void Write_UrlFollowedByCleanCells_ClosesHyperlinkAtRowEnd ()
+    {
+        // Arrange: 5-col row. URL at cols 0-1, clean cells at cols 2-4.
+        AnsiOutput output = new ();
+        IOutputBuffer buffer = output.GetLastBuffer ()!;
+        buffer.SetSize (5, 1);
+
+        // First frame: write URL cells then clear dirty by flushing
+        buffer.Move (0, 0);
+        buffer.CurrentUrl = "https://example.com";
+        buffer.AddStr ("AB");
+        buffer.CurrentUrl = null;
+        output.Write (buffer);
+
+        // Second frame: only re-mark the URL cells dirty so cols 2-4 stay clean.
+        buffer.Contents! [0, 0].IsDirty = true;
+        buffer.Contents! [0, 1].IsDirty = true;
+        buffer.DirtyLines [0] = true;
+
+        // Act
+        output.Write (buffer);
+        string result = output.GetLastOutput ();
+
+        // Assert: every OSC 8 start sequence is followed by an OSC 8 close before the row ends.
+        string start = EscSeqUtils.OSC_StartHyperlink ("https://example.com");
+        string end = EscSeqUtils.OSC_EndHyperlink ();
+        int startIdx = result.IndexOf (start, StringComparison.Ordinal);
+        Assert.True (startIdx >= 0, "OSC 8 start sequence not emitted");
+
+        int endIdx = result.IndexOf (end, startIdx + start.Length, StringComparison.Ordinal);
+        Assert.True (endIdx > startIdx, "OSC 8 hyperlink was not closed before the row ended");
+    }
+
+    // Claude - Opus 4.7
+    // Regression test for https://github.com/gui-cs/Terminal.Gui/issues/4892
+    // When a Link's display area shrinks (or a Link is replaced), the cells previously
+    // associated with a URL may be overdrawn by content that has no URL. Those cells
+    // must be removed from the URL map so OSC 8 sequences are not re-emitted for them.
+    [Fact]
+    public void AddStr_NoCurrentUrl_ClearsStaleUrlMapping ()
+    {
+        // Arrange
+        AnsiOutput output = new ();
+        IOutputBuffer buffer = output.GetLastBuffer ()!;
+        buffer.SetSize (5, 1);
+
+        // First write: cells get associated with a URL
+        buffer.Move (0, 0);
+        buffer.CurrentUrl = "https://example.com";
+        buffer.AddStr ("HELLO");
+        buffer.CurrentUrl = null;
+
+        Assert.Equal ("https://example.com", buffer.GetCellUrl (0, 0));
+        Assert.Equal ("https://example.com", buffer.GetCellUrl (4, 0));
+
+        // Act: overwrite cells with no CurrentUrl set (simulates a non-link view redrawing)
+        buffer.Move (0, 0);
+        buffer.AddStr ("WORLD");
+
+        // Assert: stale URL associations are cleared
+        Assert.Null (buffer.GetCellUrl (0, 0));
+        Assert.Null (buffer.GetCellUrl (1, 0));
+        Assert.Null (buffer.GetCellUrl (2, 0));
+        Assert.Null (buffer.GetCellUrl (3, 0));
+        Assert.Null (buffer.GetCellUrl (4, 0));
+
+        // And the rendered output for the second frame contains no OSC 8 sequences
+        string result = output.ToAnsi (buffer);
+        Assert.DoesNotContain (EscSeqUtils.OSC_StartHyperlink ("https://example.com"), result);
+    }
+
+    // Claude - Opus 4.7
+    // Regression test for https://github.com/gui-cs/Terminal.Gui/issues/4892
+    // When CurrentUrl changes from one URL to another for the same cell, the URL map
+    // should reflect the new URL (verifying the URL clear path does not break re-assignment).
+    [Fact]
+    public void AddStr_DifferentUrl_OverwritesUrlMapping ()
+    {
+        // Arrange
+        AnsiOutput output = new ();
+        IOutputBuffer buffer = output.GetLastBuffer ()!;
+        buffer.SetSize (3, 1);
+
+        buffer.Move (0, 0);
+        buffer.CurrentUrl = "https://one.com";
+        buffer.AddStr ("ABC");
+
+        // Act: rewrite same cells with a different URL
+        buffer.Move (0, 0);
+        buffer.CurrentUrl = "https://two.com";
+        buffer.AddStr ("ABC");
+
+        // Assert: cells now report the new URL
+        Assert.Equal ("https://two.com", buffer.GetCellUrl (0, 0));
+        Assert.Equal ("https://two.com", buffer.GetCellUrl (1, 0));
+        Assert.Equal ("https://two.com", buffer.GetCellUrl (2, 0));
+    }
 }