test(objectql,rest): a list at a scalar operator is pinned as the shape face's refusal at every engine and wire position (#21448)

Claude-Session: https://claude.ai/code/session_01DiCSbmJrkzNhuEAier4VoJ
Co-authored-by: Claude <noreply@anthropic.com>

Author: claude

packages/objectql/src/engine-boolean-comparand-declared-type-door.test.ts

@@ -428,7 +428,9 @@ describe('[#21333] the boolean-comparand arm at the engine collection point', ()
     ['implicit Date', (v) => v, () => new Date(Date.UTC(2026, 0, 1)), 'date'],
     ['a $nin member Date', (v) => ({ $nin: [v, true] }), () => new Date(Date.UTC(2026, 0, 1)), 'date'],
     ['a $in member [true] (the card)', (v) => ({ $in: [false, v] }), () => [true], 'array'],
-    ['$gt [true]', (v) => ({ $gt: v }), () => [true], 'array'],
+    // [#21448] `$gt [true]` left this table: a list at a scalar operator is the
+    // shared comparand-shape face's refusal, one door before this arm, at every
+    // position — pinned in its own block below.
   ];
 
   /** What the contract says is wrong, per non-string form — the clause after "which is not a boolean:". */
@@ -502,6 +504,34 @@ describe('[#21333] the boolean-comparand arm at the engine collection point', ()
     }
   });
 
