@prisma/orm-family-sql 8.0.0-rc.11-dev.41 → 8.0.0-rc.11-dev.43

package/dist/{interpreter-Bf7Um__3-DC_thY44.mjs → interpreter-DvKii7Bl-D8Ipte3f.mjs}

@@ -1,22 +1,23 @@
 import { n as isAuthoredIndexInput } from "./index-naming-Cj1Anq-T-w1JL7-EM.mjs";
 import { t as deriveValueSetFromEntity } from "./value-set-derivation-hook-Di9JZ0X7.mjs";
-import { n as buildSqlContractFromDefinition } from "./derived-checks-C4BPtrnO-B9MQRh6W.mjs";
-import { a as interpretFieldAttribute, i as findModelAttributeNode, n as fieldSpecContext, o as interpretModelAttribute, r as findFieldAttributeNode, s as sqlAttributeSpecs, t as PSL_CHECK_ON_STI_VARIANT } from "./sql-attribute-specs-DAEpjrWl-C0kmaUJt.mjs";
+import { n as buildSqlContractFromDefinition } from "./derived-checks-6WZKIUxH-B3Pd6QA5.mjs";
+import { a as interpretFieldAttribute, i as findModelAttributeNode, n as fieldSpecContext, o as interpretModelAttribute, r as findFieldAttributeNode, s as sqlAttributeSpecs, t as PSL_CHECK_ON_STI_VARIANT } from "./sql-attribute-specs-CQoOV2MU-DLD9uxC6.mjs";
 import { t as defaultTableName } from "./default-table-name-BfFY8qYR-lHNcVmY5.mjs";
-import { structuredError } from "@prisma/orm-framework/utils/structured-error";
-import { hasRegisteredFieldNamespace, instantiateAuthoringEntityType, instantiateAuthoringFieldPreset, instantiateAuthoringTypeConstructor, isAuthoringEntityTypeDescriptor, isAuthoringFieldPresetDescriptor, isAuthoringModelAttributeDescriptor, isAuthoringPslBlockDescriptor, isAuthoringTypeConstructorDescriptor, validateAuthoringHelperArguments } from "@prisma/orm-framework/components/authoring";
+import { isStructuredError, structuredError } from "@prisma/orm-framework/utils/structured-error";
+import { hasRegisteredFieldNamespace, instantiateAuthoringEntityType, instantiateAuthoringFieldPreset, instantiateAuthoringTypeConstructor, isAuthoringEntityTypeDescriptor, isAuthoringFieldPresetDescriptor, isAuthoringModelAttributeDescriptor, isAuthoringPslBlockDescriptor, isAuthoringTypeConstructorDescriptor, isDataTypeLoweringEntry, loweringEntryKey, validateAuthoringHelperArguments } from "@prisma/orm-framework/components/authoring";
 import { UNBOUND_NAMESPACE_ID } from "@prisma/orm-framework/components/ir";
 import { InternalError } from "@prisma/orm-framework/utils/internal-error";
 import { crossRef } from "@prisma/orm-framework/contract/types";
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
 import { blindCast } from "@prisma/orm-framework/utils/casts";
 import { resolveToOneRelationNullable } from "@prisma/orm-framework/contract-authoring";
+import { materializeCodec } from "@prisma/orm-framework/components/codec";
 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 { createPslDiagnosticCollector, diagnosticSource, findBlockDescriptor, keywordPslSpan, nodePslSpan } from "@prisma/orm-framework/psl-parser";
 import { consumeInvalidFkPairing, fkRelationPairKey, requiredOneToOneBackrelationDiagnostic } from "@prisma/orm-framework/psl-parser/interpret";
-//#region ../../../2-sql/2-authoring/contract-psl/dist/interpreter-Bf7Um__3.mjs
+//#region ../../../2-sql/2-authoring/contract-psl/dist/interpreter-DvKii7Bl.mjs
 function contractError(code, message, options) {
 	return structuredError(code, message, options);
 }
@@ -56,6 +57,316 @@ function mapFieldNamesToColumns(input) {
 	}
 	return columns;
 }
