feat(conformance): Phase B Unit 2 — C# read-path (temporal + projection)

Make C#'s persistence-conformance pass the shared corpus's new temporal +
projection coverage (3 new scenarios + the updated existing ones) against
Testcontainers Postgres.

Read-path canonicalization (Normalization.cs):
- TIMESTAMP vs TIMESTAMPTZ are both Npgsql `DateTime`; discriminate by
  DateTimeKind (timestamptz → Kind.Utc, value already UTC → append Z;
  timestamp → Kind.Unspecified, wall-clock → no Z). Mirrors the TS port's
  OID-keyed temporal parsers; a non-UTC-seeded TIMESTAMPTZ reads back as its
  UTC equivalent, proving normalization not just formatting.
- TIME (TimeOnly) trims trailing-zero subseconds → "HH:MM:SS".
- jsonb leaves keep their JSON-native shape (integer → number, non-integer →
  canonical plain-decimal string, string/bool/null pass through), matching the
  TS authority's recursion over parsed jsonb — instead of stringifying every
  leaf (the old hack compensating for the broken expected-side parse below).

Expected-side YAML parsing (ScenarioLoader/QueryScenarioRunner): capture the
`expect:` block as a raw YamlNode (scalar style preserved) so a plain `45` is a
JSON number and a quoted "45" is a JSON string — the same type inference the TS
authority's JS YAML loader does. Without it every INTEGER-typed expectation
degraded to a string.

