@prisma-next/adapter-mongo 0.11.0 → 0.12.0

package/dist/{mongo-adapter-DfCmEYHR.mjs → mongo-adapter-DAC5qq3o.mjs}

@@ -1,4 +1,5 @@
 import { isExprArray, isRecordArgs } from "@prisma-next/mongo-query-ast/execution";
+import { blindCast } from "@prisma-next/utils/casts";
 import { checkAborted, raceAgainstAbort, runtimeError } from "@prisma-next/framework-components/runtime";
 import { MongoParamRef } from "@prisma-next/mongo-value";
 import { AggregateWireCommand, DeleteManyWireCommand, DeleteOneWireCommand, FindOneAndDeleteWireCommand, FindOneAndUpdateWireCommand, InsertManyWireCommand, InsertOneWireCommand, UpdateManyWireCommand, UpdateOneWireCommand } from "@prisma-next/mongo-wire";
@@ -73,11 +74,46 @@ async function resolveValue(value, codecs, ctx) {
 	}
 	return result;
 }
+/**
+* Resolves a draft slot value — which may be `MongoParamRef`, a primitive, a
+* nested plain-object, or an array — into the corresponding wire value.
+* Mirrors `resolveValue`'s traversal strategy but accepts `unknown` so it can
+* handle pipeline stage documents whose field types cannot be narrowed to
+* `MongoValue` statically (e.g. `$geoNear.near: unknown`).
+*/
+async function resolveDraftSlot(value, codecs, ctx) {
+	if (value instanceof MongoParamRef) return resolveValue(value, codecs, ctx);
+	if (value === null || typeof value !== "object") return value;
+	if (value instanceof Date) return value;
+	if (Array.isArray(value)) return raceAgainstAbort(Promise.all(value.map((v) => resolveDraftSlot(v, codecs, ctx))), ctx.signal, "encode");
+	return resolveDraftDoc(blindCast(value), codecs, ctx);
+}
+/**
+* Resolves a pipeline stage draft document by walking every entry and
+* forwarding to {@link resolveDraftSlot}. Used by `MongoAdapterImpl.resolveParams`
+* for aggregate pipeline stages, which carry `unknown`-typed fields (e.g.
+* `$geoNear.near`) alongside filter sub-documents that may contain
+* `MongoParamRef` leaves.
+*/
+async function resolveDraftDoc(doc, codecs, ctx) {
+	checkAborted(ctx, "encode");
+	const entries = Object.entries(doc);
+	const resolved = await raceAgainstAbort(Promise.all(entries.map(([, val]) => resolveDraftSlot(val, codecs, ctx))), ctx.signal, "encode");
+	const result = {};
+	for (let i = 0; i < entries.length; i++) {
+		const entry = entries[i];
+		if (entry) result[entry[0]] = resolved[i];
+	}
+	return result;
+}
 function paramRefLabel(ref, codecId) {
 	return ref.name ?? codecId;
 }