+/** A `` json`...` `` body that is not a JSON document. */
+const PSL_INVALID_JSON_LITERAL = "PSL_INVALID_JSON_LITERAL";
+/** A written value the entry, a cast, or the column's codec refuses. */
+const PSL_INVALID_DEFAULT_LITERAL = "PSL_INVALID_DEFAULT_LITERAL";
+/** A written value whose data type the column's type neither is nor casts from. */
+const PSL_DEFAULT_TYPE_INCOMPATIBLE = "PSL_DEFAULT_TYPE_INCOMPATIBLE";
+/** The code the JSON reader raises, so the PSL diagnostic for a bad document is its own. */
+const INVALID_JSON_CODE = "CONTRACT.INVALID_JSON_LITERAL";
+/** The value entries of a stack, by data type id. */
+function valueEntries(support) {
+	return Object.entries(support.entries).flatMap(([key, entry]) => isDataTypeLoweringEntry(entry) ? [] : [[key, entry]]);
+}
+/** The entry a tag names, or `undefined` when no pack registered that tag. */
+function entryForTag(support, tag) {
+	for (const [key, entry] of valueEntries(support)) 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 valueEntries(support)) if (entry.written.kind === "plain" && entry.written.syntax === syntax) return {
+		key,
+		entry
+	};
+}
+/** The text an entry reads: a tag's body, a string's value, or the word a boolean is written as. */
+function plainText(written) {
+	switch (written.kind) {
+		case "tag": return written.body;
+		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);
+}
+function isJsonRefusal(error) {
+	return isStructuredError(error) && error.code === INVALID_JSON_CODE;
+}
+/** Read one written value through the entry for its syntax. */
+function readValue(support, written, elementIndex) {
+	const refuse = (refusal) => ({
+		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",
+			json: false,
+			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(found.key),
+				value: form.parse(text)
+			}
+		};
+	} catch (error) {
+		return refuse({
+			kind: "unreadable",
+			json: isJsonRefusal(error),
+			message: messageOf(error)
+		});
+	}
+}
+/** 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 {
+		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) {
+		return {
+			ok: false,
+			refusal: {
+				kind: "unreadable",
+				json: isJsonRefusal(error),
+				message: messageOf(error),
+				elementIndex
+			}
+		};
+	}
+}
+/** 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);
+}
+/**
+* Read one `@default(...)` value for a column, refusing in parts so each contract source words its
+* own diagnostic. `isList` selects the check: a list column's elements are each read and cast
+* against the element codec's data type, while a scalar column takes a written list only through
+* its type's list cast — which is how `pgvector.Vector(3) @default([0.1, 0.2])` is read.
+*/
+function readDataTypeDefault(input) {
+	const descriptorFor = input.codecLookup?.descriptorFor;
+	if (descriptorFor === void 0) throw new InternalError(`Field "${input.fieldPath}": the codec lookup resolving column codecs exposes no descriptorFor, but the column was resolved from a codec descriptor.`);
+	const descriptor = descriptorFor(input.column.codecId);
+	if (descriptor === void 0) throw new InternalError(`Field "${input.fieldPath}": no codec descriptor is registered for "${input.column.codecId}", but the column was resolved from one.`);
+	const columnType = descriptor.dataType;
+	const codec = materializeCodec(descriptor, {
+		codecId: input.column.codecId,
+		...ifDefined("typeParams", codecRefTypeParams(input.column.typeParams))
+	}, { name: input.fieldPath });
+	const validate = (value, elementIndex) => {
+		try {
+			codec.decodeJson(value);
+			return {
+				ok: true,
+				value
+			};
+		} catch (error) {
+			return {
+				ok: false,
+				refusal: {
+					kind: "undecodable",
+					codecId: input.column.codecId,
+					message: messageOf(error),
+					elementIndex
+				}
+			};
+		}
+	};
+	const readOne = (written, elementIndex) => {
+		const read = readValue(input.support, written, elementIndex);
+		if (!read.ok) return read;
+		const cast = castInto(input.support, columnType, read.typed, elementIndex);
+		if (!cast.ok) return cast;
+		return validate(cast.value, elementIndex);
+	};
+	if (input.written.kind !== "list") {
+		if (input.isList) return {
+			ok: false,
+			refusal: {
+				kind: "not-a-list",
+				elementIndex: void 0
+			}
+		};
+		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",
+					json: false,
+					message: "a list holds values, not other lists",
+					elementIndex
+				}
+			};
+			const element = readOne(written, elementIndex);
+			if (!element.ok) return element;
+			elements.push(element.value);
+		}
+		return {
+			ok: true,
+			value: elements
+		};
+	}
+	return readListIntoScalar({
+		...input,
+		written: input.written,
+		columnType,
+		validate
+	});
+}
+/** 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 elements = [];
+	for (const [elementIndex, written] of input.written.elements.entries()) {
+		if (written.kind === "list") return {
+			ok: false,
+			refusal: {
+				kind: "unreadable",
+				json: false,
+				message: "a list holds values, not other lists",
+				elementIndex
+			}
+		};
+		const read = readValue(input.support, written, elementIndex);
+		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
+			}
+		};
+		elements.push(read.typed.value);
+	}
+	try {
+		return input.validate(listCast.cast(elements), void 0);
+	} catch (error) {
+		return {
+			ok: false,
+			refusal: {
+				kind: "unreadable",
+				json: isJsonRefusal(error),
+				message: messageOf(error),
+				elementIndex: void 0
+			}
+		};
+	}
+}
+/** 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}`;
+}
+/** {@link readDataTypeDefault} worded as a PSL diagnostic's code and message. */
+function lowerDataTypeDefault(input) {
+	const read = readDataTypeDefault(input);
+	if (read.ok) return read;
+	const { refusal } = read;
+	const where = `Field "${input.fieldPath}"${at(refusal.elementIndex)}`;
+	switch (refusal.kind) {
+		case "unreadable": return {
+			ok: false,
+			code: refusal.json ? PSL_INVALID_JSON_LITERAL : PSL_INVALID_DEFAULT_LITERAL,
+			message: `${where}: ${refusal.message}`
+		};
+		case "unknown-tag": return {
+			ok: false,
+			code: "PSL_UNKNOWN_DEFAULT_LITERAL_TAG",
+			message: `Unknown literal tag "${refusal.tag}". Known tags: ${refusal.known.join(", ")}.`
+		};
+		case "unwritable": return {
+			ok: false,
+			code: PSL_DEFAULT_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_TYPE_INCOMPATIBLE,
+			message: `${where}: this column holds a list, so its default is a list literal, as in [1, 2]`
+		};
+		case "no-cast": return {
+			ok: false,
+			code: PSL_DEFAULT_TYPE_INCOMPATIBLE,
+			message: `${where}: ${refusal.columnType} has no cast from ${refusal.valueType}; ${describeCasts(refusal.casts)}`
+		};
+		case "undecodable": return {
+			ok: false,
+			code: PSL_INVALID_DEFAULT_LITERAL,
+			message: `${where}: ${refusal.message}`
+		};
+	}
+}
+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);
@@ -86,44 +397,6 @@ function lowerDefaultFunctionWithRegistry(input) {
 		}
 	};
 }
