@prisma-next/sql-runtime 0.5.0-dev.30 → 0.5.0-dev.32

package/dist/{exports-Cq_9ZrU4.mjs → exports-CrHMfIKo.mjs}

@@ -2,6 +2,7 @@ import { AsyncIterableResult, RuntimeCore, checkAborted, checkMiddlewareCompatib
 import { type } from "arktype";
 import { collectOrderedParamRefs, createCodecRegistry, isQueryAst } 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";
@@ -25,10 +26,17 @@ 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 (!registry.has(codecId)) {
+	for (const [key, codecId] of codecIds.entries()) if (!lookup.has(codecId)) {
 		const parts = key.split(".");
 		const table = parts[0] ?? "";
 		const column = parts[1] ?? "";
@@ -437,16 +445,21 @@ function assertExecutionStackContractRequirements(contract, stack) {
 	}
 }
 function validateTypeParams(typeParams, codecDescriptor, context) {
-	const result = codecDescriptor.paramsSchema(typeParams);
-	if (result instanceof type.errors) {
-		const messages = result.map((p) => p.message).join("; ");
+	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.`, {
+		...context,
+		codecId: codecDescriptor.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}`, {
 			...context,
 			codecId: codecDescriptor.codecId,
 			typeParams
 		});
 	}
-	return result;
+	return result.value;
 }
 function collectParameterizedCodecDescriptors(contributors) {
 	const descriptors = /* @__PURE__ */ new Map();
@@ -456,16 +469,76 @@ function collectParameterizedCodecDescriptors(contributors) {
 	}
 	return descriptors;
 }
-function initializeTypeHelpers(storageTypes, codecDescriptors) {
+/**
+* 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.
+*
+* Codec-registry-unification spec § Decision: every codec resolves
+* through one descriptor map; reads are non-branching.
+*/
+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));
+	}
+	return {
+		descriptorFor(codecId) {
+			return byId.get(codecId);
+		},
+		*values() {
+			yield* byId.values();
+		},
+		byTargetType(targetType) {
+			return byTargetType.get(targetType) ?? Object.freeze([]);
+		}
+	};
+}
+function collectTypeRefSites(storage) {
+	const sites = /* @__PURE__ */ new Map();
+	for (const [tableName, table] of Object.entries(storage.tables)) for (const [columnName, column] of Object.entries(table.columns)) {
+		if (typeof column.typeRef !== "string") continue;
+		const list = sites.get(column.typeRef);
+		const entry = {
+			table: tableName,
+			column: columnName
+		};
+		if (list) list.push(entry);
+		else sites.set(column.typeRef, [entry]);
+	}
+	return sites;
+}
+function initializeTypeHelpers(storage, codecDescriptors) {
 	const helpers = {};
+	const storageTypes = storage.types;
 	if (!storageTypes) return helpers;
+	const typeRefSites = collectTypeRefSites(storage);
 	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;
+		if (!descriptor) {
+			helpers[typeName] = typeInstance;
+			continue;
+		}
+		const validatedParams = validateTypeParams(typeInstance.typeParams, descriptor, { typeName });
+		const ctx = {
+			name: typeName,
+			usedAt: typeRefSites.get(typeName) ?? []
+		};
+		helpers[typeName] = descriptor.factory(validatedParams)(ctx);
 	}
 	return helpers;
 }
@@ -478,39 +551,115 @@ 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;
+}
 /**
-* Builds a registry of compiled JSON Schema validators by scanning the contract
-* for columns whose codec descriptor provides an `init` hook returning `{ validate }`.
+* Walk the contract's `storage.tables[].columns[]` and resolve each
+* column to a `Codec` through the unified descriptor map. Per-instance
+* behavior:
 *
-* Handles both:
-* - Inline `typeParams.schema` on columns
-* - `typeRef` → `storage.types[ref]` with init hook results already in `types` 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.
+*
+* 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.
+*
+* Codec-registry-unification spec § AC-4: every column resolves through
+* one descriptor map without branching on parameterization.
 */
