@prisma/orm-family-sql 8.0.0-rc.17-dev.6 → 8.0.0-rc.17-dev.8

package/dist/{psl-field-resolution-BW0ZuqBd--WxiBxb0.mjs → psl-field-resolution-CAJsUfST-BYuz5Nqh.mjs}

@@ -1,4 +1,4 @@
-import { s as sqlTextFromCanonical, t as SQL_EXPRESSION_DATA_TYPE_ID } from "./sql-expression-D7GsLgDM.mjs";
+import { c as sqlTextFromCanonical, t as SQL_EXPRESSION_DATA_TYPE_ID } from "./sql-expression-Dek0jx_g.mjs";
 import { n as checkSqlDefaultText, o as reservedSqlDefaultText } from "./validators-CIfn8ezs.mjs";
 import { a as storedAsListColumn, i as isValueObjectMember } from "./derived-checks-CfXjGvNH-CrXoMrPU.mjs";
 import { structuredError } from "@prisma/orm-framework/utils/structured-error";
@@ -7,13 +7,13 @@ import { admittedForms, castTypedValue, describeExpected, describeRefusal, descr
 import { canonicalFormOf, codecForRef } from "@prisma/orm-framework/components/codec";
 import { blindCast } from "@prisma/orm-framework/utils/casts";
 import { InternalError, isInternalError } from "@prisma/orm-framework/utils/internal-error";
-import { ArrayLiteralAst, FunctionCallAst, IdentifierAst } from "@prisma/orm-framework/psl-parser/syntax";
+import { FunctionCallAst } from "@prisma/orm-framework/psl-parser/syntax";
 import { assertDefined, invariant } from "@prisma/orm-framework/utils/assertions";
 import { describeTaggedLiteralFailure } from "@prisma/orm-framework/components/control";
 import { notOk, ok } from "@prisma/orm-framework/utils/result";
-import { bool, diagnosticSource, entityRef, fieldAttribute, fieldRef, funcCall, identifier, interpretAttribute, leafDiagnostic, list, modelAttribute, nodePslSpan, numLiteral, oneOf, optional, record, referencedFieldRef, str, taggedLiteral, typeReferenceNode } from "@prisma/orm-framework/psl-parser";
+import { bool, dataTypeValue, diagnosticSource, entityRef, fieldAttribute, fieldRef, funcCall, identifier, interpretAttribute, leafDiagnostic, list, mapArg, modelAttribute, nodePslSpan, numLiteral, oneOf, optional, record, referencedFieldRef, str, taggedLiteral, 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-BW0ZuqBd.mjs
+//#region ../../../2-sql/2-authoring/contract-psl/dist/psl-field-resolution-CAJsUfST.mjs
 function storageName(symbol, physicalNames) {
 	const name = physicalNames.get(symbol);
 	assertDefined(name, "Physical names are populated for every model and field before lowering");
@@ -146,7 +146,10 @@ function storedValueReader(input) {
 */
 function readStoredValue(input) {
 	const reading = storedValueReader(input).read(input.value, void 0);
-	return reading.ok ? reading : storedRefusalDiagnostic(reading.refusal, `Field "${input.fieldPath}"`);
+	return reading.ok ? reading : {
+		ok: false,
+		...storedRefusalMessage(reading.refusal, `Field "${input.fieldPath}"`)
+	};
 }
 /**
 * Read one `@default(...)` value for a column, refusing in parts so each contract source words its
@@ -258,13 +261,23 @@ function rewriteOf(refusal, written, dataTypes) {
 	const refused = refusal.elementIndex === void 0 || written.kind !== "list" ? written : written.elements[refusal.elementIndex];
 	return refused === void 0 || refused.kind === "list" ? void 0 : exactRewrite(dataTypes, refusal.receivingType, refused);
 }
-/** {@link readDataTypeDefault} worded as a PSL diagnostic's code and message. */
+/**
+* {@link readDataTypeDefault} worded as a PSL diagnostic's code, message and span: a cast-rule
+* refusal at the written value, or the element of a written list it is about; a refusal only
+* defaults have at the `@default` attribute.
+*/
 function lowerDataTypeDefault(input) {
 	const read = readDataTypeDefault(input);
-	return read.ok ? read : refusalDiagnostic(atSourceElement(read.refusal, input.sourceElementIndexes), `Field "${input.fieldPath}"`, input.dataTypes, guidanceFor(read, input.written, input.dataTypes));
+	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)
+	};
 }
 /**
-* Reads one number literal written in a contract source outside a default, such as an enum member's value, from its source text for a codec, as {@link lowerDataTypeDefault} reads a default: the number's entry gives it a data type, the codec's data type takes it directly or through a cast, and the codec checks it. A refusal is worded for `subject`.
+* Reads one number literal written in a contract source outside a default, such as an enum member's value, from its source text for a codec, as {@link lowerDataTypeDefault} reads a default: the number's entry gives it a data type, the codec's data type takes it directly or through a cast, and the codec checks it. A refusal is worded for `subject`, and the caller reports it at its own span.
 */
 function readWrittenNumberForCodec(input) {
 	const written = {
@@ -279,7 +292,10 @@ function readWrittenNumberForCodec(input) {
 		dataTypes: input.dataTypes,
 		fieldPath: input.subject
 	});
-	return read.ok ? read : refusalDiagnostic(read.refusal, input.subject, input.dataTypes, guidanceFor(read, written, input.dataTypes));
+	return read.ok ? read : {
+		ok: false,
+		...refusalMessage(read.refusal, input.subject, input.dataTypes, guidanceFor(read, written, input.dataTypes))
+	};
 }
 /** What a refusal of `written` tells the author to write instead. */
 function guidanceFor(failure, written, dataTypes) {
@@ -296,61 +312,58 @@ function atSourceElement(refusal, sourceElementIndexes) {
 		elementIndex
 	};
 }
-function codecRefusalDiagnostic(refusal, subject) {
+function codecRefusalMessage(refusal, subject) {
 	return {
-		ok: false,
 		code: PSL_INVALID_DEFAULT_LITERAL,
-		message: `${location(subject, refusal.elementIndex)}: ${refusal.message}`,
-		place: { kind: "attribute" }
+		message: `${location(subject, refusal.elementIndex)}: ${refusal.message}`
 	};
 }
-function storedRefusalDiagnostic(refusal, subject) {
-	if (refusal.kind === "refused-by-codec") return codecRefusalDiagnostic(refusal, subject);
+function storedRefusalMessage(refusal, subject) {
+	if (refusal.kind === "refused-by-codec") return codecRefusalMessage(refusal, subject);
 	return {
-		ok: false,
 		code: "PSL_INVALID_LITERAL",
-		message: `${location(subject, refusal.elementIndex)}: ${refusal.message}`,
-		place: { kind: "attribute" }
+		message: `${location(subject, refusal.elementIndex)}: ${refusal.message}`
 	};
 }
-/** A refusal worded as a PSL diagnostic's code, message and place; `guidance` says what to write instead. */
-function refusalDiagnostic(refusal, subject, dataTypes, guidance) {
+/** A refusal worded as a PSL diagnostic's code and message; `guidance` says what to write instead. */
+function refusalMessage(refusal, subject, dataTypes, guidance) {
 	const where = location(subject, refusal.elementIndex);
-	const atWrittenValue = {
-		kind: "written-value",
-		elementIndex: refusal.elementIndex
-	};
 	switch (refusal.kind) {
 		case "not-a-list": return {
-			ok: false,
 			code: PSL_DEFAULT_LIST_EXPECTED,
-			message: `${where}: this column holds a list, so its default is a list literal, as in [1, 2]`,
-			place: { kind: "attribute" }
+			message: `${where}: this column holds a list, so its default is a list literal, as in [1, 2]`
 		};
-		case "refused-by-codec": return codecRefusalDiagnostic(refusal, subject);
+		case "refused-by-codec": return codecRefusalMessage(refusal, subject);
 		case "no-list-cast": return {
-			ok: false,
 			code: PSL_VALUE_TYPE_INCOMPATIBLE,
-			message: `${where}: ${describeExpected(guidance.forms)}; got a list`,
-			place: atWrittenValue
+			message: `${where}: ${describeExpected(guidance.forms)}; got a list`
 		};
 		case "no-element-cast": return {
-			ok: false,
 			code: PSL_VALUE_TYPE_INCOMPATIBLE,
-			message: `${where}: ${describeRefusedValueType(refusal, dataTypes, guidance)}`,
-			place: atWrittenValue
+			message: `${where}: ${describeRefusedValueType(refusal, dataTypes, guidance)}`
 		};
 		default: {
 			const { code, message } = describeRefusal(refusal, dataTypes, guidance);
 			return {
-				ok: false,
 				code,
-				message: `${where}: ${message}`,
-				place: atWrittenValue
+				message: `${where}: ${message}`
 			};
 		}
 	}
 }
+function refusalSpan(refusal, spans, fieldPath) {
+	switch (refusal.kind) {
+		case "not-a-list":
+		case "refused-by-codec": return spans.attribute;
+		default: return writtenValueSpan(spans, refusal.elementIndex, fieldPath);
+	}
+}
+function writtenValueSpan(spans, elementIndex, fieldPath) {
+	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.`);
+	return span;
+}
 function formatSupportedFunctionList(registry) {
 	const signatures = Array.from(registry.entries()).sort(([a], [b]) => a.localeCompare(b)).flatMap(([functionName, entry]) => {
 		const usageSignatures = entry.usageSignatures?.filter((signature) => signature.length > 0);
@@ -457,16 +470,25 @@ const mapFieldSpec = fieldAttribute("map", {
 });
 function nullLiteral() {
 	const nullIdentifier = identifier("null", { documentation: "A null list element or nullable scalar default." });
-	return {
+	return mapArg({
 		kind: "null",
 		label: "null",
 		parse: (arg, ctx) => {
 			const result = nullIdentifier.parse(arg, ctx);
 			return result.ok ? ok(null) : result;
 		}
-	};
+	}, (_null, arg, ctx) => ({
+		kind: "null",
+		span: nodePslSpan(arg.syntax, ctx.sources)
+	}));
+}
+function defaultFunctionArm(name, signature) {
+	return mapArg(funcCall(name, signature), (call) => ({
+		kind: "default-function",
+		call
+	}));
 }
-function scalarDefaultArms(isList, dataTypes, registries) {
+function scalarDefaultArms(isList, dataTypes, defaultFunctionRegistry) {
 	const tagArms = (admits) => {
 		const tagsByDocumentation = /* @__PURE__ */ new Map();
 		for (const [dataType, entry] of Object.entries(dataTypes.entries)) {
@@ -475,20 +497,20 @@ function scalarDefaultArms(isList, dataTypes, registries) {
 			if (tags === void 0) tagsByDocumentation.set(entry.documentation, [entry.written.tag]);
 			else tags.push(entry.written.tag);
 		}
-		return [...tagsByDocumentation].map(([documentation, tags]) => taggedLiteral(tags, { documentation }));
+		return [...tagsByDocumentation].map(([documentation, tags]) => writtenScalar(taggedLiteral(tags, { documentation })));
 	};
 	const anyTag = () => tagArms(() => true);
-	const literal = () => oneOf(str(), numLiteral(), bool(), nullLiteral(), ...tagArms((dataType) => dataType !== SQL_EXPRESSION_DATA_TYPE_ID));
-	const listArm = () => list(literal(), { label: `list of (${literal().label})` });
-	const funcArms = [...registries.defaultFunctionRegistry.entries()].map(([name, entry]) => funcCall(name, blindCast(entry.signature)));
+	const literal = () => oneOf(writtenScalar(str()), writtenScalar(numLiteral()), writtenScalar(bool()), nullLiteral(), ...tagArms((dataType) => dataType !== SQL_EXPRESSION_DATA_TYPE_ID));
+	const listArm = () => writtenList(literal());
+	const funcArms = [...defaultFunctionRegistry.entries()].map(([name, entry]) => defaultFunctionArm(name, blindCast(entry.signature)));
 	return isList ? [
 		listArm(),
 		...funcArms,
 		...anyTag()
 	] : [
-		str(),
-		numLiteral(),
-		bool(),
+		writtenScalar(str()),
+		writtenScalar(numLiteral()),
+		writtenScalar(bool()),
 		nullLiteral(),
 		...funcArms,
 		...anyTag(),
@@ -531,8 +553,14 @@ function enumMemberNames(ctx) {
 function enumDefaultArms(members, enumName, isList) {
 	const [first, ...rest] = members;
 	if (first === void 0) return [noEnumMember()];
-	const member = (name) => identifier(name, { documentation: `The \`${name}\` member of enum \`${enumName}\`.` });
-	if (isList) return [list(oneOf(member(first), ...rest.map(member), nullLiteral()))];
+	const member = (name) => mapArg(identifier(name, { documentation: `The \`${name}\` member of enum \`${enumName}\`.` }), (parsed) => ({
+		kind: "member",
+		name: parsed
+	}));
+	if (isList) return [mapArg(list(oneOf(member(first), ...rest.map(member), nullLiteral())), (elements) => ({
+		kind: "member-list",
+		elements
+	}))];
 	return [member(first), ...rest.map(member)];
 }
 function defaultFieldSpec(ctx) {
@@ -541,7 +569,7 @@ function defaultFieldSpec(ctx) {
 		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, ctx.dataTypes, ctx.controlMutationDefaults) : enumDefaultArms(members, ctx.field.typeName, ctx.field.list), ctx.controlMutationDefaults.defaultFunctionRegistry),
+			type: defaultValueArm(members === void 0 ? scalarDefaultArms(ctx.field.list, ctx.dataTypes, ctx.defaultFunctionRegistry) : enumDefaultArms(members, ctx.field.typeName, ctx.field.list), ctx.defaultFunctionRegistry),
 			documentation: "A literal, enum member, or registered default function compatible with this field."
 		}]
 	});
