@prisma-next/sql-contract-psl 0.12.0-dev.9 → 0.13.0-dev.1

package/dist/{interpreter-QE6eZZof.mjs → interpreter-B_KtZusL.mjs}

@@ -1,8 +1,8 @@
 import { crossRef } from "@prisma-next/contract/types";
 import { hasRegisteredFieldNamespace, instantiateAuthoringEntityType, instantiateAuthoringFieldPreset, instantiateAuthoringTypeConstructor, isAuthoringEntityTypeDescriptor, isAuthoringFieldPresetDescriptor, isAuthoringTypeConstructorDescriptor, validateAuthoringHelperArguments } from "@prisma-next/framework-components/authoring";
-import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
 import { isPostgresEnumStorageEntry } from "@prisma-next/sql-contract/types";
 import { buildSqlContractFromDefinition } from "@prisma-next/sql-contract-ts/contract-builder";
+import { blindCast } from "@prisma-next/utils/casts";
 import { ifDefined } from "@prisma-next/utils/defined";
 import { notOk, ok } from "@prisma-next/utils/result";
 import { getPositionalArgument, parseQuotedStringLiteral } from "@prisma-next/psl-parser";
@@ -279,6 +279,56 @@ function findDuplicateFieldName(fieldNames) {
 		seen.add(name);
 	}
 }
+const CONTROL_POLICY_LITERAL_SET = new Set([
+	"managed",
+	"tolerated",
+	"external",
+	"observed"
+]);
+function isControlPolicyLiteral(value) {
+	return CONTROL_POLICY_LITERAL_SET.has(value);
+}
+function parseControlPolicyAttribute(input) {
+	if (input.attribute.args.filter((arg) => arg.kind === "named").length > 0) {
+		input.diagnostics.push({
+			code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+			message: "`@@control` does not accept named arguments; pass the policy positionally as `@@control(external)`.",
+			sourceId: input.sourceId,
+			span: input.attribute.span
+		});
+		return;
+	}
+	const positionalArgs = getPositionalArguments(input.attribute);
+	if (positionalArgs.length === 0) {
+		input.diagnostics.push({
+			code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+			message: "`@@control` requires exactly one positional argument: `managed`, `tolerated`, `external`, or `observed`.",
+			sourceId: input.sourceId,
+			span: input.attribute.span
+		});
+		return;
+	}
+	if (positionalArgs.length > 1) {
+		input.diagnostics.push({
+			code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+			message: `\`@@control\` accepts exactly one positional argument; got ${positionalArgs.length}.`,
+			sourceId: input.sourceId,
+			span: input.attribute.span
+		});
+		return;
+	}
+	const token = unquoteStringLiteral(positionalArgs[0] ?? "").trim();
+	if (!isControlPolicyLiteral(token)) {
+		input.diagnostics.push({
+			code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+			message: `\`@@control\` argument \`${token}\` is not a known policy. Allowed: \`managed\`, \`tolerated\`, \`external\`, \`observed\`.`,
+			sourceId: input.sourceId,
+			span: input.attribute.span
+		});
+		return;
+	}
+	return token;
+}
 function mapFieldNamesToColumns(input) {
 	const columns = [];
 	for (const fieldName of input.fieldNames) {
@@ -730,7 +780,7 @@ function getAuthoringTypeConstructor(contributions, path) {
 	let current = contributions?.type;
 	for (const segment of path) {
 		if (typeof current !== "object" || current === null || Array.isArray(current)) return;
-		current = current[segment];
+		current = blindCast(current)[segment];
 	}
 	return isAuthoringTypeConstructorDescriptor(current) ? current : void 0;
 }
@@ -749,7 +799,7 @@ function getAuthoringEntity(contributions, path) {
 	let current = contributions?.entityTypes;
 	for (const segment of path) {
 		if (typeof current !== "object" || current === null || Array.isArray(current)) return;
-		current = current[segment];
+		current = blindCast(current)[segment];
 	}
 	return isAuthoringEntityTypeDescriptor(current) ? current : void 0;
 }
@@ -762,7 +812,7 @@ function getAuthoringFieldPreset(contributions, path) {
 	let current = contributions?.field;
 	for (const segment of path) {
 		if (typeof current !== "object" || current === null || Array.isArray(current)) return;
-		current = current[segment];
+		current = blindCast(current)[segment];
 	}
 	return isAuthoringFieldPresetDescriptor(current) ? current : void 0;
 }
@@ -1258,6 +1308,10 @@ function resolveColumnDescriptor(field, enumTypeDescriptors, namedTypeDescriptor
 }
 //#endregion
 //#region src/psl-field-resolution.ts
+const MODEL_COORDINATE_SEPARATOR = "\0";
+function modelCoordinateKey(namespaceId, modelName) {
+	return `${namespaceId}${MODEL_COORDINATE_SEPARATOR}${modelName}`;
+}
 const BUILTIN_FIELD_ATTRIBUTE_NAMES = new Set([
 	"id",
 	"unique",
@@ -1344,6 +1398,7 @@ function collectResolvedFields(input) {
 		});
 		const relationAttribute = getAttribute(field.attributes, "relation");
 		if (isModelField && relationAttribute) continue;
+		if (field.typeContractSpaceId !== void 0 && relationAttribute) continue;
 		const isValueObjectField = compositeTypeNames.has(field.typeName);
 		const isListField = field.list;
 		let descriptor;
@@ -1489,9 +1544,9 @@ function collectResolvedFields(input) {
 	}
 	return resolvedFields;
 }
-function buildModelMappings(models, diagnostics, sourceId) {
+function buildModelMappings(modelEntries, defaultNamespaceId, diagnostics, sourceId) {
 	const result = /* @__PURE__ */ new Map();
-	for (const model of models) {
+	for (const { model, namespaceId } of modelEntries) {
 		const tableName = parseMapName({
 			attribute: getAttribute(model.attributes, "map"),
 			defaultValue: lowerFirst(model.name),
@@ -1512,7 +1567,7 @@ function buildModelMappings(models, diagnostics, sourceId) {
 			});
 			fieldColumns.set(field.name, columnName);
 		}
-		result.set(model.name, {
+		result.set(modelCoordinateKey(namespaceId ?? defaultNamespaceId, model.name), {
 			model,
 			tableName,
 			fieldColumns
@@ -1666,6 +1721,7 @@ function indexFkRelations(input) {
 			fieldName: relation.declaringFieldName,
 			toModel: relation.targetModelName,
 			toTable: relation.targetTableName,
+			...ifDefined("toNamespaceId", relation.targetNamespaceId),
 			cardinality: "N:1",
 			on: {
 				parentTable: relation.declaringTableName,
@@ -1852,9 +1908,6 @@ const UNSPECIFIED_PSL_NAMESPACE_NAME = "__unspecified__";
 * slot empty (which means the late-bound default at the `StorageTable`
 * layer; emitted JSON omits the field).
 */
-function defaultSqlNamespaceIdForTarget(targetId) {
-	return targetId === "postgres" ? "public" : UNBOUND_NAMESPACE_ID;
-}
 function resolveNamespaceIdForSqlTarget(input) {
 	if (input.targetId !== "postgres") return;
 	if (input.bucketName === UNSPECIFIED_PSL_NAMESPACE_NAME) return "public";
@@ -2132,6 +2185,8 @@ function buildModelNodeFromPsl(input) {
 	} : void 0;
 	const hasInlinePrimaryKey = primaryKey !== void 0;
 	let blockPrimaryKeyDeclared = false;
+	let controlPolicyDeclared = false;
+	let controlPolicy;
 	const resultBackrelationCandidates = [];
 	for (const field of model.fields) {
 		if (!field.list || !input.modelNames.has(field.typeName)) continue;
@@ -2198,6 +2253,25 @@ function buildModelNodeFromPsl(input) {
 	for (const modelAttribute of model.attributes) {
 		if (modelAttribute.name === "map") continue;
 		if (modelAttribute.name === "discriminator" || modelAttribute.name === "base") continue;
+		if (modelAttribute.name === "control") {
+			if (controlPolicyDeclared) {
+				diagnostics.push({
+					code: "PSL_DUPLICATE_ATTRIBUTE",
+					message: `\`@@control\` declared more than once on model "${model.name}".`,
+					sourceId,
+					span: modelAttribute.span
+				});
+				continue;
+			}
+			controlPolicyDeclared = true;
+			const parsed = parseControlPolicyAttribute({
+				attribute: modelAttribute,
+				sourceId,
+				diagnostics
+			});
+			if (parsed !== void 0) controlPolicy = parsed;
+			continue;
+		}
 		const attributeLabel = `Model "${model.name}" @@${modelAttribute.name}`;
 		if (modelAttribute.name === "id") {
 			if (blockPrimaryKeyDeclared) {
@@ -2383,29 +2457,155 @@ function buildModelNodeFromPsl(input) {
 		});
 	}
 	const resultFkRelationMetadata = [];
+	const resultCrossSpaceRelations = [];
 	for (const relationAttribute of relationAttributes) {
-		if (relationAttribute.field.list) continue;
-		const { typeName: fieldTypeName, typeNamespaceId: fieldTypeNamespaceId } = relationAttribute.field;
-		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}"`,
+		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 (fieldTypeNamespaceId !== void 0) {
-			if (input.modelNamespaceIds.get(fieldTypeName) !== (fieldTypeNamespaceId === "unbound" ? "__unbound__" : fieldTypeNamespaceId)) {
+		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 extensionPacks. Add "${fieldTypeContractSpaceId}" to extensionPacks in prisma-next.config.ts.`,
+					sourceId,
+					span: relationAttribute.field.span,
+					data: {
+						space: fieldTypeContractSpaceId,
+						suggestedPack: fieldTypeContractSpaceId
+					}
+				});
+				continue;
+			}
+			const parsedRelation = parseRelationAttribute({
+				attribute: relationAttribute.relation,
+				modelName: model.name,
+				fieldName: relationAttribute.field.name,
+				sourceId,
+				diagnostics
+			});
+			if (!parsedRelation) continue;
+			if (!parsedRelation.fields || !parsedRelation.references) {
+				diagnostics.push({
+					code: "PSL_INVALID_RELATION_ATTRIBUTE",
+					message: `Relation field "${model.name}.${relationAttribute.field.name}" requires fields and references arguments`,
+					sourceId,
+					span: relationAttribute.relation.span
+				});
+				continue;
+			}
+			const 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({
+				modelName: model.name,
+				fieldName: relationAttribute.field.name,
+				actionName: "onDelete",
+				actionToken: parsedRelation.onDelete,
+				sourceId,
+				span: relationAttribute.field.span,
+				diagnostics
+			}) : void 0;
+			const onUpdate = parsedRelation.onUpdate ? normalizeReferentialAction({
+				modelName: model.name,
+				fieldName: relationAttribute.field.name,
+				actionName: "onUpdate",
+				actionToken: parsedRelation.onUpdate,
+				sourceId,
+				span: relationAttribute.field.span,
+				diagnostics
+			}) : void 0;
+			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_INVALID_RELATION_TARGET",
-					message: `Relation field "${model.name}.${relationAttribute.field.name}" references unknown model "${qualifiedTypeName}"`,
+					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
+					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.constraintName),
+				...ifDefined("onDelete", onDelete),
+				...ifDefined("onUpdate", onUpdate)
+			});
+			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 = parseRelationAttribute({
 			attribute: relationAttribute.relation,
@@ -2424,7 +2624,7 @@ function buildModelNodeFromPsl(input) {
 			});
 			continue;
 		}
-		const targetMapping = input.modelMappings.get(fieldTypeName);
+		const targetMapping = normalizedQualifier !== void 0 ? input.modelMappingsByCoordinate.get(modelCoordinateKey(normalizedQualifier, fieldTypeName)) : input.modelMappings.get(fieldTypeName);
 		if (!targetMapping) {
 			diagnostics.push({
 				code: "PSL_INVALID_RELATION_TARGET",
@@ -2481,7 +2681,7 @@ function buildModelNodeFromPsl(input) {
 			span: relationAttribute.field.span,
 			diagnostics
 		}) : void 0;
-		const targetNamespaceId = input.modelNamespaceIds.get(targetMapping.model.name);
+		const targetNamespaceId = normalizedQualifier !== void 0 ? normalizedQualifier : input.modelNamespaceIds.get(targetMapping.model.name);
 		foreignKeyNodes.push({
 			columns: localColumns,
 			references: {
@@ -2500,6 +2700,7 @@ function buildModelNodeFromPsl(input) {
 			declaringTableName: tableName,
 			targetModelName: targetMapping.model.name,
 			targetTableName: targetMapping.tableName,
+			...ifDefined("targetNamespaceId", targetNamespaceId),
 			...ifDefined("relationName", parsedRelation.relationName),
 			localColumns,
 			referencedColumns
@@ -2520,9 +2721,11 @@ function buildModelNodeFromPsl(input) {
 			...ifDefined("id", primaryKey),
 			...uniqueConstraints.length > 0 ? { uniques: uniqueConstraints } : {},
 			...indexNodes.length > 0 ? { indexes: indexNodes } : {},
-			...foreignKeyNodes.length > 0 ? { foreignKeys: foreignKeyNodes } : {}
+			...foreignKeyNodes.length > 0 ? { foreignKeys: foreignKeyNodes } : {},
+			...ifDefined("control", controlPolicy)
 		},
 		fkRelationMetadata: resultFkRelationMetadata,
+		crossSpaceRelations: resultCrossSpaceRelations,
 		backrelationCandidates: resultBackrelationCandidates,
 		resolvedFields
 	};
@@ -2688,8 +2891,18 @@ function collectPolymorphismDeclarations(models, sourceId, diagnostics) {
 		baseDeclarations
 	};
 }
-function resolvePolymorphism(models, discriminatorDeclarations, baseDeclarations, modelNames, modelMappings, modelNamespaceIds, targetId, sourceId, diagnostics) {
+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({
@@ -2700,7 +2913,7 @@ function resolvePolymorphism(models, discriminatorDeclarations, baseDeclarations
 			});
 			continue;
 		}
-		const model = patched[modelName];
+		const model = patched[coordinateFor(modelName)];
 		if (!model) continue;
 		if (!Object.hasOwn(model.fields, decl.fieldName)) {
 			diagnostics.push({
@@ -2739,7 +2952,7 @@ function resolvePolymorphism(models, discriminatorDeclarations, baseDeclarations
 		}
 		patched = {
 			...patched,
-			[modelName]: {
+			[coordinateFor(modelName)]: {
 				...model,
 				discriminator: { field: decl.fieldName },
 				variants
@@ -2766,25 +2979,173 @@ function resolvePolymorphism(models, discriminatorDeclarations, baseDeclarations
 			continue;
 		}
 		if (discriminatorDeclarations.has(variantName)) continue;
-		const variantModel = patched[variantName];
+		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,
-			[variantName]: {
-				...variantModel,
-				base: crossRef(baseDecl.baseName, modelNamespaceIds.get(baseDecl.baseName) ?? defaultSqlNamespaceIdForTarget(targetId)),
-				...resolvedTable ? { storage: {
-					...variantModel.storage,
-					table: resolvedTable
-				} } : {}
-			}
+			[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.document.ast.sourceId;
 	if (!input.target) return notOk({
@@ -2811,6 +3172,7 @@ function interpretPslDocumentToSqlContract(input) {
 		diagnostics
 	});
 	const models = [];
+	const modelEntries = [];
 	const modelNamespaceIds = /* @__PURE__ */ new Map();
 	for (const namespace of input.document.ast.namespaces) {
 		const resolvedNamespaceId = resolveNamespaceIdForSqlTarget({
@@ -2819,9 +3181,14 @@ function interpretPslDocumentToSqlContract(input) {
 		});
 		for (const model of namespace.models) {
 			models.push(model);
+			modelEntries.push({
+				model,
+				namespaceId: resolvedNamespaceId
+			});
 			if (resolvedNamespaceId !== void 0) modelNamespaceIds.set(model.name, resolvedNamespaceId);
 		}
 	}
+	const defaultNamespaceId = input.target.defaultNamespaceId;
 	const topLevelEnums = input.document.ast.namespaces.filter((ns) => ns.name === UNSPECIFIED_PSL_NAMESPACE_NAME).flatMap((ns) => ns.enums);
 	const namedNamespaceEnumsByNsId = /* @__PURE__ */ new Map();
 	for (const ns of input.document.ast.namespaces) {
@@ -2838,6 +3205,7 @@ function interpretPslDocumentToSqlContract(input) {
 	const modelNames = new Set(models.map((model) => model.name));
 	const compositeTypeNames = new Set(compositeTypes.map((ct) => ct.name));
 	const composedExtensions = new Set(input.composedExtensionPacks ?? []);
+	const composedExtensionContracts = input.composedExtensionContracts;
 	const defaultFunctionRegistry = input.controlMutationDefaults?.defaultFunctionRegistry ?? /* @__PURE__ */ new Map();
 	const generatorDescriptors = input.controlMutationDefaults?.generatorDescriptors ?? [];
 	const generatorDescriptorById = /* @__PURE__ */ new Map();
@@ -2884,23 +3252,29 @@ function interpretPslDocumentToSqlContract(input) {
 		...enumResult.storageTypes,
 		...namedTypeResult.storageTypes
 	};
-	const modelMappings = buildModelMappings(models, diagnostics, sourceId);
+	const modelMappingsByCoordinate = buildModelMappings(modelEntries, defaultNamespaceId, diagnostics, sourceId);
+	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();
-	for (const model of models) {
-		const mapping = modelMappings.get(model.name);
+	const crossSpaceRelationsByModel = /* @__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,
@@ -2911,14 +3285,17 @@ function interpretPslDocumentToSqlContract(input) {
 			diagnostics,
 			modelNamespaceIds
 		});
-		const resolvedNamespaceId = modelNamespaceIds.get(model.name);
-		modelNodes.push(resolvedNamespaceId !== void 0 ? {
+		modelNodes.push(namespaceId !== void 0 ? {
 			...result.modelNode,
-			namespaceId: resolvedNamespaceId
+			namespaceId
 		} : result.modelNode);
 		fkRelationMetadata.push(...result.fkRelationMetadata);
 		backrelationCandidates.push(...result.backrelationCandidates);
-		modelResolvedFields.set(model.name, result.resolvedFields);
+		modelResolvedFields.set(coordinate, result.resolvedFields);
+		if (result.crossSpaceRelations.length > 0) {
+			const existing = crossSpaceRelationsByModel.get(model.name) ?? [];
+			crossSpaceRelationsByModel.set(model.name, [...existing, ...result.crossSpaceRelations]);
+		}
 	}
 	const { modelRelations, fkRelationsByPair } = indexFkRelations({ fkRelationMetadata });
 	applyBackrelationCandidates({
@@ -2928,7 +3305,16 @@ function interpretPslDocumentToSqlContract(input) {
 		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, sourceId, diagnostics);
+	const stiVariantNames = /* @__PURE__ */ new Set();
+	for (const variantName of baseDeclarations.keys()) if (!(modelMappings.get(variantName)?.model.attributes.some((attr) => attr.name === "map") ?? false)) stiVariantNames.add(variantName);
+	const { modelNodes: mtiLinkedModelNodes, syntheticPkFieldsByVariant } = materializeMtiVariantStorageLinks(modelNodes, baseDeclarations, stiVariantNames);
+	const { modelNodes: stiColumnModelNodes, stiBaseFieldsByBase } = materializeStiVariantStorageColumns(mtiLinkedModelNodes, baseDeclarations, stiVariantNames);
 	const valueObjects = buildValueObjects({
 		compositeTypes,
 		enumTypeDescriptors: allEnumTypeDescriptors,
@@ -2951,19 +3337,20 @@ function interpretPslDocumentToSqlContract(input) {
 		...Object.keys(storageTypes).length > 0 ? { storageTypes } : {},
 		...Object.keys(namespaceEnumStorageTypes).length > 0 ? { namespaceTypes: namespaceEnumStorageTypes } : {},
 		...ifDefined("createNamespace", input.createNamespace),
-		models: modelNodes.map((model) => ({
+		models: stiColumnModelNodes.map((model) => ({
 			...model,
 			...modelRelations.has(model.modelName) ? { relations: [...modelRelations.get(model.modelName) ?? []].sort((left, right) => compareStrings(left.fieldName, right.fieldName)) } : {}
 		}))
 	});
 	const modelsForPatch = {};
-	for (const namespaceSlice of Object.values(contract.domain.namespaces)) for (const [modelName, model] of Object.entries(namespaceSlice.models)) {
-		if (Object.hasOwn(modelsForPatch, modelName)) throw new Error(`duplicate model name "${modelName}" across domain namespaces during PSL interpretation`);
-		modelsForPatch[modelName] = model;
+	for (const [namespaceId, namespaceSlice] of Object.entries(contract.domain.namespaces)) for (const [modelName, model] of Object.entries(namespaceSlice.models)) {
+		const coordinate = modelCoordinateKey(namespaceId, modelName);
+		if (Object.hasOwn(modelsForPatch, coordinate)) throw new Error(`duplicate model "${namespaceId}.${modelName}" during PSL interpretation`);
+		modelsForPatch[coordinate] = model;
 	}
 	let patchedModels = patchModelDomainFields(modelsForPatch, modelResolvedFields);
 	const polyDiagnostics = [];
-	patchedModels = resolvePolymorphism(patchedModels, discriminatorDeclarations, baseDeclarations, modelNames, modelMappings, modelNamespaceIds, input.target.targetId, sourceId, 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
@@ -2974,13 +3361,13 @@ function interpretPslDocumentToSqlContract(input) {
 		...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[modelName] ?? model])),
+			models: Object.fromEntries(Object.entries(namespaceSlice.models).map(([modelName, model]) => [modelName, patchedModels[modelCoordinateKey(namespaceId, modelName)] ?? model])),
 			...namespaceSlice.valueObjects !== void 0 ? { valueObjects: namespaceSlice.valueObjects } : {},
-			...namespaceId === defaultSqlNamespaceIdForTarget(input.target.targetId) && Object.keys(valueObjects).length > 0 ? { valueObjects } : {}
+			...namespaceId === input.target.defaultNamespaceId && Object.keys(valueObjects).length > 0 ? { valueObjects } : {}
 		}])) }
 	});
 }
 //#endregion
 export { interpretPslDocumentToSqlContract as t };
 
-//# sourceMappingURL=interpreter-QE6eZZof.mjs.map
+//# sourceMappingURL=interpreter-B_KtZusL.mjs.map