@@ -10,6 +10,11 @@
 // instant was already refused `INVALID_FILTER` / 400. The door that calls this
 // predicate (`@objectstack/objectql`, `temporal-comparand-door.ts`) now refuses
 // the number and the `Date` too; its own suite pins the envelope.
+//
+// [#20264] The range is 0001..9999 (triage's ruling on that card), on `date`
+// AND `datetime`: year 0 joins the refused years — PostgreSQL's `DATE` and
+// `timestamptz` have no year 0 — and a `datetime` number, `Date` or string
+// outside the range is refused as the `date` one is. `time` has no year.
 
 import { describe, it, expect } from 'vitest';
 import { isUninterpretableTemporalComparand } from './temporal-comparand.js';
@@ -22,6 +27,8 @@ const OUT_OF_RANGE: ReadonlyArray<readonly [string, number]> = [
   ['the first day of year 10000', 253402300800000],
   ['year -1 (the card\'s number)', -62198755200000],
   ['the last millisecond of year -1', at('-000001-12-31T23:59:59.999Z')],
+  ['[#20264] the first millisecond of year 0', at('0000-01-01T00:00:00.000Z')],
+  ['[#20264] the last millisecond of year 0', at('0000-12-31T23:59:59.999Z')],
   ['the Date range maximum', 8.64e15],
   ['the Date range minimum', -8.64e15],
 ];
