Fix 32+ bugs: thread safety, unicode rendering, code quality, dropdown arrows, layout crash

Core infrastructure:
- InvalidationManager: finally block no longer overrides catch error recovery
- NotificationStateService: snapshot list with ToList().AsReadOnly(); disposed guard
- DisposableManager: set _disposed before disposal work to prevent TOCTOU race
- FocusStateService: guard null-to-null ClearFocus in PopFocus
- ModalStateService: cycle detection in FindDeepestModalChildInternal
- WindowStateService: merge FlashWindow TOCTOU lock blocks

Thread safety:
- WindowLifecycleHelper: marshal background thread UI mutations via EnqueueOnUIThread
- WindowLifecycleHelper: remove double-dispose in ApplyErrorState
- TerminalControl: TryClose via EnqueueOnUIThread from ReadLoop
- TreeControl: capture deferred events inside lock before firing
- ListControl: read _items.Count inside lock in Items/StringItems setters
- UnixStdinReader: add _mouseStateLock for torn-read protection
- WindowPositioningManager: use SetPositionDirect to avoid re-entrant MoveWindowTo

Window state:
- Window.SetIsActive: set _isActive before firing Activated/Deactivated events
- Window.SetIsActive: clear leaf HasFocus on deactivation

Unicode rendering (Rule 12B/12C):
- SliderControl/RangeSliderControl: UnicodeWidth.GetStringWidth for label widths
- TabControl: MarkupParser.Parse for nav hint rendering
- ListControl: UnicodeWidth for selectionIndicator width
- TreeControl: use ControlRenderingHelpers.FillRect for gradient support

Code quality:
- FigleControl, LayoutNode, DatePickerControl, DropdownControl: StringBuilder
- SequenceHelper, UnixStdinReader: named constants from ControlDefaults
- Add ContinuousPressIntervalMs constant

Dropdown arrows:
- Use narrow ▾/▴ (U+25BE/U+25B4) instead of ▼/▲ which render as 2-wide
- Add ControlDefaults for dropdown arrow characters
- Render arrow separately via MarkupParser.Parse

Layout crash fix:
- LayoutConstraints.Constrain: defensive Math.Max to prevent MinWidth > MaxWidth
- ScrollablePanelControl: clamp contentWidth to minimum 1

Tests:
- DropdownControlTests: add assertions to 5 empty keyboard tests
- TestWindowSystemBuilder: fix no-op configure callback (Func instead of Action)
- AppRegistryTests: polling loop instead of fragile Task.Delay

Author: nickprotop

SharpConsoleUI.Tests/Controls/DropdownControlTests.cs

@@ -521,8 +521,9 @@ public void ProcessInput_Enter_TogglesDropdown()
 		var dd = CreateFocusedDropdown("S:", "A", "B", "C");
 		// Without a container Window, Enter won't create portal, but IsDropdownOpen should still toggle
 		// The state is maintained internally even if portal creation fails
-		dd.ProcessKey(Key(ConsoleKey.Enter));
-		// Can't fully test open without Window, but we verify the control processes the key
+		var result = dd.ProcessKey(Key(ConsoleKey.Enter));
+		Assert.True(result);
+		Assert.True(dd.IsDropdownOpen);
 	}
 
 	[Fact]
@@ -538,32 +539,40 @@ public void ProcessInput_DownArrow_IncreasesHighlight()
 	{
 		var dd = CreateFocusedDropdown("S:", "A", "B", "C");
 		dd.SelectedIndex = 0;
-		dd.ProcessKey(Key(ConsoleKey.DownArrow));
-		// Without open dropdown, down arrow should navigate
+		var result = dd.ProcessKey(Key(ConsoleKey.DownArrow));
+		// When closed, DownArrow opens the dropdown
+		Assert.True(result);
+		Assert.True(dd.IsDropdownOpen);
 	}
 
 	[Fact]
 	public void ProcessInput_UpArrow_DecreasesHighlight()
 	{
 		var dd = CreateFocusedDropdown("S:", "A", "B", "C");
 		dd.SelectedIndex = 2;
-		dd.ProcessKey(Key(ConsoleKey.UpArrow));
+		// When closed, UpArrow does nothing
+		var result = dd.ProcessKey(Key(ConsoleKey.UpArrow));
+		Assert.False(result);
 	}
 
 	[Fact]
 	public void ProcessInput_Home_JumpsToFirst()
 	{
 		var dd = CreateFocusedDropdown("S:", "A", "B", "C");
 		dd.SelectedIndex = 2;
-		dd.ProcessKey(Key(ConsoleKey.Home));
+		// When closed, Home does nothing
+		var result = dd.ProcessKey(Key(ConsoleKey.Home));
+		Assert.False(result);
 	}
 
 	[Fact]
 	public void ProcessInput_End_JumpsToLast()
 	{
 		var dd = CreateFocusedDropdown("S:", "A", "B", "C");
 		dd.SelectedIndex = 0;
-		dd.ProcessKey(Key(ConsoleKey.End));
+		// When closed, End does nothing
+		var result = dd.ProcessKey(Key(ConsoleKey.End));
+		Assert.False(result);
 	}
 
 	[Fact]