+function isErrorWithCode(error) {
+	return error instanceof Error && "code" in error;
+}
 function isAlreadyEncodeFailure(error) {
-	return error instanceof Error && "code" in error && error.code === "RUNTIME.ENCODE_FAILED";
+	return isErrorWithCode(error) && error.code === "RUNTIME.ENCODE_FAILED";
 }
 function wrapEncodeFailure(error, ref, codecId) {
 	if (isAlreadyEncodeFailure(error)) throw error;
@@ -168,6 +204,24 @@ function needsLiteralWrap(value) {
 function lowerAggExpr(expr) {
 	return expr.accept(aggExprLoweringVisitor);
 }
+/**
+* Structural phase of filter lowering: transforms the filter AST into a
+* plain object without resolving any `MongoParamRef` leaves. Field filter
+* values remain as `MongoValue` (which includes `MongoParamRef`), so the
+* returned document can be passed to `resolveDraftDoc` in the resolve phase.
+* Synchronous — no codec calls.
+*/
+function structuralLowerFilter(filter) {
+	switch (filter.kind) {
+		case "field": return { [filter.field]: { [filter.op]: filter.value } };
+		case "and": return { $and: filter.exprs.map((e) => structuralLowerFilter(e)) };
+		case "or": return { $or: filter.exprs.map((e) => structuralLowerFilter(e)) };
+		case "not": return { $nor: [structuralLowerFilter(filter.expr)] };
+		case "exists": return { [filter.field]: { $exists: filter.exists } };
+		case "expr": return { $expr: lowerAggExpr(filter.aggExpr) };
+		default: throw new Error(`Unhandled filter kind: ${blindCast(filter).kind}`);
+	}
+}
 async function lowerFilter(filter, codecs, ctx) {
 	switch (filter.kind) {
 		case "field": return { [filter.field]: { [filter.op]: await resolveValue(filter.value, codecs, ctx) } };
@@ -176,12 +230,15 @@ async function lowerFilter(filter, codecs, ctx) {
 		case "not": return { $nor: [await lowerFilter(filter.expr, codecs, ctx)] };
 		case "exists": return { [filter.field]: { $exists: filter.exists } };
 		case "expr": return { $expr: lowerAggExpr(filter.aggExpr) };
-		default: throw new Error(`Unhandled filter kind: ${filter.kind}`);
+		default: throw new Error(`Unhandled filter kind: ${blindCast(filter).kind}`);
 	}
 }
 function isAggExprNode(value) {
 	return "accept" in value && typeof value.accept === "function";
 }
+function isAggExprArray(val) {
+	return Array.isArray(val);
+}
 function lowerGroupId(groupId) {
 	if (groupId === null) return null;
 	if (isAggExprNode(groupId)) return lowerAggExpr(groupId);
@@ -189,7 +246,7 @@ function lowerGroupId(groupId) {
 }
 function lowerExprRecord(fields) {
 	const result = {};
-	for (const [key, val] of Object.entries(fields)) if (Array.isArray(val)) result[key] = val.map((v) => lowerAggExpr(v));
+	for (const [key, val] of Object.entries(fields)) if (isAggExprArray(val)) result[key] = val.map((v) => lowerAggExpr(v));
 	else result[key] = lowerAggExpr(val);
 	return result;
 }
@@ -369,12 +426,186 @@ async function lowerStage(stage, codecs, ctx) {
 			if (stage.filter) vs["filter"] = { ...stage.filter };
 			return { $vectorSearch: vs };
 		}
-		default: throw new Error(`Unhandled stage kind: ${stage.kind}`);
+		default: throw new Error(`Unhandled stage kind: ${blindCast(stage).kind}`);
 	}
 }
 async function lowerPipeline(stages, codecs, ctx) {
 	return Promise.all(stages.map((s) => lowerStage(s, codecs, ctx)));
 }
+/**
+* Structural phase of stage lowering: mirrors `lowerStage` but defers all
+* `MongoParamRef` resolution. Filter sub-documents within stages (e.g.
+* `$match`, `$geoNear.query`, `$graphLookup.restrictSearchWithMatch`) are
+* produced by `structuralLowerFilter` and therefore retain `MongoParamRef`
+* leaves. Sub-pipelines (e.g. `$lookup.pipeline`, `$facet.*`) recurse via
+* `structuralLowerPipeline`. Synchronous — no codec calls.
+*/
+function structuralLowerStage(stage) {
+	switch (stage.kind) {
+		case "match": return { $match: structuralLowerFilter(stage.filter) };
+		case "project": {
+			const projection = {};
+			for (const [key, val] of Object.entries(stage.projection)) projection[key] = lowerProjectionValue(val);
+			return { $project: projection };
+		}
+		case "sort": return { $sort: { ...stage.sort } };
+		case "limit": return { $limit: stage.limit };
+		case "skip": return { $skip: stage.skip };
+		case "lookup": {
+			const lookup = {
+				from: stage.from,
+				as: stage.as
+			};
+			if (stage.localField !== void 0) lookup["localField"] = stage.localField;
+			if (stage.foreignField !== void 0) lookup["foreignField"] = stage.foreignField;
+			if (stage.pipeline) lookup["pipeline"] = structuralLowerPipeline(stage.pipeline);
+			if (stage.let_) lookup["let"] = lowerExprRecord(stage.let_);
+			return { $lookup: lookup };
+		}
+		case "unwind": {
+			const unwind = {
+				path: stage.path,
+				preserveNullAndEmptyArrays: stage.preserveNullAndEmptyArrays
+			};
+			if (stage.includeArrayIndex !== void 0) unwind["includeArrayIndex"] = stage.includeArrayIndex;
+			return { $unwind: unwind };
+		}
+		case "group": {
+			const group = { _id: lowerGroupId(stage.groupId) };
+			for (const [key, acc] of Object.entries(stage.accumulators)) group[key] = lowerAggExpr(acc);
+			return { $group: group };
+		}
+		case "addFields": return { $addFields: lowerExprRecord(stage.fields) };
+		case "replaceRoot": return { $replaceRoot: { newRoot: lowerAggExpr(stage.newRoot) } };
+		case "count": return { $count: stage.field };
+		case "sortByCount": return { $sortByCount: lowerAggExpr(stage.expr) };
+		case "sample": return { $sample: { size: stage.size } };
+		case "redact": return { $redact: lowerAggExpr(stage.expr) };
+		case "out": return { $out: stage.db ? {
+			db: stage.db,
+			coll: stage.collection
+		} : stage.collection };
+		case "unionWith": {
+			const unionWith = { coll: stage.collection };
+			if (stage.pipeline) unionWith["pipeline"] = structuralLowerPipeline(stage.pipeline);
+			return { $unionWith: unionWith };
+		}
+		case "bucket": {
+			const bucket = {
+				groupBy: lowerAggExpr(stage.groupBy),
+				boundaries: [...stage.boundaries]
+			};
+			if (stage.default_ !== void 0) bucket["default"] = stage.default_;
+			if (stage.output) bucket["output"] = lowerExprRecord(stage.output);
+			return { $bucket: bucket };
+		}
+		case "bucketAuto": {
+			const bucketAuto = {
+				groupBy: lowerAggExpr(stage.groupBy),
+				buckets: stage.buckets
+			};
+			if (stage.output) bucketAuto["output"] = lowerExprRecord(stage.output);
+			if (stage.granularity !== void 0) bucketAuto["granularity"] = stage.granularity;
+			return { $bucketAuto: bucketAuto };
+		}
+		case "geoNear": {
+			const geoNear = {
+				near: stage.near,
+				distanceField: stage.distanceField
+			};
+			if (stage.spherical !== void 0) geoNear["spherical"] = stage.spherical;
+			if (stage.maxDistance !== void 0) geoNear["maxDistance"] = stage.maxDistance;
+			if (stage.minDistance !== void 0) geoNear["minDistance"] = stage.minDistance;
+			if (stage.query) geoNear["query"] = structuralLowerFilter(stage.query);
+			if (stage.key !== void 0) geoNear["key"] = stage.key;
+			if (stage.distanceMultiplier !== void 0) geoNear["distanceMultiplier"] = stage.distanceMultiplier;
+			if (stage.includeLocs !== void 0) geoNear["includeLocs"] = stage.includeLocs;
+			return { $geoNear: geoNear };
+		}
+		case "facet": {
+			const facet = {};
+			for (const [key, pipeline] of Object.entries(stage.facets)) facet[key] = structuralLowerPipeline(pipeline);
+			return { $facet: facet };
+		}
+		case "graphLookup": {
+			const graphLookup = {
+				from: stage.from,
+				startWith: lowerAggExpr(stage.startWith),
+				connectFromField: stage.connectFromField,
+				connectToField: stage.connectToField,
+				as: stage.as
+			};
+			if (stage.maxDepth !== void 0) graphLookup["maxDepth"] = stage.maxDepth;
+			if (stage.depthField !== void 0) graphLookup["depthField"] = stage.depthField;
+			if (stage.restrictSearchWithMatch) graphLookup["restrictSearchWithMatch"] = structuralLowerFilter(stage.restrictSearchWithMatch);
+			return { $graphLookup: graphLookup };
+		}
+		case "merge": {
+			const merge = { into: stage.into };
+			if (stage.on !== void 0) merge["on"] = stage.on;
+			if (stage.whenMatched !== void 0) merge["whenMatched"] = Array.isArray(stage.whenMatched) ? structuralLowerPipeline(stage.whenMatched) : stage.whenMatched;
+			if (stage.whenNotMatched !== void 0) merge["whenNotMatched"] = stage.whenNotMatched;
+			return { $merge: merge };
+		}
+		case "setWindowFields": {
+			const swf = {};
+			if (stage.partitionBy) swf["partitionBy"] = lowerAggExpr(stage.partitionBy);
+			if (stage.sortBy) swf["sortBy"] = { ...stage.sortBy };
+			const output = {};
+			for (const [key, wf] of Object.entries(stage.output)) output[key] = lowerWindowField(wf);
+			swf["output"] = output;
+			return { $setWindowFields: swf };
+		}
+		case "densify": {
+			const densify = {
+				field: stage.field,
+				range: { ...stage.range }
+			};
+			if (stage.partitionByFields) densify["partitionByFields"] = [...stage.partitionByFields];
+			return { $densify: densify };
+		}
+		case "fill": {
+			const fill = {};
+			if (stage.partitionBy) fill["partitionBy"] = lowerAggExpr(stage.partitionBy);
+			if (stage.partitionByFields) fill["partitionByFields"] = [...stage.partitionByFields];
+			if (stage.sortBy) fill["sortBy"] = { ...stage.sortBy };
+			const output = {};
+			for (const [key, fo] of Object.entries(stage.output)) {
+				const entry = {};
+				if (fo.method !== void 0) entry["method"] = fo.method;
+				if (fo.value !== void 0) entry["value"] = lowerAggExpr(fo.value);
+				output[key] = entry;
+			}
+			fill["output"] = output;
+			return { $fill: fill };
+		}
+		case "search": {
+			const search = { ...stage.config };
+			if (stage.index !== void 0) search["index"] = stage.index;
+			return { $search: search };
+		}
+		case "searchMeta": {
+			const searchMeta = { ...stage.config };
+			if (stage.index !== void 0) searchMeta["index"] = stage.index;
+			return { $searchMeta: searchMeta };
+		}
+		case "vectorSearch": {
+			const vs = {
+				index: stage.index,
+				path: stage.path,
+				queryVector: [...stage.queryVector],
+				numCandidates: stage.numCandidates,
+				limit: stage.limit
+			};
+			if (stage.filter) vs["filter"] = { ...stage.filter };
+			return { $vectorSearch: vs };
+		}
+		default: throw new Error(`Unhandled stage kind: ${blindCast(stage).kind}`);
+	}
+}
+function structuralLowerPipeline(stages) {
+	return stages.map((s) => structuralLowerStage(s));
+}
 //#endregion
 //#region src/core/codecs.ts
 const mongoObjectIdCodec = mongoCodec({
@@ -515,59 +746,167 @@ function buildStandardCodecRegistry() {
 function isUpdatePipeline(update) {
 	return Array.isArray(update);
 }
+function isDraftUpdatePipeline(update) {
+	return Array.isArray(update);
+}
+async function resolveUpdate(update, codecs, ctx) {
+	if (isDraftUpdatePipeline(update)) return Promise.all(update.map((stage) => resolveDraftDoc(stage, codecs, ctx)));
+	return resolveDraftDoc(update, codecs, ctx);
+}
 var MongoAdapterImpl = class {
 	#codecs;
 	constructor(codecs) {
 		this.#codecs = codecs;
 	}
-	async #resolveDocument(expr, ctx) {
-		const entries = Object.entries(expr);
-		const resolved = await Promise.all(entries.map(([, val]) => resolveValue(val, this.#codecs, ctx)));
-		const result = {};
-		for (let i = 0; i < entries.length; i++) {
-			const entry = entries[i];
-			if (entry) result[entry[0]] = resolved[i];
-		}
-		return result;
-	}
-	async #lowerUpdate(update, ctx) {
-		if (isUpdatePipeline(update)) return Promise.all(update.map((stage) => lowerStage(stage, this.#codecs, ctx)));
-		return this.#resolveDocument(update, ctx);
-	}
-	async lower(plan, ctx) {
+	structuralLower(plan) {
 		const { command } = plan;
 		switch (command.kind) {
-			case "insertOne": return new InsertOneWireCommand(command.collection, await this.#resolveDocument(command.document, ctx));
+			case "insertOne": return {
+				kind: "insertOne",
+				collection: command.collection,
+				document: command.document
+			};
+			case "insertMany": return {
+				kind: "insertMany",
+				collection: command.collection,
+				documents: command.documents
+			};
+			case "updateOne": return {
+				kind: "updateOne",
+				collection: command.collection,
+				filter: structuralLowerFilter(command.filter),
+				update: isUpdatePipeline(command.update) ? structuralLowerPipeline(command.update) : command.update,
+				upsert: command.upsert
+			};
+			case "updateMany": return {
+				kind: "updateMany",
+				collection: command.collection,
+				filter: structuralLowerFilter(command.filter),
+				update: isUpdatePipeline(command.update) ? structuralLowerPipeline(command.update) : command.update,
+				upsert: command.upsert
+			};
+			case "deleteOne": return {
+				kind: "deleteOne",
+				collection: command.collection,
+				filter: structuralLowerFilter(command.filter)
+			};
+			case "deleteMany": return {
+				kind: "deleteMany",
+				collection: command.collection,
+				filter: structuralLowerFilter(command.filter)
+			};
+			case "findOneAndUpdate": return {
+				kind: "findOneAndUpdate",
+				collection: command.collection,
+				filter: structuralLowerFilter(command.filter),
+				update: isUpdatePipeline(command.update) ? structuralLowerPipeline(command.update) : command.update,
+				upsert: command.upsert,
+				sort: command.sort,
+				returnDocument: command.returnDocument
+			};
+			case "findOneAndDelete": return {
+				kind: "findOneAndDelete",
+				collection: command.collection,
+				filter: structuralLowerFilter(command.filter),
+				sort: command.sort
+			};
+			case "aggregate": return {
+				kind: "aggregate",
+				collection: command.collection,
+				pipeline: structuralLowerPipeline(command.pipeline)
+			};
+			case "rawAggregate": return {
+				kind: "rawAggregate",
+				collection: command.collection,
+				pipeline: command.pipeline
+			};
+			case "rawInsertOne": return {
+				kind: "rawInsertOne",
+				collection: command.collection,
+				document: command.document
+			};
+			case "rawInsertMany": return {
+				kind: "rawInsertMany",
+				collection: command.collection,
+				documents: command.documents
+			};
+			case "rawUpdateOne": return {
+				kind: "rawUpdateOne",
+				collection: command.collection,
+				filter: command.filter,
+				update: command.update
+			};
+			case "rawUpdateMany": return {
+				kind: "rawUpdateMany",
+				collection: command.collection,
+				filter: command.filter,
+				update: command.update
+			};
+			case "rawDeleteOne": return {
+				kind: "rawDeleteOne",
+				collection: command.collection,
+				filter: command.filter
+			};
+			case "rawDeleteMany": return {
+				kind: "rawDeleteMany",
+				collection: command.collection,
+				filter: command.filter
+			};
+			case "rawFindOneAndUpdate": return {
+				kind: "rawFindOneAndUpdate",
+				collection: command.collection,
+				filter: command.filter,
+				update: command.update,
+				upsert: command.upsert,
+				sort: command.sort,
+				returnDocument: command.returnDocument
+			};
+			case "rawFindOneAndDelete": return {
+				kind: "rawFindOneAndDelete",
+				collection: command.collection,
+				filter: command.filter,
+				sort: command.sort
+			};
+			// v8 ignore next 4
+			default: throw new Error(`Unknown command kind: ${blindCast(command).kind}`);
+		}
+	}
+	async resolveParams(draft, ctx) {
+		switch (draft.kind) {
+			case "insertOne": return new InsertOneWireCommand(draft.collection, await resolveDraftDoc(draft.document, this.#codecs, ctx));
+			case "insertMany": return new InsertManyWireCommand(draft.collection, await Promise.all(draft.documents.map((doc) => resolveDraftDoc(doc, this.#codecs, ctx))));
 			case "updateOne": {
-				const [filter, update] = await Promise.all([lowerFilter(command.filter, this.#codecs, ctx), this.#lowerUpdate(command.update, ctx)]);
-				return new UpdateOneWireCommand(command.collection, filter, update, command.upsert);
+				const [filter, update] = await Promise.all([resolveDraftDoc(draft.filter, this.#codecs, ctx), resolveUpdate(draft.update, this.#codecs, ctx)]);
+				return new UpdateOneWireCommand(draft.collection, filter, update, draft.upsert);
 			}
-			case "insertMany": return new InsertManyWireCommand(command.collection, await Promise.all(command.documents.map((doc) => this.#resolveDocument(doc, ctx))));
 			case "updateMany": {
-				const [filter, update] = await Promise.all([lowerFilter(command.filter, this.#codecs, ctx), this.#lowerUpdate(command.update, ctx)]);
-				return new UpdateManyWireCommand(command.collection, filter, update, command.upsert);
+				const [filter, update] = await Promise.all([resolveDraftDoc(draft.filter, this.#codecs, ctx), resolveUpdate(draft.update, this.#codecs, ctx)]);
+				return new UpdateManyWireCommand(draft.collection, filter, update, draft.upsert);
 			}
-			case "deleteOne": return new DeleteOneWireCommand(command.collection, await lowerFilter(command.filter, this.#codecs, ctx));
-			case "deleteMany": return new DeleteManyWireCommand(command.collection, await lowerFilter(command.filter, this.#codecs, ctx));
+			case "deleteOne": return new DeleteOneWireCommand(draft.collection, await resolveDraftDoc(draft.filter, this.#codecs, ctx));
+			case "deleteMany": return new DeleteManyWireCommand(draft.collection, await resolveDraftDoc(draft.filter, this.#codecs, ctx));
 			case "findOneAndUpdate": {
-				const [filter, update] = await Promise.all([lowerFilter(command.filter, this.#codecs, ctx), this.#lowerUpdate(command.update, ctx)]);
-				return new FindOneAndUpdateWireCommand(command.collection, filter, update, command.upsert, command.sort, command.returnDocument);
+				const [filter, update] = await Promise.all([resolveDraftDoc(draft.filter, this.#codecs, ctx), resolveUpdate(draft.update, this.#codecs, ctx)]);
+				return new FindOneAndUpdateWireCommand(draft.collection, filter, update, draft.upsert, draft.sort, draft.returnDocument);
 			}
-			case "findOneAndDelete": return new FindOneAndDeleteWireCommand(command.collection, await lowerFilter(command.filter, this.#codecs, ctx), command.sort);
-			case "aggregate": return new AggregateWireCommand(command.collection, await lowerPipeline(command.pipeline, this.#codecs, ctx));
-			case "rawAggregate": return new AggregateWireCommand(command.collection, command.pipeline);
-			case "rawInsertOne": return new InsertOneWireCommand(command.collection, command.document);
-			case "rawInsertMany": return new InsertManyWireCommand(command.collection, command.documents);
-			case "rawUpdateOne": return new UpdateOneWireCommand(command.collection, command.filter, command.update);
-			case "rawUpdateMany": return new UpdateManyWireCommand(command.collection, command.filter, command.update);
-			case "rawDeleteOne": return new DeleteOneWireCommand(command.collection, command.filter);
-			case "rawDeleteMany": return new DeleteManyWireCommand(command.collection, command.filter);
-			case "rawFindOneAndUpdate": return new FindOneAndUpdateWireCommand(command.collection, command.filter, command.update, command.upsert, command.sort, command.returnDocument);
-			case "rawFindOneAndDelete": return new FindOneAndDeleteWireCommand(command.collection, command.filter, command.sort);
+			case "findOneAndDelete": return new FindOneAndDeleteWireCommand(draft.collection, await resolveDraftDoc(draft.filter, this.#codecs, ctx), draft.sort);
+			case "aggregate": return new AggregateWireCommand(draft.collection, await Promise.all(draft.pipeline.map((stage) => resolveDraftDoc(stage, this.#codecs, ctx))));
+			case "rawAggregate": return new AggregateWireCommand(draft.collection, draft.pipeline);
+			case "rawInsertOne": return new InsertOneWireCommand(draft.collection, draft.document);
+			case "rawInsertMany": return new InsertManyWireCommand(draft.collection, draft.documents);
+			case "rawUpdateOne": return new UpdateOneWireCommand(draft.collection, draft.filter, draft.update);
+			case "rawUpdateMany": return new UpdateManyWireCommand(draft.collection, draft.filter, draft.update);
+			case "rawDeleteOne": return new DeleteOneWireCommand(draft.collection, draft.filter);
+			case "rawDeleteMany": return new DeleteManyWireCommand(draft.collection, draft.filter);
+			case "rawFindOneAndUpdate": return new FindOneAndUpdateWireCommand(draft.collection, draft.filter, draft.update, draft.upsert, draft.sort, draft.returnDocument);
+			case "rawFindOneAndDelete": return new FindOneAndDeleteWireCommand(draft.collection, draft.filter, draft.sort);
 			// v8 ignore next 4
-			default: throw new Error(`Unknown command kind: ${command.kind}`);
+			default: throw new Error(`Unknown draft kind: ${blindCast(draft).kind}`);
 		}
 	}
+	lower(plan, ctx) {
+		return this.resolveParams(this.structuralLower(plan), ctx);
+	}
 };
 /**
 * Construct a Mongo adapter with the standard wire-type codecs registered
@@ -584,4 +923,4 @@ function createMongoAdapter() {
 //#endregion
 export { lowerFilter as a, MONGO_VECTOR_CODEC_ID as c, lowerAggExpr as i, buildStandardCodecRegistry as n, lowerPipeline as o, mongoCodecDescriptors as r, lowerStage as s, createMongoAdapter as t };
 
-//# sourceMappingURL=mongo-adapter-DfCmEYHR.mjs.map
+//# sourceMappingURL=mongo-adapter-DAC5qq3o.mjs.map