@prisma/orm-family-sql 8.0.0-rc.14-dev.16 → 8.0.0-rc.14-dev.18

package/dist/{interpreter-CkCfPqup-DF7bZvNM.mjs → interpreter-C8cP92FD-Co9RsuUU.mjs}

@@ -1,1426 +1,28 @@
 import { n as isAuthoredIndexInput } from "./index-naming-Cj1Anq-T-C9TevpPR.mjs";
 import { n as providesPslEntityPlacement } from "./entity-handle-lowering-hook-B3atrRKX.mjs";
-import { s as sqlTextFromCanonical, t as SQL_EXPRESSION_DATA_TYPE_ID } from "./sql-expression-BXx0Ilj-.mjs";
 import { d as resolvedTypeParams } from "./types-jFnALKoT.mjs";
-import { n as checkSqlDefaultBody, o as reservedSqlDefaultBody } from "./validators-DvzOZLel.mjs";
 import { t as deriveValueSetFromEntity } from "./value-set-derivation-hook-Di9JZ0X7.mjs";
-import { a as storedAsListColumn, i as isValueObjectMember, n as buildSqlContractFromDefinition } from "./derived-checks-C_y1rk6O-DdqjzGNy.mjs";
-import { a as getAttribute, c as interpretModelAttribute, d as modelAttributeSpecsFrom, f as sqlAttributeSpecs, i as formatDbAttributeMigrationMessage, l as lowerDefaultFunctionWithRegistry, n as createSqlBinder, o as getNamedArgument, p as storageName, r as fieldSpecContext, s as interpretFieldAttribute, t as PSL_CHECK_ON_STI_VARIANT, u as mapFieldNamesToColumns } from "./sql-attribute-specs-DxpHr9Fk-CeWmMP7y.mjs";
+import { n as buildSqlContractFromDefinition } from "./derived-checks-C_y1rk6O-DdqjzGNy.mjs";
+import { S as toNamedTypeFieldDescriptor, _ as modelCoordinateKey, b as sqlAttributeSpecs, c as getAttribute, f as instantiatePslTypeConstructor, g as modelAttributeSpecsFrom, h as mapFieldNamesToColumns, i as contractError, l as getAuthoringEntity, m as interpretModelAttribute, n as bareTypeConstructorOf, p as interpretFieldAttribute, r as collectResolvedFields, s as formatDbAttributeMigrationMessage, t as PSL_CHECK_ON_STI_VARIANT, u as getNamedArgument, x as storageName, y as resolveFieldTypeDescriptor } from "./psl-field-resolution-_o74AUE4-CKYNRnzL.mjs";
 import { t as defaultTableName } from "./default-table-name-BfFY8qYR-lHNcVmY5.mjs";
-import { structuredError } from "@prisma/orm-framework/utils/structured-error";
-import { checkUncomposedNamespace, getAuthoringFieldPreset, getAuthoringTypeConstructor, hasRegisteredFieldNamespace, instantiateAuthoringEntityType, instantiateAuthoringTypeConstructor, isAuthoringEntityTypeDescriptor, isAuthoringModelAttributeDescriptor, validateAuthoringHelperArguments } from "@prisma/orm-framework/components/authoring";
+import { instantiateAuthoringEntityType, instantiateAuthoringTypeConstructor, isAuthoringEntityTypeDescriptor, isAuthoringModelAttributeDescriptor } from "@prisma/orm-framework/components/authoring";
 import { UNBOUND_NAMESPACE_ID } from "@prisma/orm-framework/components/ir";
-import { InternalError, isInternalError } from "@prisma/orm-framework/utils/internal-error";
+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 { codecForRef } from "@prisma/orm-framework/components/codec";
 import { blindCast } from "@prisma/orm-framework/utils/casts";
-import { ArrayLiteralAst, IdentifierAst, NamespaceDeclarationAst } from "@prisma/orm-framework/psl-parser/syntax";
+import { NamespaceDeclarationAst } from "@prisma/orm-framework/psl-parser/syntax";
 import { resolveToOneRelationNullable } from "@prisma/orm-framework/contract-authoring";
 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, interpretExtensionBlocks, nodePslSpan, typeReferenceNode } from "@prisma/orm-framework/psl-parser";
+import { contributedTypeOf, createPslDiagnosticCollector, diagnosticSource, findBlockDescriptor, interpretExtensionBlocks, nodePslSpan, typeReferenceNode } from "@prisma/orm-framework/psl-parser";
+import { claimedBlockKeywords, enumMemberAttributeDiagnostics, fkRelationPairKey, requiredOneToOneBackrelationDiagnostic, unsupportedBlockDiagnostic } from "@prisma/orm-framework/psl-parser/interpret";
 import { UNBOUND_PSL_NAMESPACE_NAME, UNSPECIFIED_PSL_NAMESPACE_ID } from "@prisma/orm-framework/components/psl-ast";
