test(csharp): source-v2 un-gates conformance + adds SourceV2Tests

Empties both conformance ledgers (JSON: 24 entries → 0; YAML: 1 entry → 0).
With source.rdb + @kind/@role/@table/@Schema registered, one-primary
multi-source validation wired, relationship @onDelete/@onUpdate enforced,
@column registered as a common-field attr, and ERR_RESERVED_ATTR firing in
the canonical parser, every previously gated v2 fixture passes natively.

ERR_RESERVED_ATTR now pushes to the structured error list (not warnings) in
lax mode, matching the TS parser-core.ts pattern (lax → errors-sink-direct,
strict → throw). Without this, ERR_RESERVED_ATTR was silently a warning and
the error-reserved-word-as-attr conformance check saw zero errors.

Updates Core_provider_registers_exactly_N_types from 70 → 69 to reflect
source's collapse from 3 subtypes (base, dbTable, dbView) to 2 (base, rdb).

SourceV2Tests covers the Stage 2 Unit 1 surface with named tests:
- source.rdb registration + bad-value rejection on @kind / @ROLE
- MetaSource accessor defaults + read-only-kind derivation
- One-primary rule (0 / 1 / 0 primary / 2+ primary)
- Relationship explicit + default @onDelete / @onUpdate + bad-value rejection
- ERR_RESERVED_ATTR on @-prefixed reserved words, with bare form accepted

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: dmealing

server/csharp/MetaObjects.Conformance.Tests/CoreTypesTests.cs

@@ -28,13 +28,14 @@ public void Core_provider_factory_builds_the_right_node_class()
     }
 
     [Fact]
-    public void Core_provider_registers_exactly_70_types()
+    public void Core_provider_registers_exactly_69_types()
     {
         // Guard: if a subtype array gains an entry without a matching
         // FieldDataType / AttrDataType mapping, RegisterCoreTypeDefs throws and
         // this test catches the mismatch before it reaches downstream callers.
-        // 70 = 64 + template.{base,prompt,output} + origin.collection + identity.reference (FR-003/004) + field.enum.
+        // 69 = was 70 (source had 3 subtypes: base, dbTable, dbView)
+        // - source-v2 (ADR-0007) collapses to 2 subtypes (base, rdb).
         var reg = Provider.ComposeRegistry(new[] { CoreTypes.CoreTypesProvider });
-        Assert.Equal(70, reg.AllTypes().Count);
+        Assert.Equal(69, reg.AllTypes().Count);
     }
 }

server/csharp/MetaObjects.Conformance.Tests/SourceV2Tests.cs

