@prisma/orm-family-sql 8.0.0-rc.1-dev.41 → 8.0.0-rc.1-dev.43

package/dist/runtime.mjs

@@ -1,9 +1,10 @@
 import { t as createSqlOperationRegistry } from "./dist-C_q1_QR9.mjs";
-import { A as PreparedParamRef, H as isQueryAst } from "./types-CSP6WmWn-DVuxsZJW.mjs";
+import { A as PreparedParamRef, H as isQueryAst } from "./types-B7_v-z12-De5tf8LE.mjs";
 import { t as collectOrderedParamRefs } from "./util-DQQgv2j1-D6INZaRG.mjs";
 import { t as createSqlParamRefMutator } from "./middleware-CMr4CHNz-DHIUdxlm.mjs";
-import { t as buildSqlAggregateDescriptorRegistry } from "./aggregate-descriptor-registry-DSap8YyW.mjs";
+import { t as buildSqlAggregateDescriptorRegistry } from "./aggregate-descriptor-registry-CTo0ry7h.mjs";
 import { t as buildCodecDescriptorRegistry } from "./codec-descriptor-registry-N0dhtKaH.mjs";
+import { n as runPreparedQuery, t as preparedStatementQuery } from "./prepared-query-BDLztUzY-CaDR0Rqc.mjs";
 import { isStructuredError } from "@prisma/orm-framework/utils/structured-error";
 import { createHash } from "node:crypto";
 import { assertNever } from "@prisma/orm-framework/utils/internal-error";
@@ -12,11 +13,11 @@ import { blindCast } from "@prisma/orm-framework/utils/casts";
 import { canonicalStringify } from "@prisma/orm-framework/utils/canonical-stringify";
 import { checkContractComponentRequirements, mergeCapabilityMatrices } from "@prisma/orm-framework/components/components";
 import { materializeCodec, resolveCodecDescriptorOrThrow } from "@prisma/orm-framework/components/codec";
-import { AsyncIterableResult, RuntimeCore, checkAborted, checkMiddlewareCompatibility, raceAgainstAbort, runBeforeExecuteChain, runWithMiddleware, runtimeError } from "@prisma/orm-framework/components/runtime";
+import { AsyncIterableResult, RuntimeCore, checkAborted, checkMiddlewareCompatibility, raceAgainstAbort, runBeforeExecuteChain, runBeforeQueryChain, runExecuteWithMiddleware, runQueryWithMiddleware, runtimeError } from "@prisma/orm-framework/components/runtime";
 import { canonicalizeJson } from "@prisma/orm-framework/components/utils";
 import { createExecutionStack } from "@prisma/orm-framework/components/execution";
 import { hashContent } from "@prisma/orm-framework/utils/hash-content";
-//#region ../../../2-sql/5-runtime/dist/exports-yyrgm9_7.mjs
+//#region ../../../2-sql/5-runtime/dist/exports-CNtR1FrC.mjs
 /**
 * Build an {@link AstCodecResolver} bound to a descriptor registry and a per-call instance-context factory.
 *
@@ -222,13 +223,25 @@ function budgets(options) {
 	const rowSeverity = options?.severities?.rowCount ?? "error";
 	const latencySeverity = options?.severities?.latency ?? "warn";
 	const observedRowsByPlan = /* @__PURE__ */ new WeakMap();