@@ -616,55 +644,57 @@ const uniqueModelSpec = modelAttribute("unique", {
 const PSL_INDEX_FIELDS_XOR_EXPRESSION = "PSL_INDEX_FIELDS_XOR_EXPRESSION";
 const PSL_INDEX_EXPRESSION_REQUIRES_NAME = "PSL_INDEX_EXPRESSION_REQUIRES_NAME";
 const PSL_INDEX_NAME_XOR_MAP = "PSL_INDEX_NAME_XOR_MAP";
-const indexModelSpec = modelAttribute("index", {
-	documentation: "Declares a database index over fields or a SQL expression, optionally restricted by a predicate.",
-	positional: [{
-		key: "fields",
-		type: optional(list(fieldRef(), {
-			allowEmpty: false,
-			unique: true
-		})),
-		documentation: "The ordered list of distinct indexed fields. Mutually exclusive with `expression`."
-	}],
-	named: {
-		expression: {
-			type: optional(str()),
-			documentation: "The SQL index expression. Requires `name` or `map` and cannot be combined with a fields list."
-		},
-		where: {
-			type: optional(str()),
-			documentation: "The SQL predicate restricting rows included in a partial index."
-		},
-		unique: {
-			type: optional(bool()),
-			documentation: "Whether the index enforces uniqueness."
-		},
-		name: {
-			type: optional(str()),
-			documentation: "The index name. Mutually exclusive with `map`."
-		},
-		map: {
-			type: optional(str()),
-			documentation: "The database index name. Mutually exclusive with `name`."
-		},
-		type: {
-			type: optional(str()),
-			documentation: "The target-specific index access method."
+function indexModelSpec(ctx) {
+	return modelAttribute("index", {
+		documentation: "Declares a database index over fields or a SQL expression, optionally restricted by a predicate.",
+		positional: [{
+			key: "fields",
+			type: optional(list(fieldRef(), {
+				allowEmpty: false,
+				unique: true
+			})),
+			documentation: "The ordered list of distinct indexed fields. Mutually exclusive with `expression`."
+		}],
+		named: {
+			expression: {
+				type: optional(dataTypeValue(SQL_EXPRESSION_DATA_TYPE_ID, ctx.dataTypes)),
+				documentation: "The SQL index expression. Requires `name` or `map` and cannot be combined with a fields list."
+			},
+			where: {
+				type: optional(dataTypeValue(SQL_EXPRESSION_DATA_TYPE_ID, ctx.dataTypes)),
+				documentation: "The SQL predicate restricting rows included in a partial index."
+			},
+			unique: {
+				type: optional(bool()),
+				documentation: "Whether the index enforces uniqueness."
+			},
+			name: {
+				type: optional(str()),
+				documentation: "The index name. Mutually exclusive with `map`."
+			},
+			map: {
+				type: optional(str()),
+				documentation: "The database index name. Mutually exclusive with `name`."
+			},
+			type: {
+				type: optional(str()),
+				documentation: "The target-specific index access method."
+			},
+			options: {
+				type: optional(record(str())),
+				documentation: "Target-specific index options. Requires an explicit `type`."
+			}
 		},
-		options: {
-			type: optional(record(str())),
-			documentation: "Target-specific index options. Requires an explicit `type`."
+		refine: (value, ctx, attributeNode) => {
+			const diagnostics = [];
+			if (value.fields === void 0 === (value.expression === void 0)) diagnostics.push(leafDiagnostic(ctx, attributeNode, "`@@index` requires exactly one of a fields list or an `expression` argument", PSL_INDEX_FIELDS_XOR_EXPRESSION));
+			if (value.expression !== void 0 && value.name === void 0 && value.map === void 0) diagnostics.push(leafDiagnostic(ctx, attributeNode, "`@@index` with an `expression` argument requires a `name` or `map` argument (a default name cannot be derived from an expression)", PSL_INDEX_EXPRESSION_REQUIRES_NAME));
+			if (value.name !== void 0 && value.map !== void 0) diagnostics.push(leafDiagnostic(ctx, attributeNode, "`@@index` takes at most one of `name` and `map`", PSL_INDEX_NAME_XOR_MAP));
+			if (value.options !== void 0 && value.type === void 0) diagnostics.push(leafDiagnostic(ctx, attributeNode, "`@@index` options argument requires a type argument"));
+			return diagnostics;
 		}
-	},
-	refine: (value, ctx, attributeNode) => {
-		const diagnostics = [];
-		if (value.fields === void 0 === (value.expression === void 0)) diagnostics.push(leafDiagnostic(ctx, attributeNode, "`@@index` requires exactly one of a fields list or an `expression` argument", PSL_INDEX_FIELDS_XOR_EXPRESSION));
-		if (value.expression !== void 0 && value.name === void 0 && value.map === void 0) diagnostics.push(leafDiagnostic(ctx, attributeNode, "`@@index` with an `expression` argument requires a `name` or `map` argument (a default name cannot be derived from an expression)", PSL_INDEX_EXPRESSION_REQUIRES_NAME));
-		if (value.name !== void 0 && value.map !== void 0) diagnostics.push(leafDiagnostic(ctx, attributeNode, "`@@index` takes at most one of `name` and `map`", PSL_INDEX_NAME_XOR_MAP));
-		if (value.options !== void 0 && value.type === void 0) diagnostics.push(leafDiagnostic(ctx, attributeNode, "`@@index` options argument requires a type argument"));
-		return diagnostics;
-	}
-});
+	});
+}
 const PSL_CHECK_REQUIRES_NAME_OR_MAP = "PSL_CHECK_REQUIRES_NAME_OR_MAP";
 const PSL_CHECK_NAME_XOR_MAP = "PSL_CHECK_NAME_XOR_MAP";
 const PSL_CHECK_EXPRESSION_EMPTY = "PSL_CHECK_EXPRESSION_EMPTY";
@@ -676,30 +706,32 @@ const PSL_CHECK_EXPRESSION_EMPTY = "PSL_CHECK_EXPRESSION_EMPTY";
 * declaration, which a single attribute's `refine` cannot see.
 */
 const PSL_CHECK_ON_STI_VARIANT = "PSL_CHECK_ON_STI_VARIANT";
-const checkModelSpec = modelAttribute("check", {
-	documentation: "Declares a named database CHECK constraint on this table.",
-	named: {
-		expression: {
-			type: str(),
-			documentation: "The nonempty SQL predicate checked for each row."
-		},
-		name: {
-			type: optional(str()),
-			documentation: "The constraint name. Exactly one of `name` and `map` is required."
+function checkModelSpec(ctx) {
+	return modelAttribute("check", {
+		documentation: "Declares a named database CHECK constraint on this table.",
+		named: {
+			expression: {
+				type: dataTypeValue(SQL_EXPRESSION_DATA_TYPE_ID, ctx.dataTypes),
+				documentation: "The nonempty SQL predicate checked for each row."
+			},
+			name: {
+				type: optional(str()),
+				documentation: "The constraint name. Exactly one of `name` and `map` is required."
+			},
+			map: {
+				type: optional(str()),
+				documentation: "The database constraint name. Exactly one of `name` and `map` is required."
+			}
 		},
-		map: {
-			type: optional(str()),
-			documentation: "The database constraint name. Exactly one of `name` and `map` is required."
+		refine: (value, ctx, attributeNode) => {
+			const diagnostics = [];
+			if (sqlTextFromCanonical(value.expression.value).trim().length === 0) diagnostics.push(leafDiagnostic(ctx, attributeNode, "`@@check` expression must not be empty — an empty predicate is not a constraint", PSL_CHECK_EXPRESSION_EMPTY));
+			if (value.name === void 0 && value.map === void 0) diagnostics.push(leafDiagnostic(ctx, attributeNode, "`@@check` requires a `name` or `map` argument (a default name cannot be derived — a check has no column tuple to name itself after)", PSL_CHECK_REQUIRES_NAME_OR_MAP));
+			if (value.name !== void 0 && value.map !== void 0) diagnostics.push(leafDiagnostic(ctx, attributeNode, "`@@check` takes at most one of `name` and `map`", PSL_CHECK_NAME_XOR_MAP));
+			return diagnostics;
 		}
-	},
-	refine: (value, ctx, attributeNode) => {
-		const diagnostics = [];
-		if (value.expression.trim().length === 0) diagnostics.push(leafDiagnostic(ctx, attributeNode, "`@@check` expression must not be empty — an empty predicate is not a constraint", PSL_CHECK_EXPRESSION_EMPTY));
-		if (value.name === void 0 && value.map === void 0) diagnostics.push(leafDiagnostic(ctx, attributeNode, "`@@check` requires a `name` or `map` argument (a default name cannot be derived — a check has no column tuple to name itself after)", PSL_CHECK_REQUIRES_NAME_OR_MAP));
-		if (value.name !== void 0 && value.map !== void 0) diagnostics.push(leafDiagnostic(ctx, attributeNode, "`@@check` takes at most one of `name` and `map`", PSL_CHECK_NAME_XOR_MAP));
-		return diagnostics;
-	}
-});
+	});
+}
 const controlModelSpec = modelAttribute("control", {
 	documentation: "Sets how schema management treats this model’s storage.",
 	positional: [{
@@ -789,6 +821,14 @@ const relationFieldSpec = fieldAttribute("relation", {
 	},
 	refine: relationInvariants
 });
+function modelSpecContext(input) {
+	return {
+		symbols: input.symbols,
+		model: input.model,
+		defaultFunctionRegistry: input.defaultFunctionRegistry,
+		dataTypes: input.dataTypes
+	};
+}
 function fieldSpecContext(input) {
 	const node = typeReferenceNode(input.field);
 	return {
@@ -796,27 +836,28 @@ function fieldSpecContext(input) {
 		model: input.model,
 		field: input.field,
 		typeResolution: node === void 0 ? void 0 : input.binder.symbolForNode(node),
-		controlMutationDefaults: input.controlMutationDefaults,
+		defaultFunctionRegistry: input.defaultFunctionRegistry,
 		dataTypes: input.dataTypes
 	};
 }
+/** Every entry is a factory over the spec context, whether or not its spec reads it. ADR 249. */
 const sqlAttributeSpecs = {
 	model: {
-		map: () => mapModelSpec,
-		id: () => idModelSpec,
-		unique: () => uniqueModelSpec,
-		index: () => indexModelSpec,
-		check: () => checkModelSpec,
-		control: () => controlModelSpec,
-		discriminator: () => discriminatorModelSpec,
-		base: baseModelSpec
+		map: (_ctx) => mapModelSpec,
+		id: (_ctx) => idModelSpec,
+		unique: (_ctx) => uniqueModelSpec,
+		index: indexModelSpec,
+		check: checkModelSpec,
+		control: (_ctx) => controlModelSpec,
+		discriminator: (_ctx) => discriminatorModelSpec,
+		base: (_ctx) => baseModelSpec()
 	},
 	field: {
-		map: () => mapFieldSpec,
-		id: () => idFieldSpec,
-		unique: () => uniqueFieldSpec,
-		noCheck: () => noCheckFieldSpec,
-		relation: () => relationFieldSpec,
+		map: (_ctx) => mapFieldSpec,
+		id: (_ctx) => idFieldSpec,
+		unique: (_ctx) => uniqueFieldSpec,
+		noCheck: (_ctx) => noCheckFieldSpec,
+		relation: (_ctx) => relationFieldSpec,
 		default: defaultFieldSpec
 	}
 };
@@ -1289,30 +1330,23 @@ const TAGGED_LITERAL_CANONICALIZATION_CODES = {
 	nul: "PSL_TAGGED_LITERAL_NUL",
 	"too-large": "PSL_TAGGED_LITERAL_TOO_LARGE"
 };
-function defaultValueExpression(node) {
-	return [...node.argList()?.args() ?? []].find((arg) => arg.colon() === void 0)?.value();
-}
-function listElements(expression) {
-	const list = expression === void 0 ? void 0 : ArrayLiteralAst.cast(expression.syntax);
-	return list === void 0 ? [] : [...list.elements()];
-}
+/**
+* Refuses a `null` element in the list default of a field whose list elements are not nullable,
+* at the first `null`. Returns whether it refused.
+*/
 function rejectStrictListNullDefault(input) {
 	if (input.field.elementOptional) return false;
-	for (const arg of input.node.argList()?.args() ?? []) {
-		const expression = arg.value();
-		const list = expression ? ArrayLiteralAst.cast(expression.syntax) : void 0;
-		for (const element of list?.elements() ?? []) {
-			const identifier = IdentifierAst.cast(element.syntax);
-			if (identifier?.token()?.text !== "null") continue;
-			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.`,
-				...diagnosticSource(input.sources, identifier.syntax).at()
-			});
-			return true;
-		}
-	}
-	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.`,
+		...input.source.at(nullElement.span)
+	});
+	return true;
+}
+function isParsedNullLiteral(element) {
+	return element.kind === "null";
 }
 function lowerDefaultForField(input) {
 	const node = getAttribute(input.field.attributes, "default")?.node;
@@ -1323,7 +1357,7 @@ function lowerDefaultForField(input) {
 		model: input.model,
 		field: input.field,
 		binder: input.binder,
-		controlMutationDefaults: { defaultFunctionRegistry: input.defaultFunctionRegistry },
+		defaultFunctionRegistry: input.defaultFunctionRegistry,
 		dataTypes: input.dataTypes
 	}));
 	const interpreted = interpretFieldAttribute({
@@ -1338,11 +1372,8 @@ function lowerDefaultForField(input) {
 	});
 	if (interpreted === void 0) return {};
 	const value = interpreted.value;
-	if (Array.isArray(value) && value.includes(null) && rejectStrictListNullDefault({
-		...input,
-		node
-	})) return {};
-	if (value === null) {
+	const attributeSpan = nodePslSpan(node.syntax, input.sources);
+	if (value.kind === "null") {
 		if (!input.field.optional) {
 			input.diagnostics.push({
 				code: "PSL_INVALID_DEFAULT_APPLICABILITY",
@@ -1357,17 +1388,16 @@ function lowerDefaultForField(input) {
 			canonical: true
 		} };
 	}
-	const valueExpression = defaultValueExpression(node);
-	const refusalLocation = (place) => {
-		if (place.kind === "attribute") return source.at();
-		const expression = place.elementIndex === void 0 ? valueExpression : listElements(valueExpression)[place.elementIndex];
-		if (expression === void 0) throw new InternalError(`Field "${input.modelName}.${input.fieldName}": the refused @default value has no written expression.`);
-		return diagnosticSource(input.sources, expression.syntax).at();
-	};
+	if (value.kind === "list" && rejectStrictListNullDefault({
+		...input,
+		elements: value.elements,
+		source
+	})) return {};
 	const readsListElements = (written) => input.isListColumn || input.field.list && written.kind === "list";
-	const readAsLiteral = (written, sourceElementIndexes) => {
+	const readAsLiteral = (written, spans, sourceElementIndexes) => {
 		const lowered = lowerDataTypeDefault({
 			written,
+			spans,
 			sourceElementIndexes,
 			isList: readsListElements(written),
 			column: input.columnDescriptor,
@@ -1379,15 +1409,15 @@ function lowerDefaultForField(input) {
 			input.diagnostics.push({
 				code: lowered.code,
 				message: lowered.message,
-				...refusalLocation(lowered.place)
+				...source.at(lowered.span)
 			});
 			return {};
 		}
 		let restoredValue = lowered.value;
-		if (Array.isArray(value) && value.includes(null) && Array.isArray(lowered.value)) {
+		if (value.kind === "list" && value.elements.some(isParsedNullLiteral) && Array.isArray(lowered.value)) {
 			let index = 0;
 			const nonNullValues = lowered.value;
-			restoredValue = value.map((element) => element === null ? null : nonNullValues[index++] ?? null);
+			restoredValue = value.elements.map((element) => element.kind === "null" ? null : nonNullValues[index++] ?? null);
 		}
 		if (input.valueObjectDefault !== void 0) {
 			const { document, stored } = valueObjectDefaultDocument({
@@ -1424,33 +1454,13 @@ function lowerDefaultForField(input) {
 			canonical: true
 		} };
 	};
-	const writtenScalar = (element) => {
-		if (typeof element === "string") return {
-			kind: "string",
-			text: element
-		};
-		if (typeof element === "boolean") return {
-			kind: "boolean",
-			value: element
-		};
-		if ("text" in element) return {
-			kind: "number",
-			text: element.text
-		};
-		const { canonicalization } = element;
-		if (!canonicalization.ok) {
-			input.diagnostics.push({
-				code: TAGGED_LITERAL_CANONICALIZATION_CODES[canonicalization.reason],
-				message: describeTaggedLiteralFailure(canonicalization.reason),
-				...source.at(element.span)
-			});
-			return { ok: false };
-		}
-		return {
-			kind: "tag",
-			tag: element.tag,
-			text: canonicalization.text
-		};
+	const canonicalized = (scalar) => {
+		if (scalar.written !== void 0) return scalar.written;
+		input.diagnostics.push({
+			code: TAGGED_LITERAL_CANONICALIZATION_CODES[scalar.reason],
+			message: describeTaggedLiteralFailure(scalar.reason),
+			...source.at(scalar.span)
+		});
 	};
 	const sqlExpressionDefault = (text, span) => {
 		const reserved = reservedSqlDefaultText(text);
@@ -1468,100 +1478,101 @@ function lowerDefaultForField(input) {
 			expression: text
 		} };
 	};
+	if (value.kind === "member" || value.kind === "member-list") return {};
 	if (input.columnDescriptor.valueSet !== void 0) {
-		if (typeof value === "string") return { defaultValue: {
-			kind: "literal",
-			value
-		} };
-		if (Array.isArray(value)) {
-			const members = value.filter((element) => element === null || typeof element === "string");
-			if (members.length === value.length) return { defaultValue: {
+		const memberName = (element) => element.kind === "scalar" && element.written?.kind === "string" ? element.written.text : void 0;
+		if (value.kind === "scalar") {
+			const member = memberName(value);
+			if (member !== void 0) return { defaultValue: {
+				kind: "literal",
+				value: member
+			} };
+		}
+		if (value.kind === "list") {
+			const members = value.elements.map((element) => element.kind === "null" ? null : memberName(element));
+			if (members.every((member) => member !== void 0)) return { defaultValue: {
 				kind: "literal",
 				value: members
 			} };
 		}
 	}
-	if (Array.isArray(value)) {
+	if (value.kind === "list") {
 		const elements = [];
 		const sourceElementIndexes = [];
-		for (const [sourceIndex, element] of value.entries()) {
-			if (element === null) continue;
-			const written = writtenScalar(element);
-			if ("ok" in written) return {};
+		for (const [sourceIndex, element] of value.elements.entries()) {
+			if (element.kind === "null") continue;
+			const written = canonicalized(element);
+			if (written === void 0) return {};
 			elements.push(written);
 			sourceElementIndexes.push(sourceIndex);
 		}
 		return readAsLiteral({
 			kind: "list",
 			elements
+		}, {
+			attribute: attributeSpan,
+			value: value.span,
+			elements: value.elements.map((element) => element.span)
 		}, sourceElementIndexes);
 	}
-	if (typeof value === "string") return readAsLiteral({
-		kind: "string",
-		text: value
-	});
-	if (typeof value === "boolean") return readAsLiteral({
-		kind: "boolean",
-		value
-	});
-	if ("text" in value) return readAsLiteral({
-		kind: "number",
-		text: value.text
-	});
-	if ("tag" in value) {
-		const written = writtenScalar(value);
-		if ("ok" in written) return {};
+	if (value.kind === "scalar") {
+		const written = canonicalized(value);
+		if (written === void 0) return {};
+		const spans = {
+			attribute: attributeSpan,
+			value: value.span,
+			elements: []
+		};
+		if (written.kind !== "tag") return readAsLiteral(written, spans);
 		const read = readWrittenValue(input.dataTypes, written);
 		if (read.ok && read.value.type === SQL_EXPRESSION_DATA_TYPE_ID) return sqlExpressionDefault(sqlTextFromCanonical(read.value.value), value.span);
-		return readAsLiteral(written);
+		return readAsLiteral(written, spans);
 	}
-	if (typeof value === "object") {
-		const context = {
-			sourceId: input.sources.sourceFileFor(node.syntax).filename,
-			modelName: input.modelName,
-			fieldName: input.fieldName,
-			columnCodecId: input.columnDescriptor.codecId
-		};
-		const lowered = lowerDefaultFunctionWithRegistry({
-			call: value,
-			registry: input.defaultFunctionRegistry,
-			context,
-			source
+	const { call } = value;
+	const context = {
+		sourceId: input.sources.sourceFileFor(node.syntax).filename,
+		modelName: input.modelName,
+		fieldName: input.fieldName,
+		columnCodecId: input.columnDescriptor.codecId
+	};
+	const lowered = lowerDefaultFunctionWithRegistry({
+		call,
+		registry: input.defaultFunctionRegistry,
+		context,
+		source
+	});
+	if (!lowered.ok) {
+		if (lowered.kind === "owned") input.diagnostics.push(lowered.diagnostic);
+		else input.diagnostics.pushExternal(lowered.diagnostic);
+		return {};
+	}
+	if (lowered.value.kind === "storage") return { defaultValue: lowered.value.defaultValue };
+	const generatorDescriptor = input.generatorDescriptorById.get(lowered.value.generated.id);
+	if (!generatorDescriptor) {
+		input.diagnostics.push({
+			code: "PSL_INVALID_DEFAULT_APPLICABILITY",
+			message: `Default generator "${lowered.value.generated.id}" is not available in the composed mutation default registry.`,
+			...source.at(call.span)
 		});
-		if (!lowered.ok) {
-			if (lowered.kind === "owned") input.diagnostics.push(lowered.diagnostic);
-			else input.diagnostics.pushExternal(lowered.diagnostic);
-			return {};
-		}
-		if (lowered.value.kind === "storage") return { defaultValue: lowered.value.defaultValue };
-		const generatorDescriptor = input.generatorDescriptorById.get(lowered.value.generated.id);
-		if (!generatorDescriptor) {
-			input.diagnostics.push({
-				code: "PSL_INVALID_DEFAULT_APPLICABILITY",
-				message: `Default generator "${lowered.value.generated.id}" is not available in the composed mutation default registry.`,
-				...source.at(value.span)
-			});
-			return {};
-		}
-		if (generatorDescriptor.applicableCodecIds === void 0) {
-			input.diagnostics.push({
-				code: "PSL_INVALID_DEFAULT_APPLICABILITY",
-				message: `Default generator "${generatorDescriptor.id}" is not applicable to "@default(...)" lowering. Use the corresponding field preset (e.g. \`temporal.${generatorDescriptor.id === "timestampNow" ? "updatedAt" : generatorDescriptor.id}()\`) instead.`,
-				...source.at(value.span)
-			});
-			return {};
-		}
-		if (!generatorDescriptor.applicableCodecIds.includes(input.columnDescriptor.codecId)) {
-			input.diagnostics.push({
-				code: "PSL_INVALID_DEFAULT_APPLICABILITY",
-				message: `Default generator "${generatorDescriptor.id}" is not applicable to "${input.modelName}.${input.fieldName}" with codecId "${input.columnDescriptor.codecId}".`,
-				...source.at(value.span)
-			});
-			return {};
-		}
-		return { executionDefaults: { onCreate: lowered.value.generated } };
+		return {};
 	}
-	return {};
+	if (generatorDescriptor.applicableCodecIds === void 0) {
+		input.diagnostics.push({
+			code: "PSL_INVALID_DEFAULT_APPLICABILITY",
+			message: `Default generator "${generatorDescriptor.id}" is not applicable to "@default(...)" lowering. Use the corresponding field preset (e.g. \`temporal.${generatorDescriptor.id === "timestampNow" ? "updatedAt" : generatorDescriptor.id}()\`) instead.`,
+			...source.at(call.span)
+		});
+		return {};
+	}
+	if (!generatorDescriptor.applicableCodecIds.includes(input.columnDescriptor.codecId)) {
+		input.diagnostics.push({
+			code: "PSL_INVALID_DEFAULT_APPLICABILITY",
+			message: `Default generator "${generatorDescriptor.id}" is not applicable to "${input.modelName}.${input.fieldName}" with codecId "${input.columnDescriptor.codecId}".`,
+			...source.at(call.span)
+		});
+		return {};
+	}
+	return { executionDefaults: { onCreate: lowered.value.generated } };
 }
 function lowerEnumDefaultForField(input) {
 	const { field, model, enumHandle, diagnostics } = input;
@@ -1575,7 +1586,7 @@ function lowerEnumDefaultForField(input) {
 			model,
 			field,
 			binder: input.binder,
-			controlMutationDefaults: { defaultFunctionRegistry: input.defaultFunctionRegistry },
+			defaultFunctionRegistry: input.defaultFunctionRegistry,
 			dataTypes: input.dataTypes
 		})),
 		symbols: input.symbolTable,
@@ -1587,18 +1598,19 @@ function lowerEnumDefaultForField(input) {
 	});
 	if (interpreted === void 0) return {};
 	const member = interpreted.value;
-	if (Array.isArray(member)) {
-		if (member.includes(null) && rejectStrictListNullDefault({
+	if (member.kind === "member-list") {
+		if (rejectStrictListNullDefault({
 			...input,
-			node
+			elements: member.elements,
+			source: diagnosticSource(input.sources, node.syntax)
 		})) return {};
 		return { defaultValue: {
 			kind: "literal",
-			value: blindCast(member.map((entry) => entry === null ? null : enumHandle.enumMembers.find((candidate) => candidate.name === entry)?.value))
+			value: blindCast(member.elements.map((entry) => entry.kind === "null" ? null : enumHandle.enumMembers.find((candidate) => candidate.name === entry.name)?.value))
 		} };
 	}
-	invariant(typeof member === "string", "the enum @default grammar admits only member identifiers, so the parsed value is a string");
-	const match = enumHandle.enumMembers.find((m) => m.name === member);
+	invariant(member.kind === "member", "the enum @default grammar admits only member identifiers");
+	const match = enumHandle.enumMembers.find((m) => m.name === member.name);
 	if (!match) return {};
 	return { defaultValue: {
 		kind: "literal",
@@ -1651,7 +1663,7 @@ function extractFieldConstraintNames(input) {
 	const idName = idNode === void 0 ? void 0 : interpretFieldAttribute({
 		node: idNode,
 		symbols: input.symbolTable,
-		spec: sqlAttributeSpecs.field.id(),
+		spec: sqlAttributeSpecs.field.id(input.specContext),
 		model: input.model,
 		field: input.field,
 		sources: input.sources,
@@ -1666,7 +1678,7 @@ function extractFieldConstraintNames(input) {
 		uniqueName: uniqueNode === void 0 ? void 0 : interpretFieldAttribute({
 			node: uniqueNode,
 			symbols: input.symbolTable,
-			spec: sqlAttributeSpecs.field.unique(),
+			spec: sqlAttributeSpecs.field.unique(input.specContext),
 			model: input.model,
 			field: input.field,
 			sources: input.sources,
@@ -1687,7 +1699,7 @@ function lowerNoCheckForField(input) {
 	if (node === void 0) return void 0;
 	const interpreted = interpretFieldAttribute({
 		node,
-		spec: sqlAttributeSpecs.field.noCheck(),
+		spec: sqlAttributeSpecs.field.noCheck(input.specContext),
 		symbols: input.symbolTable,
 		model: input.model,
 		field: input.field,
@@ -1877,10 +1889,19 @@ function collectResolvedFields(input) {
 			continue;
 		}
 		const mappedColumnName = storageName(field, input.physicalNames);
+		const specContext = fieldSpecContext({
+			symbols: symbolTable,
+			model,
+			field,
+			binder,
+			defaultFunctionRegistry,
+			dataTypes
+		});
 		const { idAttribute, uniqueAttribute, idName, uniqueName } = extractFieldConstraintNames({
 			symbolTable: input.symbolTable,
 			model,
 			field,
+			specContext,
 			sources: input.sources,
 			binder: input.binder,
 			diagnostics
@@ -1916,6 +1937,7 @@ function collectResolvedFields(input) {
 			symbolTable: input.symbolTable,
 			model,
 			field,
+			specContext,
 			sources: input.sources,
 			binder: input.binder,
 			isListColumn,
@@ -1944,6 +1966,6 @@ function collectResolvedFields(input) {
 	return resolvedFields;
 }
 //#endregion
-export { toNamedTypeFieldDescriptor as S, readDataTypeDefault as _, describeUnsupportedSqlAttribute as a, sqlAttributeSpecs as b, getAuthoringEntity as c, instantiatePslTypeConstructor as d, interpretFieldAttribute as f, modelCoordinateKey as g, modelAttributeSpecsFrom as h, contractError as i, getNamedArgument as l, mapFieldNamesToColumns as m, bareTypeConstructorOf as n, formatDbAttributeMigrationMessage as o, interpretModelAttribute as p, collectResolvedFields as r, getAttribute as s, PSL_CHECK_ON_STI_VARIANT as t, instantiateFieldTypeConstructor as u, readWrittenNumberForCodec as v, storageName as x, resolveFieldTypeDescriptor as y };
+export { storageName as C, sqlAttributeSpecs as S, modelCoordinateKey as _, describeUnsupportedSqlAttribute as a, readWrittenNumberForCodec as b, getAttribute as c, instantiateFieldTypeConstructor as d, instantiatePslTypeConstructor as f, modelAttributeSpecsFrom as g, mapFieldNamesToColumns as h, contractError as i, getAuthoringEntity as l, interpretModelAttribute as m, bareTypeConstructorOf as n, fieldSpecContext as o, interpretFieldAttribute as p, collectResolvedFields as r, formatDbAttributeMigrationMessage as s, PSL_CHECK_ON_STI_VARIANT as t, getNamedArgument as u, modelSpecContext as v, toNamedTypeFieldDescriptor as w, resolveFieldTypeDescriptor as x, readDataTypeDefault as y };
 
-//# sourceMappingURL=psl-field-resolution-BW0ZuqBd--WxiBxb0.mjs.map
+//# sourceMappingURL=psl-field-resolution-CAJsUfST-BYuz5Nqh.mjs.map