@prisma-next/sql-contract-psl 0.3.0-dev.128 → 0.3.0-dev.146

package/dist/{interpreter-D7gLmaHz.mjs → interpreter-qjtea3zY.mjs}

@@ -1,8 +1,191 @@
-import { defineContract } from "@prisma-next/sql-contract-ts/contract-builder";
-import { assertDefined, invariant } from "@prisma-next/utils/assertions";
+import { instantiateAuthoringTypeConstructor, isAuthoringTypeConstructorDescriptor } from "@prisma-next/framework-components/authoring";
+import { buildSqlContractFromDefinition } from "@prisma-next/sql-contract-ts/contract-builder";
 import { ifDefined } from "@prisma-next/utils/defined";
 import { notOk, ok } from "@prisma-next/utils/result";
+import { getPositionalArgument, parseQuotedStringLiteral } from "@prisma-next/psl-parser";
+import { assertDefined, invariant } from "@prisma-next/utils/assertions";
+
+//#region src/psl-attribute-parsing.ts
+function lowerFirst(value) {
+	if (value.length === 0) return value;
+	return value[0]?.toLowerCase() + value.slice(1);
+}
+function getAttribute(attributes, name) {
+	return attributes?.find((attribute) => attribute.name === name);
+}
+function getNamedArgument(attribute, name) {
+	const entry = attribute.args.find((arg) => arg.kind === "named" && arg.name === name);
+	if (!entry || entry.kind !== "named") return;
+	return entry.value;
+}
+function getPositionalArgumentEntry(attribute, index = 0) {
+	const entry = attribute.args.filter((arg) => arg.kind === "positional")[index];
+	if (!entry || entry.kind !== "positional") return;
+	return {
+		value: entry.value,
+		span: entry.span
+	};
+}
+function unquoteStringLiteral(value) {
+	const trimmed = value.trim();
+	const match = trimmed.match(/^(['"])(.*)\1$/);
+	if (!match) return trimmed;
+	return match[2] ?? "";
+}
+function parseFieldList(value) {
+	const trimmed = value.trim();
+	if (!trimmed.startsWith("[") || !trimmed.endsWith("]")) return;
+	return trimmed.slice(1, -1).split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+}
+function parseMapName(input) {
+	if (!input.attribute) return input.defaultValue;
+	const value = getPositionalArgument(input.attribute);
+	if (!value) {
+		input.diagnostics.push({
+			code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+			message: `${input.entityLabel} @map requires a positional quoted string literal argument`,
+			sourceId: input.sourceId,
+			span: input.attribute.span
+		});
+		return input.defaultValue;
+	}
+	const parsed = parseQuotedStringLiteral(value);
+	if (parsed === void 0) {
+		input.diagnostics.push({
+			code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+			message: `${input.entityLabel} @map requires a positional quoted string literal argument`,
+			sourceId: input.sourceId,
+			span: input.attribute.span
+		});
+		return input.defaultValue;
+	}
+	return parsed;
+}
+function parseConstraintMapArgument(input) {
+	if (!input.attribute) return;
+	const raw = getNamedArgument(input.attribute, "map");
+	if (!raw) return;
+	const parsed = parseQuotedStringLiteral(raw);
+	if (parsed !== void 0) return parsed;
+	input.diagnostics.push({
+		code: input.code,
+		message: `${input.entityLabel} map argument must be a quoted string literal`,
+		sourceId: input.sourceId,
+		span: input.span
+	});
+}
+function getPositionalArguments(attribute) {
+	return attribute.args.filter((arg) => arg.kind === "positional").map((arg) => arg.kind === "positional" ? arg.value : "");
+}
+function pushInvalidAttributeArgument(input) {
+	input.diagnostics.push({
+		code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+		message: input.message,
+		sourceId: input.sourceId,
+		span: input.span
+	});
+}
+function parseOptionalSingleIntegerArgument(input) {
+	if (input.attribute.args.some((arg) => arg.kind === "named")) return pushInvalidAttributeArgument({
+		diagnostics: input.diagnostics,
+		sourceId: input.sourceId,
+		span: input.attribute.span,
+		message: `${input.entityLabel} @${input.attribute.name} accepts zero or one positional integer argument.`
+	});
+	const positionalArguments = getPositionalArguments(input.attribute);
+	if (positionalArguments.length > 1) return pushInvalidAttributeArgument({
+		diagnostics: input.diagnostics,
+		sourceId: input.sourceId,
+		span: input.attribute.span,
+		message: `${input.entityLabel} @${input.attribute.name} accepts zero or one positional integer argument.`
+	});
+	if (positionalArguments.length === 0) return null;
+	const parsed = Number(unquoteStringLiteral(positionalArguments[0] ?? ""));
+	if (!Number.isInteger(parsed) || parsed < input.minimum) return pushInvalidAttributeArgument({
+		diagnostics: input.diagnostics,
+		sourceId: input.sourceId,
+		span: input.attribute.span,
+		message: `${input.entityLabel} @${input.attribute.name} requires a ${input.valueLabel}.`
+	});
+	return parsed;
+}
+function parseOptionalNumericArguments(input) {
+	if (input.attribute.args.some((arg) => arg.kind === "named")) return pushInvalidAttributeArgument({
+		diagnostics: input.diagnostics,
+		sourceId: input.sourceId,
+		span: input.attribute.span,
+		message: `${input.entityLabel} @${input.attribute.name} accepts zero, one, or two positional integer arguments.`
+	});
+	const positionalArguments = getPositionalArguments(input.attribute);
+	if (positionalArguments.length > 2) return pushInvalidAttributeArgument({
+		diagnostics: input.diagnostics,
+		sourceId: input.sourceId,
+		span: input.attribute.span,
+		message: `${input.entityLabel} @${input.attribute.name} accepts zero, one, or two positional integer arguments.`
+	});
+	if (positionalArguments.length === 0) return null;
+	const precision = Number(unquoteStringLiteral(positionalArguments[0] ?? ""));
+	if (!Number.isInteger(precision) || precision < 1) return pushInvalidAttributeArgument({
+		diagnostics: input.diagnostics,
+		sourceId: input.sourceId,
+		span: input.attribute.span,
+		message: `${input.entityLabel} @${input.attribute.name} requires a positive integer precision.`
+	});
+	if (positionalArguments.length === 1) return { precision };
+	const scale = Number(unquoteStringLiteral(positionalArguments[1] ?? ""));
+	if (!Number.isInteger(scale) || scale < 0) return pushInvalidAttributeArgument({
+		diagnostics: input.diagnostics,
+		sourceId: input.sourceId,
+		span: input.attribute.span,
+		message: `${input.entityLabel} @${input.attribute.name} requires a non-negative integer scale.`
+	});
+	return {
+		precision,
+		scale
+	};
+}
+function parseAttributeFieldList(input) {
+	const raw = getNamedArgument(input.attribute, "fields") ?? getPositionalArgument(input.attribute);
+	if (!raw) {
+		input.diagnostics.push({
+			code: input.code,
+			message: `${input.messagePrefix} requires fields list argument`,
+			sourceId: input.sourceId,
+			span: input.attribute.span
+		});
+		return;
+	}
+	const fields = parseFieldList(raw);
+	if (!fields || fields.length === 0) {
+		input.diagnostics.push({
+			code: input.code,
+			message: `${input.messagePrefix} requires bracketed field list argument`,
+			sourceId: input.sourceId,
+			span: input.attribute.span
+		});
+		return;
+	}
+	return fields;
+}
+function mapFieldNamesToColumns(input) {
+	const columns = [];
+	for (const fieldName of input.fieldNames) {
+		const columnName = input.mapping.fieldColumns.get(fieldName);
+		if (!columnName) {
+			input.diagnostics.push({
+				code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+				message: `${input.contextLabel} references unknown field "${input.modelName}.${fieldName}"`,
+				sourceId: input.sourceId,
+				span: input.span
+			});
+			return;
+		}
+		columns.push(columnName);
+	}
+	return columns;
+}
 
+//#endregion
 //#region src/default-function-registry.ts
 function resolveSpanPositionFromBase(base, text, offset) {
 	const safeOffset = Math.min(Math.max(0, offset), text.length);
@@ -142,267 +325,21 @@ function lowerDefaultFunctionWithRegistry(input) {
 }
 
 //#endregion
-//#region src/interpreter.ts
-const REFERENTIAL_ACTION_MAP = {
-	NoAction: "noAction",
-	Restrict: "restrict",
-	Cascade: "cascade",
-	SetNull: "setNull",
-	SetDefault: "setDefault",
-	noAction: "noAction",
-	restrict: "restrict",
-	cascade: "cascade",
-	setNull: "setNull",
-	setDefault: "setDefault"
-};
-function fkRelationPairKey(declaringModelName, targetModelName) {
-	return `${declaringModelName}::${targetModelName}`;
-}
-function lowerFirst(value) {
-	if (value.length === 0) return value;
-	return value[0]?.toLowerCase() + value.slice(1);
-}
-function getAttribute(attributes, name) {
-	return attributes?.find((attribute) => attribute.name === name);
-}
-function getNamedArgument(attribute, name) {
-	const entry = attribute.args.find((arg) => arg.kind === "named" && arg.name === name);
-	if (!entry || entry.kind !== "named") return;
-	return entry.value;
-}
-function getPositionalArgument(attribute, index = 0) {
-	const entry = attribute.args.filter((arg) => arg.kind === "positional")[index];
-	if (!entry || entry.kind !== "positional") return;
-	return entry.value;
-}
-function getPositionalArgumentEntry(attribute, index = 0) {
-	const entry = attribute.args.filter((arg) => arg.kind === "positional")[index];
-	if (!entry || entry.kind !== "positional") return;
+//#region src/psl-column-resolution.ts
+function toNamedTypeFieldDescriptor(typeRef, descriptor) {
 	return {
-		value: entry.value,
-		span: entry.span
-	};
-}
-function unquoteStringLiteral(value) {
-	const trimmed = value.trim();
-	const match = trimmed.match(/^(['"])(.*)\1$/);
-	if (!match) return trimmed;
-	return match[2] ?? "";
-}
-function parseQuotedStringLiteral(value) {
-	const match = value.trim().match(/^(['"])(.*)\1$/);
-	if (!match) return;
-	return match[2] ?? "";
-}
-function parseFieldList(value) {
-	const trimmed = value.trim();
-	if (!trimmed.startsWith("[") || !trimmed.endsWith("]")) return;
-	return trimmed.slice(1, -1).split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
-}
-function parseDefaultLiteralValue(expression) {
-	const trimmed = expression.trim();
-	if (trimmed === "true" || trimmed === "false") return {
-		kind: "literal",
-		value: trimmed === "true"
-	};
-	const numericValue = Number(trimmed);
-	if (!Number.isNaN(numericValue) && trimmed.length > 0 && !/^(['"]).*\1$/.test(trimmed)) return {
-		kind: "literal",
-		value: numericValue
-	};
-	if (/^(['"]).*\1$/.test(trimmed)) return {
-		kind: "literal",
-		value: unquoteStringLiteral(trimmed)
+		codecId: descriptor.codecId,
+		nativeType: descriptor.nativeType,
+		typeRef
 	};
 }
-function lowerDefaultForField(input) {
-	const positionalEntries = input.defaultAttribute.args.filter((arg) => arg.kind === "positional");
-	if (input.defaultAttribute.args.filter((arg) => arg.kind === "named").length > 0 || positionalEntries.length !== 1) {
-		input.diagnostics.push({
-			code: "PSL_INVALID_DEFAULT_FUNCTION_ARGUMENT",
-			message: `Field "${input.modelName}.${input.fieldName}" requires exactly one positional @default(...) expression.`,
-			sourceId: input.sourceId,
-			span: input.defaultAttribute.span
-		});
-		return {};
+function getAuthoringTypeConstructor(contributions, path) {
+	let current = contributions?.type;
+	for (const segment of path) {
+		if (typeof current !== "object" || current === null || Array.isArray(current)) return;
+		current = current[segment];
 	}
-	const expressionEntry = getPositionalArgumentEntry(input.defaultAttribute);
-	if (!expressionEntry) {
-		input.diagnostics.push({
-			code: "PSL_INVALID_DEFAULT_FUNCTION_ARGUMENT",
-			message: `Field "${input.modelName}.${input.fieldName}" requires a positional @default(...) expression.`,
-			sourceId: input.sourceId,
-			span: input.defaultAttribute.span
-		});
-		return {};
-	}
-	const literalDefault = parseDefaultLiteralValue(expressionEntry.value);
-	if (literalDefault) return { defaultValue: literalDefault };
-	const defaultFunctionCall = parseDefaultFunctionCall(expressionEntry.value, expressionEntry.span);
-	if (!defaultFunctionCall) {
-		input.diagnostics.push({
-			code: "PSL_INVALID_DEFAULT_VALUE",
-			message: `Unsupported default value "${expressionEntry.value}"`,
-			sourceId: input.sourceId,
-			span: input.defaultAttribute.span
-		});
-		return {};
-	}
-	const lowered = lowerDefaultFunctionWithRegistry({
-		call: defaultFunctionCall,
-		registry: input.defaultFunctionRegistry,
-		context: {
-			sourceId: input.sourceId,
-			modelName: input.modelName,
-			fieldName: input.fieldName,
-			columnCodecId: input.columnDescriptor.codecId
-		}
-	});
-	if (!lowered.ok) {
-		input.diagnostics.push(lowered.diagnostic);
-		return {};
-	}
-	if (lowered.value.kind === "storage") return { defaultValue: lowered.value.defaultValue };
-	const generatorDescriptor = input.generatorDescriptorById.get(lowered.value.generated.id);
-	if (!generatorDescriptor) {
-		input.diagnostics.push({
-			code: "PSL_INVALID_DEFAULT_APPLICABILITY",
-			message: `Default generator "${lowered.value.generated.id}" is not available in the composed mutation default registry.`,
-			sourceId: input.sourceId,
-			span: expressionEntry.span
-		});
-		return {};
-	}
-	if (!generatorDescriptor.applicableCodecIds.includes(input.columnDescriptor.codecId)) {
-		input.diagnostics.push({
-			code: "PSL_INVALID_DEFAULT_APPLICABILITY",
-			message: `Default generator "${generatorDescriptor.id}" is not applicable to "${input.modelName}.${input.fieldName}" with codecId "${input.columnDescriptor.codecId}".`,
-			sourceId: input.sourceId,
-			span: expressionEntry.span
-		});
-		return {};
-	}
-	return { executionDefault: lowered.value.generated };
-}
-function parseMapName(input) {
-	if (!input.attribute) return input.defaultValue;
-	const value = getPositionalArgument(input.attribute);
-	if (!value) {
-		input.diagnostics.push({
-			code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
-			message: `${input.entityLabel} @map requires a positional quoted string literal argument`,
-			sourceId: input.sourceId,
-			span: input.attribute.span
-		});
-		return input.defaultValue;
-	}
-	const parsed = parseQuotedStringLiteral(value);
-	if (parsed === void 0) {
-		input.diagnostics.push({
-			code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
-			message: `${input.entityLabel} @map requires a positional quoted string literal argument`,
-			sourceId: input.sourceId,
-			span: input.attribute.span
-		});
-		return input.defaultValue;
-	}
-	return parsed;
-}
-function parsePgvectorLength(input) {
-	const namedLength = getNamedArgument(input.attribute, "length");
-	const namedDim = getNamedArgument(input.attribute, "dim");
-	const positional = getPositionalArgument(input.attribute);
-	const raw = namedLength ?? namedDim ?? positional;
-	if (!raw) {
-		input.diagnostics.push({
-			code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
-			message: "@pgvector.column requires length/dim argument",
-			sourceId: input.sourceId,
-			span: input.attribute.span
-		});
-		return;
-	}
-	const parsed = Number(unquoteStringLiteral(raw));
-	if (!Number.isInteger(parsed) || parsed < 1) {
-		input.diagnostics.push({
-			code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
-			message: "@pgvector.column length/dim must be a positive integer",
-			sourceId: input.sourceId,
-			span: input.attribute.span
-		});
-		return;
-	}
-	return parsed;
-}
-function getPositionalArguments(attribute) {
-	return attribute.args.filter((arg) => arg.kind === "positional").map((arg) => arg.kind === "positional" ? arg.value : "");
-}
-function pushInvalidAttributeArgument(input) {
-	input.diagnostics.push({
-		code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
-		message: input.message,
-		sourceId: input.sourceId,
-		span: input.span
-	});
-}
-function parseOptionalSingleIntegerArgument(input) {
-	if (input.attribute.args.some((arg) => arg.kind === "named")) return pushInvalidAttributeArgument({
-		diagnostics: input.diagnostics,
-		sourceId: input.sourceId,
-		span: input.attribute.span,
-		message: `${input.entityLabel} @${input.attribute.name} accepts zero or one positional integer argument.`
-	});
-	const positionalArguments = getPositionalArguments(input.attribute);
-	if (positionalArguments.length > 1) return pushInvalidAttributeArgument({
-		diagnostics: input.diagnostics,
-		sourceId: input.sourceId,
-		span: input.attribute.span,
-		message: `${input.entityLabel} @${input.attribute.name} accepts zero or one positional integer argument.`
-	});
-	if (positionalArguments.length === 0) return null;
-	const parsed = Number(unquoteStringLiteral(positionalArguments[0] ?? ""));
-	if (!Number.isInteger(parsed) || parsed < input.minimum) return pushInvalidAttributeArgument({
-		diagnostics: input.diagnostics,
-		sourceId: input.sourceId,
-		span: input.attribute.span,
-		message: `${input.entityLabel} @${input.attribute.name} requires a ${input.valueLabel}.`
-	});
-	return parsed;
-}
-function parseOptionalNumericArguments(input) {
-	if (input.attribute.args.some((arg) => arg.kind === "named")) return pushInvalidAttributeArgument({
-		diagnostics: input.diagnostics,
-		sourceId: input.sourceId,
-		span: input.attribute.span,
-		message: `${input.entityLabel} @${input.attribute.name} accepts zero, one, or two positional integer arguments.`
-	});
-	const positionalArguments = getPositionalArguments(input.attribute);
-	if (positionalArguments.length > 2) return pushInvalidAttributeArgument({
-		diagnostics: input.diagnostics,
-		sourceId: input.sourceId,
-		span: input.attribute.span,
-		message: `${input.entityLabel} @${input.attribute.name} accepts zero, one, or two positional integer arguments.`
-	});
-	if (positionalArguments.length === 0) return null;
-	const precision = Number(unquoteStringLiteral(positionalArguments[0] ?? ""));
-	if (!Number.isInteger(precision) || precision < 1) return pushInvalidAttributeArgument({
-		diagnostics: input.diagnostics,
-		sourceId: input.sourceId,
-		span: input.attribute.span,
-		message: `${input.entityLabel} @${input.attribute.name} requires a positive integer precision.`
-	});
-	if (positionalArguments.length === 1) return { precision };
-	const scale = Number(unquoteStringLiteral(positionalArguments[1] ?? ""));
-	if (!Number.isInteger(scale) || scale < 0) return pushInvalidAttributeArgument({
-		diagnostics: input.diagnostics,
-		sourceId: input.sourceId,
-		span: input.attribute.span,
-		message: `${input.entityLabel} @${input.attribute.name} requires a non-negative integer scale.`
-	});
-	return {
-		precision,
-		scale
-	};
+	return isAuthoringTypeConstructorDescriptor(current) ? current : void 0;
 }
 const NATIVE_TYPE_SPECS = {
 	"db.VarChar": {
@@ -555,281 +492,275 @@ function resolveDbNativeTypeAttribute(input) {
 		}
 	}
 }
-function resolveColumnDescriptor(field, enumTypeDescriptors, namedTypeDescriptors, scalarTypeDescriptors) {
-	if (field.typeRef && namedTypeDescriptors.has(field.typeRef)) return namedTypeDescriptors.get(field.typeRef);
-	if (namedTypeDescriptors.has(field.typeName)) return namedTypeDescriptors.get(field.typeName);
-	if (enumTypeDescriptors.has(field.typeName)) return enumTypeDescriptors.get(field.typeName);
-	return scalarTypeDescriptors.get(field.typeName);
-}
-function collectResolvedFields(model, mapping, enumTypeDescriptors, namedTypeDescriptors, namedTypeBaseTypes, modelNames, composedExtensions, defaultFunctionRegistry, generatorDescriptorById, diagnostics, sourceId, scalarTypeDescriptors) {
-	const resolvedFields = [];
-	for (const field of model.fields) {
-		if (field.list) {
-			if (modelNames.has(field.typeName)) continue;
-			diagnostics.push({
-				code: "PSL_UNSUPPORTED_FIELD_LIST",
-				message: `Field "${model.name}.${field.name}" uses a scalar/storage list type, which is not supported in SQL PSL provider v1. Model-typed lists are only supported as backrelation navigation fields when they match an FK-side relation.`,
-				sourceId,
-				span: field.span
-			});
-			continue;
-		}
-		for (const attribute of field.attributes) {
-			if (attribute.name === "id" || attribute.name === "unique" || attribute.name === "default" || attribute.name === "relation" || attribute.name === "map" || attribute.name === "pgvector.column") continue;
-			if (attribute.name.startsWith("pgvector.") && !composedExtensions.has("pgvector")) {
-				diagnostics.push({
-					code: "PSL_EXTENSION_NAMESPACE_NOT_COMPOSED",
-					message: `Attribute "@${attribute.name}" uses unrecognized namespace "pgvector". Add extension pack "pgvector" to extensionPacks in prisma-next.config.ts.`,
-					sourceId,
-					span: attribute.span
-				});
-				continue;
-			}
-			diagnostics.push({
-				code: "PSL_UNSUPPORTED_FIELD_ATTRIBUTE",
-				message: `Field "${model.name}.${field.name}" uses unsupported attribute "@${attribute.name}"`,
-				sourceId,
-				span: attribute.span
-			});
-		}
-		if (getAttribute(field.attributes, "relation") && modelNames.has(field.typeName)) continue;
-		let descriptor = resolveColumnDescriptor(field, enumTypeDescriptors, namedTypeDescriptors, scalarTypeDescriptors);
-		const pgvectorColumnAttribute = getAttribute(field.attributes, "pgvector.column");
-		if (pgvectorColumnAttribute) if (!composedExtensions.has("pgvector")) diagnostics.push({
-			code: "PSL_EXTENSION_NAMESPACE_NOT_COMPOSED",
-			message: "Attribute \"@pgvector.column\" uses unrecognized namespace \"pgvector\". Add extension pack \"pgvector\" to extensionPacks in prisma-next.config.ts.",
-			sourceId,
-			span: pgvectorColumnAttribute.span
+function parsePgvectorLength(input) {
+	const namedLength = getNamedArgument(input.attribute, "length");
+	const namedDim = getNamedArgument(input.attribute, "dim");
+	const positional = getPositionalArgument(input.attribute);
+	const raw = namedLength ?? namedDim ?? positional;
+	if (!raw) {
+		input.diagnostics.push({
+			code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+			message: "@pgvector.column requires length/dim argument",
+			sourceId: input.sourceId,
+			span: input.attribute.span
 		});
-		else if (!(field.typeName === "Bytes" || namedTypeBaseTypes.get(field.typeRef ?? field.typeName) === "Bytes")) diagnostics.push({
+		return;
+	}
+	const parsed = Number(unquoteStringLiteral(raw));
+	if (!Number.isInteger(parsed) || parsed < 1) {
+		input.diagnostics.push({
 			code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
-			message: `Field "${model.name}.${field.name}" uses @pgvector.column on unsupported base type "${field.typeName}"`,
-			sourceId,
-			span: pgvectorColumnAttribute.span
-		});
-		else {
-			const length = parsePgvectorLength({
-				attribute: pgvectorColumnAttribute,
-				diagnostics,
-				sourceId
-			});
-			if (length !== void 0) descriptor = {
-				codecId: "pg/vector@1",
-				nativeType: "vector",
-				typeParams: { length }
-			};
-		}
-		if (!descriptor) {
-			diagnostics.push({
-				code: "PSL_UNSUPPORTED_FIELD_TYPE",
-				message: `Field "${model.name}.${field.name}" type "${field.typeName}" is not supported in SQL PSL provider v1`,
-				sourceId,
-				span: field.span
-			});
-			continue;
-		}
-		const defaultAttribute = getAttribute(field.attributes, "default");
-		const loweredDefault = defaultAttribute ? lowerDefaultForField({
-			modelName: model.name,
-			fieldName: field.name,
-			defaultAttribute,
-			columnDescriptor: descriptor,
-			generatorDescriptorById,
-			sourceId,
-			defaultFunctionRegistry,
-			diagnostics
-		}) : {};
-		if (field.optional && loweredDefault.executionDefault) {
-			const generatorDescription = loweredDefault.executionDefault.kind === "generator" ? `"${loweredDefault.executionDefault.id}"` : "for this field";
-			diagnostics.push({
-				code: "PSL_INVALID_DEFAULT_FUNCTION_ARGUMENT",
-				message: `Field "${model.name}.${field.name}" cannot be optional when using execution default ${generatorDescription}. Remove "?" or use a storage default.`,
-				sourceId,
-				span: defaultAttribute?.span ?? field.span
-			});
-			continue;
-		}
-		if (loweredDefault.executionDefault) {
-			const generatedDescriptor = generatorDescriptorById.get(loweredDefault.executionDefault.id)?.resolveGeneratedColumnDescriptor?.({ generated: loweredDefault.executionDefault });
-			if (generatedDescriptor) descriptor = generatedDescriptor;
-		}
-		const mappedColumnName = mapping.fieldColumns.get(field.name) ?? field.name;
-		resolvedFields.push({
-			field,
-			columnName: mappedColumnName,
-			descriptor,
-			...ifDefined("defaultValue", loweredDefault.defaultValue),
-			...ifDefined("executionDefault", loweredDefault.executionDefault),
-			isId: Boolean(getAttribute(field.attributes, "id")),
-			isUnique: Boolean(getAttribute(field.attributes, "unique"))
+			message: "@pgvector.column length/dim must be a positive integer",
+			sourceId: input.sourceId,
+			span: input.attribute.span
 		});
+		return;
 	}
-	return resolvedFields;
-}
-function hasSameSpan(a, b) {
-	return a.start.offset === b.start.offset && a.end.offset === b.end.offset && a.start.line === b.start.line && a.end.line === b.end.line;
+	return parsed;
 }
-function compareStrings(left, right) {
-	if (left < right) return -1;
-	if (left > right) return 1;
-	return 0;
+function parseDefaultLiteralValue(expression) {
+	const trimmed = expression.trim();
+	if (trimmed === "true" || trimmed === "false") return {
+		kind: "literal",
+		value: trimmed === "true"
+	};
+	const numericValue = Number(trimmed);
+	if (!Number.isNaN(numericValue) && trimmed.length > 0 && !/^(['"]).*\1$/.test(trimmed)) return {
+		kind: "literal",
+		value: numericValue
+	};
+	if (/^(['"]).*\1$/.test(trimmed)) return {
+		kind: "literal",
+		value: unquoteStringLiteral(trimmed)
+	};
 }
-function indexFkRelations(input) {
-	const modelRelations = /* @__PURE__ */ new Map();
-	const fkRelationsByPair = /* @__PURE__ */ new Map();
-	for (const relation of input.fkRelationMetadata) {
-		const existing = modelRelations.get(relation.declaringModelName);
-		const current = existing ?? [];
-		if (!existing) modelRelations.set(relation.declaringModelName, current);
-		current.push({
-			fieldName: relation.declaringFieldName,
-			toModel: relation.targetModelName,
-			toTable: relation.targetTableName,
-			cardinality: "N:1",
-			parentTable: relation.declaringTableName,
-			parentColumns: relation.localColumns,
-			childTable: relation.targetTableName,
-			childColumns: relation.referencedColumns
+function lowerDefaultForField(input) {
+	const positionalEntries = input.defaultAttribute.args.filter((arg) => arg.kind === "positional");
+	if (input.defaultAttribute.args.filter((arg) => arg.kind === "named").length > 0 || positionalEntries.length !== 1) {
+		input.diagnostics.push({
+			code: "PSL_INVALID_DEFAULT_FUNCTION_ARGUMENT",
+			message: `Field "${input.modelName}.${input.fieldName}" requires exactly one positional @default(...) expression.`,
+			sourceId: input.sourceId,
+			span: input.defaultAttribute.span
 		});
-		const pairKey = fkRelationPairKey(relation.declaringModelName, relation.targetModelName);
-		const pairRelations = fkRelationsByPair.get(pairKey);
-		if (!pairRelations) {
-			fkRelationsByPair.set(pairKey, [relation]);
-			continue;
-		}
-		pairRelations.push(relation);
+		return {};
 	}
-	return {
-		modelRelations,
-		fkRelationsByPair
-	};
-}
-function applyBackrelationCandidates(input) {
-	for (const candidate of input.backrelationCandidates) {
-		const pairKey = fkRelationPairKey(candidate.targetModelName, candidate.modelName);
-		const pairMatches = input.fkRelationsByPair.get(pairKey) ?? [];
-		const matches = candidate.relationName ? pairMatches.filter((relation) => relation.relationName === candidate.relationName) : [...pairMatches];
-		if (matches.length === 0) {
-			input.diagnostics.push({
-				code: "PSL_ORPHANED_BACKRELATION_LIST",
-				message: `Backrelation list field "${candidate.modelName}.${candidate.field.name}" has no matching FK-side relation on model "${candidate.targetModelName}". Add @relation(fields: [...], references: [...]) on the FK-side relation or use an explicit join model for many-to-many.`,
-				sourceId: input.sourceId,
-				span: candidate.field.span
-			});
-			continue;
-		}
-		if (matches.length > 1) {
-			input.diagnostics.push({
-				code: "PSL_AMBIGUOUS_BACKRELATION_LIST",
-				message: `Backrelation list field "${candidate.modelName}.${candidate.field.name}" matches multiple FK-side relations on model "${candidate.targetModelName}". Add @relation(name: "...") (or @relation("...")) to both sides to disambiguate.`,
-				sourceId: input.sourceId,
-				span: candidate.field.span
-			});
-			continue;
-		}
-		invariant(matches.length === 1, "Backrelation matching requires exactly one match");
-		const matched = matches[0];
-		assertDefined(matched, "Backrelation matching requires a defined relation match");
-		const existing = input.modelRelations.get(candidate.modelName);
-		const current = existing ?? [];
-		if (!existing) input.modelRelations.set(candidate.modelName, current);
-		current.push({
-			fieldName: candidate.field.name,
-			toModel: matched.declaringModelName,
-			toTable: matched.declaringTableName,
-			cardinality: "1:N",
-			parentTable: candidate.tableName,
-			parentColumns: matched.referencedColumns,
-			childTable: matched.declaringTableName,
-			childColumns: matched.localColumns
+	const expressionEntry = getPositionalArgumentEntry(input.defaultAttribute);
+	if (!expressionEntry) {
+		input.diagnostics.push({
+			code: "PSL_INVALID_DEFAULT_FUNCTION_ARGUMENT",
+			message: `Field "${input.modelName}.${input.fieldName}" requires a positional @default(...) expression.`,
+			sourceId: input.sourceId,
+			span: input.defaultAttribute.span
 		});
+		return {};
 	}
-}
-function emitModelsWithRelations(input) {
-	let nextBuilder = input.builder;
-	const sortedModels = input.resolvedModels.sort((left, right) => {
-		const tableComparison = compareStrings(left.mapping.tableName, right.mapping.tableName);
-		if (tableComparison === 0) return compareStrings(left.model.name, right.model.name);
-		return tableComparison;
-	});
-	for (const entry of sortedModels) {
-		const relationEntries = [...input.modelRelations.get(entry.model.name) ?? []].sort((left, right) => compareStrings(left.fieldName, right.fieldName));
-		nextBuilder = nextBuilder.model(entry.model.name, entry.mapping.tableName, (modelBuilder) => {
-			let next = modelBuilder;
-			for (const resolvedField of entry.resolvedFields) next = next.field(resolvedField.field.name, resolvedField.columnName);
-			for (const relation of relationEntries) next = next.relation(relation.fieldName, {
-				toModel: relation.toModel,
-				toTable: relation.toTable,
-				cardinality: relation.cardinality,
-				on: {
-					parentTable: relation.parentTable,
-					parentColumns: relation.parentColumns,
-					childTable: relation.childTable,
-					childColumns: relation.childColumns
-				}
-			});
-			return next;
+	const literalDefault = parseDefaultLiteralValue(expressionEntry.value);
+	if (literalDefault) return { defaultValue: literalDefault };
+	const defaultFunctionCall = parseDefaultFunctionCall(expressionEntry.value, expressionEntry.span);
+	if (!defaultFunctionCall) {
+		input.diagnostics.push({
+			code: "PSL_INVALID_DEFAULT_VALUE",
+			message: `Unsupported default value "${expressionEntry.value}"`,
+			sourceId: input.sourceId,
+			span: input.defaultAttribute.span
 		});
+		return {};
 	}
-	return nextBuilder;
-}
-function mapParserDiagnostics(document) {
-	return document.diagnostics.map((diagnostic) => ({
-		code: diagnostic.code,
-		message: diagnostic.message,
-		sourceId: diagnostic.sourceId,
-		span: diagnostic.span
-	}));
-}
-function normalizeReferentialAction(input) {
-	const normalized = REFERENTIAL_ACTION_MAP[input.actionToken];
-	if (normalized) return normalized;
-	input.diagnostics.push({
-		code: "PSL_UNSUPPORTED_REFERENTIAL_ACTION",
-		message: `Relation field "${input.modelName}.${input.fieldName}" has unsupported ${input.actionName} action "${input.actionToken}"`,
-		sourceId: input.sourceId,
-		span: input.span
+	const lowered = lowerDefaultFunctionWithRegistry({
+		call: defaultFunctionCall,
+		registry: input.defaultFunctionRegistry,
+		context: {
+			sourceId: input.sourceId,
+			modelName: input.modelName,
+			fieldName: input.fieldName,
+			columnCodecId: input.columnDescriptor.codecId
+		}
 	});
-}
-function parseAttributeFieldList(input) {
-	const raw = getNamedArgument(input.attribute, "fields") ?? getPositionalArgument(input.attribute);
-	if (!raw) {
+	if (!lowered.ok) {
+		input.diagnostics.push(lowered.diagnostic);
+		return {};
+	}
+	if (lowered.value.kind === "storage") return { defaultValue: lowered.value.defaultValue };
+	const generatorDescriptor = input.generatorDescriptorById.get(lowered.value.generated.id);
+	if (!generatorDescriptor) {
 		input.diagnostics.push({
-			code: input.code,
-			message: `${input.messagePrefix} requires fields list argument`,
+			code: "PSL_INVALID_DEFAULT_APPLICABILITY",
+			message: `Default generator "${lowered.value.generated.id}" is not available in the composed mutation default registry.`,
 			sourceId: input.sourceId,
-			span: input.attribute.span
+			span: expressionEntry.span
 		});
-		return;
+		return {};
 	}
-	const fields = parseFieldList(raw);
-	if (!fields || fields.length === 0) {
+	if (!generatorDescriptor.applicableCodecIds.includes(input.columnDescriptor.codecId)) {
 		input.diagnostics.push({
-			code: input.code,
-			message: `${input.messagePrefix} requires bracketed field list argument`,
+			code: "PSL_INVALID_DEFAULT_APPLICABILITY",
+			message: `Default generator "${generatorDescriptor.id}" is not applicable to "${input.modelName}.${input.fieldName}" with codecId "${input.columnDescriptor.codecId}".`,
 			sourceId: input.sourceId,
-			span: input.attribute.span
+			span: expressionEntry.span
 		});
-		return;
+		return {};
 	}
-	return fields;
+	return { executionDefault: lowered.value.generated };
 }
-function mapFieldNamesToColumns(input) {
-	const columns = [];
-	for (const fieldName of input.fieldNames) {
-		const columnName = input.mapping.fieldColumns.get(fieldName);
-		if (!columnName) {
-			input.diagnostics.push({
+function resolveColumnDescriptor(field, enumTypeDescriptors, namedTypeDescriptors, scalarTypeDescriptors) {
+	if (field.typeRef && namedTypeDescriptors.has(field.typeRef)) return namedTypeDescriptors.get(field.typeRef);
+	if (namedTypeDescriptors.has(field.typeName)) return namedTypeDescriptors.get(field.typeName);
+	if (enumTypeDescriptors.has(field.typeName)) return enumTypeDescriptors.get(field.typeName);
+	return scalarTypeDescriptors.get(field.typeName);
+}
+
+//#endregion
+//#region src/psl-field-resolution.ts
+function collectResolvedFields(model, mapping, enumTypeDescriptors, namedTypeDescriptors, namedTypeBaseTypes, modelNames, compositeTypeNames, composedExtensions, authoringContributions, defaultFunctionRegistry, generatorDescriptorById, diagnostics, sourceId, scalarTypeDescriptors) {
+	const resolvedFields = [];
+	const pgvectorVectorConstructor = getAuthoringTypeConstructor(authoringContributions, ["pgvector", "vector"]);
+	for (const field of model.fields) {
+		if (field.list && modelNames.has(field.typeName)) continue;
+		for (const attribute of field.attributes) {
+			if (attribute.name === "id" || attribute.name === "unique" || attribute.name === "default" || attribute.name === "relation" || attribute.name === "map" || attribute.name === "pgvector.column") continue;
+			if (attribute.name.startsWith("pgvector.") && !composedExtensions.has("pgvector")) {
+				diagnostics.push({
+					code: "PSL_EXTENSION_NAMESPACE_NOT_COMPOSED",
+					message: `Attribute "@${attribute.name}" uses unrecognized namespace "pgvector". Add extension pack "pgvector" to extensionPacks in prisma-next.config.ts.`,
+					sourceId,
+					span: attribute.span
+				});
+				continue;
+			}
+			diagnostics.push({
+				code: "PSL_UNSUPPORTED_FIELD_ATTRIBUTE",
+				message: `Field "${model.name}.${field.name}" uses unsupported attribute "@${attribute.name}"`,
+				sourceId,
+				span: attribute.span
+			});
+		}
+		if (getAttribute(field.attributes, "relation") && modelNames.has(field.typeName)) continue;
+		const isValueObjectField = compositeTypeNames.has(field.typeName);
+		const isListField = field.list;
+		const pgvectorOnJsonField = getAttribute(field.attributes, "pgvector.column");
+		if (pgvectorOnJsonField && (isValueObjectField || isListField)) {
+			diagnostics.push({
 				code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
-				message: `${input.contextLabel} references unknown field "${input.modelName}.${fieldName}"`,
-				sourceId: input.sourceId,
-				span: input.span
+				message: `Field "${model.name}.${field.name}" uses @pgvector.column on a JSON-backed field (${isValueObjectField ? "value object" : "list"}). @pgvector.column is only supported on scalar Bytes fields.`,
+				sourceId,
+				span: pgvectorOnJsonField.span
 			});
-			return;
+			continue;
 		}
-		columns.push(columnName);
+		let descriptor;
+		let scalarCodecId;
+		if (isValueObjectField) descriptor = scalarTypeDescriptors.get("Json");
+		else if (isListField) {
+			const originalDescriptor = resolveColumnDescriptor(field, enumTypeDescriptors, namedTypeDescriptors, scalarTypeDescriptors);
+			if (!originalDescriptor) {
+				diagnostics.push({
+					code: "PSL_UNSUPPORTED_FIELD_TYPE",
+					message: `Field "${model.name}.${field.name}" type "${field.typeName}" is not supported in SQL PSL provider v1`,
+					sourceId,
+					span: field.span
+				});
+				continue;
+			}
+			scalarCodecId = originalDescriptor.codecId;
+			descriptor = scalarTypeDescriptors.get("Json");
+		} else {
+			descriptor = resolveColumnDescriptor(field, enumTypeDescriptors, namedTypeDescriptors, scalarTypeDescriptors);
+			const pgvectorColumnAttribute = getAttribute(field.attributes, "pgvector.column");
+			if (pgvectorColumnAttribute) if (!composedExtensions.has("pgvector")) diagnostics.push({
+				code: "PSL_EXTENSION_NAMESPACE_NOT_COMPOSED",
+				message: "Attribute \"@pgvector.column\" uses unrecognized namespace \"pgvector\". Add extension pack \"pgvector\" to extensionPacks in prisma-next.config.ts.",
+				sourceId,
+				span: pgvectorColumnAttribute.span
+			});
+			else if (!(field.typeName === "Bytes" || namedTypeBaseTypes.get(field.typeRef ?? field.typeName) === "Bytes")) diagnostics.push({
+				code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+				message: `Field "${model.name}.${field.name}" uses @pgvector.column on unsupported base type "${field.typeName}"`,
+				sourceId,
+				span: pgvectorColumnAttribute.span
+			});
+			else {
+				const length = parsePgvectorLength({
+					attribute: pgvectorColumnAttribute,
+					diagnostics,
+					sourceId
+				});
+				if (length !== void 0) descriptor = pgvectorVectorConstructor ? instantiateAuthoringTypeConstructor(pgvectorVectorConstructor, [length]) : {
+					codecId: "pg/vector@1",
+					nativeType: "vector",
+					typeParams: { length }
+				};
+			}
+		}
+		if (!descriptor) {
+			diagnostics.push({
+				code: "PSL_UNSUPPORTED_FIELD_TYPE",
+				message: `Field "${model.name}.${field.name}" type "${field.typeName}" is not supported in SQL PSL provider v1`,
+				sourceId,
+				span: field.span
+			});
+			continue;
+		}
+		const defaultAttribute = getAttribute(field.attributes, "default");
+		const loweredDefault = defaultAttribute ? lowerDefaultForField({
+			modelName: model.name,
+			fieldName: field.name,
+			defaultAttribute,
+			columnDescriptor: descriptor,
+			generatorDescriptorById,
+			sourceId,
+			defaultFunctionRegistry,
+			diagnostics
+		}) : {};
+		if (field.optional && loweredDefault.executionDefault) {
+			const generatorDescription = loweredDefault.executionDefault.kind === "generator" ? `"${loweredDefault.executionDefault.id}"` : "for this field";
+			diagnostics.push({
+				code: "PSL_INVALID_DEFAULT_FUNCTION_ARGUMENT",
+				message: `Field "${model.name}.${field.name}" cannot be optional when using execution default ${generatorDescription}. Remove "?" or use a storage default.`,
+				sourceId,
+				span: defaultAttribute?.span ?? field.span
+			});
+			continue;
+		}
+		if (loweredDefault.executionDefault) {
+			const generatedDescriptor = generatorDescriptorById.get(loweredDefault.executionDefault.id)?.resolveGeneratedColumnDescriptor?.({ generated: loweredDefault.executionDefault });
+			if (generatedDescriptor) descriptor = generatedDescriptor;
+		}
+		const mappedColumnName = mapping.fieldColumns.get(field.name) ?? field.name;
+		const idAttribute = getAttribute(field.attributes, "id");
+		const uniqueAttribute = getAttribute(field.attributes, "unique");
+		const idName = parseConstraintMapArgument({
+			attribute: idAttribute,
+			sourceId,
+			diagnostics,
+			entityLabel: `Field "${model.name}.${field.name}" @id`,
+			span: field.span,
+			code: "PSL_INVALID_ATTRIBUTE_ARGUMENT"
+		});
+		const uniqueName = parseConstraintMapArgument({
+			attribute: uniqueAttribute,
+			sourceId,
+			diagnostics,
+			entityLabel: `Field "${model.name}.${field.name}" @unique`,
+			span: field.span,
+			code: "PSL_INVALID_ATTRIBUTE_ARGUMENT"
+		});
+		resolvedFields.push({
+			field,
+			columnName: mappedColumnName,
+			descriptor,
+			...ifDefined("defaultValue", loweredDefault.defaultValue),
+			...ifDefined("executionDefault", loweredDefault.executionDefault),
+			isId: Boolean(idAttribute),
+			isUnique: Boolean(uniqueAttribute),
+			...ifDefined("idName", idName),
+			...ifDefined("uniqueName", uniqueName),
+			...ifDefined("many", isListField ? true : void 0),
+			...ifDefined("valueObjectTypeName", isValueObjectField ? field.typeName : void 0),
+			...ifDefined("scalarCodecId", scalarCodecId)
+		});
 	}
-	return columns;
+	return resolvedFields;
 }
 function buildModelMappings(models, diagnostics, sourceId) {
 	const result = /* @__PURE__ */ new Map();
@@ -862,29 +793,33 @@ function buildModelMappings(models, diagnostics, sourceId) {
 	}
 	return result;
 }
-function validateNavigationListFieldAttributes(input) {
-	let valid = true;
-	for (const attribute of input.field.attributes) {
-		if (attribute.name === "relation") continue;
-		if (attribute.name.startsWith("pgvector.") && !input.composedExtensions.has("pgvector")) {
-			input.diagnostics.push({
-				code: "PSL_EXTENSION_NAMESPACE_NOT_COMPOSED",
-				message: `Attribute "@${attribute.name}" uses unrecognized namespace "pgvector". Add extension pack "pgvector" to extensionPacks in prisma-next.config.ts.`,
-				sourceId: input.sourceId,
-				span: attribute.span
-			});
-			valid = false;
-			continue;
-		}
-		input.diagnostics.push({
-			code: "PSL_UNSUPPORTED_FIELD_ATTRIBUTE",
-			message: `Field "${input.modelName}.${input.field.name}" uses unsupported attribute "@${attribute.name}"`,
-			sourceId: input.sourceId,
-			span: attribute.span
-		});
-		valid = false;
-	}
-	return valid;
+
+//#endregion
+//#region src/psl-relation-resolution.ts
+const REFERENTIAL_ACTION_MAP = {
+	NoAction: "noAction",
+	Restrict: "restrict",
+	Cascade: "cascade",
+	SetNull: "setNull",
+	SetDefault: "setDefault",
+	noAction: "noAction",
+	restrict: "restrict",
+	cascade: "cascade",
+	setNull: "setNull",
+	setDefault: "setDefault"
+};
+function fkRelationPairKey(declaringModelName, targetModelName) {
+	return `${declaringModelName}::${targetModelName}`;
+}
+function normalizeReferentialAction(input) {
+	const normalized = REFERENTIAL_ACTION_MAP[input.actionToken];
+	if (normalized) return normalized;
+	input.diagnostics.push({
+		code: "PSL_UNSUPPORTED_REFERENTIAL_ACTION",
+		message: `Relation field "${input.modelName}.${input.fieldName}" has unsupported ${input.actionName} action "${input.actionToken}"`,
+		sourceId: input.sourceId,
+		span: input.span
+	});
 }
 function parseRelationAttribute(input) {
 	if (input.attribute.args.filter((arg) => arg.kind === "positional").length > 1) {
@@ -994,63 +929,180 @@ function parseRelationAttribute(input) {
 		...ifDefined("onUpdate", onUpdateArgument ? unquoteStringLiteral(onUpdateArgument) : void 0)
 	};
 }
-function interpretPslDocumentToSqlContractIR(input) {
-	const sourceId = input.document.ast.sourceId;
-	if (!input.target) return notOk({
-		summary: "PSL to SQL Contract IR normalization failed",
-		diagnostics: [{
-			code: "PSL_TARGET_CONTEXT_REQUIRED",
-			message: "PSL interpretation requires an explicit target context from composition.",
-			sourceId
-		}]
-	});
-	if (!input.scalarTypeDescriptors) return notOk({
-		summary: "PSL to SQL Contract IR normalization failed",
-		diagnostics: [{
-			code: "PSL_SCALAR_TYPE_CONTEXT_REQUIRED",
-			message: "PSL interpretation requires composed scalar type descriptors.",
-			sourceId
-		}]
-	});
-	const diagnostics = mapParserDiagnostics(input.document);
-	const modelNames = new Set(input.document.ast.models.map((model) => model.name));
-	const composedExtensions = new Set(input.composedExtensionPacks ?? []);
-	const defaultFunctionRegistry = input.controlMutationDefaults?.defaultFunctionRegistry ?? /* @__PURE__ */ new Map();
-	const generatorDescriptors = input.controlMutationDefaults?.generatorDescriptors ?? [];
-	const generatorDescriptorById = /* @__PURE__ */ new Map();
-	for (const descriptor of generatorDescriptors) generatorDescriptorById.set(descriptor.id, descriptor);
-	let builder = defineContract().target(input.target);
+function indexFkRelations(input) {
+	const modelRelations = /* @__PURE__ */ new Map();
+	const fkRelationsByPair = /* @__PURE__ */ new Map();
+	for (const relation of input.fkRelationMetadata) {
+		const existing = modelRelations.get(relation.declaringModelName);
+		const current = existing ?? [];
+		if (!existing) modelRelations.set(relation.declaringModelName, current);
+		current.push({
+			fieldName: relation.declaringFieldName,
+			toModel: relation.targetModelName,
+			toTable: relation.targetTableName,
+			cardinality: "N:1",
+			on: {
+				parentTable: relation.declaringTableName,
+				parentColumns: relation.localColumns,
+				childTable: relation.targetTableName,
+				childColumns: relation.referencedColumns
+			}
+		});
+		const pairKey = fkRelationPairKey(relation.declaringModelName, relation.targetModelName);
+		const pairRelations = fkRelationsByPair.get(pairKey);
+		if (!pairRelations) {
+			fkRelationsByPair.set(pairKey, [relation]);
+			continue;
+		}
+		pairRelations.push(relation);
+	}
+	return {
+		modelRelations,
+		fkRelationsByPair
+	};
+}
+function applyBackrelationCandidates(input) {
+	for (const candidate of input.backrelationCandidates) {
+		const pairKey = fkRelationPairKey(candidate.targetModelName, candidate.modelName);
+		const pairMatches = input.fkRelationsByPair.get(pairKey) ?? [];
+		const matches = candidate.relationName ? pairMatches.filter((relation) => relation.relationName === candidate.relationName) : [...pairMatches];
+		if (matches.length === 0) {
+			input.diagnostics.push({
+				code: "PSL_ORPHANED_BACKRELATION_LIST",
+				message: `Backrelation list field "${candidate.modelName}.${candidate.field.name}" has no matching FK-side relation on model "${candidate.targetModelName}". Add @relation(fields: [...], references: [...]) on the FK-side relation or use an explicit join model for many-to-many.`,
+				sourceId: input.sourceId,
+				span: candidate.field.span
+			});
+			continue;
+		}
+		if (matches.length > 1) {
+			input.diagnostics.push({
+				code: "PSL_AMBIGUOUS_BACKRELATION_LIST",
+				message: `Backrelation list field "${candidate.modelName}.${candidate.field.name}" matches multiple FK-side relations on model "${candidate.targetModelName}". Add @relation(name: "...") (or @relation("...")) to both sides to disambiguate.`,
+				sourceId: input.sourceId,
+				span: candidate.field.span
+			});
+			continue;
+		}
+		invariant(matches.length === 1, "Backrelation matching requires exactly one match");
+		const matched = matches[0];
+		assertDefined(matched, "Backrelation matching requires a defined relation match");
+		const existing = input.modelRelations.get(candidate.modelName);
+		const current = existing ?? [];
+		if (!existing) input.modelRelations.set(candidate.modelName, current);
+		current.push({
+			fieldName: candidate.field.name,
+			toModel: matched.declaringModelName,
+			toTable: matched.declaringTableName,
+			cardinality: "1:N",
+			on: {
+				parentTable: candidate.tableName,
+				parentColumns: matched.referencedColumns,
+				childTable: matched.declaringTableName,
+				childColumns: matched.localColumns
+			}
+		});
+	}
+}
+function validateNavigationListFieldAttributes(input) {
+	let valid = true;
+	for (const attribute of input.field.attributes) {
+		if (attribute.name === "relation") continue;
+		if (attribute.name.startsWith("pgvector.") && !input.composedExtensions.has("pgvector")) {
+			input.diagnostics.push({
+				code: "PSL_EXTENSION_NAMESPACE_NOT_COMPOSED",
+				message: `Attribute "@${attribute.name}" uses unrecognized namespace "pgvector". Add extension pack "pgvector" to extensionPacks in prisma-next.config.ts.`,
+				sourceId: input.sourceId,
+				span: attribute.span
+			});
+			valid = false;
+			continue;
+		}
+		input.diagnostics.push({
+			code: "PSL_UNSUPPORTED_FIELD_ATTRIBUTE",
+			message: `Field "${input.modelName}.${input.field.name}" uses unsupported attribute "@${attribute.name}"`,
+			sourceId: input.sourceId,
+			span: attribute.span
+		});
+		valid = false;
+	}
+	return valid;
+}
+
+//#endregion
+//#region src/interpreter.ts
+function buildComposedExtensionPackRefs(target, extensionIds, extensionPackRefs = []) {
+	if (extensionIds.length === 0) return;
+	const extensionPackRefById = new Map(extensionPackRefs.map((packRef) => [packRef.id, packRef]));
+	return Object.fromEntries(extensionIds.map((extensionId) => [extensionId, extensionPackRefById.get(extensionId) ?? {
+		kind: "extension",
+		id: extensionId,
+		familyId: target.familyId,
+		targetId: target.targetId,
+		version: "0.0.1"
+	}]));
+}
+function hasSameSpan(a, b) {
+	return a.start.offset === b.start.offset && a.end.offset === b.end.offset && a.start.line === b.start.line && a.end.line === b.end.line;
+}
+function compareStrings(left, right) {
+	if (left < right) return -1;
+	if (left > right) return 1;
+	return 0;
+}
+function mapParserDiagnostics(document) {
+	return document.diagnostics.map((diagnostic) => ({
+		code: diagnostic.code,
+		message: diagnostic.message,
+		sourceId: diagnostic.sourceId,
+		span: diagnostic.span
+	}));
+}
+function processEnumDeclarations(input) {
+	const storageTypes = {};
 	const enumTypeDescriptors = /* @__PURE__ */ new Map();
-	const namedTypeDescriptors = /* @__PURE__ */ new Map();
-	const namedTypeBaseTypes = /* @__PURE__ */ new Map();
-	for (const enumDeclaration of input.document.ast.enums) {
+	for (const enumDeclaration of input.enums) {
 		const nativeType = parseMapName({
 			attribute: getAttribute(enumDeclaration.attributes, "map"),
 			defaultValue: enumDeclaration.name,
-			sourceId,
-			diagnostics,
+			sourceId: input.sourceId,
+			diagnostics: input.diagnostics,
 			entityLabel: `Enum "${enumDeclaration.name}"`,
 			span: enumDeclaration.span
 		});
-		const descriptor = {
+		const enumStorageType = input.enumTypeConstructor ? instantiateAuthoringTypeConstructor(input.enumTypeConstructor, [nativeType, enumDeclaration.values.map((value) => value.name)]) : {
 			codecId: "pg/enum@1",
 			nativeType,
+			typeParams: { values: enumDeclaration.values.map((value) => value.name) }
+		};
+		const descriptor = {
+			codecId: enumStorageType.codecId,
+			nativeType: enumStorageType.nativeType,
 			typeRef: enumDeclaration.name
 		};
 		enumTypeDescriptors.set(enumDeclaration.name, descriptor);
-		builder = builder.storageType(enumDeclaration.name, {
-			codecId: "pg/enum@1",
-			nativeType,
-			typeParams: { values: enumDeclaration.values.map((value) => value.name) }
-		});
+		storageTypes[enumDeclaration.name] = {
+			codecId: enumStorageType.codecId,
+			nativeType: enumStorageType.nativeType,
+			typeParams: enumStorageType.typeParams ?? { values: enumDeclaration.values.map((value) => value.name) }
+		};
 	}
-	for (const declaration of input.document.ast.types?.declarations ?? []) {
-		const baseDescriptor = enumTypeDescriptors.get(declaration.baseType) ?? input.scalarTypeDescriptors.get(declaration.baseType);
+	return {
+		storageTypes,
+		enumTypeDescriptors
+	};
+}
+function resolveNamedTypeDeclarations(input) {
+	const storageTypes = {};
+	const namedTypeDescriptors = /* @__PURE__ */ new Map();
+	const namedTypeBaseTypes = /* @__PURE__ */ new Map();
+	for (const declaration of input.declarations) {
+		const baseDescriptor = input.enumTypeDescriptors.get(declaration.baseType) ?? input.scalarTypeDescriptors.get(declaration.baseType);
 		if (!baseDescriptor) {
-			diagnostics.push({
+			input.diagnostics.push({
 				code: "PSL_UNSUPPORTED_NAMED_TYPE_BASE",
 				message: `Named type "${declaration.name}" references unsupported base type "${declaration.baseType}"`,
-				sourceId,
+				sourceId: input.sourceId,
 				span: declaration.span
 			});
 			continue;
@@ -1060,58 +1112,59 @@ function interpretPslDocumentToSqlContractIR(input) {
 		const dbNativeTypeAttribute = declaration.attributes.find((attribute) => attribute.name.startsWith("db."));
 		const unsupportedNamedTypeAttribute = declaration.attributes.find((attribute) => attribute.name !== "pgvector.column" && !attribute.name.startsWith("db."));
 		if (unsupportedNamedTypeAttribute) {
-			diagnostics.push({
+			input.diagnostics.push({
 				code: "PSL_UNSUPPORTED_NAMED_TYPE_ATTRIBUTE",
 				message: `Named type "${declaration.name}" uses unsupported attribute "${unsupportedNamedTypeAttribute.name}"`,
-				sourceId,
+				sourceId: input.sourceId,
 				span: unsupportedNamedTypeAttribute.span
 			});
 			continue;
 		}
 		if (pgvectorAttribute && dbNativeTypeAttribute) {
-			diagnostics.push({
+			input.diagnostics.push({
 				code: "PSL_UNSUPPORTED_NAMED_TYPE_ATTRIBUTE",
 				message: `Named type "${declaration.name}" cannot combine @pgvector.column with @${dbNativeTypeAttribute.name}.`,
-				sourceId,
+				sourceId: input.sourceId,
 				span: dbNativeTypeAttribute.span
 			});
 			continue;
 		}
 		if (pgvectorAttribute) {
-			if (!composedExtensions.has("pgvector")) {
-				diagnostics.push({
+			if (!input.composedExtensions.has("pgvector")) {
+				input.diagnostics.push({
 					code: "PSL_EXTENSION_NAMESPACE_NOT_COMPOSED",
 					message: "Attribute \"@pgvector.column\" uses unrecognized namespace \"pgvector\". Add extension pack \"pgvector\" to extensionPacks in prisma-next.config.ts.",
-					sourceId,
+					sourceId: input.sourceId,
 					span: pgvectorAttribute.span
 				});
 				continue;
 			}
 			if (declaration.baseType !== "Bytes") {
-				diagnostics.push({
+				input.diagnostics.push({
 					code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
 					message: `Named type "${declaration.name}" uses @pgvector.column on unsupported base type "${declaration.baseType}"`,
-					sourceId,
+					sourceId: input.sourceId,
 					span: pgvectorAttribute.span
 				});
 				continue;
 			}
 			const length = parsePgvectorLength({
 				attribute: pgvectorAttribute,
-				diagnostics,
-				sourceId
+				diagnostics: input.diagnostics,
+				sourceId: input.sourceId
 			});
 			if (length === void 0) continue;
-			namedTypeDescriptors.set(declaration.name, {
-				codecId: "pg/vector@1",
-				nativeType: "vector",
-				typeParams: { length }
-			});
-			builder = builder.storageType(declaration.name, {
+			const pgvectorStorageType = input.pgvectorVectorConstructor ? instantiateAuthoringTypeConstructor(input.pgvectorVectorConstructor, [length]) : {
 				codecId: "pg/vector@1",
 				nativeType: "vector",
 				typeParams: { length }
-			});
+			};
+			namedTypeDescriptors.set(declaration.name, toNamedTypeFieldDescriptor(declaration.name, pgvectorStorageType));
+			storageTypes[declaration.name] = {
+				codecId: pgvectorStorageType.codecId,
+				nativeType: pgvectorStorageType.nativeType,
+				typeParams: pgvectorStorageType.typeParams ?? { length }
+			};
 			continue;
 		}
 		if (dbNativeTypeAttribute) {
@@ -1119,273 +1172,614 @@ function interpretPslDocumentToSqlContractIR(input) {
 				attribute: dbNativeTypeAttribute,
 				baseType: declaration.baseType,
 				baseDescriptor,
-				diagnostics,
-				sourceId,
+				diagnostics: input.diagnostics,
+				sourceId: input.sourceId,
 				entityLabel: `Named type "${declaration.name}"`
 			});
 			if (!descriptor$1) continue;
-			namedTypeDescriptors.set(declaration.name, {
-				...descriptor$1,
-				typeRef: declaration.name
-			});
-			builder = builder.storageType(declaration.name, {
+			namedTypeDescriptors.set(declaration.name, toNamedTypeFieldDescriptor(declaration.name, descriptor$1));
+			storageTypes[declaration.name] = {
 				codecId: descriptor$1.codecId,
 				nativeType: descriptor$1.nativeType,
 				typeParams: descriptor$1.typeParams ?? {}
-			});
+			};
 			continue;
 		}
-		const descriptor = {
-			codecId: baseDescriptor.codecId,
-			nativeType: baseDescriptor.nativeType,
-			typeRef: declaration.name
-		};
+		const descriptor = toNamedTypeFieldDescriptor(declaration.name, baseDescriptor);
 		namedTypeDescriptors.set(declaration.name, descriptor);
-		builder = builder.storageType(declaration.name, {
+		storageTypes[declaration.name] = {
 			codecId: baseDescriptor.codecId,
 			nativeType: baseDescriptor.nativeType,
 			typeParams: {}
-		});
+		};
 	}
-	const modelMappings = buildModelMappings(input.document.ast.models, diagnostics, sourceId);
-	const resolvedModels = [];
-	const fkRelationMetadata = [];
-	const backrelationCandidates = [];
-	for (const model of input.document.ast.models) {
-		const mapping = modelMappings.get(model.name);
-		if (!mapping) continue;
-		const tableName = mapping.tableName;
-		const resolvedFields = collectResolvedFields(model, mapping, enumTypeDescriptors, namedTypeDescriptors, namedTypeBaseTypes, modelNames, composedExtensions, defaultFunctionRegistry, generatorDescriptorById, diagnostics, sourceId, input.scalarTypeDescriptors);
-		resolvedModels.push({
-			model,
-			mapping,
-			resolvedFields
-		});
-		const primaryKeyColumns = resolvedFields.filter((field) => field.isId).map((field) => field.columnName);
-		if (primaryKeyColumns.length === 0) diagnostics.push({
-			code: "PSL_MISSING_PRIMARY_KEY",
-			message: `Model "${model.name}" must declare at least one @id field for SQL provider`,
+	return {
+		storageTypes,
+		namedTypeDescriptors,
+		namedTypeBaseTypes
+	};
+}
+function buildModelNodeFromPsl(input) {
+	const { model, mapping, sourceId, diagnostics } = input;
+	const tableName = mapping.tableName;
+	const resolvedFields = collectResolvedFields(model, mapping, input.enumTypeDescriptors, input.namedTypeDescriptors, input.namedTypeBaseTypes, input.modelNames, input.compositeTypeNames, input.composedExtensions, input.authoringContributions, input.defaultFunctionRegistry, input.generatorDescriptorById, diagnostics, sourceId, input.scalarTypeDescriptors);
+	const primaryKeyFields = resolvedFields.filter((field) => field.isId);
+	const primaryKeyColumns = primaryKeyFields.map((field) => field.columnName);
+	const primaryKeyName = primaryKeyFields.length === 1 ? primaryKeyFields[0]?.idName : void 0;
+	const isVariantModel = model.attributes.some((attr) => attr.name === "base");
+	if (primaryKeyColumns.length === 0 && !isVariantModel) diagnostics.push({
+		code: "PSL_MISSING_PRIMARY_KEY",
+		message: `Model "${model.name}" must declare at least one @id field for SQL provider`,
+		sourceId,
+		span: model.span
+	});
+	const resultBackrelationCandidates = [];
+	for (const field of model.fields) {
+		if (!field.list || !input.modelNames.has(field.typeName)) continue;
+		const attributesValid = validateNavigationListFieldAttributes({
+			modelName: model.name,
+			field,
 			sourceId,
-			span: model.span
+			composedExtensions: input.composedExtensions,
+			diagnostics
 		});
-		for (const field of model.fields) {
-			if (!field.list || !modelNames.has(field.typeName)) continue;
-			const attributesValid = validateNavigationListFieldAttributes({
+		const relationAttribute = getAttribute(field.attributes, "relation");
+		let relationName;
+		if (relationAttribute) {
+			const parsedRelation = parseRelationAttribute({
+				attribute: relationAttribute,
 				modelName: model.name,
-				field,
+				fieldName: field.name,
 				sourceId,
-				composedExtensions,
 				diagnostics
 			});
-			const relationAttribute = getAttribute(field.attributes, "relation");
-			let relationName;
-			if (relationAttribute) {
-				const parsedRelation = parseRelationAttribute({
-					attribute: relationAttribute,
-					modelName: model.name,
-					fieldName: field.name,
+			if (!parsedRelation) continue;
+			if (parsedRelation.fields || parsedRelation.references) {
+				diagnostics.push({
+					code: "PSL_INVALID_RELATION_ATTRIBUTE",
+					message: `Backrelation list field "${model.name}.${field.name}" cannot declare fields/references; define them on the FK-side relation field`,
 					sourceId,
-					diagnostics
+					span: relationAttribute.span
 				});
-				if (!parsedRelation) continue;
-				if (parsedRelation.fields || parsedRelation.references) {
-					diagnostics.push({
-						code: "PSL_INVALID_RELATION_ATTRIBUTE",
-						message: `Backrelation list field "${model.name}.${field.name}" cannot declare fields/references; define them on the FK-side relation field`,
-						sourceId,
-						span: relationAttribute.span
-					});
-					continue;
-				}
-				if (parsedRelation.onDelete || parsedRelation.onUpdate) {
-					diagnostics.push({
-						code: "PSL_INVALID_RELATION_ATTRIBUTE",
-						message: `Backrelation list field "${model.name}.${field.name}" cannot declare onDelete/onUpdate; define referential actions on the FK-side relation field`,
-						sourceId,
-						span: relationAttribute.span
-					});
-					continue;
-				}
-				relationName = parsedRelation.relationName;
+				continue;
+			}
+			if (parsedRelation.onDelete || parsedRelation.onUpdate) {
+				diagnostics.push({
+					code: "PSL_INVALID_RELATION_ATTRIBUTE",
+					message: `Backrelation list field "${model.name}.${field.name}" cannot declare onDelete/onUpdate; define referential actions on the FK-side relation field`,
+					sourceId,
+					span: relationAttribute.span
+				});
+				continue;
 			}
-			if (!attributesValid) continue;
-			backrelationCandidates.push({
+			relationName = parsedRelation.relationName;
+		}
+		if (!attributesValid) continue;
+		resultBackrelationCandidates.push({
+			modelName: model.name,
+			tableName,
+			field,
+			targetModelName: field.typeName,
+			...ifDefined("relationName", relationName)
+		});
+	}
+	const relationAttributes = model.fields.map((field) => ({
+		field,
+		relation: getAttribute(field.attributes, "relation")
+	})).filter((entry) => Boolean(entry.relation));
+	const uniqueConstraints = resolvedFields.filter((field) => field.isUnique).map((field) => ({
+		columns: [field.columnName],
+		...ifDefined("name", field.uniqueName)
+	}));
+	const indexNodes = [];
+	const foreignKeyNodes = [];
+	for (const modelAttribute of model.attributes) {
+		if (modelAttribute.name === "map") continue;
+		if (modelAttribute.name === "discriminator" || modelAttribute.name === "base") continue;
+		if (modelAttribute.name === "unique" || modelAttribute.name === "index") {
+			const fieldNames = parseAttributeFieldList({
+				attribute: modelAttribute,
+				sourceId,
+				diagnostics,
+				code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+				messagePrefix: `Model "${model.name}" @@${modelAttribute.name}`
+			});
+			if (!fieldNames) continue;
+			const columnNames = mapFieldNamesToColumns({
 				modelName: model.name,
-				tableName,
-				field,
-				targetModelName: field.typeName,
-				...ifDefined("relationName", relationName)
+				fieldNames,
+				mapping,
+				sourceId,
+				diagnostics,
+				span: modelAttribute.span,
+				contextLabel: `Model "${model.name}" @@${modelAttribute.name}`
+			});
+			if (!columnNames) continue;
+			const constraintName = parseConstraintMapArgument({
+				attribute: modelAttribute,
+				sourceId,
+				diagnostics,
+				entityLabel: `Model "${model.name}" @@${modelAttribute.name}`,
+				span: modelAttribute.span,
+				code: "PSL_INVALID_ATTRIBUTE_ARGUMENT"
+			});
+			if (modelAttribute.name === "unique") uniqueConstraints.push({
+				columns: columnNames,
+				...ifDefined("name", constraintName)
 			});
+			else indexNodes.push({
+				columns: columnNames,
+				...ifDefined("name", constraintName)
+			});
+			continue;
 		}
-		const relationAttributes = model.fields.map((field) => ({
-			field,
-			relation: getAttribute(field.attributes, "relation")
-		})).filter((entry) => Boolean(entry.relation));
-		builder = builder.table(tableName, (tableBuilder) => {
-			let table = tableBuilder;
-			for (const resolvedField of resolvedFields) {
-				if (resolvedField.executionDefault) table = table.generated(resolvedField.columnName, {
-					type: resolvedField.descriptor,
-					generated: resolvedField.executionDefault
-				});
-				else {
-					const options = {
-						type: resolvedField.descriptor,
-						...ifDefined("nullable", resolvedField.field.optional ? true : void 0),
-						...ifDefined("default", resolvedField.defaultValue)
-					};
-					table = table.column(resolvedField.columnName, options);
-				}
-				if (resolvedField.isUnique) table = table.unique([resolvedField.columnName]);
+		if (modelAttribute.name.startsWith("pgvector.") && !input.composedExtensions.has("pgvector")) {
+			diagnostics.push({
+				code: "PSL_EXTENSION_NAMESPACE_NOT_COMPOSED",
+				message: `Attribute "@@${modelAttribute.name}" uses unrecognized namespace "pgvector". Add extension pack "pgvector" to extensionPacks in prisma-next.config.ts.`,
+				sourceId,
+				span: modelAttribute.span
+			});
+			continue;
+		}
+		diagnostics.push({
+			code: "PSL_UNSUPPORTED_MODEL_ATTRIBUTE",
+			message: `Model "${model.name}" uses unsupported attribute "@@${modelAttribute.name}"`,
+			sourceId,
+			span: modelAttribute.span
+		});
+	}
+	const resultFkRelationMetadata = [];
+	for (const relationAttribute of relationAttributes) {
+		if (relationAttribute.field.list) continue;
+		if (!input.modelNames.has(relationAttribute.field.typeName)) {
+			diagnostics.push({
+				code: "PSL_INVALID_RELATION_TARGET",
+				message: `Relation field "${model.name}.${relationAttribute.field.name}" references unknown model "${relationAttribute.field.typeName}"`,
+				sourceId,
+				span: relationAttribute.field.span
+			});
+			continue;
+		}
+		const parsedRelation = parseRelationAttribute({
+			attribute: relationAttribute.relation,
+			modelName: model.name,
+			fieldName: relationAttribute.field.name,
+			sourceId,
+			diagnostics
+		});
+		if (!parsedRelation) continue;
+		if (!parsedRelation.fields || !parsedRelation.references) {
+			diagnostics.push({
+				code: "PSL_INVALID_RELATION_ATTRIBUTE",
+				message: `Relation field "${model.name}.${relationAttribute.field.name}" requires fields and references arguments`,
+				sourceId,
+				span: relationAttribute.relation.span
+			});
+			continue;
+		}
+		const targetMapping = input.modelMappings.get(relationAttribute.field.typeName);
+		if (!targetMapping) {
+			diagnostics.push({
+				code: "PSL_INVALID_RELATION_TARGET",
+				message: `Relation field "${model.name}.${relationAttribute.field.name}" references unknown model "${relationAttribute.field.typeName}"`,
+				sourceId,
+				span: relationAttribute.field.span
+			});
+			continue;
+		}
+		const localColumns = mapFieldNamesToColumns({
+			modelName: model.name,
+			fieldNames: parsedRelation.fields,
+			mapping,
+			sourceId,
+			diagnostics,
+			span: relationAttribute.relation.span,
+			contextLabel: `Relation field "${model.name}.${relationAttribute.field.name}"`
+		});
+		if (!localColumns) continue;
+		const referencedColumns = mapFieldNamesToColumns({
+			modelName: targetMapping.model.name,
+			fieldNames: parsedRelation.references,
+			mapping: targetMapping,
+			sourceId,
+			diagnostics,
+			span: relationAttribute.relation.span,
+			contextLabel: `Relation field "${model.name}.${relationAttribute.field.name}"`
+		});
+		if (!referencedColumns) continue;
+		if (localColumns.length !== referencedColumns.length) {
+			diagnostics.push({
+				code: "PSL_INVALID_RELATION_ATTRIBUTE",
+				message: `Relation field "${model.name}.${relationAttribute.field.name}" must provide the same number of fields and references`,
+				sourceId,
+				span: relationAttribute.relation.span
+			});
+			continue;
+		}
+		const onDelete = parsedRelation.onDelete ? normalizeReferentialAction({
+			modelName: model.name,
+			fieldName: relationAttribute.field.name,
+			actionName: "onDelete",
+			actionToken: parsedRelation.onDelete,
+			sourceId,
+			span: relationAttribute.field.span,
+			diagnostics
+		}) : void 0;
+		const onUpdate = parsedRelation.onUpdate ? normalizeReferentialAction({
+			modelName: model.name,
+			fieldName: relationAttribute.field.name,
+			actionName: "onUpdate",
+			actionToken: parsedRelation.onUpdate,
+			sourceId,
+			span: relationAttribute.field.span,
+			diagnostics
+		}) : void 0;
+		foreignKeyNodes.push({
+			columns: localColumns,
+			references: {
+				model: targetMapping.model.name,
+				table: targetMapping.tableName,
+				columns: referencedColumns
+			},
+			...ifDefined("name", parsedRelation.constraintName),
+			...ifDefined("onDelete", onDelete),
+			...ifDefined("onUpdate", onUpdate)
+		});
+		resultFkRelationMetadata.push({
+			declaringModelName: model.name,
+			declaringFieldName: relationAttribute.field.name,
+			declaringTableName: tableName,
+			targetModelName: targetMapping.model.name,
+			targetTableName: targetMapping.tableName,
+			...ifDefined("relationName", parsedRelation.relationName),
+			localColumns,
+			referencedColumns
+		});
+	}
+	return {
+		modelNode: {
+			modelName: model.name,
+			tableName,
+			fields: resolvedFields.map((resolvedField) => ({
+				fieldName: resolvedField.field.name,
+				columnName: resolvedField.columnName,
+				descriptor: resolvedField.descriptor,
+				nullable: resolvedField.field.optional,
+				...ifDefined("default", resolvedField.defaultValue),
+				...ifDefined("executionDefault", resolvedField.executionDefault)
+			})),
+			...primaryKeyColumns.length > 0 ? { id: {
+				columns: primaryKeyColumns,
+				...ifDefined("name", primaryKeyName)
+			} } : {},
+			...uniqueConstraints.length > 0 ? { uniques: uniqueConstraints } : {},
+			...indexNodes.length > 0 ? { indexes: indexNodes } : {},
+			...foreignKeyNodes.length > 0 ? { foreignKeys: foreignKeyNodes } : {}
+		},
+		fkRelationMetadata: resultFkRelationMetadata,
+		backrelationCandidates: resultBackrelationCandidates,
+		resolvedFields
+	};
+}
+function buildValueObjects(compositeTypes, enumTypeDescriptors, namedTypeDescriptors, scalarTypeDescriptors, diagnostics, sourceId) {
+	const valueObjects = {};
+	const compositeTypeNames = new Set(compositeTypes.map((ct) => ct.name));
+	for (const compositeType of compositeTypes) {
+		const fields = {};
+		for (const field of compositeType.fields) {
+			if (compositeTypeNames.has(field.typeName)) {
+				const result = {
+					type: {
+						kind: "valueObject",
+						name: field.typeName
+					},
+					nullable: field.optional
+				};
+				fields[field.name] = field.list ? {
+					...result,
+					many: true
+				} : result;
+				continue;
 			}
-			if (primaryKeyColumns.length > 0) table = table.primaryKey(primaryKeyColumns);
-			for (const modelAttribute of model.attributes) {
-				if (modelAttribute.name === "map") continue;
-				if (modelAttribute.name === "unique" || modelAttribute.name === "index") {
-					const fieldNames = parseAttributeFieldList({
-						attribute: modelAttribute,
-						sourceId,
-						diagnostics,
-						code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
-						messagePrefix: `Model "${model.name}" @@${modelAttribute.name}`
-					});
-					if (!fieldNames) continue;
-					const columnNames = mapFieldNamesToColumns({
-						modelName: model.name,
-						fieldNames,
-						mapping,
-						sourceId,
-						diagnostics,
-						span: modelAttribute.span,
-						contextLabel: `Model "${model.name}" @@${modelAttribute.name}`
-					});
-					if (!columnNames) continue;
-					if (modelAttribute.name === "unique") table = table.unique(columnNames);
-					else table = table.index(columnNames);
-					continue;
-				}
-				if (modelAttribute.name.startsWith("pgvector.") && !composedExtensions.has("pgvector")) {
-					diagnostics.push({
-						code: "PSL_EXTENSION_NAMESPACE_NOT_COMPOSED",
-						message: `Attribute "@@${modelAttribute.name}" uses unrecognized namespace "pgvector". Add extension pack "pgvector" to extensionPacks in prisma-next.config.ts.`,
-						sourceId,
-						span: modelAttribute.span
-					});
-					continue;
-				}
+			const descriptor = resolveColumnDescriptor(field, enumTypeDescriptors, namedTypeDescriptors, scalarTypeDescriptors);
+			if (!descriptor) {
 				diagnostics.push({
-					code: "PSL_UNSUPPORTED_MODEL_ATTRIBUTE",
-					message: `Model "${model.name}" uses unsupported attribute "@@${modelAttribute.name}"`,
+					code: "PSL_UNSUPPORTED_FIELD_TYPE",
+					message: `Field "${compositeType.name}.${field.name}" type "${field.typeName}" is not supported`,
 					sourceId,
-					span: modelAttribute.span
+					span: field.span
 				});
+				continue;
 			}
-			for (const relationAttribute of relationAttributes) {
-				if (relationAttribute.field.list) continue;
-				if (!modelNames.has(relationAttribute.field.typeName)) {
-					diagnostics.push({
-						code: "PSL_INVALID_RELATION_TARGET",
-						message: `Relation field "${model.name}.${relationAttribute.field.name}" references unknown model "${relationAttribute.field.typeName}"`,
-						sourceId,
-						span: relationAttribute.field.span
-					});
-					continue;
+			fields[field.name] = {
+				nullable: field.optional,
+				type: {
+					kind: "scalar",
+					codecId: descriptor.codecId
 				}
-				const parsedRelation = parseRelationAttribute({
-					attribute: relationAttribute.relation,
-					modelName: model.name,
-					fieldName: relationAttribute.field.name,
+			};
+		}
+		valueObjects[compositeType.name] = { fields };
+	}
+	return valueObjects;
+}
+function patchModelDomainFields(models, modelResolvedFields) {
+	let patched = models;
+	for (const [modelName, resolvedFields] of modelResolvedFields) {
+		const model = patched[modelName];
+		if (!model) continue;
+		let needsPatch = false;
+		const patchedFields = { ...model.fields };
+		for (const rf of resolvedFields) if (rf.valueObjectTypeName) {
+			needsPatch = true;
+			patchedFields[rf.field.name] = {
+				nullable: rf.field.optional,
+				type: {
+					kind: "valueObject",
+					name: rf.valueObjectTypeName
+				},
+				...rf.many ? { many: true } : {}
+			};
+		} else if (rf.many && rf.scalarCodecId) {
+			needsPatch = true;
+			patchedFields[rf.field.name] = {
+				nullable: rf.field.optional,
+				type: {
+					kind: "scalar",
+					codecId: rf.scalarCodecId
+				},
+				many: true
+			};
+		}
+		if (needsPatch) patched = {
+			...patched,
+			[modelName]: {
+				...model,
+				fields: patchedFields
+			}
+		};
+	}
+	return patched;
+}
+function collectPolymorphismDeclarations(models, sourceId, diagnostics) {
+	const discriminatorDeclarations = /* @__PURE__ */ new Map();
+	const baseDeclarations = /* @__PURE__ */ new Map();
+	for (const model of models) for (const attr of model.attributes) {
+		if (attr.name === "discriminator") {
+			const fieldName = getPositionalArgument(attr);
+			if (!fieldName) {
+				diagnostics.push({
+					code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+					message: `Model "${model.name}" @@discriminator requires a field name argument`,
 					sourceId,
-					diagnostics
+					span: attr.span
 				});
-				if (!parsedRelation) continue;
-				if (!parsedRelation.fields || !parsedRelation.references) {
-					diagnostics.push({
-						code: "PSL_INVALID_RELATION_ATTRIBUTE",
-						message: `Relation field "${model.name}.${relationAttribute.field.name}" requires fields and references arguments`,
-						sourceId,
-						span: relationAttribute.relation.span
-					});
-					continue;
-				}
-				const targetMapping = modelMappings.get(relationAttribute.field.typeName);
-				if (!targetMapping) {
-					diagnostics.push({
-						code: "PSL_INVALID_RELATION_TARGET",
-						message: `Relation field "${model.name}.${relationAttribute.field.name}" references unknown model "${relationAttribute.field.typeName}"`,
-						sourceId,
-						span: relationAttribute.field.span
-					});
-					continue;
-				}
-				const localColumns = mapFieldNamesToColumns({
-					modelName: model.name,
-					fieldNames: parsedRelation.fields,
-					mapping,
+				continue;
+			}
+			const discField = model.fields.find((f) => f.name === fieldName);
+			if (discField && discField.typeName !== "String") {
+				diagnostics.push({
+					code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+					message: `Discriminator field "${fieldName}" on model "${model.name}" must be of type String, but is "${discField.typeName}"`,
 					sourceId,
-					diagnostics,
-					span: relationAttribute.relation.span,
-					contextLabel: `Relation field "${model.name}.${relationAttribute.field.name}"`
+					span: attr.span
 				});
-				if (!localColumns) continue;
-				const referencedColumns = mapFieldNamesToColumns({
-					modelName: targetMapping.model.name,
-					fieldNames: parsedRelation.references,
-					mapping: targetMapping,
+				continue;
+			}
+			discriminatorDeclarations.set(model.name, {
+				fieldName,
+				span: attr.span
+			});
+		}
+		if (attr.name === "base") {
+			const baseName = getPositionalArgument(attr, 0);
+			const rawValue = getPositionalArgument(attr, 1);
+			if (!baseName || !rawValue) {
+				diagnostics.push({
+					code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+					message: `Model "${model.name}" @@base requires two arguments: base model name and discriminator value`,
 					sourceId,
-					diagnostics,
-					span: relationAttribute.relation.span,
-					contextLabel: `Relation field "${model.name}.${relationAttribute.field.name}"`
+					span: attr.span
 				});
-				if (!referencedColumns) continue;
-				if (localColumns.length !== referencedColumns.length) {
-					diagnostics.push({
-						code: "PSL_INVALID_RELATION_ATTRIBUTE",
-						message: `Relation field "${model.name}.${relationAttribute.field.name}" must provide the same number of fields and references`,
-						sourceId,
-						span: relationAttribute.relation.span
-					});
-					continue;
-				}
-				const onDelete = parsedRelation.onDelete ? normalizeReferentialAction({
-					modelName: model.name,
-					fieldName: relationAttribute.field.name,
-					actionName: "onDelete",
-					actionToken: parsedRelation.onDelete,
-					sourceId,
-					span: relationAttribute.field.span,
-					diagnostics
-				}) : void 0;
-				const onUpdate = parsedRelation.onUpdate ? normalizeReferentialAction({
-					modelName: model.name,
-					fieldName: relationAttribute.field.name,
-					actionName: "onUpdate",
-					actionToken: parsedRelation.onUpdate,
+				continue;
+			}
+			const value = parseQuotedStringLiteral(rawValue);
+			if (value === void 0) {
+				diagnostics.push({
+					code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+					message: `Model "${model.name}" @@base discriminator value must be a quoted string literal`,
 					sourceId,
-					span: relationAttribute.field.span,
-					diagnostics
-				}) : void 0;
-				table = table.foreignKey(localColumns, {
-					table: targetMapping.tableName,
-					columns: referencedColumns
-				}, {
-					...ifDefined("name", parsedRelation.constraintName),
-					...ifDefined("onDelete", onDelete),
-					...ifDefined("onUpdate", onUpdate)
+					span: attr.span
 				});
-				fkRelationMetadata.push({
-					declaringModelName: model.name,
-					declaringFieldName: relationAttribute.field.name,
-					declaringTableName: tableName,
-					targetModelName: targetMapping.model.name,
-					targetTableName: targetMapping.tableName,
-					...ifDefined("relationName", parsedRelation.relationName),
-					localColumns,
-					referencedColumns
+				continue;
+			}
+			baseDeclarations.set(model.name, {
+				baseName,
+				value,
+				span: attr.span
+			});
+		}
+	}
+	return {
+		discriminatorDeclarations,
+		baseDeclarations
+	};
+}
+function resolvePolymorphism(models, discriminatorDeclarations, baseDeclarations, modelNames, modelMappings, sourceId, diagnostics) {
+	let patched = models;
+	for (const [modelName, decl] of discriminatorDeclarations) {
+		if (baseDeclarations.has(modelName)) {
+			diagnostics.push({
+				code: "PSL_DISCRIMINATOR_AND_BASE",
+				message: `Model "${modelName}" cannot have both @@discriminator and @@base`,
+				sourceId,
+				span: decl.span
+			});
+			continue;
+		}
+		const model = patched[modelName];
+		if (!model) continue;
+		if (!Object.hasOwn(model.fields, decl.fieldName)) {
+			diagnostics.push({
+				code: "PSL_DISCRIMINATOR_FIELD_NOT_FOUND",
+				message: `Discriminator field "${decl.fieldName}" is not a field on model "${modelName}"`,
+				sourceId,
+				span: decl.span
+			});
+			continue;
+		}
+		const variants = {};
+		const seenValues = /* @__PURE__ */ new Map();
+		for (const [variantName, baseDecl] of baseDeclarations) {
+			if (baseDecl.baseName !== modelName) continue;
+			const existingVariant = seenValues.get(baseDecl.value);
+			if (existingVariant) {
+				diagnostics.push({
+					code: "PSL_DUPLICATE_DISCRIMINATOR_VALUE",
+					message: `Discriminator value "${baseDecl.value}" is used by both "${existingVariant}" and "${variantName}" on base model "${modelName}"`,
+					sourceId,
+					span: baseDecl.span
 				});
+				continue;
+			}
+			seenValues.set(baseDecl.value, variantName);
+			variants[variantName] = { value: baseDecl.value };
+		}
+		if (Object.keys(variants).length === 0) {
+			diagnostics.push({
+				code: "PSL_ORPHANED_DISCRIMINATOR",
+				message: `Model "${modelName}" has @@discriminator but no variant models declare @@base(${modelName}, ...)`,
+				sourceId,
+				span: decl.span
+			});
+			continue;
+		}
+		patched = {
+			...patched,
+			[modelName]: {
+				...model,
+				discriminator: { field: decl.fieldName },
+				variants
+			}
+		};
+	}
+	for (const [variantName, baseDecl] of baseDeclarations) {
+		if (!modelNames.has(baseDecl.baseName)) {
+			diagnostics.push({
+				code: "PSL_BASE_TARGET_NOT_FOUND",
+				message: `Model "${variantName}" @@base references non-existent model "${baseDecl.baseName}"`,
+				sourceId,
+				span: baseDecl.span
+			});
+			continue;
+		}
+		if (!discriminatorDeclarations.has(baseDecl.baseName)) {
+			diagnostics.push({
+				code: "PSL_ORPHANED_BASE",
+				message: `Model "${variantName}" declares @@base(${baseDecl.baseName}, ...) but "${baseDecl.baseName}" has no @@discriminator`,
+				sourceId,
+				span: baseDecl.span
+			});
+			continue;
+		}
+		if (discriminatorDeclarations.has(variantName)) continue;
+		const variantModel = patched[variantName];
+		if (!variantModel) continue;
+		const baseMapping = modelMappings.get(baseDecl.baseName);
+		const variantMapping = modelMappings.get(variantName);
+		const resolvedTable = variantMapping?.model.attributes.some((attr) => attr.name === "map") ?? false ? variantMapping?.tableName : baseMapping?.tableName;
+		patched = {
+			...patched,
+			[variantName]: {
+				...variantModel,
+				base: baseDecl.baseName,
+				...resolvedTable ? { storage: {
+					...variantModel.storage,
+					table: resolvedTable
+				} } : {}
 			}
-			return table;
+		};
+	}
+	return patched;
+}
+function interpretPslDocumentToSqlContract(input) {
+	const sourceId = input.document.ast.sourceId;
+	if (!input.target) return notOk({
+		summary: "PSL to SQL contract interpretation failed",
+		diagnostics: [{
+			code: "PSL_TARGET_CONTEXT_REQUIRED",
+			message: "PSL interpretation requires an explicit target context from composition.",
+			sourceId
+		}]
+	});
+	if (!input.scalarTypeDescriptors) return notOk({
+		summary: "PSL to SQL contract interpretation failed",
+		diagnostics: [{
+			code: "PSL_SCALAR_TYPE_CONTEXT_REQUIRED",
+			message: "PSL interpretation requires composed scalar type descriptors.",
+			sourceId
+		}]
+	});
+	const diagnostics = mapParserDiagnostics(input.document);
+	const models = input.document.ast.models ?? [];
+	const enums = input.document.ast.enums ?? [];
+	const compositeTypes = input.document.ast.compositeTypes ?? [];
+	const modelNames = new Set(models.map((model) => model.name));
+	const compositeTypeNames = new Set(compositeTypes.map((ct) => ct.name));
+	const composedExtensions = new Set(input.composedExtensionPacks ?? []);
+	const defaultFunctionRegistry = input.controlMutationDefaults?.defaultFunctionRegistry ?? /* @__PURE__ */ new Map();
+	const generatorDescriptors = input.controlMutationDefaults?.generatorDescriptors ?? [];
+	const generatorDescriptorById = /* @__PURE__ */ new Map();
+	for (const descriptor of generatorDescriptors) generatorDescriptorById.set(descriptor.id, descriptor);
+	const enumResult = processEnumDeclarations({
+		enums,
+		sourceId,
+		enumTypeConstructor: getAuthoringTypeConstructor(input.authoringContributions, ["enum"]),
+		diagnostics
+	});
+	const namedTypeResult = resolveNamedTypeDeclarations({
+		declarations: input.document.ast.types?.declarations ?? [],
+		sourceId,
+		enumTypeDescriptors: enumResult.enumTypeDescriptors,
+		scalarTypeDescriptors: input.scalarTypeDescriptors,
+		composedExtensions,
+		pgvectorVectorConstructor: getAuthoringTypeConstructor(input.authoringContributions, ["pgvector", "vector"]),
+		diagnostics
+	});
+	const storageTypes = {
+		...enumResult.storageTypes,
+		...namedTypeResult.storageTypes
+	};
+	const modelMappings = buildModelMappings(models, diagnostics, sourceId);
+	const modelNodes = [];
+	const fkRelationMetadata = [];
+	const backrelationCandidates = [];
+	const modelResolvedFields = /* @__PURE__ */ new Map();
+	for (const model of models) {
+		const mapping = modelMappings.get(model.name);
+		if (!mapping) continue;
+		const result = buildModelNodeFromPsl({
+			model,
+			mapping,
+			modelMappings,
+			modelNames,
+			compositeTypeNames,
+			enumTypeDescriptors: enumResult.enumTypeDescriptors,
+			namedTypeDescriptors: namedTypeResult.namedTypeDescriptors,
+			namedTypeBaseTypes: namedTypeResult.namedTypeBaseTypes,
+			composedExtensions,
+			authoringContributions: input.authoringContributions,
+			defaultFunctionRegistry,
+			generatorDescriptorById,
+			scalarTypeDescriptors: input.scalarTypeDescriptors,
+			sourceId,
+			diagnostics
 		});
+		modelNodes.push(result.modelNode);
+		fkRelationMetadata.push(...result.fkRelationMetadata);
+		backrelationCandidates.push(...result.backrelationCandidates);
+		modelResolvedFields.set(model.name, result.resolvedFields);
 	}
 	const { modelRelations, fkRelationsByPair } = indexFkRelations({ fkRelationMetadata });
 	applyBackrelationCandidates({
@@ -1395,18 +1789,38 @@ function interpretPslDocumentToSqlContractIR(input) {
 		diagnostics,
 		sourceId
 	});
-	builder = emitModelsWithRelations({
-		builder,
-		resolvedModels,
-		modelRelations
-	});
+	const { discriminatorDeclarations, baseDeclarations } = collectPolymorphismDeclarations(models, sourceId, diagnostics);
 	if (diagnostics.length > 0) return notOk({
-		summary: "PSL to SQL Contract IR normalization failed",
+		summary: "PSL to SQL contract interpretation failed",
 		diagnostics: diagnostics.filter((diagnostic, index, allDiagnostics) => allDiagnostics.findIndex((candidate) => candidate.code === diagnostic.code && candidate.message === diagnostic.message && candidate.sourceId === diagnostic.sourceId && (candidate.span && diagnostic.span && hasSameSpan(candidate.span, diagnostic.span) || !candidate.span && !diagnostic.span)) === index)
 	});
-	return ok(builder.build());
+	const contract = buildSqlContractFromDefinition({
+		target: input.target,
+		...ifDefined("extensionPacks", buildComposedExtensionPackRefs(input.target, [...composedExtensions].sort(compareStrings), input.composedExtensionPackRefs)),
+		...Object.keys(storageTypes).length > 0 ? { storageTypes } : {},
+		models: modelNodes.map((model) => ({
+			...model,
+			...modelRelations.has(model.modelName) ? { relations: [...modelRelations.get(model.modelName) ?? []].sort((left, right) => compareStrings(left.fieldName, right.fieldName)) } : {}
+		}))
+	});
+	const valueObjects = buildValueObjects(compositeTypes, enumResult.enumTypeDescriptors, namedTypeResult.namedTypeDescriptors, input.scalarTypeDescriptors, diagnostics, sourceId);
+	let patchedModels = patchModelDomainFields(contract.models, modelResolvedFields);
+	const polyDiagnostics = [];
+	patchedModels = resolvePolymorphism(patchedModels, discriminatorDeclarations, baseDeclarations, modelNames, modelMappings, sourceId, polyDiagnostics);
+	if (polyDiagnostics.length > 0) return notOk({
+		summary: "PSL to SQL contract interpretation failed",
+		diagnostics: polyDiagnostics
+	});
+	const variantModelNames = new Set(baseDeclarations.keys());
+	const filteredRoots = Object.fromEntries(Object.entries(contract.roots).filter(([, modelName]) => !variantModelNames.has(modelName)));
+	return ok({
+		...contract,
+		roots: filteredRoots,
+		models: patchedModels,
+		...Object.keys(valueObjects).length > 0 ? { valueObjects } : {}
+	});
 }
 
 //#endregion
-export { interpretPslDocumentToSqlContractIR as t };
-//# sourceMappingURL=interpreter-D7gLmaHz.mjs.map
+export { interpretPslDocumentToSqlContract as t };
+//# sourceMappingURL=interpreter-qjtea3zY.mjs.map