fix(integration-tests): R6 — canonicalFloat fails loudly on out-of-band (exponential) floats

Strips trailing zeros only for plain-decimal strings; throws on exponential
notation so an out-of-band REAL/DOUBLE fixture value surfaces immediately rather
than silently corrupting. Adds unit tests for the in-band/integer/bigint/throw cases.

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

Author: dmealing

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

@@ -64,14 +64,22 @@ function canonicalDecimal(s: string): string {
   return out;
 }
 
-function canonicalFloat(n: number): string {
+export 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);
+  // Out-of-band values (exponential notation) are forbidden by the wire contract;
+  // throw immediately so an authoring error surfaces loudly rather than silently
+  // corrupting the exponent digits during the trailing-zero strip.
+  const out = String(n);
+  if (/[eE]/.test(out)) {
+    throw new Error(
+      `canonicalFloat: ${n} is outside the plain-decimal band (exponential notation); ` +
+        `REAL/DOUBLE fixture values must be in-band dyadic rationals — ` +
+        `see fixtures/persistence-conformance/normalization.md`,
+    );
   }
-  return out;
+  if (!out.includes(".")) return out;
+  const stripped = out.replace(/0+$/, "");
+  return stripped.endsWith(".") ? stripped.slice(0, -1) : stripped;
 }
 
 // Format a Date as YYYY-MM-DDTHH:MM:SS[.fff] using UTC getters so the output

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

@@ -0,0 +1,55 @@
+// Unit tests for normalization helpers — no DB required.
+
+import { describe, test, expect } from "bun:test";
+import { normalizeValue, canonicalFloat } from "../src/normalization.ts";
+
+describe("normalizeValue — floats (REAL/DOUBLE)", () => {
+  test("1.5 → '1.5'", () => {
+    expect(normalizeValue(1.5)).toBe("1.5");
+  });
+
+  test("0.125 → '0.125'", () => {
+    expect(normalizeValue(0.125)).toBe("0.125");
+  });
+
+  test("-3.25 → '-3.25'", () => {
+    expect(normalizeValue(-3.25)).toBe("-3.25");
+  });
+
+  test("1234.5 → '1234.5'", () => {
+    expect(normalizeValue(1234.5)).toBe("1234.5");
+  });
+
+  test("trailing zeros are stripped: 1.500 → '1.5'", () => {
+    // JS String() already produces '1.5' for 1.5, but canonicalFloat handles the strip
+    expect(canonicalFloat(1.5)).toBe("1.5");
+  });
+});
+
+describe("normalizeValue — integers", () => {
+  test("100 stays as number 100", () => {
+    expect(normalizeValue(100)).toBe(100);
+  });
+
+  test("0 stays as number 0", () => {
+    expect(normalizeValue(0)).toBe(0);
+  });
+});
+
+describe("normalizeValue — bigint", () => {
+  test("123n → '123' (string)", () => {
+    expect(normalizeValue(123n)).toBe("123");
+  });
+});
+
+describe("canonicalFloat — out-of-band guard", () => {
+  test("1.5e-10 throws (exponential notation)", () => {
+    expect(() => canonicalFloat(1.5e-10)).toThrow(
+      "canonicalFloat: 1.5e-10 is outside the plain-decimal band (exponential notation)",
+    );
+  });
+
+  test("normalizeValue(1.5e-10) propagates the throw", () => {
+    expect(() => normalizeValue(1.5e-10)).toThrow();
+  });
+});