@prisma/orm-family-mongo 8.0.0-rc.20-dev.3 → 8.0.0-rc.20-dev.4

package/dist/contract-builder-d5cf-u9p.mjs

@@ -0,0 +1,1832 @@
+import { i as MongoCollectionOptions, o as MongoIndex } from "./entity-kinds-BQBtfVet-B-Px7NHp.mjs";
+import { n as codecTypeParamsProblem } from "./mongo-data-type-Bv8Bd0zu-cnTiyyP0.mjs";
+import { M as unsupportedStoredNameReason, S as mongoContractRefusalsOf, g as deriveCollectionValidators, s as applyPolymorphicScopeToMongoIndex, u as buildMongoStorage, w as mongoValueSetsOf } from "./dist-DgMGRQkm.mjs";
+import { t as contractError } from "./contract-errors-BCN6RVI5-kMurtAbI.mjs";
+import { structuredError } from "@prisma/orm-framework/utils/structured-error";
+import { blindCast } from "@prisma/orm-framework/utils/casts";
+import { crossRef } from "@prisma/orm-framework/contract/types";
+import { buildExecutionSection, computeProfileHash } from "@prisma/orm-framework/contract/hashing";
+import { assertDefined } from "@prisma/orm-framework/utils/assertions";
+import { notOk, ok } from "@prisma/orm-framework/utils/result";
+import { bindEnumType, composePackAuthoringNamespace, createEntityHelpersFromNamespace, createFieldHelpersFromNamespace, enumMemberError, enumType as enumType$1, isEnumTypeHandle, member, resolveToOneRelationNullable } from "@prisma/orm-framework/contract-authoring";
+import { applyDiscriminatorRule, assembleDataTypeSupport, assertNoCrossRegistryCollisions, assertTypeAliasesValid, encodeEnumMembers, flushAuthoringWarnings, instantiateAuthoringFieldPreset, validateAuthoringHelperArguments } from "@prisma/orm-framework/components/authoring";
+import { assembleGeneratorFunctions, createGeneratorHelpers } from "@prisma/orm-framework/components/components";
+import { ifDefined } from "@prisma/orm-framework/utils/defined";
+import { canonicalStringify } from "@prisma/orm-framework/utils/canonical-stringify";
+import { extractCodecLookup } from "@prisma/orm-framework/components/control";
+//#region ../../../2-mongo-family/2-authoring/contract-ts/dist/contract-builder.mjs
+function modelFieldKey(model, field) {
+	return {
+		kind: "field",
+		owner: {
+			kind: "model",
+			name: model
+		},
+		field
+	};
+}
+function valueObjectFieldKey(valueObject, field) {
+	return {
+		kind: "field",
+		owner: {
+			kind: "valueObject",
+			name: valueObject
+		},
+		field
+	};
+}
+/** The key of a validator refusal: the part of the definition its subject names. */
+function validatorRefusalKey(refusal) {
+	switch (refusal.kind) {
+		case "embeddedModelHasVariants": return {
+			kind: "relation",
+			model: refusal.modelName,
+			relation: refusal.relationName
+		};
+		case "enumBsonType":
+		case "enumNotListable": return {
+			kind: "enum",
+			enumName: refusal.enumName
+		};
+		case "enumMemberNotListable": return {
+			kind: "enumMember",
+			enumName: refusal.enumName,
+			member: refusal.member
+		};
+		case "fieldBsonType": return {
+			kind: "field",
+			owner: refusal.owner,
+			field: refusal.fieldName
+		};
+		case "documentId": return modelFieldKey(refusal.modelName, refusal.fieldName);
+	}
+}
+function storedNameOf(field) {
+	return field.storedName ?? field.fieldName;
+}
+/** The name documents store `fieldName` under, or `fieldName` itself when the fields do not declare it. */
+function storedFieldNameIn(fields, fieldName) {
+	const field = fields.find((candidate) => candidate.fieldName === fieldName);
+	return field === void 0 ? fieldName : storedNameOf(field);
+}
+function buildContractField(field, namespaceId) {
+	const valueSet = field.enumName === void 0 ? void 0 : {
+		plane: "domain",
+		entityKind: "enum",
+		namespaceId,
+		entityName: field.enumName
+	};
+	return {
+		type: field.type,
+		nullable: field.nullable,
+		many: field.many,
+		...ifDefined("valueSet", valueSet)
+	};
+}
+function buildFields(fields, namespaceId) {
+	return Object.fromEntries(fields.map((field) => [field.fieldName, buildContractField(field, namespaceId)]));
+}
+function buildStorageFields(modelName, fields, refusals) {
+	const storageFields = {};
+	const fieldsByStoredName = /* @__PURE__ */ new Map();
+	for (const field of fields) {
+		const { fieldName } = field;
+		const key = modelFieldKey(modelName, fieldName);
+		const storedName = storedNameOf(field);
+		const unsupported = unsupportedStoredNameReason(storedName);
+		if (unsupported !== void 0) refusals.push({
+			kind: "storedNameUnsupported",
+			key,
+			reason: unsupported
+		});
+		const firstField = fieldsByStoredName.get(storedName);
+		if (firstField !== void 0) {
+			refusals.push({
+				kind: "storedNameDuplicate",
+				key,
+				storedName,
+				firstField
+			});
+			continue;
+		}
+		fieldsByStoredName.set(storedName, fieldName);
+		storageFields[fieldName] = { field: storedName };
+	}
+	return storageFields;
+}
+function toOneRelationNullable(key, relation, fields, refusals) {
+	const ownsForeignKey = relation.cardinality !== "1:1";
+	const localFields = [];
+	if (ownsForeignKey) for (const fieldName of relation.on.localFields) {
+		const localField = fields.find((field) => field.fieldName === fieldName);
+		if (localField === void 0) {
+			refusals.push({
+				kind: "relationLocalFieldUnknown",
+				key,
+				fieldName
+			});
+			return relation.nullable ?? false;
+		}
+		localFields.push(localField);
+	}
+	const { nullable, contradiction } = resolveToOneRelationNullable({
+		declaredNullable: relation.nullable,
+		localFieldNullability: localFields.map((localField) => localField.nullable === true),
+		ownsReference: ownsForeignKey
+	});
+	if (contradiction !== void 0) refusals.push({
+		kind: "relationNullability",
+		key,
+		ownsForeignKey,
+		contradiction
+	});
+	return nullable;
+}
+function buildRelation(model, relation, namespaceId, refusals) {
+	const to = crossRef(relation.toModel, namespaceId);
+	if (relation.on === void 0) return {
+		to,
+		cardinality: relation.cardinality
+	};
+	if (relation.cardinality === "1:N") return {
+		to,
+		cardinality: "1:N",
+		on: relation.on
+	};
+	const key = {
+		kind: "relation",
+		model: model.modelName,
+		relation: relation.relationName
+	};
+	return {
+		to,
+		cardinality: relation.cardinality,
+		nullable: toOneRelationNullable(key, relation, model.fields, refusals),
+		on: relation.on
+	};
+}
+function buildValueObjects(valueObjects, namespaceId, refusals) {
+	const builtValueObjects = {};
+	for (const valueObject of valueObjects ?? []) {
+		if (valueObject.name in builtValueObjects) {
+			refusals.push({
+				kind: "duplicateValueObject",
+				key: {
+					kind: "valueObject",
+					valueObject: valueObject.name
+				}
+			});
+			continue;
+		}
+		for (const field of valueObject.fields) if (field.storedName !== void 0) refusals.push({
+			kind: "valueObjectFieldStoredName",
+			key: valueObjectFieldKey(valueObject.name, field.fieldName)
+		});
+		builtValueObjects[valueObject.name] = { fields: buildFields(valueObject.fields, namespaceId) };
+	}
+	return builtValueObjects;
+}
+/**
+* Refuses a variant field stored under a name another field of its base is stored under. A variant's documents hold its base's fields too, so the two would overwrite each other, the discriminator included. A variant that restates a base field under the same name restates that field.
+*/
+function restatementDifferences(variantField, baseField) {
+	const differences = [];
+	if (storedNameOf(variantField) !== storedNameOf(baseField)) differences.push("storedName");
+	if (canonicalStringify([variantField.type, variantField.enumName]) !== canonicalStringify([baseField.type, baseField.enumName])) differences.push("type");
+	if (variantField.nullable !== baseField.nullable) differences.push("nullable");
+	if (canonicalStringify(variantField.many) !== canonicalStringify(baseField.many)) differences.push("many");
+	return differences;
+}
+/**
+* A variant's documents hold its base's fields too, and its collection's validator is written from the base. A variant field may restate a base field only exactly, and may not take a stored name a different base field uses.
+*/
+function checkFieldsAgainstBase(variant, models, refusals) {
+	if (variant.base === void 0) return;
+	const baseName = variant.base.model;
+	const base = models.find((model) => model.modelName === baseName);
+	if (base === void 0) return;
+	const baseFieldsByName = new Map(base.fields.map((field) => [field.fieldName, field]));
+	const baseFieldsByStoredName = new Map(base.fields.map((field) => [storedNameOf(field), field]));
+	for (const field of variant.fields) {
+		const key = modelFieldKey(variant.modelName, field.fieldName);
+		const restated = baseFieldsByName.get(field.fieldName);
+		if (restated !== void 0) {
+			const differences = restatementDifferences(field, restated);
+			if (differences.length > 0) refusals.push({
+				kind: "restatedBaseFieldDiffers",
+				key,
+				baseModel: baseName,
+				differences
+			});
+			continue;
+		}
+		const storedName = storedNameOf(field);
+		const baseField = baseFieldsByStoredName.get(storedName);
+		if (baseField === void 0) continue;
+		refusals.push({
+			kind: "storedNameSharedWithBase",
+			key,
+			storedName,
+			baseModel: baseName,
+			baseField: baseField.fieldName
+		});
+	}
+}
+/**
+* Each model of the contract. `variantValues` holds each accepted variant's discriminator value as its base's field stores it; a base lists those variants.
+*/
+function buildModels(input) {
+	const { models, variantValues, namespaceId, refusals } = input;
+	const builtModels = {};
+	for (const model of models) {
+		const { modelName } = model;
+		if (modelName in builtModels) {
+			refusals.push({
+				kind: "duplicateModel",
+				key: {
+					kind: "model",
+					model: modelName
+				}
+			});
+			continue;
+		}
+		checkFieldsAgainstBase(model, models, refusals);
+		const storage = {
+			...model.collection ? { collection: model.collection } : {},
+			fields: buildStorageFields(modelName, model.fields, refusals),
+			...model.storageRelations ? { relations: model.storageRelations } : {}
+		};
+		const variants = model.discriminator === void 0 ? void 0 : models.flatMap((variant) => {
+			const value = variantValues.get(variant.modelName);
+			return variant.base?.model === modelName && value !== void 0 ? [[value, crossRef(variant.modelName, namespaceId)]] : [];
+		});
+		builtModels[modelName] = {
+			fields: buildFields(model.fields, namespaceId),
+			relations: Object.fromEntries((model.relations ?? []).map((relation) => [relation.relationName, buildRelation(model, relation, namespaceId, refusals)])),
+			storage,
+			...model.owner ? { owner: model.owner } : {},
+			...model.base ? { base: crossRef(model.base.model, namespaceId) } : {},
+			...model.discriminator ? { discriminator: { field: model.discriminator.field } } : {},
+			...variants === void 0 ? {} : { variants: Object.fromEntries(variants) }
+		};
+	}
+	return builtModels;
+}
+function buildRoots(definition, models, namespaceId) {
+	if (definition.roots !== void 0) return Object.fromEntries(Object.entries(definition.roots).map(([rootName, modelName]) => [rootName, crossRef(modelName, namespaceId)]));
+	const roots = {};
+	for (const model of models) {
+		if (!model.collection || model.owner || model.base) continue;
+		roots[model.collection] = crossRef(model.modelName, namespaceId);
+	}
+	return roots;
+}
+/**
+* A key-sorted signature of a storage index, used only to find duplicate indexes. `canonicalStringify` refuses class instances such as `MongoIndex`, so this reads their enumerable properties instead.
+*/
+function stableStringify(value) {
+	if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+	if (value && typeof value === "object") return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => `${JSON.stringify(key)}:${stableStringify(entry)}`).join(",")}}`;
+	return JSON.stringify(value);
+}
+function storedIndexKey(fields, key) {
+	const scope = key.match(/^(.+)\.\$\*\*$/)?.[1];
+	if (scope !== void 0) return `${storedFieldNameIn(fields, scope)}.$**`;
+	return key === "$**" ? key : storedFieldNameIn(fields, key);
+}
+function toStorageIndex(index, fields) {
+	const input = { keys: Object.entries(index.fields).map(([field, direction]) => ({
+		field: storedIndexKey(fields, field),
+		direction
+	})) };
+	if (index.options) {
+		for (const [key, value] of Object.entries(index.options)) if (value !== void 0) input[key] = value;
+	}
+	return new MongoIndex(blindCast(input));
+}
+function toStorageCollectionOptions(opts) {
+	return new MongoCollectionOptions({
+		...opts.capped ? { capped: {
+			size: opts.size ?? 0,
+			...opts.max != null && { max: opts.max }
+		} } : {},
+		...ifDefined("storageEngine", opts.storageEngine),
+		...ifDefined("indexOptionDefaults", opts.indexOptionDefaults),
+		...ifDefined("collation", opts.collation),
+		...ifDefined("timeseries", opts.timeseries),
+		...opts.clusteredIndex !== void 0 && { clusteredIndex: opts.clusteredIndex.name !== void 0 ? { name: opts.clusteredIndex.name } : {} },
+		...ifDefined("expireAfterSeconds", opts.expireAfterSeconds),
+		...ifDefined("changeStreamPreAndPostImages", opts.changeStreamPreAndPostImages)
+	});
+}
+function findMissingIndexField(index, fields) {
+	for (const fieldName of Object.keys(index.fields)) {
+		const wildcardMatch = fieldName.match(/^(.+)\.\$\*\*$/);
+		const lookupName = wildcardMatch ? wildcardMatch[1] : fieldName;
+		if (lookupName === void 0 || lookupName.length === 0) continue;
+		if (lookupName === "$**") continue;
+		if (!fields.some((field) => field.fieldName === lookupName)) return lookupName;
+	}
+}
+function isWildcardKey(key) {
+	return key === "$**" || key.endsWith(".$**");
+}
+function isTextIndex(index) {
+	return Object.values(index.fields).includes("text");
+}
+/** The first shape rule an index breaks, of those MongoDB enforces when it creates the index. */
+function indexShapeProblem(index) {
+	const keys = Object.entries(index.fields);
+	const hasWildcard = keys.some(([key]) => isWildcardKey(key));
+	const directions = keys.map(([, direction]) => direction);
+	const options = index.options ?? {};
+	if (hasWildcard && options.unique) return "unique-wildcard";
+	if (hasWildcard && directions.some((direction) => [
+		"hashed",
+		"2d",
+		"2dsphere"
+	].includes(String(direction)))) return "wildcard-with-type";
+	if (directions.includes("hashed") && keys.length > 1) return "hashed-several-fields";
+	if (hasWildcard && options.expireAfterSeconds !== void 0) return "ttl-with-wildcard";
+	if (!hasWildcard && options.wildcardProjection !== void 0) return "projection-without-wildcard";
+	if (options.collation !== void 0 && !options.collation.locale) return "collation-without-locale";
+}
+function resolveVariantScope(model, modelsByName, variantValues) {
+	if (!model.base) return void 0;
+	const base = modelsByName.get(model.base.model);
+	const discriminatorField = base?.discriminator?.field;
+	const discriminatorValue = variantValues.get(model.modelName);
+	if (base === void 0 || !discriminatorField || discriminatorValue === void 0) return;
+	return {
+		discriminatorField: storedFieldNameIn(base.fields, discriminatorField),
+		discriminatorValue
+	};
+}
+function checkNoCollectionSettings(model, refusals) {
+	const key = {
+		kind: "collectionSettings",
+		model: model.modelName
+	};
+	if (model.indexes && model.indexes.length > 0) refusals.push({
+		kind: "collectionSettingWithoutCollection",
+		key,
+		setting: "indexes"
+	});
+	if (model.collectionOptions) refusals.push({
+		kind: "collectionSettingWithoutCollection",
+		key,
+		setting: "collectionOptions"
+	});
+	if (model.controlPolicy) refusals.push({
+		kind: "collectionSettingWithoutCollection",
+		key,
+		setting: "controlPolicy"
+	});
+}
+/** Each collection the models are stored in, with its indexes, options and control policy. Validators are added later. */
+function buildCollections(input) {
+	const { models, variantValues, refusals } = input;
+	const intermediate = {};
+	const declaredIndexOwners = /* @__PURE__ */ new Map();
+	const textIndexCollections = /* @__PURE__ */ new Set();
+	const modelsByName = new Map(models.map((model) => [model.modelName, model]));
+	for (const model of models) {
+		const { modelName, collection } = model;
+		if (!collection) {
+			checkNoCollectionSettings(model, refusals);
+			continue;
+		}
+		const collectionKey = {
+			kind: "collectionSettings",
+			model: modelName
+		};
+		const existingCollection = intermediate[collection] ?? {};
+		const existingIndexes = existingCollection.indexes ?? [];
+		if (existingCollection.options && model.collectionOptions) refusals.push({
+			kind: "collectionSettingTwice",
+			key: collectionKey,
+			setting: "collectionOptions",
+			collection
+		});
+		if (existingCollection.control !== void 0 && model.controlPolicy) refusals.push({
+			kind: "collectionSettingTwice",
+			key: collectionKey,
+			setting: "controlPolicy",
+			collection
+		});
+		const polymorphicScope = resolveVariantScope(model, modelsByName, variantValues);
+		const storageIndexes = [];
+		(model.indexes ?? []).forEach((written, position) => {
+			const key = {
+				kind: "index",
+				model: modelName,
+				position
+			};
+			const signature = canonicalStringify(written);
+			const missingField = findMissingIndexField(written, model.fields);
+			if (missingField !== void 0) {
+				refusals.push({
+					kind: "indexFieldUnknown",
+					key,
+					fieldName: missingField,
+					signature
+				});
+				return;
+			}
+			const shapeProblem = indexShapeProblem(written);
+			if (shapeProblem !== void 0) {
+				refusals.push({
+					kind: "indexShape",
+					key,
+					rule: shapeProblem,
+					signature
+				});
+				return;
+			}
+			if (isTextIndex(written)) {
+				if (textIndexCollections.has(collection)) {
+					refusals.push({
+						kind: "indexShape",
+						key,
+						rule: "second-text-index",
+						signature
+					});
+					return;
+				}
+				textIndexCollections.add(collection);
+			}
+			const storageIndex = toStorageIndex(written, model.fields);
+			const scoped = polymorphicScope === void 0 ? {
+				kind: "ok",
+				index: storageIndex
+			} : applyPolymorphicScopeToMongoIndex(storageIndex, polymorphicScope);
+			if (scoped.kind === "conflict") {
+				refusals.push({
+					kind: "indexScopeConflict",
+					key,
+					reason: scoped.reason,
+					signature
+				});
+				return;
+			}
+			const collectionIndexKey = `${collection}:${stableStringify(scoped.index)}`;
+			const firstModel = declaredIndexOwners.get(collectionIndexKey);
+			if (firstModel !== void 0) {
+				refusals.push({
+					kind: "indexDuplicate",
+					key,
+					collection,
+					firstModel,
+					signature
+				});
+				return;
+			}
+			declaredIndexOwners.set(collectionIndexKey, modelName);
+			storageIndexes.push(scoped.index);
+		});
+		const storageOptions = model.collectionOptions ? toStorageCollectionOptions(model.collectionOptions) : void 0;
+		const controlPatch = model.controlPolicy !== void 0 ? { control: model.controlPolicy } : {};
+		intermediate[collection] = storageIndexes.length > 0 ? {
+			...existingCollection,
+			indexes: [...existingIndexes, ...storageIndexes],
+			...storageOptions ? { options: storageOptions } : {},
+			...controlPatch
+		} : storageOptions ? {
+			...existingCollection,
+			options: storageOptions,
+			...controlPatch
+		} : Object.keys(controlPatch).length > 0 ? {
+			...existingCollection,
+			...controlPatch
+		} : existingCollection;
+	}
+	return intermediate;
+}
+/** Each enum with its members as its codec stores them. An enum the builder refuses is left out. */
+function buildEnums(definition, codecLookup, refusals) {
+	const builtEnums = {};
+	for (const [enumName, handle] of Object.entries(definition.enums ?? {})) {
+		const encoded = encodeEnumMembers(handle, codecLookup);
+		if (!encoded.ok) {
+			for (const problem of encoded.failure) refusals.push({
+				kind: "enumMemberProblem",
+				key: "member" in problem ? {
+					kind: "enumMember",
+					enumName,
+					member: problem.member
+				} : {
+					kind: "enum",
+					enumName
+				},
+				enumName: handle.enumName,
+				codecId: handle.codecId,
+				problem
+			});
+			continue;
+		}
+		builtEnums[enumName] = {
+			codecId: handle.codecId,
+			members: encoded.value
+		};
+	}
+	for (const [enumName, handle] of Object.entries(definition.enums ?? {})) if (enumName !== handle.enumName) refusals.push({
+		kind: "enumKeyMismatch",
+		key: {
+			kind: "enum",
+			enumName
+		},
+		enumName: handle.enumName
+	});
+	return builtEnums;
+}
+const PHASES = ["onCreate", "onUpdate"];
+function hasExecutionDefaults(field) {
+	const phases = field.executionDefaults;
+	const calls = field.generatorCalls;
+	const values = field.generatedValues;
+	return phases?.onCreate !== void 0 || phases?.onUpdate !== void 0 || values?.onCreate !== void 0 || values?.onUpdate !== void 0 || calls?.onCreate !== void 0 || calls?.onUpdate !== void 0;
+}
+/**
+* The phases a field generates: its resolved execution defaults, with the generators its calls resolve to for its codec. Undefined when a call is refused.
+*/
+function executionDefaultsOf(field, key, generatorFunctions, refusals) {
+	const typeGiven = field.executionDefaults;
+	let refused = false;
+	for (const phase of PHASES) if (typeGiven?.[phase] !== void 0 && field.generatedValues?.[phase] !== void 0) {
+		refusals.push({
+			kind: "generatorPhaseSetTwice",
+			key,
+			phase
+		});
+		refused = true;
+	}
+	const written = {
+		...typeGiven,
+		...field.generatedValues
+	};
+	const calls = field.generatorCalls;
+	if (calls === void 0) return refused ? void 0 : written;
+	const type = field.type;
+	const codecId = type.kind === "scalar" ? type.codecId : void 0;
+	const phases = written;
+	for (const phase of PHASES) {
+		const call = calls[phase];
+		if (call === void 0) continue;
+		if (written[phase] !== void 0) {
+			refusals.push({
+				kind: "generatorPhaseSetTwice",
+				key,
+				phase
+			});
+			refused = true;
+			continue;
+		}
+		const resolution = type.kind === "scalar" ? generatorFunctions.resolve(call, {
+			codecId: type.codecId,
+			typeParams: type.typeParams,
+			length: void 0
+		}) : void 0;
+		if (resolution?.ok === true) {
+			phases[phase] = resolution.generator;
+			continue;
+		}
+		refused = true;
+		refusals.push(resolution?.reason === "unknown-function" ? {
+			kind: "generatorUnknown",
+			key,
+			phase,
+			functionName: call.name,
+			codecId
+		} : {
+			kind: "generatorNotApplicable",
+			key,
+			phase,
+			functionName: call.name,
+			codecId,
+			message: resolution?.reason === "refused" ? resolution.message : void 0
+		});
+	}
+	return refused ? void 0 : phases;
+}
+function checkValueObjectExecutionDefaults(valueObjects, refusals) {
+	for (const valueObject of valueObjects ?? []) for (const field of valueObject.fields) if (hasExecutionDefaults(field)) refusals.push({
+		kind: "generatedOnValueObject",
+		key: valueObjectFieldKey(valueObject.name, field.fieldName)
+	});
+}
+function buildExecutionDefaults(input) {
+	const { models, generatorFunctions, namespaceId, refusals } = input;
+	const collectionByModelName = new Map(models.map((model) => [model.modelName, model.collection]));
+	const byRef = /* @__PURE__ */ new Map();
+	const defaults = [];
+	for (const model of models) {
+		const { modelName } = model;
+		for (const field of model.fields) {
+			if (!hasExecutionDefaults(field)) continue;
+			const { fieldName } = field;
+			const key = modelFieldKey(modelName, fieldName);
+			const phases = executionDefaultsOf(field, key, generatorFunctions, refusals);
+			if (phases === void 0) continue;
+			if (field.many) {
+				refusals.push({
+					kind: "generatedList",
+					key
+				});
+				continue;
+			}
+			if (model.base !== void 0) {
+				refusals.push({
+					kind: "generatedOnVariant",
+					key,
+					baseModel: model.base.model,
+					collection: model.collection ?? collectionByModelName.get(model.base.model)
+				});
+				continue;
+			}
+			const entry = model.collection;
+			if (entry === void 0) {
+				refusals.push({
+					kind: "generatedWithoutCollection",
+					key
+				});
+				continue;
+			}
+			const storedName = storedNameOf(field);
+			const refKey = JSON.stringify([entry, storedName]);
+			const phasesKey = canonicalStringify(phases);
+			const existing = byRef.get(refKey);
+			if (existing !== void 0) {
+				if (existing.phasesKey !== phasesKey) refusals.push({
+					kind: "generatedConflict",
+					key,
+					otherModel: existing.modelName,
+					otherField: existing.fieldName,
+					collection: entry
+				});
+				continue;
+			}
+			byRef.set(refKey, {
+				modelName,
+				fieldName,
+				phasesKey
+			});
+			defaults.push({
+				ref: {
+					namespace: namespaceId,
+					entry,
+					field: storedName
+				},
+				...phases
+			});
+		}
+	}
+	return defaults;
+}
+function generatesNothing(field) {
+	const contributed = field.presetContribution?.executionDefaults;
+	const calls = field.generatorCalls;
+	const values = field.generatedValues;
+	return values?.onCreate === void 0 && values?.onUpdate === void 0 && contributed?.onCreate === void 0 && contributed?.onUpdate === void 0 && calls?.onCreate === void 0 && calls?.onUpdate === void 0;
+}
+function checkField(field, key, input) {
+	const { type } = field;
+	if (field.enumName !== void 0 && !input.declaredEnums.has(field.enumName)) input.refusals.push({
+		kind: "enumUnknown",
+		key,
+		enumName: field.enumName
+	});
+	if (type.kind === "scalar" && type.typeParams !== void 0) {
+		const problem = codecTypeParamsProblem(type.codecId, type.typeParams, input.lookups);
+		if (problem !== void 0) input.refusals.push({
+			kind: "typeParamsInvalid",
+			key,
+			problem
+		});
+	}
+	if (field.presetContribution !== void 0 && type.kind === "scalar" && generatesNothing(field)) input.warnings.push({
+		kind: "presetWithoutEffect",
+		key,
+		preset: field.presetContribution.preset,
+		codecId: type.codecId
+	});
+}
+/**
+* Checks each field of the models and value objects on its own: its enum is declared, its data type accepts its type parameters, and a preset that made it generates a value.
+*/
+function checkFields(input) {
+	for (const model of input.models) for (const field of model.fields) checkField(field, modelFieldKey(model.modelName, field.fieldName), input);
+	for (const valueObject of input.valueObjects ?? []) for (const field of valueObject.fields) checkField(field, valueObjectFieldKey(valueObject.name, field.fieldName), input);
+}
+/**
+* The models with each variant stored in its base's collection: a variant that names no collection takes its base's, and one that names another is refused.
+*/
+function inheritVariantCollections(models, refusals) {
+	const modelsByName = new Map(models.map((model) => [model.modelName, model]));
+	return models.map((model) => {
+		if (model.base === void 0) return model;
+		const baseCollection = modelsByName.get(model.base.model)?.collection;
+		if (baseCollection === void 0) return model;
+		if (model.collection === void 0) return {
+			...model,
+			collection: baseCollection
+		};
+		if (model.collection !== baseCollection) refusals.push({
+			kind: "variantCollectionDiffers",
+			key: {
+				kind: "collectionSettings",
+				model: model.modelName
+			},
+			collection: model.collection,
+			baseModel: model.base.model,
+			baseCollection
+		});
+		return model;
+	});
+}
+function checkVariantShape(model, modelsByName, refusals) {
+	if (model.base === void 0) return;
+	const key = {
+		kind: "base",
+		variant: model.modelName
+	};
+	const baseModel = model.base.model;
+	if (model.discriminator !== void 0) refusals.push({
+		kind: "discriminatorAndBase",
+		key: {
+			kind: "discriminator",
+			model: model.modelName
+		}
+	});
+	const base = modelsByName.get(baseModel);
+	if (base === void 0) {
+		refusals.push({
+			kind: "baseUnknown",
+			key,
+			baseModel
+		});
+		return;
+	}
+	if (base.discriminator === void 0) {
+		refusals.push({
+			kind: "baseWithoutDiscriminator",
+			key,
+			baseModel
+		});
+		return;
+	}
+	if (model.base.value === void 0) refusals.push({
+		kind: "variantWithoutValue",
+		key,
+		baseModel
+	});
+}
+/** Each variant of `base` with the value its source wrote, in the order of the models. */
+function writtenVariantsOf(base, models) {
+	return models.flatMap((model) => model.base?.model === base.modelName && model.base.value !== void 0 ? [{
+		key: model.modelName,
+		written: model.base.value
+	}] : []);
+}
+function decideDiscriminator(input) {
+	const { base, models, refusals } = input;
+	const discriminator = base.discriminator;
+	if (discriminator === void 0 || base.base !== void 0) return /* @__PURE__ */ new Map();
+	const key = {
+		kind: "discriminator",
+		model: base.modelName
+	};
+	const variantNames = new Set(models.filter((model) => model.base?.model === base.modelName).map((model) => model.modelName));
+	for (const listed of discriminator.listedVariants ?? []) if (!variantNames.has(listed)) refusals.push({
+		kind: "listedVariantMissing",
+		key,
+		variant: listed
+	});
+	if (variantNames.size === 0) refusals.push({
+		kind: "discriminatorWithoutVariants",
+		key
+	});
+	const fieldName = discriminator.field;
+	const field = base.fields.find((candidate) => candidate.fieldName === fieldName);
+	if (field === void 0) {
+		refusals.push({
+			kind: "discriminatorFieldUnknown",
+			key,
+			fieldName
+		});
+		return /* @__PURE__ */ new Map();
+	}
+	const { type } = field;
+	const enumMembers = field.enumName === void 0 ? void 0 : input.enums[field.enumName]?.members.map((member) => member.value);
+	const decision = applyDiscriminatorRule({
+		field: {
+			ref: type.kind === "scalar" ? {
+				codecId: type.codecId,
+				...type.typeParams ? { typeParams: blindCast(type.typeParams) } : {}
+			} : void 0,
+			nullable: field.nullable,
+			many: field.many !== false,
+			enumMembers
+		},
+		variants: writtenVariantsOf(base, models),
+		subject: `Field "${base.modelName}.${fieldName}"`,
+		codecLookup: input.codecLookup,
+		dataTypes: input.dataTypes
+	});
+	for (const refusal of decision.fieldRefusals) refusals.push({
+		kind: "discriminatorField",
+		key,
+		fieldName,
+		refusal
+	});
+	for (const refusal of decision.variantRefusals) refusals.push({
+		kind: "discriminatorValue",
+		key: {
+			kind: "base",
+			variant: refusal.key
+		},
+		baseModel: base.modelName,
+		fieldName,
+		enumName: field.enumName,
+		refusal
+	});
+	const variantsByValue = /* @__PURE__ */ new Map();
+	for (const [variant, value] of decision.values) {
+		const firstVariant = variantsByValue.get(value);
+		if (firstVariant !== void 0) {
+			refusals.push({
+				kind: "discriminatorValueDuplicate",
+				key: {
+					kind: "base",
+					variant
+				},
+				baseModel: base.modelName,
+				value,
+				firstVariant
+			});
+			continue;
+		}
+		variantsByValue.set(value, variant);
+	}
+	return decision.values;
+}
+/**
+* Checks each base and variant, and decides each variant's discriminator value with the framework's discriminator rule. Returns each accepted variant's value as its base's discriminator field stores it.
+*/
+function decidePolymorphism(input) {
+	const { models, refusals } = input;
+	const modelsByName = new Map(models.map((model) => [model.modelName, model]));
+	const values = /* @__PURE__ */ new Map();
+	for (const model of models) {
+		checkVariantShape(model, modelsByName, refusals);
+		for (const [variant, value] of decideDiscriminator({
+			...input,
+			base: model
+		})) values.set(variant, value);
+	}
+	return values;
+}
+/** Whether a refusal is about listing an enum in a collection validator, which matters only when collections get validators. */
+function isAboutEnumListing(refusal) {
+	return refusal.kind === "enumBsonType" || refusal.kind === "enumNotListable" || refusal.kind === "enumMemberNotListable";
+}
+/**
+* Builds a MongoDB contract from its plain-data definition, with the stack's codecs and data types. Every MongoDB family rule is checked here, and each refusal comes back as data keyed by the part of the definition it is about, for the source to report in its own terms.
+*/
+function buildMongoContractFromDefinition(definition, codecLookup, dataTypes) {
+	const refusals = [];
+	const warnings = (definition.warnings ?? []).map((warning) => ({
+		kind: "source",
+		warning
+	}));
+	const namespaceId = definition.target.defaultNamespaceId;
+	const lookups = {
+		codecLookup,
+		dataTypeLookup: dataTypes.lookup
+	};
+	const generatorFunctions = assembleGeneratorFunctions([definition.target, ...Object.values(definition.extensions ?? {})]);
+	const models = inheritVariantCollections(definition.models, refusals);
+	const builtEnums = buildEnums(definition, codecLookup, refusals);
+	const variantValues = decidePolymorphism({
+		models,
+		enums: builtEnums,
+		codecLookup,
+		dataTypes,
+		refusals
+	});
+	const builtModels = buildModels({
+		models,
+		variantValues,
+		namespaceId,
+		refusals
+	});
+	const builtValueObjects = buildValueObjects(definition.valueObjects, namespaceId, refusals);
+	checkFields({
+		models,
+		valueObjects: definition.valueObjects,
+		declaredEnums: new Set(Object.keys(definition.enums ?? {})),
+		lookups,
+		refusals,
+		warnings
+	});
+	const collections = buildCollections({
+		models,
+		variantValues,
+		refusals
+	});
+	checkValueObjectExecutionDefaults(definition.valueObjects, refusals);
+	const executionDefaults = buildExecutionDefaults({
+		models,
+		generatorFunctions,
+		namespaceId,
+		refusals
+	});
+	if (refusals.length > 0) return notOk({
+		refusals,
+		warnings
+	});
+	const controlPolicies = {
+		collections: Object.fromEntries(Object.entries(collections).map(([name, collection]) => [name, collection.control])),
+		defaultControlPolicy: definition.defaultControlPolicy
+	};
+	const validatorRefusals = mongoContractRefusalsOf({
+		models: builtModels,
+		valueObjects: builtValueObjects,
+		enums: builtEnums,
+		lookups,
+		controlPolicies
+	}).filter((refusal) => definition.writesCollectionValidators || !isAboutEnumListing(refusal));
+	if (validatorRefusals.length > 0) return notOk({
+		refusals: validatorRefusals.map((refusal) => ({
+			kind: "validator",
+			key: validatorRefusalKey(refusal),
+			refusal
+		})),
+		warnings
+	});
+	const storageValueSets = mongoValueSetsOf(builtEnums);
+	const validators = definition.writesCollectionValidators ? deriveCollectionValidators({
+		models: builtModels,
+		lookups,
+		valueObjects: builtValueObjects,
+		valueSets: storageValueSets,
+		controlPolicies
+	}) : {};
+	const storage = buildMongoStorage({
+		namespaceId,
+		collections: Object.fromEntries(Object.entries(collections).map(([name, collection]) => [name, {
+			...collection,
+			...ifDefined("validator", validators[name])
+		}])),
+		valueSets: storageValueSets
+	});
+	const capabilities = {};
+	const execution = buildExecutionSection({
+		target: definition.target.targetId,
+		targetFamily: definition.target.familyId,
+		defaults: executionDefaults
+	});
+	return ok({
+		contract: {
+			target: definition.target.targetId,
+			targetFamily: definition.target.familyId,
+			...ifDefined("defaultControlPolicy", definition.defaultControlPolicy),
+			roots: buildRoots(definition, models, namespaceId),
+			domain: { namespaces: { [namespaceId]: {
+				models: builtModels,
+				...Object.keys(builtValueObjects).length > 0 ? { valueObjects: builtValueObjects } : {},
+				...Object.keys(builtEnums).length > 0 ? { enum: builtEnums } : {}
+			} } },
+			storage,
+			capabilities,
+			extensions: definition.extensions ?? {},
+			profileHash: computeProfileHash({
+				target: definition.target.targetId,
+				targetFamily: definition.target.familyId,
+				capabilities
+			}),
+			meta: {},
+			...ifDefined("execution", execution)
+		},
+		warnings
+	});
+}
+function resolveModelName(value) {
+	return typeof value === "string" ? value : value.__name;
+}
+function validateTargetPackRef(family, target) {
+	if (family.familyId !== "mongo") throw contractError("CONTRACT.PACK_FAMILY_MISMATCH", `defineContract only accepts Mongo family packs. Received family "${family.familyId}".`, { meta: {
+		packId: family.id,
+		packFamilyId: family.familyId,
+		contractFamilyId: "mongo"
+	} });
+	if (target.familyId !== family.familyId) throw contractError("CONTRACT.PACK_FAMILY_MISMATCH", `target pack "${target.id}" targets family "${target.familyId}" but contract family is "${family.familyId}".`, { meta: {
+		packId: target.id,
+		packFamilyId: target.familyId,
+		contractFamilyId: family.familyId
+	} });
+}
+function validateExtensionPackRefs(target, extensions) {
+	for (const packRef of Object.values(extensions ?? {})) {
+		if (packRef.kind !== "extension") throw contractError("CONTRACT.PACK_REF_INVALID", `defineContract only accepts extension pack refs in extensions. Received kind "${packRef.kind}".`, { meta: {
+			packId: packRef.id,
+			kind: packRef.kind
+		} });
+		if (packRef.familyId !== target.familyId) throw contractError("CONTRACT.PACK_FAMILY_MISMATCH", `extension pack "${packRef.id}" targets family "${packRef.familyId}" but contract target family is "${target.familyId}".`, { meta: {
+			packId: packRef.id,
+			packFamilyId: packRef.familyId,
+			contractFamilyId: target.familyId
+		} });
+		if (packRef.targetId && packRef.targetId !== target.targetId) throw contractError("CONTRACT.PACK_TARGET_MISMATCH", `extension pack "${packRef.id}" targets "${packRef.targetId}" but contract target is "${target.targetId}".`, { meta: {
+			packId: packRef.id,
+			packTargetId: packRef.targetId,
+			contractTargetId: target.targetId
+		} });
+	}
+}
+function fieldNodes(fields) {
+	return Object.entries(fields).map(([fieldName, builder]) => ({
+		fieldName,
+		...ifDefined("storedName", builder.__storedName),
+		type: builder.__type,
+		nullable: builder.__nullable,
+		many: builder.__many,
+		...ifDefined("enumName", builder.__enumHandle?.enumName),
+		...ifDefined("executionDefaults", builder.__executionDefaults),
+		...ifDefined("generatorCalls", builder.__generatorCalls),
+		...ifDefined("presetContribution", builder.__presetContribution)
+	}));
+}
+function relationNodes(builder) {
+	return Object.entries(builder.__relations).map(([relationName, relation]) => {
+		const common = {
+			relationName,
+			toModel: relation.__to,
+			nullable: relation.__nullable
+		};
+		return relation.__on === void 0 ? {
+			...common,
+			cardinality: relation.__cardinality
+		} : {
+			...common,
+			cardinality: relation.__cardinality,
+			on: relation.__on
+		};
+	});
+}
+function modelNode(builder, buildersByName) {
+	const base = builder.__base;
+	const variantValue = base === void 0 ? void 0 : buildersByName.get(base)?.__variants?.[builder.__name]?.value;
+	return {
+		modelName: builder.__name,
+		...ifDefined("collection", builder.__collection),
+		...ifDefined("owner", builder.__owner),
+		...ifDefined("storageRelations", builder.__storageRelations),
+		...ifDefined("controlPolicy", builder.__controlPolicy),
+		...ifDefined("collectionOptions", builder.__collectionOptions),
+		...ifDefined("indexes", builder.__indexes),
+		fields: fieldNodes(builder.__fields),
+		relations: relationNodes(builder),
+		...builder.__discriminator === void 0 ? {} : { discriminator: {
+			field: builder.__discriminator.field,
+			listedVariants: Object.keys(builder.__variants ?? {})
+		} },
+		...base === void 0 ? {} : { base: {
+			model: base,
+			value: variantValue === void 0 ? void 0 : {
+				kind: "string",
+				text: variantValue
+			}
+		} }
+	};
+}
+function valueObjectNode(builder) {
+	return {
+		name: builder.__name,
+		fields: fieldNodes(builder.__fields)
+	};
+}
+/** Turns `defineContract`'s builder objects into the plain-data definition the contract is built from. */
+function buildContractDefinition(input) {
+	const { target } = input;
+	validateTargetPackRef(input.family, target);
+	validateExtensionPackRefs(target, input.extensions);
+	const builders = Object.values(input.models ?? {});
+	const buildersByName = /* @__PURE__ */ new Map();
+	for (const builder of builders) if (!buildersByName.has(builder.__name)) buildersByName.set(builder.__name, builder);
+	return {
+		target,
+		...ifDefined("extensions", input.extensions),
+		...ifDefined("defaultControlPolicy", input.defaultControlPolicy),
+		models: builders.map((builder) => modelNode(builder, buildersByName)),
+		valueObjects: Object.values(input.valueObjects ?? {}).map(valueObjectNode),
+		...ifDefined("enums", input.enums),
+		...ifDefined("roots", input.roots === void 0 ? void 0 : Object.fromEntries(Object.entries(input.roots).map(([rootName, model]) => [rootName, resolveModelName(model)]))),
+		writesCollectionValidators: true,
+		warnings: void 0
+	};
+}
+const LIST_THE_CODEC_PACK = "List the pack that provides the codec in `extensions` in defineContract.";
+function codecRefusalError(subject, meta, codecId, refusal) {
+	if (refusal.kind === "unknownCodec") return contractError("CONTRACT.CODEC_DESCRIPTOR_MISSING", `${subject} ${refusal.reason}`, {
+		fix: LIST_THE_CODEC_PACK,
+		meta: {
+			...meta,
+			codecId
+		}
+	});
+	return contractError("CONTRACT.PACK_CONTRIBUTION_INVALID", `${subject} ${refusal.reason}`, {
+		fix: "Use a codec whose data type is a MongoDB data type, declared with mongoDataType.",
+		meta: {
+			...meta,
+			codecId,
+			dataType: refusal.dataType,
+			reason: "data-type-not-mongo"
+		}
+	});
+}
+function validatorRefusalError(refusal) {
+	switch (refusal.kind) {
+		case "embeddedModelHasVariants": return contractError("CONTRACT.RELATION_INVALID", `Relation "${refusal.modelName}.${refusal.relationName}" ${refusal.reason}`, { meta: {
+			modelName: refusal.modelName,
+			relationName: refusal.relationName,
+			reason: "embedded-model-has-variants"
+		} });
+		case "enumBsonType": return codecRefusalError(`enumType("${refusal.enumName}")`, { enumName: refusal.enumName }, refusal.codecId, refusal.refusal);
+		case "enumNotListable": return contractError("CONTRACT.ENUM_INVALID", `enumType("${refusal.enumName}") codec "${refusal.codecId}" ${refusal.reason}`, { meta: {
+			enumName: refusal.enumName,
+			codecId: refusal.codecId,
+			reason: "not-listable-by-validator"
+		} });
+		case "enumMemberNotListable": return contractError("CONTRACT.ENUM_INVALID", `enumType("${refusal.enumName}") member "${refusal.member}" ${refusal.reason}`, { meta: {
+			enumName: refusal.enumName,
+			member: refusal.member,
+			codecId: refusal.codecId,
+			reason: "member-not-listable-by-validator"
+		} });
+		case "fieldBsonType": {
+			const { owner } = refusal;
+			const label = owner.kind === "model" ? "Model" : "Value object";
+			const ownerMeta = owner.kind === "model" ? { modelName: owner.name } : { valueObjectName: owner.name };
+			return codecRefusalError(`${label} "${owner.name}" field "${refusal.fieldName}"`, {
+				...ownerMeta,
+				fieldName: refusal.fieldName
+			}, refusal.codecId, refusal.refusal);
+		}
+		case "documentId": return contractError("CONTRACT.COLLECTION_INVALID", `Model "${refusal.modelName}" field "${refusal.fieldName}" ${refusal.reason}`, { meta: {
+			modelName: refusal.modelName,
+			fieldName: refusal.fieldName,
+			collection: refusal.collection,
+			codecId: refusal.codecId,
+			bsonTypes: refusal.forbidden,
+			reason: "document-id-bson-type"
+		} });
+	}
+}
+function defaultError(key, reason, message) {
+	return contractError("CONTRACT.DEFAULT_INVALID", `Field "${`${key.owner.name}.${key.field}`}" ${message}`, { meta: {
+		modelName: key.owner.name,
+		fieldName: key.field,
+		reason
+	} });
+}
+function ownerMetaOf(key) {
+	return key.owner.kind === "model" ? {
+		modelName: key.owner.name,
+		fieldName: key.field
+	} : {
+		valueObjectName: key.owner.name,
+		fieldName: key.field
+	};
+}
+function ownerLabelOf(key) {
+	return `${key.owner.kind === "model" ? "Model" : "Value object"} "${key.owner.name}" field "${key.field}"`;
+}
+const INDEX_SHAPE_MESSAGES = {
+	"unique-wildcard": "is unique and has a wildcard key; a unique index cannot use a wildcard.",
+	"wildcard-with-type": "combines a wildcard key with a hashed, 2d or 2dsphere key, which MongoDB does not allow.",
+	"hashed-several-fields": "is hashed on several fields; a hashed index has exactly one field.",
+	"ttl-with-wildcard": "sets expireAfterSeconds on a wildcard index, which MongoDB does not allow.",
+	"projection-without-wildcard": "sets wildcardProjection but has no wildcard key; a wildcard projection needs a wildcard index.",
+	"collation-without-locale": "sets a collation without a locale; a collation needs a locale.",
+	"second-text-index": "is a second text index in its collection; MongoDB allows one text index per collection."
+};
+function discriminatorFieldError(refusal) {
+	const field = `Discriminator field "${refusal.key.model}.${refusal.fieldName}"`;
+	const meta = {
+		modelName: refusal.key.model,
+		fieldName: refusal.fieldName
+	};
+	switch (refusal.refusal.kind) {
+		case "optional": return contractError("CONTRACT.ARGUMENT_INVALID", `${field} must be required, but it is optional. Remove .optional().`, { meta: {
+			...meta,
+			reason: "discriminator-optional"
+		} });
+		case "list": return contractError("CONTRACT.ARGUMENT_INVALID", `${field} must hold one value, but it is a list. Remove .many().`, { meta: {
+			...meta,
+			reason: "discriminator-list"
+		} });
+		case "not-text": {
+			const { dataType } = refusal.refusal;
+			return contractError("CONTRACT.ARGUMENT_INVALID", `${field} must be text, such as field.string(), but its data type is ${dataType === void 0 ? "not a scalar" : `"${dataType}"`}.`, { meta: {
+				...meta,
+				dataType,
+				reason: "discriminator-not-text"
+			} });
+		}
+	}
+}
+/** The error `defineContract` throws for a refusal of the builder. */
+function refusalError(refusal) {
+	switch (refusal.kind) {
+		case "duplicateModel": return contractError("CONTRACT.NAME_DUPLICATE", `Duplicate model name "${refusal.key.model}" in defineContract().`, { meta: {
+			kind: "model",
+			name: refusal.key.model
+		} });
+		case "duplicateValueObject": return contractError("CONTRACT.NAME_DUPLICATE", `Duplicate value object name "${refusal.key.valueObject}" in defineContract().`, { meta: {
+			kind: "valueObject",
+			name: refusal.key.valueObject
+		} });
+		case "storedNameUnsupported": return contractError("CONTRACT.ARGUMENT_INVALID", `Model "${refusal.key.owner.name}" field "${refusal.key.field}" ${refusal.reason}. Give it another stored name.`, { meta: {
+			modelName: refusal.key.owner.name,
+			fieldName: refusal.key.field,
+			reason: "stored-name-unsupported"
+		} });
+		case "storedNameDuplicate": return contractError("CONTRACT.NAME_DUPLICATE", `Model "${refusal.key.owner.name}" stores both "${refusal.firstField}" and "${refusal.key.field}" as "${refusal.storedName}".`, { meta: {
+			kind: "field",
+			name: refusal.storedName,
+			first: refusal.firstField,
+			second: refusal.key.field
+		} });
+		case "restatedBaseFieldDiffers": return contractError("CONTRACT.ARGUMENT_INVALID", `Variant model "${refusal.key.owner.name}" restates field "${refusal.key.field}" of its base "${refusal.baseModel}" with a different ${refusal.differences.map(differenceWording).join(" and ")}. A variant's documents are checked against the base's field, so restate it exactly or remove it from the variant.`, { meta: {
+			modelName: refusal.key.owner.name,
+			fieldName: refusal.key.field,
+			baseModel: refusal.baseModel,
+			differences: refusal.differences,
+			reason: "restated-base-field-differs"
+		} });
+		case "storedNameSharedWithBase": return contractError("CONTRACT.NAME_DUPLICATE", `Variant model "${refusal.key.owner.name}" field "${refusal.key.field}" is stored as "${refusal.storedName}", which its base "${refusal.baseModel}" stores field "${refusal.baseField}" under. A variant's documents hold its base's fields too, so give the field another stored name.`, { meta: {
+			kind: "field",
+			name: refusal.storedName,
+			first: `${refusal.baseModel}.${refusal.baseField}`,
+			second: `${refusal.key.owner.name}.${refusal.key.field}`,
+			reason: "stored-name-shared-with-base"
+		} });
+		case "valueObjectFieldStoredName": return contractError("CONTRACT.ARGUMENT_INVALID", `Value object "${refusal.key.owner.name}" field "${refusal.key.field}" sets .mongo({ field }), but a field of a value object is stored under its own name.`, { meta: {
+			valueObjectName: refusal.key.owner.name,
+			fieldName: refusal.key.field,
+			reason: "value-object-field-stored-name"
+		} });
+		case "relationLocalFieldUnknown": {
+			const { model, relation } = refusal.key;
+			return contractError("CONTRACT.RELATION_INVALID", `Relation "${model}.${relation}" joins on local field "${refusal.fieldName}", which model "${model}" does not declare`, { meta: {
+				modelName: model,
+				relationName: relation,
+				fieldName: refusal.fieldName,
+				reason: "local-field-unknown"
+			} });
+		}
+		case "relationNullability": {
+			const { model, relation } = refusal.key;
+			const location = `Relation "${model}.${relation}"`;
+			return contractError("CONTRACT.RELATION_INVALID", !refusal.ownsForeignKey ? `${location} is required but does not own the foreign key, so nothing in storage guarantees the related document exists` : refusal.contradiction === "declared-optional" ? `${location} is optional but every local field it joins on is required` : `${location} is required but a local field it joins on is nullable`, { meta: {
+				modelName: model,
+				relationName: relation,
+				reason: "to-one-nullability-mismatch"
+			} });
+		}
+		case "collectionSettingWithoutCollection": {
+			const modelName = refusal.key.model;
+			const what = refusal.setting === "controlPolicy" ? "it" : "them";
+			return contractError("CONTRACT.COLLECTION_INVALID", `Model "${modelName}" defines ${refusal.setting} but has no collection to attach ${what} to.`, { meta: {
+				modelName,
+				reason: `${refusal.setting}-without-collection`
+			} });
+		}
+		case "collectionSettingTwice": return contractError("CONTRACT.COLLECTION_INVALID", `Collection "${refusal.collection}" has ${refusal.setting} declared by multiple models. Author ${refusal.setting} on a single model per collection.`, { meta: {
+			modelName: refusal.key.model,
+			collection: refusal.collection,
+			reason: `${refusal.setting}-declared-by-multiple-models`
+		} });
+		case "variantCollectionDiffers": return contractError("CONTRACT.COLLECTION_INVALID", `Variant model "${refusal.key.model}" is stored in collection "${refusal.collection}", but its base "${refusal.baseModel}" is stored in "${refusal.baseCollection}". A variant is stored in its base's collection; leave its collection out.`, { meta: {
+			modelName: refusal.key.model,
+			collection: refusal.collection,
+			baseModel: refusal.baseModel,
+			baseCollection: refusal.baseCollection,
+			reason: "variant-collection-differs"
+		} });
+		case "indexFieldUnknown": return contractError("CONTRACT.FIELD_UNKNOWN", `Model "${refusal.key.model}" index ${refusal.signature} references unknown field "${refusal.fieldName}".`, { meta: {
+			modelName: refusal.key.model,
+			fieldName: refusal.fieldName,
+			indexSignature: refusal.signature
+		} });
+		case "indexShape": return contractError("CONTRACT.INDEX_INVALID", `Model "${refusal.key.model}" index ${refusal.signature} ${INDEX_SHAPE_MESSAGES[refusal.rule]}`, { meta: {
+			modelName: refusal.key.model,
+			indexSignature: refusal.signature,
+			reason: refusal.rule
+		} });
+		case "indexScopeConflict": return contractError("CONTRACT.INDEX_INVALID", `Variant model "${refusal.key.model}" index ${refusal.signature} conflicts with discriminator scope: ${refusal.reason}`, { meta: {
+			variantName: refusal.key.model,
+			indexLabel: refusal.signature,
+			reason: refusal.reason
+		} });
+		case "indexDuplicate": return contractError("CONTRACT.NAME_DUPLICATE", `Collection "${refusal.collection}" defines duplicate index ${refusal.signature}. First declared on model "${refusal.firstModel}" and duplicated on model "${refusal.key.model}".`, { meta: {
+			kind: "index",
+			name: refusal.signature,
+			collection: refusal.collection,
+			first: refusal.firstModel,
+			second: refusal.key.model
+		} });
+		case "generatedOnValueObject": return defaultError(refusal.key, "executionDefaults-on-value-object", "has executionDefaults, but it belongs to a value object. Generated values are only supported on model fields.");
+		case "generatorUnknown": {
+			const { owner, field } = refusal.key;
+			return contractError("CONTRACT.DEFAULT_INVALID", `Field "${owner.name}.${field}": no pack in the contract declares the generator function "${refusal.functionName}".`, { meta: {
+				modelName: owner.name,
+				fieldName: field,
+				codecId: refusal.codecId,
+				function: refusal.functionName,
+				reason: "generator-unknown"
+			} });
+		}
+		case "generatorNotApplicable": {
+			const { owner, field } = refusal.key;
+			const subject = `Field "${owner.name}.${field}"`;
+			return contractError("CONTRACT.DEFAULT_INVALID", refusal.message !== void 0 ? `${subject}: ${refusal.message}` : `${subject}: ${refusal.functionName}() does not apply to ${refusal.codecId === void 0 ? "the field's type" : `codec "${refusal.codecId}"`}.`, { meta: {
+				modelName: owner.name,
+				fieldName: field,
+				codecId: refusal.codecId,
+				function: refusal.functionName,
+				reason: "generator-not-applicable"
+			} });
+		}
+		case "generatorPhaseSetTwice": return contractError("CONTRACT.DEFAULT_INVALID", `.${refusal.phase}() is called on a field that already generates a value ${refusal.phase === "onCreate" ? "on create" : "on update"}. Set each phase once, and do not combine .${refusal.phase}() with a field preset, type alias or alias constant that sets it.`, { meta: {
+			modelName: refusal.key.owner.name,
+			fieldName: refusal.key.field,
+			reason: "generator-phase-set-twice",
+			phase: refusal.phase
+		} });
+		case "generatedList": return defaultError(refusal.key, "many-with-executionDefaults", "generates a value on write, so it cannot be a list; remove .many().");
+		case "generatedOnVariant": return defaultError(refusal.key, "executionDefaults-on-variant", `has executionDefaults, but "${refusal.key.owner.name}" is a variant of "${refusal.baseModel}". Execution defaults apply to every document in collection "${refusal.collection}", so declare them on the base model.`);
+		case "generatedWithoutCollection": return defaultError(refusal.key, "executionDefaults-without-collection", "has executionDefaults, but its model has no collection. Generated values are only supported on fields of a model stored in a collection.");
+		case "generatedConflict": return defaultError(refusal.key, "executionDefaults-conflict", `has different executionDefaults than "${refusal.otherModel}.${refusal.otherField}", which is stored in the same collection "${refusal.collection}". Use the same executionDefaults on both models.`);
+		case "typeParamsInvalid": return structuredError("CONTRACT.TYPE_PARAMS_INVALID", refusal.problem.message, { meta: {
+			dataType: refusal.problem.dataType,
+			parameters: refusal.problem.parameters,
+			...ownerMetaOf(refusal.key)
+		} });
+		case "enumKeyMismatch": return contractError("CONTRACT.ENUM_INVALID", `enum declaration key "${refusal.key.enumName}" must match enumType name "${refusal.enumName}". Aliases are not supported.`, { meta: {
+			enumName: refusal.enumName,
+			declaredKey: refusal.key.enumName,
+			reason: "declaration-key-mismatch"
+		} });
+		case "enumMemberProblem": return enumMemberError({
+			enumName: refusal.enumName,
+			codecId: refusal.codecId
+		}, refusal.problem, "the field");
+		case "enumUnknown": return contractError("CONTRACT.ENUM_UNKNOWN", `${ownerLabelOf(refusal.key)} references enum "${refusal.enumName}" which is not declared in defineContract({ enums: { ... } }).`, { meta: {
+			...ownerMetaOf(refusal.key),
+			enumName: refusal.enumName
+		} });
+		case "discriminatorValueDuplicate": return contractError("CONTRACT.ARGUMENT_INVALID", `Discriminator value "${refusal.value}" is used by both "${refusal.firstVariant}" and "${refusal.key.variant}" on base model "${refusal.baseModel}".`, { meta: {
+			modelName: refusal.baseModel,
+			value: refusal.value,
+			variants: [refusal.firstVariant, refusal.key.variant],
+			reason: "duplicate-discriminator-value"
+		} });
+		case "discriminatorFieldUnknown": return contractError("CONTRACT.FIELD_UNKNOWN", `Model "${refusal.key.model}" names "${refusal.fieldName}" as its discriminator, but declares no field "${refusal.fieldName}".`, { meta: {
+			modelName: refusal.key.model,
+			fieldName: refusal.fieldName,
+			reason: "discriminator-field-unknown"
+		} });
+		case "discriminatorField": return discriminatorFieldError(refusal);
+		case "discriminatorValue": {
+			const variant = refusal.key.variant;
+			const meta = {
+				modelName: variant,
+				baseModel: refusal.baseModel,
+				fieldName: refusal.fieldName
+			};
+			if (refusal.refusal.kind === "unreadable") return contractError("CONTRACT.ARGUMENT_INVALID", `Variant model "${variant}" has a discriminator value that discriminator field "${refusal.baseModel}.${refusal.fieldName}" cannot hold: ${refusal.refusal.refusal.message}`, { meta: {
+				...meta,
+				reason: "discriminator-value-unreadable"
+			} });
+			return contractError("CONTRACT.ARGUMENT_INVALID", `Variant model "${variant}" has discriminator value ${JSON.stringify(refusal.refusal.stored)}, which is not a member of enum "${refusal.enumName}", the type of discriminator field "${refusal.baseModel}.${refusal.fieldName}". Use one of: ${refusal.refusal.members.map((member) => JSON.stringify(member)).join(", ")}.`, { meta: {
+				...meta,
+				reason: "discriminator-value-not-a-member"
+			} });
+		}
+		case "discriminatorAndBase": return contractError("CONTRACT.ARGUMENT_INVALID", `Model "${refusal.key.model}" has both a discriminator and a base. A model is either a base with variants or a variant of one base.`, { meta: {
+			modelName: refusal.key.model,
+			reason: "discriminator-and-base"
+		} });
+		case "discriminatorWithoutVariants": return contractError("CONTRACT.ARGUMENT_INVALID", `Model "${refusal.key.model}" has a discriminator, but no model names it as its base.`, { meta: {
+			modelName: refusal.key.model,
+			reason: "discriminator-without-variants"
+		} });
+		case "listedVariantMissing": return contractError("CONTRACT.ARGUMENT_INVALID", `Model "${refusal.key.model}" lists variant "${refusal.variant}", but no model "${refusal.variant}" names "${refusal.key.model}" as its base.`, { meta: {
+			modelName: refusal.key.model,
+			variant: refusal.variant,
+			reason: "listed-variant-missing"
+		} });
+		case "baseWithoutDiscriminator": return contractError("CONTRACT.ARGUMENT_INVALID", `Model "${refusal.key.variant}" names "${refusal.baseModel}" as its base, but "${refusal.baseModel}" has no discriminator.`, { meta: {
+			modelName: refusal.key.variant,
+			baseModel: refusal.baseModel,
+			reason: "base-without-discriminator"
+		} });
+		case "baseUnknown": return contractError("CONTRACT.ARGUMENT_INVALID", `Model "${refusal.key.variant}" names "${refusal.baseModel}" as its base, but the contract has no model "${refusal.baseModel}".`, { meta: {
+			modelName: refusal.key.variant,
+			baseModel: refusal.baseModel,
+			reason: "base-unknown"
+		} });
+		case "variantWithoutValue": return contractError("CONTRACT.ARGUMENT_INVALID", `Model "${refusal.key.variant}" names "${refusal.baseModel}" as its base, but "${refusal.baseModel}" lists no discriminator value for it.`, { meta: {
+			modelName: refusal.key.variant,
+			baseModel: refusal.baseModel,
+			reason: "variant-without-value"
+		} });
+		case "validator": return validatorRefusalError(refusal.refusal);
+	}
+}
+/** A builder warning as `defineContract` reports it. */
+function authoringWarningOf(warning) {
+	if (warning.kind === "source") return warning.warning;
+	const item = `field "${warning.key.owner.name}.${warning.key.field}"`;
+	return {
+		code: "PN_PRESET_WITHOUT_EFFECT",
+		message: `Field "${warning.key.owner.name}.${warning.key.field}" uses ${warning.preset}(), which generates no value, so the field is stored like any field of codec "${warning.codecId}".`,
+		item,
+		summary: "fields use a preset that generates no value"
+	};
+}
+function differenceWording(difference) {
+	switch (difference) {
+		case "storedName": return "stored name";
+		case "type": return "type";
+		case "nullable": return "nullability";
+		case "many": return "list shape";
+	}
+}
+const MONGO_RESERVED_HELPER_KEYS = [
+	"field",
+	"gen",
+	"index",
+	"model",
+	"rel",
+	"valueObject"
+];
+function buildFieldPreset(helperPath, descriptor, args) {
+	validateAuthoringHelperArguments(helperPath, descriptor.args, args);
+	const preset = instantiateAuthoringFieldPreset(descriptor, args);
+	const unsupported = [
+		...preset.default !== void 0 ? ["default"] : [],
+		...preset.id ? ["id"] : [],
+		...preset.unique ? ["unique"] : []
+	];
+	if (unsupported.length > 0) throw contractError("CONTRACT.PACK_CONTRIBUTION_INVALID", `Field preset "${helperPath}" contributes ${unsupported.join(", ")}, which Mongo does not support. Mongo supports presets that set a codec and execution defaults only.`, { meta: {
+		helperPath,
+		reason: "preset-contribution-unsupported",
+		contribution: unsupported
+	} });
+	return createFieldBuilder({
+		type: {
+			kind: "scalar",
+			codecId: preset.descriptor.codecId,
+			...normalizeOptionalTypeParams(preset.descriptor.typeParams)
+		},
+		nullable: preset.nullable,
+		many: false
+	}, void 0, preset.executionDefaults, void 0, void 0, {
+		preset: helperPath,
+		executionDefaults: preset.executionDefaults
+	});
+}
+function composeMongoFieldHelpers(fieldNamespace) {
+	const presetHelpers = createFieldHelpersFromNamespace(fieldNamespace, ({ helperPath, descriptor }) => (...args) => buildFieldPreset(helperPath, descriptor, args));
+	const collisions = Object.keys(presetHelpers).filter((name) => Object.hasOwn(field, name));
+	if (collisions.length > 0) throw contractError("CONTRACT.PACK_CONTRIBUTION_INVALID", `Pack-contributed field preset(s) ${collisions.map((c) => `"${c}"`).join(", ")} collide with the built-in Mongo field helper(s) of the same name.`, { meta: {
+		reason: "core-field-helper-collision",
+		contribution: collisions
+	} });
+	return {
+		...field,
+		...presetHelpers
+	};
+}
+function stackLookupsOf(components) {
+	const codecLookup = extractCodecLookup(components);
+	assertTypeAliasesValid(composePackAuthoringNamespace(components, "type"), {
+		generatorFunctions: assembleGeneratorFunctions(components),
+		paramsSchemaOf: (codecId) => codecLookup.descriptorFor(codecId)?.paramsSchema,
+		fieldLength: () => void 0
+	});
+	const { support } = assembleDataTypeSupport(components, (codecId) => codecLookup.descriptorFor(codecId)?.dataType);
+	return {
+		codecLookup,
+		dataTypes: support
+	};
+}
+function composeMongoAuthoringHelpers(family, target, extensions, lookups) {
+	const components = [
+		family,
+		target,
+		...Object.values(extensions ?? {})
+	];
+	const entityNamespace = composePackAuthoringNamespace(components, "entityTypes");
+	const fieldNamespace = composePackAuthoringNamespace(components, "field");
+	assertNoCrossRegistryCollisions({}, fieldNamespace, entityNamespace);
+	const collisions = Object.keys(entityNamespace).filter((name) => MONGO_RESERVED_HELPER_KEYS.includes(name));
+	if (collisions.length > 0) throw contractError("CONTRACT.PACK_CONTRIBUTION_INVALID", `Pack-contributed entity type(s) ${collisions.map((c) => `"${c}"`).join(", ")} collide with the reserved built-in helper key(s) on the Mongo composed helpers surface. Reserved keys: ${MONGO_RESERVED_HELPER_KEYS.map((k) => `"${k}"`).join(", ")}.`, { meta: {
+		reason: "reserved-helper-key-collision",
+		contribution: collisions
+	} });
+	return blindCast({
+		...createEntityHelpersFromNamespace(entityNamespace, { ctx: {
+			family: family.familyId,
+			target: target.targetId,
+			codecLookup: lookups.codecLookup,
+			dataTypes: lookups.dataTypes
+		} }),
+		field: composeMongoFieldHelpers(fieldNamespace),
+		gen: createGeneratorHelpers(components),
+		index,
+		model,
+		rel,
+		valueObject
+	});
+}
+function createFieldBuilder(spec, enumHandle, executionDefaults, storedName, generatorCalls, presetContribution) {
+	function many(options) {
+		return createFieldBuilder({
+			type: spec.type,
+			nullable: spec.nullable,
+			many: { elementNullable: options?.elementsNullable ?? false }
+		}, enumHandle, executionDefaults, storedName, generatorCalls, presetContribution);
+	}
+	function withGeneratorCall(phase, call) {
+		if (generatorCalls?.[phase] !== void 0 || executionDefaults?.[phase] !== void 0) throw contractError("CONTRACT.DEFAULT_INVALID", `.${phase}() is called on a field that already generates a value ${phase === "onCreate" ? "on create" : "on update"}. Set each phase once, and do not combine .${phase}() with a field preset, type alias or alias constant that sets it.`, { meta: {
+			reason: "generator-phase-set-twice",
+			phase
+		} });
+		return createFieldBuilder(spec, enumHandle, blindCast(executionDefaults), storedName, {
+			...generatorCalls,
+			[phase]: call
+		}, presetContribution);
+	}
+	return {
+		__kind: "field",
+		...ifDefined("__executionDefaults", executionDefaults),
+		...ifDefined("__generatorCalls", generatorCalls),
+		...ifDefined("__presetContribution", presetContribution),
+		onCreate: (call) => withGeneratorCall("onCreate", call),
+		onUpdate: (call) => withGeneratorCall("onUpdate", call),
+		__type: spec.type,
+		__nullable: spec.nullable,
+		__many: spec.many,
+		__enumHandle: blindCast(enumHandle),
+		__storedName: blindCast(storedName),
+		optional: () => createFieldBuilder({
+			type: spec.type,
+			nullable: true,
+			many: spec.many
+		}, enumHandle, executionDefaults, storedName, generatorCalls, presetContribution),
+		many: blindCast(many),
+		mongo: ({ field }) => createFieldBuilder(spec, enumHandle, executionDefaults, field, generatorCalls, presetContribution)
+	};
+}
+function normalizeOptionalTypeParams(typeParams) {
+	if (!typeParams) return {};
+	return { typeParams };
+}
+function createScalarFieldBuilder(codecId, options) {
+	return createFieldBuilder({
+		type: blindCast({
+			kind: "scalar",
+			codecId,
+			...normalizeOptionalTypeParams(options?.typeParams)
+		}),
+		nullable: false,
+		many: false
+	});
+}
+function vectorField(options) {
+	return createScalarFieldBuilder("mongo/vector@1", options);
+}
+const field = {
+	scalar: createScalarFieldBuilder,
+	objectId() {
+		return createScalarFieldBuilder("mongo/objectId@1");
+	},
+	string() {
+		return createScalarFieldBuilder("mongo/string@1");
+	},
+	double() {
+		return createScalarFieldBuilder("mongo/double@1");
+	},
+	int32() {
+		return createScalarFieldBuilder("mongo/int32@1");
+	},
+	bool() {
+		return createScalarFieldBuilder("mongo/bool@1");
+	},
+	date() {
+		return createScalarFieldBuilder("mongo/date@1");
+	},
+	int64() {
+		return createScalarFieldBuilder("mongo/int64@1");
+	},
+	int64Number() {
+		return createScalarFieldBuilder("mongo/int64Number@1");
+	},
+	decimal128() {
+		return createScalarFieldBuilder("mongo/decimal128@1");
+	},
+	binary() {
+		return createScalarFieldBuilder("mongo/binary@1");
+	},
+	json() {
+		return createScalarFieldBuilder("mongo/json@1");
+	},
+	bson() {
+		return createScalarFieldBuilder("mongo/bson@1");
+	},
+	vector: vectorField,
+	valueObject(valueObjectName) {
+		return createFieldBuilder({
+			type: blindCast({
+				kind: "valueObject",
+				name: resolveValueObjectName(valueObjectName)
+			}),
+			nullable: false,
+			many: false
+		});
+	},
+	namedType(handle) {
+		return createFieldBuilder({
+			type: blindCast({
+				kind: "scalar",
+				codecId: handle.codecId
+			}),
+			nullable: false,
+			many: false
+		}, handle);
+	}
+};
+function index(fields, options) {
+	return {
+		fields,
+		...options ? { options } : {}
+	};
+}
+function createFieldReference(modelName, fieldName) {
+	return {
+		__kind: "fieldRef",
+		modelName,
+		fieldName
+	};
+}
+function isFieldReference(value) {
+	return typeof value === "object" && value !== null && "__kind" in value && value.__kind === "fieldRef";
+}
+function resolveValueObjectName(value) {
+	return typeof value === "string" ? value : value.__name;
+}
+function normalizeStringList(value) {
+	return typeof value === "string" ? [value] : [...value];
+}
+function normalizeTargetField(targetModelName, value) {
+	if (!isFieldReference(value)) return value;
+	if (value.modelName !== targetModelName) throw contractError("CONTRACT.RELATION_INVALID", `Relation target "${targetModelName}" cannot reference field "${value.modelName}.${value.fieldName}".`, { meta: {
+		modelName: targetModelName,
+		reason: "cross-model-field-reference",
+		referencedModel: value.modelName,
+		referencedField: value.fieldName
+	} });
+	return value.fieldName;
+}
+function normalizeTargetFields(targetModelName, value) {
+	if (typeof value === "string") return [value];
+	if (isFieldReference(value)) return [normalizeTargetField(targetModelName, value)];
+	return value.map((entry) => normalizeTargetField(targetModelName, entry));
+}
+function createRelationBuilder(spec) {
+	return {
+		__kind: "relation",
+		__to: spec.to,
+		__cardinality: spec.cardinality,
+		__on: spec.on,
+		__nullable: spec.nullable
+	};
+}
+function createReferenceRelationBuilder(target, cardinality, options, nullable) {
+	const targetModelName = resolveModelName(target);
+	return createRelationBuilder({
+		to: blindCast(targetModelName),
+		cardinality,
+		on: {
+			localFields: blindCast(normalizeStringList(options.from)),
+			targetFields: blindCast(normalizeTargetFields(targetModelName, options.to))
+		},
+		nullable
+	});
+}
+function createEmbedRelationBuilder(target, cardinality) {
+	return createRelationBuilder({
+		to: blindCast(resolveModelName(target)),
+		cardinality,
+		on: void 0,
+		nullable: void 0
+	});
+}
+function hasOne(target, options) {
+	if (!options) return createEmbedRelationBuilder(target, "1:1");
+	return createReferenceRelationBuilder(target, "1:1", options, true);
+}
+function hasMany(target, options) {
+	if (!options) return createEmbedRelationBuilder(target, "1:N");
+	return createReferenceRelationBuilder(target, "1:N", options, void 0);
+}
+function belongsTo(target, options) {
+	return createReferenceRelationBuilder(target, "N:1", options, options.optional);
+}
+const rel = {
+	belongsTo,
+	hasMany,
+	hasOne
+};
+function valueObject(name, input) {
+	return {
+		__kind: "valueObject",
+		__name: name,
+		__fields: input.fields
+	};
+}
+function model(name, input) {
+	return {
+		__kind: "model",
+		__name: name,
+		__fields: input.fields,
+		__relations: blindCast(input.relations ?? {}),
+		__indexes: input.indexes,
+		__collectionOptions: input.collectionOptions,
+		__controlPolicy: input.controlPolicy,
+		__collection: blindCast(input.collection),
+		__owner: blindCast(input.owner ? resolveModelName(input.owner) : void 0),
+		__base: blindCast(input.base ? resolveModelName(input.base) : void 0),
+		__storageRelations: blindCast(input.storageRelations),
+		__discriminator: blindCast(input.discriminator ? { field: input.discriminator.field } : void 0),
+		__variants: blindCast(input.discriminator?.variants),
+		ref(fieldName) {
+			return createFieldReference(name, fieldName);
+		}
+	};
+}
+function isContractScaffold(value) {
+	if (typeof value !== "object" || value === null) return false;
+	return "family" in value && "target" in value;
+}
+function buildContractFromDsl(input, lookups) {
+	const definition = buildContractDefinition(input);
+	const { codecLookup, dataTypes } = lookups ?? stackLookupsOf([
+		input.family,
+		input.target,
+		...Object.values(input.extensions ?? {})
+	]);
+	const built = buildMongoContractFromDefinition(definition, codecLookup, dataTypes);
+	flushAuthoringWarnings((built.ok ? built.value.warnings : built.failure.warnings).map(authoringWarningOf));
+	if (!built.ok) {
+		const [first] = built.failure.refusals;
+		assertDefined(first, "a refused build has at least one refusal");
+		throw refusalError(first);
+	}
+	return blindCast(built.value.contract);
+}
+/** Implementation. */
+function buildBoundContract(family, target, definition, factory) {
+	const full = {
+		...definition,
+		family,
+		target
+	};
+	if (factory !== void 0) {
+		const lookups = stackLookupsOf([
+			family,
+			target,
+			...Object.values(definition.extensions ?? {})
+		]);
+		const built = factory(composeMongoAuthoringHelpers(family, target, definition.extensions, lookups));
+		return buildContractFromDsl({
+			...full,
+			...ifDefined("models", built.models),
+			...ifDefined("valueObjects", built.valueObjects),
+			...ifDefined("roots", built.roots)
+		}, lookups);
+	}
+	return buildContractFromDsl(full);
+}
+function defineContract(definition, factory) {
+	if (!isContractScaffold(definition)) throw contractError("CONTRACT.ARGUMENT_INVALID", "defineContract expects a contract definition object. Define your contract with defineContract({ family, target, models, ... }).");
+	if (factory !== void 0) return buildBoundContract(definition.family, definition.target, definition, factory);
+	return buildBoundContract(definition.family, definition.target, definition);
+}
+//#endregion
+export { enumType$1 as a, isEnumTypeHandle as c, rel as d, valueObject as f, defineContract as i, member as l, buildBoundContract as n, field as o, buildMongoContractFromDefinition as r, index as s, bindEnumType as t, model as u };
+
+//# sourceMappingURL=contract-builder-d5cf-u9p.mjs.map