fix(conformance): SP-A close-out — C# ms-truncation + sub-ms gate row + TS recover decimal->string + hygiene

Review findings: C# Normalization truncates sub-second to ms (was 7-digit, a
cross-port divergence); a .123456->.123 corpus row now proves ms-truncation on
all five ports; TS runtime recover-object maps field.decimal to STRING (matching
its codegen sibling + C#); genericized a home path in the plan doc; decimal
filter value type -> string (operator band stays numeric); dead java.sql.Time
branches carry the fractional suffix.

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

Author: dmealing

docs/superpowers/plans/2026-05-31-sp-a-type-fidelity-plan.md

@@ -8,7 +8,7 @@
 
 **Tech stack:** TS (bun, migrate-ts, codegen-ts), C# (EF Core, xUnit, Testcontainers), Java (OMDB, JUnit), Python (SQLAlchemy Core, pytest), Kotlin (Exposed, KotlinPoet). Design: `docs/superpowers/specs/2026-05-31-sp-a-type-fidelity-design.md`.
 
-**Worktree:** `/home/doug/Development/metaobjects/.claude/worktrees/sp-a-type-fidelity` (branch `sp-a-type-fidelity`, off origin/main).
+**Worktree:** `<repo-root>/.claude/worktrees/sp-a-type-fidelity` (branch `sp-a-type-fidelity`, off origin/main).
 
 ---
 

fixtures/persistence-conformance/queries/normalization-wire-types.yaml

@@ -10,10 +10,14 @@ description: |
   recordedAt's -05:00 offset must read back as 14:30:00.123Z, while observedAt's
   bare wall-clock 14:30:00.123 must read back unshifted with no Z.
 
-  SP-A: this row carries a sub-second component (millisecond resolution). The
-  fractional digits carry no trailing zeros (.120 → .12). The whole-second
-  omit-the-dot rule is proven separately by asset-uuid-roundtrip.yaml, whose
-  rows stay at "...:00" / "...:00Z".
+  SP-A: this row carries a sub-second component. recordedAt (TIMESTAMPTZ) and
+  atTime (TIME) are seeded with SIX fractional digits (.123456) whose 4th-6th
+  digits are non-zero, so every port must TRUNCATE to millisecond resolution
+  (.123456 → .123) rather than round or pass through — a port emitting .123456
+  fails the gate. observedAt (TIMESTAMP) keeps .120 to exercise the
+  no-trailing-zeros rule (.120 → .12). The whole-second omit-the-dot rule is
+  proven separately by asset-uuid-roundtrip.yaml, whose rows stay at
+  "...:00" / "...:00Z".
 seed-data: |
   INSERT INTO "assets"
     ("id","ownerId","externalId","payload","recordedAt","observedAt","asOfDate","atTime")
@@ -22,10 +26,10 @@ seed-data: |
      'BBBBBBBB-BBBB-4BBB-8BBB-BBBBBBBBBBBB',
      NULL,
      '{"b": 2, "a": 1}',
-     '2026-05-31T09:30:00.123-05:00',
+     '2026-05-31T09:30:00.123456-05:00',
      '2026-05-31T14:30:00.120',
      '2026-05-31',
-     '14:30:00.123');
+     '14:30:00.123456');
 queries:
   - name: wire-types-roundtrip
     op: get

server/csharp/MetaObjects.IntegrationTests/Runner/Normalization.cs

@@ -119,14 +119,18 @@ private static string CanonicalFloat(double d)
     // as its UTC equivalent, proving normalization (not just formatting).
     private static string FormatDateTime(DateTime dt)
     {
-        var s = TrimSubseconds(dt.ToString("yyyy-MM-ddTHH:mm:ss.fffffff", CultureInfo.InvariantCulture));
+        // Truncate (NOT round) sub-second to millisecond resolution — `fff` — to match
+        // the other four ports' integer-division truncation (TS slice(dot+1,dot+4),
+        // Java/Kotlin nanos/1_000_000, Python microsecond//1000). A 7-digit `fffffff`
+        // here would surface `.123456` where every other port emits `.123`.
+        var s = TrimSubseconds(dt.ToString("yyyy-MM-ddTHH:mm:ss.fff", CultureInfo.InvariantCulture));
         return dt.Kind == DateTimeKind.Utc ? s + "Z" : s;
     }
 
-    // TIME → "HH:MM:SS[.fff]" with trailing zero subseconds (and a bare decimal
-    // point) stripped. Phase B seeds whole seconds, so this yields "HH:MM:SS".
+    // TIME → "HH:MM:SS[.fff]" — truncated to millisecond resolution then trailing-zero
+    // subseconds (and a bare decimal point) stripped, matching the other ports.
     private static string FormatTimeOnly(TimeOnly time) =>