-/**
-* The default value a number literal gives a column whose codec holds numbers. Returns `undefined`
-* when the codec does not hold numbers, or reads the literal neither as a JSON number nor as
-* decimal text.
-*/
-function numberLiteralDefault(text, codecId, codecLookup) {
-	const codec = numberHoldingCodec(codecLookup, codecId);
-	if (codec === void 0) return void 0;
-	const number = Number(text);
-	if (tryDecodeJson(codec, number) !== void 0) return number;
-	const decoded = tryDecodeJson(codec, canonicalDecimalText(text));
-	return decoded !== void 0 && isNumberValue(decoded.value) ? decoded.value : void 0;
-}
-function numberHoldingCodec(codecLookup, codecId) {
-	return codecLookup?.descriptorFor?.(codecId)?.traits.includes("numeric") === true ? codecLookup?.get(codecId) : void 0;
-}
-const DECIMAL_NUMERAL = /^(-?)0*(\d+)(\.\d+)?$/;
-/**
-* Leading zeros and the sign of zero never change a decimal. Trailing zeros are kept, because a
-* column without a scale keeps them.
-*/
-function canonicalDecimalText(text) {
-	const numeral = DECIMAL_NUMERAL.exec(text);
-	if (numeral === null) return text;
-	const [, sign = "", whole = "", fraction = ""] = numeral;
-	const digits = `${whole}${fraction}`;
-	return /^[0.]+$/.test(digits) ? digits : `${sign}${digits}`;
-}
-function isNumberValue(value) {
-	return typeof value === "string" || typeof value === "number" || typeof value === "bigint";
-}
-function tryDecodeJson(codec, json) {
-	try {
-		return { value: codec.decodeJson(json) };
-	} catch {
-		return;
-	}
-}
 const INVALID_AUTHORING_ARGUMENT = Symbol("invalidAuthoringArgument");
 function isIdentifierStartCharacter(character) {
 	return character !== void 0 && /[A-Za-z_$]/.test(character);
@@ -797,7 +1070,7 @@ const TAGGED_LITERAL_CANONICALIZATION_CODES = {
 	nul: "PSL_TAGGED_LITERAL_NUL",
 	"too-large": "PSL_TAGGED_LITERAL_TOO_LARGE"
 };
-function lowerTaggedLiteral(literal, registry, context, source) {
+function lowerTaggedLiteral(literal, support, context, source) {
 	const reject = (code, message) => ({
 		ok: false,
 		kind: "owned",
@@ -807,10 +1080,18 @@ function lowerTaggedLiteral(literal, registry, context, source) {
 			...source.at(literal.span)
 		}
 	});
-	const entry = registry.get(literal.tag);
-	if (entry === void 0) return reject("PSL_UNKNOWN_DEFAULT_LITERAL_TAG", `Unknown literal tag "${literal.tag}". Known tags: ${[...registry.keys()].join(", ")}.`);
+	const entry = support.entries[loweringEntryKey(literal.tag)] ?? entryForTag(support, literal.tag)?.entry;
+	if (entry === void 0) return reject("PSL_UNKNOWN_DEFAULT_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));
+	if (!isDataTypeLoweringEntry(entry)) return {
+		ok: true,
+		written: {
+			kind: "tag",
+			tag: literal.tag,
+			body: canonicalization.body
+		}
+	};
 	const result = entry.lower({
 		literal: {
 			tag: literal.tag,
@@ -836,7 +1117,7 @@ function lowerDefaultForField(input) {
 			field: input.field,
 			controlMutationDefaults: {
 				defaultFunctionRegistry: input.defaultFunctionRegistry,
-				defaultLiteralTagRegistry: input.defaultLiteralTagRegistry
+				dataTypeEntries: input.dataTypeSupport.entries
 			}
 		})),
 		model: input.model,
@@ -846,65 +1127,140 @@ function lowerDefaultForField(input) {
 	});
 	if (interpreted === void 0) return {};
 	const value = interpreted.value;
-	const literalValue = (literal) => typeof literal === "object" ? numberLiteralDefault(literal.text, input.columnDescriptor.codecId, input.codecLookup) ?? Number(literal.text) : literal;
-	if (Array.isArray(value)) return { defaultValue: {
-		kind: "literal",
-		value: value.map(literalValue)
-	} };
-	if (typeof value === "object" && "text" in value) return { defaultValue: {
-		kind: "literal",
-		value: literalValue(value)
-	} };
-	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 = "tag" in value ? lowerTaggedLiteral(value, input.defaultLiteralTagRegistry, context, source) : lowerDefaultFunctionWithRegistry({
-			call: value,
-			registry: input.defaultFunctionRegistry,
-			context,
-			source
+	const context = {
+		sourceId: input.sources.sourceFileFor(node.syntax).filename,
+		modelName: input.modelName,
+		fieldName: input.fieldName,
+		columnCodecId: input.columnDescriptor.codecId
+	};
+	const readAsLiteral = (written) => {
+		const lowered = lowerDataTypeDefault({
+			written,
+			isList: input.field.list,
+			column: input.columnDescriptor,
+			codecLookup: input.codecLookup,
+			support: input.dataTypeSupport,
+			fieldPath: `${input.modelName}.${input.fieldName}`
 		});
 		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)
+				code: lowered.code,
+				message: lowered.message,
+				...source.at()
 			});
 			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 {};
+		return { defaultValue: {
+			kind: "literal",
+			value: lowered.value,
+			canonical: true
+		} };
+	};
+	const writtenElement = (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 lowered = lowerTaggedLiteral(element, input.dataTypeSupport, context, source);
+		if (!lowered.ok) {
+			if (lowered.kind === "owned") input.diagnostics.push(lowered.diagnostic);
+			else input.diagnostics.pushExternal(lowered.diagnostic);
+			return { ok: false };
 		}
-		if (!generatorDescriptor.applicableCodecIds.includes(input.columnDescriptor.codecId)) {
+		if (!("written" in lowered)) {
 			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)
+				code: PSL_INVALID_DEFAULT_LITERAL,
+				message: `Literal tag "${element.tag}" produces a default of its own and cannot be an element of a list literal.`,
+				...source.at(element.span)
 			});
-			return {};
+			return { ok: false };
 		}
-		return { executionDefaults: { onCreate: lowered.value.generated } };
+		return lowered.written;
+	};
+	if (input.columnDescriptor.valueSet !== void 0) {
+		if (typeof value === "string") return { defaultValue: {
+			kind: "literal",
+			value
+		} };
+		if (Array.isArray(value)) {
+			const members = value.filter((element) => typeof element === "string");
+			if (members.length === value.length) return { defaultValue: {
+				kind: "literal",
+				value: members
+			} };
+		}
+	}
+	if (Array.isArray(value)) {
+		const elements = [];
+		for (const element of value) {
+			const written = writtenElement(element);
+			if ("ok" in written) return {};
+			elements.push(written);
+		}
+		return readAsLiteral({
+			kind: "list",
+			elements
+		});
 	}
-	return { defaultValue: {
-		kind: "literal",
+	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
+	});
+	const lowered = "tag" in value ? lowerTaggedLiteral(value, input.dataTypeSupport, context, source) : lowerDefaultFunctionWithRegistry({
+		call: value,
+		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 ("written" in lowered) return readAsLiteral(lowered.written);
+	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 } };
 }
 function resolveColumnDescriptor(field, enumTypeDescriptors, namedTypeDescriptors, scalarColumnDescriptors) {
 	if (namedTypeDescriptors.has(field.typeName)) return namedTypeDescriptors.get(field.typeName);
@@ -924,7 +1280,7 @@ function lowerEnumDefaultForField(input) {
 			field,
 			controlMutationDefaults: {
 				defaultFunctionRegistry: input.defaultFunctionRegistry,
-				defaultLiteralTagRegistry: input.defaultLiteralTagRegistry
+				dataTypeEntries: input.dataTypeSupport.entries
 			}
 		})),
 		model,
