@prisma/orm-family-sql 8.0.0-rc.2-dev.3 → 8.0.0-rc.20-dev.1

package/dist/interpreter-DyiUUAWh-DYdjIpiE.mjs

@@ -1,3680 +0,0 @@
-import { t as deriveValueSetFromEntity } from "./value-set-derivation-hook-Di9JZ0X7.mjs";
-import { n as buildSqlContractFromDefinition } from "./derived-checks-DFMRmiAu-DGfB8aS4.mjs";
-import { structuredError } from "@prisma/orm-framework/utils/structured-error";
-import { hasRegisteredFieldNamespace, instantiateAuthoringEntityType, instantiateAuthoringFieldPreset, instantiateAuthoringTypeConstructor, isAuthoringEntityTypeDescriptor, isAuthoringFieldPresetDescriptor, isAuthoringModelAttributeDescriptor, isAuthoringPslBlockDescriptor, isAuthoringTypeConstructorDescriptor, validateAuthoringHelperArguments } from "@prisma/orm-framework/components/authoring";
-import { UNBOUND_NAMESPACE_ID } from "@prisma/orm-framework/components/ir";
-import { InternalError } from "@prisma/orm-framework/utils/internal-error";
-import { crossRef } from "@prisma/orm-framework/contract/types";
-import { ifDefined } from "@prisma/orm-framework/utils/defined";
-import { blindCast } from "@prisma/orm-framework/utils/casts";
-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-DyiUUAWh.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 noCheckKindArgument = () => oneOf(identifier("membership"), identifier("elementNotNull"));
-/**
-* `@noCheck` waives generated CHECK constraints on one column: bare for every
-* kind the column's shape derives, or naming concrete kinds. Two optional
-* positional slots cover the whole kind vocabulary; a third argument is
-* necessarily a duplicate and fails as excess arity.
-*/
-const noCheckFieldSpec = fieldAttribute("noCheck", {
-	positional: [{
-		key: "first",
-		type: optional(noCheckKindArgument())
-	}, {
-		key: "second",
-		type: optional(noCheckKindArgument())
-	}],
-	refine: (value, ctx, attributeNode) => {
-		if (value.first !== void 0 && value.first === value.second) return [leafDiagnostic(ctx, attributeNode, "`@noCheck` names the same kind twice")];
-		return [];
-	}
-});
-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 PSL_CHECK_REQUIRES_NAME_OR_MAP = "PSL_CHECK_REQUIRES_NAME_OR_MAP";
-const PSL_CHECK_NAME_XOR_MAP = "PSL_CHECK_NAME_XOR_MAP";
-const PSL_CHECK_EXPRESSION_EMPTY = "PSL_CHECK_EXPRESSION_EMPTY";
-/**
-* A single-table-inheritance variant (`@@base` with no own `@@map`) shares
-* its base model's storage table and has no table of its own to declare a
-* check on — raised from {@link interpretPslDocumentToSqlContract}, not from
-* this spec's own `refine`, because the rule needs the model's `@@base`
-* declaration, which a single attribute's `refine` cannot see.
-*/
-const PSL_CHECK_ON_STI_VARIANT = "PSL_CHECK_ON_STI_VARIANT";
-const checkModelSpec = modelAttribute("check", {
-	named: {
-		expression: str(),
-		name: optional(str()),
-		map: optional(str())
-	},
-	refine: (value, ctx, attributeNode) => {
-		const diagnostics = [];
-		if (value.expression.trim().length === 0) diagnostics.push(leafDiagnostic(ctx, attributeNode, "`@@check` expression must not be empty — an empty predicate is not a constraint", PSL_CHECK_EXPRESSION_EMPTY));
-		if (value.name === void 0 && value.map === void 0) diagnostics.push(leafDiagnostic(ctx, attributeNode, "`@@check` requires a `name` or `map` argument (a default name cannot be derived — a check has no column tuple to name itself after)", PSL_CHECK_REQUIRES_NAME_OR_MAP));
-		if (value.name !== void 0 && value.map !== void 0) diagnostics.push(leafDiagnostic(ctx, attributeNode, "`@@check` takes at most one of `name` and `map`", PSL_CHECK_NAME_XOR_MAP));
-		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.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",
-	"noCheck"
-]);
-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
-	};
-}
-/**
-* Interprets a field's `@noCheck` attribute and resolves it against the
-* column's shape: the bare form becomes every kind the shape derives, and a
-* named kind that can never apply is a spec-validation diagnostic on the
-* attribute node. Returns the concrete kinds in canonical ascending order —
-* the only form the definition tree carries.
-*/
-function lowerNoCheckForField(input) {
-	const node = findFieldAttributeNode(input.field, "noCheck");
-	if (node === void 0) return void 0;
-	const interpreted = interpretFieldAttribute({
-		node,
-		spec: noCheckFieldSpec,
-		model: input.model,
-		field: input.field,
-		sourceFile: input.sourceFile,
-		sourceId: input.sourceId,
-		diagnostics: input.diagnostics
-	});
-	if (interpreted === void 0) return void 0;
-	const span = getAttribute(input.field.attributes, "noCheck")?.span ?? input.field.span;
-	const subject = `Field "${input.model.name}.${input.field.name}"`;
-	const derivable = [];
-	if (input.isListField) derivable.push("elementNotNull");
-	if (input.isDomainEnum) derivable.push("membership");
-	const authored = [interpreted.first, interpreted.second].filter((kind) => kind === "membership" || kind === "elementNotNull");
-	if (authored.length === 0) {
-		if (derivable.length === 0) {
-			input.diagnostics.push({
-				code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
-				message: `${subject} @noCheck waives nothing — this column's shape derives no generated checks`,
-				sourceId: input.sourceId,
-				span
-			});
-			return;
-		}
-		return derivable;
-	}
-	for (const kind of authored) if (!derivable.includes(kind)) {
-		const explanation = kind === "membership" ? "membership checks are derived only from enum value sets" : "element-non-null checks are derived only for list columns";
-		input.diagnostics.push({
-			code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
-			message: `${subject} @noCheck(${kind}) does not apply — ${explanation}`,
-			sourceId: input.sourceId,
-			span
-		});
-		return;
-	}
-	return [...authored].sort();
-}
-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;
-	const declaredControlPolicy = getAttribute(model.attributes, "control")?.args.find((arg) => arg.kind === "positional")?.value.trim();
-	const modelDerivesChecks = declaredControlPolicy === void 0 || declaredControlPolicy === "managed";
-	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;
-		const noCheckKinds = modelDerivesChecks ? lowerNoCheckForField({
-			model,
-			field,
-			sourceFile: input.sourceFile,
-			sourceId,
-			isListField: isListField && !isValueObjectField,
-			isDomainEnum: enumHandle !== void 0,
-			diagnostics
-		}) : void 0;
-		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("noCheck", noCheckKinds),
-			...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 checkNodes = [];
-	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;
-		}
-		if (modelAttribute.name === "check") {
-			const node = modelAttributeNodes[attributeIndex];
-			if (node === void 0) continue;
-			if (input.capabilities["sql"]?.["checkConstraint"] !== true) {
-				diagnostics.push({
-					code: "PSL_CHECK_UNSUPPORTED_TARGET",
-					message: `Model "${model.name}" declares "@@check", but target "${input.targetId}" does not support check constraints (the adapter does not report the "checkConstraint" capability). Remove the check or author it against a target that supports check constraints.`,
-					sourceId,
-					span: modelAttribute.span
-				});
-				continue;
-			}
-			const parsed = interpretModelAttribute({
-				node,
-				spec: checkModelSpec,
-				model,
-				sourceFile: input.sourceFile,
-				sourceId,
-				diagnostics
-			});
-			if (parsed === void 0) continue;
-			checkNodes.push({
-				expression: parsed.expression,
-				name: parsed.name,
-				map: parsed.map
-			});
-			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.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("noCheck", resolvedField.noCheck),
-					...ifDefined("enumTypeHandle", enumHandle)
-				};
-			}),
-			...ifDefined("id", primaryKey),
-			...uniqueConstraints.length > 0 ? { uniques: uniqueConstraints } : {},
-			...indexNodes.length > 0 ? { indexes: indexNodes } : {},
-			...checkNodes.length > 0 ? { checks: checkNodes } : {},
-			...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);
-	for (const variantName of stiVariantNames) {
-		const variantMapping = modelMappings.get(variantName);
-		if (variantMapping === void 0) continue;
-		const baseDecl = baseDeclarations.get(variantName);
-		invariant(baseDecl !== void 0, `stiVariantNames is derived from baseDeclarations.keys(), so "${variantName}" must have a base declaration`);
-		for (const attribute of variantMapping.model.node.attributes()) {
-			if (attribute.name()?.isSimpleName("check") !== true) continue;
-			diagnostics.push({
-				code: PSL_CHECK_ON_STI_VARIANT,
-				message: `Model "${variantName}" declares "@@check", but it shares its base model "${baseDecl.baseName}"'s storage table (single-table inheritance via @@base) and has no table of its own to declare a check constraint on. Declare the check on "${baseDecl.baseName}" instead.`,
-				sourceId,
-				span: nodePslSpan(attribute.syntax, sourceFile)
-			});
-		}
-	}
-	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-DyiUUAWh-DYdjIpiE.mjs.map