refactor(csharp-render): FR-010 recover engine — pre-merge review + simplify

Pre-merge gates (code-review + code-simplifier) on the C# recover engine:

Review fixes (RecoverMap, Java `instanceof Number` / `String.valueOf` parity):
- numeric helpers (AsInt/AsLong/AsDouble) gate on actual numeric types and
  never throw — a non-numeric string or boolean returns null instead of
  throwing FormatException / coercing, preserving the never-throw contract
  once Phase-3 recover() codegen makes these helpers reachable.
- AsString/AsStringList format numbers with InvariantCulture (locale-
  independent canonical value), matching Java String.valueOf.
- 4 regression tests (never-throw, truncate-toward-zero, de-DE invariance).

Simplifier: clarity-only refinements (switch expressions, pattern matching,
collapsed redundant branches) — behavior unchanged.

KNOWN_GAPS.md: nested-object deferral (parity with Java/Kotlin) + the blessed
numeric-suffix and Unicode-whitespace cross-port divergences.

Suite: 202 passed (was 198), incl. all 10 recover-conformance corpus cases.

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

Author: dmealing

server/csharp/MetaObjects.Render.Tests/Recover/RecoverMapTests.cs

@@ -1,3 +1,4 @@
+using System.Globalization;
 using MetaObjects.Render.Recover;
 using Xunit;
 
@@ -70,4 +71,65 @@ public void AsStringListCoercesElementsToString()
         var result = RecoverMap.AsStringList(m, "xs");
         Assert.Equal(new[] { "1", "2" }, result);
     }
+
+    // --- Java-`instanceof Number` parity: numeric helpers gate on numbers, never throw (FR-010 review #1) ---
+
+    [Fact]
+    public void NumericHelpersReturnNullForNonNumberValuesAndNeverThrow()
+    {
+        // A non-numeric string must yield null (Java `instanceof Number` is false), NOT a thrown
+        // FormatException — recover() and its helpers must never throw.
+        var m = new Dictionary<string, object?> { ["s"] = "abc", ["b"] = true };
+
+        Assert.Null(RecoverMap.AsInt(m, "s"));
+        Assert.Null(RecoverMap.AsLong(m, "s"));
+        Assert.Null(RecoverMap.AsDouble(m, "s"));
+
+        // A boolean is not a Number → null (Java parity), not coerced to 1.
+        Assert.Null(RecoverMap.AsInt(m, "b"));
+        Assert.Null(RecoverMap.AsLong(m, "b"));
+        Assert.Null(RecoverMap.AsDouble(m, "b"));
+    }
+
+    [Fact]
+    public void AsIntTruncatesFloatingTowardZeroLikeJavaIntValue()
+    {
+        var m = new Dictionary<string, object?> { ["d"] = 42.9 };
+        Assert.Equal(42, RecoverMap.AsInt(m, "d"));   // truncate, not round-to-44
+        Assert.Equal(42L, RecoverMap.AsLong(m, "d"));
+    }
+
+    // --- Locale-independence: numeric→string is invariant, matching Java `String.valueOf` (FR-010 review #2) ---
+
+    [Fact]
+    public void AsStringFormatsNumbersInvariantOfCulture()
+    {
+        var prior = CultureInfo.CurrentCulture;
+        try
+        {
+            CultureInfo.CurrentCulture = new CultureInfo("de-DE"); // comma decimal separator
+            var m = new Dictionary<string, object?> { ["d"] = 1234.5 };
+            Assert.Equal("1234.5", RecoverMap.AsString(m, "d"));    // dot, not "1234,5"
+        }
+        finally
+        {
+            CultureInfo.CurrentCulture = prior;
+        }
+    }
+
+    [Fact]
+    public void AsStringListFormatsNumbersInvariantOfCulture()
+    {
+        var prior = CultureInfo.CurrentCulture;
+        try
+        {
+            CultureInfo.CurrentCulture = new CultureInfo("de-DE");
+            var m = new Dictionary<string, object?> { ["xs"] = new List<object?> { 1234.5, 6.25 } };
+            Assert.Equal(new[] { "1234.5", "6.25" }, RecoverMap.AsStringList(m, "xs"));
+        }
+        finally
+        {
+            CultureInfo.CurrentCulture = prior;
+        }
+    }
 }

server/csharp/MetaObjects.Render/Recover/Coerce.cs

@@ -47,9 +47,8 @@ public static class Coerce
         }
 
         // Per-field runtime normalizer: keyed by field path, then by simple name.
