@prisma/orm-family-sql 8.0.0-rc.15-dev.2 → 8.0.0-rc.15-dev.3

package/dist/{psl-field-resolution-Bi-CSeoQ-Do_5hZ8Z.mjs → psl-field-resolution-DUCrDnuq-BXwISml1.mjs}

@@ -1,8 +1,8 @@
 import { s as sqlTextFromCanonical, t as SQL_EXPRESSION_DATA_TYPE_ID } from "./sql-expression-D7GsLgDM.mjs";
-import { n as checkSqlDefaultBody, o as reservedSqlDefaultBody } from "./validators-BF_JSK38.mjs";
-import { a as storedAsListColumn, i as isValueObjectMember } from "./derived-checks-DAbro9yn-DtEowq-J.mjs";
+import { n as checkSqlDefaultText, o as reservedSqlDefaultText } from "./validators-Ddcw8nHL.mjs";
+import { a as storedAsListColumn, i as isValueObjectMember } from "./derived-checks-DAbro9yn-BgBbql-q.mjs";
 import { structuredError } from "@prisma/orm-framework/utils/structured-error";
-import { authoringEntryType, instantiateAuthoringTypeConstructor, isAuthoringEntityTypeDescriptor, validateAuthoringHelperArguments, validateAuthoringTypeParams } from "@prisma/orm-framework/components/authoring";
+import { admittedForms, castTypedValue, describeExpected, describeRefusal, describeRefusedValueType, exactRewrite, instantiateAuthoringTypeConstructor, isAuthoringEntityTypeDescriptor, readWrittenValue, tagForm, validateAuthoringHelperArguments, validateAuthoringTypeParams } from "@prisma/orm-framework/components/authoring";
 import { canonicalFormOf, codecForRef } from "@prisma/orm-framework/components/codec";
 import { blindCast } from "@prisma/orm-framework/utils/casts";
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
@@ -13,7 +13,7 @@ import { describeTaggedLiteralFailure } from "@prisma/orm-framework/components/c
 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 { instantiatePslFieldPreset, isBareTypeConstructor, mapPslHelperArgs, reportPresetNotCalled, reportTypeConstructorNotCalled } from "@prisma/orm-framework/psl-parser/interpret";
