test(objectql): type the #7095 query-options sites instead of erasing them to any

The four call sites the #7095 pins added tripped the #4918 query-options-erasure
ratchet (test surface 249 -> 253). Fixed at the call sites, per the rule's own
prescription — the ceiling is unchanged and no pin is weakened.

Three were ON-contract and are now typed:

  - the `it.each` sort table is `Array<[string, NonNullable<EngineQueryOptions['orderBy']>]>`,
    so the three refused sorts are checked as the well-formed `SortNode[]` they
    are. It is the FIELD they name that the engine refuses, never their shape,
    and an `as any` there would have erased the one channel that enforces
    `{ field, order }` on a direct engine call — the `direction`-vs-`order`
    mistake #4674 is about.
  - both `expand` sites drop the assertion entirely: `EngineQueryOptions.expand`
    is `Record<string, QuerySchema>`, so the nested `{ orderBy }` was always
    assignable and the cast was never buying anything.

One is DELIBERATELY off-contract — the negative pin that smuggles an opt-out
flag onto the public options bag — and is now `as unknown as EngineQueryOptions`
rather than a bare `as any`: it names the contract being bypassed, keeps the
rest of the call type-checked, and greps as an intentional act. That is exactly
the case #4918 carved the spelling out for, since the assertion's whole subject
is that the engine rejects the unknown key.

Refs #7095, #4918, #4674, #4721

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01HJgGahRqaYPRJ2oKmk9Czc

Author: claude

packages/objectql/src/query-expression-conformance.test.ts

@@ -52,6 +52,7 @@
 
 import { describe, it, expect, beforeEach } from 'vitest';
 import { ObjectStackProtocolImplementation } from '@objectstack/metadata-protocol';
+import type { EngineQueryOptions } from '@objectstack/spec/data';
 import { ObjectQL } from './engine.js';
 
 const projectObject = {
@@ -698,15 +699,23 @@ describe('#4226 — sort / select / expand on the list path (real ObjectQL engin
         expect(bySummary.map((r: any) => r.title)).toEqual(['E', 'C', 'D', 'B', 'A']);
     });
 
-    it.each([
+    // Typed as the contract rather than asserted through it: these three sorts
+    // are perfectly well-formed `SortNode[]` — it is the FIELD they name that
+    // the engine refuses, not their shape. An `as any` here would erase the one
+    // channel that enforces `{ field, order }` on a direct engine call
+    // (`query-options/no-any-erasure`, #4674/#4918), and would have hidden the
+    // very `direction`-vs-`order` mistake that rule exists to catch.
+    const REFUSED_SORTS: Array<[string, NonNullable<EngineQueryOptions['orderBy']>]> = [
         ['ascending', [{ field: 'sort_key', order: 'asc' }]],
         ['descending', [{ field: 'sort_key', order: 'desc' }]],
         ['second of two', [{ field: 'title', order: 'asc' }, { field: 'sort_key', order: 'asc' }]],
-    ])('`engine.find` REFUSES a formula ORDER BY instead of dropping it — %s', async (_label, orderBy) => {
+    ];
+
+    it.each(REFUSED_SORTS)('`engine.find` REFUSES a formula ORDER BY instead of dropping it — %s', async (_label, orderBy) => {
         // The public boundary, reached directly — no protocol, no ingress gate.
         // This is the exact call that answered 200-in-insertion-order before
         // #7095, for both directions, byte-identically.
-        await expect(engine.find('showcase_task', { orderBy: orderBy as any }))
+        await expect(engine.find('showcase_task', { orderBy }))
             .rejects.toMatchObject({
                 status: 400,
                 code: 'INVALID_SORT',
@@ -769,7 +778,7 @@ describe('#4226 — sort / select / expand on the list path (real ObjectQL engin
         // deliberately NOT ridden in on this card. Tracked as follow-up.
         const rows: any = await engine.find('showcase_task', {
             expand: { parent_id: { orderBy: [{ field: 'sort_key', order: 'asc' }] } },
-        } as any);
+        });
         // The call succeeds and the FK ids are retained UNEXPANDED — that is
         // the backstop's contract, and what makes this observable-not-refused.
         expect(rows).toHaveLength(5);
@@ -780,7 +789,7 @@ describe('#4226 — sort / select / expand on the list path (real ObjectQL engin
         // expand being broken for every sort.
         const ok: any = await engine.find('showcase_task', {
             expand: { parent_id: { orderBy: [{ field: 'title', order: 'asc' }] } },
-        } as any);
+        });
         expect(ok.some((r: any) => typeof r.parent_id === 'object' && r.parent_id !== null)).toBe(true);
     });
 
@@ -797,10 +806,15 @@ describe('#4226 — sort / select / expand on the list path (real ObjectQL engin
         // the ADR-0112 wire envelope — so this asserts the message, which is
         // what a caller reaching for such a flag would actually be told.)
         for (const smuggled of ['allowUnmaterializedSort', 'internal', '__internal', 'tolerateDroppedSort']) {
+            // `as unknown as EngineQueryOptions`, never a bare `as any`: this
+            // input is DELIBERATELY off-contract — that is the whole subject of
+            // the assertion — so the cast names the contract being bypassed and
+            // greps as an intentional act, while the rest of the call stays
+            // type-checked (#4918's prescription for exactly this case).
             await expect(engine.find('showcase_task', {
                 orderBy: [{ field: 'sort_key', order: 'asc' }],
                 [smuggled]: true,
-            } as any)).rejects.toThrow(new RegExp(`does not recognise option.*'${smuggled}'`));
+            } as unknown as EngineQueryOptions)).rejects.toThrow(new RegExp(`does not recognise option.*'${smuggled}'`));
         }
         // And the tolerance really is gone rather than merely unreachable: the
         // shape the old hole answered 200 for now throws.