@prisma-next/sql-runtime 0.5.0-dev.60 → 0.5.0-dev.61

package/dist/{exports-BcX9wp4z.mjs → exports-CZIUsCRE.mjs}

@@ -1,11 +1,11 @@
 import { AsyncIterableResult, RuntimeCore, checkAborted, checkMiddlewareCompatibility, isRuntimeError, raceAgainstAbort, runWithMiddleware, runtimeError } from "@prisma-next/framework-components/runtime";
 import { type } from "arktype";
-import { collectOrderedParamRefs, createCodecRegistry, isQueryAst } from "@prisma-next/sql-relational-core/ast";
+import { collectOrderedParamRefs, isQueryAst, validateParamRefRefs } from "@prisma-next/sql-relational-core/ast";
 import { ifDefined } from "@prisma-next/utils/defined";
-import { synthesizeNonParameterizedDescriptor } from "@prisma-next/framework-components/codec";
 import { checkContractComponentRequirements } from "@prisma-next/framework-components/components";
 import { createExecutionStack } from "@prisma-next/framework-components/execution";
 import { createSqlOperationRegistry } from "@prisma-next/sql-operations";
+import { buildCodecDescriptorRegistry } from "@prisma-next/sql-relational-core/codec-descriptor-registry";
 import { canonicalStringify } from "@prisma-next/utils/canonical-stringify";
 import { hashContent } from "@prisma-next/utils/hash-content";
 import { createHash } from "node:crypto";
@@ -28,17 +28,10 @@ function extractCodecIdsFromColumns(contract) {
 	}
 	return codecIds;
 }
