@prisma/orm-family-sql 8.0.0-rc.14-dev.15 → 8.0.0-rc.14-dev.17

package/dist/psl-field-resolution-_o74AUE4-CKYNRnzL.mjs

@@ -0,0 +1,1868 @@
+import { s as sqlTextFromCanonical, t as SQL_EXPRESSION_DATA_TYPE_ID } from "./sql-expression-BXx0Ilj-.mjs";
+import { n as checkSqlDefaultBody, o as reservedSqlDefaultBody } from "./validators-DvzOZLel.mjs";
+import { a as storedAsListColumn, i as isValueObjectMember } from "./derived-checks-C_y1rk6O-DdqjzGNy.mjs";
+import { structuredError } from "@prisma/orm-framework/utils/structured-error";
+import { instantiateAuthoringTypeConstructor, isAuthoringEntityTypeDescriptor, validateAuthoringHelperArguments } from "@prisma/orm-framework/components/authoring";
+import { InternalError, isInternalError } from "@prisma/orm-framework/utils/internal-error";
+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, FunctionCallAst, IdentifierAst } from "@prisma/orm-framework/psl-parser/syntax";
+import { assertDefined, invariant } from "@prisma/orm-framework/utils/assertions";
+import { describeTaggedLiteralFailure } from "@prisma/orm-framework/components/control";
+import { notOk, ok } from "@prisma/orm-framework/utils/result";
+import { bool, diagnosticSource, entityRef, fieldAttribute, fieldRef, funcCall, identifier, interpretAttribute, leafDiagnostic, list, modelAttribute, nodePslSpan, numLiteral, oneOf, optional, record, referencedFieldRef, str, taggedLiteral, typeReferenceNode } from "@prisma/orm-framework/psl-parser";
+import { instantiatePslFieldPreset, isBareTypeConstructor, mapPslHelperArgs, reportPresetNotCalled, reportTypeConstructorNotCalled } from "@prisma/orm-framework/psl-parser/interpret";
+//#region ../../../2-sql/2-authoring/contract-psl/dist/psl-field-resolution-_o74AUE4.mjs
+function storageName(symbol, physicalNames) {
+	const name = physicalNames.get(symbol);
+	assertDefined(name, "Physical names are populated for every model and field before lowering");
+	return name;
+}
+function getAttribute(attributes, name) {
+	return attributes?.find((attribute) => attribute.name === name);
+}
+function formatDbAttributeMigrationMessage(attribute) {
+	const renderedArguments = attribute.args.map((argument) => argument.kind === "named" && argument.name !== void 0 ? `${argument.name}: ${argument.value}` : argument.value).join(", ");
+	const argumentList = attribute.args.length === 0 ? "" : `(${renderedArguments})`;
+	const constructorName = attribute.name.slice(3);
+	return `@${attribute.name}${argumentList} is no longer supported; use ${constructorName}${argumentList} in type position`;
+}
+function getNamedArgument(attribute, name) {
+	const entry = attribute.args.find((arg) => arg.kind === "named" && arg.name === name);
+	if (entry?.kind !== "named") return;
+	return entry.value;
+}
+function mapFieldNamesToColumns(input) {
+	const columns = [];
+	for (const fieldName of input.fieldNames) {
+		const field = input.model.fields[fieldName];
+		if (field === void 0) {
+			input.diagnostics.push({
+				code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+				message: `${input.entityLabel} references unknown field "${input.model.name}.${fieldName}"`,
+				...input.source.at(input.span)
+			});
+			return;
+		}
+		columns.push(storageName(field, input.physicalNames));
+	}
+	return columns;
+}
+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(", ")}`;
+}
+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);
+		return usageSignatures && usageSignatures.length > 0 ? usageSignatures : [`${functionName}()`];
+	});
+	return signatures.length > 0 ? signatures.join(", ") : "none";
+}
+/** The diagnostic message for a `dbgenerated(...)` call, which raw SQL tagged literals replaced. */
+function removedDbgeneratedMessage(registry) {
+	return `Default function "dbgenerated" was removed. Write the SQL as a tagged literal: @default(sql\`<expression>\`). Supported functions: ${formatSupportedFunctionList(registry)}.`;
+}
+function lowerDefaultFunctionWithRegistry(input) {
+	const entry = input.registry.get(input.call.fn);
+	if (entry) {
+		const result = entry.lower({
+			call: input.call,
+			context: input.context
+		});
+		return result.ok ? result : {
+			...result,
+			kind: "external"
+		};
+	}
+	const supportedFunctionList = formatSupportedFunctionList(input.registry);
+	return {
+		ok: false,
+		kind: "owned",
+		diagnostic: {
+			code: "PSL_UNKNOWN_DEFAULT_FUNCTION",
+			message: `Default function "${input.call.fn}" is not supported in SQL PSL provider v1. Supported functions: ${supportedFunctionList}.`,
+			...input.source.at(input.call.span)
+		}
+	};
+}
+function buildModelAttributeCtx(input) {
+	return {
+		sources: input.sources,
+		selfModel: input.selfModel,
+		binder: input.binder,
+		symbols: input.symbols
+	};
+}
+function buildFieldAttributeCtx(input) {
+	return {
+		sources: input.sources,
+		selfModel: input.selfModel,
+		field: input.field,
+		binder: input.binder,
+		symbols: input.symbols
+	};
+}
+function modelAttributeSpecsFrom(modelAttributesByName) {
+	const result = Object.create(null);
+	for (const [name, descriptor] of modelAttributesByName) result[name] = blindCast(descriptor.spec);
+	return result;
+}
+function interpretModelAttribute(input) {
+	const result = interpretAttribute(input.node, input.spec, buildModelAttributeCtx({
+		symbols: input.symbols,
+		selfModel: input.model,
+		sources: input.sources,
+		binder: input.binder
+	}));
+	if (!result.ok) {
+		input.diagnostics.push(...result.failure);
+		return;
+	}
+	return result.value;
+}
+function interpretFieldAttribute(input) {
+	const result = interpretAttribute(input.node, input.spec, buildFieldAttributeCtx({
+		symbols: input.symbols,
+		selfModel: input.model,
+		field: input.field,
+		sources: input.sources,
+		binder: input.binder
+	}));
+	if (!result.ok) {
+		input.diagnostics.push(...result.failure);
+		return;
+	}
+	return result.value;
+}
+function validateMappedName(value, ctx, attributeNode) {
+	return value.name === "" ? [leafDiagnostic(ctx, attributeNode, "Mapped name must not be empty")] : [];
+}
+const mapModelSpec = modelAttribute("map", {
+	documentation: "Maps this model to a database table name.",
+	positional: [{
+		key: "name",
+		type: str(),
+		documentation: "The nonempty database table name."
+	}],
+	refine: validateMappedName
+});
+const mapFieldSpec = fieldAttribute("map", {
+	documentation: "Maps this field to a database column name.",
+	positional: [{
+		key: "name",
+		type: str(),
+		documentation: "The nonempty database column name."
+	}],
+	refine: validateMappedName
+});
+function nullLiteral() {
+	const nullIdentifier = identifier("null", { documentation: "A null list element or nullable scalar default." });
+	return {
+		kind: "null",
+		label: "null",
+		parse: (arg, ctx) => {
+			const result = nullIdentifier.parse(arg, ctx);
+			return result.ok ? ok(null) : result;
+		}
+	};
+}
+function scalarDefaultArms(isList, registries) {
+	const tagsByDocumentation = /* @__PURE__ */ new Map();
+	for (const entry of Object.values(registries.dataTypeEntries)) {
+		if (entry.written.kind !== "tag") continue;
+		const tags = tagsByDocumentation.get(entry.documentation);
+		if (tags === void 0) tagsByDocumentation.set(entry.documentation, [entry.written.tag]);
+		else tags.push(entry.written.tag);
+	}
+	const tagArms = () => [...tagsByDocumentation].map(([documentation, tags]) => taggedLiteral(tags, { documentation }));
+	const literal = () => oneOf(str(), numLiteral(), bool(), nullLiteral(), ...tagArms());
+	const listArm = () => list(literal(), { label: `list of (${literal().label})` });
+	const funcArms = [...registries.defaultFunctionRegistry.entries()].map(([name, entry]) => funcCall(name, blindCast(entry.signature)));
+	return isList ? [
+		listArm(),
+		...funcArms,
+		...tagArms()
+	] : [
+		str(),
+		numLiteral(),
+		bool(),
+		nullLiteral(),
+		...funcArms,
+		...tagArms(),
+		listArm()
+	];
+}
+/**
+* The `@default` value arms, with a `dbgenerated(...)` call reported as removed before the arms
+* are tried, so the author is told what replaced it instead of being shown the list of arms.
+*/
+function defaultValueArm(arms, registry) {
+	const value = arms.length === 1 && arms[0].kind === "list" ? arms[0] : oneOf(...arms);
+	return {
+		...value,
+		parse: (arg, ctx) => FunctionCallAst.cast(arg.syntax)?.path().join(".") === "dbgenerated" ? notOk([leafDiagnostic(ctx, arg, removedDbgeneratedMessage(registry), "PSL_UNKNOWN_DEFAULT_FUNCTION")]) : value.parse(arg, ctx)
+	};
+}
+function noEnumMember() {
+	return {
+		kind: "rejecting",
+		label: "enum member",
+		message: "Enum declares no members",
+		parse: (arg, ctx) => notOk([leafDiagnostic(ctx, arg, "Enum declares no members")])
+	};
+}
+function enumMemberNames(ctx) {
+	const resolution = ctx.typeResolution;
+	if (resolution?.kind !== "block" || resolution.symbol.keyword !== "enum") return void 0;
+	const block = resolution.symbol;
+	const names = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const entry of block.node.entries()) {
+		const key = entry.key()?.name();
+		if (key === void 0 || seen.has(key)) continue;
+		seen.add(key);
+		names.push(key);
+	}
+	return names;
+}
+function enumDefaultArms(members, enumName, isList) {
+	const [first, ...rest] = members;
+	if (first === void 0) return [noEnumMember()];
+	const member = (name) => identifier(name, { documentation: `The \`${name}\` member of enum \`${enumName}\`.` });
+	if (isList) return [list(oneOf(member(first), ...rest.map(member), nullLiteral()))];
+	return [member(first), ...rest.map(member)];
+}
+function defaultFieldSpec(ctx) {
+	const members = enumMemberNames(ctx);
+	return fieldAttribute("default", {
+		documentation: "Supplies a default value when this field is omitted from a mutation.",
+		positional: [{
+			key: "value",
+			type: defaultValueArm(members === void 0 ? scalarDefaultArms(ctx.field.list, ctx.controlMutationDefaults) : enumDefaultArms(members, ctx.field.typeName, ctx.field.list), ctx.controlMutationDefaults.defaultFunctionRegistry),
+			documentation: "A literal, enum member, or registered default function compatible with this field."
+		}]
+	});
+}
+const idFieldSpec = fieldAttribute("id", {
+	documentation: "Makes this field the primary key of the table.",
+	named: { map: {
+		type: optional(str()),
+		documentation: "The database primary-key constraint name."
+	} }
+});
+const uniqueFieldSpec = fieldAttribute("unique", {
+	documentation: "Requires values in this field to be unique.",
+	named: { map: {
+		type: optional(str()),
+		documentation: "The database unique-constraint name."
+	} }
+});
+const noCheckKindArgument = () => oneOf(identifier("membership", { documentation: "Waives the generated check that values belong to the declared domain enum." }), identifier("elementNotNull", { documentation: "Waives the generated check that scalar-list elements are non-null." }));
+/**
+* `@noCheck` waives generated CHECK constraints on one column: bare for every
+* kind the column's shape derives, or naming concrete kinds. Two optional
+* positional slots cover the whole kind vocabulary; a third argument is
+* necessarily a duplicate and fails as excess arity.
+*/
+const noCheckFieldSpec = fieldAttribute("noCheck", {
+	documentation: "Waives generated CHECK constraints for this column. With no arguments, waives every generated kind.",
+	positional: [{
+		key: "first",
+		type: optional(noCheckKindArgument()),
+		documentation: "The first generated check kind to waive: `membership` or `elementNotNull`."
+	}, {
+		key: "second",
+		type: optional(noCheckKindArgument()),
+		documentation: "A second, distinct generated check kind to waive."
+	}],
+	refine: (value, ctx, attributeNode) => {
+		if (value.first !== void 0 && value.first === value.second) return [leafDiagnostic(ctx, attributeNode, "`@noCheck` names the same kind twice")];
+		return [];
+	}
+});
+const idModelSpec = modelAttribute("id", {
+	documentation: "Declares a compound primary key for this table.",
+	positional: [{
+		key: "fields",
+		type: list(fieldRef(), {
+			allowEmpty: false,
+			unique: true
+		}),
+		documentation: "The ordered, nonempty list of distinct primary-key fields."
+	}],
+	named: { map: {
+		type: optional(str()),
+		documentation: "The database primary-key constraint name."
+	} }
+});
+const uniqueModelSpec = modelAttribute("unique", {
+	documentation: "Requires the combination of these fields to be unique.",
+	positional: [{
+		key: "fields",
+		type: list(fieldRef(), {
+			allowEmpty: false,
+			unique: true
+		}),
+		documentation: "The ordered, nonempty list of distinct fields in the unique constraint."
+	}],
+	named: { map: {
+		type: optional(str()),
+		documentation: "The database unique-constraint name."
+	} }
+});
+const PSL_INDEX_FIELDS_XOR_EXPRESSION = "PSL_INDEX_FIELDS_XOR_EXPRESSION";
+const PSL_INDEX_EXPRESSION_REQUIRES_NAME = "PSL_INDEX_EXPRESSION_REQUIRES_NAME";
+const PSL_INDEX_NAME_XOR_MAP = "PSL_INDEX_NAME_XOR_MAP";
+const indexModelSpec = modelAttribute("index", {
+	documentation: "Declares a database index over fields or a SQL expression, optionally restricted by a predicate.",
+	positional: [{
+		key: "fields",
+		type: optional(list(fieldRef(), {
+			allowEmpty: false,
+			unique: true
+		})),
+		documentation: "The ordered list of distinct indexed fields. Mutually exclusive with `expression`."
+	}],
+	named: {
+		expression: {
+			type: optional(str()),
+			documentation: "The SQL index expression. Requires `name` or `map` and cannot be combined with a fields list."
+		},
+		where: {
+			type: optional(str()),
+			documentation: "The SQL predicate restricting rows included in a partial index."
+		},
+		unique: {
+			type: optional(bool()),
+			documentation: "Whether the index enforces uniqueness."
+		},
+		name: {
+			type: optional(str()),
+			documentation: "The index name. Mutually exclusive with `map`."
+		},
+		map: {
+			type: optional(str()),
+			documentation: "The database index name. Mutually exclusive with `name`."
+		},
+		type: {
+			type: optional(str()),
+			documentation: "The target-specific index access method."
+		},
+		options: {
+			type: optional(record(str())),
+			documentation: "Target-specific index options. Requires an explicit `type`."
+		}
+	},
+	refine: (value, ctx, attributeNode) => {
+		const diagnostics = [];
+		if (value.fields === void 0 === (value.expression === void 0)) diagnostics.push(leafDiagnostic(ctx, attributeNode, "`@@index` requires exactly one of a fields list or an `expression` argument", PSL_INDEX_FIELDS_XOR_EXPRESSION));
+		if (value.expression !== void 0 && value.name === void 0 && value.map === void 0) diagnostics.push(leafDiagnostic(ctx, attributeNode, "`@@index` with an `expression` argument requires a `name` or `map` argument (a default name cannot be derived from an expression)", PSL_INDEX_EXPRESSION_REQUIRES_NAME));
+		if (value.name !== void 0 && value.map !== void 0) diagnostics.push(leafDiagnostic(ctx, attributeNode, "`@@index` takes at most one of `name` and `map`", PSL_INDEX_NAME_XOR_MAP));
+		if (value.options !== void 0 && value.type === void 0) diagnostics.push(leafDiagnostic(ctx, attributeNode, "`@@index` options argument requires a type argument"));
+		return diagnostics;
+	}
+});
+const PSL_CHECK_REQUIRES_NAME_OR_MAP = "PSL_CHECK_REQUIRES_NAME_OR_MAP";
+const PSL_CHECK_NAME_XOR_MAP = "PSL_CHECK_NAME_XOR_MAP";
+const PSL_CHECK_EXPRESSION_EMPTY = "PSL_CHECK_EXPRESSION_EMPTY";
+/**
+* A single-table-inheritance variant (`@@base` with no own `@@map`) shares
+* its base model's storage table and has no table of its own to declare a
+* check on — raised from {@link interpretPslDocumentToSqlContract}, not from
+* this spec's own `refine`, because the rule needs the model's `@@base`
+* declaration, which a single attribute's `refine` cannot see.
+*/
+const PSL_CHECK_ON_STI_VARIANT = "PSL_CHECK_ON_STI_VARIANT";
+const checkModelSpec = modelAttribute("check", {
+	documentation: "Declares a named database CHECK constraint on this table.",
+	named: {
+		expression: {
+			type: str(),
+			documentation: "The nonempty SQL predicate checked for each row."
+		},
+		name: {
+			type: optional(str()),
+			documentation: "The constraint name. Exactly one of `name` and `map` is required."
+		},
+		map: {
+			type: optional(str()),
+			documentation: "The database constraint name. Exactly one of `name` and `map` is required."
+		}
+	},
+	refine: (value, ctx, attributeNode) => {
+		const diagnostics = [];
+		if (value.expression.trim().length === 0) diagnostics.push(leafDiagnostic(ctx, attributeNode, "`@@check` expression must not be empty — an empty predicate is not a constraint", PSL_CHECK_EXPRESSION_EMPTY));
+		if (value.name === void 0 && value.map === void 0) diagnostics.push(leafDiagnostic(ctx, attributeNode, "`@@check` requires a `name` or `map` argument (a default name cannot be derived — a check has no column tuple to name itself after)", PSL_CHECK_REQUIRES_NAME_OR_MAP));
+		if (value.name !== void 0 && value.map !== void 0) diagnostics.push(leafDiagnostic(ctx, attributeNode, "`@@check` takes at most one of `name` and `map`", PSL_CHECK_NAME_XOR_MAP));
+		return diagnostics;
+	}
+});
+const controlModelSpec = modelAttribute("control", {
+	documentation: "Sets how schema management treats this model’s storage.",
+	positional: [{
+		key: "policy",
+		documentation: "The storage control policy: `managed`, `tolerated`, `external`, or `observed`.",
+		type: oneOf(identifier("managed", { documentation: "Verifies the declared shape strictly and allows migrations to create, alter, or drop the storage object." }), identifier("tolerated", { documentation: "Verifies declared columns while allowing extra columns. Migrations may create missing storage, but never alter or drop existing storage." }), identifier("external", { documentation: "Verifies declared storage without creating, altering, or dropping it." }), identifier("observed", { documentation: "Reports storage differences as warnings rather than verification failures and never emits migration operations." }))
+	}]
+});
+const discriminatorModelSpec = modelAttribute("discriminator", {
+	documentation: "Selects the field that identifies inheritance variants of this model.",
+	positional: [{
+		key: "field",
+		type: fieldRef(),
+		documentation: "The discriminator field on this model."
+	}]
+});
+function baseModelSpec() {
+	return modelAttribute("base", {
+		documentation: "Declares this model as a variant of a base model.",
+		positional: [{
+			key: "base",
+			type: entityRef({ kind: "model" }),
+			documentation: "The base model to inherit from."
+		}, {
+			key: "value",
+			type: str(),
+			documentation: "The discriminator value identifying this variant."
+		}]
+	});
+}
+function relationAttributeSpan(ctx) {
+	const node = getAttribute(ctx.field.attributes, "relation")?.node;
+	if (node !== void 0) return nodePslSpan(node.syntax, ctx.sources);
+	return ctx.field.span;
+}
+function relationInvariants(parsed, ctx) {
+	if (parsed.fields !== void 0 !== (parsed.references !== void 0)) return [{
+		code: "PSL_INVALID_ATTRIBUTE_SYNTAX",
+		message: `Relation field "${ctx.selfModel.name}.${ctx.field.name}" requires fields and references arguments`,
+		...diagnosticSource(ctx.sources, ctx.field.node.syntax).at(relationAttributeSpan(ctx))
+	}];
+	return [];
+}
+const referentialActionArgument = () => oneOf(identifier("NoAction", { documentation: "Rejects a change that would violate the foreign key when the constraint is checked; checking may be deferred when supported and configured." }), identifier("Restrict", { documentation: "Rejects deleting or updating a referenced row while referencing rows remain, without deferring the check." }), identifier("Cascade", { documentation: "Propagates deletion or key updates of a referenced row to its referencing rows." }), identifier("SetNull", { documentation: "Sets referencing foreign-key fields to null when the referenced row is deleted or its key changes. The fields must allow null." }), identifier("SetDefault", { documentation: "Sets referencing foreign-key fields to their defaults when the referenced row is deleted or its key changes. The resulting values must satisfy the foreign key." }));
+const relationFieldSpec = fieldAttribute("relation", {
+	documentation: "Defines the relation name, foreign-key fields, and referential actions for this relation.",
+	positional: [{
+		key: "name",
+		type: optional(str()),
+		documentation: "The relation name used to pair both sides. May also be supplied by name."
+	}],
+	named: {
+		name: {
+			type: optional(str()),
+			documentation: "The relation name used to pair both sides. Cannot also be supplied positionally."
+		},
+		fields: {
+			type: optional(list(fieldRef(), {
+				allowEmpty: false,
+				unique: true
+			})),
+			documentation: "The ordered local foreign-key fields. Must be supplied together with `references`."
+		},
+		references: {
+			type: optional(list(referencedFieldRef(), {
+				allowEmpty: false,
+				unique: true
+			})),
+			documentation: "The corresponding fields on the referenced model. Must be supplied together with `fields`."
+		},
+		map: {
+			type: optional(str()),
+			documentation: "The database foreign-key constraint name."
+		},
+		onDelete: {
+			type: optional(referentialActionArgument()),
+			documentation: "The referential action when a referenced row is deleted."
+		},
+		onUpdate: {
+			type: optional(referentialActionArgument()),
+			documentation: "The referential action when a referenced key is updated."
+		},
+		index: {
+			type: optional(bool()),
+			documentation: "Whether to create an index for the relation’s foreign-key fields."
+		}
+	},
+	refine: relationInvariants
+});
+function fieldSpecContext(input) {
+	const node = typeReferenceNode(input.field);
+	return {
+		symbols: input.symbols,
+		model: input.model,
+		field: input.field,
+		typeResolution: node === void 0 ? void 0 : input.binder.symbolForNode(node),
+		controlMutationDefaults: input.controlMutationDefaults
+	};
+}
+const sqlAttributeSpecs = {
+	model: {
+		map: () => mapModelSpec,
+		id: () => idModelSpec,
+		unique: () => uniqueModelSpec,
+		index: () => indexModelSpec,
+		check: () => checkModelSpec,
+		control: () => controlModelSpec,
+		discriminator: () => discriminatorModelSpec,
+		base: baseModelSpec
+	},
+	field: {
+		map: () => mapFieldSpec,
+		id: () => idFieldSpec,
+		unique: () => uniqueFieldSpec,
+		noCheck: () => noCheckFieldSpec,
+		relation: () => relationFieldSpec,
+		default: defaultFieldSpec
+	}
+};
+/** 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 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;
+	}
+}
+/**
+* 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 NOT_RESOLVED;
+	}
+	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 NOT_RESOLVED;
+	};
+	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 NOT_RESOLVED;
+	}
+	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 } : {}
+		}
+	};
+}
+const NOT_RESOLVED = { ok: false };
+function instantiateFieldTypeConstructor(input) {
+	if (input.descriptor.entityRefArg !== void 0) return resolveEntityRefTypeConstructorCall({
+		call: input.call,
+		descriptor: input.descriptor,
+		namespaceId: input.namespaceId,
+		namespaceExtensionEntities: input.namespaceExtensionEntities,
+		codecLookup: input.codecLookup,
+		diagnostics: input.diagnostics,
+		source: input.source,
+		entityLabel: input.entityLabel
+	});
+	const instantiated = instantiatePslTypeConstructor({
+		call: input.call,
+		descriptor: input.descriptor,
+		diagnostics: input.diagnostics,
+		source: input.source,
+		entityLabel: input.entityLabel
+	});
+	return instantiated === void 0 ? NOT_RESOLVED : {
+		ok: true,
+		descriptor: instantiated
+	};
+}
+function instantiateFieldPreset(input) {
+	const instantiated = instantiatePslFieldPreset(input);
+	if (!instantiated) return NOT_RESOLVED;
+	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
+	};
+}
+function bareTypeConstructorOf(resolution) {
+	if (resolution?.kind !== "contributedType") return void 0;
+	const { descriptor } = resolution.symbol;
+	return descriptor.kind === "typeConstructor" && isBareTypeConstructor(descriptor) ? descriptor : void 0;
+}
+function resolvedKindLabel(resolution) {
+	switch (resolution.kind) {
+		case "compositeType": return "composite type";
+		case "namedType": return "named type";
+		case "block": return resolution.symbol.keyword;
+		case "crossSpace": return "type of another contract space";
+		default: return resolution.kind;
+	}
+}
+function resolveFieldTypeDescriptor(input) {
+	const { field, resolution, entityLabel, diagnostics } = input;
+	if (field.malformedType || resolution === void 0) return NOT_RESOLVED;
+	const source = diagnosticSource(input.sources, field.node.syntax);
+	const unsupported = (message) => {
+		diagnostics.push({
+			code: "PSL_UNSUPPORTED_FIELD_TYPE",
+			message,
+			...source.at(field.span)
+		});
+		return NOT_RESOLVED;
+	};
+	const call = field.typeConstructor;
+	switch (resolution.kind) {
+		case "unresolved":
+		case "namespace":
+		case "contributedNamespace": return NOT_RESOLVED;
+		case "contributedType": {
+			const { descriptor, path } = resolution.symbol;
+			const written = path.join(".");
+			if (descriptor.kind === "fieldPreset") {
+				if (call === void 0) {
+					reportPresetNotCalled({
+						entityLabel,
+						presetPath: written,
+						source,
+						span: field.span,
+						diagnostics
+					});
+					return NOT_RESOLVED;
+				}
+				return instantiateFieldPreset({
+					call,
+					descriptor,
+					diagnostics,
+					source,
+					entityLabel
+				});
+			}
+			if (call !== void 0) return instantiateFieldTypeConstructor({
+				...input,
+				call,
+				descriptor,
+				source
+			});
+			if (!isBareTypeConstructor(descriptor)) {
+				reportTypeConstructorNotCalled({
+					entityLabel,
+					path: written,
+					descriptor,
+					source,
+					span: field.span,
+					diagnostics
+				});
+				return NOT_RESOLVED;
+			}
+			return {
+				ok: true,
+				descriptor: instantiateAuthoringTypeConstructor(descriptor, [])
+			};
+		}
+		case "field":
+		case "attribute": throw new InternalError(`The type of ${entityLabel} resolved to a ${resolution.kind}; a type reference never names one. This is a binder bug.`);
+	}
+	if (call !== void 0) return unsupported(`${entityLabel} calls "${call.path.join(".")}", which is a ${resolvedKindLabel(resolution)}, not a type constructor. Remove the arguments.`);
+	switch (resolution.kind) {
+		case "namedType": {
+			const descriptor = input.namedTypeDescriptors.get(resolution.symbol);
+			return descriptor === void 0 ? NOT_RESOLVED : {
+				ok: true,
+				descriptor
+			};
+		}
+		case "block": {
+			if (resolution.symbol.keyword !== "enum") return unsupported(`${entityLabel} is typed by the ${resolution.symbol.keyword} "${resolution.symbol.name}", which is not a column type.`);
+			const descriptor = input.enumTypeDescriptors.get(resolution.symbol);
+			return descriptor === void 0 ? NOT_RESOLVED : {
+				ok: true,
+				descriptor
+			};
+		}
+		case "model":
+		case "compositeType": return unsupported(`${entityLabel} is typed by the ${resolvedKindLabel(resolution)} "${resolution.symbol.name}", which is not a column type.`);
+		case "crossSpace": return unsupported(`${entityLabel} type "${field.typeName}" is a type of contract space "${field.typeContractSpaceId}"; only a relation field can name a type of another contract space.`);
+	}
+}
+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,
+		binder: input.binder,
+		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 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,
+			binder: input.binder,
+			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(sources) {
+	return ({ attribute, level, owner, field }) => {
+		if (owner.kind === "compositeType") return void 0;
+		if (level === "model") {
+			const source = diagnosticSource(sources, owner.node.syntax);
+			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(sources, field.node.syntax);
+		if (attribute.name.startsWith("db.")) return {
+			code: "PSL_UNSUPPORTED_FIELD_ATTRIBUTE",
+			message: formatDbAttributeMigrationMessage(attribute),
+			...source.at(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, authoringContributions, binder, 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,
+			resolution: fieldTypeResolution,
+			enumTypeDescriptors,
+			namedTypeDescriptors,
+			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) 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) 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 = fieldTypeResolution?.kind === "block" ? enumHandles.get(fieldTypeResolution.symbol) : void 0;
+		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),
+			...ifDefined("enumTypeHandle", enumHandle)
+		});
+	}
+	return resolvedFields;
+}
+//#endregion
+export { toNamedTypeFieldDescriptor as S, modelCoordinateKey as _, describeUnsupportedSqlAttribute as a, sqlAttributeSpecs as b, getAttribute as c, instantiateFieldTypeConstructor as d, instantiatePslTypeConstructor as f, modelAttributeSpecsFrom as g, mapFieldNamesToColumns as h, contractError as i, getAuthoringEntity as l, interpretModelAttribute as m, bareTypeConstructorOf as n, entryForTag as o, interpretFieldAttribute as p, collectResolvedFields as r, formatDbAttributeMigrationMessage as s, PSL_CHECK_ON_STI_VARIANT as t, getNamedArgument as u, readDataTypeDefault as v, storageName as x, resolveFieldTypeDescriptor as y };
+
+//# sourceMappingURL=psl-field-resolution-_o74AUE4-CKYNRnzL.mjs.map