@prisma-next/sql-runtime 0.3.0-dev.6 → 0.3.0-dev.64

package/dist/exports-BhZqJPVb.mjs

@@ -0,0 +1,771 @@
+import { AsyncIterableResult, budgets, createRuntimeCore, evaluateRawGuardrails, runtimeError } from "@prisma-next/runtime-executor";
+import { ifDefined } from "@prisma-next/utils/defined";
+import { checkContractComponentRequirements } from "@prisma-next/contract/framework-components";
+import { createExecutionStack } from "@prisma-next/core-execution-plane/stack";
+import { generateId } from "@prisma-next/ids/runtime";
+import { createOperationRegistry } from "@prisma-next/operations";
+import { createCodecRegistry } from "@prisma-next/sql-relational-core/ast";
+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/plugins/lints.ts
+const QUERY_AST_KINDS = new Set([
+	"select",
+	"insert",
+	"update",
+	"delete"
+]);
+function isSqlQueryAst(ast) {
+	if (ast === null || typeof ast !== "object" || !("kind" in ast)) return false;
+	const kind = ast.kind;
+	return typeof kind === "string" && QUERY_AST_KINDS.has(kind);
+}
+function lintError(code, message, details) {
+	const error = new Error(message);
+	Object.defineProperty(error, "name", {
+		value: "RuntimeError",
+		configurable: true
+	});
+	return Object.assign(error, {
+		code,
+		category: "LINT",
+		severity: "error",
+		details
+	});
+}
+function evaluateAstLints(ast, meta) {
+	const findings = [];
+	if (ast.kind === "delete") {
+		const deleteAst = ast;
+		if (deleteAst.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: deleteAst.table.name }
+		});
+	}
+	if (ast.kind === "update") {
+		const updateAst = ast;
+		if (updateAst.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: updateAst.table.name }
+		});
+	}
+	if (ast.kind === "select") {
+		const selectAst = ast;
+		if (selectAst.limit === void 0) findings.push({
+			code: "LINT.NO_LIMIT",
+			severity: "warn",
+			message: "Unbounded SELECT may return large result sets",
+			details: { table: selectAst.from.name }
+		});
+		if (selectAst.selectAllIntent !== void 0 || meta.annotations?.selectAllIntent !== void 0) {
+			const table = selectAst.selectAllIntent?.table ?? meta.annotations?.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)
+			});
+		}
+	}
+	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 plugin 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",
+		async beforeExecute(plan, ctx) {
+			if (isSqlQueryAst(plan.ast)) {
+				const findings = evaluateAstLints(plan.ast, plan.meta);
+				for (const lint of findings) {
+					const effectiveSeverity = getConfiguredSeverity(lint.code, options) ?? lint.severity;
+					if (effectiveSeverity === "error") throw lintError(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 lintError(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 computeExecutionDefaultValue(spec) {
+	switch (spec.kind) {
+		case "generator": return generateId(spec.params ? {
+			id: spec.id,
+			params: spec.params
+		} : { id: spec.id });
+	}
+}
+function applyMutationDefaults(contract, 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)
+		});
+		appliedColumns.add(columnName);
+	}
+	return applied;
+}
+function createExecutionContext(options) {
+	const { contract, stack } = options;
+	assertExecutionStackContractRequirements(contract, stack);
+	const codecRegistry = createCodecRegistry();
+	const operationRegistry = createOperationRegistry();
+	const contributors = [
+		stack.target,
+		stack.adapter,
+		...stack.extensionPacks
+	];
+	for (const contributor of contributors) {
+		for (const c of contributor.codecs().values()) codecRegistry.register(c);
+		for (const operation of contributor.operationSignatures()) operationRegistry.register(operation);
+	}
+	const parameterizedCodecDescriptors = collectParameterizedCodecDescriptors(contributors);
+	if (parameterizedCodecDescriptors.size > 0) validateColumnTypeParams(contract.storage, parameterizedCodecDescriptors);
+	const types = initializeTypeHelpers(contract.storage.types, parameterizedCodecDescriptors);
+	const jsonSchemaValidators = buildJsonSchemaValidatorRegistry(contract, types, parameterizedCodecDescriptors);
+	return {
+		contract,
+		operations: operationRegistry,
+		codecs: codecRegistry,
+		types,
+		...jsonSchemaValidators ? { jsonSchemaValidators } : {},
+		applyMutationDefaults: (options$1) => applyMutationDefaults(contract, 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, plan, registry) {
+	const paramName = paramDescriptor.name ?? `param_${paramDescriptor.index ?? 0}`;
+	const planCodecId = plan.meta.annotations?.codecs?.[paramName];
+	if (planCodecId) {
+		const codec$1 = registry.get(planCodecId);
+		if (codec$1) return codec$1;
+	}
+	if (paramDescriptor.codecId) {
+		const codec$1 = registry.get(paramDescriptor.codecId);
+		if (codec$1) return codec$1;
+	}
+	return null;
+}
+function encodeParam(value, paramDescriptor, plan, registry, jsonValidators) {
+	if (value === null || value === void 0) return null;
+	if (jsonValidators && paramDescriptor.refs) {
+		const { table, column } = paramDescriptor.refs;
+		validateJsonValue(jsonValidators, table, column, value, "encode", paramDescriptor.codecId);
+	}
+	const codec$1 = resolveParamCodec(paramDescriptor, plan, registry);
+	if (!codec$1) return value;
+	if (codec$1.encode) try {
+		return codec$1.encode(value);
+	} catch (error) {
+		throw new Error(`Failed to encode parameter ${paramDescriptor.name ?? paramDescriptor.index}: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	return value;
+}
+function encodeParams(plan, registry, jsonValidators) {
+	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, plan, registry, jsonValidators));
+		else encoded.push(paramValue);
+	}
+	return Object.freeze(encoded);
+}
+
+//#endregion
+//#region src/sql-family-adapter.ts
+var SqlMarkerReader = class {
+	readMarkerStatement() {
+		return readContractMarker();
+	}
+};
+var SqlFamilyAdapter = class {
+	contract;
+	markerReader;
+	constructor(contract) {
+		this.contract = contract;
+		this.markerReader = new SqlMarkerReader();
+	}
+	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.storageHash) throw runtimeError("PLAN.HASH_MISMATCH", "Plan storage hash does not match runtime contract", {
+			planStorageHash: plan.meta.storageHash,
+			runtimeStorageHash: contract.storageHash
+		});
+	}
+};
+
+//#endregion
+//#region src/sql-runtime.ts
+var SqlRuntimeImpl = class {
+	core;
+	contract;
+	adapter;
+	codecRegistry;
+	jsonSchemaValidators;
+	codecRegistryValidated;
+	constructor(options) {
+		const { context, adapter, driver, verify, plugins, mode, log } = options;
+		this.contract = context.contract;
+		this.adapter = adapter;
+		this.codecRegistry = context.codecs;
+		this.jsonSchemaValidators = context.jsonSchemaValidators;
+		this.codecRegistryValidated = false;
+		this.core = createRuntimeCore({
+			familyAdapter: new SqlFamilyAdapter(context.contract),
+			driver,
+			verify,
+			plugins,
+			...ifDefined("mode", mode),
+			...ifDefined("log", log),
+			operationRegistry: context.operations
+		});
+		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, self.jsonSchemaValidators);
+			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();
+	}
+	operations() {
+		return this.core.operations();
+	}
+	close() {
+		return this.core.close();
+	}
+};
+function createRuntime(options) {
+	const { stackInstance, context, driver, verify, plugins, mode, log } = options;
+	return new SqlRuntimeImpl({
+		context,
+		adapter: stackInstance.adapter,
+		driver,
+		verify,
+		...ifDefined("plugins", plugins),
+		...ifDefined("mode", mode),
+		...ifDefined("log", log)
+	});
+}
+
+//#endregion
+export { readContractMarker as a, createSqlExecutionStack as c, extractCodecIds as d, validateCodecRegistryCompleteness as f, ensureTableStatement as i, lints as l, createRuntime as n, writeContractMarker as o, validateContractCodecMappings as p, ensureSchemaStatement as r, createExecutionContext as s, budgets as t, lowerSqlPlan as u };
+//# sourceMappingURL=exports-BhZqJPVb.mjs.map