test: type the new pins' query options instead of casting them

The query-options-erasure ratchet counted five new casts on the test
surface; the options are on-contract, so they are typed as
FilterCondition / EngineAggregateOptions.

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

Author: claude

packages/drivers/driver-memory/src/memory-20203-epoch-ms-date-comparand.test.ts

@@ -20,6 +20,7 @@
  */
 
 import { beforeAll, describe, expect, it } from 'vitest';
+import type { FilterCondition } from '@objectstack/spec/data';
 import { InMemoryDriver } from './memory-driver.js';
 
 const OBJECT = 'ledger_order';
@@ -62,8 +63,8 @@ const OPERATORS: ReadonlyArray<readonly [string, (v: As) => unknown, string[], s
 
 describe('[#20203] an epoch-ms number on a date field reads as the UTC calendar day of its instant', () => {
   let driver: InMemoryDriver;
-  const ids = async (object: string, where: Record<string, unknown>) =>
-    ((await driver.find(object, { where } as any)) as any[]).map((r) => r.id).sort();
+  const ids = async (object: string, where: FilterCondition) =>
+    (await driver.find(object, { where })).map((r) => r.id).sort();
 
   beforeAll(async () => {
     driver = new InMemoryDriver({});
@@ -87,7 +88,7 @@ describe('[#20203] an epoch-ms number on a date field reads as the UTC calendar
   it('the write path stores the same UTC calendar day — create and update', async () => {
     await driver.create(WRITES, { id: 'w1', placed_on: N });
     await driver.create(WRITES, { id: 'w2', placed_on: -1 }); // one ms before the epoch
-    const read = async (id: string) => ((await driver.findOne(WRITES, { where: { id } } as any)) as any)?.placed_on;
+    const read = async (id: string) => (await driver.findOne(WRITES, { where: { id } }))?.placed_on;
     expect(await read('w1')).toBe('2026-02-01');
     expect(await read('w2')).toBe('1969-12-31');
     await driver.update(WRITES, 'w1', { placed_on: N_JAN10 });

packages/drivers/driver-sql/src/sql-driver-20203-epoch-ms-date-comparand.test.ts

@@ -27,6 +27,7 @@
  */
 
 import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import type { FilterCondition } from '@objectstack/spec/data';
 import { SqlDriver } from './sql-driver.js';
 import { DIALECT_CELLS, declareDialectCell, type DialectCell } from './live-dialect-matrix.testkit.js';
 
@@ -72,13 +73,13 @@ const OPERATORS: ReadonlyArray<readonly [string, (v: As) => unknown, string[], s
   ['$eq on a UTC midnight', (v) => ({ $eq: v(N_MIDNIGHT) }), ['o4', 'o6'], []],
 ];
 
-const NO_AUDIT = { bypassTenantAudit: true } as any;
+const NO_AUDIT = { bypassTenantAudit: true };
 
 function measure(cell: DialectCell): void {
   describe(`[#20203] an epoch-ms number on a date field — ${cell.label}`, () => {
     let driver: SqlDriver;
-    const ids = async (table: string, where: Record<string, unknown>) =>
-      ((await driver.find(table, { where }, NO_AUDIT)) as any[]).map((r) => r.id).sort();
+    const ids = async (table: string, where: FilterCondition) =>
+      (await driver.find(table, { where }, NO_AUDIT)).map((r) => r.id).sort();
 
     beforeAll(async () => {
       driver = new SqlDriver(cell.config());
@@ -107,7 +108,7 @@ function measure(cell: DialectCell): void {
     it('the write path stores the same UTC calendar day — create and update', async () => {
       await driver.create(WRITES, { id: 'w1', placed_on: N }, NO_AUDIT);
       await driver.create(WRITES, { id: 'w2', placed_on: -1 }, NO_AUDIT); // one ms before the epoch
-      const read = async (id: string) => ((await driver.findOne(WRITES, { where: { id } }, NO_AUDIT)) as any)?.placed_on;
+      const read = async (id: string) => (await driver.findOne(WRITES, { where: { id } }, NO_AUDIT))?.placed_on;
       expect(await read('w1')).toBe('2026-02-01');
       expect(await read('w2')).toBe('1969-12-31');
       await driver.update(WRITES, 'w1', { placed_on: N_JAN10 }, NO_AUDIT);

packages/rest/src/data-query-epoch-ms-date-comparand.test.ts

@@ -25,6 +25,7 @@
  */
 
 import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import type { EngineAggregateOptions, FilterCondition } from '@objectstack/spec/data';
 import { ObjectQL } from '@objectstack/objectql';
 import { SqlDriver } from '@objectstack/driver-sql';
 import { ObjectStackProtocolImplementation } from '@objectstack/metadata-protocol';
@@ -129,7 +130,7 @@ describe('[#20203] where — an epoch-ms number on a date field, engine and REST
     it(`${op}: ${onDate.join(', ')} on both doors; nothing on an empty table; the datetime control reads the instant`, async () => {
       for (const [state, expectDate, expectDatetime] of [['populated', onDate, onDatetime], ['empty', [], []]] as const) {
         const { engine, post } = doors[state];
-        expect(sortedIds(await engine.find(OBJECT, { where: { placed_on: comparand } } as any)), `engine, ${state}`).toEqual(expectDate);
+        expect(sortedIds(await engine.find(OBJECT, { where: { placed_on: comparand } })), `engine, ${state}`).toEqual(expectDate);
         expect(sortedIds(await post({ where: { placed_on: comparand } })), `REST, ${state}`).toEqual(expectDate);
         expect(sortedIds(await post({ where: { opened_at: comparand } })), `datetime control, ${state}`).toEqual(expectDatetime);
       }
@@ -138,7 +139,7 @@ describe('[#20203] where — an epoch-ms number on a date field, engine and REST
 });
 
 describe('[#20203] a per-aggregation filter counts what its where twin counts', () => {
-  const perAggregation = (filter: unknown) => ({
+  const perAggregation = (filter: FilterCondition): EngineAggregateOptions => ({
     aggregations: [{ function: 'count', alias: 'n' }, { function: 'count', alias: 'm', filter }],
   });
   for (const [op, comparand, onDate] of OPERATORS) {
@@ -147,15 +148,15 @@ describe('[#20203] a per-aggregation filter counts what its where twin counts',
         const { engine, post } = doors[state];
         const expected = state === 'populated' ? onDate.length : 0;
         const query = perAggregation({ placed_on: comparand });
-        expect((await engine.aggregate(OBJECT, query as any))[0]?.m, `engine, ${state}`).toBe(expected);
+        expect((await engine.aggregate(OBJECT, query))[0]?.m, `engine, ${state}`).toBe(expected);
         expect((await post(query))[0]?.m, `REST, ${state}`).toBe(expected);
       }
     });
   }
 });
 
 describe('[#20203] having on max(date) reads the number as a calendar day', () => {
-  const grouped = (having: unknown) => ({
+  const grouped = (having: FilterCondition): EngineAggregateOptions => ({
     groupBy: ['customer_id'],
     aggregations: [
       { function: 'max', field: 'placed_on', alias: 'last_placed' },
@@ -164,7 +165,7 @@ describe('[#20203] having on max(date) reads the number as a calendar day', () =
     having,
   });
   // c1: last_placed 2026-01-10 · c2: 2026-03-01 · c3: 2026-02-01
-  const HAVING: ReadonlyArray<readonly [string, Record<string, unknown>, string[]]> = [
+  const HAVING: ReadonlyArray<readonly [string, FilterCondition, string[]]> = [
     ['$gt on max(date)', { last_placed: { $gt: N } }, ['c2']],
     ['$eq on max(date)', { last_placed: { $eq: N } }, ['c3']],
     ['$in on max(date)', { last_placed: { $in: [N, N_JAN10] } }, ['c1', 'c3']],
@@ -176,7 +177,7 @@ describe('[#20203] having on max(date) reads the number as a calendar day', () =
         const { engine, post } = doors[state];
         const expected = state === 'populated' ? kept : [];
         const q = grouped(having);
-        expect((await engine.aggregate(OBJECT, q as any)).map((r: any) => r.customer_id).sort(), `engine, ${state}`).toEqual(expected);
+        expect((await engine.aggregate(OBJECT, q)).map((r: any) => r.customer_id).sort(), `engine, ${state}`).toEqual(expected);
         expect((await post(q)).map((r) => r.customer_id).sort(), `REST, ${state}`).toEqual(expected);
       }
     });