@@ -154,7 +154,7 @@ interface NormalizedCubeFilter {
   operator: CubeOperator;
   /**
    * The comparands, as authored. Temporal values are put into the field's
-   * storage form at the exits ({@link MemoryAnalyticsService.comparandsFor}),
+   * storage form at the exits ({@link MemoryAnalyticsService.storageFormFor}),
    * never here — that rule needs the resolved field path, which only an exit has.
    */
   values: unknown[];
@@ -204,10 +204,65 @@ interface MongoPredicateInput {
    * Unicode range and would answer `CAFÉ` for `café`.
    */
   readonly asciiSubstring: (value: unknown) => RegExp;
+  /**
+   * [#20661] One value put into the storage form of the field this entry
+   * constrains — the SAME conversion `comparands` came out of
+   * ({@link MemoryAnalyticsService.storageFormFor}), handed over for the one
+   * value that is not an authored operand: a bound the builder DERIVES.
+   * See {@link lteUpperBound}.
+   */
+  readonly storageForm: (value: unknown) => unknown;
 }
 
 type MongoPredicateBuilder = (input: MongoPredicateInput) => Record<string, unknown>;
 
+/**
+ * [#20661] What an `lte` bound compiles to, decided ONCE for both exits — the
+ * mingo `$match` ({@link CUBE_OPERATOR_TO_MONGO_PREDICATE}) and the SQL echo
+ * ({@link CUBE_OPERATOR_TO_SQL_PREDICATE}) only render it, so the rows a chart
+ * is drawn from and the statement shown beside it cannot disagree on it.
+ *
+ * - `before` — a bare `YYYY-MM-DD` means the WHOLE day (#4042; the SQL twin is
+ *   #3777): the bound is the next day's midnight, exclusive.
+ * - `unbounded` — the same on `9999-12-31`, which has no next day (#20600):
+ *   every value is inside the bound, so what is left to ask is a value.
+ * - `through` — anything else keeps instant semantics, inclusive, compared
+ *   against the authored comparand in its storage form.
+ *
+ * ## ⛔ The order is the fix: widen the AUTHORED string, then convert the bound
+ *
+ * ADR-0053 D-E3: the calendar-day rewrite is a *calendar* operation and runs
+ * on the bare-day STRING first; only the resulting bound is converted to the
+ * storage form. Both rows used to ask {@link nextUtcCalendarDay} about
+ * `comparands[0]`, which is ALREADY in storage form — on a declared `datetime`
+ * field that is the instant `2026-07-28T00:00:00.000Z`, which the helper
+ * correctly refuses to widen, so `$lte: '2026-07-28'` compiled an inclusive
+ * bound at that midnight and dropped the rest of the day, while `find()` on the
+ * same filter (which widens `val` and converts `nextDay`, `memory-driver.ts`)
+ * kept it. On an undeclared field the storage form IS the authored string,
+ * which is why only the declared case was wrong. ⛔ Never teach
+ * `nextUtcCalendarDay` to widen an instant instead: it refuses one because an
+ * instant already says where it stops.
+ *
+ * `comparand` is the authored value's storage form, passed in rather than
+ * recomputed: it already exists, and the `through` arm is exactly it.
+ */
+type LteUpperBound =
+  | { readonly kind: 'before'; readonly bound: unknown }
+  | { readonly kind: 'unbounded' }
+  | { readonly kind: 'through'; readonly bound: unknown };
+
+function lteUpperBound(
+  authored: unknown,
+  comparand: unknown,
+  storageForm: (value: unknown) => unknown,
+): LteUpperBound {
+  const nextDay = nextUtcCalendarDay(authored);
+  if (isUnboundedAbove(nextDay)) return { kind: 'unbounded' };
+  if (nextDay != null) return { kind: 'before', bound: storageForm(nextDay) };
+  return { kind: 'through', bound: comparand };
+}
+
 /**
  * [#5374] How each cube operator becomes a mingo field predicate — the whole
  * `{$op: …}` object, not the name of an operator.
@@ -269,10 +324,13 @@ const CUBE_OPERATOR_TO_MONGO_PREDICATE: Readonly<Record<CubeOperator, MongoPredi
   // Order-equivalent to `$lte` for plain `YYYY-MM-DD` values.
   // [#20600] On the last supported day there is no next day: every value is
   // inside the bound, so what `lte` still asks is a value (the `set` row below).
-  lte: ({ comparands }) => {
-    const nextDay = nextUtcCalendarDay(comparands[0]);
-    if (isUnboundedAbove(nextDay)) return { $ne: null };
-    return nextDay != null ? { $lt: nextDay } : { $lte: comparands[0] };
+  // [#20661] Decided from the AUTHORED value by {@link lteUpperBound}, which
+  // the SQL twin shares — widening `comparands[0]` read an instant on a
+  // declared `datetime` field and never widened at all.
+  lte: ({ raw, comparands, storageForm }) => {
+    const upper = lteUpperBound(raw[0], comparands[0], storageForm);
+    if (upper.kind === 'unbounded') return { $ne: null };
+    return upper.kind === 'before' ? { $lt: upper.bound } : { $lte: upper.bound };
   },
   // The list operators take the WHOLE list. An empty one is a real predicate —
   // `$in: []` selects nothing, `$nin: []` selects everything — and saying so
@@ -326,6 +384,11 @@ interface SqlPredicateInput {
    * See {@link globSubstringPattern} for why GLOB and not LIKE.
    */
   readonly globSubstring: (value: unknown) => string;
+  /**
+   * [#20661] The storage-form conversion `comparands` came out of, for a bound
+   * the builder derives — the twin of {@link MongoPredicateInput.storageForm}.
+   */
+  readonly storageForm: (value: unknown) => unknown;
 }
 
 type SqlPredicateBuilder = (input: SqlPredicateInput) => string;
