src/Consolonia.Themes/Modern/Controls/MenuItem.axaml (1)

16-16: Consider adding text variation selector for consistent narrow rendering.

The checkmark character (U+2713) can render as either text-style (narrow) or emoji-style (wide) depending on the terminal. Since this is a menu indicator where space efficiency matters, consider appending the text variation selector (U+FE0E) to ensure consistent single-width rendering: "✓\uFE0E".

This aligns with the PR's goal of using variation selectors to explicitly control character width.

Apply this diff to add the text variation selector:

-                        Value="✓" />
+                        Value="✓︎" />

Alternatively, verify that the automatic emoji detection in Symbol() (mentioned in the PR) handles this character appropriately for the menu context.

src/Consolonia.Gallery/Gallery/GalleryViews/GalleryTextBlock.axaml (1)

51-51: Consider demonstrating explicit variation selectors.

The added line effectively tests automatic emoji variation detection for ambiguous-width symbols. However, since the PR introduces the ability for authors to explicitly control width using variation selectors (U+FE0E for text, U+FE0F for emoji), consider adding additional TextBlock examples that demonstrate this capability.

Apply this diff to add explicit variation selector demonstrations:

 <TextBlock Text="0123456789012345678901234567890" />
+<!-- Testing automatic emoji variation detection -->
 <TextBlock Text="☰X⚙X★X⌂X♫X☀X☕X☎X❄X☠X☷X"/>
+<!-- Forcing text presentation (U+FE0E) -->
+<TextBlock Text="☰︎X⚙︎X★︎X⌂︎X♫︎X☀︎X☕︎X☎︎X❄︎X☠︎X☷︎X"/>
+<!-- Forcing emoji presentation (U+FE0F) -->
+<TextBlock Text="☰️X⚙️X★️X⌂️X♫️X☀️X☕️X☎️X❄️X☠️X☷️X"/>
 <TextBlock Text="𐓏𐓘𐓻𐓘𐓻𐓟 𐒻𐓟, 𝄞, 🎵, 👨‍👩‍👧‍👦,  🏳️‍🌈" />

This would provide a comprehensive demonstration of the variation selector functionality described in the PR objectives.

src/Tests/Consolonia.Gallery.Tests/CheckBoxTests.cs (1)

17-24: Consider tightening the regex patterns.

The change from .+ to .* makes the assertions more lenient by allowing zero characters between the checkbox symbols and labels. While this may accommodate layout changes from variation selectors, .* can match unintended strings and reduce test precision.

Consider using * (zero or more spaces) if the change is to accommodate whitespace variations, or .{1,3} if you expect 1-3 characters, to maintain better test validation.

Also applies to: 30-37

src/Consolonia.Gallery/Gallery/GalleryViews/GalleryIcons.axaml (1)

13-17: Consider a single reusable template or style for separators.

This repeats hundreds of times. Prefer an ItemTemplate with a trailing separator or a Style with a DataTrigger to add a separator element, reducing duplication and future drift.

Also applies to: 19-23, 25-29, 35-40, 41-46, 47-52, 53-58, 59-64, 65-70, 71-76, 77-82, 83-88, 89-94, 95-100, 101-106, 107-112, 113-118, 119-124, 125-130, 131-136, 137-142, 143-148, 149-154, 155-160, 161-166, 167-172, 173-178, 179-184, 185-190, 191-196, 201-206, 207-212, 213-218, 219-224, 225-230, 231-236, 237-242, 243-248, 249-254, 255-260, 261-266, 267-272, 273-278, 279-284, 285-290, 291-296, 297-302, 303-308, 309-314, 315-320, 321-326, 327-332, 333-338, 339-344, 345-350, 351-356, 357-362, 367-372, 373-378, 379-384, 385-390, 391-396, 397-402, 403-408, 409-414, 415-420, 421-426, 427-432, 433-438, 439-450, 451-456, 461-466, 467-472, 473-478, 479-484, 485-490, 491-496, 497-502, 503-508, 509-514, 515-520, 521-526, 527-532, 533-538, 539-544, 545-550, 551-556, 557-562, 563-568, 569-574, 575-580, 581-586, 587-592, 597-602, 603-608, 609-614, 615-620, 621-626, 627-632, 633-638, 639-644, 645-650, 651-656, 657-662, 663-668, 669-674, 675-680, 681-686, 691-696, 697-702, 703-708, 709-714, 715-720, 721-726, 727-732, 733-738, 739-744, 749-754, 755-760, 761-766, 767-772, 773-778, 779-784, 785-790, 791-796, 801-806, 807-812, 813-818, 819-824, 825-830, 831-836, 841-846, 847-852, 853-858, 859-864, 865-870, 871-876, 877-882, 883-888, 889-894, 899-904, 905-910, 911-916, 917-922, 923-928, 929-934, 935-940, 941-946, 947-952, 953-958, 959-964, 965-970, 975-980, 981-986, 987-992, 993-998, 999-1004, 1005-1010, 1011-1016, 1017-1022, 1023-1028, 1029-1034, 1035-1040, 1045-1050, 1051-1056, 1057-1062, 1063-1068, 1069-1074, 1075-1080, 1081-1086, 1087-1092, 1099-1104, 1105-1110, 1111-1116, 1117-1122, 1123-1128, 1129-1134, 1135-1140, 1141-1146, 1147-1152, 1153-1158, 1159-1164, 1165-1168, 1174-1178, 1179-1184, 1185-1190, 1191-1196, 1197-1202, 1203-1208, 1209-1214, 1215-1220, 1221-1226, 1227-1232, 1233-1238, 1239-1244, 1245-1250, 1251-1256, 1257-1262, 1263-1268, 1269-1274, 1275-1280, 1281-1286, 1287-1292, 1293-1298, 1299-1304

src/Tests/Consolonia.Gallery.Tests/RadioButtonTests.cs (1)

26-26: Leftover TODO.

