@prisma-next/sql-runtime 0.5.0-dev.9 → 0.6.0-dev.1

package/dist/exports-BSTHn_rH.mjs

@@ -0,0 +1,1516 @@
+import { AsyncIterableResult, RuntimeCore, checkAborted, checkMiddlewareCompatibility, isRuntimeError, raceAgainstAbort, runWithMiddleware, runtimeError } from "@prisma-next/framework-components/runtime";
+import { type } from "arktype";
+import { collectOrderedParamRefs, isQueryAst, validateParamRefRefs } from "@prisma-next/sql-relational-core/ast";
+import { ifDefined } from "@prisma-next/utils/defined";
+import { checkContractComponentRequirements } from "@prisma-next/framework-components/components";
+import { createExecutionStack } from "@prisma-next/framework-components/execution";
+import { createSqlOperationRegistry } from "@prisma-next/sql-operations";
+import { buildCodecDescriptorRegistry } from "@prisma-next/sql-relational-core/codec-descriptor-registry";
+import { APP_SPACE_ID } from "@prisma-next/framework-components/control";
+import { createSqlParamRefMutator } from "@prisma-next/sql-relational-core/middleware";
+import { canonicalStringify } from "@prisma-next/utils/canonical-stringify";
+import { hashContent } from "@prisma-next/utils/hash-content";
+import { createHash } from "node:crypto";
+//#region src/codecs/validation.ts
+function extractCodecIds(contract) {
+	const codecIds = /* @__PURE__ */ new Set();
+	for (const table of Object.values(contract.storage.tables)) for (const column of Object.values(table.columns)) {
+		const codecId = column.codecId;
+		codecIds.add(codecId);
+	}
+	return codecIds;
+}
+function extractCodecIdsFromColumns(contract) {
+	const codecIds = /* @__PURE__ */ new Map();
+	for (const [tableName, table] of Object.entries(contract.storage.tables)) for (const [columnName, column] of Object.entries(table.columns)) {
+		const codecId = column.codecId;
+		const key = `${tableName}.${columnName}`;
+		codecIds.set(key, codecId);
+	}
+	return codecIds;
+}
+function validateContractCodecMappings(registry, contract) {
+	const codecIds = extractCodecIdsFromColumns(contract);
+	const invalidCodecs = [];
+	for (const [key, codecId] of codecIds.entries()) if (registry.descriptorFor(codecId) === void 0) {
+		const parts = key.split(".");
+		const table = parts[0] ?? "";
+		const column = parts[1] ?? "";
+		invalidCodecs.push({
+			table,
+			column,
+			codecId
+		});
+	}
+	if (invalidCodecs.length > 0) {
+		const details = {
+			contractTarget: contract.target,
+			invalidCodecs
+		};
+		throw runtimeError("RUNTIME.CODEC_MISSING", `Missing codec implementations for column codecIds: ${invalidCodecs.map((c) => `${c.table}.${c.column} (${c.codecId})`).join(", ")}`, details);
+	}
+}
+function validateCodecRegistryCompleteness(registry, contract) {
+	validateContractCodecMappings(registry, contract);
+}
+//#endregion
+//#region src/lower-sql-plan.ts
+/**
+* Lowers a SQL query plan to an executable Plan by calling the adapter's lower method.
+*
+* @param adapter - Adapter to lower AST to SQL
+* @param contract - Contract for lowering context
+* @param queryPlan - SQL query plan from a lane (contains AST, params, meta, but no SQL)
+* @returns Fully executable Plan with SQL string
+*/
+function lowerSqlPlan(adapter, contract, queryPlan) {
+	const lowered = adapter.lower(queryPlan.ast, {
+		contract,
+		params: queryPlan.params
+	});
+	return Object.freeze({
+		sql: lowered.sql,
+		params: lowered.params ?? queryPlan.params,
+		ast: queryPlan.ast,
+		meta: queryPlan.meta
+	});
+}
+//#endregion
+//#region src/marker.ts
+const MetaSchema = type({ "[string]": "unknown" });
+function parseMeta(meta) {
+	if (meta === null || meta === void 0) return {};
+	let parsed;
+	if (typeof meta === "string") try {
+		parsed = JSON.parse(meta);
+	} catch {
+		return {};
+	}
+	else parsed = meta;
+	const result = MetaSchema(parsed);
+	if (result instanceof type.errors) return {};
+	return result;
+}
+const ContractMarkerRowSchema = type({
+	core_hash: "string",
+	profile_hash: "string",
+	"contract_json?": "unknown | null",
+	"canonical_version?": "number | null",
+	"updated_at?": "Date | string",
+	"app_tag?": "string | null",
+	"meta?": "unknown | null",
+	invariants: type("string").array()
+});
+function parseContractMarkerRow(row) {
+	const result = ContractMarkerRowSchema(row);
+	if (result instanceof type.errors) {
+		const messages = result.map((p) => p.message).join("; ");
+		throw new Error(`Invalid contract marker row: ${messages}`);
+	}
+	const updatedAt = result.updated_at ? result.updated_at instanceof Date ? result.updated_at : new Date(result.updated_at) : /* @__PURE__ */ new Date();
+	return {
+		storageHash: result.core_hash,
+		profileHash: result.profile_hash,
+		contractJson: result.contract_json ?? null,
+		canonicalVersion: result.canonical_version ?? null,
+		updatedAt,
+		appTag: result.app_tag ?? null,
+		meta: parseMeta(result.meta),
+		invariants: result.invariants
+	};
+}
+//#endregion
+//#region src/middleware/budgets.ts
+function hasAggregateWithoutGroupBy(ast) {
+	if (ast.groupBy !== void 0) return false;
+	return ast.projection.some((item) => item.expr.kind === "aggregate");
+}
+function primaryTableFromAst(ast) {
+	switch (ast.from.kind) {
+		case "table-source": return ast.from.name;
+		case "derived-table-source": return ast.from.alias;
+		// v8 ignore next 4
+		default: throw new Error(`Unsupported source kind: ${ast.from.kind}`);
+	}
+}
+function estimateRowsFromAst(ast, tableRows, defaultTableRows, hasAggregateWithoutGroup) {
+	if (hasAggregateWithoutGroup) return 1;
+	const tableEstimate = tableRows[primaryTableFromAst(ast)] ?? defaultTableRows;
+	if (ast.limit !== void 0) return Math.min(ast.limit, tableEstimate);
+	return tableEstimate;
+}
+function emitBudgetViolation(error, shouldBlock, ctx) {
+	if (shouldBlock) throw error;
+	ctx.log.warn({
+		code: error.code,
+		message: error.message,
+		details: error.details
+	});
+}
+function budgets(options) {
+	const maxRows = options?.maxRows ?? 1e4;
+	const defaultTableRows = options?.defaultTableRows ?? 1e4;
+	const tableRows = options?.tableRows ?? {};
+	const maxLatencyMs = options?.maxLatencyMs ?? 1e3;
+	const rowSeverity = options?.severities?.rowCount ?? "error";
+	const observedRowsByPlan = /* @__PURE__ */ new WeakMap();
+	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);
+		},
+		async onRow(_row, plan, _ctx) {
+			const state = observedRowsByPlan.get(plan);
+			if (!state) return;
+			state.count += 1;
+			if (state.count > maxRows) throw runtimeError("BUDGET.ROWS_EXCEEDED", "Observed row count exceeds budget", {
+				source: "observed",
+				observedRows: state.count,
+				maxRows
+			});
+		},
+		async afterExecute(_plan, result, ctx) {
+			const latencyMs = result.latencyMs;
+			if (latencyMs > maxLatencyMs) {
+				const shouldBlock = ctx.mode === "strict";
+				emitBudgetViolation(runtimeError("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);
+		const isUnbounded = ast.limit === void 0 && !hasAggNoGroup;
+		const shouldBlock = rowSeverity === "error" || ctx.mode === "strict";
+		if (isUnbounded) {
+			emitBudgetViolation(runtimeError("BUDGET.ROWS_EXCEEDED", "Unbounded SELECT query exceeds budget", estimated >= maxRows ? {
+				source: "ast",
+				estimatedRows: estimated,
+				maxRows
+			} : {
+				source: "ast",
+				maxRows
+			}), shouldBlock, ctx);
+			return;
+		}
+		if (estimated > maxRows) emitBudgetViolation(runtimeError("BUDGET.ROWS_EXCEEDED", "Estimated row count exceeds budget", {
+			source: "ast",
+			estimatedRows: estimated,
+			maxRows
+		}), shouldBlock, ctx);
+	}
+}
+//#endregion
+//#region src/guardrails/raw.ts
+const SELECT_STAR_REGEX = /select\s+\*/i;
+const LIMIT_REGEX = /\blimit\b/i;
+const MUTATION_PREFIX_REGEX = /^(insert|update|delete|create|alter|drop|truncate)\b/i;
+const READ_ONLY_INTENTS = new Set([
+	"read",
+	"report",
+	"readonly"
+]);
+function evaluateRawGuardrails(plan, config) {
+	const lints = [];
+	const budgets = [];
+	const normalized = normalizeWhitespace(plan.sql);
+	const statementType = classifyStatement(normalized);
+	if (statementType === "select") {
+		if (SELECT_STAR_REGEX.test(normalized)) lints.push(createLint("LINT.SELECT_STAR", "error", "Raw SQL plan selects all columns via *", { sql: snippet(plan.sql) }));
+		if (!LIMIT_REGEX.test(normalized)) {
+			const severity = config?.budgets?.unboundedSelectSeverity ?? "error";
+			lints.push(createLint("LINT.NO_LIMIT", "warn", "Raw SQL plan omits LIMIT clause", { sql: snippet(plan.sql) }));
+			budgets.push(createBudget("BUDGET.ROWS_EXCEEDED", severity, "Raw SQL plan is unbounded and may exceed row budget", {
+				sql: snippet(plan.sql),
+				...config?.budgets?.estimatedRows !== void 0 ? { estimatedRows: config.budgets.estimatedRows } : {}
+			}));
+		}
+	}
+	if (isMutationStatement(statementType) && isReadOnlyIntent(plan.meta)) lints.push(createLint("LINT.READ_ONLY_MUTATION", "error", "Raw SQL plan mutates data despite read-only intent", {
+		sql: snippet(plan.sql),
+		intent: plan.meta.annotations?.["intent"]
+	}));
+	return {
+		lints,
+		budgets,
+		statement: statementType
+	};
+}
+function classifyStatement(sql) {
+	const trimmed = sql.trim();
+	const lower = trimmed.toLowerCase();
+	if (lower.startsWith("with")) {
+		if (lower.includes("select")) return "select";
+	}
+	if (lower.startsWith("select")) return "select";
+	if (MUTATION_PREFIX_REGEX.test(trimmed)) return "mutation";
+	return "other";
+}
+function isMutationStatement(statement) {
+	return statement === "mutation";
+}
+function isReadOnlyIntent(meta) {
+	const annotations = meta.annotations;
+	const intent = typeof annotations?.intent === "string" ? annotations.intent.toLowerCase() : void 0;
+	return intent !== void 0 && READ_ONLY_INTENTS.has(intent);
+}
+function normalizeWhitespace(value) {
+	return value.replace(/\s+/g, " ").trim();
+}
+function snippet(sql) {
+	return normalizeWhitespace(sql).slice(0, 200);
+}
+function createLint(code, severity, message, details) {
+	return {
+		code,
+		severity,
+		message,
+		...details ? { details } : {}
+	};
+}
+function createBudget(code, severity, message, details) {
+	return {
+		code,
+		severity,
+		message,
+		...details ? { details } : {}
+	};
+}
+//#endregion
+//#region src/middleware/lints.ts
+function getFromSourceTableDetail(source) {
+	switch (source.kind) {
+		case "table-source": return source.name;
+		case "derived-table-source": return source.alias;
+		// v8 ignore next 4
+		default: throw new Error(`Unsupported source kind: ${source.kind}`);
+	}
+}
+function evaluateAstLints(ast) {
+	const findings = [];
+	switch (ast.kind) {
+		case "delete":
+			if (ast.where === void 0) findings.push({
+				code: "LINT.DELETE_WITHOUT_WHERE",
+				severity: "error",
+				message: "DELETE without WHERE clause blocks execution to prevent accidental full-table deletion",
+				details: { table: ast.table.name }
+			});
+			break;
+		case "update":
+			if (ast.where === void 0) findings.push({
+				code: "LINT.UPDATE_WITHOUT_WHERE",
+				severity: "error",
+				message: "UPDATE without WHERE clause blocks execution to prevent accidental full-table update",
+				details: { table: ast.table.name }
+			});
+			break;
+		case "select":
+			if (ast.limit === void 0) {
+				const table = getFromSourceTableDetail(ast.from);
+				findings.push({
+					code: "LINT.NO_LIMIT",
+					severity: "warn",
+					message: "Unbounded SELECT may return large result sets",
+					...ifDefined("details", table !== void 0 ? { table } : void 0)
+				});
+			}
+			if (ast.selectAllIntent !== void 0) {
+				const table = ast.selectAllIntent.table;
+				findings.push({
+					code: "LINT.SELECT_STAR",
+					severity: "warn",
+					message: "Query selects all columns via selectAll intent",
+					...ifDefined("details", table !== void 0 ? { table } : void 0)
+				});
+			}
+			break;
+		case "insert": break;
+		case "raw-sql": break;
+		// v8 ignore next 2
+		default: throw new Error(`Unsupported AST kind: ${ast.kind}`);
+	}
+	return findings;
+}
+function getConfiguredSeverity(code, options) {
+	const severities = options?.severities;
+	if (!severities) return void 0;
+	switch (code) {
+		case "LINT.SELECT_STAR": return severities.selectStar;
+		case "LINT.NO_LIMIT": return severities.noLimit;
+		case "LINT.DELETE_WITHOUT_WHERE": return severities.deleteWithoutWhere;
+		case "LINT.UPDATE_WITHOUT_WHERE": return severities.updateWithoutWhere;
+		case "LINT.READ_ONLY_MUTATION": return severities.readOnlyMutation;
+		case "LINT.UNINDEXED_PREDICATE": return severities.unindexedPredicate;
+		default: return;
+	}
+}
+/**
+* AST-first lint middleware for SQL plans. When `plan.ast` is a SQL QueryAst, inspects
+* the AST structurally. When `plan.ast` is missing, falls back to raw heuristic
+* guardrails or skips linting depending on `fallbackWhenAstMissing`.
+*
+* Rules (AST-based):
+* - DELETE without WHERE: blocks execution (configurable severity, default error)
+* - UPDATE without WHERE: blocks execution (configurable severity, default error)
+* - Unbounded SELECT: warn/error (severity from noLimit)
+* - SELECT * intent: warn/error (severity from selectStar)
+*
+* Fallback: When ast is missing, `fallbackWhenAstMissing: 'raw'` uses heuristic
+* SQL parsing; `'skip'` skips all lints. Default is `'raw'`.
+*/
+function lints(options) {
+	const fallback = options?.fallbackWhenAstMissing ?? "raw";
+	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
+				});
+			}
+		}
+	});
+}
+//#endregion
+//#region src/sql-context.ts
+function createSqlExecutionStack(options) {
+	return createExecutionStack({
+		target: options.target,
+		adapter: options.adapter,
+		driver: options.driver,
+		extensionPacks: options.extensionPacks
+	});
+}
+function assertExecutionStackContractRequirements(contract, stack) {
+	const providedComponentIds = new Set([
+		stack.target.id,
+		stack.adapter.id,
+		...stack.extensionPacks.map((pack) => pack.id)
+	]);
+	const result = checkContractComponentRequirements({
+		contract,
+		expectedTargetFamily: "sql",
+		expectedTargetId: stack.target.targetId,
+		providedComponentIds
+	});
+	if (result.familyMismatch) throw runtimeError("RUNTIME.CONTRACT_FAMILY_MISMATCH", `Contract target family '${result.familyMismatch.actual}' does not match runtime family '${result.familyMismatch.expected}'.`, {
+		actual: result.familyMismatch.actual,
+		expected: result.familyMismatch.expected
+	});
+	if (result.targetMismatch) throw runtimeError("RUNTIME.CONTRACT_TARGET_MISMATCH", `Contract target '${result.targetMismatch.actual}' does not match runtime target descriptor '${result.targetMismatch.expected}'.`, {
+		actual: result.targetMismatch.actual,
+		expected: result.targetMismatch.expected
+	});
+	if (result.missingExtensionPackIds.length > 0) {
+		const packIds = result.missingExtensionPackIds;
+		throw runtimeError("RUNTIME.MISSING_EXTENSION_PACK", `Contract requires extension pack(s) ${packIds.map((id) => `'${id}'`).join(", ")}, but runtime descriptors do not provide matching component(s).`, { packIds });
+	}
+}
+function validateTypeParams(typeParams, descriptor, context) {
+	const result = descriptor.paramsSchema["~standard"].validate(typeParams);
+	if (result instanceof Promise) throw runtimeError("RUNTIME.TYPE_PARAMS_INVALID", `paramsSchema for codec '${descriptor.codecId}' returned a Promise; runtime validation requires a synchronous Standard Schema validator.`, {
+		...context,
+		codecId: descriptor.codecId,
+		typeParams
+	});
+	if (result.issues) {
+		const messages = result.issues.map((issue) => issue.message).join("; ");
+		throw runtimeError("RUNTIME.TYPE_PARAMS_INVALID", `Invalid typeParams for ${context.typeName ? `type '${context.typeName}'` : `column '${context.tableName}.${context.columnName}'`} (codecId: ${descriptor.codecId}): ${messages}`, {
+			...context,
+			codecId: descriptor.codecId,
+			typeParams
+		});
+	}
+	return result.value;
+}
+/**
+* Collect every {@link CodecDescriptor} contributed by the SQL stack and partition into "parameterized" vs "non-parameterized" via the descriptor's own {@link CodecDescriptorImpl.isParameterized} getter. The getter is the canonical discriminator — a `paramsSchema` identity check would misroute any descriptor that doesn't reuse the exact `voidParamsSchema` singleton (e.g. a non-parameterized codec authoring its own no-op schema).
+*
+* The unified descriptor list collapses the legacy split (a separate slot used to register parameterized codecs) — every codec id resolves through the same map (codec-registry-unification spec § Decision).
+*/
+function collectCodecDescriptors(contributors) {
+	const all = [];
+	const parameterized = /* @__PURE__ */ new Map();
+	const seen = /* @__PURE__ */ new Set();
+	for (const contributor of contributors) for (const descriptor of contributor.codecs()) {
+		if (seen.has(descriptor.codecId)) throw runtimeError("RUNTIME.DUPLICATE_CODEC", `Duplicate codec descriptor for codecId '${descriptor.codecId}'.`, { codecId: descriptor.codecId });
+		seen.add(descriptor.codecId);
+		all.push(descriptor);
+		if (descriptor.isParameterized) parameterized.set(descriptor.codecId, descriptor);
+	}
+	return {
+		all,
+		parameterized
+	};
+}
+function collectTypeRefSites(storage) {
+	const sites = /* @__PURE__ */ new Map();
+	for (const [tableName, table] of Object.entries(storage.tables)) for (const [columnName, column] of Object.entries(table.columns)) {
+		if (typeof column.typeRef !== "string") continue;
+		const list = sites.get(column.typeRef);
+		const entry = {
+			table: tableName,
+			column: columnName
+		};
+		if (list) list.push(entry);
+		else sites.set(column.typeRef, [entry]);
+	}
+	return sites;
+}
+function initializeTypeHelpers(storage, codecDescriptors) {
+	const helpers = {};
+	const storageTypes = storage.types;
+	if (!storageTypes) return helpers;
+	const typeRefSites = collectTypeRefSites(storage);
+	for (const [typeName, typeInstance] of Object.entries(storageTypes)) {
+		const descriptor = codecDescriptors.get(typeInstance.codecId);
+		if (!descriptor) {
+			helpers[typeName] = typeInstance;
+			continue;
+		}
+		const validatedParams = validateTypeParams(typeInstance.typeParams, descriptor, { typeName });
+		const ctx = {
+			name: typeName,
+			usedAt: typeRefSites.get(typeName) ?? []
+		};
+		helpers[typeName] = descriptor.factory(validatedParams)(ctx);
+	}
+	return helpers;
+}
+function validateColumnTypeParams(storage, codecDescriptors) {
+	for (const [tableName, table] of Object.entries(storage.tables)) for (const [columnName, column] of Object.entries(table.columns)) if (column.typeParams) {
+		const descriptor = codecDescriptors.get(column.codecId);
+		if (descriptor) validateTypeParams(column.typeParams, descriptor, {
+			tableName,
+			columnName
+		});
+	}
+}
+function isResolvedCodec(candidate) {
+	return candidate !== null && typeof candidate === "object" && "id" in candidate && "decode" in candidate;
+}
+/**
+* Walk the contract's `storage.tables[].columns[]` and resolve each column to a `Codec` through the unified descriptor map. Per-instance behavior:
+*
+* - **typeRef columns**: reuse the resolved codec materialized once by `initializeTypeHelpers` for the `storage.types` entry. Multiple columns sharing one typeRef share one codec instance.
+* - **inline-typeParams columns**: call `descriptor.factory(typeParams) (ctx)` once per column (per-column anonymous instance).
+* - **non-parameterized columns**: call `descriptor.factory()(ctx)` once. The synthesized descriptor's factory is constant — every call returns the same shared codec instance — so columns sharing a non-parameterized codec id share one resolved codec without explicit caching.
+*
+* Codec-registry-unification spec § AC-4: every column resolves through one descriptor map without branching on parameterization. JSON-Schema validation, when required, lives inside the resolved codec's `decode` body (see `arktype-json`'s `ArktypeJsonCodecClass`); the framework no longer maintains a parallel validator registry.
+*/
+function buildContractCodecRegistry(contract, codecDescriptors, types, parameterizedDescriptors) {
+	const byColumn = /* @__PURE__ */ new Map();
+	const byCodecId = /* @__PURE__ */ new Map();
+	const ambiguousCodecIds = /* @__PURE__ */ new Set();
+	for (const descriptor of codecDescriptors.values()) {
+		if (descriptor.isParameterized) continue;
+		const ctx = {
+			name: `<shared:${descriptor.codecId}>`,
+			usedAt: []
+		};
+		const voidFactory = descriptor.factory;
+		byCodecId.set(descriptor.codecId, voidFactory(void 0)(ctx));
+	}
+	const parameterizedRepresentatives = /* @__PURE__ */ new Map();
+	for (const descriptor of codecDescriptors.values()) {
+		if (!descriptor.isParameterized) continue;
+		const ctx = {
+			name: `<shared:${descriptor.codecId}>`,
+			usedAt: []
+		};
+		const factory = descriptor.factory.bind(descriptor);
+		try {
+			parameterizedRepresentatives.set(descriptor.codecId, factory(void 0)(ctx));
+		} catch {}
+	}
+	for (const [tableName, table] of Object.entries(contract.storage.tables)) for (const [columnName, column] of Object.entries(table.columns)) {
+		const columnKey = `${tableName}.${columnName}`;
+		const descriptor = codecDescriptors.descriptorFor(column.codecId);
+		let resolvedCodec;
+		if (descriptor) {
+			const isParameterized = parameterizedDescriptors.has(column.codecId);
+			if (column.typeRef) {
+				const helper = types[column.typeRef];
+				if (isResolvedCodec(helper)) resolvedCodec = helper;
+			} else if (column.typeParams && isParameterized) {
+				const parameterizedDescriptor = parameterizedDescriptors.get(column.codecId);
+				if (parameterizedDescriptor) {
+					const validatedParams = validateTypeParams(column.typeParams, parameterizedDescriptor, {
+						tableName,
+						columnName
+					});
+					const ctx = {
+						name: `<col:${tableName}.${columnName}>`,
+						usedAt: [{
+							table: tableName,
+							column: columnName
+						}]
+					};
+					resolvedCodec = parameterizedDescriptor.factory(validatedParams)(ctx);
+				}
+			} else if (!isParameterized) {
+				const ctx = {
+					name: `<col:${tableName}.${columnName}>`,
+					usedAt: [{
+						table: tableName,
+						column: columnName
+					}]
+				};
+				resolvedCodec = descriptor.factory.bind(descriptor)(void 0)(ctx);
+			}
+		}
+		if (resolvedCodec) {
+			byColumn.set(columnKey, resolvedCodec);
+			const existing = byCodecId.get(column.codecId);
+			if (existing === void 0) byCodecId.set(column.codecId, resolvedCodec);
+			else if (existing !== resolvedCodec && parameterizedDescriptors.has(column.codecId)) ambiguousCodecIds.add(column.codecId);
+		}
+	}
+	return {
+		forColumn(table, column) {
+			return byColumn.get(`${table}.${column}`);
+		},
+		forCodecId(codecId) {
+			if (ambiguousCodecIds.has(codecId)) throw runtimeError("RUNTIME.TYPE_PARAMS_INVALID", `Codec '${codecId}' resolves to multiple parameterized instances; column-aware dispatch is required.`, { codecId });
+			return byCodecId.get(codecId) ?? parameterizedRepresentatives.get(codecId);
+		}
+	};
+}
+function assertMutationDefaultGeneratorsAvailable(contract, generatorRegistry) {
+	const defaults = contract.execution?.mutations.defaults ?? [];
+	if (defaults.length === 0) return;
+	const missing = /* @__PURE__ */ new Set();
+	for (const mutationDefault of defaults) for (const phase of [mutationDefault.onCreate, mutationDefault.onUpdate]) {
+		if (!phase) continue;
+		if (phase.kind === "generator" && !generatorRegistry.has(phase.id)) missing.add(phase.id);
+	}
+	if (missing.size === 0) return;
+	const ids = Array.from(missing);
+	throw runtimeError("RUNTIME.MISSING_MUTATION_DEFAULT_GENERATOR", `Contract requires mutation default generator(s) ${ids.map((id) => `'${id}'`).join(", ")}, but no runtime component provides them.`, { ids });
+}
+function collectMutationDefaultGenerators(contributors) {
+	const generators = /* @__PURE__ */ new Map();
+	const owners = /* @__PURE__ */ new Map();
+	for (const contributor of contributors) {
+		const nextGenerators = contributor.mutationDefaultGenerators?.() ?? [];
+		for (const generator of nextGenerators) {
+			const existingOwner = owners.get(generator.id);
+			if (existingOwner !== void 0) throw runtimeError("RUNTIME.DUPLICATE_MUTATION_DEFAULT_GENERATOR", `Duplicate mutation default generator '${generator.id}'.`, {
+				id: generator.id,
+				existingOwner,
+				incomingOwner: contributor.id
+			});
+			generators.set(generator.id, generator);
+			owners.set(generator.id, contributor.id);
+		}
+	}
+	return generators;
+}
+function computeExecutionDefaultValue(spec, generatorRegistry) {
+	switch (spec.kind) {
+		case "generator": {
+			const generator = generatorRegistry.get(spec.id);
+			if (!generator) throw runtimeError("RUNTIME.MUTATION_DEFAULT_GENERATOR_MISSING", `Contract references mutation default generator '${spec.id}' but no runtime component provides it.`, { id: spec.id });
+			return generator.generate(spec.params);
+		}
+	}
+}
+function applyMutationDefaults(contract, generatorRegistry, options) {
+	const defaults = contract.execution?.mutations.defaults ?? [];
+	if (defaults.length === 0) return [];
+	const isEmptyUpdate = options.op === "update" && Object.keys(options.values).length === 0;
+	const applied = [];
+	const appliedColumns = /* @__PURE__ */ new Set();
+	const rowCache = /* @__PURE__ */ new Map();
+	for (const mutationDefault of defaults) {
+		if (mutationDefault.ref.table !== options.table) continue;
+		const defaultSpec = options.op === "create" ? mutationDefault.onCreate : mutationDefault.onUpdate;
+		if (!defaultSpec) continue;
+		if (isEmptyUpdate) continue;
+		const columnName = mutationDefault.ref.column;
+		if (Object.hasOwn(options.values, columnName) || appliedColumns.has(columnName)) continue;
+		applied.push({
+			column: columnName,
+			value: resolveScopedValue(defaultSpec, generatorRegistry, rowCache, options.defaultValueCache)
+		});
+		appliedColumns.add(columnName);
+	}
+	return applied;
+}
+function resolveScopedValue(spec, generatorRegistry, rowCache, queryCache) {
+	if (spec.kind !== "generator") return computeExecutionDefaultValue(spec, generatorRegistry);
+	const cache = scopedCache(generatorRegistry.get(spec.id)?.stability, rowCache, queryCache);
+	if (!cache) return computeExecutionDefaultValue(spec, generatorRegistry);
+	if (cache.has(spec.id)) return cache.get(spec.id);
+	const value = computeExecutionDefaultValue(spec, generatorRegistry);
+	cache.set(spec.id, value);
+	return value;
+}
+function scopedCache(stability, rowCache, queryCache) {
+	switch (stability) {
+		case "row": return rowCache;
+		case "query": return queryCache;
+		default: return;
+	}
+}
+function createExecutionContext(options) {
+	const { contract, stack } = options;
+	assertExecutionStackContractRequirements(contract, stack);
+	const contributors = [
+		stack.target,
+		stack.adapter,
+		...stack.extensionPacks
+	];
+	const { all: allCodecDescriptors, parameterized: parameterizedCodecDescriptors } = collectCodecDescriptors(contributors);
+	const queryOperationRegistry = createSqlOperationRegistry();
+	for (const contributor of contributors) {
+		const ops = contributor.queryOperations?.() ?? {};
+		for (const [name, op] of Object.entries(ops)) queryOperationRegistry.register(name, op);
+	}
+	const codecDescriptors = buildCodecDescriptorRegistry(allCodecDescriptors);
+	const mutationDefaultGeneratorRegistry = collectMutationDefaultGenerators(contributors);
+	assertMutationDefaultGeneratorsAvailable(contract, mutationDefaultGeneratorRegistry);
+	if (parameterizedCodecDescriptors.size > 0) validateColumnTypeParams(contract.storage, parameterizedCodecDescriptors);
+	const types = initializeTypeHelpers(contract.storage, parameterizedCodecDescriptors);
+	return {
+		contract,
+		contractCodecs: buildContractCodecRegistry(contract, codecDescriptors, types, parameterizedCodecDescriptors),
+		codecDescriptors,
+		queryOperations: queryOperationRegistry,
+		types,
+		applyMutationDefaults: (options) => applyMutationDefaults(contract, mutationDefaultGeneratorRegistry, options)
+	};
+}
+//#endregion
+//#region src/sql-marker.ts
+const ensureSchemaStatement = {
+	sql: "create schema if not exists prisma_contract",
+	params: []
+};
+/**
+* Schema for `prisma_contract.marker`. The `space text` primary key
+* supports one row per loaded contract space (`'app'`,
+* `'<extension-id>'`, …); brand-new databases create this shape
+* directly. Pre-1.0 single-row markers (no `space` column) are not
+* auto-migrated — the target-specific migration runner detects the
+* legacy shape at boot and surfaces a structured `LEGACY_MARKER_SHAPE`
+* failure pointing the operator at re-running `dbInit`.
+*
+* @see specs/framework-mechanism.spec.md § 2.
+*/
+const ensureTableStatement = {
+	sql: `create table if not exists prisma_contract.marker (
+    space text not null primary key default '${APP_SPACE_ID}',
+    core_hash text not null,
+    profile_hash text not null,
+    contract_json jsonb,
+    canonical_version int,
+    updated_at timestamptz not null default now(),
+    app_tag text,
+    meta jsonb not null default '{}',
+    invariants text[] not null default '{}'
+  )`,
+	params: []
+};
+function readContractMarker(space) {
+	return {
+		sql: `select
+      core_hash,
+      profile_hash,
+      contract_json,
+      canonical_version,
+      updated_at,
+      app_tag,
+      meta,
+      invariants
+    from prisma_contract.marker
+    where space = $1`,
+		params: [space]
+	};
+}
+/**
+* Variable columns that participate in INSERT/UPDATE alongside the
+* always-on `space = $1` and `updated_at = now()`. Each column declares
+* its name, optional cast type, and parameter value; the placeholder
+* (`$N`) is computed positionally below — adding or reordering a
+* column doesn't desync indices. `invariants` only appears when the
+* caller supplies it — see `WriteMarkerInput.invariants`.
+*/
+function markerColumns(input) {
+	return [
+		{
+			name: "core_hash",
+			param: input.storageHash
+		},
+		{
+			name: "profile_hash",
+			param: input.profileHash
+		},
+		{
+			name: "contract_json",
+			type: "jsonb",
+			param: input.contractJson ?? null
+		},
+		{
+			name: "canonical_version",
+			param: input.canonicalVersion ?? null
+		},
+		{
+			name: "app_tag",
+			param: input.appTag ?? null
+		},
+		{
+			name: "meta",
+			type: "jsonb",
+			param: JSON.stringify(input.meta ?? {})
+		},
+		...input.invariants !== void 0 ? [{
+			name: "invariants",
+			type: "text[]",
+			param: input.invariants
+		}] : []
+	];
+}
+function writeContractMarker(input) {
+	const placed = markerColumns(input).map((c, i) => ({
+		name: c.name,
+		expr: c.type ? `$${i + 2}::${c.type}` : `$${i + 2}`,
+		param: c.param
+	}));
+	const params = [input.space, ...placed.map((c) => c.param)];
+	const insertColumns = [
+		"space",
+		...placed.map((c) => c.name),
+		"updated_at"
+	].join(", ");
+	const insertValues = [
+		"$1",
+		...placed.map((c) => c.expr),
+		"now()"
+	].join(", ");
+	const setClauses = [...placed.map((c) => `${c.name} = ${c.expr}`), "updated_at = now()"].join(", ");
+	return {
+		insert: {
+			sql: `insert into prisma_contract.marker (${insertColumns}) values (${insertValues})`,
+			params
+		},
+		update: {
+			sql: `update prisma_contract.marker set ${setClauses} where space = $1`,
+			params
+		}
+	};
+}
+//#endregion
+//#region src/codecs/alias-resolver.ts
+/**
+* Build a map from query-local table aliases to their underlying source table names.
+*
+* Self-joins like `db.sql.post.as('p1').innerJoin(db.sql.post.as('p2'), …)` produce `ColumnRef`s whose `table` is the alias (`p1`, `p2`) — the SQL renderer needs the alias for `SELECT p1.id, …`. Codec dispatch keys `byColumn` by the underlying source table, so aliases must be resolved back to the source name for `forColumn(...)` to hit. Tables that already use their canonical name (no alias) are also entered so a single
+* lookup works for both shapes.
+*/
+function buildAliasMap(ast) {
+	const aliases = /* @__PURE__ */ new Map();
+	const recordSource = (source) => {
+		if (source.kind === "table-source") {
+			const key = source.alias ?? source.name;
+			aliases.set(key, source.name);
+		} else aliases.set(source.alias, source.alias);
+	};
+	if (ast.kind === "select") {
+		recordSource(ast.from);
+		for (const join of ast.joins ?? []) recordSource(join.source);
+	} else if (ast.kind === "raw-sql") {} else recordSource(ast.table);
+	return aliases;
+}
+function makeAliasResolver(ast) {
+	if (!ast) return (alias) => alias;
+	const map = buildAliasMap(ast);
+	return (alias) => map.get(alias) ?? alias;
+}
+//#endregion
+//#region src/codecs/decoding.ts
+const WIRE_PREVIEW_LIMIT = 100;
+const EMPTY_INCLUDE_ALIASES = /* @__PURE__ */ new Set();
+function isAstBackedPlan(plan) {
+	return plan.ast !== void 0;
+}
+function projectionListFromAst(ast) {
+	if (ast.kind === "select") return ast.projection;
+	if (ast.kind === "raw-sql") return;
+	return ast.returning;
+}
+/**
+* Resolve the per-cell codec for a projection item.
+*
+* When a `(table, column)` ref is available — either implicit on a `column-ref` expression or carried explicitly via `item.refs` for column-bound non-`column-ref` projections — prefer `contractCodecs.forColumn(table, column)`: that returns the per-instance codec materialized from the descriptor's factory for that column, encoding any per-instance state (typeParams like vector length, schema validators, etc.).
+*
+* The wrong-instance risk for parameterized codecs is closed off structurally:
+*
+* 1. `buildContractCodecRegistry` pre-populates `byCodecId` with one canonical instance per non-parameterized descriptor; parameterized descriptors are intentionally absent. 2. `forCodecId` rejects ambiguous parameterized fallbacks (`ambiguousCodecIds`). 3. The non-ambiguous parameterized case stores the column-correct per-instance codec under `byCodecId`, so the fall-through still resolves to the right instance.
+*
+* The `forCodecId` fallback otherwise covers projections that are *not* column-bound (computed projections, raw SQL aliases) but still carry a `codecId` (ADR 205 stamps every `ProjectionItem` with the producer's codec id).
+*
+* Codec-registry-unification spec § AC-4 / AC-5.
+*/
+function resolveProjectionCodec(item, contractCodecs, aliasResolver) {
+	if (contractCodecs) {
+		if (item.expr.kind === "column-ref") {
+			const byColumn = contractCodecs.forColumn(aliasResolver(item.expr.table), item.expr.column);
+			if (byColumn && (item.codecId === void 0 || byColumn.id === item.codecId)) return byColumn;
+		} else if (item.refs) {
+			const byColumn = contractCodecs.forColumn(aliasResolver(item.refs.table), item.refs.column);
+			if (byColumn && (item.codecId === void 0 || byColumn.id === item.codecId)) return byColumn;
+		}
+	}
+	if (item.codecId) return contractCodecs?.forCodecId(item.codecId);
+}
+function buildDecodeContext(plan, contractCodecs) {
+	if (!isAstBackedPlan(plan)) return {
+		aliases: void 0,
+		codecs: /* @__PURE__ */ new Map(),
+		columnRefs: /* @__PURE__ */ new Map(),
+		includeAliases: EMPTY_INCLUDE_ALIASES
+	};
+	const projection = projectionListFromAst(plan.ast);
+	if (!projection) return {
+		aliases: void 0,
+		codecs: /* @__PURE__ */ new Map(),
+		columnRefs: /* @__PURE__ */ new Map(),
+		includeAliases: EMPTY_INCLUDE_ALIASES
+	};
+	const aliases = [];
+	const codecs = /* @__PURE__ */ new Map();
+	const columnRefs = /* @__PURE__ */ new Map();
+	const includeAliases = /* @__PURE__ */ new Set();
+	const aliasResolver = makeAliasResolver(plan.ast);
+	for (const item of projection) {
+		aliases.push(item.alias);
+		const codec = resolveProjectionCodec(item, contractCodecs, aliasResolver);
+		if (codec) codecs.set(item.alias, codec);
+		if (item.expr.kind === "column-ref") columnRefs.set(item.alias, {
+			table: aliasResolver(item.expr.table),
+			column: item.expr.column
+		});
+		else if (item.refs) columnRefs.set(item.alias, {
+			table: aliasResolver(item.refs.table),
+			column: item.refs.column
+		});
+		else if (item.expr.kind === "subquery" || item.expr.kind === "json-array-agg") includeAliases.add(item.alias);
+	}
+	return {
+		aliases,
+		codecs,
+		columnRefs,
+		includeAliases
+	};
+}
+function previewWireValue(wireValue) {
+	if (typeof wireValue === "string") return wireValue.length > WIRE_PREVIEW_LIMIT ? `${wireValue.substring(0, WIRE_PREVIEW_LIMIT)}...` : wireValue;
+	return String(wireValue).substring(0, WIRE_PREVIEW_LIMIT);
+}
+function wrapDecodeFailure(error, alias, ref, codec, wireValue) {
+	const message = error instanceof Error ? error.message : String(error);
+	const wrapped = runtimeError("RUNTIME.DECODE_FAILED", `Failed to decode column ${ref ? `${ref.table}.${ref.column}` : alias} with codec '${codec.id}': ${message}`, {
+		...ref ? {
+			table: ref.table,
+			column: ref.column
+		} : { alias },
+		codec: codec.id,
+		wirePreview: previewWireValue(wireValue)
+	});
+	wrapped.cause = error;
+	throw wrapped;
+}
+function wrapIncludeAggregateFailure(error, alias, wireValue) {
+	const wrapped = runtimeError("RUNTIME.DECODE_FAILED", `Failed to parse JSON array for include alias '${alias}': ${error instanceof Error ? error.message : String(error)}`, {
+		alias,
+		wirePreview: previewWireValue(wireValue)
+	});
+	wrapped.cause = error;
+	throw wrapped;
+}
+function decodeIncludeAggregate(alias, wireValue) {
+	if (wireValue === null || wireValue === void 0) return [];
+	try {
+		let parsed;
+		if (typeof wireValue === "string") parsed = JSON.parse(wireValue);
+		else if (Array.isArray(wireValue)) parsed = wireValue;
+		else parsed = JSON.parse(String(wireValue));
+		if (!Array.isArray(parsed)) throw new Error(`Expected array for include alias '${alias}', got ${typeof parsed}`);
+		return parsed;
+	} catch (error) {
+		wrapIncludeAggregateFailure(error, alias, wireValue);
+	}
+}
+/**
+* Decodes a single field. Single-armed: every cell takes the same path — `codec.decode → await → return plain value` — so sync- and async-authored codecs are indistinguishable to callers. JSON-Schema validation, when required, lives inside the resolved codec's `decode` body (e.g. `arktype-json` validates against its rehydrated schema and throws `RUNTIME.JSON_SCHEMA_VALIDATION_FAILED` from `decode` directly); there is
+* no separate validator-registry pass.
+*
+* The row-level `rowCtx` is repackaged into a per-cell `SqlCodecCallContext` whose `column = { table, name }` is a structural projection of the per-cell `ColumnRef = { table, column }` resolved from the AST-backed `DecodeContext` (the same resolution `wrapDecodeFailure` uses for envelope construction — one resolution per cell, two consumers). Cells the runtime cannot resolve to a single underlying column (aggregate
+* aliases, computed projections without a simple ref) get `column: undefined`, matching the spec contract that the runtime never silently defaults this field.
+*/
+async function decodeField(alias, wireValue, decodeCtx, rowCtx) {
+	if (wireValue === null) return null;
+	const codec = decodeCtx.codecs.get(alias);
+	if (!codec) return wireValue;
+	const ref = decodeCtx.columnRefs.get(alias);
+	let cellCtx;
+	if (ref) cellCtx = {
+		...rowCtx,
+		column: {
+			table: ref.table,
+			name: ref.column
+		}
+	};
+	else {
+		const { column: _drop, ...rowCtxWithoutColumn } = rowCtx;
+		cellCtx = rowCtxWithoutColumn;
+	}
+	try {
+		return await codec.decode(wireValue, cellCtx);
+	} catch (error) {
+		if (isRuntimeError(error)) throw error;
+		wrapDecodeFailure(error, alias, ref, codec, wireValue);
+	}
+}
+/**
+* Decodes a row by dispatching all per-cell codec calls concurrently via `Promise.all`. Each cell follows the single-armed `decodeField` path. Failures are wrapped in `RUNTIME.DECODE_FAILED` with `{ table, column, codec }` (or `{ alias, codec }` when no column ref is resolvable) and the original error attached on `cause`.
+*
+* When `rowCtx.signal` is provided:
+*
+* - **Already-aborted at entry** short-circuits with `RUNTIME.ABORTED` (`{ phase: 'decode' }`) before any `codec.decode` call is made.
+* - **Mid-flight aborts** race the per-cell `Promise.all` against the signal so the runtime returns promptly even when codec bodies ignore it. In-flight bodies that ignore the signal complete in the background (cooperative cancellation).
+* - Existing `RUNTIME.DECODE_FAILED` envelopes from codec bodies pass through unchanged (no double wrap).
+*/
+async function decodeRow(row, plan, rowCtx, contractCodecs) {
+	checkAborted(rowCtx, "decode");
+	const signal = rowCtx.signal;
+	const decodeCtx = buildDecodeContext(plan, contractCodecs);
+	const aliases = decodeCtx.aliases ?? Object.keys(row);
+	if (decodeCtx.aliases !== void 0) {
+		for (const alias of decodeCtx.aliases) if (!Object.hasOwn(row, alias)) throw runtimeError("RUNTIME.DECODE_FAILED", `Row missing projection alias "${alias}"`, {
+			alias,
+			expectedAliases: decodeCtx.aliases,
+			presentKeys: Object.keys(row)
+		});
+	}
+	const tasks = [];
+	const includeIndices = [];
+	for (let i = 0; i < aliases.length; i++) {
+		const alias = aliases[i];
+		const wireValue = row[alias];
+		if (decodeCtx.includeAliases.has(alias)) {
+			includeIndices.push({
+				index: i,
+				alias,
+				value: wireValue
+			});
+			tasks.push(Promise.resolve(void 0));
+			continue;
+		}
+		tasks.push(decodeField(alias, wireValue, decodeCtx, rowCtx));
+	}
+	const settled = await raceAgainstAbort(Promise.all(tasks), signal, "decode");
+	for (const entry of includeIndices) settled[entry.index] = decodeIncludeAggregate(entry.alias, entry.value);
+	const decoded = {};
+	for (let i = 0; i < aliases.length; i++) decoded[aliases[i]] = settled[i];
+	return decoded;
+}
+//#endregion
+//#region src/codecs/encoding.ts
+const NO_METADATA = Object.freeze({
+	codecId: void 0,
+	name: void 0,
+	refs: void 0
+});
+/**
+* Resolve the codec for an outgoing param.
+*
+* Column-aware dispatch: when `metadata.refs` is populated by a column-bound construction site, prefer `contractCodecs.forColumn(refs.table, refs.column)` — that returns the per-instance codec the contract walk materialized for the `(table, column)` pair, encoding the column's typeParams (e.g. `vector(1024)` vs. `vector(1536)`).
+*
+* On a column-lookup miss the resolver falls through to `forCodecId`. The wrong-instance risk for parameterized codecs is closed off structurally:
+*
+* 1. `buildContractCodecRegistry` pre-populates `byCodecId` with one canonical instance per non-parameterized descriptor; parameterized descriptors are intentionally absent from this pre-population. 2. `forCodecId` rejects ambiguous parameterized fallbacks (`ambiguousCodecIds`) — if the contract walk resolved more than one distinct instance under a single parameterized id, the call throws rather than binding to
+* whichever landed first. 3. For the non-ambiguous parameterized case (a single column with that id), `byCodecId` stores the column-correct per-instance codec, so the fall-through still resolves to the right instance.
+*
+* Refs-less fallback: ParamRefs constructed outside a column-bound site (literals, transient builder state) carry a non-parameterized `codecId` whose dispatch is ambiguity-free. The validator pass (`validateParamRefRefs`) already enforced refs on every parameterized ParamRef before encode runs.
+*/
+function resolveParamCodec(metadata, contractCodecs, aliasResolver) {
+	if (!metadata.codecId) return void 0;
+	if (metadata.refs && contractCodecs) {
+		const byColumn = contractCodecs.forColumn(aliasResolver(metadata.refs.table), metadata.refs.column);
+		if (byColumn && byColumn.id === metadata.codecId) return byColumn;
+	}
+	return contractCodecs?.forCodecId(metadata.codecId);
+}
+function paramLabel(metadata, paramIndex) {
+	return metadata.name ?? `param[${paramIndex}]`;
+}
+function wrapEncodeFailure(error, metadata, paramIndex, codecId) {
+	const label = paramLabel(metadata, paramIndex);
+	const wrapped = runtimeError("RUNTIME.ENCODE_FAILED", `Failed to encode parameter ${label} with codec '${codecId}': ${error instanceof Error ? error.message : String(error)}`, {
+		label,
+		codec: codecId,
+		paramIndex
+	});
+	wrapped.cause = error;
+	throw wrapped;
+}
+async function encodeParamValue(value, metadata, paramIndex, ctx, contractCodecs, aliasResolver) {
+	if (value === null || value === void 0) return null;
+	const codec = resolveParamCodec(metadata, contractCodecs, aliasResolver);
+	if (!codec) return value;
+	try {
+		return await codec.encode(value, ctx);
+	} catch (error) {
+		wrapEncodeFailure(error, metadata, paramIndex, codec.id);
+	}
+}
+/**
+* Encodes all parameters concurrently via `Promise.all`. Per parameter, sync-and async-authored codecs share the same path: `codec.encode → await → return`. Param-level failures are wrapped in `RUNTIME.ENCODE_FAILED`.
+*
+* When `ctx.signal` is provided:
+*
+* - **Already-aborted at entry** short-circuits with `RUNTIME.ABORTED` (`{ phase: 'encode' }`) before any `codec.encode` call is made — codecs can pin this with a per-call counter that stays at zero.
+* - **Mid-flight abort** races the per-param `Promise.all` against `abortable(ctx.signal)`. The runtime returns `RUNTIME.ABORTED` promptly even if codec bodies ignore the signal; the in-flight bodies are abandoned and run to completion in the background (cooperative cancellation, see ADR 204).
+* - Existing `RUNTIME.ENCODE_FAILED` envelopes that surface from a codec body before the runtime observes the abort pass through unchanged (no double wrap).
+*/
+async function encodeParams(plan, ctx, contractCodecs) {
+	checkAborted(ctx, "encode");
+	const signal = ctx.signal;
+	if (plan.params.length === 0) return plan.params;
+	const paramCount = plan.params.length;
+	const metadata = new Array(paramCount).fill(NO_METADATA);
+	if (plan.ast) {
+		const refs = collectOrderedParamRefs(plan.ast);
+		for (let i = 0; i < paramCount && i < refs.length; i++) {
+			const ref = refs[i];
+			if (ref) metadata[i] = {
+				codecId: ref.codecId,
+				name: ref.name,
+				refs: ref.refs
+			};
+		}
+	}
+	const aliasResolver = makeAliasResolver(plan.ast);
+	const tasks = new Array(paramCount);
+	for (let i = 0; i < paramCount; i++) tasks[i] = encodeParamValue(plan.params[i], metadata[i] ?? NO_METADATA, i, ctx, contractCodecs, aliasResolver);
+	const settled = await raceAgainstAbort(Promise.all(tasks), signal, "encode");
+	return Object.freeze(settled);
+}
+//#endregion
+//#region src/content-hash.ts
+/**
+* Computes a stable content hash for a lowered SQL execution plan.
+*
+* Internally builds an unambiguous canonical-stringified preimage from
+* three components:
+*
+* 1. `meta.storageHash` — discriminates by schema. A migration changes the
+*    storage hash, which invalidates cached entries automatically.
+* 2. `exec.sql` — the raw lowered SQL text. Two queries with different
+*    structure produce different keys. Note that we deliberately do **not**
+*    use `computeSqlFingerprint` here: that helper strips literals to group
+*    executions by statement shape (used by telemetry), which is the
+*    opposite of what a content hash needs — we want per-execution
+*    discrimination, not per-statement-shape grouping.
+* 3. `exec.params` — the bound parameters. `canonicalStringify` produces a
+*    deterministic serialization that is stable across object key
+*    insertion order and that distinguishes types JSON would otherwise
+*    conflate (e.g. `BigInt(1)` vs `1`).
+*
+* The components are wrapped in an object and canonicalized as a single
+* unit (rather than concatenated with a delimiter) so component
+* boundaries are unambiguous: any character appearing inside `sql` or
+* `storageHash` cannot bleed across components and produce a collision
+* with a different split of the same characters.
+*
+* The canonical string is then piped through `hashContent` to produce a
+* bounded, opaque digest. See `@prisma-next/utils/hash-content` for the
+* rationale.
+*
+* @internal
+*/
+function computeSqlContentHash(exec) {
+	return hashContent(canonicalStringify({
+		storageHash: exec.meta.storageHash,
+		sql: exec.sql,
+		params: exec.params
+	}));
+}
+//#endregion
+//#region src/fingerprint.ts
+const STRING_LITERAL_REGEX = /'(?:''|[^'])*'/g;
+const NUMERIC_LITERAL_REGEX = /\b\d+(?:\.\d+)?\b/g;
+const WHITESPACE_REGEX = /\s+/g;
+/**
+* Computes a literal-stripped, normalized fingerprint of a SQL statement.
+*
+* The function strips string and numeric literals, collapses whitespace, and
+* lowercases the result before hashing — so two structurally equivalent
+* statements (with different parameter values) produce the same fingerprint.
+* Used by SQL telemetry to group queries.
+*/
+function computeSqlFingerprint(sql) {
+	const normalized = sql.replace(STRING_LITERAL_REGEX, "?").replace(NUMERIC_LITERAL_REGEX, "?").replace(WHITESPACE_REGEX, " ").trim().toLowerCase();
+	return `sha256:${createHash("sha256").update(normalized).digest("hex")}`;
+}
+//#endregion
+//#region src/middleware/before-compile-chain.ts
+async function runBeforeCompileChain(middleware, initial, ctx) {
+	let current = initial;
+	for (const mw of middleware) {
+		if (!mw.beforeCompile) continue;
+		const result = await mw.beforeCompile(current, ctx);
+		if (result === void 0) continue;
+		if (result.ast === current.ast) continue;
+		ctx.log.debug?.({
+			event: "middleware.rewrite",
+			middleware: mw.name,
+			lane: current.meta.lane
+		});
+		current = result;
+	}
+	return current;
+}
+//#endregion
+//#region src/sql-family-adapter.ts
+var SqlFamilyAdapter = class {
+	contract;
+	markerReader;
+	constructor(contract, adapterProfile) {
+		this.contract = contract;
+		this.markerReader = adapterProfile;
+	}
+	validatePlan(plan, contract) {
+		if (plan.meta.target !== contract.target) throw runtimeError("PLAN.TARGET_MISMATCH", "Plan target does not match runtime target", {
+			planTarget: plan.meta.target,
+			runtimeTarget: contract.target
+		});
+		if (plan.meta.storageHash !== contract.storage.storageHash) throw runtimeError("PLAN.HASH_MISMATCH", "Plan storage hash does not match runtime contract", {
+			planStorageHash: plan.meta.storageHash,
+			runtimeStorageHash: contract.storage.storageHash
+		});
+	}
+};
+//#endregion
+//#region src/sql-runtime.ts
+function isExecutionPlan(plan) {
+	return "sql" in plan;
+}
+// v8 ignore next 2
+const noopLogSink = () => {};
+const noopLog = {
+	info: noopLogSink,
+	warn: noopLogSink,
+	error: noopLogSink
+};
+var SqlRuntimeImpl = class extends RuntimeCore {
+	contract;
+	adapter;
+	driver;
+	familyAdapter;
+	contractCodecs;
+	codecDescriptors;
+	sqlCtx;
+	verify;
+	codecRegistryValidated;
+	verified;
+	startupVerified;
+	_telemetry;
+	constructor(options) {
+		const { context, adapter, driver, verify, middleware, mode, log } = options;
+		if (middleware) for (const mw of middleware) checkMiddlewareCompatibility(mw, "sql", context.contract.target);
+		const sqlCtx = {
+			contract: context.contract,
+			mode: mode ?? "strict",
+			now: () => Date.now(),
+			log: log ?? noopLog,
+			contentHash: (exec) => computeSqlContentHash(exec)
+		};
+		super({
+			middleware: middleware ?? [],
+			ctx: sqlCtx
+		});
+		this.contract = context.contract;
+		this.adapter = adapter;
+		this.driver = driver;
+		this.familyAdapter = new SqlFamilyAdapter(context.contract, adapter.profile);
+		this.contractCodecs = context.contractCodecs;
+		this.codecDescriptors = context.codecDescriptors;
+		this.sqlCtx = sqlCtx;
+		this.verify = verify;
+		this.codecRegistryValidated = false;
+		this.verified = verify.mode === "startup" ? false : verify.mode === "always";
+		this.startupVerified = false;
+		this._telemetry = null;
+		if (verify.mode === "startup") {
+			validateCodecRegistryCompleteness(this.codecDescriptors, context.contract);
+			this.codecRegistryValidated = true;
+		}
+	}
+	/**
+	* Lower a `SqlQueryPlan` (AST + meta) into a `SqlExecutionPlan` with encoded parameters ready for the driver. This is the single point at which params transition from app-layer values to driver wire-format.
+	*
+	* `ctx: SqlCodecCallContext` is forwarded to `encodeParams` so per-query cancellation reaches every codec body during parameter encoding. The framework abstract typed this as `CodecCallContext`; the SQL family narrows it to the SQL-specific extension. SQL params do not populate `ctx.column` — encode-side column metadata is the middleware's domain.
+	*/
+	async lower(plan, ctx) {
+		validateParamRefRefs(plan.ast, this.codecDescriptors);
+		const lowered = lowerSqlPlan(this.adapter, this.contract, plan);
+		return Object.freeze({
+			...lowered,
+			params: await encodeParams(lowered, 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.
+	*/
+	// v8 ignore next 6
+	runDriver(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) {
+		const rewrittenDraft = await runBeforeCompileChain(this.middleware, {
+			ast: plan.ast,
+			meta: plan.meta
+		}, this.sqlCtx);
+		return rewrittenDraft.ast === plan.ast ? plan : {
+			...plan,
+			ast: rewrittenDraft.ast,
+			meta: rewrittenDraft.meta
+		};
+	}
+	execute(plan, options) {
+		return this.executeAgainstQueryable(plan, this.driver, options);
+	}
+	executeAgainstQueryable(plan, queryable, options) {
+		this.ensureCodecRegistryValidated();
+		const self = this;
+		const signal = options?.signal;
+		const codecCtx = signal === void 0 ? {} : { signal };
+		const execMiddlewareCtx = signal === void 0 ? self.ctx : {
+			...self.ctx,
+			signal
+		};
+		const generator = async function* () {
+			checkAborted(codecCtx, "stream");
+			let exec;
+			if (isExecutionPlan(plan)) {
+				if (plan.ast) validateParamRefRefs(plan.ast, self.codecDescriptors);
+				exec = Object.freeze({
+					...plan,
+					params: await encodeParams(plan, codecCtx, self.contractCodecs)
+				});
+			} else exec = await self.lower(await self.runBeforeCompile(plan), codecCtx);
+			self.familyAdapter.validatePlan(exec, self.contract);
+			self._telemetry = null;
+			if (!self.startupVerified && self.verify.mode === "startup") await self.verifyMarker();
+			if (!self.verified && self.verify.mode === "onFirstUse") await self.verifyMarker();
+			const startedAt = Date.now();
+			let outcome = null;
+			try {
+				if (self.verify.mode === "always") await self.verifyMarker();
+				const paramsMutator = createSqlParamRefMutator(exec);
+				const iterator = runWithMiddleware(exec, self.middleware, execMiddlewareCtx, () => queryable.execute({
+					sql: exec.sql,
+					params: paramsMutator.currentParams()
+				}), paramsMutator)[Symbol.asyncIterator]();
+				try {
+					while (true) {
+						checkAborted(codecCtx, "stream");
+						const next = await iterator.next();
+						if (next.done) break;
+						yield await decodeRow(next.value, exec, codecCtx, self.contractCodecs);
+					}
+				} finally {
+					await iterator.return?.();
+				}
+				outcome = "success";
+			} catch (error) {
+				outcome = "runtime-error";
+				throw error;
+			} finally {
+				if (outcome !== null) self.recordTelemetry(exec, outcome, Date.now() - startedAt);
+			}
+		};
+		return new AsyncIterableResult(generator());
+	}
+	async connection() {
+		const driverConn = await this.driver.acquireConnection();
+		const self = this;
+		return {
+			async transaction() {
+				const driverTx = await driverConn.beginTransaction();
+				return self.wrapTransaction(driverTx);
+			},
+			async release() {
+				await driverConn.release();
+			},
+			async destroy(reason) {
+				await driverConn.destroy(reason);
+			},
+			execute(plan, options) {
+				return self.executeAgainstQueryable(plan, driverConn, options);
+			}
+		};
+	}
+	wrapTransaction(driverTx) {
+		const self = this;
+		return {
+			async commit() {
+				await driverTx.commit();
+			},
+			async rollback() {
+				await driverTx.rollback();
+			},
+			execute(plan, options) {
+				return self.executeAgainstQueryable(plan, driverTx, options);
+			}
+		};
+	}
+	telemetry() {
+		return this._telemetry;
+	}
+	async close() {
+		await this.driver.close();
+	}
+	ensureCodecRegistryValidated() {
+		if (!this.codecRegistryValidated) {
+			validateCodecRegistryCompleteness(this.codecDescriptors, this.contract);
+			this.codecRegistryValidated = true;
+		}
+	}
+	async verifyMarker() {
+		const readResult = await this.familyAdapter.markerReader.readMarker(this.driver);
+		if (readResult.kind !== "present") {
+			if (this.verify.requireMarker) throw runtimeError("CONTRACT.MARKER_MISSING", "Contract marker not found in database");
+			this.verified = true;
+			return;
+		}
+		const marker = readResult.record;
+		const contract = this.contract;
+		if (marker.storageHash !== contract.storage.storageHash) throw runtimeError("CONTRACT.MARKER_MISMATCH", "Database storage hash does not match contract", {
+			expected: contract.storage.storageHash,
+			actual: marker.storageHash
+		});
+		const expectedProfile = contract.profileHash ?? null;
+		if (expectedProfile !== null && marker.profileHash !== expectedProfile) throw runtimeError("CONTRACT.MARKER_MISMATCH", "Database profile hash does not match contract", {
+			expectedProfile,
+			actualProfile: marker.profileHash
+		});
+		this.verified = true;
+		this.startupVerified = true;
+	}
+	recordTelemetry(plan, outcome, durationMs) {
+		const contract = this.contract;
+		this._telemetry = Object.freeze({
+			lane: plan.meta.lane,
+			target: contract.target,
+			fingerprint: computeSqlFingerprint(plan.sql),
+			outcome,
+			...durationMs !== void 0 ? { durationMs } : {}
+		});
+	}
+};
+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.", {});
+}
+async function withTransaction(runtime, fn) {
+	const connection = await runtime.connection();
+	const transaction = await connection.transaction();
+	let invalidated = false;
+	const txContext = {
+		get invalidated() {
+			return invalidated;
+		},
+		execute(plan, options) {
+			if (invalidated) throw transactionClosedError();
+			const inner = transaction.execute(plan, options);
+			const guarded = async function* () {
+				for await (const row of inner) {
+					if (invalidated) throw transactionClosedError();
+					yield row;
+				}
+			};
+			return new AsyncIterableResult(guarded());
+		}
+	};
+	let connectionDisposed = false;
+	const destroyConnection = async (reason) => {
+		if (connectionDisposed) return;
+		connectionDisposed = true;
+		await connection.destroy(reason).catch(() => void 0);
+	};
+	try {
+		let result;
+		try {
+			result = await fn(txContext);
+		} catch (error) {
+			try {
+				await transaction.rollback();
+			} catch (rollbackError) {
+				await destroyConnection(rollbackError);
+				const wrapped = runtimeError("RUNTIME.TRANSACTION_ROLLBACK_FAILED", "Transaction rollback failed after callback error", { rollbackError });
+				wrapped.cause = error;
+				throw wrapped;
+			}
+			throw error;
+		} finally {
+			invalidated = true;
+		}
+		try {
+			await transaction.commit();
+		} catch (commitError) {
+			try {
+				await transaction.rollback();
+			} catch {
+				await destroyConnection(commitError);
+			}
+			const wrapped = runtimeError("RUNTIME.TRANSACTION_COMMIT_FAILED", "Transaction commit failed", { commitError });
+			wrapped.cause = commitError;
+			throw wrapped;
+		}
+		return result;
+	} finally {
+		if (!connectionDisposed) await connection.release();
+	}
+}
+function createRuntime(options) {
+	const { stackInstance, context, driver, verify, middleware, mode, log } = options;
+	return new SqlRuntimeImpl({
+		context,
+		adapter: stackInstance.adapter,
+		driver,
+		verify,
+		...ifDefined("middleware", middleware),
+		...ifDefined("mode", mode),
+		...ifDefined("log", log)
+	});
+}
+//#endregion
+export { ensureTableStatement as a, createExecutionContext as c, budgets as d, parseContractMarkerRow as f, validateContractCodecMappings as g, validateCodecRegistryCompleteness as h, ensureSchemaStatement as i, createSqlExecutionStack as l, extractCodecIds as m, withTransaction as n, readContractMarker as o, lowerSqlPlan as p, APP_SPACE_ID as r, writeContractMarker as s, createRuntime as t, lints as u };
+
+//# sourceMappingURL=exports-BSTHn_rH.mjs.map