@@ -572,8 +581,9 @@ public void ProcessInput_Disabled_IgnoresInput()
 		var dd = CreateFocusedDropdown("S:", "A", "B");
 		dd.IsEnabled = false;
 		dd.SelectedIndex = 0;
-		dd.ProcessKey(Key(ConsoleKey.DownArrow));
-		// Should not change because disabled
+		var result = dd.ProcessKey(Key(ConsoleKey.DownArrow));
+		Assert.False(result);
+		Assert.Equal(0, dd.SelectedIndex);
 	}
 
 	#endregion

SharpConsoleUI.Tests/Infrastructure/TestWindowSystemBuilder.cs

@@ -36,9 +36,9 @@ private static ConsoleWindowSystem WithInputHandlers(ConsoleWindowSystem system)
 	/// <summary>
 	/// Creates a test window system with diagnostics enabled and a mock console driver.
 	/// </summary>
-	/// <param name="configure">Optional configuration callback.</param>
+	/// <param name="configure">Optional configuration callback that returns a modified options record.</param>
 	/// <returns>A configured ConsoleWindowSystem instance ready for testing.</returns>
-	public static ConsoleWindowSystem CreateTestSystem(Action<ConsoleWindowSystemOptions>? configure = null)
+	public static ConsoleWindowSystem CreateTestSystem(Func<ConsoleWindowSystemOptions, ConsoleWindowSystemOptions>? configure = null)
 	{
 		// Disable status bars by default in tests to isolate core rendering logic
 		var statusBarOptions = new Configuration.StatusBarOptions(
@@ -58,13 +58,10 @@ public static ConsoleWindowSystem CreateTestSystem(Action<ConsoleWindowSystemOpt
 			StatusBarOptions: statusBarOptions
 		);
 
-		// Allow caller to customize options
+		// Allow caller to customize options via record 'with' expressions
 		if (configure != null)
 		{
-			// Create a modified options instance
-			var customOptions = options;
-			configure(customOptions);
-			options = customOptions;
+			options = configure(options);
 		}
 
 		// Create mock console driver

SharpConsoleUI.Tests/Registry/AppRegistryTests.cs

@@ -96,10 +96,17 @@ public async Task LazyFlush_TimerFires_PersistsData()
         using var reg = new AppRegistry(config);
         reg.OpenSection("App").SetInt("X", 77);
 
-        // Wait 10x the interval — generous margin for CI environments under load
-        await Task.Delay(500);
+        // Poll until the lazy flush timer persists data, with a generous timeout for CI
+        var timeout = TimeSpan.FromSeconds(2);
+        var start = DateTime.UtcNow;
+        System.Text.Json.Nodes.JsonNode? loaded = null;
+        while (DateTime.UtcNow - start < timeout)
+        {
+            loaded = storage.Load();
+            if (loaded != null) break;
+            await Task.Delay(50);
+        }
 
-        var loaded = storage.Load();
         Assert.NotNull(loaded);
     }
 

SharpConsoleUI/Configuration/ControlDefaults.cs

@@ -73,6 +73,11 @@ public static class ControlDefaults
 		/// </summary>
 		public const int DefaultDebounceMs = 300;
 
+		/// <summary>
+		/// Interval for continuous mouse button press polling in milliseconds (default: 100ms)
+		/// </summary>
+		public const int ContinuousPressIntervalMs = 100;
+
 		/// <summary>
 		/// Cursor blink rate for text inputs in milliseconds (default: 500ms)
 		/// </summary>
@@ -448,6 +453,32 @@ public static class ControlDefaults
 		/// </summary>
 		public const string DatePickerDropdownIndicator = "\u25BC";
 
+		// Dropdown defaults
+
+		/// <summary>
+		/// Arrow indicator for a closed dropdown (points down).
+		/// Uses small triangle (U+25BE) which is reliably 1-column wide across terminals.
+		/// </summary>
+		public const string DropdownClosedArrow = "\u25BE";
+
+		/// <summary>
+		/// Arrow indicator for an open dropdown (points up).
+		/// Uses small triangle (U+25B4) which is reliably 1-column wide across terminals.
+		/// </summary>
+		public const string DropdownOpenArrow = "\u25B4";
+
+		/// <summary>
+		/// Scroll-up indicator for dropdown portal.
+		/// Uses small triangle (U+25B4) which is reliably 1-column wide across terminals.
+		/// </summary>
+		public const string DropdownScrollUpArrow = "\u25B4";
+
+		/// <summary>
+		/// Scroll-down indicator for dropdown portal.
+		/// Uses small triangle (U+25BE) which is reliably 1-column wide across terminals.
+		/// </summary>
+		public const string DropdownScrollDownArrow = "\u25BE";
+
 		// TimePicker defaults
 
 		/// <summary>

SharpConsoleUI/Controls/DatePickerControl/DatePickerControl.Rendering.cs

@@ -185,16 +185,18 @@ internal void PaintCalendarInternal(CharacterBuffer buffer, LayoutRect bounds, L
 			if (paintY >= clipRect.Y && paintY < clipRect.Bottom)
 			{
 				string monthName = _displayMonth.ToString("MMMM yyyy", _culture);
-				string header = $"  {ControlDefaults.CalendarPrevMonthArrow}  {monthName}";
-				int headerDisplayLen = Parsing.MarkupParser.StripLength(header);
+				var headerBuilder = new System.Text.StringBuilder();
+				headerBuilder.Append("  ").Append(ControlDefaults.CalendarPrevMonthArrow).Append("  ").Append(monthName);
+				int headerDisplayLen = Parsing.MarkupParser.StripLength(headerBuilder.ToString());
 				int arrowRightPos = innerWidth - 3;
 				int padding = Math.Max(0, arrowRightPos - headerDisplayLen);
-				header += new string(' ', padding) + ControlDefaults.CalendarNextMonthArrow + "  ";
+				headerBuilder.Append(' ', padding).Append(ControlDefaults.CalendarNextMonthArrow).Append("  ");
 
 				// Ensure total width
-				int totalLen = Parsing.MarkupParser.StripLength(header);
+				int totalLen = Parsing.MarkupParser.StripLength(headerBuilder.ToString());
 				if (totalLen < innerWidth)
-					header += new string(' ', innerWidth - totalLen);
+					headerBuilder.Append(' ', innerWidth - totalLen);
+				string header = headerBuilder.ToString();
 
 				var headerCells = Parsing.MarkupParser.Parse(header, headerColor, bg);
 				buffer.WriteCellsClipped(startX, paintY, headerCells, clipRect);

SharpConsoleUI/Controls/DropdownControl/DropdownControl.Portal.cs

@@ -6,6 +6,7 @@
 // License: MIT
 // -----------------------------------------------------------------------
 
+using SharpConsoleUI.Configuration;
 using SharpConsoleUI.Drivers;
 using SharpConsoleUI.Helpers;
 using SharpConsoleUI.Layout;
@@ -236,11 +237,13 @@ internal void PaintDropdownListInternal(CharacterBuffer buffer, LayoutRect clipR
 			{
 				if (paintY >= clipRect.Y && paintY < clipRect.Bottom)
 				{
-					string scrollIndicator = (dropdownScroll > 0 ? "▲" : " ");
+					var scrollBuilder = new System.Text.StringBuilder();
+					scrollBuilder.Append(dropdownScroll > 0 ? ControlDefaults.DropdownScrollUpArrow : " ");
 					int scrollPadding = dropdownWidth - 2;
 					if (scrollPadding > 0)
-						scrollIndicator += new string(' ', scrollPadding);
-					scrollIndicator += (dropdownScroll + itemsToShow < items.Count ? "▼" : " ");
+						scrollBuilder.Append(' ', scrollPadding);
+					scrollBuilder.Append(dropdownScroll + itemsToShow < items.Count ? ControlDefaults.DropdownScrollDownArrow : " ");
+					string scrollIndicator = scrollBuilder.ToString();
 
 					var scrollCells = Parsing.MarkupParser.Parse(scrollIndicator, foregroundColor, backgroundColor);
 					buffer.WriteCellsClipped(startX, paintY, scrollCells, clipRect);

SharpConsoleUI/Controls/DropdownControl/DropdownControl.Rendering.cs

@@ -6,6 +6,7 @@
 // License: MIT
 // -----------------------------------------------------------------------
 
+using SharpConsoleUI.Configuration;
 using SharpConsoleUI.Drivers;
 using SharpConsoleUI.Helpers;
 using SharpConsoleUI.Layout;
@@ -22,7 +23,7 @@ public override LayoutSize MeasureDOM(LayoutConstraints constraints)
 			int dropdownWidth = calculateHeaderWidth(constraints.MaxWidth - Margin.Left - Margin.Right);
 
 			// Sane minimum: prompt + arrow + space for at least a few chars
-			string arrow = "▼";
+			string arrow = ControlDefaults.DropdownClosedArrow;
 			int minWidth = Parsing.MarkupParser.StripLength($"{_prompt} {arrow}") + 3;
 			dropdownWidth = Math.Max(dropdownWidth, minWidth);
 
@@ -80,7 +81,7 @@ public override void PaintDOM(CharacterBuffer buffer, LayoutRect bounds, LayoutR
 			int dropdownWidth = calculateHeaderWidth(targetWidth);
 
 			// Sane minimum: prompt + arrow + space for at least a few chars
-			string arrowMin = "▼";
+			string arrowMin = ControlDefaults.DropdownClosedArrow;
 			int minWidth = Parsing.MarkupParser.StripLength($"{_prompt} {arrowMin}") + 3;
 			dropdownWidth = Math.Min(Math.Max(dropdownWidth, minWidth), targetWidth);
 
@@ -114,17 +115,16 @@ public override void PaintDOM(CharacterBuffer buffer, LayoutRect bounds, LayoutR
 
 			// Render header: arrow flush-right, padding between text and arrow
 			string selectedText = selectedIdx >= 0 && selectedIdx < paintSnapshot.Count ? paintSnapshot[selectedIdx].Text : "(None)";
-			string arrow = _isDropdownOpen && _opensUpward ? "▲" : "▼";
-			string suffix = $" {arrow}";
-			int suffixLen = Parsing.MarkupParser.StripLength(suffix);
-			int maxSelectedTextLength = dropdownWidth - promptLength - 1 - suffixLen; // 1 = space after prompt
+			string arrow = _isDropdownOpen && _opensUpward ? ControlDefaults.DropdownOpenArrow : ControlDefaults.DropdownClosedArrow;
+			int arrowDisplayWidth = Parsing.MarkupParser.StripLength(arrow);
+			// Reserve: space + arrow
+			int suffixReserved = 1 + arrowDisplayWidth;
+			int maxSelectedTextLength = dropdownWidth - promptLength - 1 - suffixReserved; // 1 = space after prompt
 			if (maxSelectedTextLength > 0 && Parsing.MarkupParser.StripLength(selectedText) > maxSelectedTextLength)
 				selectedText = TextTruncationHelper.Truncate(selectedText, maxSelectedTextLength);
 
 			string prefix = $"{_prompt} {selectedText}";
 			int prefixLen = Parsing.MarkupParser.StripLength(prefix);
-			int paddingNeeded = Math.Max(0, dropdownWidth - prefixLen - suffixLen);
-			string headerContent = prefix + new string(' ', paddingNeeded) + suffix;
 
 			int paintY = startY;
 
@@ -136,10 +136,28 @@ public override void PaintDOM(CharacterBuffer buffer, LayoutRect bounds, LayoutR
 				if (alignOffset > 0)
 					ControlRenderingHelpers.FillRect(buffer, new LayoutRect(startX, paintY, alignOffset, 1), foregroundColor, windowBackground, preserveBg);
 
-				var cells = Parsing.MarkupParser.Parse(headerContent, foregroundColor, backgroundColor);
-				buffer.WriteCellsClipped(startX + alignOffset, paintY, cells, clipRect);
+				int writeX = startX + alignOffset;
 
-				int rightFillStart = startX + alignOffset + dropdownWidth;
+				// Paint prefix (prompt + selected text)
+				var prefixCells = Parsing.MarkupParser.Parse(prefix, foregroundColor, backgroundColor);
+				buffer.WriteCellsClipped(writeX, paintY, prefixCells, clipRect);
+				writeX += prefixCells.Count;
+
+				// Paint padding between text and arrow
+				int paddingNeeded = Math.Max(0, dropdownWidth - prefixLen - suffixReserved);
+				for (int p = 0; p < paddingNeeded + 1; p++) // +1 for space before arrow
+				{
+					if (writeX >= clipRect.X && writeX < clipRect.Right)
+						buffer.SetNarrowCell(writeX, paintY, ' ', foregroundColor, backgroundColor);
+					writeX++;
+				}
+
+				// Paint arrow via Parse (handles wide chars with continuation cells)
+				var arrowCells = Parsing.MarkupParser.Parse(arrow, foregroundColor, backgroundColor);
+				buffer.WriteCellsClipped(writeX, paintY, arrowCells, clipRect);
+				writeX += arrowCells.Count;
+
+				int rightFillStart = writeX;
 				int rightFillWidth = bounds.Right - rightFillStart - Margin.Right;
 				if (rightFillWidth > 0)
 					ControlRenderingHelpers.FillRect(buffer, new LayoutRect(rightFillStart, paintY, rightFillWidth, 1), foregroundColor, windowBackground, preserveBg);

SharpConsoleUI/Controls/DropdownControl/DropdownControl.cs

@@ -6,6 +6,7 @@
 // License: MIT
 // -----------------------------------------------------------------------
 
+using SharpConsoleUI.Configuration;
 using SharpConsoleUI.Core;
 using SharpConsoleUI.Drivers;
 using SharpConsoleUI.Events;
@@ -643,7 +644,7 @@ private int calculateHeaderWidth(int? availableWidth)
 			}
 
 			// Build header string with longest item and measure exact display width
-			string arrow = "▼"; // use wider of the two arrows for stable measurement
+			string arrow = ControlDefaults.DropdownClosedArrow;
 			string header = $"{_prompt} {longestText} {arrow}";
 			return Parsing.MarkupParser.StripLength(header);
 		}

SharpConsoleUI/Controls/FigleControl.cs

@@ -287,11 +287,12 @@ private static FigletFont LoadEmbeddedFont(string fileName)
 		private static FigletFont CreateFallbackFont()
 		{
 			// Create a trivial 1-height font where each character is just itself
-			var fontData = "flf2a$ 1 1 1 0 0\n";
+			var sb = new System.Text.StringBuilder("flf2a$ 1 1 1 0 0\n");
 			for (int c = 32; c <= 126; c++)
 			{
-				fontData += (char)c + "@@\n";
+				sb.Append((char)c).Append("@@\n");
 			}
+			var fontData = sb.ToString();
 			using var stream = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(fontData));
 			return FigletFont.Load(stream);
 		}

SharpConsoleUI/Controls/ListControl/ListControl.Rendering.cs

@@ -447,7 +447,7 @@ public override void PaintDOM(CharacterBuffer buffer, LayoutRect bounds, LayoutR
 							string iconMarkup = $"[{iconColor.ToMarkup()}]{iconText}[/] ";
 							int iconVisibleLength = GetCachedTextLength(iconText) + 1;
 							itemContent = selectionIndicator + iconMarkup + lineText;
-							int visibleTextLength = selectionIndicator.Length + iconVisibleLength + GetCachedTextLength(lineText);
+							int visibleTextLength = UnicodeWidth.GetStringWidth(selectionIndicator) + iconVisibleLength + GetCachedTextLength(lineText);
 							int paddingNeeded = Math.Max(0, listWidth - visibleTextLength);
 							if (paddingNeeded > 0) itemContent += new string(' ', paddingNeeded);
 						}
@@ -461,7 +461,7 @@ public override void PaintDOM(CharacterBuffer buffer, LayoutRect bounds, LayoutR
 								indent = new string(' ', iconWidth);
 							}
 							itemContent = selectionIndicator + indent + lineText;
-							int visibleTextLength = selectionIndicator.Length + indent.Length + GetCachedTextLength(lineText);
+							int visibleTextLength = UnicodeWidth.GetStringWidth(selectionIndicator) + indent.Length + GetCachedTextLength(lineText);
 							int paddingNeeded = Math.Max(0, listWidth - visibleTextLength);
 							if (paddingNeeded > 0) itemContent += new string(' ', paddingNeeded);
 						}