“todo: check why does not react to Space” — track via issue or resolve before merge to avoid stale comments.

src/Consolonia.Core/Drawing/PixelBufferImplementation/PixelBuffer.cs (2)

89-102: Width‑aware traversal is correct; handle carets on zero‑width cells too.

Currently, caret renders only when pixel.Width > 0. If caret lands on a continuation cell (width 0), it won’t draw. Add a fallback branch for pixel.IsCaret() when width ≤ 0.

-                    if (pixel.Width > 0)
+                    if (pixel.Width > 0)
                     {
                         string text = pixel.IsCaret() ? "Ꮖ" : pixel.Foreground.Symbol.GetText();
                         
                         //todo: check why cursor is not drawing
                         stringBuilder.Append(text);
                         i += pixel.Width;
                     }
-                    else
-                        i++;
+                    else
+                    {
+                        if (pixel.IsCaret())
+                        {
+                            stringBuilder.Append("Ꮖ");
+                        }
+                        i++;
+                    }

---

94-97: Replace TODO with tracked issue or actionable comment.

Keeps codebase clean and discoverable.

src/Consolonia.Core/Helpers/UtilityExtensions.cs (1)

107-122: Add combining mark handling (e.g., keycap U+20E3).

Nonspacing/enclosing marks should extend the previous glyph (or current emoji buffer), not form a new glyph.

+                    else if (Rune.GetUnicodeCategory(runes.Current) is
+                             System.Globalization.UnicodeCategory.NonSpacingMark or
+                             System.Globalization.UnicodeCategory.EnclosingMark)
+                    {
+                        if (emoji.Length > 0)
+                            emoji.Append(runes.Current);
+                        else if (glyphs.Count > 0)
+                            glyphs[^1] = glyphs[^1] + runes.Current;
+                        else
+                            glyphs.Add(runes.Current.ToString()); // fallback
+                    }

Add at file top:

+using System.Globalization;

src/Consolonia.Controls/ControlUtils.cs (1)

47-66: Guard against width underflow when subtracting lastWidth.

ushort subtraction can underflow if sequences are malformed/unexpected. Clamp or compute with a signed accumulator.

-                        width -= lastWidth;
+                        width = (ushort)(width > lastWidth ? width - lastWidth : 0);

Alternatively, switch width/lastWidth to int and clamp on return.

src/Consolonia.Core/Drawing/PixelBufferImplementation/Symbol.cs (1)

47-61: Don’t append FE0F to every width-2 character (e.g., CJK). Gate on Emoji only.

FE0F is defined for emoji-presenting code points; adding to generic wide chars is non-standard and bloats Complex.

-            // if we think it should be wide, OR we know it's an emoji 
-            if (Width == 2 || Emoji.IsEmoji(new(ch, 1)))
+            // Only force emoji variation for emoji code points
+            if (Emoji.IsEmoji(new(ch, 1)))
             {
                 // we want to use EmojiVariation to signal we think it's wide.
                 Character = char.MinValue;
                 Width = 2;
-                if (GlyphCharCache.TryGetValue(ch, out var wideChar))
-                {
-                    Complex = wideChar;
-                }
-                else
-                {
-                    Complex = GlyphCharCache[ch] = $"{ch}{EmojiVariation}";
-                }
+                Complex = GlyphCharCache.GetOrAdd(ch, c => $"{c}{EmojiVariation}");
             }

Optional: add a unit test with a CJK char (e.g., "漢") to confirm no FE0F is appended.

src/Tests/Consolonia.Core.Tests/WithLifetimeFixture/GlyphTests.cs (2)

146-161: Assert Complex normalization explicitly and consider CJK negative case.

The FE0F-append assertion is good. Please add a negative test to ensure FE0F is not appended for non-emoji wide chars (e.g., "漢") if you adopt the gating suggested in Symbol(char).

---

175-199: Minor doc nit and an extra assert suggestion.

• Comment says “Mix of emojis with variation selectors” but the test name says “Without Variation Selectors.” Adjust comment for clarity.
• Optional: also assert new Symbol(g).Width to pin width expectations.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Learnt from: jinek
PR: jinek/Consolonia#176
File: src/Consolonia.Themes.TurboVision/Templates/Controls/MenuItem.axaml:131-131
Timestamp: 2024-12-05T18:23:58.201Z
Learning: In the Avalonia UI project, within `src/Consolonia.Themes.TurboVision/Templates/Controls/MenuItem.axaml`, MenuItem controls are intentionally designed without a `:pointerover` state to maintain touch-friendliness and consistency across controls.

Learnt from: jinek
PR: jinek/Consolonia#176
File: src/Consolonia.Themes.TurboVision/Templates/Controls/MenuItem.axaml:131-131
Timestamp: 2024-12-05T18:31:27.161Z
Learning: In `src/Consolonia.Themes.TurboVision/Templates/Controls/MenuItem.axaml`, MenuItem controls do not react to mouse-over events due to performance reasons and simplicity. Touch-screen support is planned for the future.

src/Consolonia.Core/Drawing/PixelBufferImplementation/Symbol.cs (1)

21-26: Do not lock on the dictionary; use a separate lock object and add StringComparer.Ordinal.

Thread safety was partially addressed by adding locks, but locking on the collection itself is problematic (exposes the lock object publicly via the field). Additionally, GlyphComplexCache should specify StringComparer.Ordinal for consistent, culture-invariant string comparison.

Apply this diff to fix both issues:

-        private const char TextVariation = '\ufe0e';
-        private const char EmojiVariation = '\ufe0f';
+        private const char TextVariation = '\ufe0e';
+        private const char EmojiVariation = '\ufe0f';
+        
+        private static readonly object GlyphCharCacheLock = new();
+        private static readonly object GlyphComplexCacheLock = new();