Codegen fixes surfaced by the new scenarios (regenerated the integration-test
Generated/*.g.cs baseline from canonical/meta.fitness.json — only the changed
columns differ):
- EntityGenerator: a MIN/MAX projection field materializes as its aggregated
  column's CLR type (MIN(INTEGER) → int), not the widened field.* declaration,
  so the read surfaces a JSON number. COUNT/SUM (→BIGINT/long) and AVG
  (→NUMERIC/double) already match.
- DbContextGenerator: emit HasConversion<string>() for enum columns on
  read-only projections too (previously entity-only), so a passed-through enum
  over a view round-trips instead of EF reading the text column as Int32.
- OriginConstants: named per-function constants (count/sum/avg/min/max).

Docker available. C# results: query scenarios 14/14 (incl. the 3 new +
asset-uuid-roundtrip/filter-is-null/projection-aggregate updated), full
integration suite 34/34; Codegen 81/81, Conformance 443/443, CLI 8/8,
Render 265/265. Shared fixtures untouched.

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

Author: dmealing

server/csharp/MetaObjects.Codegen/Generators/DbContextGenerator.cs

@@ -33,6 +33,14 @@ public IEnumerable<EmittedFile> Generate(GenContext ctx)
             var name = CSharpNaming.Pascal(p.Name);
             var noKey = p.PrimaryIdentity() is null ? ".HasNoKey()" : string.Empty;
             modelLines.Add($"        modelBuilder.Entity<{name}>(){noKey}.ToView(\"{p.DbView}\");");
+            // Enum-typed projection columns persist as their string symbol in the view
+            // (string-backed enums, CHECK-constrained varchar/text). Without an explicit
+            // string conversion EF defaults to the int-ordinal mapping and reads the text
+            // column as Int32 at materialization — an InvalidCastException. Mirror the
+            // entity-side HasConversion<string>() so a projection that passes an enum
+            // through (e.g. ProgramView.status over v_program) round-trips.
+            foreach (var f in p.Fields().Where(f => f.SubType == FIELD_SUBTYPE_ENUM && !f.IsArray))
+                modelLines.Add($"        modelBuilder.Entity<{name}>().Property(x => x.{CSharpNaming.Pascal(f.Name)}).HasConversion<string>();");
         }
         foreach (var e in objects.Where(o => o.IsEntity() && !o.IsReadOnlyProjection()))
         {

server/csharp/MetaObjects.Codegen/Generators/EntityGenerator.cs

@@ -15,7 +15,9 @@
 using System.Text;
 using MetaObjects.Codegen.Docs;
 using MetaObjects.Meta;
+using MetaObjects.Persistence.Origin;
 using static MetaObjects.Core.Field.FieldConstants;
+using static MetaObjects.Persistence.Origin.OriginConstants;
 
 namespace MetaObjects.Codegen.Generators;
 
@@ -104,7 +106,8 @@ private EmittedFile EmitMappedClass(MetaObject entity, GenContext ctx)
             string? member = null;
             if (CSharpNaming.ScalarFor(field.SubType) is not null)
             {
-                member = ScalarProperty(entity, field, pkFields, withAttributes: true, strategy);
+                member = ScalarProperty(entity, field, pkFields, withAttributes: true, strategy,
+                    AggregateResultScalar(field, ctx));
             }
             else if (field.SubType == FIELD_SUBTYPE_ENUM)
             {
@@ -282,9 +285,10 @@ private static string EnumProperty(
     // (the jsonb column holds the list; the list itself is never null in C#).
     private static string ScalarProperty(
         MetaObject owner, MetaField field, IReadOnlyList<string> pkFields,
-        bool withAttributes, ColumnNamingStrategy strategy = ColumnNamingStrategy.Literal)
+        bool withAttributes, ColumnNamingStrategy strategy = ColumnNamingStrategy.Literal,
+        string? baseTypeOverride = null)
     {
-        var baseType = CSharpNaming.ScalarFor(field.SubType)!;
+        var baseType = baseTypeOverride ?? CSharpNaming.ScalarFor(field.SubType)!;
         var propName = CSharpNaming.Pascal(field.Name);
 
         // Array fields: emit List<T> with an empty-list initializer and only a [Column]
@@ -337,6 +341,27 @@ private static string ScalarProperty(
             : $"    public {typeName}? {propName} {{ get; set; }}";
     }
 
+    // The CLR scalar type for a projection field whose value is a MIN/MAX aggregate:
+    // the result type of MIN(col)/MAX(col) in SQL is the aggregated column's own type,
+    // NOT the (often-widened) field.* declaration. e.g. MIN over an INTEGER column is
+    // INTEGER — so the projection property must materialize as `int`, which the read
+    // path then surfaces as a JSON number (vs. a BIGINT → string). COUNT/SUM widen to
+    // BIGINT and AVG to NUMERIC, both already matched by the declared field.* type, so
+    // only MIN/MAX need the source-type narrowing. Returns null (use the declared type)
+    // for non-aggregate fields, non-MIN/MAX aggregates, or an unresolvable @of target.
+    private static string? AggregateResultScalar(MetaField field, GenContext ctx)
+    {
+        var agg = field.Children().OfType<MetaAggregateOrigin>().FirstOrDefault();
+        if (agg?.Agg is not (AGGREGATE_FN_MIN or AGGREGATE_FN_MAX)) return null;
+        // @of is a dotted "Entity.field" reference to the aggregated column.
+        if (agg.Of is not { } of) return null;
+        var dot = of.LastIndexOf('.');
+        if (dot <= 0 || dot == of.Length - 1) return null;
+        var sourceObj = ctx.Root.FindObject(CSharpNaming.StripPkg(of[..dot]));
+        var sourceField = sourceObj?.FindField(of[(dot + 1)..]);
+        return sourceField is null ? null : CSharpNaming.ScalarFor(sourceField.SubType);
+    }
+
     // Transitive closure of plain value objects reachable through entity object-fields.
     private static List<MetaObject> ReferencedValueObjects(IReadOnlyList<MetaObject> mapped, GenContext ctx)
     {

server/csharp/MetaObjects.IntegrationTests/Generated/AppDbContext.g.cs

@@ -20,6 +20,7 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
     {
         modelBuilder.Entity<ProgramStat>().ToView("v_program_stat");
         modelBuilder.Entity<ProgramView>().ToView("v_program");
+        modelBuilder.Entity<ProgramView>().Property(x => x.Status).HasConversion<string>();
         modelBuilder.Entity<Asset>().Property(x => x.ExternalId).HasColumnType("uuid").HasConversion(v => Guid.Parse(v!), g => g.ToString("D"));
         modelBuilder.Entity<Asset>().Property(x => x.Payload).HasColumnType("jsonb");
         modelBuilder.Entity<Asset>().Property(x => x.RecordedAt).HasColumnType("timestamp with time zone");

server/csharp/MetaObjects.IntegrationTests/Generated/Asset.g.cs

@@ -22,4 +22,10 @@ public class Asset
     public string? Payload { get; set; }
     [Column("recordedAt")]
     public DateTime RecordedAt { get; set; }
+    [Column("observedAt")]
+    public DateTime ObservedAt { get; set; }
+    [Column("asOfDate")]
+    public DateOnly AsOfDate { get; set; }
+    [Column("atTime")]
+    public TimeOnly AtTime { get; set; }
 }

server/csharp/MetaObjects.IntegrationTests/Generated/ProgramStat.g.cs

@@ -15,4 +15,12 @@ public class ProgramStat
     public long ProgramId { get; set; }
     [Column("weekCount")]
     public long? WeekCount { get; set; }
+    [Column("totalMinutes")]
+    public long? TotalMinutes { get; set; }
+    [Column("avgMinutes")]
+    public double? AvgMinutes { get; set; }
+    [Column("minMinutes")]
+    public int? MinMinutes { get; set; }
+    [Column("maxMinutes")]
+    public int? MaxMinutes { get; set; }
 }

server/csharp/MetaObjects.IntegrationTests/Generated/Week.g.cs

@@ -19,4 +19,6 @@ public class Week
     [Column("label")]
     [MaxLength(80)]
     public string? Label { get; set; }
+    [Column("durationMinutes")]
+    public int DurationMinutes { get; set; }
 }

server/csharp/MetaObjects.IntegrationTests/Runner/Normalization.cs

@@ -43,16 +43,18 @@ public static class Normalization
         decimal dec => CanonicalDecimal(dec),
         // A jsonb/json column is read-as-string by Npgsql. Re-serialize with sorted
         // keys per the cross-port contract (normalization.md: JSON/JSONB → sorted
-        // keys). Scalar leaves are stringified so the shape matches the expect: block
-        // (YAML scalars deserialize as strings) and the corpus's string-scalar
-        // philosophy (BIGINT/NUMERIC as strings). A plain text value that does not
-        // parse as a JSON object/array stays a string.
-        string js when TryParseJsonContainer(js, out var node) => StringifyLeaves(SortKeys(node!)),
+        // keys), recursing through containers and normalizing each scalar leaf by its
+        // JSON type. Leaves keep their JSON-native shape (matching the TS authority,
+        // whose parsed-jsonb leaves stay JS numbers/booleans): integer numbers stay
+        // JSON numbers, non-integer numbers become canonical plain-decimal strings,
+        // strings/bools/null pass through. A plain text value that does not parse as a
+        // JSON object/array stays a string.
+        string js when TryParseJsonContainer(js, out var node) => NormalizeJsonContainer(node!),
         // Strings already canonical.
         string str => str,
         // Date/time discriminated by source CLR type.
         DateOnly date => date.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture),
-        TimeOnly time => time.ToString("HH:mm:ss.fffffff", CultureInfo.InvariantCulture),
+        TimeOnly time => FormatTimeOnly(time),
         DateTime dt => FormatDateTime(dt),
         DateTimeOffset dto => dto.UtcDateTime.ToString("yyyy-MM-ddTHH:mm:ss.fffK", CultureInfo.InvariantCulture)
                                             .TrimEnd('0').TrimEnd('.') + "Z",
@@ -104,15 +106,34 @@ private static string CanonicalFloat(double d)
         return s;
     }
 
-    // TIMESTAMP (no TZ) → "YYYY-MM-DDTHH:MM:SS[.fff]" with no trailing zeros and no Z.
-    // TIMESTAMPTZ comes via DateTimeOffset above and gets a Z; the bare DateTime
-    // branch never appends one.
+    // TIMESTAMP vs TIMESTAMPTZ are BOTH surfaced by Npgsql/EF as `DateTime`; the
+    // discriminator is DateTimeKind (Npgsql 6+/EF Core contract):
+    //   * `timestamp with time zone`    → DateTimeKind.Utc, value already in UTC
+    //                                      → "YYYY-MM-DDTHH:MM:SS[.fff]Z".
+    //   * `timestamp` (no tz)            → DateTimeKind.Unspecified, wall-clock value
+    //                                      → "YYYY-MM-DDTHH:MM:SS[.fff]" (no Z).
+    // This mirrors the TS port's OID-keyed temporal parsers (canonicalTimestamptz
+    // converts any offset to UTC + appends Z; canonicalTimestamp passes the wall
+    // clock through with no Z) — see fixtures/persistence-conformance/normalization.md
+    // and the TS temporal-parsers.ts. A non-UTC-seeded TIMESTAMPTZ thus reads back
+    // as its UTC equivalent, proving normalization (not just formatting).
     private static string FormatDateTime(DateTime dt)
     {
-        var withSubseconds = dt.ToString("yyyy-MM-ddTHH:mm:ss.fffffff", CultureInfo.InvariantCulture);
-        // Trim trailing zeros in the subsecond fraction, then trim the decimal point
-        // if the subsecond portion was entirely zero.
-        var s = withSubseconds.TrimEnd('0');
+        var s = TrimSubseconds(dt.ToString("yyyy-MM-ddTHH:mm:ss.fffffff", CultureInfo.InvariantCulture));
+        return dt.Kind == DateTimeKind.Utc ? s + "Z" : s;
+    }
+
+    // TIME → "HH:MM:SS[.fff]" with trailing zero subseconds (and a bare decimal
+    // point) stripped. Phase B seeds whole seconds, so this yields "HH:MM:SS".
+    private static string FormatTimeOnly(TimeOnly time) =>
+        TrimSubseconds(time.ToString("HH:mm:ss.fffffff", CultureInfo.InvariantCulture));
+
+    // Strip trailing zeros from a subsecond fraction, then drop the decimal point
+    // if the subsecond portion was entirely zero.
+    private static string TrimSubseconds(string formatted)
+    {
+        if (!formatted.Contains('.')) return formatted;
+        var s = formatted.TrimEnd('0');
         if (s.EndsWith('.')) s = s[..^1];
         return s;
     }
@@ -151,32 +172,48 @@ private static bool TryParseJsonContainer(string s, out JsonNode? node)
         catch (JsonException) { return false; }
     }
 
-    // Coerce every scalar leaf to its string form (numbers/bools → string), preserving
-    // object/array structure. Matches the expect: block, whose YAML scalars deserialize
-    // as strings, and the corpus's string-scalar normalization philosophy.
-    private static JsonNode StringifyLeaves(JsonNode node)
+    // Normalize a parsed jsonb container: sort object keys recursively and normalize
+    // each scalar leaf by its JSON type, mirroring the TS authority's recursion over
+    // parsed jsonb (normalizeValue): integer numbers stay JSON numbers, non-integer
+    // numbers become canonical plain-decimal strings (no trailing zeros), and
+    // strings/bools/null pass through unchanged. Object/array structure is preserved.
+    private static JsonNode? NormalizeJsonContainer(JsonNode node)
     {
         switch (node)
         {
             case JsonObject obj:
                 var o = new JsonObject();
-                foreach (var (k, v) in obj) o[k] = v is null ? null : StringifyLeaves(v.DeepClone());
+                foreach (var (k, v) in obj.OrderBy(p => p.Key, StringComparer.Ordinal))
+                    o[k] = v is null ? null : NormalizeJsonContainer(v.DeepClone());
                 return o;
             case JsonArray arr:
                 var a = new JsonArray();
-                foreach (var item in arr) a.Add(item is null ? null : StringifyLeaves(item.DeepClone()));
+                foreach (var item in arr) a.Add(item is null ? null : NormalizeJsonContainer(item.DeepClone()));
                 return a;
             default:
-                // JsonValue scalar → its canonical string form. Parse (not Trim('"'))
-                // so a string leaf containing embedded quotes/escapes round-trips
-                // losslessly: take the raw string value for JSON strings, and the
-                // serialized form for non-string scalars (numbers/bools/null).
-                return JsonValue.Create(node.GetValueKind() == JsonValueKind.String
-                    ? node.GetValue<string>()
-                    : node.ToJsonString());
+                return NormalizeJsonLeaf(node);
         }
     }
 
+    private static JsonNode? NormalizeJsonLeaf(JsonNode node) => node.GetValueKind() switch
+    {
+        JsonValueKind.String  => JsonValue.Create(node.GetValue<string>()),
+        JsonValueKind.True    => JsonValue.Create(true),
+        JsonValueKind.False   => JsonValue.Create(false),
+        JsonValueKind.Null    => null,
+        // Numbers: an integer-valued number stays a JSON number (INTEGER → number per
+        // the contract); a non-integer becomes the canonical plain-decimal string.
+        JsonValueKind.Number  => NormalizeJsonNumber(node),
+        _                     => node.DeepClone(),
+    };
+
+    private static JsonNode NormalizeJsonNumber(JsonNode node)
+    {
+        var element = node.GetValue<System.Text.Json.JsonElement>();
+        if (element.TryGetInt64(out var l)) return JsonValue.Create(l);
+        return JsonValue.Create(CanonicalFloat(element.GetDouble()));
+    }
+
     /// <summary>
     /// Canonical-JSON serialization of an arbitrary node: object keys sorted
     /// recursively so two semantically-equal trees compare byte-equal.

server/csharp/MetaObjects.IntegrationTests/Runner/QueryScenarioRunner.cs

@@ -15,11 +15,14 @@
 // [Column(...)], so the EF Core runtime addresses the schema's columns directly.
 // See docs/superpowers/specs/2026-05-30-ts-schema-authority-consolidation-design.md.
 
+using System.Globalization;
 using System.Text.Json.Nodes;
 using MetaObjects.IntegrationTests.Generated;
 using Microsoft.EntityFrameworkCore;
 using Npgsql;
 using Xunit.Sdk;
+using YamlDotNet.Core;
+using YamlDotNet.RepresentationModel;
 
 namespace MetaObjects.IntegrationTests.Runner;
 
@@ -80,25 +83,72 @@ private static void AssertResult(string scenarioPath, QuerySpec spec, object? ac
                 $"{scenarioPath} / {spec.Name}: result mismatch\n  expected: {expectedJson}\n  actual:   {actualJson}");
     }
 
-    private static string CanonicalizeExpected(object? expect, string op)
+    private static string CanonicalizeExpected(YamlNode? expect, string op)
     {
-        // YamlDotNet hands back nested mappings as Dictionary<object,object?> and
-        // bare scalars (including integers) as strings when the parent property is
-        // typed as object?. For `op:count` the expected is logically an integer;
-        // parse it so the comparison is number-vs-number, not string-vs-number.
+        // For `op:count` the expected is logically an integer; parse the scalar so
+        // the comparison is number-vs-number, not string-vs-number.
         if (op == "count")
         {
-            var n = expect switch
-            {
-                long l => l,
-                int i => i,
-                string s when long.TryParse(s, out var p) => p,
-                _ => throw new InvalidOperationException($"op:count expects an integer, got: {expect}"),
-            };
-            return n.ToString(System.Globalization.CultureInfo.InvariantCulture);
+            var raw = (expect as YamlScalarNode)?.Value;
+            if (raw is null || !long.TryParse(raw, NumberStyles.Integer, CultureInfo.InvariantCulture, out var n))
+                throw new InvalidOperationException($"op:count expects an integer, got: {raw ?? "null"}");
+            return n.ToString(CultureInfo.InvariantCulture);
         }
-        var node = ToJsonNode(expect);
-        return Canonical(node);
+        return Canonical(YamlExpectToJsonNode(expect));
+    }
+
+    // Convert the raw `expect:` YAML subtree to a JsonNode, honoring scalar STYLE so
+    // the comparison matches the wire contract (normalization.md): a plain (unquoted)
+    // scalar is YAML-core-schema-inferred (45 → number, true → bool, null/~ → null),
+    // while a QUOTED scalar is always a JSON string ("45" → "45"). This is exactly the
+    // type inference the TS authority's JS YAML loader performs; without it every
+    // INTEGER-typed expectation would degrade to a string and never match the
+    // number-shaped actual rows.
+    private static JsonNode? YamlExpectToJsonNode(YamlNode? node)
+    {
+        switch (node)
+        {
+            case null:
+            case YamlScalarNode { Value: null }:
+                return null;
+            case YamlScalarNode scalar:
+                return ScalarToJsonNode(scalar);
+            case YamlMappingNode map:
+                var obj = new JsonObject();
+                foreach (var (k, v) in map.Children)
+                    obj[((YamlScalarNode)k).Value!] = YamlExpectToJsonNode(v);
+                return obj;
+            case YamlSequenceNode seq:
+                var arr = new JsonArray();
+                foreach (var item in seq.Children) arr.Add(YamlExpectToJsonNode(item));
+                return arr;
+            default:
+                throw new InvalidOperationException($"unsupported YAML node kind in expect: {node.GetType().Name}");
+        }
+    }
+
+    // A quoted scalar is always a string. A plain scalar follows YAML core-schema
+    // inference: null/~ → null, true/false → bool, integer → long, otherwise the
+    // literal string (NUMERIC/BIGINT/UUID/float values are authored as strings, so
+    // floats and big integers stay strings here and the contract's string forms hold).
+    private static JsonNode? ScalarToJsonNode(YamlScalarNode scalar)
+    {
+        var value = scalar.Value!;
+        var quoted = scalar.Style is ScalarStyle.SingleQuoted or ScalarStyle.DoubleQuoted;
+        if (quoted) return JsonValue.Create(value);
+
+        switch (value)
+        {
+            case "" or "~" or "null" or "Null" or "NULL":
+                return null;
+            case "true" or "True" or "TRUE":
+                return JsonValue.Create(true);
+            case "false" or "False" or "FALSE":
+                return JsonValue.Create(false);
+        }
+        if (long.TryParse(value, NumberStyles.AllowLeadingSign, CultureInfo.InvariantCulture, out var l))
+            return JsonValue.Create(l);
+        return JsonValue.Create(value);
     }
 
     private static string CanonicalizeActual(object? actual, string op)

server/csharp/MetaObjects.IntegrationTests/Runner/Scenario.cs

@@ -4,6 +4,8 @@
 //
 // ScenarioLoader parses YAML into these records. The runners consume them.
 
+using YamlDotNet.RepresentationModel;
+
 namespace MetaObjects.IntegrationTests.Runner;
 
 /// <summary>Base type for any scenario in the corpus.</summary>
@@ -28,6 +30,6 @@ public sealed record QuerySpec(
     IReadOnlyList<SortSpec>? Sort,
     int? Limit,
     int? Offset,
-    object? Expect);                          // shape depends on Op (list → array, get → object|null, count → int)
+    YamlNode? Expect);                        // raw YAML subtree (scalar style preserved); shape depends on Op
 
 public sealed record SortSpec(string Field, string Dir);   // dir: asc | desc