fix: non-ASCII Discord names render as boxes in test-connection status

User reported their test-connection label showed "Connected as □□□□□"
where their actual Discord name has non-ASCII characters. Three
layered fixes, all in the same v0.1.9 release (commit goes on top of
f3df6a1, no tag yet).

PRIMARY (the user-visible fix):
  SettingsPanel labels that display user-supplied strings now render
  via GDI / Uniscribe instead of GDI+ / Graphics.DrawString. GDI does
  proper Unicode font fallback — when a glyph isn't in the declared
  font (Segoe UI), Windows falls back through Microsoft YaHei (CJK),
  Segoe UI Symbol, Segoe UI Emoji, etc. GDI+ has no fallback chain
  and renders missing glyphs as tofu boxes (□).

  Applied to four labels that show user data: _testStatusLabel,
  _currentCharLabel, _uploadStatusLabel, _captureLabel — via a small
  EnableUnicodeFontFallback() helper that sets
  UseCompatibleTextRendering = false.

  Application.SetCompatibleTextRenderingDefault is the process-wide
  switch but ACT owns that — we can only set this per-label.

DEFENSIVE — UTF-8 decoding:
  HttpContent.ReadAsStringAsync on .NET Framework 4.8 has a
  long-standing charset-fallback issue when the server omits
  charset=utf-8 in Content-Type. FastAPI's JSONResponse intentionally
  omits it (RFC 8259 mandates UTF-8 for application/json), which hits
  the fallback. Replaced with ReadAsByteArrayAsync + explicit
  Encoding.UTF8.GetString in a new ReadBodyUtf8Async helper. Same
  result on every framework version.
  dotnet/runtime#28658

DEFENSIVE — JSON escape handling:
  ExtractJsonString's escape branch took the NEXT char literally
  rather than decoding it. \uXXXX therefore became the literal text
  "uXXXX", \n became literal "n", etc. FastAPI's ensure_ascii=False
  means we don't hit this in production today, but any other JSON
  producer (or a server config change) would silently bite. Now
  handles every escape from RFC 8259 § 7:
    \" \ \/ \b \f \n \r \t \uXXXX

  Explicit hex-digit validation on \uXXXX — caught in test that
  NumberStyles.HexNumber tolerates trailing whitespace, so "\u4f6 bar"
  would otherwise have silently parsed as U+04F6 (Cyrillic Komi Gha)
  instead of returning null for the malformed input.

6 new tests in UploadClientTests pinning every escape and the
real-world raw-UTF-8 happy path. Total 131/131.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: VortexUK

src/Core/UploadClient.cs

