fix(slice-0): repair typecheck against the cardinality-discriminated relation union

Three type errors surfaced by `tsc` (not by vitest) after rebasing onto
main, all from the N:M discriminated-union work:
- emitter: `castAs<ContractManyToManyRelation>` cannot widen a
  `Record<string, unknown>`; use `blindCast` (the established escape
  hatch, matching the sibling `to` access).
- build-contract: branch relation construction on `cardinality === "N:M"`
  so the literal matches a single union variant instead of the wide
  `{ cardinality; through? }` shape that is assignable to neither.
- fixture: split `ProjectBase` out of the self-referential composite-key
  M:N so the `() => Project` initializer self-reference (TS7022) resolves,
  mirroring the existing UserBase/User pattern.

Signed-off-by: Alexey Orlenko's AI Agent <robot@aqrln.net>

Author: tensordreams

packages/1-framework/3-tooling/emitter/src/domain-type-generation.ts

@@ -8,7 +8,7 @@ import type {
 import type { CodecLookup } from '@prisma-next/framework-components/codec';
 import type { TypesImportSpec } from '@prisma-next/framework-components/emission';
 import { type ImportRequirement, renderImports } from '@prisma-next/ts-render';
-import { blindCast, castAs } from '@prisma-next/utils/casts';
+import { blindCast } from '@prisma-next/utils/casts';
 import { isSafeTypeExpression } from './type-expression-safety';
 
 export function serializeValue(value: unknown): string {
@@ -150,7 +150,10 @@ export function generateModelRelationsType(relations: Record<string, unknown>):
     }
 
     if (relObj['cardinality'] === 'N:M') {
-      const { through } = castAs<ContractManyToManyRelation>(relObj);
+      const { through } = blindCast<
+        ContractManyToManyRelation,
+        'contract JSON schema-validated before serialization; cardinality N:M check above confirms the junction variant carries through'
+      >(relObj);
       const table = serializeValue(through.table);
       const namespaceId = serializeValue(through.namespaceId);
       const parentColumns = through.parentColumns.map((c) => serializeValue(c)).join(', ');

packages/2-sql/2-authoring/contract-ts/src/build-contract.ts

@@ -619,38 +619,40 @@ export function buildSqlContractFromDefinition(
       );
       assertTargetTableMatches(semanticModel.modelName, targetModel, relation.toTable, 'Relation');
 
-      if (relation.cardinality === 'N:M' && !relation.through) {
-        throw new Error(
-          `Relation "${semanticModel.modelName}.${relation.fieldName}" with cardinality "N:M" requires through metadata`,
-        );
-      }
-
       const targetColumnToField = new Map(
         targetModel.fields.map((f) => [f.columnName, f.fieldName]),
       );
 
-      modelRelations[relation.fieldName] = {
-        to: crossRef(
-          relation.toModel,
-          resolveModelNamespaceId(targetModel, modelNameToNamespaceId, defaultNamespaceId),
-        ),
-        cardinality: relation.cardinality,
-        on: {
-          localFields: relation.on.parentColumns.map((col) => columnToField.get(col) ?? col),
-          targetFields: relation.on.childColumns.map((col) => targetColumnToField.get(col) ?? col),
-        },
-        ...(relation.through
-          ? {
-              through: buildThroughDescriptor(
-                relation.through,
-                tableNamespaceByName,
-                targetModel,
-                semanticModel.modelName,
-                relation.fieldName,
-              ),
-            }
-          : undefined),
+      const to = crossRef(
+        relation.toModel,
+        resolveModelNamespaceId(targetModel, modelNameToNamespaceId, defaultNamespaceId),
+      );
+      const on = {
+        localFields: relation.on.parentColumns.map((col) => columnToField.get(col) ?? col),
+        targetFields: relation.on.childColumns.map((col) => targetColumnToField.get(col) ?? col),
       };
+
+      if (relation.cardinality === 'N:M') {
+        if (!relation.through) {
+          throw new Error(
+            `Relation "${semanticModel.modelName}.${relation.fieldName}" with cardinality "N:M" requires through metadata`,
+          );
+        }
+        modelRelations[relation.fieldName] = {
+          to,
+          cardinality: 'N:M',
+          on,
+          through: buildThroughDescriptor(
+            relation.through,
+            tableNamespaceByName,
+            targetModel,
+            semanticModel.modelName,
+            relation.fieldName,
+          ),
+        };
+      } else {
+        modelRelations[relation.fieldName] = { to, cardinality: relation.cardinality, on };
+      }
     }
 
     let namespaceModels = modelsByNamespace[namespaceId];

test/integration/test/sql-orm-client/fixtures/contract.ts

@@ -96,24 +96,23 @@ const UserRole = model('UserRole', {
   }))
   .sql({ table: 'user_roles' });
 
-const Project = model('Project', {
+const ProjectBase = model('Project', {
   fields: {
     tenantId: field.column(int4Column).column('tenant_id'),
     id: field.column(int4Column),
     name: field.column(textColumn),
   },
-})
-  .attributes(({ fields, constraints }) => ({
-    id: constraints.id([fields.tenantId, fields.id]),
-  }))
-  .relations({
-    related: rel.manyToMany(() => Project, {
-      through: () => ProjectLink,
-      from: ['srcTenantId', 'srcId'],
-      to: ['dstTenantId', 'dstId'],
-    }),
-  })
-  .sql({ table: 'projects' });
+}).attributes(({ fields, constraints }) => ({
+  id: constraints.id([fields.tenantId, fields.id]),
+}));
+
+const Project = ProjectBase.relations({
+  related: rel.manyToMany(() => ProjectBase, {
+    through: () => ProjectLink,
+    from: ['srcTenantId', 'srcId'],
+    to: ['dstTenantId', 'dstId'],
+  }),
+}).sql({ table: 'projects' });
 
 const ProjectLink = model('ProjectLink', {
   fields: {