-function buildJsonSchemaValidatorRegistry(contract, types, codecDescriptors) {
+function buildContractCodecRegistry(contract, codecDescriptors, legacyCodecRegistry, types, parameterizedDescriptors) {
+	const byColumn = /* @__PURE__ */ new Map();
+	const byCodecId = /* @__PURE__ */ new Map();
+	const ambiguousCodecIds = /* @__PURE__ */ new Set();
 	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);
+		const columnKey = `${tableName}.${columnName}`;
+		const descriptor = codecDescriptors.descriptorFor(column.codecId);
+		let resolvedCodec;
+		if (descriptor) {
+			const isParameterized = parameterizedDescriptors.has(column.codecId);
+			if (column.typeRef) {
+				const helper = types[column.typeRef];
+				if (isResolvedCodec(helper)) resolvedCodec = helper;
+			} else if (column.typeParams && isParameterized) {
+				const parameterizedDescriptor = parameterizedDescriptors.get(column.codecId);
+				if (parameterizedDescriptor) {
+					const validatedParams = validateTypeParams(column.typeParams, parameterizedDescriptor, {
+						tableName,
+						columnName
+					});
+					const ctx = {
+						name: `<anon:${tableName}.${columnName}>`,
+						usedAt: [{
+							table: tableName,
+							column: columnName
+						}]
+					};
+					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;
 			}
 		}
+		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);
+		}
 	}
