fix(core): read an epoch-ms number on a date column as its UTC calendar day

temporalStorageForm's date arm returned a finite number unchanged, so each
face compared it by its own type rules: driver-memory matched no row, SQLite
ordered it below every date text, and PostgreSQL refused the bind (22008).
A finite number now takes the UTC calendar day of new Date(value), the
reading a Date of the same value already had; NaN, +/-Infinity and numbers
past the Date range come back unchanged.

Claude-Session: https://claude.ai/code/session_01Bvd69VPa6puiNzzPUroDBx
Co-authored-by: Claude <noreply@anthropic.com>

Author: claude

packages/core/src/utils/temporal-storage-form.test.ts

@@ -39,9 +39,58 @@ describe('temporalStorageForm — date: the UTC calendar day', () => {
     it(name, () => expect(temporalStorageForm(input, 'date')).toBe(expected));
   }
 
-  it('epoch milliseconds are not a calendar day — returned as they came', () => {
-    expect(temporalStorageForm(1769940000000, 'date')).toBe(1769940000000);
+});
+
+// [#20203] An epoch-millisecond NUMBER on a `date` column used to come back
+// unchanged, so each face compared it by its own type rules: driver-memory
+// matched no row, SQLite ordered it below every date text (6 of 6 for `$gt`)
+// and PostgreSQL refused the bind (`22008`, a 500 at REST). It is now read as
+// the `datetime` rule reads it — an instant — and takes that instant's UTC
+// calendar day, the reading a `Date` of the same value already had.
+describe('temporalStorageForm — date: an epoch-ms number is the UTC calendar day of its instant', () => {
+  const cases: ReadonlyArray<readonly [string, number, string]> = [
+    ['a time of day is dropped, never rounded', 1769940000000, '2026-02-01'], // 2026-02-01T10:00Z
+    ['a UTC midnight', 1769904000000, '2026-02-01'],
+    ['the last millisecond of a UTC day', 1769990399999, '2026-02-01'],
+    ['the epoch', 0, '1970-01-01'],
+    ['-0', -0, '1970-01-01'],
+    ['a negative number — a day before the epoch', -86400000, '1969-12-31'],
+    ['one millisecond before the epoch', -1, '1969-12-31'],
+    ['a fraction is truncated toward zero, as the Date constructor does', 1769990399999.9, '2026-02-01'],
+    ['a negative fraction truncates toward zero too', -0.5, '1970-01-01'],
+    ['the Date range maximum', 8.64e15, '275760-09-13'],
+    ['the Date range minimum', -8.64e15, '-271821-04-20'],
+  ];
+  for (const [name, input, expected] of cases) {
+    it(`${name}: ${input} → ${expected}`, () => expect(temporalStorageForm(input, 'date')).toBe(expected));
+  }
+
+  it('a number and the Date of the same value always agree', () => {
+    for (const [, input] of cases) {
+      expect(temporalStorageForm(input, 'date'), String(input)).toBe(temporalStorageForm(new Date(input), 'date'));
+    }
   });
+
+  it('…and name the calendar day of the datetime rule\'s instant for the same number', () => {
+    for (const input of [1769940000000, 1769904000000, 0, -1, -86400000, 253402300799999]) {
+      expect(temporalStorageForm(input, 'date'), String(input))
+        .toBe((temporalStorageForm(input, 'datetime') as string).slice(0, 10));
+    }
+  });
+
+  const untouched: ReadonlyArray<readonly [string, unknown]> = [
+    ['NaN', Number.NaN],
+    ['Infinity', Number.POSITIVE_INFINITY],
+    ['-Infinity', Number.NEGATIVE_INFINITY],
+    ['past the Date range', 8.64e15 + 1],
+    ['before the Date range', -8.64e15 - 1],
+    ['a bigint — not a number', 1769940000000n],
+    ['a boxed Number — not a number', Object(1769940000000)],
+    ['an epoch-ms STRING — not a leading calendar day, unchanged as before', '1769940000000'],
+  ];
+  for (const [name, input] of untouched) {
+    it(`${name} comes back unchanged`, () => expect(temporalStorageForm(input, 'date')).toBe(input));
+  }
 });
 
 describe('temporalStorageForm — time: the UTC wall clock, .fff only when non-zero', () => {

packages/core/src/utils/temporal-storage-form.ts

@@ -70,7 +70,9 @@ import type { TemporalComparandKind } from './temporal-comparand.js';
  *   everywhere: `'…T12:00+08:00'` and `'…T04:00Z'` are one instant but sort
  *   differently as text.
  * - `date`: a `Date` → its UTC calendar day (the UTC clock, never the host's —
- *   `SqlDriver.toDateOnly` records why); a string → its leading `YYYY-MM-DD`.
+ *   `SqlDriver.toDateOnly` records why); a finite number → epoch milliseconds,
+ *   read as the `Date` of that value and so its UTC calendar day (a time of
+ *   day is dropped, never rounded); a string → its leading `YYYY-MM-DD`.
  * - `time`: a bare `HH:MM[:SS[.f…]]` in range → `HH:MM:SS`, `.fff` kept only
  *   when non-zero (fractions beyond milliseconds truncated); anything else is
  *   read as an INSTANT by the `datetime` rule and keeps its UTC time of day.
@@ -114,11 +116,17 @@ function canonicalUtcDatetime(value: unknown): unknown {
 
 function canonicalCalendarDay(value: unknown): unknown {
   if (value == null) return value;
-  if (value instanceof Date) {
-    if (Number.isNaN(value.getTime())) return value;
-    const y = value.getUTCFullYear();
-    const m = String(value.getUTCMonth() + 1).padStart(2, '0');
-    const d = String(value.getUTCDate()).padStart(2, '0');
+  // [#20203] A finite number is epoch milliseconds — the reading the
+  // `datetime` rule above gives it — so it names the instant `new Date(value)`
+  // names and takes that `Date`'s UTC calendar day, through the one conversion
+  // below. A number and its `Date` therefore always agree; a number the `Date`
+  // range cannot hold (past ±8.64e15), `NaN` and ±Infinity come back unchanged.
+  const instant = typeof value === 'number' && Number.isFinite(value) ? new Date(value) : value;
+  if (instant instanceof Date) {
+    if (Number.isNaN(instant.getTime())) return value;
+    const y = instant.getUTCFullYear();
+    const m = String(instant.getUTCMonth() + 1).padStart(2, '0');
+    const d = String(instant.getUTCDate()).padStart(2, '0');
     return `${y}-${m}-${d}`;
   }
   if (typeof value === 'string') {