@@ -116,7 +116,7 @@ public async Task<Result> TestConnectionAsync(string serverUrl, string apiToken)
                 {
                     using (var resp = await _http.SendAsync(req).ConfigureAwait(false))
                     {
-                        var body = await resp.Content.ReadAsStringAsync().ConfigureAwait(false);
+                        var body = await ReadBodyUtf8Async(resp.Content).ConfigureAwait(false);
                         if (!resp.IsSuccessStatusCode)
                         {
                             return new Result
@@ -212,7 +212,7 @@ public async Task<Result> UploadEncounterAsync(string serverUrl, string apiToken
                 {
                     using (var resp = await _http.SendAsync(req).ConfigureAwait(false))
                     {
-                        var body = await resp.Content.ReadAsStringAsync().ConfigureAwait(false);
+                        var body = await ReadBodyUtf8Async(resp.Content).ConfigureAwait(false);
                         if (!resp.IsSuccessStatusCode)
                         {
                             // Pull a friendly error out of FastAPI's {"detail": "..."} shape if present.
@@ -258,6 +258,13 @@ public async Task<Result> UploadEncounterAsync(string serverUrl, string apiToken
         // -------------------------------------------------------------------
         // Tiny JSON string-field extractor — avoids pulling in a full JSON
         // parser just for one field. NOT a general-purpose JSON parser.
+        //
+        // Handles all the escape sequences defined in RFC 8259 § 7:
+        //   \" \\ \/ \b \f \n \r \t \uXXXX
+        // The \uXXXX path is the one that matters for non-ASCII Discord
+        // names if a server is ever configured with ensure_ascii=True —
+        // without it, "discord_name": "你好" came out as the
+        // literal text "u4f60u597d" in the test-connection label.
         // -------------------------------------------------------------------
 
         internal static string? ExtractJsonString(string json, string fieldName)
@@ -276,18 +283,86 @@ public async Task<Result> UploadEncounterAsync(string serverUrl, string apiToken
             for (int i = start; i < json.Length; i++)
             {
                 char ch = json[i];
-                if (ch == '\\' && i + 1 < json.Length)
+                if (ch == '"') return sb.ToString();
+                if (ch != '\\')
                 {
-                    sb.Append(json[i + 1]);
-                    i++;
+                    sb.Append(ch);
                     continue;
                 }
-                if (ch == '"') return sb.ToString();
-                sb.Append(ch);
+                // Escape sequence — need at least one more char.
+                if (i + 1 >= json.Length) return null;
+                char esc = json[i + 1];
+                switch (esc)
+                {
+                    case '"': sb.Append('"'); i++; break;
+                    case '\\': sb.Append('\\'); i++; break;
+                    case '/': sb.Append('/'); i++; break;
+                    case 'b': sb.Append('\b'); i++; break;
+                    case 'f': sb.Append('\f'); i++; break;
+                    case 'n': sb.Append('\n'); i++; break;
+                    case 'r': sb.Append('\r'); i++; break;
+                    case 't': sb.Append('\t'); i++; break;
+                    case 'u':
+                        // \uXXXX — 4 hex digits → 1 char. Surrogate
+                        // pairs (e.g. emoji) come as two \uXXXX in
+                        // sequence; we just emit each char, and
+                        // System.String stores them correctly as a
+                        // UTF-16 surrogate pair.
+                        //
+                        // Validate each char is a real hex digit before
+                        // TryParse — NumberStyles.HexNumber tolerates
+                        // leading/trailing whitespace which would make
+                        // "\u4f6 bar" silently parse as U+04F6.
+                        if (i + 5 >= json.Length) return null;
+                        for (int h = i + 2; h < i + 6; h++)
+                        {
+                            char hc = json[h];
+                            if (!((hc >= '0' && hc <= '9')
+                                || (hc >= 'a' && hc <= 'f')
+                                || (hc >= 'A' && hc <= 'F')))
+                            {
+                                return null;
+                            }
+                        }
+                        var hex = json.Substring(i + 2, 4);
+                        if (!ushort.TryParse(hex, System.Globalization.NumberStyles.HexNumber,
+                                System.Globalization.CultureInfo.InvariantCulture, out var code))
+                        {
+                            return null;
+                        }
+                        sb.Append((char)code);
+                        i += 5;
+                        break;
+                    default:
+                        // Unknown escape — preserve the backslash so the
+                        // user at least sees something they can report.
+                        sb.Append('\\');
+                        sb.Append(esc);
+                        i++;
+                        break;
+                }
             }
             return null;
         }
 
+        // -------------------------------------------------------------------
+        // .NET Framework's HttpContent.ReadAsStringAsync has a long-standing
+        // charset-fallback issue when Content-Type lacks a charset directive.
+        // FastAPI's JSONResponse intentionally omits the charset (the body
+        // is always UTF-8 per RFC 8259), which hits the fallback path on
+        // 4.8 and can mis-decode non-ASCII names. Read bytes + decode
+        // explicitly as UTF-8 — same result on every framework version.
+        //   https://github.com/dotnet/runtime/issues/28658
+        // -------------------------------------------------------------------
+
+        internal static async Task<string> ReadBodyUtf8Async(HttpContent content)
+        {
+            if (content == null) return "";
+            var bytes = await content.ReadAsByteArrayAsync().ConfigureAwait(false);
+            if (bytes == null || bytes.Length == 0) return "";
+            return Encoding.UTF8.GetString(bytes);
+        }
+
         internal static string Truncate(string s, int max)
         {
             if (string.IsNullOrEmpty(s)) return "";

src/SettingsPanel.cs

@@ -230,6 +230,7 @@ public SettingsPanel(PluginConfig config, Action<PluginConfig> onSave, UploadCli
                 Text = "",
                 MaximumSize = new Size(InputWidth - 240, 0),
             };
+            EnableUnicodeFontFallback(_testStatusLabel);
             cfgButtons.Controls.Add(_testStatusLabel);
             cfgCard.Controls.Add(cfgButtons);
 
@@ -246,6 +247,7 @@ public SettingsPanel(PluginConfig config, Action<PluginConfig> onSave, UploadCli
                 Margin = new Padding(0, 0, 0, 10),
                 Text = "",
             };
+            EnableUnicodeFontFallback(_currentCharLabel);
             logCard.Controls.Add(_currentCharLabel);
 
             logCard.Controls.Add(MakeFieldLabel("Don't upload as"));
@@ -280,6 +282,7 @@ public SettingsPanel(PluginConfig config, Action<PluginConfig> onSave, UploadCli
                 BackColor = T.Card,
                 Margin = new Padding(0, 0, 0, 10),
             };
+            EnableUnicodeFontFallback(_captureLabel);
             capCard.Controls.Add(_captureLabel);
 
             var capButtons = new FlowLayoutPanel
@@ -306,6 +309,7 @@ public SettingsPanel(PluginConfig config, Action<PluginConfig> onSave, UploadCli
                 BackColor = T.Card,
                 Text = "",
             };
+            EnableUnicodeFontFallback(_uploadStatusLabel);
             capCard.Controls.Add(_uploadStatusLabel);
 
             Controls.Add(stack);
@@ -575,6 +579,25 @@ private void UpdateCurrentCharLabel()
             }
         }
 
+        /// <summary>
+        /// Force the label to render via GDI (TextRenderer / Uniscribe)
+        /// instead of GDI+ (Graphics.DrawString). GDI does proper Unicode
+        /// font fallback through Uniscribe — when a glyph isn't in the
+        /// declared font (Segoe UI), Windows automatically substitutes
+        /// from Microsoft YaHei (CJK), Segoe UI Symbol, Segoe UI Emoji,
+        /// etc. GDI+ doesn't fall back and renders missing glyphs as
+        /// tofu boxes (□). Apply to any label that displays user-supplied
+        /// strings (Discord names, encounter titles, character names).
+        ///
+        /// Application.SetCompatibleTextRenderingDefault is the
+        /// process-wide knob but ACT owns that — we can only set this
+        /// per-label.
+        /// </summary>
+        private static void EnableUnicodeFontFallback(Label label)
+        {
+            label.UseCompatibleTextRendering = false;
+        }
+
         // ──────────────────────────────────────────────────────────────────
         // Builders — themed widget factories
         // ──────────────────────────────────────────────────────────────────

tests/EQ2Lexicon.ACTPlugin.Tests/UploadClientTests.cs

@@ -122,6 +122,74 @@ public void ExtractJsonString_HandlesEscapedQuote()
             Assert.Equal("He said \"hi\" loudly", got);
         }
 
+        // ── JSON escape sequences (RFC 8259 § 7) ───────────────────────────
+        // FastAPI's JSONResponse emits raw UTF-8 (ensure_ascii=False) so
+        // \uXXXX escapes don't show up in practice today, but any other
+        // JSON producer (or a config change) would emit them — and the
+        // pre-v0.1.9 extractor turned "你" into the literal text
+        // "u4f60", which is how the non-ASCII Discord name rendered as
+        // boxes in the test-connection label. Pin every escape RFC 8259
+        // defines so a regression here can't slip through silently.
+
+        [Fact]
+        public void ExtractJsonString_HandlesAllStandardEscapes()
+        {
+            // \\ \/ \b \f \n \r \t — order matches the RFC table.
+            var body = "{\"detail\":\"a\\\\b\\/c\\bd\\fe\\nf\\rg\\th\"}";
+            Assert.Equal("a\\b/c\bd\fe\nf\rg\th", UploadClient.ExtractJsonString(body, "detail"));
+        }
+
+        [Fact]
+        public void ExtractJsonString_HandlesUnicodeEscapes()
+        {
+            // 你好 = 你好 (CJK "hello"). Pre-fix this came out as
+            // the literal text "u4f60u597d" and rendered as boxes in the
+            // label. Mojibake-shaped bug we'd have shipped to every
+            // non-ASCII Discord username if we hadn't caught it.
+            var body = "{\"discord_name\":\"\\u4f60\\u597d\"}";
+            Assert.Equal("你好", UploadClient.ExtractJsonString(body, "discord_name"));
+        }
+
+        [Fact]
+        public void ExtractJsonString_HandlesEmojiSurrogatePair()
+        {
+            // Emoji outside the BMP are emitted as a UTF-16 surrogate
+            // pair of \uXXXX escapes. 😀 (U+1F600) = D83D + DE00.
+            // System.String stores the two chars as a valid surrogate
+            // pair so concatenation just works.
+            var body = "{\"discord_name\":\"\\uD83D\\uDE00\"}";
+            Assert.Equal("😀", UploadClient.ExtractJsonString(body, "discord_name"));
+        }
+
+        [Fact]
+        public void ExtractJsonString_HandlesMixedAsciiAndEscapes()
+        {
+            // The real-world shape: a name that's mostly ASCII but
+            // contains a single accented char that the server escaped.
+            var body = "{\"discord_name\":\"caf\\u00e9\"}";
+            Assert.Equal("café", UploadClient.ExtractJsonString(body, "discord_name"));
+        }
+
+        [Fact]
+        public void ExtractJsonString_MalformedUnicodeEscapeReturnsNull()
+        {
+            // \u followed by anything that isn't 4 hex digits is a
+            // protocol error — bail rather than guess.
+            var body = "{\"detail\":\"foo \\u4f6 bar\"}";  // only 3 hex digits
+            Assert.Null(UploadClient.ExtractJsonString(body, "detail"));
+        }
+
+        [Fact]
+        public void ExtractJsonString_HandlesRawUtf8FromFastApi()
+        {
+            // The default FastAPI path: bytes-on-the-wire are raw UTF-8,
+            // ReadBodyUtf8Async produces a string with the actual
+            // characters (not escapes). Extractor passes them through
+            // unchanged — this is the happy path that the field today.
+            var body = "{\"discord_name\":\"你好\"}";
+            Assert.Equal("你好", UploadClient.ExtractJsonString(body, "discord_name"));
+        }
+
         [Fact]
         public void ExtractJsonString_MissingFieldReturnsNull()
         {