refactor(cursor): remove software cursor; make hardware blink per-cursor

The blink jitter fixed by the re-emission change (dbb9fdf) made the opt-in
software cursor unnecessary, so remove it entirely:
- Delete CursorBlinkClock, IConsoleDriver/ConsoleBuffer TryGetCell +
  ParseAnsiColors, the UseSoftwareCursor option, the render overlay, and the
  main-loop blink-tick/keep-alive/idle-clamp hooks.

Promote hardware blink to a first-class per-cursor property, mirroring
ICursorShapeProvider:
- Add ICursorBlinkProvider.PreferredCursorBlink and CursorState.Blink.
- Thread blink through UpdateFromWindowSystem and the apply-diff via a new
  additive SetCursorShape(shape, blink) overload (single-arg preserved;
  default-interface impl keeps external drivers compiling).
- ConsoleWindowSystem resolves blink beside shape, seeded from the system
  default (Options.CursorBlink, resolved once at startup, fallback Blinking).

Keep the re-emission fix and InvalidatePhysicalCursor untouched. Keep the
pre-existing CursorBlinkRate option. Backward compatible: defaults preserve
existing behavior; no published API removed.

Author: nickprotop

SharpConsoleUI.Tests/Core/CursorBlinkClockTests.cs

@@ -0,0 +1,64 @@
+using System.Drawing;
+using SharpConsoleUI;
+using SharpConsoleUI.Core;
+using SharpConsoleUI.Drivers;
+using Xunit;
+
+namespace SharpConsoleUI.Tests.Core;
+
+/// <summary>
+/// Verifies that the per-cursor blink value carried on <see cref="CursorState"/> is applied to the
+/// driver via the two-arg <c>SetCursorShape(shape, blink)</c> overload, and re-emitted when it changes.
+/// </summary>
+public class CursorBlinkResolutionTests
+{
+	private static (CursorStateService svc, HeadlessConsoleDriver drv, Window win) Make()
+	{
+		var driver = new HeadlessConsoleDriver(80, 25);
+		var system = new ConsoleWindowSystem(driver);
+		var win = new Window(system);
+		var svc = new CursorStateService(driver);
+		return (svc, driver, win);
+	}
+
+	[Theory]
+	[InlineData(CursorBlink.Steady)]
+	[InlineData(CursorBlink.Blinking)]
+	[InlineData(CursorBlink.TerminalDefault)]
+	public void ApplyCursor_ForwardsBlinkToDriver(CursorBlink blink)
+	{
+		var (svc, drv, win) = Make();
+		svc.UpdateFromWindowSystem(win, new Point(2, 3), new Point(2, 3), null, CursorShape.Block, blink);
+		svc.ApplyCursorToConsole(80, 25);
+		Assert.Equal(blink, drv.LastCursorBlink);
+	}
+
+	[Fact]
+	public void ApplyCursor_Reemits_WhenOnlyBlinkChanges()
+	{
+		var (svc, drv, win) = Make();
+		svc.UpdateFromWindowSystem(win, new Point(2, 3), new Point(2, 3), null, CursorShape.Block, CursorBlink.Blinking);
+		svc.ApplyCursorToConsole(80, 25);
+		int afterFirst = drv.SetCursorShapeCallCount;
+
+		// Same shape/position, only blink changes -> shape must be re-emitted (it carries blink).
+		svc.UpdateFromWindowSystem(win, new Point(2, 3), new Point(2, 3), null, CursorShape.Block, CursorBlink.Steady);
+		svc.ApplyCursorToConsole(80, 25);
+
+		Assert.Equal(afterFirst + 1, drv.SetCursorShapeCallCount);
+		Assert.Equal(CursorBlink.Steady, drv.LastCursorBlink);
+	}
+
+	[Fact]
+	public void ApplyCursor_DoesNotReemit_WhenBlinkUnchanged()
+	{
+		var (svc, drv, win) = Make();
+		svc.UpdateFromWindowSystem(win, new Point(2, 3), new Point(2, 3), null, CursorShape.Block, CursorBlink.Steady);
+		svc.ApplyCursorToConsole(80, 25);
+		int afterFirst = drv.SetCursorShapeCallCount;
+
+		for (int i = 0; i < 3; i++) svc.ApplyCursorToConsole(80, 25);
+
+		Assert.Equal(afterFirst, drv.SetCursorShapeCallCount);
+	}
+}

SharpConsoleUI.Tests/Core/CursorBlinkResolutionTests.cs

@@ -56,12 +56,9 @@ public class ConsoleWindowSystem
 		// Managed thread id of the main-loop (UI) thread; set at Run() start. -1 until then.
 		private int _uiThreadId = -1;
 
