@prisma/orm-framework 0.16.0

package/dist/runtime--RZXG1zP.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime--RZXG1zP.d.mts","names":[],"sources":["../../../../1-framework/1-core/framework-components/dist/runtime.d.mts"],"mappings":";;;;;;;;;;;;;;;;;;;;;KAoBK;;;;;;;;;;;;UAYK,gBAAgB,SAAS,cAAc;WACtC;WACA;WACA,OAAO;WACP,cAAc,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA2C3B,iBAAiB,SAAS,cAAc;GAC/C,OAAO,UAAU,gBAAgB,SAAS;WAClC;WACA,cAAc,YAAY;EACnC,KAAK;aACM;eACE,cAAc;;MAEvB;;;;;;;;;;;;;;;;;;;;;;;;UAwBI,wBAAwB,cAAc;WACrC;WACA,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuCjB,iBAAiB,mBAAmB,cAAc,eAAe,SAAS,wBAAwB,WAAW,iBAAiB,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAsDnJ,iBAAiB,UAAU,eAAe,oBAAoB,yBAAyB,gCAAgC,WAAW,KAAK,GAAG,WAAW,sBAAsB,SAAS,SAAS,UAAU,QAAQ,gBAAgB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;iBAwBtN,4BAA4B,sBAAsB,yBAAyB,kBAAkB,MAAM,eAAe;;;cAGrH,oBAAoB,gBAAgB,cAAc,MAAM,YAAY;mBAC/D;UACT;UACA;UACA;EACR,YAAY,WAAW,eAAe;GACrC,OAAO,kBAAkB,cAAc;EACxC,WAAW,QAAQ;EACnB,SAAS,QAAQ;EACjB,gBAAgB,QAAQ;EACxB,KAAK,WAAW,OAAO,kBAAkB,gBAAgB,OAAO,UAAU,WAAW,YAAY,+BAA+B,eAAe,oBAAoB,WAAW,YAAY,gCAAgC,YAAY,WAAW;;;;;;;;;;;;;;;;UAgBzO,UAAU;WACT,MAAM;;;;;WAKN,OAAO;;;;;;;;;;;UAWR,cAAc,uBAAuB,UAAU;;;;;;;;;;;;;;;KAepD,WAAW,0BAA0B,IAAI;WACnC,aAAa;IACpB;;;UAGM;EACR,KAAK;EACL,KAAK;EACL,MAAM;EACN,OAAO;;;;;;;;;;;;;;;;;;;;;UAqBC;WACC;WACA;WACA;WACA,KAAK;;;;;;;;;;;;;;;;;;EAkBd,YAAY,MAAM,gBAAgB;;;;;;;WAOzB,SAAS;;;;;;;;;;;;;;;;;;;;;WAqBT;;;;;;;;;;;WAWA;;UAED;WACC;WACA;WACA;;;;;;;;;;;;;WAaA;;;;;;;;;;;;;;;;;;;;;;;UAuBD;WACC,MAAM,cAAc,2BAA2B,SAAS;;;;;;;;;;;;;cAarD;KACT;YACO;;;;;;;;;;;;;;;;UAgBF,kBAAkB,cAAc,YAAY,WAAW,iBAAiB,kBAAkB;WACzF;WACA;WACA;;;;;;;;;;;;;;;;;;;;;;;EAuBT,WAAW,MAAM,OAAO,KAAK,2BAA2B,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BhE,eAAe,MAAM,OAAO,KAAK,0BAA0B,SAAS,kBAAkB;EACtF,OAAO,KAAK,yBAAyB,MAAM,OAAO,KAAK,2BAA2B;EAClF,cAAc,MAAM,OAAO,QAAQ,oBAAoB,KAAK,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;KAuBpF,sBAAsB,cAAc,YAAY,aAAa,kBAAkB;WACzE;WACA;;;;;;;;;;;UAWD;WACC,SAAS;WACT;;;;;;;;;;UAUD,gBAAgB,cAAc;EACtC,QAAQ,KAAK,MAAM;aACR,OAAO;KACf,UAAU,wBAAwB,oBAAoB;EACzD,SAAS;;iBAEM,6BAA6B,YAAY,mBAAmB,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoDrF,sBAAsB,cAAc,eAAe,iBAAiB,kBAAkB,iBAAiB,MAAM,OAAO,YAAY,cAAc,kBAAkB,OAAO,YAAY,KAAK,0BAA0B,gBAAgB,WAAW;;;UAGpP,6BAA6B;WAC5B;WACA;WACA;WACA,UAAU;;;;;;;;iBAQJ,eAAe,iBAAiB,SAAS;iBACzC,aAAa,cAAc,iBAAiB,UAAU,0BAA0B;;;;;;;;;;;;;;;;;cAiBnF;;KAET;;;;;;;;;;iBAUY,eAAe,OAAO,qBAAqB,kBAAkB;;;;;;;;;;;iBAW7D,aAAa;WACnB,SAAS;GACjB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiCO,iBAAiB,GAAG,MAAM,QAAQ,IAAI,QAAQ,yBAAyB,OAAO,sBAAsB,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8C5G,kBAAkB,cAAc,eAAe,KAAK,MAAM,OAAO,YAAY,cAAc,kBAAkB,SAAS,KAAK,0BAA0B,iBAAiB,cAAc,OAAO,oBAAoB;;;;;;;;;;UAUtN,mBAAmB,oBAAoB,kBAAkB;WACxD,YAAY,cAAc;WAC1B,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAkCO,YAAY,cAAc,WAAW,cAAc,eAAe,oBAAoB,kBAAkB,mBAAmB,gBAAgB;qBAC7I,YAAY,cAAc;qBAC1B,KAAK;EACxB,YAAY,SAAS,mBAAmB;;;;;;YAM9B,iBAAiB,MAAM,QAAQ,QAAQ,QAAQ;;;;;;;;;;;;;;qBActC,MAAM,MAAM,OAAO,KAAK,mBAAmB,QAAQ,QAAQ;;;;;;;;;;;qBAW3D,UAAU,MAAM,QAAQ,cAAc;WAChD,SAAS;EAClB,QAAQ,KAAK,MAAM;aACR,OAAO;KACf,UAAU,wBAAwB,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAkCjD,YAAY,UAAU;EAC9B,SAAS,GAAG,cAAc,eAAe,YAAY,UAAU,QAAQ,gBAAgB,GAAG;;;;;;;;;;;;UAYlF,gBAAgB,UAAU,uBAAuB,YAAY;WAC5D,aAAa,oBAAoB,yBAAyB;;;;;;;;;;;iBAWpD,kBAAkB,UAAU,eAAe,MAAM,GAAG,uBAAuB,gBAAgB"}

package/dist/runtime-DYTFHGwh.mjs

