fix(engine): ObjectRepository declares the findOne/update shapes it already publishes

`IScopedObjectRepository.findOne` / `.update` declare `Record<string, any> | null`
and `Record<string, any> | number | null`, and `IDataEngine` — the call each of
these forwards to — declares the same. `ObjectRepository` sat between two narrow
declarations and re-widened the value back to `Promise<any>` on the way out, which
`implements IScopedObjectRepository` accepts (a wider return always satisfies a
narrower one) while every call site reaching a repository through the CLASS kept
reading `any`, `ObjectQL.createContext(…).object(n).findOne(…)` included.

Census: one consumer, `engine-filter-alias.test.ts`, which read `.status` off a
value that can be null. Repaired with the file's own `not.toBeNull()` / `!` idiom.

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

Author: claude

packages/objectql/src/engine-filter-alias.test.ts

@@ -217,8 +217,15 @@ describe('filter → where folds on every engine method (#4346)', () => {
         const repo = ctx.object('task');
         const viaWhere = await repo.findOne({ where: { status: 'done' } });
         const viaFilter = await repo.findOne({ filter: { status: 'done' } });
-        expect(viaFilter.status).toBe('done');
-        expect(viaWhere.status).toBe('done');
+        // [#16786] `repo.findOne` declares `Record<string, any> | null`, so the
+        // null both spellings could return is asserted away rather than read
+        // through — the same `expect(row).not.toBeNull()` / `row!` idiom this
+        // file already uses above. Under the old `Promise<any>` this pair
+        // agreed vacuously if BOTH lookups came back null.
+        expect(viaFilter).not.toBeNull();
+        expect(viaWhere).not.toBeNull();
+        expect(viaFilter!.status).toBe('done');
+        expect(viaWhere!.status).toBe('done');
     });
 
     it('a cleanup hook calling repo.delete({filter, multi}) no longer empties the object', async () => {

packages/objectql/src/engine.ts

@@ -14707,7 +14707,23 @@ export class ObjectRepository implements IScopedObjectRepository {
     });
   }
 
-  async findOne(query: any = {}): Promise<any> {
+  /**
+   * [#16786] Declared `Promise<Record<string, any> | null>`, not `Promise<any>`.
+   *
+   * `IScopedObjectRepository.findOne` has declared that shape since #16231's
+   * ruling A landed (PR #16783), and `IDataEngine.findOne` — the call this
+   * method forwards to, one line down — declares it too. This method sat
+   * between two narrow declarations and re-widened the value back to `any` on
+   * the way out, so `implements IScopedObjectRepository` stayed satisfied (a
+   * wider return always satisfies a narrower one) while every call site that
+   * reaches a repository through the CLASS rather than the interface kept
+   * reading `any` — `ObjectQL.createContext(…).object(n).findOne(…)` among
+   * them, which is exported.
+   *
+   * ⛔ Not a narrowing of the contract: the contract already said this. This
+   * is the implementation coming back to the declaration it published.
+   */
+  async findOne(query: any = {}): Promise<Record<string, any> | null> {
     return this.engine.findOne(this.objectName, {
       ...query,
       context: this.context,
@@ -14725,7 +14741,18 @@ export class ObjectRepository implements IScopedObjectRepository {
     return this.insert(data);
   }
 
-  async update(data: any, options: any = {}): Promise<any> {
+  /**
+   * [#16786] Declared `Promise<Record<string, any> | number | null>`, the same
+   * re-widening as {@link findOne} and repaired the same way: the record for
+   * the single-record form, the affected-row count for the predicate form
+   * (`{ where, multi: true }`), `null` when the write matched nothing.
+   *
+   * ⛔ `updateById` is deliberately NOT touched here. Its `Promise<any>` is
+   * what `IScopedObjectRepository.updateById` itself declares, so the class
+   * matches its contract and there is no drift to repair on this side; that
+   * member is `packages/spec`'s to narrow and stays open on #16786.
+   */
+  async update(data: any, options: any = {}): Promise<Record<string, any> | number | null> {
     return this.engine.update(this.objectName, data, {
       ...options,
       context: this.context,