@prisma-next/mongo-contract-psl 0.14.0-dev.4 → 0.14.0-dev.40

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

@@ -1,30 +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 { ifDefined } from "@prisma-next/utils/defined";
 import { notOk, ok } from "@prisma-next/utils/result";
-import { getPositionalArgument, parseQuotedStringLiteral } from "@prisma-next/psl-parser";
 //#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
@@ -33,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);
@@ -54,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) {
@@ -71,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);
@@ -99,6 +114,9 @@ function derivePolymorphicJsonSchema(baseFields, discriminatorField, variants, v
 }
 //#endregion
 //#region src/psl-helpers.ts
+function getPositionalArgument(attr, index = 0) {
+	return attr.args.filter((arg) => arg.kind === "positional")[index]?.value;
+}
 function getNamedArgument(attr, name) {
 	return attr.args.find((a) => a.kind === "named" && a.name === name)?.value;
 }
@@ -173,9 +191,9 @@ function parseRelationAttribute(attributes) {
 	const fields = fieldsArg ? parseFieldList(fieldsArg.value) : void 0;
 	const references = referencesArg ? parseFieldList(referencesArg.value) : void 0;
 	return {
-		...relationName !== void 0 ? { relationName } : {},
-		...fields !== void 0 ? { fields } : {},
-		...references !== void 0 ? { references } : {}
+		...ifDefined("relationName", relationName),
+		...ifDefined("fields", fields),
+		...ifDefined("references", references)
 	};
 }
 function stripQuotes(value) {
@@ -185,37 +203,35 @@ function stripQuotes(value) {
 //#endregion
 //#region src/interpreter.ts
 /**
-* Name of the framework-parser synthesised bucket for top-level
-* declarations. Re-declared locally so the interpreter does not have to
-* import from `@prisma-next/framework-components/psl-ast`.
+* 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.
 */
-const UNSPECIFIED_PSL_NAMESPACE_NAME = "__unspecified__";
+function encodeEnumValue(value, codecId, codecLookup) {
+	const codec = codecLookup.get(codecId);
+	if (!codec) throw errorEnumCodecNotInPackStack({ codecId });
+	return codec.encodeJson(value);
+}
 /**
-* Mongo FR16c validation: Mongo's authoring DSL exposes the connection's
-* database as the only namespace surface today, so the PSL interpreter
-* rejects every explicit `namespace { … }` block. The implicit
-* `__unspecified__` bucket (top-level declarations) is the only
-* namespace Mongo accepts. `namespace unbound { … }` is rejected too —
-* Mongo has no late-binding namespace concept on the PSL surface (the
-* database name comes from the connection string, not from PSL).
+* Mongo's PSL surface binds the database from the connection string, so every
+* explicit namespace block is invalid, including `namespace unbound { … }`.
 */
 function validateNamespaceBlocksForMongoTarget(input) {
-	for (const namespace of input.namespaces) {
-		if (namespace.name === UNSPECIFIED_PSL_NAMESPACE_NAME) continue;
-		input.diagnostics.push({
-			code: "PSL_UNSUPPORTED_NAMESPACE_BLOCK",
-			message: `Mongo does not support \`namespace ${namespace.name} { … }\` blocks (the database is bound by the connection string; declare models at the document top level instead).`,
-			sourceId: input.sourceId,
-			span: namespace.span
-		});
-	}
+	for (const namespace of input.namespaces) input.diagnostics.push({
+		code: "PSL_UNSUPPORTED_NAMESPACE_BLOCK",
+		message: `Mongo does not support \`namespace ${namespace.name} { … }\` blocks (the database is bound by the connection string; declare models at the document top level instead).`,
+		sourceId: input.sourceId,
+		span: nodePslSpan(namespace.node.syntax, input.sourceFile)
+	});
 }
 function fkRelationPairKey(declaringModel, targetModel) {
 	return `${declaringModel}::${targetModel}`;
 }
 function resolveFieldMappings(model) {
 	const pslNameToMapped = /* @__PURE__ */ new Map();
-	for (const field of model.fields) {
+	for (const field of Object.values(model.fields)) {
 		const mapped = getMapName(field.attributes) ?? field.name;
 		pslNameToMapped.set(field.name, mapped);
 	}
@@ -227,33 +243,32 @@ function resolveCollectionName(model) {
 function mongoCrossRef(modelName) {
 	return crossRef(modelName, UNBOUND_NAMESPACE_ID);
 }
-function collectPolymorphismDeclarations(document, sourceId, diagnostics) {
+function collectPolymorphismDeclarations(models, sourceId, diagnostics) {
 	const discriminatorDeclarations = /* @__PURE__ */ new Map();
 	const baseDeclarations = /* @__PURE__ */ new Map();
-	const allPslModels = document.ast.namespaces.flatMap((ns) => ns.models);
-	for (const pslModel of allPslModels) for (const attr of pslModel.attributes) {
+	for (const model of models) for (const attr of model.attributes) {
 		if (attr.name === "discriminator") {
 			const fieldName = getPositionalArgument(attr);
 			if (!fieldName) {
 				diagnostics.push({
 					code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
-					message: `Model "${pslModel.name}" @@discriminator requires a field name argument`,
+					message: `Model "${model.name}" @@discriminator requires a field name argument`,
 					sourceId,
 					span: attr.span
 				});
 				continue;
 			}
-			const discField = pslModel.fields.find((f) => f.name === fieldName);
+			const discField = model.fields[fieldName];
 			if (discField && discField.typeName !== "String") {
 				diagnostics.push({
 					code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
-					message: `Discriminator field "${fieldName}" on model "${pslModel.name}" must be of type String, but is "${discField.typeName}"`,
+					message: `Discriminator field "${fieldName}" on model "${model.name}" must be of type String, but is "${discField.typeName}"`,
 					sourceId,
 					span: attr.span
 				});
 				continue;
 			}
-			discriminatorDeclarations.set(pslModel.name, {
+			discriminatorDeclarations.set(model.name, {
 				fieldName,
 				span: attr.span
 			});
@@ -264,7 +279,7 @@ function collectPolymorphismDeclarations(document, sourceId, diagnostics) {
 			if (!baseName || !rawValue) {
 				diagnostics.push({
 					code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
-					message: `Model "${pslModel.name}" @@base requires two arguments: base model name and discriminator value`,
+					message: `Model "${model.name}" @@base requires two arguments: base model name and discriminator value`,
 					sourceId,
 					span: attr.span
 				});
@@ -274,14 +289,14 @@ function collectPolymorphismDeclarations(document, sourceId, diagnostics) {
 			if (value === void 0) {
 				diagnostics.push({
 					code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
-					message: `Model "${pslModel.name}" @@base discriminator value must be a quoted string literal`,
+					message: `Model "${model.name}" @@base discriminator value must be a quoted string literal`,
 					sourceId,
 					span: attr.span
 				});
 				continue;
 			}
-			const collectionName = resolveCollectionName(pslModel);
-			baseDeclarations.set(pslModel.name, {
+			const collectionName = resolveCollectionName(model);
+			baseDeclarations.set(model.name, {
 				baseName,
 				value,
 				collectionName,
@@ -295,8 +310,7 @@ function collectPolymorphismDeclarations(document, sourceId, diagnostics) {
 	};
 }
 function resolvePolymorphism(input) {
-	const { discriminatorDeclarations, baseDeclarations, modelNames, sourceId, document, indexSpans, modelIndexesByName } = input;
-	const allPslModels = document.ast.namespaces.flatMap((ns) => ns.models);
+	const { discriminatorDeclarations, baseDeclarations, modelNames, sourceId, allModels: allModelViews, indexSpans, modelIndexesByName } = input;
 	let patched = input.models;
 	let roots = input.roots;
 	let collections = input.collections;
@@ -313,8 +327,8 @@ function resolvePolymorphism(input) {
 		}
 		const model = patched[modelName];
 		if (!model) continue;
-		const pslModel = allPslModels.find((m) => m.name === modelName);
-		const mappedDiscriminatorField = pslModel ? resolveFieldMappings(pslModel).pslNameToMapped.get(decl.fieldName) ?? decl.fieldName : decl.fieldName;
+		const modelView = allModelViews.find((m) => m.name === modelName);
+		const mappedDiscriminatorField = modelView ? resolveFieldMappings(modelView).pslNameToMapped.get(decl.fieldName) ?? decl.fieldName : decl.fieldName;
 		if (!Object.hasOwn(model.fields, mappedDiscriminatorField)) {
 			diagnostics.push({
 				code: "PSL_DISCRIMINATOR_FIELD_NOT_FOUND",
@@ -368,9 +382,9 @@ function resolvePolymorphism(input) {
 		}
 		if (discriminatorDeclarations.has(variantName)) continue;
 		const baseModel = patched[baseDecl.baseName];
-		const variantPslModel = allPslModels.find((m) => m.name === variantName);
-		if (!variantPslModel) continue;
-		if (getMapName(variantPslModel.attributes) !== void 0 && baseModel && baseDecl.collectionName !== baseModel.storage.collection) {
+		const variantModelView = allModelViews.find((m) => m.name === variantName);
+		if (!variantModelView) continue;
+		if (getMapName(variantModelView.attributes) !== void 0 && baseModel && baseDecl.collectionName !== baseModel.storage.collection) {
 			diagnostics.push({
 				code: "PSL_MONGO_VARIANT_SEPARATE_COLLECTION",
 				message: `Mongo variant "${variantName}" cannot use a different collection than its base "${baseDecl.baseName}". Mongo only supports single-collection polymorphism.`,
@@ -389,7 +403,7 @@ function resolvePolymorphism(input) {
 				storage: { collection: baseCollection }
 			}
 		};
-		const variantCollectionName = resolveCollectionName(variantPslModel);
+		const variantCollectionName = resolveCollectionName(variantModelView);
 		if (roots[variantCollectionName]?.model === variantName) if (variantCollectionName === baseCollection && baseModel) roots = {
 			...roots,
 			[variantCollectionName]: mongoCrossRef(baseDecl.baseName)
@@ -531,11 +545,11 @@ function collectIndexes(pslModel, fieldMappings, modelNames, sourceId, diagnosti
 	const indexes = [];
 	let textIndexCount = 0;
 	const indexableFieldNames = /* @__PURE__ */ new Set();
-	for (const f of pslModel.fields) {
+	for (const f of Object.values(pslModel.fields)) {
 		if (modelNames.has(f.typeName)) continue;
 		indexableFieldNames.add(f.name);
 	}
-	for (const field of pslModel.fields) {
+	for (const field of Object.values(pslModel.fields)) {
 		if (modelNames.has(field.typeName)) continue;
 		const uniqueAttr = getAttribute(field.attributes, "unique");
 		if (!uniqueAttr) continue;
@@ -729,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: {
@@ -743,6 +757,28 @@ 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) {
 		diagnostics.push({
@@ -765,19 +801,64 @@ 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 { document, scalarTypeDescriptors, codecLookup } = input;
-	const sourceId = document.ast.sourceId;
-	const diagnostics = [];
+	const { symbolTable, sourceFile, scalarTypeDescriptors, codecLookup } = input;
+	const sourceId = input.sourceId;
+	const diagnostics = [...input.seedDiagnostics ?? []];
+	const topLevel = symbolTable.topLevel;
 	validateNamespaceBlocksForMongoTarget({
-		namespaces: document.ast.namespaces,
+		namespaces: Object.values(topLevel.namespaces),
 		sourceId,
+		sourceFile,
 		diagnostics
 	});
-	const allModels = document.ast.namespaces.flatMap((ns) => ns.models);
-	const allCompositeTypes = document.ast.namespaces.flatMap((ns) => ns.compositeTypes);
+	const allModels = Object.values(topLevel.models);
+	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 = {};
@@ -790,7 +871,7 @@ function interpretPslDocumentToMongoContract(input) {
 		const fieldMappings = resolveFieldMappings(pslModel);
 		const fields = {};
 		const relations = {};
-		for (const field of pslModel.fields) {
+		for (const field of Object.values(pslModel.fields)) {
 			if (isRelationField(field, modelNames)) {
 				const relation = parseRelationAttribute(field.attributes);
 				if (field.list || !(relation?.fields && relation?.references)) {
@@ -798,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
 					});
@@ -821,20 +902,20 @@ 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;
 		}
 		const isVariantModel = pslModel.attributes.some((attr) => attr.name === "base");
-		const hasIdField = pslModel.fields.some((f) => getAttribute(f.attributes, "id") !== void 0);
+		const hasIdField = Object.values(pslModel.fields).some((f) => getAttribute(f.attributes, "id") !== void 0);
 		if (!isVariantModel) if (!hasIdField) diagnostics.push({
 			code: "PSL_MISSING_ID_FIELD",
 			message: `Model "${pslModel.name}" has no field with @id attribute. Every model must have exactly one @id field.`,
@@ -864,8 +945,8 @@ function interpretPslDocumentToMongoContract(input) {
 	const valueObjects = {};
 	for (const compositeType of allCompositeTypes) {
 		const fields = {};
-		for (const field of compositeType.fields) {
-			const resolved = resolveNonRelationField(field, compositeType.name, compositeTypeNames, scalarTypeDescriptors, sourceId, diagnostics);
+		for (const field of Object.values(compositeType.fields)) {
+			const resolved = resolveNonRelationField(field, compositeType.name, compositeTypeNames, scalarTypeDescriptors, codecIdByEnumName, sourceId, diagnostics);
 			if (!resolved) continue;
 			fields[field.name] = resolved;
 		}
@@ -913,12 +994,12 @@ function interpretPslDocumentToMongoContract(input) {
 			}
 		};
 	}
-	const { discriminatorDeclarations, baseDeclarations } = collectPolymorphismDeclarations(document, sourceId, diagnostics);
+	const { discriminatorDeclarations, baseDeclarations } = collectPolymorphismDeclarations(allModels, sourceId, diagnostics);
 	const polyResult = resolvePolymorphism({
 		models,
 		roots,
 		collections,
-		document,
+		allModels,
 		discriminatorDeclarations,
 		baseDeclarations,
 		modelNames,
@@ -932,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];
@@ -941,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";
@@ -956,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({
@@ -964,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: {},
@@ -991,6 +1089,6 @@ function interpretPslDocumentToMongoContract(input) {
 	});
 }
 //#endregion
-export { interpretPslDocumentToMongoContract as t };
+export { deriveJsonSchema as n, derivePolymorphicJsonSchema as r, interpretPslDocumentToMongoContract as t };
 
-//# sourceMappingURL=interpreter-Cj1vigKn.mjs.map
+//# sourceMappingURL=interpreter-D0vfRJ7f.mjs.map