-//#region ../../../2-sql/2-authoring/contract-psl/dist/psl-field-resolution-Bi-CSeoQ.mjs
+//#region ../../../2-sql/2-authoring/contract-psl/dist/psl-field-resolution-DUCrDnuq.mjs
 function storageName(symbol, physicalNames) {
 	const name = physicalNames.get(symbol);
 	assertDefined(name, "Physical names are populated for every model and field before lowering");
@@ -58,124 +58,32 @@ const PSL_INVALID_DEFAULT_LITERAL = "PSL_INVALID_DEFAULT_LITERAL";
 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. */
-function entryForTag(support, tag) {
-	for (const [key, entry] of Object.entries(support.entries)) if (entry.written.kind === "tag" && entry.written.tag === tag) return {
-		key,
-		entry
-	};
-}
-/** Every tag a stack registers, in the order the entries were merged, for a diagnostic. */
-function knownTags(support) {
-	return Object.values(support.entries).flatMap((entry) => entry.written.kind === "tag" ? [entry.written.tag] : []);
-}
-function entryForPlain(support, syntax) {
-	for (const [key, entry] of Object.entries(support.entries)) if (entry.written.kind === "plain" && entry.written.syntax === syntax) return {
-		key,
-		entry
-	};
-}
-/** The text an entry reads: a tag's text, a string's value, or the word a boolean is written as. */
-function plainText(written) {
-	switch (written.kind) {
-		case "tag": return written.text;
-		case "string": return written.text;
-		case "boolean": return String(written.value);
-		case "number": return written.text;
-	}
-}
 function messageOf(error) {
 	return error instanceof Error ? error.message : String(error);
 }
-/** Read one written value through the entry for its syntax. */
-function readValue(support, written, elementIndex) {
-	const refuse = (refusal) => ({
+function refused(refusal, suggestedTypes) {
+	return {
 		ok: false,
-		refusal: blindCast({
-			...refusal,
-			elementIndex
-		})
-	});
-	const found = written.kind === "tag" ? entryForTag(support, written.tag) : entryForPlain(support, written.kind);
-	if (found === void 0) return written.kind === "tag" ? refuse({
-		kind: "unknown-tag",
-		tag: written.tag,
-		known: knownTags(support)
-	}) : refuse({
-		kind: "unwritable",
-		syntax: written.kind
-	});
-	const form = found.entry.written;
-	if (form.kind === "plain" && form.syntax === "number") {
-		const text = plainText(written);
-		const classified = form.classify(text);
-		if (classified === void 0) return refuse({
-			kind: "unreadable",
-			message: `no data type of this target holds the number ${text}`
-		});
-		return {
-			ok: true,
-			typed: classified
-		};
-	}
-	const text = plainText(written);
-	try {
-		return {
-			ok: true,
-			typed: {
-				type: blindCast(authoringEntryType(found.key, found.entry)),
-				value: form.parse(text)
-			}
-		};
-	} catch (error) {
-		if (isInternalError(error)) throw error;
-		return refuse({
-			kind: "unreadable",
-			message: messageOf(error)
-		});
-	}
+		refusal,
+		suggestedTypes
+	};
 }
-/** Convert a value of one data type into the form another stores, when that type takes it. */
-function castInto(support, columnType, typed, elementIndex) {
-	if (typed.type === columnType) return {
+function readOneValue(dataTypes, written, elementIndex, suggestedTypes) {
+	const read = readWrittenValue(dataTypes, written);
+	return read.ok ? {
 		ok: true,
-		value: typed.value
-	};
-	const declaration = support.lookup.get(columnType);
-	const cast = declaration?.casts[typed.type];
-	if (cast === void 0) return {
-		ok: false,
-		refusal: {
-			kind: "no-cast",
-			columnType,
-			valueType: typed.type,
-			casts: Object.keys(declaration?.casts ?? {}),
-			elementIndex
-		}
-	};
-	try {
-		return {
-			ok: true,
-			value: cast(typed.value)
-		};
-	} catch (error) {
-		if (isInternalError(error)) throw error;
-		return {
-			ok: false,
-			refusal: {
-				kind: "unreadable",
-				message: messageOf(error),
-				elementIndex
-			}
-		};
-	}
+		typed: read.value
+	} : refused({
+		...read.failure,
+		elementIndex
+	}, suggestedTypes);
 }
 /** The column's `typeParams` as the codec reference carries them, so `vector(3)` checks its length. */
 function codecRefTypeParams(typeParams) {
 	return typeParams === void 0 ? void 0 : blindCast(typeParams);
 }
 /** A value in the canonical form of the column's values, when they have one. */
-function inCanonicalForm(toCanonicalForm, value, elementIndex) {
+function inCanonicalForm(toCanonicalForm, value, elementIndex, suggestedTypes) {
 	if (toCanonicalForm === void 0) return {
 		ok: true,
 		value
@@ -193,7 +101,8 @@ function inCanonicalForm(toCanonicalForm, value, elementIndex) {
 				kind: "unreadable",
 				message: messageOf(error),
 				elementIndex
-			}
+			},
+			suggestedTypes
 		};
 	}
 }
@@ -207,6 +116,7 @@ function storedValueReader(input) {
 		...ifDefined("typeParams", codecRefTypeParams(input.column.typeParams))
 	});
 	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 suggestedTypes = [descriptor.dataType];
 	const toCanonicalForm = canonicalFormOf(descriptor, input.dataTypeLookup);
 	const read = (written, elementIndex) => {
 		try {
@@ -220,10 +130,11 @@ function storedValueReader(input) {
 					codecId: input.column.codecId,
 					message: messageOf(error),
 					elementIndex
-				}
+				},
+				suggestedTypes
 			};
 		}
