Merge FR-010 C# port — Phase 1: native recover engine + dirty-input conformance

Brings FR-010's tolerant recover engine to the C# port (MetaObjects.Render/Recover/),
a native idiomatic reimplementation of the Java reference. 8-stage pipeline
(strip → locate → forgiving-read → malformed-vs-absent → coerce → classify), XML + JSON,
never throws. Per-field FieldRecovery classification + canonical value pinned by the shared
fixtures/recover-conformance/ corpus — all 10 cases green with zero fixture edits, so the C#
engine classifies dirty LLM output identically to Java/Kotlin.

Pre-merge gates (code-review + code-simplifier) applied: RecoverMap aligned to Java
`instanceof Number` / `String.valueOf` semantics (never-throw, invariant-culture);
KNOWN_GAPS.md records the nested-object deferral + blessed cross-port divergences.

202 render tests green. Phases 2 (OutputFormatRenderer) + 3 (codegen + attrs) follow.

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

Author: dmealing

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

@@ -0,0 +1,179 @@
+using MetaObjects.Render.Recover;
+using Xunit;
+
+namespace MetaObjects.Render.Tests.Recover;
+
+/// <summary>
+/// Unit tests for <see cref="Coerce"/> — FR-010 stage 7 (scalar canonicalization).
+/// Mirrors CoerceTest.java exactly.
+/// </summary>
+public class CoerceTests
+{
+    private RecoveryReport _rep = new();
+
+    private static RecoverOptions Normal() => RecoverOptions.Defaults();
+
+    // ---- enum ----
+
+    [Fact]
+    public void EnumExactMatch()
+    {
+        var f = FieldSpec.EnumField("tone", required: true,
+            values: new[] { "FRIENDLY", "HOSTILE" },
+            aliases: new Dictionary<string, string>());
+
+        var result = Coerce.Value("FRIENDLY", f, Normal(), "tone", _rep);
+        Assert.Equal("FRIENDLY", result);
+    }
+
+    [Fact]
+    public void EnumCaseFoldedInNormal()
+    {
+        var f = FieldSpec.EnumField("tone", required: true,
+            values: new[] { "FRIENDLY" },
+            aliases: new Dictionary<string, string>());
+
+        var result = Coerce.Value("friendly", f, Normal(), "tone", _rep);
+        Assert.Equal("FRIENDLY", result);
+    }
+
+    [Fact]
+    public void EnumStrictDoesNotCaseFold()
+    {
+        var f = FieldSpec.EnumField("tone", required: true,
+            values: new[] { "FRIENDLY" },
+            aliases: new Dictionary<string, string>());
+
+        var result = Coerce.Value("friendly", f, Normal().WithTolerance(Tolerance.Strict), "tone", _rep);
+        Assert.Same(Coerce.Malformed, result);
+    }
+
+    [Fact]
+    public void EnumSchemaAliasFolds()
+    {
+        var f = FieldSpec.EnumField("tone", required: true,
+            values: new[] { "FRIENDLY" },
+            aliases: new Dictionary<string, string> { ["warm"] = "FRIENDLY" });
+
+        var result = Coerce.Value("warm", f, Normal(), "tone", _rep);
+        Assert.Equal("FRIENDLY", result);
+        Assert.Contains(_rep.Coercions(), c => c.Kind == "alias");
+    }
+
+    [Fact]
+    public void RuntimeAliasWinsOverSchema()
+    {
+        var f = FieldSpec.EnumField("tone", required: true,
+            values: new[] { "FRIENDLY", "HOSTILE" },
+            aliases: new Dictionary<string, string> { ["x"] = "FRIENDLY" });
+
+        var opts = new RecoverOptions(
+            Tolerance.Normal,
+            new Dictionary<string, string> { ["x"] = "HOSTILE" },
+            new Dictionary<string, Func<string, object?>>(),
+            null);
+
+        var result = Coerce.Value("x", f, opts, "tone", _rep);
+        Assert.Equal("HOSTILE", result);
+        Assert.Contains(_rep.Coercions(), c => c.Kind == "runtime-alias-override");
+    }
+
+    [Fact]
+    public void EnumOffVocabIsMalformed()
+    {
+        var f = FieldSpec.EnumField("tone", required: true,
+            values: new[] { "FRIENDLY" },
+            aliases: new Dictionary<string, string>());
+
+        var result = Coerce.Value("banana", f, Normal(), "tone", _rep);
+        Assert.Same(Coerce.Malformed, result);
+    }
+
+    // ---- int / range ----
+
+    [Fact]
+    public void IntClampToRange()
+    {
+        var f = FieldSpec.Range("score", FieldKind.Int, required: true, min: 0.0, max: 10.0);
+
+        var result = Coerce.Value("42", f, Normal(), "score", _rep);
+        Assert.Equal(10L, result);
+        Assert.Contains(_rep.Coercions(), c => c.Kind == "clamp");
+    }
+
+    [Fact]
+    public void IntUnparseableMalformed()
+    {
+        var f = FieldSpec.Scalar("score", FieldKind.Int, required: true);
+
+        var result = Coerce.Value("abc", f, Normal(), "score", _rep);
+        Assert.Same(Coerce.Malformed, result);
+    }
+
+    // ---- boolean ----
+
+    [Fact]
+    public void BooleanForms()
+    {
+        var f = FieldSpec.Scalar("ok", FieldKind.Boolean, required: true);
+
+        Assert.Equal(true, Coerce.Value("yes", f, Normal(), "ok", _rep));
+        Assert.Equal(false, Coerce.Value("0", f, Normal(), "ok", _rep));
+    }
+
+    // ---- onField hook ----
+
+    [Fact]
+    public void OnFieldHookWins()
+    {
+        var f = FieldSpec.Scalar("x", FieldKind.String, required: true);
+        var opts = new RecoverOptions(
+            Tolerance.Normal,
+            new Dictionary<string, string>(),
+            new Dictionary<string, Func<string, object?>>(),
+            (path, raw, spec) => "HOOKED");
+
+        var result = Coerce.Value("anything", f, opts, "x", _rep);
+        Assert.Equal("HOOKED", result);
+    }
+
+    // ---- non-finite guard ----
+
+    [Fact]
+    public void NanIsMalformedForDouble()
+    {
+        var f = FieldSpec.Scalar("n", FieldKind.Double, required: true);
+
+        var result = Coerce.Value("NaN", f, Normal(), "n", _rep);
+        Assert.Same(Coerce.Malformed, result);
+    }
+
+    [Fact]
+    public void InfinityIsMalformedForInt()
+    {
+        var f = FieldSpec.Scalar("k", FieldKind.Int, required: true);
+
+        Assert.Same(Coerce.Malformed, Coerce.Value("Infinity", f, Normal(), "k", _rep));
+        Assert.Same(Coerce.Malformed, Coerce.Value("-Infinity", f, Normal(), "k", _rep));
+    }
+
+    // ---- normalizer ----
+
+    [Fact]
+    public void NormalizerByFieldNameApplied()
+    {
+        var f = FieldSpec.Scalar("x", FieldKind.String, required: true);
+        var opts = new RecoverOptions(
+            Tolerance.Normal,
+            new Dictionary<string, string>(),
+            new Dictionary<string, Func<string, object?>>
+            {
+                ["x"] = raw => raw.ToUpperInvariant()
+            },
+            null);
+
+        var result = Coerce.Value("hello", f, opts, "x", _rep);
+        Assert.Equal("HELLO", result);
+        Assert.Contains(_rep.Coercions(), c => c.Kind == "normalizer");
+    }
+}

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

