prisma
diff --git a/‎packages/1-framework/3-tooling/cli/test/output.errors.test.ts‎
Lines changed: 2 additions & 2 deletions b/‎packages/1-framework/3-tooling/cli/test/output.errors.test.ts‎
Lines changed: 2 additions & 2 deletions
diff --git a/‎packages/2-sql/1-core/schema-ir/test/sql-column-ir.test.ts‎
Lines changed: 21 additions & 0 deletions b/‎packages/2-sql/1-core/schema-ir/test/sql-column-ir.test.ts‎
Lines changed: 21 additions & 0 deletions
diff --git a/‎packages/2-sql/2-authoring/contract-psl/src/interpreter.ts‎
Lines changed: 37 additions & 5 deletions b/‎packages/2-sql/2-authoring/contract-psl/src/interpreter.ts‎
Lines changed: 37 additions & 5 deletions
diff --git a/‎packages/2-sql/2-authoring/contract-psl/src/psl-field-resolution.ts‎
Lines changed: 7 additions & 0 deletions b/‎packages/2-sql/2-authoring/contract-psl/src/psl-field-resolution.ts‎
Lines changed: 7 additions & 0 deletions
diff --git a/‎packages/2-sql/2-authoring/contract-psl/src/psl-relation-resolution.ts‎
Lines changed: 36 additions & 30 deletions b/‎packages/2-sql/2-authoring/contract-psl/src/psl-relation-resolution.ts‎
Lines changed: 36 additions & 30 deletions
diff --git a/‎packages/2-sql/2-authoring/contract-psl/test/interpreter.diagnostics.test.ts‎
Lines changed: 2 additions & 2 deletions b/‎packages/2-sql/2-authoring/contract-psl/test/interpreter.diagnostics.test.ts‎
Lines changed: 2 additions & 2 deletions
diff --git a/‎packages/2-sql/2-authoring/contract-psl/test/interpreter.relations.many-to-many.test.ts‎
Lines changed: 3 additions & 3 deletions b/‎packages/2-sql/2-authoring/contract-psl/test/interpreter.relations.many-to-many.test.ts‎
Lines changed: 3 additions & 3 deletions
@@ -98,14 +98,14 @@ describe('formatErrorOutput - issues list label and body fallback', () => {
       domain: 'RUN',
       summary: 'Failed to resolve contract source',
       meta: {
-        issues: [{ kind: 'PSL_ORPHANED_BACKRELATION_LIST', message: 'orphaned backrelation list' }],
+        issues: [{ kind: 'PSL_ORPHANED_BACKRELATION', message: 'orphaned backrelation list' }],
       },
     };
 
     const flags = parseGlobalFlags({ verbose: true, 'no-color': true });
     const stripped = stripAnsi(formatErrorOutput(error, flags));
 
-    expect(stripped).toContain('[PSL_ORPHANED_BACKRELATION_LIST] orphaned backrelation list');
+    expect(stripped).toContain('[PSL_ORPHANED_BACKRELATION] orphaned backrelation list');
   });
 
   it('renders a schema-diff issue (no `message`) with a presence-derived `[missing] path/joined/with/slashes` label', () => {
 
@@ -167,4 +167,25 @@ describe('SqlColumnIR', () => {
       expect(column.resolvedDefault).toEqual({ kind: 'literal', value: 'x' });
     });
   });
+
+  describe('identity columns (introspected, no raw default)', () => {
+    it('yields a default child node from resolvedDefault alone, with no raw default', () => {
+      // A `GENERATED ... AS IDENTITY` column has no `column_default` at
+      // all — the postgres control adapter sets `resolvedDefault` directly
+      // to `autoincrement()` without a raw expression to parse, so
+      // `children()` must still produce a default node without a `default`
+      // (raw) field.
+      const column = new SqlColumnIR({
+        name: 'id',
+        nativeType: 'int4',
+        nullable: false,
+        resolvedDefault: { kind: 'function', expression: 'autoincrement()' },
+      });
+      expect(column.children()).toEqual([
+        new SqlColumnDefaultIR({
+          resolved: { kind: 'function', expression: 'autoincrement()' },
+        }),
+      ]);
+    });
+  });
 });
@@ -79,7 +79,7 @@ import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { notOk, ok, type Result } from '@prisma-next/utils/result';
 