+	const beforeOperation = async (plan, ctx) => {
+		observedRowsByPlan.set(plan, { count: 0 });
+		if (isQueryAst(plan.ast) && plan.ast.kind === "select") evaluateSelectAst(plan.ast, ctx);
+	};
+	const afterOperation = async (_plan, result, ctx) => {
+		const latencyMs = result.latencyMs;
+		if (latencyMs > maxLatencyMs) {
+			const shouldBlock = latencySeverity === "error" || ctx.mode === "strict";
+			emitBudgetViolation(runtimeError("BUDGET.TIME_EXCEEDED", "Query latency exceeds budget", {
+				latencyMs,
+				maxLatencyMs
+			}), shouldBlock, ctx);
+		}
+	};
 	return Object.freeze({
 		name: "budgets",
 		familyId: "sql",
-		async beforeExecute(plan, ctx) {
-			observedRowsByPlan.set(plan, { count: 0 });
-			if (isQueryAst(plan.ast) && plan.ast.kind === "select") return evaluateSelectAst(plan.ast, ctx);
-		},
+		beforeQuery: beforeOperation,
+		beforeExecute: beforeOperation,
 		async onRow(_row, plan, _ctx) {
 			const state = observedRowsByPlan.get(plan);
 			if (!state) return;
@@ -239,16 +252,8 @@ function budgets(options) {
 				maxRows
 			});
 		},
-		async afterExecute(_plan, result, ctx) {
-			const latencyMs = result.latencyMs;
-			if (latencyMs > maxLatencyMs) {
-				const shouldBlock = latencySeverity === "error" || ctx.mode === "strict";
-				emitBudgetViolation(runtimeError("BUDGET.TIME_EXCEEDED", "Query latency exceeds budget", {
-					latencyMs,
-					maxLatencyMs
-				}), shouldBlock, ctx);
-			}
-		}
+		afterQuery: afterOperation,
+		afterExecute: afterOperation
 	});
 	function evaluateSelectAst(ast, ctx) {
 		const hasAggNoGroup = hasAggregateWithoutGroupBy(ast);
@@ -430,25 +435,27 @@ function getConfiguredSeverity(code, options) {
 */
 function lints(options) {
 	const fallback = options?.fallbackWhenAstMissing ?? "raw";
+	const beforeOperation = async (plan, ctx) => {
+		const findings = [];
+		if (isQueryAst(plan.ast)) {
+			findings.push(...evaluateAstLints(plan.ast));
+			if (plan.ast.kind === "raw-sql") findings.push(...evaluateRawGuardrails(plan).lints);
+		} else if (fallback !== "skip") findings.push(...evaluateRawGuardrails(plan).lints);
+		for (const lint of findings) {
+			const effectiveSeverity = getConfiguredSeverity(lint.code, options) ?? lint.severity;
+			if (effectiveSeverity === "error") throw runtimeError(lint.code, lint.message, lint.details);
+			if (effectiveSeverity === "warn") ctx.log.warn({
+				code: lint.code,
+				message: lint.message,
+				details: lint.details
+			});
+		}
+	};
 	return Object.freeze({
 		name: "lints",
 		familyId: "sql",
-		async beforeExecute(plan, ctx) {
-			const findings = [];
-			if (isQueryAst(plan.ast)) {
-				findings.push(...evaluateAstLints(plan.ast));
-				if (plan.ast.kind === "raw-sql") findings.push(...evaluateRawGuardrails(plan).lints);
-			} else if (fallback !== "skip") findings.push(...evaluateRawGuardrails(plan).lints);
-			for (const lint of findings) {
-				const effectiveSeverity = getConfiguredSeverity(lint.code, options) ?? lint.severity;
-				if (effectiveSeverity === "error") throw runtimeError(lint.code, lint.message, lint.details);
-				if (effectiveSeverity === "warn") ctx.log.warn({
-					code: lint.code,
-					message: lint.message,
-					details: lint.details
-				});
-			}
-		}
+		beforeQuery: beforeOperation,
+		beforeExecute: beforeOperation
 	});
 }
 var PreparedStatementImpl = class {
@@ -467,8 +474,8 @@ var PreparedStatementImpl = class {
 		this.paramMetadata = internals.paramMetadata;
 		Object.freeze(this);
 	}
-	execute(target, params, options) {
-		return target.executePrepared(this, params, options);
+	query(target, params, options) {
+		return runPreparedQuery(target, this, params, options);
 	}
 };
 function documentScopedCodecTypes(contract) {
@@ -1120,10 +1127,14 @@ function buildBindSiteParams(declaration) {
 * surface `RUNTIME.PREPARE_MISSING_PARAM` so the caller cannot silently
 * bind `undefined`.
 */
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
 function resolvePreparedSlotValues(ps, userParams) {
+	if (!isRecord(userParams)) throw runtimeError("RUNTIME.PREPARE_MISSING_PARAM", "Prepared statement parameters must be an object");
 	return ps.slots.map((slot) => {
 		if (slot.kind === "literal") return slot.value;
-		if (!Object.hasOwn(userParams, slot.name)) throw runtimeError("RUNTIME.PREPARE_MISSING_PARAM", `Prepared statement execute is missing parameter '${slot.name}'`, { name: slot.name });
+		if (!Object.hasOwn(userParams, slot.name)) throw runtimeError("RUNTIME.PREPARE_MISSING_PARAM", `Prepared statement query is missing parameter '${slot.name}'`, { name: slot.name });
 		return userParams[slot.name];
 	});
 }
@@ -1181,7 +1192,7 @@ var SqlRuntimeBase = class extends RuntimeCore {
 			mode: mode ?? "strict",
 			now: () => Date.now(),
 			log: log ?? noopLog,
-			contentHash: (exec) => computeSqlContentHash(exec),
+			contentHash: (exec) => computeSqlContentHash(blindCast(exec)),
 			scope: "runtime",
 			planExecutionId: ""
 		};
@@ -1206,15 +1217,14 @@ var SqlRuntimeBase = class extends RuntimeCore {
 	* with encoded parameters ready for the driver.
 	*
 	* Implementation note: SQL splits lower-then-encode across
-	* {@link lowerToDraft} + {@link encodeDraftParams} so the runtime
-	* can fire the `beforeExecute` middleware chain between them
-	* (cipherstash bulk-encrypt, for example, mutates pre-encode
-	* `ParamRef.value` slots). This protected hook composes the two
-	* back into the cross-family `lower()` shape `RuntimeCore.execute`
-	* expects, and is called from the no-middleware fast paths /
-	* fixtures that hit `RuntimeCore`'s default template directly.
-	* `execute()` overrides the template and uses the split form so
-	* `beforeExecute` lands between the two halves.
+	* {@link lowerToDraft} + {@link encodeDraftParams} so the selected
+	* operation's middleware chain can run between them:
+	* {@link prepareQueryExecution} uses `runBeforeQueryChain` for `query()`,
+	* while {@link prepareExecuteExecution} uses `runBeforeExecuteChain` for
+	* `execute()` (cipherstash bulk-encrypt, for example, mutates pre-encode
+	* `ParamRef.value` slots). This protected hook composes the two back into
+	* the cross-family `lower()` shape `RuntimeCore` expects. The production
+	* operation methods use the matching split form before driver execution.
 	*
 	* `ctx: SqlCodecCallContext` is forwarded to `encodeParams` so
 	* per-query cancellation reaches every codec body during parameter
@@ -1226,20 +1236,20 @@ var SqlRuntimeBase = class extends RuntimeCore {
 		return await this.encodeDraftParams(draft, ctx);
 	}
 	/**
-	* AST → pre-encode draft. The returned plan has `sql` rendered and
-	* `params` populated with the user-domain values the lowering site
-	* collected from `ParamRef` nodes. No codec encode has happened
-	* yet; consumers can mutate `params` via the `SqlParamRefMutator`
-	* before {@link encodeDraftParams} runs.
+	* AST → pre-encode draft for the selected `query()` or `execute()` operation.
+	* The returned plan has `sql` rendered and `params` populated with the
+	* user-domain values the lowering site collected from `ParamRef` nodes. No
+	* codec encode has happened yet; consumers can mutate `params` via the
+	* `SqlParamRefMutator` before {@link encodeDraftParams} runs.
 	*/
 	lowerToDraft(plan) {
 		return lowerSqlPlan(this.adapter, this.contract, plan);
 	}
 	/**
-	* Encode a draft plan's params through the per-column codecs and
-	* freeze the result into the final `SqlExecutionPlan` the driver
-	* sees. Errors surface as `RUNTIME.ENCODE_FAILED` envelopes from
-	* {@link encodeParams}.
+	* Encode a draft plan's params for the selected `query()` or `execute()`
+	* operation through the per-column codecs and freeze the result into the
+	* final `SqlExecutionPlan` the driver sees. Errors surface as
+	* `RUNTIME.ENCODE_FAILED` envelopes from {@link encodeParams}.
 	*/
 	async encodeDraftParams(draft, ctx) {
 		return Object.freeze({
@@ -1247,9 +1257,7 @@ var SqlRuntimeBase = class extends RuntimeCore {
 			params: await encodeParams(draft, ctx, this.contractCodecs)
 		});
 	}
-	/**
-	* Default driver invocation required by the abstract `RuntimeCore` contract. Every production path overrides `execute()` and routes through `executeAgainstQueryable`, so this hook is defensive only — subclasses that delegate back to `super.execute()` would land here.
-	*/
+	/** Default query invocation required by the abstract `RuntimeCore` contract. */
 	// v8 ignore next 6
 	runDriver(exec) {
 		return this.driver.query({
@@ -1257,26 +1265,38 @@ var SqlRuntimeBase = class extends RuntimeCore {
 			params: exec.params
 		});
 	}
+	runExecute(exec) {
+		return this.driver.execute({
+			sql: exec.sql,
+			params: exec.params
+		});
+	}
 	/**
 	* SQL pre-compile hook. Runs the registered middleware `beforeCompile` chain over the plan's draft (AST + meta). Returns the original plan unchanged when no middleware rewrote the AST; otherwise returns a new plan carrying the rewritten AST and meta. The AST is the authoritative source of execution metadata, so a rewrite needs no sidecar reconciliation here — the lowering adapter and the encoder both walk the rewritten
 	* AST directly.
 	*/
-	async runBeforeCompile(plan) {
+	runBeforeCompile(plan) {
+		return this.compilePlan(plan, this.sqlCtx);
+	}
+	async compilePlan(plan, middlewareCtx) {
 		const rewrittenDraft = await runBeforeCompileChain(this.middleware, {
 			ast: plan.ast,
 			meta: plan.meta
-		}, this.sqlCtx);
+		}, middlewareCtx);
 		return rewrittenDraft.ast === plan.ast ? plan : {
 			...plan,
 			ast: rewrittenDraft.ast,
 			meta: rewrittenDraft.meta
 		};
 	}
+	query(plan, options) {
+		return this.queryAgainstQueryable(plan, this.driver, options);
+	}
 	execute(plan, options) {
-		return this.executeAgainstQueryable(plan, this.driver, options);
+		return this.executeStatisticsAgainstQueryable(plan, this.driver, options);
 	}
-	executePrepared(ps, params, options) {
-		return this.executePreparedAgainstQueryable(ps, params, this.driver, options);
+	[preparedStatementQuery](ps, params, options) {
+		return this.runPreparedQueryAgainstQueryable(blindCast(ps), params, this.driver, options);
 	}
 	/**
 	* Returns the raw driver connection. The connection is a `SqlQueryable` — SQL
@@ -1287,15 +1307,18 @@ var SqlRuntimeBase = class extends RuntimeCore {
 	acquireRawConnection() {
 		return this.driver.acquireConnection();
 	}
-	async *streamRows(exec, decodeContext, driverCall, codecCtx, execMiddlewareCtx) {
+	async setupDriverExecution(exec) {
 		this.familyAdapter.validatePlan(exec, this.contract);
 		this._telemetry = null;
 		if (this.verifyMarkerPromise === null) this.verifyMarkerPromise = this.verifyMarker();
 		await this.verifyMarkerPromise;
+	}
+	async *streamRows(exec, decodeContext, driverCall, codecCtx, execMiddlewareCtx) {
+		await this.setupDriverExecution(exec);
 		const startedAt = Date.now();
 		let outcome = null;
 		try {
-			const iterator = runWithMiddleware(exec, this.middleware, execMiddlewareCtx, driverCall)[Symbol.asyncIterator]();
+			const iterator = runQueryWithMiddleware(exec, this.middleware, execMiddlewareCtx, driverCall)[Symbol.asyncIterator]();
 			try {
 				while (true) {
 					checkAborted(codecCtx, "stream");
@@ -1314,55 +1337,84 @@ var SqlRuntimeBase = class extends RuntimeCore {
 			if (outcome !== null) this.recordTelemetry(exec, outcome, Date.now() - startedAt);
 		}
 	}
-	/**
-	* Execute a plan against a caller-supplied queryable, running the full
-	* middleware/codec/telemetry pipeline. Use `acquireRawConnection` to obtain a
-	* queryable that subclasses can bind typed plans to.
-	*/
-	executeAgainstQueryable(plan, queryable, options) {
-		this.ensureCodecRegistryValidated();
-		const self = this;
+	createQueryContexts(options) {
 		const signal = options?.signal;
 		const scope = options?.scope ?? "runtime";
-		const codecCtx = signal === void 0 ? {} : { signal };
-		const execMiddlewareCtx = {
-			...self.ctx,
-			...ifDefined("signal", signal),
-			...scope !== "runtime" ? { scope } : {},
-			planExecutionId: crypto.randomUUID()
+		return {
+			codecCtx: signal === void 0 ? {} : { signal },
+			middlewareCtx: {
+				...this.sqlCtx,
+				...ifDefined("signal", signal),
+				...scope !== "runtime" ? { scope } : {},
+				planExecutionId: crypto.randomUUID()
+			}
 		};
-		const generator = async function* () {
-			checkAborted(codecCtx, "stream");
-			let exec;
-			if (isExecutionPlan(plan)) {
-				const preEncodeMutator = createSqlParamRefMutator(plan);
-				await runBeforeExecuteChain(plan, self.middleware, execMiddlewareCtx, preEncodeMutator);
-				exec = Object.freeze({
+	}
+	prepareQueryExecution(plan, codecCtx, middlewareCtx) {
+		return this.prepareOperation(plan, codecCtx, middlewareCtx, runBeforeQueryChain);
+	}
+	prepareExecuteExecution(plan, codecCtx, middlewareCtx) {
+		return this.prepareOperation(plan, codecCtx, middlewareCtx, runBeforeExecuteChain);
+	}
+	async prepareOperation(plan, codecCtx, middlewareCtx, runBefore) {
+		checkAborted(codecCtx, "stream");
+		if (isExecutionPlan(plan)) {
+			const mutator = createSqlParamRefMutator(plan);
+			await runBefore(plan, this.middleware, middlewareCtx, mutator);
+			return Object.freeze({
+				...plan,
+				params: await encodeParams({
 					...plan,
-					params: await encodeParams({
-						...plan,
-						params: preEncodeMutator.currentParams()
-					}, codecCtx, self.contractCodecs)
-				});
-			} else {
-				const compiled = await self.runBeforeCompile(plan);
-				const draft = self.lowerToDraft(compiled);
-				const preEncodeMutator = createSqlParamRefMutator(draft);
-				await runBeforeExecuteChain(draft, self.middleware, execMiddlewareCtx, preEncodeMutator);
-				const draftWithMutations = Object.freeze({
-					...draft,
-					params: preEncodeMutator.currentParams()
-				});
-				exec = await self.encodeDraftParams(draftWithMutations, codecCtx);
-			}
+					params: mutator.currentParams()
+				}, codecCtx, this.contractCodecs)
+			});
+		}
+		const compiled = await this.compilePlan(plan, middlewareCtx);
+		const draft = this.lowerToDraft(compiled);
+		const mutator = createSqlParamRefMutator(draft);
+		await runBefore(draft, this.middleware, middlewareCtx, mutator);
+		const draftWithMutations = Object.freeze({
+			...draft,
+			params: mutator.currentParams()
+		});
+		return this.encodeDraftParams(draftWithMutations, codecCtx);
+	}
+	/** Query rows against a caller-supplied queryable through the shared preparation pipeline. */
+	queryAgainstQueryable(plan, queryable, options) {
+		this.ensureCodecRegistryValidated();
+		const self = this;
+		const { codecCtx, middlewareCtx } = this.createQueryContexts(options);
+		const generator = async function* () {
+			const exec = await self.prepareQueryExecution(plan, codecCtx, middlewareCtx);
 			const decodeContext = buildDecodeContext(exec.ast, self.contractCodecs);
 			yield* self.streamRows(exec, decodeContext, () => queryable.query({
 				sql: exec.sql,
 				params: exec.params
-			}), codecCtx, execMiddlewareCtx);
+			}), codecCtx, middlewareCtx);
 		};
 		return new AsyncIterableResult(generator());
 	}
+	/** Execute statistics against a caller-supplied queryable through the shared preparation pipeline. */
+	async executeStatisticsAgainstQueryable(plan, queryable, options) {
+		this.ensureCodecRegistryValidated();
+		const { codecCtx, middlewareCtx } = this.createQueryContexts(options);
+		const exec = await this.prepareExecuteExecution(plan, codecCtx, middlewareCtx);
+		await this.setupDriverExecution(exec);
+		checkAborted(codecCtx, "stream");
+		const startedAt = Date.now();
+		let outcome = "success";
+		try {
+			return await runExecuteWithMiddleware(exec, this.middleware, middlewareCtx, () => queryable.execute({
+				sql: exec.sql,
+				params: exec.params
+			}));
+		} catch (error) {
+			outcome = "runtime-error";
+			throw error;
+		} finally {
+			this.recordTelemetry(exec, outcome, Date.now() - startedAt);
+		}
+	}
 	async prepare(declaration, callback) {
 		this.ensureCodecRegistryValidated();
 		const userPlan = callback(buildBindSiteParams(declaration));
@@ -1387,22 +1439,11 @@ var SqlRuntimeBase = class extends RuntimeCore {
 			paramMetadata
 		}));
 	}
-	/**
-	* Execute a prepared statement against a caller-supplied queryable, running
-	* the full middleware/codec/telemetry pipeline.
-	*/
-	executePreparedAgainstQueryable(ps, userParams, queryable, options) {
+	/** Query prepared rows against a caller-supplied queryable through the full pipeline. */
+	runPreparedQueryAgainstQueryable(ps, userParams, queryable, options) {
 		this.ensureCodecRegistryValidated();
 		const self = this;
-		const signal = options?.signal;
-		const scope = options?.scope ?? "runtime";
-		const codecCtx = signal === void 0 ? {} : { signal };
-		const execMiddlewareCtx = {
-			...self.ctx,
-			...ifDefined("signal", signal),
-			...scope !== "runtime" ? { scope } : {},
-			planExecutionId: crypto.randomUUID()
-		};
+		const { codecCtx, middlewareCtx: execMiddlewareCtx } = this.createQueryContexts(options);
 		const generator = async function* () {
 			checkAborted(codecCtx, "stream");
 			const preEncodeValues = resolvePreparedSlotValues(ps, userParams);
@@ -1413,7 +1454,7 @@ var SqlRuntimeBase = class extends RuntimeCore {
 				meta: ps.meta
 			};
 			const mutator = createSqlParamRefMutator(preEncodeExec);
-			await runBeforeExecuteChain(preEncodeExec, self.middleware, execMiddlewareCtx, mutator);
+			await runBeforeQueryChain(preEncodeExec, self.middleware, execMiddlewareCtx, mutator);
 			const encodedParams = await encodeParamsWithMetadata(mutator.currentParams(), ps.paramMetadata, codecCtx, self.contractCodecs);
 			const exec = {
 				sql: ps.sql,
@@ -1450,14 +1491,20 @@ var SqlRuntimeBase = class extends RuntimeCore {
 			async destroy(reason) {
 				await driverConn.destroy(reason);
 			},
+			query(plan, options) {
+				return self.queryAgainstQueryable(plan, driverConn, {
+					...options,
+					scope: "connection"
+				});
+			},
 			execute(plan, options) {
-				return self.executeAgainstQueryable(plan, driverConn, {
+				return self.executeStatisticsAgainstQueryable(plan, driverConn, {
 					...options,
 					scope: "connection"
 				});
 			},
-			executePrepared(ps, params, options) {
-				return self.executePreparedAgainstQueryable(ps, params, driverConn, {
+			[preparedStatementQuery](ps, params, options) {
+				return self.runPreparedQueryAgainstQueryable(blindCast(ps), params, driverConn, {
 					...options,
 					scope: "connection"
 				});
@@ -1473,14 +1520,20 @@ var SqlRuntimeBase = class extends RuntimeCore {
 			async rollback() {
 				await driverTx.rollback();
 			},
+			query(plan, options) {
+				return self.queryAgainstQueryable(plan, driverTx, {
+					...options,
+					scope: "transaction"
+				});
+			},
 			execute(plan, options) {
-				return self.executeAgainstQueryable(plan, driverTx, {
+				return self.executeStatisticsAgainstQueryable(plan, driverTx, {
 					...options,
 					scope: "transaction"
 				});
 			},
-			executePrepared(ps, params, options) {
-				return self.executePreparedAgainstQueryable(ps, params, driverTx, {
+			[preparedStatementQuery](ps, params, options) {
+				return self.runPreparedQueryAgainstQueryable(blindCast(ps), params, driverTx, {
 					...options,
 					scope: "transaction"
 				});
@@ -1543,7 +1596,7 @@ var SqlRuntimeBase = class extends RuntimeCore {
 	}
 };
 function transactionClosedError() {
-	return runtimeError("RUNTIME.TRANSACTION_CLOSED", "Cannot read from a query result after the transaction has ended. Await the result or call .toArray() inside the transaction callback.", {});
+	return runtimeError("RUNTIME.TRANSACTION_CLOSED", "Cannot use a transaction operation after the transaction has ended. Consume query results and await execute calls inside the transaction callback.", {});
 }
 async function withTransaction(runtime, fn) {
 	const connection = await runtime.connection();
@@ -1560,13 +1613,17 @@ async function withTransaction(runtime, fn) {
 		get invalidated() {
 			return invalidated;
 		},
-		execute(plan, options) {
+		query(plan, options) {
+			if (invalidated) throw transactionClosedError();
+			return new AsyncIterableResult(guardedStream(transaction.query(plan, options)));
+		},
+		async execute(plan, options) {
 			if (invalidated) throw transactionClosedError();
-			return new AsyncIterableResult(guardedStream(transaction.execute(plan, options)));
+			return transaction.execute(plan, options);
 		},
-		executePrepared(ps, params, options) {
+		[preparedStatementQuery](ps, params, options) {
 			if (invalidated) throw transactionClosedError();
-			return new AsyncIterableResult(guardedStream(transaction.executePrepared(ps, params, options)));
+			return new AsyncIterableResult(guardedStream(runPreparedQuery(transaction, ps, params, options)));
 		}
 	};
 	let connectionDisposed = false;