fix(migrate-ts): R6 — collapse real4→real for SQLite (no phantom float diff)

SQLite has one float storage class; the real4/real (REAL vs DOUBLE PRECISION)
distinction is Postgres-only. Normalize real4→real in the SQLite dialect pass so
a field.float column round-trips without a spurious change-column-type diff.

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

Author: dmealing

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

@@ -148,6 +148,13 @@ function normalizeForSqlite(sqlType: SqlType): SqlType {
       // plain "INTEGER" regardless of source bit-width. Collapse 32 → 64 so the
       // expected snapshot matches what introspection sees.
       return { kind: "integer", bits: 64 };
+    case "real4":
+      // SQLite has a single float storage class ("REAL"); it cannot distinguish
+      // single-precision (real4 / field.float) from double-precision (real /
+      // field.double). Collapse real4 → real so the expected snapshot matches
+      // what the SQLite introspector produces, preventing a phantom
+      // change-column-type diff on every field.float column.
+      return { kind: "real" };
     default:
       return sqlType;
   }

server/typescript/packages/migrate-ts/test/unit/expected-schema.test.ts

@@ -134,6 +134,77 @@ describe("buildExpectedSchema — indexes + FKs", () => {
   });
 });
 
+describe("buildExpectedSchema — SQLite float normalization (R6)", () => {
+  async function loadInline(children: unknown[]) {
+    const json = JSON.stringify({ "metadata.root": { package: "test", children } });
+    const result = await new MetaDataLoader().load([new InMemoryStringSource(json)]);
+    if (result.errors.length > 0) {
+      throw new Error(`Loader errors:\n${result.errors.map((e) => e.message).join("\n")}`);
+    }
+    return result.root;
+  }
+
+  test("field.float → sqlType {kind:'real'} under sqlite (real4 collapsed, no phantom diff)", async () => {
+    const root = await loadInline([
+      {
+        "object.entity": {
+          name: "Measurement",
+          children: [
+            { "source.rdb": { "@table": "measurements" } },
+            { "field.long":  { name: "id" } },
+            { "field.float": { name: "score" } },
+            { "identity.primary": { "@fields": "id" } },
+          ],
+        },
+      },
+    ]);
+    const snapshot = buildExpectedSchema(root, { dialect: "sqlite" });
+    const scoreCol = snapshot.tables[0]?.columns.find((c) => c.name === "score");
+    // SQLite has one float storage class; real4 must be collapsed to real so the
+    // expected schema matches what the SQLite introspector produces ({kind:"real"}).
+    expect(scoreCol?.sqlType).toEqual({ kind: "real" });
+  });
+
+  test("field.double → sqlType {kind:'real'} under sqlite (already real, unaffected)", async () => {
+    const root = await loadInline([
+      {
+        "object.entity": {
+          name: "Measurement",
+          children: [
+            { "source.rdb": { "@table": "measurements" } },
+            { "field.long":   { name: "id" } },
+            { "field.double": { name: "value" } },
+            { "identity.primary": { "@fields": "id" } },
+          ],
+        },
+      },
+    ]);
+    const snapshot = buildExpectedSchema(root, { dialect: "sqlite" });
+    const valueCol = snapshot.tables[0]?.columns.find((c) => c.name === "value");
+    expect(valueCol?.sqlType).toEqual({ kind: "real" });
+  });
+
+  test("field.float → sqlType {kind:'real4'} under postgres (Postgres fidelity preserved)", async () => {
+    const root = await loadInline([
+      {
+        "object.entity": {
+          name: "Measurement",
+          children: [
+            { "source.rdb": { "@table": "measurements" } },
+            { "field.long":  { name: "id" } },
+            { "field.float": { name: "score" } },
+            { "identity.primary": { "@fields": "id" } },
+          ],
+        },
+      },
+    ]);
+    const snapshot = buildExpectedSchema(root, { dialect: "postgres" });
+    const scoreCol = snapshot.tables[0]?.columns.find((c) => c.name === "score");
+    // Postgres can distinguish REAL (single) from DOUBLE PRECISION; real4 must not be collapsed.
+    expect(scoreCol?.sqlType).toEqual({ kind: "real4" });
+  });
+});
+
 describe("buildExpectedSchema — identity.reference @enforce", () => {
   async function loadInline(children: unknown[]) {
     const json = JSON.stringify({ "metadata.root": { package: "test", children } });