@prisma/orm-family-sql 8.0.0-rc.11-dev.42 → 8.0.0-rc.11-dev.44

package/dist/{interpreter-Bf7Um__3-DC_thY44.mjs → interpreter-BIBwrA2w-DAiNN30m.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-BH0U6i1B-Ces5ZCvv.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-BIBwrA2w.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,
@@ -828,17 +1109,19 @@ function lowerDefaultForField(input) {
 	const node = findFieldAttributeNode(input.field, "default");
 	if (node === void 0) return {};
 	const source = diagnosticSource(input.sources, node.syntax);
+	const spec = sqlAttributeSpecs.field.default(fieldSpecContext({
+		symbols: input.symbolTable,
+		model: input.model,
+		field: input.field,
+		controlMutationDefaults: {
+			defaultFunctionRegistry: input.defaultFunctionRegistry,
+			dataTypeEntries: input.dataTypeSupport.entries
+		}
+	}));
 	const interpreted = interpretFieldAttribute({
+		symbols: input.symbolTable,
 		node,
-		spec: sqlAttributeSpecs.field.default(fieldSpecContext({
-			symbols: input.symbolTable,
-			model: input.model,
-			field: input.field,
-			controlMutationDefaults: {
-				defaultFunctionRegistry: input.defaultFunctionRegistry,
-				defaultLiteralTagRegistry: input.defaultLiteralTagRegistry
-			}
-		})),
+		spec,
 		model: input.model,
 		field: input.field,
 		sources: input.sources,
@@ -846,65 +1129,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,9 +1282,10 @@ function lowerEnumDefaultForField(input) {
 			field,
 			controlMutationDefaults: {
 				defaultFunctionRegistry: input.defaultFunctionRegistry,
-				defaultLiteralTagRegistry: input.defaultLiteralTagRegistry
+				dataTypeEntries: input.dataTypeSupport.entries
 			}
 		})),
+		symbols: input.symbolTable,
 		model,
 		field,
 		sources: input.sources,
@@ -996,6 +1355,7 @@ function extractFieldConstraintNames(input) {
 	const idNode = findFieldAttributeNode(input.field, "id");
 	const idName = idNode === void 0 ? void 0 : interpretFieldAttribute({
 		node: idNode,
+		symbols: input.symbolTable,
 		spec: sqlAttributeSpecs.field.id(),
 		model: input.model,
 		field: input.field,
@@ -1009,6 +1369,7 @@ function extractFieldConstraintNames(input) {
 		idName,
 		uniqueName: uniqueNode === void 0 ? void 0 : interpretFieldAttribute({
 			node: uniqueNode,
+			symbols: input.symbolTable,
 			spec: sqlAttributeSpecs.field.unique(),
 			model: input.model,
 			field: input.field,
@@ -1030,6 +1391,7 @@ function lowerNoCheckForField(input) {
 	const interpreted = interpretFieldAttribute({
 		node,
 		spec: sqlAttributeSpecs.field.noCheck(),
+		symbols: input.symbolTable,
 		model: input.model,
 		field: input.field,
 		sources: input.sources,
@@ -1065,7 +1427,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 +1541,7 @@ function collectResolvedFields(input) {
 			sources: input.sources,
 			enumHandle,
 			defaultFunctionRegistry,
-			defaultLiteralTagRegistry,
+			dataTypeSupport,
 			diagnostics
 		}) : lowerDefaultForField({
 			modelName: model.name,
@@ -1191,7 +1553,7 @@ function collectResolvedFields(input) {
 			columnDescriptor: descriptor,
 			generatorDescriptorById,
 			defaultFunctionRegistry,
-			defaultLiteralTagRegistry,
+			dataTypeSupport,
 			codecLookup,
 			diagnostics
 		}) : {};
@@ -1224,6 +1586,7 @@ function collectResolvedFields(input) {
 		}
 		const mappedColumnName = mapping.fieldColumns.get(field.name) ?? field.name;
 		const { idAttribute, uniqueAttribute, idName, uniqueName } = extractFieldConstraintNames({
+			symbolTable: input.symbolTable,
 			model,
 			field,
 			sources: input.sources,
@@ -1257,6 +1620,7 @@ function collectResolvedFields(input) {
 		const fieldExecutionDefaults = presetContributions?.executionDefaults ?? loweredDefault.executionDefaults;
 		const fieldDefaultValue = presetContributions?.default ?? loweredDefault.defaultValue;
 		const noCheckKinds = modelDerivesChecks ? lowerNoCheckForField({
+			symbolTable: input.symbolTable,
 			model,
 			field,
 			sources: input.sources,
@@ -1283,12 +1647,13 @@ function collectResolvedFields(input) {
 	}
 	return resolvedFields;
 }
-function buildModelMappings(modelEntries, defaultNamespaceId, diagnostics, sources) {
+function buildModelMappings(symbols, modelEntries, defaultNamespaceId, diagnostics, sources) {
 	const result = /* @__PURE__ */ new Map();
 	for (const { model, namespaceId } of modelEntries) {
 		const mapNode = findModelAttributeNode(model, "map");
 		const tableName = mapNode === void 0 ? defaultTableName(model.name) : interpretModelAttribute({
 			node: mapNode,
+			symbols,
 			spec: sqlAttributeSpecs.model.map(),
 			model,
 			sources,
@@ -1299,6 +1664,7 @@ function buildModelMappings(modelEntries, defaultNamespaceId, diagnostics, sourc
 			const fieldMapNode = findFieldAttributeNode(field, "map");
 			const columnName = fieldMapNode === void 0 ? field.name : interpretFieldAttribute({
 				node: fieldMapNode,
+				symbols,
 				spec: sqlAttributeSpecs.field.map(),
 				model,
 				field,
@@ -1474,6 +1840,7 @@ function interpretRelationAttribute(input) {
 	const node = findFieldAttributeNode(input.field, "relation");
 	if (node === void 0) return void 0;
 	return interpretFieldAttribute({
+		symbols: input.symbols,
 		node,
 		spec: sqlAttributeSpecs.field.relation(),
 		model: input.selfModel,
@@ -2150,7 +2517,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,
@@ -2286,6 +2653,7 @@ function buildModelNodeFromPsl(input) {
 				node,
 				spec: sqlAttributeSpecs.model.control(),
 				model,
+				symbols: input.symbolTable,
 				sources: input.sources,
 				diagnostics
 			});
@@ -2317,6 +2685,7 @@ function buildModelNodeFromPsl(input) {
 				node,
 				spec: sqlAttributeSpecs.model.id(),
 				model,
+				symbols: input.symbolTable,
 				sources: input.sources,
 				diagnostics
 			});
@@ -2355,6 +2724,7 @@ function buildModelNodeFromPsl(input) {
 				node,
 				spec: sqlAttributeSpecs.model.unique(),
 				model,
+				symbols: input.symbolTable,
 				sources: input.sources,
 				diagnostics
 			});
@@ -2382,6 +2752,7 @@ function buildModelNodeFromPsl(input) {
 				node,
 				spec: sqlAttributeSpecs.model.index(),
 				model,
+				symbols: input.symbolTable,
 				sources: input.sources,
 				diagnostics
 			});
@@ -2427,6 +2798,7 @@ function buildModelNodeFromPsl(input) {
 				node,
 				spec: sqlAttributeSpecs.model.check(),
 				model,
+				symbols: input.symbolTable,
 				sources: input.sources,
 				diagnostics
 			});
@@ -2459,10 +2831,11 @@ function buildModelNodeFromPsl(input) {
 					model,
 					controlMutationDefaults: {
 						defaultFunctionRegistry: input.defaultFunctionRegistry,
-						defaultLiteralTagRegistry: input.defaultLiteralTagRegistry
+						dataTypeEntries: input.dataTypeSupport.entries
 					}
 				}),
 				model,
+				symbols: input.symbolTable,
 				sources: input.sources,
 				diagnostics
 			});
@@ -2852,15 +3225,16 @@ function patchModelDomainFields(models, modelResolvedFields) {
 	}
 	return patched;
 }
-function collectPolymorphismDeclarations(models, sources, diagnostics) {
+function collectPolymorphismDeclarations(identities, symbols, sources, diagnostics) {
 	const discriminatorDeclarations = /* @__PURE__ */ new Map();
 	const baseDeclarations = /* @__PURE__ */ new Map();
-	for (const model of models) {
+	for (const { model, key } of identities.values()) {
 		const source = diagnosticSource(sources, model.node.syntax);
 		const discriminatorNode = findModelAttributeNode(model, "discriminator");
 		if (discriminatorNode !== void 0) {
 			const parsed = interpretModelAttribute({
 				node: discriminatorNode,
+				symbols,
 				spec: sqlAttributeSpecs.model.discriminator(),
 				model,
 				sources,
@@ -2874,7 +3248,7 @@ function collectPolymorphismDeclarations(models, sources, diagnostics) {
 					message: `Discriminator field "${parsed.field}" on model "${model.name}" must be of type String, but is "${discField.typeName}"`,
 					...source.at(span)
 				});
-				else discriminatorDeclarations.set(model.name, {
+				else discriminatorDeclarations.set(key, {
 					fieldName: parsed.field,
 					span,
 					source
@@ -2885,17 +3259,22 @@ function collectPolymorphismDeclarations(models, sources, diagnostics) {
 		if (baseNode !== void 0) {
 			const parsed = interpretModelAttribute({
 				node: baseNode,
+				symbols,
 				spec: sqlAttributeSpecs.model.base(),
 				model,
 				sources,
 				diagnostics
 			});
-			if (parsed !== void 0) baseDeclarations.set(model.name, {
-				source,
-				baseName: parsed.base,
-				value: parsed.value,
-				span: nodePslSpan(baseNode.syntax, sources)
-			});
+			if (parsed !== void 0) {
+				const base = identities.get(parsed.base.declaration);
+				invariant(base !== void 0, `Resolved base model "${parsed.base.declaration.name}" is missing from the collected model identities`);
+				baseDeclarations.set(key, {
+					source,
+					base,
+					value: parsed.value,
+					span: nodePslSpan(baseNode.syntax, sources)
+				});
+			}
 		}
 	}
 	return {
@@ -2903,11 +3282,9 @@ function collectPolymorphismDeclarations(models, sources, diagnostics) {
 		baseDeclarations
 	};
 }
-function resolvePolymorphism(models, discriminatorDeclarations, baseDeclarations, modelNames, modelMappings, modelNamespaceIds, defaultNamespaceId, syntheticPkFieldsByVariant, stiBaseFieldsByBase, diagnostics) {
+function resolvePolymorphism(models, discriminatorDeclarations, baseDeclarations, modelMappings, syntheticPkFieldsByVariant, stiBaseFieldsByBase, diagnostics) {
 	let patched = models;
-	const coordinateFor = (modelName) => modelCoordinateKey(modelNamespaceIds.get(modelName) ?? defaultNamespaceId, modelName);
-	for (const [baseName, fieldNames] of stiBaseFieldsByBase) {
-		const baseKey = coordinateFor(baseName);
+	for (const [baseKey, fieldNames] of stiBaseFieldsByBase) {
 		const baseModel = patched[baseKey];
 		if (!baseModel || fieldNames.length === 0) continue;
 		patched = {
@@ -2915,8 +3292,9 @@ function resolvePolymorphism(models, discriminatorDeclarations, baseDeclarations
 			[baseKey]: stripStorageOnlyDomainFields(baseModel, fieldNames)
 		};
 	}
-	for (const [modelName, decl] of discriminatorDeclarations) {
-		if (baseDeclarations.has(modelName)) {
+	for (const [modelKey, decl] of discriminatorDeclarations) {
+		const modelName = modelMappings.get(modelKey)?.model.name;
+		if (baseDeclarations.has(modelKey)) {
 			diagnostics.push({
 				code: "PSL_DISCRIMINATOR_AND_BASE",
 				message: `Model "${modelName}" cannot have both @@discriminator and @@base`,
@@ -2924,12 +3302,14 @@ function resolvePolymorphism(models, discriminatorDeclarations, baseDeclarations
 			});
 			continue;
 		}
-		const model = patched[coordinateFor(modelName)];
+		const model = patched[modelKey];
 		if (!model) continue;
 		const variants = {};
 		const seenValues = /* @__PURE__ */ new Map();
-		for (const [variantName, baseDecl] of baseDeclarations) {
-			if (baseDecl.baseName !== modelName) continue;
+		for (const [variantKey, baseDecl] of baseDeclarations) {
+			if (baseDecl.base.key !== modelKey) continue;
+			const variantName = modelMappings.get(variantKey)?.model.name;
+			invariant(variantName !== void 0, `Variant "${variantKey}" is missing from the model mappings`);
 			const existingVariant = seenValues.get(baseDecl.value);
 			if (existingVariant) {
 				diagnostics.push({
@@ -2952,39 +3332,33 @@ function resolvePolymorphism(models, discriminatorDeclarations, baseDeclarations
 		}
 		patched = {
 			...patched,
-			[coordinateFor(modelName)]: {
+			[modelKey]: {
 				...model,
 				discriminator: { field: decl.fieldName },
 				variants
 			}
 		};
 	}
-	for (const [variantName, baseDecl] of baseDeclarations) {
-		if (!modelNames.has(baseDecl.baseName)) {
-			diagnostics.push({
-				code: "PSL_BASE_TARGET_NOT_FOUND",
-				message: `Model "${variantName}" @@base references non-existent model "${baseDecl.baseName}"`,
-				...baseDecl.source.at(baseDecl.span)
-			});
-			continue;
-		}
-		if (!discriminatorDeclarations.has(baseDecl.baseName)) {
+	for (const [variantKey, baseDecl] of baseDeclarations) {
+		const variantMapping = modelMappings.get(variantKey);
+		const variantName = variantMapping?.model.name;
+		const baseName = baseDecl.base.model.name;
+		if (!discriminatorDeclarations.has(baseDecl.base.key)) {
 			diagnostics.push({
 				code: "PSL_ORPHANED_BASE",
-				message: `Model "${variantName}" declares @@base(${baseDecl.baseName}, ...) but "${baseDecl.baseName}" has no @@discriminator`,
+				message: `Model "${variantName}" declares @@base(${baseName}, ...) but "${baseName}" has no @@discriminator`,
 				...baseDecl.source.at(baseDecl.span)
 			});
 			continue;
 		}
-		if (discriminatorDeclarations.has(variantName)) continue;
-		const variantModel = patched[coordinateFor(variantName)];
+		if (discriminatorDeclarations.has(variantKey)) continue;
+		const variantModel = patched[variantKey];
 		if (!variantModel) continue;
-		const baseMapping = modelMappings.get(baseDecl.baseName);
-		const variantMapping = modelMappings.get(variantName);
+		const baseMapping = modelMappings.get(baseDecl.base.key);
 		const resolvedTable = variantMapping?.model.attributes.some((attr) => attr.name === "map") ?? false ? variantMapping?.tableName : baseMapping?.tableName;
 		const patchedVariant = {
 			...variantModel,
-			base: crossRef(baseDecl.baseName, modelNamespaceIds.get(baseDecl.baseName) ?? defaultNamespaceId),
+			base: crossRef(baseName, baseDecl.base.namespaceId),
 			...resolvedTable ? { storage: {
 				...variantModel.storage,
 				table: resolvedTable
@@ -2992,7 +3366,7 @@ function resolvePolymorphism(models, discriminatorDeclarations, baseDeclarations
 		};
 		patched = {
 			...patched,
-			[coordinateFor(variantName)]: stripStorageOnlyDomainFields(patchedVariant, syntheticPkFieldsByVariant.get(variantName) ?? [])
+			[variantKey]: stripStorageOnlyDomainFields(patchedVariant, syntheticPkFieldsByVariant.get(variantKey) ?? [])
 		};
 	}
 	return patched;
@@ -3011,16 +3385,18 @@ function resolvePolymorphism(models, discriminatorDeclarations, baseDeclarations
 * storage table stays joinable. Single-table-inheritance variants (no own
 * table) are left untouched.
 */
-function materializeMtiVariantStorageLinks(modelNodes, baseDeclarations, stiVariantNames) {
-	const nodeByModel = new Map(modelNodes.map((node) => [node.modelName, node]));
+function materializeMtiVariantStorageLinks(modelNodes, baseDeclarations, stiVariantKeys, defaultNamespaceId) {
+	const keyOf = (node) => modelCoordinateKey(node.namespaceId ?? defaultNamespaceId, node.modelName);
+	const nodeByModel = new Map(modelNodes.map((node) => [keyOf(node), node]));
 	const syntheticPkFieldsByVariant = /* @__PURE__ */ new Map();
 	return {
 		modelNodes: modelNodes.map((node) => {
-			const baseDecl = baseDeclarations.get(node.modelName);
+			const variantKey = keyOf(node);
+			const baseDecl = baseDeclarations.get(variantKey);
 			if (!baseDecl) return node;
-			const baseNode = nodeByModel.get(baseDecl.baseName);
+			const baseNode = nodeByModel.get(baseDecl.base.key);
 			if (!baseNode) return node;
-			if (stiVariantNames.has(node.modelName)) return node;
+			if (stiVariantKeys.has(variantKey)) return node;
 			const basePrimaryKey = baseNode.id;
 			if (!basePrimaryKey || basePrimaryKey.columns.length === 0) return node;
 			const existingColumns = new Set(node.fields.map((field) => field.columnName));
@@ -3037,7 +3413,7 @@ function materializeMtiVariantStorageLinks(modelNodes, baseDeclarations, stiVari
 				});
 			}
 			if (linkFields.length === 0) return node;
-			syntheticPkFieldsByVariant.set(node.modelName, linkFields.map((field) => field.fieldName));
+			syntheticPkFieldsByVariant.set(variantKey, linkFields.map((field) => field.fieldName));
 			const foreignKey = {
 				columns: basePrimaryKey.columns,
 				references: {
@@ -3079,21 +3455,22 @@ function materializeMtiVariantStorageLinks(modelNodes, baseDeclarations, stiVari
 * MTI link guard; surfacing them as diagnostics is tracked separately
 * (TML-2827).
 */
-function materializeStiVariantStorageColumns(modelNodes, baseDeclarations, stiVariantNames) {
-	if (stiVariantNames.size === 0) return {
+function materializeStiVariantStorageColumns(modelNodes, baseDeclarations, stiVariantKeys, defaultNamespaceId) {
+	if (stiVariantKeys.size === 0) return {
 		modelNodes: [...modelNodes],
 		stiBaseFieldsByBase: /* @__PURE__ */ new Map()
 	};
-	const nodeByModel = new Map(modelNodes.map((node) => [node.modelName, node]));
+	const keyOf = (node) => modelCoordinateKey(node.namespaceId ?? defaultNamespaceId, node.modelName);
+	const nodeByModel = new Map(modelNodes.map((node) => [keyOf(node), node]));
 	const stiColumnsByBase = /* @__PURE__ */ new Map();
-	for (const variantName of stiVariantNames) {
-		const variantNode = nodeByModel.get(variantName);
-		const baseDecl = baseDeclarations.get(variantName);
+	for (const variantKey of stiVariantKeys) {
+		const variantNode = nodeByModel.get(variantKey);
+		const baseDecl = baseDeclarations.get(variantKey);
 		if (!variantNode || !baseDecl) continue;
-		const baseNode = nodeByModel.get(baseDecl.baseName);
+		const baseNode = nodeByModel.get(baseDecl.base.key);
 		if (!baseNode) continue;
 		const baseColumns = new Set(baseNode.fields.map((field) => field.columnName));
-		const claimed = stiColumnsByBase.get(baseDecl.baseName) ?? [];
+		const claimed = stiColumnsByBase.get(baseDecl.base.key) ?? [];
 		const claimedColumns = new Set(claimed.map((field) => field.columnName));
 		for (const field of variantNode.fields) {
 			if (baseColumns.has(field.columnName) || claimedColumns.has(field.columnName)) continue;
@@ -3103,17 +3480,17 @@ function materializeStiVariantStorageColumns(modelNodes, baseDeclarations, stiVa
 				nullable: true
 			});
 		}
-		stiColumnsByBase.set(baseDecl.baseName, claimed);
+		stiColumnsByBase.set(baseDecl.base.key, claimed);
 	}
 	const stiBaseFieldsByBase = /* @__PURE__ */ new Map();
 	for (const [baseName, columns] of stiColumnsByBase) stiBaseFieldsByBase.set(baseName, columns.map((field) => field.fieldName));
 	return {
 		modelNodes: modelNodes.map((node) => {
-			if (stiVariantNames.has(node.modelName)) return {
+			if (stiVariantKeys.has(keyOf(node))) return {
 				...node,
 				sharesBaseTable: true
 			};
-			const stiColumns = stiColumnsByBase.get(node.modelName);
+			const stiColumns = stiColumnsByBase.get(keyOf(node));
 			if (!stiColumns || stiColumns.length === 0) return node;
 			return {
 				...node,
@@ -3211,7 +3588,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);
@@ -3278,7 +3658,7 @@ function interpretPslDocumentToSqlContract(input) {
 		} },
 		warnings: authoringWarnings
 	};
-	const earlyModelMappingsByCoordinate = buildModelMappings(modelEntries, defaultNamespaceId, createPslDiagnosticCollector(input.sources), input.sources);
+	const earlyModelMappingsByCoordinate = buildModelMappings(input.symbolTable, modelEntries, defaultNamespaceId, createPslDiagnosticCollector(input.sources), input.sources);
 	const composedPslBlockDescriptors = input.authoringContributions?.pslBlockDescriptors ?? {};
 	const namespaceExtensionEntities = /* @__PURE__ */ new Map();
 	const mergeNamespaceExtensionEntities = (nsId, entities, blocks) => {
@@ -3351,7 +3731,7 @@ function interpretPslDocumentToSqlContract(input) {
 		diagnostics
 	});
 	const storageTypes = { ...namedTypeResult.storageTypes };
-	const modelMappingsByCoordinate = buildModelMappings(modelEntries, defaultNamespaceId, diagnostics, input.sources);
+	const modelMappingsByCoordinate = buildModelMappings(input.symbolTable, modelEntries, defaultNamespaceId, diagnostics, input.sources);
 	const modelMappings = /* @__PURE__ */ new Map();
 	for (const mapping of modelMappingsByCoordinate.values()) modelMappings.set(mapping.model.name, mapping);
 	const modelNodes = [];
@@ -3380,7 +3760,7 @@ function interpretPslDocumentToSqlContract(input) {
 			targetId: input.target.targetId,
 			authoringContributions: input.authoringContributions,
 			defaultFunctionRegistry,
-			defaultLiteralTagRegistry,
+			dataTypeSupport,
 			generatorDescriptorById,
 			scalarColumnDescriptors: input.scalarColumnDescriptors,
 			sources: input.sources,
@@ -3442,25 +3822,33 @@ function interpretPslDocumentToSqlContract(input) {
 		if (existing) existing.push(...relations);
 		else modelRelations.set(modelName, [...relations]);
 	}
-	const { discriminatorDeclarations, baseDeclarations } = collectPolymorphismDeclarations(models, input.sources, diagnostics);
-	const stiVariantNames = /* @__PURE__ */ new Set();
-	for (const variantName of baseDeclarations.keys()) if (!(modelMappings.get(variantName)?.model.attributes.some((attr) => attr.name === "map") ?? false)) stiVariantNames.add(variantName);
-	for (const variantName of stiVariantNames) {
-		const variantMapping = modelMappings.get(variantName);
+	const { discriminatorDeclarations, baseDeclarations } = collectPolymorphismDeclarations(new Map(modelEntries.map(({ model, namespaceId }) => {
+		const resolvedNamespaceId = namespaceId ?? defaultNamespaceId;
+		return [model, {
+			model,
+			namespaceId: resolvedNamespaceId,
+			key: modelCoordinateKey(resolvedNamespaceId, model.name)
+		}];
+	})), input.symbolTable, input.sources, diagnostics);
+	const stiVariantKeys = /* @__PURE__ */ new Set();
+	for (const variantKey of baseDeclarations.keys()) if (!(modelMappingsByCoordinate.get(variantKey)?.model.attributes.some((attr) => attr.name === "map") ?? false)) stiVariantKeys.add(variantKey);
+	for (const variantKey of stiVariantKeys) {
+		const variantMapping = modelMappingsByCoordinate.get(variantKey);
 		if (variantMapping === void 0) continue;
-		const baseDecl = baseDeclarations.get(variantName);
-		invariant(baseDecl !== void 0, `stiVariantNames is derived from baseDeclarations.keys(), so "${variantName}" must have a base declaration`);
+		const variantName = variantMapping.model.name;
+		const baseDecl = baseDeclarations.get(variantKey);
+		invariant(baseDecl !== void 0, `stiVariantKeys is derived from baseDeclarations.keys(), so "${variantName}" must have a base declaration`);
 		for (const attribute of variantMapping.model.node.attributes()) {
 			if (attribute.name()?.isSimpleName("check") !== true) continue;
 			diagnostics.push({
 				code: PSL_CHECK_ON_STI_VARIANT,
-				message: `Model "${variantName}" declares "@@check", but it shares its base model "${baseDecl.baseName}"'s storage table (single-table inheritance via @@base) and has no table of its own to declare a check constraint on. Declare the check on "${baseDecl.baseName}" instead.`,
+				message: `Model "${variantName}" declares "@@check", but it shares its base model "${baseDecl.base.model.name}"'s storage table (single-table inheritance via @@base) and has no table of its own to declare a check constraint on. Declare the check on "${baseDecl.base.model.name}" instead.`,
 				...diagnosticSource(input.sources, attribute.syntax).at(nodePslSpan(attribute.syntax, input.sources))
 			});
 		}
 	}
-	const { modelNodes: mtiLinkedModelNodes, syntheticPkFieldsByVariant } = materializeMtiVariantStorageLinks(modelNodes, baseDeclarations, stiVariantNames);
-	const { modelNodes: stiColumnModelNodes, stiBaseFieldsByBase } = materializeStiVariantStorageColumns(mtiLinkedModelNodes, baseDeclarations, stiVariantNames);
+	const { modelNodes: mtiLinkedModelNodes, syntheticPkFieldsByVariant } = materializeMtiVariantStorageLinks(modelNodes, baseDeclarations, stiVariantKeys, defaultNamespaceId);
+	const { modelNodes: stiColumnModelNodes, stiBaseFieldsByBase } = materializeStiVariantStorageColumns(mtiLinkedModelNodes, baseDeclarations, stiVariantKeys, defaultNamespaceId);
 	const valueObjects = buildValueObjects({
 		compositeTypes,
 		enumTypeDescriptors: allEnumTypeDescriptors,
@@ -3524,13 +3912,12 @@ function interpretPslDocumentToSqlContract(input) {
 	}
 	let patchedModels = patchModelDomainFields(modelsForPatch, modelResolvedFields);
 	const polyDiagnostics = createPslDiagnosticCollector(input.sources);
-	patchedModels = resolvePolymorphism(patchedModels, discriminatorDeclarations, baseDeclarations, modelNames, modelMappings, modelNamespaceIds, input.target.defaultNamespaceId, syntheticPkFieldsByVariant, stiBaseFieldsByBase, polyDiagnostics);
+	patchedModels = resolvePolymorphism(patchedModels, discriminatorDeclarations, baseDeclarations, modelMappingsByCoordinate, syntheticPkFieldsByVariant, stiBaseFieldsByBase, polyDiagnostics);
 	if (polyDiagnostics.length > 0) return notOk({
 		summary: "PSL to SQL contract interpretation failed",
 		diagnostics: polyDiagnostics.toExternal()
 	});
-	const variantModelNames = new Set(baseDeclarations.keys());
-	const filteredRoots = Object.fromEntries(Object.entries(contract.roots).filter(([, crossReference]) => !variantModelNames.has(crossReference.model)));
+	const filteredRoots = Object.fromEntries(Object.entries(contract.roots).filter(([, crossReference]) => !baseDeclarations.has(modelCoordinateKey(crossReference.namespace, crossReference.model))));
 	return ok({
 		...contract,
 		roots: filteredRoots,
@@ -3543,6 +3930,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-BIBwrA2w-DAiNN30m.mjs.map