@@ -0,0 +1,124 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * [#20822 · ADR-0053 D-D1 item 7, as amended] The engine's `where` seam has no
+ * declared type to read for an object with no field map, and item 7 says what
+ * such a seam does: "A seam that cannot applies the rewrite type-blind." So a
+ * bare-day upper bound on ANY column of such an object leaves the engine
+ * already lowered — `$lte` a day becomes `$lt` the next day, and `$between`
+ * splits — on every verb that reads the object's declarations.
+ *
+ * Before #20822 this branch read "no field map" as "no datetime column" and
+ * left the rule to the driver's own copy. Item 5 retires those copies, so that
+ * reading would have dropped the whole-day bound on every such read: measured
+ * on `driver-memory` with its copy deleted, an unregistered object's `$lte` a
+ * day went from the whole day to midnight only.
+ *
+ * An object WITH a field map keeps the typed scope byte-identical (the control
+ * below; `engine-shared-filter-lowering-seam.test.ts` pins the rest of it).
+ *
+ * The witness is the recording driver's `where`, as in the seam's own pin.
+ */
+
+import { beforeEach, describe, expect, it } from 'vitest';
+import type { EngineAggregateOptions } from '@objectstack/spec/data';
+import { ObjectQL } from './engine.js';
+
+const UNREGISTERED = 'no_field_map_probe';
+const REGISTERED = 'typed_probe';
+
+const TYPED_SCHEMA = {
+  name: REGISTERED,
+  label: 'Typed probe',
+  fields: {
+    id: { name: 'id', type: 'text' },
+    note: { name: 'note', type: 'text' },
+    closed_at: { name: 'closed_at', type: 'datetime' },
+    due_on: { name: 'due_on', type: 'date' },
+  },
+};
+
+interface Seen { verb: string; ast: any }
+
+function makeRecordingDriver() {
+  const seen: Seen[] = [];
+  const driver: any = {
+    name: 'recording', version: '0.0.0', supports: {},
+    async connect() {}, async disconnect() {}, async checkHealth() { return true; }, async execute() { return null; },
+    async find(_o: string, ast: any) { seen.push({ verb: 'find', ast }); return []; },
+    async findOne(_o: string, ast: any) { seen.push({ verb: 'findOne', ast }); return null; },
+    async count(_o: string, ast: any) { seen.push({ verb: 'count', ast }); return 0; },
+  };
+  return { driver, seen };
+}
+
+describe('[#20822] an object with no field map: the engine seam lowers type-blind (ADR-0053 D-D1 item 7)', () => {
+  let engine: ObjectQL;
+  let seen: Seen[];
+
+  beforeEach(async () => {
+    const rec = makeRecordingDriver();
+    seen = rec.seen;
+    engine = new ObjectQL();
+    engine.registerDriver(rec.driver, true);
+    await engine.init();
+    engine.registry.registerObject(TYPED_SCHEMA as any, 'test');
+    seen.length = 0;
+  });
+
+  const lastWhere = (verb: string) => [...seen].reverse().find((s) => s.verb === verb)?.ast?.where;
+
+  it('the fixture: the probe object really has no registry entry', () => {
+    expect(engine.registry.getObject(UNREGISTERED)).toBeUndefined();
+    expect(engine.registry.getObject(REGISTERED)).toBeDefined();
+  });
+
+  it('find: a bare-day `$lte` on any column reaches the driver as `$lt` the next day', async () => {
+    await engine.find(UNREGISTERED, { where: { closed_at: { $lte: '2026-07-28' } } });
+    expect(lastWhere('find')).toEqual({ closed_at: { $lt: '2026-07-29' } });
+    // Type-blind means every column: no declaration says `note` is not a datetime.
+    await engine.find(UNREGISTERED, { where: { note: { $lte: '2026-07-28' } } });
+    expect(lastWhere('find')).toEqual({ note: { $lt: '2026-07-29' } });
+  });
+
+  it('find: `$between` with a bare-day maximum splits and widens its upper end', async () => {
+    await engine.find(UNREGISTERED, { where: { closed_at: { $between: ['2026-07-01', '2026-07-28'] } } });
+    expect(lastWhere('find')).toEqual({ closed_at: { $gte: '2026-07-01', $lt: '2026-07-29' } });
+  });
+
+  it('findOne and count take the same reading', async () => {
+    await engine.findOne(UNREGISTERED, { where: { closed_at: { $lte: '2026-07-28' } } });
+    expect(lastWhere('findOne') ?? lastWhere('find')).toEqual({ closed_at: { $lt: '2026-07-29' } });
+    await engine.count(UNREGISTERED, { where: { closed_at: { $lte: '2026-07-28' } } });
+    expect(lastWhere('count')).toEqual({ closed_at: { $lt: '2026-07-29' } });
+  });
+
+  it('aggregate: its `where` takes the same reading', async () => {
+    await engine.aggregate(UNREGISTERED, {
+      where: { closed_at: { $lte: '2026-07-28' } },
+      groupBy: ['note'],
+      aggregations: [{ function: 'count', alias: 'n' }],
+    } as EngineAggregateOptions);
+    expect(lastWhere('find')).toEqual({ closed_at: { $lt: '2026-07-29' } });
+  });
+
+  it('an instant, and `$gte` / `$lt` on a bare day, are never widened', async () => {
+    const where = { closed_at: { $lte: '2026-07-28T12:00:00.000Z' }, note: { $gte: '2026-07-01', $lt: '2026-07-28' } };
+    await engine.find(UNREGISTERED, { where });
+    expect(lastWhere('find')).toBe(where);
+  });
+
+  it('control — a field map keeps the typed scope: only the declared datetime is rewritten', async () => {
+    const where = { closed_at: { $lte: '2026-07-28' }, due_on: { $lte: '2026-07-28' }, note: { $lte: '2026-07-28' } };
+    await engine.find(REGISTERED, { where });
+    expect(lastWhere('find')).toEqual({
+      closed_at: { $lt: '2026-07-29' },
+      due_on: { $lte: '2026-07-28' },
+      note: { $lte: '2026-07-28' },
+    });
+  });
+
+  it('the judge runs the same stage and gains no verdict from it', () => {
+    expect(engine.judgeFilter(UNREGISTERED, { closed_at: { $between: ['2026-07-01', '2026-07-28'] } })).toEqual({ ok: true });
+  });
+});
@@ -1190,7 +1190,9 @@ function resolveWhereFilterTokens<W>(
  * object's declarations, so the whole-day rule rewrites a declared
  * `datetime` column only ({@link declaredDatetimeLowering}) — the scope
  * `SqlDriver` holds, so a `date`, `time` or non-temporal column reaches every
- * driver byte-identical to before (the amendment's item 7).
+ * driver byte-identical to before (the amendment's item 7). An object with no
+ * field map has no declarations to read, and there the rule applies
+ * type-blind (item 7's other half).
  *
  * Returns the input by reference when nothing resolved and nothing lowered.
  */
@@ -1207,12 +1209,21 @@ function resolveThenLowerWhere<W>(
  * positions: a column is `datetime` exactly when the object's declared field
  * map says `type: 'datetime'` — the same test `SqlDriver` indexes its
  * `datetimeFields` by, so the columns this seam widens are a subset of the
- * columns every face widens today. No field map (a registry-less host) reads
- * no column as `datetime`: the whole-day rule is then left to the faces, as it
- * was, rather than applied type-blind to columns no driver would widen.
+ * columns every face widens today.
+ *
+ * [#20822] No field map (an object the registry does not hold, a
+ * registry-less host) is a seam that cannot read the declared type, and item 7
+ * says what such a seam does: "applies the rewrite type-blind", as the
+ * type-blind emitters do (sound on `Field.date` text, where `< next-day`
+ * orders exactly as `<= day`). So the reader is omitted and the whole-day
+ * rules apply to every column. This branch used to read "no field map" as "no
+ * datetime column" and leave the rule to the faces; item 5 retires those
+ * copies, and with them gone that reading would have dropped the whole-day
+ * bound on every such read.
  */
 function declaredDatetimeLowering(schema: unknown): FilterLoweringOptions {
   const fields = (schema as { fields?: unknown } | undefined)?.fields;
+  if (fields === null || typeof fields !== 'object') return {};
   return {
     isDatetimeColumn: (column) =>
       fields !== null