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

package/dist/{contract-builder-ClL-xMK2.d.mts → contract-builder-lqaM5w74.d.mts}

@@ -1,101 +1,410 @@
-import { E as MongoIndexAuthoringInput, F as MongoIndexOptionsInput, G as MongoStorageShape, O as MongoIndexFields, Y as MongoTypeMaps, v as MongoCollection, w as MongoContractWithTypeMaps, x as MongoCollectionOptionsAuthoringInput } from "./mongo-value-set-DEd7WLCT-B2Ar2GkJ.mjs";
-import "./index-YY1SU_7o.mjs";
+import { C as MongoContract, D as MongoIndexFieldValue, E as MongoIndexAuthoringInput, F as MongoIndexOptionsInput, J as MongoTypeMaps, O as MongoIndexFields, W as MongoStorageShape, v as MongoCollection, w as MongoContractWithTypeMaps, x as MongoCollectionOptionsAuthoringInput } from "./mongo-value-set-BkGaKhbE-86TPJ91m.mjs";
+import { l as MongoContractRefusal, o as FieldOwner } from "./index-CQ1JuHm5.mjs";
 import { r as BsonValue, t as BsonInputValue } from "./index-9DDQlC5U.mjs";
+import { CodecLookupWithDescriptors, DataTypeParamsProblem } from "@prisma/orm-framework/components/codec";
 import { UNBOUND_NAMESPACE_ID } from "@prisma/orm-framework/components/ir";
-import { ContractExecutionSection, ContractFieldType, ControlPolicy, CrossReference, EnumMemberValueType, ExecutionHashBase, ExecutionMutationDefault, ExecutionMutationDefaultPhases, ExecutionMutationDefaultValue, FieldTypesFromDomain, JsonValue, ProfileHashBase, StorageHashBase } from "@prisma/orm-framework/contract/types";
+import { ContractExecutionSection, ContractField, ContractFieldType, ControlPolicy, CrossReference, EnumMemberValueType, ExecutionHashBase, ExecutionMutationDefault, ExecutionMutationDefaultPhases, ExecutionMutationDefaultValue, FieldTypesFromDomain, JsonValue, ProfileHashBase, StorageHashBase } from "@prisma/orm-framework/contract/types";
+import { Result } from "@prisma/orm-framework/utils/result";
 import { BoundEnumType, CodecTypeMap, EntityHelpersFromNamespace, EnumMember, EnumTypeHandle, ExtractAuthoringNamespaceFromPack, ExtractParameterizedOutputTypesFromPack, MergeExtensionAuthoringNamespaces, ResolveTemplateValue, TupleFromArgumentDescriptors, bindEnumType, enumType as enumType$1, isEnumTypeHandle, member } from "@prisma/orm-framework/contract-authoring";
-import { AuthoringArgumentDescriptor, AuthoringFieldPresetDescriptor } from "@prisma/orm-framework/components/authoring";
+import { AuthoringArgumentDescriptor, AuthoringFieldPresetDescriptor, AuthoringWarning, DataTypeSupport, DiscriminatorFieldRefusal, DiscriminatorVariantRefusal, EnumMemberProblem, WrittenValue } from "@prisma/orm-framework/components/authoring";
 import { ExtensionPackRef, ExtensionPackValues, FamilyPackRef, GeneratorFunctionCall, GeneratorHelpersOf, GeneratorPhase, TargetPackRef } from "@prisma/orm-framework/components/components";
 //#region ../../../2-mongo-family/2-authoring/contract-ts/dist/contract-builder.d.mts
