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

package/dist/{psl-field-resolution-DpGsATq3-BREG9FbU.mjs → psl-field-resolution-C9zwpsAu-DCc7Eifv.mjs}

@@ -1,12 +1,11 @@
 import { u as sqlCodecColumnLength } from "./sql-data-type-D7M-YTTY-C9oWGZ3z.mjs";
 import { p as sqlTextFromStored, t as SQL_EXPRESSION_DATA_TYPE_ID } from "./sql-expression-BJCuy-WI.mjs";
-import { d as resolvedTypeParams } from "./types-M_FeBD9w.mjs";
-import { n as checkSqlDefaultText, o as reservedSqlDefaultText } from "./validators-Cfy0jmZ2.mjs";
-import { a as storedAsListColumn, i as isValueObjectMember } from "./derived-checks-CXW9ytkb-B_zxX1-8.mjs";
+import { n as checkSqlDefaultText, o as reservedSqlDefaultText } from "./validators-xXKEHvnw.mjs";
+import { i as isValueObjectMember, o as storedAsListColumn } from "./derived-checks-iXF3y0Ki-28vqz_8w.mjs";
 import { n as getAttribute, o as storageName, t as formatDbAttributeMigrationMessage } from "./psl-attribute-parsing-BCsFWsSp-LaNsbcrw.mjs";
 import { structuredError } from "@prisma/orm-framework/utils/structured-error";
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
-import { admittedForms, castTypedValue, describeExpected, describeRefusal, describeRefusedValueType, exactRewrite, instantiateAuthoringTypeConstructor, isAuthoringEntityTypeDescriptor, readWrittenValue, tagForm, validateAuthoringHelperArguments, validateAuthoringTypeParams } from "@prisma/orm-framework/components/authoring";
+import { admittedForms, castTypedValue, describeExpected, describeRefusal, describeRefusedValueType, exactRewrite, instantiateAuthoringTypeAlias, instantiateAuthoringTypeConstructor, isAuthoringEntityTypeDescriptor, readWrittenValue, tagForm, validateAuthoringHelperArguments, validateAuthoringTypeParams } from "@prisma/orm-framework/components/authoring";
 import { codecForRef, dataTypeParams, readContractValue } from "@prisma/orm-framework/components/codec";
 import { blindCast } from "@prisma/orm-framework/utils/casts";
 import { InternalError, isInternalError } from "@prisma/orm-framework/utils/internal-error";
@@ -14,9 +13,9 @@ import { FunctionCallAst } from "@prisma/orm-framework/psl-parser/syntax";
 import { invariant } from "@prisma/orm-framework/utils/assertions";
 import { notOk, ok } from "@prisma/orm-framework/utils/result";
 import { describeTaggedLiteralFailure as describeTaggedLiteralFailure$1 } from "@prisma/orm-framework/components/control";
-import { bool, contributedTypeOf, dataTypeValue, diagnosticSource, entityRef, fieldAttribute, fieldRef, funcCall, generatorAttributeSpec, identifier, interpretAttribute, leafDiagnostic, list, mapArg, modelAttribute, nodePslSpan, nodeSourceText, numLiteral, oneOf, optional, record, referencedFieldRef, str, taggedLiteral, typeReferenceNode, writtenList, writtenScalar } from "@prisma/orm-framework/psl-parser";
+import { bool, contributedTypeCodecId, contributedTypeOf, dataTypeValue, diagnosticSource, entityRef, fieldAttribute, fieldRef, funcCall, generatorAttributeSpec, identifier, interpretAttribute, leafDiagnostic, list, mapArg, modelAttribute, nodePslSpan, nodeSourceText, numLiteral, oneOf, optional, record, referencedFieldRef, refuseRepeatedTypeAliasAttributes, str, taggedLiteral, typeAttribute, typeAttributeSpecContextOfField, typeAttributeSubjectLabel, typeGeneratorAttributeSpec, typeReferenceNode, writtenList, writtenScalar } from "@prisma/orm-framework/psl-parser";
 import { instantiatePslFieldPreset, isBareTypeConstructor, mapPslHelperArgs, reportPresetNotCalled, reportTypeConstructorNotCalled } from "@prisma/orm-framework/psl-parser/interpret";