+  it('[#21448] $gt [true] is the shared comparand-shape face\'s at all three positions — in its words, no read', async () => {
+    const faceSentence = (field: string, path: string) =>
+      `Operator "$gt" on field "${field}" requires a single comparable value, but received an array ([true]) at ${path}.`;
+    reads.length = 0;
+    const where = await refusalOf(engine.find(OBJECT, { where: { f_boolean: { $gt: [true] } } as FilterCondition }));
+    expect({ code: where!.code, status: where!.status }).toEqual({ code: 'INVALID_FILTER', status: 400 });
+    expect(where!.message).toMatch(/^find\('boolean_door_probe'\): Operator /);
+    expect(where!.message).toContain(faceSentence('f_boolean', 'where.f_boolean.$gt'));
+    const filtered = await refusalOf(engine.aggregate(OBJECT, {
+      aggregations: [
+        { function: 'count', alias: 'all' },
+        { function: 'count', alias: 'bad', filter: { f_boolean: { $gt: [true] } } },
+      ],
+    } as EngineAggregateOptions));
+    expect({ code: filtered!.code, status: filtered!.status }).toEqual({ code: 'INVALID_FILTER', status: 400 });
+    expect(filtered!.message).toContain(faceSentence('f_boolean', 'aggregations[1].filter.f_boolean.$gt'));
+    const having = await refusalOf(engine.aggregate(OBJECT, {
+      groupBy: ['f_boolean'], aggregations: [{ function: 'count', alias: 'n' }], having: { f_boolean: { $gt: [true] } },
+    } as EngineAggregateOptions));
+    expect({ code: having!.code, status: having!.status }).toEqual({ code: 'INVALID_FILTER', status: 400 });
+    expect(having!.message).toContain(faceSentence('f_boolean', 'having.f_boolean.$gt'));
+    expect(reads).toHaveLength(0);
+    // This arm's own walk still refuses the form when asked alone; no door
+    // reaches it at a scalar operator any more.
+    expect(() => narrowNumberComparands(OBJECT, 'find', engine.registry.getObject(OBJECT), { f_toggle: { $gt: [true] } }))
+      .toThrow(/compares a declared toggle field/);
+  });
+
   it('[#21382] the controls at all three positions: true and 1 answer exactly what they answered before', async () => {
     for (const control of [true, 1]) {
       expect(await driverWhere({ f_boolean: control }), String(control)).toEqual(lowered({ f_boolean: true }));

packages/objectql/src/engine-number-comparand-declared-type-door.test.ts

@@ -451,7 +451,9 @@ describe('[#20351] the number-comparand declared-type door at the engine collect
     ['true', () => true, 'boolean'],
     ['false', () => false, 'boolean'],
     ['a Date', () => new Date(Date.UTC(2026, 0, 1)), 'date'],
-    ['an array', () => [10], 'array'],
+    // [#21448] `[10]` left this table: a list at a scalar operator is the
+    // shared comparand-shape face's refusal, one door before this one, at every
+    // position — pinned in its own block below.
   ];
 
   it('[#20502] refuses a boolean, a Date or an array in ONE aggregation\'s own filter, rooted at that position — no read', async () => {
@@ -500,6 +502,39 @@ describe('[#20351] the number-comparand declared-type door at the engine collect
     }
   });
 
+  it('[#21448] an array at a scalar operator is the shared comparand-shape face\'s at all three positions — in its words, no read', async () => {
+    const faceSentence = (op: string, field: string, path: string) =>
+      `Operator "${op}" on field "${field}" requires a single comparable value, but received an array ([10]) at ${path}.`;
+    reads.length = 0;
+    const where = await refusalOf(engine.find(OBJECT, { where: { f_number: { $gt: [10] } } as FilterCondition }));
+    expect({ code: where!.code, status: where!.status }).toEqual({ code: 'INVALID_FILTER', status: 400 });
+    expect(where!.message).toMatch(/^find\('number_door_probe'\): Operator /);
+    expect(where!.message).toContain(faceSentence('$gt', 'f_number', 'where.f_number.$gt'));
+    for (const op of ['$gt', '$lte'] as const) {
+      const filtered = await refusalOf(engine.aggregate(OBJECT, {
+        aggregations: [
+          { function: 'count', alias: 'all' },
+          { function: 'count', alias: 'bad', filter: { f_number: { [op]: [10] } } },
+        ],
+      } as EngineAggregateOptions));
+      expect({ code: filtered!.code, status: filtered!.status }, op).toEqual({ code: 'INVALID_FILTER', status: 400 });
+      expect(filtered!.message, op).toMatch(/^aggregate\('number_door_probe'\): Operator /);
+      expect(filtered!.message, op).toContain(faceSentence(op, 'f_number', `aggregations[1].filter.f_number.${op}`));
+    }
+    const having = await refusalOf(engine.aggregate(OBJECT, {
+      groupBy: ['f_text'],
+      aggregations: [{ function: 'count', alias: 'total' }],
+      having: { total: { $gt: [10] } },
+    } as EngineAggregateOptions));
+    expect({ code: having!.code, status: having!.status }).toEqual({ code: 'INVALID_FILTER', status: 400 });
+    expect(having!.message).toContain(faceSentence('$gt', 'total', 'having.total.$gt'));
+    expect(reads).toHaveLength(0);
+    // This door's own walk still names the form when asked alone; no door
+    // reaches that arm at a scalar operator any more.
+    expect(findNonNumericComparand(engine.registry.getObject(OBJECT), { f_number: { $gt: [10] } }))
+      .toMatchObject({ field: 'f_number', form: 'array' });
+  });
+
   it('[#20502] the numeric control at all three positions: a number reaches the driver and the evaluator as written', async () => {
     reads.length = 0;
     await engine.find(OBJECT, { where: { f_number: { $gt: 10 } } });

packages/rest/src/analytics-filter-refusal-envelope.test.ts

@@ -292,6 +292,16 @@ describe('[#17551] the structurally-malformed filter spellings are refused at th
       member: 'selection.runtimeFilter.stage.$in.1',
       sentence: /^Filter comparand is a plain object \(\{"a":1\}\), which no driver can compare\./,
     },
+    {
+      // [#21448] A list at a scalar operator, whatever the column type. Both
+      // analytics faces bound its FIRST member on a text column (200, wrong
+      // rows); the shared comparand-shape face now refuses it on query, and the
+      // schema door asks that face, so it is refused here, located on the member.
+      name: 'a list at a scalar operator',
+      runtimeFilter: { stage: { $gt: ['a', 'z'] } },
+      member: 'selection.runtimeFilter.stage.$gt',
+      sentence: /^Operator "\$gt" on field "stage" requires a single comparable value, but received an array \(\["a","z"\]\)\. Write ONE value\./,
+    },
   ];
 
   for (const c of AT_THE_DOOR) {

packages/rest/src/data-boolean-comparand-door.test.ts

@@ -91,7 +91,9 @@ const REFUSED_OVER_REST: ReadonlyArray<readonly [string, unknown]> = [
   ['a $in member 2', { $in: [false, 2] }],
   ['a $nin member -1', { $nin: [-1] }],
   ['a $in member [true] (the card)', { $in: [false, [true]] }],
-  ['$gt [true] (an array at a scalar slot)', { $gt: [true] }],
+  // [#21448] `$gt [true]` left this table: a list at a scalar operator is the
+  // shared comparand-shape face's refusal, one door before this one — pinned
+  // in its own block below. A list as a `$in` MEMBER is still this door's.
 ];
 
 /**
@@ -245,6 +247,40 @@ for (const cell of CELLS) {
         expect(reads.n - before, 'no read of the object — every refusal precedes the driver').toBe(0);
       });
 
+      it('[#21448] $gt [true]: one 400 at every position, in the shared comparand-shape face\'s words — VALIDATION_FAILED at the wire, INVALID_FILTER in process — no read', async () => {
+        const before = reads.n;
+        const sentence = 'Operator "$gt" on field "done" requires a single comparable value, but received an array ([true])';
+        const where = { done: { $gt: [true] } } as FilterCondition;
+        // Over the wire the route parses its body first, and the schema door
+        // asks the face (#20116): VALIDATION_FAILED, located on the member, in
+        // the face's sentence less its location — before the engine runs.
+        for (const [body, member] of [
+          [{ where }, 'query.where.done.$gt'],
+          [perAggregation(where), 'query.aggregations.1.filter.done.$gt'],
+          [grouped('native', where), 'query.having.done.$gt'],
+        ] as const) {
+          const res = await query(body as Record<string, unknown>);
+          expect(res.status, JSON.stringify(res.body)).toBe(400);
+          expect(res.body.code, member).toBe('VALIDATION_FAILED');
+          const at = (res.body.fields as Array<{ field: string; message: string }>).filter((f) => f.field === member);
+          expect(at, JSON.stringify(res.body.fields)).toHaveLength(1);
+          expect(at[0]!.message.startsWith(`${sentence}. Write ONE value.`), at[0]!.message).toBe(true);
+        }
+        // In process the engine's seam runs the face itself: INVALID_FILTER, located.
+        const err = await refusalOf(engine.find(OBJECT, { where }));
+        expect({ code: err?.code, status: err?.status }).toEqual({ code: 'INVALID_FILTER', status: 400 });
+        expect(err?.message).toContain(`${sentence} at where.done.$gt.`);
+        const filtered = await refusalOf(engine.aggregate(OBJECT, perAggregation(where)));
+        expect({ code: filtered?.code, status: filtered?.status }).toEqual({ code: 'INVALID_FILTER', status: 400 });
+        expect(filtered?.message).toContain(`${sentence} at aggregations[1].filter.done.$gt.`);
+        for (const path of ['native', 'rows'] as const) {
+          const having = await refusalOf(engine.aggregate(OBJECT, grouped(path, where)));
+          expect({ code: having?.code, status: having?.status }, `having ${path}`).toEqual({ code: 'INVALID_FILTER', status: 400 });
+          expect(having?.message, `having ${path}`).toContain(`${sentence} at having.done.$gt.`);
+        }
+        expect(reads.n - before, 'no read of the object — every refusal precedes the driver').toBe(0);
+      });
+
       it('the controls: true, 1 and "true" answer the rows they name, at every position', async () => {
         for (const [name, spec, ids] of CONTROLS) {
           const res = await query({ where: { done: spec } });

packages/rest/src/data-number-comparand-door.test.ts

@@ -120,7 +120,9 @@ const NON_STRING_OVER_REST: ReadonlyArray<readonly [string, unknown]> = [
   ['$ne true', { $ne: true }],
   ['a $in member true', { $in: [10, true] }],
   ['a $between bound true', { $between: [true, 20] }],
-  ['$gt [1] (an array)', { $gt: [1] }],
+  // [#21448] `$gt [1]` left this table: a list at a scalar operator is the
+  // shared comparand-shape face's refusal, one door before this one — pinned
+  // in its own block below. A list as a `$in` MEMBER is still this door's.
   ['a $in member [1]', { $in: [[1], 10] }],
 ];
 
@@ -134,7 +136,7 @@ const NON_STRING_OVER_REST: ReadonlyArray<readonly [string, unknown]> = [
 const NON_STRING_IN_PROCESS: ReadonlyArray<readonly [string, () => unknown]> = [
   ['true', () => true],
   ['a Date', () => new Date(Date.UTC(2026, 0, 1))],
-  ['an array', () => [1]],
+  // [#21448] `[1]` left this table for the shared comparand-shape face's block below.
 ];
 
 /** name · the constraint as a numeric string · the same as a number · `where` count. */
@@ -301,6 +303,41 @@ for (const cell of CELLS) {
         expect(reads.n - before, 'no read of the object — every refusal precedes the driver').toBe(0);
       });
 
+      it('[#21448] a list at a scalar operator: one 400 at every position, in the shared comparand-shape face\'s words — VALIDATION_FAILED at the wire, INVALID_FILTER in process — no read', async () => {
+        const before = reads.n;
+        const sentence = (field: string) => `Operator "$gt" on field "${field}" requires a single comparable value, but received an array ([1])`;
+        // Over the wire the route parses its body first, and the schema door
+        // asks the face (#20116): VALIDATION_FAILED, located on the member, in
+        // the face's sentence less its location — before the engine runs.
+        for (const [body, member, field] of [
+          [{ where: { amount: { $gt: [1] } } }, 'query.where.amount.$gt', 'amount'],
+          [perAggregation({ amount: { $gt: [1] } } as FilterCondition), 'query.aggregations.1.filter.amount.$gt', 'amount'],
+          [grouped('native', { total: { $gt: [1] } } as FilterCondition), 'query.having.total.$gt', 'total'],
+        ] as const) {
+          const res = await query(body as Record<string, unknown>);
+          expect(res.status, JSON.stringify(res.body)).toBe(400);
+          expect(res.body.code, member).toBe('VALIDATION_FAILED');
+          const at = (res.body.fields as Array<{ field: string; message: string }>).filter((f) => f.field === member);
+          expect(at, JSON.stringify(res.body.fields)).toHaveLength(1);
+          expect(at[0]!.message.startsWith(`${sentence(field)}. Write ONE value.`), at[0]!.message).toBe(true);
+        }
+        // In process the engine's seam runs the face itself: INVALID_FILTER, located.
+        const found = await refusalOf(engine.find(OBJECT, { where: { amount: { $gt: [1] } } as FilterCondition }));
+        expect({ code: found?.code, status: found?.status }).toEqual({ code: 'INVALID_FILTER', status: 400 });
+        expect(found?.message).toContain(`${sentence('amount')} at where.amount.$gt.`);
+        const filtered = await refusalOf(engine.aggregate(OBJECT, perAggregation({ amount: { $gt: [1] } } as FilterCondition)));
+        expect({ code: filtered?.code, status: filtered?.status }).toEqual({ code: 'INVALID_FILTER', status: 400 });
+        expect(filtered?.message).toContain(`${sentence('amount')} at aggregations[1].filter.amount.$gt.`);
+        for (const path of ['native', 'rows'] as const) {
+          for (const column of ['total', 'top'] as const) {
+            const having = await refusalOf(engine.aggregate(OBJECT, grouped(path, { [column]: { $gt: [1] } } as FilterCondition)));
+            expect({ code: having?.code, status: having?.status }, `having ${path} ${column}`).toEqual({ code: 'INVALID_FILTER', status: 400 });
+            expect(having?.message, `having ${path} ${column}`).toContain(`${sentence(column)} at having.${column}.$gt.`);
+          }
+        }
+        expect(reads.n - before, 'no read of the object — every refusal precedes the driver').toBe(0);
+      });
+
       it('the control: a number is answered, and a numeric string counts what its number counts at every position', async () => {
         for (const [name, asString, asNumber, count] of NARROWED) {
           const s = await query({ where: { amount: asString } });