@prisma/orm-family-sql 8.0.0-rc.17-dev.26 → 8.0.0-rc.17-dev.28

package/dist/runtime.mjs

@@ -4,7 +4,7 @@ import { t as collectOrderedParamRefs } from "./util-BBgcP3gI-XJBkxo1K.mjs";
 import { t as createSqlParamRefMutator } from "./middleware-yBAfiVWn-CzNCthJT.mjs";
 import { t as buildSqlAggregateDescriptorRegistry } from "./aggregate-descriptor-registry-DrJ1vHEo.mjs";
 import { t as buildCodecDescriptorRegistry } from "./codec-descriptor-registry-CYK0Wzja.mjs";
-import { i as runPreparedQuery, n as preparedStatementQuery, r as runPreparedExecute, t as preparedStatementExecute } from "./prepared-query-BJr50wPm-ChoqfJbX.mjs";
+import { a as runPreparedQuery, c as transactionStart, i as runPreparedExecute, l as wasRefusedBeforeBegin, n as preparedStatementExecute, o as settlementOf, r as preparedStatementQuery, s as transactionSettlement, t as createTransactionStart } from "./transaction-state-BfXhs7D7-3k10jZ8I.mjs";
 import { isStructuredError, structuredError } from "@prisma/orm-framework/utils/structured-error";
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
 import { createHash } from "node:crypto";
@@ -13,11 +13,11 @@ import { blindCast } 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, onQueryEndOutsideTransaction, raceAgainstAbort, reportExecuteEnding, reportQueryEnding, runBeforeExecuteChain, runBeforeQueryChain, runExecuteWithMiddleware, runQueryWithMiddleware, runtimeError as runtimeError$1 } from "@prisma/orm-framework/components/runtime";
+import { AsyncIterableResult, RuntimeCore, applyMutationDefaults, assertMutationDefaultGeneratorsAvailable, checkAborted, checkMiddlewareCompatibility, collectMutationDefaultGenerators, createStateStore, executeStatement, raceAgainstAbort, runtimeError as runtimeError$1, startTransactionActivity, streamStatement } 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-Dkz8HVrQ.mjs
+//#region ../../../2-sql/5-runtime/dist/exports-BxFmkVE5.mjs
 /**
 * Build an {@link AstCodecResolver} bound to a descriptor registry and a per-call instance-context factory.
 *
@@ -216,6 +216,7 @@ function emitBudgetViolation(error, shouldBlock, ctx) {
 		details: error.details
 	});
 }
+const observedRows = Symbol("budgets.observedRows");
 function budgets(options) {
 	const maxRows = options?.maxRows ?? 1e4;
 	const defaultTableRows = options?.defaultTableRows ?? 1e4;
@@ -223,39 +224,38 @@ function budgets(options) {
 	const maxLatencyMs = options?.maxLatencyMs ?? 1e3;
 	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$1("BUDGET.TIME_EXCEEDED", "Query latency exceeds budget", {
-				latencyMs,
-				maxLatencyMs
-			}), shouldBlock, ctx);
-		}
-	};
 	return Object.freeze({
 		name: "budgets",
 		familyId: "sql",
-		beforeQuery: beforeOperation,
-		beforeExecute: beforeOperation,
-		async onRow(_row, plan, _ctx) {
-			const state = observedRowsByPlan.get(plan);
-			if (!state) return;
-			state.count += 1;
-			if (state.count > maxRows) throw runtimeError$1("BUDGET.ROWS_EXCEEDED", "Observed row count exceeds budget", {
+		async beforeEncode(plan, ctx) {
+			if (isQueryAst(plan.ast) && plan.ast.kind === "select") evaluateSelectAst(plan.ast, ctx);
+		},
+		async onRow(_row, _plan, ctx) {
+			const observed = ctx.state(observedRows);
+			const count = (typeof observed["count"] === "number" ? observed["count"] : 0) + 1;
+			observed["count"] = count;
+			if (count <= maxRows || observed["warned"] === true) return;
+			const shouldBlock = rowSeverity === "error" || ctx.mode === "strict";
+			if (!shouldBlock) observed["warned"] = true;
+			emitBudgetViolation(runtimeError$1("BUDGET.ROWS_EXCEEDED", "Observed row count exceeds budget", {
 				source: "observed",
-				observedRows: state.count,
+				observedRows: count,
 				maxRows
-			});
+			}), shouldBlock, ctx);
 		},
-		afterQuery: afterOperation,
-		afterExecute: afterOperation
+		async activityEnded(_activity, result, ctx) {
+			if (result.kind === "statement") checkLatency(result.latencyMs, ctx);
+		}
 	});
+	function checkLatency(latencyMs, ctx) {
+		if (latencyMs > maxLatencyMs) {
+			const shouldBlock = latencySeverity === "error" || ctx.mode === "strict";
+			emitBudgetViolation(runtimeError$1("BUDGET.TIME_EXCEEDED", "Query latency exceeds budget", {
+				latencyMs,
+				maxLatencyMs
+			}), shouldBlock, ctx);
+		}
+	}
 	function evaluateSelectAst(ast, ctx) {
 		const hasAggNoGroup = hasAggregateWithoutGroupBy(ast);
 		const estimated = estimateRowsFromAst(ast, tableRows, defaultTableRows, hasAggNoGroup);
@@ -455,8 +455,7 @@ function lints(options) {
 	return Object.freeze({
 		name: "lints",
 		familyId: "sql",
-		beforeQuery: beforeOperation,
-		beforeExecute: beforeOperation
+		beforeEncode: beforeOperation
 	});
 }
 var PreparedStatementImpl = class {
@@ -1227,6 +1226,7 @@ var SqlRuntimeBase = class extends RuntimeCore {
 	#refusing = false;
 	#heldQueryables = /* @__PURE__ */ new WeakSet();
 	#preparedStatementHandles = /* @__PURE__ */ new WeakMap();