-        TrimSubseconds(time.ToString("HH:mm:ss.fffffff", CultureInfo.InvariantCulture));
+        TrimSubseconds(time.ToString("HH:mm:ss.fff", CultureInfo.InvariantCulture));
 
     // Strip trailing zeros from a subsecond fraction, then drop the decimal point
     // if the subsecond portion was entirely zero.

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

@@ -58,7 +58,7 @@ object Normalization {
         // "14:30:00", not java.time's elided "14:30"); millisecond fractional suffix
         // appended when sub-second is non-zero (SP-A).
         is LocalTime -> v.format(timeFmt) + fractionalSuffix(v.nano)
-        is Time -> v.toLocalTime().format(timeFmt)
+        is Time -> v.toLocalTime().let { it.format(timeFmt) + fractionalSuffix(it.nano) }
         // TIMESTAMPTZ → UTC instant + "Z" suffix. The runner surfaces tz-aware columns as
         // OffsetDateTime (NOT collapsed to LocalDateTime), so the zone discriminator survives:
         // re-anchor to UTC and append "Z". A plain TIMESTAMP arrives as Timestamp/LocalDateTime

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

@@ -61,4 +61,13 @@ class NormalizationFloatTest {
     @Test fun `whole-second time omits the dot`() {
         assertEquals("14:30:00", Normalization.normalizeValue(LocalTime.of(14, 30, 0, 0)))
     }
+    // SP-A close-out: sub-millisecond fractional seconds TRUNCATE to ms (.123456 → .123),
+    // never round to .124 or pass through 6 digits.
+    @Test fun `sub-millisecond time truncates to millis`() {
+        assertEquals("14:30:00.123", Normalization.normalizeValue(LocalTime.of(14, 30, 0, 123_456_000)))
+    }
+    @Test fun `sub-millisecond timestamp truncates to millis`() {
+        assertEquals("2026-05-31T14:30:00.123",
+            Normalization.normalizeValue(LocalDateTime.of(2026, 5, 31, 14, 30, 0, 123_456_000)))
+    }
 }

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

@@ -61,7 +61,7 @@ public static Object normalizeValue(Object v) {
         if (v instanceof byte[] bytes) return Base64.getEncoder().encodeToString(bytes);
         if (v instanceof LocalDate d)  return d.format(DATE_FMT);
         if (v instanceof LocalTime t)  return t.format(TIME_FMT) + fractionalSuffix(t.getNano());
-        if (v instanceof Time t)       return t.toLocalTime().format(TIME_FMT);
+        if (v instanceof Time t)       return t.toLocalTime().format(TIME_FMT) + fractionalSuffix(t.toLocalTime().getNano());
         // TIMESTAMPTZ → UTC instant + "Z" suffix. The runner surfaces tz-aware
         // timestamp columns as OffsetDateTime (normalized to UTC in
         // ObjectManagerDbAdapter) so the zone discriminator survives — a plain

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

@@ -2,6 +2,10 @@
 
 import org.junit.jupiter.api.Test;
 
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
 /**
@@ -22,4 +26,15 @@ class NormalizationFloatTest {
         assertThrows(IllegalArgumentException.class,
             () -> Normalization.normalizeValue(1.0e-10f)); // Float.toString -> "1.0E-10"
     }
+
+    // SP-A close-out: sub-millisecond fractional seconds TRUNCATE to ms (123456 us of
+    // a second = 123_456_000 ns → ".123", NOT ".123456" or a rounded ".124").
+    @Test void subMillisecondTime_truncatesToMillis() {
+        assertEquals("14:30:00.123",
+            Normalization.normalizeValue(LocalTime.of(14, 30, 0, 123_456_000)));
+    }
+    @Test void subMillisecondTimestamp_truncatesToMillis() {
+        assertEquals("2026-05-31T14:30:00.123",
+            Normalization.normalizeValue(LocalDateTime.of(2026, 5, 31, 14, 30, 0, 123_456_000)));
+    }
 }

server/typescript/packages/codegen-ts/src/templates/filter-type.ts

@@ -13,25 +13,27 @@ import {
   FIELD_SUBTYPE_LONG,
   FIELD_SUBTYPE_DOUBLE,
   FIELD_SUBTYPE_FLOAT,
-  FIELD_SUBTYPE_DECIMAL,
   opsForSubType,
 } from "@metaobjectsdev/metadata";
 import { isSortableField } from "./filter-shared.js";
 
-const NUMBER_SUBTYPES = new Set<string>([
+// VALUE-type classification only (distinct from the OPERATOR band, which comes from
+// opsForSubType). decimal is deliberately NOT here: its operator band stays NUMERIC
+// (eq/ne/gt/gte/lt/lte/in/isNull, see OPS_BY_SUBTYPE) but its VALUE type is `string`,
+// matching the entity field representation (exact decimal string, not lossy number).
+const NUMBER_VALUE_SUBTYPES = new Set<string>([
   FIELD_SUBTYPE_INT,
   FIELD_SUBTYPE_SHORT,
   FIELD_SUBTYPE_BYTE,
   FIELD_SUBTYPE_LONG,
   FIELD_SUBTYPE_DOUBLE,
   FIELD_SUBTYPE_FLOAT,
-  FIELD_SUBTYPE_DECIMAL,
 ]);
 
-/** Maps a field subtype to its TS value type name for operator union codegen. */
+/** Maps a field subtype to its TS VALUE type name for operator union codegen. */
 function tsNameFor(fieldSubType: string): string {
   if (fieldSubType === FIELD_SUBTYPE_BOOLEAN) return "boolean";
-  if (NUMBER_SUBTYPES.has(fieldSubType)) return "number";
+  if (NUMBER_VALUE_SUBTYPES.has(fieldSubType)) return "number";
   return "string";
 }
 

server/typescript/packages/codegen-ts/test/templates/filter-type.test.ts

@@ -1,7 +1,7 @@
 import { describe, test, expect } from "bun:test";
 import { renderFilterType } from "../../src/templates/filter-type.js";
 import { resolve } from "node:path";
-import { MetaDataLoader } from "@metaobjectsdev/metadata";
+import { MetaDataLoader, InMemoryStringSource } from "@metaobjectsdev/metadata";
 import { FileSource } from "@metaobjectsdev/metadata/core";
 
 const FIXTURE = resolve(import.meta.dir, "..", "fixtures", "filter-fixture.json");
@@ -86,4 +86,36 @@ describe("renderFilterType", () => {
     // price should NOT appear as a filterable field (no @filterable)
     expect(out).not.toContain("price?:");
   });
+
+  // SP-A close-out: a filterable decimal field's VALUE type is `string` (exact-decimal
+  // wire form, matching the entity field) while its OPERATOR band stays NUMERIC
+  // (gt/gte/lt/lte/in — NOT the string `like`).
+  test("decimal filterable field has string value type but numeric operator band", async () => {
+    const meta = {
+      "metadata.root": {
+        package: "shop::money",
+        children: [
+          {
+            "object.entity": {
+              name: "Invoice",
+              children: [
+                { "field.decimal": { name: "total", "@filterable": true, "@precision": 12, "@scale": 2 } },
+              ],
+            },
+          },
+        ],
+      },
+    };
+    const { root } = await new MetaDataLoader().load([new InMemoryStringSource(JSON.stringify(meta))]);
+    const entity = root.objects().find((c) => c.name === "Invoice")!;
+    const out = renderFilterType(entity).toString();
+    // value type is string (gt?: string, not gt?: number)
+    expect(out).toMatch(/total\?:\s*string\s*\|\s*\{/);
+    expect(out).toMatch(/total\?:[\s\S]*?gt\?:\s*string/);
+    // numeric operator band present...
+    expect(out).toMatch(/total\?:[\s\S]*?gte\?:/);
+    expect(out).toMatch(/total\?:[\s\S]*?lte\?:/);
+    // ...and the string-only `like` operator absent.
+    expect(out).not.toMatch(/total\?:\s*string\s*\|\s*\{[^}]*like\?:/);
+  });
 });

server/typescript/packages/integration-tests/test/temporal-parsers.test.ts

@@ -58,9 +58,19 @@ describe("temporal canonical parsers — fractional milliseconds", () => {
     expect(canonicalTimestamp("2026-05-31 14:30:00.123456")).toBe("2026-05-31T14:30:00.123");
   });
 
+  test("TIMESTAMPTZ truncates beyond milliseconds (and converts to UTC Z)", () => {
+    // SP-A close-out: the corpus seeds .123456 here; the pinned contract truncates to ms.
+    expect(canonicalTimestamptz("2026-05-31 10:30:00.123456-04")).toBe("2026-05-31T14:30:00.123Z");
+  });
+
   test("TIME carries milliseconds, strips trailing zeros, omits dot when zero", () => {
     expect(canonicalTime("14:30:00.123")).toBe("14:30:00.123");
     expect(canonicalTime("14:30:00.120")).toBe("14:30:00.12");
     expect(canonicalTime("14:30:00.000")).toBe("14:30:00");
   });
+
+  test("TIME truncates beyond milliseconds", () => {
+    // SP-A close-out: the corpus seeds .123456 here; truncate to ms (not round, not passthrough).
+    expect(canonicalTime("14:30:00.123456")).toBe("14:30:00.123");
+  });
 });