@prisma-next/sql-contract-psl 0.5.0-dev.9 → 0.5.1

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

@@ -1,10 +1,9 @@
-import { instantiateAuthoringTypeConstructor, isAuthoringTypeConstructorDescriptor, validateAuthoringHelperArguments } from "@prisma-next/framework-components/authoring";
+import { hasRegisteredFieldNamespace, instantiateAuthoringFieldPreset, instantiateAuthoringTypeConstructor, isAuthoringFieldPresetDescriptor, 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";
 import { getPositionalArgument, parseQuotedStringLiteral } from "@prisma-next/psl-parser";
 import { assertDefined, invariant } from "@prisma-next/utils/assertions";
-
 //#region src/psl-attribute-parsing.ts
 function lowerFirst(value) {
 	if (value.length === 0) return value;
@@ -77,6 +76,109 @@ function parseConstraintMapArgument(input) {
 function getPositionalArguments(attribute) {
 	return attribute.args.filter((arg) => arg.kind === "positional").map((arg) => arg.kind === "positional" ? arg.value : "");
 }
+/**
+* Parses a PSL object-literal attribute argument value of the form
+* `{ key1: "value1", key2: "value2" }` into a `Record<string, string>`.
+*
+* V1 admits string literals only as leaf values. Boolean and number
+* literals are rejected. Trailing commas are allowed.
+*
+* Returns the parsed record, or pushes a diagnostic and returns undefined
+* on malformed input or non-string leaves.
+*/
+function parseObjectLiteralStringMap(input) {
+	const trimmed = input.raw.trim();
+	if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) return pushInvalidAttributeArgument({
+		diagnostics: input.diagnostics,
+		sourceId: input.sourceId,
+		span: input.span,
+		message: `${input.entityLabel} expected an object literal value of the form { key: "value", ... }`
+	});
+	const body = trimmed.slice(1, -1).trim();
+	if (body.length === 0) return {};
+	const result = {};
+	for (const part of splitObjectLiteralEntries(body)) {
+		const colonAt = findTopLevelColon(part);
+		if (colonAt === -1) return pushInvalidAttributeArgument({
+			diagnostics: input.diagnostics,
+			sourceId: input.sourceId,
+			span: input.span,
+			message: `${input.entityLabel} object-literal entry "${part}" is missing a "key: value" colon`
+		});
+		const key = part.slice(0, colonAt).trim();
+		const rawValue = part.slice(colonAt + 1).trim();
+		if (key.length === 0 || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) return pushInvalidAttributeArgument({
+			diagnostics: input.diagnostics,
+			sourceId: input.sourceId,
+			span: input.span,
+			message: `${input.entityLabel} object-literal key "${key}" must be a bare identifier`
+		});
+		const parsedString = parseQuotedStringLiteral(rawValue);
+		if (parsedString === void 0) return pushInvalidAttributeArgument({
+			diagnostics: input.diagnostics,
+			sourceId: input.sourceId,
+			span: input.span,
+			message: `${input.entityLabel} object-literal value for "${key}" must be a quoted string literal (V1 PSL @@index options support string leaves only; use the TS authoring surface for non-string options)`
+		});
+		if (Object.hasOwn(result, key)) return pushInvalidAttributeArgument({
+			diagnostics: input.diagnostics,
+			sourceId: input.sourceId,
+			span: input.span,
+			message: `${input.entityLabel} object-literal key "${key}" appears more than once`
+		});
+		result[key] = parsedString;
+	}
+	return result;
+}
+function splitObjectLiteralEntries(body) {
+	const parts = [];
+	let depthBrace = 0;
+	let depthBracket = 0;
+	let depthParen = 0;
+	let quote = null;
+	let start = 0;
+	for (let index = 0; index < body.length; index += 1) {
+		const ch = body[index] ?? "";
+		if (quote) {
+			if (ch === quote && body[index - 1] !== "\\") quote = null;
+			continue;
+		}
+		if (ch === "\"" || ch === "'") {
+			quote = ch;
+			continue;
+		}
+		if (ch === "{") depthBrace += 1;
+		else if (ch === "}") depthBrace = Math.max(0, depthBrace - 1);
+		else if (ch === "[") depthBracket += 1;
+		else if (ch === "]") depthBracket = Math.max(0, depthBracket - 1);
+		else if (ch === "(") depthParen += 1;
+		else if (ch === ")") depthParen = Math.max(0, depthParen - 1);
+		else if (ch === "," && depthBrace === 0 && depthBracket === 0 && depthParen === 0) {
+			const segment = body.slice(start, index).trim();
+			if (segment.length > 0) parts.push(segment);
+			start = index + 1;
+		}
+	}
+	const tail = body.slice(start).trim();
+	if (tail.length > 0) parts.push(tail);
+	return parts;
+}
+function findTopLevelColon(entry) {
+	let quote = null;
+	for (let index = 0; index < entry.length; index += 1) {
+		const ch = entry[index] ?? "";
+		if (quote) {
+			if (ch === quote && entry[index - 1] !== "\\") quote = null;
+			continue;
+		}
+		if (ch === "\"" || ch === "'") {
+			quote = ch;
+			continue;
+		}
+		if (ch === ":") return index;
+	}
+	return -1;
+}
 function pushInvalidAttributeArgument(input) {
 	input.diagnostics.push({
 		code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
@@ -149,7 +251,7 @@ function parseAttributeFieldList(input) {
 	if (!raw) {
 		input.diagnostics.push({
 			code: input.code,
-			message: `${input.messagePrefix} requires fields list argument`,
+			message: `${input.entityLabel} requires fields list argument`,
 			sourceId: input.sourceId,
 			span: input.attribute.span
 		});
@@ -159,7 +261,7 @@ function parseAttributeFieldList(input) {
 	if (!fields || fields.length === 0) {
 		input.diagnostics.push({
 			code: input.code,
-			message: `${input.messagePrefix} requires bracketed field list argument`,
+			message: `${input.entityLabel} requires bracketed field list argument`,
 			sourceId: input.sourceId,
 			span: input.attribute.span
 		});
@@ -167,6 +269,13 @@ function parseAttributeFieldList(input) {
 	}
 	return fields;
 }
+function findDuplicateFieldName(fieldNames) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const name of fieldNames) {
+		if (seen.has(name)) return name;
+		seen.add(name);
+	}
+}
 function mapFieldNamesToColumns(input) {
 	const columns = [];
 	for (const fieldName of input.fieldNames) {
@@ -174,7 +283,7 @@ function mapFieldNamesToColumns(input) {
 		if (!columnName) {
 			input.diagnostics.push({
 				code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
-				message: `${input.contextLabel} references unknown field "${input.modelName}.${fieldName}"`,
+				message: `${input.entityLabel} references unknown field "${input.modelName}.${fieldName}"`,
 				sourceId: input.sourceId,
 				span: input.span
 			});
@@ -184,7 +293,6 @@ function mapFieldNamesToColumns(input) {
 	}
 	return columns;
 }
-
 //#endregion
 //#region src/default-function-registry.ts
 function resolveSpanPositionFromBase(base, text, offset) {
@@ -323,7 +431,6 @@ function lowerDefaultFunctionWithRegistry(input) {
 		}
 	};
 }
-
 //#endregion
 //#region src/psl-authoring-arguments.ts
 const INVALID_AUTHORING_ARGUMENT = Symbol("invalidAuthoringArgument");
@@ -401,10 +508,10 @@ function parseJsLikeLiteral(value) {
 	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;
+		const parsed = Number(raw);
+		if (!Number.isFinite(parsed)) return INVALID_AUTHORING_ARGUMENT;
 		index += raw.length;
-		return parsed$1;
+		return parsed;
 	}
 	function parseArray() {
 		if (value[index] !== "[") return INVALID_AUTHORING_ARGUMENT;
@@ -511,6 +618,12 @@ function parsePslObjectLiteral(value) {
 function parsePslAuthoringArgumentValue(descriptor, rawValue) {
 	switch (descriptor.kind) {
 		case "string": return unquoteStringLiteral(rawValue);
+		case "boolean": {
+			const trimmed = rawValue.trim();
+			if (trimmed === "true") return true;
+			if (trimmed === "false") return false;
+			return INVALID_AUTHORING_ARGUMENT;
+		}
 		case "number": {
 			const parsed = Number(unquoteStringLiteral(rawValue));
 			return Number.isNaN(parsed) ? INVALID_AUTHORING_ARGUMENT : parsed;
@@ -562,7 +675,7 @@ function mapPslHelperArgs(input) {
 		mappedArgs[index] = value;
 	}
 	for (const argument of namedArgs) {
-		const descriptorIndex = input.descriptors.findIndex((descriptor$1) => descriptor$1.name === argument.name);
+		const descriptorIndex = input.descriptors.findIndex((descriptor) => descriptor.name === argument.name);
 		if (descriptorIndex < 0) return pushInvalidPslHelperArgument({
 			diagnostics: input.diagnostics,
 			sourceId: input.sourceId,
@@ -601,7 +714,6 @@ function mapPslHelperArgs(input) {
 	}
 	return mappedArgs;
 }
-
 //#endregion
 //#region src/psl-column-resolution.ts
 function toNamedTypeFieldDescriptor(typeRef, descriptor) {
@@ -620,33 +732,40 @@ 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:
+* Walks `authoringContributions.field` segment-by-segment and returns the field-preset descriptor at the resolved path, or `undefined` if no descriptor is registered.
+*
+* Symmetric with `getAuthoringTypeConstructor`. Field presets are strictly richer than type constructors — they can contribute `default` / `executionDefaults` / `id` / `unique` / `nullable` in addition to the `codecId` / `nativeType` / `typeParams` triple. PSL resolution tries field presets first, then falls back to type constructors on miss (see `resolveFieldTypeDescriptor`).
+*/
+function getAuthoringFieldPreset(contributions, path) {
+	let current = contributions?.field;
+	for (const segment of path) {
+		if (typeof current !== "object" || current === null || Array.isArray(current)) return;
+		current = current[segment];
+	}
+	return isAuthoringFieldPresetDescriptor(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`),
+* - a registered field-preset namespace (e.g. `temporal`),
 * - 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).
+* Family/target/field-preset 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;
+	if (namespace === "db" || namespace === context?.familyId || namespace === context?.targetId || hasRegisteredFieldNamespace(context?.authoringContributions, namespace) || 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.
+* 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.
+* 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({
@@ -660,6 +779,21 @@ function reportUncomposedNamespace(input) {
 		}
 	});
 }
+/**
+* Pushes the canonical `PSL_UNKNOWN_FIELD_PRESET` diagnostic when a typoed preset name is referenced inside a registered field-preset namespace. The `data` payload exposes the namespace and full helper path so machine consumers (agents, IDE extensions) don't have to parse the prose.
+*/
+function reportUnknownFieldPreset(input) {
+	input.diagnostics.push({
+		code: "PSL_UNKNOWN_FIELD_PRESET",
+		message: `${input.entityLabel} references unknown field preset "${input.helperPath}". Check the spelling against the available presets in the "${input.namespace}" namespace.`,
+		sourceId: input.sourceId,
+		span: input.span,
+		data: {
+			namespace: input.namespace,
+			helperPath: input.helperPath
+		}
+	});
+}
 function instantiatePslTypeConstructor(input) {
 	const helperPath = input.call.path.join(".");
 	const args = mapPslHelperArgs({
@@ -697,11 +831,15 @@ function pushUnsupportedTypeConstructorDiagnostic(input) {
 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)) {
+	const uncomposedNamespace = checkUncomposedNamespace(input.call.path.join("."), input.composedExtensions, {
+		familyId: input.familyId,
+		targetId: input.targetId,
+		authoringContributions: input.authoringContributions
+	});
+	if (uncomposedNamespace) {
 		reportUncomposedNamespace({
 			subjectLabel: `Type constructor "${input.call.path.join(".")}"`,
-			namespace,
+			namespace: uncomposedNamespace,
 			sourceId: input.sourceId,
 			span: input.call.span,
 			diagnostics: input.diagnostics
@@ -716,10 +854,95 @@ function resolvePslTypeConstructorDescriptor(input) {
 		message: input.unsupportedMessage
 	});
 }
+/**
+* Instantiates a field-preset call against its descriptor, coercing PSL AST arguments into the descriptor's typed argument shape and returning the preset's full set of contract contributions.
+*
+* Symmetric with `instantiatePslTypeConstructor` but richer: a field preset can contribute `default`, `executionDefaults`, `id`, `unique`, and `nullable` in addition to the storage-type triple. PSL → typed-args coercion happens here (via `mapPslHelperArgs`) so that `instantiateAuthoringFieldPreset` itself stays typed-input-only and TS keeps its zero-runtime-validation cost.
+*/
+function instantiatePslFieldPreset(input) {
+	const helperPath = input.call.path.join(".");
+	const args = mapPslHelperArgs({
+		args: input.call.args,
+		descriptors: input.descriptor.args ?? [],
+		helperLabel: `preset "${helperPath}"`,
+		span: input.call.span,
+		diagnostics: input.diagnostics,
+		sourceId: input.sourceId,
+		entityLabel: input.entityLabel
+	});
+	if (!args) return;
+	try {
+		validateAuthoringHelperArguments(helperPath, input.descriptor.args, args);
+		const instantiated = instantiateAuthoringFieldPreset(input.descriptor, args);
+		return {
+			descriptor: {
+				codecId: instantiated.descriptor.codecId,
+				nativeType: instantiated.descriptor.nativeType,
+				...instantiated.descriptor.typeParams !== void 0 ? { typeParams: instantiated.descriptor.typeParams } : {}
+			},
+			nullable: instantiated.nullable,
+			...instantiated.default !== void 0 ? { default: instantiated.default } : {},
+			...instantiated.executionDefaults !== void 0 ? { executionDefaults: instantiated.executionDefaults } : {},
+			id: instantiated.id,
+			unique: instantiated.unique
+		};
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		input.diagnostics.push({
+			code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+			message: `${input.entityLabel} preset "${helperPath}" ${message}`,
+			sourceId: input.sourceId,
+			span: input.call.span
+		});
+		return;
+	}
+}
 function resolveFieldTypeDescriptor(input) {
 	if (input.field.typeConstructor) {
+		const presetDescriptor = getAuthoringFieldPreset(input.authoringContributions, input.field.typeConstructor.path);
+		if (presetDescriptor) {
+			const instantiated = instantiatePslFieldPreset({
+				call: input.field.typeConstructor,
+				descriptor: presetDescriptor,
+				diagnostics: input.diagnostics,
+				sourceId: input.sourceId,
+				entityLabel: input.entityLabel
+			});
+			if (!instantiated) return {
+				ok: false,
+				alreadyReported: true
+			};
+			const presetContributions = {
+				nullable: instantiated.nullable,
+				id: instantiated.id,
+				unique: instantiated.unique,
+				...instantiated.default !== void 0 ? { default: instantiated.default } : {},
+				...instantiated.executionDefaults !== void 0 ? { executionDefaults: instantiated.executionDefaults } : {}
+			};
+			return {
+				ok: true,
+				descriptor: instantiated.descriptor,
+				presetContributions
+			};
+		}
 		const helperPath = input.field.typeConstructor.path.join(".");
-		const descriptor$1 = resolvePslTypeConstructorDescriptor({
+		const namespacePrefix = input.field.typeConstructor.path.length > 1 ? input.field.typeConstructor.path[0] : void 0;
+		const typeDescriptor = getAuthoringTypeConstructor(input.authoringContributions, input.field.typeConstructor.path);
+		if (!typeDescriptor && namespacePrefix && hasRegisteredFieldNamespace(input.authoringContributions, namespacePrefix)) {
+			reportUnknownFieldPreset({
+				entityLabel: input.entityLabel,
+				namespace: namespacePrefix,
+				helperPath,
+				sourceId: input.sourceId,
+				span: input.field.typeConstructor.span,
+				diagnostics: input.diagnostics
+			});
+			return {
+				ok: false,
+				alreadyReported: true
+			};
+		}
+		const descriptor = typeDescriptor ?? resolvePslTypeConstructorDescriptor({
 			call: input.field.typeConstructor,
 			authoringContributions: input.authoringContributions,
 			composedExtensions: input.composedExtensions,
@@ -730,13 +953,13 @@ function resolveFieldTypeDescriptor(input) {
 			unsupportedCode: "PSL_UNSUPPORTED_FIELD_TYPE",
 			unsupportedMessage: `${input.entityLabel} type constructor "${helperPath}" is not supported in SQL PSL provider v1`
 		});
-		if (!descriptor$1) return {
+		if (!descriptor) return {
 			ok: false,
 			alreadyReported: true
 		};
 		const instantiated = instantiatePslTypeConstructor({
 			call: input.field.typeConstructor,
-			descriptor: descriptor$1,
+			descriptor,
 			diagnostics: input.diagnostics,
 			sourceId: input.sourceId,
 			entityLabel: input.entityLabel
@@ -985,6 +1208,15 @@ function lowerDefaultForField(input) {
 		});
 		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.`,
+			sourceId: input.sourceId,
+			span: expressionEntry.span
+		});
+		return {};
+	}
 	if (!generatorDescriptor.applicableCodecIds.includes(input.columnDescriptor.codecId)) {
 		input.diagnostics.push({
 			code: "PSL_INVALID_DEFAULT_APPLICABILITY",
@@ -994,7 +1226,7 @@ function lowerDefaultForField(input) {
 		});
 		return {};
 	}
-	return { executionDefault: lowered.value.generated };
+	return { executionDefaults: { onCreate: lowered.value.generated } };
 }
 function resolveColumnDescriptor(field, enumTypeDescriptors, namedTypeDescriptors, scalarTypeDescriptors) {
 	if (field.typeRef && namedTypeDescriptors.has(field.typeRef)) return namedTypeDescriptors.get(field.typeRef);
@@ -1002,7 +1234,6 @@ function resolveColumnDescriptor(field, enumTypeDescriptors, namedTypeDescriptor
 	if (enumTypeDescriptors.has(field.typeName)) return enumTypeDescriptors.get(field.typeName);
 	return scalarTypeDescriptors.get(field.typeName);
 }
-
 //#endregion
 //#region src/psl-field-resolution.ts
 const BUILTIN_FIELD_ATTRIBUTE_NAMES = new Set([
@@ -1012,12 +1243,21 @@ const BUILTIN_FIELD_ATTRIBUTE_NAMES = new Set([
 	"relation",
 	"map"
 ]);
+const REMOVED_ATTRIBUTE_RULES = 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) => BUILTIN_FIELD_ATTRIBUTE_NAMES.has(name));
+	if (overlap.length > 0) throw new Error(`BUILTIN_FIELD_ATTRIBUTE_NAMES and REMOVED_ATTRIBUTE_RULES must not overlap. Names in both: ${overlap.join(", ")}`);
+}
 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
+			targetId: input.targetId,
+			authoringContributions: input.authoringContributions
 		});
 		if (uncomposedNamespace) {
 			reportUncomposedNamespace({
@@ -1029,9 +1269,12 @@ function validateFieldAttributes(input) {
 			});
 			continue;
 		}
+		const baseMessage = `Field "${input.model.name}.${input.field.name}" uses unsupported attribute "@${attribute.name}"`;
+		const removedRule = REMOVED_ATTRIBUTE_RULES.get(attribute.name);
+		const message = removedRule && !removedRule.suppressWhen(input.field) ? `${baseMessage}. ${removedRule.hint}` : baseMessage;
 		input.diagnostics.push({
 			code: "PSL_UNSUPPORTED_FIELD_ATTRIBUTE",
-			message: `Field "${input.model.name}.${input.field.name}" uses unsupported attribute "@${attribute.name}"`,
+			message,
 			sourceId: input.sourceId,
 			span: attribute.span
 		});
@@ -1065,21 +1308,25 @@ function collectResolvedFields(input) {
 	const { model, mapping, enumTypeDescriptors, namedTypeDescriptors, modelNames, compositeTypeNames, composedExtensions, authoringContributions, familyId, targetId, defaultFunctionRegistry, generatorDescriptorById, diagnostics, sourceId, scalarTypeDescriptors } = input;
 	const resolvedFields = [];
 	for (const field of model.fields) {
-		if (field.list && modelNames.has(field.typeName)) continue;
+		const isModelField = modelNames.has(field.typeName);
+		if (field.list && isModelField) continue;
 		validateFieldAttributes({
 			model,
 			field,
 			composedExtensions,
+			authoringContributions,
 			diagnostics,
 			sourceId,
 			familyId,
 			targetId
 		});
-		if (getAttribute(field.attributes, "relation") && modelNames.has(field.typeName)) continue;
+		const relationAttribute = getAttribute(field.attributes, "relation");
+		if (isModelField && relationAttribute) continue;
 		const isValueObjectField = compositeTypeNames.has(field.typeName);
 		const isListField = field.list;
 		let descriptor;
 		let scalarCodecId;
+		let presetContributions;
 		const resolveInput = {
 			field,
 			enumTypeDescriptors,
@@ -1105,6 +1352,15 @@ function collectResolvedFields(input) {
 				});
 				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.`,
+					sourceId,
+					span: field.span
+				});
+				continue;
+			}
 			scalarCodecId = resolved.descriptor.codecId;
 			descriptor = scalarTypeDescriptors.get("Json");
 		} else {
@@ -1119,9 +1375,28 @@ function collectResolvedFields(input) {
 				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.`,
+				sourceId,
+				span: 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.`,
+				sourceId,
+				span: defaultAttribute.span
+			});
+			continue;
+		}
 		const loweredDefault = defaultAttribute ? lowerDefaultForField({
 			modelName: model.name,
 			fieldName: field.name,
@@ -1132,8 +1407,9 @@ function collectResolvedFields(input) {
 			defaultFunctionRegistry,
 			diagnostics
 		}) : {};
-		if (field.optional && loweredDefault.executionDefault) {
-			const generatorDescription = loweredDefault.executionDefault.kind === "generator" ? `"${loweredDefault.executionDefault.id}"` : "for this field";
+		const loweredOnCreate = loweredDefault.executionDefaults?.onCreate;
+		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.`,
@@ -1142,8 +1418,8 @@ function collectResolvedFields(input) {
 			});
 			continue;
 		}
-		if (loweredDefault.executionDefault) {
-			const generatedDescriptor = generatorDescriptorById.get(loweredDefault.executionDefault.id)?.resolveGeneratedColumnDescriptor?.({ generated: loweredDefault.executionDefault });
+		if (loweredOnCreate) {
+			const generatedDescriptor = generatorDescriptorById.get(loweredOnCreate.id)?.resolveGeneratedColumnDescriptor?.({ generated: loweredOnCreate });
 			if (generatedDescriptor) descriptor = generatedDescriptor;
 		}
 		const mappedColumnName = mapping.fieldColumns.get(field.name) ?? field.name;
@@ -1153,14 +1429,35 @@ function collectResolvedFields(input) {
 			sourceId,
 			diagnostics
 		});
+		let isIdField = Boolean(idAttribute);
+		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`,
+				sourceId,
+				span: 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.`,
+				sourceId,
+				span: idAttribute.span
+			});
+			continue;
+		}
+		const fieldExecutionDefaults = presetContributions?.executionDefaults ?? loweredDefault.executionDefaults;
+		const fieldDefaultValue = presetContributions?.default ?? loweredDefault.defaultValue;
 		resolvedFields.push({
 			field,
 			columnName: mappedColumnName,
 			descriptor,
-			...ifDefined("defaultValue", loweredDefault.defaultValue),
-			...ifDefined("executionDefault", loweredDefault.executionDefault),
-			isId: Boolean(idAttribute),
-			isUnique: Boolean(uniqueAttribute),
+			...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),
@@ -1201,7 +1498,6 @@ function buildModelMappings(models, diagnostics, sourceId) {
 	}
 	return result;
 }
-
 //#endregion
 //#region src/psl-relation-resolution.ts
 const REFERENTIAL_ACTION_MAP = {
@@ -1418,7 +1714,8 @@ function validateNavigationListFieldAttributes(input) {
 		if (attribute.name === "relation") continue;
 		const uncomposedNamespace = checkUncomposedNamespace(attribute.name, input.composedExtensions, {
 			familyId: input.familyId,
-			targetId: input.targetId
+			targetId: input.targetId,
+			authoringContributions: input.authoringContributions
 		});
 		if (uncomposedNamespace) {
 			reportUncomposedNamespace({
@@ -1441,7 +1738,6 @@ function validateNavigationListFieldAttributes(input) {
 	}
 	return valid;
 }
-
 //#endregion
 //#region src/interpreter.ts
 function buildComposedExtensionPackRefs(target, extensionIds, extensionPackRefs = []) {
@@ -1531,7 +1827,8 @@ function validateNamedTypeAttributes(input) {
 		if (input.allowDbNativeType && attribute.name.startsWith("db.")) continue;
 		const uncomposedNamespace = checkUncomposedNamespace(attribute.name, input.composedExtensions, {
 			familyId: input.familyId,
-			targetId: input.targetId
+			targetId: input.targetId,
+			authoringContributions: input.authoringContributions
 		});
 		if (uncomposedNamespace) {
 			reportUncomposedNamespace({
@@ -1562,16 +1859,17 @@ function resolveNamedTypeDeclarations(input) {
 	const namedTypeDescriptors = /* @__PURE__ */ new Map();
 	for (const declaration of input.declarations) {
 		if (declaration.typeConstructor) {
-			const { hasUnsupportedNamedTypeAttribute: hasUnsupportedNamedTypeAttribute$1 } = validateNamedTypeAttributes({
+			const { hasUnsupportedNamedTypeAttribute } = validateNamedTypeAttributes({
 				declaration,
 				sourceId: input.sourceId,
 				diagnostics: input.diagnostics,
 				composedExtensions: input.composedExtensions,
+				authoringContributions: input.authoringContributions,
 				allowDbNativeType: false,
 				familyId: input.familyId,
 				targetId: input.targetId
 			});
-			if (hasUnsupportedNamedTypeAttribute$1) continue;
+			if (hasUnsupportedNamedTypeAttribute) continue;
 			const helperPath = declaration.typeConstructor.path.join(".");
 			const typeConstructor = resolvePslTypeConstructorDescriptor({
 				call: declaration.typeConstructor,
@@ -1626,13 +1924,14 @@ function resolveNamedTypeDeclarations(input) {
 			sourceId: input.sourceId,
 			diagnostics: input.diagnostics,
 			composedExtensions: input.composedExtensions,
+			authoringContributions: input.authoringContributions,
 			allowDbNativeType: true,
 			familyId: input.familyId,
 			targetId: input.targetId
 		});
 		if (hasUnsupportedNamedTypeAttribute) continue;
 		if (dbNativeTypeAttribute) {
-			const descriptor$1 = resolveDbNativeTypeAttribute({
+			const descriptor = resolveDbNativeTypeAttribute({
 				attribute: dbNativeTypeAttribute,
 				baseType,
 				baseDescriptor,
@@ -1640,12 +1939,12 @@ function resolveNamedTypeDeclarations(input) {
 				sourceId: input.sourceId,
 				entityLabel: `Named type "${declaration.name}"`
 			});
-			if (!descriptor$1) continue;
-			namedTypeDescriptors.set(declaration.name, toNamedTypeFieldDescriptor(declaration.name, descriptor$1));
+			if (!descriptor) continue;
+			namedTypeDescriptors.set(declaration.name, toNamedTypeFieldDescriptor(declaration.name, descriptor));
 			storageTypes[declaration.name] = {
-				codecId: descriptor$1.codecId,
-				nativeType: descriptor$1.nativeType,
-				typeParams: descriptor$1.typeParams ?? {}
+				codecId: descriptor.codecId,
+				nativeType: descriptor.nativeType,
+				typeParams: descriptor.typeParams ?? {}
 			};
 			continue;
 		}
@@ -1682,16 +1981,20 @@ function buildModelNodeFromPsl(input) {
 		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;
-	const isVariantModel = model.attributes.some((attr) => attr.name === "base");
-	if (primaryKeyColumns.length === 0 && !isVariantModel) diagnostics.push({
-		code: "PSL_MISSING_PRIMARY_KEY",
-		message: `Model "${model.name}" must declare at least one @id field for SQL provider`,
+	const inlineIdFields = resolvedFields.filter((field) => field.isId);
+	if (inlineIdFields.length > 1) diagnostics.push({
+		code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+		message: `Model "${model.name}" cannot declare inline @id on multiple fields; use model-level @@id([...]) for composite identity`,
 		sourceId,
 		span: model.span
 	});
+	const singleInlineIdField = inlineIdFields.length === 1 ? inlineIdFields[0] : void 0;
+	let primaryKey = singleInlineIdField ? {
+		columns: [singleInlineIdField.columnName],
+		...ifDefined("name", singleInlineIdField.idName)
+	} : void 0;
+	const hasInlinePrimaryKey = primaryKey !== void 0;
+	let blockPrimaryKeyDeclared = false;
 	const resultBackrelationCandidates = [];
 	for (const field of model.fields) {
 		if (!field.list || !input.modelNames.has(field.typeName)) continue;
@@ -1700,6 +2003,7 @@ function buildModelNodeFromPsl(input) {
 			field,
 			sourceId,
 			composedExtensions: input.composedExtensions,
+			authoringContributions: input.authoringContributions,
 			diagnostics,
 			familyId: input.familyId,
 			targetId: input.targetId
@@ -1757,15 +2061,98 @@ function buildModelNodeFromPsl(input) {
 	for (const modelAttribute of model.attributes) {
 		if (modelAttribute.name === "map") continue;
 		if (modelAttribute.name === "discriminator" || modelAttribute.name === "base") continue;
+		const attributeLabel = `Model "${model.name}" @@${modelAttribute.name}`;
+		if (modelAttribute.name === "id") {
+			if (blockPrimaryKeyDeclared) {
+				diagnostics.push({
+					code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+					message: `Model "${model.name}" declares @@id more than once`,
+					sourceId,
+					span: modelAttribute.span
+				});
+				continue;
+			}
+			if (hasInlinePrimaryKey) {
+				diagnostics.push({
+					code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+					message: `Model "${model.name}" cannot declare both field-level @id and model-level @@id`,
+					sourceId,
+					span: modelAttribute.span
+				});
+				blockPrimaryKeyDeclared = true;
+				continue;
+			}
+			const fieldNames = parseAttributeFieldList({
+				attribute: modelAttribute,
+				sourceId,
+				diagnostics,
+				code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+				entityLabel: attributeLabel
+			});
+			if (!fieldNames) continue;
+			const duplicateFieldName = findDuplicateFieldName(fieldNames);
+			if (duplicateFieldName !== void 0) {
+				diagnostics.push({
+					code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+					message: `${attributeLabel} list contains duplicate field "${duplicateFieldName}"`,
+					sourceId,
+					span: modelAttribute.span
+				});
+				continue;
+			}
+			const nullableFieldName = fieldNames.find((name) => model.fields.find((f) => f.name === name)?.optional === true);
+			if (nullableFieldName !== void 0) {
+				diagnostics.push({
+					code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+					message: `${attributeLabel} cannot include optional field "${nullableFieldName}"; primary key columns must be NOT NULL`,
+					sourceId,
+					span: modelAttribute.span
+				});
+				continue;
+			}
+			const columnNames = mapFieldNamesToColumns({
+				modelName: model.name,
+				fieldNames,
+				mapping,
+				sourceId,
+				diagnostics,
+				span: modelAttribute.span,
+				entityLabel: attributeLabel
+			});
+			if (!columnNames) continue;
+			primaryKey = {
+				columns: columnNames,
+				...ifDefined("name", parseConstraintMapArgument({
+					attribute: modelAttribute,
+					sourceId,
+					diagnostics,
+					entityLabel: attributeLabel,
+					span: modelAttribute.span,
+					code: "PSL_INVALID_ATTRIBUTE_ARGUMENT"
+				}))
+			};
+			blockPrimaryKeyDeclared = true;
+			continue;
+		}
 		if (modelAttribute.name === "unique" || modelAttribute.name === "index") {
 			const fieldNames = parseAttributeFieldList({
 				attribute: modelAttribute,
 				sourceId,
 				diagnostics,
 				code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
-				messagePrefix: `Model "${model.name}" @@${modelAttribute.name}`
+				entityLabel: attributeLabel
 			});
 			if (!fieldNames) continue;
+			const duplicateFieldName = findDuplicateFieldName(fieldNames);
+			if (duplicateFieldName !== void 0) {
+				diagnostics.push({
+					code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+					message: `${attributeLabel} list contains duplicate field "${duplicateFieldName}"`,
+					sourceId,
+					span: modelAttribute.span
+				});
+				continue;
+			}
 			const columnNames = mapFieldNamesToColumns({
 				modelName: model.name,
 				fieldNames,
@@ -1773,14 +2160,14 @@ function buildModelNodeFromPsl(input) {
 				sourceId,
 				diagnostics,
 				span: modelAttribute.span,
-				contextLabel: `Model "${model.name}" @@${modelAttribute.name}`
+				entityLabel: attributeLabel
 			});
 			if (!columnNames) continue;
 			const constraintName = parseConstraintMapArgument({
 				attribute: modelAttribute,
 				sourceId,
 				diagnostics,
-				entityLabel: `Model "${model.name}" @@${modelAttribute.name}`,
+				entityLabel: attributeLabel,
 				span: modelAttribute.span,
 				code: "PSL_INVALID_ATTRIBUTE_ARGUMENT"
 			});
@@ -1788,15 +2175,58 @@ function buildModelNodeFromPsl(input) {
 				columns: columnNames,
 				...ifDefined("name", constraintName)
 			});
-			else indexNodes.push({
-				columns: columnNames,
-				...ifDefined("name", constraintName)
-			});
+			else {
+				const indexEntityLabel = `Model "${model.name}" @@index`;
+				const rawTypeArg = getNamedArgument(modelAttribute, "type");
+				let indexType;
+				if (rawTypeArg !== void 0) {
+					const parsed = parseQuotedStringLiteral(rawTypeArg);
+					if (parsed === void 0) {
+						diagnostics.push({
+							code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+							message: `${indexEntityLabel} type argument must be a quoted string literal`,
+							sourceId,
+							span: modelAttribute.span
+						});
+						continue;
+					}
+					indexType = parsed;
+				}
+				const rawOptionsArg = getNamedArgument(modelAttribute, "options");
+				let indexOptions;
+				if (rawOptionsArg !== void 0) {
+					if (indexType === void 0) {
+						diagnostics.push({
+							code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+							message: `${indexEntityLabel} options argument requires a type argument`,
+							sourceId,
+							span: modelAttribute.span
+						});
+						continue;
+					}
+					const parsed = parseObjectLiteralStringMap({
+						raw: rawOptionsArg,
+						diagnostics,
+						sourceId,
+						span: modelAttribute.span,
+						entityLabel: indexEntityLabel
+					});
+					if (parsed === void 0) continue;
+					indexOptions = parsed;
+				}
+				indexNodes.push({
+					columns: columnNames,
+					...ifDefined("name", constraintName),
+					...ifDefined("type", indexType),
+					...ifDefined("options", indexOptions)
+				});
+			}
 			continue;
 		}
 		const uncomposedNamespace = checkUncomposedNamespace(modelAttribute.name, input.composedExtensions, {
 			familyId: input.familyId,
-			targetId: input.targetId
+			targetId: input.targetId,
+			authoringContributions: input.authoringContributions
 		});
 		if (uncomposedNamespace) {
 			reportUncomposedNamespace({
@@ -1861,7 +2291,7 @@ function buildModelNodeFromPsl(input) {
 			sourceId,
 			diagnostics,
 			span: relationAttribute.relation.span,
-			contextLabel: `Relation field "${model.name}.${relationAttribute.field.name}"`
+			entityLabel: `Relation field "${model.name}.${relationAttribute.field.name}"`
 		});
 		if (!localColumns) continue;
 		const referencedColumns = mapFieldNamesToColumns({
@@ -1871,7 +2301,7 @@ function buildModelNodeFromPsl(input) {
 			sourceId,
 			diagnostics,
 			span: relationAttribute.relation.span,
-			contextLabel: `Relation field "${model.name}.${relationAttribute.field.name}"`
+			entityLabel: `Relation field "${model.name}.${relationAttribute.field.name}"`
 		});
 		if (!referencedColumns) continue;
 		if (localColumns.length !== referencedColumns.length) {
@@ -1933,12 +2363,9 @@ function buildModelNodeFromPsl(input) {
 				descriptor: resolvedField.descriptor,
 				nullable: resolvedField.field.optional,
 				...ifDefined("default", resolvedField.defaultValue),
-				...ifDefined("executionDefault", resolvedField.executionDefault)
+				...ifDefined("executionDefaults", resolvedField.executionDefaults)
 			})),
-			...primaryKeyColumns.length > 0 ? { id: {
-				columns: primaryKeyColumns,
-				...ifDefined("name", primaryKeyName)
-			} } : {},
+			...ifDefined("id", primaryKey),
 			...uniqueConstraints.length > 0 ? { uniques: uniqueConstraints } : {},
 			...indexNodes.length > 0 ? { indexes: indexNodes } : {},
 			...foreignKeyNodes.length > 0 ? { foreignKeys: foreignKeyNodes } : {}
@@ -2337,7 +2764,7 @@ function interpretPslDocumentToSqlContract(input) {
 		...Object.keys(valueObjects).length > 0 ? { valueObjects } : {}
 	});
 }
-
 //#endregion
 export { interpretPslDocumentToSqlContract as t };
-//# sourceMappingURL=interpreter-iFCRN9nb.mjs.map
+
+//# sourceMappingURL=interpreter-ijCjxhaU.mjs.map