+	#holdFinishedChildren;
 	#openTransactions = /* @__PURE__ */ new WeakMap();
 	codecRegistryValidated;
 	_telemetry;
@@ -1239,13 +1239,13 @@ var SqlRuntimeBase = class extends RuntimeCore {
 			now: () => Date.now(),
 			log: log ?? noopLog,
 			contentHash: (exec) => computeSqlContentHash(blindCast(exec)),
-			scope: "runtime",
-			planExecutionId: ""
+			scope: "runtime"
 		};
 		super({
 			middleware: middleware ?? [],
 			ctx: sqlCtx
 		});
+		this.#holdFinishedChildren = this.middleware.some((mw) => mw.activityFinalized !== void 0);
 		this.contract = context.contract;
 		this.adapter = adapter;
 		this.driver = driver;
@@ -1267,9 +1267,8 @@ var SqlRuntimeBase = class extends RuntimeCore {
 	* Implementation note: SQL splits lower-then-encode across
 	* {@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
+	* {@link prepareOperation} runs the statement's `beforeEncode` 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` expects. The production
 	* operation methods use the matching split form before driver execution.
@@ -1320,12 +1319,8 @@ var SqlRuntimeBase = class extends RuntimeCore {
 		});
 	}
 	/**
-	* 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.
+	* 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 lowering adapter and the encoder both walk the rewritten AST directly.
 	*/
