@prisma-next/sql-contract-psl 0.12.0-dev.5 → 0.12.0-dev.50

package/dist/provider.mjs

@@ -1,8 +1,9 @@
-import { t as interpretPslDocumentToSqlContract } from "./interpreter-QE6eZZof.mjs";
+import { t as interpretPslDocumentToSqlContract } from "./interpreter-Rn_Vzvt-.mjs";
 import { ifDefined } from "@prisma-next/utils/defined";
 import { notOk, ok } from "@prisma-next/utils/result";
 import { parsePslDocument } from "@prisma-next/psl-parser";
 import { readFile } from "node:fs/promises";
+import { applySpecifierDefaultControlPolicy } from "@prisma-next/contract/apply-specifier-default-control-policy";
 import { basename, extname } from "pathe";
 //#region src/provider.ts
 /**
@@ -69,10 +70,11 @@ function prismaContract(schemaPath, options) {
 					scalarTypeDescriptors,
 					...ifDefined("composedExtensionPacks", context.composedExtensionPacks.length > 0 ? [...context.composedExtensionPacks] : void 0),
 					...ifDefined("composedExtensionPackRefs", options.composedExtensionPackRefs?.length ? options.composedExtensionPackRefs : void 0),
-					controlMutationDefaults: context.controlMutationDefaults
+					controlMutationDefaults: context.controlMutationDefaults,
+					...ifDefined("createNamespace", options.createNamespace)
 				});
 				if (!interpreted.ok) return interpreted;
-				return ok(interpreted.value);
+				return ok(applySpecifierDefaultControlPolicy(interpreted.value, options.defaultControlPolicy));
 			}
 		},
 		output: options.output ?? defaultOutputFromSchemaPath(schemaPath)

package/dist/provider.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"provider.mjs","names":[],"sources":["../src/provider.ts"],"sourcesContent":["import { readFile } from 'node:fs/promises';\nimport type { ContractConfig } from '@prisma-next/config/config-types';\nimport type { CodecLookup } from '@prisma-next/framework-components/codec';\nimport type { ExtensionPackRef, TargetPackRef } from '@prisma-next/framework-components/components';\nimport { parsePslDocument } from '@prisma-next/psl-parser';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport { notOk, ok } from '@prisma-next/utils/result';\nimport { basename, extname } from 'pathe';\nimport { interpretPslDocumentToSqlContract } from './interpreter';\nimport type { ColumnDescriptor } from './psl-column-resolution';\n\nexport interface PrismaContractOptions {\n  readonly output?: string;\n  readonly target: TargetPackRef<'sql', string>;\n  readonly composedExtensionPackRefs?: readonly ExtensionPackRef<'sql', string>[];\n}\n\n/**\n * Derives the emit output path from the schema input path so artefacts land\n * colocated with the source (e.g. `src/contract/schema.prisma` →\n * `src/contract/contract.json`). The provider owns this because it is the\n * only layer that knows the input path; the upstream `normalizeContractConfig`\n * default is a last-resort fallback for providers that don't carry one.\n */\nfunction defaultOutputFromSchemaPath(schemaPath: string): string {\n  const ext = extname(schemaPath);\n  if (ext.length === 0) return `${schemaPath}.json`;\n  const base = schemaPath.slice(0, -ext.length);\n  // PSL schemas commonly use `schema.prisma`; the emitted JSON is called\n  // `contract.json` to mirror the rest of the toolchain, not `schema.json`.\n  // Match only the exact basename `schema` so files like `my-schema.prisma`\n  // are not silently rewritten to `my-contract.json`.\n  if (basename(base) === 'schema') {\n    return `${base.slice(0, -'schema'.length)}contract.json`;\n  }\n  return `${base}.json`;\n}\n\nfunction buildColumnDescriptorMap(\n  scalarTypeDescriptors: ReadonlyMap<string, string>,\n  codecLookup: CodecLookup,\n): ReadonlyMap<string, ColumnDescriptor> {\n  const result = new Map<string, ColumnDescriptor>();\n  for (const [typeName, codecId] of scalarTypeDescriptors) {\n    const nativeType = codecLookup.targetTypesFor(codecId)?.[0];\n    if (nativeType === undefined) continue;\n    result.set(typeName, { codecId, nativeType });\n  }\n  return result;\n}\n\nexport function prismaContract(schemaPath: string, options: PrismaContractOptions): ContractConfig {\n  return {\n    source: {\n      inputs: [schemaPath],\n      load: async (context) => {\n        const [absoluteSchemaPath] = context.resolvedInputs;\n        if (absoluteSchemaPath === undefined) {\n          throw new Error(\n            'prismaContract: context.resolvedInputs is empty. The CLI config loader should populate it positional-matched with source.inputs.',\n          );\n        }\n        let schema: string;\n        try {\n          schema = await readFile(absoluteSchemaPath, 'utf-8');\n        } catch (error) {\n          const message = String(error);\n          return notOk({\n            summary: `Failed to read Prisma schema at \"${schemaPath}\"`,\n            diagnostics: [\n              {\n                code: 'PSL_SCHEMA_READ_FAILED',\n                message,\n                sourceId: schemaPath,\n              },\n            ],\n            meta: { schemaPath, absoluteSchemaPath, cause: message },\n          });\n        }\n\n        const document = parsePslDocument({\n          schema,\n          sourceId: schemaPath,\n        });\n\n        const scalarTypeDescriptors = buildColumnDescriptorMap(\n          context.scalarTypeDescriptors,\n          context.codecLookup,\n        );\n\n        const interpreted = interpretPslDocumentToSqlContract({\n          document,\n          target: options.target,\n          authoringContributions: context.authoringContributions,\n          scalarTypeDescriptors,\n          ...ifDefined(\n            'composedExtensionPacks',\n            context.composedExtensionPacks.length > 0\n              ? [...context.composedExtensionPacks]\n              : undefined,\n          ),\n          ...ifDefined(\n            'composedExtensionPackRefs',\n            options.composedExtensionPackRefs?.length\n              ? options.composedExtensionPackRefs\n              : undefined,\n          ),\n          controlMutationDefaults: context.controlMutationDefaults,\n        });\n        if (!interpreted.ok) {\n          return interpreted;\n        }\n\n        return ok(interpreted.value);\n      },\n    },\n    output: options.output ?? defaultOutputFromSchemaPath(schemaPath),\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;AAwBA,SAAS,4BAA4B,YAA4B;CAC/D,MAAM,MAAM,QAAQ,UAAU;CAC9B,IAAI,IAAI,WAAW,GAAG,OAAO,GAAG,WAAW;CAC3C,MAAM,OAAO,WAAW,MAAM,GAAG,CAAC,IAAI,MAAM;CAK5C,IAAI,SAAS,IAAI,MAAM,UACrB,OAAO,GAAG,KAAK,MAAM,GAAG,EAAgB,EAAE;CAE5C,OAAO,GAAG,KAAK;AACjB;AAEA,SAAS,yBACP,uBACA,aACuC;CACvC,MAAM,yBAAS,IAAI,IAA8B;CACjD,KAAK,MAAM,CAAC,UAAU,YAAY,uBAAuB;EACvD,MAAM,aAAa,YAAY,eAAe,OAAO,IAAI;EACzD,IAAI,eAAe,KAAA,GAAW;EAC9B,OAAO,IAAI,UAAU;GAAE;GAAS;EAAW,CAAC;CAC9C;CACA,OAAO;AACT;AAEA,SAAgB,eAAe,YAAoB,SAAgD;CACjG,OAAO;EACL,QAAQ;GACN,QAAQ,CAAC,UAAU;GACnB,MAAM,OAAO,YAAY;IACvB,MAAM,CAAC,sBAAsB,QAAQ;IACrC,IAAI,uBAAuB,KAAA,GACzB,MAAM,IAAI,MACR,kIACF;IAEF,IAAI;IACJ,IAAI;KACF,SAAS,MAAM,SAAS,oBAAoB,OAAO;IACrD,SAAS,OAAO;KACd,MAAM,UAAU,OAAO,KAAK;KAC5B,OAAO,MAAM;MACX,SAAS,oCAAoC,WAAW;MACxD,aAAa,CACX;OACE,MAAM;OACN;OACA,UAAU;MACZ,CACF;MACA,MAAM;OAAE;OAAY;OAAoB,OAAO;MAAQ;KACzD,CAAC;IACH;IAEA,MAAM,WAAW,iBAAiB;KAChC;KACA,UAAU;IACZ,CAAC;IAED,MAAM,wBAAwB,yBAC5B,QAAQ,uBACR,QAAQ,WACV;IAEA,MAAM,cAAc,kCAAkC;KACpD;KACA,QAAQ,QAAQ;KAChB,wBAAwB,QAAQ;KAChC;KACA,GAAG,UACD,0BACA,QAAQ,uBAAuB,SAAS,IACpC,CAAC,GAAG,QAAQ,sBAAsB,IAClC,KAAA,CACN;KACA,GAAG,UACD,6BACA,QAAQ,2BAA2B,SAC/B,QAAQ,4BACR,KAAA,CACN;KACA,yBAAyB,QAAQ;IACnC,CAAC;IACD,IAAI,CAAC,YAAY,IACf,OAAO;IAGT,OAAO,GAAG,YAAY,KAAK;GAC7B;EACF;EACA,QAAQ,QAAQ,UAAU,4BAA4B,UAAU;CAClE;AACF"}
+{"version":3,"file":"provider.mjs","names":[],"sources":["../src/provider.ts"],"sourcesContent":["import { readFile } from 'node:fs/promises';\nimport type { ContractConfig } from '@prisma-next/config/config-types';\nimport { applySpecifierDefaultControlPolicy } from '@prisma-next/contract/apply-specifier-default-control-policy';\nimport type { ControlPolicy } from '@prisma-next/contract/types';\nimport type { CodecLookup } from '@prisma-next/framework-components/codec';\nimport type { ExtensionPackRef, TargetPackRef } from '@prisma-next/framework-components/components';\nimport type { Namespace } from '@prisma-next/framework-components/ir';\nimport { parsePslDocument } from '@prisma-next/psl-parser';\nimport type { SqlNamespaceTablesInput } from '@prisma-next/sql-contract/types';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport { notOk, ok } from '@prisma-next/utils/result';\nimport { basename, extname } from 'pathe';\nimport { interpretPslDocumentToSqlContract } from './interpreter';\nimport type { ColumnDescriptor } from './psl-column-resolution';\n\nexport interface PrismaContractOptions {\n  readonly output?: string;\n  readonly target: TargetPackRef<'sql', string>;\n  readonly composedExtensionPackRefs?: readonly ExtensionPackRef<'sql', string>[];\n  readonly createNamespace?: (input: SqlNamespaceTablesInput) => Namespace;\n  readonly defaultControlPolicy?: ControlPolicy;\n}\n\n/**\n * Derives the emit output path from the schema input path so artefacts land\n * colocated with the source (e.g. `src/contract/schema.prisma` →\n * `src/contract/contract.json`). The provider owns this because it is the\n * only layer that knows the input path; the upstream `normalizeContractConfig`\n * default is a last-resort fallback for providers that don't carry one.\n */\nfunction defaultOutputFromSchemaPath(schemaPath: string): string {\n  const ext = extname(schemaPath);\n  if (ext.length === 0) return `${schemaPath}.json`;\n  const base = schemaPath.slice(0, -ext.length);\n  // PSL schemas commonly use `schema.prisma`; the emitted JSON is called\n  // `contract.json` to mirror the rest of the toolchain, not `schema.json`.\n  // Match only the exact basename `schema` so files like `my-schema.prisma`\n  // are not silently rewritten to `my-contract.json`.\n  if (basename(base) === 'schema') {\n    return `${base.slice(0, -'schema'.length)}contract.json`;\n  }\n  return `${base}.json`;\n}\n\nfunction buildColumnDescriptorMap(\n  scalarTypeDescriptors: ReadonlyMap<string, string>,\n  codecLookup: CodecLookup,\n): ReadonlyMap<string, ColumnDescriptor> {\n  const result = new Map<string, ColumnDescriptor>();\n  for (const [typeName, codecId] of scalarTypeDescriptors) {\n    const nativeType = codecLookup.targetTypesFor(codecId)?.[0];\n    if (nativeType === undefined) continue;\n    result.set(typeName, { codecId, nativeType });\n  }\n  return result;\n}\n\nexport function prismaContract(schemaPath: string, options: PrismaContractOptions): ContractConfig {\n  return {\n    source: {\n      inputs: [schemaPath],\n      load: async (context) => {\n        const [absoluteSchemaPath] = context.resolvedInputs;\n        if (absoluteSchemaPath === undefined) {\n          throw new Error(\n            'prismaContract: context.resolvedInputs is empty. The CLI config loader should populate it positional-matched with source.inputs.',\n          );\n        }\n        let schema: string;\n        try {\n          schema = await readFile(absoluteSchemaPath, 'utf-8');\n        } catch (error) {\n          const message = String(error);\n          return notOk({\n            summary: `Failed to read Prisma schema at \"${schemaPath}\"`,\n            diagnostics: [\n              {\n                code: 'PSL_SCHEMA_READ_FAILED',\n                message,\n                sourceId: schemaPath,\n              },\n            ],\n            meta: { schemaPath, absoluteSchemaPath, cause: message },\n          });\n        }\n\n        const document = parsePslDocument({\n          schema,\n          sourceId: schemaPath,\n        });\n\n        const scalarTypeDescriptors = buildColumnDescriptorMap(\n          context.scalarTypeDescriptors,\n          context.codecLookup,\n        );\n\n        const interpreted = interpretPslDocumentToSqlContract({\n          document,\n          target: options.target,\n          authoringContributions: context.authoringContributions,\n          scalarTypeDescriptors,\n          ...ifDefined(\n            'composedExtensionPacks',\n            context.composedExtensionPacks.length > 0\n              ? [...context.composedExtensionPacks]\n              : undefined,\n          ),\n          ...ifDefined(\n            'composedExtensionPackRefs',\n            options.composedExtensionPackRefs?.length\n              ? options.composedExtensionPackRefs\n              : undefined,\n          ),\n          controlMutationDefaults: context.controlMutationDefaults,\n          ...ifDefined('createNamespace', options.createNamespace),\n        });\n        if (!interpreted.ok) {\n          return interpreted;\n        }\n\n        return ok(\n          applySpecifierDefaultControlPolicy(interpreted.value, options.defaultControlPolicy),\n        );\n      },\n    },\n    output: options.output ?? defaultOutputFromSchemaPath(schemaPath),\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;AA8BA,SAAS,4BAA4B,YAA4B;CAC/D,MAAM,MAAM,QAAQ,UAAU;CAC9B,IAAI,IAAI,WAAW,GAAG,OAAO,GAAG,WAAW;CAC3C,MAAM,OAAO,WAAW,MAAM,GAAG,CAAC,IAAI,MAAM;CAK5C,IAAI,SAAS,IAAI,MAAM,UACrB,OAAO,GAAG,KAAK,MAAM,GAAG,EAAgB,EAAE;CAE5C,OAAO,GAAG,KAAK;AACjB;AAEA,SAAS,yBACP,uBACA,aACuC;CACvC,MAAM,yBAAS,IAAI,IAA8B;CACjD,KAAK,MAAM,CAAC,UAAU,YAAY,uBAAuB;EACvD,MAAM,aAAa,YAAY,eAAe,OAAO,IAAI;EACzD,IAAI,eAAe,KAAA,GAAW;EAC9B,OAAO,IAAI,UAAU;GAAE;GAAS;EAAW,CAAC;CAC9C;CACA,OAAO;AACT;AAEA,SAAgB,eAAe,YAAoB,SAAgD;CACjG,OAAO;EACL,QAAQ;GACN,QAAQ,CAAC,UAAU;GACnB,MAAM,OAAO,YAAY;IACvB,MAAM,CAAC,sBAAsB,QAAQ;IACrC,IAAI,uBAAuB,KAAA,GACzB,MAAM,IAAI,MACR,kIACF;IAEF,IAAI;IACJ,IAAI;KACF,SAAS,MAAM,SAAS,oBAAoB,OAAO;IACrD,SAAS,OAAO;KACd,MAAM,UAAU,OAAO,KAAK;KAC5B,OAAO,MAAM;MACX,SAAS,oCAAoC,WAAW;MACxD,aAAa,CACX;OACE,MAAM;OACN;OACA,UAAU;MACZ,CACF;MACA,MAAM;OAAE;OAAY;OAAoB,OAAO;MAAQ;KACzD,CAAC;IACH;IAEA,MAAM,WAAW,iBAAiB;KAChC;KACA,UAAU;IACZ,CAAC;IAED,MAAM,wBAAwB,yBAC5B,QAAQ,uBACR,QAAQ,WACV;IAEA,MAAM,cAAc,kCAAkC;KACpD;KACA,QAAQ,QAAQ;KAChB,wBAAwB,QAAQ;KAChC;KACA,GAAG,UACD,0BACA,QAAQ,uBAAuB,SAAS,IACpC,CAAC,GAAG,QAAQ,sBAAsB,IAClC,KAAA,CACN;KACA,GAAG,UACD,6BACA,QAAQ,2BAA2B,SAC/B,QAAQ,4BACR,KAAA,CACN;KACA,yBAAyB,QAAQ;KACjC,GAAG,UAAU,mBAAmB,QAAQ,eAAe;IACzD,CAAC;IACD,IAAI,CAAC,YAAY,IACf,OAAO;IAGT,OAAO,GACL,mCAAmC,YAAY,OAAO,QAAQ,oBAAoB,CACpF;GACF;EACF;EACA,QAAQ,QAAQ,UAAU,4BAA4B,UAAU;CAClE;AACF"}

package/package.json

@@ -1,25 +1,25 @@
 {
   "name": "@prisma-next/sql-contract-psl",
-  "version": "0.12.0-dev.5",
+  "version": "0.12.0-dev.50",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "description": "PSL-to-SQL ContractIR interpreter for Prisma Next",
   "dependencies": {
-    "@prisma-next/config": "0.12.0-dev.5",
-    "@prisma-next/contract": "0.12.0-dev.5",
-    "@prisma-next/framework-components": "0.12.0-dev.5",
-    "@prisma-next/psl-parser": "0.12.0-dev.5",
-    "@prisma-next/sql-contract": "0.12.0-dev.5",
-    "@prisma-next/sql-contract-ts": "0.12.0-dev.5",
-    "@prisma-next/utils": "0.12.0-dev.5",
+    "@prisma-next/config": "0.12.0-dev.50",
+    "@prisma-next/contract": "0.12.0-dev.50",
+    "@prisma-next/framework-components": "0.12.0-dev.50",
+    "@prisma-next/psl-parser": "0.12.0-dev.50",
+    "@prisma-next/sql-contract": "0.12.0-dev.50",
+    "@prisma-next/sql-contract-ts": "0.12.0-dev.50",
+    "@prisma-next/utils": "0.12.0-dev.50",
     "pathe": "^2.0.3"
   },
   "devDependencies": {
-    "@prisma-next/contract-authoring": "0.12.0-dev.5",
-    "@prisma-next/test-utils": "0.12.0-dev.5",
-    "@prisma-next/tsconfig": "0.12.0-dev.5",
-    "@prisma-next/tsdown": "0.12.0-dev.5",
+    "@prisma-next/contract-authoring": "0.12.0-dev.50",
+    "@prisma-next/test-utils": "0.12.0-dev.50",
+    "@prisma-next/tsconfig": "0.12.0-dev.50",
+    "@prisma-next/tsdown": "0.12.0-dev.50",
     "arktype": "^2.2.0",
     "tsdown": "0.22.0",
     "typescript": "5.9.3",

package/src/interpreter.ts

@@ -8,6 +8,7 @@ import type {
   ContractField,
   ContractModel,
   ContractValueObject,
+  ControlPolicy,
 } from '@prisma-next/contract/types';
 import { crossRef } from '@prisma-next/contract/types';
 import type {
@@ -23,7 +24,6 @@ import type {
   MutationDefaultGeneratorDescriptor,
 } from '@prisma-next/framework-components/control';
 import type { Namespace } from '@prisma-next/framework-components/ir';
-import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
 import type {
   ParsePslDocumentResult,
   PslAttribute,
@@ -37,17 +37,20 @@ import type {
 import {
   isPostgresEnumStorageEntry,
   type PostgresEnumStorageEntry,
+  type SqlModelStorage,
   type SqlNamespaceTablesInput,
   type StorageTypeInstance,
 } from '@prisma-next/sql-contract/types';
 import {
   buildSqlContractFromDefinition,
+  type FieldNode,
   type ForeignKeyNode,
   type IndexNode,
   type ModelNode,
   type PrimaryKeyNode,
   type UniqueConstraintNode,
 } from '@prisma-next/sql-contract-ts/contract-builder';
+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 {
@@ -58,6 +61,7 @@ import {
   mapFieldNamesToColumns,
   parseAttributeFieldList,
   parseConstraintMapArgument,
+  parseControlPolicyAttribute,
   parseMapName,
   parseObjectLiteralStringMap,
   parseQuotedStringLiteral,
@@ -229,10 +233,6 @@ const UNSPECIFIED_PSL_NAMESPACE_NAME = '__unspecified__';
  * slot empty (which means the late-bound default at the `StorageTable`
  * layer; emitted JSON omits the field).
  */
-function defaultSqlNamespaceIdForTarget(targetId: string): string {
-  return targetId === 'postgres' ? 'public' : UNBOUND_NAMESPACE_ID;
-}
-
 function resolveNamespaceIdForSqlTarget(input: {
   readonly bucketName: string;
   readonly targetId: string;
@@ -647,6 +647,8 @@ function buildModelNodeFromPsl(input: BuildModelNodeInput): BuildModelNodeResult
     : undefined;
   const hasInlinePrimaryKey = primaryKey !== undefined;
   let blockPrimaryKeyDeclared = false;
+  let controlPolicyDeclared = false;
+  let controlPolicy: ControlPolicy | undefined;
 
   const resultBackrelationCandidates: ModelBackrelationCandidate[] = [];
   for (const field of model.fields) {
@@ -733,6 +735,27 @@ function buildModelNodeFromPsl(input: BuildModelNodeInput): BuildModelNodeResult
     if (modelAttribute.name === 'discriminator' || modelAttribute.name === 'base') {
       continue;
     }
+    if (modelAttribute.name === 'control') {
+      if (controlPolicyDeclared) {
+        diagnostics.push({
+          code: 'PSL_DUPLICATE_ATTRIBUTE',
+          message: `\`@@control\` declared more than once on model "${model.name}".`,
+          sourceId,
+          span: modelAttribute.span,
+        });
+        continue;
+      }
+      controlPolicyDeclared = true;
+      const parsed = parseControlPolicyAttribute({
+        attribute: modelAttribute,
+        sourceId,
+        diagnostics,
+      });
+      if (parsed !== undefined) {
+        controlPolicy = parsed;
+      }
+      continue;
+    }
     const attributeLabel = `Model "${model.name}" @@${modelAttribute.name}`;
     if (modelAttribute.name === 'id') {
       if (blockPrimaryKeyDeclared) {
@@ -1103,6 +1126,7 @@ function buildModelNodeFromPsl(input: BuildModelNodeInput): BuildModelNodeResult
       ...(uniqueConstraints.length > 0 ? { uniques: uniqueConstraints } : {}),
       ...(indexNodes.length > 0 ? { indexes: indexNodes } : {}),
       ...(foreignKeyNodes.length > 0 ? { foreignKeys: foreignKeyNodes } : {}),
+      ...ifDefined('control', controlPolicy),
     },
     fkRelationMetadata: resultFkRelationMetadata,
     backrelationCandidates: resultBackrelationCandidates,
@@ -1310,12 +1334,27 @@ function resolvePolymorphism(
   modelNames: Set<string>,
   modelMappings: ReadonlyMap<string, ModelNameMapping>,
   modelNamespaceIds: ReadonlyMap<string, string>,
-  targetId: string,
+  defaultNamespaceId: string,
+  syntheticPkFieldsByVariant: ReadonlyMap<string, readonly string[]>,
+  stiBaseFieldsByBase: ReadonlyMap<string, readonly string[]>,
   sourceId: string,
   diagnostics: ContractSourceDiagnostic[],
 ): Record<string, ContractModel> {
   let patched = models;
 
+  // STI variant columns were materialised onto the base storage table so the
+  // variants' `storage.fields` resolve. They are storage-only on the base — the
+  // domain field belongs to the variant — so strip them from the base model's
+  // domain + storage field maps (the table column, built upstream, stays).
+  for (const [baseName, fieldNames] of stiBaseFieldsByBase) {
+    const baseModel = patched[baseName];
+    if (!baseModel || fieldNames.length === 0) continue;
+    patched = {
+      ...patched,
+      [baseName]: stripStorageOnlyDomainFields(baseModel, fieldNames),
+    };
+  }
+
   for (const [modelName, decl] of discriminatorDeclarations) {
     if (baseDeclarations.has(modelName)) {
       diagnostics.push({
@@ -1410,22 +1449,211 @@ function resolvePolymorphism(
       variantMapping?.model.attributes.some((attr) => attr.name === 'map') ?? false;
     const resolvedTable = hasExplicitMap ? variantMapping?.tableName : baseMapping?.tableName;
 
+    const patchedVariant: ContractModel = {
+      ...variantModel,
+      base: crossRef(
+        baseDecl.baseName,
+        modelNamespaceIds.get(baseDecl.baseName) ?? defaultNamespaceId,
+      ),
+      ...(resolvedTable ? { storage: { ...variantModel.storage, table: resolvedTable } } : {}),
+    };
+
     patched = {
       ...patched,
-      [variantName]: {
-        ...variantModel,
-        base: crossRef(
-          baseDecl.baseName,
-          modelNamespaceIds.get(baseDecl.baseName) ?? defaultSqlNamespaceIdForTarget(targetId),
-        ),
-        ...(resolvedTable ? { storage: { ...variantModel.storage, table: resolvedTable } } : {}),
-      },
+      [variantName]: stripStorageOnlyDomainFields(
+        patchedVariant,
+        syntheticPkFieldsByVariant.get(variantName) ?? [],
+      ),
     };
   }
 
   return patched;
 }
 
+/**
+ * Multi-table-inheritance variants (`@@base` + their own `@@map`) live in a
+ * separate table from their base. The ORM joins that table to the base on the
+ * shared primary key (`base.id = variant.id`), so the variant storage table
+ * must carry the base PK column even though the variant domain model declares
+ * only its own fields. This enriches each MTI variant's `ModelNode` with that
+ * link column, a primary key on it, and a FK back to the base table.
+ *
+ * The link column is reported back per variant in `syntheticPkFieldsByVariant`
+ * so the domain-model patch can drop it again — keeping the variant's domain
+ * surface thin (its create/read inputs don't gain a redundant `id`) while the
+ * storage table stays joinable. Single-table-inheritance variants (no own
+ * table) are left untouched.
+ */
+function materializeMtiVariantStorageLinks(
+  modelNodes: readonly ModelNode[],
+  baseDeclarations: ReadonlyMap<string, BaseDeclaration>,
+  stiVariantNames: ReadonlySet<string>,
+): { modelNodes: ModelNode[]; syntheticPkFieldsByVariant: Map<string, readonly string[]> } {
+  const nodeByModel = new Map(modelNodes.map((node) => [node.modelName, node]));
+  const syntheticPkFieldsByVariant = new Map<string, readonly string[]>();
+
+  const enriched = modelNodes.map((node): ModelNode => {
+    const baseDecl = baseDeclarations.get(node.modelName);
+    if (!baseDecl) return node;
+    const baseNode = nodeByModel.get(baseDecl.baseName);
+    if (!baseNode) return node;
+    // Single-table inheritance (no own `@@map`) shares the base table; it gets
+    // its columns materialised onto the base instead (see
+    // {@link materializeStiVariantStorageColumns}), never a link column.
+    if (stiVariantNames.has(node.modelName)) return node;
+    const basePrimaryKey = baseNode.id;
+    if (!basePrimaryKey || basePrimaryKey.columns.length === 0) return node;
+
+    const existingColumns = new Set(node.fields.map((field) => field.columnName));
+    const linkFields: FieldNode[] = [];
+    for (const pkColumn of basePrimaryKey.columns) {
+      if (existingColumns.has(pkColumn)) continue;
+      const baseField = baseNode.fields.find(
+        (field): field is FieldNode => 'descriptor' in field && field.columnName === pkColumn,
+      );
+      if (!baseField) continue;
+      linkFields.push({
+        fieldName: baseField.fieldName,
+        columnName: pkColumn,
+        descriptor: baseField.descriptor,
+        nullable: false,
+      });
+    }
+    if (linkFields.length === 0) return node;
+
+    syntheticPkFieldsByVariant.set(
+      node.modelName,
+      linkFields.map((field) => field.fieldName),
+    );
+
+    const foreignKey: ForeignKeyNode = {
+      columns: basePrimaryKey.columns,
+      references: {
+        model: baseNode.modelName,
+        table: baseNode.tableName,
+        columns: basePrimaryKey.columns,
+        ...ifDefined('namespaceId', baseNode.namespaceId),
+      },
+      constraint: true,
+      // The link columns are the variant's own primary key, which already
+      // carries a unique index — a separate FK backing index would be redundant.
+      index: false,
+      // Deleting a base row must delete its variant extension row — classic
+      // multi-table-inheritance semantics.
+      onDelete: 'cascade',
+    };
+
+    return {
+      ...node,
+      fields: [...linkFields, ...node.fields],
+      id: { columns: basePrimaryKey.columns },
+      foreignKeys: [...(node.foreignKeys ?? []), foreignKey],
+    };
+  });
+
+  return { modelNodes: enriched, syntheticPkFieldsByVariant };
+}
+
+/**
+ * Single-table-inheritance variants (`@@base` with no own `@@map`) share the
+ * base table: `resolvePolymorphism` points the variant's `storage.table` at the
+ * base, and the ORM reads variant-declared fields straight off the base table.
+ * For that to validate and round-trip, the base storage table must physically
+ * carry every STI variant's declared columns. This enriches the base
+ * `ModelNode` with those columns.
+ *
+ * The materialised columns are always nullable in storage: the base table hosts
+ * every variant's rows, so a column a variant declares as required is still
+ * NULL on sibling-variant rows. The variant's domain field keeps its declared
+ * nullability — required-in-domain / nullable-in-storage is the intended STI
+ * shape.
+ *
+ * Collisions (two variants declaring the same column, or a variant column name
+ * clashing with a base column) are resolved skip-if-exists here, mirroring the
+ * MTI link guard; surfacing them as diagnostics is tracked separately
+ * (TML-2827).
+ */
+function materializeStiVariantStorageColumns(
+  modelNodes: readonly ModelNode[],
+  baseDeclarations: ReadonlyMap<string, BaseDeclaration>,
+  stiVariantNames: ReadonlySet<string>,
+): { modelNodes: ModelNode[]; stiBaseFieldsByBase: Map<string, readonly string[]> } {
+  if (stiVariantNames.size === 0) {
+    return { modelNodes: [...modelNodes], stiBaseFieldsByBase: new Map() };
+  }
+
+  const nodeByModel = new Map(modelNodes.map((node) => [node.modelName, node]));
+  type StiColumn = ModelNode['fields'][number];
+  const stiColumnsByBase = new Map<string, StiColumn[]>();
+
+  for (const variantName of stiVariantNames) {
+    const variantNode = nodeByModel.get(variantName);
+    const baseDecl = baseDeclarations.get(variantName);
+    if (!variantNode || !baseDecl) continue;
+    const baseNode = nodeByModel.get(baseDecl.baseName);
+    if (!baseNode) continue;
+
+    const baseColumns = new Set(baseNode.fields.map((field) => field.columnName));
+    const claimed = stiColumnsByBase.get(baseDecl.baseName) ?? [];
+    const claimedColumns = new Set(claimed.map((field) => field.columnName));
+
+    for (const field of variantNode.fields) {
+      if (baseColumns.has(field.columnName) || claimedColumns.has(field.columnName)) {
+        continue;
+      }
+      claimedColumns.add(field.columnName);
+      claimed.push({ ...field, nullable: true });
+    }
+    stiColumnsByBase.set(baseDecl.baseName, claimed);
+  }
+
+  // The materialised columns exist on the base STORAGE table so the variants'
+  // `storage.fields` resolve, but they are NOT base DOMAIN fields — `severity`
+  // belongs to `Bug`, not to `Task`. Report the materialised field names per
+  // base so the domain patch can strip them from the base model (the table
+  // column stays); this is the STI analogue of `syntheticPkFieldsByVariant`.
+  const stiBaseFieldsByBase = new Map<string, readonly string[]>();
+  for (const [baseName, columns] of stiColumnsByBase) {
+    stiBaseFieldsByBase.set(
+      baseName,
+      columns.map((field) => field.fieldName),
+    );
+  }
+
+  const enriched = modelNodes.map((node): ModelNode => {
+    // STI variant: contributes a domain model but no storage table of its own.
+    if (stiVariantNames.has(node.modelName)) {
+      return { ...node, sharesBaseTable: true };
+    }
+    const stiColumns = stiColumnsByBase.get(node.modelName);
+    if (!stiColumns || stiColumns.length === 0) return node;
+    return { ...node, fields: [...node.fields, ...stiColumns] };
+  });
+
+  return { modelNodes: enriched, stiBaseFieldsByBase };
+}
+
+/**
+ * Drop the storage-only link fields (added by
+ * {@link materializeMtiVariantStorageLinks}) from a variant's domain model, so
+ * the domain surface stays thin while the storage table keeps the link column.
+ */
+function stripStorageOnlyDomainFields(
+  model: ContractModel,
+  fieldNames: readonly string[],
+): ContractModel {
+  if (fieldNames.length === 0) return model;
+  const fields = { ...model.fields };
+  for (const name of fieldNames) delete fields[name];
+  const storage = blindCast<
+    SqlModelStorage,
+    'SQL interpreter domain models always carry SqlModelStorage'
+  >(model.storage);
+  const storageFields = { ...storage.fields };
+  for (const name of fieldNames) delete storageFields[name];
+  return { ...model, fields, storage: { ...storage, fields: storageFields } };
+}
+
 export function interpretPslDocumentToSqlContract(
   input: InterpretPslDocumentToSqlContractInput,
 ): Result<Contract, ContractSourceDiagnostics> {
@@ -1632,6 +1860,27 @@ export function interpretPslDocumentToSqlContract(
     diagnostics,
   );
 
+  // A variant with `@@base` but no own `@@map` is single-table inheritance:
+  // it shares the base table. (`@@map` ⇒ multi-table inheritance.) This is the
+  // authoritative STI/MTI signal — the variant's resolved table name is not,
+  // because a no-`@@map` STI variant still gets a `lowerFirst(name)` default
+  // table name that differs from the base before `resolvePolymorphism` rewrites
+  // it onto the base table.
+  const stiVariantNames = new Set<string>();
+  for (const variantName of baseDeclarations.keys()) {
+    const variantMapping = modelMappings.get(variantName);
+    const hasExplicitMap =
+      variantMapping?.model.attributes.some((attr) => attr.name === 'map') ?? false;
+    if (!hasExplicitMap) {
+      stiVariantNames.add(variantName);
+    }
+  }
+
+  const { modelNodes: mtiLinkedModelNodes, syntheticPkFieldsByVariant } =
+    materializeMtiVariantStorageLinks(modelNodes, baseDeclarations, stiVariantNames);
+  const { modelNodes: stiColumnModelNodes, stiBaseFieldsByBase } =
+    materializeStiVariantStorageColumns(mtiLinkedModelNodes, baseDeclarations, stiVariantNames);
+
   const valueObjects = buildValueObjects({
     compositeTypes,
     enumTypeDescriptors: allEnumTypeDescriptors,
@@ -1667,7 +1916,7 @@ export function interpretPslDocumentToSqlContract(
       ? { namespaceTypes: namespaceEnumStorageTypes }
       : {}),
     ...ifDefined('createNamespace', input.createNamespace),
-    models: modelNodes.map((model) => ({
+    models: stiColumnModelNodes.map((model) => ({
       ...model,
       ...(modelRelations.has(model.modelName)
         ? {
@@ -1687,7 +1936,7 @@ export function interpretPslDocumentToSqlContract(
           `duplicate model name "${modelName}" across domain namespaces during PSL interpretation`,
         );
       }
-      modelsForPatch[modelName] = model as ContractModel;
+      modelsForPatch[modelName] = model;
     }
   }
   let patchedModels = patchModelDomainFields(modelsForPatch, modelResolvedFields);
@@ -1700,7 +1949,9 @@ export function interpretPslDocumentToSqlContract(
     modelNames,
     modelMappings,
     modelNamespaceIds,
-    input.target.targetId,
+    input.target.defaultNamespaceId,
+    syntheticPkFieldsByVariant,
+    stiBaseFieldsByBase,
     sourceId,
     polyDiagnostics,
   );
@@ -1736,7 +1987,7 @@ export function interpretPslDocumentToSqlContract(
             ...(namespaceSlice.valueObjects !== undefined
               ? { valueObjects: namespaceSlice.valueObjects }
               : {}),
-            ...(namespaceId === defaultSqlNamespaceIdForTarget(input.target.targetId) &&
+            ...(namespaceId === input.target.defaultNamespaceId &&
             Object.keys(valueObjects).length > 0
               ? { valueObjects }
               : {}),

package/src/provider.ts

@@ -1,8 +1,12 @@
 import { readFile } from 'node:fs/promises';
 import type { ContractConfig } from '@prisma-next/config/config-types';
+import { applySpecifierDefaultControlPolicy } from '@prisma-next/contract/apply-specifier-default-control-policy';
+import type { ControlPolicy } from '@prisma-next/contract/types';
 import type { CodecLookup } from '@prisma-next/framework-components/codec';
 import type { ExtensionPackRef, TargetPackRef } from '@prisma-next/framework-components/components';
+import type { Namespace } from '@prisma-next/framework-components/ir';
 import { parsePslDocument } from '@prisma-next/psl-parser';
+import type { SqlNamespaceTablesInput } from '@prisma-next/sql-contract/types';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { notOk, ok } from '@prisma-next/utils/result';
 import { basename, extname } from 'pathe';
@@ -13,6 +17,8 @@ export interface PrismaContractOptions {
   readonly output?: string;
   readonly target: TargetPackRef<'sql', string>;
   readonly composedExtensionPackRefs?: readonly ExtensionPackRef<'sql', string>[];
+  readonly createNamespace?: (input: SqlNamespaceTablesInput) => Namespace;
+  readonly defaultControlPolicy?: ControlPolicy;
 }
 
 /**
@@ -106,12 +112,15 @@ export function prismaContract(schemaPath: string, options: PrismaContractOption
               : undefined,
           ),
           controlMutationDefaults: context.controlMutationDefaults,
+          ...ifDefined('createNamespace', options.createNamespace),
         });
         if (!interpreted.ok) {
           return interpreted;
         }
 
-        return ok(interpreted.value);
+        return ok(
+          applySpecifierDefaultControlPolicy(interpreted.value, options.defaultControlPolicy),
+        );
       },
     },
     output: options.output ?? defaultOutputFromSchemaPath(schemaPath),

package/src/psl-attribute-parsing.ts

@@ -1,4 +1,5 @@
 import type { ContractSourceDiagnostic } from '@prisma-next/config/config-types';
+import type { ControlPolicy } from '@prisma-next/contract/types';
 import type { PslAttribute, PslSpan } from '@prisma-next/psl-parser';
 import { getPositionalArgument, parseQuotedStringLiteral } from '@prisma-next/psl-parser';
 
@@ -411,6 +412,71 @@ export function findDuplicateFieldName(fieldNames: readonly string[]): string |
   return undefined;
 }
 
+const CONTROL_POLICY_LITERALS = [
+  'managed',
+  'tolerated',
+  'external',
+  'observed',
+] as const satisfies readonly ControlPolicy[];
+
+const CONTROL_POLICY_LITERAL_SET = new Set<string>(CONTROL_POLICY_LITERALS);
+
+function isControlPolicyLiteral(value: string): value is ControlPolicy {
+  return CONTROL_POLICY_LITERAL_SET.has(value);
+}
+
+export function parseControlPolicyAttribute(input: {
+  readonly attribute: PslAttribute;
+  readonly sourceId: string;
+  readonly diagnostics: ContractSourceDiagnostic[];
+}): ControlPolicy | undefined {
+  const namedArgs = input.attribute.args.filter((arg) => arg.kind === 'named');
+  if (namedArgs.length > 0) {
+    input.diagnostics.push({
+      code: 'PSL_INVALID_ATTRIBUTE_ARGUMENT',
+      message:
+        '`@@control` does not accept named arguments; pass the policy positionally as `@@control(external)`.',
+      sourceId: input.sourceId,
+      span: input.attribute.span,
+    });
+    return undefined;
+  }
+
+  const positionalArgs = getPositionalArguments(input.attribute);
+  if (positionalArgs.length === 0) {
+    input.diagnostics.push({
+      code: 'PSL_INVALID_ATTRIBUTE_ARGUMENT',
+      message:
+        '`@@control` requires exactly one positional argument: `managed`, `tolerated`, `external`, or `observed`.',
+      sourceId: input.sourceId,
+      span: input.attribute.span,
+    });
+    return undefined;
+  }
+  if (positionalArgs.length > 1) {
+    input.diagnostics.push({
+      code: 'PSL_INVALID_ATTRIBUTE_ARGUMENT',
+      message: `\`@@control\` accepts exactly one positional argument; got ${positionalArgs.length}.`,
+      sourceId: input.sourceId,
+      span: input.attribute.span,
+    });
+    return undefined;
+  }
+
+  const token = unquoteStringLiteral(positionalArgs[0] ?? '').trim();
+  if (!isControlPolicyLiteral(token)) {
+    input.diagnostics.push({
+      code: 'PSL_INVALID_ATTRIBUTE_ARGUMENT',
+      message: `\`@@control\` argument \`${token}\` is not a known policy. Allowed: \`managed\`, \`tolerated\`, \`external\`, \`observed\`.`,
+      sourceId: input.sourceId,
+      span: input.attribute.span,
+    });
+    return undefined;
+  }
+
+  return token;
+}
+
 export function mapFieldNamesToColumns(input: {
   readonly modelName: string;
   readonly fieldNames: readonly string[];

package/src/psl-column-resolution.ts

@@ -25,6 +25,7 @@ import type {
   PslSpan,
   PslTypeConstructorCall,
 } from '@prisma-next/psl-parser';
+import { blindCast } from '@prisma-next/utils/casts';
 import {
   lowerDefaultFunctionWithRegistry,
   parseDefaultFunctionCall,
@@ -67,7 +68,9 @@ export function getAuthoringTypeConstructor(
     if (typeof current !== 'object' || current === null || Array.isArray(current)) {
       return undefined;
     }
-    current = (current as Record<string, unknown>)[segment];
+    current = blindCast<Record<string, unknown>, 'narrowed by preceding typeof/null/array guards'>(
+      current,
+    )[segment];
   }
 
   return isAuthoringTypeConstructorDescriptor(current) ? current : undefined;
@@ -94,7 +97,9 @@ export function getAuthoringEntity(
     if (typeof current !== 'object' || current === null || Array.isArray(current)) {
       return undefined;
     }
-    current = (current as Record<string, unknown>)[segment];
+    current = blindCast<Record<string, unknown>, 'narrowed by preceding typeof/null/array guards'>(
+      current,
+    )[segment];
   }
 
   return isAuthoringEntityTypeDescriptor(current) ? current : undefined;
@@ -115,7 +120,9 @@ export function getAuthoringFieldPreset(
     if (typeof current !== 'object' || current === null || Array.isArray(current)) {
       return undefined;
     }
-    current = (current as Record<string, unknown>)[segment];
+    current = blindCast<Record<string, unknown>, 'narrowed by preceding typeof/null/array guards'>(
+      current,
+    )[segment];
   }
 
   return isAuthoringFieldPresetDescriptor(current) ? current : undefined;