@prisma-next/sql-contract-psl 0.3.0-dev.147 → 0.3.0-dev.163

package/dist/{interpreter-qjtea3zY.mjs → interpreter-iFCRN9nb.mjs}

@@ -1,4 +1,4 @@
-import { instantiateAuthoringTypeConstructor, isAuthoringTypeConstructorDescriptor } from "@prisma-next/framework-components/authoring";
+import { instantiateAuthoringTypeConstructor, isAuthoringTypeConstructorDescriptor, validateAuthoringHelperArguments } from "@prisma-next/framework-components/authoring";
 import { buildSqlContractFromDefinition } from "@prisma-next/sql-contract-ts/contract-builder";
 import { ifDefined } from "@prisma-next/utils/defined";
 import { notOk, ok } from "@prisma-next/utils/result";
@@ -324,6 +324,284 @@ function lowerDefaultFunctionWithRegistry(input) {
 	};
 }
 
+//#endregion
+//#region src/psl-authoring-arguments.ts
+const INVALID_AUTHORING_ARGUMENT = Symbol("invalidAuthoringArgument");
+function isIdentifierStartCharacter(character) {
+	return character !== void 0 && /[A-Za-z_$]/.test(character);
+}
+function isIdentifierCharacter(character) {
+	return character !== void 0 && /[A-Za-z0-9_$]/.test(character);
+}
+function parseJsLikeLiteral(value) {
+	let index = 0;
+	function skipWhitespace() {
+		while (/\s/.test(value[index] ?? "")) index += 1;
+	}
+	function parseIdentifier() {
+		const first = value[index];
+		if (!isIdentifierStartCharacter(first)) return INVALID_AUTHORING_ARGUMENT;
+		let end = index + 1;
+		while (isIdentifierCharacter(value[end])) end += 1;
+		const identifier = value.slice(index, end);
+		index = end;
+		return identifier;
+	}
+	function parseString() {
+		const quote = value[index];
+		if (quote !== "\"" && quote !== "'") return INVALID_AUTHORING_ARGUMENT;
+		index += 1;
+		let result = "";
+		while (index < value.length) {
+			const character = value[index];
+			index += 1;
+			if (character === void 0) return INVALID_AUTHORING_ARGUMENT;
+			if (character === quote) return result;
+			if (character !== "\\") {
+				result += character;
+				continue;
+			}
+			const escaped = value[index];
+			index += 1;
+			if (escaped === void 0) return INVALID_AUTHORING_ARGUMENT;
+			switch (escaped) {
+				case "'":
+				case "\"":
+				case "\\":
+				case "/":
+					result += escaped;
+					break;
+				case "b":
+					result += "\b";
+					break;
+				case "f":
+					result += "\f";
+					break;
+				case "n":
+					result += "\n";
+					break;
+				case "r":
+					result += "\r";
+					break;
+				case "t":
+					result += "	";
+					break;
+				case "u": {
+					const hex = value.slice(index, index + 4);
+					if (!/^[0-9A-Fa-f]{4}$/.test(hex)) return INVALID_AUTHORING_ARGUMENT;
+					result += String.fromCharCode(Number.parseInt(hex, 16));
+					index += 4;
+					break;
+				}
+				default: return INVALID_AUTHORING_ARGUMENT;
+			}
+		}
+		return INVALID_AUTHORING_ARGUMENT;
+	}
+	function parseNumber() {
+		const raw = value.slice(index).match(/^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/)?.[0];
+		if (!raw) return INVALID_AUTHORING_ARGUMENT;
+		const parsed$1 = Number(raw);
+		if (!Number.isFinite(parsed$1)) return INVALID_AUTHORING_ARGUMENT;
+		index += raw.length;
+		return parsed$1;
+	}
+	function parseArray() {
+		if (value[index] !== "[") return INVALID_AUTHORING_ARGUMENT;
+		index += 1;
+		const result = [];
+		skipWhitespace();
+		if (value[index] === "]") {
+			index += 1;
+			return result;
+		}
+		while (index < value.length) {
+			const entry = parseValue();
+			if (entry === INVALID_AUTHORING_ARGUMENT) return INVALID_AUTHORING_ARGUMENT;
+			result.push(entry);
+			skipWhitespace();
+			if (value[index] === ",") {
+				index += 1;
+				skipWhitespace();
+				continue;
+			}
+			if (value[index] === "]") {
+				index += 1;
+				return result;
+			}
+			return INVALID_AUTHORING_ARGUMENT;
+		}
+		return INVALID_AUTHORING_ARGUMENT;
+	}
+	function parseObject() {
+		if (value[index] !== "{") return INVALID_AUTHORING_ARGUMENT;
+		index += 1;
+		const result = {};
+		skipWhitespace();
+		if (value[index] === "}") {
+			index += 1;
+			return result;
+		}
+		while (index < value.length) {
+			skipWhitespace();
+			const key = value[index] === "\"" || value[index] === "'" ? parseString() : parseIdentifier();
+			if (key === INVALID_AUTHORING_ARGUMENT) return INVALID_AUTHORING_ARGUMENT;
+			skipWhitespace();
+			if (value[index] !== ":") return INVALID_AUTHORING_ARGUMENT;
+			index += 1;
+			const entry = parseValue();
+			if (entry === INVALID_AUTHORING_ARGUMENT) return INVALID_AUTHORING_ARGUMENT;
+			result[key] = entry;
+			skipWhitespace();
+			if (value[index] === ",") {
+				index += 1;
+				skipWhitespace();
+				continue;
+			}
+			if (value[index] === "}") {
+				index += 1;
+				return result;
+			}
+			return INVALID_AUTHORING_ARGUMENT;
+		}
+		return INVALID_AUTHORING_ARGUMENT;
+	}
+	function parseValue() {
+		skipWhitespace();
+		const character = value[index];
+		if (character === "{") return parseObject();
+		if (character === "[") return parseArray();
+		if (character === "\"" || character === "'") return parseString();
+		if (character === "-" || /\d/.test(character ?? "")) return parseNumber();
+		const identifier = parseIdentifier();
+		if (identifier === INVALID_AUTHORING_ARGUMENT) return INVALID_AUTHORING_ARGUMENT;
+		if (identifier === "true") return true;
+		if (identifier === "false") return false;
+		if (identifier === "null") return null;
+		return INVALID_AUTHORING_ARGUMENT;
+	}
+	skipWhitespace();
+	const parsed = parseValue();
+	if (parsed === INVALID_AUTHORING_ARGUMENT) return parsed;
+	skipWhitespace();
+	return index === value.length ? parsed : INVALID_AUTHORING_ARGUMENT;
+}
+function parseStringArrayLiteral(value) {
+	const parsed = parseJsLikeLiteral(value);
+	if (parsed === INVALID_AUTHORING_ARGUMENT || !Array.isArray(parsed)) return INVALID_AUTHORING_ARGUMENT;
+	if (!parsed.every((item) => typeof item === "string")) return INVALID_AUTHORING_ARGUMENT;
+	return parsed;
+}
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parsePslObjectLiteral(value) {
+	const trimmed = value.trim();
+	if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) return INVALID_AUTHORING_ARGUMENT;
+	let parsed;
+	try {
+		parsed = JSON.parse(trimmed);
+	} catch {
+		parsed = parseJsLikeLiteral(trimmed);
+		if (parsed === INVALID_AUTHORING_ARGUMENT) return INVALID_AUTHORING_ARGUMENT;
+	}
+	if (!isPlainObject(parsed)) return INVALID_AUTHORING_ARGUMENT;
+	return parsed;
+}
+function parsePslAuthoringArgumentValue(descriptor, rawValue) {
+	switch (descriptor.kind) {
+		case "string": return unquoteStringLiteral(rawValue);
+		case "number": {
+			const parsed = Number(unquoteStringLiteral(rawValue));
+			return Number.isNaN(parsed) ? INVALID_AUTHORING_ARGUMENT : parsed;
+		}
+		case "stringArray": return parseStringArrayLiteral(rawValue);
+		case "object": return parsePslObjectLiteral(rawValue);
+		default: return INVALID_AUTHORING_ARGUMENT;
+	}
+}
+function pushInvalidPslHelperArgument(input) {
+	input.diagnostics.push({
+		code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+		message: `${input.entityLabel} ${input.helperLabel} ${input.message}`,
+		sourceId: input.sourceId,
+		span: input.span
+	});
+}
+function mapPslHelperArgs(input) {
+	const mappedArgs = input.descriptors.map(() => void 0);
+	const positionalArgs = input.args.filter((arg) => arg.kind === "positional");
+	const namedArgs = input.args.filter((arg) => arg.kind === "named");
+	if (positionalArgs.length > input.descriptors.length) return pushInvalidPslHelperArgument({
+		diagnostics: input.diagnostics,
+		sourceId: input.sourceId,
+		span: input.span,
+		entityLabel: input.entityLabel,
+		helperLabel: input.helperLabel,
+		message: `accepts at most ${input.descriptors.length} argument(s), received ${positionalArgs.length}.`
+	});
+	for (const [index, argument] of positionalArgs.entries()) {
+		const descriptor = input.descriptors[index];
+		if (!descriptor) return pushInvalidPslHelperArgument({
+			diagnostics: input.diagnostics,
+			sourceId: input.sourceId,
+			span: argument.span,
+			entityLabel: input.entityLabel,
+			helperLabel: input.helperLabel,
+			message: `does not define positional argument #${index + 1}.`
+		});
+		const value = parsePslAuthoringArgumentValue(descriptor, argument.value);
+		if (value === INVALID_AUTHORING_ARGUMENT) return pushInvalidPslHelperArgument({
+			diagnostics: input.diagnostics,
+			sourceId: input.sourceId,
+			span: argument.span,
+			entityLabel: input.entityLabel,
+			helperLabel: input.helperLabel,
+			message: `cannot parse argument #${index + 1} for descriptor kind "${descriptor.kind}".`
+		});
+		mappedArgs[index] = value;
+	}
+	for (const argument of namedArgs) {
+		const descriptorIndex = input.descriptors.findIndex((descriptor$1) => descriptor$1.name === argument.name);
+		if (descriptorIndex < 0) return pushInvalidPslHelperArgument({
+			diagnostics: input.diagnostics,
+			sourceId: input.sourceId,
+			span: argument.span,
+			entityLabel: input.entityLabel,
+			helperLabel: input.helperLabel,
+			message: `received unknown named argument "${argument.name}".`
+		});
+		if (mappedArgs[descriptorIndex] !== void 0) return pushInvalidPslHelperArgument({
+			diagnostics: input.diagnostics,
+			sourceId: input.sourceId,
+			span: argument.span,
+			entityLabel: input.entityLabel,
+			helperLabel: input.helperLabel,
+			message: `received duplicate value for argument "${argument.name}".`
+		});
+		const descriptor = input.descriptors[descriptorIndex];
+		if (!descriptor) return pushInvalidPslHelperArgument({
+			diagnostics: input.diagnostics,
+			sourceId: input.sourceId,
+			span: argument.span,
+			entityLabel: input.entityLabel,
+			helperLabel: input.helperLabel,
+			message: `does not define named argument "${argument.name}".`
+		});
+		const value = parsePslAuthoringArgumentValue(descriptor, argument.value);
+		if (value === INVALID_AUTHORING_ARGUMENT) return pushInvalidPslHelperArgument({
+			diagnostics: input.diagnostics,
+			sourceId: input.sourceId,
+			span: argument.span,
+			entityLabel: input.entityLabel,
+			helperLabel: input.helperLabel,
+			message: `cannot parse named argument "${argument.name}" for descriptor kind "${descriptor.kind}".`
+		});
+		mappedArgs[descriptorIndex] = value;
+	}
+	return mappedArgs;
+}
+
 //#endregion
 //#region src/psl-column-resolution.ts
 function toNamedTypeFieldDescriptor(typeRef, descriptor) {
@@ -341,6 +619,147 @@ function getAuthoringTypeConstructor(contributions, path) {
 	}
 	return isAuthoringTypeConstructorDescriptor(current) ? current : void 0;
 }
