@prisma-next/sql-contract-psl 0.13.0-dev.16 → 0.13.0-dev.18

package/dist/provider.mjs

@@ -1,4 +1,4 @@
-import { t as interpretPslDocumentToSqlContract } from "./interpreter-B_KtZusL.mjs";
+import { t as interpretPslDocumentToSqlContract } from "./interpreter-CQdQo427.mjs";
 import { ifDefined } from "@prisma-next/utils/defined";
 import { notOk, ok } from "@prisma-next/utils/result";
 import { parsePslDocument } from "@prisma-next/psl-parser";
@@ -60,7 +60,8 @@ function prismaContract(schemaPath, options) {
 				}
 				const document = parsePslDocument({
 					schema,
-					sourceId: schemaPath
+					sourceId: schemaPath,
+					pslBlockDescriptors: context.authoringContributions.pslBlockDescriptors
 				});
 				const scalarTypeDescriptors = buildColumnDescriptorMap(context.scalarTypeDescriptors, context.codecLookup);
 				const interpreted = interpretPslDocumentToSqlContract({
@@ -72,7 +73,8 @@ function prismaContract(schemaPath, options) {
 					composedExtensionContracts: context.composedExtensionContracts,
 					...ifDefined("composedExtensionPackRefs", options.composedExtensionPackRefs?.length ? options.composedExtensionPackRefs : void 0),
 					controlMutationDefaults: context.controlMutationDefaults,
-					...ifDefined("createNamespace", options.createNamespace)
+					...ifDefined("createNamespace", options.createNamespace),
+					codecLookup: context.codecLookup
 				});
 				if (!interpreted.ok) return interpreted;
 				return ok(applySpecifierDefaultControlPolicy(interpreted.value, options.defaultControlPolicy));

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 { 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          composedExtensionContracts: context.composedExtensionContracts,\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,CAAC,GAAG;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,4BAA4B,QAAQ;KACpC,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"}
+{"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          pslBlockDescriptors: context.authoringContributions.pslBlockDescriptors,\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          composedExtensionContracts: context.composedExtensionContracts,\n          ...ifDefined(\n            'composedExtensionPackRefs',\n            options.composedExtensionPackRefs?.length\n              ? options.composedExtensionPackRefs\n              : undefined,\n          ),\n          controlMutationDefaults: context.controlMutationDefaults,\n          ...ifDefined('createNamespace', options.createNamespace),\n          codecLookup: context.codecLookup,\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,CAAC,GAAG;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;KACV,qBAAqB,QAAQ,uBAAuB;IACtD,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,4BAA4B,QAAQ;KACpC,GAAG,UACD,6BACA,QAAQ,2BAA2B,SAC/B,QAAQ,4BACR,KAAA,CACN;KACA,yBAAyB,QAAQ;KACjC,GAAG,UAAU,mBAAmB,QAAQ,eAAe;KACvD,aAAa,QAAQ;IACvB,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.13.0-dev.16",
+  "version": "0.13.0-dev.18",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "description": "PSL-to-SQL ContractIR interpreter for Prisma Next",
   "dependencies": {
-    "@prisma-next/config": "0.13.0-dev.16",
-    "@prisma-next/contract": "0.13.0-dev.16",
-    "@prisma-next/framework-components": "0.13.0-dev.16",
-    "@prisma-next/psl-parser": "0.13.0-dev.16",
-    "@prisma-next/sql-contract": "0.13.0-dev.16",
-    "@prisma-next/sql-contract-ts": "0.13.0-dev.16",
-    "@prisma-next/utils": "0.13.0-dev.16",
+    "@prisma-next/config": "0.13.0-dev.18",
+    "@prisma-next/contract": "0.13.0-dev.18",
+    "@prisma-next/framework-components": "0.13.0-dev.18",
+    "@prisma-next/psl-parser": "0.13.0-dev.18",
+    "@prisma-next/sql-contract": "0.13.0-dev.18",
+    "@prisma-next/sql-contract-ts": "0.13.0-dev.18",
+    "@prisma-next/utils": "0.13.0-dev.18",
     "pathe": "^2.0.3"
   },
   "devDependencies": {
-    "@prisma-next/contract-authoring": "0.13.0-dev.16",
-    "@prisma-next/test-utils": "0.13.0-dev.16",
-    "@prisma-next/tsconfig": "0.13.0-dev.16",
-    "@prisma-next/tsdown": "0.13.0-dev.16",
+    "@prisma-next/contract-authoring": "0.13.0-dev.18",
+    "@prisma-next/test-utils": "0.13.0-dev.18",
+    "@prisma-next/tsconfig": "0.13.0-dev.18",
+    "@prisma-next/tsdown": "0.13.0-dev.18",
     "arktype": "^2.2.0",
     "tsdown": "0.22.1",
     "typescript": "5.9.3",

package/src/interpreter.ts

@@ -17,6 +17,7 @@ import type {
   AuthoringEntityTypeDescriptor,
 } from '@prisma-next/framework-components/authoring';
 import { instantiateAuthoringEntityType } from '@prisma-next/framework-components/authoring';
+import type { CodecLookup } from '@prisma-next/framework-components/codec';
 import type { ExtensionPackRef, TargetPackRef } from '@prisma-next/framework-components/components';
 import type {
   ControlMutationDefaultRegistry,
@@ -24,11 +25,13 @@ import type {
   MutationDefaultGeneratorDescriptor,
 } from '@prisma-next/framework-components/control';
 import type { Namespace } from '@prisma-next/framework-components/ir';
+import { namespacePslExtensionBlocks } from '@prisma-next/framework-components/psl-ast';
 import type {
   ParsePslDocumentResult,
   PslAttribute,
   PslCompositeType,
   PslEnum,
+  PslExtensionBlock,
   PslField,
   PslModel,
   PslNamedTypeDeclaration,
@@ -43,6 +46,7 @@ import {
 } from '@prisma-next/sql-contract/types';
 import {
   buildSqlContractFromDefinition,
+  type EnumTypeHandle,
   type FieldNode,
   type ForeignKeyNode,
   type IndexNode,
@@ -124,6 +128,7 @@ export interface InterpretPslDocumentToSqlContractInput {
    * `SqlUnboundNamespace` singleton.
    */
   readonly createNamespace?: (input: SqlNamespaceTablesInput) => Namespace;
+  readonly codecLookup?: CodecLookup;
 }
 
 function buildComposedExtensionPackRefs(
@@ -375,6 +380,59 @@ function processEnumDeclarations(input: ProcessEnumDeclarationsInput): {
   return { storageTypes, enumTypeDescriptors };
 }
 
+interface ProcessEnum2DeclarationsInput {
+  readonly enum2Blocks: readonly PslExtensionBlock[];
+  readonly sourceId: string;
+  readonly authoringContributions: AuthoringContributions | undefined;
+  readonly entityContext: AuthoringEntityContext;
+  readonly diagnostics: ContractSourceDiagnostic[];
+}
+
+function processEnum2Declarations(input: ProcessEnum2DeclarationsInput): {
+  readonly enumHandles: Record<string, EnumTypeHandle>;
+  readonly enumTypeDescriptors: Map<string, ColumnDescriptor>;
+} {
+  const enumHandles: Record<string, EnumTypeHandle> = {};
+  const enumTypeDescriptors = new Map<string, ColumnDescriptor>();
+
+  if (input.enum2Blocks.length === 0) {
+    return { enumHandles, enumTypeDescriptors };
+  }
+
+  const enum2EntityDescriptor = getAuthoringEntity(input.authoringContributions, ['enum2']);
+  if (!enum2EntityDescriptor) {
+    for (const decl of input.enum2Blocks) {
+      input.diagnostics.push({
+        code: 'PSL_ENUM2_MISSING_FACTORY',
+        message: `enum2 "${decl.name}" requires an "enum2" entityType factory in the active authoring contributions`,
+        sourceId: input.sourceId,
+        span: decl.span,
+      });
+    }
+    return { enumHandles, enumTypeDescriptors };
+  }
+
+  for (const decl of input.enum2Blocks) {
+    const handle = instantiateAuthoringEntityType(
+      'enum2',
+      enum2EntityDescriptor,
+      [decl],
+      input.entityContext,
+    );
+
+    if (handle === undefined || handle === null) continue;
+
+    const enumHandle = blindCast<EnumTypeHandle, 'enum2 factory returns EnumTypeHandle'>(handle);
+    enumHandles[decl.name] = enumHandle;
+    enumTypeDescriptors.set(decl.name, {
+      codecId: enumHandle.codecId,
+      nativeType: enumHandle.nativeType,
+    });
+  }
+
+  return { enumHandles, enumTypeDescriptors };
+}
+
 interface ResolveNamedTypeDeclarationsInput {
   readonly declarations: readonly PslNamedTypeDeclaration[];
   readonly sourceId: string;
@@ -619,6 +677,7 @@ interface BuildModelNodeInput {
   readonly diagnostics: ContractSourceDiagnostic[];
   /** Resolved namespace id keyed by model name — used to stamp the target namespace on FKs. */
   readonly modelNamespaceIds: ReadonlyMap<string, string>;
+  readonly enum2Handles?: ReadonlyMap<string, EnumTypeHandle>;
 }
 
 interface BuildModelNodeResult {
@@ -650,6 +709,7 @@ function buildModelNodeFromPsl(input: BuildModelNodeInput): BuildModelNodeResult
     diagnostics,
     sourceId,
     scalarTypeDescriptors: input.scalarTypeDescriptors,
+    ...ifDefined('enum2Handles', input.enum2Handles),
   });
 
   const inlineIdFields = resolvedFields.filter((field) => field.isId);
@@ -1320,14 +1380,18 @@ function buildModelNodeFromPsl(input: BuildModelNodeInput): BuildModelNodeResult
     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('executionDefaults', resolvedField.executionDefaults),
-      })),
+      fields: resolvedFields.map((resolvedField) => {
+        const enumHandle = input.enum2Handles?.get(resolvedField.field.typeName);
+        return {
+          fieldName: resolvedField.field.name,
+          columnName: resolvedField.columnName,
+          descriptor: resolvedField.descriptor,
+          nullable: resolvedField.field.optional,
+          ...ifDefined('default', resolvedField.defaultValue),
+          ...ifDefined('executionDefaults', resolvedField.executionDefaults),
+          ...ifDefined('enumTypeHandle', enumHandle),
+        };
+      }),
       ...ifDefined('id', primaryKey),
       ...(uniqueConstraints.length > 0 ? { uniques: uniqueConstraints } : {}),
       ...(indexNodes.length > 0 ? { indexes: indexNodes } : {}),
@@ -2006,6 +2070,68 @@ export function interpretPslDocumentToSqlContract(
     }
   }
 
+  const topLevelEnum2s = input.document.ast.namespaces
+    .filter((ns) => ns.name === UNSPECIFIED_PSL_NAMESPACE_NAME)
+    .flatMap((ns) => namespacePslExtensionBlocks(ns).filter((b) => b.kind === 'enum2'));
+  for (const ns of input.document.ast.namespaces) {
+    if (ns.name === UNSPECIFIED_PSL_NAMESPACE_NAME) continue;
+    const nsEnum2s = namespacePslExtensionBlocks(ns).filter((b) => b.kind === 'enum2');
+    if (nsEnum2s.length === 0) continue;
+    for (const decl of nsEnum2s) {
+      diagnostics.push({
+        code: 'PSL_ENUM2_NAMESPACE_NOT_SUPPORTED',
+        message: `enum2 "${decl.name}" inside namespace "${ns.name}" is not supported; declare enum2 at the top level`,
+        sourceId,
+        span: decl.span,
+      });
+    }
+  }
+
+  const enum2Result = processEnum2Declarations({
+    enum2Blocks: topLevelEnum2s,
+    sourceId,
+    authoringContributions: input.authoringContributions,
+    entityContext: {
+      family: input.target.familyId,
+      target: input.target.targetId,
+      ...ifDefined('codecLookup', input.codecLookup),
+      sourceId,
+      diagnostics: {
+        push: (d) => {
+          diagnostics.push(
+            blindCast<ContractSourceDiagnostic, 'sink diagnostics are span-compatible'>(d),
+          );
+        },
+      },
+    },
+    diagnostics,
+  });
+
+  const collidingEnum2Names = new Set<string>();
+  for (const [name, descriptor] of enum2Result.enumTypeDescriptors) {
+    if (allEnumTypeDescriptors.has(name)) {
+      collidingEnum2Names.add(name);
+      const collision = topLevelEnum2s.find((e) => e.name === name);
+      diagnostics.push({
+        code: 'PSL_ENUM2_DUPLICATE_TYPE_NAME',
+        message: `enum2 "${name}" collides with an existing type name; each type name must be unique`,
+        sourceId,
+        ...ifDefined('span', collision?.span),
+      });
+    } else {
+      allEnumTypeDescriptors.set(name, descriptor);
+    }
+  }
+
+  const validEnum2Handles: Record<string, EnumTypeHandle> = {};
+  for (const [name, handle] of Object.entries(enum2Result.enumHandles)) {
+    if (!collidingEnum2Names.has(name)) {
+      validEnum2Handles[name] = handle;
+    }
+  }
+
+  const enum2HandlesByName = new Map(Object.entries(validEnum2Handles));
+
   const namedTypeResult = resolveNamedTypeDeclarations({
     declarations: input.document.ast.types?.declarations ?? [],
     sourceId,
@@ -2068,6 +2194,7 @@ export function interpretPslDocumentToSqlContract(
       sourceId,
       diagnostics,
       modelNamespaceIds,
+      ...(enum2HandlesByName.size > 0 ? { enum2Handles: enum2HandlesByName } : {}),
     });
     modelNodes.push(
       namespaceId !== undefined ? { ...result.modelNode, namespaceId } : result.modelNode,
@@ -2162,6 +2289,7 @@ export function interpretPslDocumentToSqlContract(
     ...(Object.keys(namespaceEnumStorageTypes).length > 0
       ? { namespaceTypes: namespaceEnumStorageTypes }
       : {}),
+    ...(Object.keys(validEnum2Handles).length > 0 ? { enums: validEnum2Handles } : {}),
     ...ifDefined('createNamespace', input.createNamespace),
     models: stiColumnModelNodes.map((model) => ({
       ...model,
@@ -2233,6 +2361,7 @@ export function interpretPslDocumentToSqlContract(
                 patchedModels[modelCoordinateKey(namespaceId, modelName)] ?? model,
               ]),
             ),
+            ...(namespaceSlice.enum !== undefined ? { enum: namespaceSlice.enum } : {}),
             ...(namespaceSlice.valueObjects !== undefined
               ? { valueObjects: namespaceSlice.valueObjects }
               : {}),

package/src/provider.ts

@@ -87,6 +87,7 @@ export function prismaContract(schemaPath: string, options: PrismaContractOption
         const document = parsePslDocument({
           schema,
           sourceId: schemaPath,
+          pslBlockDescriptors: context.authoringContributions.pslBlockDescriptors,
         });
 
         const scalarTypeDescriptors = buildColumnDescriptorMap(
@@ -114,6 +115,7 @@ export function prismaContract(schemaPath: string, options: PrismaContractOption
           ),
           controlMutationDefaults: context.controlMutationDefaults,
           ...ifDefined('createNamespace', options.createNamespace),
+          codecLookup: context.codecLookup,
         });
         if (!interpreted.ok) {
           return interpreted;

package/src/psl-field-resolution.ts

@@ -1,14 +1,21 @@
 import type { ContractSourceDiagnostic } from '@prisma-next/config/config-types';
-import type { ColumnDefault, ExecutionMutationDefaultPhases } from '@prisma-next/contract/types';
+import type {
+  ColumnDefault,
+  ColumnDefaultLiteralInputValue,
+  ExecutionMutationDefaultPhases,
+} from '@prisma-next/contract/types';
 import type { AuthoringContributions } from '@prisma-next/framework-components/authoring';
 import type {
   ControlMutationDefaultRegistry,
   MutationDefaultGeneratorDescriptor,
 } from '@prisma-next/framework-components/control';
 import type { PslAttribute, PslField, PslModel } from '@prisma-next/psl-parser';
+import type { EnumTypeHandle } from '@prisma-next/sql-contract-ts/contract-builder';
+import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
 import {
   getAttribute,
+  getPositionalArgumentEntry,
   lowerFirst,
   parseConstraintMapArgument,
   parseMapName,
@@ -21,6 +28,61 @@ import {
   resolveFieldTypeDescriptor,
 } from './psl-column-resolution';
 
+type LoweredFieldDefault = {
+  readonly defaultValue?: ColumnDefault;
+  readonly executionDefaults?: ExecutionMutationDefaultPhases;
+};
+
+function lowerEnum2DefaultForField(input: {
+  readonly modelName: string;
+  readonly fieldName: string;
+  readonly defaultAttribute: PslAttribute;
+  readonly enumHandle: EnumTypeHandle;
+  readonly sourceId: string;
+  readonly diagnostics: ContractSourceDiagnostic[];
+}): LoweredFieldDefault {
+  const expressionEntry = getPositionalArgumentEntry(input.defaultAttribute);
+  if (!expressionEntry) {
+    return {};
+  }
+
+  const raw = expressionEntry.value.trim();
+  const isQuotedString = /^(['"]).*\1$/.test(raw);
+  const isFunctionCall = raw.includes('(') && raw.endsWith(')');
+
+  if (isQuotedString || isFunctionCall) {
+    input.diagnostics.push({
+      code: 'PSL_ENUM2_DEFAULT_MUST_BE_MEMBER_NAME',
+      message: `Field "${input.modelName}.${input.fieldName}" @default on an enum2 field must name a member (e.g. @default(Low)), not a raw value or function.`,
+      sourceId: input.sourceId,
+      span: input.defaultAttribute.span,
+    });
+    return {};
+  }
+
+  const match = input.enumHandle.enumMembers.find((m) => m.name === raw);
+  if (!match) {
+    const validNames = input.enumHandle.enumMembers.map((m) => m.name).join(', ');
+    input.diagnostics.push({
+      code: 'PSL_ENUM2_UNKNOWN_DEFAULT_MEMBER',
+      message: `Field "${input.modelName}.${input.fieldName}" @default(${raw}) does not name a member of ${input.enumHandle.enumName}. Valid members: ${validNames}.`,
+      sourceId: input.sourceId,
+      span: input.defaultAttribute.span,
+    });
+    return {};
+  }
+
+  return {
+    defaultValue: {
+      kind: 'literal',
+      value: blindCast<
+        ColumnDefaultLiteralInputValue,
+        'enum member values are codec-validated JsonValue-compatible scalars'
+      >(match.value),
+    },
+  };
+}
+
 export type ResolvedField = {
   readonly field: PslField;
   readonly columnName: string;
@@ -76,6 +138,7 @@ export interface CollectResolvedFieldsInput {
   readonly diagnostics: ContractSourceDiagnostic[];
   readonly sourceId: string;
   readonly scalarTypeDescriptors: ReadonlyMap<string, ColumnDescriptor>;
+  readonly enum2Handles?: ReadonlyMap<string, EnumTypeHandle>;
 }
 
 const BUILTIN_FIELD_ATTRIBUTE_NAMES: ReadonlySet<string> = new Set([
@@ -225,6 +288,7 @@ export function collectResolvedFields(input: CollectResolvedFieldsInput): Resolv
     diagnostics,
     sourceId,
     scalarTypeDescriptors,
+    enum2Handles,
   } = input;
   const resolvedFields: ResolvedField[] = [];
 
@@ -350,17 +414,27 @@ export function collectResolvedFields(input: CollectResolvedFieldsInput): Resolv
       });
       continue;
     }
-    const loweredDefault = defaultAttribute
-      ? lowerDefaultForField({
-          modelName: model.name,
-          fieldName: field.name,
-          defaultAttribute,
-          columnDescriptor: descriptor,
-          generatorDescriptorById,
-          sourceId,
-          defaultFunctionRegistry,
-          diagnostics,
-        })
+    const enum2Handle = enum2Handles?.get(field.typeName);
+    const loweredDefault: LoweredFieldDefault = defaultAttribute
+      ? enum2Handle
+        ? lowerEnum2DefaultForField({
+            modelName: model.name,
+            fieldName: field.name,
+            defaultAttribute,
+            enumHandle: enum2Handle,
+            sourceId,
+            diagnostics,
+          })
+        : lowerDefaultForField({
+            modelName: model.name,
+            fieldName: field.name,
+            defaultAttribute,
+            columnDescriptor: descriptor,
+            generatorDescriptorById,
+            sourceId,
+            defaultFunctionRegistry,
+            diagnostics,
+          })
       : {};
     const loweredOnCreate = loweredDefault.executionDefaults?.onCreate;
     if (field.optional && loweredOnCreate) {