@prisma-next/sql-runtime 0.3.0-dev.10 → 0.3.0-dev.113

package/dist/exports-BKjZvwMh.mjs

@@ -0,0 +1,971 @@
+import { AsyncIterableResult, createRuntimeCore, evaluateRawGuardrails, runtimeError } from "@prisma-next/runtime-executor";
+import { createCodecRegistry, isQueryAst } from "@prisma-next/sql-relational-core/ast";
+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 { createOperationRegistry } from "@prisma-next/operations";
+import { createQueryOperationRegistry } from "@prisma-next/sql-relational-core/query-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/plugins/budgets.ts
+async function computeEstimatedRows(plan, driver) {
+	if (typeof driver.explain !== "function") return;
+	try {
+		return extractEstimatedRows((await driver.explain({
+			sql: plan.sql,
+			params: plan.params
+		})).rows);
+	} catch {
+		return;
+	}
+}
+function extractEstimatedRows(rows) {
+	for (const row of rows) {
+		const estimate = findPlanRows(row);
+		if (estimate !== void 0) return estimate;
+	}
+}
+function findPlanRows(node) {
+	if (!node || typeof node !== "object") return;
+	const explainNode = node;
+	const planRows = explainNode["Plan Rows"];
+	if (typeof planRows === "number") return planRows;
+	if ("Plan" in explainNode && explainNode.Plan !== void 0) {
+		const nested = findPlanRows(explainNode.Plan);
+		if (nested !== void 0) return nested;
+	}
+	if (Array.isArray(explainNode.Plans)) for (const child of explainNode.Plans) {
+		const nested = findPlanRows(child);
+		if (nested !== void 0) return nested;
+	}
+	for (const value of Object.values(node)) if (typeof value === "object" && value !== null) {
+		const nested = findPlanRows(value);
+		if (nested !== void 0) return nested;
+	}
+}
+function budgetError(code, message, details) {
+	const error = new Error(message);
+	Object.defineProperty(error, "name", {
+		value: "RuntimeError",
+		configurable: true
+	});
+	return Object.assign(error, {
+		code,
+		category: "BUDGET",
+		severity: "error",
+		details
+	});
+}
+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",
+		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 budgetError("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(budgetError("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(budgetError("BUDGET.ROWS_EXCEEDED", "Unbounded SELECT query exceeds budget", {
+					source: "ast",
+					estimatedRows: estimated,
+					maxRows
+				}), shouldBlock, ctx);
+				return;
+			}
+			emitBudgetViolation(budgetError("BUDGET.ROWS_EXCEEDED", "Unbounded SELECT query exceeds budget", {
+				source: "ast",
+				maxRows
+			}), shouldBlock, ctx);
+			return;
+		}
+		if (estimated !== null && estimated > maxRows) emitBudgetViolation(budgetError("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(budgetError("BUDGET.ROWS_EXCEEDED", "Unbounded SELECT query exceeds budget", {
+					source: "heuristic",
+					estimatedRows: estimated,
+					maxRows
+				}), shouldBlock, ctx);
+				return;
+			}
+			emitBudgetViolation(budgetError("BUDGET.ROWS_EXCEEDED", "Unbounded SELECT query exceeds budget", {
+				source: "heuristic",
+				maxRows
+			}), shouldBlock, ctx);
+			return;
+		}
+		if (estimated !== null) {
+			if (estimated > maxRows) emitBudgetViolation(budgetError("BUDGET.ROWS_EXCEEDED", "Estimated row count exceeds budget", {
+				source: "heuristic",
+				estimatedRows: estimated,
+				maxRows
+			}), shouldBlock, ctx);
+			return;
+		}
+		if (options?.explain?.enabled === true && isSelect && typeof ctx.driver === "object" && ctx.driver !== null) {
+			const estimatedRows = await computeEstimatedRows(plan, ctx.driver);
+			if (estimatedRows !== void 0) {
+				if (estimatedRows > maxRows) emitBudgetViolation(budgetError("BUDGET.ROWS_EXCEEDED", "Estimated row count exceeds budget", {
+					source: "explain",
+					estimatedRows,
+					maxRows
+				}), shouldBlock, ctx);
+			}
+		}
+	}
+}
+
+//#endregion
+//#region src/plugins/lints.ts
+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 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 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 (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 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 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 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 queryOperationRegistry = createQueryOperationRegistry();
+	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,
+		operations: operationRegistry,
+		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 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);
+			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 { 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-BKjZvwMh.mjs.map