-        private static readonly Dictionary<char, string> GlyphCharCache = new();
-        private static readonly Dictionary<string, string> GlyphComplexCache = new();
+        private static readonly Dictionary<char, string> GlyphCharCache = new();
+        private static readonly Dictionary<string, string> GlyphComplexCache = new(StringComparer.Ordinal);

Then update lock statements:

-                lock (GlyphCharCache)
+                lock (GlyphCharCacheLock)

-                lock (GlyphComplexCache)
+                lock (GlyphComplexCacheLock)

Alternatively, use ConcurrentDictionary with GetOrAdd as suggested in the previous review to avoid explicit locking.

src/Consolonia.Core/Drawing/PixelBufferImplementation/Symbol.cs (2)

95-95: Variable shadowing: lambda parameter hides outer glyph.

The lambda parameter glyph shadows the constructor parameter of the same name, reducing readability.

Rename the lambda parameter:

-                else if (glyph.Any(glyph => glyph == TextVariation || glyph == EmojiVariation))
+                else if (glyph.Any(ch => ch == TextVariation || ch == EmojiVariation))

---

167-169: Optional: simplify Complex check.

Based on constructor logic, Complex is always null or has length ≥ 2. The condition Complex.Length > 1 is defensive but redundant.

You can simplify to:

-            if (Width == 0)
-                return String.Empty;
-            return Complex != null && Complex.Length > 1 ? Complex : new(Character, 1);
+            if (Width == 0)
+                return String.Empty;
+            return Complex ?? new string(Character, 1);

The current code is correct and defensive, so this is purely a style preference.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

src/Consolonia.Core/Drawing/PixelBufferImplementation/Symbol.cs (2)

24-25: Make glyph caches lock‑free and ordinal with ConcurrentDictionary.

Current locking works but adds contention; use GetOrAdd with ordinal comparer.

+using System.Collections.Concurrent;
@@
-        private static readonly Dictionary<char, string> GlyphCharCache = new();
-        private static readonly Dictionary<string, string> GlyphComplexCache = new();
+        private static readonly ConcurrentDictionary<char, string> GlyphCharCache = new();
+        private static readonly ConcurrentDictionary<string, string> GlyphComplexCache = new(StringComparer.Ordinal);
@@
-                lock (GlyphCharCache)
-                {
-                    if (GlyphCharCache.TryGetValue(ch, out var wideChar))
-                    {
-                        Complex = wideChar;
-                    }
-                    else
-                    {
-                        Complex = GlyphCharCache[ch] = $"{ch}{EmojiVariation}";
-                    }
-                }
+                Complex = GlyphCharCache.GetOrAdd(ch, c => $"{c}{EmojiVariation}");
@@
-                    Character = char.MinValue;
-                    lock (GlyphComplexCache)
-                    {
-                        if (GlyphComplexCache.TryGetValue(glyph, out var complex))
-                        {
-                            Complex = complex;
-                        }
-                        else
-                        {
-                            // use text variation for narrow glyphs, emoji variation for wide glyphs
-                            if (Width == 1)
-                                Complex = GlyphComplexCache[glyph] = $"{glyph}{TextVariation}";
-                            else
-                                Complex = GlyphComplexCache[glyph] = $"{glyph}{EmojiVariation}";
-                        }
-                    }
+                    Character = char.MinValue;
+                    var w = Width;
+                    Complex = GlyphComplexCache.GetOrAdd(glyph, g => w == 1 ? $"{g}{TextVariation}" : $"{g}{EmojiVariation}");

Also applies to: 53-63, 104-118

---

86-96: Fix unsafe byte casts of MeasureText() in Symbol.cs and ConsoleCursor.cs; optimize single‑char path.

Casting ushort → byte truncates silently; clamp to byte.MaxValue instead. Also optimize Symbol.cs to skip measuring single-char glyphs.

Symbol.cs (lines 86–96):

-                Width = (byte)glyph.MeasureText();
-
-                if (glyph.Length == 1)
-                {
-                    // we can use the single char constructor for optimization
-                    this = new Symbol(glyph[0]);
-                }
+                if (glyph.Length == 1)
+                {
+                    // fast path: delegate to char ctor and stop
+                    this = new Symbol(glyph[0]);
+                    return;
+                }
+
+                ushort measuredWidth = glyph.MeasureText();
+                Width = measuredWidth > byte.MaxValue ? byte.MaxValue : (byte)measuredWidth;

ConsoleCursor.cs (line 18):

-            Width = (byte)type.MeasureText();
+            ushort measuredWidth = type.MeasureText();
+            Width = measuredWidth > byte.MaxValue ? byte.MaxValue : (byte)measuredWidth;

src/Consolonia.Core/Drawing/PixelBufferImplementation/Symbol.cs (1)

81-81: Use char.MinValue consistently.

Minor style nit for consistency with the rest of the file.

-            Character = Char.MinValue;
+            Character = char.MinValue;

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Learnt from: tomlm
PR: jinek/Consolonia#153
File: src/Consolonia.Core/Controls/DialogWindow.cs:136-141
Timestamp: 2024-11-25T06:18:08.175Z
Learning: In the `DialogWindow` class (`src/Consolonia.Core/Controls/DialogWindow.cs`), casting `Width` and `Height` to `ushort` is intentional and should not be flagged as an issue.

src/Consolonia.Core/Drawing/PixelBufferImplementation/Symbol.cs (2)

22-24: Make static caches thread‑safe and lock‑free with ConcurrentDictionary.

Rendering can construct Symbols on multiple threads. Replace manual locks on Dictionary with ConcurrentDictionary and GetOrAdd; use Ordinal comparer for string keys.

