feat(codegen-kotlin): R6 — field.float maps to REAL; stringify REAL/DOUBLE on the wire

Adds a FloatField arm to KotlinTypeMapper so field.float (float4, single precision)
maps to Kotlin Float / Exposed float() -> Postgres REAL, distinct from field.double
(float8) -> Double / double() -> DOUBLE PRECISION. Previously field.float threw
"unsupported". Mirrors the committed TS/C#/Python/Java R6 ports.

- KotlinTypeMapper: FloatField + kotlinpoet FLOAT imports; `is FloatField -> FLOAT`
  in kotlinTypeName and `is FloatField -> float("col")` in exposedColumnSpec.
- integration-tests-kotlin Normalization: canonicalFloat stringifies REAL/DOUBLE on
  the wire and fails loudly on out-of-band (exponential) values — a near-exact mirror
  of the Java Normalization.canonicalFloatStr (the plan's bare stripZeros predates
  that cross-port hardening and would silently corrupt exponential strings).
- Tests: KotlinTypeMapper FloatField -> FLOAT / float-column arms; canonicalFloat
  in-band/strip/throw cases mirroring the Java + TS suites.

Note: KotlinStoredProcGenerator still lacks a FloatField arm (float as a stored-proc
param/result throws) — out of R6 scope, not a regression, and matches the cross-port
reference; left as a documented follow-up.

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

Author: dmealing

server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinTypeMapper.kt

@@ -5,6 +5,7 @@ import com.metaobjects.field.CurrencyField
 import com.metaobjects.field.DateField
 import com.metaobjects.field.DoubleField
 import com.metaobjects.field.EnumField
+import com.metaobjects.field.FloatField
 import com.metaobjects.field.IntegerField
 import com.metaobjects.field.LongField
 import com.metaobjects.field.MetaField
@@ -14,6 +15,7 @@ import com.metaobjects.`object`.MetaObject
 import com.squareup.kotlinpoet.BOOLEAN
 import com.squareup.kotlinpoet.ClassName
 import com.squareup.kotlinpoet.DOUBLE
+import com.squareup.kotlinpoet.FLOAT
 import com.squareup.kotlinpoet.INT
 import com.squareup.kotlinpoet.LONG
 import com.squareup.kotlinpoet.STRING
