@prisma-next/framework-components 0.6.0-dev.1 → 0.6.0-dev.10

package/dist/runtime.d.mts

@@ -1,4 +1,4 @@
-import { o as CodecCallContext } from "./codec-m_-FAyQn.mjs";
+import { o as CodecCallContext } from "./codec-DcjlJbcO.mjs";
 import { PlanMeta } from "@prisma-next/contract/types";
 
 //#region src/execution/async-iterable-result.d.ts
@@ -64,95 +64,6 @@ type ResultType<P> = '_row' extends keyof P ? P extends {
   readonly _row?: infer R;
 } ? R : never : never;
 //#endregion
-//#region src/execution/runtime-error.d.ts
-interface RuntimeErrorEnvelope extends Error {
-  readonly code: string;
-  readonly category: 'PLAN' | 'CONTRACT' | 'LINT' | 'BUDGET' | 'RUNTIME';
-  readonly severity: 'error';
-  readonly details?: Record<string, unknown>;
-}
-/**
- * Stable code emitted by the runtime when an in-flight `execute()`
- * is cancelled via the per-query `AbortSignal`. The envelope's
- * `details.phase` distinguishes where the abort was observed:
- *
- * - `'encode'` — abort fired during `encodeParams` (SQL) or
- *   `resolveValue` (Mongo).
- * - `'decode'` — abort fired during `decodeRow` / `decodeField`.
- * - `'stream'` — abort fired between rows or before any codec call
- *   (already-aborted at entry).
- * - `'beforeExecute'` / `'afterExecute'` / `'onRow'` — abort fired
- *   on entry to or during the corresponding middleware phase
- *   (cooperative cancellation per the param-transform seam).
- */
-declare const RUNTIME_ABORTED: "RUNTIME.ABORTED";
-/** Discriminator placed in `details.phase` of a `RUNTIME.ABORTED` envelope. */
-type RuntimeAbortedPhase = 'encode' | 'decode' | 'stream' | 'beforeExecute' | 'afterExecute' | 'onRow';
-/**
- * Type guard for the runtime-error envelope produced by `runtimeError`.
- *
- * Prefer this over duck-typing on `error.code` directly so consumers stay
- * insulated from the envelope's internal shape.
- */
-declare function isRuntimeError(error: unknown): error is RuntimeErrorEnvelope;
-declare function runtimeError(code: string, message: string, details?: Record<string, unknown>): RuntimeErrorEnvelope;
-/**
- * Construct a `RUNTIME.ABORTED` envelope. Phase distinguishes where the
- * abort was observed — codec call sites (`encode` / `decode` / `stream`)
- * or middleware seams (`beforeExecute` / `afterExecute` / `onRow`), as
- * enumerated on {@link RuntimeAbortedPhase}. Cause carries
- * `signal.reason` verbatim from the platform — native abort produces a
- * `DOMException`, explicit `controller.abort(reason)` produces whatever
- * the caller passed. No synthesis happens here.
- */
-declare function runtimeAborted(phase: RuntimeAbortedPhase, cause?: unknown): RuntimeErrorEnvelope;
-//#endregion
-//#region src/execution/race-against-abort.d.ts
-/**
- * Throw a phase-tagged `RUNTIME.ABORTED` envelope if the supplied
- * context is already aborted at the precheck site. Centralises the
- * `if (ctx.signal?.aborted) throw runtimeAborted(...)` pattern that
- * every codec dispatch site (and the `beforeExecute` middleware phase)
- * repeats. Accepts both the framework `CodecCallContext` and the
- * `RuntimeMiddlewareContext`; both expose `signal?: AbortSignal`.
- */
-declare function checkAborted(ctx: {
-  readonly signal?: AbortSignal;
-}, phase: RuntimeAbortedPhase): void;
-/**
- * Race a per-cell `Promise.all` (or any other in-flight work promise) against
- * the supplied abort signal so the runtime returns `RUNTIME.ABORTED` promptly
- * even when codec bodies ignore the signal. In-flight bodies that ignore the
- * signal are abandoned and run to completion in the background — the
- * cooperative-cancellation contract documented in ADR 204.
- *
- * Call sites still SHOULD pre-check `signal.aborted` and short-circuit with
- * a phase-tagged `RUNTIME.ABORTED` envelope before invoking this helper —
- * that path is the canonical "aborted at entry" surface and avoids
- * scheduling the work promise. As a defensive belt-and-braces, this helper
- * also handles the already-aborted case internally: `AbortSignal` does not
- * replay past abort events to listeners registered after the abort, so we
- * inspect `signal.aborted` synchronously and reject with the sentinel
- * before installing the listener. The rejection is still attributed to the
- * abort path via the sentinel-identity check.
- *
- * Distinguishing the rejection source is load-bearing for AC-ERR4
- * (`RUNTIME.ENCODE_FAILED` / `RUNTIME.DECODE_FAILED` pass through unchanged).
- * The semantically equivalent `abortable(signal)` helper in
- * `@prisma-next/utils` rejects with `signal.reason ?? new DOMException(...)`,
- * which is not stably distinguishable from a codec-thrown error by identity
- * alone (a fresh fallback DOMException is allocated per call). We instead
- * track abort attribution with a unique sentinel: only the `onAbort` listener
- * installed here ever rejects with the sentinel, so an `error === sentinel`
- * identity check after the race is unambiguous.
- *
- * Lives in `framework-components` (rather than the SQL family, where it
- * originated in m2) so every family runtime that needs cooperative
- * cancellation around a codec-dispatch `Promise.all` (SQL encode + decode
- * today, Mongo encode in m3) shares the same attribution logic.
- */
-declare function raceAgainstAbort<T>(work: Promise<T>, signal: AbortSignal | undefined, phase: RuntimeAbortedPhase): Promise<T>;
-//#endregion
 //#region src/execution/runtime-middleware.d.ts
 interface RuntimeLog {
   info(event: unknown): void;
@@ -308,6 +219,32 @@ interface RuntimeMiddleware<TPlan extends QueryPlan = QueryPlan, TMutator extend
    * rows directly: caching, mocks, rate limiting, circuit breaking.
    */
   intercept?(plan: TPlan, ctx: RuntimeMiddlewareContext): Promise<InterceptResult | undefined>;
+  /**
+   * Fires after the family runtime has produced a draft execution
+   * plan from the AST, but before the family encodes parameter values
+   * to driver wire format. Mutations applied via the
+   * family-specific `params` mutator are visible to the subsequent
+   * encode step.
+   *
+   * Lifecycle position (SQL example):
+   *   `runBeforeCompile → lowerSqlPlan → beforeExecute → encodeParams → intercept → driver`.
+   *
+   * The `params` argument is a family-specific {@link ParamRefMutator}
+   * scoped to the value slots of `ParamRef` nodes in the plan's AST.
+   * Middleware that doesn't need to mutate params can ignore the
+   * argument; existing `(plan)` / `(plan, ctx)` bodies stay compatible.
+   *
+   * `ctx.signal` carries the per-query `AbortSignal`; middleware that
+   * wraps a network SDK forwards it. Cooperative cancellation
+   * surfaces a `RUNTIME.ABORTED { phase: 'beforeExecute' }` envelope
+   * promptly even when the body ignores the signal.
+   *
+   * Intercept ordering: `intercept` runs *after* this hook; an
+   * interceptor that short-circuits the driver path still observes
+   * the post-`beforeExecute`, fully-encoded plan. The trade-off is
+   * that any `beforeExecute` SDK round-trips happen even when a
+   * downstream interceptor would have skipped the driver entirely.
+   */
   beforeExecute?(plan: TPlan, ctx: RuntimeMiddlewareContext, params?: TMutator): void | Promise<void>;
   onRow?(row: Record<string, unknown>, plan: TPlan, ctx: RuntimeMiddlewareContext): Promise<void>;
   afterExecute?(plan: TPlan, result: AfterExecuteResult, ctx: RuntimeMiddlewareContext): Promise<void>;
@@ -340,9 +277,151 @@ interface RuntimeExecutor<TPlan extends QueryPlan> {
 }
 declare function checkMiddlewareCompatibility(middleware: RuntimeMiddleware, runtimeFamilyId: string, runtimeTargetId: string): void;
 //#endregion
+//#region src/execution/before-execute-chain.d.ts
+/**
+ * Runs every middleware's `beforeExecute` hook in registration order,
+ * threading through the (optional) family-specific `paramsMutator`.
+ *
+ * Why this lives outside {@link runWithMiddleware}: middleware that
+ * mutates parameter values (e.g. cipherstash's bulk-encrypt SDK
+ * round-trip) must run *before* the family runtime encodes those
+ * parameters to driver wire format. Family runtimes call
+ * `runBeforeExecuteChain` between the AST → plan lowering step and
+ * the parameter encode step; the encode then observes the mutator's
+ * `currentParams()` view. `runWithMiddleware` retains the rest of
+ * the lifecycle (`intercept`, driver/row source loop, `onRow`,
+ * `afterExecute`) but no longer fires `beforeExecute` itself.
+ *
+ * Lifecycle within this helper:
+ *
+ *  1. For each middleware in registration order, if `beforeExecute`
+ *     is implemented:
+ *     - `checkAborted(ctx, 'beforeExecute')` short-circuits if the
+ *       caller already aborted at entry.
+ *     - The hook is invoked with `(plan, ctx, paramsMutator)`. A
+ *       middleware body that ignores the mutator stays compatible —
+ *       JavaScript allows extra positional arguments.
+ *     - If the hook returns a Promise, it is raced against
+ *       `ctx.signal` via {@link raceAgainstAbort} so cooperative
+ *       cancellation surfaces a `RUNTIME.ABORTED { phase:
+ *       'beforeExecute' }` envelope even when the body itself
+ *       ignores the signal.
+ *
+ * Error propagation: any error thrown by a `beforeExecute` body
+ * (or surfaced by the abort race) propagates out of this helper
+ * unchanged. The family runtime is responsible for converting it
+ * into the appropriate `afterExecute(completed: false)` notification
+ * once `runWithMiddleware` runs.
+ *
+ * Relationship to {@link runWithMiddleware}: the framework's
+ * `RuntimeCore.execute` template calls this helper between
+ * `lower(plan)` and `runWithMiddleware(...)`. Family runtimes that
+ * override `execute` (e.g. SQL, which inlines lower + encode for
+ * direct mutator threading) call this helper themselves at the
+ * equivalent point — between the family's AST → draft-plan
+ * lowering and the parameter-encode step.
+ *
+ * Intercept ordering: this helper fires unconditionally before
+ * `runWithMiddleware`. `intercept` (inside `runWithMiddleware`)
+ * therefore observes the post-`beforeExecute` plan — mutator
+ * mutations are visible in the params interceptors see. The
+ * trade-off is documented on `RuntimeMiddleware.intercept`.
+ */
+declare function runBeforeExecuteChain<TExec extends ExecutionPlan, TMutator extends ParamRefMutator = ParamRefMutator>(plan: TExec, middleware: ReadonlyArray<RuntimeMiddleware<TExec, TMutator>>, ctx: RuntimeMiddlewareContext, paramsMutator?: TMutator): Promise<void>;
+//#endregion
+//#region src/execution/runtime-error.d.ts
+interface RuntimeErrorEnvelope extends Error {
+  readonly code: string;
+  readonly category: 'PLAN' | 'CONTRACT' | 'LINT' | 'BUDGET' | 'RUNTIME';
+  readonly severity: 'error';
+  readonly details?: Record<string, unknown>;
+}
+/**
+ * Stable code emitted by the runtime when an in-flight `execute()`
+ * is cancelled via the per-query `AbortSignal`. The envelope's
+ * `details.phase` distinguishes where the abort was observed:
+ *
+ * - `'encode'` — abort fired during `encodeParams` (SQL) or
+ *   `resolveValue` (Mongo).
+ * - `'decode'` — abort fired during `decodeRow` / `decodeField`.
+ * - `'stream'` — abort fired between rows or before any codec call
+ *   (already-aborted at entry).
+ * - `'beforeExecute'` / `'afterExecute'` / `'onRow'` — abort fired
+ *   on entry to or during the corresponding middleware phase
+ *   (cooperative cancellation per the param-transform seam).
+ */
+declare const RUNTIME_ABORTED: "RUNTIME.ABORTED";
+/** Discriminator placed in `details.phase` of a `RUNTIME.ABORTED` envelope. */
+type RuntimeAbortedPhase = 'encode' | 'decode' | 'stream' | 'beforeExecute' | 'afterExecute' | 'onRow';
+/**
+ * Type guard for the runtime-error envelope produced by `runtimeError`.
+ *
+ * Prefer this over duck-typing on `error.code` directly so consumers stay
+ * insulated from the envelope's internal shape.
+ */
+declare function isRuntimeError(error: unknown): error is RuntimeErrorEnvelope;
+declare function runtimeError(code: string, message: string, details?: Record<string, unknown>): RuntimeErrorEnvelope;
+/**
+ * Construct a `RUNTIME.ABORTED` envelope. Phase distinguishes where the
+ * abort was observed — codec call sites (`encode` / `decode` / `stream`)
+ * or middleware seams (`beforeExecute` / `afterExecute` / `onRow`), as
+ * enumerated on {@link RuntimeAbortedPhase}. Cause carries
+ * `signal.reason` verbatim from the platform — native abort produces a
+ * `DOMException`, explicit `controller.abort(reason)` produces whatever
+ * the caller passed. No synthesis happens here.
+ */
+declare function runtimeAborted(phase: RuntimeAbortedPhase, cause?: unknown): RuntimeErrorEnvelope;
+//#endregion
+//#region src/execution/race-against-abort.d.ts
+/**
+ * Throw a phase-tagged `RUNTIME.ABORTED` envelope if the supplied
+ * context is already aborted at the precheck site. Centralises the
+ * `if (ctx.signal?.aborted) throw runtimeAborted(...)` pattern that
+ * every codec dispatch site (and the `beforeExecute` middleware phase)
+ * repeats. Accepts both the framework `CodecCallContext` and the
+ * `RuntimeMiddlewareContext`; both expose `signal?: AbortSignal`.
+ */
+declare function checkAborted(ctx: {
+  readonly signal?: AbortSignal;
+}, phase: RuntimeAbortedPhase): void;
+/**
+ * Race a per-cell `Promise.all` (or any other in-flight work promise) against
+ * the supplied abort signal so the runtime returns `RUNTIME.ABORTED` promptly
+ * even when codec bodies ignore the signal. In-flight bodies that ignore the
+ * signal are abandoned and run to completion in the background — the
+ * cooperative-cancellation contract documented in ADR 204.
+ *
+ * Call sites still SHOULD pre-check `signal.aborted` and short-circuit with
+ * a phase-tagged `RUNTIME.ABORTED` envelope before invoking this helper —
+ * that path is the canonical "aborted at entry" surface and avoids
+ * scheduling the work promise. As a defensive belt-and-braces, this helper
+ * also handles the already-aborted case internally: `AbortSignal` does not
+ * replay past abort events to listeners registered after the abort, so we
+ * inspect `signal.aborted` synchronously and reject with the sentinel
+ * before installing the listener. The rejection is still attributed to the
+ * abort path via the sentinel-identity check.
+ *
+ * Distinguishing the rejection source is load-bearing for AC-ERR4
+ * (`RUNTIME.ENCODE_FAILED` / `RUNTIME.DECODE_FAILED` pass through unchanged).
+ * The semantically equivalent `abortable(signal)` helper in
+ * `@prisma-next/utils` rejects with `signal.reason ?? new DOMException(...)`,
+ * which is not stably distinguishable from a codec-thrown error by identity
+ * alone (a fresh fallback DOMException is allocated per call). We instead
+ * track abort attribution with a unique sentinel: only the `onAbort` listener
+ * installed here ever rejects with the sentinel, so an `error === sentinel`
+ * identity check after the race is unambiguous.
+ *
+ * Lives in `framework-components` (rather than the SQL family, where it
+ * originated in m2) so every family runtime that needs cooperative
+ * cancellation around a codec-dispatch `Promise.all` (SQL encode + decode
+ * today, Mongo encode in m3) shares the same attribution logic.
+ */
+declare function raceAgainstAbort<T>(work: Promise<T>, signal: AbortSignal | undefined, phase: RuntimeAbortedPhase): Promise<T>;
+//#endregion
 //#region src/execution/run-with-middleware.d.ts
 /**
- * Drives a single execution of `runDriver()` through the middleware lifecycle.
+ * Drives a single execution of `runDriver()` through the middleware
+ * lifecycle's intercept + row-source + termination phases.
  *
  * Lifecycle, in order:
  *  1. For each middleware in registration order: `intercept(exec, ctx)`. The
@@ -352,31 +431,38 @@ declare function checkMiddlewareCompatibility(middleware: RuntimeMiddleware, run
  *     the intercepted rows, and proceeds with `source: 'middleware'`. On
  *     all-passthrough (every `intercept` returns `undefined` or is omitted),
  *     `source: 'driver'` is used and the row source is `runDriver()`.
- *  2. If `source === 'driver'`: for each middleware in registration order,
- *     `beforeExecute(exec, ctx)`. Skipped on the intercepted hit path —
- *     `beforeExecute` semantically means "about to hit the driver".
- *  3. Iterate the row source. On the driver path, for each row, for each
+ *  2. Iterate the row source. On the driver path, for each row, for each
  *     middleware in registration order: `onRow(row, exec, ctx)`; then yield
  *     the row. On the intercepted hit path, `onRow` is skipped — intercepted
  *     rows did not originate from a driver row stream — but rows are still
  *     yielded to the consumer in order.
- *  4. On successful completion: for each middleware in registration order:
+ *  3. On successful completion: for each middleware in registration order:
  *     `afterExecute(exec, { rowCount, latencyMs, completed: true, source },
  *     ctx)`.
- *  5. On any error thrown during steps 1–3: for each middleware in
+ *  4. On any error thrown during steps 1–2: for each middleware in
  *     registration order: `afterExecute(exec, { rowCount, latencyMs,
  *     completed: false, source }, ctx)`. Errors thrown by `afterExecute`
  *     during the error path are swallowed so they do not mask the original
  *     error. The original error is then rethrown.
  *
+ * `beforeExecute` is **not** fired here — see
+ * {@link runBeforeExecuteChain} in `before-execute-chain.ts`. Family
+ * runtimes call that helper between the AST → plan lowering step and
+ * the parameter encode step so middleware that mutates ParamRef
+ * values (e.g. cipherstash bulk-encrypt) can have its mutations
+ * visible to encode. `runWithMiddleware` operates on the fully-
+ * encoded plan; interceptors therefore observe a fully-mutated,
+ * encoded plan.
+ *
  * The `source` field on `AfterExecuteResult` lets observers (telemetry,
  * lints, budgets) distinguish driver-served from middleware-served
  * executions without needing their own out-of-band signal.
  *
- * This helper is the single canonical implementation of the middleware
- * orchestration loop; family runtimes should not reimplement it.
+ * This helper is the single canonical implementation of the
+ * intercept-and-row-source loop; family runtimes should not
+ * reimplement it.
  */
-declare function runWithMiddleware<TExec extends ExecutionPlan, Row, TMutator extends ParamRefMutator = ParamRefMutator>(exec: TExec, middleware: ReadonlyArray<RuntimeMiddleware<TExec, TMutator>>, ctx: RuntimeMiddlewareContext, runDriver: () => AsyncIterable<Row>, paramsMutator?: TMutator): AsyncIterableResult<Row>;
+declare function runWithMiddleware<TExec extends ExecutionPlan, Row>(exec: TExec, middleware: ReadonlyArray<RuntimeMiddleware<TExec>>, ctx: RuntimeMiddlewareContext, runDriver: () => AsyncIterable<Row>): AsyncIterableResult<Row>;
 //#endregion
 //#region src/execution/runtime-core.d.ts
 /**
@@ -399,9 +485,16 @@ interface RuntimeCoreOptions<TMiddleware extends RuntimeMiddleware<ExecutionPlan
  *    this to run its `beforeCompile` middleware-hook chain.
  * 2. `lower(plan)` — abstract. Each family produces its `*ExecutionPlan`
  *    (SQL via `lowerSqlPlan`, Mongo via `adapter.lower`).
- * 3. `runWithMiddleware(exec, this.middleware, this.ctx,
- *    () => runDriver(exec))` — concrete; lifts the middleware lifecycle
- *    out of the family runtimes into the canonical helper.
+ * 3. `runBeforeExecuteChain(exec, this.middleware, this.ctx)` — concrete;
+ *    runs every middleware's `beforeExecute` hook after lowering but
+ *    before the row source is opened. Family runtimes that need a
+ *    params mutator visible to a downstream encode step (SQL) override
+ *    `execute` and call this helper themselves at the equivalent
+ *    pre-encode point.
+ * 4. `runWithMiddleware(exec, this.middleware, this.ctx,
+ *    () => runDriver(exec))` — concrete; runs the intercept chain,
+ *    drives the row source, fires `onRow` / `afterExecute`. Does
+ *    **not** fire `beforeExecute` — see step 3.
  *
  * Concrete subclasses must implement `lower`, `runDriver`, and `close`.
  *
@@ -456,5 +549,5 @@ declare abstract class RuntimeCore<TPlan extends QueryPlan, TExec extends Execut
   }, options?: RuntimeExecuteOptions): AsyncIterableResult<Row>;
 }
 //#endregion
-export { type AfterExecuteResult, AsyncIterableResult, type ExecutionPlan, type InterceptResult, type ParamRefMutator, type QueryPlan, RUNTIME_ABORTED, type ResultType, type RuntimeAbortedPhase, RuntimeCore, type RuntimeCoreOptions, type RuntimeErrorEnvelope, type RuntimeExecuteOptions, type RuntimeExecutor, type RuntimeLog, type RuntimeMiddleware, type RuntimeMiddlewareContext, checkAborted, checkMiddlewareCompatibility, isRuntimeError, raceAgainstAbort, runWithMiddleware, runtimeAborted, runtimeError };
+export { type AfterExecuteResult, AsyncIterableResult, type ExecutionPlan, type InterceptResult, type ParamRefMutator, type QueryPlan, RUNTIME_ABORTED, type ResultType, type RuntimeAbortedPhase, RuntimeCore, type RuntimeCoreOptions, type RuntimeErrorEnvelope, type RuntimeExecuteOptions, type RuntimeExecutor, type RuntimeLog, type RuntimeMiddleware, type RuntimeMiddlewareContext, checkAborted, checkMiddlewareCompatibility, isRuntimeError, raceAgainstAbort, runBeforeExecuteChain, runWithMiddleware, runtimeAborted, runtimeError };
 //# sourceMappingURL=runtime.d.mts.map

package/dist/runtime.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.d.mts","names":[],"sources":["../src/execution/async-iterable-result.ts","../src/execution/query-plan.ts","../src/execution/runtime-error.ts","../src/execution/race-against-abort.ts","../src/execution/runtime-middleware.ts","../src/execution/run-with-middleware.ts","../src/execution/runtime-core.ts"],"mappings":"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"}
+{"version":3,"file":"runtime.d.mts","names":[],"sources":["../src/execution/async-iterable-result.ts","../src/execution/query-plan.ts","../src/execution/runtime-middleware.ts","../src/execution/before-execute-chain.ts","../src/execution/runtime-error.ts","../src/execution/race-against-abort.ts","../src/execution/run-with-middleware.ts","../src/execution/runtime-core.ts"],"mappings":"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"}

package/dist/runtime.mjs

@@ -177,9 +177,69 @@ async function raceAgainstAbort(work, signal, phase) {
 	}
 }
 //#endregion
+//#region src/execution/before-execute-chain.ts
+/**
+* Runs every middleware's `beforeExecute` hook in registration order,
+* threading through the (optional) family-specific `paramsMutator`.
+*
+* Why this lives outside {@link runWithMiddleware}: middleware that
+* mutates parameter values (e.g. cipherstash's bulk-encrypt SDK
+* round-trip) must run *before* the family runtime encodes those
+* parameters to driver wire format. Family runtimes call
+* `runBeforeExecuteChain` between the AST → plan lowering step and
+* the parameter encode step; the encode then observes the mutator's
+* `currentParams()` view. `runWithMiddleware` retains the rest of
+* the lifecycle (`intercept`, driver/row source loop, `onRow`,
+* `afterExecute`) but no longer fires `beforeExecute` itself.
+*
+* Lifecycle within this helper:
+*
+*  1. For each middleware in registration order, if `beforeExecute`
+*     is implemented:
+*     - `checkAborted(ctx, 'beforeExecute')` short-circuits if the
+*       caller already aborted at entry.
+*     - The hook is invoked with `(plan, ctx, paramsMutator)`. A
+*       middleware body that ignores the mutator stays compatible —
+*       JavaScript allows extra positional arguments.
+*     - If the hook returns a Promise, it is raced against
+*       `ctx.signal` via {@link raceAgainstAbort} so cooperative
+*       cancellation surfaces a `RUNTIME.ABORTED { phase:
+*       'beforeExecute' }` envelope even when the body itself
+*       ignores the signal.
+*
+* Error propagation: any error thrown by a `beforeExecute` body
+* (or surfaced by the abort race) propagates out of this helper
+* unchanged. The family runtime is responsible for converting it
+* into the appropriate `afterExecute(completed: false)` notification
+* once `runWithMiddleware` runs.
+*
+* Relationship to {@link runWithMiddleware}: the framework's
+* `RuntimeCore.execute` template calls this helper between
+* `lower(plan)` and `runWithMiddleware(...)`. Family runtimes that
+* override `execute` (e.g. SQL, which inlines lower + encode for
+* direct mutator threading) call this helper themselves at the
+* equivalent point — between the family's AST → draft-plan
+* lowering and the parameter-encode step.
+*
+* Intercept ordering: this helper fires unconditionally before
+* `runWithMiddleware`. `intercept` (inside `runWithMiddleware`)
+* therefore observes the post-`beforeExecute` plan — mutator
+* mutations are visible in the params interceptors see. The
+* trade-off is documented on `RuntimeMiddleware.intercept`.
+*/
+async function runBeforeExecuteChain(plan, middleware, ctx, paramsMutator) {
+	for (const mw of middleware) {
+		if (!mw.beforeExecute) continue;
+		checkAborted(ctx, "beforeExecute");
+		const work = mw.beforeExecute(plan, ctx, paramsMutator);
+		if (work !== void 0) await raceAgainstAbort(Promise.resolve(work), ctx.signal, "beforeExecute");
+	}
+}
+//#endregion
 //#region src/execution/run-with-middleware.ts
 /**
-* Drives a single execution of `runDriver()` through the middleware lifecycle.
+* Drives a single execution of `runDriver()` through the middleware
+* lifecycle's intercept + row-source + termination phases.
 *
 * Lifecycle, in order:
 *  1. For each middleware in registration order: `intercept(exec, ctx)`. The
@@ -189,31 +249,38 @@ async function raceAgainstAbort(work, signal, phase) {
 *     the intercepted rows, and proceeds with `source: 'middleware'`. On
 *     all-passthrough (every `intercept` returns `undefined` or is omitted),
 *     `source: 'driver'` is used and the row source is `runDriver()`.
-*  2. If `source === 'driver'`: for each middleware in registration order,
-*     `beforeExecute(exec, ctx)`. Skipped on the intercepted hit path —
-*     `beforeExecute` semantically means "about to hit the driver".
-*  3. Iterate the row source. On the driver path, for each row, for each
+*  2. Iterate the row source. On the driver path, for each row, for each
 *     middleware in registration order: `onRow(row, exec, ctx)`; then yield
 *     the row. On the intercepted hit path, `onRow` is skipped — intercepted
 *     rows did not originate from a driver row stream — but rows are still
 *     yielded to the consumer in order.
-*  4. On successful completion: for each middleware in registration order:
+*  3. On successful completion: for each middleware in registration order:
 *     `afterExecute(exec, { rowCount, latencyMs, completed: true, source },
 *     ctx)`.
-*  5. On any error thrown during steps 1–3: for each middleware in
+*  4. On any error thrown during steps 1–2: for each middleware in
 *     registration order: `afterExecute(exec, { rowCount, latencyMs,
 *     completed: false, source }, ctx)`. Errors thrown by `afterExecute`
 *     during the error path are swallowed so they do not mask the original
 *     error. The original error is then rethrown.
 *
+* `beforeExecute` is **not** fired here — see
+* {@link runBeforeExecuteChain} in `before-execute-chain.ts`. Family
+* runtimes call that helper between the AST → plan lowering step and
+* the parameter encode step so middleware that mutates ParamRef
+* values (e.g. cipherstash bulk-encrypt) can have its mutations
+* visible to encode. `runWithMiddleware` operates on the fully-
+* encoded plan; interceptors therefore observe a fully-mutated,
+* encoded plan.
+*
 * The `source` field on `AfterExecuteResult` lets observers (telemetry,
 * lints, budgets) distinguish driver-served from middleware-served
 * executions without needing their own out-of-band signal.
 *
-* This helper is the single canonical implementation of the middleware
-* orchestration loop; family runtimes should not reimplement it.
+* This helper is the single canonical implementation of the
+* intercept-and-row-source loop; family runtimes should not
+* reimplement it.
 */
-function runWithMiddleware(exec, middleware, ctx, runDriver, paramsMutator) {
+function runWithMiddleware(exec, middleware, ctx, runDriver) {
 	const iterator = async function* () {
 		const startedAt = Date.now();
 		let rowCount = 0;
@@ -236,14 +303,7 @@ function runWithMiddleware(exec, middleware, ctx, runDriver, paramsMutator) {
 				rowSource = result.rows;
 				break;
 			}
-			if (source === "driver") {
-				for (const mw of middleware) if (mw.beforeExecute) {
-					checkAborted(ctx, "beforeExecute");
-					const work = mw.beforeExecute(exec, ctx, paramsMutator);
-					if (work !== void 0) await raceAgainstAbort(Promise.resolve(work), ctx.signal, "beforeExecute");
-				}
-				rowSource = runDriver();
-			}
+			if (source === "driver") rowSource = runDriver();
 			for await (const row of rowSource) {
 				if (source === "driver") {
 					for (const mw of middleware) if (mw.onRow) await mw.onRow(row, exec, ctx);
@@ -285,9 +345,16 @@ function runWithMiddleware(exec, middleware, ctx, runDriver, paramsMutator) {
 *    this to run its `beforeCompile` middleware-hook chain.
 * 2. `lower(plan)` — abstract. Each family produces its `*ExecutionPlan`
 *    (SQL via `lowerSqlPlan`, Mongo via `adapter.lower`).
-* 3. `runWithMiddleware(exec, this.middleware, this.ctx,
-*    () => runDriver(exec))` — concrete; lifts the middleware lifecycle
-*    out of the family runtimes into the canonical helper.
+* 3. `runBeforeExecuteChain(exec, this.middleware, this.ctx)` — concrete;
+*    runs every middleware's `beforeExecute` hook after lowering but
+*    before the row source is opened. Family runtimes that need a
+*    params mutator visible to a downstream encode step (SQL) override
+*    `execute` and call this helper themselves at the equivalent
+*    pre-encode point.
+* 4. `runWithMiddleware(exec, this.middleware, this.ctx,
+*    () => runDriver(exec))` — concrete; runs the intercept chain,
+*    drives the row source, fires `onRow` / `afterExecute`. Does
+*    **not** fire `beforeExecute` — see step 3.
 *
 * Concrete subclasses must implement `lower`, `runDriver`, and `close`.
 *
@@ -324,6 +391,7 @@ var RuntimeCore = class {
 			checkAborted(codecCtx, "stream");
 			const compiled = await self.runBeforeCompile(plan);
 			const exec = await self.lower(compiled, codecCtx);
+			await runBeforeExecuteChain(exec, self.middleware, self.ctx);
 			yield* runWithMiddleware(exec, self.middleware, self.ctx, () => self.runDriver(exec));
 		}
 		return new AsyncIterableResult(generator());
@@ -348,6 +416,6 @@ function checkMiddlewareCompatibility(middleware, runtimeFamilyId, runtimeTarget
 	});
 }
 //#endregion
-export { AsyncIterableResult, RUNTIME_ABORTED, RuntimeCore, checkAborted, checkMiddlewareCompatibility, isRuntimeError, raceAgainstAbort, runWithMiddleware, runtimeAborted, runtimeError };
+export { AsyncIterableResult, RUNTIME_ABORTED, RuntimeCore, checkAborted, checkMiddlewareCompatibility, isRuntimeError, raceAgainstAbort, runBeforeExecuteChain, runWithMiddleware, runtimeAborted, runtimeError };
 
 //# sourceMappingURL=runtime.mjs.map