@prisma-next/sql-contract-psl 0.13.0-dev.9 → 0.14.0-dev.1

package/dist/provider.d.mts

@@ -1,8 +1,8 @@
 import { ControlPolicy } from "@prisma-next/contract/types";
-import { SqlNamespaceTablesInput } from "@prisma-next/sql-contract/types";
 import { ContractConfig } from "@prisma-next/config/config-types";
 import { ExtensionPackRef, TargetPackRef } from "@prisma-next/framework-components/components";
 import { Namespace } from "@prisma-next/framework-components/ir";
+import { SqlNamespaceTablesInput } from "@prisma-next/sql-contract/types";
 
 //#region src/provider.d.ts
 interface PrismaContractOptions {

package/dist/provider.mjs

@@ -1,4 +1,4 @@
-import { t as interpretPslDocumentToSqlContract } from "./interpreter-B_KtZusL.mjs";
+import { t as interpretPslDocumentToSqlContract } from "./interpreter-B0BsCLKT.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.9",
+  "version": "0.14.0-dev.1",
   "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.9",
-    "@prisma-next/contract": "0.13.0-dev.9",
-    "@prisma-next/framework-components": "0.13.0-dev.9",
-    "@prisma-next/psl-parser": "0.13.0-dev.9",
-    "@prisma-next/sql-contract": "0.13.0-dev.9",
-    "@prisma-next/sql-contract-ts": "0.13.0-dev.9",
-    "@prisma-next/utils": "0.13.0-dev.9",
+    "@prisma-next/config": "0.14.0-dev.1",
+    "@prisma-next/contract": "0.14.0-dev.1",
+    "@prisma-next/framework-components": "0.14.0-dev.1",
+    "@prisma-next/psl-parser": "0.14.0-dev.1",
+    "@prisma-next/sql-contract": "0.14.0-dev.1",
+    "@prisma-next/sql-contract-ts": "0.14.0-dev.1",
+    "@prisma-next/utils": "0.14.0-dev.1",
     "pathe": "^2.0.3"
   },
   "devDependencies": {
-    "@prisma-next/contract-authoring": "0.13.0-dev.9",
-    "@prisma-next/test-utils": "0.13.0-dev.9",
-    "@prisma-next/tsconfig": "0.13.0-dev.9",
-    "@prisma-next/tsdown": "0.13.0-dev.9",
+    "@prisma-next/contract-authoring": "0.14.0-dev.1",
+    "@prisma-next/test-utils": "0.14.0-dev.1",
+    "@prisma-next/tsconfig": "0.14.0-dev.1",
+    "@prisma-next/tsdown": "0.14.0-dev.1",
     "arktype": "^2.2.0",
     "tsdown": "0.22.1",
     "typescript": "5.9.3",

package/src/interpreter.ts

@@ -14,9 +14,9 @@ import { crossRef } from '@prisma-next/contract/types';
 import type {
   AuthoringContributions,
   AuthoringEntityContext,
-  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,25 +24,25 @@ 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,
   PslNamespace,
 } from '@prisma-next/psl-parser';
-import {
-  isPostgresEnumStorageEntry,
-  type PostgresEnumStorageEntry,
-  type SqlModelStorage,
-  type SqlNamespaceTablesInput,
-  type StorageTypeInstance,
+import type {
+  SqlModelStorage,
+  SqlNamespaceTablesInput,
+  StorageTypeInstance,
 } from '@prisma-next/sql-contract/types';
 import {
   buildSqlContractFromDefinition,
+  type EnumTypeHandle,
   type FieldNode,
   type ForeignKeyNode,
   type IndexNode,
@@ -63,7 +63,6 @@ import {
   parseAttributeFieldList,
   parseConstraintMapArgument,
   parseControlPolicyAttribute,
-  parseMapName,
   parseObjectLiteralStringMap,
   parseQuotedStringLiteral,
 } from './psl-attribute-parsing';
@@ -124,6 +123,7 @@ export interface InterpretPslDocumentToSqlContractInput {
    * `SqlUnboundNamespace` singleton.
    */
   readonly createNamespace?: (input: SqlNamespaceTablesInput) => Namespace;
+  readonly codecLookup?: CodecLookup;
 }
 
 function buildComposedExtensionPackRefs(
@@ -302,77 +302,56 @@ function validateNamespaceBlocksForSqlTarget(input: {
 }
 
 interface ProcessEnumDeclarationsInput {
-  readonly enums: readonly PslEnum[];
+  readonly enumBlocks: readonly PslExtensionBlock[];
   readonly sourceId: string;
-  readonly enumEntityDescriptor: AuthoringEntityTypeDescriptor | undefined;
+  readonly authoringContributions: AuthoringContributions | undefined;
   readonly entityContext: AuthoringEntityContext;
   readonly diagnostics: ContractSourceDiagnostic[];
 }
 
 function processEnumDeclarations(input: ProcessEnumDeclarationsInput): {
-  readonly storageTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry>;
+  readonly enumHandles: Record<string, EnumTypeHandle>;
   readonly enumTypeDescriptors: Map<string, ColumnDescriptor>;
 } {
-  const storageTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry> = {};
+  const enumHandles: Record<string, EnumTypeHandle> = {};
   const enumTypeDescriptors = new Map<string, ColumnDescriptor>();
 
-  if (input.enums.length === 0) {
-    return { storageTypes, enumTypeDescriptors };
+  if (input.enumBlocks.length === 0) {
+    return { enumHandles, enumTypeDescriptors };
   }
 
-  if (!input.enumEntityDescriptor) {
-    // The PSL `enum X { … }` syntax only resolves when the active
-    // pack composition contributes an `enum` entity-type factory (the
-    // Postgres target pack does so today via
-    // `authoring.entityTypes.enum`). Without the contribution we
-    // surface a diagnostic per declaration rather than silently
-    // swallowing the syntax.
-    for (const enumDeclaration of input.enums) {
+  const enumDescriptor = getAuthoringEntity(input.authoringContributions, ['enum']);
+  if (!enumDescriptor) {
+    for (const decl of input.enumBlocks) {
       input.diagnostics.push({
-        code: 'PSL_UNSUPPORTED_NAMED_TYPE_BASE',
-        message: `Enum "${enumDeclaration.name}" requires the active target pack to contribute an enum entity-type helper`,
+        code: 'PSL_ENUM_MISSING_FACTORY',
+        message: `enum "${decl.name}" requires an "enum" entityType factory in the active authoring contributions`,
         sourceId: input.sourceId,
-        span: enumDeclaration.span,
+        span: decl.span,
       });
     }
-    return { storageTypes, enumTypeDescriptors };
+    return { enumHandles, enumTypeDescriptors };
   }
 
-  for (const enumDeclaration of input.enums) {
-    const nativeType = parseMapName({
-      attribute: getAttribute(enumDeclaration.attributes, 'map'),
-      defaultValue: enumDeclaration.name,
-      sourceId: input.sourceId,
-      diagnostics: input.diagnostics,
-      entityLabel: `Enum "${enumDeclaration.name}"`,
-      span: enumDeclaration.span,
-    });
-    const values = enumDeclaration.values.map((value) => value.name);
-    const constructed = instantiateAuthoringEntityType(
+  for (const decl of input.enumBlocks) {
+    const handle = instantiateAuthoringEntityType(
       'enum',
-      input.enumEntityDescriptor,
-      [{ name: enumDeclaration.name, nativeType, values }],
+      enumDescriptor,
+      [decl],
       input.entityContext,
     );
-    if (!isPostgresEnumStorageEntry(constructed)) {
-      input.diagnostics.push({
-        code: 'PSL_UNSUPPORTED_NAMED_TYPE_BASE',
-        message: `Enum "${enumDeclaration.name}": enum entity-type factory must return a PostgresEnumStorageEntry-shaped value (kind: 'postgres-enum')`,
-        sourceId: input.sourceId,
-        span: enumDeclaration.span,
-      });
-      continue;
-    }
-    const descriptor: ColumnDescriptor = {
-      codecId: constructed.codecId,
-      nativeType: constructed.nativeType,
-      typeRef: enumDeclaration.name,
-    };
-    enumTypeDescriptors.set(enumDeclaration.name, descriptor);
-    storageTypes[enumDeclaration.name] = constructed;
+
+    if (handle === undefined || handle === null) continue;
+
+    const enumHandle = blindCast<EnumTypeHandle, 'enum factory returns EnumTypeHandle'>(handle);
+    enumHandles[decl.name] = enumHandle;
+    enumTypeDescriptors.set(decl.name, {
+      codecId: enumHandle.codecId,
+      nativeType: enumHandle.nativeType,
+    });
   }
 
-  return { storageTypes, enumTypeDescriptors };
+  return { enumHandles, enumTypeDescriptors };
 }
 
 interface ResolveNamedTypeDeclarationsInput {
@@ -451,10 +430,10 @@ function validateNamedTypeAttributes(input: {
 }
 
 function resolveNamedTypeDeclarations(input: ResolveNamedTypeDeclarationsInput): {
-  readonly storageTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry>;
+  readonly storageTypes: Record<string, StorageTypeInstance>;
   readonly namedTypeDescriptors: Map<string, ColumnDescriptor>;
 } {
-  const storageTypes: Record<string, StorageTypeInstance | PostgresEnumStorageEntry> = {};
+  const storageTypes: Record<string, StorageTypeInstance> = {};
   const namedTypeDescriptors = new Map<string, ColumnDescriptor>();
 
   for (const declaration of input.declarations) {
@@ -619,6 +598,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 enumHandles?: ReadonlyMap<string, EnumTypeHandle>;
 }
 
 interface BuildModelNodeResult {
@@ -650,6 +630,7 @@ function buildModelNodeFromPsl(input: BuildModelNodeInput): BuildModelNodeResult
     diagnostics,
     sourceId,
     scalarTypeDescriptors: input.scalarTypeDescriptors,
+    ...ifDefined('enumHandles', input.enumHandles),
   });
 
   const inlineIdFields = resolvedFields.filter((field) => field.isId);
@@ -1320,14 +1301,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.enumHandles?.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 } : {}),
@@ -1924,33 +1909,6 @@ export function interpretPslDocumentToSqlContract(
     }
   }
   const defaultNamespaceId = input.target.defaultNamespaceId;
-  // Top-level enums (the __unspecified__ bucket) route to `storageTypes`;
-  // enums inside a named namespace block route to `namespaceTypes[nsId]`.
-  const topLevelEnums = input.document.ast.namespaces
-    .filter((ns) => ns.name === UNSPECIFIED_PSL_NAMESPACE_NAME)
-    .flatMap((ns) => ns.enums);
-  const namedNamespaceEnumsByNsId = new Map<string, readonly PslEnum[]>();
-  for (const ns of input.document.ast.namespaces) {
-    if (ns.name === UNSPECIFIED_PSL_NAMESPACE_NAME || ns.enums.length === 0) {
-      continue;
-    }
-    const resolvedId = resolveNamespaceIdForSqlTarget({
-      bucketName: ns.name,
-      targetId: input.target.targetId,
-    });
-    if (resolvedId === undefined) {
-      continue;
-    }
-    // Read-then-merge so that any future change to the PSL parser (or to
-    // `resolveNamespaceIdForSqlTarget`) that produces two AST entries
-    // resolving to the same `resolvedId` would accumulate their enums
-    // rather than silently dropping the earlier set. Today the parser
-    // already merges duplicate `namespace <name> { … }` blocks into a
-    // single AST entry per name, so this loop sees one `ns` per
-    // resolvedId and the merge degrades to a plain set.
-    const existing = namedNamespaceEnumsByNsId.get(resolvedId) ?? [];
-    namedNamespaceEnumsByNsId.set(resolvedId, [...existing, ...ns.enums]);
-  }
 
   const compositeTypes = input.document.ast.namespaces.flatMap((ns) => ns.compositeTypes);
   const modelNames = new Set(models.map((model) => model.name));
@@ -1966,45 +1924,48 @@ export function interpretPslDocumentToSqlContract(
     generatorDescriptorById.set(descriptor.id, descriptor);
   }
 
-  const enumEntityDescriptor = getAuthoringEntity(input.authoringContributions, ['enum']);
-  const enumEntityContext = {
-    family: input.target.familyId,
-    target: input.target.targetId,
-  };
+  const topLevelEnums = input.document.ast.namespaces
+    .filter((ns) => ns.name === UNSPECIFIED_PSL_NAMESPACE_NAME)
+    .flatMap((ns) => namespacePslExtensionBlocks(ns).filter((b) => b.kind === 'enum'));
+  for (const ns of input.document.ast.namespaces) {
+    if (ns.name === UNSPECIFIED_PSL_NAMESPACE_NAME) continue;
+    const nsEnums = namespacePslExtensionBlocks(ns).filter((b) => b.kind === 'enum');
+    if (nsEnums.length === 0) continue;
+    for (const decl of nsEnums) {
+      diagnostics.push({
+        code: 'PSL_ENUM_NAMESPACE_NOT_SUPPORTED',
+        message: `enum "${decl.name}" inside namespace "${ns.name}" is not supported; declare enum at the top level`,
+        sourceId,
+        span: decl.span,
+      });
+    }
+  }
 
   const enumResult = processEnumDeclarations({
-    enums: topLevelEnums,
+    enumBlocks: topLevelEnums,
     sourceId,
-    enumEntityDescriptor,
-    entityContext: enumEntityContext,
+    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,
   });
 
-  // Process enums declared in named namespace blocks and collect them into
-  // `namespaceTypes` keyed by the resolved namespace id.
   const allEnumTypeDescriptors = new Map(enumResult.enumTypeDescriptors);
-  const namespaceEnumStorageTypes: Record<string, Record<string, PostgresEnumStorageEntry>> = {};
-  for (const [nsId, nsEnums] of namedNamespaceEnumsByNsId) {
-    const nsEnumResult = processEnumDeclarations({
-      enums: nsEnums,
-      sourceId,
-      enumEntityDescriptor,
-      entityContext: enumEntityContext,
-      diagnostics,
-    });
-    for (const [name, descriptor] of nsEnumResult.enumTypeDescriptors) {
-      allEnumTypeDescriptors.set(name, descriptor);
-    }
-    const nsEntries: Record<string, PostgresEnumStorageEntry> = {};
-    for (const [name, entry] of Object.entries(nsEnumResult.storageTypes)) {
-      if (isPostgresEnumStorageEntry(entry)) {
-        nsEntries[name] = entry;
-      }
-    }
-    if (Object.keys(nsEntries).length > 0) {
-      namespaceEnumStorageTypes[nsId] = nsEntries;
-    }
-  }
+
+  const validEnumHandles: Record<string, EnumTypeHandle> = { ...enumResult.enumHandles };
+
+  const enumHandlesByName = new Map(Object.entries(validEnumHandles));
 
   const namedTypeResult = resolveNamedTypeDeclarations({
     declarations: input.document.ast.types?.declarations ?? [],
@@ -2018,7 +1979,7 @@ export function interpretPslDocumentToSqlContract(
     diagnostics,
   });
 
-  const storageTypes = { ...enumResult.storageTypes, ...namedTypeResult.storageTypes };
+  const storageTypes = { ...namedTypeResult.storageTypes };
 
   const modelMappingsByCoordinate = buildModelMappings(
     modelEntries,
@@ -2068,6 +2029,7 @@ export function interpretPslDocumentToSqlContract(
       sourceId,
       diagnostics,
       modelNamespaceIds,
+      ...(enumHandlesByName.size > 0 ? { enumHandles: enumHandlesByName } : {}),
     });
     modelNodes.push(
       namespaceId !== undefined ? { ...result.modelNode, namespaceId } : result.modelNode,
@@ -2159,9 +2121,7 @@ export function interpretPslDocumentToSqlContract(
       ),
     ),
     ...(Object.keys(storageTypes).length > 0 ? { storageTypes } : {}),
-    ...(Object.keys(namespaceEnumStorageTypes).length > 0
-      ? { namespaceTypes: namespaceEnumStorageTypes }
-      : {}),
+    ...(Object.keys(validEnumHandles).length > 0 ? { enums: validEnumHandles } : {}),
     ...ifDefined('createNamespace', input.createNamespace),
     models: stiColumnModelNodes.map((model) => ({
       ...model,
@@ -2233,6 +2193,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-column-resolution.ts

@@ -550,7 +550,7 @@ export const NATIVE_TYPE_SPECS: Readonly<Record<string, NativeTypeSpec>> = {
     codecId: 'sql/char@1',
     nativeType: 'character',
   },
-  'db.Uuid': { args: 'noArgs', baseType: 'String', codecId: null, nativeType: 'uuid' },
+  'db.Uuid': { args: 'noArgs', baseType: 'String', codecId: 'pg/uuid@1', nativeType: 'uuid' },
   'db.SmallInt': { args: 'noArgs', baseType: 'Int', codecId: 'pg/int2@1', nativeType: 'int2' },
   'db.Real': { args: 'noArgs', baseType: 'Float', codecId: 'pg/float4@1', nativeType: 'float4' },
   'db.Numeric': {