-		return inCanonicalForm(toCanonicalForm, written, elementIndex);
+		return inCanonicalForm(toCanonicalForm, written, elementIndex, suggestedTypes);
 	};
 	return {
 		descriptor,
@@ -231,11 +142,11 @@ function storedValueReader(input) {
 	};
 }
 /**
-* 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.
+* Reads a value already in its stored JSON form, such as one member of a JSON document default, with the column's codec, and gives it the canonical form of the column's values. Worded as {@link lowerDataTypeDefault} words the same refusals.
 */
 function readStoredValue(input) {
 	const reading = storedValueReader(input).read(input.value, void 0);
-	return reading.ok ? reading : refusalDiagnostic(reading.refusal, `Field "${input.fieldPath}"`);
+	return reading.ok ? reading : storedRefusalDiagnostic(reading.refusal, `Field "${input.fieldPath}"`);
 }
 /**
 * Read one `@default(...)` value for a column, refusing in parts so each contract source words its
@@ -246,37 +157,31 @@ function readStoredValue(input) {
 function readDataTypeDefault(input) {
 	const { descriptor, read: readStored } = storedValueReader({
 		...input,
-		dataTypeLookup: input.support.lookup
+		dataTypeLookup: input.dataTypes.lookup
 	});
 	const columnType = descriptor.dataType;
+	const suggestedTypes = [columnType];
 	const readOne = (written, elementIndex) => {
-		const read = readValue(input.support, written, elementIndex);
+		const read = readOneValue(input.dataTypes, written, elementIndex, suggestedTypes);
 		if (!read.ok) return read;
-		const cast = castInto(input.support, columnType, read.typed, elementIndex);
-		if (!cast.ok) return cast;
-		return readStored(cast.value, elementIndex);
+		const cast = castTypedValue(input.dataTypes, columnType, read.typed);
+		if (!cast.ok) return refused({
+			...cast.failure,
+			elementIndex
+		}, suggestedTypes);
+		return readStored(cast.value.value, elementIndex);
 	};
 	if (input.written.kind !== "list") {
-		if (input.isList) return {
-			ok: false,
-			refusal: {
-				kind: "not-a-list",
-				elementIndex: void 0
-			}
-		};
+		if (input.isList) return refused({
+			kind: "not-a-list",
+			elementIndex: void 0
+		}, suggestedTypes);
 		return readOne(input.written, void 0);
 	}
 	if (input.isList) {
 		const elements = [];
 		for (const [elementIndex, written] of input.written.elements.entries()) {
-			if (written.kind === "list") return {
-				ok: false,
-				refusal: {
-					kind: "unreadable",
-					message: "a list holds values, not other lists",
-					elementIndex
-				}
-			};
+			if (written.kind === "list") return nestedList(elementIndex, suggestedTypes);
 			const element = readOne(written, elementIndex);
 			if (!element.ok) return element;
 			elements.push(element.value);
@@ -293,122 +198,159 @@ function readDataTypeDefault(input) {
 		readStored
 	});
 }
+function nestedList(elementIndex, suggestedTypes) {
+	return refused({
+		kind: "unreadable",
+		message: "a list holds values, not other lists",
+		elementIndex
+	}, suggestedTypes);
+}
 /** A written list on a column that is not a list: the column's type takes it through its list cast. */
 function readListIntoScalar(input) {
-	const listCast = input.support.lookup.get(input.columnType)?.listCast;
-	if (listCast === void 0) return {
-		ok: false,
-		refusal: {
-			kind: "no-cast",
-			columnType: input.columnType,
-			valueType: "a list",
-			casts: Object.keys(input.support.lookup.get(input.columnType)?.casts ?? {}),
-			elementIndex: void 0
-		}
-	};
+	const declaration = input.dataTypes.lookup.get(input.columnType);
+	const listCast = declaration?.listCast;
+	if (listCast === void 0) return refused({
+		kind: "no-list-cast",
+		receivingType: input.columnType,
+		casts: Object.keys(declaration?.casts ?? {}),
+		elementIndex: void 0
+	}, [input.columnType]);
 	const elements = [];
 	for (const [elementIndex, written] of input.written.elements.entries()) {
-		if (written.kind === "list") return {
-			ok: false,
-			refusal: {
-				kind: "unreadable",
-				message: "a list holds values, not other lists",
-				elementIndex
-			}
-		};
-		const read = readValue(input.support, written, elementIndex);
+		if (written.kind === "list") return nestedList(elementIndex, listCast.of);
+		const read = readOneValue(input.dataTypes, written, elementIndex, listCast.of);
 		if (!read.ok) return read;
-		if (!listCast.of.includes(read.typed.type)) return {
-			ok: false,
-			refusal: {
-				kind: "no-cast",
-				columnType: input.columnType,
-				valueType: read.typed.type,
-				casts: [...listCast.of],
-				elementIndex
-			}
-		};
+		if (!listCast.of.includes(read.typed.type)) return refused({
+			kind: "no-element-cast",
+			receivingType: input.columnType,
+			valueType: read.typed.type,
+			elementTypes: listCast.of,
+			elementIndex
+		}, listCast.of);
 		elements.push(read.typed.value);
 	}
 	try {
 		return input.readStored(listCast.cast(elements), void 0);
 	} catch (error) {
 		if (isInternalError(error)) throw error;
-		return {
-			ok: false,
-			refusal: {
-				kind: "unreadable",
-				message: messageOf(error),
-				elementIndex: void 0
-			}
-		};
+		return refused({
+			kind: "unreadable",
+			message: messageOf(error),
+			elementIndex: void 0
+		}, [input.columnType]);
 	}
 }