-//#region ../../../2-sql/2-authoring/contract-psl/dist/psl-field-resolution-DpGsATq3.mjs
+//#region ../../../2-sql/2-authoring/contract-psl/dist/psl-field-resolution-C9zwpsAu.mjs
 function contractError(code, message, options) {
 	return structuredError(code, message, options);
 }
@@ -230,13 +229,16 @@ function rewriteOf(refusal, written, dataTypes) {
 * defaults have at the `@default` attribute.
 */
 function lowerDataTypeDefault(input) {
-	const read = readDataTypeDefault(input);
+	const read = readDataTypeDefault({
+		...input,
+		fieldPath: input.subject
+	});
 	if (read.ok) return read;
 	const refusal = atSourceElement(read.refusal, input.sourceElementIndexes);
 	return {
 		ok: false,
-		...refusalMessage(refusal, `Field "${input.fieldPath}"`, input.dataTypes, guidanceFor(read, input.written, input.dataTypes)),
-		span: refusalSpan(refusal, input.spans, input.fieldPath)
+		...refusalMessage(refusal, input.subject, input.dataTypes, guidanceFor(read, input.written, input.dataTypes)),
+		span: refusalSpan(refusal, input.spans, input.subject)
 	};
 }
 /**
@@ -311,17 +313,17 @@ function refusalMessage(refusal, subject, dataTypes, guidance) {
 		}
 	}
 }
-function refusalSpan(refusal, spans, fieldPath) {
+function refusalSpan(refusal, spans, subject) {
 	switch (refusal.kind) {
 		case "not-a-list":
 		case "refused-by-column": return spans.attribute;
-		default: return writtenValueSpan(spans, refusal.elementIndex, fieldPath);
+		default: return writtenValueSpan(spans, refusal.elementIndex, subject);
 	}
 }
-function writtenValueSpan(spans, elementIndex, fieldPath) {
+function writtenValueSpan(spans, elementIndex, subject) {
 	if (elementIndex === void 0) return spans.value;
 	const span = spans.elements[elementIndex];
-	if (span === void 0) throw new InternalError(`Field "${fieldPath}": a refused @default list element ${elementIndex + 1} has no written span.`);
+	if (span === void 0) throw new InternalError(`${subject}: a refused @default list element ${elementIndex + 1} has no written span.`);
 	return span;
 }
 function formatSupportedFunctionList(registry) {
@@ -407,6 +409,19 @@ function interpretFieldAttribute(input) {
 	}
 	return result.value;
 }
+/** Interprets an attribute that reads only its type, such as `@default` on a field or a type alias, draining parse failures into `diagnostics`. */
+function interpretTypeAttribute(input) {
+	const result = interpretAttribute(input.node, input.spec, {
+		sources: input.sources,
+		symbols: input.symbols,
+		binder: input.binder
+	});
+	if (!result.ok) {
+		input.diagnostics.push(...result.failure);
+		return;
+	}
+	return result.value;
+}
 function validateMappedName(value, ctx, attributeNode) {
 	return value.name === "" ? [leafDiagnostic(ctx, attributeNode, "Mapped name must not be empty")] : [];
 }
@@ -452,7 +467,7 @@ function defaultFunctionCall(name, entry, dataTypes) {
 /** The data type of the column a field declares, when its type, or the named type it is declared with, is a constructor or preset the stack knows. */
 function receivingDataType(ctx) {
 	const typeConstructor = ctx.typeConstructor;
-	return typeConstructor === void 0 ? void 0 : ctx.dataTypes.dataTypeOfCodec(typeConstructor.descriptor.output.codecId);
+	return typeConstructor === void 0 ? void 0 : ctx.dataTypes.dataTypeOfCodec(contributedTypeCodecId(typeConstructor.descriptor));
 }
 /** Whether a value of `type` can be written for a column of `receiving`: it is that type, or the column's type casts from it. An unknown column takes every type. */
 function receives(dataTypes, receiving, type) {
@@ -497,7 +512,7 @@ function scalarDefaultArms(isList, receiving, dataTypes, defaultFunctionRegistry
 * The `@default` value arms, with a `dbgenerated(...)` call reported as removed before the arms
 * are tried, so the author is told what replaced it instead of being shown the list of arms.
 */
-function defaultValueArm(arms, registry, generatorFunctions, fieldPath) {
+function defaultValueArm(arms, registry, generatorFunctions, subject) {
 	const value = arms.length === 1 && arms[0].kind === "list" ? arms[0] : oneOf(...arms);
 	return {
 		...value,
@@ -506,7 +521,7 @@ function defaultValueArm(arms, registry, generatorFunctions, fieldPath) {
 			if (callee === "dbgenerated") return notOk([leafDiagnostic(ctx, arg, removedDbgeneratedMessage(registry), "PSL_UNKNOWN_DEFAULT_FUNCTION")]);
 			if (callee !== void 0 && !registry.has(callee) && generatorFunctions.has(callee)) {
 				const call = nodeSourceText(arg, ctx);
-				return notOk([leafDiagnostic(ctx, arg, `Field "${fieldPath}": ${call} is a value the client generates, and @default sets a database default only. Write @onCreate(${call}) instead.`, "PSL_GENERATOR_IN_DEFAULT")]);
+				return notOk([leafDiagnostic(ctx, arg, `${subject}: ${call} is a value the client generates, and @default sets a database default only. Write @onCreate(${call}) instead.`, "PSL_GENERATOR_IN_DEFAULT")]);
 			}
 			return value.parse(arg, ctx);
 		}
@@ -547,13 +562,14 @@ function enumDefaultArms(members, enumName, isList) {
 	}))];
 	return [member(first), ...rest.map(member)];
 }
-function defaultFieldSpec(ctx) {
+/** The spec of `@default` on a field or a type alias, offering the values its type takes. */
+function typeDefaultSpec(ctx) {
 	const members = enumMemberNames(ctx);
-	return fieldAttribute("default", {
+	return typeAttribute("default", {
 		documentation: "Supplies a default value when this field is omitted from a mutation.",
 		positional: [{
 			key: "value",
-			type: defaultValueArm(members === void 0 ? scalarDefaultArms(ctx.field.list, receivingDataType(ctx), ctx.dataTypes, ctx.defaultFunctionRegistry) : enumDefaultArms(members, ctx.field.typeName, ctx.field.list), ctx.defaultFunctionRegistry, ctx.generatorFunctions, `${ctx.model.name}.${ctx.field.name}`),
+			type: defaultValueArm(members === void 0 ? scalarDefaultArms(ctx.list, receivingDataType(ctx), ctx.dataTypes, ctx.defaultFunctionRegistry) : enumDefaultArms(members, ctx.typeName, ctx.list), ctx.defaultFunctionRegistry, ctx.generatorFunctions, typeAttributeSubjectLabel(ctx.subject)),
 			documentation: "A literal, enum member, or registered default function compatible with this field."
 		}]
 	});
@@ -822,7 +838,7 @@ const sqlAttributeSpecs = {
 		id: (_ctx) => idFieldSpec,
 		unique: (_ctx) => uniqueFieldSpec,
 		relation: (_ctx) => relationFieldSpec,
-		default: defaultFieldSpec,
+		default: (ctx) => typeDefaultSpec(typeAttributeSpecContextOfField(ctx)),
 		onCreate: generatorAttributeSpec("onCreate"),
 		onUpdate: generatorAttributeSpec("onUpdate")
 	}
@@ -962,12 +978,6 @@ function jsonKind(value) {
 	if (typeof value === "object") return "a JSON object";
 	return `a JSON ${typeof value}`;
 }
-function toNamedTypeFieldDescriptor(typeRef, descriptor) {
-	return {
-		codecId: descriptor.codecId,
-		typeRef
-	};
-}
 function argumentSpan(call, descriptors, index) {
 	if (index === void 0) return call.span;
 	const name = descriptors?.[index]?.name;
@@ -1192,15 +1202,10 @@ function instantiateFieldPreset(input) {
 		presetContributions
 	};
 }
-function bareTypeConstructorOf(resolution) {
-	if (resolution?.kind !== "contributedType") return void 0;
-	const { descriptor } = resolution.symbol;
-	return descriptor.kind === "typeConstructor" && isBareTypeConstructor(descriptor) ? descriptor : void 0;
-}
 function resolvedKindLabel(resolution) {
 	switch (resolution.kind) {
 		case "compositeType": return "composite type";
-		case "namedType": return "named type";
+		case "namedType": return "type alias";
 		case "block": return resolution.symbol.keyword;
 		case "crossSpace": return "type of another contract space";
 		default: return resolution.kind;
@@ -1227,6 +1232,20 @@ function resolveFieldTypeDescriptor(input) {
 		case "contributedType": {
 			const { descriptor, path } = resolution.symbol;
 			const written = path.join(".");
+			if (descriptor.kind === "typeAlias") {
+				if (call !== void 0) {
+					diagnostics.push({
+						code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+						message: `${written} is a type alias and takes no arguments.`,
+						...source.at(call.span)
+					});
+					return NOT_RESOLVED;
+				}
+				return {
+					ok: true,
+					descriptor: instantiateAuthoringTypeAlias(descriptor).type
+				};
+			}
 			if (descriptor.kind === "fieldPreset") {
 				if (call === void 0) {
 					reportPresetNotCalled({
@@ -1279,10 +1298,10 @@ function resolveFieldTypeDescriptor(input) {
 	if (call !== void 0) return unsupported(`${entityLabel} calls "${call.path.join(".")}", which is a ${resolvedKindLabel(resolution)}, not a type constructor. Remove the arguments.`);
 	switch (resolution.kind) {
 		case "namedType": {
-			const descriptor = input.namedTypeDescriptors.get(resolution.symbol);
-			return descriptor === void 0 ? NOT_RESOLVED : {
+			const alias = input.typeAliases.get(resolution.symbol);
+			return alias === void 0 ? NOT_RESOLVED : {
 				ok: true,
-				descriptor
+				descriptor: alias.descriptor
 			};
 		}
 		case "block": {
@@ -1308,12 +1327,12 @@ const TAGGED_LITERAL_CANONICALIZATION_CODES = {
 * at the first `null`. Returns whether it refused.
 */
 function rejectStrictListNullDefault(input) {
-	if (input.field.elementOptional) return false;
+	if (input.owner.elementOptional) return false;
 	const nullElement = input.elements.find(isParsedNullLiteral);
 	if (nullElement === void 0) return false;
 	input.diagnostics.push({
 		code: "PSL_INVALID_DEFAULT_APPLICABILITY",
-		message: `Field "${input.modelName}.${input.field.name}" has strict list elements and cannot use null in a literal list default. Make the element type nullable or remove null from the default.`,
+		message: `${typeAttributeSubjectLabel(input.owner.specContext.subject)} has strict list elements and cannot use null in a literal list default. Make the element type nullable or remove null from the default.`,
 		...input.source.at(nullElement.span)
 	});
 	return true;
@@ -1321,25 +1340,44 @@ function rejectStrictListNullDefault(input) {
 function isParsedNullLiteral(element) {
 	return element.kind === "null";
 }
+function fieldAttributeOwner(input) {
+	const { field, model } = input;
+	return {
+		attributes: field.attributes,
+		optional: field.optional,
+		list: field.list,
+		elementOptional: field.elementOptional,
+		specContext: typeAttributeSpecContextOfField(fieldSpecContext({
+			symbols: input.symbolTable,
+			model,
+			field,
+			binder: input.binder,
+			defaultFunctionRegistry: input.defaultFunctionRegistry,
+			generatorFunctions: input.generatorFunctions,
+			dataTypes: input.dataTypes
+		})),
+		loweringNames: {
+			modelName: model.name,
+			fieldName: field.name
+		}
+	};
+}
 function lowerDefaultForField(input) {
-	const node = getAttribute(input.field.attributes, "default")?.node;
+	return lowerTypeDefault({
+		...input,
+		owner: fieldAttributeOwner(input)
+	});
+}
+/** The default a field's or type alias's `@default(...)` lowers to for its column. */
+function lowerTypeDefault(input) {
+	const node = getAttribute(input.owner.attributes, "default")?.node;
 	if (node === void 0) return {};
 	const source = diagnosticSource(input.sources, node.syntax);
-	const spec = sqlAttributeSpecs.field.default(fieldSpecContext({
-		symbols: input.symbolTable,
-		model: input.model,
-		field: input.field,
-		binder: input.binder,
-		defaultFunctionRegistry: input.defaultFunctionRegistry,
-		generatorFunctions: input.generatorFunctions,
-		dataTypes: input.dataTypes
-	}));
-	const interpreted = interpretFieldAttribute({
+	const subject = typeAttributeSubjectLabel(input.owner.specContext.subject);
+	const interpreted = interpretTypeAttribute({
 		symbols: input.symbolTable,
 		node,
-		spec,
-		model: input.model,
-		field: input.field,
+		spec: typeDefaultSpec(input.owner.specContext),
 		sources: input.sources,
 		binder: input.binder,
 		diagnostics: input.diagnostics
@@ -1348,10 +1386,10 @@ function lowerDefaultForField(input) {
 	const value = interpreted.value;
 	const attributeSpan = nodePslSpan(node.syntax, input.sources);
 	if (value.kind === "null") {
-		if (!input.field.optional) {
+		if (!input.owner.optional) {
 			input.diagnostics.push({
 				code: "PSL_INVALID_DEFAULT_APPLICABILITY",
-				message: `Field "${input.modelName}.${input.fieldName}" is non-nullable and cannot use null as its literal default. Make the field nullable or use a non-null default.`,
+				message: `${subject} is non-nullable and cannot use null as its literal default. Make the field nullable or use a non-null default.`,
 				...source.at()
 			});
 			return {};
@@ -1367,7 +1405,7 @@ function lowerDefaultForField(input) {
 		elements: value.elements,
 		source
 	})) return {};
-	const readsListElements = (written) => input.isListColumn || input.field.list && written.kind === "list";
+	const readsListElements = (written) => input.isListColumn || input.owner.list && written.kind === "list";
 	const readAsLiteral = (written, spans, sourceElementIndexes) => {
 		const lowered = lowerDataTypeDefault({
 			written,
@@ -1380,7 +1418,7 @@ function lowerDefaultForField(input) {
 			},
 			codecLookup: input.codecLookup,
 			dataTypes: input.dataTypes,
-			fieldPath: `${input.modelName}.${input.fieldName}`
+			subject
 		});
 		if (!lowered.ok) {
 			input.diagnostics.push({
@@ -1404,11 +1442,11 @@ function lowerDefaultForField(input) {
 				codecLookup: input.codecLookup
 			});
 			const mismatches = valueObjectDefaultMismatches({
-				fieldPath: `${input.modelName}.${input.fieldName}`,
+				fieldPath: input.owner.specContext.subject.name,
 				value: document,
-				list: input.field.list,
-				nullable: input.field.optional,
-				elementNullable: input.field.elementOptional,
+				list: input.owner.list,
+				nullable: input.owner.optional,
+				elementNullable: input.owner.elementOptional,
 				...input.valueObjectDefault,
 				lookups: {
 					codecLookup: input.codecLookup,
@@ -1510,8 +1548,7 @@ function lowerDefaultForField(input) {
 	const { call } = value;
 	const context = {
 		sourceId: input.sources.sourceFileFor(node.syntax).filename,
-		modelName: input.modelName,
-		fieldName: input.fieldName,
+		...input.owner.loweringNames,
 		columnCodecId: input.columnDescriptor.codecId
 	};
 	const lowered = lowerDefaultFunctionWithRegistry({
@@ -1530,34 +1567,32 @@ function lowerDefaultForField(input) {
 const GENERATOR_PHASES = ["onCreate", "onUpdate"];
 /** The generators a field's `@onCreate(fn())` and `@onUpdate(fn())` resolve to for its column, or `undefined` for a field with neither. */
 function lowerGeneratorAttributesForField(input) {
-	const specContext = fieldSpecContext({
-		symbols: input.symbolTable,
-		model: input.model,
-		field: input.field,
-		binder: input.binder,
-		defaultFunctionRegistry: input.defaultFunctionRegistry,
-		generatorFunctions: input.generatorFunctions,
-		dataTypes: input.dataTypes
+	return lowerTypeGenerators({
+		...input,
+		owner: fieldAttributeOwner(input)
 	});
+}
+/** The generators the `@onCreate(fn())` and `@onUpdate(fn())` of a field or type alias resolve to for its column, or `undefined` when it has neither. */
+function lowerTypeGenerators(input) {
+	const { subject } = input.owner.specContext;
+	const label = typeAttributeSubjectLabel(subject);
 	const phases = {};
 	for (const phase of GENERATOR_PHASES) {
-		const [attribute, duplicate] = input.field.attributes.filter(({ name }) => name === phase);
+		const [attribute, duplicate] = input.owner.attributes.filter(({ name }) => name === phase);
 		if (attribute === void 0) continue;
 		if (duplicate !== void 0) {
 			input.diagnostics.push({
 				code: "PSL_DUPLICATE_ATTRIBUTE",
-				message: `\`@${phase}\` declared more than once on field "${input.modelName}.${input.fieldName}".`,
+				message: `\`@${phase}\` declared more than once on ${subject.kind} "${subject.name}".`,
 				...diagnosticSource(input.sources, duplicate.node.syntax).at(duplicate.span)
 			});
 			continue;
 		}
 		const node = attribute.node;
-		const interpreted = interpretFieldAttribute({
+		const interpreted = interpretTypeAttribute({
 			symbols: input.symbolTable,
 			node,
-			spec: sqlAttributeSpecs.field[phase](specContext),
-			model: input.model,
-			field: input.field,
+			spec: typeGeneratorAttributeSpec(phase, input.owner.specContext),
 			sources: input.sources,
 			binder: input.binder,
 			diagnostics: input.diagnostics
@@ -1578,31 +1613,22 @@ function lowerGeneratorAttributesForField(input) {
 		}
 		input.diagnostics.push({
 			code: "PSL_GENERATOR_NOT_APPLICABLE",
-			message: resolution.reason === "refused" ? `Field "${input.modelName}.${input.fieldName}": ${resolution.message}` : `Field "${input.modelName}.${input.fieldName}": ${call.fn}() does not apply to codec "${input.columnDescriptor.codecId}".`,
+			message: resolution.reason === "refused" ? `${label}: ${resolution.message}` : `${label}: ${call.fn}() does not apply to codec "${input.columnDescriptor.codecId}".`,
 			...diagnosticSource(input.sources, node.syntax).at(call.span)
 		});
 	}
 	return phases.onCreate === void 0 && phases.onUpdate === void 0 ? void 0 : phases;
 }
-function lowerEnumDefaultForField(input) {
-	const { field, model, enumHandle, diagnostics } = input;
-	const node = getAttribute(field.attributes, "default")?.node;
+/** The default a field's or type alias's `@default(...)` names among the members of its enum. */
+function lowerEnumDefault(input) {
+	const { owner, enumHandle, diagnostics } = input;
+	const node = getAttribute(owner.attributes, "default")?.node;
 	if (node === void 0) return {};
 	if (enumHandle.enumMembers.length === 0) return {};
-	const interpreted = interpretFieldAttribute({
+	const interpreted = interpretTypeAttribute({
 		node,
-		spec: sqlAttributeSpecs.field.default(fieldSpecContext({
-			symbols: input.symbolTable,
-			model,
-			field,
-			binder: input.binder,
-			defaultFunctionRegistry: input.defaultFunctionRegistry,
-			generatorFunctions: input.generatorFunctions,
-			dataTypes: input.dataTypes
-		})),
+		spec: typeDefaultSpec(owner.specContext),
 		symbols: input.symbolTable,
-		model,
-		field,
 		sources: input.sources,
 		binder: input.binder,
 		diagnostics
@@ -1611,9 +1637,10 @@ function lowerEnumDefaultForField(input) {
 	const member = interpreted.value;
 	if (member.kind === "member-list") {
 		if (rejectStrictListNullDefault({
-			...input,
+			owner,
 			elements: member.elements,
-			source: diagnosticSource(input.sources, node.syntax)
+			source: diagnosticSource(input.sources, node.syntax),
+			diagnostics
 		})) return {};
 		return { defaultValue: {
 			kind: "literal",
@@ -1634,7 +1661,7 @@ function modelCoordinateKey(namespaceId, modelName) {
 }
 const GENERATOR_ATTRIBUTE_NAMES = ["onCreate", "onUpdate"];
 const REMOVED_ATTRIBUTE_RULES = /* @__PURE__ */ new Map([["updatedAt", {
-	hint: "Use @onCreate(now()) @onUpdate(now()) instead.",
+	hint: "Use @onCreate(now()) @onUpdate(now()), or type the field temporal.UpdatedAt.",
 	suppressWhen: (field) => field.attributes.some((attribute) => attribute.name === "onUpdate")
 }]]);
 {
@@ -1701,7 +1728,7 @@ function extractFieldConstraintNames(input) {
 	};
 }
 function collectResolvedFields(input) {
-	const { model, symbolTable, enumTypeDescriptors, namedTypeDescriptors, valueObjectTypes, authoringContributions, binder, targetId, defaultFunctionRegistry, generatorFunctions, dataTypes, diagnostics, sources, scalarColumnDescriptors, enumHandles, capabilities, namespaceId, namespaceExtensionEntities, codecLookup } = input;
+	const { model, symbolTable, enumTypeDescriptors, typeAliases, valueObjectTypes, authoringContributions, binder, targetId, defaultFunctionRegistry, generatorFunctions, dataTypes, diagnostics, sources, scalarColumnDescriptors, enumHandles, capabilities, namespaceId, namespaceExtensionEntities, codecLookup } = input;
 	const resolvedFields = [];
 	const valueObjectStorageTypeName = authoringContributions?.valueObjectStorageType;
 	for (const field of Object.values(model.fields)) {
@@ -1727,7 +1754,7 @@ function collectResolvedFields(input) {
 			field,
 			resolution: fieldTypeResolution,
 			enumTypeDescriptors,
-			namedTypeDescriptors,
+			typeAliases,
 			diagnostics,
 			sources,
 			entityLabel: `Field "${model.name}.${field.name}"`,
@@ -1783,6 +1810,14 @@ function collectResolvedFields(input) {
 			});
 			continue;
 		}
+		const typeAlias = typeAliases.ofResolution(fieldTypeResolution);
+		if (typeAlias !== void 0) refuseRepeatedTypeAliasAttributes({
+			field,
+			fieldPath: `${model.name}.${field.name}`,
+			alias: typeAlias.alias,
+			sources,
+			diagnostics
+		});
 		const defaultAttribute = getAttribute(field.attributes, "default");
 		if (presetContributions?.default && defaultAttribute) {
 			diagnostics.push({
@@ -1792,8 +1827,8 @@ function collectResolvedFields(input) {
 			});
 			continue;
 		}
-		const enumHandle = fieldTypeResolution?.kind === "block" ? enumHandles.get(fieldTypeResolution.symbol) : void 0;
-		const loweredDefault = defaultAttribute ? enumHandle ? lowerEnumDefaultForField({
+		const enumHandle = fieldTypeResolution?.kind === "block" ? enumHandles.get(fieldTypeResolution.symbol) : typeAlias?.enumHandle;
+		const fieldLowering = {
 			modelName: model.name,
 			fieldName: field.name,
 			field,
@@ -1801,47 +1836,40 @@ function collectResolvedFields(input) {
 			symbolTable,
 			sources: input.sources,
 			binder: input.binder,
-			enumHandle,
 			defaultFunctionRegistry,
 			generatorFunctions,
 			dataTypes,
 			diagnostics
+		};
+		const ownDefault = defaultAttribute ? enumHandle ? lowerEnumDefault({
+			...fieldLowering,
+			owner: fieldAttributeOwner(fieldLowering),
+			enumHandle
 		}) : lowerDefaultForField({
-			modelName: model.name,
-			fieldName: field.name,
-			field,
-			model,
-			symbolTable,
-			sources: input.sources,
-			binder: input.binder,
+			...fieldLowering,
 			columnDescriptor: descriptor,
-			columnTypeParams: resolvedTypeParams(descriptor, input.namedTypes),
+			columnTypeParams: descriptor.typeParams,
 			isListColumn,
 			valueObjectDefault: valueObjectName === void 0 ? void 0 : {
 				valueObjectName,
 				types: valueObjectTypes
 			},
-			defaultFunctionRegistry,
-			generatorFunctions,
-			dataTypes,
-			codecLookup,
-			diagnostics
+			codecLookup
 		}) : {};
-		const generatedValues = lowerGeneratorAttributesForField({
-			modelName: model.name,
-			fieldName: field.name,
-			field,
-			model,
-			symbolTable,
-			sources: input.sources,
-			binder: input.binder,
+		if (isListField && typeAlias?.defaultValue !== void 0) {
+			diagnostics.push({
+				code: "PSL_DEFAULT_LIST_EXPECTED",
+				message: `Field "${model.name}.${field.name}" is a list, but its type alias "${typeAlias.name}" sets @default for a single value. Remove "[]" or the @default of the alias.`,
+				...source.at(field.span)
+			});
+			continue;
+		}
+		const loweredDefault = { ...ifDefined("defaultValue", typeAlias?.defaultValue ?? ownDefault.defaultValue) };
+		const generatedValues = mergeExecutionDefaults(lowerGeneratorAttributesForField({
+			...fieldLowering,
 			columnDescriptor: descriptor,
-			columnTypeParams: resolvedTypeParams(descriptor, input.namedTypes),
-			defaultFunctionRegistry,
-			generatorFunctions,
-			dataTypes,
-			diagnostics
-		});
+			columnTypeParams: descriptor.typeParams
+		}), typeAlias?.executionDefaults);
 		if (isListField && loweredDefault.defaultValue?.kind === "function" && loweredDefault.defaultValue.expression === "autoincrement()") {
 			diagnostics.push({
 				code: "PSL_LIST_AUTOINCREMENT_UNSUPPORTED",
@@ -1850,13 +1878,15 @@ function collectResolvedFields(input) {
 			});
 			continue;
 		}
-		const generatorAttribute = GENERATOR_ATTRIBUTE_NAMES.map((name) => getAttribute(field.attributes, name)).find((attribute) => attribute !== void 0);
-		if (isListField && generatorAttribute !== void 0 && generatedValues !== void 0) {
-			const argument = generatorAttribute.args.find((arg) => arg.kind === "positional")?.value.trim() ?? "";
+		const ownGeneratorAttribute = GENERATOR_ATTRIBUTE_NAMES.map((name) => getAttribute(field.attributes, name)).find((attribute) => attribute !== void 0);
+		if (isListField && generatedValues !== void 0) {
+			const fieldLabel = `Field "${model.name}.${field.name}"`;
+			const perElement = "Lists have no per-element generated values;";
+			const call = ownGeneratorAttribute?.args.find((arg) => arg.kind === "positional")?.value.trim() ?? "";
 			diagnostics.push({
 				code: "PSL_LIST_EXECUTION_DEFAULT_UNSUPPORTED",
-				message: `Field "${model.name}.${field.name}" is a list and cannot use @${generatorAttribute.name}(${argument}). Lists have no per-element generated values; remove @${generatorAttribute.name}(...).`,
-				...source.at(generatorAttribute.span)
+				message: ownGeneratorAttribute === void 0 ? `${fieldLabel} is a list, and its type alias "${typeAlias?.name}" generates a value. ${perElement} remove "[]" or type the field without the alias.` : `${fieldLabel} is a list and cannot use @${ownGeneratorAttribute.name}(${call}). ${perElement} remove @${ownGeneratorAttribute.name}(...).`,
+				...source.at(ownGeneratorAttribute?.span ?? field.span)
 			});
 			continue;
 		}
@@ -1943,6 +1973,6 @@ function mergeExecutionDefaults(fromAttributes, fromPreset) {
 	};
 }
 //#endregion
-export { readDataTypeDefault as _, defaultFunctionCall as a, sqlAttributeSpecs as b, getAuthoringEntity as c, interpretFieldAttribute as d, interpretModelAttribute as f, modelSpecContext as g, modelCoordinateKey as h, contractError as i, instantiateFieldTypeConstructor as l, modelAttributeSpecsFrom as m, bareTypeConstructorOf as n, describeUnsupportedSqlAttribute as o, lowerDataTypeDefault as p, collectResolvedFields as r, fieldSpecContext as s, PSL_CHECK_ON_STI_VARIANT as t, instantiatePslTypeConstructor as u, readWrittenValueForCodec as v, toNamedTypeFieldDescriptor as x, resolveFieldTypeDescriptor as y };
+export { sqlAttributeSpecs as S, modelCoordinateKey as _, describeUnsupportedSqlAttribute as a, readWrittenValueForCodec as b, instantiateFieldTypeConstructor as c, interpretModelAttribute as d, lowerDataTypeDefault as f, modelAttributeSpecsFrom as g, lowerTypeGenerators as h, defaultFunctionCall as i, instantiatePslTypeConstructor as l, lowerTypeDefault as m, collectResolvedFields as n, fieldSpecContext as o, lowerEnumDefault as p, contractError as r, getAuthoringEntity as s, PSL_CHECK_ON_STI_VARIANT as t, interpretFieldAttribute as u, modelSpecContext as v, resolveFieldTypeDescriptor as x, readDataTypeDefault as y };
 
-//# sourceMappingURL=psl-field-resolution-DpGsATq3-BREG9FbU.mjs.map
+//# sourceMappingURL=psl-field-resolution-C9zwpsAu-DCc7Eifv.mjs.map