feat(migrate-ts): R6 — field.float emits REAL; stringify REAL/DOUBLE on the wire

Add a distinct `real4` SqlType variant for single-precision (REAL / float4)
to separate it from `real` (DOUBLE PRECISION / float8). Route field.float to
real4 and field.double to real. Render real4 as REAL in both postgres and
sqlite emitters. Split pgTypeToSqlType so float4/real → real4 and
float8/double precision → real, ensuring no phantom diffs after a round-trip.

Update the persistence-conformance normalization rule: integer-valued JS
numbers stay as JSON numbers; non-integer JS numbers (REAL/DOUBLE columns)
stringify via canonicalFloat() — plain decimal, trailing zeros stripped.

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

Author: dmealing

server/typescript/packages/integration-tests/src/normalization.ts

@@ -20,7 +20,11 @@ const UUID_RE = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0
 export function normalizeValue(v: unknown): unknown {
   if (v === null || v === undefined) return null;
   if (typeof v === "boolean") return v;
-  if (typeof v === "number") return v;
+  // INTEGER/SMALLINT come back as integer-valued JS numbers → keep as JSON number.
+  // REAL/DOUBLE come back as non-integer JS numbers → stringify (plain decimal, strip zeros).
+  // (The runner sees an already-mapped row with no column-type metadata; fixtures pin
+  // float/double values to be non-integer so this value-route is exact — see normalization.md.)
+  if (typeof v === "number") return Number.isInteger(v) ? v : canonicalFloat(v);
   // node-postgres returns BIGINT as string by default — leave as string (contract).
   if (typeof v === "bigint") return v.toString();
   if (typeof v === "string") {
@@ -60,6 +64,16 @@ function canonicalDecimal(s: string): string {
   return out;
 }
 
+function canonicalFloat(n: number): string {
+  // In-band dyadic values (per normalization.md) render plain + shortest via String().
+  let out = String(n);
+  if (out.includes(".")) {
+    out = out.replace(/0+$/, "");
+    if (out.endsWith(".")) out = out.slice(0, -1);
+  }
+  return out;
+}
+
 // Format a Date as YYYY-MM-DDTHH:MM:SS[.fff] using UTC getters so the output
 // is independent of the runner's host timezone. Trailing zero subseconds are
 // trimmed; the decimal point goes too if the subseconds were entirely zero.

server/typescript/packages/migrate-ts/src/emit/postgres.ts

@@ -147,6 +147,7 @@ function pgType(t: SqlType): string {
     case "text":      return t.maxLength !== undefined ? `VARCHAR(${t.maxLength})` : "TEXT";
     case "integer":   return t.bits === 64 ? "BIGINT" : "INTEGER";
     case "real":      return "DOUBLE PRECISION";
+    case "real4":     return "REAL";
     case "numeric":   {
       if (t.precision !== undefined && t.scale !== undefined) return `NUMERIC(${t.precision},${t.scale})`;
       if (t.precision !== undefined) return `NUMERIC(${t.precision})`;

server/typescript/packages/migrate-ts/src/emit/sqlite.ts

@@ -278,6 +278,7 @@ function sqliteType(t: SqlType, identity: ColumnDescriptor["identity"]): string
     // in pragma_table_info, enabling round-trip fidelity (see introspect/sqlite.ts).
     case "integer":   return t.bits === 64 ? "INTEGER" : "INT";
     case "real":      return "REAL";
+    case "real4":     return "REAL";
     case "numeric":   {
       if (t.precision !== undefined && t.scale !== undefined) return `NUMERIC(${t.precision},${t.scale})`;
       return "NUMERIC";

server/typescript/packages/migrate-ts/src/expected-schema.ts

@@ -380,8 +380,8 @@ function subtypeToSqlType(field: MetaData): SqlType {
     case FIELD_SUBTYPE_BYTE:      return { kind: "integer", bits: 32 };
     case FIELD_SUBTYPE_LONG:
     case FIELD_SUBTYPE_CURRENCY:  return { kind: "integer", bits: 64 };
-    case FIELD_SUBTYPE_DOUBLE:
-    case FIELD_SUBTYPE_FLOAT:     return { kind: "real" };
+    case FIELD_SUBTYPE_DOUBLE:    return { kind: "real" };
+    case FIELD_SUBTYPE_FLOAT:     return { kind: "real4" };
     case FIELD_SUBTYPE_DECIMAL:   return { kind: "numeric" };
     case FIELD_SUBTYPE_BOOLEAN:   return { kind: "boolean" };
     case FIELD_SUBTYPE_DATE:      return { kind: "date" };

server/typescript/packages/migrate-ts/src/introspect/postgres.ts

@@ -103,8 +103,8 @@ export function pgTypeToSqlType(dataType: string, maxLength?: number | null): Sq
     return { kind: "integer", bits: 32 };
   }
 
-  // Floating-point
-  if (dt === "float4" || dt === "real") return { kind: "real" };
+  // Floating-point: float4/real is single precision; float8/double precision is double.
+  if (dt === "float4" || dt === "real") return { kind: "real4" };
   if (dt === "float8" || dt === "double precision") return { kind: "real" };
 
   // Arbitrary-precision numeric — "numeric(p,s)" or bare "numeric"/"decimal"

server/typescript/packages/migrate-ts/src/sql-type.ts

@@ -8,7 +8,8 @@
 export type SqlType =
   | { kind: "text"; maxLength?: number }
   | { kind: "integer"; bits: 32 | 64 }
-  | { kind: "real" }
+  | { kind: "real" }        // DOUBLE PRECISION (float8) — field.double
+  | { kind: "real4" }       // REAL (float4, single precision) — field.float
   | { kind: "numeric"; precision?: number; scale?: number }
   | { kind: "boolean" }
   | { kind: "timestamp"; withTimezone: boolean }
@@ -32,6 +33,7 @@ export function sqlTypeEquals(a: SqlType, b: SqlType): boolean {
     case "timestamp":
       return a.withTimezone === (b as Extract<SqlType, { kind: "timestamp" }>).withTimezone;
     case "real":
+    case "real4":
     case "boolean":
     case "date":
     case "json":
@@ -76,10 +78,11 @@ export function isWidening(from: SqlType, to: SqlType): boolean {
       // widening iff p2 ≥ p1 AND s2 = s1 AND (p2 - s2) ≥ (p1 - s1)
       return tp >= fp && ts === fs && (tp - ts) >= (fp - fs);
     }
-    // real/boolean/date/json/blob/uuid: same kind already handled by sqlTypeEquals;
+    // real/real4/boolean/date/json/blob/uuid: same kind already handled by sqlTypeEquals;
     // any difference here means the discriminant matched but structural equality failed
     // (impossible given SqlType has no other variants for these kinds). Defensive false.
     case "real":
+    case "real4":
     case "boolean":
     case "date":
     case "json":

server/typescript/packages/migrate-ts/test/integration/postgres-introspect.test.ts

@@ -419,14 +419,22 @@ describe("pgTypeToSqlType normalization", () => {
     expect(pgTypeToSqlType("numeric")).toEqual({ kind: "numeric" });
   });
 
-  test("float4 → real", () => {
-    expect(pgTypeToSqlType("float4")).toEqual({ kind: "real" });
+  test("float4 → real4 (single-precision)", () => {
+    expect(pgTypeToSqlType("float4")).toEqual({ kind: "real4" });
   });
 
-  test("double precision → real", () => {
+  test("real (pg alias for float4) → real4 (single-precision)", () => {
+    expect(pgTypeToSqlType("real")).toEqual({ kind: "real4" });
+  });
+
+  test("double precision → real (double-precision)", () => {
     expect(pgTypeToSqlType("double precision")).toEqual({ kind: "real" });
   });
 
+  test("float8 (pg alias for double precision) → real (double-precision)", () => {
+    expect(pgTypeToSqlType("float8")).toEqual({ kind: "real" });
+  });
+
   test("unknown type falls back to text", () => {
     expect(pgTypeToSqlType("citext")).toEqual({ kind: "text" });
   });