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

package/src/interpreter.ts

@@ -3,1505 +3,1194 @@ import type {
   ContractSourceDiagnosticSpan,
   ContractSourceDiagnostics,
 } from '@prisma-next/config/config-types';
-import type { TargetPackRef } from '@prisma-next/contract/framework-components';
-import type { ContractIR } from '@prisma-next/contract/ir';
-import type { ColumnDefault, ExecutionMutationDefaultValue } from '@prisma-next/contract/types';
+import type {
+  Contract,
+  ContractField,
+  ContractModel,
+  ContractValueObject,
+} from '@prisma-next/contract/types';
+import type {
+  AuthoringContributions,
+  AuthoringTypeConstructorDescriptor,
+} from '@prisma-next/framework-components/authoring';
+import { instantiateAuthoringTypeConstructor } from '@prisma-next/framework-components/authoring';
+import type { ExtensionPackRef, TargetPackRef } from '@prisma-next/framework-components/components';
 import type {
   ParsePslDocumentResult,
   PslAttribute,
+  PslCompositeType,
+  PslEnum,
   PslField,
   PslModel,
-  PslSpan,
+  PslNamedTypeDeclaration,
 } from '@prisma-next/psl-parser';
-import { defineContract } from '@prisma-next/sql-contract-ts/contract-builder';
-import { assertDefined, invariant } from '@prisma-next/utils/assertions';
+import type { StorageTypeInstance } from '@prisma-next/sql-contract/types';
+import {
+  buildSqlContractFromDefinition,
+  type ForeignKeyNode,
+  type IndexNode,
+  type ModelNode,
+  type UniqueConstraintNode,
+} from '@prisma-next/sql-contract-ts/contract-builder';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { notOk, ok, type Result } from '@prisma-next/utils/result';
-import {
-  createBuiltinDefaultFunctionRegistry,
-  type DefaultFunctionRegistry,
-  lowerDefaultFunctionWithRegistry,
-  parseDefaultFunctionCall,
+import type {
+  ControlMutationDefaultRegistry,
+  ControlMutationDefaults,
+  MutationDefaultGeneratorDescriptor,
 } from './default-function-registry';
-
-type ColumnDescriptor = {
-  readonly codecId: string;
-  readonly nativeType: string;
-  readonly typeRef?: string;
-  readonly typeParams?: Record<string, unknown>;
-};
-
-export interface InterpretPslDocumentToSqlContractIRInput {
+import {
+  getAttribute,
+  getPositionalArgument,
+  mapFieldNamesToColumns,
+  parseAttributeFieldList,
+  parseConstraintMapArgument,
+  parseMapName,
+  parseQuotedStringLiteral,
+} from './psl-attribute-parsing';
+import type { ColumnDescriptor } from './psl-column-resolution';
+import {
+  checkUncomposedNamespace,
+  getAuthoringTypeConstructor,
+  instantiatePslTypeConstructor,
+  reportUncomposedNamespace,
+  resolveDbNativeTypeAttribute,
+  resolveFieldTypeDescriptor,
+  resolvePslTypeConstructorDescriptor,
+  toNamedTypeFieldDescriptor,
+} from './psl-column-resolution';
+import {
+  buildModelMappings,
+  collectResolvedFields,
+  type ModelNameMapping,
+  type ResolvedField,
+} from './psl-field-resolution';
+import {
+  applyBackrelationCandidates,
+  type FkRelationMetadata,
+  indexFkRelations,
+  type ModelBackrelationCandidate,
+  normalizeReferentialAction,
+  parseRelationAttribute,
+  validateNavigationListFieldAttributes,
+} from './psl-relation-resolution';
+
+export interface InterpretPslDocumentToSqlContractInput {
   readonly document: ParsePslDocumentResult;
-  readonly target?: TargetPackRef<'sql', 'postgres'>;
+  readonly target: TargetPackRef<'sql', 'postgres'>;
+  readonly scalarTypeDescriptors: ReadonlyMap<string, ColumnDescriptor>;
   readonly composedExtensionPacks?: readonly string[];
-  readonly defaultFunctionRegistry?: DefaultFunctionRegistry;
-}
-
-const DEFAULT_POSTGRES_TARGET: TargetPackRef<'sql', 'postgres'> = {
-  kind: 'target',
-  familyId: 'sql',
-  targetId: 'postgres',
-  id: 'postgres',
-  version: '0.0.1',
-  capabilities: {},
-};
-
-const SCALAR_COLUMN_MAP: Record<string, ColumnDescriptor> = {
-  String: { codecId: 'pg/text@1', nativeType: 'text' },
-  Boolean: { codecId: 'pg/bool@1', nativeType: 'bool' },
-  Int: { codecId: 'pg/int4@1', nativeType: 'int4' },
-  BigInt: { codecId: 'pg/int8@1', nativeType: 'int8' },
-  Float: { codecId: 'pg/float8@1', nativeType: 'float8' },
-  Decimal: { codecId: 'pg/numeric@1', nativeType: 'numeric' },
-  DateTime: { codecId: 'pg/timestamptz@1', nativeType: 'timestamptz' },
-  Json: { codecId: 'pg/jsonb@1', nativeType: 'jsonb' },
-  Bytes: { codecId: 'pg/bytea@1', nativeType: 'bytea' },
-};
-
-const GENERATED_ID_COLUMN_MAP: Partial<Record<string, ColumnDescriptor>> = {
-  ulid: { codecId: 'sql/char@1', nativeType: 'character', typeParams: { length: 26 } },
-  uuidv7: { codecId: 'sql/char@1', nativeType: 'character', typeParams: { length: 36 } },
-  uuidv4: { codecId: 'sql/char@1', nativeType: 'character', typeParams: { length: 36 } },
-  cuid2: { codecId: 'sql/char@1', nativeType: 'character', typeParams: { length: 24 } },
-};
-
-function resolveGeneratedColumnDescriptor(
-  executionDefault: ExecutionMutationDefaultValue,
-): ColumnDescriptor | undefined {
-  if (executionDefault.kind !== 'generator') {
-    return undefined;
-  }
-
-  if (executionDefault.id === 'nanoid') {
-    const rawSize = executionDefault.params?.['size'];
-    const length =
-      typeof rawSize === 'number' && Number.isInteger(rawSize) && rawSize >= 2 && rawSize <= 255
-        ? rawSize
-        : 21;
-    return { codecId: 'sql/char@1', nativeType: 'character', typeParams: { length } };
-  }
-
-  return GENERATED_ID_COLUMN_MAP[executionDefault.id];
-}
-
-const REFERENTIAL_ACTION_MAP = {
-  NoAction: 'noAction',
-  Restrict: 'restrict',
-  Cascade: 'cascade',
-  SetNull: 'setNull',
-  SetDefault: 'setDefault',
-  noAction: 'noAction',
-  restrict: 'restrict',
-  cascade: 'cascade',
-  setNull: 'setNull',
-  setDefault: 'setDefault',
-} as const;
-
-type ResolvedField = {
-  readonly field: PslField;
-  readonly columnName: string;
-  readonly descriptor: ColumnDescriptor;
-  readonly defaultValue?: ColumnDefault;
-  readonly executionDefault?: ExecutionMutationDefaultValue;
-  readonly isId: boolean;
-  readonly isUnique: boolean;
-};
-
-type ParsedRelationAttribute = {
-  readonly relationName?: string;
-  readonly fields?: readonly string[];
-  readonly references?: readonly string[];
-  readonly onDelete?: string;
-  readonly onUpdate?: string;
-};
-
-type FkRelationMetadata = {
-  readonly declaringModelName: string;
-  readonly declaringFieldName: string;
-  readonly declaringTableName: string;
-  readonly targetModelName: string;
-  readonly targetTableName: string;
-  readonly relationName?: string;
-  readonly localColumns: readonly string[];
-  readonly referencedColumns: readonly string[];
-};
-
-type ModelBackrelationCandidate = {
-  readonly modelName: string;
-  readonly tableName: string;
-  readonly field: PslField;
-  readonly targetModelName: string;
-  readonly relationName?: string;
-};
-
-type ModelRelationMetadata = {
-  readonly fieldName: string;
-  readonly toModel: string;
-  readonly toTable: string;
-  readonly cardinality: '1:N' | 'N:1';
-  readonly parentTable: string;
-  readonly parentColumns: readonly string[];
-  readonly childTable: string;
-  readonly childColumns: readonly string[];
-};
-
-type ResolvedModelEntry = {
-  readonly model: PslModel;
-  readonly mapping: ModelNameMapping;
-  readonly resolvedFields: readonly ResolvedField[];
-};
-
-function fkRelationPairKey(declaringModelName: string, targetModelName: string): string {
-  // NOTE: We assume PSL model identifiers do not contain the `::` separator.
-  return `${declaringModelName}::${targetModelName}`;
-}
-
-type ModelNameMapping = {
-  readonly model: PslModel;
-  readonly tableName: string;
-  readonly fieldColumns: Map<string, string>;
-};
-
-type DynamicTableBuilder = {
-  column(
-    name: string,
-    options: { type: ColumnDescriptor; nullable?: true; default?: ColumnDefault },
-  ): DynamicTableBuilder;
-  generated(
-    name: string,
-    options: { type: ColumnDescriptor; generated: ExecutionMutationDefaultValue },
-  ): DynamicTableBuilder;
-  unique(columns: readonly string[]): DynamicTableBuilder;
-  primaryKey(columns: readonly string[]): DynamicTableBuilder;
-  index(columns: readonly string[]): DynamicTableBuilder;
-  foreignKey(
-    columns: readonly string[],
-    references: { table: string; columns: readonly string[] },
-    options?: { onDelete?: string; onUpdate?: string },
-  ): DynamicTableBuilder;
-};
-
-type DynamicModelBuilder = {
-  field(name: string, column: string): DynamicModelBuilder;
-  relation(
-    name: string,
-    options: {
-      toModel: string;
-      toTable: string;
-      cardinality: '1:1' | '1:N' | 'N:1';
-      on: {
-        parentTable: string;
-        parentColumns: readonly string[];
-        childTable: string;
-        childColumns: readonly string[];
-      };
-    },
-  ): DynamicModelBuilder;
-};
-
-type DynamicContractBuilder = {
-  target(target: TargetPackRef<'sql', 'postgres'>): DynamicContractBuilder;
-  storageType(
-    name: string,
-    typeInstance: {
-      codecId: string;
-      nativeType: string;
-      typeParams: Record<string, unknown>;
-    },
-  ): DynamicContractBuilder;
-  table(
-    name: string,
-    callback: (tableBuilder: DynamicTableBuilder) => DynamicTableBuilder,
-  ): DynamicContractBuilder;
-  model(
-    name: string,
-    table: string,
-    callback: (modelBuilder: DynamicModelBuilder) => DynamicModelBuilder,
-  ): DynamicContractBuilder;
-  build(): ContractIR;
-};
-
-function lowerFirst(value: string): string {
-  if (value.length === 0) return value;
-  return value[0]?.toLowerCase() + value.slice(1);
-}
-
-function getAttribute(attributes: readonly PslAttribute[], name: string): PslAttribute | undefined {
-  return attributes.find((attribute) => attribute.name === name);
+  readonly composedExtensionPackRefs?: readonly ExtensionPackRef<'sql', 'postgres'>[];
+  readonly controlMutationDefaults?: ControlMutationDefaults;
+  readonly authoringContributions?: AuthoringContributions;
 }
 
-function getNamedArgument(attribute: PslAttribute, name: string): string | undefined {
-  const entry = attribute.args.find((arg) => arg.kind === 'named' && arg.name === name);
-  if (!entry || entry.kind !== 'named') {
+function buildComposedExtensionPackRefs(
+  target: TargetPackRef<'sql', 'postgres'>,
+  extensionIds: readonly string[],
+  extensionPackRefs: readonly ExtensionPackRef<'sql', 'postgres'>[] = [],
+): Record<string, ExtensionPackRef<'sql', 'postgres'>> | undefined {
+  if (extensionIds.length === 0) {
     return undefined;
   }
-  return entry.value;
-}
 
-function getPositionalArgument(attribute: PslAttribute, index = 0): string | undefined {
-  const entries = attribute.args.filter((arg) => arg.kind === 'positional');
-  const entry = entries[index];
-  if (!entry || entry.kind !== 'positional') {
-    return undefined;
-  }
-  return entry.value;
+  const extensionPackRefById = new Map(extensionPackRefs.map((packRef) => [packRef.id, packRef]));
+
+  return Object.fromEntries(
+    extensionIds.map((extensionId) => [
+      extensionId,
+      extensionPackRefById.get(extensionId) ??
+        ({
+          kind: 'extension',
+          id: extensionId,
+          familyId: target.familyId,
+          targetId: target.targetId,
+          version: '0.0.1',
+        } satisfies ExtensionPackRef<'sql', 'postgres'>),
+    ]),
+  );
 }
 
-function getPositionalArgumentEntry(
-  attribute: PslAttribute,
-  index = 0,
-): { value: string; span: PslSpan } | undefined {
-  const entries = attribute.args.filter((arg) => arg.kind === 'positional');
-  const entry = entries[index];
-  if (!entry || entry.kind !== 'positional') {
-    return undefined;
-  }
-  return {
-    value: entry.value,
-    span: entry.span,
-  };
+function diagnosticDedupKey(diagnostic: ContractSourceDiagnostic): string {
+  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 unquoteStringLiteral(value: string): string {
-  const trimmed = value.trim();
-  const match = trimmed.match(/^(['"])(.*)\1$/);
-  if (!match) {
-    return trimmed;
+function dedupeDiagnostics(
+  diagnostics: readonly ContractSourceDiagnostic[],
+): ContractSourceDiagnostic[] {
+  const seen = new Map<string, ContractSourceDiagnostic>();
+  for (const diagnostic of diagnostics) {
+    const key = diagnosticDedupKey(diagnostic);
+    if (!seen.has(key)) {
+      seen.set(key, diagnostic);
+    }
   }
-  return match[2] ?? '';
+  return [...seen.values()];
 }
 
-function parseQuotedStringLiteral(value: string): string | undefined {
-  const trimmed = value.trim();
-  // This intentionally accepts either '...' or "..." and relies on PSL's
-  // own string literal rules to disallow unescaped interior delimiters.
-  const match = trimmed.match(/^(['"])(.*)\1$/);
-  if (!match) {
-    return undefined;
+function compareStrings(left: string, right: string): -1 | 0 | 1 {
+  if (left < right) {
+    return -1;
   }
-  return match[2] ?? '';
-}
-
-function parseFieldList(value: string): readonly string[] | undefined {
-  const trimmed = value.trim();
-  if (!trimmed.startsWith('[') || !trimmed.endsWith(']')) {
-    return undefined;
+  if (left > right) {
+    return 1;
   }
-  const body = trimmed.slice(1, -1);
-  const parts = body
-    .split(',')
-    .map((entry) => entry.trim())
-    .filter((entry) => entry.length > 0);
-  return parts;
+  return 0;
 }
 
-function parseDefaultLiteralValue(expression: string): ColumnDefault | undefined {
-  const trimmed = expression.trim();
-  if (trimmed === 'true' || trimmed === 'false') {
-    return { kind: 'literal', value: trimmed === 'true' };
-  }
-  const numericValue = Number(trimmed);
-  if (!Number.isNaN(numericValue) && trimmed.length > 0 && !/^(['"]).*\1$/.test(trimmed)) {
-    return { kind: 'literal', value: numericValue };
-  }
-  if (/^(['"]).*\1$/.test(trimmed)) {
-    return { kind: 'literal', value: unquoteStringLiteral(trimmed) };
-  }
-  return undefined;
+function mapParserDiagnostics(document: ParsePslDocumentResult): ContractSourceDiagnostic[] {
+  return document.diagnostics.map((diagnostic) => ({
+    code: diagnostic.code,
+    message: diagnostic.message,
+    sourceId: diagnostic.sourceId,
+    span: diagnostic.span,
+  }));
 }
 
-function lowerDefaultForField(input: {
-  readonly modelName: string;
-  readonly fieldName: string;
-  readonly defaultAttribute: PslAttribute;
+interface ProcessEnumDeclarationsInput {
+  readonly enums: readonly PslEnum[];
   readonly sourceId: string;
-  readonly defaultFunctionRegistry: DefaultFunctionRegistry;
+  readonly enumTypeConstructor: AuthoringTypeConstructorDescriptor | undefined;
   readonly diagnostics: ContractSourceDiagnostic[];
-}): {
-  readonly defaultValue?: ColumnDefault;
-  readonly executionDefault?: ExecutionMutationDefaultValue;
-} {
-  const positionalEntries = input.defaultAttribute.args.filter((arg) => arg.kind === 'positional');
-  const namedEntries = input.defaultAttribute.args.filter((arg) => arg.kind === 'named');
-
-  if (namedEntries.length > 0 || positionalEntries.length !== 1) {
-    input.diagnostics.push({
-      code: 'PSL_INVALID_DEFAULT_FUNCTION_ARGUMENT',
-      message: `Field "${input.modelName}.${input.fieldName}" requires exactly one positional @default(...) expression.`,
-      sourceId: input.sourceId,
-      span: input.defaultAttribute.span,
-    });
-    return {};
-  }
-
-  const expressionEntry = getPositionalArgumentEntry(input.defaultAttribute);
-  if (!expressionEntry) {
-    input.diagnostics.push({
-      code: 'PSL_INVALID_DEFAULT_FUNCTION_ARGUMENT',
-      message: `Field "${input.modelName}.${input.fieldName}" requires a positional @default(...) expression.`,
-      sourceId: input.sourceId,
-      span: input.defaultAttribute.span,
-    });
-    return {};
-  }
+}
 
-  const literalDefault = parseDefaultLiteralValue(expressionEntry.value);
-  if (literalDefault) {
-    return { defaultValue: literalDefault };
-  }
+function processEnumDeclarations(input: ProcessEnumDeclarationsInput): {
+  readonly storageTypes: Record<string, StorageTypeInstance>;
+  readonly enumTypeDescriptors: Map<string, ColumnDescriptor>;
+} {
+  const storageTypes: Record<string, StorageTypeInstance> = {};
+  const enumTypeDescriptors = new Map<string, ColumnDescriptor>();
 
-  const defaultFunctionCall = parseDefaultFunctionCall(expressionEntry.value, expressionEntry.span);
-  if (!defaultFunctionCall) {
-    input.diagnostics.push({
-      code: 'PSL_INVALID_DEFAULT_VALUE',
-      message: `Unsupported default value "${expressionEntry.value}"`,
+  for (const enumDeclaration of input.enums) {
+    const nativeType = parseMapName({
+      attribute: getAttribute(enumDeclaration.attributes, 'map'),
+      defaultValue: enumDeclaration.name,
       sourceId: input.sourceId,
-      span: input.defaultAttribute.span,
+      diagnostics: input.diagnostics,
+      entityLabel: `Enum "${enumDeclaration.name}"`,
+      span: enumDeclaration.span,
     });
-    return {};
+    const enumStorageType = input.enumTypeConstructor
+      ? instantiateAuthoringTypeConstructor(input.enumTypeConstructor, [
+          nativeType,
+          enumDeclaration.values.map((value) => value.name),
+        ])
+      : {
+          codecId: 'pg/enum@1',
+          nativeType,
+          typeParams: { values: enumDeclaration.values.map((value) => value.name) },
+        };
+    const descriptor: ColumnDescriptor = {
+      codecId: enumStorageType.codecId,
+      nativeType: enumStorageType.nativeType,
+      typeRef: enumDeclaration.name,
+    };
+    enumTypeDescriptors.set(enumDeclaration.name, descriptor);
+    storageTypes[enumDeclaration.name] = {
+      codecId: enumStorageType.codecId,
+      nativeType: enumStorageType.nativeType,
+      typeParams: enumStorageType.typeParams ?? {
+        values: enumDeclaration.values.map((value) => value.name),
+      },
+    };
   }
 
-  const lowered = lowerDefaultFunctionWithRegistry({
-    call: defaultFunctionCall,
-    registry: input.defaultFunctionRegistry,
-    context: {
-      sourceId: input.sourceId,
-      modelName: input.modelName,
-      fieldName: input.fieldName,
-    },
-  });
-
-  if (!lowered.ok) {
-    input.diagnostics.push(lowered.diagnostic);
-    return {};
-  }
+  return { storageTypes, enumTypeDescriptors };
+}
 
-  if (lowered.value.kind === 'storage') {
-    return { defaultValue: lowered.value.defaultValue };
-  }
-  return { executionDefault: lowered.value.generated };
+interface ResolveNamedTypeDeclarationsInput {
+  readonly declarations: readonly PslNamedTypeDeclaration[];
+  readonly sourceId: string;
+  readonly enumTypeDescriptors: ReadonlyMap<string, ColumnDescriptor>;
+  readonly scalarTypeDescriptors: ReadonlyMap<string, ColumnDescriptor>;
+  readonly composedExtensions: ReadonlySet<string>;
+  readonly familyId: string;
+  readonly targetId: string;
+  readonly authoringContributions: AuthoringContributions | undefined;
+  readonly diagnostics: ContractSourceDiagnostic[];
 }
 
-function parseMapName(input: {
-  readonly attribute: PslAttribute | undefined;
-  readonly defaultValue: string;
+function validateNamedTypeAttributes(input: {
+  readonly declaration: PslNamedTypeDeclaration;
   readonly sourceId: string;
   readonly diagnostics: ContractSourceDiagnostic[];
-  readonly entityLabel: string;
-  readonly span: PslSpan;
-}): string {
-  if (!input.attribute) {
-    return input.defaultValue;
-  }
+  readonly composedExtensions: ReadonlySet<string>;
+  readonly allowDbNativeType: boolean;
+  readonly familyId: string;
+  readonly targetId: string;
+}): {
+  readonly dbNativeTypeAttribute: PslAttribute | undefined;
+  readonly hasUnsupportedNamedTypeAttribute: boolean;
+} {
+  const dbNativeTypeAttributes = input.allowDbNativeType
+    ? input.declaration.attributes.filter((attribute) => attribute.name.startsWith('db.'))
+    : [];
+  const [dbNativeTypeAttribute, ...extraDbNativeTypeAttributes] = dbNativeTypeAttributes;
+  let hasUnsupportedNamedTypeAttribute = false;
 
-  const value = getPositionalArgument(input.attribute);
-  if (!value) {
-    input.diagnostics.push({
-      code: 'PSL_INVALID_ATTRIBUTE_ARGUMENT',
-      message: `${input.entityLabel} @map requires a positional quoted string literal argument`,
-      sourceId: input.sourceId,
-      span: input.attribute.span,
-    });
-    return input.defaultValue;
-  }
-  const parsed = parseQuotedStringLiteral(value);
-  if (parsed === undefined) {
+  for (const extra of extraDbNativeTypeAttributes) {
     input.diagnostics.push({
       code: 'PSL_INVALID_ATTRIBUTE_ARGUMENT',
-      message: `${input.entityLabel} @map requires a positional quoted string literal argument`,
+      message: `Named type "${input.declaration.name}" can declare at most one @db.* attribute`,
       sourceId: input.sourceId,
-      span: input.attribute.span,
+      span: extra.span,
     });
-    return input.defaultValue;
+    hasUnsupportedNamedTypeAttribute = true;
   }
-  return parsed;
-}
 
-function parsePgvectorLength(input: {
-  readonly attribute: PslAttribute;
-  readonly diagnostics: ContractSourceDiagnostic[];
-  readonly sourceId: string;
-}): number | undefined {
-  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,
+  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,
     });
-    return undefined;
-  }
-  const parsed = Number(unquoteStringLiteral(raw));
-  if (!Number.isInteger(parsed) || parsed < 1) {
+    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_INVALID_ATTRIBUTE_ARGUMENT',
-      message: '@pgvector.column length/dim must be a positive integer',
+      code: 'PSL_UNSUPPORTED_NAMED_TYPE_ATTRIBUTE',
+      message: `Named type "${input.declaration.name}" uses unsupported attribute "${attribute.name}"`,
       sourceId: input.sourceId,
-      span: input.attribute.span,
+      span: attribute.span,
     });
-    return undefined;
+    hasUnsupportedNamedTypeAttribute = true;
   }
-  return parsed;
-}
 
-function resolveColumnDescriptor(
-  field: PslField,
-  enumTypeDescriptors: Map<string, ColumnDescriptor>,
-  namedTypeDescriptors: Map<string, ColumnDescriptor>,
-): ColumnDescriptor | undefined {
-  if (field.typeRef && namedTypeDescriptors.has(field.typeRef)) {
-    return namedTypeDescriptors.get(field.typeRef);
-  }
-  if (namedTypeDescriptors.has(field.typeName)) {
-    return namedTypeDescriptors.get(field.typeName);
-  }
-  if (enumTypeDescriptors.has(field.typeName)) {
-    return enumTypeDescriptors.get(field.typeName);
-  }
-  return SCALAR_COLUMN_MAP[field.typeName];
+  return { dbNativeTypeAttribute, hasUnsupportedNamedTypeAttribute };
 }
 
-function collectResolvedFields(
-  model: PslModel,
-  mapping: ModelNameMapping,
-  enumTypeDescriptors: Map<string, ColumnDescriptor>,
-  namedTypeDescriptors: Map<string, ColumnDescriptor>,
-  namedTypeBaseTypes: Map<string, string>,
-  modelNames: Set<string>,
-  composedExtensions: Set<string>,
-  defaultFunctionRegistry: DefaultFunctionRegistry,
-  diagnostics: ContractSourceDiagnostic[],
-  sourceId: string,
-): ResolvedField[] {
-  const resolvedFields: ResolvedField[] = [];
+function resolveNamedTypeDeclarations(input: ResolveNamedTypeDeclarationsInput): {
+  readonly storageTypes: Record<string, StorageTypeInstance>;
+  readonly namedTypeDescriptors: Map<string, ColumnDescriptor>;
+} {
+  const storageTypes: Record<string, StorageTypeInstance> = {};
+  const namedTypeDescriptors = new Map<string, ColumnDescriptor>();
 
-  for (const field of model.fields) {
-    if (field.list) {
-      if (modelNames.has(field.typeName)) {
+  for (const declaration of input.declarations) {
+    if (declaration.typeConstructor) {
+      const { hasUnsupportedNamedTypeAttribute } = validateNamedTypeAttributes({
+        declaration,
+        sourceId: input.sourceId,
+        diagnostics: input.diagnostics,
+        composedExtensions: input.composedExtensions,
+        allowDbNativeType: false,
+        familyId: input.familyId,
+        targetId: input.targetId,
+      });
+      if (hasUnsupportedNamedTypeAttribute) {
         continue;
       }
-      diagnostics.push({
-        code: 'PSL_UNSUPPORTED_FIELD_LIST',
-        message: `Field "${model.name}.${field.name}" uses a scalar/storage list type, which is not supported in SQL PSL provider v1. Model-typed lists are only supported as backrelation navigation fields when they match an FK-side relation.`,
-        sourceId,
-        span: field.span,
-      });
-      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'
-      ) {
+      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;
       }
-      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,
-        });
+
+      const storageType = instantiatePslTypeConstructor({
+        call: declaration.typeConstructor,
+        descriptor: typeConstructor,
+        diagnostics: input.diagnostics,
+        sourceId: input.sourceId,
+        entityLabel: `Named type "${declaration.name}"`,
+      });
+      if (!storageType) {
         continue;
       }
-      diagnostics.push({
-        code: 'PSL_UNSUPPORTED_FIELD_ATTRIBUTE',
-        message: `Field "${model.name}.${field.name}" uses unsupported attribute "@${attribute.name}"`,
-        sourceId,
-        span: attribute.span,
-      });
-    }
 
-    const relationAttribute = getAttribute(field.attributes, 'relation');
-    if (relationAttribute && modelNames.has(field.typeName)) {
+      namedTypeDescriptors.set(
+        declaration.name,
+        toNamedTypeFieldDescriptor(declaration.name, storageType),
+      );
+      storageTypes[declaration.name] = {
+        codecId: storageType.codecId,
+        nativeType: storageType.nativeType,
+        typeParams: storageType.typeParams ?? {},
+      };
       continue;
     }
 
-    let descriptor = resolveColumnDescriptor(field, enumTypeDescriptors, namedTypeDescriptors);
-    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 {
-        const isBytesBase =
-          field.typeName === 'Bytes' ||
-          namedTypeBaseTypes.get(field.typeRef ?? field.typeName) === 'Bytes';
-        if (!isBytesBase) {
-          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,
-          });
-          if (length !== undefined) {
-            descriptor = {
-              codecId: 'pg/vector@1',
-              nativeType: `vector(${length})`,
-              typeParams: { length },
-            };
-          }
-        }
-      }
+    // Parser invariant: when typeConstructor is absent, baseType is defined.
+    // The check below narrows `baseType` for TypeScript and guards against a
+    // parser regression; it is unreachable under a correct parser.
+    if (declaration.baseType === undefined) {
+      input.diagnostics.push({
+        code: 'PSL_UNSUPPORTED_NAMED_TYPE_BASE',
+        message: `Named type "${declaration.name}" must declare a base type or constructor`,
+        sourceId: input.sourceId,
+        span: declaration.span,
+      });
+      continue;
     }
-
-    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,
+    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,
       });
       continue;
     }
 
-    const defaultAttribute = getAttribute(field.attributes, 'default');
-    const loweredDefault = defaultAttribute
-      ? lowerDefaultForField({
-          modelName: model.name,
-          fieldName: field.name,
-          defaultAttribute,
-          sourceId,
-          defaultFunctionRegistry,
-          diagnostics,
-        })
-      : {};
-    if (field.optional && loweredDefault.executionDefault) {
-      const generatorDescription =
-        loweredDefault.executionDefault.kind === 'generator'
-          ? `"${loweredDefault.executionDefault.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.`,
-        sourceId,
-        span: defaultAttribute?.span ?? field.span,
-      });
+    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 (loweredDefault.executionDefault) {
-      const generatedDescriptor = resolveGeneratedColumnDescriptor(loweredDefault.executionDefault);
-      if (generatedDescriptor) {
-        descriptor = generatedDescriptor;
+
+    if (dbNativeTypeAttribute) {
+      const descriptor = resolveDbNativeTypeAttribute({
+        attribute: dbNativeTypeAttribute,
+        baseType,
+        baseDescriptor,
+        diagnostics: input.diagnostics,
+        sourceId: input.sourceId,
+        entityLabel: `Named type "${declaration.name}"`,
+      });
+      if (!descriptor) {
+        continue;
       }
+      namedTypeDescriptors.set(
+        declaration.name,
+        toNamedTypeFieldDescriptor(declaration.name, descriptor),
+      );
+      storageTypes[declaration.name] = {
+        codecId: descriptor.codecId,
+        nativeType: descriptor.nativeType,
+        typeParams: descriptor.typeParams ?? {},
+      };
+      continue;
     }
-    const mappedColumnName = mapping.fieldColumns.get(field.name) ?? field.name;
-    resolvedFields.push({
-      field,
-      columnName: mappedColumnName,
-      descriptor,
-      ...ifDefined('defaultValue', loweredDefault.defaultValue),
-      ...ifDefined('executionDefault', loweredDefault.executionDefault),
-      isId: Boolean(getAttribute(field.attributes, 'id')),
-      isUnique: Boolean(getAttribute(field.attributes, 'unique')),
-    });
+
+    const descriptor = toNamedTypeFieldDescriptor(declaration.name, baseDescriptor);
+    namedTypeDescriptors.set(declaration.name, descriptor);
+    storageTypes[declaration.name] = {
+      codecId: baseDescriptor.codecId,
+      nativeType: baseDescriptor.nativeType,
+      typeParams: {},
+    };
   }
 
-  return resolvedFields;
+  return { storageTypes, namedTypeDescriptors };
 }
 
-function hasSameSpan(a: PslSpan, b: ContractSourceDiagnosticSpan): boolean {
-  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
-  );
+interface BuildModelNodeInput {
+  readonly model: PslModel;
+  readonly mapping: ModelNameMapping;
+  readonly modelMappings: ReadonlyMap<string, ModelNameMapping>;
+  readonly modelNames: Set<string>;
+  readonly compositeTypeNames: ReadonlySet<string>;
+  readonly enumTypeDescriptors: Map<string, ColumnDescriptor>;
+  readonly namedTypeDescriptors: Map<string, ColumnDescriptor>;
+  readonly composedExtensions: Set<string>;
+  readonly familyId: string;
+  readonly targetId: string;
+  readonly authoringContributions: AuthoringContributions | undefined;
+  readonly defaultFunctionRegistry: ControlMutationDefaultRegistry;
+  readonly generatorDescriptorById: ReadonlyMap<string, MutationDefaultGeneratorDescriptor>;
+  readonly scalarTypeDescriptors: ReadonlyMap<string, ColumnDescriptor>;
+  readonly sourceId: string;
+  readonly diagnostics: ContractSourceDiagnostic[];
 }
 
-function compareStrings(left: string, right: string): -1 | 0 | 1 {
-  if (left < right) {
-    return -1;
-  }
-  if (left > right) {
-    return 1;
-  }
-  return 0;
+interface BuildModelNodeResult {
+  readonly modelNode: ModelNode;
+  readonly fkRelationMetadata: FkRelationMetadata[];
+  readonly backrelationCandidates: ModelBackrelationCandidate[];
+  readonly resolvedFields: readonly ResolvedField[];
 }
 
-function indexFkRelations(input: { readonly fkRelationMetadata: readonly FkRelationMetadata[] }): {
-  readonly modelRelations: Map<string, ModelRelationMetadata[]>;
-  readonly fkRelationsByPair: Map<string, FkRelationMetadata[]>;
-} {
-  const modelRelations = new Map<string, ModelRelationMetadata[]>();
-  const fkRelationsByPair = new Map<string, FkRelationMetadata[]>();
-
-  for (const relation of input.fkRelationMetadata) {
-    const existing = modelRelations.get(relation.declaringModelName);
-    const current = existing ?? [];
-    if (!existing) {
-      modelRelations.set(relation.declaringModelName, current);
-    }
-    current.push({
-      fieldName: relation.declaringFieldName,
-      toModel: relation.targetModelName,
-      toTable: relation.targetTableName,
-      cardinality: 'N:1',
-      parentTable: relation.declaringTableName,
-      parentColumns: relation.localColumns,
-      childTable: relation.targetTableName,
-      childColumns: relation.referencedColumns,
-    });
+function buildModelNodeFromPsl(input: BuildModelNodeInput): BuildModelNodeResult {
+  const { model, mapping, sourceId, diagnostics } = input;
+  const tableName = mapping.tableName;
+
+  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 pairKey = fkRelationPairKey(relation.declaringModelName, relation.targetModelName);
-    const pairRelations = fkRelationsByPair.get(pairKey);
-    if (!pairRelations) {
-      fkRelationsByPair.set(pairKey, [relation]);
-      continue;
-    }
-    pairRelations.push(relation);
-  }
-
-  return { modelRelations, fkRelationsByPair };
-}
-
-function applyBackrelationCandidates(input: {
-  readonly backrelationCandidates: readonly ModelBackrelationCandidate[];
-  readonly fkRelationsByPair: Map<string, readonly FkRelationMetadata[]>;
-  readonly modelRelations: Map<string, ModelRelationMetadata[]>;
-  readonly diagnostics: ContractSourceDiagnostic[];
-  readonly sourceId: string;
-}): void {
-  for (const candidate of input.backrelationCandidates) {
-    const pairKey = fkRelationPairKey(candidate.targetModelName, candidate.modelName);
-    const pairMatches = input.fkRelationsByPair.get(pairKey) ?? [];
-    const matches = candidate.relationName
-      ? pairMatches.filter((relation) => relation.relationName === candidate.relationName)
-      : [...pairMatches];
-
-    if (matches.length === 0) {
-      input.diagnostics.push({
-        code: 'PSL_ORPHANED_BACKRELATION_LIST',
-        message: `Backrelation list field "${candidate.modelName}.${candidate.field.name}" has no matching FK-side relation on model "${candidate.targetModelName}". Add @relation(fields: [...], references: [...]) on the FK-side relation or use an explicit join model for many-to-many.`,
-        sourceId: input.sourceId,
-        span: candidate.field.span,
-      });
-      continue;
-    }
-    if (matches.length > 1) {
-      input.diagnostics.push({
-        code: 'PSL_AMBIGUOUS_BACKRELATION_LIST',
-        message: `Backrelation list field "${candidate.modelName}.${candidate.field.name}" matches multiple FK-side relations on model "${candidate.targetModelName}". Add @relation(name: "...") (or @relation("...")) to both sides to disambiguate.`,
-        sourceId: input.sourceId,
-        span: candidate.field.span,
-      });
-      continue;
-    }
-
-    invariant(matches.length === 1, 'Backrelation matching requires exactly one match');
-    const matched = matches[0];
-    assertDefined(matched, 'Backrelation matching requires a defined relation match');
-
-    const existing = input.modelRelations.get(candidate.modelName);
-    const current = existing ?? [];
-    if (!existing) {
-      input.modelRelations.set(candidate.modelName, current);
-    }
-    current.push({
-      fieldName: candidate.field.name,
-      toModel: matched.declaringModelName,
-      toTable: matched.declaringTableName,
-      cardinality: '1:N',
-      parentTable: candidate.tableName,
-      parentColumns: matched.referencedColumns,
-      childTable: matched.declaringTableName,
-      childColumns: matched.localColumns,
-    });
-  }
-}
-
-function emitModelsWithRelations(input: {
-  readonly builder: DynamicContractBuilder;
-  readonly resolvedModels: ResolvedModelEntry[];
-  readonly modelRelations: Map<string, readonly ModelRelationMetadata[]>;
-}): DynamicContractBuilder {
-  let nextBuilder = input.builder;
-
-  const sortedModels = input.resolvedModels.sort((left, right) => {
-    const tableComparison = compareStrings(left.mapping.tableName, right.mapping.tableName);
-    if (tableComparison === 0) {
-      return compareStrings(left.model.name, right.model.name);
-    }
-    return tableComparison;
-  });
-
-  for (const entry of sortedModels) {
-    const relationEntries = [...(input.modelRelations.get(entry.model.name) ?? [])].sort(
-      (left, right) => compareStrings(left.fieldName, right.fieldName),
-    );
-    nextBuilder = nextBuilder.model(
-      entry.model.name,
-      entry.mapping.tableName,
-      (modelBuilder: DynamicModelBuilder) => {
-        let next = modelBuilder;
-        for (const resolvedField of entry.resolvedFields) {
-          next = next.field(resolvedField.field.name, resolvedField.columnName);
-        }
-        for (const relation of relationEntries) {
-          next = next.relation(relation.fieldName, {
-            toModel: relation.toModel,
-            toTable: relation.toTable,
-            cardinality: relation.cardinality,
-            on: {
-              parentTable: relation.parentTable,
-              parentColumns: relation.parentColumns,
-              childTable: relation.childTable,
-              childColumns: relation.childColumns,
-            },
-          });
-        }
-        return next;
-      },
-    );
-  }
-
-  return nextBuilder;
-}
-
-function mapParserDiagnostics(document: ParsePslDocumentResult): ContractSourceDiagnostic[] {
-  return document.diagnostics.map((diagnostic) => ({
-    code: diagnostic.code,
-    message: diagnostic.message,
-    sourceId: diagnostic.sourceId,
-    span: diagnostic.span,
-  }));
-}
-
-function normalizeReferentialAction(input: {
-  readonly modelName: string;
-  readonly fieldName: string;
-  readonly actionName: 'onDelete' | 'onUpdate';
-  readonly actionToken: string;
-  readonly sourceId: string;
-  readonly span: PslSpan;
-  readonly diagnostics: ContractSourceDiagnostic[];
-}): string | undefined {
-  const normalized =
-    REFERENTIAL_ACTION_MAP[input.actionToken as keyof typeof REFERENTIAL_ACTION_MAP];
-  if (normalized) {
-    return normalized;
-  }
-
-  input.diagnostics.push({
-    code: 'PSL_UNSUPPORTED_REFERENTIAL_ACTION',
-    message: `Relation field "${input.modelName}.${input.fieldName}" has unsupported ${input.actionName} action "${input.actionToken}"`,
-    sourceId: input.sourceId,
-    span: input.span,
-  });
-  return undefined;
-}
-
-function parseAttributeFieldList(input: {
-  readonly attribute: PslAttribute;
-  readonly sourceId: string;
-  readonly diagnostics: ContractSourceDiagnostic[];
-  readonly code: string;
-  readonly messagePrefix: string;
-}): readonly string[] | undefined {
-  const raw = getNamedArgument(input.attribute, 'fields') ?? getPositionalArgument(input.attribute);
-  if (!raw) {
-    input.diagnostics.push({
-      code: input.code,
-      message: `${input.messagePrefix} requires fields list argument`,
-      sourceId: input.sourceId,
-      span: input.attribute.span,
-    });
-    return undefined;
-  }
-  const fields = parseFieldList(raw);
-  if (!fields || fields.length === 0) {
-    input.diagnostics.push({
-      code: input.code,
-      message: `${input.messagePrefix} requires bracketed field list argument`,
-      sourceId: input.sourceId,
-      span: input.attribute.span,
+  const primaryKeyFields = resolvedFields.filter((field) => field.isId);
+  const primaryKeyColumns = primaryKeyFields.map((field) => field.columnName);
+  const primaryKeyName = primaryKeyFields.length === 1 ? primaryKeyFields[0]?.idName : undefined;
+  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`,
+      sourceId,
+      span: model.span,
     });
-    return undefined;
   }
-  return fields;
-}
 
-function mapFieldNamesToColumns(input: {
-  readonly modelName: string;
-  readonly fieldNames: readonly string[];
-  readonly mapping: ModelNameMapping;
-  readonly sourceId: string;
-  readonly diagnostics: ContractSourceDiagnostic[];
-  readonly span: PslSpan;
-  readonly contextLabel: string;
-}): readonly string[] | undefined {
-  const columns: string[] = [];
-  for (const fieldName of input.fieldNames) {
-    const columnName = input.mapping.fieldColumns.get(fieldName);
-    if (!columnName) {
-      input.diagnostics.push({
-        code: 'PSL_INVALID_ATTRIBUTE_ARGUMENT',
-        message: `${input.contextLabel} references unknown field "${input.modelName}.${fieldName}"`,
-        sourceId: input.sourceId,
-        span: input.span,
-      });
-      return undefined;
+  const resultBackrelationCandidates: ModelBackrelationCandidate[] = [];
+  for (const field of model.fields) {
+    if (!field.list || !input.modelNames.has(field.typeName)) {
+      continue;
     }
-    columns.push(columnName);
-  }
-  return columns;
-}
-
-function buildModelMappings(
-  models: readonly PslModel[],
-  diagnostics: ContractSourceDiagnostic[],
-  sourceId: string,
-): Map<string, ModelNameMapping> {
-  const result = new Map<string, ModelNameMapping>();
-  for (const model of models) {
-    const mapAttribute = getAttribute(model.attributes, 'map');
-    const tableName = parseMapName({
-      attribute: mapAttribute,
-      defaultValue: lowerFirst(model.name),
+    const attributesValid = validateNavigationListFieldAttributes({
+      modelName: model.name,
+      field,
       sourceId,
+      composedExtensions: input.composedExtensions,
       diagnostics,
-      entityLabel: `Model "${model.name}"`,
-      span: model.span,
+      familyId: input.familyId,
+      targetId: input.targetId,
     });
-    const fieldColumns = new Map<string, string>();
-    for (const field of model.fields) {
-      const fieldMapAttribute = getAttribute(field.attributes, 'map');
-      const columnName = parseMapName({
-        attribute: fieldMapAttribute,
-        defaultValue: field.name,
+    const relationAttribute = getAttribute(field.attributes, 'relation');
+    let relationName: string | undefined;
+    if (relationAttribute) {
+      const parsedRelation = parseRelationAttribute({
+        attribute: relationAttribute,
+        modelName: model.name,
+        fieldName: field.name,
         sourceId,
         diagnostics,
-        entityLabel: `Field "${model.name}.${field.name}"`,
-        span: field.span,
       });
-      fieldColumns.set(field.name, columnName);
+      if (!parsedRelation) {
+        continue;
+      }
+      if (parsedRelation.fields || parsedRelation.references) {
+        diagnostics.push({
+          code: 'PSL_INVALID_RELATION_ATTRIBUTE',
+          message: `Backrelation list field "${model.name}.${field.name}" cannot declare fields/references; define them on the FK-side relation field`,
+          sourceId,
+          span: relationAttribute.span,
+        });
+        continue;
+      }
+      if (parsedRelation.onDelete || parsedRelation.onUpdate) {
+        diagnostics.push({
+          code: 'PSL_INVALID_RELATION_ATTRIBUTE',
+          message: `Backrelation list field "${model.name}.${field.name}" cannot declare onDelete/onUpdate; define referential actions on the FK-side relation field`,
+          sourceId,
+          span: relationAttribute.span,
+        });
+        continue;
+      }
+      relationName = parsedRelation.relationName;
     }
-    result.set(model.name, {
-      model,
+    if (!attributesValid) {
+      continue;
+    }
+
+    resultBackrelationCandidates.push({
+      modelName: model.name,
       tableName,
-      fieldColumns,
+      field,
+      targetModelName: field.typeName,
+      ...ifDefined('relationName', relationName),
     });
   }
-  return result;
-}
 
-function validateNavigationListFieldAttributes(input: {
-  readonly modelName: string;
-  readonly field: PslField;
-  readonly sourceId: string;
-  readonly composedExtensions: Set<string>;
-  readonly diagnostics: ContractSourceDiagnostic[];
-}): boolean {
-  let valid = true;
-  for (const attribute of input.field.attributes) {
-    if (attribute.name === 'relation') {
+  const relationAttributes = model.fields
+    .map((field) => ({
+      field,
+      relation: getAttribute(field.attributes, 'relation'),
+    }))
+    .filter((entry): entry is { field: PslField; relation: PslAttribute } =>
+      Boolean(entry.relation),
+    );
+  const uniqueConstraints: UniqueConstraintNode[] = resolvedFields
+    .filter((field) => field.isUnique)
+    .map((field) => ({
+      columns: [field.columnName],
+      ...ifDefined('name', field.uniqueName),
+    }));
+  const indexNodes: IndexNode[] = [];
+  const foreignKeyNodes: ForeignKeyNode[] = [];
+
+  for (const modelAttribute of model.attributes) {
+    if (modelAttribute.name === 'map') {
       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.`,
-        sourceId: input.sourceId,
-        span: attribute.span,
-      });
-      valid = false;
+    if (modelAttribute.name === 'discriminator' || modelAttribute.name === 'base') {
       continue;
     }
-    input.diagnostics.push({
-      code: 'PSL_UNSUPPORTED_FIELD_ATTRIBUTE',
-      message: `Field "${input.modelName}.${input.field.name}" uses unsupported attribute "@${attribute.name}"`,
-      sourceId: input.sourceId,
-      span: attribute.span,
-    });
-    valid = false;
-  }
-  return valid;
-}
-
-function parseRelationAttribute(input: {
-  readonly attribute: PslAttribute;
-  readonly modelName: string;
-  readonly fieldName: string;
-  readonly sourceId: string;
-  readonly diagnostics: ContractSourceDiagnostic[];
-}): ParsedRelationAttribute | undefined {
-  const positionalEntries = input.attribute.args.filter((arg) => arg.kind === 'positional');
-  if (positionalEntries.length > 1) {
-    input.diagnostics.push({
-      code: 'PSL_INVALID_RELATION_ATTRIBUTE',
-      message: `Relation field "${input.modelName}.${input.fieldName}" has too many positional arguments`,
-      sourceId: input.sourceId,
-      span: input.attribute.span,
-    });
-    return undefined;
-  }
-
-  let relationNameFromPositional: string | undefined;
-  const positionalNameEntry = getPositionalArgumentEntry(input.attribute);
-  if (positionalNameEntry) {
-    const parsedName = parseQuotedStringLiteral(positionalNameEntry.value);
-    if (!parsedName) {
-      input.diagnostics.push({
-        code: 'PSL_INVALID_RELATION_ATTRIBUTE',
-        message: `Relation field "${input.modelName}.${input.fieldName}" positional relation name must be a quoted string literal`,
-        sourceId: input.sourceId,
-        span: positionalNameEntry.span,
+    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}`,
       });
-      return undefined;
-    }
-    relationNameFromPositional = parsedName;
-  }
-
-  for (const arg of input.attribute.args) {
-    if (arg.kind === 'positional') {
+      if (!fieldNames) {
+        continue;
+      }
+      const columnNames = mapFieldNamesToColumns({
+        modelName: model.name,
+        fieldNames,
+        mapping,
+        sourceId,
+        diagnostics,
+        span: modelAttribute.span,
+        contextLabel: `Model "${model.name}" @@${modelAttribute.name}`,
+      });
+      if (!columnNames) {
+        continue;
+      }
+      const constraintName = parseConstraintMapArgument({
+        attribute: modelAttribute,
+        sourceId,
+        diagnostics,
+        entityLabel: `Model "${model.name}" @@${modelAttribute.name}`,
+        span: modelAttribute.span,
+        code: 'PSL_INVALID_ATTRIBUTE_ARGUMENT',
+      });
+      if (modelAttribute.name === 'unique') {
+        uniqueConstraints.push({
+          columns: columnNames,
+          ...ifDefined('name', constraintName),
+        });
+      } else {
+        indexNodes.push({
+          columns: columnNames,
+          ...ifDefined('name', constraintName),
+        });
+      }
       continue;
     }
-    if (
-      arg.name !== 'name' &&
-      arg.name !== 'fields' &&
-      arg.name !== 'references' &&
-      arg.name !== 'onDelete' &&
-      arg.name !== 'onUpdate'
-    ) {
-      input.diagnostics.push({
-        code: 'PSL_INVALID_RELATION_ATTRIBUTE',
-        message: `Relation field "${input.modelName}.${input.fieldName}" has unsupported argument "${arg.name}"`,
-        sourceId: input.sourceId,
-        span: arg.span,
+    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,
+        diagnostics,
       });
-      return undefined;
+      continue;
     }
-  }
-
-  const namedRelationNameRaw = getNamedArgument(input.attribute, 'name');
-  const namedRelationName = namedRelationNameRaw
-    ? parseQuotedStringLiteral(namedRelationNameRaw)
-    : undefined;
-  if (namedRelationNameRaw && !namedRelationName) {
-    input.diagnostics.push({
-      code: 'PSL_INVALID_RELATION_ATTRIBUTE',
-      message: `Relation field "${input.modelName}.${input.fieldName}" named relation name must be a quoted string literal`,
-      sourceId: input.sourceId,
-      span: input.attribute.span,
-    });
-    return undefined;
-  }
-
-  if (
-    relationNameFromPositional &&
-    namedRelationName &&
-    relationNameFromPositional !== namedRelationName
-  ) {
-    input.diagnostics.push({
-      code: 'PSL_INVALID_RELATION_ATTRIBUTE',
-      message: `Relation field "${input.modelName}.${input.fieldName}" has conflicting positional and named relation names`,
-      sourceId: input.sourceId,
-      span: input.attribute.span,
-    });
-    return undefined;
-  }
-  const relationName = namedRelationName ?? relationNameFromPositional;
-
-  const fieldsRaw = getNamedArgument(input.attribute, 'fields');
-  const referencesRaw = getNamedArgument(input.attribute, 'references');
-  if ((fieldsRaw && !referencesRaw) || (!fieldsRaw && referencesRaw)) {
-    input.diagnostics.push({
-      code: 'PSL_INVALID_RELATION_ATTRIBUTE',
-      message: `Relation field "${input.modelName}.${input.fieldName}" requires fields and references arguments`,
-      sourceId: input.sourceId,
-      span: input.attribute.span,
+    diagnostics.push({
+      code: 'PSL_UNSUPPORTED_MODEL_ATTRIBUTE',
+      message: `Model "${model.name}" uses unsupported attribute "@@${modelAttribute.name}"`,
+      sourceId,
+      span: modelAttribute.span,
     });
-    return undefined;
   }
 
-  let fields: readonly string[] | undefined;
-  let references: readonly string[] | undefined;
-  if (fieldsRaw && referencesRaw) {
-    const parsedFields = parseFieldList(fieldsRaw);
-    const parsedReferences = parseFieldList(referencesRaw);
-    if (
-      !parsedFields ||
-      !parsedReferences ||
-      parsedFields.length === 0 ||
-      parsedReferences.length === 0
-    ) {
-      input.diagnostics.push({
-        code: 'PSL_INVALID_RELATION_ATTRIBUTE',
-        message: `Relation field "${input.modelName}.${input.fieldName}" requires bracketed fields and references lists`,
-        sourceId: input.sourceId,
-        span: input.attribute.span,
-      });
-      return undefined;
+  const resultFkRelationMetadata: FkRelationMetadata[] = [];
+  for (const relationAttribute of relationAttributes) {
+    if (relationAttribute.field.list) {
+      continue;
     }
-    fields = parsedFields;
-    references = parsedReferences;
-  }
-
-  const onDeleteArgument = getNamedArgument(input.attribute, 'onDelete');
-  const onUpdateArgument = getNamedArgument(input.attribute, 'onUpdate');
 
-  return {
-    ...ifDefined('relationName', relationName),
-    ...ifDefined('fields', fields),
-    ...ifDefined('references', references),
-    ...ifDefined('onDelete', onDeleteArgument ? unquoteStringLiteral(onDeleteArgument) : undefined),
-    ...ifDefined('onUpdate', onUpdateArgument ? unquoteStringLiteral(onUpdateArgument) : undefined),
-  };
-}
-
-export function interpretPslDocumentToSqlContractIR(
-  input: InterpretPslDocumentToSqlContractIRInput,
-): Result<ContractIR, ContractSourceDiagnostics> {
-  const diagnostics: ContractSourceDiagnostic[] = mapParserDiagnostics(input.document);
-  const modelNames = new Set(input.document.ast.models.map((model) => model.name));
-  const sourceId = input.document.ast.sourceId;
-  const composedExtensions = new Set(input.composedExtensionPacks ?? []);
-  const defaultFunctionRegistry =
-    input.defaultFunctionRegistry ?? createBuiltinDefaultFunctionRegistry();
-
-  let builder = defineContract().target(
-    input.target ?? DEFAULT_POSTGRES_TARGET,
-  ) as unknown as DynamicContractBuilder;
-  const enumTypeDescriptors = new Map<string, ColumnDescriptor>();
-  const namedTypeDescriptors = new Map<string, ColumnDescriptor>();
-  const namedTypeBaseTypes = new Map<string, string>();
-
-  for (const enumDeclaration of input.document.ast.enums) {
-    const nativeType = enumDeclaration.name.toLowerCase();
-    const descriptor: ColumnDescriptor = {
-      codecId: 'pg/enum@1',
-      nativeType,
-      typeRef: enumDeclaration.name,
-    };
-    enumTypeDescriptors.set(enumDeclaration.name, descriptor);
-    builder = builder.storageType(enumDeclaration.name, {
-      codecId: 'pg/enum@1',
-      nativeType,
-      typeParams: { values: enumDeclaration.values.map((value) => value.name) },
-    });
-  }
-
-  for (const declaration of input.document.ast.types?.declarations ?? []) {
-    const baseDescriptor =
-      enumTypeDescriptors.get(declaration.baseType) ?? SCALAR_COLUMN_MAP[declaration.baseType];
-    if (!baseDescriptor) {
+    if (!input.modelNames.has(relationAttribute.field.typeName)) {
       diagnostics.push({
-        code: 'PSL_UNSUPPORTED_NAMED_TYPE_BASE',
-        message: `Named type "${declaration.name}" references unsupported base type "${declaration.baseType}"`,
+        code: 'PSL_INVALID_RELATION_TARGET',
+        message: `Relation field "${model.name}.${relationAttribute.field.name}" references unknown model "${relationAttribute.field.typeName}"`,
         sourceId,
-        span: declaration.span,
+        span: relationAttribute.field.span,
       });
       continue;
     }
-    namedTypeBaseTypes.set(declaration.name, declaration.baseType);
 
-    const pgvectorAttribute = getAttribute(declaration.attributes, 'pgvector.column');
-    const unsupportedNamedTypeAttribute = declaration.attributes.find(
-      (attribute) => attribute.name !== 'pgvector.column',
-    );
-    if (unsupportedNamedTypeAttribute) {
+    const parsedRelation = parseRelationAttribute({
+      attribute: relationAttribute.relation,
+      modelName: model.name,
+      fieldName: relationAttribute.field.name,
+      sourceId,
+      diagnostics,
+    });
+    if (!parsedRelation) {
+      continue;
+    }
+    if (!parsedRelation.fields || !parsedRelation.references) {
       diagnostics.push({
-        code: 'PSL_UNSUPPORTED_NAMED_TYPE_ATTRIBUTE',
-        message: `Named type "${declaration.name}" uses unsupported attribute "${unsupportedNamedTypeAttribute.name}"`,
+        code: 'PSL_INVALID_RELATION_ATTRIBUTE',
+        message: `Relation field "${model.name}.${relationAttribute.field.name}" requires fields and references arguments`,
         sourceId,
-        span: unsupportedNamedTypeAttribute.span,
+        span: relationAttribute.relation.span,
       });
       continue;
     }
 
-    if (pgvectorAttribute) {
-      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: pgvectorAttribute.span,
-        });
-        continue;
-      }
-      if (declaration.baseType !== 'Bytes') {
-        diagnostics.push({
-          code: 'PSL_INVALID_ATTRIBUTE_ARGUMENT',
-          message: `Named type "${declaration.name}" uses @pgvector.column on unsupported base type "${declaration.baseType}"`,
-          sourceId,
-          span: pgvectorAttribute.span,
-        });
-        continue;
-      }
-      const length = parsePgvectorLength({
-        attribute: pgvectorAttribute,
-        diagnostics,
+    const targetMapping = input.modelMappings.get(relationAttribute.field.typeName);
+    if (!targetMapping) {
+      diagnostics.push({
+        code: 'PSL_INVALID_RELATION_TARGET',
+        message: `Relation field "${model.name}.${relationAttribute.field.name}" references unknown model "${relationAttribute.field.typeName}"`,
         sourceId,
-      });
-      if (length === undefined) {
-        continue;
-      }
-      namedTypeDescriptors.set(declaration.name, {
-        codecId: 'pg/vector@1',
-        nativeType: `vector(${length})`,
-        typeRef: declaration.name,
-      });
-      builder = builder.storageType(declaration.name, {
-        codecId: 'pg/vector@1',
-        nativeType: `vector(${length})`,
-        typeParams: { length },
+        span: relationAttribute.field.span,
       });
       continue;
     }
 
-    const descriptor: ColumnDescriptor = {
-      codecId: baseDescriptor.codecId,
-      nativeType: baseDescriptor.nativeType,
-      typeRef: declaration.name,
-    };
-    namedTypeDescriptors.set(declaration.name, descriptor);
-    builder = builder.storageType(declaration.name, {
-      codecId: baseDescriptor.codecId,
-      nativeType: baseDescriptor.nativeType,
-      typeParams: {},
+    const localColumns = mapFieldNamesToColumns({
+      modelName: model.name,
+      fieldNames: parsedRelation.fields,
+      mapping,
+      sourceId,
+      diagnostics,
+      span: relationAttribute.relation.span,
+      contextLabel: `Relation field "${model.name}.${relationAttribute.field.name}"`,
     });
-  }
-
-  const modelMappings = buildModelMappings(input.document.ast.models, diagnostics, sourceId);
-  const resolvedModels: Array<{
-    model: PslModel;
-    mapping: ModelNameMapping;
-    resolvedFields: ResolvedField[];
-  }> = [];
-  const fkRelationMetadata: FkRelationMetadata[] = [];
-  const backrelationCandidates: ModelBackrelationCandidate[] = [];
-
-  for (const model of input.document.ast.models) {
-    const mapping = modelMappings.get(model.name);
-    if (!mapping) {
+    if (!localColumns) {
       continue;
     }
-    const tableName = mapping.tableName;
-    const resolvedFields = collectResolvedFields(
-      model,
-      mapping,
-      enumTypeDescriptors,
-      namedTypeDescriptors,
-      namedTypeBaseTypes,
-      modelNames,
-      composedExtensions,
-      defaultFunctionRegistry,
-      diagnostics,
+    const referencedColumns = mapFieldNamesToColumns({
+      modelName: targetMapping.model.name,
+      fieldNames: parsedRelation.references,
+      mapping: targetMapping,
       sourceId,
-    );
-    resolvedModels.push({ model, mapping, resolvedFields });
-
-    const primaryKeyColumns = resolvedFields
-      .filter((field) => field.isId)
-      .map((field) => field.columnName);
-    if (primaryKeyColumns.length === 0) {
+      diagnostics,
+      span: relationAttribute.relation.span,
+      contextLabel: `Relation field "${model.name}.${relationAttribute.field.name}"`,
+    });
+    if (!referencedColumns) {
+      continue;
+    }
+    if (localColumns.length !== referencedColumns.length) {
       diagnostics.push({
-        code: 'PSL_MISSING_PRIMARY_KEY',
-        message: `Model "${model.name}" must declare at least one @id field for SQL provider`,
+        code: 'PSL_INVALID_RELATION_ATTRIBUTE',
+        message: `Relation field "${model.name}.${relationAttribute.field.name}" must provide the same number of fields and references`,
         sourceId,
-        span: model.span,
+        span: relationAttribute.relation.span,
       });
+      continue;
     }
 
-    for (const field of model.fields) {
-      if (!field.list || !modelNames.has(field.typeName)) {
+    const onDelete = parsedRelation.onDelete
+      ? normalizeReferentialAction({
+          modelName: model.name,
+          fieldName: relationAttribute.field.name,
+          actionName: 'onDelete',
+          actionToken: parsedRelation.onDelete,
+          sourceId,
+          span: relationAttribute.field.span,
+          diagnostics,
+        })
+      : undefined;
+    const onUpdate = parsedRelation.onUpdate
+      ? normalizeReferentialAction({
+          modelName: model.name,
+          fieldName: relationAttribute.field.name,
+          actionName: 'onUpdate',
+          actionToken: parsedRelation.onUpdate,
+          sourceId,
+          span: relationAttribute.field.span,
+          diagnostics,
+        })
+      : undefined;
+
+    foreignKeyNodes.push({
+      columns: localColumns,
+      references: {
+        model: targetMapping.model.name,
+        table: targetMapping.tableName,
+        columns: referencedColumns,
+      },
+      ...ifDefined('name', parsedRelation.constraintName),
+      ...ifDefined('onDelete', onDelete),
+      ...ifDefined('onUpdate', onUpdate),
+    });
+
+    resultFkRelationMetadata.push({
+      declaringModelName: model.name,
+      declaringFieldName: relationAttribute.field.name,
+      declaringTableName: tableName,
+      targetModelName: targetMapping.model.name,
+      targetTableName: targetMapping.tableName,
+      ...ifDefined('relationName', parsedRelation.relationName),
+      localColumns,
+      referencedColumns,
+    });
+  }
+
+  return {
+    modelNode: {
+      modelName: model.name,
+      tableName,
+      fields: resolvedFields.map((resolvedField) => ({
+        fieldName: resolvedField.field.name,
+        columnName: resolvedField.columnName,
+        descriptor: resolvedField.descriptor,
+        nullable: resolvedField.field.optional,
+        ...ifDefined('default', resolvedField.defaultValue),
+        ...ifDefined('executionDefault', resolvedField.executionDefault),
+      })),
+      ...(primaryKeyColumns.length > 0
+        ? {
+            id: {
+              columns: primaryKeyColumns,
+              ...ifDefined('name', primaryKeyName),
+            },
+          }
+        : {}),
+      ...(uniqueConstraints.length > 0 ? { uniques: uniqueConstraints } : {}),
+      ...(indexNodes.length > 0 ? { indexes: indexNodes } : {}),
+      ...(foreignKeyNodes.length > 0 ? { foreignKeys: foreignKeyNodes } : {}),
+    },
+    fkRelationMetadata: resultFkRelationMetadata,
+    backrelationCandidates: resultBackrelationCandidates,
+    resolvedFields,
+  };
+}
+
+interface BuildValueObjectsInput {
+  readonly compositeTypes: readonly PslCompositeType[];
+  readonly enumTypeDescriptors: ReadonlyMap<string, ColumnDescriptor>;
+  readonly namedTypeDescriptors: ReadonlyMap<string, ColumnDescriptor>;
+  readonly scalarTypeDescriptors: ReadonlyMap<string, ColumnDescriptor>;
+  readonly composedExtensions: ReadonlySet<string>;
+  readonly familyId: string;
+  readonly targetId: string;
+  readonly authoringContributions: AuthoringContributions | undefined;
+  readonly diagnostics: ContractSourceDiagnostic[];
+  readonly sourceId: string;
+}
+
+function buildValueObjects(input: BuildValueObjectsInput): Record<string, ContractValueObject> {
+  const {
+    compositeTypes,
+    enumTypeDescriptors,
+    namedTypeDescriptors,
+    scalarTypeDescriptors,
+    composedExtensions,
+    familyId,
+    targetId,
+    authoringContributions,
+    diagnostics,
+    sourceId,
+  } = input;
+  const valueObjects: Record<string, ContractValueObject> = {};
+  const compositeTypeNames = new Set(compositeTypes.map((ct) => ct.name));
+
+  for (const compositeType of compositeTypes) {
+    const fields: Record<string, ContractField> = {};
+    for (const field of compositeType.fields) {
+      if (compositeTypeNames.has(field.typeName)) {
+        const result: ContractField = {
+          type: { kind: 'valueObject', name: field.typeName },
+          nullable: field.optional,
+        };
+        fields[field.name] = field.list ? { ...result, many: true } : result;
         continue;
       }
-      const attributesValid = validateNavigationListFieldAttributes({
-        modelName: model.name,
+      const resolved = resolveFieldTypeDescriptor({
         field,
-        sourceId,
+        enumTypeDescriptors,
+        namedTypeDescriptors,
+        scalarTypeDescriptors,
+        authoringContributions,
         composedExtensions,
+        familyId,
+        targetId,
         diagnostics,
+        sourceId,
+        entityLabel: `Field "${compositeType.name}.${field.name}"`,
       });
-      const relationAttribute = getAttribute(field.attributes, 'relation');
-      let relationName: string | undefined;
-      if (relationAttribute) {
-        const parsedRelation = parseRelationAttribute({
-          attribute: relationAttribute,
-          modelName: model.name,
-          fieldName: field.name,
-          sourceId,
-          diagnostics,
-        });
-        if (!parsedRelation) {
-          continue;
-        }
-        if (parsedRelation.fields || parsedRelation.references) {
+      if (!resolved.ok) {
+        if (!resolved.alreadyReported) {
           diagnostics.push({
-            code: 'PSL_INVALID_RELATION_ATTRIBUTE',
-            message: `Backrelation list field "${model.name}.${field.name}" cannot declare fields/references; define them on the FK-side relation field`,
+            code: 'PSL_UNSUPPORTED_FIELD_TYPE',
+            message: `Field "${compositeType.name}.${field.name}" type "${field.typeName}" is not supported`,
             sourceId,
-            span: relationAttribute.span,
+            span: field.span,
           });
-          continue;
         }
-        if (parsedRelation.onDelete || parsedRelation.onUpdate) {
-          diagnostics.push({
-            code: 'PSL_INVALID_RELATION_ATTRIBUTE',
-            message: `Backrelation list field "${model.name}.${field.name}" cannot declare onDelete/onUpdate; define referential actions on the FK-side relation field`,
-            sourceId,
-            span: relationAttribute.span,
-          });
-          continue;
-        }
-        relationName = parsedRelation.relationName;
-      }
-      if (!attributesValid) {
         continue;
       }
+      const scalarField: ContractField = {
+        nullable: field.optional,
+        type: { kind: 'scalar', codecId: resolved.descriptor.codecId },
+      };
+      fields[field.name] = field.list ? { ...scalarField, many: true } : scalarField;
+    }
+    valueObjects[compositeType.name] = { fields };
+  }
 
-      backrelationCandidates.push({
-        modelName: model.name,
-        tableName,
-        field,
-        targetModelName: field.typeName,
-        ...ifDefined('relationName', relationName),
-      });
+  return valueObjects;
+}
+
+function patchModelDomainFields(
+  models: Record<string, ContractModel>,
+  modelResolvedFields: ReadonlyMap<string, readonly ResolvedField[]>,
+): Record<string, ContractModel> {
+  let patched = models;
+
+  for (const [modelName, resolvedFields] of modelResolvedFields) {
+    const model = patched[modelName];
+    if (!model) continue;
+
+    let needsPatch = false;
+    const patchedFields: Record<string, ContractField> = { ...model.fields };
+
+    for (const rf of resolvedFields) {
+      if (rf.valueObjectTypeName) {
+        needsPatch = true;
+        patchedFields[rf.field.name] = {
+          nullable: rf.field.optional,
+          type: { kind: 'valueObject', name: rf.valueObjectTypeName },
+          ...(rf.many ? { many: true as const } : {}),
+        };
+      } else if (rf.many && rf.scalarCodecId) {
+        needsPatch = true;
+        patchedFields[rf.field.name] = {
+          nullable: rf.field.optional,
+          type: { kind: 'scalar', codecId: rf.scalarCodecId },
+          many: true as const,
+        };
+      }
     }
 
-    const relationAttributes = model.fields
-      .map((field) => ({
-        field,
-        relation: getAttribute(field.attributes, 'relation'),
-      }))
-      .filter((entry): entry is { field: PslField; relation: PslAttribute } =>
-        Boolean(entry.relation),
-      );
+    if (needsPatch) {
+      patched = { ...patched, [modelName]: { ...model, fields: patchedFields } };
+    }
+  }
 
-    builder = builder.table(tableName, (tableBuilder: DynamicTableBuilder) => {
-      let table = tableBuilder;
+  return patched;
+}
 
-      for (const resolvedField of resolvedFields) {
-        if (resolvedField.executionDefault) {
-          table = table.generated(resolvedField.columnName, {
-            type: resolvedField.descriptor,
-            generated: resolvedField.executionDefault,
-          });
-        } else {
-          const options: {
-            type: ColumnDescriptor;
-            nullable?: true;
-            default?: ColumnDefault;
-          } = {
-            type: resolvedField.descriptor,
-            ...ifDefined('nullable', resolvedField.field.optional ? (true as const) : undefined),
-            ...ifDefined('default', resolvedField.defaultValue),
-          };
-          table = table.column(resolvedField.columnName, options);
-        }
+type DiscriminatorDeclaration = {
+  readonly fieldName: string;
+  readonly span: ContractSourceDiagnosticSpan;
+};
 
-        if (resolvedField.isUnique) {
-          table = table.unique([resolvedField.columnName]);
-        }
-      }
+type BaseDeclaration = {
+  readonly baseName: string;
+  readonly value: string;
+  readonly span: ContractSourceDiagnosticSpan;
+};
 
-      if (primaryKeyColumns.length > 0) {
-        table = table.primaryKey(primaryKeyColumns);
-      }
+function collectPolymorphismDeclarations(
+  models: readonly PslModel[],
+  sourceId: string,
+  diagnostics: ContractSourceDiagnostic[],
+): {
+  discriminatorDeclarations: Map<string, DiscriminatorDeclaration>;
+  baseDeclarations: Map<string, BaseDeclaration>;
+} {
+  const discriminatorDeclarations = new Map<string, DiscriminatorDeclaration>();
+  const baseDeclarations = new Map<string, BaseDeclaration>();
 
-      for (const modelAttribute of model.attributes) {
-        if (modelAttribute.name === 'map') {
-          continue;
-        }
-        if (modelAttribute.name === 'unique' || modelAttribute.name === 'index') {
-          const fieldNames = parseAttributeFieldList({
-            attribute: modelAttribute,
-            sourceId,
-            diagnostics,
+  for (const model of models) {
+    for (const attr of model.attributes) {
+      if (attr.name === 'discriminator') {
+        const fieldName = getPositionalArgument(attr);
+        if (!fieldName) {
+          diagnostics.push({
             code: 'PSL_INVALID_ATTRIBUTE_ARGUMENT',
-            messagePrefix: `Model "${model.name}" @@${modelAttribute.name}`,
-          });
-          if (!fieldNames) {
-            continue;
-          }
-          const columnNames = mapFieldNamesToColumns({
-            modelName: model.name,
-            fieldNames,
-            mapping,
+            message: `Model "${model.name}" @@discriminator requires a field name argument`,
             sourceId,
-            diagnostics,
-            span: modelAttribute.span,
-            contextLabel: `Model "${model.name}" @@${modelAttribute.name}`,
+            span: attr.span,
           });
-          if (!columnNames) {
-            continue;
-          }
-          if (modelAttribute.name === 'unique') {
-            table = table.unique(columnNames);
-          } else {
-            table = table.index(columnNames);
-          }
           continue;
         }
-        if (modelAttribute.name.startsWith('pgvector.') && !composedExtensions.has('pgvector')) {
+        const discField = model.fields.find((f) => f.name === fieldName);
+        if (discField && discField.typeName !== 'String') {
           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.`,
+            code: 'PSL_INVALID_ATTRIBUTE_ARGUMENT',
+            message: `Discriminator field "${fieldName}" on model "${model.name}" must be of type String, but is "${discField.typeName}"`,
             sourceId,
-            span: modelAttribute.span,
+            span: attr.span,
           });
           continue;
         }
-        diagnostics.push({
-          code: 'PSL_UNSUPPORTED_MODEL_ATTRIBUTE',
-          message: `Model "${model.name}" uses unsupported attribute "@@${modelAttribute.name}"`,
-          sourceId,
-          span: modelAttribute.span,
-        });
+        discriminatorDeclarations.set(model.name, { fieldName, span: attr.span });
       }
 
-      for (const relationAttribute of relationAttributes) {
-        if (relationAttribute.field.list) {
-          continue;
-        }
-
-        if (!modelNames.has(relationAttribute.field.typeName)) {
+      if (attr.name === 'base') {
+        const baseName = getPositionalArgument(attr, 0);
+        const rawValue = getPositionalArgument(attr, 1);
+        if (!baseName || !rawValue) {
           diagnostics.push({
-            code: 'PSL_INVALID_RELATION_TARGET',
-            message: `Relation field "${model.name}.${relationAttribute.field.name}" references unknown model "${relationAttribute.field.typeName}"`,
+            code: 'PSL_INVALID_ATTRIBUTE_ARGUMENT',
+            message: `Model "${model.name}" @@base requires two arguments: base model name and discriminator value`,
             sourceId,
-            span: relationAttribute.field.span,
+            span: attr.span,
           });
           continue;
         }
-
-        const parsedRelation = parseRelationAttribute({
-          attribute: relationAttribute.relation,
-          modelName: model.name,
-          fieldName: relationAttribute.field.name,
-          sourceId,
-          diagnostics,
-        });
-        if (!parsedRelation) {
-          continue;
-        }
-        if (!parsedRelation.fields || !parsedRelation.references) {
+        const value = parseQuotedStringLiteral(rawValue);
+        if (value === undefined) {
           diagnostics.push({
-            code: 'PSL_INVALID_RELATION_ATTRIBUTE',
-            message: `Relation field "${model.name}.${relationAttribute.field.name}" requires fields and references arguments`,
+            code: 'PSL_INVALID_ATTRIBUTE_ARGUMENT',
+            message: `Model "${model.name}" @@base discriminator value must be a quoted string literal`,
             sourceId,
-            span: relationAttribute.relation.span,
+            span: attr.span,
           });
           continue;
         }
+        baseDeclarations.set(model.name, { baseName, value, span: attr.span });
+      }
+    }
+  }
 
-        const targetMapping = modelMappings.get(relationAttribute.field.typeName);
-        if (!targetMapping) {
-          diagnostics.push({
-            code: 'PSL_INVALID_RELATION_TARGET',
-            message: `Relation field "${model.name}.${relationAttribute.field.name}" references unknown model "${relationAttribute.field.typeName}"`,
-            sourceId,
-            span: relationAttribute.field.span,
-          });
-          continue;
-        }
+  return { discriminatorDeclarations, baseDeclarations };
+}
 
-        const localColumns = mapFieldNamesToColumns({
-          modelName: model.name,
-          fieldNames: parsedRelation.fields,
-          mapping,
+function resolvePolymorphism(
+  models: Record<string, ContractModel>,
+  discriminatorDeclarations: Map<string, DiscriminatorDeclaration>,
+  baseDeclarations: Map<string, BaseDeclaration>,
+  modelNames: Set<string>,
+  modelMappings: ReadonlyMap<string, ModelNameMapping>,
+  sourceId: string,
+  diagnostics: ContractSourceDiagnostic[],
+): Record<string, ContractModel> {
+  let patched = models;
+
+  for (const [modelName, decl] of discriminatorDeclarations) {
+    if (baseDeclarations.has(modelName)) {
+      diagnostics.push({
+        code: 'PSL_DISCRIMINATOR_AND_BASE',
+        message: `Model "${modelName}" cannot have both @@discriminator and @@base`,
+        sourceId,
+        span: decl.span,
+      });
+      continue;
+    }
+
+    const model = patched[modelName];
+    if (!model) continue;
+
+    if (!Object.hasOwn(model.fields, decl.fieldName)) {
+      diagnostics.push({
+        code: 'PSL_DISCRIMINATOR_FIELD_NOT_FOUND',
+        message: `Discriminator field "${decl.fieldName}" is not a field on model "${modelName}"`,
+        sourceId,
+        span: decl.span,
+      });
+      continue;
+    }
+
+    const variants: Record<string, { readonly value: string }> = {};
+    const seenValues = new Map<string, string>();
+
+    for (const [variantName, baseDecl] of baseDeclarations) {
+      if (baseDecl.baseName !== modelName) continue;
+
+      const existingVariant = seenValues.get(baseDecl.value);
+      if (existingVariant) {
+        diagnostics.push({
+          code: 'PSL_DUPLICATE_DISCRIMINATOR_VALUE',
+          message: `Discriminator value "${baseDecl.value}" is used by both "${existingVariant}" and "${variantName}" on base model "${modelName}"`,
           sourceId,
-          diagnostics,
-          span: relationAttribute.relation.span,
-          contextLabel: `Relation field "${model.name}.${relationAttribute.field.name}"`,
+          span: baseDecl.span,
         });
-        if (!localColumns) {
-          continue;
-        }
-        const referencedColumns = mapFieldNamesToColumns({
-          modelName: targetMapping.model.name,
-          fieldNames: parsedRelation.references,
-          mapping: targetMapping,
+        continue;
+      }
+      seenValues.set(baseDecl.value, variantName);
+      variants[variantName] = { value: baseDecl.value };
+    }
+
+    if (Object.keys(variants).length === 0) {
+      diagnostics.push({
+        code: 'PSL_ORPHANED_DISCRIMINATOR',
+        message: `Model "${modelName}" has @@discriminator but no variant models declare @@base(${modelName}, ...)`,
+        sourceId,
+        span: decl.span,
+      });
+      continue;
+    }
+
+    patched = {
+      ...patched,
+      [modelName]: { ...model, discriminator: { field: decl.fieldName }, variants },
+    };
+  }
+
+  for (const [variantName, baseDecl] of baseDeclarations) {
+    if (!modelNames.has(baseDecl.baseName)) {
+      diagnostics.push({
+        code: 'PSL_BASE_TARGET_NOT_FOUND',
+        message: `Model "${variantName}" @@base references non-existent model "${baseDecl.baseName}"`,
+        sourceId,
+        span: baseDecl.span,
+      });
+      continue;
+    }
+
+    if (!discriminatorDeclarations.has(baseDecl.baseName)) {
+      diagnostics.push({
+        code: 'PSL_ORPHANED_BASE',
+        message: `Model "${variantName}" declares @@base(${baseDecl.baseName}, ...) but "${baseDecl.baseName}" has no @@discriminator`,
+        sourceId,
+        span: baseDecl.span,
+      });
+      continue;
+    }
+
+    if (discriminatorDeclarations.has(variantName)) {
+      continue;
+    }
+
+    const variantModel = patched[variantName];
+    if (!variantModel) continue;
+
+    const baseMapping = modelMappings.get(baseDecl.baseName);
+    const variantMapping = modelMappings.get(variantName);
+    const hasExplicitMap =
+      variantMapping?.model.attributes.some((attr) => attr.name === 'map') ?? false;
+    const resolvedTable = hasExplicitMap ? variantMapping?.tableName : baseMapping?.tableName;
+
+    patched = {
+      ...patched,
+      [variantName]: {
+        ...variantModel,
+        base: baseDecl.baseName,
+        ...(resolvedTable ? { storage: { ...variantModel.storage, table: resolvedTable } } : {}),
+      },
+    };
+  }
+
+  return patched;
+}
+
+export function interpretPslDocumentToSqlContract(
+  input: InterpretPslDocumentToSqlContractInput,
+): Result<Contract, ContractSourceDiagnostics> {
+  const sourceId = input.document.ast.sourceId;
+  if (!input.target) {
+    return notOk({
+      summary: 'PSL to SQL contract interpretation failed',
+      diagnostics: [
+        {
+          code: 'PSL_TARGET_CONTEXT_REQUIRED',
+          message: 'PSL interpretation requires an explicit target context from composition.',
           sourceId,
-          diagnostics,
-          span: relationAttribute.relation.span,
-          contextLabel: `Relation field "${model.name}.${relationAttribute.field.name}"`,
-        });
-        if (!referencedColumns) {
-          continue;
-        }
-        if (localColumns.length !== referencedColumns.length) {
-          diagnostics.push({
-            code: 'PSL_INVALID_RELATION_ATTRIBUTE',
-            message: `Relation field "${model.name}.${relationAttribute.field.name}" must provide the same number of fields and references`,
-            sourceId,
-            span: relationAttribute.relation.span,
-          });
-          continue;
-        }
+        },
+      ],
+    });
+  }
+  if (!input.scalarTypeDescriptors) {
+    return notOk({
+      summary: 'PSL to SQL contract interpretation failed',
+      diagnostics: [
+        {
+          code: 'PSL_SCALAR_TYPE_CONTEXT_REQUIRED',
+          message: 'PSL interpretation requires composed scalar type descriptors.',
+          sourceId,
+        },
+      ],
+    });
+  }
 
-        const onDelete = parsedRelation.onDelete
-          ? normalizeReferentialAction({
-              modelName: model.name,
-              fieldName: relationAttribute.field.name,
-              actionName: 'onDelete',
-              actionToken: parsedRelation.onDelete,
-              sourceId,
-              span: relationAttribute.field.span,
-              diagnostics,
-            })
-          : undefined;
-        const onUpdate = parsedRelation.onUpdate
-          ? normalizeReferentialAction({
-              modelName: model.name,
-              fieldName: relationAttribute.field.name,
-              actionName: 'onUpdate',
-              actionToken: parsedRelation.onUpdate,
-              sourceId,
-              span: relationAttribute.field.span,
-              diagnostics,
-            })
-          : undefined;
-
-        table = table.foreignKey(
-          localColumns,
-          {
-            table: targetMapping.tableName,
-            columns: referencedColumns,
-          },
-          {
-            ...ifDefined('onDelete', onDelete),
-            ...ifDefined('onUpdate', onUpdate),
-          },
-        );
-
-        fkRelationMetadata.push({
-          declaringModelName: model.name,
-          declaringFieldName: relationAttribute.field.name,
-          declaringTableName: tableName,
-          targetModelName: targetMapping.model.name,
-          targetTableName: targetMapping.tableName,
-          ...ifDefined('relationName', parsedRelation.relationName),
-          localColumns,
-          referencedColumns,
-        });
-      }
+  const diagnostics: ContractSourceDiagnostic[] = mapParserDiagnostics(input.document);
+  const models = input.document.ast.models ?? [];
+  const enums = input.document.ast.enums ?? [];
+  const compositeTypes = input.document.ast.compositeTypes ?? [];
+  const modelNames = new Set(models.map((model) => model.name));
+  const compositeTypeNames = new Set(compositeTypes.map((ct) => ct.name));
+  const composedExtensions = new Set(input.composedExtensionPacks ?? []);
+  const defaultFunctionRegistry: ControlMutationDefaultRegistry =
+    input.controlMutationDefaults?.defaultFunctionRegistry ?? new Map();
+  const generatorDescriptors = input.controlMutationDefaults?.generatorDescriptors ?? [];
+  const generatorDescriptorById = new Map<string, MutationDefaultGeneratorDescriptor>();
+  for (const descriptor of generatorDescriptors) {
+    generatorDescriptorById.set(descriptor.id, descriptor);
+  }
 
-      return table;
+  const enumResult = processEnumDeclarations({
+    enums,
+    sourceId,
+    enumTypeConstructor: getAuthoringTypeConstructor(input.authoringContributions, ['enum']),
+    diagnostics,
+  });
+
+  const namedTypeResult = resolveNamedTypeDeclarations({
+    declarations: input.document.ast.types?.declarations ?? [],
+    sourceId,
+    enumTypeDescriptors: enumResult.enumTypeDescriptors,
+    scalarTypeDescriptors: input.scalarTypeDescriptors,
+    composedExtensions,
+    familyId: input.target.familyId,
+    targetId: input.target.targetId,
+    authoringContributions: input.authoringContributions,
+    diagnostics,
+  });
+
+  const storageTypes = { ...enumResult.storageTypes, ...namedTypeResult.storageTypes };
+
+  const modelMappings = buildModelMappings(models, diagnostics, sourceId);
+  const modelNodes: ModelNode[] = [];
+  const fkRelationMetadata: FkRelationMetadata[] = [];
+  const backrelationCandidates: ModelBackrelationCandidate[] = [];
+  const modelResolvedFields = new Map<string, readonly ResolvedField[]>();
+
+  for (const model of models) {
+    const mapping = modelMappings.get(model.name);
+    if (!mapping) {
+      continue;
+    }
+    const result = buildModelNodeFromPsl({
+      model,
+      mapping,
+      modelMappings,
+      modelNames,
+      compositeTypeNames,
+      enumTypeDescriptors: enumResult.enumTypeDescriptors,
+      namedTypeDescriptors: namedTypeResult.namedTypeDescriptors,
+      composedExtensions,
+      familyId: input.target.familyId,
+      targetId: input.target.targetId,
+      authoringContributions: input.authoringContributions,
+      defaultFunctionRegistry,
+      generatorDescriptorById,
+      scalarTypeDescriptors: input.scalarTypeDescriptors,
+      sourceId,
+      diagnostics,
     });
+    modelNodes.push(result.modelNode);
+    fkRelationMetadata.push(...result.fkRelationMetadata);
+    backrelationCandidates.push(...result.backrelationCandidates);
+    modelResolvedFields.set(model.name, result.resolvedFields);
   }
 
   const { modelRelations, fkRelationsByPair } = indexFkRelations({ fkRelationMetadata });
@@ -1512,31 +1201,90 @@ export function interpretPslDocumentToSqlContractIR(
     diagnostics,
     sourceId,
   });
-  builder = emitModelsWithRelations({
-    builder,
-    resolvedModels,
-    modelRelations,
+
+  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) {
-    const dedupedDiagnostics = 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,
-    );
+    return notOk({
+      summary: 'PSL to SQL contract interpretation failed',
+      diagnostics: dedupeDiagnostics(diagnostics),
+    });
+  }
+
+  const contract = buildSqlContractFromDefinition({
+    target: input.target,
+    ...ifDefined(
+      'extensionPacks',
+      buildComposedExtensionPackRefs(
+        input.target,
+        [...composedExtensions].sort(compareStrings),
+        input.composedExtensionPackRefs,
+      ),
+    ),
+    ...(Object.keys(storageTypes).length > 0 ? { storageTypes } : {}),
+    models: modelNodes.map((model) => ({
+      ...model,
+      ...(modelRelations.has(model.modelName)
+        ? {
+            relations: [...(modelRelations.get(model.modelName) ?? [])].sort((left, right) =>
+              compareStrings(left.fieldName, right.fieldName),
+            ),
+          }
+        : {}),
+    })),
+  });
+
+  let patchedModels = patchModelDomainFields(
+    contract.models as Record<string, ContractModel>,
+    modelResolvedFields,
+  );
 
+  const polyDiagnostics: ContractSourceDiagnostic[] = [];
+  patchedModels = resolvePolymorphism(
+    patchedModels,
+    discriminatorDeclarations,
+    baseDeclarations,
+    modelNames,
+    modelMappings,
+    sourceId,
+    polyDiagnostics,
+  );
+
+  if (polyDiagnostics.length > 0) {
     return notOk({
-      summary: 'PSL to SQL Contract IR normalization failed',
-      diagnostics: dedupedDiagnostics,
+      summary: 'PSL to SQL contract interpretation failed',
+      diagnostics: polyDiagnostics,
     });
   }
 
-  const contract = builder.build() as ContractIR;
-  return ok(contract);
+  const variantModelNames = new Set(baseDeclarations.keys());
+  const filteredRoots = Object.fromEntries(
+    Object.entries(contract.roots).filter(([, modelName]) => !variantModelNames.has(modelName)),
+  );
+
+  const patchedContract: Contract = {
+    ...contract,
+    roots: filteredRoots,
+    models: patchedModels,
+    ...(Object.keys(valueObjects).length > 0 ? { valueObjects } : {}),
+  };
+
+  return ok(patchedContract);
 }