-using System.Collections.Generic;
+using System.Collections.Generic;
+using System.Collections.Concurrent;
@@
-        private static readonly Dictionary<char, string> GlyphCharCache = new();
-        private static readonly Dictionary<string, string> GlyphComplexCache = new();
+        private static readonly ConcurrentDictionary<char, string> GlyphCharCache = new();
+        private static readonly ConcurrentDictionary<string, string> GlyphComplexCache = new(StringComparer.Ordinal);
@@
-                lock (GlyphCharCache)
-                {
-                    if (GlyphCharCache.TryGetValue(ch, out string wideChar))
-                        Complex = wideChar;
-                    else
-                        Complex = GlyphCharCache[ch] = $"{ch}{EmojiVariation}";
-                }
+                Complex = GlyphCharCache.GetOrAdd(ch, c => $"{c}{EmojiVariation}");
@@
-                    lock (GlyphComplexCache)
-                    {
-                        if (GlyphComplexCache.TryGetValue(glyph, out string complex))
-                        {
-                            Complex = complex;
-                        }
-                        else
-                        {
-                            // use text variation for narrow glyphs, emoji variation for wide glyphs
-                            if (Width == 1)
-                                Complex = GlyphComplexCache[glyph] = $"{glyph}{TextVariation}";
-                            else
-                                Complex = GlyphComplexCache[glyph] = $"{glyph}{EmojiVariation}";
-                        }
-                    }
+                    var w = Width; // capture
+                    Complex = GlyphComplexCache.GetOrAdd(glyph, g => w == 1 ? $"{g}{TextVariation}" : $"{g}{EmojiVariation}");

Also applies to: 51-57, 98-112

---

82-82: Clamp MeasureText() (ushort) to byte to avoid truncation.

Casting can silently wrap above 255. Clamp, or consider widening Width to ushort in a future API change.

-                Width = (byte)glyph.MeasureText();
+                ushort measured = glyph.MeasureText();
+                Width = measured > byte.MaxValue ? byte.MaxValue : (byte)measured;

src/Consolonia.Core/Helpers/UtilityExtensions.cs (1)

81-81: Minor: avoid per-rune string allocation.

Cache runes.Current.ToString() once per iteration to reduce allocations on long inputs.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Learnt from: tomlm
PR: jinek/Consolonia#153
File: src/Consolonia.Core/Controls/DialogWindow.cs:136-141
Timestamp: 2024-11-25T06:18:08.175Z
Learning: In the `DialogWindow` class (`src/Consolonia.Core/Controls/DialogWindow.cs`), casting `Width` and `Height` to `ushort` is intentional and should not be flagged as an issue.

src/Consolonia.Core/Dummy/DummyConsole.cs (1)

46-48: Consider returning a default value instead of throwing.

The DummyConsole is used in testing scenarios where code may check the SupportsEmojiVariation capability. Throwing NotImplementedException could cause test failures. Consider returning false (or true if you want to test emoji variation paths) instead.

Apply this diff:

-
-        public bool SupportsEmojiVariation => throw new System.NotImplementedException();
-
+        public bool SupportsEmojiVariation => false;

src/Consolonia.Core/Infrastructure/DefaultNetConsoleOutput.cs (1)

7-7: Remove unused using directive at line 7.

The using Consolonia.Core.Text; import is not referenced anywhere in this file. Remove it to keep the imports clean.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

src/Consolonia.Core/Infrastructure/AnsiConsoleOutput.cs (2)

91-91: Use constructor instead of tuple cast.

The cast syntax (PixelBufferCoordinate)((ushort)0, (ushort)(_headBufferPoint.Y + 1)) is non-idiomatic. Use the new constructor for clarity and consistency with line 88.

Apply this diff:

-    _headBufferPoint = (PixelBufferCoordinate)((ushort)0, (ushort)(_headBufferPoint.Y + 1));
+    _headBufferPoint = new PixelBufferCoordinate((ushort)0, (ushort)(_headBufferPoint.Y + 1));

---

106-106: Use constructor instead of tuple cast.

Same issue as line 91—use the new constructor for consistency.

Apply this diff:

-        bufferPoint = (PixelBufferCoordinate)((ushort)0, (ushort)(bufferPoint.Y + 1));
+        bufferPoint = new PixelBufferCoordinate((ushort)0, (ushort)(bufferPoint.Y + 1));

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

src/Consolonia.Core/Infrastructure/DefaultNetConsoleOutput.cs (1)

118-124: Use Console.Write, not Console.WriteLine, for cursor-delta detection.
WriteLine adds a newline and corrupts the width measurement. Switch to Write.

-            (int left, _) = Console.GetCursorPosition();
-            Console.WriteLine("👨‍👩‍👧‍👦");
-            (int left2, _) = Console.GetCursorPosition();
+            (int left, _) = Console.GetCursorPosition();
+            Console.Write("👨‍👩‍👧‍👦");
+            (int left2, _) = Console.GetCursorPosition();

src/Consolonia.Core/Infrastructure/AnsiConsoleOutput.cs (2)

80-92: Set the caret before writing in the emoji-variation path.
Currently writes at the head position, ignoring bufferPoint. Position first.

-            if (SupportsEmojiVariation)
+            if (SupportsEmojiVariation)
             {
+                SetCaretPosition(bufferPoint);
                 sb.Append(str);
                 sb.Append(Esc.Reset);
 
                 WriteText(sb.ToString());
                 ushort textWidth = str.MeasureText();
-                if (_headBufferPoint.X < Size.Width - textWidth)
+                if (_headBufferPoint.X < Size.Width - textWidth)
                     _headBufferPoint =
                         new PixelBufferCoordinate((ushort)(_headBufferPoint.X + textWidth), _headBufferPoint.Y);
                 else
                     _headBufferPoint = (PixelBufferCoordinate)((ushort)0, (ushort)(_headBufferPoint.Y + 1));
             }

---

