@prisma-next/sql-contract-psl 0.12.0-dev.5 → 0.12.0-dev.51

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 = {

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;;;UCiDb,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;EDxDzB;;;AAAmB;;;;ACiD9B;;EDjDW,SCkEA,eAAA,IAAmB,KAAA,EAAO,uBAAA,KAA4B,SAAA;AAAA;AAAA,iBAwgDjD,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-Rn_Vzvt-.mjs";
 export { interpretPslDocumentToSqlContract };

package/dist/{interpreter-QE6eZZof.mjs → interpreter-Rn_Vzvt-.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;
 }
@@ -1852,9 +1902,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 +2179,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 +2247,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) {
@@ -2520,7 +2588,8 @@ 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,
 		backrelationCandidates: resultBackrelationCandidates,
@@ -2688,8 +2757,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 +2848,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({
@@ -2929,6 +3154,10 @@ function interpretPslDocumentToSqlContract(input) {
 		sourceId
 	});
 	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 +3180,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 +3192,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 +3205,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-Rn_Vzvt-.mjs.map