@prisma-next/sql-contract-psl 0.3.0-dev.54 → 0.3.0-dev.63

package/dist/interpreter-IXr5c7s7.mjs

@@ -0,0 +1,1376 @@
+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 invalidArgumentDiagnostic(input) {
+	return {
+		ok: false,
+		diagnostic: {
+			code: "PSL_INVALID_DEFAULT_FUNCTION_ARGUMENT",
+			message: input.message,
+			sourceId: input.context.sourceId,
+			span: input.span
+		}
+	};
+}
+function executionGenerator(id, params) {
+	return {
+		ok: true,
+		value: {
+			kind: "execution",
+			generated: {
+				kind: "generator",
+				id,
+				...params ? { params } : {}
+			}
+		}
+	};
+}
+function expectNoArgs(input) {
+	if (input.call.args.length === 0) return;
+	return invalidArgumentDiagnostic({
+		context: input.context,
+		span: input.call.span,
+		message: `Default function "${input.call.name}" does not accept arguments. Use ${input.usage}.`
+	});
+}
+function parseIntegerArgument(raw) {
+	const trimmed = raw.trim();
+	if (!/^-?\d+$/.test(trimmed)) return;
+	const value = Number(trimmed);
+	if (!Number.isInteger(value)) return;
+	return value;
+}
+function parseStringLiteral(raw) {
+	const match = raw.trim().match(/^(['"])(.*)\1$/s);
+	if (!match) return;
+	return match[2] ?? "";
+}
+function lowerAutoincrement(input) {
+	const maybeNoArgs = expectNoArgs({
+		call: input.call,
+		context: input.context,
+		usage: "`autoincrement()`"
+	});
+	if (maybeNoArgs) return maybeNoArgs;
+	return {
+		ok: true,
+		value: {
+			kind: "storage",
+			defaultValue: {
+				kind: "function",
+				expression: "autoincrement()"
+			}
+		}
+	};
+}
+function lowerNow(input) {
+	const maybeNoArgs = expectNoArgs({
+		call: input.call,
+		context: input.context,
+		usage: "`now()`"
+	});
+	if (maybeNoArgs) return maybeNoArgs;
+	return {
+		ok: true,
+		value: {
+			kind: "storage",
+			defaultValue: {
+				kind: "function",
+				expression: "now()"
+			}
+		}
+	};
+}
+function lowerUuid(input) {
+	if (input.call.args.length === 0) return executionGenerator("uuidv4");
+	if (input.call.args.length !== 1) return invalidArgumentDiagnostic({
+		context: input.context,
+		span: input.call.span,
+		message: "Default function \"uuid\" accepts at most one version argument: `uuid()`, `uuid(4)`, or `uuid(7)`."
+	});
+	const version = parseIntegerArgument(input.call.args[0]?.raw ?? "");
+	if (version === 4) return executionGenerator("uuidv4");
+	if (version === 7) return executionGenerator("uuidv7");
+	return invalidArgumentDiagnostic({
+		context: input.context,
+		span: input.call.args[0]?.span ?? input.call.span,
+		message: "Default function \"uuid\" supports only `uuid()`, `uuid(4)`, or `uuid(7)` in SQL PSL provider v1."
+	});
+}
+function lowerCuid(input) {
+	if (input.call.args.length === 0) return {
+		ok: false,
+		diagnostic: {
+			code: "PSL_UNKNOWN_DEFAULT_FUNCTION",
+			message: "Default function \"cuid()\" is not supported in SQL PSL provider v1. Use `cuid(2)` instead.",
+			sourceId: input.context.sourceId,
+			span: input.call.span
+		}
+	};
+	if (input.call.args.length !== 1) return invalidArgumentDiagnostic({
+		context: input.context,
+		span: input.call.span,
+		message: "Default function \"cuid\" accepts exactly one version argument: `cuid(2)`."
+	});
+	if (parseIntegerArgument(input.call.args[0]?.raw ?? "") === 2) return executionGenerator("cuid2");
+	return invalidArgumentDiagnostic({
+		context: input.context,
+		span: input.call.args[0]?.span ?? input.call.span,
+		message: "Default function \"cuid\" supports only `cuid(2)` in SQL PSL provider v1."
+	});
+}
+function lowerUlid(input) {
+	const maybeNoArgs = expectNoArgs({
+		call: input.call,
+		context: input.context,
+		usage: "`ulid()`"
+	});
+	if (maybeNoArgs) return maybeNoArgs;
+	return executionGenerator("ulid");
+}
+function lowerNanoid(input) {
+	if (input.call.args.length === 0) return executionGenerator("nanoid");
+	if (input.call.args.length !== 1) return invalidArgumentDiagnostic({
+		context: input.context,
+		span: input.call.span,
+		message: "Default function \"nanoid\" accepts at most one size argument: `nanoid()` or `nanoid(<2-255>)`."
+	});
+	const size = parseIntegerArgument(input.call.args[0]?.raw ?? "");
+	if (size !== void 0 && size >= 2 && size <= 255) return executionGenerator("nanoid", { size });
+	return invalidArgumentDiagnostic({
+		context: input.context,
+		span: input.call.args[0]?.span ?? input.call.span,
+		message: "Default function \"nanoid\" size argument must be an integer between 2 and 255."
+	});
+}
+function lowerDbgenerated(input) {
+	if (input.call.args.length !== 1) return invalidArgumentDiagnostic({
+		context: input.context,
+		span: input.call.span,
+		message: "Default function \"dbgenerated\" requires exactly one string argument: `dbgenerated(\"...\")`."
+	});
+	const rawExpression = parseStringLiteral(input.call.args[0]?.raw ?? "");
+	if (rawExpression === void 0) return invalidArgumentDiagnostic({
+		context: input.context,
+		span: input.call.args[0]?.span ?? input.call.span,
+		message: "Default function \"dbgenerated\" argument must be a string literal."
+	});
+	if (rawExpression.trim().length === 0) return invalidArgumentDiagnostic({
+		context: input.context,
+		span: input.call.args[0]?.span ?? input.call.span,
+		message: "Default function \"dbgenerated\" argument cannot be empty."
+	});
+	return {
+		ok: true,
+		value: {
+			kind: "storage",
+			defaultValue: {
+				kind: "function",
+				expression: rawExpression
+			}
+		}
+	};
+}
+const supportedFunctionUsageByName = {
+	autoincrement: ["autoincrement()"],
+	now: ["now()"],
+	uuid: [
+		"uuid()",
+		"uuid(4)",
+		"uuid(7)"
+	],
+	cuid: ["cuid(2)"],
+	ulid: ["ulid()"],
+	nanoid: ["nanoid()", "nanoid(n)"],
+	dbgenerated: ["dbgenerated(\"...\")"]
+};
+const unknownFunctionSuggestionsByName = {
+	cuid2: "Use `cuid(2)`.",
+	uuidv4: "Use `uuid()` or `uuid(4)`.",
+	uuidv7: "Use `uuid(7)`."
+};
+function formatSupportedFunctionList(registry) {
+	const signatures = Array.from(registry.keys()).sort().flatMap((functionName) => supportedFunctionUsageByName[functionName] ?? [`${functionName}()`]);
+	return signatures.length > 0 ? signatures.join(", ") : "none";
+}
+function createBuiltinDefaultFunctionRegistry() {
+	return new Map([
+		["autoincrement", lowerAutoincrement],
+		["now", lowerNow],
+		["uuid", lowerUuid],
+		["cuid", lowerCuid],
+		["ulid", lowerUlid],
+		["nanoid", lowerNanoid],
+		["dbgenerated", lowerDbgenerated]
+	]);
+}
+function lowerDefaultFunctionWithRegistry(input) {
+	const handler = input.registry.get(input.call.name);
+	if (handler) return handler({
+		call: input.call,
+		context: input.context
+	});
+	const supportedFunctionList = formatSupportedFunctionList(input.registry);
+	const suggestion = unknownFunctionSuggestionsByName[input.call.name];
+	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}.${suggestion ? ` ${suggestion}` : ""}`,
+			sourceId: input.context.sourceId,
+			span: input.call.span
+		}
+	};
+}
+
+//#endregion
+//#region src/interpreter.ts
+const DEFAULT_POSTGRES_TARGET = {
+	kind: "target",
+	familyId: "sql",
+	targetId: "postgres",
+	id: "postgres",
+	version: "0.0.1",
+	capabilities: {}
+};
+const SCALAR_COLUMN_MAP = {
+	String: {
+		codecId: "pg/text@1",
+		nativeType: "text"
+	},
+	Boolean: {
+		codecId: "pg/bool@1",
+		nativeType: "bool"
+	},
+	Int: {
+		codecId: "pg/int4@1",
+		nativeType: "int4"
+	},
+	BigInt: {
+		codecId: "pg/int8@1",
+		nativeType: "int8"
+	},
+	Float: {
+		codecId: "pg/float8@1",
+		nativeType: "float8"
+	},
+	Decimal: {
+		codecId: "pg/numeric@1",
+		nativeType: "numeric"
+	},
+	DateTime: {
+		codecId: "pg/timestamptz@1",
+		nativeType: "timestamptz"
+	},
+	Json: {
+		codecId: "pg/jsonb@1",
+		nativeType: "jsonb"
+	},
+	Bytes: {
+		codecId: "pg/bytea@1",
+		nativeType: "bytea"
+	}
+};
+const GENERATED_ID_COLUMN_MAP = {
+	ulid: {
+		codecId: "sql/char@1",
+		nativeType: "character",
+		typeParams: { length: 26 }
+	},
+	uuidv7: {
+		codecId: "sql/char@1",
+		nativeType: "character",
+		typeParams: { length: 36 }
+	},
+	uuidv4: {
+		codecId: "sql/char@1",
+		nativeType: "character",
+		typeParams: { length: 36 }
+	},
+	cuid2: {
+		codecId: "sql/char@1",
+		nativeType: "character",
+		typeParams: { length: 24 }
+	}
+};
+function resolveGeneratedColumnDescriptor(executionDefault) {
+	if (executionDefault.kind !== "generator") return;
+	if (executionDefault.id === "nanoid") {
+		const rawSize = executionDefault.params?.["size"];
+		return {
+			codecId: "sql/char@1",
+			nativeType: "character",
+			typeParams: { length: typeof rawSize === "number" && Number.isInteger(rawSize) && rawSize >= 2 && rawSize <= 255 ? rawSize : 21 }
+		};
+	}
+	return GENERATED_ID_COLUMN_MAP[executionDefault.id];
+}
+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
+		}
+	});
+	if (!lowered.ok) {
+		input.diagnostics.push(lowered.diagnostic);
+		return {};
+	}
+	if (lowered.value.kind === "storage") return { defaultValue: lowered.value.defaultValue };
+	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 resolveColumnDescriptor(field, enumTypeDescriptors, namedTypeDescriptors) {
+	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 SCALAR_COLUMN_MAP[field.typeName];
+}
+function collectResolvedFields(model, mapping, enumTypeDescriptors, namedTypeDescriptors, namedTypeBaseTypes, modelNames, composedExtensions, defaultFunctionRegistry, diagnostics, sourceId) {
+	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);
+		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(${length})`,
+				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,
+			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 = resolveGeneratedColumnDescriptor(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 !== "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 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("onDelete", onDeleteArgument ? unquoteStringLiteral(onDeleteArgument) : void 0),
+		...ifDefined("onUpdate", onUpdateArgument ? unquoteStringLiteral(onUpdateArgument) : void 0)
+	};
+}
+function interpretPslDocumentToSqlContractIR(input) {
+	const diagnostics = mapParserDiagnostics(input.document);
+	const modelNames = new Set(input.document.ast.models.map((model) => model.name));
+	const sourceId = input.document.ast.sourceId;
+	const composedExtensions = new Set(input.composedExtensionPacks ?? []);
+	const defaultFunctionRegistry = input.defaultFunctionRegistry ?? createBuiltinDefaultFunctionRegistry();
+	let builder = defineContract().target(input.target ?? DEFAULT_POSTGRES_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 = enumDeclaration.name.toLowerCase();
+		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) ?? SCALAR_COLUMN_MAP[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 unsupportedNamedTypeAttribute = declaration.attributes.find((attribute) => attribute.name !== "pgvector.column");
+		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) {
+			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(${length})`,
+				typeRef: declaration.name
+			});
+			builder = builder.storageType(declaration.name, {
+				codecId: "pg/vector@1",
+				nativeType: `vector(${length})`,
+				typeParams: { length }
+			});
+			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, diagnostics, sourceId);
+		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("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 { createBuiltinDefaultFunctionRegistry as n, interpretPslDocumentToSqlContractIR as t };
+//# sourceMappingURL=interpreter-IXr5c7s7.mjs.map