@prisma/orm-family-sql 8.0.0-rc.14-dev.6 → 8.0.0-rc.14-dev.7

package/dist/{interpreter-Bcc3MIC5-C4dZrobt.mjs → interpreter-j1ewAXPb-BwieIKeF.mjs}

@@ -1,18 +1,19 @@
 import { n as isAuthoredIndexInput } from "./index-naming-Cj1Anq-T-C9TevpPR.mjs";
 import { n as providesPslEntityPlacement } from "./entity-handle-lowering-hook-B3atrRKX.mjs";
 import { s as sqlTextFromCanonical, t as SQL_EXPRESSION_DATA_TYPE_ID } from "./sql-expression-BXx0Ilj-.mjs";
+import { d as resolvedTypeParams } from "./types-BmXzMDQL.mjs";
 import { n as checkSqlDefaultBody, o as reservedSqlDefaultBody } from "./validators-BlqrBU7I.mjs";
 import { t as deriveValueSetFromEntity } from "./value-set-derivation-hook-Di9JZ0X7.mjs";
-import { n as buildSqlContractFromDefinition } from "./derived-checks-C6psACIj-BSBDa2_9.mjs";
+import { a as storedAsListColumn, i as isValueObjectMember, n as buildSqlContractFromDefinition } from "./derived-checks-D8_YCVs5-CfBVLnya.mjs";
 import { a as getAttribute, c as interpretModelAttribute, d as modelAttributeSpecsFrom, f as sqlAttributeSpecs, i as formatDbAttributeMigrationMessage, l as lowerDefaultFunctionWithRegistry, n as createSqlBinder, o as getNamedArgument, p as storageName, r as fieldSpecContext, s as interpretFieldAttribute, t as PSL_CHECK_ON_STI_VARIANT, u as mapFieldNamesToColumns } from "./sql-attribute-specs-Bs9QDuS7-DmIRJUz9.mjs";
 import { t as defaultTableName } from "./default-table-name-BfFY8qYR-lHNcVmY5.mjs";
 import { structuredError } from "@prisma/orm-framework/utils/structured-error";