-		// Software cursor: opt-in caret drawn by the app (blinking) with hardware cursor hidden.
-		// Resolved once at startup from the driver's options.
-		private bool _useSoftwareCursor;
-		private int _cursorBlinkRateMs = 500;
-		private readonly Core.CursorBlinkClock _blinkClock = new();
-		private System.Drawing.Point _lastSoftwareCursorPos = new(-1, -1);
+		// System-wide default hardware-cursor blink behavior, resolved once at startup from the
+		// driver's options. Per-cursor providers (ICursorBlinkProvider) override this per frame.
+		private Core.CursorBlink _defaultCursorBlink = Core.CursorBlink.Blinking;
 
 		// Signal to wake the main loop when input or UI actions arrive
 		private readonly ManualResetEventSlim _wakeSignal = new(false);
@@ -415,12 +412,11 @@ public ConsoleWindowSystem(IConsoleDriver driver, ITheme theme, PluginConfigurat
 			// Initialize panels from config or legacy StatusBarOptions
 			_panelStateService.InitializePanels(_options);
 
-			// Resolve software-cursor settings once from the driver's options (if it exposes them).
-			// Headless/other drivers leave the defaults (false / 500ms).
+			// Resolve the system-wide default cursor-blink behavior once from the driver's options
+			// (if it exposes them). Headless/other drivers leave the default (Blinking).
 			if (_consoleDriver is Drivers.NetConsoleDriver netDriver)
 			{
-				_useSoftwareCursor = netDriver.Options.UseSoftwareCursor;
-				_cursorBlinkRateMs = netDriver.Options.CursorBlinkRate;
+				_defaultCursorBlink = netDriver.Options.CursorBlink;
 			}
 		}
 
@@ -475,10 +471,6 @@ public IConsoleDriver ConsoleDriver
 		/// </summary>
 		internal CursorStateService CursorStateService => _cursorStateService;
 
-		/// <summary>True when a software caret should currently be drawn.</summary>
-		internal bool SoftwareCursorOn =>
-			_useSoftwareCursor && _cursorStateService.CurrentState.IsVisible && _blinkClock.IsOn(_cursorBlinkRateMs);
-
 		/// <summary>
 		/// Gets the window state service for managing window lifecycle and state.
 		/// </summary>
@@ -939,8 +931,6 @@ public int Run()
 					var now = DateTime.UtcNow;
 					var elapsed = (now - _lastRenderTime).TotalMilliseconds;
 
-					if (_useSoftwareCursor) _blinkClock.Advance(elapsed);
-
 					// Track performance metrics on EVERY iteration (independent of rendering)
 					bool metricsNeedUpdate = false;
 					if (Performance.IsPerformanceMetricsEnabled)
@@ -964,8 +954,7 @@ public int Run()
 					}
 
 					// Frame pacing: render if windows are dirty OR metrics need update OR desktop needs render OR animations active
-					bool shouldRender = AnyWindowDirty() || metricsNeedUpdate || Render.DesktopNeedsRender || Animations.HasActiveAnimations || Parsing.MarkupSpinnerClock.ShouldKeepRendering(Animations.IsEnabled) || Render.IsStatusBarDirty() || _desktopPortalService.AnyPortalDirty()
-						|| (_useSoftwareCursor && _cursorStateService.CurrentState.IsVisible);
+					bool shouldRender = AnyWindowDirty() || metricsNeedUpdate || Render.DesktopNeedsRender || Animations.HasActiveAnimations || Parsing.MarkupSpinnerClock.ShouldKeepRendering(Animations.IsEnabled) || Render.IsStatusBarDirty() || _desktopPortalService.AnyPortalDirty();
 
 					// Calculate recommended sleep duration once (used in both branches)
 					var recommendedSleep = _inputStateService.GetRecommendedSleepDuration(
@@ -1008,9 +997,6 @@ public int Run()
 					UpdateCursor();
 					if (_uiActionsPending && _idleTime > Configuration.SystemDefaults.MinSleepDurationMs)
 						_idleTime = Configuration.SystemDefaults.MinSleepDurationMs;
-					// Keep the loop ticking fast enough for smooth caret blinking.
-					if (_useSoftwareCursor && _cursorStateService.CurrentState.IsVisible)
-						_idleTime = Math.Min(_idleTime, _cursorBlinkRateMs);
 					_currentPhase = Core.MainLoopPhase.Idle;
 					try
 					{
@@ -1320,6 +1306,8 @@ private void UpdateCursor()
 					// Get the owner control if available
 					IWindowControl? ownerControl = null;
 					CursorShape cursorShape = CursorShape.Block;
+					// Seed blink from the system-wide default; a per-cursor provider may override it below.
+					CursorBlink cursorBlink = _defaultCursorBlink;
 
 					if (ActiveWindow.EventDispatcher != null && ActiveWindow.EventDispatcher.HasActiveInteractiveContent(out var interactiveContent) &&
 						interactiveContent is IWindowControl windowControl)
@@ -1340,6 +1328,18 @@ private void UpdateCursor()
 						{
 							cursorShape = shapeProvider.PreferredCursorShape.Value;
 						}
+
+						// Blink resolves the same way: deepest provider first, then top-level control.
+						if (deepestControl is ICursorBlinkProvider deepBlinkProvider &&
+							deepBlinkProvider.PreferredCursorBlink.HasValue)
+						{
+							cursorBlink = deepBlinkProvider.PreferredCursorBlink.Value;
+						}
+						else if (windowControl is ICursorBlinkProvider blinkProvider &&
+							blinkProvider.PreferredCursorBlink.HasValue)
+						{
+							cursorBlink = blinkProvider.PreferredCursorBlink.Value;
+						}
 					}
 
 					// Update cursor state service with new state
@@ -1348,7 +1348,8 @@ private void UpdateCursor()
 						logicalPosition: cursorPosition,
 						absolutePosition: new Point(absoluteLeft, absoluteTop),
 						ownerControl: ownerControl,
-						shape: cursorShape);
+						shape: cursorShape,
+						blink: cursorBlink);
 				}
 				else
 				{
@@ -1360,18 +1361,6 @@ private void UpdateCursor()
 				_cursorStateService.HideCursor();
 			}
 