@@ -36,7 +43,7 @@ const PAST_THE_DATE_RANGE: ReadonlyArray<readonly [string, number]> = [
 
 /** Finite numbers whose UTC calendar day has a four-digit year — read as before. */
 const IN_RANGE: ReadonlyArray<readonly [string, number]> = [
-  ['the first millisecond of year 0', at('0000-01-01T00:00:00.000Z')],
+  ['[#20264] the first millisecond of year 1', at('0001-01-01T00:00:00.000Z')],
   ['0999-06-15', -30627504000000],
   ['1000-01-01', at('1000-01-01T00:00:00.000Z')],
   ['2026-02-01T10:00Z', 1769940000000],
@@ -45,7 +52,7 @@ const IN_RANGE: ReadonlyArray<readonly [string, number]> = [
 ];
 
 describe('[#20240] isUninterpretableTemporalComparand — a date column\'s number or Date outside the four-digit years', () => {
-  it('refuses a number and the Date of the same value, for a year below 0 or above 9999', () => {
+  it('refuses a number and the Date of the same value, for a year below 0001 or above 9999', () => {
     for (const [name, ms] of OUT_OF_RANGE) {
       expect(isUninterpretableTemporalComparand('date', ms), `number, ${name}`).toBe(true);
       expect(isUninterpretableTemporalComparand('date', new Date(ms)), `Date, ${name}`).toBe(true);
@@ -80,20 +87,37 @@ describe('[#20240] isUninterpretableTemporalComparand — a date column\'s numbe
     expect(isUninterpretableTemporalComparand('date', '-000001-01-01T00:00:00.000Z')).toBe(true);
     expect(isUninterpretableTemporalComparand('date', '0999-06-15T00:00:00.000Z')).toBe(false);
     expect(isUninterpretableTemporalComparand('date', '0999-06-15')).toBe(false);
+    // [#20264] Year 0 in its string spellings, beside the first supported day.
+    expect(isUninterpretableTemporalComparand('date', '0000-06-15')).toBe(true);
+    expect(isUninterpretableTemporalComparand('date', '0000-06-15T00:00:00.000Z')).toBe(true);
+    expect(isUninterpretableTemporalComparand('date', '0001-01-01')).toBe(false);
   });
 
-  it('leaves the datetime and time rules alone — they read an instant', () => {
-    for (const kind of ['datetime', 'time'] as const) {
-      for (const [name, ms] of [...OUT_OF_RANGE, ...PAST_THE_DATE_RANGE, ...IN_RANGE]) {
-        expect(isUninterpretableTemporalComparand(kind, ms), `${kind}, number, ${name}`).toBe(false);
-        expect(isUninterpretableTemporalComparand(kind, new Date(ms)), `${kind}, Date, ${name}`).toBe(false);
+  it('[#20264] judges a datetime number or Date by the same years — the rule reads it, but its year is outside', () => {
+    for (const [name, ms] of [...OUT_OF_RANGE, ...PAST_THE_DATE_RANGE]) {
+      expect(isUninterpretableTemporalComparand('datetime', ms), `number, ${name}`).toBe(true);
+      if (Number.isFinite(new Date(ms).getTime())) {
+        expect(isUninterpretableTemporalComparand('datetime', new Date(ms)), `Date, ${name}`).toBe(true);
       }
     }
+    for (const [name, ms] of IN_RANGE) {
+      expect(isUninterpretableTemporalComparand('datetime', ms), `number, ${name}`).toBe(false);
+      expect(isUninterpretableTemporalComparand('datetime', new Date(ms)), `Date, ${name}`).toBe(false);
+    }
+  });
+
+  it('leaves the time rule alone — a wall clock has no year', () => {
+    for (const [name, ms] of [...OUT_OF_RANGE, ...PAST_THE_DATE_RANGE, ...IN_RANGE]) {
+      expect(isUninterpretableTemporalComparand('time', ms), `number, ${name}`).toBe(false);
+      expect(isUninterpretableTemporalComparand('time', new Date(ms)), `Date, ${name}`).toBe(false);
+    }
   });
 
   it('does not judge NaN, ±Infinity or an Invalid Date — they name no instant and no year', () => {
-    for (const value of [Number.NaN, Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY, new Date(Number.NaN)]) {
-      expect(isUninterpretableTemporalComparand('date', value), String(value)).toBe(false);
+    for (const kind of ['date', 'datetime'] as const) {
+      for (const value of [Number.NaN, Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY, new Date(Number.NaN)]) {
+        expect(isUninterpretableTemporalComparand(kind, value), `${kind} ${String(value)}`).toBe(false);
+      }
     }
   });
 
@@ -103,3 +127,51 @@ describe('[#20240] isUninterpretableTemporalComparand — a date column\'s numbe
     }
   });
 });
+
+// [#20264] The `datetime` rule reads an extended-year ISO string, a negative
+// year and year 0 because `Date.parse` does, and spells them `+010000-…`,
+// `-000001-…` and `0000-…`. The first two sort below every four-digit year as
+// text, so a `where` on a `datetime` field counted `$gt` / `$lt` / `$eq`
+// 7 / 0 / 0 on driver-memory and SQLite for a bound in year 10000 (the right
+// answer is 0 / 7 / 0), and PostgreSQL answered 500 (`22009`, `22007`) for
+// them and for year 0 (`22008`). Each is now uninterpretable, beside the same
+// instant a millisecond inside the range.
+describe('[#20264] isUninterpretableTemporalComparand — a datetime string outside the years 0001 to 9999', () => {
+  const REFUSED: ReadonlyArray<readonly [string, string]> = [
+    ['the extended ISO spelling of year 10000', '+010000-01-01T00:00:00.000Z'],
+    ['a bare extended day', '10000-01-01'],
+    ['the extended ISO spelling of year -1', '-000001-01-01T00:00:00.000Z'],
+    ['year 0, ISO', '0000-06-15T00:00:00.000Z'],
+    ['year 0, a bare day (read as midnight UTC)', '0000-06-15'],
+    ['year 0, zone-naive (read as UTC)', '0000-06-15 10:00'],
+    ['year 9999 in its zone, year 10000 in UTC', '9999-12-31T23:59:59-01:00'],
+    ['year 1 in its zone, year 0 in UTC', '0001-01-01T00:00:00+08:00'],
+    ['epoch milliseconds for year 10000, as a string', '253402300800000'],
+  ];
+  const READ: ReadonlyArray<readonly [string, string]> = [
+    ['the first instant of year 1', '0001-01-01T00:00:00.000Z'],
+    ['the last instant of year 9999', '9999-12-31T23:59:59.999Z'],
+    ['year 1, a bare day', '0001-01-01'],
+    ['year 0099 — inside the range', '0099-03-04T10:00:00.000Z'],
+    ['a 2026 instant (the control)', '2026-02-01T10:00:00.000Z'],
+    ['a 2026 zone-naive timestamp (the control)', '2026-02-01 10:00'],
+    ['epoch milliseconds for 2026, as a string (the control)', '1769940000000'],
+  ];
+  it('refuses each, on datetime and on date', () => {
+    for (const [name, value] of REFUSED) {
+      expect(isUninterpretableTemporalComparand('datetime', value), name).toBe(true);
+    }
+    for (const value of ['+010000-01-01T00:00:00.000Z', '-000001-01-01T00:00:00.000Z', '0000-06-15']) {
+      expect(isUninterpretableTemporalComparand('date', value), value).toBe(true);
+    }
+  });
+  it('reads every instant inside the range, as before — the discriminating half', () => {
+    for (const [name, value] of READ) {
+      expect(isUninterpretableTemporalComparand('datetime', value), name).toBe(false);
+    }
+  });
+  it('a time column judges no year — its rule keeps a time of day', () => {
+    expect(isUninterpretableTemporalComparand('time', '0000-06-15T10:00:00.000Z')).toBe(false);
+    expect(isUninterpretableTemporalComparand('time', '10:00')).toBe(false);
+  });
+});
@@ -9,7 +9,7 @@
 // `sql-driver-temporal-storage-form.test.ts`). This file pins the rule itself.
 
 import { describe, it, expect } from 'vitest';
-import { temporalStorageForm } from './temporal-storage-form.js';
+import { isOutsideTemporalYearRange, temporalStorageForm } from './temporal-storage-form.js';
 
 describe('temporalStorageForm — datetime: canonical UTC ISO text', () => {
   const cases: ReadonlyArray<readonly [string, unknown, unknown]> = [
@@ -98,18 +98,17 @@ describe('temporalStorageForm — date: an epoch-ms number is the UTC calendar d
 // same day `0999-06-15`. As text `999-…` sorts above every padded day
 // (`'9' > '0'`), so over REST the number for 0999-06-15 counted `$gt` 0 /
 // `$lt` 7 on driver-memory and SQLite where its ISO string counted 6 / 0. The
-// year is now four digits. A year below 0 or above 9999 has no `YYYY-MM-DD`
-// form: it keeps the spelling it had (no ordered form is invented), and the
-// temporal-comparand door refuses it as a comparand.
+// year is now four digits. [#20264] The padding covers 0001..0999: a year
+// outside 0001..9999 — year 0 included, which this block padded to `0000-…`
+// before that card's ruling — has no `YYYY-MM-DD` form: it keeps its unpadded
+// spelling (no ordered form is invented), and the doors refuse it.
 describe('temporalStorageForm — date: the year of a Date or number is four digits', () => {
   const at = (iso: string) => Date.parse(iso);
   const cases: ReadonlyArray<readonly [string, number]> = [
     ['0999-06-15', -30627504000000],
     ['0099-03-04', at('0099-03-04T12:00:00.000Z')],
     ['0009-03-04', at('0009-03-04T00:00:00.000Z')],
     ['0001-01-01', at('0001-01-01T00:00:00.000Z')],
-    ['0000-06-15', at('0000-06-15T00:00:00.000Z')],
-    ['0000-01-01', at('0000-01-01T00:00:00.000Z')],
     ['1000-01-01', at('1000-01-01T00:00:00.000Z')], //   already four digits — unchanged
     ['9999-12-31', at('9999-12-31T23:59:59.999Z')], //   the last millisecond of year 9999
   ];
@@ -127,11 +126,22 @@ describe('temporalStorageForm — date: the year of a Date or number is four dig
     expect([...spelled].sort()).toEqual(chronological);
   });
 
-  it('a year outside 0..9999 keeps its spelling — no ordered form is invented', () => {
+  it('a year outside 0001..9999 keeps its spelling — no ordered form is invented', () => {
     expect(temporalStorageForm(253402300800000, 'date')).toBe('10000-01-01');
     expect(temporalStorageForm(new Date(253402300800000), 'date')).toBe('10000-01-01');
     expect(temporalStorageForm(-62198755200000, 'date')).toBe('-1-01-01');
     expect(temporalStorageForm(at('-000001-12-31T23:59:59.999Z'), 'date')).toBe('-1-12-31');
+    // [#20264] Year 0 is outside too: unpadded, where #20240 padded it `0000-…`.
+    expect(temporalStorageForm(at('0000-06-15T00:00:00.000Z'), 'date')).toBe('0-06-15');
+    expect(temporalStorageForm(new Date(at('0000-01-01T00:00:00.000Z')), 'date')).toBe('0-01-01');
+  });
+
+  it('[#20264] the datetime rule stays total — it spells a year outside the range as toISOString does', () => {
+    // The doors refuse these; the write and read paths behind them are unchanged.
+    expect(temporalStorageForm(253402300800000, 'datetime')).toBe('+010000-01-01T00:00:00.000Z');
+    expect(temporalStorageForm('+010000-01-01T00:00:00.000Z', 'datetime')).toBe('+010000-01-01T00:00:00.000Z');
+    expect(temporalStorageForm(-62198755200000, 'datetime')).toBe('-000001-01-01T00:00:00.000Z');
+    expect(temporalStorageForm('0000-06-15', 'datetime')).toBe('0000-06-15T00:00:00.000Z');
   });
 });
 
@@ -178,3 +188,70 @@ describe('temporalStorageForm — total: what the rule cannot read comes back un
     expect(temporalStorageForm(list, 'datetime')).toBe(list);
   });
 });
+
+// [#20264] The supported years, 0001..9999, on `date` and `datetime`: the one
+// range the temporal-comparand door (a comparand) and the record validator (a
+// written value) both ask, so they cannot disagree about a year. The year is
+// the one the kind's rule reads — a `date` string's leading day, otherwise the
+// UTC year of the instant.
+describe('[#20264] isOutsideTemporalYearRange — the years a date or datetime value may name', () => {
+  const at = (iso: string) => Date.parse(iso);
+  const OUTSIDE: ReadonlyArray<readonly [string, unknown, 'date' | 'datetime' | 'both']> = [
+    ['year 10000, a number', at('+010000-01-01T00:00:00.000Z'), 'both'],
+    ['year 10000, a Date', new Date(at('+010000-01-01T00:00:00.000Z')), 'both'],
+    ['year 10000, the extended ISO string', '+010000-01-01T00:00:00.000Z', 'both'],
+    ['year -1, the extended ISO string', '-000001-01-01T00:00:00.000Z', 'both'],
+    ['year 0, a number', at('0000-06-15T00:00:00.000Z'), 'both'],
+    ['year 0, a bare day', '0000-06-15', 'both'],
+    ['year 0, an ISO instant', '0000-06-15T10:00:00.000Z', 'both'],
+    ['a number past the Date range', 8.64e15 + 1, 'both'],
+    ['year 10000 in UTC, 9999 in its zone', '9999-12-31T23:59:59-01:00', 'datetime'],
+    ['year 0 in UTC, 1 in its zone', '0001-01-01T00:00:00+08:00', 'datetime'],
+    ['epoch milliseconds for year 10000, as a string', '253402300800000', 'datetime'],
+  ];
+  const INSIDE: ReadonlyArray<readonly [string, unknown, 'date' | 'datetime' | 'both']> = [
+    ['the first instant of year 1', at('0001-01-01T00:00:00.000Z'), 'both'],
+    ['the last instant of year 9999', new Date(at('9999-12-31T23:59:59.999Z')), 'both'],
+    ['year 1, a bare day', '0001-01-01', 'both'],
+    ['year 9999, a bare day', '9999-12-31', 'both'],
+    ['year 0099', '0099-03-04T10:00:00.000Z', 'both'],
+    ['a 2026 instant (the control)', '2026-02-01T10:00:00.000Z', 'both'],
+    ['a 2026 number (the control)', 1769940000000, 'both'],
+    // A `date` takes a string's leading day, whatever instant the rest names.
+    ['year 9999 in its leading day, 10000 as an instant', '9999-12-31T23:59:59-01:00', 'date'],
+    ['year 1 in its leading day, 0 as an instant', '0001-01-01T00:00:00+08:00', 'date'],
+  ];
+  const kindsOf = (k: 'date' | 'datetime' | 'both') => (k === 'both' ? (['date', 'datetime'] as const) : [k]);
+
+  it('is true for a year outside 0001..9999, in every spelling the kind reads', () => {
+    for (const [name, value, kinds] of OUTSIDE) {
+      for (const kind of kindsOf(kinds)) expect(isOutsideTemporalYearRange(value, kind), `${kind}, ${name}`).toBe(true);
+    }
+  });
+
+  it('is false for a year inside it, the edges and a 2026 control included', () => {
+    for (const [name, value, kinds] of INSIDE) {
+      for (const kind of kindsOf(kinds)) expect(isOutsideTemporalYearRange(value, kind), `${kind}, ${name}`).toBe(false);
+    }
+  });
+
+  it('names no year for a time, or for a value that names no instant', () => {
+    for (const value of [at('+010000-01-01T00:00:00.000Z'), '0000-06-15T10:00:00.000Z']) {
+      expect(isOutsideTemporalYearRange(value, 'time')).toBe(false);
+    }
+    for (const kind of ['date', 'datetime'] as const) {
+      for (const value of [null, undefined, '', '   ', 'not-a-date', '{today}', Number.NaN, Number.POSITIVE_INFINITY, new Date(Number.NaN), true, {}]) {
+        expect(isOutsideTemporalYearRange(value, kind), `${kind} ${String(value)}`).toBe(false);
+      }
+    }
+  });
+
+  it('agrees with the date rule: a number or Date is outside exactly when the rule cannot spell it YYYY-MM-DD', () => {
+    for (const [, value] of [...OUTSIDE, ...INSIDE]) {
+      if (typeof value !== 'number' && !(value instanceof Date)) continue;
+      const spelled = temporalStorageForm(value, 'date');
+      const isDay = typeof spelled === 'string' && /^\d{4}-\d{2}-\d{2}$/.test(spelled);
+      expect(isOutsideTemporalYearRange(value, 'date'), String(value)).toBe(!isDay);
+    }
+  });
+});
@@ -191,10 +191,19 @@ describe('[#20263] having — a comparand its column cannot read is refused befo
       ['"+010000-01-01T00:00:00.000Z"', 'not a date value']],
     ['the number for 10000-01-01 on max(date), in the year class\'s own words',
       () => ({ last_placed: { $gt: Y10000 } }), { placed_on: { $gt: Y10000 } },
-      ['253402300800000', 'outside the years 0000 to 9999', 'keep the wrong groups']],
+      ['253402300800000', 'outside the years 0001 to 9999', 'keep the wrong groups']],
     ['the Date for 10000-01-01 on max(date)',
       () => ({ last_placed: { $lt: new Date(Y10000) } }), { placed_on: { $lt: new Date(Y10000) } },
-      ['Date +010000-01-01T00:00:00.000Z', 'outside the years 0000 to 9999']],
+      ['Date +010000-01-01T00:00:00.000Z', 'outside the years 0001 to 9999']],
+    // [#20264] A datetime year outside 0001..9999 is the year class too, on
+    // `having` with no edit here: the predicate asks core's one range. At the
+    // base this `$lt` kept no group — the extended text sorts below every year.
+    ['an extended-year ISO string on min(datetime), in the year class\'s words',
+      () => ({ first_opened: { $lt: '+010000-01-01T00:00:00.000Z' } }), { opened_at: { $lt: '+010000-01-01T00:00:00.000Z' } },
+      ["`having` on 'first_opened' (min(opened_at), a datetime column)", 'outside the years 0001 to 9999', 'keep the wrong groups']],
+    ['the number for year 0 on max(date) — [#20264] year 0 joins the refused years',
+      () => ({ last_placed: { $gt: Date.parse('0000-06-15T00:00:00.000Z') } }), { placed_on: { $gt: Date.parse('0000-06-15T00:00:00.000Z') } },
+      ['outside the years 0001 to 9999']],
     ['"not-a-date" on min(datetime)',
       () => ({ first_opened: { $lt: 'not-a-date' } }), { opened_at: { $lt: 'not-a-date' } },
       ["`having` on 'first_opened' (min(opened_at), a datetime column)", 'not a datetime value']],
@@ -317,12 +326,9 @@ describe('[#20263] having — what the door leaves alone answers exactly as befo
     ['an in-range Date on max(date)', { last_placed: { $gt: new Date(1769940000000) } }, ['c2']],
     ['a 2026 instant on min(datetime)', { first_opened: { $gt: '2026-02-01T00:00:00.000Z' } }, ['c2', 'c3', 'c4']],
     ['a bare day as the upper bound of min(datetime)', { first_opened: { $lte: '2026-02-01' } }, ['c1', 'c2']],
-    // The `datetime` rule reads an extended-year instant, so the predicate calls
-    // it interpretable and its `where` twin is not refused by the door either.
-    // Its text orders below every four-digit year, so `$lt` keeps no group, on
-    // `having` as before; which years a comparand may name is #20264's to
-    // decide, in the predicate, and `having` follows it with no second edit.
-    ['an extended-year ISO on min(datetime) — read by the datetime rule', { first_opened: { $lt: '+010000-01-01T00:00:00.000Z' } }, []],
+    // [#20264] An extended-year instant on min(datetime) is refused now (see
+    // the REFUSED table); the first instant of year 1 is read, as before.
+    ['the first instant of year 1 on min(datetime) — inside the range', { first_opened: { $gt: '0001-01-01T00:00:00.000Z' } }, ['c1', 'c2', 'c3', 'c4']],
     ['a wall clock on max(time)', { last_slot: { $gte: '12:00' } }, ['c2', 'c3', 'c4']],
     ['the number for 10000-01-01 on max(time) — not judged on time', { last_slot: { $gt: Y10000 } }, []],
     ['a string on sum — not temporal', { total: { $gt: 'not-a-date' } }, []],