-import { getAttribute, mapFieldNamesToColumns } from './psl-attribute-parsing';
+import { getAttribute, getNamedArgument, mapFieldNamesToColumns } from './psl-attribute-parsing';
 import type { ColumnDescriptor } from './psl-column-resolution';
 import {
   checkUncomposedNamespace,
@@ -103,7 +103,7 @@ import {
   interpretRelationAttribute,
   type ModelBackrelationCandidate,
   normalizeReferentialAction,
-  validateNavigationListFieldAttributes,
+  validateBackrelationFieldAttributes,
 } from './psl-relation-resolution';
 import {
   baseModelSpec,
@@ -668,6 +668,21 @@ interface BuildModelNodeResult {
   readonly modelAttributeEntities: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
 }
 
+/**
+ * The owning side of a relation is the one that declares `fields`/`references` on its
+ * `@relation` attribute — those name the FK columns. A singular model-typed field whose
+ * `@relation` carries only a name (or nothing at all) is the back side: infer prints exactly
+ * that shape for a 1:1 back-relation whenever the FK needs disambiguating (two FKs between the
+ * same table pair, or a self-referencing unique FK). Checking for the attribute's mere presence
+ * would misclassify that back side as the owning side.
+ */
+function relationAttributeDeclaresOwningSide(relationAttribute: ResolvedAttribute): boolean {
+  return (
+    getNamedArgument(relationAttribute, 'fields') !== undefined ||
+    getNamedArgument(relationAttribute, 'references') !== undefined
+  );
+}
+
 function buildModelNodeFromPsl(input: BuildModelNodeInput): BuildModelNodeResult {
   const { model, mapping, sourceId, diagnostics } = input;
   const tableName = mapping.tableName;
@@ -726,10 +741,20 @@ function buildModelNodeFromPsl(input: BuildModelNodeInput): BuildModelNodeResult
 
   const resultBackrelationCandidates: ModelBackrelationCandidate[] = [];
   for (const field of Object.values(model.fields)) {
-    if (!field.list || !input.modelNames.has(field.typeName)) {
+    if (!input.modelNames.has(field.typeName)) {
+      continue;
+    }
+    const relationAttribute = getAttribute(field.attributes, 'relation');
+    if (
+      !field.list &&
+      relationAttribute &&
+      relationAttributeDeclaresOwningSide(relationAttribute)
+    ) {
+      // The owning side of the relation: it declares fields/references and is
+      // lowered separately below, by the `relationAttributes` FK-building loop.
       continue;
     }
-    const attributesValid = validateNavigationListFieldAttributes({
+    const attributesValid = validateBackrelationFieldAttributes({
       modelName: model.name,
       field,
       sourceId,
@@ -739,7 +764,6 @@ function buildModelNodeFromPsl(input: BuildModelNodeInput): BuildModelNodeResult
       familyId: input.familyId,
       targetId: input.targetId,
     });
-    const relationAttribute = getAttribute(field.attributes, 'relation');
     let relationName: string | undefined;
     if (relationAttribute) {
       const parsedRelation = interpretRelationAttribute({
@@ -786,6 +810,7 @@ function buildModelNodeFromPsl(input: BuildModelNodeInput): BuildModelNodeResult
       tableName,
       field,
       targetModelName: field.typeName,
+      isList: field.list,
       ...ifDefined('relationName', relationName),
     });
   }
@@ -1095,6 +1120,13 @@ function buildModelNodeFromPsl(input: BuildModelNodeInput): BuildModelNodeResult
       continue;
     }
 
+    if (!relationAttributeDeclaresOwningSide(relationAttribute.relation)) {
+      // A singular model-typed field whose `@relation` carries only a name (or nothing) is the
+      // back side of a 1:1 relation, already lowered above via backrelationCandidates. It is
+      // not the owning side, so it has no fields/references to validate here.
+      continue;
+    }
+
     // Cross-contract-space relation: the target model lives in a different contract space
     // identified by `typeContractSpaceId` (e.g. `supabase:auth.User`).
     if (fieldTypeContractSpaceId !== undefined) {
 
@@ -347,6 +347,13 @@ export function collectResolvedFields(input: CollectResolvedFieldsInput): Resolv
     if (field.typeContractSpaceId !== undefined && relationAttribute) {
       continue;
     }
+    // A model-typed, non-list field with no `@relation` is the back side of a
+    // 1:1 relation — the owning side always carries `@relation(fields: [...],
+    // references: [...])`. It is lowered separately, via the interpreter's
+    // backrelation-candidate matching, not as a scalar column here.
+    if (isModelField) {
+      continue;
+    }
 
     const isValueObjectField = compositeTypeNames.has(field.typeName);
     const isListField = field.list;
 
@@ -62,6 +62,8 @@ export type ModelBackrelationCandidate = {
   readonly tableName: string;
   readonly field: FieldSymbol;
   readonly targetModelName: string;
+  /** Whether the PSL field itself is list-typed (`Target[]`) rather than singular (`Target?`). A singular candidate is the back side of a 1:1 relation and can never be many-to-many. */
+  readonly isList: boolean;
   readonly relationName?: string;
 };
 
@@ -453,44 +455,48 @@ export function applyBackrelationCandidates(input: {
       : [...pairMatches];
 
     if (matches.length === 0) {
-      const { pairs: junctionPairs, nearMisses } = findJunctionFkPairs({
-        candidate,
-        fkRelationsByDeclaringModel: input.fkRelationsByDeclaringModel,
-        modelIdColumns: input.modelIdColumns,
-      });
-      const junctionPair = junctionPairs[0];
-      if (junctionPairs.length === 1 && junctionPair) {
-        relationsForModel(input.modelRelations, candidate.modelName).push(
-          manyToManyRelationNode(candidate, junctionPair),
-        );
-        continue;
-      }
-      if (junctionPairs.length > 1) {
-        input.diagnostics.push({
-          code: 'PSL_AMBIGUOUS_BACKRELATION_LIST',
-          message: `Backrelation list field "${candidate.modelName}.${candidate.field.name}" matches multiple junction FK pairs for a many-to-many relation. Add @relation(name: "...") (or @relation("...")) to the list field and the junction FK-side relation pointing back at "${candidate.modelName}" to disambiguate.`,
-          sourceId: input.sourceId,
-          span: candidate.field.span,
+      // A singular candidate is the back side of a 1:1 — many-to-many junction
+      // matching only makes sense for a list-typed backrelation.
+      if (candidate.isList) {
+        const { pairs: junctionPairs, nearMisses } = findJunctionFkPairs({
+          candidate,
+          fkRelationsByDeclaringModel: input.fkRelationsByDeclaringModel,
+          modelIdColumns: input.modelIdColumns,
         });
-        continue;
-      }
-      const nearMiss = nearMisses[0];
-      if (nearMiss) {
-        input.diagnostics.push(junctionNearMissDiagnostic(candidate, nearMiss, input.sourceId));
-        continue;
+        const junctionPair = junctionPairs[0];
+        if (junctionPairs.length === 1 && junctionPair) {
+          relationsForModel(input.modelRelations, candidate.modelName).push(
+            manyToManyRelationNode(candidate, junctionPair),
+          );
+          continue;
+        }
+        if (junctionPairs.length > 1) {
+          input.diagnostics.push({
+            code: 'PSL_AMBIGUOUS_BACKRELATION',
+            message: `Backrelation list field "${candidate.modelName}.${candidate.field.name}" matches multiple junction FK pairs for a many-to-many relation. Add @relation(name: "...") (or @relation("...")) to the list field and the junction FK-side relation pointing back at "${candidate.modelName}" to disambiguate.`,
+            sourceId: input.sourceId,
+            span: candidate.field.span,
+          });
+          continue;
+        }
+        const nearMiss = nearMisses[0];
+        if (nearMiss) {
+          input.diagnostics.push(junctionNearMissDiagnostic(candidate, nearMiss, input.sourceId));
+          continue;
+        }
       }
       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.`,
+        code: 'PSL_ORPHANED_BACKRELATION',
+        message: `Backrelation 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${candidate.isList ? ' 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.`,
+        code: 'PSL_AMBIGUOUS_BACKRELATION',
+        message: `Backrelation 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,
       });
@@ -506,7 +512,7 @@ export function applyBackrelationCandidates(input: {
       toModel: matched.declaringModelName,
       toTable: matched.declaringTableName,
       ...ifDefined('toNamespaceId', matched.declaringNamespaceId),
-      cardinality: '1:N',
+      cardinality: candidate.isList ? '1:N' : '1:1',
       on: {
         parentTable: candidate.tableName,
         parentColumns: matched.referencedColumns,
@@ -517,7 +523,7 @@ export function applyBackrelationCandidates(input: {
   }
 }
 
-export function validateNavigationListFieldAttributes(input: {
+export function validateBackrelationFieldAttributes(input: {
   readonly modelName: string;
   readonly field: FieldSymbol;
   readonly sourceId: string;
 
@@ -500,7 +500,7 @@ model Post {
     expect(result.failure.diagnostics).toEqual(
       expect.arrayContaining([
         expect.objectContaining({
-          code: 'PSL_ORPHANED_BACKRELATION_LIST',
+          code: 'PSL_ORPHANED_BACKRELATION',
           message: expect.stringContaining('User.posts'),
         }),
       ]),
@@ -534,7 +534,7 @@ model Post {
     expect(result.failure.diagnostics).toEqual(
       expect.arrayContaining([
         expect.objectContaining({
-          code: 'PSL_AMBIGUOUS_BACKRELATION_LIST',
+          code: 'PSL_AMBIGUOUS_BACKRELATION',
           message: expect.stringContaining('User.posts'),
         }),
       ]),
 
@@ -428,7 +428,7 @@ model Follow {
     expect(result.failure.diagnostics).toEqual(
       expect.arrayContaining([
         expect.objectContaining({
-          code: 'PSL_AMBIGUOUS_BACKRELATION_LIST',
+          code: 'PSL_AMBIGUOUS_BACKRELATION',
           message: expect.stringContaining('User.follows'),
         }),
       ]),
@@ -566,7 +566,7 @@ model TagWatch {
     expect(result.failure.diagnostics).toEqual(
       expect.arrayContaining([
         expect.objectContaining({
-          code: 'PSL_AMBIGUOUS_BACKRELATION_LIST',
+          code: 'PSL_AMBIGUOUS_BACKRELATION',
           message: expect.stringContaining('User.ownedTags'),
         }),
       ]),
@@ -590,7 +590,7 @@ model Tag {
     expect(result.failure.diagnostics).toEqual(
       expect.arrayContaining([
         expect.objectContaining({
-          code: 'PSL_ORPHANED_BACKRELATION_LIST',
+          code: 'PSL_ORPHANED_BACKRELATION',
           message: expect.stringContaining('Post.tags'),
         }),
       ]),