@prisma/orm-family-sql 8.0.0-rc.18-dev.4 → 8.0.0-rc.18-dev.6

package/dist/runtime.mjs

@@ -9,15 +9,44 @@ import { isStructuredError, structuredError } from "@prisma/orm-framework/utils/
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
 import { createHash } from "node:crypto";
 import { materializeCodec, resolveCodecDescriptorOrThrow } from "@prisma/orm-framework/components/codec";
-import { blindCast } from "@prisma/orm-framework/utils/casts";
+import { blindCast, castAs } from "@prisma/orm-framework/utils/casts";
 import { assertNever, isInternalError } from "@prisma/orm-framework/utils/internal-error";
 import { canonicalStringify } from "@prisma/orm-framework/utils/canonical-stringify";
 import { checkContractComponentRequirements, mergeCapabilityMatrices } from "@prisma/orm-framework/components/components";
-import { AsyncIterableResult, RuntimeCore, applyMutationDefaults, assertMutationDefaultGeneratorsAvailable, checkAborted, checkMiddlewareCompatibility, collectMutationDefaultGenerators, createStateStore, executeStatement, raceAgainstAbort, runtimeError as runtimeError$1, startTransactionActivity, streamStatement } from "@prisma/orm-framework/components/runtime";
+import { AsyncIterableResult, RuntimeCore, applyMutationDefaults, assertMutationDefaultGeneratorsAvailable, checkAborted, checkMiddlewareCompatibility, collectMutationDefaultGenerators, createContextBeneath, executeStatement, raceAgainstAbort, runtimeError as runtimeError$1, startClientActivity, startTransactionActivity, streamStatement } from "@prisma/orm-framework/components/runtime";
 import { canonicalizeJson } from "@prisma/orm-framework/components/utils";
+import { invariant } from "@prisma/orm-framework/utils/assertions";
 import { createExecutionStack } from "@prisma/orm-framework/components/execution";
 import { hashContent } from "@prisma/orm-framework/utils/hash-content";
-//#region ../../../2-sql/5-runtime/dist/exports-BxFmkVE5.mjs
+//#region ../../../2-sql/5-runtime/dist/exports-B30eE9m7.mjs
+/** The symbol-keyed member through which a runtime, connection, transaction, `withTransaction` context or activity handle starts activities; user-facing types do not show it. */
+const activitySource = Symbol("activitySource");
+function hasActivitySourceMember(target) {
+	return activitySource in target;
+}
+/** The `activitySource` member of a queryable; `undefined` for a queryable that cannot start activities, such as a test stub. */
+function findActivitySource(target) {
+	return hasActivitySourceMember(target) ? target[activitySource] : void 0;
+}
+function activitySourceOf(target) {
+	const source = findActivitySource(target);
+	invariant(source !== void 0, "The queryable cannot start activities");
+	return source;
+}
+/** An activity source that starts activities on whatever queryable `target()` returns when called, for an object that sends its statements to a queryable it looks up each time. */
+function delegatingActivitySource(target) {
+	return {
+		startActivity: (activity) => startActivityOn(target(), activity),
+		planContentHash: (plan) => planContentHashOn(target(), plan)
+	};
+}
+/** Starts an activity on a queryable through its `activitySource` member. */
+function startActivityOn(target, activity) {
+	return activitySourceOf(target).startActivity(activity);
+}
+function planContentHashOn(target, plan) {
+	return activitySourceOf(target).planContentHash(plan);
+}
 /**
 * Build an {@link AstCodecResolver} bound to a descriptor registry and a per-call instance-context factory.
 *
@@ -794,6 +823,7 @@ function createExecutionContext(options) {
 		queryOperations: queryOperationRegistry,
 		types,
 		rawCodecInferer: stack.adapter.rawCodecInferer,
+		collectionMethods: contributors.flatMap((contributor) => contributor.collectionMethods?.() ?? []),
 		applyMutationDefaults: (options) => applyMutationDefaults(contract.execution, mutationDefaultGeneratorRegistry, options)
 	};
 }
@@ -1084,6 +1114,10 @@ var InFlightOperations = class {
 	get started() {
 		return this.#started;
 	}
+	/** How many operations are in flight. */
+	get count() {
+		return this.#count;
+	}
 	get active() {
 		return this.#count > 0;
 	}