-	if (validators.size === 0) return void 0;
 	return {
-		get: (key) => validators.get(key),
-		size: validators.size
+		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);
+			}
+		},
+		jsonValidators: validators.size > 0 ? {
+			get: (key) => validators.get(key),
+			size: validators.size
+		} : void 0
 	};
 }
 function collectMutationDefaultGenerators(contributors) {
@@ -572,13 +721,16 @@ function createExecutionContext(options) {
 	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 mutationDefaultGeneratorRegistry = collectMutationDefaultGenerators(contributors);
 	if (parameterizedCodecDescriptors.size > 0) validateColumnTypeParams(contract.storage, parameterizedCodecDescriptors);
-	const types = initializeTypeHelpers(contract.storage.types, parameterizedCodecDescriptors);
-	const jsonSchemaValidators = buildJsonSchemaValidatorRegistry(contract, types, parameterizedCodecDescriptors);
+	const types = initializeTypeHelpers(contract.storage, parameterizedCodecDescriptors);
+	const { registry: contractCodecs, jsonValidators: jsonSchemaValidators } = buildContractCodecRegistry(contract, codecDescriptors, codecRegistry, types, parameterizedCodecDescriptors);
 	return {
 		contract,
 		codecs: codecRegistry,
+		contractCodecs,
+		codecDescriptors,
 		queryOperations: queryOperationRegistry,
 		types,
 		...jsonSchemaValidators ? { jsonSchemaValidators } : {},
@@ -740,7 +892,35 @@ function projectionListFromAst(ast) {
 	if (ast.kind === "select") return ast.projection;
 	return ast.returning;
 }
-function buildDecodeContext(plan, registry) {
+/**
+* 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.
+*
+* Codec-registry-unification spec § AC-4.
+*/
+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 buildDecodeContext(plan, registry, contractCodecs) {
 	if (!isAstBackedPlan(plan)) return {
 		aliases: void 0,
 		codecs: /* @__PURE__ */ new Map(),
@@ -760,10 +940,8 @@ function buildDecodeContext(plan, registry) {
 	const includeAliases = /* @__PURE__ */ new Set();
 	for (const item of projection) {
 		aliases.push(item.alias);
-		if (item.codecId) {
-			const codec$1 = registry.get(item.codecId);
-			if (codec$1) codecs.set(item.alias, codec$1);
-		}
+		const codec$1 = resolveProjectionCodec(item, registry, contractCodecs);
+		if (codec$1) codecs.set(item.alias, codec$1);
 		if (item.expr.kind === "column-ref") columnRefs.set(item.alias, {
 			table: item.expr.table,
 			column: item.expr.column
@@ -882,10 +1060,10 @@ async function decodeField(alias, wireValue, decodeCtx, jsonValidators, rowCtx)
 * - Existing `RUNTIME.DECODE_FAILED` envelopes from codec bodies pass
 *   through unchanged (no double wrap).
 */
-async function decodeRow(row, plan, registry, jsonValidators, rowCtx) {
+async function decodeRow(row, plan, registry, jsonValidators, rowCtx, contractCodecs) {
 	checkAborted(rowCtx, "decode");
 	const signal = rowCtx.signal;
-	const decodeCtx = buildDecodeContext(plan, registry);
+	const decodeCtx = buildDecodeContext(plan, registry, 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}"`, {
@@ -923,6 +1101,34 @@ const NO_METADATA = Object.freeze({
 	codecId: void 0,
 	name: 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).
+*
+* 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.
+*
+* 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.
+*/
+function resolveParamCodec(metadata, registry, contractCodecs) {
+	if (!metadata.codecId) return void 0;
+	const fromContract = contractCodecs?.forCodecId(metadata.codecId);
+	if (fromContract) return fromContract;
+	return registry.get(metadata.codecId);
+}
 function paramLabel(metadata, paramIndex) {
 	return metadata.name ?? `param[${paramIndex}]`;
 }
@@ -936,10 +1142,9 @@ function wrapEncodeFailure(error, metadata, paramIndex, codecId) {
 	wrapped.cause = error;
 	throw wrapped;
 }
-async function encodeParamValue(value, metadata, paramIndex, registry, ctx) {
+async function encodeParamValue(value, metadata, paramIndex, registry, ctx, contractCodecs) {
 	if (value === null || value === void 0) return null;
-	if (!metadata.codecId) return value;
-	const codec$1 = registry.get(metadata.codecId);
+	const codec$1 = resolveParamCodec(metadata, registry, contractCodecs);
 	if (!codec$1) return value;
 	try {
 		return await codec$1.encode(value, ctx);
@@ -966,7 +1171,7 @@ async function encodeParamValue(value, metadata, paramIndex, registry, ctx) {
 *   body before the runtime observes the abort pass through unchanged
 *   (no double wrap).
 */
-async function encodeParams(plan, registry, ctx) {
+async function encodeParams(plan, registry, ctx, contractCodecs) {
 	checkAborted(ctx, "encode");
 	const signal = ctx.signal;
 	if (plan.params.length === 0) return plan.params;
@@ -983,7 +1188,7 @@ async function encodeParams(plan, registry, ctx) {
 		}
 	}
 	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);
+	for (let i = 0; i < paramCount; i++) tasks[i] = encodeParamValue(plan.params[i], metadata[i] ?? NO_METADATA, i, registry, ctx, contractCodecs);
 	const settled = await raceAgainstAbort(Promise.all(tasks), signal, "encode");
 	return Object.freeze(settled);
 }
@@ -1057,6 +1262,8 @@ var SqlRuntimeImpl = class extends RuntimeCore {
 	driver;
 	familyAdapter;
 	codecRegistry;
+	contractCodecs;
+	codecDescriptors;
 	jsonSchemaValidators;
 	sqlCtx;
 	verify;
@@ -1086,6 +1293,8 @@ var SqlRuntimeImpl = class extends RuntimeCore {
 		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;
@@ -1094,7 +1303,7 @@ var SqlRuntimeImpl = class extends RuntimeCore {
 		this.startupVerified = false;
 		this._telemetry = null;
 		if (verify.mode === "startup") {
-			validateCodecRegistryCompleteness(this.codecRegistry, context.contract);
+			validateCodecRegistryCompleteness(this.codecDescriptors, context.contract);
 			this.codecRegistryValidated = true;
 		}
 	}
@@ -1113,7 +1322,7 @@ var SqlRuntimeImpl = class extends RuntimeCore {
 		const lowered = lowerSqlPlan(this.adapter, this.contract, plan);
 		return Object.freeze({
 			...lowered,
-			params: await encodeParams(lowered, this.codecRegistry, ctx)
+			params: await encodeParams(lowered, this.codecRegistry, ctx, this.contractCodecs)
 		});
 	}
 	/**
@@ -1160,7 +1369,7 @@ var SqlRuntimeImpl = class extends RuntimeCore {
 			checkAborted(codecCtx, "stream");
 			const exec = isExecutionPlan(plan) ? Object.freeze({
 				...plan,
-				params: await encodeParams(plan, self.codecRegistry, codecCtx)
+				params: await encodeParams(plan, self.codecRegistry, codecCtx, self.contractCodecs)
 			}) : await self.lower(await self.runBeforeCompile(plan), codecCtx);
 			self.familyAdapter.validatePlan(exec, self.contract);
 			self._telemetry = null;
@@ -1179,7 +1388,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);
+						yield await decodeRow(next.value, exec, self.codecRegistry, self.jsonSchemaValidators, codecCtx, self.contractCodecs);
 					}
 				} finally {
 					await iterator.return?.();
@@ -1235,7 +1444,7 @@ var SqlRuntimeImpl = class extends RuntimeCore {
 	}
 	ensureCodecRegistryValidated() {
 		if (!this.codecRegistryValidated) {
-			validateCodecRegistryCompleteness(this.codecRegistry, this.contract);
+			validateCodecRegistryCompleteness(this.codecDescriptors, this.contract);
 			this.codecRegistryValidated = true;
 		}
 	}
@@ -1352,4 +1561,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-Cq_9ZrU4.mjs.map
+//# sourceMappingURL=exports-CrHMfIKo.mjs.map