95-112: Fix Y-coordinate and remove dead append in per-glyph path.
Use bufferPoint.Y when advancing, not _headBufferPoint.Y. Also remove unused sb.Append(str).

                 WriteText(sb.ToString());
 
                 foreach (string glyph in str.GetGlyphs(SupportsComplexEmoji))
                 {
                     SetCaretPosition(bufferPoint);
                     WriteText(glyph);
                     ushort textWidth = glyph.MeasureText();
                     if (bufferPoint.X < Size.Width - textWidth)
-                        bufferPoint =
-                            new PixelBufferCoordinate((ushort)(bufferPoint.X + textWidth), _headBufferPoint.Y);
+                        bufferPoint =
+                            new PixelBufferCoordinate((ushort)(bufferPoint.X + textWidth), bufferPoint.Y);
                     else
                         bufferPoint = (PixelBufferCoordinate)((ushort)0, (ushort)(bufferPoint.Y + 1));
                 }
 
-                sb.Append(str);
                 WriteText(Esc.Reset);
                 _headBufferPoint = bufferPoint;

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

src/Consolonia.Core/Helpers/UtilityExtensions.cs (1)

80-101: Avoid per‑rune string allocations for Emoji.IsEmoji.

Using rune.ToString() allocates. If NeoSmart.Unicode exposes an overload for Rune or codepoint, use it; otherwise cache ToString() once per iteration.

Example:

- if (Emoji.IsEmoji(runes.Current.ToString()))
+ string current = runes.Current.ToString();
+ if (Emoji.IsEmoji(current))

src/Consolonia.Controls/ControlUtils.cs (1)

66-72: Modifiers/keycap extender branch: remove dead comment or normalize behavior.

This branch intentionally does nothing (continue current glyph). Replace comment with a single clarifying line to avoid confusion.

-                    {
-                        // Emoji modifier (skin tone) or keycap extender should continue current glyph
-
-                        // else: combining — ignore
-                    }
+                    {
+                        // Emoji modifier or keycap extender: no width change; continues prior glyph.
+                    }

src/Consolonia.Core/Infrastructure/AnsiConsoleOutput.cs (1)

127-148: Variation capability probe: clarify test char and tighten check.

Consider probing with a base that defaults to text (e.g., “⚙”) to ensure FE0F actually widens. Current “🗑\uFE0F” might already default to emoji on some consoles.

-            // write out a char with wide variation selector
-            WriteText($"🗑\ufe0f");
+            // probe FE0F effect using a text-default emoji-capable base
+            WriteText($"⚙\ufe0f");

If you keep “🗑\uFE0F”, please verify left3-left2==2 on your target consoles.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

src/Consolonia.Core/Dummy/DummyConsole.cs (1)

1-1: Potentially unused using directive.

The using System; directive appears unused since no System types are referenced in this file. Consider removing it to keep imports clean.

-using System;
-
 using Avalonia.Media;

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

src/Consolonia.Core/Infrastructure/AnsiConsoleOutput.cs (2)

86-90: Critical: bufferPoint is never advanced in the SupportsEmojiVariation branch.

When SupportsEmojiVariation is true, the code writes text at bufferPoint but never updates bufferPoint to reflect the new cursor position. This causes the subsequent _headBufferPoint update (lines 111-115) to use stale data, resulting in incorrect cursor tracking.

Apply this diff:

             if (SupportsEmojiVariation)
             {
                 SetCaretPosition(bufferPoint);
                 WriteText(str);
+                bufferPoint = new PixelBufferCoordinate((ushort)(bufferPoint.X + textWidth), bufferPoint.Y);
             }

---

96-100: Critical: Use glyphWidth instead of textWidth for clearing.

Line 99 uses textWidth (the width of the entire string) instead of glyphWidth (the width of the current glyph). This causes the code to clear far more space than necessary for each wide glyph, potentially erasing content beyond the current glyph's bounds.

Apply this diff:

                 if (glyphWidth > 1)
                 {
                     WriteText(Esc.SetCursorPosition(bufferPoint.X, bufferPoint.Y));
-                    WriteText(new string(' ', textWidth));
+                    WriteText(new string(' ', glyphWidth));
                 }

src/Consolonia.Controls/ControlUtils.cs (1)

40-45: Gate FE0E/FE0F width toggles to valid bases (emoji or keycap) and track last rune.

Currently, any prior width-1 rune plus FE0F becomes width 2 (e.g., "x\uFE0F"), which diverges from real terminals. Only toggle width when the preceding rune is an emoji or a keycap base; track lastRune and add a simple keycap-base check. Also update lastRune each iteration.

Apply within this method:

@@
-            ushort width = 0;
-            ushort lastWidth = 0;
+            ushort width = 0;
+            ushort lastWidth = 0;
+            var lastRune = new Rune();
@@
-                    else if (rune.Value == Codepoints.VariationSelectors.EmojiSymbol &&
-                             lastWidth == 1)
+                    else if (rune.Value == Codepoints.VariationSelectors.EmojiSymbol &&
+                             lastWidth == 1 &&
+                             (Emoji.IsEmoji(lastRune.ToString()) || IsKeycapBase(lastRune.Value)))
                     {
                         // adjust for the emoji presentation, which is width 2
                         width++;
                         lastWidth = 2;
                     }
-                    else if (rune.Value == Codepoints.VariationSelectors.TextSymbol &&
-                             lastWidth == 2)
+                    else if (rune.Value == Codepoints.VariationSelectors.TextSymbol &&
+                             lastWidth == 2 &&
+                             (Emoji.IsEmoji(lastRune.ToString()) || IsKeycapBase(lastRune.Value)))
                     {
                         // adjust for the text presentation, which is width 1
                         width--;
                         lastWidth = 1;
                     }
@@
-                    if (runeWidth > 0) lastWidth = (ushort)runeWidth;
+                    if (runeWidth > 0) lastWidth = (ushort)runeWidth;
+                    // track previous rune for variation gating
+                    lastRune = rune;

Add this local helper near the end of the method (before return width;):

static bool IsKeycapBase(int v) => (v >= '0' && v <= '9') || v == '#' || v == '*';

Also applies to: 52-65, 79-79

src/Consolonia.Core/Helpers/UtilityExtensions.cs (1)

81-101: Flags are split: treat Regional Indicator pairs as a single glyph.