+/**
+* Returns the namespace prefix of `attributeName` if it references an
+* unrecognized extension namespace, otherwise `undefined`. A namespace is
+* considered recognized when it is:
+*
+* - `db` (native-type spec, always allowed),
+* - the active family id (e.g. `sql`),
+* - the active target id (e.g. `postgres`),
+* - present in `composedExtensions`.
+*
+* Family/target namespaces are exempted so that e.g. `@sql.foo` surfaces as
+* PSL_UNSUPPORTED_*_ATTRIBUTE (the attribute isn't defined) rather than
+* PSL_EXTENSION_NAMESPACE_NOT_COMPOSED (the namespace is already composed).
+*/
+function checkUncomposedNamespace(attributeName, composedExtensions, context) {
+	const dotIndex = attributeName.indexOf(".");
+	if (dotIndex <= 0 || dotIndex === attributeName.length - 1) return;
+	const namespace = attributeName.slice(0, dotIndex);
+	if (namespace === "db" || namespace === context?.familyId || namespace === context?.targetId || composedExtensions.has(namespace)) return;
+	return namespace;
+}
+/**
+* Pushes the canonical `PSL_EXTENSION_NAMESPACE_NOT_COMPOSED` diagnostic for a
+* subject (attribute, model attribute, or type constructor) that references an
+* extension namespace which is not composed in the current contract.
+*
+* The `data` payload carries the missing namespace so machine consumers
+* (agents, IDE extensions, CLI auto-fix) don't have to parse the prose.
+*/
+function reportUncomposedNamespace(input) {
+	input.diagnostics.push({
+		code: "PSL_EXTENSION_NAMESPACE_NOT_COMPOSED",
+		message: `${input.subjectLabel} uses unrecognized namespace "${input.namespace}". Add extension pack "${input.namespace}" to extensionPacks in prisma-next.config.ts.`,
+		sourceId: input.sourceId,
+		span: input.span,
+		data: {
+			namespace: input.namespace,
+			suggestedPack: input.namespace
+		}
+	});
+}
+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,
+		sourceId: input.sourceId,
+		entityLabel: input.entityLabel
+	});
+	if (!args) return;
+	try {
+		validateAuthoringHelperArguments(helperPath, input.descriptor.args, args);
+		return instantiateAuthoringTypeConstructor(input.descriptor, args);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		input.diagnostics.push({
+			code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+			message: `${input.entityLabel} constructor "${helperPath}" ${message}`,
+			sourceId: input.sourceId,
+			span: input.call.span
+		});
+		return;
+	}
+}
+function pushUnsupportedTypeConstructorDiagnostic(input) {
+	input.diagnostics.push({
+		code: input.code,
+		message: input.message,
+		sourceId: input.sourceId,
+		span: input.span
+	});
+}
+function resolvePslTypeConstructorDescriptor(input) {
+	const descriptor = getAuthoringTypeConstructor(input.authoringContributions, input.call.path);
+	if (descriptor) return descriptor;
+	const namespace = input.call.path.length > 1 ? input.call.path[0] : void 0;
+	if (namespace && namespace !== "db" && namespace !== input.familyId && namespace !== input.targetId && !input.composedExtensions.has(namespace)) {
+		reportUncomposedNamespace({
+			subjectLabel: `Type constructor "${input.call.path.join(".")}"`,
+			namespace,
+			sourceId: input.sourceId,
+			span: input.call.span,
+			diagnostics: input.diagnostics
+		});
+		return;
+	}
+	return pushUnsupportedTypeConstructorDiagnostic({
+		diagnostics: input.diagnostics,
+		sourceId: input.sourceId,
+		span: input.call.span,
+		code: input.unsupportedCode,
+		message: input.unsupportedMessage
+	});
+}
+function resolveFieldTypeDescriptor(input) {
+	if (input.field.typeConstructor) {
+		const helperPath = input.field.typeConstructor.path.join(".");
+		const descriptor$1 = resolvePslTypeConstructorDescriptor({
+			call: input.field.typeConstructor,
+			authoringContributions: input.authoringContributions,
+			composedExtensions: input.composedExtensions,
+			familyId: input.familyId,
+			targetId: input.targetId,
+			diagnostics: input.diagnostics,
+			sourceId: input.sourceId,
+			unsupportedCode: "PSL_UNSUPPORTED_FIELD_TYPE",
+			unsupportedMessage: `${input.entityLabel} type constructor "${helperPath}" is not supported in SQL PSL provider v1`
+		});
+		if (!descriptor$1) return {
+			ok: false,
+			alreadyReported: true
+		};
+		const instantiated = instantiatePslTypeConstructor({
+			call: input.field.typeConstructor,
+			descriptor: descriptor$1,
+			diagnostics: input.diagnostics,
+			sourceId: input.sourceId,
+			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.scalarTypeDescriptors);
+	if (!descriptor) return {
+		ok: false,
+		alreadyReported: false
+	};
+	return {
+		ok: true,
+		descriptor
+	};
+}
 const NATIVE_TYPE_SPECS = {
 	"db.VarChar": {
 		args: "optionalLength",
@@ -492,32 +911,6 @@ function resolveDbNativeTypeAttribute(input) {
 		}
 	}
 }
-function parsePgvectorLength(input) {
-	const namedLength = getNamedArgument(input.attribute, "length");
-	const namedDim = getNamedArgument(input.attribute, "dim");
-	const positional = getPositionalArgument(input.attribute);
-	const raw = namedLength ?? namedDim ?? positional;
-	if (!raw) {
-		input.diagnostics.push({
-			code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
-			message: "@pgvector.column requires length/dim argument",
-			sourceId: input.sourceId,
-			span: input.attribute.span
-		});
-		return;
-	}
-	const parsed = Number(unquoteStringLiteral(raw));
-	if (!Number.isInteger(parsed) || parsed < 1) {
-		input.diagnostics.push({
-			code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
-			message: "@pgvector.column length/dim must be a positive integer",
-			sourceId: input.sourceId,
-			span: input.attribute.span
-		});
-		return;
-	}
-	return parsed;
-}
 function parseDefaultLiteralValue(expression) {
 	const trimmed = expression.trim();
 	if (trimmed === "true" || trimmed === "false") return {
@@ -612,49 +1005,99 @@ function resolveColumnDescriptor(field, enumTypeDescriptors, namedTypeDescriptor
 
 //#endregion
 //#region src/psl-field-resolution.ts
-function collectResolvedFields(model, mapping, enumTypeDescriptors, namedTypeDescriptors, namedTypeBaseTypes, modelNames, compositeTypeNames, composedExtensions, authoringContributions, defaultFunctionRegistry, generatorDescriptorById, diagnostics, sourceId, scalarTypeDescriptors) {
+const BUILTIN_FIELD_ATTRIBUTE_NAMES = new Set([
+	"id",
+	"unique",
+	"default",
+	"relation",
+	"map"
+]);
+function validateFieldAttributes(input) {
+	for (const attribute of input.field.attributes) {
+		if (BUILTIN_FIELD_ATTRIBUTE_NAMES.has(attribute.name)) continue;
+		const uncomposedNamespace = checkUncomposedNamespace(attribute.name, input.composedExtensions, {
+			familyId: input.familyId,
+			targetId: input.targetId
+		});
+		if (uncomposedNamespace) {
+			reportUncomposedNamespace({
+				subjectLabel: `Attribute "@${attribute.name}"`,
+				namespace: uncomposedNamespace,
+				sourceId: input.sourceId,
+				span: attribute.span,
+				diagnostics: input.diagnostics
+			});
+			continue;
+		}
+		input.diagnostics.push({
+			code: "PSL_UNSUPPORTED_FIELD_ATTRIBUTE",
+			message: `Field "${input.model.name}.${input.field.name}" uses unsupported attribute "@${attribute.name}"`,
+			sourceId: input.sourceId,
+			span: attribute.span
+		});
+	}
+}
+function extractFieldConstraintNames(input) {
+	const idAttribute = getAttribute(input.field.attributes, "id");
+	const uniqueAttribute = getAttribute(input.field.attributes, "unique");
+	return {
+		idAttribute,
+		uniqueAttribute,
+		idName: parseConstraintMapArgument({
+			attribute: idAttribute,
+			sourceId: input.sourceId,
+			diagnostics: input.diagnostics,
+			entityLabel: `Field "${input.model.name}.${input.field.name}" @id`,
+			span: input.field.span,
+			code: "PSL_INVALID_ATTRIBUTE_ARGUMENT"
+		}),
+		uniqueName: parseConstraintMapArgument({
+			attribute: uniqueAttribute,
+			sourceId: input.sourceId,
+			diagnostics: input.diagnostics,
+			entityLabel: `Field "${input.model.name}.${input.field.name}" @unique`,
+			span: input.field.span,
+			code: "PSL_INVALID_ATTRIBUTE_ARGUMENT"
+		})
+	};
+}
+function collectResolvedFields(input) {
+	const { model, mapping, enumTypeDescriptors, namedTypeDescriptors, modelNames, compositeTypeNames, composedExtensions, authoringContributions, familyId, targetId, defaultFunctionRegistry, generatorDescriptorById, diagnostics, sourceId, scalarTypeDescriptors } = input;
 	const resolvedFields = [];
-	const pgvectorVectorConstructor = getAuthoringTypeConstructor(authoringContributions, ["pgvector", "vector"]);
 	for (const field of model.fields) {
 		if (field.list && modelNames.has(field.typeName)) continue;
-		for (const attribute of field.attributes) {
-			if (attribute.name === "id" || attribute.name === "unique" || attribute.name === "default" || attribute.name === "relation" || attribute.name === "map" || attribute.name === "pgvector.column") continue;
-			if (attribute.name.startsWith("pgvector.") && !composedExtensions.has("pgvector")) {
-				diagnostics.push({
-					code: "PSL_EXTENSION_NAMESPACE_NOT_COMPOSED",
-					message: `Attribute "@${attribute.name}" uses unrecognized namespace "pgvector". Add extension pack "pgvector" to extensionPacks in prisma-next.config.ts.`,
-					sourceId,
-					span: attribute.span
-				});
-				continue;
-			}
-			diagnostics.push({
-				code: "PSL_UNSUPPORTED_FIELD_ATTRIBUTE",
-				message: `Field "${model.name}.${field.name}" uses unsupported attribute "@${attribute.name}"`,
-				sourceId,
-				span: attribute.span
-			});
-		}
+		validateFieldAttributes({
+			model,
+			field,
+			composedExtensions,
+			diagnostics,
+			sourceId,
+			familyId,
+			targetId
+		});
 		if (getAttribute(field.attributes, "relation") && modelNames.has(field.typeName)) continue;
 		const isValueObjectField = compositeTypeNames.has(field.typeName);
 		const isListField = field.list;
-		const pgvectorOnJsonField = getAttribute(field.attributes, "pgvector.column");
-		if (pgvectorOnJsonField && (isValueObjectField || isListField)) {
-			diagnostics.push({
-				code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
-				message: `Field "${model.name}.${field.name}" uses @pgvector.column on a JSON-backed field (${isValueObjectField ? "value object" : "list"}). @pgvector.column is only supported on scalar Bytes fields.`,
-				sourceId,
-				span: pgvectorOnJsonField.span
-			});
-			continue;
-		}
 		let descriptor;
 		let scalarCodecId;
+		const resolveInput = {
+			field,
+			enumTypeDescriptors,
+			namedTypeDescriptors,
+			scalarTypeDescriptors,
+			authoringContributions,
+			composedExtensions,
+			familyId,
+			targetId,
+			diagnostics,
+			sourceId,
+			entityLabel: `Field "${model.name}.${field.name}"`
+		};
 		if (isValueObjectField) descriptor = scalarTypeDescriptors.get("Json");
 		else if (isListField) {
-			const originalDescriptor = resolveColumnDescriptor(field, enumTypeDescriptors, namedTypeDescriptors, scalarTypeDescriptors);
-			if (!originalDescriptor) {
-				diagnostics.push({
+			const resolved = resolveFieldTypeDescriptor(resolveInput);
+			if (!resolved.ok) {
+				if (!resolved.alreadyReported) diagnostics.push({
 					code: "PSL_UNSUPPORTED_FIELD_TYPE",
 					message: `Field "${model.name}.${field.name}" type "${field.typeName}" is not supported in SQL PSL provider v1`,
 					sourceId,
@@ -662,45 +1105,22 @@ function collectResolvedFields(model, mapping, enumTypeDescriptors, namedTypeDes
 				});
 				continue;
 			}
-			scalarCodecId = originalDescriptor.codecId;
+			scalarCodecId = resolved.descriptor.codecId;
 			descriptor = scalarTypeDescriptors.get("Json");
 		} else {
-			descriptor = resolveColumnDescriptor(field, enumTypeDescriptors, namedTypeDescriptors, scalarTypeDescriptors);
-			const pgvectorColumnAttribute = getAttribute(field.attributes, "pgvector.column");
-			if (pgvectorColumnAttribute) if (!composedExtensions.has("pgvector")) diagnostics.push({
-				code: "PSL_EXTENSION_NAMESPACE_NOT_COMPOSED",
-				message: "Attribute \"@pgvector.column\" uses unrecognized namespace \"pgvector\". Add extension pack \"pgvector\" to extensionPacks in prisma-next.config.ts.",
-				sourceId,
-				span: pgvectorColumnAttribute.span
-			});
-			else if (!(field.typeName === "Bytes" || namedTypeBaseTypes.get(field.typeRef ?? field.typeName) === "Bytes")) diagnostics.push({
-				code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
-				message: `Field "${model.name}.${field.name}" uses @pgvector.column on unsupported base type "${field.typeName}"`,
-				sourceId,
-				span: pgvectorColumnAttribute.span
-			});
-			else {
-				const length = parsePgvectorLength({
-					attribute: pgvectorColumnAttribute,
-					diagnostics,
-					sourceId
+			const resolved = resolveFieldTypeDescriptor(resolveInput);
+			if (!resolved.ok) {
+				if (!resolved.alreadyReported) diagnostics.push({
+					code: "PSL_UNSUPPORTED_FIELD_TYPE",
+					message: `Field "${model.name}.${field.name}" type "${field.typeName}" is not supported in SQL PSL provider v1`,
+					sourceId,
+					span: field.span
 				});
-				if (length !== void 0) descriptor = pgvectorVectorConstructor ? instantiateAuthoringTypeConstructor(pgvectorVectorConstructor, [length]) : {
-					codecId: "pg/vector@1",
-					nativeType: "vector",
-					typeParams: { length }
-				};
+				continue;
 			}
+			descriptor = resolved.descriptor;
 		}
-		if (!descriptor) {
-			diagnostics.push({
-				code: "PSL_UNSUPPORTED_FIELD_TYPE",
-				message: `Field "${model.name}.${field.name}" type "${field.typeName}" is not supported in SQL PSL provider v1`,
-				sourceId,
-				span: field.span
-			});
-			continue;
-		}
+		if (!descriptor) continue;
 		const defaultAttribute = getAttribute(field.attributes, "default");
 		const loweredDefault = defaultAttribute ? lowerDefaultForField({
 			modelName: model.name,
@@ -727,23 +1147,11 @@ function collectResolvedFields(model, mapping, enumTypeDescriptors, namedTypeDes
 			if (generatedDescriptor) descriptor = generatedDescriptor;
 		}
 		const mappedColumnName = mapping.fieldColumns.get(field.name) ?? field.name;
-		const idAttribute = getAttribute(field.attributes, "id");
-		const uniqueAttribute = getAttribute(field.attributes, "unique");
-		const idName = parseConstraintMapArgument({
-			attribute: idAttribute,
-			sourceId,
-			diagnostics,
-			entityLabel: `Field "${model.name}.${field.name}" @id`,
-			span: field.span,
-			code: "PSL_INVALID_ATTRIBUTE_ARGUMENT"
-		});
-		const uniqueName = parseConstraintMapArgument({
-			attribute: uniqueAttribute,
+		const { idAttribute, uniqueAttribute, idName, uniqueName } = extractFieldConstraintNames({
+			model,
+			field,
 			sourceId,
-			diagnostics,
-			entityLabel: `Field "${model.name}.${field.name}" @unique`,
-			span: field.span,
-			code: "PSL_INVALID_ATTRIBUTE_ARGUMENT"
+			diagnostics
 		});
 		resolvedFields.push({
 			field,
@@ -1008,12 +1416,17 @@ function validateNavigationListFieldAttributes(input) {
 	let valid = true;
 	for (const attribute of input.field.attributes) {
 		if (attribute.name === "relation") continue;
-		if (attribute.name.startsWith("pgvector.") && !input.composedExtensions.has("pgvector")) {
-			input.diagnostics.push({
-				code: "PSL_EXTENSION_NAMESPACE_NOT_COMPOSED",
-				message: `Attribute "@${attribute.name}" uses unrecognized namespace "pgvector". Add extension pack "pgvector" to extensionPacks in prisma-next.config.ts.`,
+		const uncomposedNamespace = checkUncomposedNamespace(attribute.name, input.composedExtensions, {
+			familyId: input.familyId,
+			targetId: input.targetId
+		});
+		if (uncomposedNamespace) {
+			reportUncomposedNamespace({
+				subjectLabel: `Attribute "@${attribute.name}"`,
+				namespace: uncomposedNamespace,
 				sourceId: input.sourceId,
-				span: attribute.span
+				span: attribute.span,
+				diagnostics: input.diagnostics
 			});
 			valid = false;
 			continue;
@@ -1042,8 +1455,18 @@ function buildComposedExtensionPackRefs(target, extensionIds, extensionPackRefs
 		version: "0.0.1"
 	}]));
 }
-function hasSameSpan(a, b) {
-	return a.start.offset === b.start.offset && a.end.offset === b.end.offset && a.start.line === b.start.line && a.end.line === b.end.line;
+function diagnosticDedupKey(diagnostic) {
+	const span = diagnostic.span;
+	const spanKey = span ? `${span.start.offset}:${span.end.offset}:${span.start.line}:${span.end.line}` : "";
+	return `${diagnostic.code}\u0000${diagnostic.sourceId}\u0000${spanKey}\u0000${diagnostic.message}`;
+}
+function dedupeDiagnostics(diagnostics) {
+	const seen = /* @__PURE__ */ new Map();
+	for (const diagnostic of diagnostics) {
+		const key = diagnosticDedupKey(diagnostic);
+		if (!seen.has(key)) seen.set(key, diagnostic);
+	}
+	return [...seen.values()];
 }
 function compareStrings(left, right) {
 	if (left < right) return -1;
@@ -1092,85 +1515,126 @@ function processEnumDeclarations(input) {
 		enumTypeDescriptors
 	};
 }
+function validateNamedTypeAttributes(input) {
+	const [dbNativeTypeAttribute, ...extraDbNativeTypeAttributes] = input.allowDbNativeType ? input.declaration.attributes.filter((attribute) => attribute.name.startsWith("db.")) : [];
+	let hasUnsupportedNamedTypeAttribute = false;
+	for (const extra of extraDbNativeTypeAttributes) {
+		input.diagnostics.push({
+			code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+			message: `Named type "${input.declaration.name}" can declare at most one @db.* attribute`,
+			sourceId: input.sourceId,
+			span: extra.span
+		});
+		hasUnsupportedNamedTypeAttribute = true;
+	}
+	for (const attribute of input.declaration.attributes) {
+		if (input.allowDbNativeType && attribute.name.startsWith("db.")) continue;
+		const uncomposedNamespace = checkUncomposedNamespace(attribute.name, input.composedExtensions, {
+			familyId: input.familyId,
+			targetId: input.targetId
+		});
+		if (uncomposedNamespace) {
+			reportUncomposedNamespace({
+				subjectLabel: `Attribute "@${attribute.name}"`,
+				namespace: uncomposedNamespace,
+				sourceId: input.sourceId,
+				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}"`,
+			sourceId: input.sourceId,
+			span: attribute.span
+		});
+		hasUnsupportedNamedTypeAttribute = true;
+	}
+	return {
+		dbNativeTypeAttribute,
+		hasUnsupportedNamedTypeAttribute
+	};
+}
 function resolveNamedTypeDeclarations(input) {
 	const storageTypes = {};
 	const namedTypeDescriptors = /* @__PURE__ */ new Map();
-	const namedTypeBaseTypes = /* @__PURE__ */ new Map();
 	for (const declaration of input.declarations) {
-		const baseDescriptor = input.enumTypeDescriptors.get(declaration.baseType) ?? input.scalarTypeDescriptors.get(declaration.baseType);
-		if (!baseDescriptor) {
-			input.diagnostics.push({
-				code: "PSL_UNSUPPORTED_NAMED_TYPE_BASE",
-				message: `Named type "${declaration.name}" references unsupported base type "${declaration.baseType}"`,
+		if (declaration.typeConstructor) {
+			const { hasUnsupportedNamedTypeAttribute: hasUnsupportedNamedTypeAttribute$1 } = validateNamedTypeAttributes({
+				declaration,
 				sourceId: input.sourceId,
-				span: declaration.span
+				diagnostics: input.diagnostics,
+				composedExtensions: input.composedExtensions,
+				allowDbNativeType: false,
+				familyId: input.familyId,
+				targetId: input.targetId
 			});
-			continue;
-		}
-		namedTypeBaseTypes.set(declaration.name, declaration.baseType);
-		const pgvectorAttribute = getAttribute(declaration.attributes, "pgvector.column");
-		const dbNativeTypeAttribute = declaration.attributes.find((attribute) => attribute.name.startsWith("db."));
-		const unsupportedNamedTypeAttribute = declaration.attributes.find((attribute) => attribute.name !== "pgvector.column" && !attribute.name.startsWith("db."));
-		if (unsupportedNamedTypeAttribute) {
-			input.diagnostics.push({
-				code: "PSL_UNSUPPORTED_NAMED_TYPE_ATTRIBUTE",
-				message: `Named type "${declaration.name}" uses unsupported attribute "${unsupportedNamedTypeAttribute.name}"`,
+			if (hasUnsupportedNamedTypeAttribute$1) continue;
+			const helperPath = declaration.typeConstructor.path.join(".");
+			const typeConstructor = resolvePslTypeConstructorDescriptor({
+				call: declaration.typeConstructor,
+				authoringContributions: input.authoringContributions,
+				composedExtensions: input.composedExtensions,
+				familyId: input.familyId,
+				targetId: input.targetId,
+				diagnostics: input.diagnostics,
+				sourceId: input.sourceId,
+				unsupportedCode: "PSL_UNSUPPORTED_NAMED_TYPE_CONSTRUCTOR",
+				unsupportedMessage: `Named type "${declaration.name}" references unsupported constructor "${helperPath}"`
+			});
+			if (!typeConstructor) continue;
+			const storageType = instantiatePslTypeConstructor({
+				call: declaration.typeConstructor,
+				descriptor: typeConstructor,
+				diagnostics: input.diagnostics,
 				sourceId: input.sourceId,
-				span: unsupportedNamedTypeAttribute.span
+				entityLabel: `Named type "${declaration.name}"`
 			});
+			if (!storageType) continue;
+			namedTypeDescriptors.set(declaration.name, toNamedTypeFieldDescriptor(declaration.name, storageType));
+			storageTypes[declaration.name] = {
+				codecId: storageType.codecId,
+				nativeType: storageType.nativeType,
+				typeParams: storageType.typeParams ?? {}
+			};
 			continue;
 		}
-		if (pgvectorAttribute && dbNativeTypeAttribute) {
+		if (declaration.baseType === void 0) {
 			input.diagnostics.push({
-				code: "PSL_UNSUPPORTED_NAMED_TYPE_ATTRIBUTE",
-				message: `Named type "${declaration.name}" cannot combine @pgvector.column with @${dbNativeTypeAttribute.name}.`,
+				code: "PSL_UNSUPPORTED_NAMED_TYPE_BASE",
+				message: `Named type "${declaration.name}" must declare a base type or constructor`,
 				sourceId: input.sourceId,
-				span: dbNativeTypeAttribute.span
+				span: declaration.span
 			});
 			continue;
 		}
-		if (pgvectorAttribute) {
-			if (!input.composedExtensions.has("pgvector")) {
-				input.diagnostics.push({
-					code: "PSL_EXTENSION_NAMESPACE_NOT_COMPOSED",
-					message: "Attribute \"@pgvector.column\" uses unrecognized namespace \"pgvector\". Add extension pack \"pgvector\" to extensionPacks in prisma-next.config.ts.",
-					sourceId: input.sourceId,
-					span: pgvectorAttribute.span
-				});
-				continue;
-			}
-			if (declaration.baseType !== "Bytes") {
-				input.diagnostics.push({
-					code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
-					message: `Named type "${declaration.name}" uses @pgvector.column on unsupported base type "${declaration.baseType}"`,
-					sourceId: input.sourceId,
-					span: pgvectorAttribute.span
-				});
-				continue;
-			}
-			const length = parsePgvectorLength({
-				attribute: pgvectorAttribute,
-				diagnostics: input.diagnostics,
-				sourceId: input.sourceId
+		const { baseType } = declaration;
+		const baseDescriptor = input.enumTypeDescriptors.get(baseType) ?? input.scalarTypeDescriptors.get(baseType);
+		if (!baseDescriptor) {
+			input.diagnostics.push({
+				code: "PSL_UNSUPPORTED_NAMED_TYPE_BASE",
+				message: `Named type "${declaration.name}" references unsupported base type "${baseType}"`,
+				sourceId: input.sourceId,
+				span: declaration.span
 			});
-			if (length === void 0) continue;
-			const pgvectorStorageType = input.pgvectorVectorConstructor ? instantiateAuthoringTypeConstructor(input.pgvectorVectorConstructor, [length]) : {
-				codecId: "pg/vector@1",
-				nativeType: "vector",
-				typeParams: { length }
-			};
-			namedTypeDescriptors.set(declaration.name, toNamedTypeFieldDescriptor(declaration.name, pgvectorStorageType));
-			storageTypes[declaration.name] = {
-				codecId: pgvectorStorageType.codecId,
-				nativeType: pgvectorStorageType.nativeType,
-				typeParams: pgvectorStorageType.typeParams ?? { length }
-			};
 			continue;
 		}
+		const { dbNativeTypeAttribute, hasUnsupportedNamedTypeAttribute } = validateNamedTypeAttributes({
+			declaration,
+			sourceId: input.sourceId,
+			diagnostics: input.diagnostics,
+			composedExtensions: input.composedExtensions,
+			allowDbNativeType: true,
+			familyId: input.familyId,
+			targetId: input.targetId
+		});
+		if (hasUnsupportedNamedTypeAttribute) continue;
 		if (dbNativeTypeAttribute) {
 			const descriptor$1 = resolveDbNativeTypeAttribute({
 				attribute: dbNativeTypeAttribute,
-				baseType: declaration.baseType,
+				baseType,
 				baseDescriptor,
 				diagnostics: input.diagnostics,
 				sourceId: input.sourceId,
@@ -1195,14 +1659,29 @@ function resolveNamedTypeDeclarations(input) {
 	}
 	return {
 		storageTypes,
-		namedTypeDescriptors,
-		namedTypeBaseTypes
+		namedTypeDescriptors
 	};
 }
 function buildModelNodeFromPsl(input) {
 	const { model, mapping, sourceId, diagnostics } = input;
 	const tableName = mapping.tableName;
-	const resolvedFields = collectResolvedFields(model, mapping, input.enumTypeDescriptors, input.namedTypeDescriptors, input.namedTypeBaseTypes, input.modelNames, input.compositeTypeNames, input.composedExtensions, input.authoringContributions, input.defaultFunctionRegistry, input.generatorDescriptorById, diagnostics, sourceId, input.scalarTypeDescriptors);
+	const resolvedFields = collectResolvedFields({
+		model,
+		mapping,
+		enumTypeDescriptors: input.enumTypeDescriptors,
+		namedTypeDescriptors: input.namedTypeDescriptors,
+		modelNames: input.modelNames,
+		compositeTypeNames: input.compositeTypeNames,
+		composedExtensions: input.composedExtensions,
+		authoringContributions: input.authoringContributions,
+		familyId: input.familyId,
+		targetId: input.targetId,
+		defaultFunctionRegistry: input.defaultFunctionRegistry,
+		generatorDescriptorById: input.generatorDescriptorById,
+		diagnostics,
+		sourceId,
+		scalarTypeDescriptors: input.scalarTypeDescriptors
+	});
 	const primaryKeyFields = resolvedFields.filter((field) => field.isId);
 	const primaryKeyColumns = primaryKeyFields.map((field) => field.columnName);
 	const primaryKeyName = primaryKeyFields.length === 1 ? primaryKeyFields[0]?.idName : void 0;
@@ -1221,7 +1700,9 @@ function buildModelNodeFromPsl(input) {
 			field,
 			sourceId,
 			composedExtensions: input.composedExtensions,
-			diagnostics
+			diagnostics,
+			familyId: input.familyId,
+			targetId: input.targetId
 		});
 		const relationAttribute = getAttribute(field.attributes, "relation");
 		let relationName;
@@ -1313,12 +1794,17 @@ function buildModelNodeFromPsl(input) {
 			});
 			continue;
 		}
-		if (modelAttribute.name.startsWith("pgvector.") && !input.composedExtensions.has("pgvector")) {
-			diagnostics.push({
-				code: "PSL_EXTENSION_NAMESPACE_NOT_COMPOSED",
-				message: `Attribute "@@${modelAttribute.name}" uses unrecognized namespace "pgvector". Add extension pack "pgvector" to extensionPacks in prisma-next.config.ts.`,
+		const uncomposedNamespace = checkUncomposedNamespace(modelAttribute.name, input.composedExtensions, {
+			familyId: input.familyId,
+			targetId: input.targetId
+		});
+		if (uncomposedNamespace) {
+			reportUncomposedNamespace({
+				subjectLabel: `Attribute "@@${modelAttribute.name}"`,
+				namespace: uncomposedNamespace,
 				sourceId,
-				span: modelAttribute.span
+				span: modelAttribute.span,
+				diagnostics
 			});
 			continue;
 		}
@@ -1462,7 +1948,8 @@ function buildModelNodeFromPsl(input) {
 		resolvedFields
 	};
 }
-function buildValueObjects(compositeTypes, enumTypeDescriptors, namedTypeDescriptors, scalarTypeDescriptors, diagnostics, sourceId) {
+function buildValueObjects(input) {
+	const { compositeTypes, enumTypeDescriptors, namedTypeDescriptors, scalarTypeDescriptors, composedExtensions, familyId, targetId, authoringContributions, diagnostics, sourceId } = input;
 	const valueObjects = {};
 	const compositeTypeNames = new Set(compositeTypes.map((ct) => ct.name));
 	for (const compositeType of compositeTypes) {
@@ -1482,9 +1969,21 @@ function buildValueObjects(compositeTypes, enumTypeDescriptors, namedTypeDescrip
 				} : result;
 				continue;
 			}
-			const descriptor = resolveColumnDescriptor(field, enumTypeDescriptors, namedTypeDescriptors, scalarTypeDescriptors);
-			if (!descriptor) {
-				diagnostics.push({
+			const resolved = resolveFieldTypeDescriptor({
+				field,
+				enumTypeDescriptors,
+				namedTypeDescriptors,
+				scalarTypeDescriptors,
+				authoringContributions,
+				composedExtensions,
+				familyId,
+				targetId,
+				diagnostics,
+				sourceId,
+				entityLabel: `Field "${compositeType.name}.${field.name}"`
+			});
+			if (!resolved.ok) {
+				if (!resolved.alreadyReported) diagnostics.push({
 					code: "PSL_UNSUPPORTED_FIELD_TYPE",
 					message: `Field "${compositeType.name}.${field.name}" type "${field.typeName}" is not supported`,
 					sourceId,
@@ -1492,13 +1991,17 @@ function buildValueObjects(compositeTypes, enumTypeDescriptors, namedTypeDescrip
 				});
 				continue;
 			}
-			fields[field.name] = {
+			const scalarField = {
 				nullable: field.optional,
 				type: {
 					kind: "scalar",
-					codecId: descriptor.codecId
+					codecId: resolved.descriptor.codecId
 				}
 			};
+			fields[field.name] = field.list ? {
+				...scalarField,
+				many: true
+			} : scalarField;
 		}
 		valueObjects[compositeType.name] = { fields };
 	}
@@ -1744,7 +2247,9 @@ function interpretPslDocumentToSqlContract(input) {
 		enumTypeDescriptors: enumResult.enumTypeDescriptors,
 		scalarTypeDescriptors: input.scalarTypeDescriptors,
 		composedExtensions,
-		pgvectorVectorConstructor: getAuthoringTypeConstructor(input.authoringContributions, ["pgvector", "vector"]),
+		familyId: input.target.familyId,
+		targetId: input.target.targetId,
+		authoringContributions: input.authoringContributions,
 		diagnostics
 	});
 	const storageTypes = {
@@ -1767,8 +2272,9 @@ function interpretPslDocumentToSqlContract(input) {
 			compositeTypeNames,
 			enumTypeDescriptors: enumResult.enumTypeDescriptors,
 			namedTypeDescriptors: namedTypeResult.namedTypeDescriptors,
-			namedTypeBaseTypes: namedTypeResult.namedTypeBaseTypes,
 			composedExtensions,
+			familyId: input.target.familyId,
+			targetId: input.target.targetId,
 			authoringContributions: input.authoringContributions,
 			defaultFunctionRegistry,
 			generatorDescriptorById,
@@ -1790,9 +2296,21 @@ function interpretPslDocumentToSqlContract(input) {
 		sourceId
 	});
 	const { discriminatorDeclarations, baseDeclarations } = collectPolymorphismDeclarations(models, sourceId, diagnostics);
+	const valueObjects = buildValueObjects({
+		compositeTypes,
+		enumTypeDescriptors: enumResult.enumTypeDescriptors,
+		namedTypeDescriptors: namedTypeResult.namedTypeDescriptors,
+		scalarTypeDescriptors: input.scalarTypeDescriptors,
+		composedExtensions,
+		familyId: input.target.familyId,
+		targetId: input.target.targetId,
+		authoringContributions: input.authoringContributions,
+		diagnostics,
+		sourceId
+	});
 	if (diagnostics.length > 0) return notOk({
 		summary: "PSL to SQL contract interpretation failed",
-		diagnostics: diagnostics.filter((diagnostic, index, allDiagnostics) => allDiagnostics.findIndex((candidate) => candidate.code === diagnostic.code && candidate.message === diagnostic.message && candidate.sourceId === diagnostic.sourceId && (candidate.span && diagnostic.span && hasSameSpan(candidate.span, diagnostic.span) || !candidate.span && !diagnostic.span)) === index)
+		diagnostics: dedupeDiagnostics(diagnostics)
 	});
 	const contract = buildSqlContractFromDefinition({
 		target: input.target,
@@ -1803,7 +2321,6 @@ function interpretPslDocumentToSqlContract(input) {
 			...modelRelations.has(model.modelName) ? { relations: [...modelRelations.get(model.modelName) ?? []].sort((left, right) => compareStrings(left.fieldName, right.fieldName)) } : {}
 		}))
 	});
-	const valueObjects = buildValueObjects(compositeTypes, enumResult.enumTypeDescriptors, namedTypeResult.namedTypeDescriptors, input.scalarTypeDescriptors, diagnostics, sourceId);
 	let patchedModels = patchModelDomainFields(contract.models, modelResolvedFields);
 	const polyDiagnostics = [];
 	patchedModels = resolvePolymorphism(patchedModels, discriminatorDeclarations, baseDeclarations, modelNames, modelMappings, sourceId, polyDiagnostics);
@@ -1823,4 +2340,4 @@ function interpretPslDocumentToSqlContract(input) {
 
 //#endregion
 export { interpretPslDocumentToSqlContract as t };
-//# sourceMappingURL=interpreter-qjtea3zY.mjs.map
+//# sourceMappingURL=interpreter-iFCRN9nb.mjs.map