@@ -0,0 +1,116 @@
+using MetaObjects.Render.Recover;
+using Xunit;
+
+namespace MetaObjects.Render.Tests.Recover;
+
+/// <summary>
+/// Unit tests for <see cref="JsonForgivingReader"/> (FR-010 stage 4).
+/// Ported from Java JsonForgivingReaderTest — all cases preserved exactly,
+/// including TRUNCATED sentinel and no-hang assertions.
+/// </summary>
+public class JsonForgivingReaderTests
+{
+    private static Dictionary<string, object?> Read(string? s) =>
+        new JsonForgivingReader().Read(s);
+
+    [Fact]
+    public void CleanObject()
+    {
+        var m = Read("{\"a\":\"1\",\"b\":\"two\"}");
+        Assert.Equal("1", m["a"]);
+        Assert.Equal("two", m["b"]);
+    }
+
+    [Fact]
+    public void TrailingComma()
+    {
+        var m = Read("{\"a\":\"1\",}");
+        Assert.Equal("1", m["a"]);
+        Assert.Single(m);
+    }
+
+    [Fact]
+    public void SingleQuotes()
+    {
+        var m = Read("{'a':'1'}");
+        Assert.Equal("1", m["a"]);
+    }
+
+    [Fact]
+    public void UnquotedKeys()
+    {
+        var m = Read("{a:\"1\",b:\"2\"}");
+        Assert.Equal("1", m["a"]);
+        Assert.Equal("2", m["b"]);
+    }
+
+    [Fact]
+    public void NestedObject()
+    {
+        var m = Read("{\"a\":{\"b\":\"1\"}}");
+        var inner = Assert.IsType<Dictionary<string, object?>>(m["a"]);
+        Assert.Equal("1", inner["b"]);
+    }
+
+    [Fact]
+    public void ArrayValues()
+    {
+        var m = Read("{\"xs\":[\"a\",\"b\"]}");
+        var xs = Assert.IsType<List<object?>>(m["xs"]);
+        Assert.Equal(new List<object?> { "a", "b" }, xs);
+    }
+
+    [Fact]
+    public void TruncatedRecoversCompletePrefixKeys()
+    {
+        var m = Read("{\"a\":\"1\",\"b\":\"2\",\"c\":");
+        Assert.Equal("1", m["a"]);
+        Assert.Equal("2", m["b"]);
+        Assert.Same(JsonForgivingReader.Truncated, m["c"]);
+    }
+
+    [Fact]
+    public void UnrecoverableReturnsEmpty()
+    {
+        Assert.Empty(Read("@@@@"));
+    }
+
+    [Fact(Timeout = 5000)]
+    public async Task MalformedArrayBraceCloseDoesNotHang()
+    {
+        var m = await Task.Run(() => Read("{\"xs\":[}"));
+        // xs present (empty/partial list), no hang
+        Assert.True(m.ContainsKey("xs"));
+    }
+
+    [Fact(Timeout = 5000)]
+    public async Task MalformedArrayBraceCloseAfterCommaDoesNotHang()
+    {
+        var m = await Task.Run(() => Read("{\"xs\":[1,}"));
+        // does not hang; xs recovered as a list with the prefix element
+        Assert.IsType<List<object?>>(m["xs"]);
+    }
+
+    [Fact]
+    public void EmptyValueMarksTruncated()
+    {
+        var m = Read("{\"a\":\"1\",\"c\":}");
+        Assert.Equal("1", m["a"]);
+        Assert.Same(JsonForgivingReader.Truncated, m["c"]);
+    }
+
+    [Fact]
+    public void EmptyValueWhitespaceMarksTruncated()
+    {
+        var m = Read("{\"a\": }");
+        Assert.Same(JsonForgivingReader.Truncated, m["a"]);
+    }
+
+    [Fact]
+    public void EmptyValueThenMoreKeysContinues()
+    {
+        var m = Read("{\"a\":,\"b\":\"2\"}");
+        Assert.Same(JsonForgivingReader.Truncated, m["a"]);
+        Assert.Equal("2", m["b"]);
+    }
+}

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