-			// Software cursor: reset the blink clock whenever the caret moves so the new
-			// position starts in the "on" phase. CurrentState holds the real (visible) caret.
-			if (_useSoftwareCursor)
-			{
-				var caretPos = _cursorStateService.CurrentState.AbsolutePosition;
-				if (caretPos != _lastSoftwareCursorPos)
-				{
-					_blinkClock.Reset();
-					_lastSoftwareCursorPos = caretPos;
-				}
-			}
-
 			// Apply cursor state to the actual console
 			// CRITICAL: Protect Console I/O with lock to prevent concurrent writes
 			// from corrupting ANSI sequences during InputLoop's mouse parsing
@@ -1380,15 +1369,6 @@ private void UpdateCursor()
 				_cursorStateService.ApplyCursorToConsole(
 					_consoleDriver.ScreenSize.Width,
 					_consoleDriver.ScreenSize.Height);
-
-				// Software cursor: keep CurrentState as the real (visible) caret for the overlay,
-				// but force the HARDWARE cursor hidden so only the app-drawn caret is seen.
-				// Only emit when the caret is logically visible (avoids churn; the overlay
-				// redraws every frame while focused — see the keep-alive in the main loop).
-				if (_useSoftwareCursor && _cursorStateService.CurrentState.IsVisible)
-				{
-					_consoleDriver.SetCursorVisible(false);
-				}
 			}
 		}
 

SharpConsoleUI.Tests/Drivers/TryGetCellTests.cs

@@ -24,6 +24,19 @@ public interface ICursorShapeProvider
 		CursorShape? PreferredCursorShape { get; }
 	}
 
+	/// <summary>
+	/// Interface for controls that can specify a preferred cursor blink behavior.
+	/// Controls implementing this interface can customize whether the cursor blinks when focused.
+	/// </summary>
+	public interface ICursorBlinkProvider
+	{
+		/// <summary>
+		/// Gets the preferred cursor blink behavior for this control.
+		/// Return null to use the system default blink.
+		/// </summary>
+		CursorBlink? PreferredCursorBlink { get; }
+	}
+
 	/// <summary>
 	/// Represents the shape/style of the cursor
 	/// </summary>
@@ -89,6 +102,11 @@ public record CursorState
 		/// </summary>
 		public CursorShape Shape { get; init; }
 
+		/// <summary>
+		/// The blink behavior of the cursor
+		/// </summary>
+		public CursorBlink Blink { get; init; }
+
 		/// <summary>
 		/// Timestamp when this state was created
 		/// </summary>
@@ -103,14 +121,16 @@ public CursorState(
 			Point? logicalPosition = null,
 			IWindowControl? ownerControl = null,
 			Window? ownerWindow = null,
-			CursorShape shape = CursorShape.Block)
+			CursorShape shape = CursorShape.Block,
+			CursorBlink blink = CursorBlink.Blinking)
 		{
 			IsVisible = isVisible;
 			AbsolutePosition = absolutePosition ?? Point.Empty;
 			LogicalPosition = logicalPosition;
 			OwnerControl = ownerControl;
 			OwnerWindow = ownerWindow;
 			Shape = shape;
+			Blink = blink;
 			UpdateTime = DateTime.UtcNow;
 		}