-/** Where in a written list a diagnostic is about, for a message: ` at element 2`. */
-function at(elementIndex) {
-	return elementIndex === void 0 ? "" : ` at element ${elementIndex + 1}`;
+/** Where a diagnostic is about, for a message: `Field "N.count" at element 2`. */
+function location(subject, elementIndex) {
+	return elementIndex === void 0 ? subject : `${subject} at element ${elementIndex + 1}`;
+}
+/**
+* What may be written where every one of `types` is received, each form once: `a number`. A column
+* whose type nothing writes still takes a `sql` literal, which `@default` stores as a SQL expression.
+*/
+function formsOf(dataTypes, types) {
+	const forms = admittedForms(dataTypes, types);
+	return forms.length === 0 ? [tagForm("sql")] : forms;
+}
+/** The exact rewrite of the written value a `no-cast` refusal is about, before list elements are renumbered to the source list. */
+function rewriteOf(refusal, written, dataTypes) {
+	if (refusal.kind !== "no-cast") return void 0;
+	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. */
 function lowerDataTypeDefault(input) {
 	const read = readDataTypeDefault(input);
-	return read.ok ? read : refusalDiagnostic(read.refusal, `Field "${input.fieldPath}"`);
+	return read.ok ? read : refusalDiagnostic(atSourceElement(read.refusal, input.sourceElementIndexes), `Field "${input.fieldPath}"`, input.dataTypes, guidanceFor(read, input.written, input.dataTypes));
 }
 /**
 * 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`.
 */
 function readWrittenNumberForCodec(input) {
+	const written = {
+		kind: "number",
+		text: input.text
+	};
 	const read = readDataTypeDefault({
-		written: {
-			kind: "number",
-			text: input.text
-		},
+		written,
 		isList: false,
 		column: { codecId: input.codecId },
 		codecLookup: input.codecLookup,
-		support: input.support,
+		dataTypes: input.dataTypes,
 		fieldPath: input.subject
 	});
-	return read.ok ? read : refusalDiagnostic(read.refusal, input.subject);
+	return read.ok ? read : refusalDiagnostic(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) {
+	return {
+		forms: formsOf(dataTypes, failure.suggestedTypes),
+		rewrite: rewriteOf(failure.refusal, written, dataTypes)
+	};
+}
+function atSourceElement(refusal, sourceElementIndexes) {
+	if (refusal.elementIndex === void 0) return refusal;
+	const elementIndex = sourceElementIndexes?.[refusal.elementIndex];
+	return elementIndex === void 0 ? refusal : {
+		...refusal,
+		elementIndex
+	};
 }
-/** A refusal worded as a PSL diagnostic's code and message. */
-function refusalDiagnostic(refusal, subject) {
-	const where = `${subject}${at(refusal.elementIndex)}`;
+function codecRefusalDiagnostic(refusal, subject) {
+	return {
+		ok: false,
+		code: PSL_INVALID_DEFAULT_LITERAL,
+		message: `${location(subject, refusal.elementIndex)}: ${refusal.message}`,
+		place: { kind: "attribute" }
+	};
+}
+function storedRefusalDiagnostic(refusal, subject) {
+	if (refusal.kind === "refused-by-codec") return codecRefusalDiagnostic(refusal, subject);
+	return {
+		ok: false,
+		code: "PSL_INVALID_LITERAL",
+		message: `${location(subject, refusal.elementIndex)}: ${refusal.message}`,
+		place: { kind: "attribute" }
+	};
+}
+/** A refusal worded as a PSL diagnostic's code, message and place; `guidance` says what to write instead. */
+function refusalDiagnostic(refusal, subject, dataTypes, guidance) {
+	const where = location(subject, refusal.elementIndex);
+	const atWrittenValue = {
+		kind: "written-value",
+		elementIndex: refusal.elementIndex
+	};
 	switch (refusal.kind) {
-		case "unreadable": return {
-			ok: false,
-			code: "PSL_INVALID_LITERAL",
-			message: `${where}: ${refusal.message}`
-		};
-		case "unknown-tag": return {
-			ok: false,
-			code: "PSL_UNKNOWN_LITERAL_TAG",
-			message: `Unknown literal tag "${refusal.tag}". Known tags: ${refusal.known.join(", ")}.`
-		};
-		case "unwritable": return {
-			ok: false,
-			code: PSL_VALUE_TYPE_INCOMPATIBLE,
-			message: `${where}: this target has no data type for a ${refusal.syntax} value`
-		};
 		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]`
+			message: `${where}: this column holds a list, so its default is a list literal, as in [1, 2]`,
+			place: { kind: "attribute" }
 		};
-		case "no-cast": return {
+		case "refused-by-codec": return codecRefusalDiagnostic(refusal, subject);
+		case "no-list-cast": return {
 			ok: false,
 			code: PSL_VALUE_TYPE_INCOMPATIBLE,
-			message: `${where}: ${refusal.columnType} has no cast from ${refusal.valueType}; ${describeCasts(refusal.casts)}`
+			message: `${where}: ${describeExpected(guidance.forms)}; got a list`,
+			place: atWrittenValue
 		};
-		case "refused-by-codec": return {
+		case "no-element-cast": return {
 			ok: false,
-			code: PSL_INVALID_DEFAULT_LITERAL,
-			message: `${where}: ${refusal.message}`
+			code: PSL_VALUE_TYPE_INCOMPATIBLE,
+			message: `${where}: ${describeRefusedValueType(refusal, dataTypes, guidance)}`,
+			place: atWrittenValue
 		};
+		default: {
+			const { code, message } = describeRefusal(refusal, dataTypes, guidance);
+			return {
+				ok: false,
+				code,
+				message: `${where}: ${message}`,
+				place: atWrittenValue
+			};
+		}
 	}
 }
-function describeCasts(casts) {
-	return casts.length === 0 ? "it casts from nothing" : `it casts from ${casts.join(", ")}`;
-}
 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);
@@ -524,29 +466,32 @@ function nullLiteral() {
 		}
 	};
 }
-function scalarDefaultArms(isList, registries) {
-	const tagsByDocumentation = /* @__PURE__ */ new Map();
-	for (const entry of Object.values(registries.dataTypeEntries)) {
-		if (entry.written.kind !== "tag") continue;
-		const tags = tagsByDocumentation.get(entry.documentation);
-		if (tags === void 0) tagsByDocumentation.set(entry.documentation, [entry.written.tag]);
-		else tags.push(entry.written.tag);
-	}
-	const tagArms = () => [...tagsByDocumentation].map(([documentation, tags]) => taggedLiteral(tags, { documentation }));
-	const literal = () => oneOf(str(), numLiteral(), bool(), nullLiteral(), ...tagArms());
+function scalarDefaultArms(isList, dataTypes, registries) {
+	const tagArms = (admits) => {
+		const tagsByDocumentation = /* @__PURE__ */ new Map();
+		for (const [dataType, entry] of Object.entries(dataTypes.entries)) {
+			if (entry.written.kind !== "tag" || !admits(dataType)) continue;
+			const tags = tagsByDocumentation.get(entry.documentation);
+			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 }));
+	};
+	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)));
 	return isList ? [
 		listArm(),
 		...funcArms,
-		...tagArms()
+		...anyTag()
 	] : [
 		str(),
 		numLiteral(),
 		bool(),
 		nullLiteral(),
 		...funcArms,
-		...tagArms(),
+		...anyTag(),
 		listArm()
 	];
 }
@@ -596,7 +541,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.controlMutationDefaults) : enumDefaultArms(members, ctx.field.typeName, ctx.field.list), ctx.controlMutationDefaults.defaultFunctionRegistry),
+			type: defaultValueArm(members === void 0 ? scalarDefaultArms(ctx.field.list, ctx.dataTypes, ctx.controlMutationDefaults) : enumDefaultArms(members, ctx.field.typeName, ctx.field.list), ctx.controlMutationDefaults.defaultFunctionRegistry),
 			documentation: "A literal, enum member, or registered default function compatible with this field."
 		}]
 	});
@@ -851,7 +796,8 @@ function fieldSpecContext(input) {
 		model: input.model,
 		field: input.field,
 		typeResolution: node === void 0 ? void 0 : input.binder.symbolForNode(node),
-		controlMutationDefaults: input.controlMutationDefaults
+		controlMutationDefaults: input.controlMutationDefaults,
+		dataTypes: input.dataTypes
 	};
 }
 const sqlAttributeSpecs = {
@@ -1343,26 +1289,12 @@ const TAGGED_LITERAL_CANONICALIZATION_CODES = {
 	nul: "PSL_TAGGED_LITERAL_NUL",
 	"too-large": "PSL_TAGGED_LITERAL_TOO_LARGE"
 };
-function readTaggedLiteral(literal, support, source) {
-	const reject = (code, message) => ({
-		ok: false,
-		diagnostic: {
-			code,
-			message,
-			...source.at(literal.span)
-		}
-	});
-	if (entryForTag(support, literal.tag) === void 0) return reject("PSL_UNKNOWN_LITERAL_TAG", `Unknown literal tag "${literal.tag}". Known tags: ${knownTags(support).join(", ")}.`);
-	const { canonicalization } = literal;
-	if (!canonicalization.ok) return reject(TAGGED_LITERAL_CANONICALIZATION_CODES[canonicalization.reason], describeTaggedLiteralFailure(canonicalization.reason));
-	return {
-		ok: true,
-		written: {
-			kind: "tag",
-			tag: literal.tag,
-			text: canonicalization.body
-		}
-	};
+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()];
 }
 function rejectStrictListNullDefault(input) {
 	if (input.field.elementOptional) return false;
@@ -1391,10 +1323,8 @@ function lowerDefaultForField(input) {
 		model: input.model,
 		field: input.field,
 		binder: input.binder,
-		controlMutationDefaults: {
-			defaultFunctionRegistry: input.defaultFunctionRegistry,
-			dataTypeEntries: input.dataTypeSupport.entries
-		}
+		controlMutationDefaults: { defaultFunctionRegistry: input.defaultFunctionRegistry },
+		dataTypes: input.dataTypes
 	}));
 	const interpreted = interpretFieldAttribute({
 		symbols: input.symbolTable,
@@ -1427,21 +1357,29 @@ 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();
+	};
 	const readsListElements = (written) => input.isListColumn || input.field.list && written.kind === "list";
-	const readAsLiteral = (written) => {
+	const readAsLiteral = (written, sourceElementIndexes) => {
 		const lowered = lowerDataTypeDefault({
 			written,
+			sourceElementIndexes,
 			isList: readsListElements(written),
 			column: input.columnDescriptor,
 			codecLookup: input.codecLookup,
-			support: input.dataTypeSupport,
+			dataTypes: input.dataTypes,
 			fieldPath: `${input.modelName}.${input.fieldName}`
 		});
 		if (!lowered.ok) {
 			input.diagnostics.push({
 				code: lowered.code,
 				message: lowered.message,
-				...source.at()
+				...refusalLocation(lowered.place)
 			});
 			return {};
 		}
@@ -1466,7 +1404,7 @@ function lowerDefaultForField(input) {
 				elementNullable: input.field.elementOptional,
 				...input.valueObjectDefault,
 				codecLookup: input.codecLookup,
-				dataTypeLookup: input.dataTypeSupport.lookup
+				dataTypeLookup: input.dataTypes.lookup
 			});
 			for (const { code, message } of mismatches) input.diagnostics.push({
 				code,
@@ -1486,7 +1424,7 @@ function lowerDefaultForField(input) {
 			canonical: true
 		} };
 	};
-	const writtenElement = (element) => {
+	const writtenScalar = (element) => {
 		if (typeof element === "string") return {
 			kind: "string",
 			text: element
@@ -1499,16 +1437,24 @@ function lowerDefaultForField(input) {
 			kind: "number",
 			text: element.text
 		};
-		const literal = readTaggedLiteral(element, input.dataTypeSupport, source);
-		if (!literal.ok) {
-			input.diagnostics.push(literal.diagnostic);
+		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 literal.written;
+		return {
+			kind: "tag",
+			tag: element.tag,
+			text: canonicalization.text
+		};
 	};
 	const sqlExpressionDefault = (text, span) => {
-		const reserved = reservedSqlDefaultBody(text);
-		const refusal = reserved === void 0 ? checkSqlDefaultBody(text) : `Write @default(${reserved}()) instead of sql\`${reserved}()\`; ${reserved}() is a Prisma default function, not raw SQL.`;
+		const reserved = reservedSqlDefaultText(text);
+		const refusal = reserved === void 0 ? checkSqlDefaultText(text) : `Write @default(${reserved}()) instead of sql\`${reserved}()\`; ${reserved}() is a Prisma default function, not raw SQL.`;
 		if (refusal !== void 0) {
 			input.diagnostics.push({
 				code: PSL_INVALID_DEFAULT_SQL,
@@ -1537,16 +1483,18 @@ function lowerDefaultForField(input) {
 	}
 	if (Array.isArray(value)) {
 		const elements = [];
-		for (const element of value) {
+		const sourceElementIndexes = [];
+		for (const [sourceIndex, element] of value.entries()) {
 			if (element === null) continue;
-			const written = writtenElement(element);
+			const written = writtenScalar(element);
 			if ("ok" in written) return {};
 			elements.push(written);
+			sourceElementIndexes.push(sourceIndex);
 		}
 		return readAsLiteral({
 			kind: "list",
 			elements
-		});
+		}, sourceElementIndexes);
 	}
 	if (typeof value === "string") return readAsLiteral({
 		kind: "string",
@@ -1561,14 +1509,11 @@ function lowerDefaultForField(input) {
 		text: value.text
 	});
 	if ("tag" in value) {
-		const literal = readTaggedLiteral(value, input.dataTypeSupport, source);
-		if (!literal.ok) {
-			input.diagnostics.push(literal.diagnostic);
-			return {};
-		}
-		const read = readValue(input.dataTypeSupport, literal.written, void 0);
-		if (read.ok && read.typed.type === SQL_EXPRESSION_DATA_TYPE_ID) return sqlExpressionDefault(sqlTextFromCanonical(read.typed.value), value.span);
-		return readAsLiteral(literal.written);
+		const written = writtenScalar(value);
+		if ("ok" in written) return {};
+		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);
 	}
 	if (typeof value === "object") {
 		const context = {
@@ -1630,10 +1575,8 @@ function lowerEnumDefaultForField(input) {
 			model,
 			field,
 			binder: input.binder,
-			controlMutationDefaults: {
-				defaultFunctionRegistry: input.defaultFunctionRegistry,
-				dataTypeEntries: input.dataTypeSupport.entries
-			}
+			controlMutationDefaults: { defaultFunctionRegistry: input.defaultFunctionRegistry },
+			dataTypes: input.dataTypes
 		})),
 		symbols: input.symbolTable,
 		model,
@@ -1782,7 +1725,7 @@ function lowerNoCheckForField(input) {
 	return [...authored].sort();
 }
 function collectResolvedFields(input) {
-	const { model, symbolTable, enumTypeDescriptors, namedTypeDescriptors, valueObjectTypes, authoringContributions, binder, targetId, defaultFunctionRegistry, dataTypeSupport, generatorDescriptorById, diagnostics, sources, scalarColumnDescriptors, enumHandles, capabilities, namespaceId, namespaceExtensionEntities, codecLookup } = input;
+	const { model, symbolTable, enumTypeDescriptors, namedTypeDescriptors, valueObjectTypes, authoringContributions, binder, targetId, defaultFunctionRegistry, dataTypes, 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();
@@ -1884,7 +1827,7 @@ function collectResolvedFields(input) {
 			binder: input.binder,
 			enumHandle,
 			defaultFunctionRegistry,
-			dataTypeSupport,
+			dataTypes,
 			diagnostics
 		}) : lowerDefaultForField({
 			modelName: model.name,
@@ -1902,7 +1845,7 @@ function collectResolvedFields(input) {
 			},
 			generatorDescriptorById,
 			defaultFunctionRegistry,
-			dataTypeSupport,
+			dataTypes,
 			codecLookup,
 			diagnostics
 		}) : {};
@@ -2001,6 +1944,6 @@ function collectResolvedFields(input) {
 	return resolvedFields;
 }
 //#endregion
-export { toNamedTypeFieldDescriptor as C, storageName as S, modelCoordinateKey as _, describeUnsupportedSqlAttribute as a, resolveFieldTypeDescriptor 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, entryForTag as o, interpretFieldAttribute as p, collectResolvedFields as r, formatDbAttributeMigrationMessage as s, PSL_CHECK_ON_STI_VARIANT as t, getNamedArgument as u, readDataTypeDefault as v, sqlAttributeSpecs as x, readWrittenNumberForCodec as y };
+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 };
 
-//# sourceMappingURL=psl-field-resolution-Bi-CSeoQ-Do_5hZ8Z.mjs.map
+//# sourceMappingURL=psl-field-resolution-DUCrDnuq-BXwISml1.mjs.map