@@ -0,0 +1,338 @@
+// SourceV2Tests — targeted tests for the source-v2 (ADR-0007) port: source.rdb
+// registration + accessors + bad-value rejection, one-primary multi-source
+// validation, relationship referential actions, and ERR_RESERVED_ATTR
+// enforcement in the canonical parser.
+//
+// Mirrors the Java Stage 2 Unit 1 test layout. The corresponding fixtures live
+// in fixtures/conformance/source-* and error-* (used by ConformanceTests too);
+// these tests give each behavior a named entry point with a clear failure
+// message and a small inline JSON variant where round-trip + accessor checks
+// are convenient.
+
+using MetaObjects;
+using MetaObjects.Loader;
+using MetaObjects.Meta;
+using Xunit;
+
+namespace MetaObjects.Conformance.Tests;
+
+public class SourceV2Tests
+{
+    private static LoadResult LoadInline(string json) =>
+        new MetaDataLoader().Load([new InMemorySource(json, id: "inline.json")]);
+
+    // -------------------------------------------------------------------------
+    // source.rdb registration + accessors
+    // -------------------------------------------------------------------------
+
+    [Fact]
+    public void Source_rdb_is_registered_with_table_kind_role_schema_attrs()
+    {
+        var reg = Provider.ComposeRegistry(new[] { CoreTypes.CoreTypesProvider });
+        Assert.True(reg.Has("source", "rdb"));
+
+        var def = reg.Find("source", "rdb")!;
+        var attrNames = def.Attributes.Select(a => a.Name).ToHashSet();
+        Assert.Contains("table", attrNames);
+        Assert.Contains("kind", attrNames);
+        Assert.Contains("role", attrNames);
+        Assert.Contains("schema", attrNames);
+    }
+
+    [Fact]
+    public void Source_rdb_kind_enum_rejects_unknown_value()
+    {
+        const string json = """
+        { "metadata.root": { "package": "acme", "children": [
+          { "object.entity": { "name": "Product", "children": [
+            { "source.rdb": { "@table": "products", "@kind": "nosuchkind" } },
+            { "field.long": { "name": "id" } },
+            { "identity.primary": { "@fields": "id" } }
+          ]}}
+        ]}}
+        """;
+        var result = LoadInline(json);
+        Assert.Contains(result.Errors, e => e.Code == ErrorCode.ERR_BAD_ATTR_VALUE);
+    }
+
+    [Fact]
+    public void Source_rdb_role_enum_rejects_unknown_value()
+    {
+        const string json = """
+        { "metadata.root": { "package": "acme", "children": [
+          { "object.entity": { "name": "Product", "children": [
+            { "source.rdb": { "@table": "products", "@role": "shadow" } },
+            { "field.long": { "name": "id" } },
+            { "identity.primary": { "@fields": "id" } }
+          ]}}
+        ]}}
+        """;
+        var result = LoadInline(json);
+        Assert.Contains(result.Errors, e => e.Code == ErrorCode.ERR_BAD_ATTR_VALUE);
+    }
+
+    [Fact]
+    public void MetaSource_accessors_default_when_attrs_absent()
+    {
+        const string json = """
+        { "metadata.root": { "package": "acme", "children": [
+          { "object.entity": { "name": "Product", "children": [
+            { "source.rdb": { "@table": "products" } },
+            { "field.long": { "name": "id" } },
+            { "identity.primary": { "@fields": "id" } }
+          ]}}
+        ]}}
+        """;
+        var result = LoadInline(json);
+        Assert.Empty(result.Errors);
+
+        var obj = (MetaObject)result.Root.Children().First(c => c.Type == "object");
+        var src = obj.OwnSources().Single();
+        Assert.Equal("products", src.TableName);
+        Assert.Equal("table", src.EffectiveKind);
+        Assert.Equal("primary", src.Role);
+        Assert.True(src.IsWritable());
+        Assert.False(src.IsReadOnly());
+    }
+
+    [Fact]
+    public void MetaSource_read_only_kind_makes_source_read_only()
+    {
+        const string json = """
+        { "metadata.root": { "package": "acme", "children": [
+          { "object.entity": { "name": "ProductView", "children": [
+            { "source.rdb": { "@table": "v_products", "@kind": "view" } },
+            { "field.long": { "name": "id" } },
+            { "identity.primary": { "@fields": "id" } }
+          ]}}
+        ]}}
+        """;
+        var result = LoadInline(json);
+        Assert.Empty(result.Errors);
+
+        var obj = (MetaObject)result.Root.Children().First(c => c.Type == "object");
+        var src = obj.OwnSources().Single();
+        Assert.Equal("view", src.EffectiveKind);
+        Assert.True(src.IsReadOnly());
+        Assert.False(src.IsWritable());
+    }
+
+    // -------------------------------------------------------------------------
+    // One-primary multi-source validation
+    // -------------------------------------------------------------------------
+
+    [Fact]
+    public void Zero_sources_is_OK()
+    {
+        const string json = """
+        { "metadata.root": { "package": "acme", "children": [
+          { "object.value": { "name": "Address", "children": [
+            { "field.string": { "name": "city" } }
+          ]}}
+        ]}}
+        """;
+        Assert.Empty(LoadInline(json).Errors);
+    }
+
+    [Fact]
+    public void Single_primary_source_is_OK()
+    {
+        const string json = """
+        { "metadata.root": { "package": "acme", "children": [
+          { "object.entity": { "name": "Product", "children": [
+            { "source.rdb": { "@table": "products" } },
+            { "field.long": { "name": "id" } },
+            { "identity.primary": { "@fields": "id" } }
+          ]}}
+        ]}}
+        """;
+        Assert.Empty(LoadInline(json).Errors);
+    }
+
+    [Fact]
+    public void No_primary_among_sources_is_ERR_SOURCE_NO_PRIMARY()
+    {
+        const string json = """
+        { "metadata.root": { "package": "acme", "children": [
+          { "object.entity": { "name": "Product", "children": [
+            { "source.rdb": { "@role": "replica", "@table": "products_r" } },
+            { "field.long": { "name": "id" } },
+            { "identity.primary": { "@fields": "id" } }
+          ]}}
+        ]}}
+        """;
+        var result = LoadInline(json);
+        Assert.Contains(result.Errors, e => e.Code == ErrorCode.ERR_SOURCE_NO_PRIMARY);
+    }
+
+    [Fact]
+    public void Multiple_primary_sources_is_ERR_SOURCE_MULTIPLE_PRIMARY()
+    {
+        const string json = """
+        { "metadata.root": { "package": "acme", "children": [
+          { "object.entity": { "name": "Product", "children": [
+            { "source.rdb": { "@table": "products_a" } },
+            { "source.rdb": { "@table": "products_b" } },
+            { "field.long": { "name": "id" } },
+            { "identity.primary": { "@fields": "id" } }
+          ]}}
+        ]}}
+        """;
+        var result = LoadInline(json);
+        Assert.Contains(result.Errors, e => e.Code == ErrorCode.ERR_SOURCE_MULTIPLE_PRIMARY);
+    }
+
+    // -------------------------------------------------------------------------
+    // Relationship @onDelete / @onUpdate referential actions
+    // -------------------------------------------------------------------------
+
+    [Fact]
+    public void Relationship_explicit_onDelete_round_trips_and_resolves()
+    {
+        const string json = """
+        { "metadata.root": { "package": "acme", "children": [
+          { "object.entity": { "name": "Program", "children": [
+            { "source.rdb": { "@table": "programs" } },
+            { "field.long": { "name": "id" } },
+            { "identity.primary": { "@fields": "id" } }
+          ]}},
+          { "object.entity": { "name": "Week", "children": [
+            { "source.rdb": { "@table": "weeks" } },
+            { "field.long": { "name": "id" } },
+            { "field.long": { "name": "programId" } },
+            { "relationship.composition": { "name": "program",
+                "@objectRef": "Program", "@cardinality": "one",
+                "@onDelete": "cascade", "@onUpdate": "cascade" } },
+            { "identity.primary": { "@fields": "id" } },
+            { "identity.reference": { "name": "programRef",
+                "@fields": "programId", "@references": "Program" } }
+          ]}}
+        ]}}
+        """;
+        var result = LoadInline(json);
+        Assert.Empty(result.Errors);
+
+        var week = (MetaObject)result.Root.Children().First(o => o.Name == "Week");
+        var rel = week.Relationships().Single();
+        Assert.Equal("cascade", rel.EffectiveOnDelete);
+        Assert.Equal("cascade", rel.EffectiveOnUpdate);
+    }
+
+    [Fact]
+    public void Relationship_subtype_default_resolves_when_attr_absent()
+    {
+        const string json = """
+        { "metadata.root": { "package": "acme", "children": [
+          { "object.entity": { "name": "Program", "children": [
+            { "source.rdb": { "@table": "programs" } },
+            { "field.long": { "name": "id" } },
+            { "identity.primary": { "@fields": "id" } }
+          ]}},
+          { "object.entity": { "name": "Week", "children": [
+            { "source.rdb": { "@table": "weeks" } },
+            { "field.long": { "name": "id" } },
+            { "field.long": { "name": "programId" } },
+            { "relationship.composition": { "name": "program",
+                "@objectRef": "Program", "@cardinality": "one" } },
+            { "identity.primary": { "@fields": "id" } },
+            { "identity.reference": { "name": "programRef",
+                "@fields": "programId", "@references": "Program" } }
+          ]}}
+        ]}}
+        """;
+        var result = LoadInline(json);
+        Assert.Empty(result.Errors);
+
+        var week = (MetaObject)result.Root.Children().First(o => o.Name == "Week");
+        var rel = week.Relationships().Single();
+        // composition default → cascade; update default → cascade.
+        Assert.Equal("cascade", rel.EffectiveOnDelete);
+        Assert.Equal("cascade", rel.EffectiveOnUpdate);
+    }
+
+    [Fact]
+    public void Relationship_bad_onDelete_value_is_ERR_BAD_ATTR_VALUE()
+    {
+        const string json = """
+        { "metadata.root": { "package": "acme", "children": [
+          { "object.entity": { "name": "Program", "children": [
+            { "source.rdb": { "@table": "programs" } },
+            { "field.long": { "name": "id" } },
+            { "identity.primary": { "@fields": "id" } }
+          ]}},
+          { "object.entity": { "name": "Week", "children": [
+            { "source.rdb": { "@table": "weeks" } },
+            { "field.long": { "name": "id" } },
+            { "field.long": { "name": "programId" } },
+            { "relationship.composition": { "name": "program",
+                "@objectRef": "Program", "@cardinality": "one",
+                "@onDelete": "destroyAll" } },
+            { "identity.primary": { "@fields": "id" } },
+            { "identity.reference": { "name": "programRef",
+                "@fields": "programId", "@references": "Program" } }
+          ]}}
+        ]}}
+        """;
+        var result = LoadInline(json);
+        Assert.Contains(result.Errors, e => e.Code == ErrorCode.ERR_BAD_ATTR_VALUE);
+    }
+
+    // -------------------------------------------------------------------------
+    // ERR_RESERVED_ATTR enforcement in the canonical parser
+    // -------------------------------------------------------------------------
+
+    [Fact]
+    public void At_prefixed_isArray_is_ERR_RESERVED_ATTR()
+    {
+        const string json = """
+        { "metadata.root": { "package": "acme", "children": [
+          { "object.entity": { "name": "Owner", "children": [
+            { "field.long": { "name": "id" } },
+            { "field.object": { "name": "items", "@isArray": true, "@objectRef": "Item" } },
+            { "identity.primary": { "name": "pk", "@fields": "id" } }
+          ]}},
+          { "object.entity": { "name": "Item", "children": [
+            { "field.long": { "name": "id" } },
+            { "identity.primary": { "name": "pk", "@fields": "id" } }
+          ]}}
+        ]}}
+        """;
+        var result = LoadInline(json);
+        Assert.Contains(result.Errors, e => e.Code == ErrorCode.ERR_RESERVED_ATTR);
+    }
+
+    [Fact]
+    public void At_prefixed_name_is_ERR_RESERVED_ATTR()
+    {
+        const string json = """
+        { "metadata.root": { "package": "acme", "children": [
+          { "object.entity": { "name": "Owner", "children": [
+            { "field.long": { "@name": "id" } },
+            { "identity.primary": { "name": "pk", "@fields": "id" } }
+          ]}}
+        ]}}
+        """;
+        var result = LoadInline(json);
+        Assert.Contains(result.Errors, e => e.Code == ErrorCode.ERR_RESERVED_ATTR);
+    }
+
+    [Fact]
+    public void Bare_isArray_structural_key_is_OK()
+    {
+        const string json = """
+        { "metadata.root": { "package": "acme", "children": [
+          { "object.entity": { "name": "Owner", "children": [
+            { "field.long": { "name": "id" } },
+            { "field.object": { "name": "items", "isArray": true, "@objectRef": "Item" } },
+            { "identity.primary": { "name": "pk", "@fields": "id" } }
+          ]}},
+          { "object.entity": { "name": "Item", "children": [
+            { "field.long": { "name": "id" } },
+            { "identity.primary": { "name": "pk", "@fields": "id" } }
+          ]}}
+        ]}}
+        """;
+        var result = LoadInline(json);
+        Assert.Empty(result.Errors);
+    }
+}