-        Func<string, object?>? norm = null;
-        opts.Normalizers.TryGetValue(fieldPath, out norm);
-        if (norm == null) opts.Normalizers.TryGetValue(spec.Name, out norm);
+        if (!opts.Normalizers.TryGetValue(fieldPath, out var norm))
+            opts.Normalizers.TryGetValue(spec.Name, out norm);
         if (norm != null)
         {
             object? normalized = norm(raw);

server/csharp/MetaObjects.Render/Recover/JsonForgivingReader.cs

@@ -38,7 +38,7 @@ public sealed class JsonForgivingReader
         char c = _s[_i];
         if (c == '{') return ReadObject();
         if (c == '[') return ReadArray();
-        if (c == '"' || c == '\'') return ReadString(c);
+        if (c is '"' or '\'') return ReadString(c);
         return ReadBareScalar();
     }
 
@@ -96,8 +96,7 @@ public sealed class JsonForgivingReader
             Ws();
             if (_i < _s.Length && _s[_i] == ',') _i++;
             else if (_i < _s.Length && _s[_i] == ']') { _i++; return xs; }
-            else if (_i >= _s.Length) return xs;
-            else return xs; // any other non-separator char → stop
+            else return xs; // EOF or any other non-separator char → stop
         }
     }
 
@@ -106,7 +105,7 @@ public sealed class JsonForgivingReader
         Ws();
         if (_i >= _s.Length) return null;
         char c = _s[_i];
-        if (c == '"' || c == '\'') return ReadString(c);
+        if (c is '"' or '\'') return ReadString(c);
         int start = _i;
         while (_i < _s.Length && (char.IsLetterOrDigit(_s[_i]) || _s[_i] == '_')) _i++;
         return _i > start ? _s[start.._i] : null;

server/csharp/MetaObjects.Render/Recover/KNOWN_GAPS.md

@@ -0,0 +1,36 @@
+# FR-010 C# recover engine — known gaps & intentional cross-port divergences
+
+Scope: the tolerant `Recover` pipeline (`MetaObjects.Render/Recover/`). The Java engine
+(`server/java/render/.../recover/`) is the reference; `fixtures/recover-conformance/` is the
+cross-port oracle. All 10 corpus cases pass.
+
+## Bounded deferrals (parity with Java/Kotlin)
+
+- **Nested-object recover.** Only scalar / enum / scalar-array fields are recovered. A
+  `field.object` (nested record) is not descended into. Same deferral as the Java and Kotlin
+  ports (tracked there as Plan 2.1/3.1). Phase 3 codegen will reject / skip nested fields
+  consistently rather than emit a partial mapping.
+
+## Intentional, documented divergences (NOT bugs)
+
+These differ from Java on inputs the corpus does not exercise. The cross-port contract pins
+*classification + canonical value* (numeric within ±1e-9), **not** byte-identical native
+formatting — see the FR-010 design spec and `fr-010-plan-decisions` memory.
+
+- **Numeric suffix / exotic literals.** Java's `Double.parseDouble` accepts `"42f"`, `"42d"`,
+  and hex-float literals (→ RECOVERED). The C# parse (`double.TryParse`, invariant culture)
+  rejects them → **MALFORMED**. The load-bearing behavior — finite-only acceptance and
+  `NaN`/`±Infinity` → MALFORMED — is identical across ports. (See the cross-port note in
+  `Coerce.cs`.)
+
+- **Unicode whitespace.** `JsonForgivingReader` uses `char.IsWhiteSpace`; Java uses
+  `Character.isWhitespace`. They disagree on NBSP (U+00A0), U+2007, U+202F. Only reachable when
+  a value/key is padded with a non-ASCII space — outside corpus coverage.
+
+## Resolved in this port (review-driven, before Phase 1 merge)
+
+- `RecoverMap` numeric helpers gate on actual numeric types (mirroring Java `instanceof Number`):
+  a non-numeric string or a boolean returns `null` instead of throwing / coercing. Preserves the
+  never-throw contract once Phase-3 `recover()` codegen makes these helpers reachable.
+- `RecoverMap.AsString` / `AsStringList` format numbers with `CultureInfo.InvariantCulture`,
+  matching Java `String.valueOf` (locale-independent canonical value).

server/csharp/MetaObjects.Render/Recover/Recover.cs

