test(objectql): type-clean the new transaction contract test under the TEST_DEBT re-measure (#5696)

objectql's test layer is excluded from its own `tsconfig.json`, so
`pnpm --filter @objectstack/objectql typecheck` never reads these files —
only the ledger's `--re-measure` does, by synthesizing a config with the test
globs unexcluded. The new file arrived with 7 errors nothing local reported.

Two shapes, both fixed rather than absorbed:

- `registry.registerObject(x as any)` — `packageId` is not optional (TS2554).
- `promise.catch((e) => e as E)` types the result `E | <resolved type>`, so
  every property read on it is TS2339. Replaced by a `rejection<E>()` helper
  that narrows to the rejection AND throws if the call did not reject at all —
  which the bare `.catch()` would have let pass silently as a green test.

Re-measured: zero errors in this file.

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

Author: claude

packages/objectql/src/engine-transaction-contract.test.ts

@@ -29,6 +29,23 @@ interface Recorded {
   args: unknown[];
 }
 
+/**
+ * The error a call rejected with, typed as `E`.
+ *
+ * `promise.catch((e) => e as E)` types the result as `E | <resolved type>`, so
+ * every property read on it is a type error. This narrows to the rejection and
+ * fails loudly if the call did NOT reject — which a bare `.catch()` would
+ * silently let through as a passing test.
+ */
+async function rejection<E>(p: Promise<unknown>): Promise<E> {
+  try {
+    await p;
+  } catch (e) {
+    return e as E;
+  }
+  throw new Error('expected the call to reject, but it resolved');
+}
+
 function recordingLogger() {
   const records: Recorded[] = [];
   const push = (level: Recorded['level']) => (message: string, ...args: unknown[]) =>
@@ -107,7 +124,7 @@ async function engineWith(opts: { transactional: boolean }) {
   const driver = makeDriver('primary', { transactional: opts.transactional });
   engine.registerDriver(driver, true);
   await engine.init();
-  engine.registry.registerObject({ name: 'thing', fields: { name: { type: 'text' } } } as any);
+  engine.registry.registerObject({ name: 'thing', fields: { name: { type: 'text' } } } as any, '__test__');
   return { rec, engine, driver };
 }
 
@@ -132,9 +149,9 @@ describe('transaction({ require: true }) refuses a driver that cannot roll back
   it('carries the boundary-crossing code, the datasource, and the fix', async () => {
     const { engine } = await engineWith({ transactional: false });
 
-    const err = await engine
-      .transaction(async () => 'unreachable', undefined, { require: true })
-      .catch((e: unknown) => e as TransactionUnsupportedError);
+    const err = await rejection<TransactionUnsupportedError>(
+      engine.transaction(async () => 'unreachable', undefined, { require: true }),
+    );
 
     expect(err.code).toBe('ERR_TRANSACTION_UNSUPPORTED');
     expect(err.datasource).toBe('primary');