@@ -0,0 +1,13 @@
+---
+'@objectstack/driver-mongodb': patch
+---
+
+fix(driver-mongodb): `MongoDBDriver` compiles the whole-day comparison it is handed — its own copy of the bare-day upper bound is deleted (ADR-0053 D-D1 items 5, 7 and 9, #20822)
+
+Clause-②: no
+
+- **What is deleted.** `translateFilter` no longer widens a bare `YYYY-MM-DD` `$lte` to `$lt` the next day, no longer widens a `$between` maximum the same way, and no longer turns `$lte '9999-12-31'` into `$ne: null` or drops a `$between` maximum on that day. Every verb that translates a `where` inherits it: `find`, `findOne`, `count`, `updateMany`, `deleteMany`, `explain`, and the `$match` stage of `aggregate` / `buildAggregationPipeline`.
+- **A read through the engine or the RLS compile seam is unchanged.** The seam hands the driver a filter the shared `lowerFilterCondition` (`@objectstack/spec/data`) has already rewritten on the declared `datetime` columns: `$lt` the next day, a split `$between`, `$null: false` on the last supported day. The deleted copy gave the same answer on that input. A `date` column answers as before, because its stored calendar-day text orders the same either way.
+- **Two answers converge on what `SqlDriver` returns** (ADR-0053 D-D1 item 7's scope). On a registered object, a bare-day `$lte` or `$between` maximum is now compared as written on a column that is not declared `datetime`: a `text` column holding ISO instant text, or a column the object does not declare. This driver used to widen it to the whole day.
+- **A caller that passes no seam gets the comparison it wrote** (item 5): a `MongoDBDriver` verb or `translateFilter` called directly. A bare-day `$lte` compares against that day's midnight, a `$between` is inclusive at both ends, and `$lte '9999-12-31'` compares against that midnight. To keep the seam's reading on a direct call, lower the filter first: `driver.find(object, { where: lowerFilterCondition(where, { isDatetimeColumn }) })`, with `lowerFilterCondition` from `@objectstack/spec/data`.
+- No exported name changes.
@@ -20,7 +20,7 @@
  */
 
 import { describe, it, expect, beforeAll, afterAll, beforeEach } from 'vitest';
-import { parseFilterAST } from '@objectstack/spec/data';
+import { lowerFilterCondition, parseFilterAST } from '@objectstack/spec/data';
 import type { MongoMemoryServer } from 'mongodb-memory-server';
 import { MongoDBDriver } from './mongodb-driver.js';
 import { createTestMongod } from './test-mongod.js';
@@ -29,6 +29,23 @@ const sharedMongod: MongoMemoryServer | undefined = await createTestMongod('date
 
 const ids = (rows: any[]) => rows.map((r: any) => r.id).sort();
 
+/** The declared field map `task` is synced with — what a typed seam reads. */
+const TASK_FIELDS: Record<string, { type: string }> = {
+  title: { type: 'string' },
+  created_at: { type: 'datetime' },
+  created_on: { type: 'date' },
+};
+
+/**
+ * [#20822 · ADR-0053 D-D1 items 5 and 9, as amended] What a TYPED seam hands
+ * this driver: the filter through the shared lowering, `datetime` columns only.
+ * The driver keeps no whole-day copy of its own, so a bare-day upper bound on
+ * `created_at` keeps the whole day only on a seam-fed read — the cells below
+ * that assert the whole day read through this, as every engine read does.
+ */
+const seamed = <T,>(where: T): T =>
+  lowerFilterCondition(where, { isDatetimeColumn: (column) => TASK_FIELDS[column]?.type === 'datetime' });
+
 describe.skipIf(!sharedMongod)('MongoDB Field.datetime storage (#4047)', () => {
   const mongod = sharedMongod as MongoMemoryServer;
   let driver: MongoDBDriver;
@@ -52,11 +69,7 @@ describe.skipIf(!sharedMongod)('MongoDB Field.datetime storage (#4047)', () => {
     // — the mongo analogue of `initObjects` populating `datetimeFields`.
     await driver.syncSchema('task', {
       name: 'task',
-      fields: {
-        title: { type: 'string' },
-        created_at: { type: 'datetime' },
-        created_on: { type: 'date' },
-      },
+      fields: TASK_FIELDS,
     });
   });
 
@@ -96,7 +109,7 @@ describe.skipIf(!sharedMongod)('MongoDB Field.datetime storage (#4047)', () => {
     // The dashboard's shape: bare-day bounds as ISO strings, against a
     // system-injected datetime field. Pre-fix this returned [] on mongo.
     const found = await driver.find('task', {
-      where: { created_at: { $gte: '2026-04-29', $lte: '2026-07-28' } },
+      where: seamed({ created_at: { $gte: '2026-04-29', $lte: '2026-07-28' } }),
     } as any);
     expect(ids(found)).toEqual(['d_midnight', 'd_yesterday', 's_evening', 's_morning']);
   });
@@ -116,7 +129,8 @@ describe.skipIf(!sharedMongod)('MongoDB Field.datetime storage (#4047)', () => {
 
   it('keeps #3777/#4042 bound semantics on top of the converged storage', async () => {
     await seedMixed();
-    // Bare-day upper bound = the whole day (half-open), lower bound = midnight.
+    // Lower bound = midnight. (The whole-day upper bound is the seam's: the
+    // seamed cells above and below.)
     const gte = await driver.find('task', { where: { created_at: { $gte: '2026-07-28' } } } as any);
     expect(ids(gte)).toEqual(['d_midnight', 'd_next_day', 's_evening', 's_morning']);
 
@@ -133,17 +147,17 @@ describe.skipIf(!sharedMongod)('MongoDB Field.datetime storage (#4047)', () => {
   it('$between and the array spelling take the same coercion', async () => {
     await seedMixed();
     const between = await driver.find('task', {
-      where: { created_at: { $between: ['2026-04-29', '2026-07-28'] } },
+      where: seamed({ created_at: { $between: ['2026-04-29', '2026-07-28'] } }),
     } as any);
     expect(ids(between)).toEqual(['d_midnight', 'd_yesterday', 's_evening', 's_morning']);
 
     // [#5158] The authored array form, lowered the declared way. The INFIX
     // join (`[condA, 'and', condB]`) has no lowering at all and is refused at
     // the door; the declared spelling of "both bounds" is the prefix group.
     const array = await driver.find('task', {
-      where: parseFilterAST(
+      where: seamed(parseFilterAST(
         ['and', ['created_at', '>=', '2026-04-29'], ['created_at', '<=', '2026-07-28']],
-      ) as any,
+      )) as any,
     } as any);
     expect(ids(array)).toEqual(['d_midnight', 'd_yesterday', 's_evening', 's_morning']);
   });
 
@@ -74,6 +74,7 @@
 
 import { describe, it, expect } from 'vitest';
 import { translateFilter } from './mongodb-filter.js';
+import { lowerFilterCondition } from '@objectstack/spec/data';
 
 /** The shape `mapDataError` / `sendError` read off a thrown driver error. */
 interface WireBearingError extends Error {
@@ -164,11 +165,15 @@ describe('[#5346] driver-mongodb refuses a malformed $between comparand', () =>
     });
   });
 
-  it('the whole-day upper bound rule (#4042) is untouched', () => {
-    // A bare-day max still compiles half-open, which is the behaviour the arm
-    // carried before the `else` was added — the refusal must not have changed
-    // what a VALID range means.
+  it('a bare-day range is translated as written; the whole-day bound is the seam`s (#20822)', () => {
+    // The refusal must not change what a VALID range means. Since #20822 a
+    // bare-day max is compiled as written here (ADR-0053 D-D1 item 5): the
+    // whole-day bound (#4042) is applied once, by the shared lowering at the
+    // seams, which hands this arm `$gte` and `$lt` the next day instead.
     expect(translateFilter({ due: { $between: ['2026-07-01', '2026-07-28'] } })).toEqual({
+      due: { $gte: '2026-07-01', $lte: '2026-07-28' },
+    });
+    expect(translateFilter(lowerFilterCondition({ due: { $between: ['2026-07-01', '2026-07-28'] } }))).toEqual({
       due: { $gte: '2026-07-01', $lt: '2026-07-29' },
     });
   });
 
@@ -1,7 +1,7 @@
 // Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
 
 import { describe, it, expect } from 'vitest';
-import { parseFilterAST } from '@objectstack/spec/data';
+import { lowerFilterCondition, parseFilterAST } from '@objectstack/spec/data';
 import { translateFilter } from './mongodb-filter.js';
 
 describe('MongoDB Filter Translator', () => {
@@ -43,74 +43,114 @@ describe('MongoDB Filter Translator', () => {
     });
   });
 
-  describe('calendar-day upper bounds (#4042; the SQL twin is #3777)', () => {
-    it('a bare-day $lte compiles half-open — through the whole day', () => {
+  /**
+   * [#20822 · ADR-0053 D-D1 items 5 and 9, as amended] The whole-day upper bound
+   * (#4042; the SQL twin is #3777) is applied once, by the shared lowering at
+   * the seams that feed this driver, and this translator keeps no copy of it:
+   * it compiles the comparison it is handed. One block per side of the seam.
+   */
+  describe('calendar-day upper bounds — a direct call, compiled as written (item 5)', () => {
+    it('a bare-day $lte is `<=` its midnight', () => {
       expect(translateFilter({ created_at: { $lte: '2026-07-28' } })).toEqual({
+        created_at: { $lte: '2026-07-28' },
+      });
+    });
+
+    it('a bare-day $between is inclusive at both ends', () => {
+      expect(translateFilter({ created_at: { $between: ['2026-04-29', '2026-07-31'] } })).toEqual({
+        created_at: { $gte: '2026-04-29', $lte: '2026-07-31' },
+      });
+    });
+
+    it('the authored array `<=` is lowered by parseFilterAST only, not widened (#5158)', () => {
+      expect(translateFilter(parseFilterAST([['created_at', '<=', '2026-07-28']]))).toEqual({
+        created_at: { $lte: '2026-07-28' },
+      });
+    });
+
+    it('the last supported day is an ordinary bound, $lte and a $between max alike', () => {
+      expect(translateFilter({ created_at: { $lte: '9999-12-31' } })).toEqual({
+        created_at: { $lte: '9999-12-31' },
+      });
+      expect(translateFilter({ created_at: { $between: ['2026-04-29', '9999-12-31'] } })).toEqual({
+        created_at: { $gte: '2026-04-29', $lte: '9999-12-31' },
+      });
+    });
+  });
+
+  describe('calendar-day upper bounds — a seam-fed filter, through the shared lowering (the control)', () => {
+    /** What a TYPED seam hands this driver: `created_at` is the declared `datetime`. */
+    const seamed = <T,>(where: T): T =>
+      lowerFilterCondition(where, { isDatetimeColumn: (column) => column === 'created_at' });
+
+    it('a bare-day $lte arrives half-open — through the whole day', () => {
+      expect(translateFilter(seamed({ created_at: { $lte: '2026-07-28' } }))).toEqual({
         created_at: { $lt: '2026-07-29' },
       });
     });
 
     it('a full-ISO $lte keeps instant semantics — only the bare day is widened', () => {
-      expect(translateFilter({ created_at: { $lte: '2026-07-28T12:00:00.000Z' } })).toEqual({
+      expect(translateFilter(seamed({ created_at: { $lte: '2026-07-28T12:00:00.000Z' } }))).toEqual({
         created_at: { $lte: '2026-07-28T12:00:00.000Z' },
       });
     });
 
     it('bare-day $gte / $gt / $lt keep their midnight anchoring', () => {
-      expect(translateFilter({ created_at: { $gte: '2026-07-28' } })).toEqual({
+      expect(translateFilter(seamed({ created_at: { $gte: '2026-07-28' } }))).toEqual({
         created_at: { $gte: '2026-07-28' },
       });
-      expect(translateFilter({ created_at: { $lt: '2026-07-28' } })).toEqual({
+      expect(translateFilter(seamed({ created_at: { $lt: '2026-07-28' } }))).toEqual({
         created_at: { $lt: '2026-07-28' },
       });
     });
 
-    it('$between with a bare-day max decomposes half-open, rolling the month', () => {
-      expect(translateFilter({ created_at: { $between: ['2026-04-29', '2026-07-31'] } })).toEqual({
+    it('$between with a bare-day max arrives split and half-open, rolling the month', () => {
+      expect(translateFilter(seamed({ created_at: { $between: ['2026-04-29', '2026-07-31'] } }))).toEqual({
         created_at: { $gte: '2026-04-29', $lt: '2026-08-01' },
       });
     });
 
     it('the authored array `<=` takes the same rule, once lowered (#5158)', () => {
-      // `translateFilter` no longer compiles the array spelling; the authored
-      // shape reaches it through `parseFilterAST`, which is what both doors do.
-      expect(translateFilter(parseFilterAST([['created_at', '<=', '2026-07-28']]))).toEqual({
+      expect(translateFilter(seamed(parseFilterAST([['created_at', '<=', '2026-07-28']])))).toEqual({
         created_at: { $lt: '2026-07-29' },
       });
       expect(
-        translateFilter(parseFilterAST([['created_at', '<=', '2026-07-28T12:00:00.000Z']])),
+        translateFilter(seamed(parseFilterAST([['created_at', '<=', '2026-07-28T12:00:00.000Z']]))),
       ).toEqual({
         created_at: { $lte: '2026-07-28T12:00:00.000Z' },
       });
     });
 
     // [#20600] 9999-12-31, the last supported day, has no next day: every value
-    // is inside its whole-day bound, so no upper bound is compiled. The helper
-    // answered the five-digit '10000-01-01', a bound below every stored value.
+    // is inside its whole-day bound, so the lowering keeps only `$null: false`.
     it('a bare-day $lte on the last supported day asks only for a value', () => {
-      expect(translateFilter({ created_at: { $lte: '9999-12-31' } })).toEqual({
+      expect(translateFilter(seamed({ created_at: { $lte: '9999-12-31' } }))).toEqual({
         created_at: { $ne: null },
       });
       // The control: the day before is an ordinary half-open bound.
-      expect(translateFilter({ created_at: { $lte: '9999-12-30' } })).toEqual({
+      expect(translateFilter(seamed({ created_at: { $lte: '9999-12-30' } }))).toEqual({
         created_at: { $lt: '9999-12-31' },
       });
     });
 
     it('a $between whose max is the last supported day keeps its min alone', () => {
-      expect(translateFilter({ created_at: { $between: ['2026-04-29', '9999-12-31'] } })).toEqual({
+      expect(translateFilter(seamed({ created_at: { $between: ['2026-04-29', '9999-12-31'] } }))).toEqual({
         created_at: { $gte: '2026-04-29' },
       });
-      expect(translateFilter({ created_at: { $between: ['2026-04-29', '9999-12-30'] } })).toEqual({
+      expect(translateFilter(seamed({ created_at: { $between: ['2026-04-29', '9999-12-30'] } }))).toEqual({
         created_at: { $gte: '2026-04-29', $lt: '9999-12-31' },
       });
     });
 
-    it("the lowered $ne beside an author's own $ne keeps both (#13524)", () => {
-      expect(translateFilter({ created_at: { $lte: '9999-12-31', $ne: '9999-12-31T10:00:00.000Z' } })).toEqual({
+    it("the lowered value requirement beside an author's own $ne keeps both (#13524)", () => {
+      // The `$ne` a value also takes the lowering's NULL escape (#5298), so the
+      // two constraints arrive as conjuncts and both survive the translation.
+      expect(
+        translateFilter(seamed({ created_at: { $lte: '9999-12-31', $ne: '9999-12-31T10:00:00.000Z' } })),
+      ).toEqual({
         $and: [
-          { created_at: { $ne: '9999-12-31T10:00:00.000Z' } },
           { created_at: { $ne: null } },
+          { $and: [{ $or: [{ created_at: { $eq: null } }, { created_at: { $ne: '9999-12-31T10:00:00.000Z' } }] }] },
         ],
       });
     });