@prisma/orm-target-mongo 8.0.0-rc.12-dev.8 → 8.0.0-rc.12-dev.10

package/dist/{control-CDO-vU3z.d.mts → control-Cfov50jX.d.mts}

@@ -1,15 +1,15 @@
-import { a as MongoRunnerDependencies } from "./control-CbxqWOJS.mjs";
-import { s as OpFactoryCall$1 } from "./op-factory-call-B7EKa4Ri-B2Lb6W68.mjs";
+import { s as OpFactoryCall$1 } from "./op-factory-call-DV0hKDUc-DHt1CB5L.mjs";
 import { Namespace, NamespaceBase } from "@prisma/orm-framework/components/ir";
 import { AnyMongoMigrationOperation, MongoAndExpr, MongoExistsExpr, MongoExprFilter, MongoFieldFilter, MongoFilterExpr, MongoFilterVisitor, MongoMigrationPlanOperation, MongoNotExpr, MongoOrExpr } from "@prisma/orm-family-mongo/query-ast/control";
-import { MongoSchemaIR } from "@prisma/orm-family-mongo/schema-ir";
 import { MongoControlTargetDescriptor } from "@prisma/orm-family-mongo/family/control";
 import { Result } from "@prisma/orm-framework/utils/result";
+import { MongoContractSerializerBase, MongoSchemaVerifierBase } from "@prisma/orm-family-mongo/family/ir";
+import { MongoCollection, MongoCollectionInput, MongoContract, MongoNamespaceEntries, MongoStorage, MongoValueSetInput } from "@prisma/orm-family-mongo/contract";
+import { MongoSchemaIR } from "@prisma/orm-family-mongo/schema-ir";
 import { Migration, MigrationMeta } from "@prisma/orm-toolchain/migration-tools/migration";
 import { MigrationOperationPolicy, MigrationPlan, MigrationPlanOperation, MigrationPlanWithAuthoringSurface, MigrationPlanner, MigrationPlannerConflict, MigrationPlannerResult, MigrationRunnerExecutionChecks, MigrationRunnerFailure, MigrationRunnerPerSpaceSuccessValue, MigrationScaffoldContext, OperationContext, SchemaDiffIssue, SchemaVerifyOptions, VerifyDatabaseSchemaResult } from "@prisma/orm-framework/components/control";
 import { ImportSpecifierResolver } from "@prisma/orm-framework/components/emission";
-import { MongoContractSerializerBase, MongoSchemaVerifierBase } from "@prisma/orm-family-mongo/family/ir";
-import { MongoCollection, MongoCollectionInput, MongoContract, MongoNamespaceEntries, MongoStorage, MongoValueSetInput } from "@prisma/orm-family-mongo/contract";
+import { MongoRunnerDependencies } from "@prisma/orm-family-mongo/family/control-adapter";
 import { Contract } from "@prisma/orm-framework/contract/types";
 import { TargetBoundComponentDescriptor } from "@prisma/orm-framework/components/components";
 import { AggregateMigrationEdgeRef } from "@prisma/orm-toolchain/migration-tools/aggregate";
@@ -30,7 +30,7 @@ type MongoTargetContract = Omit<MongoContract, 'storage'> & {
   readonly storage: MongoStorage;
 };
 //#endregion
-//#region src/core/control-target.d.ts
+//#region src/core/migrations/control-target.d.ts
 /**
  * `migration.ts` default-exports a `Migration` subclass whose `operations`
  * getter returns the ordered list of operations and whose `describe()`
@@ -43,7 +43,7 @@ type MongoTargetContract = Omit<MongoContract, 'storage'> & {
  */
 declare const mongoTargetDescriptor: MongoControlTargetDescriptor<MongoTargetContract>;
 //#endregion