@@ -0,0 +1,516 @@
+import { n as runtimeError } from "./runtime-error-BA9d7XjZ-BlT8t6LB.mjs";
+//#region ../../../1-framework/1-core/framework-components/dist/runtime.mjs
+/**
+* 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).
+*/
+const RUNTIME_ABORTED = "RUNTIME.ABORTED";
+/**
+* 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.
+*/
+function runtimeAborted(phase, cause) {
+	const envelope = runtimeError(RUNTIME_ABORTED, `Operation aborted during ${phase}`, { phase });
+	return Object.assign(envelope, { cause });
+}
+/**
+* Defines a typed annotation handle.
+*
+* Two-step call form. The first step takes the `Payload` type argument
+* (TypeScript cannot infer `Payload` from anything in the options, so it
+* must be supplied explicitly); the second step takes the runtime options
+* and infers `Kinds` from the `applicableTo` array via a `const` type
+* parameter, so the operation kinds appear exactly once at the call site.
+*
+* @example
+* ```typescript
+* // Read-only annotation. Lane terminals like `db.User.first(...)` accept
+* // it; `db.User.create(...)` rejects it at the type level.
+* const cacheAnnotation = defineAnnotation<{ ttl?: number; skip?: boolean }>()({
+*   namespace: 'cache',
+*   applicableTo: ['read'],
+* }); // Kinds inferred as 'read'
+*
+* // Write-only annotation. Mirror image.
+* const auditAnnotation = defineAnnotation<{ actor: string }>()({
+*   namespace: 'audit',
+*   applicableTo: ['write'],
+* }); // Kinds inferred as 'write'
+*
+* // Annotation applicable to both kinds (e.g. tracing).
+* const otelAnnotation = defineAnnotation<{ traceId: string }>()({
+*   namespace: 'otel',
+*   applicableTo: ['read', 'write'],
+* }); // Kinds inferred as 'read' | 'write'
+* ```
+*
+* **Reserved namespaces.** See `DefineAnnotationOptions.namespace` for the
+* list of framework-internal namespaces (`codecs`, target-specific keys).
+* `defineAnnotation` does not structurally prevent a user from naming a
+* reserved namespace, but the framework makes no compatibility guarantee
+* about handles that do.
+*/
+function defineAnnotation() {
+	return (options) => {
+		const namespace = options.namespace;
+		const applicableTo = Object.freeze(new Set(options.applicableTo));
+		function handle(value) {
+			return Object.freeze({
+				__annotation: true,
+				namespace,
+				value,
+				applicableTo
+			});
+		}
+		function read(plan) {
+			const stored = plan.meta.annotations?.[namespace];
+			if (!isAnnotationValue(stored)) return;
+			if (stored.namespace !== namespace) return;
+			return stored.value;
+		}
+		return Object.freeze(Object.assign(handle, {
+			namespace,
+			applicableTo,
+			read
+		}));
+	};
+}
+/**
+* Runtime applicability gate. Throws `RUNTIME.ANNOTATION_INAPPLICABLE` if
+* any annotation in `annotations` declares an `applicableTo` set that does
+* not include `kind`. Used by lane terminals (SQL DSL builders' `.build()`,
+* ORM `Collection` terminals) to fail closed when the type-level
+* `ValidAnnotations` gate is bypassed via cast / `any` / dynamic
+* invocation.
+*
+* Passes silently on:
+*  - empty arrays
+*  - annotations whose `applicableTo` includes `kind`
+*
+* Throws on:
+*  - any annotation whose `applicableTo` does not include `kind`. The
+*    error names the offending annotation's `namespace` and the
+*    `terminalName` so users can locate the misuse.
+*
+* @example
+* ```typescript
+* // Inside an ORM read terminal:
+* assertAnnotationsApplicable(annotations, 'read', 'first');
+* ```
+*/
+function assertAnnotationsApplicable(annotations, kind, terminalName) {
+	for (const annotation of annotations) if (!annotation.applicableTo.has(kind)) throw runtimeError("RUNTIME.ANNOTATION_INAPPLICABLE", `Annotation '${annotation.namespace}' is not applicable to '${kind}' operations (terminal: '${terminalName}'). The annotation declares applicableTo = [${Array.from(annotation.applicableTo).map((k) => `'${k}'`).join(", ")}].`, {
+		namespace: annotation.namespace,
+		terminalName,
+		kind,
+		applicableTo: Array.from(annotation.applicableTo)
+	});
+}
+/**
+* Type guard for branded annotation values stored in `plan.meta.annotations`.
+*
+* Internal — used by `AnnotationHandle.read` to distinguish user
+* annotations (created by calling a handle returned from
+* `defineAnnotation(...)`) from framework-internal metadata that may
+* happen to live under the same namespace key.
+*/
+function isAnnotationValue(value) {
+	if (value === null || typeof value !== "object") return false;
+	return value.__annotation === true;
+}
+var AsyncIterableResult = class {
+	generator;
+	consumed = false;
+	consumedBy;
+	bufferedArrayPromise;
+	constructor(generator) {
+		this.generator = generator;
+	}
+	[Symbol.asyncIterator]() {
+		if (this.consumed) throw runtimeError("RUNTIME.ITERATOR_CONSUMED", `AsyncIterableResult iterator has already been consumed via ${this.consumedBy === "bufferedArray" ? "toArray()/then()" : "for-await loop"}. Each AsyncIterableResult can only be iterated once.`, {
+			consumedBy: this.consumedBy,
+			suggestion: this.consumedBy === "bufferedArray" ? "If you need to iterate multiple times, store the results from toArray() in a variable and reuse that." : "If you need to iterate multiple times, use toArray() to collect all results first."
+		});
+		this.consumed = true;
+		this.consumedBy = "iterator";
+		return this.generator;
+	}
+	toArray() {
+		if (this.consumedBy === "iterator") return Promise.reject(runtimeError("RUNTIME.ITERATOR_CONSUMED", "AsyncIterableResult iterator has already been consumed via for-await loop. Each AsyncIterableResult can only be iterated once.", {
+			consumedBy: this.consumedBy,
+			suggestion: "The iterator was already consumed by a for-await loop. Use toArray() or await the result before iterating."
+		}));
+		if (this.bufferedArrayPromise) return this.bufferedArrayPromise;
+		this.consumed = true;
+		this.consumedBy = "bufferedArray";
+		this.bufferedArrayPromise = (async () => {
+			const out = [];
+			for await (const item of this.generator) out.push(item);
+			return out;
+		})();
+		return this.bufferedArrayPromise;
+	}
+	async first() {
+		return (await this.toArray())[0] ?? null;
+	}
+	async firstOrThrow() {
+		const row = await this.first();
+		if (row === null) throw runtimeError("RUNTIME.NO_ROWS", "Expected at least one row, but none were returned", {});
+		return row;
+	}
+	then(onfulfilled, onrejected) {
+		return this.toArray().then(onfulfilled, onrejected);
+	}
+};
+/**
+* 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`.
+*/
+function checkAborted(ctx, phase) {
+	if (ctx.signal?.aborted) throw runtimeAborted(phase, ctx.signal.reason);
+}
+/**
+* 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
+* `@internal/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.
+*/
+async function raceAgainstAbort(work, signal, phase) {
+	if (signal === void 0) return await work;
+	const sentinel = { reason: void 0 };
+	let onAbort;
+	const abortPromise = new Promise((_, reject) => {
+		if (signal.aborted) {
+			sentinel.reason = signal.reason;
+			reject(sentinel);
+			return;
+		}
+		onAbort = () => {
+			sentinel.reason = signal.reason;
+			reject(sentinel);
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
+	try {
+		return await Promise.race([work, abortPromise]);
+	} catch (error) {
+		if (error === sentinel) throw runtimeAborted(phase, sentinel.reason);
+		throw error;
+	} finally {
+		if (onAbort) signal.removeEventListener("abort", onAbort);
+	}
+}
+/**
+* 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");
+	}
+}
+/**
+* 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
+*     first non-`undefined` result wins; subsequent middleware's `intercept`
+*     does not fire. On a hit, the runtime emits a `middleware.intercept`
+*     debug event naming the winning middleware, switches the row source to
+*     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. 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.
+*  3. On successful completion: for each middleware in registration order:
+*     `afterExecute(exec, { rowCount, latencyMs, completed: true, source },
+*     ctx)`.
+*  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
+* intercept-and-row-source loop; family runtimes should not
+* reimplement it.
+*/
+function runWithMiddleware(exec, middleware, ctx, runDriver) {
+	const iterator = async function* () {
+		const startedAt = Date.now();
+		let rowCount = 0;
+		let completed = false;
+		let source = "driver";
+		let rowSource;
+		try {
+			for (const mw of middleware) {
+				if (!mw.intercept) continue;
+				source = "middleware";
+				const result = await mw.intercept(exec, ctx);
+				if (result === void 0) {
+					source = "driver";
+					continue;
+				}
+				ctx.log.debug?.({
+					event: "middleware.intercept",
+					middleware: mw.name
+				});
+				rowSource = result.rows;
+				break;
+			}
+			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);
+				}
+				rowCount++;
+				yield row;
+			}
+			completed = true;
+		} catch (error) {
+			const latencyMs = Date.now() - startedAt;
+			for (const mw of middleware) if (mw.afterExecute) try {
+				await mw.afterExecute(exec, {
+					rowCount,
+					latencyMs,
+					completed,
+					source
+				}, ctx);
+			} catch {}
+			throw error;
+		}
+		const latencyMs = Date.now() - startedAt;
+		for (const mw of middleware) if (mw.afterExecute) await mw.afterExecute(exec, {
+			rowCount,
+			latencyMs,
+			completed,
+			source
+		}, ctx);
+	};
+	return new AsyncIterableResult(iterator());
+}
+/**
+* Family-agnostic abstract runtime base.
+*
+* Defines the entire `execute(plan)` template in one place:
+*
+* 1. `runBeforeCompile(plan)` — concrete; defaults to identity. SQL overrides
+*    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. `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`.
+*
+* The class is generic over:
+* - `TPlan` — the family's pre-lowering plan type.
+* - `TExec` — the family's post-lowering (executable) plan type.
+* - `TMiddleware` — the family's middleware type. Constrained to
+*   `RuntimeMiddleware<TExec>` because `runWithMiddleware` invokes the
+*   `beforeExecute` / `onRow` / `afterExecute` hooks with the lowered
+*   `TExec`. (The spec/plan wording "RuntimeMiddleware<TPlan>" is
+*   tightened to `<TExec>` here so the helper call typechecks; the
+*   intent is unchanged — middleware sees the post-lowering plan.)
+*/
+var RuntimeCore = class {
+	middleware;
+	ctx;
+	constructor(options) {
+		this.middleware = options.middleware;
+		this.ctx = options.ctx;
+	}
+	/**
+	* Pre-lowering hook for plan rewriting. Defaults to identity. Subclasses
+	* may override to run a `beforeCompile` middleware chain (SQL does this
+	* to support typed AST rewrites — see `before-compile-chain.ts`).
+	*/
+	runBeforeCompile(plan) {
+		return plan;
+	}
+	execute(plan, options) {
+		const self = this;
+		const signal = options?.signal;
+		const codecCtx = signal === void 0 ? {} : { signal };
+		const execCtx = {
+			...self.ctx,
+			planExecutionId: crypto.randomUUID()
+		};
+		async function* generator() {
+			checkAborted(codecCtx, "stream");
+			const compiled = await self.runBeforeCompile(plan);
+			const exec = await self.lower(compiled, codecCtx);
+			await runBeforeExecuteChain(exec, self.middleware, execCtx);
+			yield* runWithMiddleware(exec, self.middleware, execCtx, () => self.runDriver(exec));
+		}
+		return new AsyncIterableResult(generator());
+	}
+};
+function checkMiddlewareCompatibility(middleware, runtimeFamilyId, runtimeTargetId) {
+	if (middleware.targetId !== void 0 && middleware.familyId === void 0) throw runtimeError("RUNTIME.MIDDLEWARE_INCOMPATIBLE", `Middleware '${middleware.name}' specifies targetId '${middleware.targetId}' without familyId`, {
+		middleware: middleware.name,
+		targetId: middleware.targetId
+	});
+	if (middleware.familyId !== void 0 && middleware.familyId !== runtimeFamilyId) throw runtimeError("RUNTIME.MIDDLEWARE_FAMILY_MISMATCH", `Middleware '${middleware.name}' requires family '${middleware.familyId}' but the runtime is configured for family '${runtimeFamilyId}'`, {
+		middleware: middleware.name,
+		middlewareFamilyId: middleware.familyId,
+		runtimeFamilyId
+	});
+	if (middleware.targetId !== void 0 && middleware.targetId !== runtimeTargetId) throw runtimeError("RUNTIME.MIDDLEWARE_TARGET_MISMATCH", `Middleware '${middleware.name}' requires target '${middleware.targetId}' but the runtime is configured for target '${runtimeTargetId}'`, {
+		middleware: middleware.name,
+		middlewareTargetId: middleware.targetId,
+		runtimeTargetId
+	});
+}
+var MetaBuilderImpl = class {
+	#kind;
+	#terminalName;
+	#annotations = /* @__PURE__ */ new Map();
+	constructor(kind, terminalName) {
+		this.#kind = kind;
+		this.#terminalName = terminalName;
+	}
+	get annotations() {
+		return this.#annotations;
+	}
+	annotate(annotation) {
+		const value = annotation;
+		assertAnnotationsApplicable([value], this.#kind, this.#terminalName);
+		this.#annotations.set(value.namespace, value);
+		return this;
+	}
+};
+/**
+* Construct a lane-side meta builder for a terminal of operation kind `K`.
+*
+* Lane terminals call this with their `kind` (`'read'` or `'write'`) and a
+* `terminalName` for error messages, hand the resulting builder to the
+* user-supplied configurator callback (typed as `MetaBuilder<K>`, the
+* narrower public view), and read `meta.annotations` afterwards to thread
+* the recorded values into `plan.meta.annotations`.
+*/
+function createMetaBuilder(kind, terminalName) {
+	return new MetaBuilderImpl(kind, terminalName);
+}
+//#endregion
+export { checkAborted as a, defineAnnotation as c, runWithMiddleware as d, runtimeAborted as f, assertAnnotationsApplicable as i, raceAgainstAbort as l, RUNTIME_ABORTED as n, checkMiddlewareCompatibility as o, RuntimeCore as r, createMetaBuilder as s, AsyncIterableResult as t, runBeforeExecuteChain as u };
+
+//# sourceMappingURL=runtime-DYTFHGwh.mjs.map

package/dist/runtime-DYTFHGwh.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-DYTFHGwh.mjs","names":["#kind","#terminalName","#annotations"],"sources":["../../../../1-framework/1-core/framework-components/dist/runtime.mjs"],"sourcesContent":["import { n as runtimeError, t as isRuntimeError } from \"./runtime-error-BA9d7XjZ.mjs\";\n//#region src/execution/runtime-error.ts\n/**\n* Stable code emitted by the runtime when an in-flight `execute()`\n* is cancelled via the per-query `AbortSignal`. The envelope's\n* `details.phase` distinguishes where the abort was observed:\n*\n* - `'encode'` — abort fired during `encodeParams` (SQL) or\n*   `resolveValue` (Mongo).\n* - `'decode'` — abort fired during `decodeRow` / `decodeField`.\n* - `'stream'` — abort fired between rows or before any codec call\n*   (already-aborted at entry).\n* - `'beforeExecute'` / `'afterExecute'` / `'onRow'` — abort fired\n*   on entry to or during the corresponding middleware phase\n*   (cooperative cancellation per the param-transform seam).\n*/\nconst RUNTIME_ABORTED = \"RUNTIME.ABORTED\";\n/**\n* Construct a `RUNTIME.ABORTED` envelope. Phase distinguishes where the\n* abort was observed — codec call sites (`encode` / `decode` / `stream`)\n* or middleware seams (`beforeExecute` / `afterExecute` / `onRow`), as\n* enumerated on {@link RuntimeAbortedPhase}. Cause carries\n* `signal.reason` verbatim from the platform — native abort produces a\n* `DOMException`, explicit `controller.abort(reason)` produces whatever\n* the caller passed. No synthesis happens here.\n*/\nfunction runtimeAborted(phase, cause) {\n\tconst envelope = runtimeError(RUNTIME_ABORTED, `Operation aborted during ${phase}`, { phase });\n\treturn Object.assign(envelope, { cause });\n}\n//#endregion\n//#region src/annotations.ts\n/**\n* Defines a typed annotation handle.\n*\n* Two-step call form. The first step takes the `Payload` type argument\n* (TypeScript cannot infer `Payload` from anything in the options, so it\n* must be supplied explicitly); the second step takes the runtime options\n* and infers `Kinds` from the `applicableTo` array via a `const` type\n* parameter, so the operation kinds appear exactly once at the call site.\n*\n* @example\n* ```typescript\n* // Read-only annotation. Lane terminals like `db.User.first(...)` accept\n* // it; `db.User.create(...)` rejects it at the type level.\n* const cacheAnnotation = defineAnnotation<{ ttl?: number; skip?: boolean }>()({\n*   namespace: 'cache',\n*   applicableTo: ['read'],\n* }); // Kinds inferred as 'read'\n*\n* // Write-only annotation. Mirror image.\n* const auditAnnotation = defineAnnotation<{ actor: string }>()({\n*   namespace: 'audit',\n*   applicableTo: ['write'],\n* }); // Kinds inferred as 'write'\n*\n* // Annotation applicable to both kinds (e.g. tracing).\n* const otelAnnotation = defineAnnotation<{ traceId: string }>()({\n*   namespace: 'otel',\n*   applicableTo: ['read', 'write'],\n* }); // Kinds inferred as 'read' | 'write'\n* ```\n*\n* **Reserved namespaces.** See `DefineAnnotationOptions.namespace` for the\n* list of framework-internal namespaces (`codecs`, target-specific keys).\n* `defineAnnotation` does not structurally prevent a user from naming a\n* reserved namespace, but the framework makes no compatibility guarantee\n* about handles that do.\n*/\nfunction defineAnnotation() {\n\treturn (options) => {\n\t\tconst namespace = options.namespace;\n\t\tconst applicableTo = Object.freeze(new Set(options.applicableTo));\n\t\tfunction handle(value) {\n\t\t\treturn Object.freeze({\n\t\t\t\t__annotation: true,\n\t\t\t\tnamespace,\n\t\t\t\tvalue,\n\t\t\t\tapplicableTo\n\t\t\t});\n\t\t}\n\t\tfunction read(plan) {\n\t\t\tconst stored = plan.meta.annotations?.[namespace];\n\t\t\tif (!isAnnotationValue(stored)) return;\n\t\t\tif (stored.namespace !== namespace) return;\n\t\t\treturn stored.value;\n\t\t}\n\t\treturn Object.freeze(Object.assign(handle, {\n\t\t\tnamespace,\n\t\t\tapplicableTo,\n\t\t\tread\n\t\t}));\n\t};\n}\n/**\n* Runtime applicability gate. Throws `RUNTIME.ANNOTATION_INAPPLICABLE` if\n* any annotation in `annotations` declares an `applicableTo` set that does\n* not include `kind`. Used by lane terminals (SQL DSL builders' `.build()`,\n* ORM `Collection` terminals) to fail closed when the type-level\n* `ValidAnnotations` gate is bypassed via cast / `any` / dynamic\n* invocation.\n*\n* Passes silently on:\n*  - empty arrays\n*  - annotations whose `applicableTo` includes `kind`\n*\n* Throws on:\n*  - any annotation whose `applicableTo` does not include `kind`. The\n*    error names the offending annotation's `namespace` and the\n*    `terminalName` so users can locate the misuse.\n*\n* @example\n* ```typescript\n* // Inside an ORM read terminal:\n* assertAnnotationsApplicable(annotations, 'read', 'first');\n* ```\n*/\nfunction assertAnnotationsApplicable(annotations, kind, terminalName) {\n\tfor (const annotation of annotations) if (!annotation.applicableTo.has(kind)) throw runtimeError(\"RUNTIME.ANNOTATION_INAPPLICABLE\", `Annotation '${annotation.namespace}' is not applicable to '${kind}' operations (terminal: '${terminalName}'). The annotation declares applicableTo = [${Array.from(annotation.applicableTo).map((k) => `'${k}'`).join(\", \")}].`, {\n\t\tnamespace: annotation.namespace,\n\t\tterminalName,\n\t\tkind,\n\t\tapplicableTo: Array.from(annotation.applicableTo)\n\t});\n}\n/**\n* Type guard for branded annotation values stored in `plan.meta.annotations`.\n*\n* Internal — used by `AnnotationHandle.read` to distinguish user\n* annotations (created by calling a handle returned from\n* `defineAnnotation(...)`) from framework-internal metadata that may\n* happen to live under the same namespace key.\n*/\nfunction isAnnotationValue(value) {\n\tif (value === null || typeof value !== \"object\") return false;\n\treturn value.__annotation === true;\n}\n//#endregion\n//#region src/execution/async-iterable-result.ts\nvar AsyncIterableResult = class {\n\tgenerator;\n\tconsumed = false;\n\tconsumedBy;\n\tbufferedArrayPromise;\n\tconstructor(generator) {\n\t\tthis.generator = generator;\n\t}\n\t[Symbol.asyncIterator]() {\n\t\tif (this.consumed) throw runtimeError(\"RUNTIME.ITERATOR_CONSUMED\", `AsyncIterableResult iterator has already been consumed via ${this.consumedBy === \"bufferedArray\" ? \"toArray()/then()\" : \"for-await loop\"}. Each AsyncIterableResult can only be iterated once.`, {\n\t\t\tconsumedBy: this.consumedBy,\n\t\t\tsuggestion: this.consumedBy === \"bufferedArray\" ? \"If you need to iterate multiple times, store the results from toArray() in a variable and reuse that.\" : \"If you need to iterate multiple times, use toArray() to collect all results first.\"\n\t\t});\n\t\tthis.consumed = true;\n\t\tthis.consumedBy = \"iterator\";\n\t\treturn this.generator;\n\t}\n\ttoArray() {\n\t\tif (this.consumedBy === \"iterator\") return Promise.reject(runtimeError(\"RUNTIME.ITERATOR_CONSUMED\", \"AsyncIterableResult iterator has already been consumed via for-await loop. Each AsyncIterableResult can only be iterated once.\", {\n\t\t\tconsumedBy: this.consumedBy,\n\t\t\tsuggestion: \"The iterator was already consumed by a for-await loop. Use toArray() or await the result before iterating.\"\n\t\t}));\n\t\tif (this.bufferedArrayPromise) return this.bufferedArrayPromise;\n\t\tthis.consumed = true;\n\t\tthis.consumedBy = \"bufferedArray\";\n\t\tthis.bufferedArrayPromise = (async () => {\n\t\t\tconst out = [];\n\t\t\tfor await (const item of this.generator) out.push(item);\n\t\t\treturn out;\n\t\t})();\n\t\treturn this.bufferedArrayPromise;\n\t}\n\tasync first() {\n\t\treturn (await this.toArray())[0] ?? null;\n\t}\n\tasync firstOrThrow() {\n\t\tconst row = await this.first();\n\t\tif (row === null) throw runtimeError(\"RUNTIME.NO_ROWS\", \"Expected at least one row, but none were returned\", {});\n\t\treturn row;\n\t}\n\tthen(onfulfilled, onrejected) {\n\t\treturn this.toArray().then(onfulfilled, onrejected);\n\t}\n};\n//#endregion\n//#region src/execution/race-against-abort.ts\n/**\n* Throw a phase-tagged `RUNTIME.ABORTED` envelope if the supplied\n* context is already aborted at the precheck site. Centralises the\n* `if (ctx.signal?.aborted) throw runtimeAborted(...)` pattern that\n* every codec dispatch site (and the `beforeExecute` middleware phase)\n* repeats. Accepts both the framework `CodecCallContext` and the\n* `RuntimeMiddlewareContext`; both expose `signal?: AbortSignal`.\n*/\nfunction checkAborted(ctx, phase) {\n\tif (ctx.signal?.aborted) throw runtimeAborted(phase, ctx.signal.reason);\n}\n/**\n* Race a per-cell `Promise.all` (or any other in-flight work promise) against\n* the supplied abort signal so the runtime returns `RUNTIME.ABORTED` promptly\n* even when codec bodies ignore the signal. In-flight bodies that ignore the\n* signal are abandoned and run to completion in the background — the\n* cooperative-cancellation contract documented in ADR 204.\n*\n* Call sites still SHOULD pre-check `signal.aborted` and short-circuit with\n* a phase-tagged `RUNTIME.ABORTED` envelope before invoking this helper —\n* that path is the canonical \"aborted at entry\" surface and avoids\n* scheduling the work promise. As a defensive belt-and-braces, this helper\n* also handles the already-aborted case internally: `AbortSignal` does not\n* replay past abort events to listeners registered after the abort, so we\n* inspect `signal.aborted` synchronously and reject with the sentinel\n* before installing the listener. The rejection is still attributed to the\n* abort path via the sentinel-identity check.\n*\n* Distinguishing the rejection source is load-bearing for AC-ERR4\n* (`RUNTIME.ENCODE_FAILED` / `RUNTIME.DECODE_FAILED` pass through unchanged).\n* The semantically equivalent `abortable(signal)` helper in\n* `@internal/utils` rejects with `signal.reason ?? new DOMException(...)`,\n* which is not stably distinguishable from a codec-thrown error by identity\n* alone (a fresh fallback DOMException is allocated per call). We instead\n* track abort attribution with a unique sentinel: only the `onAbort` listener\n* installed here ever rejects with the sentinel, so an `error === sentinel`\n* identity check after the race is unambiguous.\n*\n* Lives in `framework-components` (rather than the SQL family, where it\n* originated in m2) so every family runtime that needs cooperative\n* cancellation around a codec-dispatch `Promise.all` (SQL encode + decode\n* today, Mongo encode in m3) shares the same attribution logic.\n*/\nasync function raceAgainstAbort(work, signal, phase) {\n\tif (signal === void 0) return await work;\n\tconst sentinel = { reason: void 0 };\n\tlet onAbort;\n\tconst abortPromise = new Promise((_, reject) => {\n\t\tif (signal.aborted) {\n\t\t\tsentinel.reason = signal.reason;\n\t\t\treject(sentinel);\n\t\t\treturn;\n\t\t}\n\t\tonAbort = () => {\n\t\t\tsentinel.reason = signal.reason;\n\t\t\treject(sentinel);\n\t\t};\n\t\tsignal.addEventListener(\"abort\", onAbort, { once: true });\n\t});\n\ttry {\n\t\treturn await Promise.race([work, abortPromise]);\n\t} catch (error) {\n\t\tif (error === sentinel) throw runtimeAborted(phase, sentinel.reason);\n\t\tthrow error;\n\t} finally {\n\t\tif (onAbort) signal.removeEventListener(\"abort\", onAbort);\n\t}\n}\n//#endregion\n//#region src/execution/before-execute-chain.ts\n/**\n* Runs every middleware's `beforeExecute` hook in registration order,\n* threading through the (optional) family-specific `paramsMutator`.\n*\n* Why this lives outside {@link runWithMiddleware}: middleware that\n* mutates parameter values (e.g. cipherstash's bulk-encrypt SDK\n* round-trip) must run *before* the family runtime encodes those\n* parameters to driver wire format. Family runtimes call\n* `runBeforeExecuteChain` between the AST → plan lowering step and\n* the parameter encode step; the encode then observes the mutator's\n* `currentParams()` view. `runWithMiddleware` retains the rest of\n* the lifecycle (`intercept`, driver/row source loop, `onRow`,\n* `afterExecute`) but no longer fires `beforeExecute` itself.\n*\n* Lifecycle within this helper:\n*\n*  1. For each middleware in registration order, if `beforeExecute`\n*     is implemented:\n*     - `checkAborted(ctx, 'beforeExecute')` short-circuits if the\n*       caller already aborted at entry.\n*     - The hook is invoked with `(plan, ctx, paramsMutator)`. A\n*       middleware body that ignores the mutator stays compatible —\n*       JavaScript allows extra positional arguments.\n*     - If the hook returns a Promise, it is raced against\n*       `ctx.signal` via {@link raceAgainstAbort} so cooperative\n*       cancellation surfaces a `RUNTIME.ABORTED { phase:\n*       'beforeExecute' }` envelope even when the body itself\n*       ignores the signal.\n*\n* Error propagation: any error thrown by a `beforeExecute` body\n* (or surfaced by the abort race) propagates out of this helper\n* unchanged. The family runtime is responsible for converting it\n* into the appropriate `afterExecute(completed: false)` notification\n* once `runWithMiddleware` runs.\n*\n* Relationship to {@link runWithMiddleware}: the framework's\n* `RuntimeCore.execute` template calls this helper between\n* `lower(plan)` and `runWithMiddleware(...)`. Family runtimes that\n* override `execute` (e.g. SQL, which inlines lower + encode for\n* direct mutator threading) call this helper themselves at the\n* equivalent point — between the family's AST → draft-plan\n* lowering and the parameter-encode step.\n*\n* Intercept ordering: this helper fires unconditionally before\n* `runWithMiddleware`. `intercept` (inside `runWithMiddleware`)\n* therefore observes the post-`beforeExecute` plan — mutator\n* mutations are visible in the params interceptors see. The\n* trade-off is documented on `RuntimeMiddleware.intercept`.\n*/\nasync function runBeforeExecuteChain(plan, middleware, ctx, paramsMutator) {\n\tfor (const mw of middleware) {\n\t\tif (!mw.beforeExecute) continue;\n\t\tcheckAborted(ctx, \"beforeExecute\");\n\t\tconst work = mw.beforeExecute(plan, ctx, paramsMutator);\n\t\tif (work !== void 0) await raceAgainstAbort(Promise.resolve(work), ctx.signal, \"beforeExecute\");\n\t}\n}\n//#endregion\n//#region src/execution/run-with-middleware.ts\n/**\n* Drives a single execution of `runDriver()` through the middleware\n* lifecycle's intercept + row-source + termination phases.\n*\n* Lifecycle, in order:\n*  1. For each middleware in registration order: `intercept(exec, ctx)`. The\n*     first non-`undefined` result wins; subsequent middleware's `intercept`\n*     does not fire. On a hit, the runtime emits a `middleware.intercept`\n*     debug event naming the winning middleware, switches the row source to\n*     the intercepted rows, and proceeds with `source: 'middleware'`. On\n*     all-passthrough (every `intercept` returns `undefined` or is omitted),\n*     `source: 'driver'` is used and the row source is `runDriver()`.\n*  2. Iterate the row source. On the driver path, for each row, for each\n*     middleware in registration order: `onRow(row, exec, ctx)`; then yield\n*     the row. On the intercepted hit path, `onRow` is skipped — intercepted\n*     rows did not originate from a driver row stream — but rows are still\n*     yielded to the consumer in order.\n*  3. On successful completion: for each middleware in registration order:\n*     `afterExecute(exec, { rowCount, latencyMs, completed: true, source },\n*     ctx)`.\n*  4. On any error thrown during steps 1–2: for each middleware in\n*     registration order: `afterExecute(exec, { rowCount, latencyMs,\n*     completed: false, source }, ctx)`. Errors thrown by `afterExecute`\n*     during the error path are swallowed so they do not mask the original\n*     error. The original error is then rethrown.\n*\n* `beforeExecute` is **not** fired here — see\n* {@link runBeforeExecuteChain} in `before-execute-chain.ts`. Family\n* runtimes call that helper between the AST → plan lowering step and\n* the parameter encode step so middleware that mutates ParamRef\n* values (e.g. cipherstash bulk-encrypt) can have its mutations\n* visible to encode. `runWithMiddleware` operates on the fully-\n* encoded plan; interceptors therefore observe a fully-mutated,\n* encoded plan.\n*\n* The `source` field on `AfterExecuteResult` lets observers (telemetry,\n* lints, budgets) distinguish driver-served from middleware-served\n* executions without needing their own out-of-band signal.\n*\n* This helper is the single canonical implementation of the\n* intercept-and-row-source loop; family runtimes should not\n* reimplement it.\n*/\nfunction runWithMiddleware(exec, middleware, ctx, runDriver) {\n\tconst iterator = async function* () {\n\t\tconst startedAt = Date.now();\n\t\tlet rowCount = 0;\n\t\tlet completed = false;\n\t\tlet source = \"driver\";\n\t\tlet rowSource;\n\t\ttry {\n\t\t\tfor (const mw of middleware) {\n\t\t\t\tif (!mw.intercept) continue;\n\t\t\t\tsource = \"middleware\";\n\t\t\t\tconst result = await mw.intercept(exec, ctx);\n\t\t\t\tif (result === void 0) {\n\t\t\t\t\tsource = \"driver\";\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tctx.log.debug?.({\n\t\t\t\t\tevent: \"middleware.intercept\",\n\t\t\t\t\tmiddleware: mw.name\n\t\t\t\t});\n\t\t\t\trowSource = result.rows;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tif (source === \"driver\") rowSource = runDriver();\n\t\t\tfor await (const row of rowSource) {\n\t\t\t\tif (source === \"driver\") {\n\t\t\t\t\tfor (const mw of middleware) if (mw.onRow) await mw.onRow(row, exec, ctx);\n\t\t\t\t}\n\t\t\t\trowCount++;\n\t\t\t\tyield row;\n\t\t\t}\n\t\t\tcompleted = true;\n\t\t} catch (error) {\n\t\t\tconst latencyMs = Date.now() - startedAt;\n\t\t\tfor (const mw of middleware) if (mw.afterExecute) try {\n\t\t\t\tawait mw.afterExecute(exec, {\n\t\t\t\t\trowCount,\n\t\t\t\t\tlatencyMs,\n\t\t\t\t\tcompleted,\n\t\t\t\t\tsource\n\t\t\t\t}, ctx);\n\t\t\t} catch {}\n\t\t\tthrow error;\n\t\t}\n\t\tconst latencyMs = Date.now() - startedAt;\n\t\tfor (const mw of middleware) if (mw.afterExecute) await mw.afterExecute(exec, {\n\t\t\trowCount,\n\t\t\tlatencyMs,\n\t\t\tcompleted,\n\t\t\tsource\n\t\t}, ctx);\n\t};\n\treturn new AsyncIterableResult(iterator());\n}\n//#endregion\n//#region src/execution/runtime-core.ts\n/**\n* Family-agnostic abstract runtime base.\n*\n* Defines the entire `execute(plan)` template in one place:\n*\n* 1. `runBeforeCompile(plan)` — concrete; defaults to identity. SQL overrides\n*    this to run its `beforeCompile` middleware-hook chain.\n* 2. `lower(plan)` — abstract. Each family produces its `*ExecutionPlan`\n*    (SQL via `lowerSqlPlan`, Mongo via `adapter.lower`).\n* 3. `runBeforeExecuteChain(exec, this.middleware, this.ctx)` — concrete;\n*    runs every middleware's `beforeExecute` hook after lowering but\n*    before the row source is opened. Family runtimes that need a\n*    params mutator visible to a downstream encode step (SQL) override\n*    `execute` and call this helper themselves at the equivalent\n*    pre-encode point.\n* 4. `runWithMiddleware(exec, this.middleware, this.ctx,\n*    () => runDriver(exec))` — concrete; runs the intercept chain,\n*    drives the row source, fires `onRow` / `afterExecute`. Does\n*    **not** fire `beforeExecute` — see step 3.\n*\n* Concrete subclasses must implement `lower`, `runDriver`, and `close`.\n*\n* The class is generic over:\n* - `TPlan` — the family's pre-lowering plan type.\n* - `TExec` — the family's post-lowering (executable) plan type.\n* - `TMiddleware` — the family's middleware type. Constrained to\n*   `RuntimeMiddleware<TExec>` because `runWithMiddleware` invokes the\n*   `beforeExecute` / `onRow` / `afterExecute` hooks with the lowered\n*   `TExec`. (The spec/plan wording \"RuntimeMiddleware<TPlan>\" is\n*   tightened to `<TExec>` here so the helper call typechecks; the\n*   intent is unchanged — middleware sees the post-lowering plan.)\n*/\nvar RuntimeCore = class {\n\tmiddleware;\n\tctx;\n\tconstructor(options) {\n\t\tthis.middleware = options.middleware;\n\t\tthis.ctx = options.ctx;\n\t}\n\t/**\n\t* Pre-lowering hook for plan rewriting. Defaults to identity. Subclasses\n\t* may override to run a `beforeCompile` middleware chain (SQL does this\n\t* to support typed AST rewrites — see `before-compile-chain.ts`).\n\t*/\n\trunBeforeCompile(plan) {\n\t\treturn plan;\n\t}\n\texecute(plan, options) {\n\t\tconst self = this;\n\t\tconst signal = options?.signal;\n\t\tconst codecCtx = signal === void 0 ? {} : { signal };\n\t\tconst execCtx = {\n\t\t\t...self.ctx,\n\t\t\tplanExecutionId: crypto.randomUUID()\n\t\t};\n\t\tasync function* generator() {\n\t\t\tcheckAborted(codecCtx, \"stream\");\n\t\t\tconst compiled = await self.runBeforeCompile(plan);\n\t\t\tconst exec = await self.lower(compiled, codecCtx);\n\t\t\tawait runBeforeExecuteChain(exec, self.middleware, execCtx);\n\t\t\tyield* runWithMiddleware(exec, self.middleware, execCtx, () => self.runDriver(exec));\n\t\t}\n\t\treturn new AsyncIterableResult(generator());\n\t}\n};\n//#endregion\n//#region src/execution/runtime-middleware.ts\nfunction checkMiddlewareCompatibility(middleware, runtimeFamilyId, runtimeTargetId) {\n\tif (middleware.targetId !== void 0 && middleware.familyId === void 0) throw runtimeError(\"RUNTIME.MIDDLEWARE_INCOMPATIBLE\", `Middleware '${middleware.name}' specifies targetId '${middleware.targetId}' without familyId`, {\n\t\tmiddleware: middleware.name,\n\t\ttargetId: middleware.targetId\n\t});\n\tif (middleware.familyId !== void 0 && middleware.familyId !== runtimeFamilyId) throw runtimeError(\"RUNTIME.MIDDLEWARE_FAMILY_MISMATCH\", `Middleware '${middleware.name}' requires family '${middleware.familyId}' but the runtime is configured for family '${runtimeFamilyId}'`, {\n\t\tmiddleware: middleware.name,\n\t\tmiddlewareFamilyId: middleware.familyId,\n\t\truntimeFamilyId\n\t});\n\tif (middleware.targetId !== void 0 && middleware.targetId !== runtimeTargetId) throw runtimeError(\"RUNTIME.MIDDLEWARE_TARGET_MISMATCH\", `Middleware '${middleware.name}' requires target '${middleware.targetId}' but the runtime is configured for target '${runtimeTargetId}'`, {\n\t\tmiddleware: middleware.name,\n\t\tmiddlewareTargetId: middleware.targetId,\n\t\truntimeTargetId\n\t});\n}\n//#endregion\n//#region src/meta-builder.ts\nvar MetaBuilderImpl = class {\n\t#kind;\n\t#terminalName;\n\t#annotations = /* @__PURE__ */ new Map();\n\tconstructor(kind, terminalName) {\n\t\tthis.#kind = kind;\n\t\tthis.#terminalName = terminalName;\n\t}\n\tget annotations() {\n\t\treturn this.#annotations;\n\t}\n\tannotate(annotation) {\n\t\tconst value = annotation;\n\t\tassertAnnotationsApplicable([value], this.#kind, this.#terminalName);\n\t\tthis.#annotations.set(value.namespace, value);\n\t\treturn this;\n\t}\n};\n/**\n* Construct a lane-side meta builder for a terminal of operation kind `K`.\n*\n* Lane terminals call this with their `kind` (`'read'` or `'write'`) and a\n* `terminalName` for error messages, hand the resulting builder to the\n* user-supplied configurator callback (typed as `MetaBuilder<K>`, the\n* narrower public view), and read `meta.annotations` afterwards to thread\n* the recorded values into `plan.meta.annotations`.\n*/\nfunction createMetaBuilder(kind, terminalName) {\n\treturn new MetaBuilderImpl(kind, terminalName);\n}\n//#endregion\nexport { AsyncIterableResult, RUNTIME_ABORTED, RuntimeCore, assertAnnotationsApplicable, checkAborted, checkMiddlewareCompatibility, createMetaBuilder, defineAnnotation, isRuntimeError, raceAgainstAbort, runBeforeExecuteChain, runWithMiddleware, runtimeAborted, runtimeError };\n\n//# sourceMappingURL=runtime.mjs.map"],"mappings":"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"}

package/dist/runtime-error-BA9d7XjZ-BlT8t6LB.mjs

@@ -0,0 +1,40 @@
+//#region ../../../1-framework/1-core/framework-components/dist/runtime-error-BA9d7XjZ.mjs
+/**
+* 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.
+*/
+function isRuntimeError(error) {
+	return error instanceof Error && "code" in error && typeof error.code === "string" && "category" in error && "severity" in error;
+}
+function runtimeError(code, message, details) {
+	const error = Object.assign(new Error(message), {
+		code,
+		category: resolveCategory(code),
+		severity: "error",
+		...details !== void 0 ? { details } : {}
+	});
+	Object.defineProperty(error, "name", {
+		value: "RuntimeError",
+		configurable: true
+	});
+	return error;
+}
+function resolveCategory(code) {
+	const prefix = code.split(".")[0] ?? "RUNTIME";
+	switch (prefix) {
+		case "PLAN":
+		case "CONTRACT":
+		case "LINT":
+		case "BUDGET":
+		case "DRIVER":
+		case "MIGRATION":
+		case "ORM": return prefix;
+		default: return "RUNTIME";
+	}
+}
+//#endregion
+export { runtimeError as n, isRuntimeError as t };
+
+//# sourceMappingURL=runtime-error-BA9d7XjZ-BlT8t6LB.mjs.map

package/dist/runtime-error-BA9d7XjZ-BlT8t6LB.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-error-BA9d7XjZ-BlT8t6LB.mjs","names":[],"sources":["../../../../1-framework/1-core/framework-components/dist/runtime-error-BA9d7XjZ.mjs"],"sourcesContent":["//#region src/shared/runtime-error.ts\n/**\n* Type guard for the runtime-error envelope produced by `runtimeError`.\n*\n* Prefer this over duck-typing on `error.code` directly so consumers stay\n* insulated from the envelope's internal shape.\n*/\nfunction isRuntimeError(error) {\n\treturn error instanceof Error && \"code\" in error && typeof error.code === \"string\" && \"category\" in error && \"severity\" in error;\n}\nfunction runtimeError(code, message, details) {\n\tconst error = Object.assign(new Error(message), {\n\t\tcode,\n\t\tcategory: resolveCategory(code),\n\t\tseverity: \"error\",\n\t\t...details !== void 0 ? { details } : {}\n\t});\n\tObject.defineProperty(error, \"name\", {\n\t\tvalue: \"RuntimeError\",\n\t\tconfigurable: true\n\t});\n\treturn error;\n}\nfunction resolveCategory(code) {\n\tconst prefix = code.split(\".\")[0] ?? \"RUNTIME\";\n\tswitch (prefix) {\n\t\tcase \"PLAN\":\n\t\tcase \"CONTRACT\":\n\t\tcase \"LINT\":\n\t\tcase \"BUDGET\":\n\t\tcase \"DRIVER\":\n\t\tcase \"MIGRATION\":\n\t\tcase \"ORM\": return prefix;\n\t\tdefault: return \"RUNTIME\";\n\t}\n}\n//#endregion\nexport { runtimeError as n, isRuntimeError as t };\n\n//# sourceMappingURL=runtime-error-BA9d7XjZ.mjs.map"],"mappings":";;;;;;;AAOA,SAAS,eAAe,OAAO;CAC9B,OAAO,iBAAiB,SAAS,UAAU,SAAS,OAAO,MAAM,SAAS,YAAY,cAAc,SAAS,cAAc;AAC5H;AACA,SAAS,aAAa,MAAM,SAAS,SAAS;CAC7C,MAAM,QAAQ,OAAO,OAAO,IAAI,MAAM,OAAO,GAAG;EAC/C;EACA,UAAU,gBAAgB,IAAI;EAC9B,UAAU;EACV,GAAG,YAAY,KAAK,IAAI,EAAE,QAAQ,IAAI,CAAC;CACxC,CAAC;CACD,OAAO,eAAe,OAAO,QAAQ;EACpC,OAAO;EACP,cAAc;CACf,CAAC;CACD,OAAO;AACR;AACA,SAAS,gBAAgB,MAAM;CAC9B,MAAM,SAAS,KAAK,MAAM,GAAG,CAAC,CAAC,MAAM;CACrC,QAAQ,QAAR;EACC,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK,OAAO,OAAO;EACnB,SAAS,OAAO;CACjB;AACD"}

package/dist/simplify-deep-Dw9I_ZUl.d.mts

@@ -0,0 +1,6 @@
+//#region ../../../1-framework/0-foundation/utils/dist/simplify-deep.d.mts
+//#region src/simplify-deep.d.ts
+type SimplifyDeep<T> = T extends readonly (infer Element)[] ? T extends unknown[] ? SimplifyDeep<Element>[] : readonly SimplifyDeep<Element>[] : T extends string | number | boolean | bigint | symbol | Date | RegExp | Uint8Array | ((...args: never[]) => unknown) ? T : T extends object ? { [K in keyof T]: SimplifyDeep<T[K]>; } : T;
+//#endregion
+export { SimplifyDeep as t };
+//# sourceMappingURL=simplify-deep-Dw9I_ZUl.d.mts.map

package/dist/simplify-deep-Dw9I_ZUl.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simplify-deep-Dw9I_ZUl.d.mts","names":[],"sources":["../../../../1-framework/0-foundation/utils/dist/simplify-deep.d.mts"],"mappings":";;KACK,aAAa,KAAK,0BAA0B,aAAa,sBAAsB,aAAa,sBAAsB,aAAa,aAAa,wDAAwD,OAAO,SAAS,kBAAkB,6BAA6B,IAAI,sBAAsB,WAAW,IAAI,aAAa,EAAE,SAAS"}