@@ -28,7 +28,7 @@ What the rule does, now in one place:
 - A value the rule cannot read is compared as written, and so is every non-temporal column, presence tests (`$exists`, `$null`), the text operators and a `{ $field }` reference.
 - An object whose declared fields the engine cannot see keeps the previous comparison.
 
-`@objectstack/core` exports the rule as `temporalStorageForm(value, kind)`, `kind` being `'datetime' | 'date' | 'time'`. `driver-sql` (`canonicalUtcDatetime`, `toDateOnly`, `canonicalTimeOfDay`) and `driver-memory` (`coerceTemporalValue`) each carried a copy of it; both now call it. The copies agreed on every shape measured when they were lifted, so no `where`, write or read answer of either driver changes. MySQL still binds a `datetime` in its own literal spelling.
+`@objectstack/core` exports the rule as `temporalStorageForm(value, kind)`, `kind` being `'datetime' | 'date' | 'time'`. `driver-sql` (`canonicalUtcDatetime`, `toDateOnly`, `canonicalTimeOfDay`) and `driver-memory` (`coerceTemporalValue`) each carried a copy of it; both now call it. The copies agreed on every shape measured when they were lifted, so the lift itself changes no `where`, write or read answer of either driver (#20203, in the same release, then reads an epoch-millisecond number on a `date` field as its UTC calendar day). MySQL still binds a `datetime` in its own literal spelling.
 
 `@objectstack/objectql`'s `applyInMemoryAggregation(rows, ast, timezone?, fields?)` takes the object's declared field map as an optional fourth argument, and a per-aggregation `filter` reads a temporal comparand by the rule only when it is given. Called without it, the function answers as before.
 
 
@@ -0,0 +1,31 @@
+---
+"@objectstack/core": patch
+"@objectstack/driver-sql": patch
+"@objectstack/driver-memory": patch
+"@objectstack/objectql": patch
+---
+
+fix(core): an epoch-millisecond number compared against a `date` field is read as the UTC calendar day of its instant, by every driver and at every position that compares it (#20203)
+
+Clause-②: no — no key, export or operator moves, and no comparand that was accepted is now refused: a number was already an accepted comparand on every `date` position, and its answer moves to the storage rule's reading.
+
+`temporalStorageForm(value, 'date')` in `@objectstack/core` returned a finite number unchanged, so each face compared it by its own type rules and they disagreed. Over six rows, with `1769940000000` (2026-02-01T10:00:00.000Z) against a `date` field:
+
+| face | `$gt` | `$lt` | `$eq` | `$in` (with a Jan 10 member) | `$between` (from Jan 2) |
+|:--|:--|:--|:--|:--|:--|
+| `where` on `driver-memory` | 0 | 0 | 0 | 0 | 0 |
+| `where` on `driver-sql`, SQLite | 6 | 0 | 0 | 0 | 0 |
+| `where` on `driver-sql`, PostgreSQL | `DATABASE_ERROR`, a 500 at REST | the same | the same | the same | the same |
+| a per-aggregation `filter` on `engine.aggregate` | 0 | 0 | 0 | 0 | 6 |
+| **now, on every face above** | **1** | **3** | **2** | **3** | **5** |
+
+The same holds through `engine.find` and `POST /data/:object/query`, and for `$gte`, `$lte`, `$ne`, `$nin` and implicit equality. PostgreSQL's server refused the bound number itself (`22008`, date/time field value out of range), on an empty table too. `having` over `max` of a `date` field kept no group for `$gt`, `$eq` or `$in`; it now keeps the groups whose day compares.
+
+A finite number is now read as the `datetime` rule already reads it, as epoch milliseconds. It takes the UTC calendar day of that instant: the day `new Date(value)` names, through the same conversion a `Date` takes. So a number and its `Date` always answer alike. A time of day is dropped, never rounded, a negative number is a day before 1970, and a fraction truncates toward zero as the `Date` constructor does. `driver-sql` (`toDateOnly`, `temporalFilterValue`), `driver-memory` (`coerceTemporalValue`) and the engine's per-aggregation `filter` and `having` all call this rule, so they now agree.
+
+The rule is shared by the drivers' write and read paths too:
+
+- `create()` / `update()` on either driver, given a number for a `date` field, stores its UTC day. Before, `driver-memory` and SQLite stored the number, and PostgreSQL refused the statement. The engine and REST write doors refuse a number on a `date` field before a driver sees it (`VALIDATION_FAILED`), as before.
+- A number already stored in a SQLite `date` column is read back as its UTC day by `find()`, a `groupBy` key and `distinct()`. Only a direct driver write could have put one there.
+
+Not changed, measured identical before and after: `NaN`, ±Infinity, a number outside the `Date` range (past ±8.64e15), a bigint, an epoch-millisecond string, every `Date` and every string on a `date` field, and every `datetime` and `time` reading. `driver-mongodb` keeps its own copy of the `date` rule and is not changed here.
@@ -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', () => {
 
@@ -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') {
 
@@ -0,0 +1,97 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * [#20203] An epoch-millisecond NUMBER compared against a `date` field is read
+ * as the UTC calendar day of its instant — by `@objectstack/core`'s
+ * `temporalStorageForm`, the rule `coerceTemporalValue` calls — the reading a
+ * `Date` of the same value already had here.
+ *
+ * Measured on the base through this driver's `find()`, and through the engine
+ * and `POST /api/v1/data/:object/query` over it (which reach the same
+ * coercion): `where: { placed_on: { $gt: 1769940000000 } }` answered 0 of 6,
+ * because the number reached mingo unchanged and mingo never matches a number
+ * against the `YYYY-MM-DD` text the column holds. Every operator answered that
+ * way — 0, or all 6 for `$ne` / `$nin` — while `driver-sql` answered 6 on
+ * SQLite and a 500 on PostgreSQL (its suite pins it), and the same number on a
+ * `datetime` field (the control) was read as its instant everywhere.
+ *
+ * Each row asserts three things: the number's answer, the `Date` twin's answer
+ * (identical), and the `datetime` control.
+ */
+
+import { beforeAll, describe, expect, it } from 'vitest';
+import type { FilterCondition } from '@objectstack/spec/data';
+import { InMemoryDriver } from './memory-driver.js';
+
+const OBJECT = 'ledger_order';
+const EMPTY = 'ledger_order_empty';
+const WRITES = 'ledger_order_writes';
+const FIELDS = { placed_on: { type: 'date' }, opened_at: { type: 'datetime' } };
+
+const ROWS = [
+  { id: 'o1', placed_on: '2026-01-10', opened_at: '2026-01-01T10:00:00.000Z' },
+  { id: 'o2', placed_on: '2026-01-02', opened_at: '2026-01-02T10:00:00.000Z' },
+  { id: 'o3', placed_on: '2026-03-01', opened_at: '2026-02-01T10:00:00.000Z' },
+  { id: 'o4', placed_on: '2026-02-01', opened_at: '2026-02-05T10:00:00.000Z' },
+  { id: 'o5', placed_on: '2026-01-15', opened_at: '2026-02-06T10:00:00.000Z' },
+  { id: 'o6', placed_on: '2026-02-01', opened_at: '2026-03-01T10:00:00.000Z' },
+];
+
+const N = 1769940000000; //          2026-02-01T10:00:00.000Z — a time of day, not a UTC midnight
+const N_JAN10 = 1768057200000; //    2026-01-10T15:00:00.000Z
+const N_JAN02 = 1767394800000; //    2026-01-02T23:00:00.000Z — late in its UTC day
+const N_MIDNIGHT = 1769904000000; // 2026-02-01T00:00:00.000Z
+
+type As = (ms: number) => unknown;
+const asNumber: As = (ms) => ms;
+const asDate: As = (ms) => new Date(ms);
+
+/** operator · the comparand, built from a number or its `Date` · `date` ids · `datetime` control ids */
+const OPERATORS: ReadonlyArray<readonly [string, (v: As) => unknown, string[], string[]]> = [
+  ['$gt', (v) => ({ $gt: v(N) }), ['o3'], ['o4', 'o5', 'o6']],
+  ['$lt', (v) => ({ $lt: v(N) }), ['o1', 'o2', 'o5'], ['o1', 'o2']],
+  ['$eq', (v) => ({ $eq: v(N) }), ['o4', 'o6'], ['o3']],
+  ['$in', (v) => ({ $in: [v(N), v(N_JAN10)] }), ['o1', 'o4', 'o6'], ['o3']],
+  ['$between', (v) => ({ $between: [v(N_JAN02), v(N)] }), ['o1', 'o2', 'o4', 'o5', 'o6'], ['o3']],
+  ['$gte', (v) => ({ $gte: v(N) }), ['o3', 'o4', 'o6'], ['o3', 'o4', 'o5', 'o6']],
+  ['$lte', (v) => ({ $lte: v(N) }), ['o1', 'o2', 'o4', 'o5', 'o6'], ['o1', 'o2', 'o3']],
+  ['$ne', (v) => ({ $ne: v(N) }), ['o1', 'o2', 'o3', 'o5'], ['o1', 'o2', 'o4', 'o5', 'o6']],
+  ['$nin', (v) => ({ $nin: [v(N), v(N_JAN10)] }), ['o2', 'o3', 'o5'], ['o1', 'o2', 'o4', 'o5', 'o6']],
+  ['implicit equality', (v) => v(N), ['o4', 'o6'], ['o3']],
+  ['$eq on a UTC midnight', (v) => ({ $eq: v(N_MIDNIGHT) }), ['o4', 'o6'], []],
+];
+
+describe('[#20203] an epoch-ms number on a date field reads as the UTC calendar day of its instant', () => {
+  let driver: InMemoryDriver;
+  const ids = async (object: string, where: FilterCondition) =>
+    (await driver.find(object, { where })).map((r) => r.id).sort();
+
+  beforeAll(async () => {
+    driver = new InMemoryDriver({});
+    await driver.connect();
+    for (const name of [OBJECT, EMPTY, WRITES]) await driver.syncSchema(name, { name, fields: FIELDS });
+    for (const row of ROWS) await driver.create(OBJECT, { ...row });
+  });
+
+  for (const [op, comparand, onDate, onDatetime] of OPERATORS) {
+    it(`${op}: ${onDate.join(', ')}; its Date agrees; the datetime control reads the instant`, async () => {
+      expect(await ids(OBJECT, { placed_on: comparand(asNumber) }), 'number on date').toEqual(onDate);
+      expect(await ids(OBJECT, { placed_on: comparand(asDate) }), 'the Date twin on date').toEqual(onDate);
+      expect(await ids(OBJECT, { opened_at: comparand(asNumber) }), 'datetime control').toEqual(onDatetime);
+    });
+
+    it(`${op}: an empty object answers no row`, async () => {
+      expect(await ids(EMPTY, { placed_on: comparand(asNumber) })).toEqual([]);
+    });
+  }
+
+  it('the write path stores the same UTC calendar day — create and update', async () => {
+    await driver.create(WRITES, { id: 'w1', placed_on: N });
+    await driver.create(WRITES, { id: 'w2', placed_on: -1 }); // one ms before the epoch
+    const read = async (id: string) => (await driver.findOne(WRITES, { where: { id } }))?.placed_on;
+    expect(await read('w1')).toBe('2026-02-01');
+    expect(await read('w2')).toBe('1969-12-31');
+    await driver.update(WRITES, 'w1', { placed_on: N_JAN10 });
+    expect(await read('w1')).toBe('2026-01-10');
+  });
+});