-	runBeforeCompile(plan) {
-		return this.compilePlan(plan, this.sqlCtx);
-	}
 	async compilePlan(plan, middlewareCtx) {
 		const rewrittenDraft = await runBeforeCompileChain(this.middleware, {
 			ast: plan.ast,
@@ -1374,25 +1369,19 @@ var SqlRuntimeBase = class extends RuntimeCore {
 		if (queryable === this.driver && this.#refusing) throw runtimeClosedError();
 		return this.#inFlight.begin();
 	}
-	scheduleAfterTransaction(queryable, exec, ctx) {
-		const runStage = this.afterTransactionStageFor(exec, ctx);
-		if (runStage === void 0) return void 0;
-		const rememberOnTransaction = this.#openTransactions.get(queryable);
-		return rememberOnTransaction === void 0 ? onQueryEndOutsideTransaction(runStage) : rememberOnTransaction(runStage);
+	parentOf(queryable) {
+		return this.#openTransactions.get(queryable);
 	}
 	getListDecoder() {
 		return sqlNativeArrayListDecoder;
 	}
-	streamRows(exec, createDecodeContext, driverCall, codecCtx, execMiddlewareCtx, queryable, onDriverAnswered) {
-		return reportQueryEnding(this.scheduleAfterTransaction(queryable, exec, execMiddlewareCtx), () => this.streamDecodedRows(exec, createDecodeContext, driverCall, codecCtx, execMiddlewareCtx, queryable, onDriverAnswered));
-	}
-	async *streamDecodedRows(exec, createDecodeContext, driverCall, codecCtx, execMiddlewareCtx, queryable, onDriverAnswered) {
+	async *streamDecodedRows(run, exec, createDecodeContext, driverCall, codecCtx, queryable, onDriverAnswered) {
 		const rowDecodeContext = createDecodeContext();
 		await this.setupDriverExecution(exec, queryable);
 		const startedAt = Date.now();
 		let telemetryOutcome = null;
 		try {
-			const iterator = runQueryWithMiddleware(exec, this.middleware, execMiddlewareCtx, driverCall)[Symbol.asyncIterator]();
+			const iterator = run.runQuery(exec, driverCall)[Symbol.asyncIterator]();
 			let answered = false;
 			try {
 				while (true) {
@@ -1418,25 +1407,18 @@ var SqlRuntimeBase = class extends RuntimeCore {
 		const scope = options?.scope ?? "runtime";
 		return {
 			codecCtx: signal === void 0 ? {} : { signal },
-			middlewareCtx: {
+			contextFields: {
 				...this.sqlCtx,
 				...ifDefined("signal", signal),
-				...scope !== "runtime" ? { scope } : {},
-				planExecutionId: crypto.randomUUID()
+				...scope !== "runtime" ? { scope } : {}
 			}
 		};
 	}
-	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) {
+	async prepareOperation(plan, codecCtx, run) {
 		checkAborted(codecCtx, "stream");
 		if (isExecutionPlan(plan)) {
 			const mutator = createSqlParamRefMutator(plan);
-			await runBefore(plan, this.middleware, middlewareCtx, mutator);
+			await run.beforeEncode(plan, mutator);
 			return Object.freeze({
 				...plan,
 				params: await encodeParams({
@@ -1445,10 +1427,10 @@ var SqlRuntimeBase = class extends RuntimeCore {
 				}, codecCtx, this.contractCodecs)
 			});
 		}
-		const compiled = await this.compilePlan(plan, middlewareCtx);
+		const compiled = await this.compilePlan(plan, run.ctx);
 		const draft = this.lowerToDraft(compiled);
 		const mutator = createSqlParamRefMutator(draft);
-		await runBefore(draft, this.middleware, middlewareCtx, mutator);
+		await run.beforeEncode(draft, mutator);
 		const draftWithMutations = Object.freeze({
 			...draft,
 			params: mutator.currentParams()
@@ -1459,15 +1441,22 @@ var SqlRuntimeBase = class extends RuntimeCore {
 	queryAgainstQueryable(plan, queryable, options) {
 		this.ensureCodecRegistryValidated();
 		const self = this;
-		const { codecCtx, middlewareCtx } = this.createQueryContexts(options);
+		const { codecCtx, contextFields } = this.createQueryContexts(options);
 		const generator = async function* () {
 			const endOperation = self.beginOperation(queryable);
 			try {
-				const exec = await self.prepareQueryExecution(plan, codecCtx, middlewareCtx);
-				yield* self.streamRows(exec, () => buildDecodeContext(exec.ast, self.contractCodecs), () => queryable.query({
-					sql: exec.sql,
-					params: exec.params
-				}), codecCtx, middlewareCtx, queryable, endOperation);
+				yield* streamStatement({
+					middleware: self.middleware,
+					plan,
+					context: contextFields,
+					parent: self.parentOf(queryable)
+				}, async function* (run) {
+					const exec = await self.prepareOperation(plan, codecCtx, run);
+					yield* self.streamDecodedRows(run, exec, () => buildDecodeContext(exec.ast, self.contractCodecs), () => queryable.query({
+						sql: exec.sql,
+						params: exec.params
+					}), codecCtx, queryable, endOperation);
+				});
 			} finally {
 				endOperation();
 			}
@@ -1485,33 +1474,41 @@ var SqlRuntimeBase = class extends RuntimeCore {
 	}
 	async executeStatisticsInFlight(plan, queryable, options) {
 		this.ensureCodecRegistryValidated();
-		const { codecCtx, middlewareCtx } = this.createQueryContexts(options);
-		const exec = await this.prepareExecuteExecution(plan, codecCtx, middlewareCtx);
-		return this.executeEncodedPlan(exec, queryable, codecCtx, middlewareCtx, () => queryable.execute({
-			sql: exec.sql,
-			params: exec.params
-		}));
-	}
-	executeEncodedPlan(exec, queryable, codecCtx, middlewareCtx, driverCall) {
-		return reportExecuteEnding(this.scheduleAfterTransaction(queryable, exec, middlewareCtx), async () => {
-			await this.setupDriverExecution(exec, queryable);
-			checkAborted(codecCtx, "stream");
-			const startedAt = Date.now();
-			let telemetryOutcome = "success";
-			try {
-				return await runExecuteWithMiddleware(exec, this.middleware, middlewareCtx, driverCall);
-			} catch (error) {
-				telemetryOutcome = "runtime-error";
-				throw error;
-			} finally {
-				this.recordTelemetry(exec, telemetryOutcome, Date.now() - startedAt);
-			}
+		const { codecCtx, contextFields } = this.createQueryContexts(options);
+		return this.executeOn(queryable, plan, contextFields, async (run) => {
+			const exec = await this.prepareOperation(plan, codecCtx, run);
+			return this.executeEncodedPlan(run, exec, queryable, codecCtx, () => queryable.execute({
+				sql: exec.sql,
+				params: exec.params
+			}));
 		});
 	}
+	executeOn(queryable, plan, context, body) {
+		return executeStatement({
+			middleware: this.middleware,
+			plan,
+			context,
+			parent: this.parentOf(queryable)
+		}, body);
+	}
+	async executeEncodedPlan(run, exec, queryable, codecCtx, driverCall) {
+		await this.setupDriverExecution(exec, queryable);
+		checkAborted(codecCtx, "stream");
+		const startedAt = Date.now();
+		let telemetryOutcome = "success";
+		try {
+			return await run.runExecute(exec, driverCall);
+		} catch (error) {
+			telemetryOutcome = "runtime-error";
+			throw error;
+		} finally {
+			this.recordTelemetry(exec, telemetryOutcome, Date.now() - startedAt);
+		}
+	}
 	async prepare(declaration, callback) {
 		this.ensureCodecRegistryValidated();
 		const userPlan = callback(buildBindSiteParams(declaration));
-		const finalPlan = await this.runBeforeCompile(userPlan);
+		const finalPlan = await this.compilePlan(userPlan, standaloneContext(this.sqlCtx));
 		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);
@@ -1537,18 +1534,23 @@ var SqlRuntimeBase = class extends RuntimeCore {
 	runPreparedQueryAgainstQueryable(ps, userParams, queryable, options) {
 		this.ensureCodecRegistryValidated();
 		const self = this;
-		const { codecCtx, middlewareCtx: execMiddlewareCtx } = this.createQueryContexts(options);
+		const { codecCtx, contextFields } = this.createQueryContexts(options);
 		const generator = async function* () {
 			const endOperation = self.beginOperation(queryable);
 			try {
-				yield* self.streamPreparedRows(ps, userParams, queryable, codecCtx, execMiddlewareCtx, endOperation);
+				yield* streamStatement({
+					middleware: self.middleware,
+					plan: ps,
+					context: contextFields,
+					parent: self.parentOf(queryable)
+				}, (run) => self.streamPreparedRows(run, ps, userParams, queryable, codecCtx, endOperation));
 			} finally {
 				endOperation();
 			}
 		};
 		return new AsyncIterableResult(generator());
 	}
-	async *streamPreparedRows(ps, userParams, queryable, codecCtx, execMiddlewareCtx, onDriverAnswered) {
+	async *streamPreparedRows(run, ps, userParams, queryable, codecCtx, onDriverAnswered) {
 		checkAborted(codecCtx, "stream");
 		const preEncodeValues = resolvePreparedSlotValues(ps, userParams);
 		const preEncodeExec = {
@@ -1558,7 +1560,7 @@ var SqlRuntimeBase = class extends RuntimeCore {
 			meta: ps.meta
 		};
 		const mutator = createSqlParamRefMutator(preEncodeExec);
-		await runBeforeQueryChain(preEncodeExec, this.middleware, execMiddlewareCtx, mutator);
+		await run.beforeEncode(preEncodeExec, mutator);
 		const encodedParams = await encodeParamsWithMetadata(mutator.currentParams(), ps.paramMetadata, codecCtx, this.contractCodecs);
 		const exec = {
 			sql: ps.sql,
@@ -1577,7 +1579,7 @@ var SqlRuntimeBase = class extends RuntimeCore {
 				}
 			}
 		};
-		yield* this.streamRows(exec, () => ps.decodeContext, () => queryable.query(request), codecCtx, execMiddlewareCtx, queryable, onDriverAnswered);
+		yield* this.streamDecodedRows(run, exec, () => ps.decodeContext, () => queryable.query(request), codecCtx, queryable, onDriverAnswered);
 	}
 	/** Execute a prepared statement's statistics against a caller-supplied queryable through the full pipeline. */
 	async runPreparedExecuteAgainstQueryable(ps, userParams, queryable, options) {
@@ -1590,7 +1592,10 @@ var SqlRuntimeBase = class extends RuntimeCore {
 	}
 	async runPreparedExecuteInFlight(ps, userParams, queryable, options) {
 		this.ensureCodecRegistryValidated();
-		const { codecCtx, middlewareCtx } = this.createQueryContexts(options);
+		const { codecCtx, contextFields } = this.createQueryContexts(options);
+		return this.executeOn(queryable, ps, contextFields, (run) => this.executePrepared(run, ps, userParams, queryable, codecCtx));
+	}
+	async executePrepared(run, ps, userParams, queryable, codecCtx) {
 		checkAborted(codecCtx, "stream");
 		const preEncodeValues = resolvePreparedSlotValues(ps, userParams);
 		const preEncodeExec = {
@@ -1600,7 +1605,7 @@ var SqlRuntimeBase = class extends RuntimeCore {
 			meta: ps.meta
 		};
 		const mutator = createSqlParamRefMutator(preEncodeExec);
-		await runBeforeExecuteChain(preEncodeExec, this.middleware, middlewareCtx, mutator);
+		await run.beforeEncode(preEncodeExec, mutator);
 		const exec = {
 			sql: ps.sql,
 			params: await encodeParamsWithMetadata(mutator.currentParams(), ps.paramMetadata, codecCtx, this.contractCodecs),
@@ -1618,7 +1623,7 @@ var SqlRuntimeBase = class extends RuntimeCore {
 				}
 			}
 		};
-		return this.executeEncodedPlan(exec, queryable, codecCtx, middlewareCtx, () => queryable.execute(request));
+		return this.executeEncodedPlan(run, exec, queryable, codecCtx, () => queryable.execute(request));
 	}
 	async connection() {
 		const endOperation = this.beginOperation(this.driver);
@@ -1630,11 +1635,10 @@ var SqlRuntimeBase = class extends RuntimeCore {
 		}
 		this.#heldQueryables.add(driverConn);
 		const self = this;
-		return {
-			async transaction() {
-				const driverTx = await self.#inFlight.track(() => driverConn.beginTransaction());
-				self.#heldQueryables.add(driverTx);
-				return self.wrapTransaction(driverTx, driverConn);
+		const wrappedConnection = {
+			[transactionStart]: createTransactionStart(),
+			transaction() {
+				return self.beginTransactionOn(driverConn, wrappedConnection);
 			},
 			async release() {
 				await self.#inFlight.track(() => driverConn.release());
@@ -1667,33 +1671,106 @@ var SqlRuntimeBase = class extends RuntimeCore {
 				});
 			}
 		};
+		return wrappedConnection;
 	}
 	/**
-	* Wraps a driver transaction so every query run on it passes through the runtime with `scope: 'transaction'`, and fires each query's `afterTransaction` stage once when the transaction ends. `connection` is the connection `driverTx` was begun on. A query sent on it, or on the transaction, from now until `commit()` or `rollback()` is called runs inside the transaction, so its stage also fires when the transaction ends. A subclass that begins a driver transaction itself returns it through this wrapper. A transaction a subclass wraps reads the contract marker through the driver; only the connections and transactions this class hands out read it through themselves.
+	* 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.
 	*/
-	wrapTransaction(driverTx, connection) {
-		const remembered = this.anyMiddlewareDeclaresAfterTransaction ? this.rememberQueriesUntilEnd([driverTx, connection]) : void 0;
+	async beginTransactionOn(connection, owner) {
+		owner[transactionStart].refusedBeforeBegin = false;
+		let activity;
+		try {
+			activity = await startTransactionActivity({
+				middleware: this.middleware,
+				context: {
+					...this.sqlCtx,
+					scope: "transaction"
+				},
+				holdFinishedChildren: this.#holdFinishedChildren
+			});
+		} catch (error) {
+			owner[transactionStart].refusedBeforeBegin = true;
+			throw error;
+		}
+		let driverTx;
+		try {
+			driverTx = await this.#inFlight.track(() => connection.beginTransaction());
+		} catch (error) {
+			await activity.end({
+				by: "rollback",
+				outcome: "failed",
+				commitAttempted: false
+			});
+			throw error;
+		}
+		if (this.#heldQueryables.has(connection)) this.#heldQueryables.add(driverTx);
+		return this.wrapTransaction(driverTx, connection, activity);
+	}
+	wrapTransaction(driverTx, connection, activity) {
+		this.#openTransactions.set(driverTx, activity);
+		this.#openTransactions.set(connection, activity);
+		const stopAdopting = () => {
+			for (const queryable of [driverTx, connection]) if (this.#openTransactions.get(queryable) === activity) this.#openTransactions.delete(queryable);
+		};
 		let commitAttempted = false;
+		const settlement = {
+			committed: false,
+			rolledBack: false,
+			logDroppedError(error) {
+				try {
+					activity.ctx.log.error({
+						event: "middleware.activityEnded.error",
+						error
+					});
+				} catch {}
+			}
+		};
+		let commitEnding;
 		const self = this;
 		return {
+			[transactionSettlement]: settlement,
 			async commit() {
 				commitAttempted = true;
-				remembered?.stopRemembering();
+				stopAdopting();
 				try {
 					await self.#inFlight.track(() => driverTx.commit());
 				} catch (error) {
-					await remembered?.end("unknown");
+					await activity.end({
+						by: "commit",
+						outcome: "failed"
+					});
 					throw error;
 				}
-				await remembered?.end("committed");
+				settlement.committed = true;
+				commitEnding = activity.end({
+					by: "commit",
+					outcome: "succeeded"
+				});
+				await commitEnding;
 			},
 			async rollback() {
-				remembered?.stopRemembering();
+				stopAdopting();
+				if (settlement.committed) {
+					await commitEnding?.catch(() => void 0);
+					return;
+				}
+				if (settlement.rolledBack) return;
 				try {
 					await self.#inFlight.track(() => driverTx.rollback());
-				} finally {
-					await remembered?.end(commitAttempted ? "unknown" : "rolled-back");
+				} catch (error) {
+					await activity.end({
+						by: "rollback",
+						outcome: "failed",
+						commitAttempted
+					});
+					throw error;
 				}
+				settlement.rolledBack = true;
+				await activity.end({
+					by: "rollback",
+					outcome: "succeeded",
+					commitAttempted
+				});
 			},
 			query(plan, options) {
 				return self.queryAgainstQueryable(plan, driverTx, {
@@ -1721,26 +1798,6 @@ var SqlRuntimeBase = class extends RuntimeCore {
 			}
 		};
 	}
-	rememberQueriesUntilEnd(queryables) {
-		const awaitingTransactionEnd = [];
-		let aQueryFailed = false;
-		const remember = (runStage) => {
-			awaitingTransactionEnd.push(runStage);
-			return async (ending) => {
-				if (ending === "failed") aQueryFailed = true;
-			};
-		};
-		for (const queryable of queryables) this.#openTransactions.set(queryable, remember);
-		return {
-			stopRemembering: () => {
-				for (const queryable of queryables) if (this.#openTransactions.get(queryable) === remember) this.#openTransactions.delete(queryable);
-			},
-			end: async (outcome) => {
-				const reported = outcome === "committed" && aQueryFailed ? "unknown" : outcome;
-				for (const runStage of awaitingTransactionEnd.splice(0)) await runStage({ outcome: reported });
-			}
-		};
-	}
 	telemetry() {
 		return this._telemetry;
 	}
@@ -1811,12 +1868,27 @@ var SqlRuntimeBase = class extends RuntimeCore {
 		});
 	}
 };
+function standaloneContext(fields) {
+	return {
+		...fields,
+		parent: void 0,
+		state: createStateStore().state,
+		inTransaction: () => false
+	};
+}
 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.", {});
 }
 async function withTransaction(runtime, fn) {
 	const connection = await runtime.connection();
-	const transaction = await connection.transaction();
+	let transaction;
+	try {
+		transaction = await connection.transaction();
+	} catch (error) {
+		if (wasRefusedBeforeBegin(connection)) await connection.release().catch(() => void 0);
+		else await connection.destroy(error).catch(() => void 0);
+		throw error;
+	}
 	let invalidated = false;
 	async function* guardedStream(inner) {
 		if (invalidated) throw transactionClosedError();
@@ -1860,6 +1932,11 @@ async function withTransaction(runtime, fn) {
 			try {
 				await transaction.rollback();
 			} catch (rollbackError) {
+				const settlement = settlementOf(transaction);
+				if (settlement?.rolledBack === true) {
+					settlement.logDroppedError(rollbackError);
+					throw error;
+				}
 				await destroyConnection(rollbackError);
 				const wrapped = runtimeError$1("RUNTIME.TRANSACTION_ROLLBACK_FAILED", "Transaction rollback failed after callback error", { rollbackError });
 				wrapped.cause = error;
@@ -1872,10 +1949,13 @@ async function withTransaction(runtime, fn) {
 		try {
 			await transaction.commit();
 		} catch (commitError) {
+			if (settlementOf(transaction)?.committed === true) throw commitError;
 			try {
 				await transaction.rollback();
-			} catch {
-				await destroyConnection(commitError);
+			} catch (rollbackError) {
+				const settlement = settlementOf(transaction);
+				if (settlement?.rolledBack === true) settlement.logDroppedError(rollbackError);
+				else await destroyConnection(commitError);
 			}
 			const wrapped = runtimeError$1("RUNTIME.TRANSACTION_COMMIT_FAILED", "Transaction commit failed", { commitError });
 			wrapped.cause = commitError;