-import { claimedBlockKeywords, enumMemberAttributeDiagnostics, fkRelationPairKey, instantiatePslFieldPreset, mapPslHelperArgs, reportUncomposedNamespace, reportUnknownFieldPreset, requiredOneToOneBackrelationDiagnostic, uncomposedNamespaceDiagnostic, unsupportedBlockDiagnostic } from "@prisma/orm-framework/psl-parser/interpret";
-//#region ../../../2-sql/2-authoring/contract-psl/dist/interpreter-CkCfPqup.mjs
-function contractError(code, message, options) {
-	return structuredError(code, message, options);
-}
-/** A written value the column's codec refuses. */
-const PSL_INVALID_DEFAULT_LITERAL = "PSL_INVALID_DEFAULT_LITERAL";
-/** A written value whose data type the receiving type neither is nor casts from. */
-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) => ({
-		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(found.key),
-				value: form.parse(text)
-			}
-		};
-	} catch (error) {
-		if (isInternalError(error)) throw error;
-		return refuse({
-			kind: "unreadable",
-			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) {
-		if (isInternalError(error)) throw error;
-		return {
-			ok: false,
-			refusal: {
-				kind: "unreadable",
-				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);
-}
-/**
-* The column's codec descriptor, and `read`, which reads a value in its stored JSON form with the column's codec, built with the column's type parameters.
-*/
-function storedValueReader(input) {
-	if (input.codecLookup === void 0) throw new InternalError(`Field "${input.fieldPath}": no codec lookup was given, but the column was resolved from a codec descriptor.`);
-	const descriptor = input.codecLookup.descriptorFor(input.column.codecId);
-	const codec = codecForRef(input.codecLookup, {
-		codecId: input.column.codecId,
-		...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 read = (value, elementIndex) => {
-		try {
-			codec.decodeJson(value);
-			return {
-				ok: true,
-				value
-			};
-		} catch (error) {
-			if (isInternalError(error)) throw error;
-			return {
-				ok: false,
-				refusal: {
-					kind: "refused-by-codec",
-					codecId: input.column.codecId,
-					message: messageOf(error),
-					elementIndex
-				}
-			};
-		}
-	};
-	return {
-		descriptor,
-		read
-	};
-}
-/**
-* 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.
-*/
-function readStoredValue(input) {
-	const reading = storedValueReader(input).read(input.value, void 0);
-	return reading.ok ? reading : refusalDiagnostic(reading.refusal, input.fieldPath);
-}
-/**
-* 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 { descriptor, read: readStored } = storedValueReader(input);
-	const columnType = descriptor.dataType;
-	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 readStored(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",
-					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,
-		readStored
-	});
-}
-/** 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",
-				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.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
-			}
-		};
-	}
-}
-/** 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);
-	return read.ok ? read : refusalDiagnostic(read.refusal, input.fieldPath);
-}
-/** A refusal worded as a PSL diagnostic's code and message. */
-function refusalDiagnostic(refusal, fieldPath) {
-	const where = `Field "${fieldPath}"${at(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]`
-		};
-		case "no-cast": return {
-			ok: false,
-			code: PSL_VALUE_TYPE_INCOMPATIBLE,
-			message: `${where}: ${refusal.columnType} has no cast from ${refusal.valueType}; ${describeCasts(refusal.casts)}`
-		};
-		case "refused-by-codec": 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(", ")}`;
-}
-/** Each way the default does not match the composite type. */
-function valueObjectDefaultMismatches(input) {
-	const mismatches = [];
-	const shape = (path, message) => mismatches.push({
-		code: PSL_VALUE_TYPE_INCOMPATIBLE,
-		message: `Field "${path}": ${message}`
-	});
-	const checkObject = (value, valueObjectName, path) => {
-		const valueObject = input.types.nodes.get(valueObjectName);
-		const declared = input.types.declaredMembers.get(valueObjectName);
-		if (valueObject === void 0 || declared === void 0) throw new InternalError(`Field "${path}" is typed by the value object "${valueObjectName}", which the contract does not declare.`);
-		if (!isJsonObject(value)) {
-			shape(path, `a value of "${valueObjectName}" is a JSON object, not ${jsonKind(value)}`);
-			return;
-		}
-		for (const key of Object.keys(value)) if (!declared.has(key)) shape(path, `"${key}" is not a member of "${valueObjectName}"`);
-		for (const member of valueObject.fields) checkMember(value[member.fieldName], member, `${path}.${member.fieldName}`);
-	};
-	const checkMember = (value, member, path) => {
-		if (value === void 0) {
-			if (!member.nullable) shape(path, "the member is required, and the default has no value for it");
-			return;
-		}
-		if (value === null && member.nullable) return;
-		if (member.many === true) {
-			if (!Array.isArray(value)) {
-				shape(path, `the member is a list, so its value is a JSON array, not ${jsonKind(value)}`);
-				return;
-			}
-			for (const [index, element] of value.entries()) {
-				if (element === null && member.elementNullable) continue;
-				checkOne(element, member, `${path}[${index}]`, "an element of the member is not null");
-			}
-			return;
-		}
-		checkOne(value, member, path, "the member is not optional, so its value is not null");
-	};
-	const checkOne = (value, member, path, notNull) => {
-		if (isValueObjectMember(member)) {
-			if (value === null) shape(path, notNull);
-			else checkObject(value, member.valueObjectName, path);
-			return;
-		}
-		const reading = readStoredValue({
-			value,
-			column: member.descriptor,
-			codecLookup: input.codecLookup,
-			fieldPath: path
-		});
-		if (!reading.ok) {
-			if (value === null) shape(path, notNull);
-			else mismatches.push({
-				code: reading.code,
-				message: reading.message
-			});
-			return;
-		}
-		const enumMismatch = enumValueMismatch(value, member, path, input.codecLookup);
-		if (enumMismatch !== void 0) mismatches.push(enumMismatch);
-	};
-	if (input.value === null) {
-		if (input.nullable) return mismatches;
-		shape(input.fieldPath, input.list ? "the default of a list of value objects is a JSON array, not null" : "the default of a value object is a JSON object, not null");
-		return mismatches;
-	}
-	if (input.list) {
-		if (!Array.isArray(input.value)) {
-			shape(input.fieldPath, `the default of a list of value objects is a JSON array, not ${jsonKind(input.value)}`);
-			return mismatches;
-		}
-		for (const [index, element] of input.value.entries()) {
-			if (element === null && input.elementNullable) continue;
-			checkObject(element, input.valueObjectName, `${input.fieldPath}[${index}]`);
-		}
-		return mismatches;
-	}
-	if (!isJsonObject(input.value)) {
-		shape(input.fieldPath, `the default of a value object is a JSON object, not ${jsonKind(input.value)}`);
-		return mismatches;
-	}
-	checkObject(input.value, input.valueObjectName, input.fieldPath);
-	return mismatches;
-}
-/**
-* A member typed by an enum takes only the enum's values, in the form its codec stores them, as a model field of that enum takes only its members.
-*/
-function enumValueMismatch(value, member, path, codecLookup) {
-	const handle = member.enumTypeHandle;
-	if (handle === void 0) return void 0;
-	const codec = codecLookup?.get(handle.codecId);
-	const stored = handle.values.map((enumValue) => codec === void 0 ? enumValue : codec.encodeJson(enumValue));
-	if (stored.some((storedValue) => storedValue === value)) return void 0;
-	return {
-		code: PSL_INVALID_DEFAULT_LITERAL,
-		message: `Field "${path}": Expected one of: ${stored.map((storedValue) => JSON.stringify(storedValue)).join(" | ")}`
-	};
-}
-function isJsonObject(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function jsonKind(value) {
-	if (value === null) return "null";
-	if (Array.isArray(value)) return "a JSON array";
-	if (typeof value === "object") return "a JSON object";
-	return `a JSON ${typeof value}`;
-}
-function toNamedTypeFieldDescriptor(typeRef, descriptor) {
-	return {
-		codecId: descriptor.codecId,
-		nativeType: descriptor.nativeType,
-		typeRef
-	};
-}
-/**
-* Walks `authoringContributions.entityTypes` segment-by-segment and returns
-* the entity type descriptor at the resolved path, or `undefined` if no
-* descriptor is registered.
-*
-* Used by the PSL interpreter to dispatch declarative entity-shaped
-* declarations (`enum`, future `namespace { … }`, …) through the
-* pack entity-type mechanism — the descriptor's `factory` (or
-* `template`) materialises the IR-class instance without the
-* interpreter knowing target-specific construction.
-*/
-function getAuthoringEntity(contributions, path) {
-	let current = contributions?.entityTypes;
-	for (const segment of path) {
-		if (typeof current !== "object" || current === null || "kind" in current) return;
-		current = current[segment];
-	}
-	return current !== void 0 && isAuthoringEntityTypeDescriptor(current) ? current : void 0;
-}
-function replacesUnresolvedTypeVoice(typeName, composedExtensions, context) {
-	if (checkUncomposedNamespace(typeName, composedExtensions, context) !== void 0) return true;
-	const dotIndex = typeName.indexOf(".");
-	if (dotIndex <= 0 || dotIndex === typeName.length - 1) return false;
-	return hasRegisteredFieldNamespace(context.authoringContributions, typeName.slice(0, dotIndex));
-}
-function instantiatePslTypeConstructor(input) {
-	const helperPath = input.call.path.join(".");
-	const args = mapPslHelperArgs({
-		args: input.call.args,
-		descriptors: input.descriptor.args ?? [],
-		helperLabel: `constructor "${helperPath}"`,
-		span: input.call.span,
-		diagnostics: input.diagnostics,
-		source: input.source,
-		entityLabel: input.entityLabel
-	});
-	if (!args) return;
-	try {
-		validateAuthoringHelperArguments(helperPath, input.descriptor.args, args);
-		return instantiateAuthoringTypeConstructor(input.descriptor, args);
-	} catch (error) {
-		if (isInternalError(error)) throw error;
-		const message = error instanceof Error ? error.message : String(error);
-		input.diagnostics.push({
-			code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
-			message: `${input.entityLabel} constructor "${helperPath}" ${message}`,
-			...input.source.at(input.call.span)
-		});
-		return;
-	}
-}
-function pushUnsupportedTypeConstructorDiagnostic(input) {
-	input.diagnostics.push({
-		code: input.code,
-		message: input.message,
-		...input.source.at(input.span)
-	});
-}
-function resolvePslTypeConstructorDescriptor(input) {
-	const descriptor = getAuthoringTypeConstructor(input.authoringContributions, input.call.path);
-	if (descriptor) return descriptor;
-	const uncomposedNamespace = checkUncomposedNamespace(input.call.path.join("."), input.composedExtensions, {
-		familyId: input.familyId,
-		targetId: input.targetId,
-		authoringContributions: input.authoringContributions
-	});
-	if (uncomposedNamespace) {
-		reportUncomposedNamespace({
-			subjectLabel: `Type constructor "${input.call.path.join(".")}"`,
-			namespace: uncomposedNamespace,
-			source: input.source,
-			span: input.call.span,
-			diagnostics: input.diagnostics
-		});
-		return;
-	}
-	return pushUnsupportedTypeConstructorDiagnostic({
-		diagnostics: input.diagnostics,
-		source: input.source,
-		span: input.call.span,
-		code: input.unsupportedCode,
-		message: input.unsupportedMessage
-	});
-}
-/**
-* Structural check for a codec descriptor exposing the authoring-time
-* `columnFromEntity` hook a type constructor's `entityRefArg` resolves
-* through (e.g. the `pg/enum@1` codec descriptor). No casts.
-*/
-function hasColumnFromEntityHook(descriptor) {
-	return "columnFromEntity" in descriptor && typeof descriptor.columnFromEntity === "function";
-}
-/**
-* Resolves a type-constructor call whose descriptor declares an
-* `entityRefArg` (e.g. `pg.enum(AalLevel)`): extracts the call's sole
-* positional-argument ref string, resolves it against the field's
-* namespace's already-lowered extension entities (keyed by the declared
-* `entityRefArg.entityKind`, then block name), and converts the resolved
-* entity to column params via the `columnFromEntity` authoring hook on the
-* codec descriptor registered for `descriptor.output.codecId`. The `nativeType`
-* / `typeParams.typeName` `columnFromEntity` returns are bare — schema
-* qualification (e.g. `auth.aal_level`) is a target concern, applied later
-* when the target builds the field's namespace. A `valueSet` ref is
-* attached when the same namespace derived a value-set under the same block
-* name (the generic `deriveValueSet` mechanism), scoped to the field's own
-* namespace.
-*/
-function resolveEntityRefTypeConstructorCall(input) {
-	const entityRefArg = input.descriptor.entityRefArg;
-	if (entityRefArg === void 0) throw new InternalError("resolveEntityRefTypeConstructorCall called with a descriptor that does not declare an entityRefArg. This is an interpreter bug.");
-	const helperPath = input.call.path.join(".");
-	const positionalArgs = input.call.args.filter((arg) => arg.kind === "positional");
-	const ref = positionalArgs[entityRefArg.index]?.value;
-	if (input.call.args.length !== 1 || positionalArgs.length !== 1 || ref === void 0) {
-		input.diagnostics.push({
-			code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
-			message: `${input.entityLabel} type constructor "${helperPath}" expects exactly one positional argument naming the referenced entity`,
-			...input.source.at(input.call.span)
-		});
-		return {
-			ok: false,
-			alreadyReported: true
-		};
-	}
-	const reportUnknownRef = () => {
-		input.diagnostics.push({
-			code: "PSL_UNKNOWN_ENTITY_REF",
-			message: `${input.entityLabel} type constructor "${helperPath}(${ref})" does not resolve — no entity named "${ref}" was found in namespace "${input.namespaceId ?? "(unspecified)"}"`,
-			...input.source.at(input.call.span)
-		});
-		return {
-			ok: false,
-			alreadyReported: true
-		};
-	};
-	const entity = input.namespaceExtensionEntities?.[entityRefArg.entityKind]?.[ref];
-	if (entity === void 0) return reportUnknownRef();
-	const codecId = input.descriptor.output.codecId;
-	const codecDescriptor = input.codecLookup?.descriptorFor(codecId);
-	if (codecDescriptor === void 0 || !hasColumnFromEntityHook(codecDescriptor)) throw contractError("CONTRACT.PACK_CONTRIBUTION_INVALID", `Type constructor "${helperPath}" registers codecId "${codecId}" with an entity-ref argument, but its codec descriptor has no "columnFromEntity" authoring hook. This is a contributor bug in the pack registering "${helperPath}", not a user-schema error.`, { meta: {
-		helperPath,
-		codecId
-	} });
-	const resolved = codecDescriptor.columnFromEntity(entity);
-	if (resolved === void 0) return reportUnknownRef();
-	const derivedValueSet = input.namespaceExtensionEntities?.["valueSet"]?.[ref];
-	if (derivedValueSet !== void 0 && input.namespaceId === void 0) {
-		input.diagnostics.push({
-			code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
-			message: `${input.entityLabel} type constructor "${helperPath}(${ref})" resolves to a value-set-typed entity, but the field has no resolvable namespace to scope the value-set ref to`,
-			...input.source.at(input.call.span)
-		});
-		return {
-			ok: false,
-			alreadyReported: true
-		};
-	}
-	const valueSet = derivedValueSet !== void 0 && input.namespaceId !== void 0 ? {
-		plane: "storage",
-		entityKind: "valueSet",
-		namespaceId: input.namespaceId,
-		entityName: ref
-	} : void 0;
-	return {
-		ok: true,
-		descriptor: {
-			codecId,
-			nativeType: resolved.nativeType,
-			...resolved.typeParams !== void 0 ? { typeParams: resolved.typeParams } : {},
-			...valueSet !== void 0 ? { valueSet } : {}
-		}
-	};
-}
-function resolveFieldTypeDescriptor(input) {
-	const source = diagnosticSource(input.sources, input.field.node.syntax);
-	if (input.field.malformedType) return {
-		ok: false,
-		alreadyReported: true
-	};
-	if (input.field.typeConstructor) {
-		const presetDescriptor = getAuthoringFieldPreset(input.authoringContributions, input.field.typeConstructor.path);
-		if (presetDescriptor) {
-			const instantiated = instantiatePslFieldPreset({
-				call: input.field.typeConstructor,
-				descriptor: presetDescriptor,
-				diagnostics: input.diagnostics,
-				source,
-				entityLabel: input.entityLabel
-			});
-			if (!instantiated) return {
-				ok: false,
-				alreadyReported: true
-			};
-			const presetContributions = {
-				nullable: instantiated.nullable,
-				id: instantiated.id,
-				unique: instantiated.unique,
-				...instantiated.default !== void 0 ? { default: instantiated.default } : {},
-				...instantiated.executionDefaults !== void 0 ? { executionDefaults: instantiated.executionDefaults } : {}
-			};
-			return {
-				ok: true,
-				descriptor: instantiated.descriptor,
-				presetContributions
-			};
-		}
-		const helperPath = input.field.typeConstructor.path.join(".");
-		const namespacePrefix = input.field.typeConstructor.path.length > 1 ? input.field.typeConstructor.path[0] : void 0;
-		const typeDescriptor = getAuthoringTypeConstructor(input.authoringContributions, input.field.typeConstructor.path);
-		if (typeDescriptor?.entityRefArg) return resolveEntityRefTypeConstructorCall({
-			call: input.field.typeConstructor,
-			descriptor: typeDescriptor,
-			namespaceId: input.namespaceId,
-			namespaceExtensionEntities: input.namespaceExtensionEntities,
-			codecLookup: input.codecLookup,
-			diagnostics: input.diagnostics,
-			source,
-			entityLabel: input.entityLabel
-		});
-		if (!typeDescriptor && namespacePrefix && hasRegisteredFieldNamespace(input.authoringContributions, namespacePrefix)) {
-			reportUnknownFieldPreset({
-				entityLabel: input.entityLabel,
-				namespace: namespacePrefix,
-				helperPath,
-				authoringContributions: input.authoringContributions,
-				source,
-				span: input.field.typeConstructor.span,
-				diagnostics: input.diagnostics
-			});
-			return {
-				ok: false,
-				alreadyReported: true
-			};
-		}
-		const descriptor = typeDescriptor ?? resolvePslTypeConstructorDescriptor({
-			call: input.field.typeConstructor,
-			authoringContributions: input.authoringContributions,
-			composedExtensions: input.composedExtensions,
-			familyId: input.familyId,
-			targetId: input.targetId,
-			diagnostics: input.diagnostics,
-			source,
-			unsupportedCode: "PSL_UNSUPPORTED_FIELD_TYPE",
-			unsupportedMessage: `${input.entityLabel} type constructor "${helperPath}" is not supported in SQL PSL provider v1`
-		});
-		if (!descriptor) return {
-			ok: false,
-			alreadyReported: true
-		};
-		const instantiated = instantiatePslTypeConstructor({
-			call: input.field.typeConstructor,
-			descriptor,
-			diagnostics: input.diagnostics,
-			source,
-			entityLabel: input.entityLabel
-		});
-		if (!instantiated) return {
-			ok: false,
-			alreadyReported: true
-		};
-		return {
-			ok: true,
-			descriptor: instantiated
-		};
-	}
-	const descriptor = resolveColumnDescriptor(input.field, input.enumTypeDescriptors, input.namedTypeDescriptors, input.scalarColumnDescriptors);
-	if (!descriptor) return {
-		ok: false,
-		alreadyReported: false
-	};
-	return {
-		ok: true,
-		descriptor
-	};
-}
-const PSL_INVALID_DEFAULT_SQL = "PSL_INVALID_DEFAULT_SQL";
-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 rejectStrictListNullDefault(input) {
-	if (input.field.elementOptional) return false;
-	for (const arg of input.node.argList()?.args() ?? []) {
-		const expression = arg.value();
-		const list = expression ? ArrayLiteralAst.cast(expression.syntax) : void 0;
-		for (const element of list?.elements() ?? []) {
-			const identifier = IdentifierAst.cast(element.syntax);
-			if (identifier?.token()?.text !== "null") continue;
-			input.diagnostics.push({
-				code: "PSL_INVALID_DEFAULT_APPLICABILITY",
-				message: `Field "${input.modelName}.${input.field.name}" has strict list elements and cannot use null in a literal list default. Make the element type nullable or remove null from the default.`,
-				...diagnosticSource(input.sources, identifier.syntax).at()
-			});
-			return true;
-		}
-	}
-	return false;
-}
-function lowerDefaultForField(input) {
-	const node = getAttribute(input.field.attributes, "default")?.node;
-	if (node === void 0) return {};
-	const source = diagnosticSource(input.sources, node.syntax);
-	const spec = sqlAttributeSpecs.field.default(fieldSpecContext({
-		symbols: input.symbolTable,
-		model: input.model,
-		field: input.field,
-		controlMutationDefaults: {
-			defaultFunctionRegistry: input.defaultFunctionRegistry,
-			dataTypeEntries: input.dataTypeSupport.entries
-		}
-	}));
-	const interpreted = interpretFieldAttribute({
-		symbols: input.symbolTable,
-		node,
-		spec,
-		model: input.model,
-		field: input.field,
-		sources: input.sources,
-		binder: input.binder,
-		diagnostics: input.diagnostics
-	});
-	if (interpreted === void 0) return {};
-	const value = interpreted.value;
-	if (Array.isArray(value) && value.includes(null) && rejectStrictListNullDefault({
-		...input,
-		node
-	})) return {};
-	if (value === null) {
-		if (!input.field.optional) {
-			input.diagnostics.push({
-				code: "PSL_INVALID_DEFAULT_APPLICABILITY",
-				message: `Field "${input.modelName}.${input.fieldName}" is non-nullable and cannot use null as its literal default. Make the field nullable or use a non-null default.`,
-				...source.at()
-			});
-			return {};
-		}
-		return { defaultValue: {
-			kind: "literal",
-			value: null,
-			canonical: true
-		} };
-	}
-	const readsListElements = (written) => input.isListColumn || input.field.list && written.kind === "list";
-	const readAsLiteral = (written) => {
-		const lowered = lowerDataTypeDefault({
-			written,
-			isList: readsListElements(written),
-			column: input.columnDescriptor,
-			codecLookup: input.codecLookup,
-			support: input.dataTypeSupport,
-			fieldPath: `${input.modelName}.${input.fieldName}`
-		});
-		if (!lowered.ok) {
-			input.diagnostics.push({
-				code: lowered.code,
-				message: lowered.message,
-				...source.at()
-			});
-			return {};
-		}
-		let restoredValue = lowered.value;
-		if (Array.isArray(value) && value.includes(null) && Array.isArray(lowered.value)) {
-			let index = 0;
-			const nonNullValues = lowered.value;
-			restoredValue = value.map((element) => element === null ? null : nonNullValues[index++] ?? null);
-		}
-		if (input.valueObjectDefault !== void 0) {
-			const mismatches = valueObjectDefaultMismatches({
-				fieldPath: `${input.modelName}.${input.fieldName}`,
-				value: restoredValue,
-				list: input.field.list,
-				nullable: input.field.optional,
-				elementNullable: input.field.elementOptional,
-				...input.valueObjectDefault,
-				codecLookup: input.codecLookup
-			});
-			for (const { code, message } of mismatches) input.diagnostics.push({
-				code,
-				message,
-				...source.at()
-			});
-			if (mismatches.length > 0) return {};
-		}
-		return { defaultValue: {
-			kind: "literal",
-			value: restoredValue,
-			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 literal = readTaggedLiteral(element, input.dataTypeSupport, source);
-		if (!literal.ok) {
-			input.diagnostics.push(literal.diagnostic);
-			return { ok: false };
-		}
-		return literal.written;
-	};
-	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.`;
-		if (refusal !== void 0) {
-			input.diagnostics.push({
-				code: PSL_INVALID_DEFAULT_SQL,
-				message: refusal,
-				...source.at(span)
-			});
-			return {};
-		}
-		return { defaultValue: {
-			kind: "function",
-			expression: text
-		} };
-	};
-	if (input.columnDescriptor.valueSet !== void 0) {
-		if (typeof value === "string") return { defaultValue: {
-			kind: "literal",
-			value
-		} };
-		if (Array.isArray(value)) {
-			const members = value.filter((element) => element === null || typeof element === "string");
-			if (members.length === value.length) return { defaultValue: {
-				kind: "literal",
-				value: members
-			} };
-		}
-	}
-	if (Array.isArray(value)) {
-		const elements = [];
-		for (const element of value) {
-			if (element === null) continue;
-			const written = writtenElement(element);
-			if ("ok" in written) return {};
-			elements.push(written);
-		}
-		return readAsLiteral({
-			kind: "list",
-			elements
-		});
-	}
-	if (typeof value === "string") return readAsLiteral({
-		kind: "string",
-		text: value
-	});
-	if (typeof value === "boolean") return readAsLiteral({
-		kind: "boolean",
-		value
-	});
-	if ("text" in value) return readAsLiteral({
-		kind: "number",
-		text: value.text
-	});
-	if ("tag" in value) {
-		const 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);
-	}
-	if (typeof value === "object") {
-		const context = {
-			sourceId: input.sources.sourceFileFor(node.syntax).filename,
-			modelName: input.modelName,
-			fieldName: input.fieldName,
-			columnCodecId: input.columnDescriptor.codecId
-		};
-		const lowered = lowerDefaultFunctionWithRegistry({
-			call: value,
-			registry: input.defaultFunctionRegistry,
-			context,
-			source
-		});
-		if (!lowered.ok) {
-			if (lowered.kind === "owned") input.diagnostics.push(lowered.diagnostic);
-			else input.diagnostics.pushExternal(lowered.diagnostic);
-			return {};
-		}
-		if (lowered.value.kind === "storage") return { defaultValue: lowered.value.defaultValue };
-		const generatorDescriptor = input.generatorDescriptorById.get(lowered.value.generated.id);
-		if (!generatorDescriptor) {
-			input.diagnostics.push({
-				code: "PSL_INVALID_DEFAULT_APPLICABILITY",
-				message: `Default generator "${lowered.value.generated.id}" is not available in the composed mutation default registry.`,
-				...source.at(value.span)
-			});
-			return {};
-		}
-		if (generatorDescriptor.applicableCodecIds === void 0) {
-			input.diagnostics.push({
-				code: "PSL_INVALID_DEFAULT_APPLICABILITY",
-				message: `Default generator "${generatorDescriptor.id}" is not applicable to "@default(...)" lowering. Use the corresponding field preset (e.g. \`temporal.${generatorDescriptor.id === "timestampNow" ? "updatedAt" : generatorDescriptor.id}()\`) instead.`,
-				...source.at(value.span)
-			});
-			return {};
-		}
-		if (!generatorDescriptor.applicableCodecIds.includes(input.columnDescriptor.codecId)) {
-			input.diagnostics.push({
-				code: "PSL_INVALID_DEFAULT_APPLICABILITY",
-				message: `Default generator "${generatorDescriptor.id}" is not applicable to "${input.modelName}.${input.fieldName}" with codecId "${input.columnDescriptor.codecId}".`,
-				...source.at(value.span)
-			});
-			return {};
-		}
-		return { executionDefaults: { onCreate: lowered.value.generated } };
-	}
-	return {};
-}
-function resolveColumnDescriptor(field, enumTypeDescriptors, namedTypeDescriptors, scalarColumnDescriptors) {
-	if (namedTypeDescriptors.has(field.typeName)) return namedTypeDescriptors.get(field.typeName);
-	if (enumTypeDescriptors.has(field.typeName)) return enumTypeDescriptors.get(field.typeName);
-	return scalarColumnDescriptors.get(field.typeName);
-}
-function lowerEnumDefaultForField(input) {
-	const { field, model, enumHandle, diagnostics } = input;
-	const node = getAttribute(field.attributes, "default")?.node;
-	if (node === void 0) return {};
-	if (enumHandle.enumMembers.length === 0) return {};
-	const interpreted = interpretFieldAttribute({
-		node,
-		spec: sqlAttributeSpecs.field.default(fieldSpecContext({
-			symbols: input.symbolTable,
-			model,
-			field,
-			controlMutationDefaults: {
-				defaultFunctionRegistry: input.defaultFunctionRegistry,
-				dataTypeEntries: input.dataTypeSupport.entries
-			}
-		})),
-		symbols: input.symbolTable,
-		model,
-		field,
-		sources: input.sources,
-		binder: input.binder,
-		diagnostics
-	});
-	if (interpreted === void 0) return {};
-	const member = interpreted.value;
-	if (Array.isArray(member)) {
-		if (member.includes(null) && rejectStrictListNullDefault({
-			...input,
-			node
-		})) return {};
-		return { defaultValue: {
-			kind: "literal",
-			value: blindCast(member.map((entry) => entry === null ? null : enumHandle.enumMembers.find((candidate) => candidate.name === entry)?.value))
-		} };
-	}
-	invariant(typeof member === "string", "the enum @default grammar admits only member identifiers, so the parsed value is a string");
-	const match = enumHandle.enumMembers.find((m) => m.name === member);
-	if (!match) return {};
-	return { defaultValue: {
-		kind: "literal",
-		value: blindCast(match.value)
-	} };
-}
-const MODEL_COORDINATE_SEPARATOR = "\0";
-function modelCoordinateKey(namespaceId, modelName) {
-	return `${namespaceId}${MODEL_COORDINATE_SEPARATOR}${modelName}`;
-}
-const REMOVED_ATTRIBUTE_RULES = /* @__PURE__ */ new Map([["updatedAt", {
-	hint: "Use `temporal.updatedAt()` as a field-preset call instead.",
-	suppressWhen: (field) => field.typeConstructor?.path[0] === "temporal"
-}]]);
-{
-	const overlap = [...REMOVED_ATTRIBUTE_RULES.keys()].filter((name) => Object.hasOwn(sqlAttributeSpecs.field, name));
-	if (overlap.length > 0) throw new InternalError(`Registered SQL field attributes and REMOVED_ATTRIBUTE_RULES must not overlap. Names in both: ${overlap.join(", ")}`);
-}
-function describeUnsupportedSqlAttribute(input) {
-	const namespaceContext = {
-		...ifDefined("familyId", input.familyId),
-		...ifDefined("targetId", input.targetId),
-		authoringContributions: input.authoringContributions
-	};
-	return ({ attribute, level, owner, field }) => {
-		if (owner.kind === "compositeType") return void 0;
-		if (level === "model") {
-			const source = diagnosticSource(input.sources, owner.node.syntax);
-			const uncomposedNamespace = checkUncomposedNamespace(attribute.name, input.composedExtensions, namespaceContext);
-			if (uncomposedNamespace) return uncomposedNamespaceDiagnostic({
-				subjectLabel: `Attribute "@@${attribute.name}"`,
-				namespace: uncomposedNamespace,
-				source,
-				span: attribute.span
-			});
-			return {
-				code: "PSL_UNSUPPORTED_MODEL_ATTRIBUTE",
-				message: `Model "${owner.name}" uses unsupported attribute "@@${attribute.name}"`,
-				...source.at(attribute.span)
-			};
-		}
-		if (field === void 0) return void 0;
-		const source = diagnosticSource(input.sources, field.node.syntax);
-		if (attribute.name.startsWith("db.")) return {
-			code: "PSL_UNSUPPORTED_FIELD_ATTRIBUTE",
-			message: formatDbAttributeMigrationMessage(attribute),
-			...source.at(attribute.span)
-		};
-		const uncomposedNamespace = checkUncomposedNamespace(attribute.name, input.composedExtensions, namespaceContext);
-		if (uncomposedNamespace) return uncomposedNamespaceDiagnostic({
-			subjectLabel: `Attribute "@${attribute.name}"`,
-			namespace: uncomposedNamespace,
-			source,
-			span: attribute.span
-		});
-		const baseMessage = `Field "${owner.name}.${field.name}" uses unsupported attribute "@${attribute.name}"`;
-		const removedRule = REMOVED_ATTRIBUTE_RULES.get(attribute.name);
-		return {
-			code: "PSL_UNSUPPORTED_FIELD_ATTRIBUTE",
-			message: removedRule && !removedRule.suppressWhen(field) ? `${baseMessage}. ${removedRule.hint}` : baseMessage,
-			...source.at(attribute.span)
-		};
-	};
-}
-function extractFieldConstraintNames(input) {
-	const idAttribute = getAttribute(input.field.attributes, "id");
-	const uniqueAttribute = getAttribute(input.field.attributes, "unique");
-	const idNode = getAttribute(input.field.attributes, "id")?.node;
-	const idName = idNode === void 0 ? void 0 : interpretFieldAttribute({
-		node: idNode,
-		symbols: input.symbolTable,
-		spec: sqlAttributeSpecs.field.id(),
-		model: input.model,
-		field: input.field,
-		sources: input.sources,
-		binder: input.binder,
-		diagnostics: input.diagnostics
-	})?.map;
-	const uniqueNode = getAttribute(input.field.attributes, "unique")?.node;
-	return {
-		idAttribute,
-		uniqueAttribute,
-		idName,
-		uniqueName: uniqueNode === void 0 ? void 0 : interpretFieldAttribute({
-			node: uniqueNode,
-			symbols: input.symbolTable,
-			spec: sqlAttributeSpecs.field.unique(),
-			model: input.model,
-			field: input.field,
-			sources: input.sources,
-			binder: input.binder,
-			diagnostics: input.diagnostics
-		})?.map
-	};
-}
-/**
-* Interprets a field's `@noCheck` attribute and resolves it against the
-* column's shape: the bare form becomes every kind the shape derives, and a
-* named kind that can never apply is a spec-validation diagnostic on the
-* attribute node. Returns the concrete kinds in canonical ascending order —
-* the only form the definition tree carries.
-*/
-function lowerNoCheckForField(input) {
-	const node = getAttribute(input.field.attributes, "noCheck")?.node;
-	if (node === void 0) return void 0;
-	const interpreted = interpretFieldAttribute({
-		node,
-		spec: sqlAttributeSpecs.field.noCheck(),
-		symbols: input.symbolTable,
-		model: input.model,
-		field: input.field,
-		sources: input.sources,
-		binder: input.binder,
-		diagnostics: input.diagnostics
-	});
-	if (interpreted === void 0) return void 0;
-	const span = getAttribute(input.field.attributes, "noCheck")?.span ?? input.field.span;
-	const subject = `Field "${input.model.name}.${input.field.name}"`;
-	const derivable = [];
-	if (input.isListColumn && !input.elementNullable) derivable.push("elementNotNull");
-	if (input.isDomainEnum) derivable.push("membership");
-	const authored = [interpreted.first, interpreted.second].filter((kind) => kind === "membership" || kind === "elementNotNull");
-	if (authored.length === 0) {
-		if (derivable.length === 0) {
-			input.diagnostics.push({
-				code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
-				message: `${subject} @noCheck waives nothing — this column's shape derives no generated checks`,
-				...diagnosticSource(input.sources, input.field.node.syntax).at(span)
-			});
-			return;
-		}
-		return derivable;
-	}
-	for (const kind of authored) if (!derivable.includes(kind)) {
-		const explanation = kind === "membership" ? "membership checks are derived only from enum value sets" : "element-non-null checks are derived only for lists whose elements are semantically non-null";
-		input.diagnostics.push({
-			code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
-			message: `${subject} @noCheck(${kind}) does not apply — ${explanation}`,
-			...diagnosticSource(input.sources, input.field.node.syntax).at(span)
-		});
-		return;
-	}
-	return [...authored].sort();
-}
-function collectResolvedFields(input) {
-	const { model, symbolTable, enumTypeDescriptors, namedTypeDescriptors, valueObjectTypes, composedExtensions, authoringContributions, binder, 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();
-	const modelDerivesChecks = declaredControlPolicy === void 0 || declaredControlPolicy === "managed";
-	for (const field of Object.values(model.fields)) {
-		const source = diagnosticSource(sources, field.node.syntax);
-		const fieldTypeReference = typeReferenceNode(field);
-		const fieldTypeResolution = fieldTypeReference === void 0 ? void 0 : binder.symbolForNode(fieldTypeReference);
-		const isModelField = fieldTypeResolution?.kind === "model";
-		if (field.list && isModelField) continue;
-		const relationAttribute = getAttribute(field.attributes, "relation");
-		if (isModelField && relationAttribute) continue;
-		if (field.typeContractSpaceId !== void 0 && relationAttribute) continue;
-		if (isModelField) continue;
-		const valueObjectName = fieldTypeResolution?.kind === "compositeType" ? fieldTypeResolution.symbol.name : void 0;
-		const isValueObjectField = valueObjectName !== void 0;
-		const isListField = field.list;
-		const isListColumn = storedAsListColumn({
-			list: isListField,
-			typedByValueObject: isValueObjectField
-		});
-		let descriptor;
-		let presetContributions;
-		const resolveInput = {
-			field,
-			binder,
-			enumTypeDescriptors,
-			namedTypeDescriptors,
-			scalarColumnDescriptors,
-			authoringContributions,
-			composedExtensions,
-			familyId,
-			targetId,
-			diagnostics,
-			sources,
-			entityLabel: `Field "${model.name}.${field.name}"`,
-			...ifDefined("namespaceId", namespaceId),
-			...ifDefined("namespaceExtensionEntities", namespaceExtensionEntities),
-			...ifDefined("codecLookup", codecLookup)
-		};
-		if (isValueObjectField) {
-			if (valueObjectStorageTypeName === void 0) {
-				diagnostics.push({
-					code: "PSL_UNSUPPORTED_FIELD_TYPE",
-					message: `Field "${model.name}.${field.name}" is typed by the composite type "${field.typeName}", but the adapter of the stack declares no storage type for value objects, so the field has no column to be stored in.`,
-					...source.at(field.span)
-				});
-				continue;
-			}
-			descriptor = scalarColumnDescriptors.get(valueObjectStorageTypeName);
-			if (descriptor === void 0) throw new InternalError(`The stack declares "${valueObjectStorageTypeName}" as its value-object storage type, but it is not one of the stack's scalar types; the control stack checks this when it is assembled.`);
-		} else if (isListField) {
-			if (capabilities["sql"]?.["scalarList"] !== true) {
-				diagnostics.push({
-					code: "PSL_SCALAR_LIST_UNSUPPORTED_TARGET",
-					message: `Field "${model.name}.${field.name}" is a scalar list, but target "${targetId}" does not support scalar lists (the adapter does not report the "scalarList" capability). Remove the list or author it against a target that supports scalar lists.`,
-					...source.at(field.span)
-				});
-				continue;
-			}
-			const resolved = resolveFieldTypeDescriptor(resolveInput);
-			if (!resolved.ok) {
-				if (!resolved.alreadyReported && fieldTypeResolution?.kind !== "unresolved") diagnostics.push({
-					code: "PSL_UNSUPPORTED_FIELD_TYPE",
-					message: `Field "${model.name}.${field.name}" type "${field.typeName}" is not supported in SQL PSL provider v1`,
-					...source.at(field.span)
-				});
-				continue;
-			}
-			if (resolved.presetContributions) {
-				diagnostics.push({
-					code: "PSL_PRESET_NOT_LIST",
-					message: `Field "${model.name}.${field.name}" uses a field-preset call as a list element type. Presets cannot be list elements; remove "[]" or use a scalar type.`,
-					...source.at(field.span)
-				});
-				continue;
-			}
-			descriptor = resolved.descriptor;
-		} else {
-			const resolved = resolveFieldTypeDescriptor(resolveInput);
-			if (!resolved.ok) {
-				if (!resolved.alreadyReported && fieldTypeResolution?.kind !== "unresolved") diagnostics.push({
-					code: "PSL_UNSUPPORTED_FIELD_TYPE",
-					message: `Field "${model.name}.${field.name}" type "${field.typeName}" is not supported in SQL PSL provider v1`,
-					...source.at(field.span)
-				});
-				continue;
-			}
-			descriptor = resolved.descriptor;
-			presetContributions = resolved.presetContributions;
-		}
-		if (!descriptor) continue;
-		if (presetContributions && field.optional) {
-			diagnostics.push({
-				code: "PSL_PRESET_NOT_OPTIONAL",
-				message: `Field "${model.name}.${field.name}" uses a field-preset call and cannot be optional. Remove "?" or use a different field type.`,
-				...source.at(field.span)
-			});
-			continue;
-		}
-		const defaultAttribute = getAttribute(field.attributes, "default");
-		if (presetContributions && defaultAttribute) {
-			diagnostics.push({
-				code: "PSL_PRESET_AND_DEFAULT_CONFLICT",
-				message: `Field "${model.name}.${field.name}" uses a field-preset call and cannot also declare @default(...). The preset already specifies the default value.`,
-				...source.at(defaultAttribute.span)
-			});
-			continue;
-		}
-		const enumHandle = enumHandles?.get(field.typeName);
-		const loweredDefault = defaultAttribute ? enumHandle ? lowerEnumDefaultForField({
-			modelName: model.name,
-			fieldName: field.name,
-			field,
-			model,
-			symbolTable,
-			sources: input.sources,
-			binder: input.binder,
-			enumHandle,
-			defaultFunctionRegistry,
-			dataTypeSupport,
-			diagnostics
-		}) : lowerDefaultForField({
-			modelName: model.name,
-			fieldName: field.name,
-			field,
-			model,
-			symbolTable,
-			sources: input.sources,
-			binder: input.binder,
-			columnDescriptor: descriptor,
-			isListColumn,
-			valueObjectDefault: valueObjectName === void 0 ? void 0 : {
-				valueObjectName,
-				types: valueObjectTypes
-			},
-			generatorDescriptorById,
-			defaultFunctionRegistry,
-			dataTypeSupport,
-			codecLookup,
-			diagnostics
-		}) : {};
-		const loweredOnCreate = loweredDefault.executionDefaults?.onCreate;
-		if (isListField && loweredDefault.defaultValue?.kind === "function" && loweredDefault.defaultValue.expression === "autoincrement()") {
-			diagnostics.push({
-				code: "PSL_LIST_AUTOINCREMENT_UNSUPPORTED",
-				message: `Field "${model.name}.${field.name}" is a list and cannot use autoincrement(); it is a Prisma marker for a sequence-backed scalar column, not SQL.`,
-				...source.at(defaultAttribute?.span ?? field.span)
-			});
-			continue;
-		}
-		if (isListField && loweredOnCreate) {
-			const defaultExpression = defaultAttribute?.args.find((arg) => arg.kind === "positional")?.value.trim() ?? "this function";
-			diagnostics.push({
-				code: "PSL_LIST_EXECUTION_DEFAULT_UNSUPPORTED",
-				message: `Field "${model.name}.${field.name}" is a list and cannot use an execution default ("${defaultExpression}"). Lists have no per-element execution-default semantics; use a literal list @default or remove the default.`,
-				...source.at(defaultAttribute?.span ?? field.span)
-			});
-			continue;
-		}
-		if (field.optional && loweredOnCreate) {
-			const generatorDescription = loweredOnCreate.kind === "generator" ? `"${loweredOnCreate.id}"` : "for this field";
-			diagnostics.push({
-				code: "PSL_INVALID_DEFAULT_FUNCTION_ARGUMENT",
-				message: `Field "${model.name}.${field.name}" cannot be optional when using execution default ${generatorDescription}. Remove "?" or use a storage default.`,
-				...source.at(defaultAttribute?.span ?? field.span)
-			});
-			continue;
-		}
-		const mappedColumnName = storageName(field, input.physicalNames);
-		const { idAttribute, uniqueAttribute, idName, uniqueName } = extractFieldConstraintNames({
-			symbolTable: input.symbolTable,
-			model,
-			field,
-			sources: input.sources,
-			binder: input.binder,
-			diagnostics
-		});
-		let isIdField = Boolean(idAttribute);
-		if (idAttribute && isListField) {
-			diagnostics.push({
-				code: "PSL_LIST_ID_UNSUPPORTED",
-				message: `Field "${model.name}.${field.name}" is a list and cannot be a primary key. Remove @id; a list cannot be an identity column.`,
-				...source.at(idAttribute.span)
-			});
-			continue;
-		}
-		if (idAttribute && field.optional) {
-			diagnostics.push({
-				code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
-				message: `Field "${model.name}.${field.name}" @id cannot be optional; primary key columns must be NOT NULL`,
-				...source.at(idAttribute.span)
-			});
-			isIdField = false;
-		}
-		if (presetContributions && idAttribute && !presetContributions.id) {
-			diagnostics.push({
-				code: "PSL_PRESET_AND_ID_CONFLICT",
-				message: `Field "${model.name}.${field.name}" uses a field-preset call and cannot also declare @id. Use a preset that contributes id semantics, or drop @id.`,
-				...source.at(idAttribute.span)
-			});
-			continue;
-		}
-		const fieldExecutionDefaults = presetContributions?.executionDefaults ?? loweredDefault.executionDefaults;
-		const fieldDefaultValue = presetContributions?.default ?? loweredDefault.defaultValue;
-		const noCheckKinds = modelDerivesChecks ? lowerNoCheckForField({
-			symbolTable: input.symbolTable,
-			model,
-			field,
-			sources: input.sources,
-			binder: input.binder,
-			isListColumn,
-			elementNullable: field.elementOptional,
-			isDomainEnum: enumHandle !== void 0,
-			diagnostics
-		}) : void 0;
-		resolvedFields.push({
-			field,
-			columnName: mappedColumnName,
-			descriptor,
-			nullable: presetContributions?.nullable ?? field.optional,
-			...ifDefined("defaultValue", fieldDefaultValue),
-			...ifDefined("executionDefaults", fieldExecutionDefaults),
-			isId: isIdField || Boolean(presetContributions?.id),
-			isUnique: Boolean(uniqueAttribute) || Boolean(presetContributions?.unique),
-			...ifDefined("idName", idName),
-			...ifDefined("uniqueName", uniqueName),
-			...ifDefined("many", isListField ? true : void 0),
-			...ifDefined("noCheck", noCheckKinds),
-			...ifDefined("elementNullable", field.elementOptional ? true : void 0),
-			...ifDefined("valueObjectTypeName", valueObjectName)
-		});
-	}
-	return resolvedFields;
+//#region ../../../2-sql/2-authoring/contract-psl/dist/interpreter-C8cP92FD.mjs
+function baseColumnDescriptor(resolution, enumTypeDescriptors) {
+	if (resolution?.kind === "block") return enumTypeDescriptors.get(resolution.symbol);
+	const scalar = bareTypeConstructorOf(resolution);
+	return scalar === void 0 ? void 0 : instantiateAuthoringTypeConstructor(scalar, []);
 }
 function validateNamedTypeAttributes(input) {
 	let hasUnsupportedNamedTypeAttribute = false;
@@ -1434,22 +36,6 @@ function validateNamedTypeAttributes(input) {
 			hasUnsupportedNamedTypeAttribute = true;
 			continue;
 		}
-		const uncomposedNamespace = checkUncomposedNamespace(attribute.name, input.composedExtensions, {
-			familyId: input.familyId,
-			targetId: input.targetId,
-			authoringContributions: input.authoringContributions
-		});
-		if (uncomposedNamespace) {
-			reportUncomposedNamespace({
-				subjectLabel: `Attribute "@${attribute.name}"`,
-				namespace: uncomposedNamespace,
-				source: input.source,
-				span: attribute.span,
-				diagnostics: input.diagnostics
-			});
-			hasUnsupportedNamedTypeAttribute = true;
-			continue;
-		}
 		input.diagnostics.push({
 			code: "PSL_UNSUPPORTED_NAMED_TYPE_ATTRIBUTE",
 			message: `Named type "${input.declaration.name}" uses unsupported attribute "${attribute.name}"`,
@@ -1464,6 +50,8 @@ function resolveNamedTypeDeclarations(input) {
 	const namedTypeDescriptors = /* @__PURE__ */ new Map();
 	for (const declaration of input.declarations) {
 		const source = diagnosticSource(input.source.sources, declaration.node.syntax);
+		const reference = typeReferenceNode(declaration);
+		const resolution = reference === void 0 ? void 0 : input.binder.symbolForNode(reference);
 		if (declaration.isConstructor) {
 			const typeConstructor = declaration.typeConstructor;
 			if (typeConstructor === void 0) {
@@ -1477,25 +65,17 @@ function resolveNamedTypeDeclarations(input) {
 			if (validateNamedTypeAttributes({
 				declaration,
 				source,
-				diagnostics: input.diagnostics,
-				composedExtensions: input.composedExtensions,
-				authoringContributions: input.authoringContributions,
-				familyId: input.familyId,
-				targetId: input.targetId
+				diagnostics: input.diagnostics
 			})) continue;
-			const helperPath = typeConstructor.path.join(".");
-			const descriptor = resolvePslTypeConstructorDescriptor({
-				call: typeConstructor,
-				authoringContributions: input.authoringContributions,
-				composedExtensions: input.composedExtensions,
-				familyId: input.familyId,
-				targetId: input.targetId,
-				diagnostics: input.diagnostics,
-				source,
-				unsupportedCode: "PSL_UNSUPPORTED_NAMED_TYPE_CONSTRUCTOR",
-				unsupportedMessage: `Named type "${declaration.name}" references unsupported constructor "${helperPath}"`
-			});
-			if (!descriptor) continue;
+			const descriptor = resolution?.kind === "contributedType" && resolution.symbol.descriptor.kind === "typeConstructor" ? resolution.symbol.descriptor : void 0;
+			if (!descriptor) {
+				input.diagnostics.push({
+					code: "PSL_UNSUPPORTED_NAMED_TYPE_CONSTRUCTOR",
+					message: `Named type "${declaration.name}" references unsupported constructor "${typeConstructor.path.join(".")}"`,
+					...source.at(typeConstructor.span)
+				});
+				continue;
+			}
 			const storageType = instantiatePslTypeConstructor({
 				call: typeConstructor,
 				descriptor,
@@ -1504,7 +84,7 @@ function resolveNamedTypeDeclarations(input) {
 				entityLabel: `Named type "${declaration.name}"`
 			});
 			if (!storageType) continue;
-			namedTypeDescriptors.set(declaration.name, toNamedTypeFieldDescriptor(declaration.name, storageType));
+			namedTypeDescriptors.set(declaration, toNamedTypeFieldDescriptor(declaration.name, storageType));
 			storageTypeEntries.push([declaration.name, {
 				kind: "codec-instance",
 				codecId: storageType.codecId,
@@ -1522,7 +102,7 @@ function resolveNamedTypeDeclarations(input) {
 			});
 			continue;
 		}
-		const baseDescriptor = input.enumTypeDescriptors.get(baseType) ?? input.scalarColumnDescriptors.get(baseType);
+		const baseDescriptor = baseColumnDescriptor(resolution, input.enumTypeDescriptors);
 		if (!baseDescriptor) {
 			input.diagnostics.push({
 				code: "PSL_UNSUPPORTED_NAMED_TYPE_BASE",
@@ -1534,14 +114,10 @@ function resolveNamedTypeDeclarations(input) {
 		if (validateNamedTypeAttributes({
 			declaration,
 			source,
-			diagnostics: input.diagnostics,
-			composedExtensions: input.composedExtensions,
-			authoringContributions: input.authoringContributions,
-			familyId: input.familyId,
-			targetId: input.targetId
+			diagnostics: input.diagnostics
 		})) continue;
 		const descriptor = toNamedTypeFieldDescriptor(declaration.name, baseDescriptor);
-		namedTypeDescriptors.set(declaration.name, descriptor);
+		namedTypeDescriptors.set(declaration, descriptor);
 		storageTypeEntries.push([declaration.name, {
 			kind: "codec-instance",
 			codecId: baseDescriptor.codecId,
@@ -1874,22 +450,6 @@ function validateBackrelationFieldAttributes(input) {
 	let valid = true;
 	for (const attribute of input.field.attributes) {
 		if (attribute.name === "relation") continue;
-		const uncomposedNamespace = checkUncomposedNamespace(attribute.name, input.composedExtensions, {
-			familyId: input.familyId,
-			targetId: input.targetId,
-			authoringContributions: input.authoringContributions
-		});
-		if (uncomposedNamespace) {
-			reportUncomposedNamespace({
-				subjectLabel: `Attribute "@${attribute.name}"`,
-				namespace: uncomposedNamespace,
-				source,
-				span: attribute.span,
-				diagnostics: input.diagnostics
-			});
-			valid = false;
-			continue;
-		}
 		input.diagnostics.push({
 			code: "PSL_UNSUPPORTED_FIELD_ATTRIBUTE",
 			message: `Field "${input.modelName}.${input.field.name}" uses unsupported attribute "@${attribute.name}"`,
@@ -2112,7 +672,7 @@ function lowerExtensionBlocksForNamespace(blocks, ownerNamespaceId, entityTypesB
 	return rows;
 }
 function processEnumDeclarations(input) {
-	const enumHandles = {};
+	const enumHandles = /* @__PURE__ */ new Map();
 	const enumTypeDescriptors = /* @__PURE__ */ new Map();
 	if (input.enumBlocks.length === 0) return {
 		enumHandles,
@@ -2139,8 +699,8 @@ function processEnumDeclarations(input) {
 			sourceId: input.source.sources.sourceFileFor(symbol.node.syntax).filename
 		});
 		if (handle === void 0 || handle === null) continue;
-		enumHandles[envelope.name] = handle;
-		enumTypeDescriptors.set(envelope.name, {
+		enumHandles.set(symbol, handle);
+		enumTypeDescriptors.set(symbol, {
 			codecId: handle.codecId,
 			nativeType: handle.nativeType
 		});
@@ -2189,9 +749,7 @@ function buildModelNodeFromPsl(input) {
 		enumTypeDescriptors: input.enumTypeDescriptors,
 		namedTypeDescriptors: input.namedTypeDescriptors,
 		valueObjectTypes: input.valueObjectTypes,
-		composedExtensions: input.composedExtensions,
 		authoringContributions: input.authoringContributions,
-		familyId: input.familyId,
 		targetId: input.targetId,
 		defaultFunctionRegistry: input.defaultFunctionRegistry,
 		dataTypeSupport: input.dataTypeSupport,
@@ -2200,7 +758,7 @@ function buildModelNodeFromPsl(input) {
 		sources: input.sources,
 		binder: input.binder,
 		scalarColumnDescriptors: input.scalarColumnDescriptors,
-		...ifDefined("enumHandles", input.enumHandles),
+		enumHandles: input.enumHandles,
 		capabilities: input.capabilities,
 		...ifDefined("namespaceId", modelNamespaceId),
 		...ifDefined("namespaceExtensionEntities", namespaceExtensionEntitiesForModel),
@@ -2234,11 +792,7 @@ function buildModelNodeFromPsl(input) {
 			field,
 			sources: input.sources,
 			binder: input.binder,
-			composedExtensions: input.composedExtensions,
-			authoringContributions: input.authoringContributions,
-			diagnostics,
-			familyId: input.familyId,
-			targetId: input.targetId
+			diagnostics
 		});
 		let relationName;
 		if (relationAttribute) {
@@ -2782,7 +1336,7 @@ function buildModelNodeFromPsl(input) {
 				return {
 					...common,
 					...ifDefined("noCheck", resolvedField.noCheck),
-					...ifDefined("enumTypeHandle", input.enumHandles?.get(resolvedField.field.typeName))
+					...ifDefined("enumTypeHandle", resolvedField.enumTypeHandle)
 				};
 			}),
 			...ifDefined("id", primaryKey),
@@ -2831,13 +1385,9 @@ function buildValueObjectNodes(input) {
 			}
 			const resolved = resolveFieldTypeDescriptor({
 				field,
+				resolution: fieldTypeResolution,
 				enumTypeDescriptors: input.enumTypeDescriptors,
 				namedTypeDescriptors: input.namedTypeDescriptors,
-				scalarColumnDescriptors: input.scalarColumnDescriptors,
-				authoringContributions: input.authoringContributions,
-				composedExtensions: input.composedExtensions,
-				familyId: input.familyId,
-				targetId: input.targetId,
 				diagnostics,
 				sources,
 				entityLabel: `Field "${compositeType.name}.${field.name}"`,
@@ -2845,14 +1395,7 @@ function buildValueObjectNodes(input) {
 				...ifDefined("namespaceExtensionEntities", input.defaultNamespaceExtensionEntities),
 				...ifDefined("codecLookup", input.codecLookup)
 			});
-			if (!resolved.ok) {
-				if (!resolved.alreadyReported && fieldTypeResolution?.kind !== "unresolved") diagnostics.push({
-					code: "PSL_UNSUPPORTED_FIELD_TYPE",
-					message: `Field "${compositeType.name}.${field.name}" type "${field.typeName}" is not supported`,
-					...diagnosticSource(sources, field.node.syntax).at(field.span)
-				});
-				continue;
-			}
+			if (!resolved.ok) continue;
 			const { descriptor } = resolved;
 			if (descriptor.valueSet !== void 0) {
 				diagnostics.push({
@@ -2868,7 +1411,7 @@ function buildValueObjectNodes(input) {
 					codecId: descriptor.codecId,
 					...ifDefined("typeParams", resolvedTypeParams(descriptor, input.namedTypes))
 				},
-				...ifDefined("enumTypeHandle", enumHandles.get(field.typeName))
+				...ifDefined("enumTypeHandle", fieldTypeResolution?.kind === "block" ? enumHandles.get(fieldTypeResolution.symbol) : void 0)
 			});
 		}
 		return {
@@ -2877,7 +1420,12 @@ function buildValueObjectNodes(input) {
 		};
 	});
 }
-function collectPolymorphismDeclarations(identities, symbols, sources, binder, diagnostics) {
+function isStringTyped(field, stringCodecId, binder) {
+	const node = typeReferenceNode(field);
+	const scalar = contributedTypeOf(node === void 0 ? void 0 : binder.symbolForNode(node), binder);
+	return stringCodecId !== void 0 && scalar?.descriptor.kind === "typeConstructor" && scalar.descriptor.output.codecId === stringCodecId;
+}
+function collectPolymorphismDeclarations(identities, symbols, sources, binder, stringCodecId, diagnostics) {
 	const discriminatorDeclarations = /* @__PURE__ */ new Map();
 	const baseDeclarations = /* @__PURE__ */ new Map();
 	for (const { model, key } of identities.values()) {
@@ -2896,7 +1444,7 @@ function collectPolymorphismDeclarations(identities, symbols, sources, binder, d
 			if (parsed !== void 0) {
 				const span = nodePslSpan(discriminatorNode.syntax, sources);
 				const discField = model.fields[parsed.field];
-				if (discField && discField.typeName !== "String") diagnostics.push({
+				if (discField && !isStringTyped(discField, stringCodecId, binder)) diagnostics.push({
 					code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
 					message: `Discriminator field "${parsed.field}" on model "${model.name}" must be of type String, but is "${discField.typeName}"`,
 					...source.at(span)
@@ -3192,14 +1740,6 @@ function relationTargetKindLabel(resolution) {
 		default: return;
 	}
 }
-function replacedBySqlTypeVoice(diagnostic, composedExtensions, context) {
-	const data = diagnostic.data;
-	if (data?.["reference"] !== "type") return false;
-	if (data["constructorCall"] !== true) return false;
-	const name = data["name"];
-	if (typeof name !== "string") return false;
-	return replacesUnresolvedTypeVoice(name, composedExtensions, context);
-}
 function interpretPslDocumentToSqlContract(input) {
 	if (!input.target) throw new InternalError("PSL interpretation requires an explicit target context from composition.");
 	if (!input.scalarColumnDescriptors) throw new InternalError("PSL interpretation requires composed scalar type descriptors.");
@@ -3207,34 +1747,10 @@ function interpretPslDocumentToSqlContract(input) {
 	assertDefined(anchorDocument, "interpretPslDocumentToSqlContract requires at least one document");
 	const source = diagnosticSource(input.sources, anchorDocument.syntax);
 	const diagnostics = createPslDiagnosticCollector(input.sources);
-	const composedExtensionNames = new Set(input.composedExtensions ?? []);
 	const modelAttributesByName = buildModelAttributesByName(input.authoringContributions);
 	const contributedModelSpecs = modelAttributeSpecsFrom(modelAttributesByName);
 	const composedPslBlockDescriptors = input.authoringContributions?.pslBlockDescriptors ?? {};
-	const { binder, diagnostics: binderDiagnostics } = createSqlBinder({
-		symbolTable: input.symbolTable,
-		sources: input.sources,
-		pslBlockDescriptors: composedPslBlockDescriptors,
-		authoringContributions: input.authoringContributions,
-		controlMutationDefaults: {
-			defaultFunctionRegistry: input.controlMutationDefaults?.defaultFunctionRegistry ?? /* @__PURE__ */ new Map(),
-			dataTypeEntries: input.authoringContributions?.dataTypes ?? {}
-		},
-		scalarColumnDescriptors: input.scalarColumnDescriptors,
-		contributedModelAttributeSpecs: contributedModelSpecs,
-		describeUnsupportedAttribute: describeUnsupportedSqlAttribute({
-			composedExtensions: composedExtensionNames,
-			authoringContributions: input.authoringContributions,
-			sources: input.sources,
-			familyId: input.target.familyId,
-			targetId: input.target.targetId
-		})
-	});
-	diagnostics.push(...binderDiagnostics.filter((diagnostic) => !replacedBySqlTypeVoice(diagnostic, composedExtensionNames, {
-		familyId: "sql",
-		targetId: input.target.targetId,
-		authoringContributions: input.authoringContributions
-	})));
+	const { binder } = input;
 	const { topLevel } = input.symbolTable;
 	const namespaceSymbols = Object.values(topLevel.namespaces);
 	validateNamespaceBlocksForSqlTarget({
@@ -3359,9 +1875,9 @@ function interpretPslDocumentToSqlContract(input) {
 		},
 		diagnostics
 	});
-	const allEnumTypeDescriptors = new Map(enumResult.enumTypeDescriptors);
-	const validEnumHandles = { ...enumResult.enumHandles };
-	const enumHandlesByName = new Map(Object.entries(validEnumHandles));
+	const allEnumTypeDescriptors = enumResult.enumTypeDescriptors;
+	const enumHandles = enumResult.enumHandles;
+	const validEnumHandles = Object.fromEntries(Array.from(enumHandles, ([symbol, handle]) => [symbol.name, handle]));
 	const entityTypesByDiscriminator = buildEntityTypesByDiscriminator(input.authoringContributions);
 	const authoringWarnings = [];
 	const extensionEntityContext = {
@@ -3432,17 +1948,16 @@ function interpretPslDocumentToSqlContract(input) {
 			});
 		}
 	}
-	const isScalarRefinement = (symbol) => !symbol.isConstructor && symbol.baseType !== void 0 && input.scalarColumnDescriptors.has(symbol.baseType);
+	const isScalarRefinement = (symbol) => {
+		const reference = typeReferenceNode(symbol);
+		return !symbol.isConstructor && symbol.baseType !== void 0 && reference !== void 0 && bareTypeConstructorOf(binder.symbolForNode(reference)) !== void 0;
+	};
 	const allNamedTypes = Object.values(topLevel.namedTypes);
 	const namedTypeResult = resolveNamedTypeDeclarations({
 		declarations: [...allNamedTypes.filter(isScalarRefinement), ...allNamedTypes.filter((symbol) => !isScalarRefinement(symbol))],
 		source,
+		binder,
 		enumTypeDescriptors: allEnumTypeDescriptors,
-		scalarColumnDescriptors: input.scalarColumnDescriptors,
-		composedExtensions,
-		familyId: input.target.familyId,
-		targetId: input.target.targetId,
-		authoringContributions: input.authoringContributions,
 		diagnostics
 	});
 	const storageTypes = { ...namedTypeResult.storageTypes };
@@ -3455,14 +1970,9 @@ function interpretPslDocumentToSqlContract(input) {
 	const valueObjects = buildValueObjectNodes({
 		compositeTypes,
 		enumTypeDescriptors: allEnumTypeDescriptors,
-		enumHandles: enumHandlesByName,
+		enumHandles,
 		namedTypeDescriptors: namedTypeResult.namedTypeDescriptors,
 		namedTypes: namedTypeResult.storageTypes,
-		scalarColumnDescriptors: input.scalarColumnDescriptors,
-		composedExtensions,
-		familyId: input.target.familyId,
-		targetId: input.target.targetId,
-		authoringContributions: input.authoringContributions,
 		diagnostics,
 		sources: input.sources,
 		defaultNamespaceId,
@@ -3482,7 +1992,6 @@ function interpretPslDocumentToSqlContract(input) {
 			valueObjectTypes,
 			enumTypeDescriptors: allEnumTypeDescriptors,
 			namedTypeDescriptors: namedTypeResult.namedTypeDescriptors,
-			composedExtensions,
 			composedExtensionContracts,
 			familyId: input.target.familyId,
 			targetId: input.target.targetId,
@@ -3495,7 +2004,7 @@ function interpretPslDocumentToSqlContract(input) {
 			binder,
 			symbolTable: input.symbolTable,
 			diagnostics,
-			...enumHandlesByName.size > 0 ? { enumHandles: enumHandlesByName } : {},
+			enumHandles,
 			capabilities: input.capabilities,
 			...namespaceExtensionEntities.size > 0 ? { namespaceExtensionEntities } : {},
 			...ifDefined("codecLookup", input.codecLookup),
@@ -3559,7 +2068,7 @@ function interpretPslDocumentToSqlContract(input) {
 			namespaceId: resolvedNamespaceId,
 			key: modelCoordinateKey(resolvedNamespaceId, model.name)
 		}];
-	})), input.symbolTable, input.sources, binder, diagnostics);
+	})), input.symbolTable, input.sources, binder, input.scalarColumnDescriptors.get("String")?.codecId, diagnostics);
 	const stiVariantKeys = /* @__PURE__ */ new Set();
 	for (const [variantKey, declaration] of baseDeclarations) if (!(getAttribute(declaration.model.attributes, "map") !== void 0)) stiVariantKeys.add(variantKey);
 	for (const variantKey of stiVariantKeys) {
@@ -3645,6 +2154,6 @@ function interpretPslDocumentToSqlContract(input) {
 	});
 }
 //#endregion
-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 };
+export { normalizeReferentialAction as a, interpretPslDocumentToSqlContract as i, buildEntityTypesByDiscriminator as n, indexFkRelations as r, applyBackrelationCandidates as t };
 
-//# sourceMappingURL=interpreter-CkCfPqup-DF7bZvNM.mjs.map
+//# sourceMappingURL=interpreter-C8cP92FD-Co9RsuUU.mjs.map