@prisma-next/mongo-contract-psl 0.14.0-dev.6 → 0.14.0-dev.61

package/dist/exports/provider.d.mts

@@ -3,6 +3,11 @@ import { ContractConfig } from "@prisma-next/config/config-types";
 //#region src/provider.d.ts
 interface MongoContractOptions {
   readonly output?: string;
+  /** The target's default codec ids for an `enum` block that omits `@@type`. */
+  readonly enumInferenceCodecs?: {
+    readonly text: string;
+    readonly int: string;
+  };
 }
 declare function mongoContract(schemaPath: string, options?: MongoContractOptions): ContractConfig;
 //#endregion

package/dist/exports/provider.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"provider.d.mts","names":[],"sources":["../../src/provider.ts"],"mappings":";;;UAUiB,oBAAA;EAAA,SACN,MAAM;AAAA;AAAA,iBAgBD,aAAA,CAAc,UAAA,UAAoB,OAAA,GAAU,oBAAA,GAAuB,cAAc"}
+{"version":3,"file":"provider.d.mts","names":[],"sources":["../../src/provider.ts"],"mappings":";;;UAUiB,oBAAA;EAAA,SACN,MAAA;EADM;EAAA,SAGN,mBAAA;IAAA,SAAiC,IAAA;IAAA,SAAuB,GAAA;EAAA;AAAA;AAAA,iBAgBnD,aAAA,CAAc,UAAA,UAAoB,OAAA,GAAU,oBAAA,GAAuB,cAAc"}

package/dist/exports/provider.mjs

@@ -1,7 +1,7 @@
-import { t as interpretPslDocumentToMongoContract } from "../interpreter-DCiVHDlW.mjs";
+import { t as interpretPslDocumentToMongoContract } from "../interpreter-D0vfRJ7f.mjs";
 import { buildSymbolTable, rangeToPslSpan } from "@prisma-next/psl-parser";
-import { notOk, ok } from "@prisma-next/utils/result";
 import { ifDefined } from "@prisma-next/utils/defined";
+import { notOk, ok } from "@prisma-next/utils/result";
 import { readFile } from "node:fs/promises";
 import { parse } from "@prisma-next/psl-parser/syntax";
 //#region src/provider.ts
@@ -53,7 +53,9 @@ function mongoContract(schemaPath, options) {
 					sourceId: schemaPath,
 					seedDiagnostics: [...mapParseDiagnostics(parseDiagnostics, sourceFile, schemaPath), ...mapParseDiagnostics(symbolTableDiagnostics, sourceFile, schemaPath)],
 					scalarTypeDescriptors: context.scalarTypeDescriptors,
-					codecLookup: context.codecLookup
+					codecLookup: context.codecLookup,
+					authoringContributions: context.authoringContributions,
+					...ifDefined("enumInferenceCodecs", options?.enumInferenceCodecs)
 				});
 				if (!interpreted.ok) return interpreted;
 				return ok(interpreted.value);