@@ -1065,7 +1421,7 @@ function lowerNoCheckForField(input) {
 	return [...authored].sort();
 }
 function collectResolvedFields(input) {
-	const { model, symbolTable, mapping, enumTypeDescriptors, namedTypeDescriptors, modelNames, compositeTypeNames, composedExtensions, authoringContributions, familyId, targetId, defaultFunctionRegistry, defaultLiteralTagRegistry, generatorDescriptorById, diagnostics, sources, scalarColumnDescriptors, enumHandles, capabilities, namespaceId, namespaceExtensionEntities, codecLookup } = input;
+	const { model, symbolTable, mapping, enumTypeDescriptors, namedTypeDescriptors, modelNames, compositeTypeNames, composedExtensions, authoringContributions, familyId, targetId, defaultFunctionRegistry, dataTypeSupport, generatorDescriptorById, diagnostics, sources, scalarColumnDescriptors, enumHandles, capabilities, namespaceId, namespaceExtensionEntities, codecLookup } = input;
 	const resolvedFields = [];
 	const valueObjectStorageTypeName = authoringContributions?.valueObjectStorageType;
 	const declaredControlPolicy = getAttribute(model.attributes, "control")?.args.find((arg) => arg.kind === "positional")?.value.trim();
@@ -1179,7 +1535,7 @@ function collectResolvedFields(input) {
 			sources: input.sources,
 			enumHandle,
 			defaultFunctionRegistry,
-			defaultLiteralTagRegistry,
+			dataTypeSupport,
 			diagnostics
 		}) : lowerDefaultForField({
 			modelName: model.name,
@@ -1191,7 +1547,7 @@ function collectResolvedFields(input) {
 			columnDescriptor: descriptor,
 			generatorDescriptorById,
 			defaultFunctionRegistry,
-			defaultLiteralTagRegistry,
+			dataTypeSupport,
 			codecLookup,
 			diagnostics
 		}) : {};
@@ -2150,7 +2506,7 @@ function buildModelNodeFromPsl(input) {
 		familyId: input.familyId,
 		targetId: input.targetId,
 		defaultFunctionRegistry: input.defaultFunctionRegistry,
-		defaultLiteralTagRegistry: input.defaultLiteralTagRegistry,
+		dataTypeSupport: input.dataTypeSupport,
 		generatorDescriptorById: input.generatorDescriptorById,
 		diagnostics,
 		sources: input.sources,
@@ -2459,7 +2815,7 @@ function buildModelNodeFromPsl(input) {
 					model,
 					controlMutationDefaults: {
 						defaultFunctionRegistry: input.defaultFunctionRegistry,
-						defaultLiteralTagRegistry: input.defaultLiteralTagRegistry
+						dataTypeEntries: input.dataTypeSupport.entries
 					}
 				}),
 				model,
@@ -3211,7 +3567,10 @@ function interpretPslDocumentToSqlContract(input) {
 	const composedExtensions = new Set(input.composedExtensions ?? []);
 	const composedExtensionContracts = input.composedExtensionContracts;
 	const defaultFunctionRegistry = input.controlMutationDefaults?.defaultFunctionRegistry ?? /* @__PURE__ */ new Map();
-	const defaultLiteralTagRegistry = input.controlMutationDefaults?.defaultLiteralTagRegistry ?? /* @__PURE__ */ new Map();
+	const dataTypeSupport = {
+		entries: input.authoringContributions?.dataTypes ?? {},
+		lookup: input.dataTypeLookup
+	};
 	const generatorDescriptors = input.controlMutationDefaults?.generatorDescriptors ?? [];
 	const generatorDescriptorById = /* @__PURE__ */ new Map();
 	for (const descriptor of generatorDescriptors) generatorDescriptorById.set(descriptor.id, descriptor);
@@ -3380,7 +3739,7 @@ function interpretPslDocumentToSqlContract(input) {
 			targetId: input.target.targetId,
 			authoringContributions: input.authoringContributions,
 			defaultFunctionRegistry,
-			defaultLiteralTagRegistry,
+			dataTypeSupport,
 			generatorDescriptorById,
 			scalarColumnDescriptors: input.scalarColumnDescriptors,
 			sources: input.sources,
@@ -3543,6 +3902,6 @@ function interpretPslDocumentToSqlContract(input) {
 	});
 }
 //#endregion
-export { normalizeReferentialAction as a, interpretPslDocumentToSqlContract as i, buildEntityTypesByDiscriminator as n, numberLiteralDefault as o, indexFkRelations as r, resolveFieldTypeDescriptor as s, applyBackrelationCandidates as t };
+export { interpretPslDocumentToSqlContract as a, resolveFieldTypeDescriptor as c, indexFkRelations as i, buildEntityTypesByDiscriminator as n, normalizeReferentialAction as o, entryForTag as r, readDataTypeDefault as s, applyBackrelationCandidates as t };
 
-//# sourceMappingURL=interpreter-Bf7Um__3-DC_thY44.mjs.map
+//# sourceMappingURL=interpreter-DvKii7Bl-D8Ipte3f.mjs.map