@@ -0,0 +1,45 @@
+---
+'@objectstack/spec': minor
+---
+
+**BREAKING for callers** — `parseFilterAST` now refuses a blank `$between` endpoint, exactly as the authoring schema already does. An empty-string or absent (`undefined`) bound, at either side, is refused with `INVALID_FILTER` / 400, and the refusal names the blank side — MIN or MAX, plus the index (#19071).
+
+Clause-②: no
+
+## What changed, and why it is the implementation catching up rather than a new rule
+
+`RANGE_ENDPOINT_DESCRIPTION` — the published endpoint contract shared by both of `$between`'s bounds — has stated since 2026-09-17 that "BOTH are required NON-BLANK: an empty string, null and undefined are refused, and the refusal names the blank side". That rule shipped at the authoring schema only. The runtime door disagreed with it: `parseFilterAST({ at: { $between: ['', ''] } })` returned the filter unchanged, same object reference, measured on `origin/main` before this change and re-measured after.
+
+One published sentence therefore had two truth values, decided by which door a caller came through — and the door that passed it is the one that matters most here. A caller that lowers a filter with `parseFilterAST` and hands it straight to a driver (an embedder; this repo's own driver conformance suites) never meets the schema. At every backend a blank bound stops bounding on that side while the range still reads as a complete two-element range, so the query runs with one meaningless boundary and returns rows outside the window its filter names, with no signal at any layer.
+
+```
+FROM  parseFilterAST({ at: { $between: ['2026-01-01', ''] } })
+      -> { at: { $between: ['2026-01-01', ''] } }   // unchanged, same reference,
+                                                    // straight on to the driver
+
+TO    parseFilterAST({ at: { $between: ['2026-01-01', ''] } })
+      -> throws INVALID_FILTER / 400:
+         'Operator "$between" on field "at" requires two non-blank bounds.
+          Received an empty string at where.at.$between[1] (the MAX bound). …'
+```
+
+## Migration — FROM → TO
+
+| You wrote | Write instead |
+| --- | --- |
+| `{ $between: ['2026-01-01', ''] }` | `{ $between: ['2026-01-01', '2026-12-31'] }` — the bound you meant, written out |
+| `{ $between: ['', 100] }` | `{ $between: [0, 100] }` — the lower bound you meant |
+| a range that was only ever bounded on ONE side | `{ "$gte": min }` or `{ "$lte": max }` — a one-sided bound is not a range |
+
+**The one-line fix: write the bound that is missing, or — if only one side was ever meant — drop `$between` and write that side as a scalar comparison.** The same prescription the authoring door already gives, now given at the door an embedder actually reaches.
+
+## What does NOT change
+
+- **`null` bounds** keep their own message, refused since 2026-08-31. It prescribes the null PREDICATE, because an author who wrote `null` was reaching for absence and an author who left a bound empty was reaching for a bound — two blank spellings, two intents, two remedies. `null` is also checked first, so a pair that is blank on one side and null on the other keeps the message it has always had.
+- **Whitespace-only endpoints** are still accepted, at BOTH doors. The 2026-09-17 ruling is the empty string; the authoring door pins `{ $between: [' ', 'M'] }` as parsing green on purpose, and trimming here would re-open the very split this change closes, in the opposite direction.
+- **Falsiness.** `{ $between: [0, 0] }` and `{ $between: ['0', '9'] }` lower exactly as before. The rule is blankness, not falsiness.
+- **`$in` / `$nin` members.** A falsy or empty-string MEMBER is a value, not an absence (2026-08-31, `filter-comparand-shape.test.ts`). Only a range ENDPOINT is judged here, and only the `$between` row of that pin moves.
+- **Arity**, which was already refused with its own message, and every legal range: numbers, Dates, ISO days, UTC instants, clock times and non-temporal text all lower byte-identically, same object reference.
+- **The published export surface.** No export is added, removed or renamed; the refusal rides the existing `$between` arm of the shared comparand-shape door, so the engine's delegating wrapper inherits it unchanged.
+
+<!-- adr-0087: not-required (already-registered filter-between-blank-endpoint-refused) the transition from a blank $between endpoint to two present, non-empty bounds was registered by #18012 for this same surface set; this change adds no new transition, it brings the runtime lowering face under the one already on the ledger, and the entry's own prescription and acceptance criteria apply verbatim -->
@@ -21,7 +21,7 @@
 
 import { describe, it, expect } from 'vitest';
 import { StandardErrorCode } from '../api/errors.zod';
-import { parseFilterAST, VALID_AST_OPERATORS } from './filter.zod';
+import { parseFilterAST, RangeOperatorSchema, VALID_AST_OPERATORS } from './filter.zod';
 import { assertListComparandShapes } from './filter-comparand-shape';
 
 type Refusal = Error & { code?: string; status?: number };
@@ -151,13 +151,115 @@ describe('the list-comparand shape door (#5869) runs inside parseFilterAST (#922
       .toContain('where.$or[0].stage.$nin[0]');
   });
 
-  it('refuses ONLY null — falsy and empty-ish members are values, not absence', () => {
+  it('refuses ONLY null among the MEMBERS — falsy and empty-ish members are values', () => {
     // The carve-out is null-shaped and nothing wider: #5041's and #5234's
     // member questions stand untouched, and every falsy VALUE keeps working.
     expect(parseFilterAST({ n: { $in: [0, false, ''] } })).toEqual({ n: { $in: [0, false, ''] } });
     expect(parseFilterAST({ n: { $nin: [0, false, ''] } })).toEqual({ n: { $nin: [0, false, ''] } });
-    expect(parseFilterAST({ at: { $between: ['', ''] } })).toEqual({ at: { $between: ['', ''] } });
+    // A falsy ENDPOINT is still an endpoint — `0` is a bound like any other.
     expect(parseFilterAST({ n: { $between: [0, 0] } })).toEqual({ n: { $between: [0, 0] } });
+    // ⚠️ `{ at: { $between: ['', ''] } }` was pinned HERE as a value that
+    // passes. That row — and only that row — is INVERTED by the 2026-09-20
+    // ruling (#19071); it now lives in the blank-endpoint section below. The
+    // `$in` / `$nin` rows above are untouched, because falsy VALUES are values
+    // and a range ENDPOINT is a different question.
+  });
+
+  // ── the BLANK endpoint carve-out, ruled 2026-09-20 (#19071) ────────────
+
+  it.each([
+    ['both sides blank', { at: { $between: ['', ''] } }],
+    ['a blank MAX', { at: { $between: ['2026-07-01', ''] } }],
+    ['a blank MIN', { at: { $between: ['', '2026-07-31'] } }],
+    ['an absent MAX', { at: { $between: ['2026-07-01', undefined] } }],
+    ['an absent MIN', { at: { $between: [undefined, '2026-07-31'] } }],
+    ['the lowered array form', [['at', 'between', ['', '2026-07-31']]]],
+  ])('refuses a BLANK $between ENDPOINT — %s', (_label, where) => {
+    const err = refusalOf(() => parseFilterAST(where));
+    expect(err.code).toBe(StandardErrorCode.enum.INVALID_FILTER);
+    expect(err.status).toBe(400);
+  });
+
+  it('the blank-bound refusal names the SIDE and prescribes both remedies', () => {
+    // 2026-09-20: the refusal 「naming the blank side and carrying the same
+    // guidance as the schema door」 — with a padded pair both bounds are
+    // present, and the author is the one person who cannot see which is empty.
+    const err = refusalOf(() => parseFilterAST({ close_date: { $between: ['2026-07-01', ''] } }));
+    expect(err.message)
+      .toMatch(/^Operator "\$between" on field "close_date" requires two non-blank bounds/);
+    expect(err.message).toContain('an empty string at where.close_date.$between[1] (the MAX bound)');
+    expect(err.message).toContain('{"$gte": min} / {"$lte": max}');
+    expect(err.message).toMatch(/Authoring spellings: between\./);
+    expect(err.message).toMatch(/UNFILTERED result set/);
+    expect(refusalOf(() => parseFilterAST({ close_date: { $between: ['', '2026-07-31'] } })).message)
+      .toContain('where.close_date.$between[0] (the MIN bound)');
+    // An ABSENT bound says so in words: `undefined` inside an array renders as
+    // `null` through JSON.stringify, and null is the one blank spelling this
+    // message is NOT about.
+    expect(refusalOf(() => parseFilterAST({ close_date: { $between: [5, undefined] } })).message)
+      .toContain('Received undefined at where.close_date.$between[1] (the MAX bound)');
+  });
+
+  it('a blank bound is refused at its own path inside $and / $or / $not too', () => {
+    expect(refusalOf(() => parseFilterAST({ $not: { at: { $between: ['', 'M'] } } })).message)
+      .toContain('where.$not.at.$between[0]');
+    expect(refusalOf(() => parseFilterAST({ $or: [{ at: { $between: ['A', ''] } }] })).message)
+      .toContain('where.$or[0].at.$between[1]');
+  });
+
+  it('the null bound keeps the 2026-08-31 ruling\'s own message — two spellings, two remedies', () => {
+    // An author who wrote `null` was reaching for absence; an author who left
+    // a bound empty was reaching for a bound. If this went red the null author
+    // would be sent to a scalar comparison instead of the null predicate.
+    const err = refusalOf(() => parseFilterAST({ at: { $between: ['2026-07-01', null] } }));
+    expect(err.message).toContain('requires two non-null bounds');
+    expect(err.message).toContain('{"at": {"$null": true}}');
+    expect(err.message).not.toContain('non-blank');
+    // null is checked FIRST, so a pair that is blank on one side and null on
+    // the other keeps the message it has had since 2026-08-31.
+    expect(refusalOf(() => parseFilterAST({ at: { $between: ['', null] } })).message)
+      .toContain('requires two non-null bounds');
+  });
+
+  it('answers every endpoint spelling exactly as the SCHEMA door does', () => {
+    // The defect this ruling closes was one published sentence
+    // (`RANGE_ENDPOINT_DESCRIPTION`) with two truth values, so the pin is the
+    // AGREEMENT itself rather than a second hand-written list that can drift
+    // from the door it is supposed to match.
+    const endpointPairs: Array<[string, unknown[]]> = [
+      ["['', '']", ['', '']],
+      ["['2026-01-01', '']", ['2026-01-01', '']],
+      ["['', '2026-12-31']", ['', '2026-12-31']],
+      ['[5, undefined]', [5, undefined]],
+      ['[undefined, 5]', [undefined, 5]],
+      ['[null, 1]', [null, 1]],
+      ['[1, null]', [1, null]],
+      // Controls that must stay LEGAL at BOTH doors — a red here would mean a
+      // door started reading falsiness, or shortness, instead of blankness.
+      ['[0, 0]', [0, 0]],
+      ["['0', '9']", ['0', '9']],
+      ["['A', 'M']", ['A', 'M']],
+      ["['08:00:00', '18:00:00']", ['08:00:00', '18:00:00']],
+      ["['2026-01-01', '2026-12-31']", ['2026-01-01', '2026-12-31']],
+      // ⛔ Whitespace-only is NOT judged, at EITHER door: the 2026-09-17 ruling
+      // is the empty string, `filter.test.ts` pins the schema side of this very
+      // row, and a trim here would re-open the split in the other direction.
+      ["['   ', 'M']", ['   ', 'M']],
+    ];
+    const refused: string[] = [];
+    for (const [label, pair] of endpointPairs) {
+      const schemaRefuses = !RangeOperatorSchema.safeParse({ $between: pair }).success;
+      let runtimeRefuses = false;
+      try {
+        parseFilterAST({ close_date: { $between: pair } });
+      } catch {
+        runtimeRefuses = true;
+      }
+      expect(runtimeRefuses, `${label}: schema refuses=${schemaRefuses}`).toBe(schemaRefuses);
+      if (schemaRefuses) refused.push(label);
+    }
+    // Guards the loop from passing vacuously in either direction.
+    expect(refused).toHaveLength(7);
   });
 
   // ── the ordering carve-out, ruled 2026-09-01 (#14080) ──────────────────
@@ -266,6 +368,11 @@ describe('the list-comparand shape door (#5869) runs inside parseFilterAST (#922
       { stage: { $nin: [null] } },
       { close_date: { $between: [null, null] } },
       { close_date: { $between: ['2026-07-01', null] } },
+      // The 2026-09-20 blank carve-out (#19071): the named side and both
+      // prescriptions ride the same unrelaxed bound.
+      { close_date: { $between: ['2026-07-01', ''] } },
+      { close_date: { $between: ['', '2026-07-31'] } },
+      { close_date: { $between: [5, undefined] } },
       // The 2026-09-01 ordering carve-out (#14080): `$gte` / `$lte` carry the
       // longest spelling lists, so they are the tallest of the four.
       { close_date: { $gte: null } },
 
@@ -132,6 +132,40 @@
  *   gate does not descend into one: a comparand is data, and a stricter reading
  *   here would invent a contract no backend agrees with.
  *
+ * ## Refused BY RULING, 2026-09-20: a BLANK `$between` ENDPOINT (#19071)
+ *
+ * The runtime twin of the schema door's 2026-09-17 rule (#18012). That ruling
+ * wrote "BOTH are required NON-BLANK: an empty string, null and undefined are
+ * refused, and the refusal names the blank side" into the PUBLISHED endpoint
+ * contract (`RANGE_ENDPOINT_DESCRIPTION`, `./filter.zod.ts`) and enforced it at
+ * the schema door alone. This door went on lowering `{ $between: ['', ''] }`
+ * unchanged, so one published sentence had two truth values depending on which
+ * door a caller came through — and the door that passed it is the one an
+ * embedder reaches by handing a lowered filter straight to a driver, where the
+ * range stops bounding on the blank side while still reading as a complete
+ * range. Ruled 2026-09-20 (#19071, option A): the implementation follows the
+ * declaration.
+ *
+ * The scope is the SCHEMA door's notion of blank, ⛔ not a second one invented
+ * here — two doors disagreeing IS the defect:
+ *
+ * - **`''` and `undefined`** are refused, naming the blank side (MIN / MAX and
+ *   the index) and carrying the schema door's own prescription.
+ * - **`null`** keeps {@link nullRangeBoundError}, which prescribes the null
+ *   PREDICATE: an author who wrote `null` was reaching for absence, an author
+ *   who left a bound empty was reaching for a bound. Two blank spellings, two
+ *   intents, two remedies; ⛔ do not unify them. It is checked FIRST, so a pair
+ *   that is `null` on one side and blank on the other keeps the 2026-08-31
+ *   message it has always had.
+ * - **A whitespace-only endpoint is NOT judged**, because the schema door does
+ *   not judge one: `RangeOperatorSchema.safeParse({ $between: [' ', 'M'] })`
+ *   answers `success: true`, pinned deliberately in `filter.test.ts`. ⛔ A trim
+ *   here would re-open the very split this ruling closes, in the opposite
+ *   direction, and narrow a published face further than any ruling has.
+ * - **Falsiness is untouched**: `[0, 0]` and `['0', '9']` are ranges, and a
+ *   falsy `$in` / `$nin` MEMBER stays a value — #13357's rows stand, because
+ *   this ruling is about range ENDPOINTS and those are about VALUES.
+ *
  * ## Refusal envelope
  *
  * Every refusal carries `code: 'INVALID_FILTER'` and `status: 400` (ADR-0112
@@ -371,6 +405,45 @@ function nullRangeBoundError(
   );
 }
 
+/**
+ * A `$between` bound that is BLANK — the empty string or `undefined`, at
+ * either end. Refused BY RULING, 2026-09-20 (#19071); see the module note's
+ * third "Refused BY RULING" section.
+ *
+ * Its own message rather than an arm of {@link nullRangeBoundError}: that one
+ * prescribes the null PREDICATE, which is the wrong remedy for a bound the
+ * author simply did not type. This one is the schema door's
+ * `blankRangeBoundMessage` (`./filter.zod.ts`) carrying the same two
+ * prescriptions — write the bound you meant, or, if only one side was ever
+ * bounded, drop `$between` for the scalar comparison that says so — in this
+ * door's own #5346/#5348 wording contract: operator, field, position, the
+ * named side, authoring spellings, front-loaded and inside the 500-char client
+ * bound. Reconciled by pin, as the null pair is.
+ *
+ * The received value is described in WORDS rather than previewed: `undefined`
+ * inside an array renders as `null` through `JSON.stringify`, which would show
+ * an author the one spelling this message is not about.
+ */
+function blankRangeBoundError(
+  context: string | undefined,
+  field: string,
+  bound: unknown,
+  index: number,
+  path: string,
+): Error {
+  const spellings = LIST_COMPARAND_OPERATORS.get('$between') ?? [];
+  return invalidFilterComparandError(
+    context,
+    `Operator "$between" on field "${field}" requires two non-blank bounds. Received ` +
+    `${bound === undefined ? 'undefined' : 'an empty string'} at ${path}[${index}] ` +
+    `(the ${index === 0 ? 'MIN' : 'MAX'} bound). A blank endpoint is compared as a value, so ` +
+    `the range stops bounding on that side. Write the bound you meant; for a genuinely ` +
+    `one-sided range use {"$gte": min} / {"$lte": max}. Authoring spellings: ` +
+    `${spellings.join(', ')}. The filter was NOT applied, and an unapplied filter would have ` +
+    `returned the UNFILTERED result set.`,
+  );
+}
+
 /**
  * A `null` comparand of `$gt` / `$gte` / `$lt` / `$lte` — refused BY RULING,
  * 2026-09-01 (#14080); see the module note's second "Refused BY RULING"
@@ -494,6 +567,18 @@ function assertFieldListComparands(
       if (nullBound !== -1) {
         throw nullRangeBoundError(context, field, comparand, nullBound, `${path}.${op}`);
       }
+      // Then the BLANK carve-out (2026-09-20 ruling, #19071) — exactly the two
+      // spellings the schema door refuses as blank, so the two doors answer one
+      // question the same way. Strict equality against `''` and `undefined`:
+      // ⛔ no trim, because a whitespace-only endpoint PASSES the schema door
+      // and narrowing further here would re-open the split in the other
+      // direction; and `0` / `'0'` / `false` are endpoints, not blanks.
+      const blankBound = comparand.findIndex((bound) => bound === '' || bound === undefined);
+      if (blankBound !== -1) {
+        throw blankRangeBoundError(
+          context, field, comparand[blankBound], blankBound, `${path}.${op}`,
+        );
+      }
       continue;
     }
     if (!Array.isArray(comparand)) {