package/dist/exports/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, ContractSourceDiagnostic } from '@prisma-next/config/config-types';\nimport { buildSymbolTable, rangeToPslSpan } from '@prisma-next/psl-parser';\nimport type { ParseDiagnostic, SourceFile } from '@prisma-next/psl-parser/syntax';\nimport { parse } from '@prisma-next/psl-parser/syntax';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport { notOk, ok } from '@prisma-next/utils/result';\n\nimport { interpretPslDocumentToMongoContract } from './interpreter';\n\nexport interface MongoContractOptions {\n  readonly output?: string;\n}\n\nfunction mapParseDiagnostics(\n  diagnostics: readonly ParseDiagnostic[],\n  sourceFile: SourceFile,\n  sourceId: string,\n): ContractSourceDiagnostic[] {\n  return diagnostics.map((diagnostic) => ({\n    code: diagnostic.code,\n    message: diagnostic.message,\n    sourceId,\n    span: rangeToPslSpan(diagnostic.range, sourceFile),\n  }));\n}\n\nexport function mongoContract(schemaPath: string, options?: MongoContractOptions): ContractConfig {\n  return {\n    source: {\n      sourceFormat: 'psl',\n      inputs: [schemaPath],\n      load: async (context) => {\n        const [absoluteSchemaPath] = context.resolvedInputs;\n        if (absoluteSchemaPath === undefined) {\n          throw new Error(\n            'mongoContract: 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, sourceFile, diagnostics: parseDiagnostics } = parse(schema);\n        const { table: symbolTable, diagnostics: symbolTableDiagnostics } = buildSymbolTable({\n          document,\n          sourceFile,\n          scalarTypes: [...context.scalarTypeDescriptors.keys()],\n          pslBlockDescriptors: context.authoringContributions.pslBlockDescriptors,\n        });\n\n        // Do not short-circuit on provider-level diagnostics; recovered CST can\n        // still produce interpreter diagnostics in the same response.\n        const seedDiagnostics = [\n          ...mapParseDiagnostics(parseDiagnostics, sourceFile, schemaPath),\n          ...mapParseDiagnostics(symbolTableDiagnostics, sourceFile, schemaPath),\n        ];\n\n        const interpreted = interpretPslDocumentToMongoContract({\n          symbolTable,\n          sourceFile,\n          sourceId: schemaPath,\n          seedDiagnostics,\n          scalarTypeDescriptors: context.scalarTypeDescriptors,\n          codecLookup: context.codecLookup,\n        });\n        if (!interpreted.ok) {\n          return interpreted;\n        }\n\n        return ok(interpreted.value);\n      },\n    },\n    ...ifDefined('output', options?.output),\n  };\n}\n"],"mappings":";;;;;;;AAcA,SAAS,oBACP,aACA,YACA,UAC4B;CAC5B,OAAO,YAAY,KAAK,gBAAgB;EACtC,MAAM,WAAW;EACjB,SAAS,WAAW;EACpB;EACA,MAAM,eAAe,WAAW,OAAO,UAAU;CACnD,EAAE;AACJ;AAEA,SAAgB,cAAc,YAAoB,SAAgD;CAChG,OAAO;EACL,QAAQ;GACN,cAAc;GACd,QAAQ,CAAC,UAAU;GACnB,MAAM,OAAO,YAAY;IACvB,MAAM,CAAC,sBAAsB,QAAQ;IACrC,IAAI,uBAAuB,KAAA,GACzB,MAAM,IAAI,MACR,iIACF;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,EAAE,UAAU,YAAY,aAAa,qBAAqB,MAAM,MAAM;IAC5E,MAAM,EAAE,OAAO,aAAa,aAAa,2BAA2B,iBAAiB;KACnF;KACA;KACA,aAAa,CAAC,GAAG,QAAQ,sBAAsB,KAAK,CAAC;KACrD,qBAAqB,QAAQ,uBAAuB;IACtD,CAAC;IASD,MAAM,cAAc,oCAAoC;KACtD;KACA;KACA,UAAU;KACV,iBAAA,CARA,GAAG,oBAAoB,kBAAkB,YAAY,UAAU,GAC/D,GAAG,oBAAoB,wBAAwB,YAAY,UAAU,CAOvD;KACd,uBAAuB,QAAQ;KAC/B,aAAa,QAAQ;IACvB,CAAC;IACD,IAAI,CAAC,YAAY,IACf,OAAO;IAGT,OAAO,GAAG,YAAY,KAAK;GAC7B;EACF;EACA,GAAG,UAAU,UAAU,SAAS,MAAM;CACxC;AACF"}
+{"version":3,"file":"provider.mjs","names":[],"sources":["../../src/provider.ts"],"sourcesContent":["import { readFile } from 'node:fs/promises';\nimport type { ContractConfig, ContractSourceDiagnostic } from '@prisma-next/config/config-types';\nimport { buildSymbolTable, rangeToPslSpan } from '@prisma-next/psl-parser';\nimport type { ParseDiagnostic, SourceFile } from '@prisma-next/psl-parser/syntax';\nimport { parse } from '@prisma-next/psl-parser/syntax';\nimport { ifDefined } from '@prisma-next/utils/defined';\nimport { notOk, ok } from '@prisma-next/utils/result';\n\nimport { interpretPslDocumentToMongoContract } from './interpreter';\n\nexport interface MongoContractOptions {\n  readonly output?: string;\n  /** The target's default codec ids for an `enum` block that omits `@@type`. */\n  readonly enumInferenceCodecs?: { readonly text: string; readonly int: string };\n}\n\nfunction mapParseDiagnostics(\n  diagnostics: readonly ParseDiagnostic[],\n  sourceFile: SourceFile,\n  sourceId: string,\n): ContractSourceDiagnostic[] {\n  return diagnostics.map((diagnostic) => ({\n    code: diagnostic.code,\n    message: diagnostic.message,\n    sourceId,\n    span: rangeToPslSpan(diagnostic.range, sourceFile),\n  }));\n}\n\nexport function mongoContract(schemaPath: string, options?: MongoContractOptions): ContractConfig {\n  return {\n    source: {\n      sourceFormat: 'psl',\n      inputs: [schemaPath],\n      load: async (context) => {\n        const [absoluteSchemaPath] = context.resolvedInputs;\n        if (absoluteSchemaPath === undefined) {\n          throw new Error(\n            'mongoContract: 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, sourceFile, diagnostics: parseDiagnostics } = parse(schema);\n        const { table: symbolTable, diagnostics: symbolTableDiagnostics } = buildSymbolTable({\n          document,\n          sourceFile,\n          scalarTypes: [...context.scalarTypeDescriptors.keys()],\n          pslBlockDescriptors: context.authoringContributions.pslBlockDescriptors,\n        });\n\n        // Do not short-circuit on provider-level diagnostics; recovered CST can\n        // still produce interpreter diagnostics in the same response.\n        const seedDiagnostics = [\n          ...mapParseDiagnostics(parseDiagnostics, sourceFile, schemaPath),\n          ...mapParseDiagnostics(symbolTableDiagnostics, sourceFile, schemaPath),\n        ];\n\n        const interpreted = interpretPslDocumentToMongoContract({\n          symbolTable,\n          sourceFile,\n          sourceId: schemaPath,\n          seedDiagnostics,\n          scalarTypeDescriptors: context.scalarTypeDescriptors,\n          codecLookup: context.codecLookup,\n          authoringContributions: context.authoringContributions,\n          ...ifDefined('enumInferenceCodecs', options?.enumInferenceCodecs),\n        });\n        if (!interpreted.ok) {\n          return interpreted;\n        }\n\n        return ok(interpreted.value);\n      },\n    },\n    ...ifDefined('output', options?.output),\n  };\n}\n"],"mappings":";;;;;;;AAgBA,SAAS,oBACP,aACA,YACA,UAC4B;CAC5B,OAAO,YAAY,KAAK,gBAAgB;EACtC,MAAM,WAAW;EACjB,SAAS,WAAW;EACpB;EACA,MAAM,eAAe,WAAW,OAAO,UAAU;CACnD,EAAE;AACJ;AAEA,SAAgB,cAAc,YAAoB,SAAgD;CAChG,OAAO;EACL,QAAQ;GACN,cAAc;GACd,QAAQ,CAAC,UAAU;GACnB,MAAM,OAAO,YAAY;IACvB,MAAM,CAAC,sBAAsB,QAAQ;IACrC,IAAI,uBAAuB,KAAA,GACzB,MAAM,IAAI,MACR,iIACF;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,EAAE,UAAU,YAAY,aAAa,qBAAqB,MAAM,MAAM;IAC5E,MAAM,EAAE,OAAO,aAAa,aAAa,2BAA2B,iBAAiB;KACnF;KACA;KACA,aAAa,CAAC,GAAG,QAAQ,sBAAsB,KAAK,CAAC;KACrD,qBAAqB,QAAQ,uBAAuB;IACtD,CAAC;IASD,MAAM,cAAc,oCAAoC;KACtD;KACA;KACA,UAAU;KACV,iBAAA,CARA,GAAG,oBAAoB,kBAAkB,YAAY,UAAU,GAC/D,GAAG,oBAAoB,wBAAwB,YAAY,UAAU,CAOvD;KACd,uBAAuB,QAAQ;KAC/B,aAAa,QAAQ;KACrB,wBAAwB,QAAQ;KAChC,GAAG,UAAU,uBAAuB,SAAS,mBAAmB;IAClE,CAAC;IACD,IAAI,CAAC,YAAY,IACf,OAAO;IAGT,OAAO,GAAG,YAAY,KAAK;GAC7B;EACF;EACA,GAAG,UAAU,UAAU,SAAS,MAAM;CACxC;AACF"}

package/dist/index.d.mts

@@ -1,10 +1,28 @@
-import { Contract } from "@prisma-next/contract/types";
+import { MongoValidator } from "@prisma-next/mongo-contract";
+import { Contract, ContractField, ContractValueObject, JsonValue } from "@prisma-next/contract/types";
+import { AuthoringContributions } from "@prisma-next/framework-components/authoring";
 import { SymbolTable } from "@prisma-next/psl-parser";
 import { Result } from "@prisma-next/utils/result";
 import { SourceFile } from "@prisma-next/psl-parser/syntax";
-import { ContractSourceDiagnostic, ContractSourceDiagnostics } from "@prisma-next/config/config-types";
 import { CodecLookup } from "@prisma-next/framework-components/codec";
+import { ContractSourceDiagnostic, ContractSourceDiagnostics } from "@prisma-next/config/config-types";
 
+//#region src/derive-json-schema.d.ts
+/**
+ * The permitted values a field's value set restricts it to, keyed by the value set's name — the
+ * storage `entries.valueSet` slot. The validator's `enum` keyword is sourced from these, not from
+ * `domain.enum`.
+ */
+type FieldValueSets = Record<string, {
+  readonly values: readonly JsonValue[];
+}>;
+declare function deriveJsonSchema(fields: Record<string, ContractField>, valueObjects?: Record<string, ContractValueObject>, codecLookup?: CodecLookup, valueSets?: FieldValueSets): MongoValidator;
+interface PolymorphicVariant {
+  readonly discriminatorValue: string;
+  readonly fields: Record<string, ContractField>;
+}
+declare function derivePolymorphicJsonSchema(baseFields: Record<string, ContractField>, discriminatorField: string, variants: readonly PolymorphicVariant[], valueObjects?: Record<string, ContractValueObject>, codecLookup?: CodecLookup, valueSets?: FieldValueSets): MongoValidator;
+//#endregion
 //#region src/interpreter.d.ts
 interface InterpretPslDocumentToMongoContractInput {
   readonly symbolTable: SymbolTable;
@@ -13,8 +31,14 @@ interface InterpretPslDocumentToMongoContractInput {
   readonly scalarTypeDescriptors: ReadonlyMap<string, string>;
   readonly codecLookup?: CodecLookup;
   readonly seedDiagnostics?: readonly ContractSourceDiagnostic[];
+  readonly authoringContributions?: AuthoringContributions;
+  /** The target's default codec ids for an `enum` block that omits `@@type`. */
+  readonly enumInferenceCodecs?: {
+    readonly text: string;
+    readonly int: string;
+  };
 }
 declare function interpretPslDocumentToMongoContract(input: InterpretPslDocumentToMongoContractInput): Result<Contract, ContractSourceDiagnostics>;
 //#endregion
-export { type InterpretPslDocumentToMongoContractInput, interpretPslDocumentToMongoContract };
+export { type FieldValueSets, type InterpretPslDocumentToMongoContractInput, deriveJsonSchema, derivePolymorphicJsonSchema, interpretPslDocumentToMongoContract };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/interpreter.ts"],"mappings":";;;;;;;;UAkDiB,wCAAA;EAAA,SACN,WAAA,EAAa,WAAA;EAAA,SACb,UAAA,EAAY,UAAA;EAAA,SACZ,QAAA;EAAA,SACA,qBAAA,EAAuB,WAAA;EAAA,SACvB,WAAA,GAAc,WAAA;EAAA,SACd,eAAA,YAA2B,wBAAA;AAAA;AAAA,iBAoxBtB,mCAAA,CACd,KAAA,EAAO,wCAAA,GACN,MAAA,CAAO,QAAA,EAAU,yBAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/derive-json-schema.ts","../src/interpreter.ts"],"mappings":";;;;;;;;;;;;;;;KASY,cAAA,GAAiB,MAAM;EAAA,SAAoB,MAAA,WAAiB,SAAA;AAAA;AAAA,iBA2FxD,gBAAA,CACd,MAAA,EAAQ,MAAA,SAAe,aAAA,GACvB,YAAA,GAAe,MAAA,SAAe,mBAAA,GAC9B,WAAA,GAAc,WAAA,EACd,SAAA,GAAY,cAAA,GACX,cAAA;AAAA,UAQc,kBAAA;EAAA,SACN,kBAAA;EAAA,SACA,MAAA,EAAQ,MAAM,SAAS,aAAA;AAAA;AAAA,iBAGlB,2BAAA,CACd,UAAA,EAAY,MAAA,SAAe,aAAA,GAC3B,kBAAA,UACA,QAAA,WAAmB,kBAAA,IACnB,YAAA,GAAe,MAAA,SAAe,mBAAA,GAC9B,WAAA,GAAc,WAAA,EACd,SAAA,GAAY,cAAA,GACX,cAAA;;;UC3Cc,wCAAA;EAAA,SACN,WAAA,EAAa,WAAA;EAAA,SACb,UAAA,EAAY,UAAA;EAAA,SACZ,QAAA;EAAA,SACA,qBAAA,EAAuB,WAAA;EAAA,SACvB,WAAA,GAAc,WAAA;EAAA,SACd,eAAA,YAA2B,wBAAA;EAAA,SAC3B,sBAAA,GAAyB,sBAAA;EDhFmB;EAAA,SCkF5C,mBAAA;IAAA,SAAiC,IAAA;IAAA,SAAuB,GAAA;EAAA;AAAA;AAAA,iBA41BnD,mCAAA,CACd,KAAA,EAAO,wCAAA,GACN,MAAA,CAAO,QAAA,EAAU,yBAAA"}

package/dist/index.mjs

@@ -1,2 +1,2 @@
-import { t as interpretPslDocumentToMongoContract } from "./interpreter-DCiVHDlW.mjs";
-export { interpretPslDocumentToMongoContract };
+import { n as deriveJsonSchema, r as derivePolymorphicJsonSchema, t as interpretPslDocumentToMongoContract } from "./interpreter-D0vfRJ7f.mjs";
+export { deriveJsonSchema, derivePolymorphicJsonSchema, interpretPslDocumentToMongoContract };

package/dist/{interpreter-DCiVHDlW.mjs → interpreter-D0vfRJ7f.mjs}

@@ -1,31 +1,45 @@
+import { MongoIndex, MongoStorage, MongoValidator, applyPolymorphicScopeToMongoIndex, buildMongoNamespace } from "@prisma-next/mongo-contract";
 import { computeProfileHash, computeStorageHash } from "@prisma-next/contract/hashing";
 import { crossRef } from "@prisma-next/contract/types";
+import { errorEnumCodecNotInPackStack } from "@prisma-next/errors/control";
+import { instantiateAuthoringEntityType, isAuthoringEntityTypeDescriptor } from "@prisma-next/framework-components/authoring";
 import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
-import { MongoIndex, MongoStorage, MongoValidator, applyPolymorphicScopeToMongoIndex, buildMongoNamespace } from "@prisma-next/mongo-contract";
 import { mongoContractCanonicalizationHooks } from "@prisma-next/mongo-contract/canonicalization-hooks";
 import { nodePslSpan, parseQuotedStringLiteral } from "@prisma-next/psl-parser";
+import { assertDefined } from "@prisma-next/utils/assertions";
 import { blindCast } from "@prisma-next/utils/casts";
-import { notOk, ok } from "@prisma-next/utils/result";
 import { ifDefined } from "@prisma-next/utils/defined";
+import { notOk, ok } from "@prisma-next/utils/result";
 //#region src/derive-json-schema.ts
 function resolveBsonType(codecId, codecLookup) {
 	return codecLookup?.targetTypesFor(codecId)?.[0];
 }
-function fieldToBsonSchema(field, valueObjects, codecLookup) {
+function fieldToBsonSchema(field, valueObjects, codecLookup, valueSets) {
 	if (field.type.kind === "scalar") {
 		const bsonType = resolveBsonType(field.type.codecId, codecLookup);
 		if (!bsonType) return void 0;
-		if ("many" in field && field.many) return {
-			bsonType: "array",
-			items: { bsonType }
-		};
-		if (field.nullable) return { bsonType: ["null", bsonType] };
-		return { bsonType };
+		const enumValues = field.valueSet !== void 0 ? valueSets?.[field.valueSet.entityName]?.values ?? null : null;
+		if ("many" in field && field.many) {
+			const items = { bsonType };
+			if (enumValues) items["enum"] = enumValues;
+			return {
+				bsonType: "array",
+				items
+			};
+		}
+		if (field.nullable) {
+			const s = { bsonType: ["null", bsonType] };
+			if (enumValues) s["enum"] = [...enumValues, null];
+			return s;
+		}
+		const s = { bsonType };
+		if (enumValues) s["enum"] = enumValues;
+		return s;
 	}
 	if (field.type.kind === "valueObject") {
 		const vo = valueObjects?.[field.type.name];
 		if (!vo) return void 0;
-		const voSchema = deriveObjectSchema(vo.fields, valueObjects, codecLookup);
+		const voSchema = deriveObjectSchema(vo.fields, valueObjects, codecLookup, valueSets);
 		if ("many" in field && field.many) return {
 			bsonType: "array",
 			items: voSchema
@@ -34,11 +48,11 @@ function fieldToBsonSchema(field, valueObjects, codecLookup) {
 		return voSchema;
 	}
 }
-function deriveObjectSchema(fields, valueObjects, codecLookup) {
+function deriveObjectSchema(fields, valueObjects, codecLookup, valueSets) {
 	const properties = {};
 	const required = [];
 	for (const [fieldName, field] of Object.entries(fields)) {
-		const schema = fieldToBsonSchema(field, valueObjects, codecLookup);
+		const schema = fieldToBsonSchema(field, valueObjects, codecLookup, valueSets);
 		if (schema) {
 			properties[fieldName] = schema;
 			if (!field.nullable) required.push(fieldName);
@@ -55,15 +69,15 @@ function deriveObjectSchema(fields, valueObjects, codecLookup) {
 function isRecord(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function deriveJsonSchema(fields, valueObjects, codecLookup) {
+function deriveJsonSchema(fields, valueObjects, codecLookup, valueSets) {
 	return new MongoValidator({
-		jsonSchema: deriveObjectSchema(fields, valueObjects, codecLookup),
+		jsonSchema: deriveObjectSchema(fields, valueObjects, codecLookup, valueSets),
 		validationLevel: "strict",
 		validationAction: "error"
 	});
 }
-function derivePolymorphicJsonSchema(baseFields, discriminatorField, variants, valueObjects, codecLookup) {
-	const baseSchema = deriveObjectSchema(baseFields, valueObjects, codecLookup);
+function derivePolymorphicJsonSchema(baseFields, discriminatorField, variants, valueObjects, codecLookup, valueSets) {
+	const baseSchema = deriveObjectSchema(baseFields, valueObjects, codecLookup, valueSets);
 	const baseProperties = isRecord(baseSchema["properties"]) ? baseSchema["properties"] : {};
 	const oneOf = [];
 	for (const variant of variants) {
@@ -72,7 +86,7 @@ function derivePolymorphicJsonSchema(baseFields, discriminatorField, variants, v
 		const variantProperties = {};
 		const variantRequired = [discriminatorField];
 		for (const [name, field] of Object.entries(variantOnlyFields)) {
-			const schema = fieldToBsonSchema(field, valueObjects, codecLookup);
+			const schema = fieldToBsonSchema(field, valueObjects, codecLookup, valueSets);
 			if (schema) {
 				variantProperties[name] = schema;
 				if (!field.nullable) variantRequired.push(name);
@@ -189,6 +203,18 @@ function stripQuotes(value) {
 //#endregion
 //#region src/interpreter.ts
 /**
+* Encode an authored enum value to its codec-encoded JSON form via the codec resolved by id from the
+* contract's codec lookup, so a non-identity `encodeJson` (permitted by the `mongoCodec` factory) is
+* respected. Matches the TS builder's `encodeEnumValue`: the lookup is always threaded in production,
+* and a codecId the lookup cannot resolve is a hard error — the enum uses a codec that is not part of
+* the contract's pack stack.
+*/
+function encodeEnumValue(value, codecId, codecLookup) {
+	const codec = codecLookup.get(codecId);
+	if (!codec) throw errorEnumCodecNotInPackStack({ codecId });
+	return codec.encodeJson(value);
+}
+/**
 * Mongo's PSL surface binds the database from the connection string, so every
 * explicit namespace block is invalid, including `namespace unbound { … }`.
 */
@@ -717,7 +743,7 @@ const MONGO_OBJECT_ID_PSL_TYPE = "ObjectId";
 function resolveFieldCodecId(field, scalarTypeDescriptors) {
 	return scalarTypeDescriptors.get(field.typeName);
 }
-function resolveNonRelationField(field, ownerName, compositeTypeNames, scalarTypeDescriptors, sourceId, diagnostics) {
+function resolveNonRelationField(field, ownerName, compositeTypeNames, scalarTypeDescriptors, codecIdByEnumName, sourceId, diagnostics) {
 	if (compositeTypeNames.has(field.typeName)) {
 		const result = {
 			type: {
@@ -731,6 +757,27 @@ function resolveNonRelationField(field, ownerName, compositeTypeNames, scalarTyp
 			many: true
 		} : result;
 	}
+	const enumCodecId = codecIdByEnumName.get(field.typeName);
+	if (enumCodecId !== void 0) {
+		const valueSet = {
+			plane: "domain",
+			entityKind: "enum",
+			namespaceId: UNBOUND_NAMESPACE_ID,
+			entityName: field.typeName
+		};
+		const result = {
+			type: {
+				kind: "scalar",
+				codecId: enumCodecId
+			},
+			nullable: field.optional,
+			valueSet
+		};
+		return field.list ? {
+			...result,
+			many: true
+		} : result;
+	}
 	if (field.malformedType) return;
 	const codecId = resolveFieldCodecId(field, scalarTypeDescriptors);
 	if (!codecId) {
@@ -754,6 +801,32 @@ function resolveNonRelationField(field, ownerName, compositeTypeNames, scalarTyp
 		many: true
 	} : result;
 }
+function processEnumDeclarations(input) {
+	const builtEnums = {};
+	if (input.enumBlocks.length === 0) return builtEnums;
+	const enumDescriptor = input.authoringContributions?.entityTypes?.["enum"] !== void 0 && isAuthoringEntityTypeDescriptor(input.authoringContributions.entityTypes["enum"]) ? input.authoringContributions.entityTypes["enum"] : void 0;
+	if (!enumDescriptor) {
+		for (const decl of input.enumBlocks) input.diagnostics.push({
+			code: "PSL_ENUM_MISSING_FACTORY",
+			message: `enum "${decl.name}" requires an "enum" entityType factory in the active authoring contributions`,
+			sourceId: input.sourceId,
+			span: decl.span
+		});
+		return builtEnums;
+	}
+	for (const decl of input.enumBlocks) {
+		const handle = instantiateAuthoringEntityType("enum", enumDescriptor, [decl], input.entityContext);
+		if (handle === void 0 || handle === null) continue;
+		builtEnums[decl.name] = {
+			codecId: handle.codecId,
+			members: handle.enumMembers.map((m) => ({
+				name: m.name,
+				value: blindCast(m.value)
+			}))
+		};
+	}
+	return builtEnums;
+}
 function interpretPslDocumentToMongoContract(input) {
 	const { symbolTable, sourceFile, scalarTypeDescriptors, codecLookup } = input;
 	const sourceId = input.sourceId;
@@ -769,6 +842,23 @@ function interpretPslDocumentToMongoContract(input) {
 	const allCompositeTypes = Object.values(topLevel.compositeTypes);
 	const modelNames = new Set(allModels.map((m) => m.name));
 	const compositeTypeNames = new Set(allCompositeTypes.map((ct) => ct.name));
+	const builtEnums = processEnumDeclarations({
+		enumBlocks: Object.values(topLevel.blocks).filter((b) => b.keyword === "enum").map((b) => b.block),
+		sourceId,
+		authoringContributions: input.authoringContributions,
+		entityContext: {
+			family: "mongo",
+			target: "mongo",
+			...ifDefined("enumInferenceCodecs", input.enumInferenceCodecs),
+			...ifDefined("codecLookup", codecLookup),
+			sourceId,
+			diagnostics: { push: (d) => {
+				diagnostics.push(blindCast(d));
+			} }
+		},
+		diagnostics
+	});
+	const codecIdByEnumName = new Map(Object.entries(builtEnums).map(([name, e]) => [name, e.codecId]));
 	const models = {};
 	const collections = {};
 	const roots = {};
@@ -789,7 +879,7 @@ function interpretPslDocumentToMongoContract(input) {
 						modelName: pslModel.name,
 						fieldName: field.name,
 						targetModelName: field.typeName,
-						...relation?.relationName !== void 0 ? { relationName: relation.relationName } : {},
+						...ifDefined("relationName", relation?.relationName),
 						cardinality: field.list ? "1:N" : "1:1",
 						field
 					});
@@ -812,14 +902,14 @@ function interpretPslDocumentToMongoContract(input) {
 						declaringModel: pslModel.name,
 						fieldName: field.name,
 						targetModel: field.typeName,
-						...relation.relationName !== void 0 ? { relationName: relation.relationName } : {},
+						...ifDefined("relationName", relation.relationName),
 						localFields: localMapped,
 						targetFields: targetMapped
 					});
 				}
 				continue;
 			}
-			const resolved = resolveNonRelationField(field, pslModel.name, compositeTypeNames, scalarTypeDescriptors, sourceId, diagnostics);
+			const resolved = resolveNonRelationField(field, pslModel.name, compositeTypeNames, scalarTypeDescriptors, codecIdByEnumName, sourceId, diagnostics);
 			if (!resolved) continue;
 			const mappedName = fieldMappings.pslNameToMapped.get(field.name) ?? field.name;
 			fields[mappedName] = resolved;
@@ -856,7 +946,7 @@ function interpretPslDocumentToMongoContract(input) {
 	for (const compositeType of allCompositeTypes) {
 		const fields = {};
 		for (const field of Object.values(compositeType.fields)) {
-			const resolved = resolveNonRelationField(field, compositeType.name, compositeTypeNames, scalarTypeDescriptors, sourceId, diagnostics);
+			const resolved = resolveNonRelationField(field, compositeType.name, compositeTypeNames, scalarTypeDescriptors, codecIdByEnumName, sourceId, diagnostics);
 			if (!resolved) continue;
 			fields[field.name] = resolved;
 		}
@@ -923,6 +1013,15 @@ function interpretPslDocumentToMongoContract(input) {
 	});
 	const resolvedModels = polyResult.models;
 	const resolvedCollections = polyResult.collections;
+	const storageValueSets = {};
+	const enumEntries = Object.entries(builtEnums);
+	if (enumEntries.length > 0) {
+		assertDefined(codecLookup, "Mongo PSL interpretation requires a codec lookup to encode enum values");
+		for (const [enumName, builtEnum] of enumEntries) storageValueSets[enumName] = {
+			kind: "valueSet",
+			values: builtEnum.members.map((m) => encodeEnumValue(m.value, builtEnum.codecId, codecLookup))
+		};
+	}
 	for (const [, modelEntry] of Object.entries(resolvedModels)) {
 		if (modelEntry.base) continue;
 		const coll = resolvedCollections[modelEntry.storage.collection];
@@ -932,8 +1031,8 @@ function interpretPslDocumentToMongoContract(input) {
 				discriminatorValue: value,
 				fields: resolvedModels[variantName]?.fields ?? {}
 			}));
-			coll["validator"] = derivePolymorphicJsonSchema(modelEntry.fields, modelEntry.discriminator.field, variantEntries, valueObjects, codecLookup);
-		} else coll["validator"] = deriveJsonSchema(modelEntry.fields, valueObjects, codecLookup);
+			coll["validator"] = derivePolymorphicJsonSchema(modelEntry.fields, modelEntry.discriminator.field, variantEntries, valueObjects, codecLookup, storageValueSets);
+		} else coll["validator"] = deriveJsonSchema(modelEntry.fields, valueObjects, codecLookup, storageValueSets);
 	}
 	const target = "mongo";
 	const targetFamily = "mongo";
@@ -947,7 +1046,10 @@ function interpretPslDocumentToMongoContract(input) {
 	}
 	const unboundNamespace = buildMongoNamespace({
 		id: UNBOUND_NAMESPACE_ID,
-		entries: { collection: collectionInputs }
+		entries: {
+			collection: collectionInputs,
+			...Object.keys(storageValueSets).length > 0 ? { valueSet: storageValueSets } : {}
+		}
 	});
 	const storage = new MongoStorage({
 		storageHash: computeStorageHash({
@@ -955,20 +1057,25 @@ function interpretPslDocumentToMongoContract(input) {
 			targetFamily,
 			storage: { namespaces: { [UNBOUND_NAMESPACE_ID]: {
 				id: UNBOUND_NAMESPACE_ID,
-				entries: { collection: unboundNamespace.entries.collection }
+				entries: {
+					collection: unboundNamespace.entries.collection,
+					...unboundNamespace.entries.valueSet !== void 0 ? { valueSet: unboundNamespace.entries.valueSet } : {}
+				}
 			} } },
 			...mongoContractCanonicalizationHooks
 		}),
 		namespaces: { [UNBOUND_NAMESPACE_ID]: unboundNamespace }
 	});
 	const capabilities = {};
+	const hasEnums = Object.keys(builtEnums).length > 0;
 	return ok({
 		targetFamily,
 		target,
 		roots: polyResult.roots,
 		domain: { namespaces: { [UNBOUND_NAMESPACE_ID]: {
 			models: polyResult.models,
-			...Object.keys(valueObjects).length > 0 ? { valueObjects } : {}
+			...Object.keys(valueObjects).length > 0 ? { valueObjects } : {},
+			...hasEnums ? { enum: builtEnums } : {}
 		} } },
 		storage,
 		extensionPacks: {},
@@ -982,6 +1089,6 @@ function interpretPslDocumentToMongoContract(input) {
 	});
 }
 //#endregion
-export { interpretPslDocumentToMongoContract as t };
+export { deriveJsonSchema as n, derivePolymorphicJsonSchema as r, interpretPslDocumentToMongoContract as t };
 
-//# sourceMappingURL=interpreter-DCiVHDlW.mjs.map
+//# sourceMappingURL=interpreter-D0vfRJ7f.mjs.map