@prisma-next/sql-runtime 0.3.0-pr.99.6 → 0.4.0-dev.1

package/dist/exports-BO6Fl7yn.mjs

@@ -0,0 +1,889 @@
+import { checkMiddlewareCompatibility, runtimeError } from "@prisma-next/framework-components/runtime";
+import { createCodecRegistry, isQueryAst } from "@prisma-next/sql-relational-core/ast";
+import { AsyncIterableResult, createRuntimeCore, evaluateRawGuardrails } from "@prisma-next/runtime-executor";
+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";
+
+//#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 body = adapter.lower(queryPlan.ast, {
+		contract,
+		params: queryPlan.params
+	}).body;
+	return Object.freeze({
+		sql: body.sql,
+		params: body.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/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
+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 decodeRow(row, plan, registry, jsonValidators) {
+	const decoded = {};
+	const projection = plan.meta.projection;
+	const fallbackColumnRefIndex = jsonValidators && (!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);
+	for (const alias of aliases) {
+		const wireValue = row[alias];
+		const projectionValue = projection && typeof projection === "object" && !Array.isArray(projection) ? projection[alias] : void 0;
+		if (typeof projectionValue === "string" && projectionValue.startsWith("include:")) {
+			if (wireValue === null || wireValue === void 0) {
+				decoded[alias] = [];
+				continue;
+			}
+			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}`);
+				decoded[alias] = parsed;
+			} catch (error) {
+				const decodeError = /* @__PURE__ */ new Error(`Failed to parse JSON array for include alias '${alias}': ${error instanceof Error ? error.message : String(error)}`);
+				decodeError.code = "RUNTIME.DECODE_FAILED";
+				decodeError.category = "RUNTIME";
+				decodeError.severity = "error";
+				decodeError.details = {
+					alias,
+					wirePreview: typeof wireValue === "string" && wireValue.length > 100 ? `${wireValue.substring(0, 100)}...` : String(wireValue).substring(0, 100)
+				};
+				throw decodeError;
+			}
+			continue;
+		}
+		if (wireValue === null || wireValue === void 0) {
+			decoded[alias] = wireValue;
+			continue;
+		}
+		const codec$1 = resolveRowCodec(alias, plan, registry);
+		if (!codec$1) {
+			decoded[alias] = wireValue;
+			continue;
+		}
+		try {
+			const decodedValue = codec$1.decode(wireValue);
+			if (jsonValidators) {
+				const ref = resolveColumnRefForAlias(alias, projection, fallbackColumnRefIndex);
+				if (ref) validateJsonValue(jsonValidators, ref.table, ref.column, decodedValue, "decode", codec$1.id);
+			}
+			decoded[alias] = decodedValue;
+		} catch (error) {
+			if (error instanceof Error && "code" in error && error.code === "RUNTIME.JSON_SCHEMA_VALIDATION_FAILED") throw error;
+			const decodeError = /* @__PURE__ */ new Error(`Failed to decode row alias '${alias}' with codec '${codec$1.id}': ${error instanceof Error ? error.message : String(error)}`);
+			decodeError.code = "RUNTIME.DECODE_FAILED";
+			decodeError.category = "RUNTIME";
+			decodeError.severity = "error";
+			decodeError.details = {
+				alias,
+				codec: codec$1.id,
+				wirePreview: typeof wireValue === "string" && wireValue.length > 100 ? `${wireValue.substring(0, 100)}...` : String(wireValue).substring(0, 100)
+			};
+			throw decodeError;
+		}
+	}
+	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 encodeParam(value, paramDescriptor, paramIndex, registry) {
+	if (value === null || value === void 0) return null;
+	const codec$1 = resolveParamCodec(paramDescriptor, registry);
+	if (!codec$1) return value;
+	if (codec$1.encode) try {
+		return codec$1.encode(value);
+	} catch (error) {
+		const label = paramDescriptor.name ?? `param[${paramIndex}]`;
+		throw new Error(`Failed to encode parameter ${label}: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	return value;
+}
+function encodeParams(plan, registry) {
+	if (plan.params.length === 0) return plan.params;
+	const encoded = [];
+	for (let i = 0; i < plan.params.length; i++) {
+		const paramValue = plan.params[i];
+		const paramDescriptor = plan.meta.paramDescriptors[i];
+		if (paramDescriptor) encoded.push(encodeParam(paramValue, paramDescriptor, i, registry));
+		else encoded.push(paramValue);
+	}
+	return Object.freeze(encoded);
+}
+
+//#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
+var SqlRuntimeImpl = class {
+	core;
+	contract;
+	adapter;
+	codecRegistry;
+	jsonSchemaValidators;
+	codecRegistryValidated;
+	constructor(options) {
+		const { context, adapter, driver, verify, middleware, mode, log } = options;
+		this.contract = context.contract;
+		this.adapter = adapter;
+		this.codecRegistry = context.codecs;
+		this.jsonSchemaValidators = context.jsonSchemaValidators;
+		this.codecRegistryValidated = false;
+		if (middleware) for (const mw of middleware) checkMiddlewareCompatibility(mw, "sql", context.contract.target);
+		this.core = createRuntimeCore({
+			familyAdapter: new SqlFamilyAdapter(context.contract, adapter.profile),
+			driver,
+			verify,
+			...ifDefined("middleware", middleware),
+			...ifDefined("mode", mode),
+			...ifDefined("log", log)
+		});
+		if (verify.mode === "startup") {
+			validateCodecRegistryCompleteness(this.codecRegistry, context.contract);
+			this.codecRegistryValidated = true;
+		}
+	}
+	ensureCodecRegistryValidated(contract) {
+		if (!this.codecRegistryValidated) {
+			validateCodecRegistryCompleteness(this.codecRegistry, contract);
+			this.codecRegistryValidated = true;
+		}
+	}
+	toExecutionPlan(plan) {
+		const isSqlQueryPlan = (p) => {
+			return "ast" in p && !("sql" in p);
+		};
+		return isSqlQueryPlan(plan) ? lowerSqlPlan(this.adapter, this.contract, plan) : plan;
+	}
+	executeAgainstQueryable(plan, queryable) {
+		this.ensureCodecRegistryValidated(this.contract);
+		const executablePlan = this.toExecutionPlan(plan);
+		const iterator = async function* (self) {
+			const encodedParams = encodeParams(executablePlan, self.codecRegistry);
+			const planWithEncodedParams = {
+				...executablePlan,
+				params: encodedParams
+			};
+			const coreIterator = queryable.execute(planWithEncodedParams);
+			for await (const rawRow of coreIterator) yield decodeRow(rawRow, executablePlan, self.codecRegistry, self.jsonSchemaValidators);
+		};
+		return new AsyncIterableResult(iterator(this));
+	}
+	execute(plan) {
+		return this.executeAgainstQueryable(plan, this.core);
+	}
+	async connection() {
+		const coreConn = await this.core.connection();
+		const self = this;
+		return {
+			async transaction() {
+				const coreTx = await coreConn.transaction();
+				return {
+					commit: coreTx.commit.bind(coreTx),
+					rollback: coreTx.rollback.bind(coreTx),
+					execute(plan) {
+						return self.executeAgainstQueryable(plan, coreTx);
+					}
+				};
+			},
+			release: coreConn.release.bind(coreConn),
+			execute(plan) {
+				return self.executeAgainstQueryable(plan, coreConn);
+			}
+		};
+	}
+	telemetry() {
+		return this.core.telemetry();
+	}
+	close() {
+		return this.core.close();
+	}
+};
+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 { writeContractMarker as a, lints as c, extractCodecIds as d, validateCodecRegistryCompleteness as f, readContractMarker as i, budgets as l, ensureSchemaStatement as n, createExecutionContext as o, validateContractCodecMappings as p, ensureTableStatement as r, createSqlExecutionStack as s, createRuntime as t, lowerSqlPlan as u };
+//# sourceMappingURL=exports-BO6Fl7yn.mjs.map