-//#region src/core/filter-evaluator.d.ts
+//#region src/core/migrations/filter-evaluator.d.ts
 declare class FilterEvaluator implements MongoFilterVisitor<boolean> {
   private doc;
   evaluate(filter: MongoFilterExpr, doc: Record<string, unknown>): boolean;
@@ -55,12 +55,12 @@ declare class FilterEvaluator implements MongoFilterVisitor<boolean> {
   expr(_expr: MongoExprFilter): boolean;
 }
 //#endregion
-//#region src/core/mongo-ops-serializer.d.ts
+//#region src/core/migrations/mongo-ops-serializer.d.ts
 declare function deserializeMongoOp(json: unknown): AnyMongoMigrationOperation;
 declare function deserializeMongoOps(json: readonly unknown[]): AnyMongoMigrationOperation[];
 declare function serializeMongoOps(ops: readonly AnyMongoMigrationOperation[]): string;
 //#endregion
-//#region src/core/mongo-planner.d.ts
+//#region src/core/migrations/mongo-planner.d.ts
 type PlanCallsResult = {
   readonly kind: 'success';
   readonly calls: OpFactoryCall$1[];
@@ -105,7 +105,7 @@ declare class MongoMigrationPlanner implements MigrationPlanner<'mongo', 'mongo'
   emptyMigration(context: MigrationScaffoldContext): MigrationPlanWithAuthoringSurface;
 }
 //#endregion
-//#region src/core/mongo-runner.d.ts
+//#region src/core/migrations/mongo-runner.d.ts
 interface MongoMigrationRunnerExecuteOptions {
   readonly plan: MigrationPlan;
   readonly destinationContract: MongoContract;
@@ -146,74 +146,7 @@ declare class MongoMigrationRunner {
   private ensureMarkerCompatibility;
 }
 //#endregion
-//#region src/core/mongo-target-contract-serializer.d.ts
-declare class MongoTargetContractSerializer extends MongoContractSerializerBase<MongoTargetContract> {
-  protected constructTargetContract(validated: MongoContract): MongoTargetContract;
-  serializeContract(contract: MongoTargetContract): JsonObject;
-}
-//#endregion
-//#region src/core/mongo-target-database.d.ts
-interface MongoTargetDatabaseInput {
-  readonly id: string;
-  readonly entries?: Readonly<Record<string, Readonly<Record<string, unknown>>>> & {
-    readonly collection?: Readonly<Record<string, MongoCollectionInput>>;
-    readonly valueSet?: Readonly<Record<string, MongoValueSetInput>>;
-  };
-}
-/**
- * Mongo target `Namespace` concretion. In Mongo the "namespace" concept
- * binds to the connection's `db` field — a `MongoTargetDatabase` instance
- * names the database the collections live under. `entries['collection']`
- * holds collection IR. The unbound singleton (below) is the late-bound
- * namespace whose binding the connection's `db` resolves at runtime rather
- * than at authoring time.
- *
- * Qualifier emission is the rendering seam: query / DDL emission asks the
- * namespace for its qualifier (e.g. `"<db>.<collection>"`) and consumes
- * the result polymorphically. The unbound singleton overrides these
- * methods to elide the prefix entirely — call sites stay polymorphic and
- * never branch on `id === UNBOUND_NAMESPACE_ID`.
- */
-declare class MongoTargetDatabase extends NamespaceBase {
-  readonly kind: string;
-  readonly id: string;
-  readonly entries: MongoNamespaceEntries;
-  constructor(input: MongoTargetDatabaseInput);
-  get collection(): Readonly<Record<string, MongoCollection>>;
-  /**
-   * The bare qualifier as it would appear in a rendered string. The
-   * unbound-database singleton overrides this to return `''`.
-   */
-  qualifier(): string;
-  /**
-   * Qualify a collection name with the database prefix. The
-   * unbound-database singleton overrides this to emit just the
-   * collection name. Used by emission/introspection paths that need a
-   * fully-qualified reference.
-   */
-  qualifyCollection(collectionName: string): string;
-}
-/**
- * Singleton subclass for the reserved sentinel namespace id
- * (`UNBOUND_NAMESPACE_ID`) — the late-bound namespace whose binding the
- * connection's `db` resolves at runtime. Overrides qualifier emission
- * to elide the database prefix; call sites that consume `qualifier()`
- * / `qualifyCollection()` get unqualified output without branching on
- * the namespace id.
- *
- * This is the target-side materialization of "the framework provides
- * affordances; targets implement specifics": the framework names the
- * sentinel; Mongo decides what late-bound means here (the collection
- * name, naked — the database is supplied by the live connection).
- */
-declare class MongoTargetUnboundDatabase extends MongoTargetDatabase {
-  static readonly instance: MongoTargetUnboundDatabase;
-  private constructor();
-  qualifier(): string;
-  qualifyCollection(collectionName: string): string;
-}
-//#endregion
-//#region src/core/mongo-target-schema-verifier.d.ts
+//#region src/core/migrations/mongo-target-schema-verifier.d.ts
 /**
  * Mongo target `SchemaVerifier` concretion. Extends the family base's
  * namespace-walk scaffolding and contributes the per-namespace diff via
@@ -245,7 +178,7 @@ declare class MongoTargetSchemaVerifier extends MongoSchemaVerifierBase<MongoTar
   protected verifyTargetExtensions(_options: SchemaVerifyOptions<MongoTargetContract, MongoSchemaIR>): readonly SchemaDiffIssue[];
 }
 //#endregion
-//#region src/core/planner-produced-migration.d.ts
+//#region src/core/migrations/planner-produced-migration.d.ts
 /**
  * Planner-produced Mongo migration, returned by `MongoMigrationPlanner.plan(...)`
  * and `MongoMigrationPlanner.emptyMigration(...)`.
@@ -272,10 +205,10 @@ declare class PlannerProducedMongoMigration extends Migration<AnyMongoMigrationO
   renderTypeScript(resolveImportSpecifier: ImportSpecifierResolver): string;
 }
 //#endregion
-//#region src/core/render-ops.d.ts
+//#region src/core/migrations/render-ops.d.ts
 declare function renderOps(calls: ReadonlyArray<OpFactoryCall$1>): MongoMigrationPlanOperation[];
 //#endregion
-//#region src/core/render-typescript.d.ts
+//#region src/core/migrations/render-typescript.d.ts
 interface RenderMigrationMeta {
   readonly from: string | null;
   readonly to: string;
@@ -308,5 +241,72 @@ interface RenderMigrationMeta {
  */
 declare function renderCallsToTypeScript(calls: ReadonlyArray<OpFactoryCall$1>, meta: RenderMigrationMeta): string;
 //#endregion
+//#region src/core/mongo-target-contract-serializer.d.ts
+declare class MongoTargetContractSerializer extends MongoContractSerializerBase<MongoTargetContract> {
+  protected constructTargetContract(validated: MongoContract): MongoTargetContract;
+  serializeContract(contract: MongoTargetContract): JsonObject;
+}
+//#endregion
+//#region src/core/mongo-target-database.d.ts
+interface MongoTargetDatabaseInput {
+  readonly id: string;
+  readonly entries?: Readonly<Record<string, Readonly<Record<string, unknown>>>> & {
+    readonly collection?: Readonly<Record<string, MongoCollectionInput>>;
+    readonly valueSet?: Readonly<Record<string, MongoValueSetInput>>;
+  };
+}
+/**
+ * Mongo target `Namespace` concretion. In Mongo the "namespace" concept
+ * binds to the connection's `db` field — a `MongoTargetDatabase` instance
+ * names the database the collections live under. `entries['collection']`
+ * holds collection IR. The unbound singleton (below) is the late-bound
+ * namespace whose binding the connection's `db` resolves at runtime rather
+ * than at authoring time.
+ *
+ * Qualifier emission is the rendering seam: query / DDL emission asks the
+ * namespace for its qualifier (e.g. `"<db>.<collection>"`) and consumes
+ * the result polymorphically. The unbound singleton overrides these
+ * methods to elide the prefix entirely — call sites stay polymorphic and
+ * never branch on `id === UNBOUND_NAMESPACE_ID`.
+ */
+declare class MongoTargetDatabase extends NamespaceBase {
+  readonly kind: string;
+  readonly id: string;
+  readonly entries: MongoNamespaceEntries;
+  constructor(input: MongoTargetDatabaseInput);
+  get collection(): Readonly<Record<string, MongoCollection>>;
+  /**
+   * The bare qualifier as it would appear in a rendered string. The
+   * unbound-database singleton overrides this to return `''`.
+   */
+  qualifier(): string;
+  /**
+   * Qualify a collection name with the database prefix. The
+   * unbound-database singleton overrides this to emit just the
+   * collection name. Used by emission/introspection paths that need a
+   * fully-qualified reference.
+   */
+  qualifyCollection(collectionName: string): string;
+}
+/**
+ * Singleton subclass for the reserved sentinel namespace id
+ * (`UNBOUND_NAMESPACE_ID`) — the late-bound namespace whose binding the
+ * connection's `db` resolves at runtime. Overrides qualifier emission
+ * to elide the database prefix; call sites that consume `qualifier()`
+ * / `qualifyCollection()` get unqualified output without branching on
+ * the namespace id.
+ *
+ * This is the target-side materialization of "the framework provides
+ * affordances; targets implement specifics": the framework names the
+ * sentinel; Mongo decides what late-bound means here (the collection
+ * name, naked — the database is supplied by the live connection).
+ */
+declare class MongoTargetUnboundDatabase extends MongoTargetDatabase {
+  static readonly instance: MongoTargetUnboundDatabase;
+  private constructor();
+  qualifier(): string;
+  qualifyCollection(collectionName: string): string;
+}
+//#endregion
 export { renderOps as _, MongoTargetContract as a, MongoTargetSchemaVerifier as c, PlannerProducedMongoMigration as d, RenderMigrationMeta as f, renderCallsToTypeScript as g, mongoTargetDescriptor as h, MongoMigrationRunnerExecuteOptions as i, MongoTargetUnboundDatabase as l, deserializeMongoOps as m, MongoMigrationPlanner as n, MongoTargetContractSerializer as o, deserializeMongoOp as p, MongoMigrationRunner as r, MongoTargetDatabase as s, FilterEvaluator as t, PlanCallsResult as u, serializeMongoOps as v };
-//# sourceMappingURL=control-CDO-vU3z.d.mts.map
+//# sourceMappingURL=control-Cfov50jX.d.mts.map

package/dist/control-Cfov50jX.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"control-Cfov50jX.d.mts","names":[],"sources":["../../../../3-mongo-target/1-mongo-target/dist/control.d.mts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;KA4BK,sBAAsB,KAAK;WACrB,SAAS;;;;;;;;;;;;;;cAcN,uBAAuB,6BAA6B;;;cAGpD,2BAA2B;UAC/B;EACR,SAAS,QAAQ,iBAAiB,KAAK;EACvC,MAAM,MAAM;EACZ,IAAI,MAAM;EACV,GAAG,MAAM;EACT,IAAI,MAAM;EACV,OAAO,MAAM;EACb,KAAK,OAAO;;;;iBAIG,mBAAmB,gBAAgB;iBACnC,oBAAoB,2BAA2B;iBAC/C,kBAAkB,cAAc;;;KAG5C;WACM;WACA,OAAO;;WAEP;WACA,WAAW;;cAER,iCAAiC;EAC7C,UAAU;aACC;aACA;aACA,QAAQ;aACR,qBAAqB,cAAc;MAC1C;EACJ,KAAK;aACM;aACA;aACA,QAAQ;;;;;;aAMR,cAAc;aACd,qBAAqB,cAAc;;;;;;aAMnC;MACP;;;;;;;;;;EAUJ,eAAe,SAAS,2BAA2B;;;;UAI3C;WACC,MAAM;WACN,qBAAqB;WACrB,QAAQ;WACR;IACP,kBAAkB,IAAI;IACtB,qBAAqB,IAAI;;WAElB,kBAAkB;WAClB,qBAAqB,cAAc;WACnC;WACA,UAAU;;;;;;;;;;;WAWV,qBAAqB,QAAQ,+BAA+B;;WAE5D,yBAAyB;;KAE/B,6BAA6B,OAAO,qCAAqC;cAChE;mBACK;EACjB,YAAY,MAAM;EAClB,QAAQ,SAAS,qCAAqC,QAAQ;UACtD;UACA;UACA;UACA;UACA;UACA;UACA;;;;;;;;;;;;;;;;;;;;;;;;;cAyBI,kCAAkC,wBAAwB,qBAAqB;YACjF,gBAAgB;aACf,UAAU;aACV,QAAQ;aACR;aACA,WAAW;eACT;YACH,uBAAuB,UAAU,oBAAoB,qBAAqB,0BAA0B;;;;;;;;;;;;;;;;;;;cAmBlG,sCAAsC,UAAU,uCAAuC;mBAClF;mBACA;mBACA;WACR;EACT,YAAY,gBAAgB,mBAAiB,MAAM,eAAe;MAC9D,uBAAuB;EAC3B,YAAY;EACZ,iBAAiB,wBAAwB;;;;iBAI1B,UAAU,OAAO,cAAc,mBAAiB;;;UAGvD;WACC;WACA;;WAEA;;;;;;;WAOA,yBAAyB;;;;;;;;;;;;;;;;;;;iBAmBnB,wBAAwB,OAAO,cAAc,kBAAgB,MAAM;;;cAGtE,sCAAsC,4BAA4B;YACpE,wBAAwB,WAAW,gBAAgB;EAC7D,kBAAkB,UAAU,sBAAsB;;;;UAI1C;WACC;WACA,UAAU,SAAS,eAAe,SAAS;aACzC,aAAa,SAAS,eAAe;aACrC,WAAW,SAAS,eAAe;;;;;;;;;;;;;;;;;cAiBlC,4BAA4B;WAC/B;WACA;WACA,SAAS;EAClB,YAAY,OAAO;MACf,cAAc,SAAS,eAAe;;;;;EAK1C;;;;;;;EAOA,kBAAkB;;;;;;;;;;;;;;;cAeN,mCAAmC;kBAC/B,UAAU;UAClB;EACR;EACA,kBAAkB"}

package/dist/{control-CB0AAVw_.mjs → control-DESRWr7S.mjs}

@@ -1,30 +1,155 @@
-import { t as mongoTargetDescriptorMeta } from "./descriptor-meta-BQRniVcn-8meGwEZr.mjs";
-import { a as dropCollection, n as createCollection, o as dropIndex, r as createIndex, t as collMod } from "./migration-factories-CqjDpXHw-fxXh_wY1.mjs";
-import { i as extractDb, r as createMongoRunnerDeps } from "./control-BDevch6o.mjs";
-import { n as MongoDriverImpl } from "./mongo-driver-BGXMvnQ8-B_flHHzS.mjs";
-import { structuredError } from "@prisma/orm-framework/utils/structured-error";
+import { a as mongoTargetError } from "./codecs-ChbLv6Rd-BmoC4ktF.mjs";
+import { t as mongoTargetDescriptorMeta } from "./descriptor-meta-CSm-03KE-DDeX4NIT.mjs";
+import { a as dropCollection, n as createCollection, o as dropIndex, r as createIndex, t as collMod } from "./migration-factories-BwvR6Mvk-Ba1ywTUZ.mjs";
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
 import { NamespaceBase, UNBOUND_NAMESPACE_ID, elementCoordinates, freezeNode, hydrateNamespaceEntities } from "@prisma/orm-framework/components/ir";
 import { blindCast } from "@prisma/orm-framework/utils/casts";
 import { CollModCommand, CreateCollectionCommand, CreateIndexCommand, DropCollectionCommand, DropIndexCommand, ListCollectionsCommand, ListIndexesCommand, MongoAndExpr, MongoExistsExpr, MongoFieldFilter, MongoNotExpr, MongoOrExpr } from "@prisma/orm-family-mongo/query-ast/control";
-import { AggregateCommand, MongoAddFieldsStage, MongoLimitStage, MongoLookupStage, MongoMatchStage, MongoMergeStage, MongoProjectStage, MongoSortStage, RawAggregateCommand, RawDeleteManyCommand, RawDeleteOneCommand, RawFindOneAndDeleteCommand, RawFindOneAndUpdateCommand, RawInsertManyCommand, RawInsertOneCommand, RawUpdateManyCommand, RawUpdateOneCommand } from "@prisma/orm-family-mongo/query-ast/execution";
-import { InternalError } from "@prisma/orm-framework/utils/internal-error";
-import { canonicalize, deepEqual } from "@prisma/orm-family-mongo/schema-ir";
-import { errorRunnerFailed } from "@prisma/orm-framework/errors/execution";
-import { type } from "arktype";
 import { canonicalizeSchemasForVerification, contractToMongoSchemaIR, diffMongoSchemas } from "@prisma/orm-family-mongo/family/control";
 import { notOk, ok } from "@prisma/orm-framework/utils/result";
+import { MongoContractSerializerBase, MongoSchemaVerifierBase } from "@prisma/orm-family-mongo/family/ir";
+import { MongoStorage } from "@prisma/orm-family-mongo/contract";
+import { composeMongoEntityKinds } from "@prisma/orm-family-mongo/contract/entity-kinds";
+import { canonicalize, deepEqual } from "@prisma/orm-family-mongo/schema-ir";
 import { TsExpression, jsonToTsSource, renderImports } from "@prisma/orm-framework/ts-render";
 import { Migration } from "@prisma/orm-toolchain/migration-tools/migration";
 import { APP_SPACE_ID, contractSnapshotJsonSpecifier, contractSnapshotTypesSpecifier, issueOutcome } from "@prisma/orm-framework/components/control";
 import { resolveRequirementSpecifiers } from "@prisma/orm-framework/components/emission";
 import { detectScaffoldRuntime, shebangLineFor } from "@prisma/orm-toolchain/migration-tools/migration-ts";
+import { errorRunnerFailed } from "@prisma/orm-framework/errors/execution";
 import { verifyMongoSchema } from "@prisma/orm-family-mongo/family/schema-verify";
-import { MongoContractSerializerBase, MongoSchemaVerifierBase } from "@prisma/orm-family-mongo/family/ir";
-import { MongoStorage } from "@prisma/orm-family-mongo/contract";
-import { composeMongoEntityKinds } from "@prisma/orm-family-mongo/contract/entity-kinds";
+import { InternalError } from "@prisma/orm-framework/utils/internal-error";
+import { AggregateCommand, MongoAddFieldsStage, MongoLimitStage, MongoLookupStage, MongoMatchStage, MongoMergeStage, MongoProjectStage, MongoSortStage, RawAggregateCommand, RawDeleteManyCommand, RawDeleteOneCommand, RawFindOneAndDeleteCommand, RawFindOneAndUpdateCommand, RawInsertManyCommand, RawInsertOneCommand, RawUpdateManyCommand, RawUpdateOneCommand } from "@prisma/orm-family-mongo/query-ast/execution";
+import { type } from "arktype";
 //#region ../../../3-mongo-target/1-mongo-target/dist/control.mjs
 /**
+* Mongo target `Namespace` concretion. In Mongo the "namespace" concept
+* binds to the connection's `db` field — a `MongoTargetDatabase` instance
+* names the database the collections live under. `entries['collection']`
+* holds collection IR. The unbound singleton (below) is the late-bound
+* namespace whose binding the connection's `db` resolves at runtime rather
+* than at authoring time.
+*
+* Qualifier emission is the rendering seam: query / DDL emission asks the
+* namespace for its qualifier (e.g. `"<db>.<collection>"`) and consumes
+* the result polymorphically. The unbound singleton overrides these
+* methods to elide the prefix entirely — call sites stay polymorphic and
+* never branch on `id === UNBOUND_NAMESPACE_ID`.
+*/
+var MongoTargetDatabase = class extends NamespaceBase {
+	id;
+	entries;
+	constructor(input) {
+		super();
+		this.id = input.id;
+		const rawEntries = {
+			collection: {},
+			...input.entries
+		};
+		this.entries = Object.freeze(blindCast(hydrateNamespaceEntities(rawEntries, composeMongoEntityKinds(), "carry")));
+		Object.defineProperty(this, "kind", {
+			value: "database",
+			writable: false,
+			enumerable: false,
+			configurable: true
+		});
+		freezeNode(this);
+	}
+	get collection() {
+		return this.entries.collection ?? Object.freeze({});
+	}
+	/**
+	* The bare qualifier as it would appear in a rendered string. The
+	* unbound-database singleton overrides this to return `''`.
+	*/
+	qualifier() {
+		return this.id;
+	}
+	/**
+	* Qualify a collection name with the database prefix. The
+	* unbound-database singleton overrides this to emit just the
+	* collection name. Used by emission/introspection paths that need a
+	* fully-qualified reference.
+	*/
+	qualifyCollection(collectionName) {
+		return `${this.id}.${collectionName}`;
+	}
+};
+/**
+* Singleton subclass for the reserved sentinel namespace id
+* (`UNBOUND_NAMESPACE_ID`) — the late-bound namespace whose binding the
+* connection's `db` resolves at runtime. Overrides qualifier emission
+* to elide the database prefix; call sites that consume `qualifier()`
+* / `qualifyCollection()` get unqualified output without branching on
+* the namespace id.
+*
+* This is the target-side materialization of "the framework provides
+* affordances; targets implement specifics": the framework names the
+* sentinel; Mongo decides what late-bound means here (the collection
+* name, naked — the database is supplied by the live connection).
+*/
+var MongoTargetUnboundDatabase = class MongoTargetUnboundDatabase extends MongoTargetDatabase {
+	static instance = new MongoTargetUnboundDatabase();
+	constructor() {
+		super({ id: UNBOUND_NAMESPACE_ID });
+	}
+	qualifier() {
+		return "";
+	}
+	qualifyCollection(collectionName) {
+		return collectionName;
+	}
+};
+var MongoTargetContractSerializer = class extends MongoContractSerializerBase {
+	constructTargetContract(validated) {
+		const { storage, ...rest } = validated;
+		const namespaces = Object.fromEntries(Object.entries(storage.namespaces).map(([nsId, nsData]) => {
+			const collectionCount = Object.keys(nsData.entries.collection ?? {}).length;
+			const valueSetCount = Object.keys(nsData.entries["valueSet"] ?? {}).length;
+			if (nsId === UNBOUND_NAMESPACE_ID && collectionCount === 0 && valueSetCount === 0) return [nsId, MongoTargetUnboundDatabase.instance];
+			const dbInput = { id: nsData.id };
+			if (nsData.entries["collection"] !== void 0 || nsData.entries["valueSet"] !== void 0) dbInput.entries = {
+				collection: blindCast(nsData.entries["collection"] ?? {}),
+				...ifDefined("valueSet", blindCast(nsData.entries["valueSet"]))
+			};
+			return [nsId, new MongoTargetDatabase(dbInput)];
+		}));
+		const targetStorage = new MongoStorage({
+			storageHash: storage.storageHash,
+			namespaces
+		});
+		return {
+			...rest,
+			storage: targetStorage
+		};
+	}
+	serializeContract(contract) {
+		const { storage, ...rest } = contract;
+		const namespacesJson = {};
+		for (const [nsId, ns] of Object.entries(storage.namespaces)) {
+			const collectionsOut = {};
+			for (const [collName, coll] of Object.entries(ns.entries.collection ?? {})) collectionsOut[collName] = blindCast(JSON.parse(JSON.stringify(coll)));
+			const valueSetOut = {};
+			for (const [vsName, vs] of Object.entries(ns.entries.valueSet ?? {})) valueSetOut[vsName] = blindCast(JSON.parse(JSON.stringify(vs)));
+			namespacesJson[nsId] = {
+				id: ns.id,
+				kind: "mongo-database",
+				entries: {
+					collection: collectionsOut,
+					...ifDefined("valueSet", Object.keys(valueSetOut).length > 0 ? valueSetOut : void 0)
+				}
+			};
+		}
+		return blindCast({
+			...rest,
+			storage: {
+				storageHash: String(storage.storageHash),
+				namespaces: namespacesJson
+			}
+		});
+	}
+};
+/**
 * The single module a scaffolded Mongo `migration.ts` imports from: the
 * operation factories below, plus the `Migration` base and `MigrationCLI`
 * that `render-typescript.ts` adds. The authored name; `render-typescript.ts`
@@ -532,9 +657,6 @@ function planMutableOptionsDiffCall(collName, origin, dest) {
 		operationClass: desiredCSPPI.enabled ? "widening" : "destructive"
 	});
 }
-function mongoTargetError(code, message, options) {
-	return structuredError(code, message, options);
-}
 function isRecord(value) {
 	return value !== null && typeof value === "object";
 }
@@ -1330,133 +1452,6 @@ var MongoMigrationRunner = class {
 	}
 };
 /**
-* Mongo target `Namespace` concretion. In Mongo the "namespace" concept
-* binds to the connection's `db` field — a `MongoTargetDatabase` instance
-* names the database the collections live under. `entries['collection']`
-* holds collection IR. The unbound singleton (below) is the late-bound
-* namespace whose binding the connection's `db` resolves at runtime rather
-* than at authoring time.
-*
-* Qualifier emission is the rendering seam: query / DDL emission asks the
-* namespace for its qualifier (e.g. `"<db>.<collection>"`) and consumes
-* the result polymorphically. The unbound singleton overrides these
-* methods to elide the prefix entirely — call sites stay polymorphic and
-* never branch on `id === UNBOUND_NAMESPACE_ID`.
-*/
-var MongoTargetDatabase = class extends NamespaceBase {
-	id;
-	entries;
-	constructor(input) {
-		super();
-		this.id = input.id;
-		const rawEntries = {
-			collection: {},
-			...input.entries
-		};
-		this.entries = Object.freeze(blindCast(hydrateNamespaceEntities(rawEntries, composeMongoEntityKinds(), "carry")));
-		Object.defineProperty(this, "kind", {
-			value: "database",
-			writable: false,
-			enumerable: false,
-			configurable: true
-		});
-		freezeNode(this);
-	}
-	get collection() {
-		return this.entries.collection ?? Object.freeze({});
-	}
-	/**
-	* The bare qualifier as it would appear in a rendered string. The
-	* unbound-database singleton overrides this to return `''`.
-	*/
-	qualifier() {
-		return this.id;
-	}
-	/**
-	* Qualify a collection name with the database prefix. The
-	* unbound-database singleton overrides this to emit just the
-	* collection name. Used by emission/introspection paths that need a
-	* fully-qualified reference.
-	*/
-	qualifyCollection(collectionName) {
-		return `${this.id}.${collectionName}`;
-	}
-};
-/**
-* Singleton subclass for the reserved sentinel namespace id
-* (`UNBOUND_NAMESPACE_ID`) — the late-bound namespace whose binding the
-* connection's `db` resolves at runtime. Overrides qualifier emission
-* to elide the database prefix; call sites that consume `qualifier()`
-* / `qualifyCollection()` get unqualified output without branching on
-* the namespace id.
-*
-* This is the target-side materialization of "the framework provides
-* affordances; targets implement specifics": the framework names the
-* sentinel; Mongo decides what late-bound means here (the collection
-* name, naked — the database is supplied by the live connection).
-*/
-var MongoTargetUnboundDatabase = class MongoTargetUnboundDatabase extends MongoTargetDatabase {
-	static instance = new MongoTargetUnboundDatabase();
-	constructor() {
-		super({ id: UNBOUND_NAMESPACE_ID });
-	}
-	qualifier() {
-		return "";
-	}
-	qualifyCollection(collectionName) {
-		return collectionName;
-	}
-};
-var MongoTargetContractSerializer = class extends MongoContractSerializerBase {
-	constructTargetContract(validated) {
-		const { storage, ...rest } = validated;
-		const namespaces = Object.fromEntries(Object.entries(storage.namespaces).map(([nsId, nsData]) => {
-			const collectionCount = Object.keys(nsData.entries.collection ?? {}).length;
-			const valueSetCount = Object.keys(nsData.entries["valueSet"] ?? {}).length;
-			if (nsId === UNBOUND_NAMESPACE_ID && collectionCount === 0 && valueSetCount === 0) return [nsId, MongoTargetUnboundDatabase.instance];
-			const dbInput = { id: nsData.id };
-			if (nsData.entries["collection"] !== void 0 || nsData.entries["valueSet"] !== void 0) dbInput.entries = {
-				collection: blindCast(nsData.entries["collection"] ?? {}),
-				...ifDefined("valueSet", blindCast(nsData.entries["valueSet"]))
-			};
-			return [nsId, new MongoTargetDatabase(dbInput)];
-		}));
-		const targetStorage = new MongoStorage({
-			storageHash: storage.storageHash,
-			namespaces
-		});
-		return {
-			...rest,
-			storage: targetStorage
-		};
-	}
-	serializeContract(contract) {
-		const { storage, ...rest } = contract;
-		const namespacesJson = {};
-		for (const [nsId, ns] of Object.entries(storage.namespaces)) {
-			const collectionsOut = {};
-			for (const [collName, coll] of Object.entries(ns.entries.collection ?? {})) collectionsOut[collName] = blindCast(JSON.parse(JSON.stringify(coll)));
-			const valueSetOut = {};
-			for (const [vsName, vs] of Object.entries(ns.entries.valueSet ?? {})) valueSetOut[vsName] = blindCast(JSON.parse(JSON.stringify(vs)));
-			namespacesJson[nsId] = {
-				id: ns.id,
-				kind: "mongo-database",
-				entries: {
-					collection: collectionsOut,
-					...ifDefined("valueSet", Object.keys(valueSetOut).length > 0 ? valueSetOut : void 0)
-				}
-			};
-		}
-		return blindCast({
-			...rest,
-			storage: {
-				storageHash: String(storage.storageHash),
-				namespaces: namespacesJson
-			}
-		});
-	}
-};
-/**
 * Mongo target `SchemaVerifier` concretion. Extends the family base's
 * namespace-walk scaffolding and contributes the per-namespace diff via
 * `verifyNamespace`; the diff body reuses the existing target-side
@@ -1560,7 +1555,7 @@ const mongoTargetDescriptor = {
 		createRunner(family) {
 			let cachedDeps;
 			const runMongo = async (driver, runnerOptions) => {
-				cachedDeps ??= createMongoRunnerDeps(driver, MongoDriverImpl.fromDb(extractDb(driver)), family);
+				cachedDeps ??= family.createRunnerDependencies({ driver });
 				return new MongoMigrationRunner(cachedDeps).execute({
 					...runnerOptions,
 					destinationContract: blindCast(runnerOptions.destinationContract)
@@ -1605,4 +1600,4 @@ const mongoTargetDescriptor = {
 //#endregion
 export { renderCallsToTypeScript as _, DropIndexCall as a, schemaIndexToCreateIndexOptions as b, MongoMigrationRunner as c, MongoTargetSchemaVerifier as d, MongoTargetUnboundDatabase as f, mongoTargetDescriptor as g, deserializeMongoOps as h, DropCollectionCall as i, MongoTargetContractSerializer as l, deserializeMongoOp as m, CreateCollectionCall as n, FilterEvaluator as o, PlannerProducedMongoMigration as p, CreateIndexCall as r, MongoMigrationPlanner as s, CollModCall as t, MongoTargetDatabase as u, renderOps as v, serializeMongoOps as x, schemaCollectionToCreateCollectionOptions as y };
 
-//# sourceMappingURL=control-CB0AAVw_.mjs.map
+//# sourceMappingURL=control-DESRWr7S.mjs.map