@@ -26,17 +26,11 @@ public static RecoverOutcome Run(string? text, RecoverSchema schema, RecoverOpti
 
         Dictionary<string, object?> raw;
         if (span == null)
-        {
             raw = new Dictionary<string, object?>();
-        }
         else if (schema.Format == Format.Json)
-        {
             raw = new JsonForgivingReader().Read(span);
-        }
         else
-        {
             raw = new XmlForgivingReader().Read(span, ci);
-        }
 
         if (raw.Count == 0 && (stripped.Length == 0 || span == null))
         {

server/csharp/MetaObjects.Render/Recover/RecoverMap.cs

@@ -1,3 +1,5 @@
+using System.Globalization;
+
 namespace MetaObjects.Render.Recover;
 
 /// <summary>
@@ -7,43 +9,88 @@ namespace MetaObjects.Render.Recover;
 public static class RecoverMap
 {
     /// <summary>
-    /// Returns the string value for key <paramref name="k"/>, coercing non-strings via
-    /// <see cref="Convert.ToString(object)"/>. Returns <c>null</c> when the key is absent.
+    /// Returns the string value for key <paramref name="k"/>, coercing non-strings via invariant-culture
+    /// <see cref="Convert.ToString(object, IFormatProvider)"/>. Returns <c>null</c> when the key is absent.
     /// </summary>
+    /// <remarks>
+    /// Mirrors Java <c>String.valueOf</c>: locale-independent. The generated path only calls this on
+    /// string-typed fields (value already a string), so the numeric fallback is defensive.
+    /// </remarks>
     public static string? AsString(IReadOnlyDictionary<string, object?> d, string k)
     {
         if (!d.TryGetValue(k, out object? v)) return null;
-        return v == null ? null : (v is string s ? s : Convert.ToString(v));
+        return v switch
+        {
+            null => null,
+            string s => s,
+            _ => Convert.ToString(v, CultureInfo.InvariantCulture),
+        };
     }
 
     /// <summary>
     /// Returns the value narrowed to <see cref="int"/> for key <paramref name="k"/>.
-    /// Returns <c>null</c> when the key is absent or the value is not a <see cref="IConvertible"/> number.
+    /// Returns <c>null</c> when the key is absent or the value is not a number.
     /// </summary>
+    /// <remarks>
+    /// Mirrors Java <c>Number.intValue()</c>: gates on actual numeric types (never throws on a string/bool,
+    /// unlike <see cref="Convert"/>) and truncates floating values toward zero.
+    /// </remarks>
     public static int? AsInt(IReadOnlyDictionary<string, object?> d, string k)
     {
         if (!d.TryGetValue(k, out object? v)) return null;
-        return v is IConvertible c ? (int?)Convert.ToInt32(c) : null;
+        return v switch
+        {
+            long l => (int)l,
+            int i => i,
+            double db => (int)db,
+            float f => (int)f,
+            decimal m => (int)m,
+            short s => s,
+            byte b => b,
+            _ => null,
+        };
     }
 
     /// <summary>
     /// Returns the value as <see cref="long"/> for key <paramref name="k"/>.
-    /// Returns <c>null</c> when the key is absent or the value is not a <see cref="IConvertible"/> number.
+    /// Returns <c>null</c> when the key is absent or the value is not a number.
     /// </summary>
+    /// <remarks>Mirrors Java <c>Number.longValue()</c>: numeric-typed, never throws, truncates toward zero.</remarks>
     public static long? AsLong(IReadOnlyDictionary<string, object?> d, string k)
     {
         if (!d.TryGetValue(k, out object? v)) return null;
-        return v is IConvertible c ? (long?)Convert.ToInt64(c) : null;
+        return v switch
+        {
+            long l => l,
+            int i => i,
+            double db => (long)db,
+            float f => (long)f,
+            decimal m => (long)m,
+            short s => s,
+            byte b => b,
+            _ => null,
+        };
     }
 
     /// <summary>
     /// Returns the value as <see cref="double"/> for key <paramref name="k"/>.
-    /// Returns <c>null</c> when the key is absent or the value is not a <see cref="IConvertible"/> number.
+    /// Returns <c>null</c> when the key is absent or the value is not a number.
     /// </summary>
+    /// <remarks>Mirrors Java <c>Number.doubleValue()</c>: numeric-typed, never throws.</remarks>
     public static double? AsDouble(IReadOnlyDictionary<string, object?> d, string k)
     {
         if (!d.TryGetValue(k, out object? v)) return null;
-        return v is IConvertible c ? (double?)Convert.ToDouble(c) : null;
+        return v switch
+        {
+            long l => l,
+            int i => i,
+            double db => db,
+            float f => f,
+            decimal m => (double)m,
+            short s => s,
+            byte b => b,
+            _ => null,
+        };
     }
 
     /// <summary>
@@ -67,7 +114,7 @@ public static class RecoverMap
         if (v is not List<object?> list) return null;
         var out_ = new List<string?>(list.Count);
         foreach (object? e in list)
-            out_.Add(e == null ? null : Convert.ToString(e));
+            out_.Add(e == null ? null : Convert.ToString(e, CultureInfo.InvariantCulture));
         return out_.AsReadOnly();
     }
 }

server/csharp/MetaObjects.Render/Recover/XmlForgivingReader.cs

@@ -99,15 +99,9 @@ private static void Accumulate(Dictionary<string, object?> out_, string key, obj
             out_[key] = value;
             return;
         }
-        object? existing = out_[key];
-        if (existing is List<object?> list)
-        {
+        if (out_[key] is List<object?> list)
             list.Add(value);
-        }
         else
-        {
-            var newList = new List<object?> { existing, value };
-            out_[key] = newList;
-        }
+            out_[key] = new List<object?> { out_[key], value };
     }
 }