@prisma-next/sql-contract-psl 0.0.1 → 0.3.0-dev.114

package/dist/interpreter-D7gLmaHz.mjs

@@ -0,0 +1,1412 @@
+import { defineContract } from "@prisma-next/sql-contract-ts/contract-builder";
+import { assertDefined, invariant } from "@prisma-next/utils/assertions";
+import { ifDefined } from "@prisma-next/utils/defined";
+import { notOk, ok } from "@prisma-next/utils/result";
+
+//#region src/default-function-registry.ts
+function resolveSpanPositionFromBase(base, text, offset) {
+	const safeOffset = Math.min(Math.max(0, offset), text.length);
+	let line = base.start.line;
+	let column = base.start.column;
+	for (let index = 0; index < safeOffset; index += 1) {
+		const character = text[index] ?? "";
+		if (character === "\r") {
+			if (text[index + 1] === "\n" && index + 1 < safeOffset) index += 1;
+			line += 1;
+			column = 1;
+			continue;
+		}
+		if (character === "\n") {
+			line += 1;
+			column = 1;
+			continue;
+		}
+		column += 1;
+	}
+	return {
+		offset: base.start.offset + safeOffset,
+		line,
+		column
+	};
+}
+function createSpanFromBase(base, startOffset, endOffset, text) {
+	const safeStart = Math.max(0, Math.min(startOffset, text.length));
+	const safeEnd = Math.max(safeStart, Math.min(endOffset, text.length));
+	return {
+		start: resolveSpanPositionFromBase(base, text, safeStart),
+		end: resolveSpanPositionFromBase(base, text, safeEnd)
+	};
+}
+function splitTopLevelArgs(raw) {
+	if (raw.trim().length === 0) return [];
+	const parts = [];
+	let depthParen = 0;
+	let depthBracket = 0;
+	let quote = null;
+	let start = 0;
+	for (let index = 0; index < raw.length; index += 1) {
+		const character = raw[index] ?? "";
+		if (quote) {
+			if (character === quote && raw[index - 1] !== "\\") quote = null;
+			continue;
+		}
+		if (character === "\"" || character === "'") {
+			quote = character;
+			continue;
+		}
+		if (character === "(") {
+			depthParen += 1;
+			continue;
+		}
+		if (character === ")") {
+			depthParen = Math.max(0, depthParen - 1);
+			continue;
+		}
+		if (character === "[") {
+			depthBracket += 1;
+			continue;
+		}
+		if (character === "]") {
+			depthBracket = Math.max(0, depthBracket - 1);
+			continue;
+		}
+		if (character === "," && depthParen === 0 && depthBracket === 0) {
+			parts.push({
+				raw: raw.slice(start, index),
+				start,
+				end: index
+			});
+			start = index + 1;
+		}
+	}
+	parts.push({
+		raw: raw.slice(start),
+		start,
+		end: raw.length
+	});
+	return parts;
+}
+function parseDefaultFunctionCall(expression, expressionSpan) {
+	const trimmed = expression.trim();
+	const leadingWhitespace = expression.length - expression.trimStart().length;
+	const trailingWhitespace = expression.length - expression.trimEnd().length;
+	const contentEnd = expression.length - trailingWhitespace;
+	const openParen = trimmed.indexOf("(");
+	const closeParen = trimmed.lastIndexOf(")");
+	if (openParen <= 0 || closeParen !== trimmed.length - 1) return;
+	const functionName = trimmed.slice(0, openParen).trim();
+	if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(functionName)) return;
+	const parts = splitTopLevelArgs(trimmed.slice(openParen + 1, closeParen));
+	const args = [];
+	for (const part of parts) {
+		const raw = part.raw.trim();
+		if (raw.length === 0) return;
+		const leadingPartWhitespace = part.raw.length - part.raw.trimStart().length;
+		const argStart = leadingWhitespace + openParen + 1 + part.start + leadingPartWhitespace;
+		const argEnd = argStart + raw.length;
+		args.push({
+			raw,
+			span: createSpanFromBase(expressionSpan, argStart, argEnd, expression)
+		});
+	}
+	return {
+		name: functionName,
+		raw: trimmed,
+		args,
+		span: createSpanFromBase(expressionSpan, leadingWhitespace, contentEnd, expression)
+	};
+}
+function formatSupportedFunctionList(registry) {
+	const signatures = Array.from(registry.entries()).sort(([a], [b]) => a.localeCompare(b)).flatMap(([functionName, entry]) => {
+		const usageSignatures = entry.usageSignatures?.filter((signature) => signature.length > 0);
+		return usageSignatures && usageSignatures.length > 0 ? usageSignatures : [`${functionName}()`];
+	});
+	return signatures.length > 0 ? signatures.join(", ") : "none";
+}
+function lowerDefaultFunctionWithRegistry(input) {
+	const entry = input.registry.get(input.call.name);
+	if (entry) return entry.lower({
+		call: input.call,
+		context: input.context
+	});
+	const supportedFunctionList = formatSupportedFunctionList(input.registry);
+	return {
+		ok: false,
+		diagnostic: {
+			code: "PSL_UNKNOWN_DEFAULT_FUNCTION",
+			message: `Default function "${input.call.name}" is not supported in SQL PSL provider v1. Supported functions: ${supportedFunctionList}.`,
+			sourceId: input.context.sourceId,
+			span: input.call.span
+		}
+	};
+}
+
+//#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;
+	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)
+	};
+}
+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 {};
+	}
+	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
+	};
+}
+const NATIVE_TYPE_SPECS = {
+	"db.VarChar": {
+		args: "optionalLength",
+		baseType: "String",
+		codecId: "sql/varchar@1",
+		nativeType: "character varying"
+	},
+	"db.Char": {
+		args: "optionalLength",
+		baseType: "String",
+		codecId: "sql/char@1",
+		nativeType: "character"
+	},
+	"db.Uuid": {
+		args: "noArgs",
+		baseType: "String",
+		codecId: null,
+		nativeType: "uuid"
+	},
+	"db.SmallInt": {
+		args: "noArgs",
+		baseType: "Int",
+		codecId: "pg/int2@1",
+		nativeType: "int2"
+	},
+	"db.Real": {
+		args: "noArgs",
+		baseType: "Float",
+		codecId: "pg/float4@1",
+		nativeType: "float4"
+	},
+	"db.Numeric": {
+		args: "optionalNumeric",
+		baseType: "Decimal",
+		codecId: "pg/numeric@1",
+		nativeType: "numeric"
+	},
+	"db.Timestamp": {
+		args: "optionalPrecision",
+		baseType: "DateTime",
+		codecId: "pg/timestamp@1",
+		nativeType: "timestamp"
+	},
+	"db.Timestamptz": {
+		args: "optionalPrecision",
+		baseType: "DateTime",
+		codecId: "pg/timestamptz@1",
+		nativeType: "timestamptz"
+	},
+	"db.Date": {
+		args: "noArgs",
+		baseType: "DateTime",
+		codecId: null,
+		nativeType: "date"
+	},
+	"db.Time": {
+		args: "optionalPrecision",
+		baseType: "DateTime",
+		codecId: "pg/time@1",
+		nativeType: "time"
+	},
+	"db.Timetz": {
+		args: "optionalPrecision",
+		baseType: "DateTime",
+		codecId: "pg/timetz@1",
+		nativeType: "timetz"
+	},
+	"db.Json": {
+		args: "noArgs",
+		baseType: "Json",
+		codecId: "pg/json@1",
+		nativeType: "json"
+	}
+};
+function resolveDbNativeTypeAttribute(input) {
+	const spec = NATIVE_TYPE_SPECS[input.attribute.name];
+	if (!spec) {
+		input.diagnostics.push({
+			code: "PSL_UNSUPPORTED_NAMED_TYPE_ATTRIBUTE",
+			message: `${input.entityLabel} uses unsupported attribute "@${input.attribute.name}"`,
+			sourceId: input.sourceId,
+			span: input.attribute.span
+		});
+		return;
+	}
+	if (input.baseType !== spec.baseType) return pushInvalidAttributeArgument({
+		diagnostics: input.diagnostics,
+		sourceId: input.sourceId,
+		span: input.attribute.span,
+		message: `${input.entityLabel} uses @${input.attribute.name} on unsupported base type "${input.baseType}". Expected "${spec.baseType}".`
+	});
+	switch (spec.args) {
+		case "noArgs":
+			if (getPositionalArguments(input.attribute).length > 0 || input.attribute.args.length > 0) return pushInvalidAttributeArgument({
+				diagnostics: input.diagnostics,
+				sourceId: input.sourceId,
+				span: input.attribute.span,
+				message: `${input.entityLabel} @${input.attribute.name} does not accept arguments.`
+			});
+			return {
+				codecId: spec.codecId ?? input.baseDescriptor.codecId,
+				nativeType: spec.nativeType
+			};
+		case "optionalLength": {
+			const length = parseOptionalSingleIntegerArgument({
+				attribute: input.attribute,
+				diagnostics: input.diagnostics,
+				sourceId: input.sourceId,
+				entityLabel: input.entityLabel,
+				minimum: 1,
+				valueLabel: "positive integer length"
+			});
+			if (length === void 0) return;
+			return {
+				codecId: spec.codecId,
+				nativeType: spec.nativeType,
+				...length === null ? {} : { typeParams: { length } }
+			};
+		}
+		case "optionalPrecision": {
+			const precision = parseOptionalSingleIntegerArgument({
+				attribute: input.attribute,
+				diagnostics: input.diagnostics,
+				sourceId: input.sourceId,
+				entityLabel: input.entityLabel,
+				minimum: 0,
+				valueLabel: "non-negative integer precision"
+			});
+			if (precision === void 0) return;
+			return {
+				codecId: spec.codecId,
+				nativeType: spec.nativeType,
+				...precision === null ? {} : { typeParams: { precision } }
+			};
+		}
+		case "optionalNumeric": {
+			const numeric = parseOptionalNumericArguments({
+				attribute: input.attribute,
+				diagnostics: input.diagnostics,
+				sourceId: input.sourceId,
+				entityLabel: input.entityLabel
+			});
+			if (numeric === void 0) return;
+			return {
+				codecId: spec.codecId,
+				nativeType: spec.nativeType,
+				...numeric === null ? {} : { typeParams: numeric }
+			};
+		}
+	}
+}
+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
+		});
+		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 = {
+				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"))
+		});
+	}
+	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;
+}
+function compareStrings(left, right) {
+	if (left < right) return -1;
+	if (left > right) return 1;
+	return 0;
+}
+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
+		});
+		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",
+			parentTable: candidate.tableName,
+			parentColumns: matched.referencedColumns,
+			childTable: matched.declaringTableName,
+			childColumns: matched.localColumns
+		});
+	}
+}
+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;
+		});
+	}
+	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
+	});
+}
+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;
+}
+function buildModelMappings(models, diagnostics, sourceId) {
+	const result = /* @__PURE__ */ new Map();
+	for (const model of models) {
+		const tableName = parseMapName({
+			attribute: getAttribute(model.attributes, "map"),
+			defaultValue: lowerFirst(model.name),
+			sourceId,
+			diagnostics,
+			entityLabel: `Model "${model.name}"`,
+			span: model.span
+		});
+		const fieldColumns = /* @__PURE__ */ new Map();
+		for (const field of model.fields) {
+			const columnName = parseMapName({
+				attribute: getAttribute(field.attributes, "map"),
+				defaultValue: field.name,
+				sourceId,
+				diagnostics,
+				entityLabel: `Field "${model.name}.${field.name}"`,
+				span: field.span
+			});
+			fieldColumns.set(field.name, columnName);
+		}
+		result.set(model.name, {
+			model,
+			tableName,
+			fieldColumns
+		});
+	}
+	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;
+}
+function parseRelationAttribute(input) {
+	if (input.attribute.args.filter((arg) => arg.kind === "positional").length > 1) {
+		input.diagnostics.push({
+			code: "PSL_INVALID_RELATION_ATTRIBUTE",
+			message: `Relation field "${input.modelName}.${input.fieldName}" has too many positional arguments`,
+			sourceId: input.sourceId,
+			span: input.attribute.span
+		});
+		return;
+	}
+	let relationNameFromPositional;
+	const positionalNameEntry = getPositionalArgumentEntry(input.attribute);
+	if (positionalNameEntry) {
+		const parsedName = parseQuotedStringLiteral(positionalNameEntry.value);
+		if (!parsedName) {
+			input.diagnostics.push({
+				code: "PSL_INVALID_RELATION_ATTRIBUTE",
+				message: `Relation field "${input.modelName}.${input.fieldName}" positional relation name must be a quoted string literal`,
+				sourceId: input.sourceId,
+				span: positionalNameEntry.span
+			});
+			return;
+		}
+		relationNameFromPositional = parsedName;
+	}
+	for (const arg of input.attribute.args) {
+		if (arg.kind === "positional") continue;
+		if (arg.name !== "name" && arg.name !== "fields" && arg.name !== "references" && arg.name !== "map" && arg.name !== "onDelete" && arg.name !== "onUpdate") {
+			input.diagnostics.push({
+				code: "PSL_INVALID_RELATION_ATTRIBUTE",
+				message: `Relation field "${input.modelName}.${input.fieldName}" has unsupported argument "${arg.name}"`,
+				sourceId: input.sourceId,
+				span: arg.span
+			});
+			return;
+		}
+	}
+	const namedRelationNameRaw = getNamedArgument(input.attribute, "name");
+	const namedRelationName = namedRelationNameRaw ? parseQuotedStringLiteral(namedRelationNameRaw) : void 0;
+	if (namedRelationNameRaw && !namedRelationName) {
+		input.diagnostics.push({
+			code: "PSL_INVALID_RELATION_ATTRIBUTE",
+			message: `Relation field "${input.modelName}.${input.fieldName}" named relation name must be a quoted string literal`,
+			sourceId: input.sourceId,
+			span: input.attribute.span
+		});
+		return;
+	}
+	if (relationNameFromPositional && namedRelationName && relationNameFromPositional !== namedRelationName) {
+		input.diagnostics.push({
+			code: "PSL_INVALID_RELATION_ATTRIBUTE",
+			message: `Relation field "${input.modelName}.${input.fieldName}" has conflicting positional and named relation names`,
+			sourceId: input.sourceId,
+			span: input.attribute.span
+		});
+		return;
+	}
+	const relationName = namedRelationName ?? relationNameFromPositional;
+	const constraintNameRaw = getNamedArgument(input.attribute, "map");
+	const constraintName = constraintNameRaw ? parseQuotedStringLiteral(constraintNameRaw) : void 0;
+	if (constraintNameRaw && !constraintName) {
+		input.diagnostics.push({
+			code: "PSL_INVALID_RELATION_ATTRIBUTE",
+			message: `Relation field "${input.modelName}.${input.fieldName}" map argument must be a quoted string literal`,
+			sourceId: input.sourceId,
+			span: input.attribute.span
+		});
+		return;
+	}
+	const fieldsRaw = getNamedArgument(input.attribute, "fields");
+	const referencesRaw = getNamedArgument(input.attribute, "references");
+	if (fieldsRaw && !referencesRaw || !fieldsRaw && referencesRaw) {
+		input.diagnostics.push({
+			code: "PSL_INVALID_RELATION_ATTRIBUTE",
+			message: `Relation field "${input.modelName}.${input.fieldName}" requires fields and references arguments`,
+			sourceId: input.sourceId,
+			span: input.attribute.span
+		});
+		return;
+	}
+	let fields;
+	let references;
+	if (fieldsRaw && referencesRaw) {
+		const parsedFields = parseFieldList(fieldsRaw);
+		const parsedReferences = parseFieldList(referencesRaw);
+		if (!parsedFields || !parsedReferences || parsedFields.length === 0 || parsedReferences.length === 0) {
+			input.diagnostics.push({
+				code: "PSL_INVALID_RELATION_ATTRIBUTE",
+				message: `Relation field "${input.modelName}.${input.fieldName}" requires bracketed fields and references lists`,
+				sourceId: input.sourceId,
+				span: input.attribute.span
+			});
+			return;
+		}
+		fields = parsedFields;
+		references = parsedReferences;
+	}
+	const onDeleteArgument = getNamedArgument(input.attribute, "onDelete");
+	const onUpdateArgument = getNamedArgument(input.attribute, "onUpdate");
+	return {
+		...ifDefined("relationName", relationName),
+		...ifDefined("fields", fields),
+		...ifDefined("references", references),
+		...ifDefined("constraintName", constraintName),
+		...ifDefined("onDelete", onDeleteArgument ? unquoteStringLiteral(onDeleteArgument) : void 0),
+		...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);
+	const enumTypeDescriptors = /* @__PURE__ */ new Map();
+	const namedTypeDescriptors = /* @__PURE__ */ new Map();
+	const namedTypeBaseTypes = /* @__PURE__ */ new Map();
+	for (const enumDeclaration of input.document.ast.enums) {
+		const nativeType = parseMapName({
+			attribute: getAttribute(enumDeclaration.attributes, "map"),
+			defaultValue: enumDeclaration.name,
+			sourceId,
+			diagnostics,
+			entityLabel: `Enum "${enumDeclaration.name}"`,
+			span: enumDeclaration.span
+		});
+		const descriptor = {
+			codecId: "pg/enum@1",
+			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) }
+		});
+	}
+	for (const declaration of input.document.ast.types?.declarations ?? []) {
+		const baseDescriptor = enumTypeDescriptors.get(declaration.baseType) ?? input.scalarTypeDescriptors.get(declaration.baseType);
+		if (!baseDescriptor) {
+			diagnostics.push({
+				code: "PSL_UNSUPPORTED_NAMED_TYPE_BASE",
+				message: `Named type "${declaration.name}" references unsupported base type "${declaration.baseType}"`,
+				sourceId,
+				span: declaration.span
+			});
+			continue;
+		}
+		namedTypeBaseTypes.set(declaration.name, declaration.baseType);
+		const pgvectorAttribute = getAttribute(declaration.attributes, "pgvector.column");
+		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({
+				code: "PSL_UNSUPPORTED_NAMED_TYPE_ATTRIBUTE",
+				message: `Named type "${declaration.name}" uses unsupported attribute "${unsupportedNamedTypeAttribute.name}"`,
+				sourceId,
+				span: unsupportedNamedTypeAttribute.span
+			});
+			continue;
+		}
+		if (pgvectorAttribute && dbNativeTypeAttribute) {
+			diagnostics.push({
+				code: "PSL_UNSUPPORTED_NAMED_TYPE_ATTRIBUTE",
+				message: `Named type "${declaration.name}" cannot combine @pgvector.column with @${dbNativeTypeAttribute.name}.`,
+				sourceId,
+				span: dbNativeTypeAttribute.span
+			});
+			continue;
+		}
+		if (pgvectorAttribute) {
+			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: pgvectorAttribute.span
+				});
+				continue;
+			}
+			if (declaration.baseType !== "Bytes") {
+				diagnostics.push({
+					code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+					message: `Named type "${declaration.name}" uses @pgvector.column on unsupported base type "${declaration.baseType}"`,
+					sourceId,
+					span: pgvectorAttribute.span
+				});
+				continue;
+			}
+			const length = parsePgvectorLength({
+				attribute: pgvectorAttribute,
+				diagnostics,
+				sourceId
+			});
+			if (length === void 0) continue;
+			namedTypeDescriptors.set(declaration.name, {
+				codecId: "pg/vector@1",
+				nativeType: "vector",
+				typeParams: { length }
+			});
+			builder = builder.storageType(declaration.name, {
+				codecId: "pg/vector@1",
+				nativeType: "vector",
+				typeParams: { length }
+			});
+			continue;
+		}
+		if (dbNativeTypeAttribute) {
+			const descriptor$1 = resolveDbNativeTypeAttribute({
+				attribute: dbNativeTypeAttribute,
+				baseType: declaration.baseType,
+				baseDescriptor,
+				diagnostics,
+				sourceId,
+				entityLabel: `Named type "${declaration.name}"`
+			});
+			if (!descriptor$1) continue;
+			namedTypeDescriptors.set(declaration.name, {
+				...descriptor$1,
+				typeRef: declaration.name
+			});
+			builder = builder.storageType(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
+		};
+		namedTypeDescriptors.set(declaration.name, descriptor);
+		builder = builder.storageType(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`,
+			sourceId,
+			span: model.span
+		});
+		for (const field of model.fields) {
+			if (!field.list || !modelNames.has(field.typeName)) continue;
+			const attributesValid = validateNavigationListFieldAttributes({
+				modelName: model.name,
+				field,
+				sourceId,
+				composedExtensions,
+				diagnostics
+			});
+			const relationAttribute = getAttribute(field.attributes, "relation");
+			let relationName;
+			if (relationAttribute) {
+				const parsedRelation = parseRelationAttribute({
+					attribute: relationAttribute,
+					modelName: model.name,
+					fieldName: field.name,
+					sourceId,
+					diagnostics
+				});
+				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;
+			}
+			if (!attributesValid) continue;
+			backrelationCandidates.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));
+		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 (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;
+				}
+				diagnostics.push({
+					code: "PSL_UNSUPPORTED_MODEL_ATTRIBUTE",
+					message: `Model "${model.name}" uses unsupported attribute "@@${modelAttribute.name}"`,
+					sourceId,
+					span: modelAttribute.span
+				});
+			}
+			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;
+				}
+				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 = 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;
+				table = table.foreignKey(localColumns, {
+					table: targetMapping.tableName,
+					columns: referencedColumns
+				}, {
+					...ifDefined("name", parsedRelation.constraintName),
+					...ifDefined("onDelete", onDelete),
+					...ifDefined("onUpdate", onUpdate)
+				});
+				fkRelationMetadata.push({
+					declaringModelName: model.name,
+					declaringFieldName: relationAttribute.field.name,
+					declaringTableName: tableName,
+					targetModelName: targetMapping.model.name,
+					targetTableName: targetMapping.tableName,
+					...ifDefined("relationName", parsedRelation.relationName),
+					localColumns,
+					referencedColumns
+				});
+			}
+			return table;
+		});
+	}
+	const { modelRelations, fkRelationsByPair } = indexFkRelations({ fkRelationMetadata });
+	applyBackrelationCandidates({
+		backrelationCandidates,
+		fkRelationsByPair,
+		modelRelations,
+		diagnostics,
+		sourceId
+	});
+	builder = emitModelsWithRelations({
+		builder,
+		resolvedModels,
+		modelRelations
+	});
+	if (diagnostics.length > 0) return notOk({
+		summary: "PSL to SQL Contract IR normalization 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());
+}
+
+//#endregion
+export { interpretPslDocumentToSqlContractIR as t };
+//# sourceMappingURL=interpreter-D7gLmaHz.mjs.map