-//#region src/contract-builder.d.ts
+//#region src/build-refusals.d.ts
+/** The part of a definition a refusal is about, by names and positions the definition carries. */
+type RefusalKey = {
+  readonly kind: 'model';
+  readonly model: string;
+} | {
+  readonly kind: 'valueObject';
+  readonly valueObject: string;
+} | {
+  readonly kind: 'field';
+  readonly owner: FieldOwner;
+  readonly field: string;
+} | {
+  readonly kind: 'enum';
+  readonly enumName: string;
+} | {
+  readonly kind: 'enumMember';
+  readonly enumName: string;
+  readonly member: string;
+} |
+/** `position` counts the model's own indexes, in the order the definition lists them. */
+{
+  readonly kind: 'index';
+  readonly model: string;
+  readonly position: number;
+} | {
+  readonly kind: 'relation';
+  readonly model: string;
+  readonly relation: string;
+} |
+/** The base model's discriminator. */
+{
+  readonly kind: 'discriminator';
+  readonly model: string;
+} |
+/** The variant's base and its discriminator value. */
+{
+  readonly kind: 'base';
+  readonly variant: string;
+} |
+/** The collection settings of the model that declares them. */
+{
+  readonly kind: 'collectionSettings';
+  readonly model: string;
+};
+type ModelKey$1 = Extract<RefusalKey, {
+  readonly kind: 'model';
+}>;
+type ValueObjectKey = Extract<RefusalKey, {
+  readonly kind: 'valueObject';
+}>;
+type FieldKey = Extract<RefusalKey, {
+  readonly kind: 'field';
+}>;
+type EnumKey = Extract<RefusalKey, {
+  readonly kind: 'enum';
+}>;
+type IndexKey = Extract<RefusalKey, {
+  readonly kind: 'index';
+}>;
+type RelationKey = Extract<RefusalKey, {
+  readonly kind: 'relation';
+}>;
+type DiscriminatorKey = Extract<RefusalKey, {
+  readonly kind: 'discriminator';
+}>;
+type BaseKey = Extract<RefusalKey, {
+  readonly kind: 'base';
+}>;
+type CollectionSettingsKey = Extract<RefusalKey, {
+  readonly kind: 'collectionSettings';
+}>;
+/** What a variant's restatement of a base field changes, which the collection's validator, written from the base, would refuse. */
+type RestatedFieldDifference = 'storedName' | 'type' | 'nullable' | 'many';
+type CollectionSetting = 'indexes' | 'collectionOptions' | 'controlPolicy';
+type IndexShapeRule = 'unique-wildcard' | 'wildcard-with-type' | 'hashed-several-fields' | 'ttl-with-wildcard' | 'projection-without-wildcard' | 'collation-without-locale' | 'second-text-index';
+/** Why the builder refuses part of a definition, keyed by the part. Each source words the refusal itself. */
+type BuildRefusal = {
+  readonly kind: 'duplicateModel';
+  readonly key: ModelKey$1;
+} | {
+  readonly kind: 'duplicateValueObject';
+  readonly key: ValueObjectKey;
+} | {
+  readonly kind: 'storedNameUnsupported';
+  readonly key: FieldKey;
+  readonly reason: string;
+} | {
+  readonly kind: 'storedNameDuplicate';
+  readonly key: FieldKey;
+  readonly storedName: string;
+  readonly firstField: string;
+} | {
+  readonly kind: 'storedNameSharedWithBase';
+  readonly key: FieldKey;
+  readonly storedName: string;
+  readonly baseModel: string;
+  readonly baseField: string;
+} | {
+  readonly kind: 'restatedBaseFieldDiffers';
+  readonly key: FieldKey;
+  readonly baseModel: string;
+  readonly differences: readonly RestatedFieldDifference[];
+} | {
+  readonly kind: 'valueObjectFieldStoredName';
+  readonly key: FieldKey;
+} | {
+  readonly kind: 'relationLocalFieldUnknown';
+  readonly key: RelationKey;
+  readonly fieldName: string;
+} | {
+  readonly kind: 'relationNullability';
+  readonly key: RelationKey;
+  readonly ownsForeignKey: boolean;
+  readonly contradiction: 'declared-optional' | 'declared-required';
+} | {
+  readonly kind: 'collectionSettingWithoutCollection';
+  readonly key: CollectionSettingsKey;
+  readonly setting: CollectionSetting;
+} | {
+  readonly kind: 'collectionSettingTwice';
+  readonly key: CollectionSettingsKey;
+  readonly setting: Exclude<CollectionSetting, 'indexes'>;
+  readonly collection: string;
+} | {
+  readonly kind: 'variantCollectionDiffers';
+  readonly key: CollectionSettingsKey;
+  readonly collection: string;
+  readonly baseModel: string;
+  readonly baseCollection: string;
+} | {
+  readonly kind: 'indexFieldUnknown';
+  readonly key: IndexKey;
+  readonly fieldName: string;
+  readonly signature: string;
+} | {
+  readonly kind: 'indexShape';
+  readonly key: IndexKey;
+  readonly rule: IndexShapeRule;
+  readonly signature: string;
+} | {
+  readonly kind: 'indexScopeConflict';
+  readonly key: IndexKey;
+  readonly reason: string;
+  readonly signature: string;
+} | {
+  readonly kind: 'indexDuplicate';
+  readonly key: IndexKey;
+  readonly collection: string;
+  readonly firstModel: string;
+  readonly signature: string;
+} | {
+  readonly kind: 'generatedOnValueObject';
+  readonly key: FieldKey;
+} | {
+  readonly kind: 'generatorUnknown';
+  readonly key: FieldKey;
+  readonly phase: GeneratorPhase;
+  readonly functionName: string;
+  readonly codecId: string | undefined;
+} | {
+  readonly kind: 'generatorNotApplicable';
+  readonly key: FieldKey;
+  readonly phase: GeneratorPhase;
+  readonly functionName: string;
+  readonly codecId: string | undefined;
+  /** The generator's own reason, when it refuses the field rather than not applying to its codec. */
+  readonly message: string | undefined;
+} | {
+  readonly kind: 'generatorPhaseSetTwice';
+  readonly key: FieldKey;
+  readonly phase: GeneratorPhase;
+} | {
+  readonly kind: 'generatedList';
+  readonly key: FieldKey;
+} | {
+  readonly kind: 'generatedOnVariant';
+  readonly key: FieldKey;
+  readonly baseModel: string;
+  readonly collection: string | undefined;
+} | {
+  readonly kind: 'generatedWithoutCollection';
+  readonly key: FieldKey;
+} | {
+  readonly kind: 'generatedConflict';
+  readonly key: FieldKey;
+  readonly otherModel: string;
+  readonly otherField: string;
+  readonly collection: string;
+} | {
+  readonly kind: 'typeParamsInvalid';
+  readonly key: FieldKey;
+  readonly problem: DataTypeParamsProblem;
+} | {
+  readonly kind: 'enumKeyMismatch';
+  readonly key: EnumKey;
+  readonly enumName: string;
+} | {
+  readonly kind: 'enumMemberProblem';
+  readonly key: EnumKey | Extract<RefusalKey, {
+    readonly kind: 'enumMember';
+  }>;
+  readonly enumName: string;
+  readonly codecId: string;
+  readonly problem: EnumMemberProblem;
+} | {
+  readonly kind: 'enumUnknown';
+  readonly key: FieldKey;
+  readonly enumName: string;
+} | {
+  readonly kind: 'discriminatorValueDuplicate';
+  readonly key: BaseKey;
+  readonly baseModel: string;
+  readonly value: string;
+  readonly firstVariant: string;
+} | {
+  readonly kind: 'discriminatorFieldUnknown';
+  readonly key: DiscriminatorKey;
+  readonly fieldName: string;
+} | {
+  readonly kind: 'discriminatorField';
+  readonly key: DiscriminatorKey;
+  readonly fieldName: string;
+  readonly refusal: DiscriminatorFieldRefusal;
+} | {
+  readonly kind: 'discriminatorValue';
+  readonly key: BaseKey;
+  readonly baseModel: string;
+  readonly fieldName: string;
+  readonly enumName: string | undefined;
+  readonly refusal: DiscriminatorVariantRefusal<string>;
+} | {
+  readonly kind: 'discriminatorAndBase';
+  readonly key: DiscriminatorKey;
+} | {
+  readonly kind: 'discriminatorWithoutVariants';
+  readonly key: DiscriminatorKey;
+} | {
+  readonly kind: 'listedVariantMissing';
+  readonly key: DiscriminatorKey;
+  readonly variant: string;
+} | {
+  readonly kind: 'baseWithoutDiscriminator';
+  readonly key: BaseKey;
+  readonly baseModel: string;
+} | {
+  readonly kind: 'baseUnknown';
+  readonly key: BaseKey;
+  readonly baseModel: string;
+} | {
+  readonly kind: 'variantWithoutValue';
+  readonly key: BaseKey;
+  readonly baseModel: string;
+} | {
+  readonly kind: 'validator';
+  readonly key: RefusalKey;
+  readonly refusal: MongoContractRefusal;
+};
+/** Something the builder accepts but the author probably did not mean, or a warning the source collected. */
+type BuildWarning = {
+  readonly kind: 'presetWithoutEffect';
+  readonly key: FieldKey;
+  readonly preset: string;
+  readonly codecId: string;
+} | {
+  readonly kind: 'source';
+  readonly warning: AuthoringWarning;
+};
+//#endregion
+//#region src/contract-definition.d.ts
+/** The generator calls a source writes for a field, resolved for the field's codec when the contract is built. */
+interface GeneratorCallsNode {
+  readonly onCreate?: GeneratorFunctionCall;
+  readonly onUpdate?: GeneratorFunctionCall;
+}
+/** What a field preset contributed to a field. */
+interface PresetContributionNode {
+  /** The preset's helper path, as in `temporal.createdAt`. */
+  readonly preset: string;
+  readonly executionDefaults: ExecutionMutationDefaultPhases | undefined;
+}
+interface FieldNode {
+  readonly fieldName: string;
+  /** The name documents store the field under, when the source gives one other than the field's own. */
+  readonly storedName?: string;
+  readonly type: ContractFieldType;
+  readonly nullable: boolean;
+  readonly many: NonNullable<ContractField['many']>;
+  /** The name of the enum that types the field. */
+  readonly enumName?: string;
+  /** Defaults the field generates, already resolved from presets and type aliases. */
+  readonly executionDefaults?: ExecutionMutationDefaultPhases;
+  readonly generatorCalls?: GeneratorCallsNode;
+  /** Generators the field's own attributes set, which the source has already resolved for the field's codec. */
+  readonly generatedValues?: ExecutionMutationDefaultPhases;
+  /** Present when a field preset made the field. */
+  readonly presetContribution?: PresetContributionNode;
+}
+/** An index as the source wrote it. */
+interface IndexNode {
+  /** Field name to its direction or index kind, in key order. */
+  readonly fields: Readonly<Record<string, MongoIndexFieldValue>>;
+  readonly options?: MongoIndexOptionsInput;
+}
+interface RelationNodeBase {
+  readonly relationName: string;
+  readonly toModel: string;
+  /** Whether a to-one related document may be absent, as the source states it. */
+  readonly nullable: boolean | undefined;
+}
+/** A relation to a model stored inside this model's documents. */
+interface EmbedRelationNode extends RelationNodeBase {
+  readonly cardinality: '1:1' | '1:N';
+  readonly on?: never;
+}
+/** A relation to documents joined on fields. */
+interface ReferenceRelationNode extends RelationNodeBase {
+  readonly cardinality: '1:1' | '1:N' | 'N:1';
+  readonly on: {
+    readonly localFields: readonly string[];
+    readonly targetFields: readonly string[];
+  };
+}
+type RelationNode = EmbedRelationNode | ReferenceRelationNode;
+/** A variant's base model and the discriminator value that selects the variant, as the source wrote it. */
+interface VariantBaseNode {
+  readonly model: string;
+  /** Undefined when the base does not name a value for the variant. */
+  readonly value: WrittenValue | undefined;
+}
+/** The field that tells the variants of a base apart. */
+interface DiscriminatorNode {
+  readonly field: string;
+  /** The variant models the source lists on the base, when it lists them there; each must name this model as its base. */
+  readonly listedVariants?: readonly string[];
+}
+interface ModelNode {
+  readonly modelName: string;
+  /** The collection the model is stored in; absent for a model stored only inside another. */
+  readonly collection?: string;
+  readonly owner?: string;
+  readonly storageRelations?: Readonly<Record<string, {
+    readonly field: string;
+  }>>;
+  readonly controlPolicy?: ControlPolicy;
+  readonly collectionOptions?: MongoCollectionOptionsAuthoringInput;
+  /** In the order the source wrote them. */
+  readonly indexes?: readonly IndexNode[];
+  readonly fields: readonly FieldNode[];
+  readonly relations?: readonly RelationNode[];
+  readonly discriminator?: DiscriminatorNode;
+  readonly base?: VariantBaseNode;
+}
+interface ValueObjectNode {
+  readonly name: string;
+  readonly fields: readonly FieldNode[];
+}
+/** A MongoDB contract as plain data, with every name resolved, which `buildMongoContractFromDefinition` builds into a contract. */
+interface ContractDefinition {
+  readonly target: TargetPackRef<'mongo', string>;
+  readonly extensions?: Readonly<Record<string, ExtensionPackRef<string, string>>>;
+  readonly defaultControlPolicy?: ControlPolicy;
+  readonly models: readonly ModelNode[];
+  readonly valueObjects?: readonly ValueObjectNode[];
+  readonly enums?: Readonly<Record<string, EnumTypeHandle>>;
+  /** Root name to model name. Derived from the models when absent. */
+  readonly roots?: Readonly<Record<string, string>>;
+  /** Whether each collection gets a validator derived from its models. Without validators, an enum a validator could not list is not refused. */
+  readonly writesCollectionValidators: boolean;
+  /** Warnings the source collected before the build, reported with the build's own. */
+  readonly warnings: readonly AuthoringWarning[] | undefined;
+}
+//#endregion
+//#region src/build-contract.d.ts
+/** A contract the builder built, with the warnings to report about it. */
+interface BuiltContract {
+  readonly contract: MongoContract;
+  readonly warnings: readonly BuildWarning[];
+}
+/** Why the builder refused a definition, with the warnings to report about it all the same. */
+interface BuildFailure {
+  readonly refusals: readonly BuildRefusal[];
+  readonly warnings: readonly BuildWarning[];
+}
+/**
+ * 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.
+ */
+declare function buildMongoContractFromDefinition(definition: ContractDefinition, codecLookup: CodecLookupWithDescriptors, dataTypes: DataTypeSupport): Result<BuiltContract, BuildFailure>;
+//#endregion
+//#region src/contract-dsl.d.ts
 type VariantSpec = {
   readonly value: string;
 };
 type StorageRelationSpec = {
   readonly field: string;
 };