-import { checkUncomposedNamespace, getAuthoringFieldPreset, hasRegisteredFieldNamespace, instantiateAuthoringEntityType, instantiateAuthoringTypeConstructor, isAuthoringEntityTypeDescriptor, isAuthoringModelAttributeDescriptor, isAuthoringTypeConstructorDescriptor, validateAuthoringHelperArguments } from "@prisma/orm-framework/components/authoring";
+import { checkUncomposedNamespace, getAuthoringFieldPreset, getAuthoringTypeConstructor, hasRegisteredFieldNamespace, instantiateAuthoringEntityType, instantiateAuthoringTypeConstructor, isAuthoringEntityTypeDescriptor, isAuthoringModelAttributeDescriptor, 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 { InternalError, isInternalError } from "@prisma/orm-framework/utils/internal-error";
 import { crossRef } from "@prisma/orm-framework/contract/types";
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
-import { materializeCodec } from "@prisma/orm-framework/components/codec";
+import { codecForRef } from "@prisma/orm-framework/components/codec";
 import { blindCast } from "@prisma/orm-framework/utils/casts";
 import { NamespaceDeclarationAst } from "@prisma/orm-framework/psl-parser/syntax";
 import { resolveToOneRelationNullable } from "@prisma/orm-framework/contract-authoring";
@@ -22,12 +23,14 @@ import { notOk, ok } from "@prisma/orm-framework/utils/result";
 import { createPslDiagnosticCollector, diagnosticSource, findBlockDescriptor, interpretExtensionBlocks, nodePslSpan, typeReferenceNode } from "@prisma/orm-framework/psl-parser";
 import { UNBOUND_PSL_NAMESPACE_NAME, UNSPECIFIED_PSL_NAMESPACE_ID } from "@prisma/orm-framework/components/psl-ast";
 import { claimedBlockKeywords, enumMemberAttributeDiagnostics, fkRelationPairKey, instantiatePslFieldPreset, mapPslHelperArgs, reportUncomposedNamespace, reportUnknownFieldPreset, requiredOneToOneBackrelationDiagnostic, uncomposedNamespaceDiagnostic, unsupportedBlockDiagnostic } from "@prisma/orm-framework/psl-parser/interpret";
-//#region ../../../2-sql/2-authoring/contract-psl/dist/interpreter-Bcc3MIC5.mjs
+//#region ../../../2-sql/2-authoring/contract-psl/dist/interpreter-j1ewAXPb.mjs
 function contractError(code, message, options) {
 	return structuredError(code, message, options);
 }
 /** A written value the column's codec refuses. */
 const PSL_INVALID_DEFAULT_LITERAL = "PSL_INVALID_DEFAULT_LITERAL";
+/** A written value whose data type the receiving type neither is nor casts from. */
+const PSL_VALUE_TYPE_INCOMPATIBLE = "PSL_VALUE_TYPE_INCOMPATIBLE";
 /** A single value written as the default of a column that holds a list. */
 const PSL_DEFAULT_LIST_EXPECTED = "PSL_DEFAULT_LIST_EXPECTED";
 /** The entry a tag names, or `undefined` when no pack registered that tag. */
@@ -100,6 +103,7 @@ function readValue(support, written, elementIndex) {
 			}
 		};
 	} catch (error) {
+		if (isInternalError(error)) throw error;
 		return refuse({
 			kind: "unreadable",
 			message: messageOf(error)
@@ -130,6 +134,7 @@ function castInto(support, columnType, typed, elementIndex) {
 			value: cast(typed.value)
 		};
 	} catch (error) {
+		if (isInternalError(error)) throw error;
 		return {
 			ok: false,
 			refusal: {
@@ -145,22 +150,17 @@ function codecRefTypeParams(typeParams) {
 	return typeParams === void 0 ? void 0 : blindCast(typeParams);
 }
 /**
-* Read one `@default(...)` value for a column, refusing in parts so each contract source words its
-* own diagnostic. `isList` selects the check: a list column's elements are each read and cast
-* against the element codec's data type, while a scalar column takes a written list only through
-* its type's list cast — which is how `pgvector.Vector(3) @default([0.1, 0.2])` is read.
+* The column's codec descriptor, and `read`, which reads a value in its stored JSON form with the column's codec, built with the column's type parameters.
 */
-function readDataTypeDefault(input) {
-	const descriptorFor = input.codecLookup?.descriptorFor;
-	if (descriptorFor === void 0) throw new InternalError(`Field "${input.fieldPath}": the codec lookup resolving column codecs exposes no descriptorFor, but the column was resolved from a codec descriptor.`);
-	const descriptor = descriptorFor(input.column.codecId);
-	if (descriptor === void 0) throw new InternalError(`Field "${input.fieldPath}": no codec descriptor is registered for "${input.column.codecId}", but the column was resolved from one.`);
-	const columnType = descriptor.dataType;
-	const codec = materializeCodec(descriptor, {
+function storedValueReader(input) {
+	if (input.codecLookup === void 0) throw new InternalError(`Field "${input.fieldPath}": no codec lookup was given, but the column was resolved from a codec descriptor.`);
+	const descriptor = input.codecLookup.descriptorFor(input.column.codecId);
+	const codec = codecForRef(input.codecLookup, {
 		codecId: input.column.codecId,
 		...ifDefined("typeParams", codecRefTypeParams(input.column.typeParams))
-	}, { name: input.fieldPath });
-	const validate = (value, elementIndex) => {
+	});
+	if (codec === void 0 || descriptor === void 0) throw new InternalError(`Field "${input.fieldPath}": no codec descriptor is registered for "${input.column.codecId}", but the column was resolved from one.`);
+	const read = (value, elementIndex) => {
 		try {
 			codec.decodeJson(value);
 			return {
@@ -168,10 +168,11 @@ function readDataTypeDefault(input) {
 				value
 			};
 		} catch (error) {
+			if (isInternalError(error)) throw error;
 			return {
 				ok: false,
 				refusal: {
-					kind: "undecodable",
+					kind: "refused-by-codec",
 					codecId: input.column.codecId,
 					message: messageOf(error),
 					elementIndex
@@ -179,12 +180,33 @@ function readDataTypeDefault(input) {
 			};
 		}
 	};
+	return {
+		descriptor,
+		read
+	};
+}
+/**
+* Reads a value already in its stored JSON form, such as one member of a JSON document default, with the column's codec. Worded as {@link lowerDataTypeDefault} words a codec refusal.
+*/
+function readStoredValue(input) {
+	const reading = storedValueReader(input).read(input.value, void 0);
+	return reading.ok ? reading : refusalDiagnostic(reading.refusal, input.fieldPath);
+}
+/**
+* Read one `@default(...)` value for a column, refusing in parts so each contract source words its
+* own diagnostic. `isList` selects the check: a list column's elements are each read and cast
+* against the element codec's data type, while a scalar column takes a written list only through
+* its type's list cast — which is how `pgvector.Vector(3) @default([0.1, 0.2])` is read.
+*/
+function readDataTypeDefault(input) {
+	const { descriptor, read: readStored } = storedValueReader(input);
+	const columnType = descriptor.dataType;
 	const readOne = (written, elementIndex) => {
 		const read = readValue(input.support, written, elementIndex);
 		if (!read.ok) return read;
 		const cast = castInto(input.support, columnType, read.typed, elementIndex);
 		if (!cast.ok) return cast;
-		return validate(cast.value, elementIndex);
+		return readStored(cast.value, elementIndex);
 	};
 	if (input.written.kind !== "list") {
 		if (input.isList) return {
@@ -220,7 +242,7 @@ function readDataTypeDefault(input) {
 		...input,
 		written: input.written,
 		columnType,
-		validate
+		readStored
 	});
 }
 /** A written list on a column that is not a list: the column's type takes it through its list cast. */
@@ -261,8 +283,9 @@ function readListIntoScalar(input) {
 		elements.push(read.typed.value);
 	}
 	try {
-		return input.validate(listCast.cast(elements), void 0);
+		return input.readStored(listCast.cast(elements), void 0);
 	} catch (error) {
+		if (isInternalError(error)) throw error;
 		return {
 			ok: false,
 			refusal: {
@@ -280,9 +303,11 @@ function at(elementIndex) {
 /** {@link readDataTypeDefault} worded as a PSL diagnostic's code and message. */
 function lowerDataTypeDefault(input) {
 	const read = readDataTypeDefault(input);
-	if (read.ok) return read;
-	const { refusal } = read;
-	const where = `Field "${input.fieldPath}"${at(refusal.elementIndex)}`;
+	return read.ok ? read : refusalDiagnostic(read.refusal, input.fieldPath);
+}
+/** A refusal worded as a PSL diagnostic's code and message. */
+function refusalDiagnostic(refusal, fieldPath) {
+	const where = `Field "${fieldPath}"${at(refusal.elementIndex)}`;
 	switch (refusal.kind) {
 		case "unreadable": return {
 			ok: false,
@@ -296,7 +321,7 @@ function lowerDataTypeDefault(input) {
 		};
 		case "unwritable": return {
 			ok: false,
-			code: "PSL_VALUE_TYPE_INCOMPATIBLE",
+			code: PSL_VALUE_TYPE_INCOMPATIBLE,
 			message: `${where}: this target has no data type for a ${refusal.syntax} value`
 		};
 		case "not-a-list": return {
@@ -306,10 +331,10 @@ function lowerDataTypeDefault(input) {
 		};
 		case "no-cast": return {
 			ok: false,
-			code: "PSL_VALUE_TYPE_INCOMPATIBLE",
+			code: PSL_VALUE_TYPE_INCOMPATIBLE,
 			message: `${where}: ${refusal.columnType} has no cast from ${refusal.valueType}; ${describeCasts(refusal.casts)}`
 		};
-		case "undecodable": return {
+		case "refused-by-codec": return {
 			ok: false,
 			code: PSL_INVALID_DEFAULT_LITERAL,
 			message: `${where}: ${refusal.message}`
@@ -319,6 +344,106 @@ function lowerDataTypeDefault(input) {
 function describeCasts(casts) {
 	return casts.length === 0 ? "it casts from nothing" : `it casts from ${casts.join(", ")}`;
 }
+/** Each way the default does not match the composite type. */
+function valueObjectDefaultMismatches(input) {
+	const mismatches = [];
+	const shape = (path, message) => mismatches.push({
+		code: PSL_VALUE_TYPE_INCOMPATIBLE,
+		message: `Field "${path}": ${message}`
+	});
+	const checkObject = (value, valueObjectName, path) => {
+		const valueObject = input.types.nodes.get(valueObjectName);
+		const declared = input.types.declaredMembers.get(valueObjectName);
+		if (valueObject === void 0 || declared === void 0) throw new InternalError(`Field "${path}" is typed by the value object "${valueObjectName}", which the contract does not declare.`);
+		if (!isJsonObject(value)) {
+			shape(path, `a value of "${valueObjectName}" is a JSON object, not ${jsonKind(value)}`);
+			return;
+		}
+		for (const key of Object.keys(value)) if (!declared.has(key)) shape(path, `"${key}" is not a member of "${valueObjectName}"`);
+		for (const member of valueObject.fields) checkMember(value[member.fieldName], member, `${path}.${member.fieldName}`);
+	};
+	const checkMember = (value, member, path) => {
+		if (value === void 0) {
+			if (!member.nullable) shape(path, "the member is required, and the default has no value for it");
+			return;
+		}
+		if (value === null && member.nullable) return;
+		if (member.many === true) {
+			if (!Array.isArray(value)) {
+				shape(path, `the member is a list, so its value is a JSON array, not ${jsonKind(value)}`);
+				return;
+			}
+			for (const [index, element] of value.entries()) checkOne(element, member, `${path}[${index}]`, "an element of the member is not null");
+			return;
+		}
+		checkOne(value, member, path, "the member is not optional, so its value is not null");
+	};
+	const checkOne = (value, member, path, notNull) => {
+		if (isValueObjectMember(member)) {
+			if (value === null) shape(path, notNull);
+			else checkObject(value, member.valueObjectName, path);
+			return;
+		}
+		const reading = readStoredValue({
+			value,
+			column: member.descriptor,
+			codecLookup: input.codecLookup,
+			fieldPath: path
+		});
+		if (!reading.ok) {
+			if (value === null) shape(path, notNull);
+			else mismatches.push({
+				code: reading.code,
+				message: reading.message
+			});
+			return;
+		}
+		const enumMismatch = enumValueMismatch(value, member, path, input.codecLookup);
+		if (enumMismatch !== void 0) mismatches.push(enumMismatch);
+	};
+	if (input.value === null) {
+		if (input.nullable) return mismatches;
+		shape(input.fieldPath, input.list ? "the default of a list of value objects is a JSON array, not null" : "the default of a value object is a JSON object, not null");
+		return mismatches;
+	}
+	if (input.list) {
+		if (!Array.isArray(input.value)) {
+			shape(input.fieldPath, `the default of a list of value objects is a JSON array, not ${jsonKind(input.value)}`);
+			return mismatches;
+		}
+		for (const [index, element] of input.value.entries()) checkObject(element, input.valueObjectName, `${input.fieldPath}[${index}]`);
+		return mismatches;
+	}
+	if (!isJsonObject(input.value)) {
+		shape(input.fieldPath, `the default of a value object is a JSON object, not ${jsonKind(input.value)}`);
+		return mismatches;
+	}
+	checkObject(input.value, input.valueObjectName, input.fieldPath);
+	return mismatches;
+}
+/**
+* A member typed by an enum takes only the enum's values, in the form its codec stores them, as a model field of that enum takes only its members.
+*/
+function enumValueMismatch(value, member, path, codecLookup) {
+	const handle = member.enumTypeHandle;
+	if (handle === void 0) return void 0;
+	const codec = codecLookup?.get(handle.codecId);
+	const stored = handle.values.map((enumValue) => codec === void 0 ? enumValue : codec.encodeJson(enumValue));
+	if (stored.some((storedValue) => storedValue === value)) return void 0;
+	return {
+		code: PSL_INVALID_DEFAULT_LITERAL,
+		message: `Field "${path}": Expected one of: ${stored.map((storedValue) => JSON.stringify(storedValue)).join(" | ")}`
+	};
+}
+function isJsonObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function jsonKind(value) {
+	if (value === null) return "null";
+	if (Array.isArray(value)) return "a JSON array";
+	if (typeof value === "object") return "a JSON object";
+	return `a JSON ${typeof value}`;
+}
 function toNamedTypeFieldDescriptor(typeRef, descriptor) {
 	return {
 		codecId: descriptor.codecId,
@@ -326,14 +451,6 @@ function toNamedTypeFieldDescriptor(typeRef, descriptor) {
 		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
@@ -375,6 +492,7 @@ function instantiatePslTypeConstructor(input) {
 		validateAuthoringHelperArguments(helperPath, input.descriptor.args, args);
 		return instantiateAuthoringTypeConstructor(input.descriptor, args);
 	} catch (error) {
+		if (isInternalError(error)) throw error;
 		const message = error instanceof Error ? error.message : String(error);
 		input.diagnostics.push({
 			code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
@@ -471,7 +589,7 @@ function resolveEntityRefTypeConstructorCall(input) {
 	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);
+	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
@@ -659,10 +777,11 @@ function lowerDefaultForField(input) {
 	});
 	if (interpreted === void 0) return {};
 	const value = interpreted.value;
+	const readsListElements = (written) => input.isListColumn || input.field.list && written.kind === "list";
 	const readAsLiteral = (written) => {
 		const lowered = lowerDataTypeDefault({
 			written,
-			isList: input.field.list,
+			isList: readsListElements(written),
 			column: input.columnDescriptor,
 			codecLookup: input.codecLookup,
 			support: input.dataTypeSupport,
@@ -676,6 +795,22 @@ function lowerDefaultForField(input) {
 			});
 			return {};
 		}
+		if (input.valueObjectDefault !== void 0) {
+			const mismatches = valueObjectDefaultMismatches({
+				fieldPath: `${input.modelName}.${input.fieldName}`,
+				value: lowered.value,
+				list: input.field.list,
+				nullable: input.field.optional,
+				...input.valueObjectDefault,
+				codecLookup: input.codecLookup
+			});
+			for (const { code, message } of mismatches) input.diagnostics.push({
+				code,
+				message,
+				...source.at()
+			});
+			if (mismatches.length > 0) return {};
+		}
 		return { defaultValue: {
 			kind: "literal",
 			value: lowered.value,
@@ -870,6 +1005,7 @@ function describeUnsupportedSqlAttribute(input) {
 		authoringContributions: input.authoringContributions
 	};
 	return ({ attribute, level, owner, field }) => {
+		if (owner.kind === "compositeType") return void 0;
 		if (level === "model") {
 			const source = diagnosticSource(input.sources, owner.node.syntax);
 			const uncomposedNamespace = checkUncomposedNamespace(attribute.name, input.composedExtensions, namespaceContext);
@@ -963,7 +1099,7 @@ function lowerNoCheckForField(input) {
 	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.isListColumn) 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) {
@@ -989,7 +1125,7 @@ function lowerNoCheckForField(input) {
 	return [...authored].sort();
 }
 function collectResolvedFields(input) {
-	const { model, symbolTable, enumTypeDescriptors, namedTypeDescriptors, composedExtensions, authoringContributions, binder, familyId, targetId, defaultFunctionRegistry, dataTypeSupport, generatorDescriptorById, diagnostics, sources, scalarColumnDescriptors, enumHandles, capabilities, namespaceId, namespaceExtensionEntities, codecLookup } = input;
+	const { model, symbolTable, enumTypeDescriptors, namedTypeDescriptors, valueObjectTypes, composedExtensions, authoringContributions, binder, familyId, targetId, defaultFunctionRegistry, dataTypeSupport, generatorDescriptorById, diagnostics, sources, 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();
@@ -1004,10 +1140,14 @@ function collectResolvedFields(input) {
 		if (isModelField && relationAttribute) continue;
 		if (field.typeContractSpaceId !== void 0 && relationAttribute) continue;
 		if (isModelField) continue;
-		const isValueObjectField = fieldTypeResolution?.kind === "compositeType";
+		const valueObjectName = fieldTypeResolution?.kind === "compositeType" ? fieldTypeResolution.symbol.name : void 0;
+		const isValueObjectField = valueObjectName !== void 0;
 		const isListField = field.list;
+		const isListColumn = storedAsListColumn({
+			list: isListField,
+			typedByValueObject: isValueObjectField
+		});
 		let descriptor;
-		let scalarCodecId;
 		let presetContributions;
 		const resolveInput = {
 			field,
@@ -1026,8 +1166,18 @@ function collectResolvedFields(input) {
 			...ifDefined("namespaceExtensionEntities", namespaceExtensionEntities),
 			...ifDefined("codecLookup", codecLookup)
 		};
-		if (isValueObjectField) descriptor = valueObjectStorageTypeName !== void 0 ? scalarColumnDescriptors.get(valueObjectStorageTypeName) : void 0;
-		else if (isListField) {
+		if (isValueObjectField) {
+			if (valueObjectStorageTypeName === void 0) {
+				diagnostics.push({
+					code: "PSL_UNSUPPORTED_FIELD_TYPE",
+					message: `Field "${model.name}.${field.name}" is typed by the composite type "${field.typeName}", but the adapter of the stack declares no storage type for value objects, so the field has no column to be stored in.`,
+					...source.at(field.span)
+				});
+				continue;
+			}
+			descriptor = scalarColumnDescriptors.get(valueObjectStorageTypeName);
+			if (descriptor === void 0) throw new InternalError(`The stack declares "${valueObjectStorageTypeName}" as its value-object storage type, but it is not one of the stack's scalar types; the control stack checks this when it is assembled.`);
+		} else if (isListField) {
 			if (capabilities["sql"]?.["scalarList"] !== true) {
 				diagnostics.push({
 					code: "PSL_SCALAR_LIST_UNSUPPORTED_TARGET",
@@ -1053,7 +1203,6 @@ function collectResolvedFields(input) {
 				});
 				continue;
 			}
-			scalarCodecId = resolved.descriptor.codecId;
 			descriptor = resolved.descriptor;
 		} else {
 			const resolved = resolveFieldTypeDescriptor(resolveInput);
@@ -1108,6 +1257,11 @@ function collectResolvedFields(input) {
 			sources: input.sources,
 			binder: input.binder,
 			columnDescriptor: descriptor,
+			isListColumn,
+			valueObjectDefault: valueObjectName === void 0 ? void 0 : {
+				valueObjectName,
+				types: valueObjectTypes
+			},
 			generatorDescriptorById,
 			defaultFunctionRegistry,
 			dataTypeSupport,
@@ -1183,7 +1337,7 @@ function collectResolvedFields(input) {
 			field,
 			sources: input.sources,
 			binder: input.binder,
-			isListField: isListField && !isValueObjectField,
+			isListColumn,
 			isDomainEnum: enumHandle !== void 0,
 			diagnostics
 		}) : void 0;
@@ -1200,8 +1354,7 @@ function collectResolvedFields(input) {
 			...ifDefined("uniqueName", uniqueName),
 			...ifDefined("many", isListField ? true : void 0),
 			...ifDefined("noCheck", noCheckKinds),
-			...ifDefined("valueObjectTypeName", isValueObjectField ? field.typeName : void 0),
-			...ifDefined("scalarCodecId", scalarCodecId)
+			...ifDefined("valueObjectTypeName", valueObjectName)
 		});
 	}
 	return resolvedFields;
@@ -1972,6 +2125,7 @@ function buildModelNodeFromPsl(input) {
 		symbolTable: input.symbolTable,
 		enumTypeDescriptors: input.enumTypeDescriptors,
 		namedTypeDescriptors: input.namedTypeDescriptors,
+		valueObjectTypes: input.valueObjectTypes,
 		composedExtensions: input.composedExtensions,
 		authoringContributions: input.authoringContributions,
 		familyId: input.familyId,
@@ -2548,17 +2702,23 @@ function buildModelNodeFromPsl(input) {
 			modelName: model.name,
 			tableName,
 			fields: resolvedFields.map((resolvedField) => {
-				const enumHandle = input.enumHandles?.get(resolvedField.field.typeName);
-				return {
+				const common = {
 					fieldName: resolvedField.field.name,
 					columnName: resolvedField.columnName,
 					descriptor: resolvedField.descriptor,
 					nullable: resolvedField.nullable,
-					...resolvedField.many && resolvedField.valueObjectTypeName === void 0 ? { many: true } : {},
+					...ifDefined("many", resolvedField.many),
 					...ifDefined("default", resolvedField.defaultValue),
-					...ifDefined("executionDefaults", resolvedField.executionDefaults),
+					...ifDefined("executionDefaults", resolvedField.executionDefaults)
+				};
+				if (resolvedField.valueObjectTypeName !== void 0) return {
+					...common,
+					valueObjectName: resolvedField.valueObjectTypeName
+				};
+				return {
+					...common,
 					...ifDefined("noCheck", resolvedField.noCheck),
-					...ifDefined("enumTypeHandle", enumHandle)
+					...ifDefined("enumTypeHandle", input.enumHandles?.get(resolvedField.field.typeName))
 				};
 			}),
 			...ifDefined("id", primaryKey),
@@ -2572,44 +2732,53 @@ function buildModelNodeFromPsl(input) {
 		invalidFkPairings: resultInvalidFkPairings,
 		crossSpaceRelations: resultCrossSpaceRelations,
 		backrelationCandidates: resultBackrelationCandidates,
-		resolvedFields,
 		modelAttributeEntities
 	};
 }
-function buildValueObjects(input) {
-	const { compositeTypes, enumTypeDescriptors, namedTypeDescriptors, scalarColumnDescriptors, composedExtensions, familyId, targetId, authoringContributions, diagnostics, sources, binder } = input;
-	const valueObjects = {};
-	for (const compositeType of compositeTypes) {
-		const fields = {};
+function buildValueObjectNodes(input) {
+	const { compositeTypes, enumHandles, diagnostics, sources, binder } = input;
+	return compositeTypes.map((compositeType) => {
+		for (const attribute of compositeType.attributes) diagnostics.push({
+			code: "PSL_UNSUPPORTED_COMPOSITE_TYPE_ATTRIBUTE",
+			message: `Composite type "${compositeType.name}" uses attribute "@@${attribute.name}", which a composite type does not take`,
+			...diagnosticSource(sources, compositeType.node.syntax).at(attribute.span)
+		});
+		const fields = [];
 		for (const field of Object.values(compositeType.fields)) {
+			for (const attribute of field.attributes) diagnostics.push({
+				code: "PSL_UNSUPPORTED_FIELD_ATTRIBUTE",
+				message: `Member "${field.name}" of composite type "${compositeType.name}" uses attribute "@${attribute.name}", which a composite type member does not take`,
+				...diagnosticSource(sources, field.node.syntax).at(attribute.span)
+			});
+			const common = {
+				fieldName: field.name,
+				nullable: field.optional,
+				...ifDefined("many", field.list ? true : void 0)
+			};
 			const fieldTypeReference = typeReferenceNode(field);
 			const fieldTypeResolution = fieldTypeReference === void 0 ? void 0 : binder.symbolForNode(fieldTypeReference);
 			if (fieldTypeResolution?.kind === "compositeType") {
-				const result = {
-					type: {
-						kind: "valueObject",
-						name: fieldTypeResolution.symbol.name
-					},
-					nullable: field.optional
-				};
-				fields[field.name] = field.list ? {
-					...result,
-					many: true
-				} : result;
+				fields.push({
+					...common,
+					valueObjectName: fieldTypeResolution.symbol.name
+				});
 				continue;
 			}
 			const resolved = resolveFieldTypeDescriptor({
 				field,
-				enumTypeDescriptors,
-				namedTypeDescriptors,
-				scalarColumnDescriptors,
-				authoringContributions,
-				composedExtensions,
-				familyId,
-				targetId,
+				enumTypeDescriptors: input.enumTypeDescriptors,
+				namedTypeDescriptors: input.namedTypeDescriptors,
+				scalarColumnDescriptors: input.scalarColumnDescriptors,
+				authoringContributions: input.authoringContributions,
+				composedExtensions: input.composedExtensions,
+				familyId: input.familyId,
+				targetId: input.targetId,
 				diagnostics,
 				sources,
-				entityLabel: `Field "${compositeType.name}.${field.name}"`
+				entityLabel: `Field "${compositeType.name}.${field.name}"`,
+				namespaceId: input.defaultNamespaceId,
+				...ifDefined("namespaceExtensionEntities", input.defaultNamespaceExtensionEntities),
+				...ifDefined("codecLookup", input.codecLookup)
 			});
 			if (!resolved.ok) {
 				if (!resolved.alreadyReported && fieldTypeResolution?.kind !== "unresolved") diagnostics.push({
@@ -2619,62 +2788,29 @@ function buildValueObjects(input) {
 				});
 				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;
-			const builtType = model.fields[rf.field.name]?.type;
-			const typeParams = builtType?.kind === "scalar" ? builtType.typeParams : void 0;
-			patchedFields[rf.field.name] = {
-				nullable: rf.field.optional,
-				type: {
-					kind: "scalar",
-					codecId: rf.scalarCodecId,
-					...ifDefined("typeParams", typeParams)
+			const { descriptor } = resolved;
+			if (descriptor.valueSet !== void 0) {
+				diagnostics.push({
+					code: "PSL_UNSUPPORTED_FIELD_TYPE",
+					message: `Field "${compositeType.name}.${field.name}" is typed by the storage enum "${descriptor.valueSet.entityName}", which a composite type member cannot use: a member has no column to store it in. Use a PSL enum instead.`,
+					...diagnosticSource(sources, field.node.syntax).at(field.span)
+				});
+				continue;
+			}
+			fields.push({
+				...common,
+				descriptor: {
+					codecId: descriptor.codecId,
+					...ifDefined("typeParams", resolvedTypeParams(descriptor, input.namedTypes))
 				},
-				many: true
-			};
+				...ifDefined("enumTypeHandle", enumHandles.get(field.typeName))
+			});
 		}
-		if (needsPatch) patched = {
-			...patched,
-			[modelName]: {
-				...model,
-				fields: patchedFields
-			}
+		return {
+			name: compositeType.name,
+			fields
 		};
-	}
-	return patched;
+	});
 }
 function collectPolymorphismDeclarations(identities, symbols, sources, binder, diagnostics) {
 	const discriminatorDeclarations = /* @__PURE__ */ new Map();
@@ -2855,7 +2991,7 @@ function materializeMtiVariantStorageLinks(modelNodes, baseDeclarations, stiVari
 			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);
+				const baseField = baseNode.fields.find((field) => field.columnName === pkColumn);
 				if (!baseField) continue;
 				linkFields.push({
 					fieldName: baseField.fieldName,
@@ -3248,15 +3384,36 @@ function interpretPslDocumentToSqlContract(input) {
 	const fkRelationMetadata = [];
 	const invalidFkPairings = [];
 	const backrelationCandidates = [];
-	const modelResolvedFields = /* @__PURE__ */ new Map();
 	const crossSpaceRelationsByModel = /* @__PURE__ */ new Map();
 	const modelAttributeEntitiesByNamespace = /* @__PURE__ */ new Map();
+	const valueObjects = buildValueObjectNodes({
+		compositeTypes,
+		enumTypeDescriptors: allEnumTypeDescriptors,
+		enumHandles: enumHandlesByName,
+		namedTypeDescriptors: namedTypeResult.namedTypeDescriptors,
+		namedTypes: namedTypeResult.storageTypes,
+		scalarColumnDescriptors: input.scalarColumnDescriptors,
+		composedExtensions,
+		familyId: input.target.familyId,
+		targetId: input.target.targetId,
+		authoringContributions: input.authoringContributions,
+		diagnostics,
+		sources: input.sources,
+		defaultNamespaceId,
+		defaultNamespaceExtensionEntities: namespaceExtensionEntities.get(defaultNamespaceId),
+		codecLookup: input.codecLookup,
+		binder
+	});
+	const valueObjectTypes = {
+		nodes: new Map(valueObjects.map((valueObject) => [valueObject.name, valueObject])),
+		declaredMembers: new Map(compositeTypes.map((compositeType) => [compositeType.name, new Set(Object.keys(compositeType.fields))]))
+	};
 	for (const { model, namespaceId } of modelEntries) {
-		const coordinate = modelCoordinateKey(namespaceId ?? defaultNamespaceId, model.name);
 		const result = buildModelNodeFromPsl({
 			model,
 			physicalNames,
 			namespaceId,
+			valueObjectTypes,
 			enumTypeDescriptors: allEnumTypeDescriptors,
 			namedTypeDescriptors: namedTypeResult.namedTypeDescriptors,
 			composedExtensions,
@@ -3288,7 +3445,6 @@ function interpretPslDocumentToSqlContract(input) {
 		fkRelationMetadata.push(...result.fkRelationMetadata);
 		invalidFkPairings.push(...result.invalidFkPairings);
 		backrelationCandidates.push(...result.backrelationCandidates);
-		modelResolvedFields.set(coordinate, result.resolvedFields);
 		if (result.crossSpaceRelations.length > 0) {
 			const existing = crossSpaceRelationsByModel.get(model) ?? [];
 			crossSpaceRelationsByModel.set(model, [...existing, ...result.crossSpaceRelations]);
@@ -3358,19 +3514,6 @@ function interpretPslDocumentToSqlContract(input) {
 		...modelRelations.has(symbol) ? { relations: [...modelRelations.get(symbol) ?? []].sort((left, right) => compareStrings(left.fieldName, right.fieldName)) } : {}
 	})), baseDeclarations, stiVariantKeys, defaultNamespaceId);
 	const { modelNodes: stiColumnModelNodes, stiBaseFieldsByBase } = materializeStiVariantStorageColumns(mtiLinkedModelNodes, baseDeclarations, stiVariantKeys, defaultNamespaceId);
-	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,
-		sources: input.sources,
-		binder
-	});
 	if (diagnostics.length > 0 || (input.seedDiagnostics?.length ?? 0) > 0) return notOk({
 		summary: "PSL to SQL contract interpretation failed",
 		diagnostics: [...input.seedDiagnostics ?? [], ...diagnostics.toExternal()]
@@ -3409,17 +3552,17 @@ function interpretPslDocumentToSqlContract(input) {
 		...Object.keys(validEnumHandles).length > 0 ? { enums: validEnumHandles } : {},
 		...namespaceExtensionEntities.size > 0 ? { namespaces: [...namespaceExtensionEntities.keys()] } : {},
 		createNamespace: createNamespaceWithExtensions,
+		...ifDefined("valueObjects", valueObjects.length > 0 ? valueObjects : void 0),
 		models: stiColumnModelNodes
 	}, input.codecLookup);
-	const modelsForPatch = {};
+	const modelsByCoordinate = {};
 	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;
+		invariant(!Object.hasOwn(modelsByCoordinate, coordinate), `symbol table guarantees coordinate uniqueness; duplicate model "${namespaceId}.${modelName}" reached interpretation`);
+		modelsByCoordinate[coordinate] = model;
 	}
-	let patchedModels = patchModelDomainFields(modelsForPatch, modelResolvedFields);
 	const polyDiagnostics = createPslDiagnosticCollector(input.sources);
-	patchedModels = resolvePolymorphism(patchedModels, physicalNames, discriminatorDeclarations, baseDeclarations, syntheticPkFieldsByVariant, stiBaseFieldsByBase, polyDiagnostics);
+	const polymorphicModels = resolvePolymorphism(modelsByCoordinate, physicalNames, discriminatorDeclarations, baseDeclarations, syntheticPkFieldsByVariant, stiBaseFieldsByBase, polyDiagnostics);
 	if (polyDiagnostics.length > 0) return notOk({
 		summary: "PSL to SQL contract interpretation failed",
 		diagnostics: polyDiagnostics.toExternal()
@@ -3429,14 +3572,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[modelCoordinateKey(namespaceId, modelName)] ?? model])),
+			models: Object.fromEntries(Object.entries(namespaceSlice.models).map(([modelName, model]) => [modelName, polymorphicModels[modelCoordinateKey(namespaceId, modelName)] ?? model])),
 			...ifDefined("enum", namespaceSlice.enum),
-			...ifDefined("valueObjects", namespaceSlice.valueObjects),
-			...namespaceId === input.target.defaultNamespaceId && Object.keys(valueObjects).length > 0 ? { valueObjects } : {}
+			...ifDefined("valueObjects", namespaceSlice.valueObjects)
 		}])) }
 	});
 }
 //#endregion
 export { interpretPslDocumentToSqlContract as a, resolveFieldTypeDescriptor as c, indexFkRelations as i, buildEntityTypesByDiscriminator as n, normalizeReferentialAction as o, entryForTag as r, readDataTypeDefault as s, applyBackrelationCandidates as t };
 
-//# sourceMappingURL=interpreter-Bcc3MIC5-C4dZrobt.mjs.map
+//# sourceMappingURL=interpreter-j1ewAXPb-BwieIKeF.mjs.map