Second consecutive RI (U+1F1E6–U+1F1FF) should continue the current flag glyph; today it flushes, producing two glyphs (e.g., "🇺🇸").

Apply inside the Emoji.IsEmoji(...) branch:

-                    if (Emoji.IsEmoji(runes.Current.ToString()))
+                    if (Emoji.IsEmoji(runes.Current.ToString()))
                     {
-                        if (lastRune.Value == Codepoints.ZWJ ||
-                            lastRune.Value == Codepoints.ORC)
+                        // Regional Indicator pair: continue current glyph
+                        if (lastRune.Value >= 0x1F1E6 && lastRune.Value <= 0x1F1FF &&
+                            runes.Current.Value >= 0x1F1E6 && runes.Current.Value <= 0x1F1FF)
+                        {
+                            emoji.Append(runes.Current);
+                        }
+                        else if (lastRune.Value == Codepoints.ZWJ ||
+                                 lastRune.Value == Codepoints.ORC)
                         {
                             // the last char was a joiner or object replacement, so we continue building the emoji
                             emoji.Append(runes.Current);
                         }
                         else
                         {
                             // we have a new emoji starting, so we flush any existing emoji buffer
                             // ending the previous glyph and starting a new one
                             if (emoji.Length > 0)
                             {
                                 glyphs.Add(emoji.ToString());
                                 emoji.Clear();
                             }
 
                             emoji.Append(runes.Current);
                         }
                     }

Please add tests for flags: "🇺🇸", "🇩🇪", text+flag mixtures; verify each is a single glyph and width 2.

src/Consolonia.Core/Helpers/UtilityExtensions.cs (1)

106-118: Minor: use glyphs[^1] consistently for clarity.

Replace glyphs[glyphs.Count - 1] with glyphs[^1] to match existing usage above and reduce verbosity.

Example:

-else if (glyphs.Count > 0) glyphs[^1] = glyphs[^1] + runes.Current;
+else if (glyphs.Count > 0) glyphs[^1] = glyphs[^1] + runes.Current;
@@
-                            string lastGlyph = glyphs[glyphs.Count - 1];
-                            glyphs[glyphs.Count - 1] = lastGlyph + runes.Current;
+                            glyphs[^1] = glyphs[^1] + runes.Current;

Also applies to: 129-134

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

src/Consolonia.Core/Text/TextShaper.cs (3)

15-39: Harden glyph caches: overflow guard and dedicated lock.

• Casting GlyphByIndex.Count to ushort will overflow ≥ 65536 unique glyphs.
• Locking on a mutable dictionary is brittle; use a private sync object shared by both maps.
• Make GetGlyphByIndex lock consistently and give a clearer error.

@@
-        private static readonly Dictionary<ushort, string> GlyphByIndex = new();
-        private static readonly Dictionary<string, ushort> IndexByGlyph = new();
+        private static readonly object GlyphCacheSync = new();
+        private static readonly Dictionary<ushort, string> GlyphByIndex = new();
+        private static readonly Dictionary<string, ushort> IndexByGlyph = new();
@@
-                lock (IndexByGlyph)
+                lock (GlyphCacheSync)
                 {
                     if (!IndexByGlyph.TryGetValue(glyph, out glyphIndex))
                     {
-                        glyphIndex = (ushort)GlyphByIndex.Count;
+                        if (GlyphByIndex.Count >= ushort.MaxValue)
+                            throw new InvalidOperationException("Glyph cache exhausted (≥ 65536 unique glyphs).");
+                        glyphIndex = (ushort)GlyphByIndex.Count;
                         GlyphByIndex[glyphIndex] = glyph;
                         IndexByGlyph[glyph] = glyphIndex;
                     }
                 }

Optional non-throwing API:

public static bool TryGetGlyphByIndex(ushort glyphIndex, out string glyph)
{
    lock (GlyphCacheSync) return GlyphByIndex.TryGetValue(glyphIndex, out glyph);
}

---

27-44: Use int loop index and explicit GlyphInfo argument types.

ushort i can wrap for large inputs; cast args to match Avalonia’s signature.

-            for (ushort i = 0; i < shapedBuffer.Length; i++)
+            for (int i = 0; i < shapedBuffer.Length; i++)
             {
                 string glyph = glyphs[i];
                 ushort glyphIndex;
-                lock (IndexByGlyph)
+                lock (IndexByGlyph)
                 {
                     if (!IndexByGlyph.TryGetValue(glyph, out glyphIndex))
                     {
                         glyphIndex = (ushort)GlyphByIndex.Count;
                         GlyphByIndex[glyphIndex] = glyph;
                         IndexByGlyph[glyph] = glyphIndex;
                     }
                 }
 
                 // NOTE: We are using the placeholder glyph since we are pushing
                 // raw text to the console and not using a font system to render the text
-                shapedBuffer[i] = new GlyphInfo(glyphIndex, i, glyph.MeasureText());
+                shapedBuffer[i] = new GlyphInfo(glyphIndex, i, (double)glyph.MeasureText());
             }

---

49-55: Lock the same sync as writers and fail clearly on miss.

-        public static string GetGlyphByIndex(ushort glyphIndex)
+        public static string GetGlyphByIndex(ushort glyphIndex)
         {
-            lock (IndexByGlyph)
+            lock (GlyphCacheSync)
             {
-                return GlyphByIndex[glyphIndex];
+                if (!GlyphByIndex.TryGetValue(glyphIndex, out var glyph))
+                    throw new KeyNotFoundException($"Glyph index {glyphIndex} not found in cache.");
+                return glyph;
             }
         }

src/Consolonia.Core/Infrastructure/AnsiConsoleOutput.cs (1)

83-118: Caret/head desync and over‑clear cause artifacts; advance bufferPoint and only clear trailing cell(s).

• Variation branch doesn’t advance bufferPoint; final head uses stale _headBufferPoint.
• Wide-glyph path clears glyphWidth spaces; should clear glyphWidth - 1 at X+1.

             ushort textWidth = str.MeasureText();
