test(persistence-conformance): R6 — Measurement entity exercises REAL/DOUBLE round-trip

Adds the cross-port end-to-end proof for R6 float fidelity: a Measurement entity
(tempC field.float → REAL, massKg field.double → DOUBLE PRECISION) to the shared
persistence corpus, plus a float round-trip query scenario. All five ports
(TS/C#/Java/Python/Kotlin) create the table and round-trip the values byte-identically
against Testcontainers Postgres.

- canonical/meta.fitness.json: + Measurement (id, tempC float, massKg double).
- queries/measurement-floats.yaml: get + list assert REAL/DOUBLE values round-trip as
  canonical plain-decimal strings. Seed values (1.5, 0.125, -3.25, 1234.5) are dyadic
  rationals exact in BOTH float4 and float8, so normalization is byte-identical regardless
  of a driver's native float width.
- migrations/bootstrap-canonical-from-empty.yaml: + measurements table, + base-table row,
  AND column-type assertions ("tempC" REAL / "massKg" DOUBLE PRECISION). The type
  assertions are load-bearing: because the seed values are exact in both precisions, the
  value round-trip alone cannot catch a port that wrongly emits DOUBLE for field.float —
  the DDL-type check is what gates the REAL vs DOUBLE distinction across the SQL ports.

Per-port entity binding (OO ports need a native registration; TS/Java/Python auto-discover
from metadata):
- C#: Generated/Measurement.g.cs (EF entity, tempC→float/massKg→double) + DbSet.
- Kotlin: tables/MeasurementTable.kt (Exposed float()/double()); registered in the query
  + migration runners; KotlinCodegenMatchesReferenceTest gains a Measurement expectation
  that verifies the generator emits the float()/double() column families (Kotlin's REAL/
  DOUBLE type gate, since it uses Exposed create rather than emitted SQL).

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

Author: dmealing

fixtures/persistence-conformance/canonical/meta.fitness.json

@@ -27,6 +27,16 @@
           { "identity.reference": { "name": "fkProgram", "@fields": "programId", "@references": "Program" } }
         ]
       }},