@@ -129,6 +131,9 @@ object KotlinTypeMapper {
         is IntegerField   -> INT
         is LongField      -> LONG
         is DoubleField    -> DOUBLE
+        // REAL (float4) — distinct single-precision arm so field.float round-trips as
+        // Kotlin Float / Exposed REAL, separate from field.double (float8). See R6.
+        is FloatField     -> FLOAT
         is BooleanField   -> BOOLEAN
         is DateField      -> ClassName("java.time", "LocalDate")
         is TimestampField -> ClassName("java.time", "Instant")
@@ -226,6 +231,9 @@ object KotlinTypeMapper {
         is IntegerField   -> "integer(\"$colName\")"
         is LongField      -> "long(\"$colName\")"
         is DoubleField    -> "double(\"$colName\")"
+        // Exposed `float(name)` maps to Postgres REAL (float4); `double` maps to
+        // DOUBLE PRECISION (float8). Keeps field.float distinct on the wire. See R6.
+        is FloatField     -> "float(\"$colName\")"
         is BooleanField   -> "bool(\"$colName\")"
         is DateField      -> "date(\"$colName\")"
         // Default for field.timestamp is plain `timestamp(...)` — Postgres `timestamp

server/java/codegen-kotlin/src/test/kotlin/com/metaobjects/generator/kotlin/KotlinTypeMapperTest.kt

@@ -8,6 +8,7 @@ import com.metaobjects.field.CurrencyField
 import com.metaobjects.field.DateField
 import com.metaobjects.field.DoubleField
 import com.metaobjects.field.EnumField
+import com.metaobjects.field.FloatField
 import com.metaobjects.field.IntegerField
 import com.metaobjects.field.LongField
 import com.metaobjects.field.PrimitiveField
@@ -17,6 +18,7 @@ import com.metaobjects.metadata.ktx.loadString
 import com.squareup.kotlinpoet.BOOLEAN
 import com.squareup.kotlinpoet.ClassName
 import com.squareup.kotlinpoet.DOUBLE
+import com.squareup.kotlinpoet.FLOAT
 import com.squareup.kotlinpoet.INT
 import com.squareup.kotlinpoet.LONG
 import com.squareup.kotlinpoet.STRING
@@ -54,6 +56,11 @@ class KotlinTypeMapperTest {
         assertEquals(DOUBLE, KotlinTypeMapper.kotlinTypeName(f))
     }
 
+    @Test fun `float field maps to Float`() {
+        val f = FloatField("weight")
+        assertEquals(FLOAT, KotlinTypeMapper.kotlinTypeName(f))
+    }
+
     @Test fun `boolean field maps to Boolean`() {
         val f = BooleanField("active")
         assertEquals(BOOLEAN, KotlinTypeMapper.kotlinTypeName(f))
@@ -101,6 +108,11 @@ class KotlinTypeMapperTest {
         assertEquals("double(\"ratio\")", KotlinTypeMapper.exposedColumnSpec(f))
     }
 
+    @Test fun `float field maps to float exposed column`() {
+        val f = FloatField("weight")
+        assertEquals("float(\"weight\")", KotlinTypeMapper.exposedColumnSpec(f))
+    }
+
     @Test fun `date field maps to date exposed column`() {
         val f = DateField("birthday")
         assertEquals("date(\"birthday\")", KotlinTypeMapper.exposedColumnSpec(f))

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

@@ -39,8 +39,8 @@ object Normalization {
         is Int -> v
         is Short -> v.toInt()
         is Byte -> v.toInt()
-        is Float -> v.toDouble()
-        is Double -> v
+        is Float -> canonicalFloat(v)
+        is Double -> canonicalFloat(v)
         is BigDecimal -> canonicalDecimal(v)
         is UUID -> v.toString().lowercase()
         is ByteArray -> Base64.getEncoder().encodeToString(v)
@@ -64,6 +64,22 @@ object Normalization {
         return if (s.contains(".") || !s.contains("E")) s else BigDecimal(s).toPlainString()
     }
 
+    /** REAL → canonical plain-decimal string, from the single (no widening tail). */
+    private fun canonicalFloat(f: Float): String = canonicalFloatStr(f.toString(), f)
+    /** DOUBLE → canonical plain-decimal string. */
+    private fun canonicalFloat(d: Double): String = canonicalFloatStr(d.toString(), d)
+    private fun canonicalFloatStr(s: String, v: Any): String {
+        require(!s.contains('E') && !s.contains('e')) {
+            "canonicalFloat: $v is outside the plain-decimal band (exponential notation); " +
+                "REAL/DOUBLE fixture values must be in-band dyadic rationals — " +
+                "see fixtures/persistence-conformance/normalization.md"
+        }
+        if (!s.contains('.')) return s
+        var out = s.trimEnd('0')
+        if (out.endsWith(".")) out = out.dropLast(1)
+        return out
+    }
+
     fun canonicalRowsJson(rows: List<Map<String, Any?>>): String {
         val normalized = rows.map { normalizeRow(it) }
         return String(mapper.writeValueAsBytes(normalized), StandardCharsets.UTF_8)

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

@@ -0,0 +1,28 @@
+package com.metaobjects.integration.kotlin
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFailsWith
+
+/**
+ * R6: REAL/DOUBLE wire normalization (mirror of the TS `normalization.test.ts` and Java
+ * `NormalizationFloatTest` cases). [Normalization.normalizeValue] routes Float/Double through
+ * the canonical-float stringifier: in-band values become plain-decimal strings (trailing zeros
+ * + bare decimal point stripped); out-of-band (exponential) values fail loudly so a bad fixture
+ * surfaces immediately instead of silently corrupting the cross-port byte-equality compare.
+ */
+class NormalizationFloatTest {
+    @Test fun `in-band float is plain decimal string`() {
+        assertEquals("1.5", Normalization.normalizeValue(1.5f))   // REAL (float4)
+        assertEquals("0.25", Normalization.normalizeValue(0.25)) // DOUBLE (float8)
+    }
+    @Test fun `integer-valued double strips trailing zero and point`() {
+        assertEquals("2", Normalization.normalizeValue(2.0)) // "2.0" -> "2." -> "2"
+    }
+    @Test fun `out-of-band double throws`() {
+        assertFailsWith<IllegalArgumentException> { Normalization.normalizeValue(1.0e-10) } // "1.0E-10"
+    }
+    @Test fun `out-of-band float throws`() {
+        assertFailsWith<IllegalArgumentException> { Normalization.normalizeValue(1.0e-10f) } // "1.0E-10"
+    }
+}