@@
-            // move to position
+            // write at requested position
             if (SupportsEmojiVariation)
             {
                 SetCaretPosition(bufferPoint);
                 WriteText(str);
+                bufferPoint = new PixelBufferCoordinate((ushort)(bufferPoint.X + textWidth), bufferPoint.Y);
             }
             else
             {
                 // rendering over the top with the glyph.
                 // process each glyph, rendering the width as spaces then moving the cursor and
                 foreach (string glyph in str.GetGlyphs(SupportsComplexEmoji))
                 {
                     ushort glyphWidth = glyph.MeasureText();
                     if (glyphWidth > 1)
                     {
-                        WriteText(Esc.SetCursorPosition(bufferPoint.X, bufferPoint.Y));
-                        WriteText(new string(' ', (int)Math.Min(Size.Width - bufferPoint.X, bufferPoint.X + glyphWidth)));
+                        // clear only trailing cell(s) of this wide glyph
+                        WriteText(Esc.SetCursorPosition(bufferPoint.X + 1, bufferPoint.Y));
+                        WriteText(new string(' ', Math.Min(glyphWidth - 1, Size.Width - (bufferPoint.X + 1))));
                     }
 
                     WriteText(Esc.SetCursorPosition(bufferPoint.X, bufferPoint.Y));
                     WriteText(glyph);
 
                     bufferPoint =
                         new PixelBufferCoordinate((ushort)(bufferPoint.X + glyphWidth), bufferPoint.Y);
                 }
             }
 
             WriteText(Esc.Reset);
-            if (_headBufferPoint.X < Size.Width - textWidth)
-                _headBufferPoint =
-                    new PixelBufferCoordinate((ushort)(_headBufferPoint.X + textWidth), _headBufferPoint.Y);
-            else
-                _headBufferPoint = (PixelBufferCoordinate)((ushort)0, (ushort)(_headBufferPoint.Y + 1));
+            _headBufferPoint = bufferPoint;

src/Consolonia.Controls/ControlUtils.cs (2)

60-73: Gate FE0E/FE0F width changes to valid bases (emoji or keycap).

Currently “x\uFE0F” becomes width 2. Limit variation-based width flips to emoji or keycap bases; track last rune.

@@
-            ushort width = 0;
-            ushort lastWidth = 0;
+            ushort width = 0;
+            ushort lastWidth = 0;
+            var lastRune = new Rune();
@@
-                    else if (rune.Value == Codepoints.VariationSelectors.EmojiSymbol &&
-                             lastWidth == 1)
+                    else if (rune.Value == Codepoints.VariationSelectors.EmojiSymbol &&
+                             lastWidth == 1 &&
+                             (Emoji.IsEmoji(lastRune.ToString()) || IsKeycapBase(lastRune.Value)))
                     {
                         // adjust for the emoji presentation, which is width 2
                         width++;
                         lastWidth = 2;
                     }
-                    else if (rune.Value == Codepoints.VariationSelectors.TextSymbol &&
-                             lastWidth == 2)
+                    else if (rune.Value == Codepoints.VariationSelectors.TextSymbol &&
+                             lastWidth == 2 &&
+                             (Emoji.IsEmoji(lastRune.ToString()) || IsKeycapBase(lastRune.Value)))
                     {
                         // adjust for the text presentation, which is width 1
                         width--;
                         lastWidth = 1;
                     }
@@
-                    if (runeWidth > 0) lastWidth = (ushort)runeWidth;
+                    if (runeWidth > 0) lastWidth = (ushort)runeWidth;
+                    // update lastRune at end of iteration
+                    lastRune = rune;
                 }
@@
             }
 
+            static bool IsKeycapBase(int v) => (v >= '0' && v <= '9') || v == '#' || v == '*';

---

82-95: Fix Regional Indicator (RI) accounting: handle odd singles and reset on exit.

Odd/lone RI is dropped; RI parity leaks across non‑RI. Add reset when leaving RI and account pending odd at EoS.

@@
-                    else if (rune.Value >= 0x1F1E6 && rune.Value <= 0x1F1FF)
+                    else if (rune.Value >= 0x1F1E6 && rune.Value <= 0x1F1FF)
                     {
                         regionalRuneCount++;
                         if (regionalRuneCount % 2 == 0)
                             // every pair of regional indicator symbols form a single glyph
                             width += (ushort)runeWidth;
                         // If the last rune is a regional indicator symbol, continue the current glyph
                     }
                     else
                     {
+                        // leaving RI run: if we had a pending single RI, count it now
+                        if ((regionalRuneCount % 2) == 1)
+                        {
+                            // RI width is 2 as emoji; fall back to Unicode width if needed
+                            int pending = Emoji.IsEmoji("🇦") ? 2 : runeWidth; // placeholder; RI is wide on our path
+                            if (pending > 0) width += (ushort)pending;
+                            regionalRuneCount = 0;
+                        }
                         width += (ushort)runeWidth;
+                        regionalRuneCount = 0;
                     }
@@
-            return width;
+            // End-of-string: pending single RI
+            if ((regionalRuneCount % 2) == 1)
+            {
+                // Use RI width as 2 (emoji presentation)
+                width += 2;
+            }
+            return width;

Also applies to: 111-111

src/Consolonia.Core/Helpers/UtilityExtensions.cs (1)

166-175: Reset RI state when leaving RI sequences.

Parity leaks across plain text. Reset here to avoid pairing across non‑adjacent runs.

                 else
                 {
                     if (emoji.Length > 0)
                     {
                         glyphs.Add(emoji.ToString());
                         emoji.Clear();
                     }
-
+                    regionalRuneCount = 0;
                     glyphs.Add(runes.Current.ToString());
                 }

src/Consolonia.Controls/ControlUtils.cs (1)

45-45: Avoid per‑rune string allocs in hot path.