@@ -1117,6 +1151,60 @@ async function runBeforeCompileChain(middleware, initial, ctx) {
 	}
 	return current;
 }
+/**
+* Begins a transaction on a connection the transaction owns. The connection is released once the transaction has committed or rolled back, and destroyed after a failed rollback or a failed start other than a refusal before `BEGIN`. After a failed commit it stays held for the rollback that follows. A release that fails after the transaction settled is passed to `log.error`, and `commit()` or `rollback()` keeps its own outcome.
+*/
+async function beginOwnedTransaction(connection, begin, log) {
+	let transaction;
+	try {
+		transaction = await begin();
+	} catch (error) {
+		if (wasRefusedBeforeBegin(connection)) await connection.release().catch(() => void 0);
+		else await connection.destroy(error).catch(() => void 0);
+		throw error;
+	}
+	let disposed = false;
+	const dispose = async (destroyReason) => {
+		if (disposed) return;
+		disposed = true;
+		if (destroyReason !== void 0) {
+			await connection.destroy(destroyReason.reason).catch(() => void 0);
+			return;
+		}
+		try {
+			await connection.release();
+		} catch (error) {
+			try {
+				log.error({
+					event: "runtime.connection.release.error",
+					error
+				});
+			} catch {}
+		}
+	};
+	return Object.assign(castAs(Object.create(transaction)), {
+		async commit() {
+			try {
+				await transaction.commit();
+			} catch (error) {
+				if (settlementOf(transaction)?.committed === true) await dispose();
+				throw error;
+			}
+			await dispose();
+		},
+		async rollback() {
+			try {
+				await transaction.rollback();
+			} catch (error) {
+				const settlement = settlementOf(transaction);
+				const settled = settlement?.rolledBack === true || settlement?.committed === true;
+				await dispose(settled ? void 0 : { reason: error });
+				throw error;
+			}
+			await dispose();
+		}
+	});
+}
 function normalizeSpec(spec) {
 	if (typeof spec === "string") return {
 		codec: { codecId: spec },
@@ -1223,6 +1311,7 @@ var SqlRuntimeBase = class extends RuntimeCore {
 	closePromise;
 	closeRefusal;
 	#inFlight = new InFlightOperations();
+	#openActivityHandles = 0;
 	#refusing = false;
 	#heldQueryables = /* @__PURE__ */ new WeakSet();
 	#preparedStatementHandles = /* @__PURE__ */ new WeakMap();
@@ -1344,6 +1433,150 @@ var SqlRuntimeBase = class extends RuntimeCore {
 	[preparedStatementExecute](ps, params, options) {
 		return this.runPreparedExecuteAgainstQueryable(blindCast(ps), params, this.driver, options);
 	}
+	[activitySource] = {
+		startActivity: (activity) => this.startActivityOnRoute(this.queryableRoute(this.driver, "runtime", () => void 0, {
+			transaction: (parent) => this.beginOwnedTransactionBeneath(parent),
+			runtimeWork: true
+		}), activity, void 0),
+		planContentHash: (plan) => this.planContentHashFor(plan, "runtime", void 0)
+	};
+	/**
+	* Starts a client activity whose statements and transaction run on `route`, beneath `parent` or, without one, beneath `route.parent()`.
+	*/
+	async startActivityOnRoute(route, activity, parent) {
+		const endWork = route.runtimeWork ? this.beginActivityWork() : () => void 0;
+		let run;
+		try {
+			run = await startClientActivity(activity, {
+				middleware: this.middleware,
+				context: {
+					...this.sqlCtx,
+					scope: route.scope
+				},
+				parent: parent ?? route.parent(),
+				holdFinishedChildren: this.#holdFinishedChildren
+			});
+		} catch (error) {
+			endWork();
+			throw error;
+		}
+		return this.activityHandle(run, route, endWork);
+	}
+	/** The content hash of the statement `plan` would send on a queryable of `scope` beneath `parent`. */
+	async planContentHashFor(plan, scope, parent) {
+		this.ensureCodecRegistryValidated();
+		if (isExecutionPlan(plan)) return computeSqlContentHash(Object.freeze({
+			...plan,
+			params: await encodeParams(plan, {}, this.contractCodecs)
+		}));
+		const compiled = await this.compilePlan(plan, createContextBeneath({
+			...this.sqlCtx,
+			scope
+		}, parent));
+		return computeSqlContentHash(await this.encodeDraftParams(this.lowerToDraft(compiled), {}));
+	}
+	/** An activity route whose statements run on `queryable`. */
+	queryableRoute(queryable, scope, parent, options) {
+		return {
+			scope,
+			parent,
+			...options,
+			query: (plan, executeOptions) => this.queryAgainstQueryable(plan, queryable, {
+				...executeOptions,
+				scope
+			}),
+			execute: (plan, executeOptions) => this.executeStatisticsAgainstQueryable(plan, queryable, {
+				...executeOptions,
+				scope
+			}),
+			preparedQuery: (statement, params, executeOptions) => this.runPreparedQueryAgainstQueryable(statement, params, queryable, {
+				...executeOptions,
+				scope
+			}),
+			preparedExecute: (statement, params, executeOptions) => this.runPreparedExecuteAgainstQueryable(statement, params, queryable, {
+				...executeOptions,
+				scope
+			})
+		};
+	}
+	/** The activity route of a held connection that `owner` wraps: its statements run on `connection`, and its transactions begin there. */
+	connectionRoute(connection, owner) {
+		const openTransaction = this.#openTransactions.get(connection);
+		return this.queryableRoute(connection, "connection", () => openTransaction, {
+			transaction: openTransaction === void 0 ? (parent) => this.beginTransactionBeneathOn(connection, owner, parent) : void 0,
+			runtimeWork: false
+		});
+	}
+	beginTransactionBeneathOn(connection, owner, parent) {
+		const openTransaction = this.#openTransactions.get(connection);
+		if (openTransaction !== void 0) return Promise.reject(transactionAlreadyOpenError(parent, openTransaction));
+		return this.beginTransactionOn(connection, owner, parent);
+	}
+	/** The `activitySource` member of a held connection that `owner()` wraps. */
+	connectionActivitySource(connection, owner) {
+		return {
+			startActivity: (activity) => this.startActivityOnRoute(this.connectionRoute(connection, owner()), activity, void 0),
+			planContentHash: (plan) => this.planContentHashFor(plan, "connection", this.#openTransactions.get(connection))
+		};
+	}
+	activityHandle(run, route, endWork) {
+		const self = this;
+		const beneath = (options) => ({
+			...options,
+			activityParent: run
+		});
+		const beginTransaction = route.transaction;
+		const source = {
+			async startActivity(activity) {
+				run.assertAcceptsChildren();
+				return self.startActivityOnRoute(route, activity, run);
+			},
+			planContentHash(plan) {
+				return self.planContentHashFor(plan, route.scope, run);
+			}
+		};
+		return {
+			...source,
+			[activitySource]: source,
+			activity: run.activity,
+			get intercepted() {
+				return run.intercepted;
+			},
+			query(plan, options) {
+				return rowsBeneath(run, () => route.query(plan, beneath(options)));
+			},
+			async execute(plan, options) {
+				run.assertAcceptsChildren();
+				return route.execute(plan, beneath(options));
+			},
+			[preparedStatementQuery](ps, params, options) {
+				return rowsBeneath(run, () => route.preparedQuery(blindCast(ps), params, beneath(options)));
+			},
+			async [preparedStatementExecute](ps, params, options) {
+				run.assertAcceptsChildren();
+				return route.preparedExecute(blindCast(ps), params, beneath(options));
+			},
+			async end(end) {
+				try {
+					await run.end(end);
+				} finally {
+					endWork();
+				}
+			},
+			...ifDefined("transaction", beginTransaction === void 0 ? void 0 : async () => {
+				run.assertAcceptsChildren();
+				return beginTransaction(run);
+			})
+		};
+	}
+	async beginOwnedTransactionBeneath(parent) {
+		const { driverConnection, connection } = await this.openConnection();
+		return this.ownTransaction(connection, () => this.beginTransactionOn(driverConnection, connection, parent));
+	}
+	/** Begins a transaction with `begin` on a connection the transaction owns; see `beginOwnedTransaction`. */
+	ownTransaction(connection, begin) {
+		return beginOwnedTransaction(connection, begin, this.sqlCtx.log);
+	}
 	/**
 	* Returns the raw driver connection. The connection is a `SqlQueryable` — SQL
 	* issued on it runs below the middleware/codec/telemetry pipeline. It carries
@@ -1365,12 +1598,36 @@ var SqlRuntimeBase = class extends RuntimeCore {
 		}
 		await this.verifyMarkerPromise;
 	}
+	beginActivityWork() {
+		const endOperation = this.beginOperation(this.driver);
+		this.#openActivityHandles++;
+		let ended = false;
+		return () => {
+			if (ended) return;
+			ended = true;
+			this.#openActivityHandles--;
+			endOperation();
+		};
+	}
+	warnWhenWaitingOnlyForActivities(warned) {
+		if (warned.done || this.#openActivityHandles === 0) return;
+		if (this.#inFlight.count !== this.#openActivityHandles) return;
+		warned.done = true;
+		this.sqlCtx.log.warn({
+			event: "runtime.close.waiting-for-activities",
+			openActivities: this.#openActivityHandles
+		});
+	}
 	beginOperation(queryable) {
 		if (queryable === this.driver && this.#refusing) throw runtimeClosedError();
 		return this.#inFlight.begin();
 	}
-	parentOf(queryable) {
-		return this.#openTransactions.get(queryable);
+	parentOf(queryable, options) {
+		const openTransaction = this.#openTransactions.get(queryable);
+		const activityParent = options?.activityParent;
+		if (activityParent === void 0) return openTransaction;
+		if (openTransaction !== void 0 && !activityParent.ctx.inTransaction()) throw activityOutsideTransactionError(activityParent, openTransaction);
+		return activityParent;
 	}
 	getListDecoder() {
 		return sqlNativeArrayListDecoder;
@@ -1449,7 +1706,7 @@ var SqlRuntimeBase = class extends RuntimeCore {
 					middleware: self.middleware,
 					plan,
 					context: contextFields,
-					parent: self.parentOf(queryable)
+					parent: self.parentOf(queryable, options)
 				}, async function* (run) {
 					const exec = await self.prepareOperation(plan, codecCtx, run);
 					yield* self.streamDecodedRows(run, exec, () => buildDecodeContext(exec.ast, self.contractCodecs), () => queryable.query({
@@ -1475,7 +1732,7 @@ var SqlRuntimeBase = class extends RuntimeCore {
 	async executeStatisticsInFlight(plan, queryable, options) {
 		this.ensureCodecRegistryValidated();
 		const { codecCtx, contextFields } = this.createQueryContexts(options);
-		return this.executeOn(queryable, plan, contextFields, async (run) => {
+		return this.executeOn(queryable, options, plan, contextFields, async (run) => {
 			const exec = await this.prepareOperation(plan, codecCtx, run);
 			return this.executeEncodedPlan(run, exec, queryable, codecCtx, () => queryable.execute({
 				sql: exec.sql,
@@ -1483,12 +1740,12 @@ var SqlRuntimeBase = class extends RuntimeCore {
 			}));
 		});
 	}
-	executeOn(queryable, plan, context, body) {
+	executeOn(queryable, options, plan, context, body) {
 		return executeStatement({
 			middleware: this.middleware,
 			plan,
 			context,
-			parent: this.parentOf(queryable)
+			parent: this.parentOf(queryable, options)
 		}, body);
 	}
 	async executeEncodedPlan(run, exec, queryable, codecCtx, driverCall) {
@@ -1508,7 +1765,7 @@ var SqlRuntimeBase = class extends RuntimeCore {
 	async prepare(declaration, callback) {
 		this.ensureCodecRegistryValidated();
 		const userPlan = callback(buildBindSiteParams(declaration));
-		const finalPlan = await this.compilePlan(userPlan, standaloneContext(this.sqlCtx));
+		const finalPlan = await this.compilePlan(userPlan, createContextBeneath(this.sqlCtx, void 0));
 		const orderedRefs = collectOrderedParamRefs(finalPlan.ast);
 		const referencedNames = /* @__PURE__ */ new Set();
 		for (const ref of orderedRefs) if (ref.kind === "prepared-param-ref") referencedNames.add(ref.name);
@@ -1542,7 +1799,7 @@ var SqlRuntimeBase = class extends RuntimeCore {
 					middleware: self.middleware,
 					plan: ps,
 					context: contextFields,
-					parent: self.parentOf(queryable)
+					parent: self.parentOf(queryable, options)
 				}, (run) => self.streamPreparedRows(run, ps, userParams, queryable, codecCtx, endOperation));
 			} finally {
 				endOperation();
@@ -1593,7 +1850,7 @@ var SqlRuntimeBase = class extends RuntimeCore {
 	async runPreparedExecuteInFlight(ps, userParams, queryable, options) {
 		this.ensureCodecRegistryValidated();
 		const { codecCtx, contextFields } = this.createQueryContexts(options);
-		return this.executeOn(queryable, ps, contextFields, (run) => this.executePrepared(run, ps, userParams, queryable, codecCtx));
+		return this.executeOn(queryable, options, ps, contextFields, (run) => this.executePrepared(run, ps, userParams, queryable, codecCtx));
 	}
 	async executePrepared(run, ps, userParams, queryable, codecCtx) {
 		checkAborted(codecCtx, "stream");
@@ -1626,6 +1883,9 @@ var SqlRuntimeBase = class extends RuntimeCore {
 		return this.executeEncodedPlan(run, exec, queryable, codecCtx, () => queryable.execute(request));
 	}
 	async connection() {
+		return (await this.openConnection()).connection;
+	}
+	async openConnection() {
 		const endOperation = this.beginOperation(this.driver);
 		let driverConn;
 		try {
@@ -1638,8 +1898,9 @@ var SqlRuntimeBase = class extends RuntimeCore {
 		const wrappedConnection = {
 			[transactionStart]: createTransactionStart(),
 			transaction() {
-				return self.beginTransactionOn(driverConn, wrappedConnection);
+				return self.beginTransactionOn(driverConn, wrappedConnection, void 0);
 			},
+			[activitySource]: self.connectionActivitySource(driverConn, () => wrappedConnection),
 			async release() {
 				await self.#inFlight.track(() => driverConn.release());
 			},
@@ -1671,12 +1932,15 @@ var SqlRuntimeBase = class extends RuntimeCore {
 				});
 			}
 		};
-		return wrappedConnection;
+		return {
+			driverConnection: driverConn,
+			connection: wrappedConnection
+		};
 	}
 	/**
 	* Begins a transaction on `connection`, which `owner` wraps, as a transaction activity. When the transaction's `activityStarted` hooks refuse the start, no `BEGIN` is sent, `owner` is recorded as clean, and `withTransaction` releases it; after any other start failure it destroys it. The transaction's `activityStarted` hooks run before `BEGIN`. Every statement sent on the transaction, or on `connection`, from the end of `BEGIN` until `commit()` or `rollback()` is called is the transaction's child, and is finalized when the transaction ends, with its outcome. `commit()` and `rollback()` resolve after every finalization hook has run. A subclass that holds its own connection begins its transactions here.
 	*/
-	async beginTransactionOn(connection, owner) {
+	async beginTransactionOn(connection, owner, parent) {
 		owner[transactionStart].refusedBeforeBegin = false;
 		let activity;
 		try {
@@ -1686,6 +1950,7 @@ var SqlRuntimeBase = class extends RuntimeCore {
 					...this.sqlCtx,
 					scope: "transaction"
 				},
+				parent,
 				holdFinishedChildren: this.#holdFinishedChildren
 			});
 		} catch (error) {
@@ -1709,7 +1974,8 @@ var SqlRuntimeBase = class extends RuntimeCore {
 	wrapTransaction(driverTx, connection, activity) {
 		this.#openTransactions.set(driverTx, activity);
 		this.#openTransactions.set(connection, activity);
-		const stopAdopting = () => {
+		const stopAcceptingChildren = () => {
+			activity.stopAcceptingChildren();
 			for (const queryable of [driverTx, connection]) if (this.#openTransactions.get(queryable) === activity) this.#openTransactions.delete(queryable);
 		};
 		let commitAttempted = false;
@@ -1731,7 +1997,7 @@ var SqlRuntimeBase = class extends RuntimeCore {
 			[transactionSettlement]: settlement,
 			async commit() {
 				commitAttempted = true;
-				stopAdopting();
+				stopAcceptingChildren();
 				try {
 					await self.#inFlight.track(() => driverTx.commit());
 				} catch (error) {
@@ -1749,7 +2015,7 @@ var SqlRuntimeBase = class extends RuntimeCore {
 				await commitEnding;
 			},
 			async rollback() {
-				stopAdopting();
+				stopAcceptingChildren();
 				if (settlement.committed) {
 					await commitEnding?.catch(() => void 0);
 					return;
@@ -1772,6 +2038,13 @@ var SqlRuntimeBase = class extends RuntimeCore {
 					commitAttempted
 				});
 			},
+			[activitySource]: {
+				startActivity: (clientActivity) => self.startActivityOnRoute(self.queryableRoute(driverTx, "transaction", () => activity, {
+					transaction: void 0,
+					runtimeWork: false
+				}), clientActivity, void 0),
+				planContentHash: (plan) => self.planContentHashFor(plan, "transaction", activity)
+			},
 			query(plan, options) {
 				return self.queryAgainstQueryable(plan, driverTx, {
 					...options,
@@ -1806,16 +2079,19 @@ var SqlRuntimeBase = class extends RuntimeCore {
 		return this.closePromise;
 	}
 	async closeDriverAfterWork() {
-		if (this.closeRefusal === "when-idle") await this.waitForIdleTurn();
+		const warned = { done: false };
+		if (this.closeRefusal === "when-idle") await this.waitForIdleTurn(warned);
 		this.#refusing = true;
+		this.warnWhenWaitingOnlyForActivities(warned);
 		await this.#inFlight.drained();
 		await this.driver.close();
 	}
-	async waitForIdleTurn() {
+	async waitForIdleTurn(warned) {
 		for (;;) {
 			const startedBefore = this.#inFlight.started;
 			await new Promise((resolve) => scheduleTimer(resolve, 0));
 			if (!this.#inFlight.active && this.#inFlight.started === startedBefore) return;
+			this.warnWhenWaitingOnlyForActivities(warned);
 			await this.#inFlight.drained();
 		}
 	}
@@ -1868,13 +2144,25 @@ var SqlRuntimeBase = class extends RuntimeCore {
 		});
 	}
 };
-function standaloneContext(fields) {
-	return {
-		...fields,
-		parent: void 0,
-		state: createStateStore().state,
-		inTransaction: () => false
-	};
+function activityOutsideTransactionError(parent, openTransaction) {
+	return runtimeError$1("RUNTIME.ACTIVITY_OUTSIDE_TRANSACTION", `Work was sent through a '${parent.activity.kind}' activity onto a connection whose open transaction the activity is not part of. Start the activity on the transaction instead.`, {
+		kind: parent.activity.kind,
+		id: parent.activity.id,
+		transactionId: openTransaction.activity.id
+	});
+}
+function transactionAlreadyOpenError(parent, openTransaction) {
+	return runtimeError$1("RUNTIME.TRANSACTION_ALREADY_OPEN", `A transaction is already open on this connection; a '${parent.activity.kind}' activity cannot begin another until it commits or rolls back.`, {
+		kind: parent.activity.kind,
+		id: parent.activity.id,
+		transactionId: openTransaction.activity.id
+	});
+}
+function rowsBeneath(run, rows) {
+	return new AsyncIterableResult((async function* () {
+		run.assertAcceptsChildren();
+		yield* rows();
+	})());
 }
 function transactionClosedError() {
 	return runtimeError$1("RUNTIME.TRANSACTION_CLOSED", "Cannot use a transaction operation after the transaction has ended. Consume query results and await execute calls inside the transaction callback.", {});
@@ -1897,26 +2185,56 @@ async function withTransaction(runtime, fn) {
 			if (invalidated) throw transactionClosedError();
 		}
 	}
+	function guardedQueryable(target) {
+		return {
+			query(plan, options) {
+				if (invalidated) throw transactionClosedError();
+				return new AsyncIterableResult(guardedStream(target.query(plan, options)));
+			},
+			async execute(plan, options) {
+				if (invalidated) throw transactionClosedError();
+				return target.execute(plan, options);
+			},
+			[preparedStatementQuery](ps, params, options) {
+				if (invalidated) throw transactionClosedError();
+				return new AsyncIterableResult(guardedStream(runPreparedQuery(target, ps, params, options)));
+			},
+			[preparedStatementExecute](ps, params, options) {
+				if (invalidated) throw transactionClosedError();
+				return runPreparedExecute(target, ps, params, options);
+			}
+		};
+	}
+	function guardedSource(target) {
+		return {
+			async startActivity(activity) {
+				if (invalidated) throw transactionClosedError();
+				return guardedHandle(await startActivityOn(target, activity));
+			},
+			planContentHash(plan) {
+				return planContentHashOn(target, plan);
+			}
+		};
+	}
+	function guardedHandle(handle) {
+		const source = guardedSource(handle);
+		return {
+			...source,
+			...guardedQueryable(handle),
+			[activitySource]: source,
+			activity: handle.activity,
+			get intercepted() {
+				return handle.intercepted;
+			},
+			end: (end) => handle.end(end)
+		};
+	}
 	const txContext = {
+		...guardedQueryable(transaction),
 		get invalidated() {
 			return invalidated;
 		},
-		query(plan, options) {
-			if (invalidated) throw transactionClosedError();
-			return new AsyncIterableResult(guardedStream(transaction.query(plan, options)));
-		},
-		async execute(plan, options) {
-			if (invalidated) throw transactionClosedError();
-			return transaction.execute(plan, options);
-		},
-		[preparedStatementQuery](ps, params, options) {
-			if (invalidated) throw transactionClosedError();
-			return new AsyncIterableResult(guardedStream(runPreparedQuery(transaction, ps, params, options)));
-		},
-		[preparedStatementExecute](ps, params, options) {
-			if (invalidated) throw transactionClosedError();
-			return runPreparedExecute(transaction, ps, params, options);
-		}
+		[activitySource]: guardedSource(transaction)
 	};
 	let connectionDisposed = false;
 	const destroyConnection = async (reason) => {
@@ -1967,6 +2285,6 @@ async function withTransaction(runtime, fn) {
 	}
 }
 //#endregion
-export { PreparedExecutionImpl, PreparedStatementImpl, SqlRuntimeBase, budgets, createAstCodecRegistry, createExecutionContext, createSqlExecutionStack, deriveParamMetadata, encodeParamsWithMetadata, extractCodecIds, lints, lowerSqlPlan, validateCodecRegistryCompleteness, validateContractCodecMappings, withTransaction };
+export { PreparedExecutionImpl, PreparedStatementImpl, SqlRuntimeBase, activitySource, budgets, createAstCodecRegistry, createExecutionContext, createSqlExecutionStack, delegatingActivitySource, deriveParamMetadata, encodeParamsWithMetadata, extractCodecIds, findActivitySource, lints, lowerSqlPlan, planContentHashOn, startActivityOn, validateCodecRegistryCompleteness, validateContractCodecMappings, withTransaction };
 
 //# sourceMappingURL=runtime.mjs.map