@prisma/orm-family-sql 0.16.0-dev.36

package/dist/interpreter-5WgpL-ax-_nqHLUTr.mjs

@@ -0,0 +1,3526 @@
+import { t as deriveValueSetFromEntity } from "./value-set-derivation-hook-Di9JZ0X7.mjs";
+import { t as buildSqlContractFromDefinition } from "./build-contract-DBCz_YSs-DO0wMHai.mjs";
+import { UNBOUND_NAMESPACE_ID } from "@prisma/orm-framework/components/ir";
+import { structuredError } from "@prisma/orm-framework/utils/structured-error";
+import { InternalError } from "@prisma/orm-framework/utils/internal-error";
+import { crossRef } from "@prisma/orm-framework/contract/types";
+import { hasRegisteredFieldNamespace, instantiateAuthoringEntityType, instantiateAuthoringFieldPreset, instantiateAuthoringTypeConstructor, isAuthoringEntityTypeDescriptor, isAuthoringFieldPresetDescriptor, isAuthoringModelAttributeDescriptor, isAuthoringPslBlockDescriptor, isAuthoringTypeConstructorDescriptor, validateAuthoringHelperArguments } from "@prisma/orm-framework/components/authoring";
+import { blindCast } from "@prisma/orm-framework/utils/casts";
+import { ifDefined } from "@prisma/orm-framework/utils/defined";
+import { bool, entityRef, fieldAttribute, fieldRef, findBlockDescriptor, funcCall, identifier, interpretAttribute, keywordPslSpan, leafDiagnostic, list, modelAttribute, nodePslSpan, num, oneOf, optional, record, str } from "@prisma/orm-framework/psl-parser";
+import { assertDefined, invariant } from "@prisma/orm-framework/utils/assertions";
+import { notOk, ok } from "@prisma/orm-framework/utils/result";
+//#region ../../../2-sql/2-authoring/contract-psl/dist/interpreter-5WgpL-ax.mjs
+function contractError(code, message, options) {
+	return structuredError(code, message, options);
+}
+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 formatDbAttributeMigrationMessage(attribute) {
+	const renderedArguments = attribute.args.map((argument) => argument.kind === "named" && argument.name !== void 0 ? `${argument.name}: ${argument.value}` : argument.value).join(", ");
+	const argumentList = attribute.args.length === 0 ? "" : `(${renderedArguments})`;
+	const constructorName = attribute.name.slice(3);
+	return `@${attribute.name}${argumentList} is no longer supported; use ${constructorName}${argumentList} in type position`;
+}
+function getNamedArgument(attribute, name) {
+	const entry = attribute.args.find((arg) => arg.kind === "named" && arg.name === name);
+	if (entry?.kind !== "named") return;
+	return entry.value;
+}
+function unquoteStringLiteral(value) {
+	const trimmed = value.trim();
+	const match = trimmed.match(/^(['"])(.*)\1$/);
+	if (!match) return trimmed;
+	return match[2] ?? "";
+}
+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.entityLabel} references unknown field "${input.modelName}.${fieldName}"`,
+				sourceId: input.sourceId,
+				span: input.span
+			});
+			return;
+		}
+		columns.push(columnName);
+	}
+	return columns;
+}
+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.fn);
+	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.fn}" is not supported in SQL PSL provider v1. Supported functions: ${supportedFunctionList}.`,
+			sourceId: input.context.sourceId,
+			span: input.call.span
+		}
+	};
+}
+const INVALID_AUTHORING_ARGUMENT = Symbol("invalidAuthoringArgument");
+function isIdentifierStartCharacter(character) {
+	return character !== void 0 && /[A-Za-z_$]/.test(character);
+}
+function isIdentifierCharacter(character) {
+	return character !== void 0 && /[A-Za-z0-9_$]/.test(character);
+}
+function parseJsLikeLiteral(value) {
+	let index = 0;
+	function skipWhitespace() {
+		while (/\s/.test(value[index] ?? "")) index += 1;
+	}
+	function parseIdentifier() {
+		const first = value[index];
+		if (!isIdentifierStartCharacter(first)) return INVALID_AUTHORING_ARGUMENT;
+		let end = index + 1;
+		while (isIdentifierCharacter(value[end])) end += 1;
+		const identifier = value.slice(index, end);
+		index = end;
+		return identifier;
+	}
+	function parseString() {
+		const quote = value[index];
+		if (quote !== "\"" && quote !== "'") return INVALID_AUTHORING_ARGUMENT;
+		index += 1;
+		let result = "";
+		while (index < value.length) {
+			const character = value[index];
+			index += 1;
+			if (character === void 0) return INVALID_AUTHORING_ARGUMENT;
+			if (character === quote) return result;
+			if (character !== "\\") {
+				result += character;
+				continue;
+			}
+			const escaped = value[index];
+			index += 1;
+			if (escaped === void 0) return INVALID_AUTHORING_ARGUMENT;
+			switch (escaped) {
+				case "'":
+				case "\"":
+				case "\\":
+				case "/":
+					result += escaped;
+					break;
+				case "b":
+					result += "\b";
+					break;
+				case "f":
+					result += "\f";
+					break;
+				case "n":
+					result += "\n";
+					break;
+				case "r":
+					result += "\r";
+					break;
+				case "t":
+					result += "	";
+					break;
+				case "u": {
+					const hex = value.slice(index, index + 4);
+					if (!/^[0-9A-Fa-f]{4}$/.test(hex)) return INVALID_AUTHORING_ARGUMENT;
+					result += String.fromCharCode(Number.parseInt(hex, 16));
+					index += 4;
+					break;
+				}
+				default: return INVALID_AUTHORING_ARGUMENT;
+			}
+		}
+		return INVALID_AUTHORING_ARGUMENT;
+	}
+	function parseNumber() {
+		const raw = value.slice(index).match(/^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/)?.[0];
+		if (!raw) return INVALID_AUTHORING_ARGUMENT;
+		const parsed = Number(raw);
+		if (!Number.isFinite(parsed)) return INVALID_AUTHORING_ARGUMENT;
+		index += raw.length;
+		return parsed;
+	}
+	function parseArray() {
+		if (value[index] !== "[") return INVALID_AUTHORING_ARGUMENT;
+		index += 1;
+		const result = [];
+		skipWhitespace();
+		if (value[index] === "]") {
+			index += 1;
+			return result;
+		}
+		while (index < value.length) {
+			const entry = parseValue();
+			if (entry === INVALID_AUTHORING_ARGUMENT) return INVALID_AUTHORING_ARGUMENT;
+			result.push(entry);
+			skipWhitespace();
+			if (value[index] === ",") {
+				index += 1;
+				skipWhitespace();
+				continue;
+			}
+			if (value[index] === "]") {
+				index += 1;
+				return result;
+			}
+			return INVALID_AUTHORING_ARGUMENT;
+		}
+		return INVALID_AUTHORING_ARGUMENT;
+	}
+	function parseObject() {
+		if (value[index] !== "{") return INVALID_AUTHORING_ARGUMENT;
+		index += 1;
+		const result = {};
+		skipWhitespace();
+		if (value[index] === "}") {
+			index += 1;
+			return result;
+		}
+		while (index < value.length) {
+			skipWhitespace();
+			const key = value[index] === "\"" || value[index] === "'" ? parseString() : parseIdentifier();
+			if (key === INVALID_AUTHORING_ARGUMENT) return INVALID_AUTHORING_ARGUMENT;
+			skipWhitespace();
+			if (value[index] !== ":") return INVALID_AUTHORING_ARGUMENT;
+			index += 1;
+			const entry = parseValue();
+			if (entry === INVALID_AUTHORING_ARGUMENT) return INVALID_AUTHORING_ARGUMENT;
+			result[key] = entry;
+			skipWhitespace();
+			if (value[index] === ",") {
+				index += 1;
+				skipWhitespace();
+				continue;
+			}
+			if (value[index] === "}") {
+				index += 1;
+				return result;
+			}
+			return INVALID_AUTHORING_ARGUMENT;
+		}
+		return INVALID_AUTHORING_ARGUMENT;
+	}
+	function parseValue() {
+		skipWhitespace();
+		const character = value[index];
+		if (character === "{") return parseObject();
+		if (character === "[") return parseArray();
+		if (character === "\"" || character === "'") return parseString();
+		if (character === "-" || /\d/.test(character ?? "")) return parseNumber();
+		const identifier = parseIdentifier();
+		if (identifier === INVALID_AUTHORING_ARGUMENT) return INVALID_AUTHORING_ARGUMENT;
+		if (identifier === "true") return true;
+		if (identifier === "false") return false;
+		if (identifier === "null") return null;
+		return INVALID_AUTHORING_ARGUMENT;
+	}
+	skipWhitespace();
+	const parsed = parseValue();
+	if (parsed === INVALID_AUTHORING_ARGUMENT) return parsed;
+	skipWhitespace();
+	return index === value.length ? parsed : INVALID_AUTHORING_ARGUMENT;
+}
+function parseStringArrayLiteral(value) {
+	const parsed = parseJsLikeLiteral(value);
+	if (parsed === INVALID_AUTHORING_ARGUMENT || !Array.isArray(parsed)) return INVALID_AUTHORING_ARGUMENT;
+	if (!parsed.every((item) => typeof item === "string")) return INVALID_AUTHORING_ARGUMENT;
+	return parsed;
+}
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parsePslObjectLiteral(value) {
+	const trimmed = value.trim();
+	if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) return INVALID_AUTHORING_ARGUMENT;
+	let parsed;
+	try {
+		parsed = JSON.parse(trimmed);
+	} catch {
+		parsed = parseJsLikeLiteral(trimmed);
+		if (parsed === INVALID_AUTHORING_ARGUMENT) return INVALID_AUTHORING_ARGUMENT;
+	}
+	if (!isPlainObject(parsed)) return INVALID_AUTHORING_ARGUMENT;
+	return parsed;
+}
+function parsePslAuthoringArgumentValue(descriptor, rawValue) {
+	switch (descriptor.kind) {
+		case "string": return unquoteStringLiteral(rawValue);
+		case "boolean": {
+			const trimmed = rawValue.trim();
+			if (trimmed === "true") return true;
+			if (trimmed === "false") return false;
+			return INVALID_AUTHORING_ARGUMENT;
+		}
+		case "number": {
+			const parsed = Number(unquoteStringLiteral(rawValue));
+			return Number.isNaN(parsed) ? INVALID_AUTHORING_ARGUMENT : parsed;
+		}
+		case "stringArray": return parseStringArrayLiteral(rawValue);
+		case "object": return parsePslObjectLiteral(rawValue);
+		case "option": {
+			const trimmed = rawValue.trim();
+			return /^[A-Za-z_][A-Za-z0-9_]*$/.test(trimmed) ? trimmed : INVALID_AUTHORING_ARGUMENT;
+		}
+		default: return INVALID_AUTHORING_ARGUMENT;
+	}
+}
+function pushInvalidPslHelperArgument(input) {
+	input.diagnostics.push({
+		code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+		message: `${input.entityLabel} ${input.helperLabel} ${input.message}`,
+		sourceId: input.sourceId,
+		span: input.span
+	});
+}
+function mapPslHelperArgs(input) {
+	const mappedArgs = input.descriptors.map(() => void 0);
+	const positionalArgs = input.args.filter((arg) => arg.kind === "positional");
+	const namedArgs = input.args.filter((arg) => arg.kind === "named");
+	if (positionalArgs.length > input.descriptors.length) return pushInvalidPslHelperArgument({
+		diagnostics: input.diagnostics,
+		sourceId: input.sourceId,
+		span: input.span,
+		entityLabel: input.entityLabel,
+		helperLabel: input.helperLabel,
+		message: `accepts at most ${input.descriptors.length} argument(s), received ${positionalArgs.length}.`
+	});
+	for (const [index, argument] of positionalArgs.entries()) {
+		const descriptor = input.descriptors[index];
+		if (!descriptor) return pushInvalidPslHelperArgument({
+			diagnostics: input.diagnostics,
+			sourceId: input.sourceId,
+			span: argument.span,
+			entityLabel: input.entityLabel,
+			helperLabel: input.helperLabel,
+			message: `does not define positional argument #${index + 1}.`
+		});
+		const value = parsePslAuthoringArgumentValue(descriptor, argument.value);
+		if (value === INVALID_AUTHORING_ARGUMENT) return pushInvalidPslHelperArgument({
+			diagnostics: input.diagnostics,
+			sourceId: input.sourceId,
+			span: argument.span,
+			entityLabel: input.entityLabel,
+			helperLabel: input.helperLabel,
+			message: `cannot parse argument #${index + 1} for descriptor kind "${descriptor.kind}".`
+		});
+		mappedArgs[index] = value;
+	}
+	for (const argument of namedArgs) {
+		const descriptorIndex = input.descriptors.findIndex((descriptor) => descriptor.name === argument.name);
+		if (descriptorIndex < 0) return pushInvalidPslHelperArgument({
+			diagnostics: input.diagnostics,
+			sourceId: input.sourceId,
+			span: argument.span,
+			entityLabel: input.entityLabel,
+			helperLabel: input.helperLabel,
+			message: `received unknown named argument "${argument.name}".`
+		});
+		if (mappedArgs[descriptorIndex] !== void 0) return pushInvalidPslHelperArgument({
+			diagnostics: input.diagnostics,
+			sourceId: input.sourceId,
+			span: argument.span,
+			entityLabel: input.entityLabel,
+			helperLabel: input.helperLabel,
+			message: `received duplicate value for argument "${argument.name}".`
+		});
+		const descriptor = input.descriptors[descriptorIndex];
+		if (!descriptor) return pushInvalidPslHelperArgument({
+			diagnostics: input.diagnostics,
+			sourceId: input.sourceId,
+			span: argument.span,
+			entityLabel: input.entityLabel,
+			helperLabel: input.helperLabel,
+			message: `does not define named argument "${argument.name}".`
+		});
+		const value = parsePslAuthoringArgumentValue(descriptor, argument.value);
+		if (value === INVALID_AUTHORING_ARGUMENT) return pushInvalidPslHelperArgument({
+			diagnostics: input.diagnostics,
+			sourceId: input.sourceId,
+			span: argument.span,
+			entityLabel: input.entityLabel,
+			helperLabel: input.helperLabel,
+			message: `cannot parse named argument "${argument.name}" for descriptor kind "${descriptor.kind}".`
+		});
+		mappedArgs[descriptorIndex] = value;
+	}
+	return mappedArgs;
+}
+function findModelAttributeNode(model, name) {
+	for (const attribute of model.node.attributes()) if (attribute.name()?.isSimpleName(name) === true) return attribute;
+}
+function findFieldAttributeNode(field, name) {
+	for (const attribute of field.node.attributes()) if (attribute.name()?.isSimpleName(name) === true) return attribute;
+}
+function buildModelInterpretCtx(input) {
+	return {
+		level: "model",
+		sourceId: input.sourceId,
+		sourceFile: input.sourceFile,
+		selfModel: input.selfModel,
+		resolveReferencedModel: () => void 0
+	};
+}
+function buildFieldInterpretCtx(input) {
+	return {
+		level: "field",
+		sourceId: input.sourceId,
+		sourceFile: input.sourceFile,
+		selfModel: input.selfModel,
+		resolveReferencedModel: input.resolveReferencedModel ?? (() => void 0),
+		field: input.field
+	};
+}
+function interpretModelAttribute(input) {
+	const result = interpretAttribute(input.node, input.spec, buildModelInterpretCtx({
+		selfModel: input.model,
+		sourceFile: input.sourceFile,
+		sourceId: input.sourceId
+	}));
+	if (!result.ok) {
+		for (const failure of result.failure) input.diagnostics.push(failure);
+		return;
+	}
+	return result.value;
+}
+function interpretFieldAttribute(input) {
+	const result = interpretAttribute(input.node, input.spec, buildFieldInterpretCtx({
+		selfModel: input.model,
+		field: input.field,
+		sourceFile: input.sourceFile,
+		sourceId: input.sourceId,
+		resolveReferencedModel: input.resolveReferencedModel
+	}));
+	if (!result.ok) {
+		for (const failure of result.failure) input.diagnostics.push(failure);
+		return;
+	}
+	return result.value;
+}
+const mapModelSpec = modelAttribute("map", { positional: [{
+	key: "name",
+	type: str()
+}] });
+const mapFieldSpec = fieldAttribute("map", { positional: [{
+	key: "name",
+	type: str()
+}] });
+function buildDefaultSpec(input) {
+	const literal = () => oneOf(str(), num(), bool());
+	const funcArms = [...input.registry.entries()].map(([name, entry]) => funcCall(name, blindCast(entry.signature)));
+	return fieldAttribute("default", { positional: [{
+		key: "value",
+		type: oneOf(...input.isList ? [list(literal()), ...funcArms] : [
+			str(),
+			num(),
+			bool(),
+			...funcArms
+		])
+	}] });
+}
+function buildEnumDefaultSpec(memberNames) {
+	const [first, ...rest] = memberNames;
+	return fieldAttribute("default", { positional: [{
+		key: "member",
+		type: oneOf(...[identifier(first), ...rest.map((name) => identifier(name))])
+	}] });
+}
+const idFieldSpec = fieldAttribute("id", { named: { map: optional(str()) } });
+const uniqueFieldSpec = fieldAttribute("unique", { named: { map: optional(str()) } });
+const idModelSpec = modelAttribute("id", {
+	positional: [{
+		key: "fields",
+		type: list(fieldRef("self"), {
+			nonEmpty: true,
+			unique: true
+		})
+	}],
+	named: { map: optional(str()) }
+});
+const uniqueModelSpec = modelAttribute("unique", {
+	positional: [{
+		key: "fields",
+		type: list(fieldRef("self"), {
+			nonEmpty: true,
+			unique: true
+		})
+	}],
+	named: { map: optional(str()) }
+});
+const PSL_INDEX_FIELDS_XOR_EXPRESSION = "PSL_INDEX_FIELDS_XOR_EXPRESSION";
+const PSL_INDEX_EXPRESSION_REQUIRES_NAME = "PSL_INDEX_EXPRESSION_REQUIRES_NAME";
+const PSL_INDEX_NAME_XOR_MAP = "PSL_INDEX_NAME_XOR_MAP";
+const indexModelSpec = modelAttribute("index", {
+	positional: [{
+		key: "fields",
+		type: optional(list(fieldRef("self"), {
+			nonEmpty: true,
+			unique: true
+		}))
+	}],
+	named: {
+		expression: optional(str()),
+		where: optional(str()),
+		unique: optional(bool()),
+		name: optional(str()),
+		map: optional(str()),
+		type: optional(str()),
+		options: optional(record(str()))
+	},
+	refine: (value, ctx, attributeNode) => {
+		const diagnostics = [];
+		if (value.fields === void 0 === (value.expression === void 0)) diagnostics.push(leafDiagnostic(ctx, attributeNode, "`@@index` requires exactly one of a fields list or an `expression` argument", PSL_INDEX_FIELDS_XOR_EXPRESSION));
+		if (value.expression !== void 0 && value.name === void 0 && value.map === void 0) diagnostics.push(leafDiagnostic(ctx, attributeNode, "`@@index` with an `expression` argument requires a `name` or `map` argument (a default name cannot be derived from an expression)", PSL_INDEX_EXPRESSION_REQUIRES_NAME));
+		if (value.name !== void 0 && value.map !== void 0) diagnostics.push(leafDiagnostic(ctx, attributeNode, "`@@index` takes at most one of `name` and `map`", PSL_INDEX_NAME_XOR_MAP));
+		if (value.options !== void 0 && value.type === void 0) diagnostics.push(leafDiagnostic(ctx, attributeNode, "`@@index` options argument requires a type argument"));
+		return diagnostics;
+	}
+});
+const controlModelSpec = modelAttribute("control", { positional: [{
+	key: "policy",
+	type: oneOf(identifier("managed"), identifier("tolerated"), identifier("external"), identifier("observed"))
+}] });
+const discriminatorModelSpec = modelAttribute("discriminator", { positional: [{
+	key: "field",
+	type: fieldRef("self")
+}] });
+const baseModelSpec = modelAttribute("base", { positional: [{
+	key: "base",
+	type: entityRef()
+}, {
+	key: "value",
+	type: str()
+}] });
+function toNamedTypeFieldDescriptor(typeRef, descriptor) {
+	return {
+		codecId: descriptor.codecId,
+		nativeType: descriptor.nativeType,
+		typeRef
+	};
+}
+function getAuthoringTypeConstructor(contributions, path) {
+	let current = contributions?.type;
+	for (const segment of path) {
+		if (typeof current !== "object" || current === null || "kind" in current) return;
+		current = current[segment];
+	}
+	return current !== void 0 && isAuthoringTypeConstructorDescriptor(current) ? current : void 0;
+}
+/**
+* Walks `authoringContributions.entityTypes` segment-by-segment and returns
+* the entity type descriptor at the resolved path, or `undefined` if no
+* descriptor is registered.
+*
+* Used by the PSL interpreter to dispatch declarative entity-shaped
+* declarations (`enum`, future `namespace { … }`, …) through the
+* pack entity-type mechanism — the descriptor's `factory` (or
+* `template`) materialises the IR-class instance without the
+* interpreter knowing target-specific construction.
+*/
+function getAuthoringEntity(contributions, path) {
+	let current = contributions?.entityTypes;
+	for (const segment of path) {
+		if (typeof current !== "object" || current === null || "kind" in current) return;
+		current = current[segment];
+	}
+	return current !== void 0 && isAuthoringEntityTypeDescriptor(current) ? current : void 0;
+}
+/**
+* Walks `authoringContributions.field` segment-by-segment and returns the field-preset descriptor at the resolved path, or `undefined` if no descriptor is registered.
+*
+* Symmetric with `getAuthoringTypeConstructor`. Field presets are strictly richer than type constructors — they can contribute `default` / `executionDefaults` / `id` / `unique` / `nullable` in addition to the `codecId` / `nativeType` / `typeParams` triple. PSL resolution tries field presets first, then falls back to type constructors on miss (see `resolveFieldTypeDescriptor`).
+*/
+function getAuthoringFieldPreset(contributions, path) {
+	let current = contributions?.field;
+	for (const segment of path) {
+		if (typeof current !== "object" || current === null || "kind" in current) return;
+		current = current[segment];
+	}
+	return current !== void 0 && isAuthoringFieldPresetDescriptor(current) ? current : void 0;
+}
+/**
+* Returns the namespace prefix of `attributeName` if it references an unrecognized extension namespace, otherwise `undefined`. A namespace is considered recognized when it is:
+*
+* - `db` (native-type spec, always allowed),
+* - the active family id (e.g. `sql`),
+* - the active target id (e.g. `postgres`),
+* - a registered field-preset namespace (e.g. `temporal`),
+* - present in `composedExtensions`.
+*
+* Family/target/field-preset namespaces are exempted so that e.g. `@sql.foo` surfaces as PSL_UNSUPPORTED_*_ATTRIBUTE (the attribute isn't defined) rather than PSL_EXTENSION_NAMESPACE_NOT_COMPOSED (the namespace is already composed).
+*/
+function checkUncomposedNamespace(attributeName, composedExtensions, context) {
+	const dotIndex = attributeName.indexOf(".");
+	if (dotIndex <= 0 || dotIndex === attributeName.length - 1) return;
+	const namespace = attributeName.slice(0, dotIndex);
+	if (namespace === "db" || namespace === context?.familyId || namespace === context?.targetId || hasRegisteredFieldNamespace(context?.authoringContributions, namespace) || composedExtensions.has(namespace)) return;
+	return namespace;
+}
+/**
+* Pushes the canonical `PSL_EXTENSION_NAMESPACE_NOT_COMPOSED` diagnostic for a subject (attribute, model attribute, or type constructor) that references an extension namespace which is not composed in the current contract.
+*
+* The `data` payload carries the missing namespace so machine consumers (agents, IDE extensions, CLI auto-fix) don't have to parse the prose.
+*/
+function reportUncomposedNamespace(input) {
+	input.diagnostics.push({
+		code: "PSL_EXTENSION_NAMESPACE_NOT_COMPOSED",
+		message: `${input.subjectLabel} uses unrecognized namespace "${input.namespace}". Add extension pack "${input.namespace}" to extensions in prisma-next.config.ts.`,
+		sourceId: input.sourceId,
+		span: input.span,
+		data: {
+			namespace: input.namespace,
+			suggestedPack: input.namespace
+		}
+	});
+}
+/**
+* Pushes the canonical `PSL_UNKNOWN_FIELD_PRESET` diagnostic when a typoed preset name is referenced inside a registered field-preset namespace. The `data` payload exposes the namespace and full helper path so machine consumers (agents, IDE extensions) don't have to parse the prose.
+*/
+function reportUnknownFieldPreset(input) {
+	input.diagnostics.push({
+		code: "PSL_UNKNOWN_FIELD_PRESET",
+		message: `${input.entityLabel} references unknown field preset "${input.helperPath}". Check the spelling against the available presets in the "${input.namespace}" namespace.`,
+		sourceId: input.sourceId,
+		span: input.span,
+		data: {
+			namespace: input.namespace,
+			helperPath: input.helperPath
+		}
+	});
+}
+function instantiatePslTypeConstructor(input) {
+	const helperPath = input.call.path.join(".");
+	const args = mapPslHelperArgs({
+		args: input.call.args,
+		descriptors: input.descriptor.args ?? [],
+		helperLabel: `constructor "${helperPath}"`,
+		span: input.call.span,
+		diagnostics: input.diagnostics,
+		sourceId: input.sourceId,
+		entityLabel: input.entityLabel
+	});
+	if (!args) return;
+	try {
+		validateAuthoringHelperArguments(helperPath, input.descriptor.args, args);
+		return instantiateAuthoringTypeConstructor(input.descriptor, args);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		input.diagnostics.push({
+			code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+			message: `${input.entityLabel} constructor "${helperPath}" ${message}`,
+			sourceId: input.sourceId,
+			span: input.call.span
+		});
+		return;
+	}
+}
+function pushUnsupportedTypeConstructorDiagnostic(input) {
+	input.diagnostics.push({
+		code: input.code,
+		message: input.message,
+		sourceId: input.sourceId,
+		span: input.span
+	});
+}
+function resolvePslTypeConstructorDescriptor(input) {
+	const descriptor = getAuthoringTypeConstructor(input.authoringContributions, input.call.path);
+	if (descriptor) return descriptor;
+	const uncomposedNamespace = checkUncomposedNamespace(input.call.path.join("."), input.composedExtensions, {
+		familyId: input.familyId,
+		targetId: input.targetId,
+		authoringContributions: input.authoringContributions
+	});
+	if (uncomposedNamespace) {
+		reportUncomposedNamespace({
+			subjectLabel: `Type constructor "${input.call.path.join(".")}"`,
+			namespace: uncomposedNamespace,
+			sourceId: input.sourceId,
+			span: input.call.span,
+			diagnostics: input.diagnostics
+		});
+		return;
+	}
+	return pushUnsupportedTypeConstructorDiagnostic({
+		diagnostics: input.diagnostics,
+		sourceId: input.sourceId,
+		span: input.call.span,
+		code: input.unsupportedCode,
+		message: input.unsupportedMessage
+	});
+}
+/**
+* Instantiates a field-preset call against its descriptor, coercing PSL AST arguments into the descriptor's typed argument shape and returning the preset's full set of contract contributions.
+*
+* Symmetric with `instantiatePslTypeConstructor` but richer: a field preset can contribute `default`, `executionDefaults`, `id`, `unique`, and `nullable` in addition to the storage-type triple. PSL → typed-args coercion happens here (via `mapPslHelperArgs`) so that `instantiateAuthoringFieldPreset` itself stays typed-input-only and TS keeps its zero-runtime-validation cost.
+*/
+function instantiateFieldPreset(input) {
+	const helperPath = input.call.path.join(".");
+	const args = mapPslHelperArgs({
+		args: input.call.args,
+		descriptors: input.descriptor.args ?? [],
+		helperLabel: `preset "${helperPath}"`,
+		span: input.call.span,
+		diagnostics: input.diagnostics,
+		sourceId: input.sourceId,
+		entityLabel: input.entityLabel
+	});
+	if (!args) return;
+	try {
+		validateAuthoringHelperArguments(helperPath, input.descriptor.args, args);
+		const instantiated = instantiateAuthoringFieldPreset(input.descriptor, args);
+		return {
+			descriptor: {
+				codecId: instantiated.descriptor.codecId,
+				nativeType: instantiated.descriptor.nativeType,
+				...instantiated.descriptor.typeParams !== void 0 ? { typeParams: instantiated.descriptor.typeParams } : {}
+			},
+			nullable: instantiated.nullable,
+			...instantiated.default !== void 0 ? { default: instantiated.default } : {},
+			...instantiated.executionDefaults !== void 0 ? { executionDefaults: instantiated.executionDefaults } : {},
+			id: instantiated.id,
+			unique: instantiated.unique
+		};
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		input.diagnostics.push({
+			code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+			message: `${input.entityLabel} preset "${helperPath}" ${message}`,
+			sourceId: input.sourceId,
+			span: input.call.span
+		});
+		return;
+	}
+}
+/**
+* Structural check for a codec descriptor exposing the authoring-time
+* `columnFromEntity` hook a type constructor's `entityRefArg` resolves
+* through (e.g. the `pg/enum@1` codec descriptor). No casts.
+*/
+function hasColumnFromEntityHook(descriptor) {
+	return "columnFromEntity" in descriptor && typeof descriptor.columnFromEntity === "function";
+}
+/**
+* Resolves a type-constructor call whose descriptor declares an
+* `entityRefArg` (e.g. `pg.enum(AalLevel)`): extracts the call's sole
+* positional-argument ref string, resolves it against the field's
+* namespace's already-lowered extension entities (keyed by the declared
+* `entityRefArg.entityKind`, then block name), and converts the resolved
+* entity to column params via the `columnFromEntity` authoring hook on the
+* codec descriptor registered for `descriptor.output.codecId`. The `nativeType`
+* / `typeParams.typeName` `columnFromEntity` returns are bare — schema
+* qualification (e.g. `auth.aal_level`) is a target concern, applied later
+* when the target builds the field's namespace. A `valueSet` ref is
+* attached when the same namespace derived a value-set under the same block
+* name (the generic `deriveValueSet` mechanism), scoped to the field's own
+* namespace.
+*/
+function resolveEntityRefTypeConstructorCall(input) {
+	const entityRefArg = input.descriptor.entityRefArg;
+	if (entityRefArg === void 0) throw new InternalError("resolveEntityRefTypeConstructorCall called with a descriptor that does not declare an entityRefArg. This is an interpreter bug.");
+	const helperPath = input.call.path.join(".");
+	const positionalArgs = input.call.args.filter((arg) => arg.kind === "positional");
+	const ref = positionalArgs[entityRefArg.index]?.value;
+	if (input.call.args.length !== 1 || positionalArgs.length !== 1 || ref === void 0) {
+		input.diagnostics.push({
+			code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+			message: `${input.entityLabel} type constructor "${helperPath}" expects exactly one positional argument naming the referenced entity`,
+			sourceId: input.sourceId,
+			span: input.call.span
+		});
+		return {
+			ok: false,
+			alreadyReported: true
+		};
+	}
+	const reportUnknownRef = () => {
+		input.diagnostics.push({
+			code: "PSL_UNKNOWN_ENTITY_REF",
+			message: `${input.entityLabel} type constructor "${helperPath}(${ref})" does not resolve — no entity named "${ref}" was found in namespace "${input.namespaceId ?? "(unspecified)"}"`,
+			sourceId: input.sourceId,
+			span: input.call.span
+		});
+		return {
+			ok: false,
+			alreadyReported: true
+		};
+	};
+	const entity = input.namespaceExtensionEntities?.[entityRefArg.entityKind]?.[ref];
+	if (entity === void 0) return reportUnknownRef();
+	const codecId = input.descriptor.output.codecId;
+	const codecDescriptor = input.codecLookup?.descriptorFor?.(codecId);
+	if (codecDescriptor === void 0 || !hasColumnFromEntityHook(codecDescriptor)) throw contractError("CONTRACT.PACK_CONTRIBUTION_INVALID", `Type constructor "${helperPath}" registers codecId "${codecId}" with an entity-ref argument, but its codec descriptor has no "columnFromEntity" authoring hook. This is a contributor bug in the pack registering "${helperPath}", not a user-schema error.`, { meta: {
+		helperPath,
+		codecId
+	} });
+	const resolved = codecDescriptor.columnFromEntity(entity);
+	if (resolved === void 0) return reportUnknownRef();
+	const derivedValueSet = input.namespaceExtensionEntities?.["valueSet"]?.[ref];
+	if (derivedValueSet !== void 0 && input.namespaceId === void 0) {
+		input.diagnostics.push({
+			code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+			message: `${input.entityLabel} type constructor "${helperPath}(${ref})" resolves to a value-set-typed entity, but the field has no resolvable namespace to scope the value-set ref to`,
+			sourceId: input.sourceId,
+			span: input.call.span
+		});
+		return {
+			ok: false,
+			alreadyReported: true
+		};
+	}
+	const valueSet = derivedValueSet !== void 0 && input.namespaceId !== void 0 ? {
+		plane: "storage",
+		entityKind: "valueSet",
+		namespaceId: input.namespaceId,
+		entityName: ref
+	} : void 0;
+	return {
+		ok: true,
+		descriptor: {
+			codecId,
+			nativeType: resolved.nativeType,
+			...resolved.typeParams !== void 0 ? { typeParams: resolved.typeParams } : {},
+			...valueSet !== void 0 ? { valueSet } : {}
+		}
+	};
+}
+function resolveFieldTypeDescriptor(input) {
+	if (input.field.malformedType) return {
+		ok: false,
+		alreadyReported: true
+	};
+	if (input.field.typeConstructor) {
+		const presetDescriptor = getAuthoringFieldPreset(input.authoringContributions, input.field.typeConstructor.path);
+		if (presetDescriptor) {
+			const instantiated = instantiateFieldPreset({
+				call: input.field.typeConstructor,
+				descriptor: presetDescriptor,
+				diagnostics: input.diagnostics,
+				sourceId: input.sourceId,
+				entityLabel: input.entityLabel
+			});
+			if (!instantiated) return {
+				ok: false,
+				alreadyReported: true
+			};
+			const presetContributions = {
+				nullable: instantiated.nullable,
+				id: instantiated.id,
+				unique: instantiated.unique,
+				...instantiated.default !== void 0 ? { default: instantiated.default } : {},
+				...instantiated.executionDefaults !== void 0 ? { executionDefaults: instantiated.executionDefaults } : {}
+			};
+			return {
+				ok: true,
+				descriptor: instantiated.descriptor,
+				presetContributions
+			};
+		}
+		const helperPath = input.field.typeConstructor.path.join(".");
+		const namespacePrefix = input.field.typeConstructor.path.length > 1 ? input.field.typeConstructor.path[0] : void 0;
+		const typeDescriptor = getAuthoringTypeConstructor(input.authoringContributions, input.field.typeConstructor.path);
+		if (typeDescriptor?.entityRefArg) return resolveEntityRefTypeConstructorCall({
+			call: input.field.typeConstructor,
+			descriptor: typeDescriptor,
+			namespaceId: input.namespaceId,
+			namespaceExtensionEntities: input.namespaceExtensionEntities,
+			codecLookup: input.codecLookup,
+			diagnostics: input.diagnostics,
+			sourceId: input.sourceId,
+			entityLabel: input.entityLabel
+		});
+		if (!typeDescriptor && namespacePrefix && hasRegisteredFieldNamespace(input.authoringContributions, namespacePrefix)) {
+			reportUnknownFieldPreset({
+				entityLabel: input.entityLabel,
+				namespace: namespacePrefix,
+				helperPath,
+				sourceId: input.sourceId,
+				span: input.field.typeConstructor.span,
+				diagnostics: input.diagnostics
+			});
+			return {
+				ok: false,
+				alreadyReported: true
+			};
+		}
+		const descriptor = typeDescriptor ?? resolvePslTypeConstructorDescriptor({
+			call: input.field.typeConstructor,
+			authoringContributions: input.authoringContributions,
+			composedExtensions: input.composedExtensions,
+			familyId: input.familyId,
+			targetId: input.targetId,
+			diagnostics: input.diagnostics,
+			sourceId: input.sourceId,
+			unsupportedCode: "PSL_UNSUPPORTED_FIELD_TYPE",
+			unsupportedMessage: `${input.entityLabel} type constructor "${helperPath}" is not supported in SQL PSL provider v1`
+		});
+		if (!descriptor) return {
+			ok: false,
+			alreadyReported: true
+		};
+		const instantiated = instantiatePslTypeConstructor({
+			call: input.field.typeConstructor,
+			descriptor,
+			diagnostics: input.diagnostics,
+			sourceId: input.sourceId,
+			entityLabel: input.entityLabel
+		});
+		if (!instantiated) return {
+			ok: false,
+			alreadyReported: true
+		};
+		return {
+			ok: true,
+			descriptor: instantiated
+		};
+	}
+	const descriptor = resolveColumnDescriptor(input.field, input.enumTypeDescriptors, input.namedTypeDescriptors, input.scalarColumnDescriptors);
+	if (!descriptor) return {
+		ok: false,
+		alreadyReported: false
+	};
+	return {
+		ok: true,
+		descriptor
+	};
+}
+function lowerDefaultForField(input) {
+	const node = findFieldAttributeNode(input.field, "default");
+	if (node === void 0) return {};
+	const interpreted = interpretFieldAttribute({
+		node,
+		spec: buildDefaultSpec({
+			isList: input.isList ?? false,
+			registry: input.defaultFunctionRegistry
+		}),
+		model: input.model,
+		field: input.field,
+		sourceFile: input.sourceFile,
+		sourceId: input.sourceId,
+		diagnostics: input.diagnostics
+	});
+	if (interpreted === void 0) return {};
+	const value = interpreted.value;
+	if (Array.isArray(value)) return { defaultValue: {
+		kind: "literal",
+		value: [...value]
+	} };
+	if (typeof value === "object") {
+		const lowered = lowerDefaultFunctionWithRegistry({
+			call: value,
+			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: value.span
+			});
+			return {};
+		}
+		if (generatorDescriptor.applicableCodecIds === void 0) {
+			input.diagnostics.push({
+				code: "PSL_INVALID_DEFAULT_APPLICABILITY",
+				message: `Default generator "${generatorDescriptor.id}" is not applicable to "@default(...)" lowering. Use the corresponding field preset (e.g. \`temporal.${generatorDescriptor.id === "timestampNow" ? "updatedAt" : generatorDescriptor.id}()\`) instead.`,
+				sourceId: input.sourceId,
+				span: value.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: value.span
+			});
+			return {};
+		}
+		return { executionDefaults: { onCreate: lowered.value.generated } };
+	}
+	return { defaultValue: {
+		kind: "literal",
+		value
+	} };
+}
+function resolveColumnDescriptor(field, enumTypeDescriptors, namedTypeDescriptors, scalarColumnDescriptors) {
+	if (namedTypeDescriptors.has(field.typeName)) return namedTypeDescriptors.get(field.typeName);
+	if (enumTypeDescriptors.has(field.typeName)) return enumTypeDescriptors.get(field.typeName);
+	return scalarColumnDescriptors.get(field.typeName);
+}
+function lowerEnumDefaultForField(input) {
+	const { field, model, sourceFile, enumHandle, sourceId, diagnostics } = input;
+	const node = findFieldAttributeNode(field, "default");
+	if (node === void 0) return {};
+	const [firstMember, ...restMembers] = enumHandle.enumMembers.map((m) => m.name);
+	if (firstMember === void 0) return {};
+	const interpreted = interpretFieldAttribute({
+		node,
+		spec: buildEnumDefaultSpec([firstMember, ...restMembers]),
+		model,
+		field,
+		sourceFile,
+		sourceId,
+		diagnostics
+	});
+	if (interpreted === void 0) return {};
+	const member = interpreted.member;
+	const match = enumHandle.enumMembers.find((m) => m.name === member);
+	if (!match) return {};
+	return { defaultValue: {
+		kind: "literal",
+		value: blindCast(match.value)
+	} };
+}
+const MODEL_COORDINATE_SEPARATOR = "\0";
+function modelCoordinateKey(namespaceId, modelName) {
+	return `${namespaceId}${MODEL_COORDINATE_SEPARATOR}${modelName}`;
+}
+const BUILTIN_FIELD_ATTRIBUTE_NAMES = /* @__PURE__ */ new Set([
+	"id",
+	"unique",
+	"default",
+	"relation",
+	"map"
+]);
+const REMOVED_ATTRIBUTE_RULES = /* @__PURE__ */ new Map([["updatedAt", {
+	hint: "Use `temporal.updatedAt()` as a field-preset call instead.",
+	suppressWhen: (field) => field.typeConstructor?.path[0] === "temporal"
+}]]);
+{
+	const overlap = [...REMOVED_ATTRIBUTE_RULES.keys()].filter((name) => BUILTIN_FIELD_ATTRIBUTE_NAMES.has(name));
+	if (overlap.length > 0) throw new InternalError(`BUILTIN_FIELD_ATTRIBUTE_NAMES and REMOVED_ATTRIBUTE_RULES must not overlap. Names in both: ${overlap.join(", ")}`);
+}
+function validateFieldAttributes(input) {
+	for (const attribute of input.field.attributes) {
+		if (BUILTIN_FIELD_ATTRIBUTE_NAMES.has(attribute.name)) continue;
+		if (attribute.name.startsWith("db.")) {
+			input.diagnostics.push({
+				code: "PSL_UNSUPPORTED_FIELD_ATTRIBUTE",
+				message: formatDbAttributeMigrationMessage(attribute),
+				sourceId: input.sourceId,
+				span: attribute.span
+			});
+			continue;
+		}
+		const uncomposedNamespace = checkUncomposedNamespace(attribute.name, input.composedExtensions, {
+			familyId: input.familyId,
+			targetId: input.targetId,
+			authoringContributions: input.authoringContributions
+		});
+		if (uncomposedNamespace) {
+			reportUncomposedNamespace({
+				subjectLabel: `Attribute "@${attribute.name}"`,
+				namespace: uncomposedNamespace,
+				sourceId: input.sourceId,
+				span: attribute.span,
+				diagnostics: input.diagnostics
+			});
+			continue;
+		}
+		const baseMessage = `Field "${input.model.name}.${input.field.name}" uses unsupported attribute "@${attribute.name}"`;
+		const removedRule = REMOVED_ATTRIBUTE_RULES.get(attribute.name);
+		const message = removedRule && !removedRule.suppressWhen(input.field) ? `${baseMessage}. ${removedRule.hint}` : baseMessage;
+		input.diagnostics.push({
+			code: "PSL_UNSUPPORTED_FIELD_ATTRIBUTE",
+			message,
+			sourceId: input.sourceId,
+			span: attribute.span
+		});
+	}
+}
+function extractFieldConstraintNames(input) {
+	const idAttribute = getAttribute(input.field.attributes, "id");
+	const uniqueAttribute = getAttribute(input.field.attributes, "unique");
+	const idNode = findFieldAttributeNode(input.field, "id");
+	const idName = idNode === void 0 ? void 0 : interpretFieldAttribute({
+		node: idNode,
+		spec: idFieldSpec,
+		model: input.model,
+		field: input.field,
+		sourceFile: input.sourceFile,
+		sourceId: input.sourceId,
+		diagnostics: input.diagnostics
+	})?.map;
+	const uniqueNode = findFieldAttributeNode(input.field, "unique");
+	return {
+		idAttribute,
+		uniqueAttribute,
+		idName,
+		uniqueName: uniqueNode === void 0 ? void 0 : interpretFieldAttribute({
+			node: uniqueNode,
+			spec: uniqueFieldSpec,
+			model: input.model,
+			field: input.field,
+			sourceFile: input.sourceFile,
+			sourceId: input.sourceId,
+			diagnostics: input.diagnostics
+		})?.map
+	};
+}
+function collectResolvedFields(input) {
+	const { model, mapping, enumTypeDescriptors, namedTypeDescriptors, modelNames, compositeTypeNames, composedExtensions, authoringContributions, familyId, targetId, defaultFunctionRegistry, generatorDescriptorById, diagnostics, sourceId, scalarColumnDescriptors, enumHandles, capabilities, namespaceId, namespaceExtensionEntities, codecLookup } = input;
+	const resolvedFields = [];
+	const valueObjectStorageTypeName = authoringContributions?.valueObjectStorageType;
+	for (const field of Object.values(model.fields)) {
+		const isModelField = modelNames.has(field.typeName);
+		if (field.list && isModelField) continue;
+		validateFieldAttributes({
+			model,
+			field,
+			composedExtensions,
+			authoringContributions,
+			diagnostics,
+			sourceId,
+			familyId,
+			targetId
+		});
+		const relationAttribute = getAttribute(field.attributes, "relation");
+		if (isModelField && relationAttribute) continue;
+		if (field.typeContractSpaceId !== void 0 && relationAttribute) continue;
+		if (isModelField) continue;
+		const isValueObjectField = compositeTypeNames.has(field.typeName);
+		const isListField = field.list;
+		let descriptor;
+		let scalarCodecId;
+		let presetContributions;
+		const resolveInput = {
+			field,
+			enumTypeDescriptors,
+			namedTypeDescriptors,
+			scalarColumnDescriptors,
+			authoringContributions,
+			composedExtensions,
+			familyId,
+			targetId,
+			diagnostics,
+			sourceId,
+			entityLabel: `Field "${model.name}.${field.name}"`,
+			...ifDefined("namespaceId", namespaceId),
+			...ifDefined("namespaceExtensionEntities", namespaceExtensionEntities),
+			...ifDefined("codecLookup", codecLookup)
+		};
+		if (isValueObjectField) descriptor = valueObjectStorageTypeName !== void 0 ? scalarColumnDescriptors.get(valueObjectStorageTypeName) : void 0;
+		else if (isListField) {
+			if (capabilities["sql"]?.["scalarList"] !== true) {
+				diagnostics.push({
+					code: "PSL_SCALAR_LIST_UNSUPPORTED_TARGET",
+					message: `Field "${model.name}.${field.name}" is a scalar list, but target "${targetId}" does not support scalar lists (the adapter does not report the "scalarList" capability). Remove the list or author it against a target that supports scalar lists.`,
+					sourceId,
+					span: field.span
+				});
+				continue;
+			}
+			const resolved = resolveFieldTypeDescriptor(resolveInput);
+			if (!resolved.ok) {
+				if (!resolved.alreadyReported) 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;
+			}
+			if (resolved.presetContributions) {
+				diagnostics.push({
+					code: "PSL_PRESET_NOT_LIST",
+					message: `Field "${model.name}.${field.name}" uses a field-preset call as a list element type. Presets cannot be list elements; remove "[]" or use a scalar type.`,
+					sourceId,
+					span: field.span
+				});
+				continue;
+			}
+			scalarCodecId = resolved.descriptor.codecId;
+			descriptor = resolved.descriptor;
+		} else {
+			const resolved = resolveFieldTypeDescriptor(resolveInput);
+			if (!resolved.ok) {
+				if (!resolved.alreadyReported) 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;
+			}
+			descriptor = resolved.descriptor;
+			presetContributions = resolved.presetContributions;
+		}
+		if (!descriptor) continue;
+		if (presetContributions && field.optional) {
+			diagnostics.push({
+				code: "PSL_PRESET_NOT_OPTIONAL",
+				message: `Field "${model.name}.${field.name}" uses a field-preset call and cannot be optional. Remove "?" or use a different field type.`,
+				sourceId,
+				span: field.span
+			});
+			continue;
+		}
+		const defaultAttribute = getAttribute(field.attributes, "default");
+		if (presetContributions && defaultAttribute) {
+			diagnostics.push({
+				code: "PSL_PRESET_AND_DEFAULT_CONFLICT",
+				message: `Field "${model.name}.${field.name}" uses a field-preset call and cannot also declare @default(...). The preset already specifies the default value.`,
+				sourceId,
+				span: defaultAttribute.span
+			});
+			continue;
+		}
+		const enumHandle = enumHandles?.get(field.typeName);
+		const loweredDefault = defaultAttribute ? enumHandle ? lowerEnumDefaultForField({
+			modelName: model.name,
+			fieldName: field.name,
+			field,
+			model,
+			sourceFile: input.sourceFile,
+			enumHandle,
+			sourceId,
+			diagnostics
+		}) : lowerDefaultForField({
+			modelName: model.name,
+			fieldName: field.name,
+			field,
+			model,
+			sourceFile: input.sourceFile,
+			columnDescriptor: descriptor,
+			generatorDescriptorById,
+			sourceId,
+			defaultFunctionRegistry,
+			diagnostics,
+			isList: isListField
+		}) : {};
+		const loweredOnCreate = loweredDefault.executionDefaults?.onCreate;
+		const loweredFunctionDefault = loweredDefault.defaultValue?.kind === "function";
+		if (isListField && (loweredOnCreate || loweredFunctionDefault)) {
+			const defaultExpression = defaultAttribute?.args.find((arg) => arg.kind === "positional")?.value.trim() ?? "this function";
+			diagnostics.push({
+				code: "PSL_LIST_EXECUTION_DEFAULT_UNSUPPORTED",
+				message: `Field "${model.name}.${field.name}" is a list and cannot use an execution default ("${defaultExpression}"). Lists have no per-element execution-default semantics; use a literal list @default or remove the default.`,
+				sourceId,
+				span: defaultAttribute?.span ?? field.span
+			});
+			continue;
+		}
+		if (field.optional && loweredOnCreate) {
+			const generatorDescription = loweredOnCreate.kind === "generator" ? `"${loweredOnCreate.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;
+		}
+		const mappedColumnName = mapping.fieldColumns.get(field.name) ?? field.name;
+		const { idAttribute, uniqueAttribute, idName, uniqueName } = extractFieldConstraintNames({
+			model,
+			field,
+			sourceFile: input.sourceFile,
+			sourceId,
+			diagnostics
+		});
+		let isIdField = Boolean(idAttribute);
+		if (idAttribute && isListField) {
+			diagnostics.push({
+				code: "PSL_LIST_ID_UNSUPPORTED",
+				message: `Field "${model.name}.${field.name}" is a list and cannot be a primary key. Remove @id; a list cannot be an identity column.`,
+				sourceId,
+				span: idAttribute.span
+			});
+			continue;
+		}
+		if (idAttribute && field.optional) {
+			diagnostics.push({
+				code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+				message: `Field "${model.name}.${field.name}" @id cannot be optional; primary key columns must be NOT NULL`,
+				sourceId,
+				span: idAttribute.span
+			});
+			isIdField = false;
+		}
+		if (presetContributions && idAttribute && !presetContributions.id) {
+			diagnostics.push({
+				code: "PSL_PRESET_AND_ID_CONFLICT",
+				message: `Field "${model.name}.${field.name}" uses a field-preset call and cannot also declare @id. Use a preset that contributes id semantics, or drop @id.`,
+				sourceId,
+				span: idAttribute.span
+			});
+			continue;
+		}
+		const fieldExecutionDefaults = presetContributions?.executionDefaults ?? loweredDefault.executionDefaults;
+		const fieldDefaultValue = presetContributions?.default ?? loweredDefault.defaultValue;
+		resolvedFields.push({
+			field,
+			columnName: mappedColumnName,
+			descriptor,
+			nullable: presetContributions?.nullable ?? field.optional,
+			...ifDefined("defaultValue", fieldDefaultValue),
+			...ifDefined("executionDefaults", fieldExecutionDefaults),
+			isId: isIdField || Boolean(presetContributions?.id),
+			isUnique: Boolean(uniqueAttribute) || Boolean(presetContributions?.unique),
+			...ifDefined("idName", idName),
+			...ifDefined("uniqueName", uniqueName),
+			...ifDefined("many", isListField ? true : void 0),
+			...ifDefined("valueObjectTypeName", isValueObjectField ? field.typeName : void 0),
+			...ifDefined("scalarCodecId", scalarCodecId)
+		});
+	}
+	return resolvedFields;
+}
+function buildModelMappings(modelEntries, defaultNamespaceId, diagnostics, sourceId, sourceFile) {
+	const result = /* @__PURE__ */ new Map();
+	for (const { model, namespaceId } of modelEntries) {
+		const mapNode = findModelAttributeNode(model, "map");
+		const tableName = mapNode === void 0 ? lowerFirst(model.name) : interpretModelAttribute({
+			node: mapNode,
+			spec: mapModelSpec,
+			model,
+			sourceFile,
+			sourceId,
+			diagnostics
+		})?.name ?? lowerFirst(model.name);
+		const fieldColumns = /* @__PURE__ */ new Map();
+		for (const field of Object.values(model.fields)) {
+			const fieldMapNode = findFieldAttributeNode(field, "map");
+			const columnName = fieldMapNode === void 0 ? field.name : interpretFieldAttribute({
+				node: fieldMapNode,
+				spec: mapFieldSpec,
+				model,
+				field,
+				sourceFile,
+				sourceId,
+				diagnostics
+			})?.name ?? field.name;
+			fieldColumns.set(field.name, columnName);
+		}
+		result.set(modelCoordinateKey(namespaceId ?? defaultNamespaceId, model.name), {
+			model,
+			tableName,
+			fieldColumns
+		});
+	}
+	return result;
+}
+function validateNamedTypeAttributes(input) {
+	let hasUnsupportedNamedTypeAttribute = false;
+	for (const attribute of input.declaration.attributes) {
+		if (attribute.name.startsWith("db.")) {
+			input.diagnostics.push({
+				code: "PSL_UNSUPPORTED_NAMED_TYPE_ATTRIBUTE",
+				message: formatDbAttributeMigrationMessage(attribute),
+				sourceId: input.sourceId,
+				span: attribute.span
+			});
+			hasUnsupportedNamedTypeAttribute = true;
+			continue;
+		}
+		const uncomposedNamespace = checkUncomposedNamespace(attribute.name, input.composedExtensions, {
+			familyId: input.familyId,
+			targetId: input.targetId,
+			authoringContributions: input.authoringContributions
+		});
+		if (uncomposedNamespace) {
+			reportUncomposedNamespace({
+				subjectLabel: `Attribute "@${attribute.name}"`,
+				namespace: uncomposedNamespace,
+				sourceId: input.sourceId,
+				span: attribute.span,
+				diagnostics: input.diagnostics
+			});
+			hasUnsupportedNamedTypeAttribute = true;
+			continue;
+		}
+		input.diagnostics.push({
+			code: "PSL_UNSUPPORTED_NAMED_TYPE_ATTRIBUTE",
+			message: `Named type "${input.declaration.name}" uses unsupported attribute "${attribute.name}"`,
+			sourceId: input.sourceId,
+			span: attribute.span
+		});
+		hasUnsupportedNamedTypeAttribute = true;
+	}
+	return hasUnsupportedNamedTypeAttribute;
+}
+function resolveNamedTypeDeclarations(input) {
+	const storageTypeEntries = [];
+	const namedTypeDescriptors = /* @__PURE__ */ new Map();
+	for (const declaration of input.declarations) {
+		if (declaration.isConstructor) {
+			const typeConstructor = declaration.typeConstructor;
+			if (typeConstructor === void 0) {
+				input.diagnostics.push({
+					code: "PSL_UNSUPPORTED_NAMED_TYPE_BASE",
+					message: `Named type "${declaration.name}" must declare a base type or constructor`,
+					sourceId: input.sourceId,
+					span: declaration.span
+				});
+				continue;
+			}
+			if (validateNamedTypeAttributes({
+				declaration,
+				sourceId: input.sourceId,
+				diagnostics: input.diagnostics,
+				composedExtensions: input.composedExtensions,
+				authoringContributions: input.authoringContributions,
+				familyId: input.familyId,
+				targetId: input.targetId
+			})) continue;
+			const helperPath = typeConstructor.path.join(".");
+			const descriptor = resolvePslTypeConstructorDescriptor({
+				call: typeConstructor,
+				authoringContributions: input.authoringContributions,
+				composedExtensions: input.composedExtensions,
+				familyId: input.familyId,
+				targetId: input.targetId,
+				diagnostics: input.diagnostics,
+				sourceId: input.sourceId,
+				unsupportedCode: "PSL_UNSUPPORTED_NAMED_TYPE_CONSTRUCTOR",
+				unsupportedMessage: `Named type "${declaration.name}" references unsupported constructor "${helperPath}"`
+			});
+			if (!descriptor) continue;
+			const storageType = instantiatePslTypeConstructor({
+				call: typeConstructor,
+				descriptor,
+				diagnostics: input.diagnostics,
+				sourceId: input.sourceId,
+				entityLabel: `Named type "${declaration.name}"`
+			});
+			if (!storageType) continue;
+			namedTypeDescriptors.set(declaration.name, toNamedTypeFieldDescriptor(declaration.name, storageType));
+			storageTypeEntries.push([declaration.name, {
+				kind: "codec-instance",
+				codecId: storageType.codecId,
+				nativeType: storageType.nativeType,
+				typeParams: storageType.typeParams ?? {}
+			}]);
+			continue;
+		}
+		const baseType = declaration.baseType;
+		if (baseType === void 0) {
+			input.diagnostics.push({
+				code: "PSL_UNSUPPORTED_NAMED_TYPE_BASE",
+				message: `Named type "${declaration.name}" must declare a base type or constructor`,
+				sourceId: input.sourceId,
+				span: declaration.span
+			});
+			continue;
+		}
+		const baseDescriptor = input.enumTypeDescriptors.get(baseType) ?? input.scalarColumnDescriptors.get(baseType);
+		if (!baseDescriptor) {
+			input.diagnostics.push({
+				code: "PSL_UNSUPPORTED_NAMED_TYPE_BASE",
+				message: `Named type "${declaration.name}" references unsupported base type "${baseType}"`,
+				sourceId: input.sourceId,
+				span: declaration.span
+			});
+			continue;
+		}
+		if (validateNamedTypeAttributes({
+			declaration,
+			sourceId: input.sourceId,
+			diagnostics: input.diagnostics,
+			composedExtensions: input.composedExtensions,
+			authoringContributions: input.authoringContributions,
+			familyId: input.familyId,
+			targetId: input.targetId
+		})) continue;
+		const descriptor = toNamedTypeFieldDescriptor(declaration.name, baseDescriptor);
+		namedTypeDescriptors.set(declaration.name, descriptor);
+		storageTypeEntries.push([declaration.name, {
+			kind: "codec-instance",
+			codecId: baseDescriptor.codecId,
+			nativeType: baseDescriptor.nativeType,
+			typeParams: baseDescriptor.typeParams ?? {}
+		}]);
+	}
+	return {
+		storageTypes: Object.fromEntries(storageTypeEntries),
+		namedTypeDescriptors
+	};
+}
+const REFERENTIAL_ACTION_MAP = {
+	NoAction: "noAction",
+	Restrict: "restrict",
+	Cascade: "cascade",
+	SetNull: "setNull",
+	SetDefault: "setDefault",
+	noAction: "noAction",
+	restrict: "restrict",
+	cascade: "cascade",
+	setNull: "setNull",
+	setDefault: "setDefault"
+};
+function fkRelationPairKey(declaringModelName, targetModelName) {
+	return `${declaringModelName}::${targetModelName}`;
+}
+function normalizeReferentialAction(actionToken) {
+	return REFERENTIAL_ACTION_MAP[actionToken];
+}
+function relationInvariants(parsed, ctx) {
+	if (parsed.fields !== void 0 !== (parsed.references !== void 0)) return [{
+		code: "PSL_INVALID_ATTRIBUTE_SYNTAX",
+		message: `Relation field "${ctx.selfModel.name}.${ctx.field?.name ?? ""}" requires fields and references arguments`,
+		sourceId: ctx.sourceId,
+		span: relationAttributeSpan(ctx)
+	}];
+	return [];
+}
+const sqlRelation = fieldAttribute("relation", {
+	positional: [{
+		key: "name",
+		type: optional(str())
+	}],
+	named: {
+		name: optional(str()),
+		fields: optional(list(fieldRef("self"), {
+			nonEmpty: true,
+			unique: true
+		})),
+		references: optional(list(fieldRef("referenced"), {
+			nonEmpty: true,
+			unique: true
+		})),
+		map: optional(str()),
+		onDelete: optional(oneOf(identifier("NoAction"), identifier("Restrict"), identifier("Cascade"), identifier("SetNull"), identifier("SetDefault"))),
+		onUpdate: optional(oneOf(identifier("NoAction"), identifier("Restrict"), identifier("Cascade"), identifier("SetNull"), identifier("SetDefault"))),
+		/**
+		* Opts a foreign key out of its default backing index
+		* (`index: false`). Omitted (the default) keeps the FK's derived
+		* backing-index expectation; only `false` is meaningful — there is no
+		* `index: true` spelling since that is already the default.
+		*/
+		index: optional(bool())
+	},
+	refine: relationInvariants
+});
+function relationAttributeSpan(ctx) {
+	const field = ctx.field;
+	if (field !== void 0) {
+		const node = findFieldAttributeNode(field, "relation");
+		if (node !== void 0) return nodePslSpan(node.syntax, ctx.sourceFile);
+		return field.span;
+	}
+	return ctx.selfModel.span;
+}
+function resolveReferencedModel(symbols, field) {
+	const topLevel = symbols.topLevel.models[field.typeName];
+	if (topLevel !== void 0) return topLevel;
+	for (const namespace of Object.values(symbols.topLevel.namespaces)) {
+		const model = namespace.models[field.typeName];
+		if (model !== void 0) return model;
+	}
+}
+function interpretRelationAttribute(input) {
+	const node = findFieldAttributeNode(input.field, "relation");
+	if (node === void 0) return void 0;
+	return interpretFieldAttribute({
+		node,
+		spec: sqlRelation,
+		model: input.selfModel,
+		field: input.field,
+		sourceFile: input.sourceFile,
+		sourceId: input.sourceId,
+		diagnostics: input.diagnostics,
+		resolveReferencedModel: () => resolveReferencedModel(input.symbols, input.field)
+	});
+}
+function indexFkRelations(input) {
+	const modelRelations = /* @__PURE__ */ new Map();
+	const fkRelationsByPair = /* @__PURE__ */ new Map();
+	const fkRelationsByDeclaringModel = /* @__PURE__ */ new Map();
+	for (const relation of input.fkRelationMetadata) {
+		const declaringFkRelations = fkRelationsByDeclaringModel.get(relation.declaringModelName);
+		if (declaringFkRelations) declaringFkRelations.push(relation);
+		else fkRelationsByDeclaringModel.set(relation.declaringModelName, [relation]);
+		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,
+			...ifDefined("toNamespaceId", relation.targetNamespaceId),
+			cardinality: "N:1",
+			on: {
+				parentTable: relation.declaringTableName,
+				parentColumns: relation.localColumns,
+				childTable: relation.targetTableName,
+				childColumns: relation.referencedColumns
+			}
+		});
+		const pairKey = fkRelationPairKey(relation.declaringModelName, relation.targetModelName);
+		const pairRelations = fkRelationsByPair.get(pairKey);
+		if (!pairRelations) {
+			fkRelationsByPair.set(pairKey, [relation]);
+			continue;
+		}
+		pairRelations.push(relation);
+	}
+	return {
+		modelRelations,
+		fkRelationsByPair,
+		fkRelationsByDeclaringModel
+	};
+}
+function idColumnsAreExactlyFkPair(idColumns, parentColumns, childColumns) {
+	if (idColumns.length !== parentColumns.length + childColumns.length) return false;
+	const fkColumns = /* @__PURE__ */ new Set([...parentColumns, ...childColumns]);
+	if (fkColumns.size !== parentColumns.length + childColumns.length) return false;
+	return idColumns.every((column) => fkColumns.has(column));
+}
+/**
+* Reorders the child FK's junction columns into the target model's id-column
+* order. Returns undefined unless the FK references exactly the target's full
+* id, because downstream consumers pair `through.childColumns` positionally
+* against the target id columns — an FK referencing anything else (a non-id
+* unique, a partial id) would produce a silently wrong join.
+*/
+function childColumnsInTargetIdOrder(childFk, targetIdColumns) {
+	if (childFk.referencedColumns.length !== targetIdColumns.length) return;
+	const localByReferenced = /* @__PURE__ */ new Map();
+	for (const [index, referencedColumn] of childFk.referencedColumns.entries()) {
+		const localColumn = childFk.localColumns[index];
+		if (localColumn === void 0) return;
+		localByReferenced.set(referencedColumn, localColumn);
+	}
+	if (localByReferenced.size !== targetIdColumns.length) return;
+	const ordered = [];
+	for (const idColumn of targetIdColumns) {
+		const localColumn = localByReferenced.get(idColumn);
+		if (localColumn === void 0) return;
+		ordered.push(localColumn);
+	}
+	return ordered;
+}
+/**
+* Finds explicit junction models that connect a bare backrelation list field
+* to its target model: a model whose composite id columns are exactly the FK
+* columns of one relation back to the candidate's model (the parent side) and
+* one relation to the candidate's target model (the child side). The child
+* FK must reference exactly the target model's id columns; its junction
+* columns are carried in target-id order on the pair. A relation name on the
+* list field pins the parent-side FK relation, which is how self-referential
+* many-to-many sides are disambiguated.
+*
+* Alongside the recognised pairs, returns junction-shaped near-misses (models
+* that link both sides but were declined) so the caller can emit a
+* junction-specific diagnostic instead of the generic orphaned-list message.
+*/
+function findJunctionFkPairs(input) {
+	const targetIdColumns = input.modelIdColumns.get(input.candidate.targetModelName);
+	if (!targetIdColumns || targetIdColumns.length === 0) return {
+		pairs: [],
+		nearMisses: []
+	};
+	const pairs = [];
+	const nearMisses = [];
+	for (const [junctionModelName, junctionFks] of input.fkRelationsByDeclaringModel) {
+		const idColumns = input.modelIdColumns.get(junctionModelName);
+		for (const parentFk of junctionFks) {
+			if (parentFk.targetModelName !== input.candidate.modelName) continue;
+			if (input.candidate.relationName !== void 0 && parentFk.relationName !== input.candidate.relationName) continue;
+			for (const childFk of junctionFks) {
+				if (childFk === parentFk || childFk.targetModelName !== input.candidate.targetModelName) continue;
+				if (!idColumns || !idColumnsAreExactlyFkPair(idColumns, parentFk.localColumns, childFk.localColumns)) {
+					nearMisses.push({
+						junctionModelName,
+						reason: "id-not-fk-covering"
+					});
+					continue;
+				}
+				const orderedChildColumns = childColumnsInTargetIdOrder(childFk, targetIdColumns);
+				if (!orderedChildColumns) {
+					nearMisses.push({
+						junctionModelName,
+						reason: "target-fk-not-id"
+					});
+					continue;
+				}
+				pairs.push({
+					parentFk,
+					childFk,
+					childColumnsInTargetIdOrder: orderedChildColumns
+				});
+			}
+		}
+	}
+	return {
+		pairs,
+		nearMisses
+	};
+}
+function junctionNearMissDiagnostic(candidate, nearMiss, sourceId) {
+	const listField = `${candidate.modelName}.${candidate.field.name}`;
+	const data = {
+		listField,
+		junctionModel: nearMiss.junctionModelName,
+		targetModel: candidate.targetModelName
+	};
+	if (nearMiss.reason === "target-fk-not-id") return {
+		code: "PSL_JUNCTION_TARGET_FK_NOT_ID",
+		message: `Backrelation list field "${listField}" found junction model "${nearMiss.junctionModelName}", but its foreign key to "${candidate.targetModelName}" does not reference "${candidate.targetModelName}"'s @id. The junction's target-side foreign key must reference "${candidate.targetModelName}"'s full @id columns for many-to-many recognition.`,
+		sourceId,
+		span: candidate.field.span,
+		data
+	};
+	return {
+		code: "PSL_JUNCTION_ID_NOT_FK_COVERING",
+		message: `Backrelation list field "${listField}" found junction-shaped model "${nearMiss.junctionModelName}" linking "${candidate.modelName}" and "${candidate.targetModelName}", but its id does not cover exactly its foreign-key columns. Declare @@id([...]) on "${nearMiss.junctionModelName}" listing exactly the two foreign-key columns for many-to-many recognition.`,
+		sourceId,
+		span: candidate.field.span,
+		data
+	};
+}
+function manyToManyRelationNode(candidate, pair) {
+	return {
+		fieldName: candidate.field.name,
+		toModel: pair.childFk.targetModelName,
+		toTable: pair.childFk.targetTableName,
+		...ifDefined("toNamespaceId", pair.childFk.targetNamespaceId),
+		cardinality: "N:M",
+		on: {
+			parentTable: candidate.tableName,
+			parentColumns: pair.parentFk.referencedColumns,
+			childTable: pair.parentFk.declaringTableName,
+			childColumns: pair.parentFk.localColumns
+		},
+		through: {
+			table: pair.parentFk.declaringTableName,
+			...ifDefined("namespaceId", pair.parentFk.declaringNamespaceId),
+			parentColumns: pair.parentFk.localColumns,
+			childColumns: pair.childColumnsInTargetIdOrder
+		}
+	};
+}
+function relationsForModel(modelRelations, modelName) {
+	const existing = modelRelations.get(modelName);
+	if (existing) return existing;
+	const created = [];
+	modelRelations.set(modelName, created);
+	return created;
+}
+/**
+* A set of columns is unique when it exactly matches one of the model's unique
+* column sets — its primary key or any single- or multi-column `@unique` /
+* `@@unique` constraint. Set equality (not subset) is required: a singular
+* back-relation means at most one child per parent, which a unique constraint
+* covering exactly the FK columns guarantees.
+*/
+function fkColumnsAreUnique(localColumns, uniqueColumnSets) {
+	const local = new Set(localColumns);
+	return uniqueColumnSets.some((columns) => columns.length === local.size && columns.every((column) => local.has(column)));
+}
+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) {
+			if (candidate.isList) {
+				const { pairs: junctionPairs, nearMisses } = findJunctionFkPairs({
+					candidate,
+					fkRelationsByDeclaringModel: input.fkRelationsByDeclaringModel,
+					modelIdColumns: input.modelIdColumns
+				});
+				const junctionPair = junctionPairs[0];
+				if (junctionPairs.length === 1 && junctionPair) {
+					relationsForModel(input.modelRelations, candidate.modelName).push(manyToManyRelationNode(candidate, junctionPair));
+					continue;
+				}
+				if (junctionPairs.length > 1) {
+					input.diagnostics.push({
+						code: "PSL_AMBIGUOUS_BACKRELATION",
+						message: `Backrelation list field "${candidate.modelName}.${candidate.field.name}" matches multiple junction FK pairs for a many-to-many relation. Add @relation(name: "...") (or @relation("...")) to the list field and the junction FK-side relation pointing back at "${candidate.modelName}" to disambiguate.`,
+						sourceId: input.sourceId,
+						span: candidate.field.span
+					});
+					continue;
+				}
+				const nearMiss = nearMisses[0];
+				if (nearMiss) {
+					input.diagnostics.push(junctionNearMissDiagnostic(candidate, nearMiss, input.sourceId));
+					continue;
+				}
+			}
+			input.diagnostics.push({
+				code: "PSL_ORPHANED_BACKRELATION",
+				message: `Backrelation 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${candidate.isList ? " 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",
+				message: `Backrelation 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");
+		if (!candidate.isList) {
+			const uniqueColumnSets = input.modelUniqueColumnSets.get(matched.declaringModelName) ?? [];
+			if (!fkColumnsAreUnique(matched.localColumns, uniqueColumnSets)) {
+				input.diagnostics.push({
+					code: "PSL_NON_UNIQUE_BACKRELATION",
+					message: `Backrelation field "${candidate.modelName}.${candidate.field.name}" is singular, but the matching FK on "${matched.declaringModelName}" (fields ${matched.localColumns.map((column) => `"${column}"`).join(", ")}) is not unique. A singular back-relation implies at most one related row; add @unique (or @@unique([...])) to the FK fields, or make "${candidate.field.name}" a list.`,
+					sourceId: input.sourceId,
+					span: candidate.field.span
+				});
+				continue;
+			}
+		}
+		relationsForModel(input.modelRelations, candidate.modelName).push({
+			fieldName: candidate.field.name,
+			toModel: matched.declaringModelName,
+			toTable: matched.declaringTableName,
+			...ifDefined("toNamespaceId", matched.declaringNamespaceId),
+			cardinality: candidate.isList ? "1:N" : "1:1",
+			on: {
+				parentTable: candidate.tableName,
+				parentColumns: matched.referencedColumns,
+				childTable: matched.declaringTableName,
+				childColumns: matched.localColumns
+			}
+		});
+	}
+}
+function validateBackrelationFieldAttributes(input) {
+	let valid = true;
+	for (const attribute of input.field.attributes) {
+		if (attribute.name === "relation") continue;
+		const uncomposedNamespace = checkUncomposedNamespace(attribute.name, input.composedExtensions, {
+			familyId: input.familyId,
+			targetId: input.targetId,
+			authoringContributions: input.authoringContributions
+		});
+		if (uncomposedNamespace) {
+			reportUncomposedNamespace({
+				subjectLabel: `Attribute "@${attribute.name}"`,
+				namespace: uncomposedNamespace,
+				sourceId: input.sourceId,
+				span: attribute.span,
+				diagnostics: input.diagnostics
+			});
+			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 buildComposedExtensionPackRefs(target, extensionIds, extensionPackRefs = []) {
+	if (extensionIds.length === 0) return;
+	const extensionPackRefById = new Map(extensionPackRefs.map((packRef) => [packRef.id, packRef]));
+	return Object.fromEntries(extensionIds.map((extensionId) => [extensionId, extensionPackRefById.get(extensionId) ?? {
+		kind: "extension",
+		id: extensionId,
+		familyId: target.familyId,
+		targetId: target.targetId,
+		version: "0.0.1"
+	}]));
+}
+function compareStrings(left, right) {
+	if (left < right) return -1;
+	if (left > right) return 1;
+	return 0;
+}
+/**
+* Name of the framework-parser synthesised bucket for top-level
+* declarations. Re-declared here so the per-target dispatch does not
+* have to import from `@internal/framework-components/psl-ast`
+* (which would cross a layer that the interpreter does not otherwise
+* import from). The value is part of the framework parser's contract;
+* if it changes there, the matching test in this package's
+* `interpreter.diagnostics.test.ts` flips first.
+*/
+const UNSPECIFIED_PSL_NAMESPACE_NAME = "__unspecified__";
+/**
+* Per-target namespace-block validation: walk the AST's namespace buckets and
+* emit diagnostics for syntactic constructs the target does not accept.
+*
+* - **SQLite** has no schema concept and rejects every explicit
+*   `namespace { … }` block. The implicit `__unspecified__` bucket
+*   (produced by the parser for top-level declarations outside any
+*   block) is the only namespace SQLite accepts.
+* - **Postgres** accepts every explicit block — `namespace unbound { … }`
+*   is the late-binding opt-in (lowers to the IR `__unbound__` slot in
+*   a follow-on commit), `namespace public { … }` reopen-merges with
+*   the implicit bucket, and any other name lowers to a named schema.
+*
+* Storage-side lowering of these buckets to IR namespace slots is not
+* yet wired; this helper closes only the diagnostic surface.
+*/
+/**
+* Per-target namespace lowering: map a PSL AST namespace bucket name to the
+* resolved IR namespace id (the key downstream consumers use against
+* `SqlStorage.namespaces`).
+*
+* - **Postgres**: an explicit `namespace unbound { … }` block lowers
+*   to the framework sentinel `__unbound__` — the slot whose binding
+*   the connection's `search_path` resolves at runtime. Every other
+*   explicit bucket name (e.g. `auth`, `public`) passes through as a
+*   named schema id. The implicit `__unspecified__` bucket — top-level
+*   declarations outside any `namespace { … }` block — leaves the
+*   coordinate unset; downstream consumers treat unset as the
+*   late-bound default, and TS / PSL authoring stay byte-identical
+*   on single-namespace contracts. (A future round will add a
+*   target-default-namespace surface so `__unspecified__` lowers to
+*   `public` consistently on both authoring paths.)
+* - **SQLite**: SQLite has no schema concept; every namespace
+*   collapses to the late-bound default. The namespace-block
+*   validation step (above) has already rejected any explicit
+*   `namespace { … }` block on SQLite, so the only bucket the
+*   lowering ever sees there is `__unspecified__`.
+*
+* Returns `undefined` for targets / bucket names with no explicit
+* namespaceId to assign — callers leave the model's `namespaceId`
+* slot empty (which means the late-bound default at the `StorageTable`
+* layer; emitted JSON omits the field).
+*/
+function resolveNamespaceIdForSqlTarget(input) {
+	if (input.targetId !== "postgres") return;
+	if (input.bucketName === UNSPECIFIED_PSL_NAMESPACE_NAME) return "public";
+	if (input.bucketName === "unbound") return UNBOUND_NAMESPACE_ID;
+	return input.bucketName;
+}
+/**
+* A namespace block is the unbound block when its name RESOLVES to the
+* unbound id — both the `namespace unbound { }` spelling (mapped by
+* {@link resolveNamespaceIdForSqlTarget}) and the raw sentinel spelling
+* `namespace __unbound__ { }` (passed through verbatim) behave identically:
+* same models-sibling restriction, same block-lowering bucket.
+*/
+function isUnboundNamespaceBlock(ns, targetId) {
+	return resolveNamespaceIdForSqlTarget({
+		bucketName: ns.name,
+		targetId
+	}) === UNBOUND_NAMESPACE_ID;
+}
+function validateNamespaceBlocksForSqlTarget(input) {
+	if (input.targetId === "sqlite") {
+		for (const namespace of input.namespaces) input.diagnostics.push({
+			code: "PSL_UNSUPPORTED_NAMESPACE_BLOCK",
+			message: `SQLite does not support \`namespace ${namespace.name} { … }\` blocks (SQLite has no schema concept; declare models at the document top level instead).`,
+			sourceId: input.sourceId,
+			span: nodePslSpan(namespace.node.syntax, input.sourceFile)
+		});
+		return;
+	}
+	if (input.targetId === "postgres") {
+		const unboundBlock = input.namespaces.find((ns) => isUnboundNamespaceBlock(ns, input.targetId) && Object.keys(ns.models).length > 0);
+		const hasSibling = input.namespaces.some((ns) => !isUnboundNamespaceBlock(ns, input.targetId));
+		if (unboundBlock !== void 0 && hasSibling) input.diagnostics.push({
+			code: "PSL_RESERVED_NAMESPACE_NAME",
+			message: "Namespace \"unbound\" is reserved for the late-binding sentinel mapping; a `namespace unbound { … }` containing models cannot appear alongside other named namespace blocks. Use `namespace unbound { … }` alone (no sibling named namespaces) for late-binding multi-tenant contracts.",
+			sourceId: input.sourceId,
+			span: nodePslSpan(unboundBlock.node.syntax, input.sourceFile)
+		});
+	}
+}
+/**
+* Walks the flat `entityTypes` namespace tree in `authoringContributions` and
+* returns a map from discriminator string to the matching descriptor. The
+* interpreter uses this to dispatch parsed extension blocks to their factory
+* without naming any specific discriminator value (generic, by-discriminator).
+*/
+function buildEntityTypesByDiscriminator(contributions) {
+	const result = /* @__PURE__ */ new Map();
+	const namespace = contributions?.entityTypes;
+	if (namespace === void 0) return result;
+	const walk = (node) => {
+		for (const value of Object.values(node)) if (isAuthoringEntityTypeDescriptor(value)) result.set(value.discriminator, value);
+		else if (typeof value === "object" && value !== null) walk(value);
+	};
+	walk(namespace);
+	return result;
+}
+/**
+* The `PSL_DUPLICATE_ATTRIBUTE` diagnostic for a model attribute declared
+* more than once on one model. Shared by the built-in `@@control` path and
+* the contributed-model-attribute path so the code and wording stay in one
+* place. `name` is the bare attribute name (`control`, `rls`, …).
+*/
+function duplicateModelAttributeDiagnostic(input) {
+	return {
+		code: "PSL_DUPLICATE_ATTRIBUTE",
+		message: `\`@@${input.name}\` declared more than once on model "${input.modelName}".`,
+		sourceId: input.sourceId,
+		...ifDefined("span", input.span)
+	};
+}
+/**
+* Enforces `AuthoringPslBlockDescriptor.requiresModelAttribute` over one
+* scope (the top level or one namespace): every block whose descriptor
+* declares the requirement must name a model that carries the required
+* bare `@@` attribute. Runs on the parsed symbol table, so it is
+* independent of block/model declaration order and of lowering order. A
+* missing parameter or an unresolvable model is skipped — the
+* missing-required-parameter and unresolved-ref diagnostics own those
+* failure modes.
+*/
+function validateBlockModelAttributeRequirements(input) {
+	for (const scope of input.scopes) for (const blockSymbol of Object.values(scope.blocks)) {
+		const requirement = findBlockDescriptor(input.pslBlockDescriptors, blockSymbol.keyword)?.requiresModelAttribute;
+		if (requirement === void 0) continue;
+		const captured = blockSymbol.block.parameters[requirement.parameter];
+		if (captured?.kind !== "ref") continue;
+		const model = scope.models[captured.identifier];
+		if (model === void 0) continue;
+		if (model.attributes.some((attribute) => attribute.name === requirement.attribute)) continue;
+		input.diagnostics.push({
+			code: "PSL_EXTENSION_TARGET_MODEL_MISSING_ATTRIBUTE",
+			message: `\`${blockSymbol.keyword}\` block "${blockSymbol.block.name}" targets model "${captured.identifier}", which does not declare \`@@${requirement.attribute}\`. Add \`@@${requirement.attribute}\` to model "${captured.identifier}".`,
+			sourceId: input.sourceId,
+			span: captured.span
+		});
+	}
+}
+/**
+* Walks the flat `modelAttributes` namespace tree in `authoringContributions`
+* and returns a map from bare `@@` attribute name to the matching
+* descriptor. The model-attribute loop in `buildModelNodeFromPsl` uses this
+* to dispatch a contributed attribute without naming any specific attribute.
+*/
+function buildModelAttributesByName(contributions) {
+	const result = /* @__PURE__ */ new Map();
+	const namespace = contributions?.modelAttributes;
+	if (namespace === void 0) return result;
+	const walk = (node) => {
+		for (const value of Object.values(node)) if (isAuthoringModelAttributeDescriptor(value)) result.set(value.attribute, value);
+		else if (typeof value === "object" && value !== null) walk(value);
+	};
+	walk(namespace);
+	return result;
+}
+/**
+* For a single lexical scope (a named PSL namespace, or the document top
+* level), lowers all extension blocks into IR entities via the registered
+* factory for each block's discriminator. Groups results by discriminator
+* (the entries key — one-string rule: discriminator === entries key).
+*
+* This pass is intentionally generic: no discriminator value is named here.
+* The factory (registered by the target pack) owns all block-specific logic.
+* A descriptor's factory output may also opt into value-set derivation via
+* the SQL family's `SqlValueSetDerivingEntityTypeOutput.deriveValueSet` hook
+* (probed by {@link deriveValueSetFromEntity}) — when present, the derived
+* value-set is folded into the namespace's `valueSet` slot (keyed by block
+* name), so a value-set-carrying pack entity (e.g. Postgres `native_enum`)
+* contributes the value-set that drives value-set → codec typing without
+* this pass inspecting a target-specific shape.
+*
+* The `namespaceId` is attached to the block before the factory call so the
+* factory can record the namespace coordinate without the interpreter
+* containing any target-specific knowledge about how namespace ids are used.
+*
+* Ref conversion is this pass's job, over typed data: each block-descriptor
+* parameter declared `{ kind: 'ref', refKind: 'model' }` (same-namespace
+* scope) is resolved to the referenced model's storage table name and
+* attached to the block as `resolvedModelRefs` ({@link ResolvedPslModelRefs})
+* before the factory runs — the factory consumes a resolved coordinate and
+* never looks a model up itself. A required model ref that is missing or
+* does not resolve is this pass's diagnostic; the factory is skipped.
+*/
+function lowerExtensionBlocksForNamespace(blocks, nsId, entityTypesByDiscriminator, entityContext, pslBlockDescriptors, resolveModelTable) {
+	const blockSymbols = Object.values(blocks);
+	if (blockSymbols.length === 0) return {};
+	const result = {};
+	for (const blockSymbol of blockSymbols) {
+		const block = blockSymbol.block;
+		const descriptor = entityTypesByDiscriminator.get(block.kind);
+		if (descriptor === void 0) continue;
+		const blockDescriptor = findBlockDescriptor(pslBlockDescriptors, block.keyword);
+		let unresolvedRef = false;
+		let resolvedModelRefs;
+		for (const [paramName, paramDecl] of Object.entries(blockDescriptor?.parameters ?? {})) {
+			if (paramDecl.kind !== "ref" || paramDecl.refKind !== "model" || paramDecl.scope !== "same-namespace") continue;
+			const captured = block.parameters[paramName];
+			if (captured?.kind !== "ref") {
+				if (paramDecl.required === true) {
+					entityContext.diagnostics?.push({
+						code: "PSL_EXTENSION_MODEL_REF_UNRESOLVED",
+						message: `\`${block.keyword}\` block "${block.name}" is missing the required \`${paramName}\` model reference.`,
+						sourceId: entityContext.sourceId ?? "unknown",
+						span: block.span
+					});
+					unresolvedRef = true;
+				}
+				continue;
+			}
+			const tableName = resolveModelTable(captured.identifier);
+			if (tableName === void 0) {
+				entityContext.diagnostics?.push({
+					code: "PSL_EXTENSION_MODEL_REF_UNRESOLVED",
+					message: `\`${block.keyword}\` block "${block.name}" references model "${captured.identifier}" in \`${paramName}\`, which is not declared in the same namespace. Declare the model or fix the reference.`,
+					sourceId: entityContext.sourceId ?? "unknown",
+					span: captured.span
+				});
+				unresolvedRef = true;
+				continue;
+			}
+			resolvedModelRefs = {
+				...resolvedModelRefs ?? {},
+				[paramName]: { tableName }
+			};
+		}
+		if (unresolvedRef) continue;
+		const annotatedBlock = {
+			...block,
+			namespaceId: nsId,
+			...resolvedModelRefs !== void 0 ? { resolvedModelRefs } : {}
+		};
+		const entity = instantiateAuthoringEntityType(descriptor.discriminator, descriptor, [annotatedBlock], entityContext);
+		if (entity === void 0) continue;
+		const entriesKey = descriptor.discriminator;
+		const slot = result[entriesKey] ?? {};
+		result[entriesKey] = slot;
+		slot[block.name] = entity;
+		const derivedValueSet = deriveValueSetFromEntity(descriptor.output, entity);
+		if (derivedValueSet !== void 0) {
+			const valueSetSlot = result["valueSet"] ?? {};
+			result["valueSet"] = valueSetSlot;
+			valueSetSlot[block.name] = derivedValueSet;
+		}
+	}
+	return result;
+}
+function processEnumDeclarations(input) {
+	const enumHandles = {};
+	const enumTypeDescriptors = /* @__PURE__ */ new Map();
+	if (input.enumBlocks.length === 0) return {
+		enumHandles,
+		enumTypeDescriptors
+	};
+	const enumDescriptor = getAuthoringEntity(input.authoringContributions, ["enum"]);
+	if (!enumDescriptor) {
+		for (const decl of input.enumBlocks) input.diagnostics.push({
+			code: "PSL_ENUM_MISSING_FACTORY",
+			message: `enum "${decl.name}" requires an "enum" entityType factory in the active authoring contributions`,
+			sourceId: input.sourceId,
+			span: decl.span
+		});
+		return {
+			enumHandles,
+			enumTypeDescriptors
+		};
+	}
+	for (const decl of input.enumBlocks) {
+		const handle = instantiateAuthoringEntityType("enum", enumDescriptor, [decl], input.entityContext);
+		if (handle === void 0 || handle === null) continue;
+		enumHandles[decl.name] = handle;
+		enumTypeDescriptors.set(decl.name, {
+			codecId: handle.codecId,
+			nativeType: handle.nativeType
+		});
+	}
+	return {
+		enumHandles,
+		enumTypeDescriptors
+	};
+}
+/** Generic top-level blocks are supported only when a composed descriptor claims their keyword. */
+function composedBlockKeywords(authoringContributions) {
+	const keywords = /* @__PURE__ */ new Set();
+	const descriptors = authoringContributions?.pslBlockDescriptors ?? {};
+	for (const [keyword, value] of Object.entries(descriptors)) if (isAuthoringPslBlockDescriptor(value)) keywords.add(keyword);
+	return keywords;
+}
+/**
+* The owning side of a relation is the one that declares `fields`/`references` on its
+* `@relation` attribute — those name the FK columns. A singular model-typed field whose
+* `@relation` carries only a name (or nothing at all) is the back side: infer prints exactly
+* that shape for a 1:1 back-relation whenever the FK needs disambiguating (two FKs between the
+* same table pair, or a self-referencing unique FK). Checking for the attribute's mere presence
+* would misclassify that back side as the owning side.
+*/
+function relationAttributeDeclaresOwningSide(relationAttribute) {
+	return getNamedArgument(relationAttribute, "fields") !== void 0 || getNamedArgument(relationAttribute, "references") !== void 0;
+}
+function buildModelNodeFromPsl(input) {
+	const { model, mapping, sourceId, diagnostics } = input;
+	const tableName = mapping.tableName;
+	const modelNamespaceId = input.modelNamespaceIds.get(model.name);
+	const namespaceExtensionEntitiesForModel = modelNamespaceId !== void 0 ? input.namespaceExtensionEntities?.get(modelNamespaceId) : void 0;
+	const resolvedFields = collectResolvedFields({
+		model,
+		mapping,
+		enumTypeDescriptors: input.enumTypeDescriptors,
+		namedTypeDescriptors: input.namedTypeDescriptors,
+		modelNames: input.modelNames,
+		compositeTypeNames: input.compositeTypeNames,
+		composedExtensions: input.composedExtensions,
+		authoringContributions: input.authoringContributions,
+		familyId: input.familyId,
+		targetId: input.targetId,
+		defaultFunctionRegistry: input.defaultFunctionRegistry,
+		generatorDescriptorById: input.generatorDescriptorById,
+		diagnostics,
+		sourceId,
+		sourceFile: input.sourceFile,
+		scalarColumnDescriptors: input.scalarColumnDescriptors,
+		...ifDefined("enumHandles", input.enumHandles),
+		capabilities: input.capabilities,
+		...ifDefined("namespaceId", modelNamespaceId),
+		...ifDefined("namespaceExtensionEntities", namespaceExtensionEntitiesForModel),
+		...ifDefined("codecLookup", input.codecLookup)
+	});
+	const inlineIdFields = resolvedFields.filter((field) => field.isId);
+	if (inlineIdFields.length > 1) diagnostics.push({
+		code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+		message: `Model "${model.name}" cannot declare inline @id on multiple fields; use model-level @@id([...]) for composite identity`,
+		sourceId,
+		span: model.span
+	});
+	const singleInlineIdField = inlineIdFields.length === 1 ? inlineIdFields[0] : void 0;
+	let primaryKey = singleInlineIdField ? {
+		columns: [singleInlineIdField.columnName],
+		...ifDefined("name", singleInlineIdField.idName)
+	} : void 0;
+	const hasInlinePrimaryKey = primaryKey !== void 0;
+	let blockPrimaryKeyDeclared = false;
+	let controlPolicyDeclared = false;
+	let controlPolicy;
+	const declaredContributedModelAttributes = /* @__PURE__ */ new Set();
+	const modelAttributeEntities = {};
+	const resultBackrelationCandidates = [];
+	for (const field of Object.values(model.fields)) {
+		if (!input.modelNames.has(field.typeName)) continue;
+		const relationAttribute = getAttribute(field.attributes, "relation");
+		if (!field.list && relationAttribute && relationAttributeDeclaresOwningSide(relationAttribute)) continue;
+		const attributesValid = validateBackrelationFieldAttributes({
+			modelName: model.name,
+			field,
+			sourceId,
+			composedExtensions: input.composedExtensions,
+			authoringContributions: input.authoringContributions,
+			diagnostics,
+			familyId: input.familyId,
+			targetId: input.targetId
+		});
+		let relationName;
+		if (relationAttribute) {
+			const parsedRelation = interpretRelationAttribute({
+				selfModel: model,
+				field,
+				symbols: input.symbolTable,
+				sourceFile: input.sourceFile,
+				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 || parsedRelation.index !== void 0) {
+				diagnostics.push({
+					code: "PSL_INVALID_RELATION_ATTRIBUTE",
+					message: `Backrelation list field "${model.name}.${field.name}" cannot declare onDelete/onUpdate/index; define them on the FK-side relation field`,
+					sourceId,
+					span: relationAttribute.span
+				});
+				continue;
+			}
+			relationName = parsedRelation.name;
+		}
+		if (!attributesValid) continue;
+		resultBackrelationCandidates.push({
+			modelName: model.name,
+			tableName,
+			field,
+			targetModelName: field.typeName,
+			isList: field.list,
+			...ifDefined("relationName", relationName)
+		});
+	}
+	const relationAttributes = Object.values(model.fields).map((field) => ({
+		field,
+		relation: getAttribute(field.attributes, "relation")
+	})).filter((entry) => Boolean(entry.relation));
+	const uniqueConstraints = resolvedFields.filter((field) => field.isUnique).map((field) => ({
+		columns: [field.columnName],
+		...ifDefined("name", field.uniqueName)
+	}));
+	const indexNodes = [];
+	const foreignKeyNodes = [];
+	const modelAttributeNodes = Array.from(model.node.attributes());
+	for (const [attributeIndex, modelAttribute] of model.attributes.entries()) {
+		if (modelAttribute.name === "map") continue;
+		if (modelAttribute.name === "discriminator" || modelAttribute.name === "base") continue;
+		if (modelAttribute.name === "control") {
+			if (controlPolicyDeclared) {
+				diagnostics.push(duplicateModelAttributeDiagnostic({
+					name: "control",
+					modelName: model.name,
+					sourceId,
+					span: modelAttribute.span
+				}));
+				continue;
+			}
+			controlPolicyDeclared = true;
+			const node = modelAttributeNodes[attributeIndex];
+			if (node === void 0) continue;
+			const parsed = interpretModelAttribute({
+				node,
+				spec: controlModelSpec,
+				model,
+				sourceFile: input.sourceFile,
+				sourceId,
+				diagnostics
+			});
+			if (parsed !== void 0) controlPolicy = parsed.policy;
+			continue;
+		}
+		const attributeLabel = `Model "${model.name}" @@${modelAttribute.name}`;
+		if (modelAttribute.name === "id") {
+			if (blockPrimaryKeyDeclared) {
+				diagnostics.push({
+					code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+					message: `Model "${model.name}" declares @@id more than once`,
+					sourceId,
+					span: modelAttribute.span
+				});
+				continue;
+			}
+			if (hasInlinePrimaryKey) {
+				diagnostics.push({
+					code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+					message: `Model "${model.name}" cannot declare both field-level @id and model-level @@id`,
+					sourceId,
+					span: modelAttribute.span
+				});
+				blockPrimaryKeyDeclared = true;
+				continue;
+			}
+			const node = modelAttributeNodes[attributeIndex];
+			if (node === void 0) continue;
+			const parsed = interpretModelAttribute({
+				node,
+				spec: idModelSpec,
+				model,
+				sourceFile: input.sourceFile,
+				sourceId,
+				diagnostics
+			});
+			if (parsed === void 0) continue;
+			const fieldNames = parsed.fields;
+			const nullableFieldName = fieldNames.find((name) => model.fields[name]?.optional === true);
+			if (nullableFieldName !== void 0) {
+				diagnostics.push({
+					code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+					message: `${attributeLabel} cannot include optional field "${nullableFieldName}"; primary key columns must be NOT NULL`,
+					sourceId,
+					span: modelAttribute.span
+				});
+				continue;
+			}
+			const columnNames = mapFieldNamesToColumns({
+				modelName: model.name,
+				fieldNames,
+				mapping,
+				sourceId,
+				diagnostics,
+				span: modelAttribute.span,
+				entityLabel: attributeLabel
+			});
+			if (!columnNames) continue;
+			primaryKey = {
+				columns: columnNames,
+				...ifDefined("name", parsed.map)
+			};
+			blockPrimaryKeyDeclared = true;
+			continue;
+		}
+		if (modelAttribute.name === "unique") {
+			const node = modelAttributeNodes[attributeIndex];
+			if (node === void 0) continue;
+			const parsed = interpretModelAttribute({
+				node,
+				spec: uniqueModelSpec,
+				model,
+				sourceFile: input.sourceFile,
+				sourceId,
+				diagnostics
+			});
+			if (parsed === void 0) continue;
+			const columnNames = mapFieldNamesToColumns({
+				modelName: model.name,
+				fieldNames: parsed.fields,
+				mapping,
+				sourceId,
+				diagnostics,
+				span: modelAttribute.span,
+				entityLabel: attributeLabel
+			});
+			if (!columnNames) continue;
+			uniqueConstraints.push({
+				columns: columnNames,
+				...ifDefined("name", parsed.map)
+			});
+			continue;
+		}
+		if (modelAttribute.name === "index") {
+			const node = modelAttributeNodes[attributeIndex];
+			if (node === void 0) continue;
+			const parsed = interpretModelAttribute({
+				node,
+				spec: indexModelSpec,
+				model,
+				sourceFile: input.sourceFile,
+				sourceId,
+				diagnostics
+			});
+			if (parsed === void 0) continue;
+			let columnNames;
+			if (parsed.fields !== void 0) {
+				const mapped = mapFieldNamesToColumns({
+					modelName: model.name,
+					fieldNames: parsed.fields,
+					mapping,
+					sourceId,
+					diagnostics,
+					span: modelAttribute.span,
+					entityLabel: attributeLabel
+				});
+				if (!mapped) continue;
+				columnNames = mapped;
+			}
+			indexNodes.push(blindCast({
+				...ifDefined("columns", columnNames),
+				...ifDefined("expression", parsed.expression),
+				where: parsed.where,
+				unique: parsed.unique,
+				name: parsed.name,
+				map: parsed.map,
+				type: parsed.type,
+				options: parsed.options
+			}));
+			continue;
+		}
+		const contributedModelAttribute = input.modelAttributesByName.get(modelAttribute.name);
+		if (contributedModelAttribute !== void 0) {
+			if (declaredContributedModelAttributes.has(modelAttribute.name)) {
+				diagnostics.push(duplicateModelAttributeDiagnostic({
+					name: modelAttribute.name,
+					modelName: model.name,
+					sourceId,
+					span: modelAttribute.span
+				}));
+				continue;
+			}
+			declaredContributedModelAttributes.add(modelAttribute.name);
+			const node = modelAttributeNodes[attributeIndex];
+			if (node === void 0) continue;
+			const parsed = interpretModelAttribute({
+				node,
+				spec: blindCast(contributedModelAttribute.spec),
+				model,
+				sourceFile: input.sourceFile,
+				sourceId,
+				diagnostics
+			});
+			if (parsed === void 0) continue;
+			const lowered = blindCast(contributedModelAttribute.lower)(parsed, {
+				family: input.familyId,
+				target: input.targetId,
+				modelName: model.name,
+				storageName: tableName,
+				namespaceId: modelNamespaceId ?? input.defaultNamespaceId,
+				sourceId,
+				diagnostics: { push: (d) => {
+					diagnostics.push(blindCast(d));
+				} }
+			});
+			if (lowered === void 0) continue;
+			const slot = modelAttributeEntities[contributedModelAttribute.attribute] ?? {};
+			modelAttributeEntities[contributedModelAttribute.attribute] = slot;
+			slot[lowered.key] = lowered.entity;
+			continue;
+		}
+		const uncomposedNamespace = checkUncomposedNamespace(modelAttribute.name, input.composedExtensions, {
+			familyId: input.familyId,
+			targetId: input.targetId,
+			authoringContributions: input.authoringContributions
+		});
+		if (uncomposedNamespace) {
+			reportUncomposedNamespace({
+				subjectLabel: `Attribute "@@${modelAttribute.name}"`,
+				namespace: uncomposedNamespace,
+				sourceId,
+				span: modelAttribute.span,
+				diagnostics
+			});
+			continue;
+		}
+		diagnostics.push({
+			code: "PSL_UNSUPPORTED_MODEL_ATTRIBUTE",
+			message: `Model "${model.name}" uses unsupported attribute "@@${modelAttribute.name}"`,
+			sourceId,
+			span: modelAttribute.span
+		});
+	}
+	const resultFkRelationMetadata = [];
+	const resultCrossSpaceRelations = [];
+	for (const relationAttribute of relationAttributes) {
+		const { typeName: fieldTypeName, typeNamespaceId: fieldTypeNamespaceId, typeContractSpaceId: fieldTypeContractSpaceId } = relationAttribute.field;
+		if (relationAttribute.field.list) {
+			if (fieldTypeContractSpaceId !== void 0) diagnostics.push({
+				code: "PSL_UNSUPPORTED_CROSS_SPACE_LIST",
+				message: `Relation field "${model.name}.${relationAttribute.field.name}" is a cross-space list relation (type "${fieldTypeContractSpaceId}:${fieldTypeNamespaceId !== void 0 ? `${fieldTypeNamespaceId}.` : ""}${fieldTypeName}[]"). Cross-space relations must be singular in v0.1 — list cross-space relations are not supported.`,
+				sourceId,
+				span: relationAttribute.field.span
+			});
+			continue;
+		}
+		if (!relationAttributeDeclaresOwningSide(relationAttribute.relation)) continue;
+		if (fieldTypeContractSpaceId !== void 0) {
+			const extContractForSpace = input.composedExtensionContracts.get(fieldTypeContractSpaceId);
+			if (extContractForSpace === void 0) {
+				diagnostics.push({
+					code: "PSL_UNKNOWN_CONTRACT_SPACE",
+					message: `Relation field "${model.name}.${relationAttribute.field.name}" references contract space "${fieldTypeContractSpaceId}" which is not declared in extensions. Add "${fieldTypeContractSpaceId}" to extensions in prisma-next.config.ts.`,
+					sourceId,
+					span: relationAttribute.field.span,
+					data: {
+						space: fieldTypeContractSpaceId,
+						suggestedPack: fieldTypeContractSpaceId
+					}
+				});
+				continue;
+			}
+			const parsedRelation = interpretRelationAttribute({
+				selfModel: model,
+				field: relationAttribute.field,
+				symbols: input.symbolTable,
+				sourceFile: input.sourceFile,
+				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 localColumns = mapFieldNamesToColumns({
+				modelName: model.name,
+				fieldNames: parsedRelation.fields,
+				mapping,
+				sourceId,
+				diagnostics,
+				span: relationAttribute.relation.span,
+				entityLabel: `Relation field "${model.name}.${relationAttribute.field.name}"`
+			});
+			if (!localColumns) continue;
+			const referencedColumns = parsedRelation.references;
+			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(parsedRelation.onDelete) : void 0;
+			const onUpdate = parsedRelation.onUpdate ? normalizeReferentialAction(parsedRelation.onUpdate) : void 0;
+			const crossTargetNamespaceId = fieldTypeNamespaceId ?? "__unbound__";
+			const extContract = extContractForSpace;
+			const resolvedTable = extContract.domain.namespaces[crossTargetNamespaceId]?.models[fieldTypeName]?.storage["table"];
+			if (typeof resolvedTable !== "string") {
+				const availableModels = Object.keys(extContract.domain.namespaces[crossTargetNamespaceId]?.models ?? {}).join(", ") || "(none)";
+				diagnostics.push({
+					code: "PSL_UNKNOWN_CROSS_SPACE_TARGET",
+					message: `Relation field "${model.name}.${relationAttribute.field.name}" references model "${fieldTypeName}" in namespace "${crossTargetNamespaceId}" of space "${fieldTypeContractSpaceId}", but that model was not found in the extension contract. Available models: ${availableModels}`,
+					sourceId,
+					span: relationAttribute.field.span,
+					data: {
+						space: fieldTypeContractSpaceId,
+						namespace: crossTargetNamespaceId,
+						model: fieldTypeName
+					}
+				});
+				continue;
+			}
+			const crossTargetTableName = resolvedTable;
+			foreignKeyNodes.push({
+				columns: localColumns,
+				references: {
+					model: fieldTypeName,
+					table: crossTargetTableName,
+					columns: referencedColumns,
+					namespaceId: crossTargetNamespaceId,
+					spaceId: fieldTypeContractSpaceId
+				},
+				...ifDefined("name", parsedRelation.map),
+				...ifDefined("onDelete", onDelete),
+				...ifDefined("onUpdate", onUpdate),
+				...ifDefined("index", parsedRelation.index)
+			});
+			resultCrossSpaceRelations.push({
+				fieldName: relationAttribute.field.name,
+				toModel: fieldTypeName,
+				toTable: crossTargetTableName,
+				cardinality: "N:1",
+				spaceId: fieldTypeContractSpaceId,
+				namespaceId: crossTargetNamespaceId,
+				on: {
+					parentTable: tableName,
+					parentColumns: localColumns,
+					childTable: crossTargetTableName,
+					childColumns: referencedColumns
+				}
+			});
+			continue;
+		}
+		const qualifiedTypeName = fieldTypeNamespaceId ? `${fieldTypeNamespaceId}.${fieldTypeName}` : fieldTypeName;
+		if (!input.modelNames.has(fieldTypeName)) {
+			diagnostics.push({
+				code: "PSL_INVALID_RELATION_TARGET",
+				message: `Relation field "${model.name}.${relationAttribute.field.name}" references unknown model "${qualifiedTypeName}"`,
+				sourceId,
+				span: relationAttribute.field.span
+			});
+			continue;
+		}
+		const normalizedQualifier = fieldTypeNamespaceId === void 0 ? void 0 : fieldTypeNamespaceId === "unbound" ? "__unbound__" : fieldTypeNamespaceId;
+		if (normalizedQualifier !== void 0 && !input.modelMappingsByCoordinate.has(modelCoordinateKey(normalizedQualifier, fieldTypeName))) {
+			diagnostics.push({
+				code: "PSL_INVALID_RELATION_TARGET",
+				message: `Relation field "${model.name}.${relationAttribute.field.name}" references unknown model "${qualifiedTypeName}"`,
+				sourceId,
+				span: relationAttribute.field.span
+			});
+			continue;
+		}
+		const parsedRelation = interpretRelationAttribute({
+			selfModel: model,
+			field: relationAttribute.field,
+			symbols: input.symbolTable,
+			sourceFile: input.sourceFile,
+			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 = normalizedQualifier !== void 0 ? input.modelMappingsByCoordinate.get(modelCoordinateKey(normalizedQualifier, fieldTypeName)) : input.modelMappings.get(fieldTypeName);
+		if (!targetMapping) {
+			diagnostics.push({
+				code: "PSL_INVALID_RELATION_TARGET",
+				message: `Relation field "${model.name}.${relationAttribute.field.name}" references unknown model "${qualifiedTypeName}"`,
+				sourceId,
+				span: relationAttribute.field.span
+			});
+			continue;
+		}
+		const localColumns = mapFieldNamesToColumns({
+			modelName: model.name,
+			fieldNames: parsedRelation.fields,
+			mapping,
+			sourceId,
+			diagnostics,
+			span: relationAttribute.relation.span,
+			entityLabel: `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,
+			entityLabel: `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(parsedRelation.onDelete) : void 0;
+		const onUpdate = parsedRelation.onUpdate ? normalizeReferentialAction(parsedRelation.onUpdate) : void 0;
+		const targetNamespaceId = normalizedQualifier !== void 0 ? normalizedQualifier : input.modelNamespaceIds.get(targetMapping.model.name);
+		foreignKeyNodes.push({
+			columns: localColumns,
+			references: {
+				model: targetMapping.model.name,
+				table: targetMapping.tableName,
+				columns: referencedColumns,
+				...ifDefined("namespaceId", targetNamespaceId)
+			},
+			...ifDefined("name", parsedRelation.map),
+			...ifDefined("onDelete", onDelete),
+			...ifDefined("onUpdate", onUpdate),
+			...ifDefined("index", parsedRelation.index)
+		});
+		resultFkRelationMetadata.push({
+			declaringModelName: model.name,
+			declaringFieldName: relationAttribute.field.name,
+			declaringTableName: tableName,
+			...ifDefined("declaringNamespaceId", input.modelNamespaceIds.get(model.name)),
+			targetModelName: targetMapping.model.name,
+			targetTableName: targetMapping.tableName,
+			...ifDefined("targetNamespaceId", targetNamespaceId),
+			...ifDefined("relationName", parsedRelation.name),
+			localColumns,
+			referencedColumns
+		});
+	}
+	return {
+		modelNode: {
+			modelName: model.name,
+			tableName,
+			fields: resolvedFields.map((resolvedField) => {
+				const enumHandle = input.enumHandles?.get(resolvedField.field.typeName);
+				return {
+					fieldName: resolvedField.field.name,
+					columnName: resolvedField.columnName,
+					descriptor: resolvedField.descriptor,
+					nullable: resolvedField.nullable,
+					...resolvedField.many && resolvedField.valueObjectTypeName === void 0 ? { many: true } : {},
+					...ifDefined("default", resolvedField.defaultValue),
+					...ifDefined("executionDefaults", resolvedField.executionDefaults),
+					...ifDefined("enumTypeHandle", enumHandle)
+				};
+			}),
+			...ifDefined("id", primaryKey),
+			...uniqueConstraints.length > 0 ? { uniques: uniqueConstraints } : {},
+			...indexNodes.length > 0 ? { indexes: indexNodes } : {},
+			...foreignKeyNodes.length > 0 ? { foreignKeys: foreignKeyNodes } : {},
+			...ifDefined("control", controlPolicy)
+		},
+		fkRelationMetadata: resultFkRelationMetadata,
+		crossSpaceRelations: resultCrossSpaceRelations,
+		backrelationCandidates: resultBackrelationCandidates,
+		resolvedFields,
+		modelAttributeEntities
+	};
+}
+function buildValueObjects(input) {
+	const { compositeTypes, enumTypeDescriptors, namedTypeDescriptors, scalarColumnDescriptors, composedExtensions, familyId, targetId, authoringContributions, diagnostics, sourceId } = input;
+	const valueObjects = {};
+	const compositeTypeNames = new Set(compositeTypes.map((ct) => ct.name));
+	for (const compositeType of compositeTypes) {
+		const fields = {};
+		for (const field of Object.values(compositeType.fields)) {
+			if (compositeTypeNames.has(field.typeName)) {
+				const result = {
+					type: {
+						kind: "valueObject",
+						name: field.typeName
+					},
+					nullable: field.optional
+				};
+				fields[field.name] = field.list ? {
+					...result,
+					many: true
+				} : result;
+				continue;
+			}
+			const resolved = resolveFieldTypeDescriptor({
+				field,
+				enumTypeDescriptors,
+				namedTypeDescriptors,
+				scalarColumnDescriptors,
+				authoringContributions,
+				composedExtensions,
+				familyId,
+				targetId,
+				diagnostics,
+				sourceId,
+				entityLabel: `Field "${compositeType.name}.${field.name}"`
+			});
+			if (!resolved.ok) {
+				if (!resolved.alreadyReported) diagnostics.push({
+					code: "PSL_UNSUPPORTED_FIELD_TYPE",
+					message: `Field "${compositeType.name}.${field.name}" type "${field.typeName}" is not supported`,
+					sourceId,
+					span: field.span
+				});
+				continue;
+			}
+			const scalarField = {
+				nullable: field.optional,
+				type: {
+					kind: "scalar",
+					codecId: resolved.descriptor.codecId
+				}
+			};
+			fields[field.name] = field.list ? {
+				...scalarField,
+				many: true
+			} : scalarField;
+		}
+		valueObjects[compositeType.name] = { fields };
+	}
+	return valueObjects;
+}
+function patchModelDomainFields(models, modelResolvedFields) {
+	let patched = models;
+	for (const [modelName, resolvedFields] of modelResolvedFields) {
+		const model = patched[modelName];
+		if (!model) continue;
+		let needsPatch = false;
+		const patchedFields = { ...model.fields };
+		for (const rf of resolvedFields) if (rf.valueObjectTypeName) {
+			needsPatch = true;
+			patchedFields[rf.field.name] = {
+				nullable: rf.field.optional,
+				type: {
+					kind: "valueObject",
+					name: rf.valueObjectTypeName
+				},
+				...rf.many ? { many: true } : {}
+			};
+		} else if (rf.many && rf.scalarCodecId) {
+			needsPatch = true;
+			patchedFields[rf.field.name] = {
+				nullable: rf.field.optional,
+				type: {
+					kind: "scalar",
+					codecId: rf.scalarCodecId
+				},
+				many: true
+			};
+		}
+		if (needsPatch) patched = {
+			...patched,
+			[modelName]: {
+				...model,
+				fields: patchedFields
+			}
+		};
+	}
+	return patched;
+}
+function collectPolymorphismDeclarations(models, sourceFile, sourceId, diagnostics) {
+	const discriminatorDeclarations = /* @__PURE__ */ new Map();
+	const baseDeclarations = /* @__PURE__ */ new Map();
+	for (const model of models) {
+		const discriminatorNode = findModelAttributeNode(model, "discriminator");
+		if (discriminatorNode !== void 0) {
+			const parsed = interpretModelAttribute({
+				node: discriminatorNode,
+				spec: discriminatorModelSpec,
+				model,
+				sourceFile,
+				sourceId,
+				diagnostics
+			});
+			if (parsed !== void 0) {
+				const span = nodePslSpan(discriminatorNode.syntax, sourceFile);
+				const discField = model.fields[parsed.field];
+				if (discField && discField.typeName !== "String") diagnostics.push({
+					code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+					message: `Discriminator field "${parsed.field}" on model "${model.name}" must be of type String, but is "${discField.typeName}"`,
+					sourceId,
+					span
+				});
+				else discriminatorDeclarations.set(model.name, {
+					fieldName: parsed.field,
+					span
+				});
+			}
+		}
+		const baseNode = findModelAttributeNode(model, "base");
+		if (baseNode !== void 0) {
+			const parsed = interpretModelAttribute({
+				node: baseNode,
+				spec: baseModelSpec,
+				model,
+				sourceFile,
+				sourceId,
+				diagnostics
+			});
+			if (parsed !== void 0) baseDeclarations.set(model.name, {
+				baseName: parsed.base,
+				value: parsed.value,
+				span: nodePslSpan(baseNode.syntax, sourceFile)
+			});
+		}
+	}
+	return {
+		discriminatorDeclarations,
+		baseDeclarations
+	};
+}
+function resolvePolymorphism(models, discriminatorDeclarations, baseDeclarations, modelNames, modelMappings, modelNamespaceIds, defaultNamespaceId, syntheticPkFieldsByVariant, stiBaseFieldsByBase, sourceId, diagnostics) {
+	let patched = models;
+	const coordinateFor = (modelName) => modelCoordinateKey(modelNamespaceIds.get(modelName) ?? defaultNamespaceId, modelName);
+	for (const [baseName, fieldNames] of stiBaseFieldsByBase) {
+		const baseKey = coordinateFor(baseName);
+		const baseModel = patched[baseKey];
+		if (!baseModel || fieldNames.length === 0) continue;
+		patched = {
+			...patched,
+			[baseKey]: stripStorageOnlyDomainFields(baseModel, fieldNames)
+		};
+	}
+	for (const [modelName, decl] of discriminatorDeclarations) {
+		if (baseDeclarations.has(modelName)) {
+			diagnostics.push({
+				code: "PSL_DISCRIMINATOR_AND_BASE",
+				message: `Model "${modelName}" cannot have both @@discriminator and @@base`,
+				sourceId,
+				span: decl.span
+			});
+			continue;
+		}
+		const model = patched[coordinateFor(modelName)];
+		if (!model) continue;
+		const variants = {};
+		const seenValues = /* @__PURE__ */ new Map();
+		for (const [variantName, baseDecl] of baseDeclarations) {
+			if (baseDecl.baseName !== modelName) continue;
+			const existingVariant = seenValues.get(baseDecl.value);
+			if (existingVariant) {
+				diagnostics.push({
+					code: "PSL_DUPLICATE_DISCRIMINATOR_VALUE",
+					message: `Discriminator value "${baseDecl.value}" is used by both "${existingVariant}" and "${variantName}" on base model "${modelName}"`,
+					sourceId,
+					span: baseDecl.span
+				});
+				continue;
+			}
+			seenValues.set(baseDecl.value, variantName);
+			variants[variantName] = { value: baseDecl.value };
+		}
+		if (Object.keys(variants).length === 0) {
+			diagnostics.push({
+				code: "PSL_ORPHANED_DISCRIMINATOR",
+				message: `Model "${modelName}" has @@discriminator but no variant models declare @@base(${modelName}, ...)`,
+				sourceId,
+				span: decl.span
+			});
+			continue;
+		}
+		patched = {
+			...patched,
+			[coordinateFor(modelName)]: {
+				...model,
+				discriminator: { field: decl.fieldName },
+				variants
+			}
+		};
+	}
+	for (const [variantName, baseDecl] of baseDeclarations) {
+		if (!modelNames.has(baseDecl.baseName)) {
+			diagnostics.push({
+				code: "PSL_BASE_TARGET_NOT_FOUND",
+				message: `Model "${variantName}" @@base references non-existent model "${baseDecl.baseName}"`,
+				sourceId,
+				span: baseDecl.span
+			});
+			continue;
+		}
+		if (!discriminatorDeclarations.has(baseDecl.baseName)) {
+			diagnostics.push({
+				code: "PSL_ORPHANED_BASE",
+				message: `Model "${variantName}" declares @@base(${baseDecl.baseName}, ...) but "${baseDecl.baseName}" has no @@discriminator`,
+				sourceId,
+				span: baseDecl.span
+			});
+			continue;
+		}
+		if (discriminatorDeclarations.has(variantName)) continue;
+		const variantModel = patched[coordinateFor(variantName)];
+		if (!variantModel) continue;
+		const baseMapping = modelMappings.get(baseDecl.baseName);
+		const variantMapping = modelMappings.get(variantName);
+		const resolvedTable = variantMapping?.model.attributes.some((attr) => attr.name === "map") ?? false ? variantMapping?.tableName : baseMapping?.tableName;
+		const patchedVariant = {
+			...variantModel,
+			base: crossRef(baseDecl.baseName, modelNamespaceIds.get(baseDecl.baseName) ?? defaultNamespaceId),
+			...resolvedTable ? { storage: {
+				...variantModel.storage,
+				table: resolvedTable
+			} } : {}
+		};
+		patched = {
+			...patched,
+			[coordinateFor(variantName)]: stripStorageOnlyDomainFields(patchedVariant, syntheticPkFieldsByVariant.get(variantName) ?? [])
+		};
+	}
+	return patched;
+}
+/**
+* Multi-table-inheritance variants (`@@base` + their own `@@map`) live in a
+* separate table from their base. The ORM joins that table to the base on the
+* shared primary key (`base.id = variant.id`), so the variant storage table
+* must carry the base PK column even though the variant domain model declares
+* only its own fields. This enriches each MTI variant's `ModelNode` with that
+* link column, a primary key on it, and a FK back to the base table.
+*
+* The link column is reported back per variant in `syntheticPkFieldsByVariant`
+* so the domain-model patch can drop it again — keeping the variant's domain
+* surface thin (its create/read inputs don't gain a redundant `id`) while the
+* storage table stays joinable. Single-table-inheritance variants (no own
+* table) are left untouched.
+*/
+function materializeMtiVariantStorageLinks(modelNodes, baseDeclarations, stiVariantNames) {
+	const nodeByModel = new Map(modelNodes.map((node) => [node.modelName, node]));
+	const syntheticPkFieldsByVariant = /* @__PURE__ */ new Map();
+	return {
+		modelNodes: modelNodes.map((node) => {
+			const baseDecl = baseDeclarations.get(node.modelName);
+			if (!baseDecl) return node;
+			const baseNode = nodeByModel.get(baseDecl.baseName);
+			if (!baseNode) return node;
+			if (stiVariantNames.has(node.modelName)) return node;
+			const basePrimaryKey = baseNode.id;
+			if (!basePrimaryKey || basePrimaryKey.columns.length === 0) return node;
+			const existingColumns = new Set(node.fields.map((field) => field.columnName));
+			const linkFields = [];
+			for (const pkColumn of basePrimaryKey.columns) {
+				if (existingColumns.has(pkColumn)) continue;
+				const baseField = baseNode.fields.find((field) => "descriptor" in field && field.columnName === pkColumn);
+				if (!baseField) continue;
+				linkFields.push({
+					fieldName: baseField.fieldName,
+					columnName: pkColumn,
+					descriptor: baseField.descriptor,
+					nullable: false
+				});
+			}
+			if (linkFields.length === 0) return node;
+			syntheticPkFieldsByVariant.set(node.modelName, linkFields.map((field) => field.fieldName));
+			const foreignKey = {
+				columns: basePrimaryKey.columns,
+				references: {
+					model: baseNode.modelName,
+					table: baseNode.tableName,
+					columns: basePrimaryKey.columns,
+					...ifDefined("namespaceId", baseNode.namespaceId)
+				},
+				constraint: true,
+				index: false,
+				onDelete: "cascade"
+			};
+			return {
+				...node,
+				fields: [...linkFields, ...node.fields],
+				id: { columns: basePrimaryKey.columns },
+				foreignKeys: [...node.foreignKeys ?? [], foreignKey]
+			};
+		}),
+		syntheticPkFieldsByVariant
+	};
+}
+/**
+* Single-table-inheritance variants (`@@base` with no own `@@map`) share the
+* base table: `resolvePolymorphism` points the variant's `storage.table` at the
+* base, and the ORM reads variant-declared fields straight off the base table.
+* For that to validate and round-trip, the base storage table must physically
+* carry every STI variant's declared columns. This enriches the base
+* `ModelNode` with those columns.
+*
+* The materialised columns are always nullable in storage: the base table hosts
+* every variant's rows, so a column a variant declares as required is still
+* NULL on sibling-variant rows. The variant's domain field keeps its declared
+* nullability — required-in-domain / nullable-in-storage is the intended STI
+* shape.
+*
+* Collisions (two variants declaring the same column, or a variant column name
+* clashing with a base column) are resolved skip-if-exists here, mirroring the
+* MTI link guard; surfacing them as diagnostics is tracked separately
+* (TML-2827).
+*/
+function materializeStiVariantStorageColumns(modelNodes, baseDeclarations, stiVariantNames) {
+	if (stiVariantNames.size === 0) return {
+		modelNodes: [...modelNodes],
+		stiBaseFieldsByBase: /* @__PURE__ */ new Map()
+	};
+	const nodeByModel = new Map(modelNodes.map((node) => [node.modelName, node]));
+	const stiColumnsByBase = /* @__PURE__ */ new Map();
+	for (const variantName of stiVariantNames) {
+		const variantNode = nodeByModel.get(variantName);
+		const baseDecl = baseDeclarations.get(variantName);
+		if (!variantNode || !baseDecl) continue;
+		const baseNode = nodeByModel.get(baseDecl.baseName);
+		if (!baseNode) continue;
+		const baseColumns = new Set(baseNode.fields.map((field) => field.columnName));
+		const claimed = stiColumnsByBase.get(baseDecl.baseName) ?? [];
+		const claimedColumns = new Set(claimed.map((field) => field.columnName));
+		for (const field of variantNode.fields) {
+			if (baseColumns.has(field.columnName) || claimedColumns.has(field.columnName)) continue;
+			claimedColumns.add(field.columnName);
+			claimed.push({
+				...field,
+				nullable: true
+			});
+		}
+		stiColumnsByBase.set(baseDecl.baseName, claimed);
+	}
+	const stiBaseFieldsByBase = /* @__PURE__ */ new Map();
+	for (const [baseName, columns] of stiColumnsByBase) stiBaseFieldsByBase.set(baseName, columns.map((field) => field.fieldName));
+	return {
+		modelNodes: modelNodes.map((node) => {
+			if (stiVariantNames.has(node.modelName)) return {
+				...node,
+				sharesBaseTable: true
+			};
+			const stiColumns = stiColumnsByBase.get(node.modelName);
+			if (!stiColumns || stiColumns.length === 0) return node;
+			return {
+				...node,
+				fields: [...node.fields, ...stiColumns]
+			};
+		}),
+		stiBaseFieldsByBase
+	};
+}
+/**
+* Drop the storage-only link fields (added by
+* {@link materializeMtiVariantStorageLinks}) from a variant's domain model, so
+* the domain surface stays thin while the storage table keeps the link column.
+*/
+function stripStorageOnlyDomainFields(model, fieldNames) {
+	if (fieldNames.length === 0) return model;
+	const fields = { ...model.fields };
+	for (const name of fieldNames) delete fields[name];
+	const storage = blindCast(model.storage);
+	const storageFields = { ...storage.fields };
+	for (const name of fieldNames) delete storageFields[name];
+	return {
+		...model,
+		fields,
+		storage: {
+			...storage,
+			fields: storageFields
+		}
+	};
+}
+function interpretPslDocumentToSqlContract(input) {
+	const sourceId = input.sourceId;
+	if (!input.target) return notOk({
+		summary: "PSL to SQL contract interpretation failed",
+		diagnostics: [{
+			code: "PSL_TARGET_CONTEXT_REQUIRED",
+			message: "PSL interpretation requires an explicit target context from composition.",
+			sourceId
+		}]
+	});
+	if (!input.scalarColumnDescriptors) return notOk({
+		summary: "PSL to SQL contract interpretation failed",
+		diagnostics: [{
+			code: "PSL_SCALAR_TYPE_CONTEXT_REQUIRED",
+			message: "PSL interpretation requires composed scalar type descriptors.",
+			sourceId
+		}]
+	});
+	const { topLevel } = input.symbolTable;
+	const sourceFile = input.sourceFile;
+	const namespaceSymbols = Object.values(topLevel.namespaces);
+	const diagnostics = [...input.seedDiagnostics ?? []];
+	validateNamespaceBlocksForSqlTarget({
+		namespaces: namespaceSymbols,
+		targetId: input.target.targetId,
+		sourceId,
+		sourceFile,
+		diagnostics
+	});
+	validateBlockModelAttributeRequirements({
+		scopes: [topLevel, ...namespaceSymbols],
+		pslBlockDescriptors: input.authoringContributions?.pslBlockDescriptors ?? {},
+		sourceId,
+		diagnostics
+	});
+	const models = [];
+	const modelEntries = [];
+	const modelNamespaceIds = /* @__PURE__ */ new Map();
+	const compositeTypes = [];
+	const collectScope = (bucketName, scopeModels, scopeCompositeTypes) => {
+		const resolvedNamespaceId = resolveNamespaceIdForSqlTarget({
+			bucketName,
+			targetId: input.target.targetId
+		});
+		for (const model of scopeModels) {
+			models.push(model);
+			modelEntries.push({
+				model,
+				namespaceId: resolvedNamespaceId
+			});
+			if (resolvedNamespaceId !== void 0) modelNamespaceIds.set(model.name, resolvedNamespaceId);
+		}
+		for (const compositeType of scopeCompositeTypes) compositeTypes.push(compositeType);
+	};
+	collectScope(UNSPECIFIED_PSL_NAMESPACE_NAME, Object.values(topLevel.models), Object.values(topLevel.compositeTypes));
+	for (const namespace of namespaceSymbols) collectScope(namespace.name, Object.values(namespace.models), Object.values(namespace.compositeTypes));
+	const defaultNamespaceId = input.target.defaultNamespaceId;
+	const modelNames = new Set(models.map((model) => model.name));
+	const compositeTypeNames = new Set(compositeTypes.map((ct) => ct.name));
+	const composedExtensions = new Set(input.composedExtensions ?? []);
+	const composedExtensionContracts = input.composedExtensionContracts;
+	const defaultFunctionRegistry = input.controlMutationDefaults?.defaultFunctionRegistry ?? /* @__PURE__ */ new Map();
+	const generatorDescriptors = input.controlMutationDefaults?.generatorDescriptors ?? [];
+	const generatorDescriptorById = /* @__PURE__ */ new Map();
+	for (const descriptor of generatorDescriptors) generatorDescriptorById.set(descriptor.id, descriptor);
+	const isEnumBlock = (block) => block.keyword === "enum";
+	const legitimateBlockKeywords = composedBlockKeywords(input.authoringContributions);
+	const reportUnsupportedTopLevelBlock = (block) => {
+		diagnostics.push({
+			code: "PSL_UNSUPPORTED_TOP_LEVEL_BLOCK",
+			message: `Unsupported top-level block "${block.keyword}"`,
+			sourceId,
+			span: keywordPslSpan(block.node.syntax, block.keyword, sourceFile)
+		});
+	};
+	const topLevelEnums = [];
+	const topLevelExtensionBlocks = {};
+	for (const [blockName, block] of Object.entries(topLevel.blocks)) {
+		if (!legitimateBlockKeywords.has(block.keyword)) {
+			reportUnsupportedTopLevelBlock(block);
+			continue;
+		}
+		if (isEnumBlock(block)) topLevelEnums.push(block.block);
+		else topLevelExtensionBlocks[blockName] = block;
+	}
+	for (const namespace of namespaceSymbols) for (const block of Object.values(namespace.blocks)) {
+		if (isEnumBlock(block)) {
+			diagnostics.push({
+				code: "PSL_ENUM_NAMESPACE_NOT_SUPPORTED",
+				message: `enum "${block.name}" inside namespace "${namespace.name}" is not supported; declare enum at the top level`,
+				sourceId,
+				span: nodePslSpan(block.node.syntax, sourceFile)
+			});
+			continue;
+		}
+		if (!legitimateBlockKeywords.has(block.keyword)) reportUnsupportedTopLevelBlock(block);
+	}
+	const enumResult = processEnumDeclarations({
+		enumBlocks: topLevelEnums,
+		sourceId,
+		authoringContributions: input.authoringContributions,
+		entityContext: {
+			family: input.target.familyId,
+			target: input.target.targetId,
+			...ifDefined("codecLookup", input.codecLookup),
+			sourceId,
+			diagnostics: { push: (d) => {
+				diagnostics.push(blindCast(d));
+			} },
+			...ifDefined("enumInferenceCodecs", input.enumInferenceCodecs)
+		},
+		diagnostics
+	});
+	const allEnumTypeDescriptors = new Map(enumResult.enumTypeDescriptors);
+	const validEnumHandles = { ...enumResult.enumHandles };
+	const enumHandlesByName = new Map(Object.entries(validEnumHandles));
+	const entityTypesByDiscriminator = buildEntityTypesByDiscriminator(input.authoringContributions);
+	const modelAttributesByName = buildModelAttributesByName(input.authoringContributions);
+	const authoringWarnings = [];
+	const extensionEntityContext = {
+		family: input.target.familyId,
+		target: input.target.targetId,
+		...ifDefined("enumInferenceCodecs", input.enumInferenceCodecs),
+		...ifDefined("codecLookup", input.codecLookup),
+		sourceId,
+		diagnostics: { push: (d) => {
+			diagnostics.push(blindCast(d));
+		} },
+		warnings: authoringWarnings
+	};
+	const earlyModelMappingsByCoordinate = buildModelMappings(modelEntries, defaultNamespaceId, [], sourceId, sourceFile);
+	const composedPslBlockDescriptors = input.authoringContributions?.pslBlockDescriptors ?? {};
+	const namespaceExtensionEntities = /* @__PURE__ */ new Map();
+	const mergeNamespaceExtensionEntities = (nsId, entities) => {
+		if (Object.keys(entities).length === 0) return;
+		const existing = namespaceExtensionEntities.get(nsId);
+		if (existing === void 0) {
+			namespaceExtensionEntities.set(nsId, entities);
+			return;
+		}
+		const merged = { ...existing };
+		for (const [entriesKey, slot] of Object.entries(entities)) {
+			const existingSlot = existing[entriesKey];
+			if (existingSlot !== void 0) {
+				for (const name of Object.keys(slot)) if (Object.hasOwn(existingSlot, name)) diagnostics.push({
+					code: "PSL_DUPLICATE_EXTENSION_ENTITY",
+					message: `entries slot "${entriesKey}" in namespace "${nsId}": entity "${name}" is declared more than once in the same namespace.`,
+					sourceId
+				});
+			}
+			merged[entriesKey] = {
+				...existingSlot,
+				...slot
+			};
+		}
+		namespaceExtensionEntities.set(nsId, merged);
+	};
+	for (const ns of namespaceSymbols) {
+		if (ns.name === UNSPECIFIED_PSL_NAMESPACE_NAME) continue;
+		const nsId = resolveNamespaceIdForSqlTarget({
+			bucketName: ns.name,
+			targetId: input.target.targetId
+		});
+		if (nsId === void 0) continue;
+		mergeNamespaceExtensionEntities(nsId, lowerExtensionBlocksForNamespace(ns.blocks, nsId, entityTypesByDiscriminator, extensionEntityContext, composedPslBlockDescriptors, (modelName) => earlyModelMappingsByCoordinate.get(modelCoordinateKey(nsId, modelName))?.tableName));
+	}
+	if (Object.keys(topLevelExtensionBlocks).length > 0) {
+		const topLevelNsId = resolveNamespaceIdForSqlTarget({
+			bucketName: UNSPECIFIED_PSL_NAMESPACE_NAME,
+			targetId: input.target.targetId
+		}) ?? defaultNamespaceId;
+		mergeNamespaceExtensionEntities(topLevelNsId, lowerExtensionBlocksForNamespace(topLevelExtensionBlocks, topLevelNsId, entityTypesByDiscriminator, extensionEntityContext, composedPslBlockDescriptors, (modelName) => earlyModelMappingsByCoordinate.get(modelCoordinateKey(topLevelNsId, modelName))?.tableName));
+	}
+	const defaultNsExtensionValueSets = namespaceExtensionEntities.get(defaultNamespaceId)?.["valueSet"];
+	if (defaultNsExtensionValueSets !== void 0) {
+		for (const name of Object.keys(defaultNsExtensionValueSets)) if (Object.hasOwn(validEnumHandles, name)) diagnostics.push({
+			code: "PSL_VALUE_SET_NAME_COLLISION",
+			message: `namespace "${defaultNamespaceId}": name "${name}" is declared both as a domain enum and as an extension entity that derives a value-set; rename one`,
+			sourceId
+		});
+	}
+	const isScalarRefinement = (symbol) => !symbol.isConstructor && symbol.baseType !== void 0 && input.scalarColumnDescriptors.has(symbol.baseType);
+	const allNamedTypes = Object.values(topLevel.namedTypes);
+	const namedTypeResult = resolveNamedTypeDeclarations({
+		declarations: [...allNamedTypes.filter(isScalarRefinement), ...allNamedTypes.filter((symbol) => !isScalarRefinement(symbol))],
+		sourceId,
+		enumTypeDescriptors: allEnumTypeDescriptors,
+		scalarColumnDescriptors: input.scalarColumnDescriptors,
+		composedExtensions,
+		familyId: input.target.familyId,
+		targetId: input.target.targetId,
+		authoringContributions: input.authoringContributions,
+		diagnostics
+	});
+	const storageTypes = { ...namedTypeResult.storageTypes };
+	const modelMappingsByCoordinate = buildModelMappings(modelEntries, defaultNamespaceId, diagnostics, sourceId, sourceFile);
+	const modelMappings = /* @__PURE__ */ new Map();
+	for (const mapping of modelMappingsByCoordinate.values()) modelMappings.set(mapping.model.name, mapping);
+	const modelNodes = [];
+	const fkRelationMetadata = [];
+	const backrelationCandidates = [];
+	const modelResolvedFields = /* @__PURE__ */ new Map();
+	const crossSpaceRelationsByModel = /* @__PURE__ */ new Map();
+	const modelAttributeEntitiesByNamespace = /* @__PURE__ */ new Map();
+	for (const { model, namespaceId } of modelEntries) {
+		const coordinate = modelCoordinateKey(namespaceId ?? defaultNamespaceId, model.name);
+		const mapping = modelMappingsByCoordinate.get(coordinate);
+		if (!mapping) continue;
+		const result = buildModelNodeFromPsl({
+			model,
+			mapping,
+			modelMappings,
+			modelMappingsByCoordinate,
+			modelNames,
+			compositeTypeNames,
+			enumTypeDescriptors: allEnumTypeDescriptors,
+			namedTypeDescriptors: namedTypeResult.namedTypeDescriptors,
+			composedExtensions,
+			composedExtensionContracts,
+			familyId: input.target.familyId,
+			targetId: input.target.targetId,
+			authoringContributions: input.authoringContributions,
+			defaultFunctionRegistry,
+			generatorDescriptorById,
+			scalarColumnDescriptors: input.scalarColumnDescriptors,
+			sourceId,
+			sourceFile,
+			symbolTable: input.symbolTable,
+			diagnostics,
+			modelNamespaceIds,
+			...enumHandlesByName.size > 0 ? { enumHandles: enumHandlesByName } : {},
+			capabilities: input.capabilities,
+			...namespaceExtensionEntities.size > 0 ? { namespaceExtensionEntities } : {},
+			...ifDefined("codecLookup", input.codecLookup),
+			modelAttributesByName,
+			defaultNamespaceId
+		});
+		modelNodes.push(namespaceId !== void 0 ? {
+			...result.modelNode,
+			namespaceId
+		} : result.modelNode);
+		fkRelationMetadata.push(...result.fkRelationMetadata);
+		backrelationCandidates.push(...result.backrelationCandidates);
+		modelResolvedFields.set(coordinate, result.resolvedFields);
+		if (result.crossSpaceRelations.length > 0) {
+			const existing = crossSpaceRelationsByModel.get(model.name) ?? [];
+			crossSpaceRelationsByModel.set(model.name, [...existing, ...result.crossSpaceRelations]);
+		}
+		if (Object.keys(result.modelAttributeEntities).length > 0) {
+			const nsKey = namespaceId ?? defaultNamespaceId;
+			const existingByAttribute = modelAttributeEntitiesByNamespace.get(nsKey) ?? {};
+			for (const [attribute, keyed] of Object.entries(result.modelAttributeEntities)) existingByAttribute[attribute] = {
+				...existingByAttribute[attribute] ?? {},
+				...keyed
+			};
+			modelAttributeEntitiesByNamespace.set(nsKey, existingByAttribute);
+		}
+	}
+	const { modelRelations, fkRelationsByPair, fkRelationsByDeclaringModel } = indexFkRelations({ fkRelationMetadata });
+	const modelIdColumns = /* @__PURE__ */ new Map();
+	const modelUniqueColumnSets = /* @__PURE__ */ new Map();
+	for (const modelNode of modelNodes) {
+		if (modelNode.id) modelIdColumns.set(modelNode.modelName, modelNode.id.columns);
+		const uniqueColumnSets = [];
+		if (modelNode.id) uniqueColumnSets.push(modelNode.id.columns);
+		for (const unique of modelNode.uniques ?? []) uniqueColumnSets.push(unique.columns);
+		modelUniqueColumnSets.set(modelNode.modelName, uniqueColumnSets);
+	}
+	applyBackrelationCandidates({
+		backrelationCandidates,
+		fkRelationsByPair,
+		fkRelationsByDeclaringModel,
+		modelIdColumns,
+		modelUniqueColumnSets,
+		modelRelations,
+		diagnostics,
+		sourceId
+	});
+	for (const [modelName, relations] of crossSpaceRelationsByModel) {
+		const existing = modelRelations.get(modelName);
+		if (existing) existing.push(...relations);
+		else modelRelations.set(modelName, [...relations]);
+	}
+	const { discriminatorDeclarations, baseDeclarations } = collectPolymorphismDeclarations(models, sourceFile, sourceId, diagnostics);
+	const stiVariantNames = /* @__PURE__ */ new Set();
+	for (const variantName of baseDeclarations.keys()) if (!(modelMappings.get(variantName)?.model.attributes.some((attr) => attr.name === "map") ?? false)) stiVariantNames.add(variantName);
+	const { modelNodes: mtiLinkedModelNodes, syntheticPkFieldsByVariant } = materializeMtiVariantStorageLinks(modelNodes, baseDeclarations, stiVariantNames);
+	const { modelNodes: stiColumnModelNodes, stiBaseFieldsByBase } = materializeStiVariantStorageColumns(mtiLinkedModelNodes, baseDeclarations, stiVariantNames);
+	const valueObjects = buildValueObjects({
+		compositeTypes,
+		enumTypeDescriptors: allEnumTypeDescriptors,
+		namedTypeDescriptors: namedTypeResult.namedTypeDescriptors,
+		scalarColumnDescriptors: input.scalarColumnDescriptors,
+		composedExtensions,
+		familyId: input.target.familyId,
+		targetId: input.target.targetId,
+		authoringContributions: input.authoringContributions,
+		diagnostics,
+		sourceId
+	});
+	if (diagnostics.length > 0) return notOk({
+		summary: "PSL to SQL contract interpretation failed",
+		diagnostics
+	});
+	const { createNamespace } = input;
+	const createNamespaceWithExtensions = (nsInput) => {
+		const entities = namespaceExtensionEntities.get(nsInput.id);
+		const attributeEntities = modelAttributeEntitiesByNamespace.get(nsInput.id);
+		if (entities === void 0 && attributeEntities === void 0) return createNamespace(nsInput);
+		if (attributeEntities !== void 0) {
+			for (const slot of Object.keys(attributeEntities)) if (Object.hasOwn(nsInput.entries, slot) || entities !== void 0 && slot in entities) throw contractError("CONTRACT.PACK_CONTRIBUTION_INVALID", `entries slot "${slot}" in namespace "${nsInput.id}" is contributed by both a model attribute and a block/base entry kind. A model-attribute entries key must be unique across the namespace's entry kinds.`, { meta: {
+				slot,
+				namespaceId: nsInput.id
+			} });
+		}
+		const mergedValueSet = {
+			...nsInput.entries["valueSet"],
+			...entities?.["valueSet"]
+		};
+		const extended = {
+			...nsInput,
+			entries: {
+				...nsInput.entries,
+				...entities,
+				...attributeEntities,
+				...Object.keys(mergedValueSet).length > 0 ? { valueSet: mergedValueSet } : {}
+			}
+		};
+		return createNamespace(extended);
+	};
+	const contract = buildSqlContractFromDefinition({
+		target: input.target,
+		warnings: authoringWarnings.length > 0 ? authoringWarnings : void 0,
+		...ifDefined("extensions", buildComposedExtensionPackRefs(input.target, [...composedExtensions].sort(compareStrings), input.composedExtensionPackRefs)),
+		...Object.keys(storageTypes).length > 0 ? { storageTypes } : {},
+		...Object.keys(validEnumHandles).length > 0 ? { enums: validEnumHandles } : {},
+		...namespaceExtensionEntities.size > 0 ? { namespaces: [...namespaceExtensionEntities.keys()] } : {},
+		createNamespace: createNamespaceWithExtensions,
+		models: stiColumnModelNodes.map((model) => ({
+			...model,
+			...modelRelations.has(model.modelName) ? { relations: [...modelRelations.get(model.modelName) ?? []].sort((left, right) => compareStrings(left.fieldName, right.fieldName)) } : {}
+		}))
+	}, input.codecLookup);
+	const modelsForPatch = {};
+	for (const [namespaceId, namespaceSlice] of Object.entries(contract.domain.namespaces)) for (const [modelName, model] of Object.entries(namespaceSlice.models)) {
+		const coordinate = modelCoordinateKey(namespaceId, modelName);
+		invariant(!Object.hasOwn(modelsForPatch, coordinate), `symbol table guarantees coordinate uniqueness; duplicate model "${namespaceId}.${modelName}" reached interpretation`);
+		modelsForPatch[coordinate] = model;
+	}
+	let patchedModels = patchModelDomainFields(modelsForPatch, modelResolvedFields);
+	const polyDiagnostics = [];
+	patchedModels = resolvePolymorphism(patchedModels, discriminatorDeclarations, baseDeclarations, modelNames, modelMappings, modelNamespaceIds, input.target.defaultNamespaceId, syntheticPkFieldsByVariant, stiBaseFieldsByBase, sourceId, polyDiagnostics);
+	if (polyDiagnostics.length > 0) return notOk({
+		summary: "PSL to SQL contract interpretation failed",
+		diagnostics: polyDiagnostics
+	});
+	const variantModelNames = new Set(baseDeclarations.keys());
+	const filteredRoots = Object.fromEntries(Object.entries(contract.roots).filter(([, crossReference]) => !variantModelNames.has(crossReference.model)));
+	return ok({
+		...contract,
+		roots: filteredRoots,
+		domain: { namespaces: Object.fromEntries(Object.entries(contract.domain.namespaces).map(([namespaceId, namespaceSlice]) => [namespaceId, {
+			models: Object.fromEntries(Object.entries(namespaceSlice.models).map(([modelName, model]) => [modelName, patchedModels[modelCoordinateKey(namespaceId, modelName)] ?? model])),
+			...ifDefined("enum", namespaceSlice.enum),
+			...ifDefined("valueObjects", namespaceSlice.valueObjects),
+			...namespaceId === input.target.defaultNamespaceId && Object.keys(valueObjects).length > 0 ? { valueObjects } : {}
+		}])) }
+	});
+}
+//#endregion
+export { interpretPslDocumentToSqlContract as t };
+
+//# sourceMappingURL=interpreter-5WgpL-ax-_nqHLUTr.mjs.map