@@ -0,0 +1,85 @@
+using MetaObjects.Render.Recover;
+using Xunit;
+
+namespace MetaObjects.Render.Tests.Recover;
+
+/// <summary>
+/// Unit tests for <see cref="Locate"/> (FR-010 stages 2–3).
+/// Ported from Java LocateTest, with the additional no-throw guard case.
+/// </summary>
+public class LocateTests
+{
+    // ---- Json ----
+
+    [Fact]
+    public void Json_IsolatesBalancedObjectFromProse()
+    {
+        var input = "Here is the result: {\"a\":1,\"b\":{\"c\":2}} — done.";
+        Assert.Equal("{\"a\":1,\"b\":{\"c\":2}}", Locate.Json(input));
+    }
+
+    [Fact]
+    public void Json_IgnoresBracesInsideStrings()
+    {
+        var input = "{\"text\":\"a } not a close\",\"n\":1}";
+        Assert.Equal(input, Locate.Json(input));
+    }
+
+    [Fact]
+    public void Json_TruncatedReturnsPrefixToEnd()
+    {
+        var input = "prefix {\"a\":1,\"b\":";
+        Assert.Equal("{\"a\":1,\"b\":", Locate.Json(input));
+    }
+
+    [Fact]
+    public void Json_NoBraceReturnsNull()
+    {
+        Assert.Null(Locate.Json("no object here"));
+    }
+
+    [Fact]
+    public void Json_FirstClosedCandidateWins()
+    {
+        var input = "noise {\"a\":1} tail {\"b\":2}";
+        Assert.Equal("{\"a\":1}", Locate.Json(input));
+    }
+
+    // ---- Xml ----
+
+    [Fact]
+    public void Xml_SpansRoot()
+    {
+        var input = "blah <answer><t>hi</t></answer> blah";
+        Assert.Equal("<answer><t>hi</t></answer>", Locate.Xml(input, "answer", false));
+    }
+
+    [Fact]
+    public void Xml_UnclosedRootReturnsToEnd()
+    {
+        var input = "x <answer><t>hi</t>";
+        Assert.Equal("<answer><t>hi</t>", Locate.Xml(input, "answer", false));
+    }
+
+    [Fact]
+    public void Xml_CaseInsensitiveMatch()
+    {
+        var input = "<Answer><t>hi</t></Answer>";
+        Assert.Equal("<Answer><t>hi</t></Answer>", Locate.Xml(input, "answer", true));
+    }
+
+    [Fact]
+    public void Xml_NoOpenReturnsNull()
+    {
+        Assert.Null(Locate.Xml("nothing", "answer", false));
+    }
+
+    [Fact]
+    public void Xml_BareCloseTagDoesNotThrow()
+    {
+        // Guard: a string that starts with a close tag for the root should not throw
+        // and should return null (no opener found).
+        var result = Locate.Xml("</x>", "x", false);
+        Assert.Null(result);
+    }
+}