@prisma/orm-family-mongo 0.16.0-dev.36

package/dist/contract-builder-BFq0gOMV.mjs

@@ -0,0 +1,634 @@
+import { i as MongoCollectionOptions, o as MongoIndex } from "./entity-kinds-B4KNTF8z-DPIuUuuB.mjs";
+import { a as applyPolymorphicScopeToMongoIndex, r as MongoStorage, s as buildMongoNamespace } from "./dist-DHrEJnhK.mjs";
+import { t as mongoContractCanonicalizationHooks } from "./canonicalization-hooks-DF3Z6sjO.mjs";
+import { t as contractError } from "./contract-errors-BCN6RVI5-kMurtAbI.mjs";
+import { crossRef } from "@prisma/orm-framework/contract/types";
+import { UNBOUND_NAMESPACE_ID } from "@prisma/orm-framework/components/ir";
+import { blindCast } from "@prisma/orm-framework/utils/casts";
+import { computeProfileHash, computeStorageHash } from "@prisma/orm-framework/contract/hashing";
+import { errorEnumCodecNotInPackStack } from "@prisma/orm-framework/errors/control";
+import { assertNoCrossRegistryCollisions, mergeAuthoringNamespaces } from "@prisma/orm-framework/components/authoring";
+import { ifDefined } from "@prisma/orm-framework/utils/defined";
+import { bindEnumType, createEntityHelpersFromNamespace, enumType, isEnumTypeHandle, member } from "@prisma/orm-framework/contract-authoring";
+import { extractCodecLookup } from "@prisma/orm-framework/components/control";
+import { canonicalStringify } from "@prisma/orm-framework/utils/canonical-stringify";
+//#region ../../../2-mongo-family/2-authoring/contract-ts/dist/contract-builder.mjs
+/**
+* Encode an authored enum value to its codec-encoded JSON form, mirroring SQL's `build-contract`.
+*
+* The codec is resolved by id from the lookup built from the contract's target pack, so a
+* non-identity `encodeJson` (permitted by the `mongoCodec` factory) is respected. A codecId the
+* lookup cannot resolve is a hard error: the enum uses a codec that is not part of the contract's
+* pack stack.
+*/
+function encodeEnumValue(value, codecId, codecLookup) {
+	const codec = codecLookup.get(codecId);
+	if (!codec) throw errorEnumCodecNotInPackStack({ codecId });
+	return codec.encodeJson(value);
+}
+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 extractEntitiesNamespace(component) {
+	return component.authoring?.entityTypes ?? {};
+}
+const MONGO_RESERVED_HELPER_KEYS = [
+	"field",
+	"index",
+	"model",
+	"rel",
+	"valueObject"
+];
+function composeMongoEntityHelpers(family, target, extensions) {
+	const components = [
+		family,
+		target,
+		...Object.values(extensions ?? {})
+	];
+	const merged = {};
+	for (const component of components) {
+		const ns = extractEntitiesNamespace(component);
+		if (Object.keys(ns).length > 0) mergeAuthoringNamespaces(merged, ns, [], "entity", "entity");
+	}
+	assertNoCrossRegistryCollisions({}, {}, merged);
+	const collisions = Object.keys(merged).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 createEntityHelpersFromNamespace(merged, { ctx: {
+		family: family.familyId,
+		target: target.targetId
+	} });
+}
+function createFieldBuilder(spec, enumHandle) {
+	return {
+		__kind: "field",
+		__type: spec.type,
+		__nullable: spec.nullable,
+		__many: spec.many,
+		__enumHandle: blindCast(enumHandle),
+		optional() {
+			return createFieldBuilder({
+				type: spec.type,
+				nullable: true,
+				many: spec.many
+			}, enumHandle);
+		},
+		many() {
+			return createFieldBuilder({
+				type: spec.type,
+				nullable: spec.nullable,
+				many: true
+			}, enumHandle);
+		}
+	};
+}
+function normalizeOptionalTypeParams(typeParams) {
+	if (!typeParams) return {};
+	return { typeParams };
+}
+function createScalarFieldBuilder(codecId, options) {
+	return createFieldBuilder({
+		type: {
+			kind: "scalar",
+			codecId,
+			...normalizeOptionalTypeParams(options?.typeParams)
+		},
+		nullable: false,
+		many: false
+	});
+}
+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");
+	},
+	vector(options) {
+		return createScalarFieldBuilder("mongo/vector@1", options);
+	},
+	valueObject(valueObjectName) {
+		return createFieldBuilder({
+			type: {
+				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 resolveModelName(value) {
+	return typeof value === "string" ? value : value.__name;
+}
+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
+	};
+}
+function createReferenceRelationBuilder(target, cardinality, options) {
+	const targetModelName = resolveModelName(target);
+	return createRelationBuilder({
+		to: targetModelName,
+		cardinality,
+		on: {
+			localFields: normalizeStringList(options.from),
+			targetFields: normalizeTargetFields(targetModelName, options.to)
+		}
+	});
+}
+function createEmbedRelationBuilder(target, cardinality) {
+	return createRelationBuilder({
+		to: resolveModelName(target),
+		cardinality,
+		on: void 0
+	});
+}
+function hasOne(target, options) {
+	if (!options) return createEmbedRelationBuilder(target, "1:1");
+	return createReferenceRelationBuilder(target, "1:1", options);
+}
+function hasMany(target, options) {
+	if (!options) return createEmbedRelationBuilder(target, "1:N");
+	return createReferenceRelationBuilder(target, "1:N", options);
+}
+function belongsTo(target, options) {
+	return createReferenceRelationBuilder(target, "N:1", options);
+}
+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: input.relations ?? {},
+		__indexes: input.indexes,
+		__collectionOptions: input.collectionOptions,
+		__controlPolicy: input.controlPolicy,
+		__collection: input.collection,
+		__owner: input.owner ? resolveModelName(input.owner) : void 0,
+		__base: input.base ? resolveModelName(input.base) : void 0,
+		__storageRelations: input.storageRelations,
+		__discriminator: input.discriminator ? { field: input.discriminator.field } : void 0,
+		__variants: input.discriminator?.variants,
+		ref(fieldName) {
+			return createFieldReference(name, fieldName);
+		}
+	};
+}
+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) {
+	if (!extensions) return;
+	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 isContractScaffold(value) {
+	if (typeof value !== "object" || value === null) return false;
+	return "family" in value && "target" in value;
+}
+function buildContractField(builder) {
+	const valueSet = builder.__enumHandle ? {
+		plane: "domain",
+		entityKind: "enum",
+		namespaceId: UNBOUND_NAMESPACE_ID,
+		entityName: builder.__enumHandle.enumName
+	} : void 0;
+	return builder.__many ? {
+		type: builder.__type,
+		nullable: builder.__nullable,
+		many: true,
+		...ifDefined("valueSet", valueSet)
+	} : {
+		type: builder.__type,
+		nullable: builder.__nullable,
+		...ifDefined("valueSet", valueSet)
+	};
+}
+function buildFields(fields) {
+	const builtFields = {};
+	for (const [fieldName, fieldBuilder] of Object.entries(fields)) builtFields[fieldName] = buildContractField(fieldBuilder);
+	return builtFields;
+}
+function buildRelation(relationBuilder) {
+	const to = crossRef(relationBuilder.__to, UNBOUND_NAMESPACE_ID);
+	return relationBuilder.__on ? {
+		to,
+		cardinality: relationBuilder.__cardinality,
+		on: relationBuilder.__on
+	} : {
+		to,
+		cardinality: relationBuilder.__cardinality
+	};
+}
+function buildRelations(relations) {
+	const builtRelations = {};
+	for (const [relationName, relationBuilder] of Object.entries(relations)) builtRelations[relationName] = buildRelation(relationBuilder);
+	return builtRelations;
+}
+function buildValueObjects(valueObjects) {
+	const builtValueObjects = {};
+	for (const valueObjectBuilder of Object.values(valueObjects ?? {})) {
+		if (valueObjectBuilder.__name in builtValueObjects) throw contractError("CONTRACT.NAME_DUPLICATE", `Duplicate value object name "${valueObjectBuilder.__name}" in defineContract().`, { meta: {
+			kind: "valueObject",
+			name: valueObjectBuilder.__name
+		} });
+		builtValueObjects[valueObjectBuilder.__name] = { fields: buildFields(valueObjectBuilder.__fields) };
+	}
+	return builtValueObjects;
+}
+function buildModels(models) {
+	const builtModels = {};
+	for (const modelBuilder of Object.values(models ?? {})) {
+		if (modelBuilder.__name in builtModels) throw contractError("CONTRACT.NAME_DUPLICATE", `Duplicate model name "${modelBuilder.__name}" in defineContract().`, { meta: {
+			kind: "model",
+			name: modelBuilder.__name
+		} });
+		const storage = {
+			...modelBuilder.__collection ? { collection: modelBuilder.__collection } : {},
+			...modelBuilder.__storageRelations ? { relations: modelBuilder.__storageRelations } : {}
+		};
+		builtModels[modelBuilder.__name] = {
+			fields: buildFields(modelBuilder.__fields),
+			relations: buildRelations(modelBuilder.__relations),
+			storage,
+			...modelBuilder.__owner ? { owner: modelBuilder.__owner } : {},
+			...modelBuilder.__base ? { base: crossRef(modelBuilder.__base, UNBOUND_NAMESPACE_ID) } : {},
+			...modelBuilder.__discriminator ? { discriminator: modelBuilder.__discriminator } : {},
+			...modelBuilder.__variants ? { variants: modelBuilder.__variants } : {}
+		};
+	}
+	return builtModels;
+}
+function deriveRoots(models) {
+	const roots = {};
+	for (const modelBuilder of Object.values(models ?? {})) {
+		if (!modelBuilder.__collection || modelBuilder.__owner || modelBuilder.__base) continue;
+		roots[modelBuilder.__collection] = crossRef(modelBuilder.__name, UNBOUND_NAMESPACE_ID);
+	}
+	return roots;
+}
+function normalizeRoots(roots) {
+	const normalizedRoots = {};
+	for (const [rootName, rootValue] of Object.entries(roots ?? {})) normalizedRoots[rootName] = crossRef(resolveModelName(rootValue), UNBOUND_NAMESPACE_ID);
+	return normalizedRoots;
+}
+function toStorageIndex(index) {
+	const input = { keys: Object.entries(index.fields).map(([field, direction]) => ({
+		field,
+		direction
+	})) };
+	if (index.options) {
+		for (const [key, value] of Object.entries(index.options)) if (value !== void 0) input[key] = value;
+	}
+	return new MongoIndex(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, modelFields) {
+	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 (!Object.hasOwn(modelFields, lookupName)) return lookupName;
+	}
+}
+function resolveVariantScope(modelBuilder, modelsByName) {
+	if (!modelBuilder.__base) return void 0;
+	const baseBuilder = modelsByName[modelBuilder.__base];
+	if (!baseBuilder) return void 0;
+	const discriminatorField = baseBuilder.__discriminator?.field;
+	const variantValue = baseBuilder.__variants?.[modelBuilder.__name]?.value;
+	if (!discriminatorField || variantValue === void 0) return void 0;
+	return {
+		discriminatorField,
+		discriminatorValue: variantValue
+	};
+}
+function scopeVariantIndex(storageIndex, scope, variantName, authoredIndex) {
+	const result = applyPolymorphicScopeToMongoIndex(storageIndex, scope);
+	if (result.kind === "conflict") {
+		const indexLabel = authoredIndex ? canonicalStringify(authoredIndex) : "<unknown>";
+		throw contractError("CONTRACT.INDEX_INVALID", `Variant model "${variantName}" index ${indexLabel} conflicts with discriminator scope: ${result.reason}`, { meta: {
+			variantName,
+			indexLabel,
+			reason: result.reason
+		} });
+	}
+	return result.index;
+}
+function buildCollections(models) {
+	const intermediate = {};
+	const declaredIndexOwners = /* @__PURE__ */ new Map();
+	const modelMap = models ?? {};
+	const modelsByName = {};
+	for (const builder of Object.values(modelMap)) modelsByName[builder.__name] = builder;
+	for (const modelBuilder of Object.values(modelMap)) {
+		if (!modelBuilder.__collection) {
+			if (modelBuilder.__indexes && modelBuilder.__indexes.length > 0) throw contractError("CONTRACT.COLLECTION_INVALID", `Model "${modelBuilder.__name}" defines indexes but has no collection to attach them to.`, { meta: {
+				modelName: modelBuilder.__name,
+				reason: "indexes-without-collection"
+			} });
+			if (modelBuilder.__collectionOptions) throw contractError("CONTRACT.COLLECTION_INVALID", `Model "${modelBuilder.__name}" defines collectionOptions but has no collection to attach them to.`, { meta: {
+				modelName: modelBuilder.__name,
+				reason: "collectionOptions-without-collection"
+			} });
+			if (modelBuilder.__controlPolicy) throw contractError("CONTRACT.COLLECTION_INVALID", `Model "${modelBuilder.__name}" defines controlPolicy but has no collection to attach it to.`, { meta: {
+				modelName: modelBuilder.__name,
+				reason: "controlPolicy-without-collection"
+			} });
+			continue;
+		}
+		const existingCollection = intermediate[modelBuilder.__collection] ?? {};
+		const existingIndexes = existingCollection.indexes ?? [];
+		if (existingCollection.options && modelBuilder.__collectionOptions) throw contractError("CONTRACT.COLLECTION_INVALID", `Collection "${modelBuilder.__collection}" has collectionOptions declared by multiple models. Author collectionOptions on a single model per collection.`, { meta: {
+			modelName: modelBuilder.__name,
+			collection: modelBuilder.__collection,
+			reason: "collectionOptions-declared-by-multiple-models"
+		} });
+		if (existingCollection.control !== void 0 && modelBuilder.__controlPolicy) throw contractError("CONTRACT.COLLECTION_INVALID", `Collection "${modelBuilder.__collection}" has controlPolicy declared by multiple models. Author controlPolicy on a single model per collection.`, { meta: {
+			modelName: modelBuilder.__name,
+			collection: modelBuilder.__collection,
+			reason: "controlPolicy-declared-by-multiple-models"
+		} });
+		for (const collectionIndex of modelBuilder.__indexes ?? []) {
+			const missingField = findMissingIndexField(collectionIndex, modelBuilder.__fields);
+			if (missingField !== void 0) {
+				const indexSignature = canonicalStringify(collectionIndex);
+				throw contractError("CONTRACT.FIELD_UNKNOWN", `Model "${modelBuilder.__name}" index ${indexSignature} references unknown field "${missingField}".`, { meta: {
+					modelName: modelBuilder.__name,
+					fieldName: missingField,
+					indexSignature
+				} });
+			}
+		}
+		const polymorphicScope = resolveVariantScope(modelBuilder, modelsByName);
+		const rawStorageIndexes = (modelBuilder.__indexes ?? []).map(toStorageIndex);
+		const storageIndexes = polymorphicScope ? rawStorageIndexes.map((idx, i) => scopeVariantIndex(idx, polymorphicScope, modelBuilder.__name, modelBuilder.__indexes?.[i])) : rawStorageIndexes;
+		for (let i = 0; i < storageIndexes.length; i++) {
+			const storageIndex = storageIndexes[i];
+			if (storageIndex === void 0) continue;
+			const indexSignature = stableStringify(storageIndex);
+			const collectionIndexKey = `${modelBuilder.__collection}:${indexSignature}`;
+			const firstOwner = declaredIndexOwners.get(collectionIndexKey);
+			if (firstOwner) {
+				const authoredIndex = modelBuilder.__indexes?.[i];
+				const reportedSignature = authoredIndex ? canonicalStringify(authoredIndex) : indexSignature;
+				throw contractError("CONTRACT.NAME_DUPLICATE", `Collection "${modelBuilder.__collection}" defines duplicate index ${reportedSignature}. First declared on model "${firstOwner}" and duplicated on model "${modelBuilder.__name}".`, { meta: {
+					kind: "index",
+					name: reportedSignature,
+					collection: modelBuilder.__collection,
+					first: firstOwner,
+					second: modelBuilder.__name
+				} });
+			}
+			declaredIndexOwners.set(collectionIndexKey, modelBuilder.__name);
+		}
+		const storageOptions = modelBuilder.__collectionOptions ? toStorageCollectionOptions(modelBuilder.__collectionOptions) : void 0;
+		const controlPatch = modelBuilder.__controlPolicy !== void 0 ? { control: modelBuilder.__controlPolicy } : {};
+		intermediate[modelBuilder.__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;
+}
+function buildContractFromDefinition(definition) {
+	validateTargetPackRef(definition.family, definition.target);
+	validateExtensionPackRefs(definition.target, definition.extensions);
+	const builtModels = buildModels(definition.models);
+	const builtValueObjects = buildValueObjects(definition.valueObjects);
+	const roots = definition.roots ? normalizeRoots(definition.roots) : deriveRoots(definition.models);
+	const capabilities = {};
+	const collections = buildCollections(definition.models);
+	const codecLookup = extractCodecLookup([definition.target]);
+	const storageValueSets = {};
+	for (const [enumName, handle] of Object.entries(definition.enums ?? {})) storageValueSets[enumName] = {
+		kind: "valueSet",
+		values: handle.values.map((v) => encodeEnumValue(v, handle.codecId, codecLookup))
+	};
+	const unboundNamespace = buildMongoNamespace({
+		id: UNBOUND_NAMESPACE_ID,
+		entries: {
+			collection: collections,
+			...ifDefined("valueSet", Object.keys(storageValueSets).length > 0 ? storageValueSets : void 0)
+		}
+	});
+	const storageBody = { namespaces: { [UNBOUND_NAMESPACE_ID]: {
+		id: UNBOUND_NAMESPACE_ID,
+		collections: unboundNamespace.entries.collection,
+		...ifDefined("valueSet", unboundNamespace.entries.valueSet)
+	} } };
+	const storage = new MongoStorage({
+		storageHash: computeStorageHash({
+			target: definition.target.targetId,
+			targetFamily: definition.family.familyId,
+			storage: storageBody,
+			...mongoContractCanonicalizationHooks
+		}),
+		namespaces: { [UNBOUND_NAMESPACE_ID]: unboundNamespace }
+	});
+	const builtEnums = {};
+	for (const [enumName, handle] of Object.entries(definition.enums ?? {})) {
+		if (enumName !== handle.enumName) throw contractError("CONTRACT.ENUM_INVALID", `enum declaration key "${enumName}" must match enumType name "${handle.enumName}". Aliases are not supported.`, { meta: {
+			enumName: handle.enumName,
+			declaredKey: enumName,
+			reason: "declaration-key-mismatch"
+		} });
+		builtEnums[enumName] = {
+			codecId: handle.codecId,
+			members: handle.enumMembers.map((m) => ({
+				name: m.name,
+				value: encodeEnumValue(m.value, handle.codecId, codecLookup)
+			}))
+		};
+	}
+	const hasEnums = Object.keys(builtEnums).length > 0;
+	for (const [modelName, modelBuilder] of Object.entries(definition.models ?? {})) for (const [fieldName, fieldBuilder] of Object.entries(modelBuilder.__fields)) {
+		const handle = fieldBuilder.__enumHandle;
+		if (handle && !(handle.enumName in builtEnums)) throw contractError("CONTRACT.ENUM_UNKNOWN", `Model "${modelName}" field "${fieldName}" references enum "${handle.enumName}" which is not declared in defineContract({ enums: { ... } }).`, { meta: {
+			modelName,
+			fieldName,
+			enumName: handle.enumName
+		} });
+	}
+	return blindCast({
+		target: definition.target.targetId,
+		targetFamily: definition.family.familyId,
+		...ifDefined("defaultControlPolicy", definition.defaultControlPolicy),
+		roots,
+		domain: { namespaces: { [UNBOUND_NAMESPACE_ID]: {
+			models: builtModels,
+			...Object.keys(builtValueObjects).length > 0 ? { valueObjects: builtValueObjects } : {},
+			...hasEnums ? { enum: builtEnums } : {}
+		} } },
+		storage,
+		capabilities,
+		extensions: definition.extensions ?? {},
+		profileHash: computeProfileHash({
+			target: definition.target.targetId,
+			targetFamily: definition.family.familyId,
+			capabilities
+		}),
+		meta: {}
+	});
+}
+/** Implementation. */
+function buildBoundContract(family, target, definition, factory) {
+	const full = {
+		...definition,
+		family,
+		target
+	};
+	if (factory !== void 0) {
+		const built = factory({
+			...composeMongoEntityHelpers(family, target, definition.extensions),
+			field,
+			index,
+			model,
+			rel,
+			valueObject
+		});
+		return buildContractFromDefinition({
+			...full,
+			...ifDefined("models", built.models),
+			...ifDefined("valueObjects", built.valueObjects),
+			...ifDefined("roots", built.roots)
+		});
+	}
+	return buildContractFromDefinition(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 { field as a, member as c, valueObject as d, enumType as i, model as l, buildBoundContract as n, index as o, defineContract as r, isEnumTypeHandle as s, bindEnumType as t, rel as u };
+
+//# sourceMappingURL=contract-builder-BFq0gOMV.mjs.map