@@ -2,7 +2,7 @@
 '@objectstack/spec': minor
 ---
 
-`@objectstack/spec/data` now exports the typed hook `ctx.api` face — `HookApi`, `HookObjectApi`, `HookQuery`, `HookCountQuery`, `HookUpdateDoc`, `HookUpdateOptions`, `HookDeleteOptions`, `HookDoc` and `HookDriverPassthroughOptions` — so a metadata app's `*.hook.ts` imports the platform's type instead of hand-declaring one (#18163). The same entry additionally re-exports `EngineTransactionInfo`, `EngineTransactionOptions`, `IScopedContext` and `IScopedObjectRepository`, which its public declarations reference structurally: without them a consumer that imports only `@objectstack/spec/data` and emits declarations answers `TS2883: The inferred type ... cannot be named without a reference to ...`. Type-only re-exports of the declarations `@objectstack/spec/contracts` already publishes, not second declarations.
+`@objectstack/spec/data` now exports the typed hook `ctx.api` face — `HookApi`, `HookObjectApi`, `HookQuery`, `HookCountQuery`, `HookUpdateDoc`, `HookUpdateOptions`, `HookDeleteOptions`, `HookDoc` and `HookDriverPassthroughOptions` — so a metadata app's `*.hook.ts` imports the platform's type instead of hand-declaring one (#18163). The same entry additionally re-exports `EngineTransactionInfo` and `EngineTransactionOptions`, which its public declarations reference structurally: without them a consumer that imports only `@objectstack/spec/data` and emits declarations answers `TS2883: The inferred type ... cannot be named without a reference to ...`. Type-only re-exports of the declarations `@objectstack/spec/contracts` already publishes, not second declarations.
 
 ```ts
 import type { HookApi } from '@objectstack/spec/data';
@@ -19,6 +19,6 @@ The platform already implemented this surface; it just never published a type an
 - **Every option shape is DERIVED, not transcribed.** Each is an `Omit`/`Pick` over the `Engine*Options` schemas that the engine's own per-method legal-key sets are pinned against, so a key added to a schema reaches the published type in the same run it reaches the engine's accepted set. `count` is the one shape without the driver pass-through keys, because the engine forwards no bag on that method and rejects them there — engine behaviour no document states, and exactly what a hand-written copy gets wrong.
 - **What is deliberately absent, each for a stated reason**: `context` (the repository injects it and discards a caller's), the `cursor` / `distinct` / `upsert` tombstones, `sudo()` (the #5945 exclusion stands — `Hook.runAs: 'system'` is the declared way to run elevated), and `aggregate` / `execute` / `create` / `deleteById`.
 
-Additive only: thirteen new exported names from `./data` (nine new declarations plus four type-only re-exports), no removal and no signature change, so nothing an existing consumer imports moves.
+Additive only: eleven new exported names from `./data` (nine new declarations plus two type-only re-exports), no removal and no signature change, so nothing an existing consumer imports moves.
 
 Clause-②: yes (widening)
@@ -12,8 +12,8 @@
 # excluded: documentation drift is `check:docs`'s axis, not this one.
 #
 # entry: ./data
-# exported names: 845
-# declarations: 858
+# exported names: 844
+# declarations: 857
 #
 # GENERATED — ⛔ never hand-edited. Regenerate after a real build:
 #   pnpm --filter @objectstack/spec build && pnpm --filter @objectstack/spec gen:api-surface-declarations
@@ -14631,39 +14631,6 @@ declare const INLINE_CREDENTIAL_REFUSED: (key: string) => string;
 // ── INSTANT_TYPES (const) ──
 declare const INSTANT_TYPES: ReadonlySet<string>;
 
-// ── IScopedContext (interface) ──
-interface IScopedContext {
-    /** The repository for `name`, bound to this context. */
-    object(name: string): IScopedObjectRepository;
-    /**
-     * Run `callback` inside one driver transaction: committed when it returns,
-     * rolled back when it throws.
-     *
-     * The callback receives a NEW `IScopedContext` whose operations share the
-     * transaction handle — reach objects through THAT context (`tx.object(…)`),
-     * not the outer one, or the writes land outside the transaction.
-     *
-     * ## Why the callback's second parameter is declared even though no corpus
-     * site reads it
-     *
-     * The evidence bar above governs WHICH MEMBERS exist, not what a declared
-     * member's signature is allowed to say. A parameter list describes what the
-     * PRODUCER hands the callback, and the producer hands it two arguments
-     * unconditionally (`ScopedContext.transaction`, #5696): declaring one would
-     * be a false statement that additionally makes `async (tx, info) => …`
-     * — legal, working code — a compile error. Contravariance means the
-     * zero-argument and one-argument callbacks the corpus actually writes still
-     * satisfy this, so the truthful signature is also the more permissive one.
-     * {@link EngineTransactionInfo} is reused rather than re-spelled, for the
-     * same reason `opts` is: ADR-0119 D1 and #5696 rule that this surface is a
-     * second IMPLEMENTATION of `IObjectQLEngine.transaction`, never a second
-     * DIALECT of it — `opts.require`'s fail-closed refusal is honoured here
-     * identically, and a contract that omitted it would re-open in declaration
-     * the dialect the implementation was made to close.
-     */
-    transaction<T>(callback: (trxCtx: IScopedContext, info: EngineTransactionInfo) => Promise<T>, opts?: EngineTransactionOptions): Promise<T>;
-}
-
 // ── ImportFieldMapping (type) ──
 type ImportFieldMapping = z.input<typeof ImportFieldMappingSchema>;
 
 
@@ -365,7 +365,6 @@
     "IMPORT_REFERENCE_TYPES (const)",
     "INLINE_CREDENTIAL_REFUSED (const)",
     "INSTANT_TYPES (const)",
-    "IScopedContext (interface)",
     "ImportFieldMapping (type)",
     "ImportFieldMappingParsed (type)",
     "ImportFieldMappingSchema (const)",
 
@@ -355,7 +355,6 @@
     "IMPORT_REFERENCE_TYPES": "src/data/import-coercion.ts#IMPORT_REFERENCE_TYPES (const)",
     "INLINE_CREDENTIAL_REFUSED": "src/data/driver/common.zod.ts#INLINE_CREDENTIAL_REFUSED (const)",
     "INSTANT_TYPES": "src/data/field-value.zod.ts#INSTANT_TYPES (const)",
-    "IScopedContext": "src/contracts/scoped-context.ts#IScopedContext (interface)",
     "ImportFieldMapping": "src/data/mapping.zod.ts#ImportFieldMapping (type)",
     "ImportFieldMappingParsed": "src/data/mapping.zod.ts#ImportFieldMappingParsed (type)",
     "ImportFieldMappingSchema": "src/data/mapping.zod.ts#ImportFieldMappingSchema (const)",
 
@@ -59,8 +59,6 @@ import type {
   HookObjectApi,
   HookQuery,
   HookUpdateOptions,
-  IScopedContext as ReExportedScopedContext,
-  IScopedObjectRepository as ReExportedScopedRepository,
 } from './hook-api';
 import type { IScopedContext, IScopedObjectRepository } from '../contracts/scoped-context';
 
@@ -191,20 +189,10 @@ describe('HookApi — the published hook ctx.api face', () => {
     // `@objectstack/spec/data` and emitting declarations answers TS2883 without
     // them, and `check:entry-nameability` cannot see it (it probes the call
     // surface of VALUE exports; `HookApi` is a type).
-    it('the transaction signature\'s two types, and the ctx.api pair', () => {
+    it('both types the transaction signature references', () => {
       const infoIsReachable: Assignable<EngineTransactionInfo, EngineTransactionInfo> = true;
       const optsIsReachable: Assignable<EngineTransactionOptions, EngineTransactionOptions> = true;
-      // Same declaration, reached through both entries — one declaration, two
-      // paths, which is what `check:dual-source-exports` asks about.
-      const oneDeclaration: Assignable<ReExportedScopedContext, IScopedContext> = true;
-      const andBack: Assignable<IScopedContext, ReExportedScopedContext> = true;
-      // The repository comes with it: `IScopedContext.object(name)` returns it,
-      // so exporting the context without it is a HALF closure — measured as a
-      // surviving TS2883 on `ctx.api.object(...)`.
-      const repoReachable: Assignable<ReExportedScopedRepository, IScopedObjectRepository> = true;
-      expect([infoIsReachable, optsIsReachable, oneDeclaration, andBack, repoReachable]).toEqual([
-        true, true, true, true, true,
-      ]);
+      expect([infoIsReachable, optsIsReachable]).toEqual([true, true]);
     });
   });
 
 
@@ -328,24 +328,36 @@ export interface HookApi {
  * ```
  *
  * The second position — `transaction`'s `opts` — answers the same way for
- * `EngineTransactionOptions`. Those two are the blocking finding.
- *
- * The other two names close the SAME defect one frame out, and they come as a
- * PAIR because that is what the measurement said. `HookContext.api` has leaked
- * `IScopedContext` since #5945, and exporting that name alone is a HALF
- * closure: `IScopedContext.object(name)` returns `IScopedObjectRepository`, so
- * with three names `(ctx) => ctx.api!.object('deal')` still answered TS2883 on
- * that fourth name. With all four, a probe carrying every position — both
- * `transaction` arguments, `ctx.api`, `ctx.api.object(…)`, `api.object(…)` and
- * a repository read — emits at exit 0, and the emitted declarations resolve
- * every inferred type through `@objectstack/spec/data`. The chain terminates
- * there: the repository's own members answer in structural types
- * (`Promise` of `Record` of `string` to `any`, or `null`) that name nothing
- * further. Taken in one stroke because leaving it publishes a hook seam whose
- * own `ctx.api` cannot be named from the entry that publishes the seam — the
- * exact gap this card was opened to close — and because all four are one-line
- * re-exports in this file, of declarations `@objectstack/spec/contracts`
- * already publishes, adding no gate beyond the three this diff regenerates.
+ * `EngineTransactionOptions`. Those two are what this card owes, and they are
+ * what this file exports: they are names THIS card's own new declarations
+ * introduced to the entry.
+ *
+ * ⛔ A THIRD instance of the same defect is deliberately NOT closed here, and
+ * the reason is a measurement rather than a scope reflex. `HookContext.api` has
+ * leaked `IScopedContext` off this entry since #5945 — pre-existing, present on
+ * this card's base and unchanged by it. Closing it is not the one-line job it
+ * looks like:
+ *
+ *   - It needs TWO names, not one. `IScopedContext.object(name)` returns
+ *     `IScopedObjectRepository`, so with `IScopedContext` exported alone a
+ *     consumer writing `ctx.api.object('deal')` still answers TS2883 on the
+ *     repository — measured, at head, with the three-name variant applied. A
+ *     one-name patch publishes a HALF closure that READS closed, which is the
+ *     declared-not-enforced shape this repo refuses.
+ *   - The second of those two names is not free. Adding
+ *     `IScopedObjectRepository` to this entry moves the dts bundler's module
+ *     order enough to reorder members inside object type literals in the
+ *     UNRELATED `ui` shard: 330 lines, which `check:api-surface-declarations`
+ *     reports as "33 reshaped" and asks a reviewer to rule on. Measured as
+ *     order-only — identical token multiset, identical line count, nothing
+ *     added, removed or renamed — and the generator is stable against a fixed
+ *     dist, so it is noise rather than drift. But it is a verdict somebody has
+ *     to read, in a shard this card does not touch.
+ *
+ * Two names with a clean surface delta, or four names plus an adjudication in
+ * someone else's shard: that is a trade for its own card and its own review,
+ * not a rider on a FAIL remediation. The pre-existing leak is reported with
+ * both measurements so that card can be written without re-deriving them.
  *
  * ⛔ `check:entry-nameability` is NOT the instrument that answers this. By its
  * own docblock it probes the CALL surface of VALUE exports that have a call
@@ -355,9 +367,8 @@ export interface HookApi {
  * are a known target outside it. The instrument that answers is a consumer
  * program with `declaration` emit, which is what the excerpt above is.
  *
- * Type-only re-exports: they add four names to this entry and no runtime byte,
+ * Type-only re-exports: they add two names to this entry and no runtime byte,
  * and each is ONE declaration reachable from two entries rather than two
  * declarations sharing a name, which is what `check:dual-source-exports` asks.
  */
 export type { EngineTransactionInfo, EngineTransactionOptions } from '../contracts/objectql-engine';
-export type { IScopedContext, IScopedObjectRepository } from '../contracts/scoped-context';