@@ -464,12 +527,15 @@ const CUBE_OPERATOR_TO_SQL_PREDICATE: Readonly<Record<CubeOperator, SqlPredicate
   // which is measurable as an echo one row NARROWER than the chart it describes.
   // [#20600] …and `IS NOT NULL` on the last supported day, as the mingo row
   // above answers `$ne: null` there.
-  lte: ({ column, comparands, literal }) => {
-    const nextDay = nextUtcCalendarDay(comparands[0]);
-    if (isUnboundedAbove(nextDay)) return `${column} IS NOT NULL`;
-    return nextDay != null
-      ? `${column} < ${literal(nextDay)}`
-      : `${column} <= ${literal(comparands[0])}`;
+  // [#20661] The same {@link lteUpperBound} decision the mingo row renders, so
+  // on a declared `datetime` field the echo reads `< '2026-07-29T00:00:00.000Z'`
+  // where it used to read `<= '2026-07-28T00:00:00.000Z'`.
+  lte: ({ column, raw, comparands, storageForm, literal }) => {
+    const upper = lteUpperBound(raw[0], comparands[0], storageForm);
+    if (upper.kind === 'unbounded') return `${column} IS NOT NULL`;
+    return upper.kind === 'before'
+      ? `${column} < ${literal(upper.bound)}`
+      : `${column} <= ${literal(upper.bound)}`;
   },
   // The list operators take the WHOLE list, and an EMPTY one is a real
   // predicate on this side too — `$in: []` selects nothing, `$nin: []`
@@ -628,7 +694,7 @@ function numericAggregandExpr(path: string): Record<string, unknown> {
  *
  * Every other value on this path already renders faithfully, measured rather
  * than assumed: a `Date` comparand is canonicalized to an ISO string by
- * {@link MemoryAnalyticsService.comparandsFor} before it reaches here, and
+ * {@link MemoryAnalyticsService.storageFormFor} before it reaches here, and
  * `toJSON` runs BEFORE a replacer in any case, so dates are unchanged. A
  * `BigInt` comparand does throw — but out of mingo's own `Query.compile` during
  * EXECUTION, before this dump is ever built, so no replacer here reaches it.
@@ -882,9 +948,11 @@ export class MemoryAnalyticsService implements IAnalyticsService {
         // FROM: a boolean reaches mingo as a boolean and `null` as `null`, so a
         // predicate over `is_active` or `closed_at` selects the same rows
         // `find()` selects instead of none / all of them.
+        const storageForm = this.storageFormFor(cube, filter.member);
         const predicate = this.mongoPredicateBuilder(filter.operator)({
-          comparands: this.comparandsFor(cube, filter.member, filter.values),
+          comparands: filter.values.map(storageForm),
           raw: filter.values,
+          storageForm,
           substring: (value) => this.driver.filterSubstringPattern(value),
           // [#6520] `$icontains`' fold, from the spec's shared definition rather
           // than from the driver's Unicode-folding `filterSubstringPattern`.
@@ -1362,10 +1430,12 @@ export class MemoryAnalyticsService implements IAnalyticsService {
     const normalizedFilters = this.normalizeFilters(query);
     for (const filter of normalizedFilters) {
       const fieldPath = this.resolveFieldPath(cube, filter.member);
+      const storageForm = this.storageFormFor(cube, filter.member);
       whereClauses.push(this.sqlPredicateBuilder(filter.operator)({
         column: fieldPath,
-        comparands: this.comparandsFor(cube, filter.member, filter.values),
+        comparands: filter.values.map(storageForm),
         raw: filter.values,
+        storageForm,
         literal: (value) => this.toSqlLiteral(value),
         globSubstring: (value) => this.toSqlLiteral(globSubstringPattern(value)),
       }));
@@ -1537,9 +1607,13 @@ export class MemoryAnalyticsService implements IAnalyticsService {
   }
 
   /**
-   * [#5373] The comparands of one lowered entry, in the storage form of the
-   * field they are compared against — the ONE place either exit converts a
-   * value, so the two exits cannot drift apart.
+   * [#5373] The conversion that puts a value into the storage form of the field
+   * one lowered entry is compared against — the ONE place either exit converts
+   * a value, so the two exits cannot drift apart. Each exit maps the entry's
+   * comparands through it, and hands the same function to its predicate builder
+   * for the one value a builder derives rather than receives: the whole-day
+   * bound of an `lte` (#20661, {@link lteUpperBound}), which has to be widened
+   * from the AUTHORED day before it is converted (ADR-0053 D-E3).
    *
    * The only conversion left is the temporal one (#4047): a `datetime` column
    * holds canonical UTC ISO text, so a `Date` comparand has to become that text
@@ -1552,10 +1626,10 @@ export class MemoryAnalyticsService implements IAnalyticsService {
    * boolean stays a boolean, `null` stays `null`, and a text column's `'100'`
    * stays the string `'100'` instead of becoming the number `100`.
    */
-  private comparandsFor(cube: Cube, member: string, values: unknown[]): unknown[] {
+  private storageFormFor(cube: Cube, member: string): (value: unknown) => unknown {
     const table = this.extractTableName(cube.sql);
     const fieldPath = this.resolveFieldPath(cube, member);
-    return values.map(v => this.driver.filterComparandStorageForm(table, fieldPath, v));
+    return (value) => this.driver.filterComparandStorageForm(table, fieldPath, value);
   }
 
   /**