-function adaptDescriptorRegistry(registry) {
-	return { has: (id) => registry.descriptorFor(id) !== void 0 };
-}
-function isDescriptorRegistry(registry) {
-	return "descriptorFor" in registry;
-}
 function validateContractCodecMappings(registry, contract) {
-	const lookup = isDescriptorRegistry(registry) ? adaptDescriptorRegistry(registry) : registry;
 	const codecIds = extractCodecIdsFromColumns(contract);
 	const invalidCodecs = [];
-	for (const [key, codecId] of codecIds.entries()) if (!lookup.has(codecId)) {
+	for (const [key, codecId] of codecIds.entries()) if (registry.descriptorFor(codecId) === void 0) {
 		const parts = key.split(".");
 		const table = parts[0] ?? "";
 		const column = parts[1] ?? "";
@@ -138,14 +131,12 @@ function primaryTableFromAst(ast) {
 	switch (ast.from.kind) {
 		case "table-source": return ast.from.name;
 		case "derived-table-source": return ast.from.alias;
-		default: return;
+		default: throw new Error(`Unsupported source kind: ${ast.from.kind}`);
 	}
 }
 function estimateRowsFromAst(ast, tableRows, defaultTableRows, hasAggregateWithoutGroup) {
 	if (hasAggregateWithoutGroup) return 1;
-	const table = primaryTableFromAst(ast);
-	if (!table) return null;
-	const tableEstimate = tableRows[table] ?? defaultTableRows;
+	const tableEstimate = tableRows[primaryTableFromAst(ast)] ?? defaultTableRows;
 	if (ast.limit !== void 0) return Math.min(ast.limit, tableEstimate);
 	return tableEstimate;
 }
@@ -198,21 +189,17 @@ function budgets(options) {
 		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", {
+			emitBudgetViolation(runtimeError("BUDGET.ROWS_EXCEEDED", "Unbounded SELECT query exceeds budget", estimated >= maxRows ? {
+				source: "ast",
+				estimatedRows: estimated,
+				maxRows
+			} : {
 				source: "ast",
 				maxRows
 			}), shouldBlock, ctx);
 			return;
 		}
-		if (estimated !== null && estimated > maxRows) emitBudgetViolation(runtimeError("BUDGET.ROWS_EXCEEDED", "Estimated row count exceeds budget", {
+		if (estimated > maxRows) emitBudgetViolation(runtimeError("BUDGET.ROWS_EXCEEDED", "Estimated row count exceeds budget", {
 			source: "ast",
 			estimatedRows: estimated,
 			maxRows
@@ -446,68 +433,41 @@ function assertExecutionStackContractRequirements(contract, stack) {
 		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["~standard"].validate(typeParams);
-	if (result instanceof Promise) throw runtimeError("RUNTIME.TYPE_PARAMS_INVALID", `paramsSchema for codec '${codecDescriptor.codecId}' returned a Promise; runtime validation requires a synchronous Standard Schema validator.`, {
+function validateTypeParams(typeParams, descriptor, context) {
+	const result = descriptor.paramsSchema["~standard"].validate(typeParams);
+	if (result instanceof Promise) throw runtimeError("RUNTIME.TYPE_PARAMS_INVALID", `paramsSchema for codec '${descriptor.codecId}' returned a Promise; runtime validation requires a synchronous Standard Schema validator.`, {
 		...context,
-		codecId: codecDescriptor.codecId,
+		codecId: descriptor.codecId,
 		typeParams
 	});
 	if (result.issues) {
 		const messages = result.issues.map((issue) => issue.message).join("; ");
-		throw runtimeError("RUNTIME.TYPE_PARAMS_INVALID", `Invalid typeParams for ${context.typeName ? `type '${context.typeName}'` : `column '${context.tableName}.${context.columnName}'`} (codecId: ${codecDescriptor.codecId}): ${messages}`, {
+		throw runtimeError("RUNTIME.TYPE_PARAMS_INVALID", `Invalid typeParams for ${context.typeName ? `type '${context.typeName}'` : `column '${context.tableName}.${context.columnName}'`} (codecId: ${descriptor.codecId}): ${messages}`, {
 			...context,
-			codecId: codecDescriptor.codecId,
+			codecId: descriptor.codecId,
 			typeParams
 		});
 	}
 	return result.value;
 }
-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;
-}
 /**
-* Build the unified descriptor map. Combines parameterized descriptors
-* (which already ship as `CodecDescriptor`s) with synthesized descriptors
-* for non-parameterized codecs registered through the legacy `codecs:`
-* slot. Codec ids that ship a parameterized descriptor take precedence —
-* even when the legacy registry registers a representative codec under
-* the same id, the parameterized descriptor is the authoritative source.
+* Collect every {@link CodecDescriptor} contributed by the SQL stack and partition into "parameterized" vs "non-parameterized" via the descriptor's own {@link CodecDescriptorImpl.isParameterized} getter. The getter is the canonical discriminator — a `paramsSchema` identity check would misroute any descriptor that doesn't reuse the exact `voidParamsSchema` singleton (e.g. a non-parameterized codec authoring its own no-op schema).
 *
-* Codec-registry-unification spec § Decision: every codec resolves
-* through one descriptor map; reads are non-branching.
+* The unified descriptor list collapses the legacy split (a separate slot used to register parameterized codecs) — every codec id resolves through the same map (codec-registry-unification spec § Decision).
 */
-function buildCodecDescriptorRegistry(codecRegistry, parameterizedDescriptors) {
-	const byId = /* @__PURE__ */ new Map();
-	const byTargetType = /* @__PURE__ */ new Map();
-	function registerInIndices(descriptor) {
-		byId.set(descriptor.codecId, descriptor);
-		for (const targetType of descriptor.targetTypes) {
-			const list = byTargetType.get(targetType);
-			if (list) list.push(descriptor);
-			else byTargetType.set(targetType, [descriptor]);
-		}
-	}
-	for (const descriptor of parameterizedDescriptors.values()) registerInIndices(descriptor);
-	for (const codec$1 of codecRegistry.values()) {
-		if (byId.has(codec$1.id)) continue;
-		registerInIndices(synthesizeNonParameterizedDescriptor(codec$1));
+function collectCodecDescriptors(contributors) {
+	const all = [];
+	const parameterized = /* @__PURE__ */ new Map();
+	const seen = /* @__PURE__ */ new Set();
+	for (const contributor of contributors) for (const descriptor of contributor.codecs()) {
+		if (seen.has(descriptor.codecId)) throw runtimeError("RUNTIME.DUPLICATE_CODEC", `Duplicate codec descriptor for codecId '${descriptor.codecId}'.`, { codecId: descriptor.codecId });
+		seen.add(descriptor.codecId);
+		all.push(descriptor);
+		if (descriptor.isParameterized) parameterized.set(descriptor.codecId, descriptor);
 	}
 	return {
-		descriptorFor(codecId) {
-			return byId.get(codecId);
-		},
-		*values() {
-			yield* byId.values();
-		},
-		byTargetType(targetType) {
-			return byTargetType.get(targetType) ?? Object.freeze([]);
-		}
+		all,
+		parameterized
 	};
 }
 function collectTypeRefSites(storage) {
@@ -553,50 +513,43 @@ function validateColumnTypeParams(storage, codecDescriptors) {
 		});
 	}
 }
-function hasJsonValidatorTrait(candidate) {
-	if (candidate === null || typeof candidate !== "object") return false;
-	const traits = candidate.traits;
-	if (!Array.isArray(traits)) return false;
-	if (!traits.includes("json-validator")) return false;
-	return typeof candidate.validate === "function";
-}
-function extractValidator(candidate) {
-	return hasJsonValidatorTrait(candidate) ? candidate.validate : void 0;
-}
 function isResolvedCodec(candidate) {
 	return candidate !== null && typeof candidate === "object" && "id" in candidate && "decode" in candidate;
 }
 /**
-* Walk the contract's `storage.tables[].columns[]` and resolve each
-* column to a `Codec` through the unified descriptor map. Per-instance
-* behavior:
-*
-* - **typeRef columns**: reuse the resolved codec materialized once by
-*   `initializeTypeHelpers` for the `storage.types` entry. Multiple
-*   columns sharing one typeRef share one codec instance.
-* - **inline-typeParams columns**: call `descriptor.factory(typeParams)
-*   (ctx)` once per column (per-column anonymous instance).
-* - **non-parameterized columns**: call `descriptor.factory()(ctx)`
-*   once. The synthesized descriptor's factory is constant — every call
-*   returns the same shared codec instance — so columns sharing a non-
-*   parameterized codec id share one resolved codec without explicit
-*   caching.
+* Walk the contract's `storage.tables[].columns[]` and resolve each column to a `Codec` through the unified descriptor map. Per-instance behavior:
 *
-* Combines what `initializeTypeHelpers` (named-instance walk) and the
-* old `buildJsonSchemaValidatorRegistry` (per-column walk) used to do
-* separately: one walk over all columns, one resolved codec per column,
-* one trait-gated validator extraction per column. The result drives
-* both the dispatch registry (`ContractCodecRegistry.forColumn`) and the
-* validator registry.
+* - **typeRef columns**: reuse the resolved codec materialized once by `initializeTypeHelpers` for the `storage.types` entry. Multiple columns sharing one typeRef share one codec instance.
+* - **inline-typeParams columns**: call `descriptor.factory(typeParams) (ctx)` once per column (per-column anonymous instance).
+* - **non-parameterized columns**: call `descriptor.factory()(ctx)` once. The synthesized descriptor's factory is constant — every call returns the same shared codec instance — so columns sharing a non-parameterized codec id share one resolved codec without explicit caching.
 *
-* Codec-registry-unification spec § AC-4: every column resolves through
-* one descriptor map without branching on parameterization.
+* Codec-registry-unification spec § AC-4: every column resolves through one descriptor map without branching on parameterization. JSON-Schema validation, when required, lives inside the resolved codec's `decode` body (see `arktype-json`'s `ArktypeJsonCodecClass`); the framework no longer maintains a parallel validator registry.
 */
-function buildContractCodecRegistry(contract, codecDescriptors, legacyCodecRegistry, types, parameterizedDescriptors) {
+function buildContractCodecRegistry(contract, codecDescriptors, types, parameterizedDescriptors) {
 	const byColumn = /* @__PURE__ */ new Map();
 	const byCodecId = /* @__PURE__ */ new Map();
 	const ambiguousCodecIds = /* @__PURE__ */ new Set();
-	const validators = /* @__PURE__ */ new Map();
+	for (const descriptor of codecDescriptors.values()) {
+		if (descriptor.isParameterized) continue;
+		const ctx = {
+			name: `<shared:${descriptor.codecId}>`,
+			usedAt: []
+		};
+		const voidFactory = descriptor.factory;
+		byCodecId.set(descriptor.codecId, voidFactory(void 0)(ctx));
+	}
+	const parameterizedRepresentatives = /* @__PURE__ */ new Map();
+	for (const descriptor of codecDescriptors.values()) {
+		if (!descriptor.isParameterized) continue;
+		const ctx = {
+			name: `<shared:${descriptor.codecId}>`,
+			usedAt: []
+		};
+		const factory = descriptor.factory.bind(descriptor);
+		try {
+			parameterizedRepresentatives.set(descriptor.codecId, factory(void 0)(ctx));
+		} catch {}
+	}
 	for (const [tableName, table] of Object.entries(contract.storage.tables)) for (const [columnName, column] of Object.entries(table.columns)) {
 		const columnKey = `${tableName}.${columnName}`;
 		const descriptor = codecDescriptors.descriptorFor(column.codecId);
@@ -614,7 +567,7 @@ function buildContractCodecRegistry(contract, codecDescriptors, legacyCodecRegis
 						columnName
 					});
 					const ctx = {
-						name: `<anon:${tableName}.${columnName}>`,
+						name: `<col:${tableName}.${columnName}>`,
 						usedAt: [{
 							table: tableName,
 							column: columnName
@@ -623,45 +576,31 @@ function buildContractCodecRegistry(contract, codecDescriptors, legacyCodecRegis
 					resolvedCodec = parameterizedDescriptor.factory(validatedParams)(ctx);
 				}
 			} else if (!isParameterized) {
-				let cached = byCodecId.get(column.codecId);
-				if (!cached) {
-					const ctx = {
-						name: `<shared:${column.codecId}>`,
-						usedAt: [{
-							table: tableName,
-							column: columnName
-						}]
-					};
-					const voidFactory = descriptor.factory;
-					cached = voidFactory(void 0)(ctx);
-					byCodecId.set(column.codecId, cached);
-				}
-				resolvedCodec = cached;
+				const ctx = {
+					name: `<col:${tableName}.${columnName}>`,
+					usedAt: [{
+						table: tableName,
+						column: columnName
+					}]
+				};
+				resolvedCodec = descriptor.factory.bind(descriptor)(void 0)(ctx);
 			}
 		}
 		if (resolvedCodec) {
 			byColumn.set(columnKey, resolvedCodec);
-			const validate = extractValidator(resolvedCodec);
-			if (validate) validators.set(columnKey, validate);
 			const existing = byCodecId.get(column.codecId);
 			if (existing === void 0) byCodecId.set(column.codecId, resolvedCodec);
 			else if (existing !== resolvedCodec && parameterizedDescriptors.has(column.codecId)) ambiguousCodecIds.add(column.codecId);
 		}
 	}
 	return {
-		registry: {
-			forColumn(table, column) {
-				return byColumn.get(`${table}.${column}`);
-			},
-			forCodecId(codecId) {
-				if (ambiguousCodecIds.has(codecId)) throw runtimeError("RUNTIME.TYPE_PARAMS_INVALID", `Codec '${codecId}' resolves to multiple parameterized instances; column-aware dispatch is required.`, { codecId });
-				return byCodecId.get(codecId) ?? legacyCodecRegistry.get(codecId);
-			}
+		forColumn(table, column) {
+			return byColumn.get(`${table}.${column}`);
 		},
-		jsonValidators: validators.size > 0 ? {
-			get: (key) => validators.get(key),
-			size: validators.size
-		} : void 0
+		forCodecId(codecId) {
+			if (ambiguousCodecIds.has(codecId)) throw runtimeError("RUNTIME.TYPE_PARAMS_INVALID", `Codec '${codecId}' resolves to multiple parameterized instances; column-aware dispatch is required.`, { codecId });
+			return byCodecId.get(codecId) ?? parameterizedRepresentatives.get(codecId);
+		}
 	};
 }
 function assertMutationDefaultGeneratorsAvailable(contract, generatorRegistry) {
@@ -744,30 +683,25 @@ function scopedCache(stability, rowCache, queryCache) {
 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 { all: allCodecDescriptors, parameterized: parameterizedCodecDescriptors } = collectCodecDescriptors(contributors);
 	const queryOperationRegistry = createSqlOperationRegistry();
 	for (const contributor of contributors) for (const op of contributor.queryOperations?.() ?? []) queryOperationRegistry.register(op);
-	const parameterizedCodecDescriptors = collectParameterizedCodecDescriptors(contributors);
-	const codecDescriptors = buildCodecDescriptorRegistry(codecRegistry, parameterizedCodecDescriptors);
+	const codecDescriptors = buildCodecDescriptorRegistry(allCodecDescriptors);
 	const mutationDefaultGeneratorRegistry = collectMutationDefaultGenerators(contributors);
 	assertMutationDefaultGeneratorsAvailable(contract, mutationDefaultGeneratorRegistry);
 	if (parameterizedCodecDescriptors.size > 0) validateColumnTypeParams(contract.storage, parameterizedCodecDescriptors);
 	const types = initializeTypeHelpers(contract.storage, parameterizedCodecDescriptors);
-	const { registry: contractCodecs, jsonValidators: jsonSchemaValidators } = buildContractCodecRegistry(contract, codecDescriptors, codecRegistry, types, parameterizedCodecDescriptors);
 	return {
 		contract,
-		codecs: codecRegistry,
-		contractCodecs,
+		contractCodecs: buildContractCodecRegistry(contract, codecDescriptors, types, parameterizedCodecDescriptors),
 		codecDescriptors,
 		queryOperations: queryOperationRegistry,
 		types,
-		...jsonSchemaValidators ? { jsonSchemaValidators } : {},
 		applyMutationDefaults: (options$1) => applyMutationDefaults(contract, mutationDefaultGeneratorRegistry, options$1)
 	};
 }
@@ -882,37 +816,31 @@ function writeContractMarker(input) {
 }
 
 //#endregion
-//#region src/codecs/json-schema-validation.ts
+//#region src/codecs/alias-resolver.ts
 /**
-* Validates a JSON value against its column's JSON Schema, if a validator exists.
+* Build a map from query-local table aliases to their underlying source table names.
 *
-* Throws `RUNTIME.JSON_SCHEMA_VALIDATION_FAILED` on validation failure.
-* No-ops if no validator is registered for the column.
+* Self-joins like `db.sql.post.as('p1').innerJoin(db.sql.post.as('p2'), …)` produce `ColumnRef`s whose `table` is the alias (`p1`, `p2`) — the SQL renderer needs the alias for `SELECT p1.id, …`. Codec dispatch keys `byColumn` by the underlying source table, so aliases must be resolved back to the source name for `forColumn(...)` to hit. Tables that already use their canonical name (no alias) are also entered so a single
+* lookup works for both shapes.
 */
-function 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 buildAliasMap(ast) {
+	const aliases = /* @__PURE__ */ new Map();
+	const recordSource = (source) => {
+		if (source.kind === "table-source") {
+			const key = source.alias ?? source.name;
+			aliases.set(key, source.name);
+		} else aliases.set(source.alias, source.alias);
+	};
+	if (ast.kind === "select") {
+		recordSource(ast.from);
+		for (const join of ast.joins ?? []) recordSource(join.source);
+	} else recordSource(ast.table);
+	return aliases;
 }
-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("; ");
+function makeAliasResolver(ast) {
+	if (!ast) return (alias) => alias;
+	const map = buildAliasMap(ast);
+	return (alias) => map.get(alias) ?? alias;
 }
 
 //#endregion
@@ -929,32 +857,29 @@ function projectionListFromAst(ast) {
 /**
 * Resolve the per-cell codec for a projection item.
 *
-* Phase B: when a `(table, column)` ref is available for the projection,
-* prefer `contractCodecs.forColumn(table, column)` — that's the per-
-* instance resolved codec materialized from the codec descriptor's
-* factory at context-construction time (carries any per-instance state
-* such as the compiled JSON-Schema validator). When the projection
-* resolves to a non-`column-ref` expression (computed projections, raw
-* SQL aliases) but still carries a codec id (ADR 205 stamps every
-* `ProjectionItem` with the producer's codec id), fall back to the
-* codec-id-keyed `forCodecId(codecId)` lookup, which itself falls back
-* to the legacy `CodecRegistry` for codec ids the contract walk
-* couldn't resolve.
+* When a `(table, column)` ref is available — either implicit on a `column-ref` expression or carried explicitly via `item.refs` for column-bound non-`column-ref` projections — prefer `contractCodecs.forColumn(table, column)`: that returns the per-instance codec materialized from the descriptor's factory for that column, encoding any per-instance state (typeParams like vector length, schema validators, etc.).
+*
+* The wrong-instance risk for parameterized codecs is closed off structurally:
+*
+* 1. `buildContractCodecRegistry` pre-populates `byCodecId` with one canonical instance per non-parameterized descriptor; parameterized descriptors are intentionally absent. 2. `forCodecId` rejects ambiguous parameterized fallbacks (`ambiguousCodecIds`). 3. The non-ambiguous parameterized case stores the column-correct per-instance codec under `byCodecId`, so the fall-through still resolves to the right instance.
 *
-* Codec-registry-unification spec § AC-4.
+* The `forCodecId` fallback otherwise covers projections that are *not* column-bound (computed projections, raw SQL aliases) but still carry a `codecId` (ADR 205 stamps every `ProjectionItem` with the producer's codec id).
+*
+* Codec-registry-unification spec § AC-4 / AC-5.
 */
-function resolveProjectionCodec(item, registry, contractCodecs) {
-	if (item.expr.kind === "column-ref" && contractCodecs) {
-		const byColumn = contractCodecs.forColumn(item.expr.table, item.expr.column);
-		if (byColumn) return byColumn;
-	}
-	if (item.codecId) {
-		const fromContract = contractCodecs?.forCodecId(item.codecId);
-		if (fromContract) return fromContract;
-		return registry.get(item.codecId);
+function resolveProjectionCodec(item, contractCodecs, aliasResolver) {
+	if (contractCodecs) {
+		if (item.expr.kind === "column-ref") {
+			const byColumn = contractCodecs.forColumn(aliasResolver(item.expr.table), item.expr.column);
+			if (byColumn && (item.codecId === void 0 || byColumn.id === item.codecId)) return byColumn;
+		} else if (item.refs) {
+			const byColumn = contractCodecs.forColumn(aliasResolver(item.refs.table), item.refs.column);
+			if (byColumn && (item.codecId === void 0 || byColumn.id === item.codecId)) return byColumn;
+		}
 	}
+	if (item.codecId) return contractCodecs?.forCodecId(item.codecId);
 }
-function buildDecodeContext(plan, registry, contractCodecs) {
+function buildDecodeContext(plan, contractCodecs) {
 	if (!isAstBackedPlan(plan)) return {
 		aliases: void 0,
 		codecs: /* @__PURE__ */ new Map(),
@@ -972,14 +897,19 @@ function buildDecodeContext(plan, registry, contractCodecs) {
 	const codecs = /* @__PURE__ */ new Map();
 	const columnRefs = /* @__PURE__ */ new Map();
 	const includeAliases = /* @__PURE__ */ new Set();
+	const aliasResolver = makeAliasResolver(plan.ast);
 	for (const item of projection) {
 		aliases.push(item.alias);
-		const codec$1 = resolveProjectionCodec(item, registry, contractCodecs);
-		if (codec$1) codecs.set(item.alias, codec$1);
+		const codec = resolveProjectionCodec(item, contractCodecs, aliasResolver);
+		if (codec) codecs.set(item.alias, codec);
 		if (item.expr.kind === "column-ref") columnRefs.set(item.alias, {
-			table: item.expr.table,
+			table: aliasResolver(item.expr.table),
 			column: item.expr.column
 		});
+		else if (item.refs) columnRefs.set(item.alias, {
+			table: aliasResolver(item.refs.table),
+			column: item.refs.column
+		});
 		else if (item.expr.kind === "subquery" || item.expr.kind === "json-array-agg") includeAliases.add(item.alias);
 	}
 	return {
@@ -993,17 +923,14 @@ function previewWireValue(wireValue) {
 	if (typeof wireValue === "string") return wireValue.length > WIRE_PREVIEW_LIMIT ? `${wireValue.substring(0, WIRE_PREVIEW_LIMIT)}...` : wireValue;
 	return String(wireValue).substring(0, WIRE_PREVIEW_LIMIT);
 }
-function isJsonSchemaValidationError(error) {
-	return isRuntimeError(error) && error.code === "RUNTIME.JSON_SCHEMA_VALIDATION_FAILED";
-}
-function wrapDecodeFailure(error, alias, ref, codec$1, wireValue) {
+function wrapDecodeFailure(error, alias, ref, codec, wireValue) {
 	const message = error instanceof Error ? error.message : String(error);
-	const wrapped = runtimeError("RUNTIME.DECODE_FAILED", `Failed to decode column ${ref ? `${ref.table}.${ref.column}` : alias} with codec '${codec$1.id}': ${message}`, {
+	const wrapped = runtimeError("RUNTIME.DECODE_FAILED", `Failed to decode column ${ref ? `${ref.table}.${ref.column}` : alias} with codec '${codec.id}': ${message}`, {
 		...ref ? {
 			table: ref.table,
 			column: ref.column
 		} : { alias },
-		codec: codec$1.id,
+		codec: codec.id,
 		wirePreview: previewWireValue(wireValue)
 	});
 	wrapped.cause = error;
@@ -1031,24 +958,16 @@ function decodeIncludeAggregate(alias, wireValue) {
 	}
 }
 /**
-* Decodes a single field. Single-armed: every cell takes the same path —
-* `codec.decode → await → JSON-Schema validate → return plain value` — so
-* sync- and async-authored codecs are indistinguishable to callers.
+* Decodes a single field. Single-armed: every cell takes the same path — `codec.decode → await → return plain value` — so sync- and async-authored codecs are indistinguishable to callers. JSON-Schema validation, when required, lives inside the resolved codec's `decode` body (e.g. `arktype-json` validates against its rehydrated schema and throws `RUNTIME.JSON_SCHEMA_VALIDATION_FAILED` from `decode` directly); there is
+* no separate validator-registry pass.
 *
-* The row-level `rowCtx` is repackaged into a per-cell
-* `SqlCodecCallContext` whose `column = { table, name }` is a structural
-* projection of the per-cell `ColumnRef = { table, column }` resolved from
-* the AST-backed `DecodeContext` (the same resolution `wrapDecodeFailure`
-* uses for envelope construction — one resolution per cell, two consumers).
-* Cells the runtime cannot resolve to a single underlying column (aggregate
-* aliases, computed projections without a simple ref) get
-* `column: undefined`, matching the spec contract that the runtime never
-* silently defaults this field.
+* The row-level `rowCtx` is repackaged into a per-cell `SqlCodecCallContext` whose `column = { table, name }` is a structural projection of the per-cell `ColumnRef = { table, column }` resolved from the AST-backed `DecodeContext` (the same resolution `wrapDecodeFailure` uses for envelope construction — one resolution per cell, two consumers). Cells the runtime cannot resolve to a single underlying column (aggregate
+* aliases, computed projections without a simple ref) get `column: undefined`, matching the spec contract that the runtime never silently defaults this field.
 */
-async function decodeField(alias, wireValue, decodeCtx, jsonValidators, rowCtx) {
+async function decodeField(alias, wireValue, decodeCtx, rowCtx) {
 	if (wireValue === null) return null;
-	const codec$1 = decodeCtx.codecs.get(alias);
-	if (!codec$1) return wireValue;
+	const codec = decodeCtx.codecs.get(alias);
+	if (!codec) return wireValue;
 	const ref = decodeCtx.columnRefs.get(alias);
 	let cellCtx;
 	if (ref) cellCtx = {
@@ -1062,42 +981,26 @@ async function decodeField(alias, wireValue, decodeCtx, jsonValidators, rowCtx)
 		const { column: _drop, ...rowCtxWithoutColumn } = rowCtx;
 		cellCtx = rowCtxWithoutColumn;
 	}
-	let decoded;
 	try {
-		decoded = await codec$1.decode(wireValue, cellCtx);
-	} catch (error) {
-		wrapDecodeFailure(error, alias, ref, codec$1, wireValue);
-	}
-	if (jsonValidators && ref) try {
-		validateJsonValue(jsonValidators, ref.table, ref.column, decoded, "decode", codec$1.id);
+		return await codec.decode(wireValue, cellCtx);
 	} catch (error) {
-		if (isJsonSchemaValidationError(error)) throw error;
-		wrapDecodeFailure(error, alias, ref, codec$1, wireValue);
+		if (isRuntimeError(error)) throw error;
+		wrapDecodeFailure(error, alias, ref, codec, wireValue);
 	}
-	return decoded;
 }
 /**
-* Decodes a row by dispatching all per-cell codec calls concurrently via
-* `Promise.all`. Each cell follows the single-armed `decodeField` path.
-* Failures are wrapped in `RUNTIME.DECODE_FAILED` with `{ table, column,
-* codec }` (or `{ alias, codec }` when no column ref is resolvable) and the
-* original error attached on `cause`.
+* Decodes a row by dispatching all per-cell codec calls concurrently via `Promise.all`. Each cell follows the single-armed `decodeField` path. Failures are wrapped in `RUNTIME.DECODE_FAILED` with `{ table, column, codec }` (or `{ alias, codec }` when no column ref is resolvable) and the original error attached on `cause`.
 *
 * When `rowCtx.signal` is provided:
 *
-* - **Already-aborted at entry** short-circuits with `RUNTIME.ABORTED`
-*   (`{ phase: 'decode' }`) before any `codec.decode` call is made.
-* - **Mid-flight aborts** race the per-cell `Promise.all` against the
-*   signal so the runtime returns promptly even when codec bodies ignore
-*   it. In-flight bodies that ignore the signal complete in the
-*   background (cooperative cancellation).
-* - Existing `RUNTIME.DECODE_FAILED` envelopes from codec bodies pass
-*   through unchanged (no double wrap).
+* - **Already-aborted at entry** short-circuits with `RUNTIME.ABORTED` (`{ phase: 'decode' }`) before any `codec.decode` call is made.
+* - **Mid-flight aborts** race the per-cell `Promise.all` against the signal so the runtime returns promptly even when codec bodies ignore it. In-flight bodies that ignore the signal complete in the background (cooperative cancellation).
+* - Existing `RUNTIME.DECODE_FAILED` envelopes from codec bodies pass through unchanged (no double wrap).
 */
-async function decodeRow(row, plan, registry, jsonValidators, rowCtx, contractCodecs) {
+async function decodeRow(row, plan, rowCtx, contractCodecs) {
 	checkAborted(rowCtx, "decode");
 	const signal = rowCtx.signal;
-	const decodeCtx = buildDecodeContext(plan, registry, contractCodecs);
+	const decodeCtx = buildDecodeContext(plan, contractCodecs);
 	const aliases = decodeCtx.aliases ?? Object.keys(row);
 	if (decodeCtx.aliases !== void 0) {
 		for (const alias of decodeCtx.aliases) if (!Object.hasOwn(row, alias)) throw runtimeError("RUNTIME.DECODE_FAILED", `Row missing projection alias "${alias}"`, {
@@ -1120,7 +1023,7 @@ async function decodeRow(row, plan, registry, jsonValidators, rowCtx, contractCo
 			tasks.push(Promise.resolve(void 0));
 			continue;
 		}
-		tasks.push(decodeField(alias, wireValue, decodeCtx, jsonValidators, rowCtx));
+		tasks.push(decodeField(alias, wireValue, decodeCtx, rowCtx));
 	}
 	const settled = await raceAgainstAbort(Promise.all(tasks), signal, "decode");
 	for (const entry of includeIndices) settled[entry.index] = decodeIncludeAggregate(entry.alias, entry.value);
@@ -1133,35 +1036,28 @@ async function decodeRow(row, plan, registry, jsonValidators, rowCtx, contractCo
 //#region src/codecs/encoding.ts
 const NO_METADATA = Object.freeze({
 	codecId: void 0,
-	name: void 0
+	name: void 0,
+	refs: void 0
 });
 /**
 * Resolve the codec for an outgoing param.
 *
-* Phase B (and AC-5-deferred carve-out): `ParamRef` does not carry a
-* `(table, column)` ref today — every `ParamRef` carries `codecId` but
-* not the column it relates to. Encode-side dispatch therefore consults
-* `contractCodecs.forCodecId(codecId)` (which itself prefers the
-* contract-walk-derived shared codec, falling back to the legacy
-* `CodecRegistry.get` for parameterized codec ids whose contracts don't
-* have a column the walk could resolve through).
+* Column-aware dispatch: when `metadata.refs` is populated by a column-bound construction site, prefer `contractCodecs.forColumn(refs.table, refs.column)` — that returns the per-instance codec the contract walk materialized for the `(table, column)` pair, encoding the column's typeParams (e.g. `vector(1024)` vs. `vector(1536)`).
+*
+* On a column-lookup miss the resolver falls through to `forCodecId`. The wrong-instance risk for parameterized codecs is closed off structurally:
 *
-* For the parameterized codecs shipped at Phase B (pgvector, postgres
-* json/jsonb), encode is per-instance-stateless w.r.t. params:
-* - pgvector formats `[v1,v2,...]` regardless of declared length;
-* - postgres json/jsonb encode is `JSON.stringify` regardless of schema.
+* 1. `buildContractCodecRegistry` pre-populates `byCodecId` with one canonical instance per non-parameterized descriptor; parameterized descriptors are intentionally absent from this pre-population. 2. `forCodecId` rejects ambiguous parameterized fallbacks (`ambiguousCodecIds`) — if the contract walk resolved more than one distinct instance under a single parameterized id, the call throws rather than binding to
+* whichever landed first. 3. For the non-ambiguous parameterized case (a single column with that id), `byCodecId` stores the column-correct per-instance codec, so the fall-through still resolves to the right instance.
 *
-* So the codec-id-keyed lookup yields a structurally equivalent encoder
-* even when the resolved per-instance codec carries extra state (e.g. a
-* compiled JSON-Schema validator used only by `decode`). TML-2357 retires
-* the fallback by threading `ParamRef.refs` through column-bound
-* construction sites.
+* Refs-less fallback: ParamRefs constructed outside a column-bound site (literals, transient builder state) carry a non-parameterized `codecId` whose dispatch is ambiguity-free. The validator pass (`validateParamRefRefs`) already enforced refs on every parameterized ParamRef before encode runs.
 */
-function resolveParamCodec(metadata, registry, contractCodecs) {
+function resolveParamCodec(metadata, contractCodecs, aliasResolver) {
 	if (!metadata.codecId) return void 0;
-	const fromContract = contractCodecs?.forCodecId(metadata.codecId);
-	if (fromContract) return fromContract;
-	return registry.get(metadata.codecId);
+	if (metadata.refs && contractCodecs) {
+		const byColumn = contractCodecs.forColumn(aliasResolver(metadata.refs.table), metadata.refs.column);
+		if (byColumn && byColumn.id === metadata.codecId) return byColumn;
+	}
+	return contractCodecs?.forCodecId(metadata.codecId);
 }
 function paramLabel(metadata, paramIndex) {
 	return metadata.name ?? `param[${paramIndex}]`;
@@ -1176,36 +1072,26 @@ function wrapEncodeFailure(error, metadata, paramIndex, codecId) {
 	wrapped.cause = error;
 	throw wrapped;
 }
-async function encodeParamValue(value, metadata, paramIndex, registry, ctx, contractCodecs) {
+async function encodeParamValue(value, metadata, paramIndex, ctx, contractCodecs, aliasResolver) {
 	if (value === null || value === void 0) return null;
-	const codec$1 = resolveParamCodec(metadata, registry, contractCodecs);
-	if (!codec$1) return value;
+	const codec = resolveParamCodec(metadata, contractCodecs, aliasResolver);
+	if (!codec) return value;
 	try {
-		return await codec$1.encode(value, ctx);
+		return await codec.encode(value, ctx);
 	} catch (error) {
-		wrapEncodeFailure(error, metadata, paramIndex, codec$1.id);
+		wrapEncodeFailure(error, metadata, paramIndex, codec.id);
 	}
 }
 /**
-* Encodes all parameters concurrently via `Promise.all`. Per parameter, sync-
-* and async-authored codecs share the same path: `codec.encode → await →
-* return`. Param-level failures are wrapped in `RUNTIME.ENCODE_FAILED`.
+* Encodes all parameters concurrently via `Promise.all`. Per parameter, sync-and async-authored codecs share the same path: `codec.encode → await → return`. Param-level failures are wrapped in `RUNTIME.ENCODE_FAILED`.
 *
 * When `ctx.signal` is provided:
 *
-* - **Already-aborted at entry** short-circuits with `RUNTIME.ABORTED`
-*   (`{ phase: 'encode' }`) before any `codec.encode` call is made — codecs
-*   can pin this with a per-call counter that stays at zero.
-* - **Mid-flight abort** races the per-param `Promise.all` against
-*   `abortable(ctx.signal)`. The runtime returns `RUNTIME.ABORTED` promptly
-*   even if codec bodies ignore the signal; the in-flight bodies are
-*   abandoned and run to completion in the background (cooperative
-*   cancellation, see ADR 204).
-* - Existing `RUNTIME.ENCODE_FAILED` envelopes that surface from a codec
-*   body before the runtime observes the abort pass through unchanged
-*   (no double wrap).
+* - **Already-aborted at entry** short-circuits with `RUNTIME.ABORTED` (`{ phase: 'encode' }`) before any `codec.encode` call is made — codecs can pin this with a per-call counter that stays at zero.
+* - **Mid-flight abort** races the per-param `Promise.all` against `abortable(ctx.signal)`. The runtime returns `RUNTIME.ABORTED` promptly even if codec bodies ignore the signal; the in-flight bodies are abandoned and run to completion in the background (cooperative cancellation, see ADR 204).
+* - Existing `RUNTIME.ENCODE_FAILED` envelopes that surface from a codec body before the runtime observes the abort pass through unchanged (no double wrap).
 */
-async function encodeParams(plan, registry, ctx, contractCodecs) {
+async function encodeParams(plan, ctx, contractCodecs) {
 	checkAborted(ctx, "encode");
 	const signal = ctx.signal;
 	if (plan.params.length === 0) return plan.params;
@@ -1217,12 +1103,14 @@ async function encodeParams(plan, registry, ctx, contractCodecs) {
 			const ref = refs[i];
 			if (ref) metadata[i] = {
 				codecId: ref.codecId,
-				name: ref.name
+				name: ref.name,
+				refs: ref.refs
 			};
 		}
 	}
+	const aliasResolver = makeAliasResolver(plan.ast);
 	const tasks = new Array(paramCount);
-	for (let i = 0; i < paramCount; i++) tasks[i] = encodeParamValue(plan.params[i], metadata[i] ?? NO_METADATA, i, registry, ctx, contractCodecs);
+	for (let i = 0; i < paramCount; i++) tasks[i] = encodeParamValue(plan.params[i], metadata[i] ?? NO_METADATA, i, ctx, contractCodecs, aliasResolver);
 	const settled = await raceAgainstAbort(Promise.all(tasks), signal, "encode");
 	return Object.freeze(settled);
 }
@@ -1331,15 +1219,20 @@ var SqlFamilyAdapter = class {
 function isExecutionPlan(plan) {
 	return "sql" in plan;
 }
+// v8 ignore next 2
+const noopLogSink = () => {};
+const noopLog = {
+	info: noopLogSink,
+	warn: noopLogSink,
+	error: noopLogSink
+};
 var SqlRuntimeImpl = class extends RuntimeCore {
 	contract;
 	adapter;
 	driver;
 	familyAdapter;
-	codecRegistry;
 	contractCodecs;
 	codecDescriptors;
-	jsonSchemaValidators;
 	sqlCtx;
 	verify;
 	codecRegistryValidated;
@@ -1353,11 +1246,7 @@ var SqlRuntimeImpl = class extends RuntimeCore {
 			contract: context.contract,
 			mode: mode ?? "strict",
 			now: () => Date.now(),
-			log: log ?? {
-				info: () => {},
-				warn: () => {},
-				error: () => {}
-			},
+			log: log ?? noopLog,
 			contentHash: (exec) => computeSqlContentHash(exec)
 		};
 		super({
@@ -1368,10 +1257,8 @@ var SqlRuntimeImpl = class extends RuntimeCore {
 		this.adapter = adapter;
 		this.driver = driver;
 		this.familyAdapter = new SqlFamilyAdapter(context.contract, adapter.profile);
-		this.codecRegistry = context.codecs;
 		this.contractCodecs = context.contractCodecs;
 		this.codecDescriptors = context.codecDescriptors;
-		this.jsonSchemaValidators = context.jsonSchemaValidators;
 		this.sqlCtx = sqlCtx;
 		this.verify = verify;
 		this.codecRegistryValidated = false;
@@ -1384,29 +1271,22 @@ var SqlRuntimeImpl = class extends RuntimeCore {
 		}
 	}
 	/**
-	* Lower a `SqlQueryPlan` (AST + meta) into a `SqlExecutionPlan` with
-	* encoded parameters ready for the driver. This is the single point at
-	* which params transition from app-layer values to driver wire-format.
+	* Lower a `SqlQueryPlan` (AST + meta) into a `SqlExecutionPlan` with encoded parameters ready for the driver. This is the single point at which params transition from app-layer values to driver wire-format.
 	*
-	* `ctx: SqlCodecCallContext` is forwarded to `encodeParams` so per-query
-	* cancellation reaches every codec body during parameter encoding. The
-	* framework abstract typed this as `CodecCallContext`; the SQL family
-	* narrows it to the SQL-specific extension. SQL params do not populate
-	* `ctx.column` — encode-side column metadata is the middleware's domain.
+	* `ctx: SqlCodecCallContext` is forwarded to `encodeParams` so per-query cancellation reaches every codec body during parameter encoding. The framework abstract typed this as `CodecCallContext`; the SQL family narrows it to the SQL-specific extension. SQL params do not populate `ctx.column` — encode-side column metadata is the middleware's domain.
 	*/
 	async lower(plan, ctx) {
+		validateParamRefRefs(plan.ast, this.codecDescriptors);
 		const lowered = lowerSqlPlan(this.adapter, this.contract, plan);
 		return Object.freeze({
 			...lowered,
-			params: await encodeParams(lowered, this.codecRegistry, ctx, this.contractCodecs)
+			params: await encodeParams(lowered, ctx, this.contractCodecs)
 		});
 	}
 	/**
-	* Default driver invocation. Production execution paths override the
-	* queryable target (e.g. transaction or connection) by going through
-	* `executeAgainstQueryable`; this implementation supports any caller of
-	* `super.execute(plan)` and the abstract-base contract.
+	* Default driver invocation required by the abstract `RuntimeCore` contract. Every production path overrides `execute()` and routes through `executeAgainstQueryable`, so this hook is defensive only — subclasses that delegate back to `super.execute()` would land here.
 	*/
+	// v8 ignore next 6
 	runDriver(exec) {
 		return this.driver.execute({
 			sql: exec.sql,
@@ -1414,13 +1294,8 @@ var SqlRuntimeImpl = class extends RuntimeCore {
 		});
 	}
 	/**
-	* SQL pre-compile hook. Runs the registered middleware `beforeCompile`
-	* chain over the plan's draft (AST + meta). Returns the original plan
-	* unchanged when no middleware rewrote the AST; otherwise returns a new
-	* plan carrying the rewritten AST and meta. The AST is the authoritative
-	* source of execution metadata, so a rewrite needs no sidecar
-	* reconciliation here — the lowering adapter and the encoder both walk
-	* the rewritten AST directly.
+	* SQL pre-compile hook. Runs the registered middleware `beforeCompile` chain over the plan's draft (AST + meta). Returns the original plan unchanged when no middleware rewrote the AST; otherwise returns a new plan carrying the rewritten AST and meta. The AST is the authoritative source of execution metadata, so a rewrite needs no sidecar reconciliation here — the lowering adapter and the encoder both walk the rewritten
+	* AST directly.
 	*/
 	async runBeforeCompile(plan) {
 		const rewrittenDraft = await runBeforeCompileChain(this.middleware, {
@@ -1443,10 +1318,14 @@ var SqlRuntimeImpl = class extends RuntimeCore {
 		const codecCtx = signal === void 0 ? {} : { signal };
 		const generator = async function* () {
 			checkAborted(codecCtx, "stream");
-			const exec = isExecutionPlan(plan) ? Object.freeze({
-				...plan,
-				params: await encodeParams(plan, self.codecRegistry, codecCtx, self.contractCodecs)
-			}) : await self.lower(await self.runBeforeCompile(plan), codecCtx);
+			let exec;
+			if (isExecutionPlan(plan)) {
+				if (plan.ast) validateParamRefRefs(plan.ast, self.codecDescriptors);
+				exec = Object.freeze({
+					...plan,
+					params: await encodeParams(plan, codecCtx, self.contractCodecs)
+				});
+			} else exec = await self.lower(await self.runBeforeCompile(plan), codecCtx);
 			self.familyAdapter.validatePlan(exec, self.contract);
 			self._telemetry = null;
 			if (!self.startupVerified && self.verify.mode === "startup") await self.verifyMarker();
@@ -1464,7 +1343,7 @@ var SqlRuntimeImpl = class extends RuntimeCore {
 						checkAborted(codecCtx, "stream");
 						const next = await iterator.next();
 						if (next.done) break;
-						yield await decodeRow(next.value, exec, self.codecRegistry, self.jsonSchemaValidators, codecCtx, self.contractCodecs);
+						yield await decodeRow(next.value, exec, codecCtx, self.contractCodecs);
 					}
 				} finally {
 					await iterator.return?.();
@@ -1525,8 +1404,6 @@ var SqlRuntimeImpl = class extends RuntimeCore {
 		}
 	}
 	async verifyMarker() {
-		if (this.verify.mode === "always") this.verified = false;
-		if (this.verified) return;
 		const readStatement = this.familyAdapter.markerReader.readMarkerStatement();
 		const result = await this.driver.query(readStatement.sql, readStatement.params);
 		if (result.rows.length === 0) {
@@ -1637,4 +1514,4 @@ function createRuntime(options) {
 
 //#endregion
 export { readContractMarker as a, createSqlExecutionStack as c, parseContractMarkerRow as d, lowerSqlPlan as f, validateContractCodecMappings as h, ensureTableStatement as i, lints as l, validateCodecRegistryCompleteness as m, withTransaction as n, writeContractMarker as o, extractCodecIds as p, ensureSchemaStatement as r, createExecutionContext as s, createRuntime as t, budgets as u };
-//# sourceMappingURL=exports-BcX9wp4z.mjs.map
+//# sourceMappingURL=exports-CZIUsCRE.mjs.map