@prisma-next/mongo-query-builder 0.5.0-dev.65 → 0.5.0-dev.67

package/dist/index.d.mts

@@ -4,7 +4,6 @@ import { MongoValue } from "@prisma-next/mongo-value";
 import { ContractField } from "@prisma-next/contract/types";
 
 //#region src/resolve-path.d.ts
-
 /**
  * Marker `DocField` variant representing a non-leaf (value-object) path in
  * a [NestedDocShape]. Extends `DocField` with a `fields` property carrying
@@ -21,10 +20,10 @@ import { ContractField } from "@prisma-next/contract/types";
  * nullable parent resolves to the leaf's own `nullable` — matching how
  * MongoDB treats missing intermediate documents).
  */
-interface ObjectField<N$1 extends NestedDocShape> extends DocField {
+interface ObjectField<N extends NestedDocShape> extends DocField {
   readonly codecId: 'prisma/object@1';
   readonly nullable: boolean;
-  readonly fields: N$1;
+  readonly fields: N;
 }
 /**
  * Marker `DocField` variant representing "an array of foreign-model rows"
@@ -40,10 +39,10 @@ interface ObjectField<N$1 extends NestedDocShape> extends DocField {
  * runtime shape is unchanged; the marker exists solely to thread the
  * foreign element type through the result-row resolver.
  */
-interface ModelArrayField<ModelName$1 extends string> extends DocField {
+interface ModelArrayField<ModelName extends string> extends DocField {
   readonly codecId: 'prisma/modelArray@1';
   readonly nullable: false;
-  readonly model: ModelName$1;
+  readonly model: ModelName;
 }
 /**
  * Phantom-symbol brand placed on `ModelToDocShape`'s output (and inherited
@@ -74,8 +73,8 @@ type ModelOriginBrand = typeof ModelOriginBrand;
  * `InferModelRow<TContract, ModelName>` rather than the per-field codec
  * walk. Use as `ModelToDocShape<TC, ModelName> & ModelOriginBranded<ModelName>`.
  */
-type ModelOriginBranded<ModelName$1 extends string> = {
-  readonly [ModelOriginBrand]?: ModelName$1;
+type ModelOriginBranded<ModelName extends string> = {
+  readonly [ModelOriginBrand]?: ModelName;
 };
 /**
  * Document shape that carries nested value-object sub-shapes.
@@ -150,11 +149,11 @@ type TranslateField<TContract extends ContractHasValueObjects, F> = F extends {
  * `VOs[VOName]['fields']` is preserved and the hover / indexed-access
  * surface stays concrete at instantiation time.
  */
-type VONestedShape<TContract extends ContractHasValueObjects, VOName$1 extends string> = TContract extends {
+type VONestedShape<TContract extends ContractHasValueObjects, VOName extends string> = TContract extends {
   readonly valueObjects: infer VOs extends Record<string, {
     readonly fields: Record<string, unknown>;
   }>;
-} ? VOName$1 extends keyof VOs ? { readonly [K in keyof VOs[VOName$1]['fields'] & string]: TranslateField<TContract, VOs[VOName$1]['fields'][K]> } : never : never;
+} ? VOName extends keyof VOs ? { readonly [K in keyof VOs[VOName]['fields'] & string]: TranslateField<TContract, VOs[VOName]['fields'][K]> } : never : never;
 /**
  * Build the `NestedDocShape` for a model. Scalar leaves resolve to their
  * concrete codec id; value-object fields recurse into the referenced
@@ -169,7 +168,7 @@ type VONestedShape<TContract extends ContractHasValueObjects, VOName$1 extends s
  * literal field record collapses `keyof` to `string` and the result hover
  * degrades to `{ readonly [x: string]: any }`.
  */
-type ModelNestedShape<TContract extends MongoContract, ModelName$1 extends string & keyof TContract['models']> = { readonly [K in keyof TContract['models'][ModelName$1]['fields'] & string]: TranslateField<TContract & ContractHasValueObjects, TContract['models'][ModelName$1]['fields'][K]> };
+type ModelNestedShape<TContract extends MongoContract, ModelName extends string & keyof TContract['models']> = { readonly [K in keyof TContract['models'][ModelName]['fields'] & string]: TranslateField<TContract & ContractHasValueObjects, TContract['models'][ModelName]['fields'][K]> };
 /**
  * Resolve a dot-path against a `NestedDocShape`. Returns:
  *  - the leaf `DocField` when `Path` terminates on a scalar/array leaf,
@@ -183,7 +182,7 @@ type ModelNestedShape<TContract extends MongoContract, ModelName$1 extends strin
  * rejects bad paths with a clear error instead of silently resolving to
  * `never`.
  */
-type ResolvePath<N$1 extends NestedDocShape, Path extends string> = Path extends `${infer Head}.${infer Rest}` ? Head extends keyof N$1 & string ? N$1[Head] extends ObjectField<infer Sub> ? ResolvePath<Sub, Rest> : never : never : Path extends keyof N$1 & string ? N$1[Path] : never;
+type ResolvePath<N extends NestedDocShape, Path extends string> = Path extends `${infer Head}.${infer Rest}` ? Head extends keyof N & string ? N[Head] extends ObjectField<infer Sub> ? ResolvePath<Sub, Rest> : never : never : Path extends keyof N & string ? N[Path] : never;
 /**
  * Union of every valid dot-path within a `NestedDocShape`. Includes
  * top-level keys (scalar leaves *and* value-object roots) and every
@@ -202,14 +201,14 @@ type ResolvePath<N$1 extends NestedDocShape, Path extends string> = Path extends
  * open-ended `keyof` cannot resolve a specific literal path, so the
  * callable form must be disabled at the type level.
  */
-type ValidPaths<N$1 extends NestedDocShape> = string extends keyof N$1 ? never : { [K in keyof N$1 & string]: N$1[K] extends ObjectField<infer Sub> ? K | `${K}.${ValidPaths<Sub>}` : K }[keyof N$1 & string];
+type ValidPaths<N extends NestedDocShape> = string extends keyof N ? never : { [K in keyof N & string]: N[K] extends ObjectField<infer Sub> ? K | `${K}.${ValidPaths<Sub>}` : K }[keyof N & string];
 /**
  * IDE-oriented alias for `ValidPaths`. Kept as a separate export so future
  * refinements (e.g. ArkType-style lazy expansion for very deep shapes) can
  * diverge from the strict `ValidPaths` constraint without breaking
  * downstream consumers. For now the two are intentionally equivalent.
  */
-type PathCompletions<N$1 extends NestedDocShape> = ValidPaths<N$1>;
+type PathCompletions<N extends NestedDocShape> = ValidPaths<N>;
 //#endregion
 //#region src/types.d.ts
 interface DocField {
@@ -254,10 +253,10 @@ type ExtractCodecId<F> = F extends {
 } ? C : F extends {
   codecId: infer C extends string;
 } ? C : string;
-type ModelToDocShape<TContract extends MongoContract, ModelName$1 extends string & keyof TContract['models']> = { [K in keyof TContract['models'][ModelName$1]['fields'] & string]: {
-  readonly codecId: ExtractCodecId<TContract['models'][ModelName$1]['fields'][K]>;
-  readonly nullable: TContract['models'][ModelName$1]['fields'][K]['nullable'];
-} } & ModelOriginBranded<ModelName$1>;
+type ModelToDocShape<TContract extends MongoContract, ModelName extends string & keyof TContract['models']> = { [K in keyof TContract['models'][ModelName]['fields'] & string]: {
+  readonly codecId: ExtractCodecId<TContract['models'][ModelName]['fields'][K]>;
+  readonly nullable: TContract['models'][ModelName]['fields'][K]['nullable'];
+} } & ModelOriginBranded<ModelName>;
 /**
  * Per-field resolver. Walks `Shape`'s string keys, routing
  * `ModelArrayField` (the lookup marker) through `InferModelRow` and
@@ -350,7 +349,7 @@ type UnwrapArrayDocField<F extends DocField> = F;
  * `ResolveRow` still routes through `InferModelRow` and value-object
  * fields keep their concrete nested types.
  */
-type UnwoundShape<S extends DocShape, K$1 extends keyof S & string> = { [P in keyof S & string]: P extends K$1 ? UnwrapArrayDocField<S[P]> : S[P] } & (S extends ModelOriginBranded<infer ModelName extends string> ? ModelOriginBranded<ModelName> : unknown);
+type UnwoundShape<S extends DocShape, K extends keyof S & string> = { [P in keyof S & string]: P extends K ? UnwrapArrayDocField<S[P]> : S[P] } & (S extends ModelOriginBranded<infer ModelName extends string> ? ModelOriginBranded<ModelName> : unknown);
 //#endregion
 //#region src/accumulator-helpers.d.ts
 declare const acc: {
@@ -537,7 +536,7 @@ interface LeafExpression<F extends DocField> extends TypedAggExpr<F> {
  * so the value object can be piped through `$addFields` /
  * `$replaceRoot` / etc. as-is.
  */
-interface ObjectExpression<N$1 extends NestedDocShape> extends TypedAggExpr<ObjectField<N$1>> {
+interface ObjectExpression<N extends NestedDocShape> extends TypedAggExpr<ObjectField<N>> {
   readonly _path: string;
   exists(flag?: boolean): MongoFilterExpr;
   eq(value: null): MongoFilterExpr;
@@ -606,7 +605,7 @@ interface StageEmitters {
  * `f.rawPath(...)` remains available in that state for callers that need
  * an explicit unvalidated path.
  */
-type FieldAccessor<S extends DocShape, N$1 extends NestedDocShape = Record<string, never>> = { readonly [K in keyof S & string]: Expression<S[K]> } & (<P$1 extends ValidPaths<N$1>>(path: P$1) => Expression<ResolvePath<N$1, P$1>>) & {
+type FieldAccessor<S extends DocShape, N extends NestedDocShape = Record<string, never>> = { readonly [K in keyof S & string]: Expression<S[K]> } & (<P extends ValidPaths<N>>(path: P) => Expression<ResolvePath<N, P>>) & {
   readonly stage: StageEmitters;
   /**
    * Escape hatch: build a `LeafExpression<F>` for an unvalidated string
@@ -634,7 +633,7 @@ type FieldAccessor<S extends DocShape, N$1 extends NestedDocShape = Record<strin
  * `undefined` to keep accidental coercion behaviour unsurprising —
  * matching the previous `FieldProxy` / `FilterProxy` semantics.
  */
-declare function createFieldAccessor<S extends DocShape, N$1 extends NestedDocShape = Record<string, never>>(): FieldAccessor<S, N$1>;
+declare function createFieldAccessor<S extends DocShape, N extends NestedDocShape = Record<string, never>>(): FieldAccessor<S, N>;
 //#endregion
 //#region src/lookup-builder.d.ts
 /**
@@ -679,10 +678,10 @@ type LookupResultBrand = 'mongo-query-builder/lookup-result@1';
  * `PipelineChain.lookup`'s return type can encode the result-row
  * promotion precisely.
  */
-interface LookupResult<RootName extends string, ModelName$1 extends string, As extends string> {
+interface LookupResult<RootName extends string, ModelName extends string, As extends string> {
   readonly _brand: LookupResultBrand;
   readonly _root: RootName;
-  readonly _model: ModelName$1;
+  readonly _model: ModelName;
   readonly _localField: string;
   readonly _foreignField: string;
   readonly _as: As;
@@ -692,8 +691,8 @@ interface LookupResult<RootName extends string, ModelName$1 extends string, As e
  * model literals plus the captured local / foreign paths, and exposes
  * `.as(name)` to finalise the spec with the user-chosen field name.
  */
-interface LookupBuilderWithKey<RootName extends string, ModelName$1 extends string> {
-  as<As extends string>(name: As): LookupResult<RootName, ModelName$1, As>;
+interface LookupBuilderWithKey<RootName extends string, ModelName extends string> {
+  as<As extends string>(name: As): LookupResult<RootName, ModelName, As>;
 }
 /**
  * Builder returned by `from(name)`. Carries the foreign root / model
@@ -704,8 +703,8 @@ interface LookupBuilderWithKey<RootName extends string, ModelName$1 extends stri
  * `on(cb)` runs the user's callback to capture the leaf paths and
  * returns a `LookupBuilderWithKey` that exposes `.as(name)`.
  */
-interface LookupBuilder<TContract extends MongoContract, Shape extends DocShape, Nested extends Record<string, DocField>, RootName extends string, ModelName$1 extends string> {
-  on(cb: (local: FieldAccessor<Shape, Nested>, foreign: ModelName$1 extends keyof TContract['models'] & string ? FieldAccessor<ModelToDocShape<TContract, ModelName$1>, ModelNestedShape<TContract, ModelName$1>> : never) => LookupOnResult): LookupBuilderWithKey<RootName, ModelName$1>;
+interface LookupBuilder<TContract extends MongoContract, Shape extends DocShape, Nested extends Record<string, DocField>, RootName extends string, ModelName extends string> {
+  on(cb: (local: FieldAccessor<Shape, Nested>, foreign: ModelName extends keyof TContract['models'] & string ? FieldAccessor<ModelToDocShape<TContract, ModelName>, ModelNestedShape<TContract, ModelName>> : never) => LookupOnResult): LookupBuilderWithKey<RootName, ModelName>;
 }
 /**
  * Type of the `from` callable passed to `PipelineChain.lookup`'s outer
@@ -777,9 +776,9 @@ interface PipelineChainState {
  * marker table (and rationale per row) in
  * `docs/architecture docs/adrs/ADR 201 - State-machine pattern for typed DSL builders.md`.
  */
-declare class PipelineChain<TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>, Shape extends DocShape, U$1 extends UpdateEnabled = 'update-ok', F extends FindAndModifyEnabled = 'fam-ok', L extends LeadingMatch = 'leading', N$1 extends NestedDocShape = Record<string, never>> {
+declare class PipelineChain<TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>, Shape extends DocShape, U extends UpdateEnabled = 'update-ok', F extends FindAndModifyEnabled = 'fam-ok', L extends LeadingMatch = 'leading', N extends NestedDocShape = Record<string, never>> {
   #private;
-  readonly __updateCompat: U$1;
+  readonly __updateCompat: U;
   readonly __findAndModifyCompat: F;
   readonly __leadingMatch: L;
   constructor(contract: TContract, state: PipelineChainState);
@@ -791,27 +790,27 @@ declare class PipelineChain<TContract extends MongoContractWithTypeMaps<MongoCon
    * `deconstructUpdateChain` can only peel leading `$match` stages into the
    * wire-command filter.
    */
-  match(filter: MongoFilterExpr): PipelineChain<TContract, Shape, L extends 'leading' ? U$1 : 'update-cleared', F, L, N$1>;
-  match(fn: (fields: FieldAccessor<Shape, N$1>) => MongoFilterExpr): PipelineChain<TContract, Shape, L extends 'leading' ? U$1 : 'update-cleared', F, L, N$1>;
+  match(filter: MongoFilterExpr): PipelineChain<TContract, Shape, L extends 'leading' ? U : 'update-cleared', F, L, N>;
+  match(fn: (fields: FieldAccessor<Shape, N>) => MongoFilterExpr): PipelineChain<TContract, Shape, L extends 'leading' ? U : 'update-cleared', F, L, N>;
   /**
    * `$sort`. Clears `UpdateEnabled` (`update` has no per-document sort) but
    * preserves `FindAndModifyEnabled` (`findAndModify` has a `sort` slot).
    */
-  sort(spec: SortSpec<Shape>): PipelineChain<TContract, Shape, 'update-cleared', F, 'past-leading', N$1>;
+  sort(spec: SortSpec<Shape>): PipelineChain<TContract, Shape, 'update-cleared', F, 'past-leading', N>;
   /**
    * `$limit`. Clears both markers — `limit` is incompatible with the `update`
    * wire command, and `findAndModify` already implies single-document
    * semantics (so `.limit(...)` adds no meaning, only ambiguity).
    */
-  limit(n: number): PipelineChain<TContract, Shape, 'update-cleared', 'fam-cleared', 'past-leading', N$1>;
+  limit(n: number): PipelineChain<TContract, Shape, 'update-cleared', 'fam-cleared', 'past-leading', N>;
   /**
    * `$skip`. Clears both markers — MongoDB's `findAndModify` wire command
    * has no `skip` slot, so `deconstructFindAndModifyChain` rejects any
    * `$skip` at runtime; keeping the marker `fam-cleared` makes the type
    * system reflect the same constraint (see ADR 201 marker table).
    */
-  skip(n: number): PipelineChain<TContract, Shape, 'update-cleared', 'fam-cleared', 'past-leading', N$1>;
-  sample(n: number): PipelineChain<TContract, Shape, 'update-cleared', 'fam-cleared', 'past-leading', N$1>;
+  skip(n: number): PipelineChain<TContract, Shape, 'update-cleared', 'fam-cleared', 'past-leading', N>;
+  sample(n: number): PipelineChain<TContract, Shape, 'update-cleared', 'fam-cleared', 'past-leading', N>;
   /**
    * `$addFields`. Preserves `UpdateEnabled` (representable as
    * update-with-pipeline `$set`); clears `FindAndModifyEnabled` (no analogue
@@ -819,7 +818,7 @@ declare class PipelineChain<TContract extends MongoContractWithTypeMaps<MongoCon
    * preserved — newly added flat fields are reachable via property access
    * (`f.newField`) but do not themselves carry nested structure.
    */
-  addFields<NewFields extends Record<string, TypedAggExpr<DocField>>>(fn: (fields: FieldAccessor<Shape, N$1>) => NewFields): PipelineChain<TContract, Shape & ExtractDocShape<NewFields>, U$1, 'fam-cleared', 'past-leading', N$1>;
+  addFields<NewFields extends Record<string, TypedAggExpr<DocField>>>(fn: (fields: FieldAccessor<Shape, N>) => NewFields): PipelineChain<TContract, Shape & ExtractDocShape<NewFields>, U, 'fam-cleared', 'past-leading', N>;
   /**
    * `$lookup`. Clears both markers — joins are not representable in either
    * the `update` or `findAndModify` wire commands. The original document's
@@ -833,7 +832,7 @@ declare class PipelineChain<TContract extends MongoContractWithTypeMaps<MongoCon
    * `ResolveRow` produces `Array<ForeignRow>` (with concrete leaf
    * types) instead of the legacy `unknown[]`.
    */
-  lookup<RootName extends string, ModelName$1 extends string, As extends string>(fn: (from: LookupFrom<TContract, Shape, N$1>) => LookupResult<RootName, ModelName$1, As>): PipelineChain<TContract, Shape & Record<As, ModelArrayField<ModelName$1>>, 'update-cleared', 'fam-cleared', 'past-leading', N$1>;
+  lookup<RootName extends string, ModelName extends string, As extends string>(fn: (from: LookupFrom<TContract, Shape, N>) => LookupResult<RootName, ModelName, As>): PipelineChain<TContract, Shape & Record<As, ModelArrayField<ModelName>>, 'update-cleared', 'fam-cleared', 'past-leading', N>;
   /**
    * `$project`. Preserves `UpdateEnabled` (representable as update-with-pipeline
    * `$project` / `$unset`); clears `FindAndModifyEnabled` (use `.project()` on
@@ -844,8 +843,8 @@ declare class PipelineChain<TContract extends MongoContractWithTypeMaps<MongoCon
    * fundamentally rewrites the document, so dot-paths into the *source*
    * document are no longer meaningful downstream.
    */
-  project<K$1 extends keyof Shape & string>(...keys: K$1[]): PipelineChain<TContract, Pick<Shape, K$1 | ('_id' extends keyof Shape ? '_id' : never)>, U$1, 'fam-cleared', 'past-leading'>;
-  project<Spec extends Record<string, 1 | TypedAggExpr<DocField>>>(fn: (fields: FieldAccessor<Shape, N$1>) => Spec): PipelineChain<TContract, ProjectedShape<Shape, Spec>, U$1, 'fam-cleared', 'past-leading'>;
+  project<K extends keyof Shape & string>(...keys: K[]): PipelineChain<TContract, Pick<Shape, K | ('_id' extends keyof Shape ? '_id' : never)>, U, 'fam-cleared', 'past-leading'>;
+  project<Spec extends Record<string, 1 | TypedAggExpr<DocField>>>(fn: (fields: FieldAccessor<Shape, N>) => Spec): PipelineChain<TContract, ProjectedShape<Shape, Spec>, U, 'fam-cleared', 'past-leading'>;
   /**
    * `$unwind`. Clears both markers — array unrolling produces multiple output
    * documents per input, incompatible with both single-document update and
@@ -853,27 +852,27 @@ declare class PipelineChain<TContract extends MongoContractWithTypeMaps<MongoCon
    * replaces the unwound array slot with its element but leaves the rest
    * of the document structurally intact.
    */
-  unwind<K$1 extends keyof Shape & string>(field: K$1, options?: {
+  unwind<K extends keyof Shape & string>(field: K, options?: {
     preserveNullAndEmptyArrays?: boolean;
-  }): PipelineChain<TContract, UnwoundShape<Shape, K$1>, 'update-cleared', 'fam-cleared', 'past-leading', N$1>;
+  }): PipelineChain<TContract, UnwoundShape<Shape, K>, 'update-cleared', 'fam-cleared', 'past-leading', N>;
   /**
    * `$group`. Clears both markers — group output bears no relation to source
    * documents; neither `update` nor `findAndModify` can consume it. Nested
    * path shape is reset (the source document's path tree is gone).
    */
-  group<Spec extends GroupSpec>(fn: (fields: FieldAccessor<Shape, N$1>) => Spec): PipelineChain<TContract, GroupedDocShape<Spec>, 'update-cleared', 'fam-cleared', 'past-leading'>;
+  group<Spec extends GroupSpec>(fn: (fields: FieldAccessor<Shape, N>) => Spec): PipelineChain<TContract, GroupedDocShape<Spec>, 'update-cleared', 'fam-cleared', 'past-leading'>;
   /**
    * `$replaceRoot`. Preserves `UpdateEnabled` (representable as
    * update-with-pipeline `$replaceRoot`); clears `FindAndModifyEnabled`.
    * Nested path shape is reset — the replaced root has no relation to
    * the original document structure.
    */
-  replaceRoot<NewShape extends DocShape>(fn: (fields: FieldAccessor<Shape, N$1>) => Expression<DocField> | TypedAggExpr<DocField>): PipelineChain<TContract, NewShape, U$1, 'fam-cleared', 'past-leading'>;
+  replaceRoot<NewShape extends DocShape>(fn: (fields: FieldAccessor<Shape, N>) => Expression<DocField> | TypedAggExpr<DocField>): PipelineChain<TContract, NewShape, U, 'fam-cleared', 'past-leading'>;
   count<Field extends string>(field: Field): PipelineChain<TContract, Record<Field, {
     readonly codecId: 'mongo/double@1';
     readonly nullable: false;
   }>, 'update-cleared', 'fam-cleared', 'past-leading'>;
-  sortByCount<F2 extends DocField>(fn: (fields: FieldAccessor<Shape, N$1>) => Expression<F2> | TypedAggExpr<F2>): PipelineChain<TContract, {
+  sortByCount<F2 extends DocField>(fn: (fields: FieldAccessor<Shape, N>) => Expression<F2> | TypedAggExpr<F2>): PipelineChain<TContract, {
     _id: F2;
     count: {
       readonly codecId: 'mongo/double@1';
@@ -884,7 +883,7 @@ declare class PipelineChain<TContract extends MongoContractWithTypeMaps<MongoCon
    * `$redact`. Preserves `UpdateEnabled`; clears `FindAndModifyEnabled`.
    * Shape- and nested-path-preserving (the document tree is unchanged).
    */
-  redact(fn: (fields: FieldAccessor<Shape, N$1>) => Expression<DocField> | TypedAggExpr<DocField>): PipelineChain<TContract, Shape, U$1, 'fam-cleared', 'past-leading', N$1>;
+  redact(fn: (fields: FieldAccessor<Shape, N>) => Expression<DocField> | TypedAggExpr<DocField>): PipelineChain<TContract, Shape, U, 'fam-cleared', 'past-leading', N>;
   /**
    * `$out` write terminal. Materialises the pipeline output into
    * `collection` (optionally in `db`), replacing any prior contents. Unlike
@@ -914,7 +913,7 @@ declare class PipelineChain<TContract extends MongoContractWithTypeMaps<MongoCon
     whenMatched?: string | ReadonlyArray<MongoUpdatePipelineStage>;
     whenNotMatched?: string;
   }): MongoQueryPlan<unknown, AggregateCommand>;
-  unionWith(collection: string, pipeline?: ReadonlyArray<MongoPipelineStage>): PipelineChain<TContract, Shape, 'update-cleared', 'fam-cleared', 'past-leading', N$1>;
+  unionWith(collection: string, pipeline?: ReadonlyArray<MongoPipelineStage>): PipelineChain<TContract, Shape, 'update-cleared', 'fam-cleared', 'past-leading', N>;
   bucket(options: {
     groupBy: MongoAggExpr;
     boundaries: ReadonlyArray<unknown>;
@@ -958,14 +957,14 @@ declare class PipelineChain<TContract extends MongoContractWithTypeMaps<MongoCon
     field: string;
     partitionByFields?: ReadonlyArray<string>;
     range: MongoDensifyRange;
-  }): PipelineChain<TContract, Shape, 'update-cleared', 'fam-cleared', 'past-leading', N$1>;
+  }): PipelineChain<TContract, Shape, 'update-cleared', 'fam-cleared', 'past-leading', N>;
   fill(options: {
     partitionBy?: MongoAggExpr;
     partitionByFields?: ReadonlyArray<string>;
     sortBy?: Record<string, 1 | -1>;
     output: Record<string, MongoFillOutput>;
-  }): PipelineChain<TContract, Shape, 'update-cleared', 'fam-cleared', 'past-leading', N$1>;
-  search(config: Record<string, unknown>, index?: string): PipelineChain<TContract, Shape, 'update-cleared', 'fam-cleared', 'past-leading', N$1>;
+  }): PipelineChain<TContract, Shape, 'update-cleared', 'fam-cleared', 'past-leading', N>;
+  search(config: Record<string, unknown>, index?: string): PipelineChain<TContract, Shape, 'update-cleared', 'fam-cleared', 'past-leading', N>;
   searchMeta(config: Record<string, unknown>, index?: string): PipelineChain<TContract, DocShape, 'update-cleared', 'fam-cleared', 'past-leading'>;
   vectorSearch(options: {
     index: string;
@@ -974,7 +973,7 @@ declare class PipelineChain<TContract extends MongoContractWithTypeMaps<MongoCon
     numCandidates: number;
     limit: number;
     filter?: Record<string, unknown>;
-  }): PipelineChain<TContract, Shape, 'update-cleared', 'fam-cleared', 'past-leading', N$1>;
+  }): PipelineChain<TContract, Shape, 'update-cleared', 'fam-cleared', 'past-leading', N>;
   pipe(stage: MongoPipelineStage): PipelineChain<TContract, Shape, 'update-cleared', 'fam-cleared', 'past-leading'>;
   pipe<NewShape extends DocShape>(stage: MongoPipelineStage): PipelineChain<TContract, NewShape, 'update-cleared', 'fam-cleared', 'past-leading'>;
   /**
@@ -995,14 +994,14 @@ declare class PipelineChain<TContract extends MongoContractWithTypeMaps<MongoCon
    * code. See `docs/architecture docs/adrs/ADR 201 - State-machine
    * pattern for typed DSL builders.md` for the marker-transition table.
    */
-  updateMany(this: PipelineChain<TContract, Shape, 'update-ok', F, L, N$1>, updaterFn?: (fields: FieldAccessor<Shape, N$1>) => UpdaterResult): MongoQueryPlan<UpdateResult$1, UpdateManyCommand>;
+  updateMany(this: PipelineChain<TContract, Shape, 'update-ok', F, L, N>, updaterFn?: (fields: FieldAccessor<Shape, N>) => UpdaterResult): MongoQueryPlan<UpdateResult$1, UpdateManyCommand>;
   /**
    * No-arg `updateOne()`: same as `updateMany()` but maps to a single-doc
    * update. Carries the same optional-callback/subclass-compat caveat
    * documented above — the callback form is reachable only via forced
    * casts in internal tests.
    */
-  updateOne(this: PipelineChain<TContract, Shape, 'update-ok', F, L, N$1>, updaterFn?: (fields: FieldAccessor<Shape, N$1>) => UpdaterResult): MongoQueryPlan<UpdateResult$1, UpdateOneCommand>;
+  updateOne(this: PipelineChain<TContract, Shape, 'update-ok', F, L, N>, updaterFn?: (fields: FieldAccessor<Shape, N>) => UpdaterResult): MongoQueryPlan<UpdateResult$1, UpdateOneCommand>;
   /**
    * Find a single document matching the accumulated pipeline (which must
    * consist solely of leading `$match` stages followed by at most one
@@ -1016,7 +1015,7 @@ declare class PipelineChain<TContract extends MongoContractWithTypeMaps<MongoCon
    * runtime error is thrown as a defensive check (the type system should
    * prevent this).
    */
-  findOneAndUpdate(this: PipelineChain<TContract, Shape, U$1, 'fam-ok', L, N$1>, updaterFn: (fields: FieldAccessor<Shape, N$1>) => UpdaterResult, opts?: {
+  findOneAndUpdate(this: PipelineChain<TContract, Shape, U, 'fam-ok', L, N>, updaterFn: (fields: FieldAccessor<Shape, N>) => UpdaterResult, opts?: {
     readonly upsert?: boolean;
     readonly returnDocument?: 'before' | 'after';
   }): MongoQueryPlan<ResolveRow<Shape, ExtractMongoCodecTypes<TContract>, TContract> | null, FindOneAndUpdateCommand>;
@@ -1024,7 +1023,7 @@ declare class PipelineChain<TContract extends MongoContractWithTypeMaps<MongoCon
    * Find a single document matching the accumulated pipeline and delete it.
    * Same marker gating and deconstruction as `findOneAndUpdate`.
    */
-  findOneAndDelete(this: PipelineChain<TContract, Shape, U$1, 'fam-ok', L, N$1>): MongoQueryPlan<ResolveRow<Shape, ExtractMongoCodecTypes<TContract>, TContract> | null, FindOneAndDeleteCommand>;
+  findOneAndDelete(this: PipelineChain<TContract, Shape, U, 'fam-ok', L, N>): MongoQueryPlan<ResolveRow<Shape, ExtractMongoCodecTypes<TContract>, TContract> | null, FindOneAndDeleteCommand>;
   /**
    * Materialise the chain as a `MongoQueryPlan` wrapping an `AggregateCommand`.
    */
@@ -1214,14 +1213,14 @@ declare const fn: {
  *    accidentally produce an unqualified write by forgetting to `.match(...)`
  *    later in the chain. Bodies land in M2.
  */
-declare class CollectionHandle<TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>, ModelName$1 extends keyof TContract['models'] & string> extends PipelineChain<TContract, ModelToDocShape<TContract, ModelName$1>, 'update-cleared', 'fam-cleared', 'leading', ModelNestedShape<TContract, ModelName$1>> {
+declare class CollectionHandle<TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>, ModelName extends keyof TContract['models'] & string> extends PipelineChain<TContract, ModelToDocShape<TContract, ModelName>, 'update-cleared', 'fam-cleared', 'leading', ModelNestedShape<TContract, ModelName>> {
   #private;
-  constructor(ctx: BindingContext<TContract>, modelName: ModelName$1);
+  constructor(ctx: BindingContext<TContract>, modelName: ModelName);
   /**
    * Bound model name. Exposed so type tests can assert the binding without
    * flipping into a pipeline. Not part of the public-API contract.
    */
-  get _modelName(): ModelName$1;
+  get _modelName(): ModelName;
   /**
    * Begin accumulating a filter. Transitions to `FilteredCollection`.
    *
@@ -1231,8 +1230,8 @@ declare class CollectionHandle<TContract extends MongoContractWithTypeMaps<Mongo
    * Mongo — but `FilteredCollection` makes the accumulated filter
    * addressable for the write/find-and-modify terminals landing in M2/M3.
    */
-  match(filter: MongoFilterExpr): FilteredCollection<TContract, ModelName$1>;
-  match(fn: (fields: FieldAccessor<ModelToDocShape<TContract, ModelName$1>, ModelNestedShape<TContract, ModelName$1>>) => MongoFilterExpr): FilteredCollection<TContract, ModelName$1>;
+  match(filter: MongoFilterExpr): FilteredCollection<TContract, ModelName>;
+  match(fn: (fields: FieldAccessor<ModelToDocShape<TContract, ModelName>, ModelNestedShape<TContract, ModelName>>) => MongoFilterExpr): FilteredCollection<TContract, ModelName>;
   /**
    * Insert a single document. Document fields are passed straight through to
    * the wire `InsertOneCommand` — codec normalisation happens at the
@@ -1255,7 +1254,7 @@ declare class CollectionHandle<TContract extends MongoContractWithTypeMaps<Mongo
    * unqualified write by forgetting to `.match(...)` first. Pair with
    * `.match(...).updateMany(...)` for the filtered case.
    */
-  updateAll(updaterFn: (fields: FieldAccessor<ModelToDocShape<TContract, ModelName$1>, ModelNestedShape<TContract, ModelName$1>>) => UpdaterResult): MongoQueryPlan<UpdateResult$1, UpdateManyCommand>;
+  updateAll(updaterFn: (fields: FieldAccessor<ModelToDocShape<TContract, ModelName>, ModelNestedShape<TContract, ModelName>>) => UpdaterResult): MongoQueryPlan<UpdateResult$1, UpdateManyCommand>;
   /**
    * Delete *every* document in the collection. See `updateAll` for the
    * rationale around the unqualified-write surface being limited to this
@@ -1272,7 +1271,7 @@ declare class CollectionHandle<TContract extends MongoContractWithTypeMaps<Mongo
    * new document derived from the filter equality fields plus the update
    * spec when no match is found; otherwise updates the matched document.
    */
-  upsertOne(filterFn: (fields: FieldAccessor<ModelToDocShape<TContract, ModelName$1>, ModelNestedShape<TContract, ModelName$1>>) => MongoFilterExpr, updaterFn: (fields: FieldAccessor<ModelToDocShape<TContract, ModelName$1>, ModelNestedShape<TContract, ModelName$1>>) => UpdaterResult): MongoQueryPlan<UpdateResult$1, UpdateOneCommand>;
+  upsertOne(filterFn: (fields: FieldAccessor<ModelToDocShape<TContract, ModelName>, ModelNestedShape<TContract, ModelName>>) => MongoFilterExpr, updaterFn: (fields: FieldAccessor<ModelToDocShape<TContract, ModelName>, ModelNestedShape<TContract, ModelName>>) => UpdaterResult): MongoQueryPlan<UpdateResult$1, UpdateOneCommand>;
 }
 /**
  * State reached after one or more `.match(...)` calls on `CollectionHandle`.
@@ -1298,10 +1297,10 @@ declare class CollectionHandle<TContract extends MongoContractWithTypeMaps<Mongo
  * — those are insert or unqualified-write operations that are nonsense
  * after a filter has been applied.
  */
-declare class FilteredCollection<TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>, ModelName$1 extends keyof TContract['models'] & string> extends PipelineChain<TContract, ModelToDocShape<TContract, ModelName$1>, 'update-cleared', 'fam-cleared', 'leading', ModelNestedShape<TContract, ModelName$1>> {
+declare class FilteredCollection<TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>, ModelName extends keyof TContract['models'] & string> extends PipelineChain<TContract, ModelToDocShape<TContract, ModelName>, 'update-cleared', 'fam-cleared', 'leading', ModelNestedShape<TContract, ModelName>> {
   #private;
-  constructor(ctx: BindingContext<TContract>, modelName: ModelName$1, filters: ReadonlyArray<MongoFilterExpr>);
-  get _modelName(): ModelName$1;
+  constructor(ctx: BindingContext<TContract>, modelName: ModelName, filters: ReadonlyArray<MongoFilterExpr>);
+  get _modelName(): ModelName;
   /**
    * Accumulated filter list. Exposed for the M2/M3 write/find-and-modify
    * terminals to splat into wire-command `filter` slots; not part of the
@@ -1315,8 +1314,8 @@ declare class FilteredCollection<TContract extends MongoContractWithTypeMaps<Mon
    * second `$match` stage), so the write/find-and-modify terminals see a
    * single authoritative filter expression.
    */
-  match(filter: MongoFilterExpr): FilteredCollection<TContract, ModelName$1>;
-  match(fn: (fields: FieldAccessor<ModelToDocShape<TContract, ModelName$1>, ModelNestedShape<TContract, ModelName$1>>) => MongoFilterExpr): FilteredCollection<TContract, ModelName$1>;
+  match(filter: MongoFilterExpr): FilteredCollection<TContract, ModelName>;
+  match(fn: (fields: FieldAccessor<ModelToDocShape<TContract, ModelName>, ModelNestedShape<TContract, ModelName>>) => MongoFilterExpr): FilteredCollection<TContract, ModelName>;
   /**
    * Update every matching document. `updaterFn` receives a `FieldAccessor`
    * and returns an array of `TypedUpdateOp` (e.g. `[f.amount.inc(1),
@@ -1324,14 +1323,14 @@ declare class FilteredCollection<TContract extends MongoContractWithTypeMaps<Mon
    * update spec by `foldUpdateOps`, which throws on operator+path
    * collisions.
    */
-  updateMany(updaterFn: (fields: FieldAccessor<ModelToDocShape<TContract, ModelName$1>, ModelNestedShape<TContract, ModelName$1>>) => UpdaterResult): MongoQueryPlan<UpdateResult$1, UpdateManyCommand>;
+  updateMany(updaterFn: (fields: FieldAccessor<ModelToDocShape<TContract, ModelName>, ModelNestedShape<TContract, ModelName>>) => UpdaterResult): MongoQueryPlan<UpdateResult$1, UpdateManyCommand>;
   /**
    * Update at most one matching document. The driver picks the document
    * (typically the first one matched by the underlying scan); no ordering
    * guarantee is implied — chain `.sort(...)` and use the M3
    * `.findOneAndUpdate(...)` terminal when ordering matters.
    */
-  updateOne(updaterFn: (fields: FieldAccessor<ModelToDocShape<TContract, ModelName$1>, ModelNestedShape<TContract, ModelName$1>>) => UpdaterResult): MongoQueryPlan<UpdateResult$1, UpdateOneCommand>;
+  updateOne(updaterFn: (fields: FieldAccessor<ModelToDocShape<TContract, ModelName>, ModelNestedShape<TContract, ModelName>>) => UpdaterResult): MongoQueryPlan<UpdateResult$1, UpdateOneCommand>;
   /**
    * Delete every matching document.
    */
@@ -1347,7 +1346,7 @@ declare class FilteredCollection<TContract extends MongoContractWithTypeMaps<Mon
    * `CollectionHandle.upsertOne(f => filter, updaterFn)` but reuses the
    * already-accumulated `.match(...)` filter chain.
    */
-  upsertOne(updaterFn: (fields: FieldAccessor<ModelToDocShape<TContract, ModelName$1>, ModelNestedShape<TContract, ModelName$1>>) => UpdaterResult): MongoQueryPlan<UpdateResult$1, UpdateOneCommand>;
+  upsertOne(updaterFn: (fields: FieldAccessor<ModelToDocShape<TContract, ModelName>, ModelNestedShape<TContract, ModelName>>) => UpdaterResult): MongoQueryPlan<UpdateResult$1, UpdateOneCommand>;
   /**
    * Find a single matching document and apply `updaterFn` to it.
    *
@@ -1355,15 +1354,15 @@ declare class FilteredCollection<TContract extends MongoContractWithTypeMaps<Mon
    * `opts.returnDocument` (default `'after'`) controls whether the row
    * stream yields the document as it was before or after the update.
    */
-  findOneAndUpdate(updaterFn: (fields: FieldAccessor<ModelToDocShape<TContract, ModelName$1>, ModelNestedShape<TContract, ModelName$1>>) => UpdaterResult, opts?: {
+  findOneAndUpdate(updaterFn: (fields: FieldAccessor<ModelToDocShape<TContract, ModelName>, ModelNestedShape<TContract, ModelName>>) => UpdaterResult, opts?: {
     readonly upsert?: boolean;
     readonly returnDocument?: 'before' | 'after';
-  }): MongoQueryPlan<ResolveRow<ModelToDocShape<TContract, ModelName$1>, ExtractMongoCodecTypes<TContract>, TContract> | null, FindOneAndUpdateCommand>;
+  }): MongoQueryPlan<ResolveRow<ModelToDocShape<TContract, ModelName>, ExtractMongoCodecTypes<TContract>, TContract> | null, FindOneAndUpdateCommand>;
   /**
    * Find a single matching document and delete it. Returns the deleted
    * document via the row stream.
    */
-  findOneAndDelete(): MongoQueryPlan<ResolveRow<ModelToDocShape<TContract, ModelName$1>, ExtractMongoCodecTypes<TContract>, TContract> | null, FindOneAndDeleteCommand>;
+  findOneAndDelete(): MongoQueryPlan<ResolveRow<ModelToDocShape<TContract, ModelName>, ExtractMongoCodecTypes<TContract>, TContract> | null, FindOneAndDeleteCommand>;
 }
 /**
  * Bound execution context shared across the three state classes.
@@ -1387,8 +1386,8 @@ interface BindingContext<TContract extends MongoContractWithTypeMaps<MongoContra
  * cannot know what the caller's command yields.
  */
 interface QueryRoot<TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>> {
-  from<K$1 extends keyof TContract['roots'] & string>(rootName: K$1): CollectionHandle<TContract, TContract['roots'][K$1] & string & keyof TContract['models']>;
-  rawCommand<C$1 extends AnyMongoCommand>(command: C$1): MongoQueryPlan<unknown, C$1>;
+  from<K extends keyof TContract['roots'] & string>(rootName: K): CollectionHandle<TContract, TContract['roots'][K] & string & keyof TContract['models']>;
+  rawCommand<C extends AnyMongoCommand>(command: C): MongoQueryPlan<unknown, C>;
 }
 declare function mongoQuery<TContract extends MongoContractWithTypeMaps<MongoContract, MongoTypeMaps>>(options: {
   contractJson: unknown;