+      { "object.entity": {
+        "name": "Measurement",
+        "children": [
+          { "source.rdb": { "@table": "measurements" } },
+          { "field.long":   { "name": "id" } },
+          { "field.float":  { "name": "tempC",  "@required": true } },
+          { "field.double": { "name": "massKg", "@required": true } },
+          { "identity.primary": { "@fields": "id", "@generation": "increment" } }
+        ]
+      }},
       { "object.entity": {
         "name": "ProgramView",
         "children": [

fixtures/persistence-conformance/migrations/bootstrap-canonical-from-empty.yaml

@@ -15,6 +15,13 @@ expect:
     - 'CONSTRAINT "programs_pkey" PRIMARY KEY ("id")'
     - 'CREATE TABLE "weeks"'
     - 'CONSTRAINT "weeks_pkey" PRIMARY KEY ("id")'
+    - 'CREATE TABLE "measurements"'
+    # R6 float fidelity: field.float → REAL (float4), field.double → DOUBLE PRECISION
+    # (float8). Asserting the column types here (not just the round-trip, which is
+    # value-identical for in-band dyadic rationals) is what makes this corpus catch a
+    # REAL→DOUBLE regression.
+    - '"tempC" REAL'
+    - '"massKg" DOUBLE PRECISION'
     - 'CREATE UNIQUE INDEX "byTitle" ON "programs" ("title");'
     - 'ALTER TABLE "weeks" ADD CONSTRAINT "weeks_programId_fk"'
     # Match both TS (`CREATE VIEW`) and C# (`CREATE OR REPLACE VIEW`, idempotent)
@@ -29,5 +36,6 @@ expect:
        WHERE table_schema = 'public' AND table_type = 'BASE TABLE'
        ORDER BY table_name
     rows:
+      - { table_name: "measurements" }
       - { table_name: "programs" }
       - { table_name: "weeks" }

fixtures/persistence-conformance/queries/measurement-floats.yaml

@@ -0,0 +1,25 @@
+name: measurement-floats
+description: |
+  REAL (field.float, float4) and DOUBLE PRECISION (field.double, float8) round-trip
+  as canonical plain-decimal strings — no trailing zeros, no exponential notation.
+  Seed values are in-band dyadic rationals (exactly representable in float4/float8),
+  so every port must surface byte-identical normalized rows regardless of its driver's
+  native float type. This is the end-to-end proof of the R6 float-fidelity contract.
+seed-data: |
+  INSERT INTO "measurements" ("id", "tempC", "massKg") VALUES
+    (1,  1.5,  0.125),
+    (2, -3.25, 1234.5);
+queries:
+  - name: get-measurement-1
+    op: get
+    entity: Measurement
+    by: { id: 1 }
+    expect: { id: "1", tempC: "1.5", massKg: "0.125" }
+
+  - name: list-measurements-by-id-asc
+    op: list
+    entity: Measurement
+    sort: [{ field: id, dir: asc }]
+    expect:
+      - { id: "1", tempC: "1.5",   massKg: "0.125" }
+      - { id: "2", tempC: "-3.25", massKg: "1234.5" }

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

@@ -9,6 +9,7 @@ public class AppDbContext : DbContext
 {
     public AppDbContext(DbContextOptions<AppDbContext> options) : base(options) { }
 
+    public DbSet<Measurement> Measurements { get; set; } = default!;
     public DbSet<Program> Programs { get; set; } = default!;
     public DbSet<ProgramStat> ProgramStats { get; set; } = default!;
     public DbSet<ProgramView> ProgramViews { get; set; } = default!;

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

@@ -0,0 +1,21 @@
+// <auto-generated/>
+// Generated by MetaObjects entity-generator. Do not edit by hand.
+#nullable enable
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace MetaObjects.IntegrationTests.Generated;
+
+[Table("measurements")]
+public class Measurement
+{
+    [Key]
+    [Column("id")]
+    public long Id { get; set; }
+    [Column("tempC")]
+    public float TempC { get; set; }
+    [Column("massKg")]
+    public double MassKg { get; set; }
+}

server/java/integration-tests-kotlin/src/test/kotlin/com/metaobjects/integration/kotlin/KotlinCodegenMatchesReferenceTest.kt

@@ -48,6 +48,16 @@ internal class KotlinCodegenMatchesReferenceTest {
                 ExpectedFk(columnName = "programId", targetTable = "ProgramTable"),
             ),
         ),
+        // R6 float fidelity: field.float → Exposed `float(...)` (REAL),
+        // field.double → `double(...)` (DOUBLE PRECISION). Verifies the generator
+        // emits the distinct single/double-precision column families.
+        "Measurement" to EntityExpectation(
+            columns = listOf(
+                ExpectedColumn("id", families = setOf("long")),
+                ExpectedColumn("tempC", families = setOf("float")),
+                ExpectedColumn("massKg", families = setOf("double")),
+            ),
+        ),
         "ProgramView" to EntityExpectation(
             columns = listOf(
                 ExpectedColumn("id", families = setOf("long")),

server/java/integration-tests-kotlin/src/test/kotlin/com/metaobjects/integration/kotlin/MigrationScenarioConformanceTest.kt

@@ -1,5 +1,6 @@
 package com.metaobjects.integration.kotlin
 
+import com.metaobjects.integration.kotlin.tables.MeasurementTable
 import com.metaobjects.integration.kotlin.tables.ProgramTable
 import com.metaobjects.integration.kotlin.tables.ProgramV1Table
 import com.metaobjects.integration.kotlin.tables.ProgramV2Table
@@ -56,7 +57,7 @@ internal class MigrationScenarioConformanceTest {
             // 1. Apply the canonical schema via Exposed's full-CREATE path —
             //    Exposed's analogue of the sibling SchemaMigrationEngine.emit() flow.
             transaction(db) {
-                SchemaUtils.create(ProgramTable, WeekTable)
+                SchemaUtils.create(ProgramTable, WeekTable, MeasurementTable)
             }
 
             // 2. Run the scenario's apply-up-then-query post-condition: it queries

server/java/integration-tests-kotlin/src/test/kotlin/com/metaobjects/integration/kotlin/QueryScenarioRunner.kt

@@ -2,6 +2,7 @@ package com.metaobjects.integration.kotlin
 
 import com.metaobjects.integration.kotlin.Scenarios.QueryScenario
 import com.metaobjects.integration.kotlin.Scenarios.QuerySpec
+import com.metaobjects.integration.kotlin.tables.MeasurementTable
 import com.metaobjects.integration.kotlin.tables.ProgramStatView
 import com.metaobjects.integration.kotlin.tables.ProgramTable
 import com.metaobjects.integration.kotlin.tables.WeekTable
@@ -49,7 +50,7 @@ object QueryScenarioRunner {
         val db = Database.connect(pg.jdbcUrl, user = pg.username, password = pg.password)
 
         transaction(db) {
-            SchemaUtils.create(ProgramTable, WeekTable)
+            SchemaUtils.create(ProgramTable, WeekTable, MeasurementTable)
         }
 
         // 2. Seed via the YAML's raw SQL — runs outside Exposed transactions, on a
@@ -109,6 +110,7 @@ object QueryScenarioRunner {
     private fun tableFor(entity: String): Table = when (entity) {
         "Program" -> ProgramTable
         "Week" -> WeekTable
+        "Measurement" -> MeasurementTable
         "ProgramStat" -> ProgramStatView
         else -> error("No Exposed Table registered for entity '$entity' — extend QueryScenarioRunner.tableFor")
     }

server/java/integration-tests-kotlin/src/test/kotlin/com/metaobjects/integration/kotlin/tables/MeasurementTable.kt

@@ -0,0 +1,20 @@
+package com.metaobjects.integration.kotlin.tables
+
+import org.jetbrains.exposed.sql.Table
+
+/**
+ * Hand-written reference Exposed Table mirroring `Measurement` from
+ * `fixtures/persistence-conformance/canonical/meta.fitness.json`.
+ *
+ *  - `field.float`  → `float`  (REAL / float4, single precision)
+ *  - `field.double` → `double` (DOUBLE PRECISION / float8)
+ *
+ * The two floating columns are the R6 float-fidelity round-trip subject.
+ */
+object MeasurementTable : Table("measurements") {
+    val id = long("id").autoIncrement()
+    val tempC = float("tempC")
+    val massKg = double("massKg")
+
+    override val primaryKey = PrimaryKey(id)
+}