-type StringListInput = string | readonly string[];
-type Present<T> = Exclude<T, undefined>;
-type EmptyObject = Record<never, never>;
-type Simplify<T> = { [K in keyof T]: T[K]; } & EmptyObject;
-type Flatten<T> = { [K in keyof T]: T[K]; };
-type StrictShape<Actual, Shape> = Actual & Shape & Record<Exclude<keyof Actual, keyof Shape>, never>;
-type UnionToIntersection<Union> = (Union extends unknown ? (value: Union) => void : never) extends ((value: infer Intersection) => void) ? Intersection : never;
-type ExtractCodecTypesFromPack<P> = P extends {
-  __codecTypes?: infer CodecTypes;
-} ? CodecTypes extends Record<string, {
-  output: unknown;
-}> ? CodecTypes : Record<string, never> : Record<string, never>;
-type MongoCodecTypes = {
-  readonly 'mongo/objectId@1': {
-    readonly input: string;
-    readonly output: string;
-    readonly traits: 'equality';
-  };
-  readonly 'mongo/string@1': {
-    readonly input: string;
-    readonly output: string;
-    readonly traits: 'equality' | 'order' | 'textual';
-  };
-  readonly 'mongo/double@1': {
-    readonly input: number;
-    readonly output: number;
-    readonly traits: 'equality' | 'order' | 'numeric';
-  };
-  readonly 'mongo/int32@1': {
-    readonly input: number;
-    readonly output: number;
-    readonly traits: 'equality' | 'order' | 'numeric';
-  };
-  readonly 'mongo/bool@1': {
-    readonly input: boolean;
-    readonly output: boolean;
-    readonly traits: 'equality' | 'boolean';
-  };
-  readonly 'mongo/date@1': {
-    readonly input: Date;
-    readonly output: Date;
-    readonly traits: 'equality' | 'order';
-  };
-  readonly 'mongo/vector@1': {
-    readonly input: readonly number[];
-    readonly output: readonly number[];
-    readonly traits: 'equality';
-  };
-  readonly 'mongo/int64@1': {
-    readonly input: bigint;
-    readonly output: bigint;
-    readonly traits: 'equality' | 'order' | 'numeric';
-  };
-  readonly 'mongo/int64Number@1': {
-    readonly input: number;
-    readonly output: number;
-    readonly traits: 'equality' | 'order' | 'numeric';
-  };
-  readonly 'mongo/decimal128@1': {
-    readonly input: string;
-    readonly output: string;
-    readonly traits: 'equality' | 'order' | 'numeric';
-    readonly keepsWrittenForm: true;
-  };
-  readonly 'mongo/binary@1': {
-    readonly input: Uint8Array;
-    readonly output: Uint8Array;
-    readonly traits: 'equality';
-  };
-  readonly 'mongo/json@1': {
-    readonly input: JsonValue;
-    readonly output: JsonValue;
-    readonly traits: never;
-  };
-  readonly 'mongo/bson@1': {
-    readonly input: BsonInputValue;
-    readonly output: BsonValue;
-    readonly traits: never;
-  };
-};
-type MergeExtensionCodecTypes<Packs extends Record<string, unknown>> = UnionToIntersection<{ [K in keyof Packs]: ExtractCodecTypesFromPack<Packs[K]>; }[keyof Packs]>;
-type MergeExtensionCodecTypesSafe<Packs> = Packs extends Record<string, unknown> ? keyof Packs extends never ? Record<never, never> : MergeExtensionCodecTypes<Packs> : Record<never, never>;
 interface FieldBuilder<Type extends ContractFieldType = ContractFieldType, Nullable extends boolean = boolean, Many extends false | {
   readonly elementNullable: boolean;
 } = false | {
@@ -110,11 +419,13 @@ interface FieldBuilder<Type extends ContractFieldType = ContractFieldType, Nulla
   readonly __storedName: StoredName;
   /** The generator function calls `.onCreate(...)` and `.onUpdate(...)` give, resolved by the field's codec when the contract is built. */
   readonly __generatorCalls?: FieldGeneratorCalls;
+  /** What the field preset that made the field contributed. */
+  readonly __presetContribution?: PresetContributionNode;
   /** Generates the field's value in the client when a document is created without one, with a call from `gen`, such as `gen.now()`. */
   onCreate(call: GeneratorFunctionCall): FieldBuilder<Type, Nullable, Many, Handle, WithGeneratedPhase<ExecutionDefaults, 'onCreate'>, StoredName>;
   /** Generates the field's value in the client every time a document is updated, with a call from `gen`, such as `gen.now()`. */
   onUpdate(call: GeneratorFunctionCall): FieldBuilder<Type, Nullable, Many, Handle, WithGeneratedPhase<ExecutionDefaults, 'onUpdate'>, StoredName>;
-  readonly optional: FilledOnWrite<ExecutionDefaults> extends true ? (this: 'This field generates a value on write, so it cannot be optional') => never : () => FieldBuilder<Type, true, Many, Handle, ExecutionDefaults, StoredName>;
+  readonly optional: () => FieldBuilder<Type, true, Many, Handle, ExecutionDefaults, StoredName>;
   readonly many: FilledOnWrite<ExecutionDefaults> extends true ? (this: 'This field generates a value on write, so it cannot be a list') => never : {
     (): FieldBuilder<Type, Nullable, {
       readonly elementNullable: false;
@@ -205,6 +516,91 @@ type NamedModelBuilder<Name extends string = string, Fields extends Record<strin
   readonly field: string;
 } | undefined, Variants extends Record<string, VariantSpec> | undefined = Record<string, VariantSpec> | undefined> = ModelBuilder<Name, Fields, Relations, Collection, Owner, Base, StorageRelations, Discriminator, Variants>;
 type AnyModelBuilder = NamedModelBuilder;
+type ModelNameInput = string | AnyModelBuilder;
+//#endregion
+//#region src/contract-builder.d.ts
+type StringListInput = string | readonly string[];
+type Present<T> = Exclude<T, undefined>;
+type EmptyObject = Record<never, never>;
+type Simplify<T> = { [K in keyof T]: T[K]; } & EmptyObject;
+type Flatten<T> = { [K in keyof T]: T[K]; };
+type StrictShape<Actual, Shape> = Actual & Shape & Record<Exclude<keyof Actual, keyof Shape>, never>;
+type UnionToIntersection<Union> = (Union extends unknown ? (value: Union) => void : never) extends ((value: infer Intersection) => void) ? Intersection : never;
+type ExtractCodecTypesFromPack<P> = P extends {
+  __codecTypes?: infer CodecTypes;
+} ? CodecTypes extends Record<string, {
+  output: unknown;
+}> ? CodecTypes : Record<string, never> : Record<string, never>;
+type MongoCodecTypes = {
+  readonly 'mongo/objectId@1': {
+    readonly input: string;
+    readonly output: string;
+    readonly traits: 'equality';
+  };
+  readonly 'mongo/string@1': {
+    readonly input: string;
+    readonly output: string;
+    readonly traits: 'equality' | 'order' | 'textual';
+  };
+  readonly 'mongo/double@1': {
+    readonly input: number;
+    readonly output: number;
+    readonly traits: 'equality' | 'order' | 'numeric';
+  };
+  readonly 'mongo/int32@1': {
+    readonly input: number;
+    readonly output: number;
+    readonly traits: 'equality' | 'order' | 'numeric';
+  };
+  readonly 'mongo/bool@1': {
+    readonly input: boolean;
+    readonly output: boolean;
+    readonly traits: 'equality' | 'boolean';
+  };
+  readonly 'mongo/date@1': {
+    readonly input: Date;
+    readonly output: Date;
+    readonly traits: 'equality' | 'order';
+  };
+  readonly 'mongo/vector@1': {
+    readonly input: readonly number[];
+    readonly output: readonly number[];
+    readonly traits: 'equality';
+  };
+  readonly 'mongo/int64@1': {
+    readonly input: bigint;
+    readonly output: bigint;
+    readonly traits: 'equality' | 'order' | 'numeric';
+  };
+  readonly 'mongo/int64Number@1': {
+    readonly input: number;
+    readonly output: number;
+    readonly traits: 'equality' | 'order' | 'numeric';
+  };
+  readonly 'mongo/decimal128@1': {
+    readonly input: string;
+    readonly output: string;
+    readonly traits: 'equality' | 'order' | 'numeric';
+    readonly keepsWrittenForm: true;
+  };
+  readonly 'mongo/binary@1': {
+    readonly input: Uint8Array;
+    readonly output: Uint8Array;
+    readonly traits: 'equality';
+  };
+  readonly 'mongo/json@1': {
+    readonly input: JsonValue;
+    readonly output: JsonValue;
+    readonly traits: never;
+  };
+  readonly 'mongo/bson@1': {
+    readonly input: BsonInputValue;
+    readonly output: BsonValue;
+    readonly traits: never;
+  };
+};
+type MergeExtensionCodecTypes<Packs extends Record<string, unknown>> = UnionToIntersection<{ [K in keyof Packs]: ExtractCodecTypesFromPack<Packs[K]>; }[keyof Packs]>;
+type MergeExtensionCodecTypesSafe<Packs> = Packs extends Record<string, unknown> ? keyof Packs extends never ? Record<never, never> : MergeExtensionCodecTypes<Packs> : Record<never, never>;
 type ExtractFieldReferenceName<T> = T extends FieldReference<string, infer FieldName extends string> ? FieldName : never;
 type ExtractModelName<T> = T extends NamedModelBuilder<infer Name> ? Name : never;
 type ExtractValueObjectName<T> = T extends NamedValueObjectBuilder<infer Name> ? Name : never;
@@ -221,7 +617,6 @@ type ModelStorageRelationsSection<T> = ExtractModelStorageRelations<T> extends R
 type RootModelCollection<T> = ExtractModelCollection<T> extends string ? ExtractModelOwner<T> extends undefined ? ExtractModelBase<T> extends undefined ? ExtractModelCollection<T> : never : never : never;
 type RootModelName<T> = RootModelCollection<T> extends never ? never : ExtractModelName<T>;
 type CollectionName<T> = ExtractModelCollection<T> extends string ? ExtractModelCollection<T> : never;
-type ModelNameInput = string | AnyModelBuilder;
 type ValueObjectNameInput = string | AnyValueObjectBuilder;
 type RelationTargetFieldsInput<TargetName extends string> = StringListInput | FieldReference<TargetName, string> | readonly FieldReference<TargetName, string>[];
 type NormalizeModelName<T> = T extends string ? T : ExtractModelName<T>;
@@ -439,7 +834,7 @@ type ContractScaffold<Family extends FamilyPackRef<string>, Target extends Targe
   readonly roots?: Roots;
   readonly defaultControlPolicy?: ControlPolicy;
 };
-type ContractDefinition<Family extends FamilyPackRef<string>, Target extends TargetPackRef<string, string>, Models extends Record<string, AnyModelBuilder> = Record<never, never>, ValueObjects extends Record<string, AnyValueObjectBuilder> = Record<never, never>, Extensions extends Record<string, ExtensionPackRef<string, string>> | undefined = undefined, Roots extends Record<string, ModelNameInput> | undefined = undefined> = ContractScaffold<Family, Target, Extensions, Roots> & {
+type ContractInput<Family extends FamilyPackRef<string>, Target extends TargetPackRef<string, string>, Models extends Record<string, AnyModelBuilder> = Record<never, never>, ValueObjects extends Record<string, AnyValueObjectBuilder> = Record<never, never>, Extensions extends Record<string, ExtensionPackRef<string, string>> | undefined = undefined, Roots extends Record<string, ModelNameInput> | undefined = undefined> = ContractScaffold<Family, Target, Extensions, Roots> & {
   readonly models?: Models;
   readonly valueObjects?: ValueObjects;
   readonly enums?: Record<string, EnumTypeHandle>;
@@ -605,7 +1000,7 @@ type WithFamilyTarget<Input, F extends FamilyPackRef<string>, T extends TargetPa
  * this is a plain overloaded function (not a factory returning an overloaded function)
  * so no overloaded-function-return cast is needed.
  *
- * Overload 1: definition form (no factory).
+ * Overload 1: input form (no factory).
  */
 declare function buildBoundContract<const F extends FamilyPackRef<string>, const T extends TargetPackRef<string, string>, const Definition extends BoundDefinitionInput<Record<string, AnyModelBuilder>, Record<string, AnyValueObjectBuilder>, Record<string, ExtensionPackRef<string, string>> | undefined, Record<string, ModelNameInput> | undefined>>(family: F, target: T, definition: Definition, factory?: undefined): MongoContractResult<WithFamilyTarget<Definition, F, T>>;
 /**
@@ -616,12 +1011,12 @@ declare function buildBoundContract<const F extends FamilyPackRef<string>, const
   readonly valueObjects?: Record<string, AnyValueObjectBuilder>;
   readonly roots?: Record<string, ModelNameInput> | undefined;
 }>(family: F, target: T, definition: Definition, factory: (helpers: ContractAuthoringHelpers<F, T, NonNullable<Definition['extensions']>>) => Built): MongoContractResult<WithFamilyTarget<Definition & Built, F, T>>;
-declare function defineContract<const Definition extends ContractDefinition<FamilyPackRef<string>, TargetPackRef<string, string>, Record<string, AnyModelBuilder>, Record<string, AnyValueObjectBuilder>, Record<string, ExtensionPackRef<string, string>> | undefined, Record<string, ModelNameInput> | undefined>>(definition: Definition): MongoContractResult<Definition>;
+declare function defineContract<const Definition extends ContractInput<FamilyPackRef<string>, TargetPackRef<string, string>, Record<string, AnyModelBuilder>, Record<string, AnyValueObjectBuilder>, Record<string, ExtensionPackRef<string, string>> | undefined, Record<string, ModelNameInput> | undefined>>(definition: Definition): MongoContractResult<Definition>;
 declare function defineContract<const Definition extends ContractScaffold<FamilyPackRef<string>, TargetPackRef<string, string>, Record<string, ExtensionPackRef<string, string>> | undefined, Record<string, ModelNameInput> | undefined>, const Built extends {
   readonly models?: Record<string, AnyModelBuilder>;
   readonly valueObjects?: Record<string, AnyValueObjectBuilder>;
   readonly roots?: Record<string, ModelNameInput> | undefined;
 }>(definition: Definition, factory: (helpers: ContractAuthoringHelpers<Definition['family'], Definition['target'], ScaffoldExtensions<Definition>>) => Built): MongoContractResult<Definition & Built>;
 //#endregion
-export { member as C, valueObject as E, isEnumTypeHandle as S, rel as T, buildBoundContract as _, ContractFactory as a, field as b, EnumTypeHandle as c, FieldReference as d, ModelBuilder as f, bindEnumType as g, ValueObjectBuilder as h, ContractDefinition as i, ExtractCodecTypesFromPack as l, RelationBuilder as m, CodecTypeMap as n, ContractScaffold as o, MongoContractResult as p, ContractAuthoringHelpers as r, EnumMember as s, BoundEnumType as t, FieldBuilder as u, defineContract as v, model as w, index as x, enumType$1 as y };
-//# sourceMappingURL=contract-builder-ClL-xMK2.d.mts.map
+export { RelationNode as A, field as B, ModelBuilder as C, ReferenceRelationNode as D, PresetContributionNode as E, bindEnumType as F, rel as G, isEnumTypeHandle as H, buildBoundContract as I, valueObject as K, buildMongoContractFromDefinition as L, ValueObjectBuilder as M, ValueObjectNode as N, RefusalKey as O, VariantBaseNode as P, defineContract as R, IndexShapeRule as S, MongoContractResult as T, member as U, index as V, model as W, FieldBuilder as _, BuiltContract as a, FieldReference as b, ContractDefinition as c, ContractScaffold as d, DiscriminatorNode as f, ExtractCodecTypesFromPack as g, EnumTypeHandle as h, BuildWarning as i, RestatedFieldDifference as j, RelationBuilder as k, ContractFactory as l, EnumMember as m, BuildFailure as n, CodecTypeMap as o, EmbedRelationNode as p, BuildRefusal as r, ContractAuthoringHelpers as s, BoundEnumType as t, ContractInput as u, FieldKey as v, ModelNode as w, IndexNode as x, FieldNode as y, enumType$1 as z };
+//# sourceMappingURL=contract-builder-lqaM5w74.d.mts.map