Emoji.IsEmoji(rune.ToString()) allocates each iteration. Consider a cached set/range check or a span-friendly helper to cut allocations.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

src/Consolonia.Core/Infrastructure/AnsiConsoleOutput.cs (1)

86-90: Critical: bufferPoint must be advanced after writing text.

The SupportsEmojiVariation=true path writes the string but never advances bufferPoint. This causes _headBufferPoint tracking to break because the final update logic (lines 113-117) relies on either an advanced bufferPoint or the previous _headBufferPoint state, leading to incorrect cursor positioning after this method returns.

Apply this diff to advance bufferPoint after writing:

 if (SupportsEmojiVariation)
 {
     SetCaretPosition(bufferPoint);
     WriteText(str);
+    bufferPoint = new PixelBufferCoordinate((ushort)(bufferPoint.X + textWidth), bufferPoint.Y);
 }

src/Consolonia.Core/Infrastructure/AnsiConsoleOutput.cs (1)

147-150: Consider testing variation selector handling more explicitly.

The current test writes "🗑" and checks if the cursor advances by 2 positions. However, to truly verify variation selector support, consider testing a character that changes width based on the variation selector. For example:

-// write out a char with wide variation selector
-WriteText("🗑");
+// Test variation selector: ☺ defaults to text (width 1), ☺️ (with FE0F) is emoji (width 2)
+WriteText("☺\uFE0F");
 (int left3, _) = Console.GetCursorPosition();
 _supportsEmojiVariation = left3 - left2 == 2;

This would more accurately detect whether the terminal respects variation selectors to control text vs. emoji presentation.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

src/Consolonia.Core/Text/TextShaper.cs (4)

43-43: Type clarity: Add explicit casts for GlyphInfo constructor.

According to previous analysis, GlyphInfo expects (ushort GlyphIndex, int GlyphCluster, double GlyphAdvance), but the call passes ushort for all three arguments, relying on implicit conversions. While valid, explicit casts improve clarity and intent.

Apply this diff for explicit type conversions:

-                shapedBuffer[i] = new GlyphInfo(glyphIndex, i, glyph.MeasureText());
+                shapedBuffer[i] = new GlyphInfo(glyphIndex, (int)i, (double)glyph.MeasureText());

Note: If you fix the loop index to int (line 27), then only the third argument needs casting:

-                shapedBuffer[i] = new GlyphInfo(glyphIndex, i, (double)glyph.MeasureText());
+                shapedBuffer[i] = new GlyphInfo(glyphIndex, i, (double)glyph.MeasureText());

---

49-55: Improve error handling in GetGlyphByIndex.

The method now uses the correct lock (GlyphCacheSync), but still uses direct dictionary indexing that will throw KeyNotFoundException without context. Previous review suggested using TryGetValue with a clearer error message or adding a non-throwing TryGetGlyphByIndex API.

Apply this diff to improve error handling:

         public static string GetGlyphByIndex(ushort glyphIndex)
         {
             lock (GlyphCacheSync)
             {
-                return GlyphByIndex[glyphIndex];
+                if (!GlyphByIndex.TryGetValue(glyphIndex, out var glyph))
+                    throw new KeyNotFoundException($"Glyph index {glyphIndex} not found in cache.");
+                return glyph;
             }
         }

Optionally, add a non-throwing API for safer access:

public static bool TryGetGlyphByIndex(ushort glyphIndex, out string glyph)
{
    lock (GlyphCacheSync) 
        return GlyphByIndex.TryGetValue(glyphIndex, out glyph);
}

---

27-28: Critical: ushort loop index will wrap and hang for long inputs.

The loop index i declared as ushort will wrap at 65535 and spin indefinitely when shapedBuffer.Length >= 65536. This was flagged previously but remains unfixed.

Apply this diff to fix:

-            for (ushort i = 0; i < shapedBuffer.Length; i++)
+            for (int i = 0; i < shapedBuffer.Length; i++)

---

35-38: Critical: Guard against cache overflow.

Casting GlyphByIndex.Count to ushort without checking will overflow at 65536 unique glyphs, corrupting the cache mappings. This was previously flagged as needing an overflow guard but remains unfixed.

Apply this diff to add an overflow check:

                     if (!IndexByGlyph.TryGetValue(glyph, out glyphIndex))
                     {
+                        if (GlyphByIndex.Count >= ushort.MaxValue)
+                            throw new InvalidOperationException("Glyph cache exhausted (≥ 65536 unique glyphs).");
                         glyphIndex = (ushort)GlyphByIndex.Count;
                         GlyphByIndex[glyphIndex] = glyph;
                         IndexByGlyph[glyph] = glyphIndex;

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

src/Consolonia.Core/Infrastructure/AnsiConsoleOutput.cs (1)

94-95: Polish the comment for clarity.

The comment ends abruptly with "and", making it feel incomplete. Consider revising for better readability.

Apply this diff to clarify the comment:

-                // rendering over the top with the glyph.
-                // process each glyph, rendering the width as spaces then moving the cursor and
+                // Process each glyph individually: for wide glyphs, clear trailing cells with spaces
+                // to prevent artifacts, then position the cursor and render the glyph.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

src/Consolonia.Core/Infrastructure/AnsiConsoleOutput.cs (1)

85-85: Optional: Clarify comments for maintainability.

The comment on line 85 ("move to position") describes only the SupportsEmojiVariation branch, not the overall structure. The comment on lines 94-95 ends mid-sentence ("moving the cursor and"). While the code is clear, more precise comments would aid future maintenance.

Consider:

-            // move to position
+            // Render text using terminal's native emoji support
             if (SupportsEmojiVariation)

-                // rendering over the top with the glyph.
-                // process each glyph, rendering the width as spaces then moving the cursor and
+                // Fallback: manually render each glyph with explicit space-clearing for wide characters
+                // to work around terminals that don't advance cursor correctly for emoji

Also applies to: 94-95

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro