@prisma-next/sql-contract-psl 0.12.0-dev.7 → 0.12.0-dev.71

package/README.md

@@ -14,7 +14,7 @@ This keeps core/CLI source-agnostic while giving PSL-first SQL users a one-line
 ## Responsibilities
 
 - Interpret `ParsePslDocumentResult` into SQL `Contract`
-- Interpret generic PSL attributes into SQL contract semantics (`@id`, `@unique`, `@default`, `@relation`, `@map`, `@@map`)
+- Interpret generic PSL attributes into SQL contract semantics (`@id`, `@unique`, `@default`, `@relation`, `@map`, `@@map`, `@@control`)
 - Interpret SQL timestamp semantics: `DateTime @default(now())` (or the equivalent `temporal.createdAt()` field-preset call) as a storage default, and `temporal.updatedAt()` as an execution mutation default
 - Lower shared constructor expressions in both `types {}` blocks and inline field positions (for example `ShortName = sql.String(length: 35)` and `embedding pgvector.Vector(length: 1536)?`)
 - Lower supported default functions through composed registry inputs
@@ -71,12 +71,20 @@ Supported timestamp authoring surface:
 - The Prisma-flavored `@updatedAt` attribute is not supported; references produce `PSL_UNSUPPORTED_FIELD_ATTRIBUTE` with a migration hint pointing at `temporal.updatedAt()`. The hint is suppressed when the field already declares any `temporal.*` preset.
 - `@createdAt` is not supported as a PSL alias.
 
+Model-level control policy:
+
+- `@@control(<policy>)` lowers to the storage table's `control` field. The argument is one positional lowercase literal: `managed`, `tolerated`, `external`, or `observed`. Omit `@@control` to leave per-table control unset (the framework default applies at runtime).
+
+Contract-level default (specifier options bag):
+
+- `defaultControlPolicy` on `prismaContract(...)` sets `Contract.defaultControlPolicy` at load time when the interpreted contract does not already define one (source wins when both are present).
+
 ## Public API
 
 - `@prisma-next/sql-contract-psl`
   - `interpretPslDocumentToSqlContract({ document, target, scalarTypeDescriptors, authoringContributions?, controlMutationDefaults?, composedExtensionPacks? })`
 - `@prisma-next/sql-contract-psl/provider`
-  - `prismaContract(schemaPath, { output?, target, scalarTypeDescriptors, authoringContributions?, controlMutationDefaults?, composedExtensionPacks? })`
+  - `prismaContract(schemaPath, { output?, target, defaultControlPolicy?, scalarTypeDescriptors, authoringContributions?, controlMutationDefaults?, composedExtensionPacks? })`
   - Provider input is fully preassembled by composition layers (for example `@prisma-next/family-sql/control` helpers).
 
 ## Dependencies

package/dist/index.d.mts

@@ -1,12 +1,12 @@
 import { Contract } from "@prisma-next/contract/types";
 import { AuthoringContributions } from "@prisma-next/framework-components/authoring";
-import { Namespace } from "@prisma-next/framework-components/ir";
 import { SqlNamespaceTablesInput } from "@prisma-next/sql-contract/types";
 import { Result } from "@prisma-next/utils/result";
 import { ParsePslDocumentResult } from "@prisma-next/psl-parser";
 import { ControlMutationDefaults, ControlMutationDefaults as ControlMutationDefaults$1, DefaultFunctionLoweringContext, DefaultFunctionLoweringHandler, DefaultFunctionRegistry, DefaultFunctionRegistryEntry, MutationDefaultGeneratorDescriptor } from "@prisma-next/framework-components/control";
 import { ContractSourceDiagnostics } from "@prisma-next/config/config-types";
 import { ExtensionPackRef, TargetPackRef } from "@prisma-next/framework-components/components";
+import { Namespace } from "@prisma-next/framework-components/ir";
 
 //#region src/psl-column-resolution.d.ts
 type ColumnDescriptor = {
@@ -25,6 +25,16 @@ interface InterpretPslDocumentToSqlContractInput {
   readonly composedExtensionPackRefs?: readonly ExtensionPackRef<'sql', string>[];
   readonly controlMutationDefaults?: ControlMutationDefaults$1;
   readonly authoringContributions?: AuthoringContributions;
+  /**
+   * Extension contracts keyed by space ID. Required for cross-space FK
+   * resolution. A composed space must have an entry here; if the space ID
+   * appears in `composedExtensionPacks` but is absent from this map, the
+   * interpreter emits `PSL_UNKNOWN_CONTRACT_SPACE` and fails fast — there
+   * is no silent fallback. If a space's contract is present but the
+   * referenced model or namespace is not found in it, the interpreter
+   * emits `PSL_UNKNOWN_CROSS_SPACE_TARGET`.
+   */
+  readonly composedExtensionContracts: ReadonlyMap<string, Contract>;
   /**
    * Target-supplied `Namespace` factory threaded into
    * `buildSqlContractFromDefinition` for the contract's

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/psl-column-resolution.ts","../src/interpreter.ts"],"mappings":";;;;;;;;;;;KAyCY,gBAAA;EAAA,SACD,OAAA;EAAA,SACA,UAAA;EAAA,SACA,OAAA;EAAA,SACA,UAAA,GAAa,MAAM;AAAA;;;UC8Cb,sCAAA;EAAA,SACN,QAAA,EAAU,sBAAA;EAAA,SACV,MAAA,EAAQ,aAAA;EAAA,SACR,qBAAA,EAAuB,WAAA,SAAoB,gBAAA;EAAA,SAC3C,sBAAA;EAAA,SACA,yBAAA,YAAqC,gBAAA;EAAA,SACrC,uBAAA,GAA0B,yBAAA;EAAA,SAC1B,sBAAA,GAAyB,sBAAA;EDrDzB;;;AAAmB;;;;AC8C9B;;ED9CW,SC+DA,eAAA,IAAmB,KAAA,EAAO,uBAAA,KAA4B,SAAA;AAAA;AAAA,iBAwyCjD,iCAAA,CACd,KAAA,EAAO,sCAAA,GACN,MAAA,CAAO,QAAA,EAAU,yBAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/psl-column-resolution.ts","../src/interpreter.ts"],"mappings":";;;;;;;;;;;KA0CY,gBAAA;EAAA,SACD,OAAA;EAAA,SACA,UAAA;EAAA,SACA,OAAA;EAAA,SACA,UAAA,GAAa,MAAM;AAAA;;;UCkDb,sCAAA;EAAA,SACN,QAAA,EAAU,sBAAA;EAAA,SACV,MAAA,EAAQ,aAAA;EAAA,SACR,qBAAA,EAAuB,WAAA,SAAoB,gBAAA;EAAA,SAC3C,sBAAA;EAAA,SACA,yBAAA,YAAqC,gBAAA;EAAA,SACrC,uBAAA,GAA0B,yBAAA;EAAA,SAC1B,sBAAA,GAAyB,sBAAA;EDzDzB;;;AAAmB;;;;ACkD9B;;EDlDW,SCmEA,0BAAA,EAA4B,WAAA,SAAoB,QAAA;EAhBtC;;;;;;;;;EAAA,SA0BV,eAAA,IAAmB,KAAA,EAAO,uBAAA,KAA4B,SAAA;AAAA;AAAA,iBAurDjD,iCAAA,CACd,KAAA,EAAO,sCAAA,GACN,MAAA,CAAO,QAAA,EAAU,yBAAA"}

package/dist/index.mjs

@@ -1,2 +1,2 @@
-import { t as interpretPslDocumentToSqlContract } from "./interpreter-QE6eZZof.mjs";
+import { t as interpretPslDocumentToSqlContract } from "./interpreter-B5_yovSP.mjs";
 export { interpretPslDocumentToSqlContract };

package/dist/{interpreter-QE6eZZof.mjs → interpreter-B5_yovSP.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;
 }
@@ -1344,6 +1394,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;
@@ -1852,9 +1903,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 +2180,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 +2248,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,9 +2452,136 @@ 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 { 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 (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_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.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({
@@ -2520,9 +2716,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 +2886,16 @@ 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;
+	for (const [baseName, fieldNames] of stiBaseFieldsByBase) {
+		const baseModel = patched[baseName];
+		if (!baseModel || fieldNames.length === 0) continue;
+		patched = {
+			...patched,
+			[baseName]: stripStorageOnlyDomainFields(baseModel, fieldNames)
+		};
+	}
 	for (const [modelName, decl] of discriminatorDeclarations) {
 		if (baseDeclarations.has(modelName)) {
 			diagnostics.push({
@@ -2771,20 +2977,168 @@ function resolvePolymorphism(models, discriminatorDeclarations, baseDeclarations
 		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
-				} } : {}
-			}
+			[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({
@@ -2838,6 +3192,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();
@@ -2889,6 +3244,7 @@ function interpretPslDocumentToSqlContract(input) {
 	const fkRelationMetadata = [];
 	const backrelationCandidates = [];
 	const modelResolvedFields = /* @__PURE__ */ new Map();
+	const crossSpaceRelationsByModel = /* @__PURE__ */ new Map();
 	for (const model of models) {
 		const mapping = modelMappings.get(model.name);
 		if (!mapping) continue;
@@ -2901,6 +3257,7 @@ function interpretPslDocumentToSqlContract(input) {
 			enumTypeDescriptors: allEnumTypeDescriptors,
 			namedTypeDescriptors: namedTypeResult.namedTypeDescriptors,
 			composedExtensions,
+			composedExtensionContracts,
 			familyId: input.target.familyId,
 			targetId: input.target.targetId,
 			authoringContributions: input.authoringContributions,
@@ -2919,6 +3276,10 @@ function interpretPslDocumentToSqlContract(input) {
 		fkRelationMetadata.push(...result.fkRelationMetadata);
 		backrelationCandidates.push(...result.backrelationCandidates);
 		modelResolvedFields.set(model.name, 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 +3289,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,7 +3321,7 @@ 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)) } : {}
 		}))
@@ -2963,7 +3333,7 @@ function interpretPslDocumentToSqlContract(input) {
 	}
 	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
@@ -2976,11 +3346,11 @@ function interpretPslDocumentToSqlContract(input) {
 		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])),
 			...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-B5_yovSP.mjs.map