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

package/dist/exports-BOHa3Emo.mjs

@@ -1,1334 +0,0 @@
-import { AsyncIterableResult, RuntimeCore, checkMiddlewareCompatibility, isRuntimeError, runWithMiddleware, runtimeError } from "@prisma-next/framework-components/runtime";
-import { createCodecRegistry, isQueryAst } 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 { type } from "arktype";
-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.has(codecId)) {
-		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/middleware/budgets.ts
-function hasAggregateWithoutGroupBy(ast) {
-	if (ast.groupBy !== void 0) return false;
-	return ast.projection.some((item) => item.expr.kind === "aggregate");
-}
-function estimateRowsFromAst(ast, tableRows, defaultTableRows, refs, hasAggregateWithoutGroup) {
-	if (hasAggregateWithoutGroup) return 1;
-	const table = refs?.tables?.[0];
-	if (!table) return null;
-	const tableEstimate = tableRows[table] ?? defaultTableRows;
-	if (ast.limit !== void 0) return Math.min(ast.limit, tableEstimate);
-	return tableEstimate;
-}
-function estimateRowsFromHeuristics(plan, tableRows, defaultTableRows) {
-	const table = plan.meta.refs?.tables?.[0];
-	if (!table) return null;
-	const tableEstimate = tableRows[table] ?? defaultTableRows;
-	const limit = plan.meta.annotations?.["limit"];
-	if (typeof limit === "number") return Math.min(limit, tableEstimate);
-	return tableEstimate;
-}
-function hasDetectableLimitFromHeuristics(plan) {
-	return typeof plan.meta.annotations?.["limit"] === "number";
-}
-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)) {
-				if (plan.ast.kind === "select") return evaluateSelectAst(plan, plan.ast, ctx);
-				return;
-			}
-			return evaluateWithHeuristics(plan, 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(plan, ast, ctx) {
-		const hasAggNoGroup = hasAggregateWithoutGroupBy(ast);
-		const estimated = estimateRowsFromAst(ast, tableRows, defaultTableRows, plan.meta.refs, hasAggNoGroup);
-		const isUnbounded = ast.limit === void 0 && !hasAggNoGroup;
-		const shouldBlock = rowSeverity === "error" || ctx.mode === "strict";
-		if (isUnbounded) {
-			if (estimated !== null && estimated >= maxRows) {
-				emitBudgetViolation(runtimeError("BUDGET.ROWS_EXCEEDED", "Unbounded SELECT query exceeds budget", {
-					source: "ast",
-					estimatedRows: estimated,
-					maxRows
-				}), shouldBlock, ctx);
-				return;
-			}
-			emitBudgetViolation(runtimeError("BUDGET.ROWS_EXCEEDED", "Unbounded SELECT query exceeds budget", {
-				source: "ast",
-				maxRows
-			}), shouldBlock, ctx);
-			return;
-		}
-		if (estimated !== null && estimated > maxRows) emitBudgetViolation(runtimeError("BUDGET.ROWS_EXCEEDED", "Estimated row count exceeds budget", {
-			source: "ast",
-			estimatedRows: estimated,
-			maxRows
-		}), shouldBlock, ctx);
-	}
-	async function evaluateWithHeuristics(plan, ctx) {
-		const estimated = estimateRowsFromHeuristics(plan, tableRows, defaultTableRows);
-		const isUnbounded = !hasDetectableLimitFromHeuristics(plan);
-		const isSelect = plan.sql.trimStart().toUpperCase().startsWith("SELECT");
-		const shouldBlock = rowSeverity === "error" || ctx.mode === "strict";
-		if (isSelect && isUnbounded) {
-			if (estimated !== null && estimated >= maxRows) {
-				emitBudgetViolation(runtimeError("BUDGET.ROWS_EXCEEDED", "Unbounded SELECT query exceeds budget", {
-					source: "heuristic",
-					estimatedRows: estimated,
-					maxRows
-				}), shouldBlock, ctx);
-				return;
-			}
-			emitBudgetViolation(runtimeError("BUDGET.ROWS_EXCEEDED", "Unbounded SELECT query exceeds budget", {
-				source: "heuristic",
-				maxRows
-			}), shouldBlock, ctx);
-			return;
-		}
-		if (estimated !== null) {
-			if (estimated > maxRows) emitBudgetViolation(runtimeError("BUDGET.ROWS_EXCEEDED", "Estimated row count exceeds budget", {
-				source: "heuristic",
-				estimatedRows: estimated,
-				maxRows
-			}), shouldBlock, ctx);
-			return;
-		}
-	}
-}
-
-//#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$1 = [];
-	const budgets$1 = [];
-	const normalized = normalizeWhitespace(plan.sql);
-	const statementType = classifyStatement(normalized);
-	if (statementType === "select") {
-		if (SELECT_STAR_REGEX.test(normalized)) lints$1.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$1.push(createLint("LINT.NO_LIMIT", "warn", "Raw SQL plan omits LIMIT clause", { sql: snippet(plan.sql) }));
-			budgets$1.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$1.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"]
-	}));
-	const refs = plan.meta.refs;
-	if (refs) evaluateIndexCoverage(refs, lints$1);
-	return {
-		lints: lints$1,
-		budgets: budgets$1,
-		statement: statementType
-	};
-}
-function evaluateIndexCoverage(refs, lints$1) {
-	const predicateColumns = refs.columns ?? [];
-	if (predicateColumns.length === 0) return;
-	const indexes = refs.indexes ?? [];
-	if (indexes.length === 0) {
-		lints$1.push(createLint("LINT.UNINDEXED_PREDICATE", "warn", "Raw SQL plan predicates lack supporting indexes", { predicates: predicateColumns }));
-		return;
-	}
-	if (!predicateColumns.every((column) => indexes.some((index) => index.table === column.table && index.columns.some((col) => col.toLowerCase() === column.column.toLowerCase())))) lints$1.push(createLint("LINT.UNINDEXED_PREDICATE", "warn", "Raw SQL plan predicates lack supporting indexes", { predicates: predicateColumns }));
-}
-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;
-		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;
-		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) {
-			if (isQueryAst(plan.ast)) {
-				const findings = evaluateAstLints(plan.ast);
-				for (const lint of findings) {
-					const effectiveSeverity = getConfiguredSeverity(lint.code, options) ?? lint.severity;
-					if (effectiveSeverity === "error") throw runtimeError(lint.code, lint.message, lint.details);
-					if (effectiveSeverity === "warn") ctx.log.warn({
-						code: lint.code,
-						message: lint.message,
-						details: lint.details
-					});
-				}
-				return;
-			}
-			if (fallback === "skip") return;
-			const evaluation = evaluateRawGuardrails(plan);
-			for (const lint of evaluation.lints) {
-				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, codecDescriptor, context) {
-	const result = codecDescriptor.paramsSchema(typeParams);
-	if (result instanceof type.errors) {
-		const messages = result.map((p) => p.message).join("; ");
-		throw runtimeError("RUNTIME.TYPE_PARAMS_INVALID", `Invalid typeParams for ${context.typeName ? `type '${context.typeName}'` : `column '${context.tableName}.${context.columnName}'`} (codecId: ${codecDescriptor.codecId}): ${messages}`, {
-			...context,
-			codecId: codecDescriptor.codecId,
-			typeParams
-		});
-	}
-	return result;
-}
-function collectParameterizedCodecDescriptors(contributors) {
-	const descriptors = /* @__PURE__ */ new Map();
-	for (const contributor of contributors) for (const descriptor of contributor.parameterizedCodecs()) {
-		if (descriptors.has(descriptor.codecId)) throw runtimeError("RUNTIME.DUPLICATE_PARAMETERIZED_CODEC", `Duplicate parameterized codec descriptor for codecId '${descriptor.codecId}'.`, { codecId: descriptor.codecId });
-		descriptors.set(descriptor.codecId, descriptor);
-	}
-	return descriptors;
-}
-function initializeTypeHelpers(storageTypes, codecDescriptors) {
-	const helpers = {};
-	if (!storageTypes) return helpers;
-	for (const [typeName, typeInstance] of Object.entries(storageTypes)) {
-		const descriptor = codecDescriptors.get(typeInstance.codecId);
-		if (descriptor) {
-			const validatedParams = validateTypeParams(typeInstance.typeParams, descriptor, { typeName });
-			if (descriptor.init) helpers[typeName] = descriptor.init(validatedParams);
-			else helpers[typeName] = typeInstance;
-		} else helpers[typeName] = typeInstance;
-	}
-	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
-		});
-	}
-}
-/**
-* Builds a registry of compiled JSON Schema validators by scanning the contract
-* for columns whose codec descriptor provides an `init` hook returning `{ validate }`.
-*
-* Handles both:
-* - Inline `typeParams.schema` on columns
-* - `typeRef` → `storage.types[ref]` with init hook results already in `types` registry
-*/
-function buildJsonSchemaValidatorRegistry(contract, types, codecDescriptors) {
-	const validators = /* @__PURE__ */ new Map();
-	const codecIdsWithInit = /* @__PURE__ */ new Set();
-	for (const [codecId, descriptor] of codecDescriptors) if (descriptor.init) codecIdsWithInit.add(codecId);
-	if (codecIdsWithInit.size === 0) return;
-	for (const [tableName, table] of Object.entries(contract.storage.tables)) for (const [columnName, column] of Object.entries(table.columns)) {
-		if (!codecIdsWithInit.has(column.codecId)) continue;
-		const key = `${tableName}.${columnName}`;
-		if (column.typeRef) {
-			const helper = types[column.typeRef];
-			if (helper?.validate) validators.set(key, helper.validate);
-			continue;
-		}
-		if (column.typeParams) {
-			const descriptor = codecDescriptors.get(column.codecId);
-			if (descriptor?.init) {
-				const helper = descriptor.init(column.typeParams);
-				if (helper?.validate) validators.set(key, helper.validate);
-			}
-		}
-	}
-	if (validators.size === 0) return void 0;
-	return {
-		get: (key) => validators.get(key),
-		size: validators.size
-	};
-}
-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 applied = [];
-	const appliedColumns = /* @__PURE__ */ new Set();
-	for (const mutationDefault of defaults) {
-		if (mutationDefault.ref.table !== options.table) continue;
-		const defaultSpec = options.op === "create" ? mutationDefault.onCreate : mutationDefault.onUpdate;
-		if (!defaultSpec) continue;
-		const columnName = mutationDefault.ref.column;
-		if (Object.hasOwn(options.values, columnName) || appliedColumns.has(columnName)) continue;
-		applied.push({
-			column: columnName,
-			value: computeExecutionDefaultValue(defaultSpec, generatorRegistry)
-		});
-		appliedColumns.add(columnName);
-	}
-	return applied;
-}
-function createExecutionContext(options) {
-	const { contract, stack } = options;
-	assertExecutionStackContractRequirements(contract, stack);
-	const codecRegistry = createCodecRegistry();
-	const contributors = [
-		stack.target,
-		stack.adapter,
-		...stack.extensionPacks
-	];
-	for (const contributor of contributors) for (const c of contributor.codecs().values()) codecRegistry.register(c);
-	const queryOperationRegistry = createSqlOperationRegistry();
-	for (const contributor of contributors) for (const op of contributor.queryOperations?.() ?? []) queryOperationRegistry.register(op);
-	const parameterizedCodecDescriptors = collectParameterizedCodecDescriptors(contributors);
-	const mutationDefaultGeneratorRegistry = collectMutationDefaultGenerators(contributors);
-	if (parameterizedCodecDescriptors.size > 0) validateColumnTypeParams(contract.storage, parameterizedCodecDescriptors);
-	const types = initializeTypeHelpers(contract.storage.types, parameterizedCodecDescriptors);
-	const jsonSchemaValidators = buildJsonSchemaValidatorRegistry(contract, types, parameterizedCodecDescriptors);
-	return {
-		contract,
-		codecs: codecRegistry,
-		queryOperations: queryOperationRegistry,
-		types,
-		...jsonSchemaValidators ? { jsonSchemaValidators } : {},
-		applyMutationDefaults: (options$1) => applyMutationDefaults(contract, mutationDefaultGeneratorRegistry, options$1)
-	};
-}
-
-//#endregion
-//#region src/sql-marker.ts
-const ensureSchemaStatement = {
-	sql: "create schema if not exists prisma_contract",
-	params: []
-};
-const ensureTableStatement = {
-	sql: `create table if not exists prisma_contract.marker (
-    id smallint primary key default 1,
-    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 '{}'
-  )`,
-	params: []
-};
-function readContractMarker() {
-	return {
-		sql: `select
-      core_hash,
-      profile_hash,
-      contract_json,
-      canonical_version,
-      updated_at,
-      app_tag,
-      meta
-    from prisma_contract.marker
-    where id = $1`,
-		params: [1]
-	};
-}
-function writeContractMarker(input) {
-	const baseParams = [
-		1,
-		input.storageHash,
-		input.profileHash,
-		input.contractJson ?? null,
-		input.canonicalVersion ?? null,
-		input.appTag ?? null,
-		JSON.stringify(input.meta ?? {})
-	];
-	return {
-		insert: {
-			sql: `insert into prisma_contract.marker (
-        id,
-        core_hash,
-        profile_hash,
-        contract_json,
-        canonical_version,
-        updated_at,
-        app_tag,
-        meta
-      ) values (
-        $1,
-        $2,
-        $3,
-        $4::jsonb,
-        $5,
-        now(),
-        $6,
-        $7::jsonb
-      )`,
-			params: baseParams
-		},
-		update: {
-			sql: `update prisma_contract.marker set
-        core_hash = $2,
-        profile_hash = $3,
-        contract_json = $4::jsonb,
-        canonical_version = $5,
-        updated_at = now(),
-        app_tag = $6,
-        meta = $7::jsonb
-      where id = $1`,
-			params: baseParams
-		}
-	};
-}
-
-//#endregion
-//#region src/codecs/json-schema-validation.ts
-/**
-* Validates a JSON value against its column's JSON Schema, if a validator exists.
-*
-* Throws `RUNTIME.JSON_SCHEMA_VALIDATION_FAILED` on validation failure.
-* No-ops if no validator is registered for the column.
-*/
-function validateJsonValue(registry, table, column, value, direction, codecId) {
-	const key = `${table}.${column}`;
-	const validate = registry.get(key);
-	if (!validate) return;
-	const result = validate(value);
-	if (result.valid) return;
-	throw createJsonSchemaValidationError(table, column, direction, result.errors, codecId);
-}
-function createJsonSchemaValidationError(table, column, direction, errors, codecId) {
-	return runtimeError("RUNTIME.JSON_SCHEMA_VALIDATION_FAILED", `JSON schema validation failed for column '${table}.${column}' (${direction}): ${formatErrorSummary(errors)}`, {
-		table,
-		column,
-		codecId,
-		direction,
-		errors: [...errors]
-	});
-}
-function formatErrorSummary(errors) {
-	if (errors.length === 0) return "unknown validation error";
-	if (errors.length === 1) {
-		const err = errors[0];
-		return err.path === "/" ? err.message : `${err.path}: ${err.message}`;
-	}
-	return errors.map((err) => err.path === "/" ? err.message : `${err.path}: ${err.message}`).join("; ");
-}
-
-//#endregion
-//#region src/codecs/decoding.ts
-const WIRE_PREVIEW_LIMIT = 100;
-function resolveRowCodec(alias, plan, registry) {
-	const planCodecId = plan.meta.annotations?.codecs?.[alias];
-	if (planCodecId) {
-		const codec$1 = registry.get(planCodecId);
-		if (codec$1) return codec$1;
-	}
-	if (plan.meta.projectionTypes) {
-		const typeId = plan.meta.projectionTypes[alias];
-		if (typeId) {
-			const codec$1 = registry.get(typeId);
-			if (codec$1) return codec$1;
-		}
-	}
-	return null;
-}
-/**
-* Builds a lookup index from column name → { table, column } ref.
-* Called once per decodeRow invocation to avoid O(aliases × refs) linear scans.
-*/
-function buildColumnRefIndex(plan) {
-	const columns = plan.meta.refs?.columns;
-	if (!columns) return null;
-	const index = /* @__PURE__ */ new Map();
-	for (const ref of columns) index.set(ref.column, ref);
-	return index;
-}
-function parseProjectionRef(value) {
-	if (value.startsWith("include:") || value.startsWith("operation:")) return null;
-	const separatorIndex = value.indexOf(".");
-	if (separatorIndex <= 0 || separatorIndex === value.length - 1) return null;
-	return {
-		table: value.slice(0, separatorIndex),
-		column: value.slice(separatorIndex + 1)
-	};
-}
-function resolveColumnRefForAlias(alias, projection, fallbackColumnRefIndex) {
-	if (projection && !Array.isArray(projection)) {
-		const mappedRef = projection[alias];
-		if (typeof mappedRef !== "string") return;
-		return parseProjectionRef(mappedRef) ?? void 0;
-	}
-	return fallbackColumnRefIndex?.get(alias);
-}
-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 isJsonSchemaValidationError(error) {
-	return isRuntimeError(error) && error.code === "RUNTIME.JSON_SCHEMA_VALIDATION_FAILED";
-}
-function wrapDecodeFailure(error, alias, ref, codec$1, 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$1.id}': ${message}`, {
-		...ref ? {
-			table: ref.table,
-			column: ref.column
-		} : { alias },
-		codec: codec$1.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 → JSON-Schema validate → return plain value` — so
-* sync- and async-authored codecs are indistinguishable to callers.
-*/
-async function decodeField(alias, wireValue, plan, registry, jsonValidators, projection, fallbackColumnRefIndex) {
-	if (wireValue === null || wireValue === void 0) return wireValue;
-	const codec$1 = resolveRowCodec(alias, plan, registry);
-	if (!codec$1) return wireValue;
-	const ref = resolveColumnRefForAlias(alias, projection, fallbackColumnRefIndex);
-	let decoded;
-	try {
-		decoded = await codec$1.decode(wireValue);
-	} catch (error) {
-		wrapDecodeFailure(error, alias, ref, codec$1, wireValue);
-	}
-	if (jsonValidators && ref) try {
-		validateJsonValue(jsonValidators, ref.table, ref.column, decoded, "decode", codec$1.id);
-	} catch (error) {
-		if (isJsonSchemaValidationError(error)) throw error;
-		wrapDecodeFailure(error, alias, ref, codec$1, wireValue);
-	}
-	return decoded;
-}
-/**
-* 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`.
-*/
-async function decodeRow(row, plan, registry, jsonValidators) {
-	const projection = plan.meta.projection;
-	const fallbackColumnRefIndex = !projection || Array.isArray(projection) ? buildColumnRefIndex(plan) : null;
-	let aliases;
-	if (projection && !Array.isArray(projection)) aliases = Object.keys(projection);
-	else if (projection && Array.isArray(projection)) aliases = projection;
-	else aliases = Object.keys(row);
-	const tasks = [];
-	const includeIndices = [];
-	for (let i = 0; i < aliases.length; i++) {
-		const alias = aliases[i];
-		const wireValue = row[alias];
-		const projectionValue = projection && typeof projection === "object" && !Array.isArray(projection) ? projection[alias] : void 0;
-		if (typeof projectionValue === "string" && projectionValue.startsWith("include:")) {
-			includeIndices.push({
-				index: i,
-				alias,
-				value: wireValue
-			});
-			tasks.push(Promise.resolve(void 0));
-			continue;
-		}
-		tasks.push(decodeField(alias, wireValue, plan, registry, jsonValidators, projection, fallbackColumnRefIndex));
-	}
-	const settled = await Promise.all(tasks);
-	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
-function resolveParamCodec(paramDescriptor, registry) {
-	if (paramDescriptor.codecId) {
-		const codec$1 = registry.get(paramDescriptor.codecId);
-		if (codec$1) return codec$1;
-	}
-	return null;
-}
-function paramLabel(paramDescriptor, paramIndex) {
-	return paramDescriptor.name ?? `param[${paramIndex}]`;
-}
-function wrapEncodeFailure(error, paramDescriptor, paramIndex, codecId) {
-	const label = paramLabel(paramDescriptor, 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;
-}
-/**
-* Encodes a single parameter through its codec. Always awaits codec.encode so
-* a Promise can never leak into the driver, even if a sync-authored codec is
-* lifted to async by the codec() factory. Failures are wrapped in
-* `RUNTIME.ENCODE_FAILED` with `{ label, codec, paramIndex }` and the original
-* error attached on `cause`.
-*/
-async function encodeParam(value, paramDescriptor, paramIndex, registry) {
-	if (value === null || value === void 0) return null;
-	const codec$1 = resolveParamCodec(paramDescriptor, registry);
-	if (!codec$1) return value;
-	try {
-		return await codec$1.encode(value);
-	} catch (error) {
-		wrapEncodeFailure(error, paramDescriptor, paramIndex, codec$1.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`.
-*/
-async function encodeParams(plan, registry) {
-	if (plan.params.length === 0) return plan.params;
-	const descriptorCount = plan.meta.paramDescriptors.length;
-	const paramCount = plan.params.length;
-	const tasks = new Array(paramCount);
-	for (let i = 0; i < paramCount; i++) {
-		const paramValue = plan.params[i];
-		const paramDescriptor = plan.meta.paramDescriptors[i];
-		if (!paramDescriptor) throw runtimeError("RUNTIME.MISSING_PARAM_DESCRIPTOR", `Missing paramDescriptor for parameter at index ${i} (plan has ${paramCount} params, ${descriptorCount} descriptors). The planner must emit one descriptor per param; this is a contract violation.`, {
-			paramIndex: i,
-			paramCount,
-			descriptorCount
-		});
-		tasks[i] = encodeParam(paramValue, paramDescriptor, i, registry);
-	}
-	const encoded = await Promise.all(tasks);
-	return Object.freeze(encoded);
-}
-
-//#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/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"
-});
-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 validatedRow = result;
-	const updatedAt = validatedRow.updated_at ? validatedRow.updated_at instanceof Date ? validatedRow.updated_at : new Date(validatedRow.updated_at) : /* @__PURE__ */ new Date();
-	return {
-		storageHash: validatedRow.core_hash,
-		profileHash: validatedRow.profile_hash,
-		contractJson: validatedRow.contract_json ?? null,
-		canonicalVersion: validatedRow.canonical_version ?? null,
-		updatedAt,
-		appTag: validatedRow.app_tag ?? null,
-		meta: parseMeta(validatedRow.meta)
-	};
-}
-
-//#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;
-	}
-	if (current.ast === initial.ast) return current;
-	const paramDescriptors = deriveParamDescriptorsFromAst(current.ast);
-	const meta = {
-		...current.meta,
-		paramDescriptors
-	};
-	return {
-		ast: current.ast,
-		meta
-	};
-}
-function deriveParamDescriptorsFromAst(ast) {
-	const refs = ast.collectParamRefs();
-	const seen = /* @__PURE__ */ new Set();
-	const descriptors = [];
-	for (const ref of refs) {
-		if (seen.has(ref)) continue;
-		seen.add(ref);
-		descriptors.push({
-			index: descriptors.length + 1,
-			...ref.name !== void 0 ? { name: ref.name } : {},
-			source: "dsl",
-			...ref.codecId !== void 0 ? { codecId: ref.codecId } : {}
-		});
-	}
-	return descriptors;
-}
-
-//#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;
-}
-var SqlRuntimeImpl = class extends RuntimeCore {
-	contract;
-	adapter;
-	driver;
-	familyAdapter;
-	codecRegistry;
-	jsonSchemaValidators;
-	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 ?? {
-				info: () => {},
-				warn: () => {},
-				error: () => {}
-			}
-		};
-		super({
-			middleware: middleware ?? [],
-			ctx: sqlCtx
-		});
-		this.contract = context.contract;
-		this.adapter = adapter;
-		this.driver = driver;
-		this.familyAdapter = new SqlFamilyAdapter(context.contract, adapter.profile);
-		this.codecRegistry = context.codecs;
-		this.jsonSchemaValidators = context.jsonSchemaValidators;
-		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.codecRegistry, 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.
-	*/
-	async lower(plan) {
-		const lowered = lowerSqlPlan(this.adapter, this.contract, plan);
-		return Object.freeze({
-			...lowered,
-			params: await encodeParams(lowered, this.codecRegistry)
-		});
-	}
-	/**
-	* Default driver invocation. Production execution paths override the
-	* queryable target (e.g. transaction or connection) by going through
-	* `executeAgainstQueryable`; this implementation supports any caller of
-	* `super.execute(plan)` and the abstract-base contract.
-	*/
-	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) and returns a `SqlQueryPlan`
-	* with the rewritten AST and meta when the chain mutates them. The chain
-	* re-derives `meta.paramDescriptors` from the rewritten AST so descriptors
-	* stay in lockstep with the params the adapter will emit during lowering.
-	*/
-	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) {
-		return this.executeAgainstQueryable(plan, this.driver);
-	}
-	executeAgainstQueryable(plan, queryable) {
-		this.ensureCodecRegistryValidated();
-		const self = this;
-		const generator = async function* () {
-			const exec = isExecutionPlan(plan) ? Object.freeze({
-				...plan,
-				params: await encodeParams(plan, self.codecRegistry)
-			}) : await self.lower(await self.runBeforeCompile(plan));
-			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 stream = runWithMiddleware(exec, self.middleware, self.ctx, () => queryable.execute({
-					sql: exec.sql,
-					params: exec.params
-				}));
-				for await (const rawRow of stream) yield await decodeRow(rawRow, exec, self.codecRegistry, self.jsonSchemaValidators);
-				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) {
-				return self.executeAgainstQueryable(plan, driverConn);
-			}
-		};
-	}
-	wrapTransaction(driverTx) {
-		const self = this;
-		return {
-			async commit() {
-				await driverTx.commit();
-			},
-			async rollback() {
-				await driverTx.rollback();
-			},
-			execute(plan) {
-				return self.executeAgainstQueryable(plan, driverTx);
-			}
-		};
-	}
-	telemetry() {
-		return this._telemetry;
-	}
-	async close() {
-		await this.driver.close();
-	}
-	ensureCodecRegistryValidated() {
-		if (!this.codecRegistryValidated) {
-			validateCodecRegistryCompleteness(this.codecRegistry, this.contract);
-			this.codecRegistryValidated = true;
-		}
-	}
-	async verifyMarker() {
-		if (this.verify.mode === "always") this.verified = false;
-		if (this.verified) return;
-		const readStatement = this.familyAdapter.markerReader.readMarkerStatement();
-		const result = await this.driver.query(readStatement.sql, readStatement.params);
-		if (result.rows.length === 0) {
-			if (this.verify.requireMarker) throw runtimeError("CONTRACT.MARKER_MISSING", "Contract marker not found in database");
-			this.verified = true;
-			return;
-		}
-		const marker = parseContractMarkerRow(result.rows[0]);
-		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) {
-			if (invalidated) throw transactionClosedError();
-			const inner = transaction.execute(plan);
-			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 { readContractMarker as a, createSqlExecutionStack as c, lowerSqlPlan as d, extractCodecIds as f, ensureTableStatement as i, lints as l, validateContractCodecMappings as m, withTransaction as n, writeContractMarker as o, validateCodecRegistryCompleteness as p, ensureSchemaStatement as r, createExecutionContext as s, createRuntime as t, budgets as u };
-//# sourceMappingURL=exports-BOHa3Emo.mjs.map