server/csharp/MetaObjects.Conformance.Tests/conformance-expected-failures.json

@@ -1,29 +1,5 @@
 {
   "language": "csharp",
-  "fixtures": [
-    "doc-common-attrs-on-all-types",
-    "error-field-object-storage-flattened-array",
-    "error-field-object-storage-no-object-ref",
-    "error-origin-bad-aggregate-fn",
-    "error-origin-bad-via-path",
-    "error-reserved-word-as-attr",
-    "error-source-multiple-primary",
-    "error-source-no-primary",
-    "field-object-storage-flattened",
-    "field-object-storage-flattened-nullable",
-    "field-object-storage-jsonb-array",
-    "field-object-storage-jsonb-single",
-    "origin-aggregate-count",
-    "origin-aggregate-sum",
-    "origin-multi-level-via",
-    "origin-passthrough-simple",
-    "source-db-table-default-schema-omitted",
-    "source-db-table-explicit",
-    "source-db-table-with-schema",
-    "source-db-view-projection",
-    "source-db-view-with-schema",
-    "source-multi-source-roles",
-    "source-rdb-column",
-    "source-rdb-referential-actions"
-  ]
+  "_comment": "Source-v2 (ADR-0007) un-gated the v1 source fixtures + the multi-primary + reserved-attr fixtures + the field-object-storage cluster + origin cluster + doc-common-attrs-on-all-types. All conformance fixtures pass.",
+  "fixtures": []
 }

server/csharp/MetaObjects.Conformance.Tests/yaml-conformance-expected-failures.json

@@ -1,7 +1,5 @@
 {
   "language": "csharp",
-  "_comment": "C# v1 metadata vocabulary doesn't declare @column on field.string, so the YAML D2 coercion guard has no schema to compare `column: TRUE` against — no ERR_YAML_COERCION fires. The 3 v2-vocabulary happy-paths and the num-in-enum fixture (which uses v1-declared @values on field.enum) pass natively.",
-  "fixtures": [
-    "error-yaml-coerced-bool-in-string"
-  ]
+  "_comment": "Source-v2 (ADR-0007) registered @column on every field subtype, so the YAML D2 coercion guard now catches `column: TRUE`. All YAML conformance fixtures pass.",
+  "fixtures": []
 }