@atscript/db-mongo 0.1.38

package/dist/index.mjs

@@ -0,0 +1,1703 @@
+import { buildMongoFilter } from "./mongo-filter-CL69Yhcm.mjs";
+import { AtscriptDbView, BaseDbAdapter, DbError, DbSpace, computeInsights, getKeyProps } from "@atscript/db";
+import { MongoClient, MongoServerError, ObjectId } from "mongodb";
+
+//#region packages/db-mongo/src/lib/collection-patcher.ts
+function _define_property$1(obj, key, value) {
+	if (key in obj) Object.defineProperty(obj, key, {
+		value,
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+else obj[key] = value;
+	return obj;
+}
+var CollectionPatcher = class {
+	/**
+	* Entry point – walk the payload, build `filter`, `update` and `options`.
+	*
+	* @returns Helper object exposing both individual parts and
+	*          a `.toArgs()` convenience callback.
+	*/ preparePatch() {
+		this.filterObj = { _id: this.collection.prepareId(this.payload._id) };
+		this.flattenPayload(this.payload);
+		const updateFilter = this.updatePipeline;
+		return {
+			toArgs: () => [
+				this.filterObj,
+				updateFilter,
+				this.optionsObj
+			],
+			filter: this.filterObj,
+			updateFilter,
+			updateOptions: this.optionsObj
+		};
+	}
+	/**
+	* Helper – lazily create `$set` section and assign *key* → *value*.
+	*
+	* @param key Fully‑qualified dotted path
+	* @param val Value to be written
+	* @private
+	*/ _set(key, val) {
+		if (this.currentSetStage && !(key in this.currentSetStage.$set)) {
+			this.currentSetStage.$set[key] = val;
+			return;
+		}
+		this.currentSetStage = { $set: { [key]: val } };
+		this.updatePipeline.push(this.currentSetStage);
+	}
+	/**
+	* Recursively walk through the patch *payload* and convert it into `$set`/…
+	* statements. Top‑level arrays are delegated to {@link parseArrayPatch}.
+	*
+	* @param payload Current payload chunk
+	* @param prefix  Dotted path accumulated so far
+	* @private
+	*/ flattenPayload(payload, prefix = "") {
+		const evalKey = (k) => prefix ? `${prefix}.${k}` : k;
+		for (const [_key, value] of Object.entries(payload)) {
+			const key = evalKey(_key);
+			const flatType = this.collection.flatMap.get(key);
+			const topLevelArray = flatType?.metadata?.get("db.__topLevelArray");
+			if (typeof value === "object" && !Array.isArray(value) && topLevelArray && !flatType?.metadata?.has("db.json")) this.parseArrayPatch(key, value, flatType);
+else if (typeof value === "object" && flatType?.metadata?.get("db.patch.strategy") === "merge") this.flattenPayload(value, key);
+else if (key !== "_id") this._set(key, value);
+		}
+		return this.updatePipeline;
+	}
+	/**
+	* Dispatch a *single* array patch. Exactly one of `$replace`, `$insert`,
+	* `$upsert`, `$update`, `$remove` must be present – otherwise we throw.
+	*
+	* @param key   Dotted path to the array field
+	* @param value Payload slice for that field
+	* @private
+	*/ parseArrayPatch(key, value, flatType) {
+		const toRemove = value.$remove;
+		const toReplace = value.$replace;
+		const toInsert = value.$insert;
+		const toUpsert = value.$upsert;
+		const toUpdate = value.$update;
+		const keyProps = flatType.type.kind === "array" ? getKeyProps(flatType) : new Set();
+		const keys = keyProps.size > 0 ? [...keyProps] : [];
+		this._remove(key, toRemove, keys, flatType);
+		this._replace(key, toReplace);
+		this._insert(key, toInsert, keys, flatType);
+		this._upsert(key, toUpsert, keys, flatType);
+		this._update(key, toUpdate, keys, flatType);
+	}
+	/**
+	* Build an *aggregation‐expression* that checks equality by **all** keys in
+	* `keys`.  Example output for keys `["id", "lang"]` and bases `a`, `b`:
+	* ```json
+	* { "$and": [ { "$eq": ["$$a.id", "$$b.id"] }, { "$eq": ["$$a.lang", "$$b.lang"] } ] }
+	* ```
+	*
+	* @param keys  Ordered list of key property names
+	* @param left  Base token for *left* expression (e.g. `"$$el"`)
+	* @param right Base token for *right* expression (e.g. `"$$this"`)
+	*/ _keysEqual(keys, left, right) {
+		const eqs = keys.map((k) => ({ $eq: [`${left}.${k}`, `${right}.${k}`] }));
+		return eqs.length === 1 ? eqs[0] : { $and: eqs };
+	}
+	/**
+	* `$replace` – overwrite the entire array with `input`.
+	*
+	* @param key   Dotted path to the array
+	* @param input New array value (may be `undefined`)
+	* @private
+	*/ _replace(key, input) {
+		if (input) this._set(key, input);
+	}
+	/**
+	* `$insert`
+	* - plain append      → $concatArrays
+	* - unique / keyed    → delegate to _upsert (insert-or-update)
+	*/ _insert(key, input, keys, flatType) {
+		if (!input?.length) return;
+		const uniqueItems = flatType.metadata?.has("expect.array.uniqueItems");
+		if (uniqueItems || keys.length > 0) this._upsert(key, input, keys, flatType);
+else this._set(key, { $concatArrays: [{ $ifNull: [`$${key}`, []] }, input] });
+	}
+	/**
+	* `$upsert`
+	* - keyed  → remove existing matching by key(s) then append candidate
+	* - unique → $setUnion (deep equality)
+	*/ _upsert(key, input, keys, flatType) {
+		if (!input?.length) return;
+		if (keys.length > 0) {
+			const mergeStrategy = flatType.metadata?.get("db.patch.strategy") === "merge";
+			const vars = {
+				acc: "$$value",
+				cand: "$$this"
+			};
+			let appendExpr = "$$cand";
+			if (mergeStrategy) {
+				vars.existing = { $arrayElemAt: [{ $filter: {
+					input: "$$value",
+					as: "el",
+					cond: this._keysEqual(keys, "$$el", "$$this")
+				} }, 0] };
+				appendExpr = { $cond: [
+					{ $ifNull: ["$$existing", false] },
+					{ $mergeObjects: ["$$existing", "$$cand"] },
+					"$$cand"
+				] };
+			}
+			this._set(key, { $reduce: {
+				input,
+				initialValue: { $ifNull: [`$${key}`, []] },
+				in: { $let: {
+					vars,
+					in: { $concatArrays: [{ $filter: {
+						input: "$$acc",
+						as: "el",
+						cond: { $not: this._keysEqual(keys, "$$el", "$$cand") }
+					} }, [appendExpr]] }
+				} }
+			} });
+			return;
+		}
+		this._set(key, { $setUnion: [{ $ifNull: [`$${key}`, []] }, input] });
+	}
+	/**
+	* `$update`
+	* - keyed       → map array and merge / replace matching element(s)
+	* - non-keyed   → behave like `$addToSet` (insert only when not present)
+	*/ _update(key, input, keys, flatType) {
+		if (!input?.length) return;
+		if (keys.length > 0) {
+			const mergeStrategy = flatType.metadata?.get("db.patch.strategy") === "merge";
+			this._set(key, { $reduce: {
+				input,
+				initialValue: { $ifNull: [`$${key}`, []] },
+				in: { $map: {
+					input: "$$value",
+					as: "el",
+					in: { $cond: [
+						this._keysEqual(keys, "$$el", "$$this"),
+						mergeStrategy ? { $mergeObjects: ["$$el", "$$this"] } : "$$this",
+						"$$el"
+					] }
+				} }
+			} });
+		} else this._set(key, { $setUnion: [{ $ifNull: [`$${key}`, []] }, input] });
+	}
+	/**
+	* `$remove`
+	* - keyed     → filter out any element whose key set matches a payload item
+	* - non-keyed → deep equality remove (`$setDifference`)
+	*/ _remove(key, input, keys, _flatType) {
+		if (!input?.length) return;
+		if (keys.length > 0) this._set(key, { $let: {
+			vars: { rem: input },
+			in: { $filter: {
+				input: { $ifNull: [`$${key}`, []] },
+				as: "el",
+				cond: { $not: { $anyElementTrue: { $map: {
+					input: "$$rem",
+					as: "r",
+					in: this._keysEqual(keys, "$$el", "$$r")
+				} } } }
+			} }
+		} });
+else this._set(key, { $setDifference: [{ $ifNull: [`$${key}`, []] }, input] });
+	}
+	constructor(collection, payload) {
+		_define_property$1(this, "collection", void 0);
+		_define_property$1(this, "payload", void 0);
+		/**
+		* Internal accumulator: filter passed to `updateOne()`.
+		* Filled only with the `_id` field right now.
+		*/ _define_property$1(this, "filterObj", void 0);
+		/** MongoDB *update* document being built. */ _define_property$1(this, "updatePipeline", void 0);
+		/** Current `$set` stage being populated. */ _define_property$1(this, "currentSetStage", void 0);
+		/** Additional *options* (mainly `arrayFilters`). */ _define_property$1(this, "optionsObj", void 0);
+		this.collection = collection;
+		this.payload = payload;
+		this.filterObj = {};
+		this.updatePipeline = [];
+		this.currentSetStage = null;
+		this.optionsObj = {};
+	}
+};
+_define_property$1(CollectionPatcher, "getKeyProps", getKeyProps);
+
+//#endregion
+//#region packages/db-mongo/src/lib/mongo-types.ts
+const INDEX_PREFIX = "atscript__";
+const DEFAULT_INDEX_NAME = "DEFAULT";
+const JOINED_PREFIX = "__joined_";
+function mongoIndexKey(type, name) {
+	const cleanName = name.replace(/[^a-z0-9_.-]/gi, "_").replace(/_+/g, "_").slice(0, 127 - INDEX_PREFIX.length - type.length - 2);
+	return `${INDEX_PREFIX}${type}__${cleanName}`;
+}
+
+//#endregion
+//#region packages/db-mongo/src/lib/mongo-relations.ts
+function buildPKKey(primaryKeys, doc) {
+	if (primaryKeys.length === 1) return String(doc[primaryKeys[0]] ?? "");
+	let key = "";
+	for (let i = 0; i < primaryKeys.length; i++) {
+		if (i > 0) key += "\0";
+		key += String(doc[primaryKeys[i]] ?? "");
+	}
+	return key;
+}
+async function loadRelationsImpl(host, rows, withRelations, relations, foreignKeys, tableResolver) {
+	if (rows.length === 0 || withRelations.length === 0) return;
+	const primaryKeys = host._table.primaryKeys;
+	const relMeta = [];
+	for (const withRel of withRelations) {
+		if (withRel.name.includes(".")) continue;
+		const relation = relations.get(withRel.name);
+		if (!relation) throw new Error(`Unknown relation "${withRel.name}" in $with. Available relations: ${[...relations.keys()].join(", ") || "(none)"}`);
+		const lookupResult = buildRelationLookup(host, withRel, relation, foreignKeys, tableResolver);
+		if (!lookupResult) continue;
+		relMeta.push({
+			name: withRel.name,
+			isArray: lookupResult.isArray,
+			relation,
+			nestedWith: extractNestedWith(withRel),
+			stages: lookupResult.stages
+		});
+	}
+	if (relMeta.length === 0) return;
+	const pkMatchFilter = buildPKMatchFilter(rows, primaryKeys);
+	if (pkMatchFilter) {
+		const pipeline = [{ $match: pkMatchFilter }];
+		for (const meta of relMeta) pipeline.push(...meta.stages);
+		const results = await host.collection.aggregate(pipeline, host._getSessionOpts()).toArray();
+		mergeRelationResults(rows, results, primaryKeys, relMeta);
+	} else for (const row of rows) for (const meta of relMeta) row[meta.name] = meta.isArray ? [] : null;
+	await loadNestedRelations(rows, relMeta, tableResolver);
+}
+/** Builds a $match filter to re-select source rows by PK. */ function buildPKMatchFilter(rows, primaryKeys) {
+	if (primaryKeys.length === 1) {
+		const pk = primaryKeys[0];
+		const values = new Set();
+		for (const row of rows) {
+			const v = row[pk];
+			if (v !== null && v !== undefined) values.add(v);
+		}
+		if (values.size === 0) return undefined;
+		return { [pk]: { $in: [...values] } };
+	}
+	const seen = new Set();
+	const orFilters = [];
+	for (const row of rows) {
+		const key = buildPKKey(primaryKeys, row);
+		if (seen.has(key)) continue;
+		seen.add(key);
+		const condition = {};
+		let valid = true;
+		for (const pk of primaryKeys) {
+			const val = row[pk];
+			if (val === null || val === undefined) {
+				valid = false;
+				break;
+			}
+			condition[pk] = val;
+		}
+		if (valid) orFilters.push(condition);
+	}
+	if (orFilters.length === 0) return undefined;
+	return orFilters.length === 1 ? orFilters[0] : { $or: orFilters };
+}
+/** Dispatches to the correct $lookup builder based on relation direction. */ function buildRelationLookup(host, withRel, relation, foreignKeys, tableResolver) {
+	switch (relation.direction) {
+		case "to": return buildToLookup(withRel, relation, foreignKeys);
+		case "from": return buildFromLookup(host, withRel, relation, tableResolver);
+		case "via": return buildViaLookup(host, withRel, relation, tableResolver);
+		default: return undefined;
+	}
+}
+/** Builds `let` variable bindings and the corresponding `$expr` match for `$lookup`. */ function buildLookupJoin(localFields, remoteFields, varPrefix) {
+	const letVars = {};
+	for (let i = 0; i < localFields.length; i++) letVars[`${varPrefix}${i}`] = `$${localFields[i]}`;
+	if (remoteFields.length === 1) return {
+		letVars,
+		exprMatch: { $eq: [`$${remoteFields[0]}`, `$$${varPrefix}0`] }
+	};
+	const andClauses = [];
+	for (let i = 0; i < remoteFields.length; i++) andClauses.push({ $eq: [`$${remoteFields[i]}`, `$$${varPrefix}${i}`] });
+	return {
+		letVars,
+		exprMatch: { $and: andClauses }
+	};
+}
+/** $lookup for TO relations (FK is on this table → target). Always single-valued. */ function buildToLookup(withRel, relation, foreignKeys) {
+	const fk = findFKForRelation(relation, foreignKeys);
+	if (!fk) return undefined;
+	const innerPipeline = buildLookupInnerPipeline(withRel, fk.targetFields);
+	const { letVars, exprMatch } = buildLookupJoin(fk.localFields, fk.targetFields, "fk_");
+	const stages = [{ $lookup: {
+		from: fk.targetTable,
+		let: letVars,
+		pipeline: [{ $match: { $expr: exprMatch } }, ...innerPipeline],
+		as: withRel.name
+	} }, { $unwind: {
+		path: `$${withRel.name}`,
+		preserveNullAndEmptyArrays: true
+	} }];
+	return {
+		stages,
+		isArray: false
+	};
+}
+/** $lookup for FROM relations (FK is on target → this table). */ function buildFromLookup(host, withRel, relation, tableResolver) {
+	const targetType = relation.targetType();
+	if (!targetType || !tableResolver) return undefined;
+	const targetMeta = tableResolver(targetType);
+	if (!targetMeta) return undefined;
+	const remoteFK = findRemoteFK(targetMeta, host._table.tableName, relation.alias);
+	if (!remoteFK) return undefined;
+	const targetTableName = resolveRelTargetTableName(relation);
+	const innerPipeline = buildLookupInnerPipeline(withRel, remoteFK.fields);
+	const { letVars, exprMatch } = buildLookupJoin(remoteFK.targetFields, remoteFK.fields, "pk_");
+	const stages = [{ $lookup: {
+		from: targetTableName,
+		let: letVars,
+		pipeline: [{ $match: { $expr: exprMatch } }, ...innerPipeline],
+		as: withRel.name
+	} }];
+	if (!relation.isArray) stages.push({ $unwind: {
+		path: `$${withRel.name}`,
+		preserveNullAndEmptyArrays: true
+	} });
+	return {
+		stages,
+		isArray: relation.isArray
+	};
+}
+/** $lookup for VIA relations (M:N through junction table). Always array. */ function buildViaLookup(host, withRel, relation, tableResolver) {
+	if (!relation.viaType || !tableResolver) return undefined;
+	const junctionType = relation.viaType();
+	if (!junctionType) return undefined;
+	const junctionMeta = tableResolver(junctionType);
+	if (!junctionMeta) return undefined;
+	const junctionTableName = junctionType.metadata?.get("db.table") || junctionType.id || "";
+	const targetTableName = resolveRelTargetTableName(relation);
+	const fkToThis = findRemoteFK(junctionMeta, host._table.tableName);
+	if (!fkToThis) return undefined;
+	const fkToTarget = findRemoteFK(junctionMeta, targetTableName);
+	if (!fkToTarget) return undefined;
+	const innerPipeline = buildLookupInnerPipeline(withRel, fkToTarget.targetFields);
+	const { letVars, exprMatch } = buildLookupJoin(fkToThis.targetFields, fkToThis.fields, "pk_");
+	const stages = [{ $lookup: {
+		from: junctionTableName,
+		let: letVars,
+		pipeline: [
+			{ $match: { $expr: exprMatch } },
+			{ $lookup: {
+				from: targetTableName,
+				localField: fkToTarget.fields[0],
+				foreignField: fkToTarget.targetFields[0],
+				pipeline: innerPipeline,
+				as: "__target"
+			} },
+			{ $unwind: {
+				path: "$__target",
+				preserveNullAndEmptyArrays: false
+			} },
+			{ $replaceRoot: { newRoot: "$__target" } }
+		],
+		as: withRel.name
+	} }];
+	return {
+		stages,
+		isArray: true
+	};
+}
+/** Builds inner pipeline stages for relation controls ($sort, $limit, $skip, $select, filter). */ function buildLookupInnerPipeline(withRel, requiredFields) {
+	const pipeline = [];
+	const flatRel = withRel;
+	const nested = withRel.controls || {};
+	const filter = withRel.filter;
+	const sort = nested.$sort || flatRel.$sort;
+	const limit = nested.$limit ?? flatRel.$limit;
+	const skip = nested.$skip ?? flatRel.$skip;
+	const select = nested.$select || flatRel.$select;
+	if (filter && Object.keys(filter).length > 0) pipeline.push({ $match: buildMongoFilter(filter) });
+	if (sort) pipeline.push({ $sort: sort });
+	if (skip) pipeline.push({ $skip: skip });
+	if (limit !== null && limit !== undefined) pipeline.push({ $limit: limit });
+	if (select) {
+		const projection = {};
+		for (const f of select) projection[f] = 1;
+		for (const f of requiredFields) projection[f] = 1;
+		if (!select.includes("_id") && !requiredFields.includes("_id")) projection["_id"] = 0;
+		pipeline.push({ $project: projection });
+	}
+	return pipeline;
+}
+/** Extracts nested $with from a WithRelation's controls. */ function extractNestedWith(withRel) {
+	const flatRel = withRel;
+	const nested = withRel.controls || {};
+	const nestedWith = nested.$with || flatRel.$with;
+	return nestedWith && nestedWith.length > 0 ? nestedWith : undefined;
+}
+/** Post-processes nested $with by delegating to the target table's own relation loading. */ async function loadNestedRelations(rows, relMeta, tableResolver) {
+	if (!tableResolver) return;
+	const tasks = [];
+	for (const meta of relMeta) {
+		if (!meta.nestedWith || meta.nestedWith.length === 0) continue;
+		const targetType = meta.relation.targetType();
+		if (!targetType) continue;
+		const targetTable = tableResolver(targetType);
+		if (!targetTable) continue;
+		const subRows = [];
+		for (const row of rows) {
+			const val = row[meta.name];
+			if (meta.isArray && Array.isArray(val)) for (const item of val) subRows.push(item);
+else if (val && typeof val === "object") subRows.push(val);
+		}
+		if (subRows.length === 0) continue;
+		tasks.push(targetTable.loadRelations(subRows, meta.nestedWith));
+	}
+	await Promise.all(tasks);
+}
+/** Merges aggregation results back onto the original rows by PK. */ function mergeRelationResults(rows, results, primaryKeys, relMeta) {
+	const resultIndex = new Map();
+	for (const doc of results) resultIndex.set(buildPKKey(primaryKeys, doc), doc);
+	for (const row of rows) {
+		const enriched = resultIndex.get(buildPKKey(primaryKeys, row));
+		for (const meta of relMeta) if (enriched) {
+			const value = enriched[meta.name];
+			if (!meta.isArray && Array.isArray(value)) row[meta.name] = value[0] ?? null;
+else row[meta.name] = value ?? (meta.isArray ? [] : null);
+		} else row[meta.name] = meta.isArray ? [] : null;
+	}
+}
+/** Finds FK entry for a TO relation from this table's foreignKeys map. */ function findFKForRelation(relation, foreignKeys) {
+	const targetTableName = resolveRelTargetTableName(relation);
+	for (const fk of foreignKeys.values()) if (relation.alias) {
+		if (fk.alias === relation.alias) return {
+			localFields: fk.fields,
+			targetFields: fk.targetFields,
+			targetTable: fk.targetTable
+		};
+	} else if (fk.targetTable === targetTableName) return {
+		localFields: fk.fields,
+		targetFields: fk.targetFields,
+		targetTable: fk.targetTable
+	};
+	return undefined;
+}
+/** Finds a FK on a remote table that points back to the given table name. */ function findRemoteFK(target, thisTableName, alias) {
+	for (const fk of target.foreignKeys.values()) {
+		if (alias && fk.alias === alias && fk.targetTable === thisTableName) return fk;
+		if (!alias && fk.targetTable === thisTableName) return fk;
+	}
+	return undefined;
+}
+/** Resolves the target table/collection name from a relation's target type. */ function resolveRelTargetTableName(relation) {
+	const targetType = relation.targetType();
+	return targetType?.metadata?.get("db.table") || targetType?.id || "";
+}
+
+//#endregion
+//#region packages/db-mongo/src/lib/mongo-search.ts
+function getSearchIndexesImpl(host) {
+	const result = [];
+	for (const [name, index] of host.getMongoSearchIndexes()) result.push({
+		name,
+		description: `${index.type} index`,
+		type: index.type === "vector" ? "vector" : "text"
+	});
+	return result;
+}
+function isVectorSearchableImpl(host) {
+	for (const index of host.getMongoSearchIndexes().values()) if (index.type === "vector") return true;
+	return false;
+}
+async function searchImpl(host, text, query, indexName) {
+	const stage = buildSearchStage(host, text, indexName);
+	if (!stage) throw new Error(indexName ? `Search index "${indexName}" not found` : "No search index available");
+	return runSearchPipeline(host, stage, query, "search");
+}
+async function searchWithCountImpl(host, text, query, indexName) {
+	const stage = buildSearchStage(host, text, indexName);
+	if (!stage) throw new Error(indexName ? `Search index "${indexName}" not found` : "No search index available");
+	return runSearchWithCountPipeline(host, stage, query, "searchWithCount");
+}
+async function vectorSearchImpl(host, vector, query, indexName) {
+	const controls = query.controls || {};
+	const stage = buildVectorSearchStage(host, vector, indexName, controls.$limit);
+	const threshold = resolveThreshold(host, controls, indexName);
+	return runSearchPipeline(host, stage, query, "vectorSearch", threshold);
+}
+async function vectorSearchWithCountImpl(host, vector, query, indexName) {
+	const controls = query.controls || {};
+	const stage = buildVectorSearchStage(host, vector, indexName, controls.$limit);
+	const threshold = resolveThreshold(host, controls, indexName);
+	return runSearchWithCountPipeline(host, stage, query, "vectorSearchWithCount", threshold);
+}
+/** Resolves the effective threshold: query-time $threshold > schema-level @db.search.vector.threshold. */ function resolveThreshold(host, controls, indexName) {
+	const queryThreshold = controls.$threshold;
+	if (queryThreshold !== undefined) return queryThreshold;
+	return host.getVectorThreshold(indexName);
+}
+/** Builds a MongoDB $search pipeline stage for text search. */ function buildSearchStage(host, text, indexName) {
+	const index = host.getMongoSearchIndex(indexName);
+	if (!index) return undefined;
+	if (index.type === "vector") throw new Error("Vector indexes cannot be used with text search. Use vectorSearch() instead.");
+	return { $search: {
+		index: index.key,
+		text: {
+			query: text,
+			path: { wildcard: "*" }
+		}
+	} };
+}
+/** Builds a $vectorSearch aggregation stage from a pre-computed vector. */ function buildVectorSearchStage(host, vector, indexName, limit) {
+	let index;
+	if (indexName) {
+		const found = host.getMongoSearchIndex(indexName);
+		if (!found || found.type !== "vector") throw new Error(`Vector index "${indexName}" not found`);
+		index = found;
+	} else for (const idx of host.getMongoSearchIndexes().values()) if (idx.type === "vector") {
+		index = idx;
+		break;
+	}
+	if (!index) throw new Error("No vector index available");
+	let vectorField;
+	if (index.definition.fields) {
+		for (const f of index.definition.fields) if (f.type === "vector") {
+			vectorField = f;
+			break;
+		}
+	}
+	if (!vectorField) throw new Error(`Vector index "${index.name}" has no vector field`);
+	return { $vectorSearch: {
+		index: index.key,
+		path: vectorField.path,
+		queryVector: vector,
+		numCandidates: Math.max((limit || 20) * 10, 100),
+		limit: limit || 20
+	} };
+}
+/** Runs a search/vector pipeline and returns results. Shared by search + vectorSearch. */ async function runSearchPipeline(host, stage, query, label, threshold) {
+	const filter = buildMongoFilter(query.filter);
+	const controls = query.controls || {};
+	const pipeline = [stage];
+	if (threshold !== undefined) {
+		pipeline.push({ $addFields: { _score: { $meta: "vectorSearchScore" } } });
+		pipeline.push({ $match: { _score: { $gte: threshold } } });
+	}
+	pipeline.push({ $match: filter });
+	if (controls.$sort) pipeline.push({ $sort: controls.$sort });
+	if (controls.$skip) pipeline.push({ $skip: controls.$skip });
+	if (controls.$limit) pipeline.push({ $limit: controls.$limit });
+else pipeline.push({ $limit: 1e3 });
+	if (controls.$select) pipeline.push({ $project: controls.$select.asProjection });
+	host._log(`aggregate (${label})`, pipeline);
+	return host.collection.aggregate(pipeline, host._getSessionOpts()).toArray();
+}
+/** Runs a search/vector pipeline with $facet for count. Shared by searchWithCount + vectorSearchWithCount. */ async function runSearchWithCountPipeline(host, stage, query, label, threshold) {
+	const filter = buildMongoFilter(query.filter);
+	const controls = query.controls || {};
+	const preStages = [];
+	if (threshold !== undefined) {
+		preStages.push({ $addFields: { _score: { $meta: "vectorSearchScore" } } });
+		preStages.push({ $match: { _score: { $gte: threshold } } });
+	}
+	const dataStages = [];
+	if (controls.$sort) dataStages.push({ $sort: controls.$sort });
+	if (controls.$skip) dataStages.push({ $skip: controls.$skip });
+	if (controls.$limit) dataStages.push({ $limit: controls.$limit });
+	if (controls.$select) dataStages.push({ $project: controls.$select.asProjection });
+	const pipeline = [
+		stage,
+		...preStages,
+		{ $match: filter },
+		{ $facet: {
+			data: dataStages,
+			meta: [{ $count: "count" }]
+		} }
+	];
+	host._log(`aggregate (${label})`, pipeline);
+	const result = await host.collection.aggregate(pipeline, host._getSessionOpts()).toArray();
+	return {
+		data: result[0]?.data || [],
+		count: result[0]?.meta[0]?.count || 0
+	};
+}
+
+//#endregion
+//#region packages/db-mongo/src/lib/mongo-schema-sync.ts
+const DESTRUCTIVE_OPTION_KEYS = new Set([
+	"capped",
+	"capped.size",
+	"capped.max"
+]);
+async function tableExistsImpl(host) {
+	return host.collectionExists();
+}
+function getDesiredTableOptionsImpl(cappedOptions) {
+	if (!cappedOptions) return [];
+	const opts = [{
+		key: "capped",
+		value: "true"
+	}, {
+		key: "capped.size",
+		value: String(cappedOptions.size)
+	}];
+	if (cappedOptions.max !== undefined) opts.push({
+		key: "capped.max",
+		value: String(cappedOptions.max)
+	});
+	return opts;
+}
+async function getExistingTableOptionsImpl(host) {
+	const cols = await host.db.listCollections({ name: host._table.tableName }, { nameOnly: false }).toArray();
+	if (cols.length === 0) return [];
+	const collOpts = cols[0].options;
+	if (!collOpts?.capped) return [];
+	const opts = [{
+		key: "capped",
+		value: "true"
+	}];
+	if (collOpts.size !== undefined) opts.push({
+		key: "capped.size",
+		value: String(collOpts.size)
+	});
+	if (collOpts.max !== undefined) opts.push({
+		key: "capped.max",
+		value: String(collOpts.max)
+	});
+	return opts;
+}
+async function ensureTableImpl(host, table) {
+	if (table instanceof AtscriptDbView && !table.isExternal) return ensureView(host, table);
+	return host.ensureCollectionExists();
+}
+/** Creates a MongoDB view from the AtscriptDbView's view plan. */ async function ensureView(host, view) {
+	const exists = await host.collectionExists();
+	if (exists) return;
+	const plan = view.viewPlan;
+	const columns = view.getViewColumnMappings();
+	const pipeline = [];
+	for (const join of plan.joins) {
+		const { localField, foreignField } = resolveJoinFields(join.condition, plan.entryTable, join.targetTable);
+		pipeline.push({ $lookup: {
+			from: join.targetTable,
+			localField,
+			foreignField,
+			as: `${JOINED_PREFIX}${join.targetTable}`
+		} });
+		pipeline.push({ $unwind: {
+			path: `$__joined_${join.targetTable}`,
+			preserveNullAndEmptyArrays: true
+		} });
+	}
+	if (plan.filter) {
+		const matchExpr = queryNodeToMatch(plan.filter, plan.entryTable);
+		pipeline.push({ $match: matchExpr });
+	}
+	const hasAggregates = columns.some((c) => c.aggFn);
+	/** Resolves a column to its MongoDB source field path. */ const colSourceField = (col) => col.sourceTable === plan.entryTable ? `$${col.sourceColumn}` : `$${JOINED_PREFIX}${col.sourceTable}.${col.sourceColumn}`;
+	if (hasAggregates) {
+		const group = { _id: {} };
+		const project = { _id: 0 };
+		for (const col of columns) if (col.aggFn) {
+			if (col.aggFn === "count" && col.aggField === "*") group[col.viewColumn] = { $sum: 1 };
+else group[col.viewColumn] = { [`$${col.aggFn}`]: colSourceField(col) };
+			project[col.viewColumn] = `$${col.viewColumn}`;
+		} else {
+			group._id[col.viewColumn] = colSourceField(col);
+			project[col.viewColumn] = `$_id.${col.viewColumn}`;
+		}
+		pipeline.push({ $group: group });
+		if (plan.having) {
+			const havingMatch = queryNodeToHaving(plan.having, columns);
+			pipeline.push({ $match: havingMatch });
+		}
+		pipeline.push({ $project: project });
+	} else {
+		const project = { _id: 0 };
+		for (const col of columns) project[col.viewColumn] = colSourceField(col);
+		pipeline.push({ $project: project });
+	}
+	host._log("createView", host._table.tableName, plan.entryTable, pipeline);
+	await host.db.createCollection(host._table.tableName, {
+		viewOn: plan.entryTable,
+		pipeline
+	});
+}
+/** Extracts localField/foreignField from a join condition. */ function resolveJoinFields(condition, entryTable, joinTable) {
+	const comp = "$and" in condition ? condition.$and[0] : condition;
+	const c = comp;
+	const leftTable = c.left.type ? c.left.type()?.metadata?.get("db.table") || "" : entryTable;
+	if (leftTable === joinTable) return {
+		localField: c.right.field,
+		foreignField: c.left.field
+	};
+	return {
+		localField: c.left.field,
+		foreignField: c.right.field
+	};
+}
+/** Translates an AtscriptQueryNode to a MongoDB $match expression. */ function queryNodeToMatch(node, entryTable) {
+	if ("$and" in node) {
+		const items = node.$and;
+		const result = [];
+		for (const item of items) result.push(queryNodeToMatch(item, entryTable));
+		return { $and: result };
+	}
+	if ("$or" in node) {
+		const items = node.$or;
+		const result = [];
+		for (const item of items) result.push(queryNodeToMatch(item, entryTable));
+		return { $or: result };
+	}
+	if ("$not" in node) return { $not: queryNodeToMatch(node.$not, entryTable) };
+	const comp = node;
+	const fieldPath = resolveViewFieldPath(comp.left, entryTable);
+	if (comp.right && typeof comp.right === "object" && "field" in comp.right) {
+		const rightPath = resolveViewFieldPath(comp.right, entryTable);
+		return { $expr: { [comp.op]: [`$${fieldPath}`, `$${rightPath}`] } };
+	}
+	if (comp.op === "$eq") return { [fieldPath]: comp.right };
+	if (comp.op === "$ne") return { [fieldPath]: { $ne: comp.right } };
+	return { [fieldPath]: { [comp.op]: comp.right } };
+}
+/** Resolves a field ref to a MongoDB dot path for view pipeline expressions. */ function resolveViewFieldPath(ref, entryTable) {
+	if (!ref.type) return ref.field;
+	const table = ref.type()?.metadata?.get("db.table") || "";
+	if (table === entryTable) return ref.field;
+	return `${JOINED_PREFIX}${table}.${ref.field}`;
+}
+/**
+* Translates an AtscriptQueryNode to a MongoDB $match for use after $group (HAVING).
+* After $group, aggregate fields are top-level and dimension fields are under _id.
+*/ function queryNodeToHaving(node, columns) {
+	const colMap = new Map(columns.map((c) => [c.viewColumn, c]));
+	const resolveHavingField = (ref) => {
+		if (!ref.type) {
+			const col = colMap.get(ref.field);
+			if (col?.aggFn) return ref.field;
+			if (col) return `_id.${ref.field}`;
+		}
+		return ref.field;
+	};
+	return queryNodeToHavingInner(node, resolveHavingField);
+}
+function queryNodeToHavingInner(node, resolveField) {
+	if ("$and" in node) return { $and: node.$and.map((n) => queryNodeToHavingInner(n, resolveField)) };
+	if ("$or" in node) return { $or: node.$or.map((n) => queryNodeToHavingInner(n, resolveField)) };
+	if ("$not" in node) return { $not: queryNodeToHavingInner(node.$not, resolveField) };
+	const comp = node;
+	const fieldPath = resolveField(comp.left);
+	if (comp.right && typeof comp.right === "object" && "field" in comp.right) {
+		const rightPath = resolveField(comp.right);
+		return { $expr: { [comp.op]: [`$${fieldPath}`, `$${rightPath}`] } };
+	}
+	if (comp.op === "$eq") return { [fieldPath]: comp.right };
+	if (comp.op === "$ne") return { [fieldPath]: { $ne: comp.right } };
+	return { [fieldPath]: { [comp.op]: comp.right } };
+}
+async function dropTableImpl(host) {
+	host._log("drop", host._table.tableName);
+	await host.collection.drop();
+	host.clearCollectionCache();
+}
+async function dropViewByNameImpl(host, viewName) {
+	host._log("dropView", viewName);
+	try {
+		await host.db.collection(viewName).drop();
+	} catch {}
+}
+async function dropTableByNameImpl(host, tableName) {
+	host._log("dropByName", tableName);
+	try {
+		await host.db.collection(tableName).drop();
+	} catch {}
+}
+async function recreateTableImpl(host) {
+	const tableName = host._table.tableName;
+	host._log("recreateTable", tableName);
+	const tempName = `${tableName}__tmp_${Date.now()}`;
+	const source = host.db.collection(tableName);
+	const count = await source.countDocuments();
+	if (count > 0) await source.aggregate([{ $out: tempName }]).toArray();
+	await host.collection.drop();
+	host.clearCollectionCache();
+	await host.ensureCollectionExists();
+	if (count > 0) {
+		const temp = host.db.collection(tempName);
+		await temp.aggregate([{ $merge: { into: tableName } }]).toArray();
+		await temp.drop();
+	}
+}
+async function renameTableImpl(host, oldName) {
+	const newName = host.resolveTableName(false);
+	host._log("renameTable", oldName, "→", newName);
+	await host.db.renameCollection(oldName, newName);
+	host.clearCollectionCache();
+}
+async function syncColumnsImpl(host, diff) {
+	const renamed = [];
+	const added = [];
+	const update = {};
+	if (diff.renamed.length > 0) {
+		const renameSpec = {};
+		for (const r of diff.renamed) {
+			renameSpec[r.oldName] = r.field.physicalName;
+			renamed.push(r.field.physicalName);
+		}
+		update.$rename = renameSpec;
+	}
+	if (diff.added.length > 0) {
+		const setSpec = {};
+		for (const field of diff.added) {
+			const defaultVal = resolveSyncDefault(field);
+			if (defaultVal !== undefined) setSpec[field.physicalName] = defaultVal;
+			added.push(field.physicalName);
+		}
+		if (Object.keys(setSpec).length > 0) update.$set = setSpec;
+	}
+	if (Object.keys(update).length > 0) await host.collection.updateMany({}, update, host._getSessionOpts());
+	return {
+		added,
+		renamed
+	};
+}
+async function dropColumnsImpl(host, columns) {
+	if (columns.length === 0) return;
+	const unsetSpec = {};
+	for (const col of columns) unsetSpec[col] = "";
+	await host.collection.updateMany({}, { $unset: unsetSpec }, host._getSessionOpts());
+}
+/** Resolves a field's default value for bulk $set during column sync. */ function resolveSyncDefault(field) {
+	if (!field.defaultValue) return field.optional ? null : undefined;
+	if (field.defaultValue.kind === "value") return field.defaultValue.value;
+	return undefined;
+}
+async function syncIndexesImpl(host) {
+	await host.ensureCollectionExists();
+	const allIndexes = new Map();
+	for (const [key, index] of host._table.indexes.entries()) {
+		const fields = {};
+		const weights = {};
+		let mongoType;
+		if (index.type === "fulltext") {
+			mongoType = "text";
+			for (const f of index.fields) {
+				fields[f.name] = "text";
+				if (f.weight) weights[f.name] = f.weight;
+			}
+		} else {
+			mongoType = index.type;
+			for (const f of index.fields) fields[f.name] = 1;
+		}
+		allIndexes.set(key, {
+			key,
+			name: index.name,
+			type: mongoType,
+			fields,
+			weights
+		});
+	}
+	for (const [key, index] of host._mongoIndexes.entries()) if (index.type === "text") {
+		const existing = allIndexes.get(key);
+		if (existing && existing.type === "text") {
+			Object.assign(existing.fields, index.fields);
+			Object.assign(existing.weights, index.weights);
+		} else allIndexes.set(key, index);
+	} else allIndexes.set(key, index);
+	const existingIndexes = await host.collection.listIndexes().toArray();
+	const indexesToCreate = new Map(allIndexes);
+	for (const remote of existingIndexes) {
+		if (!remote.name.startsWith(INDEX_PREFIX)) continue;
+		if (indexesToCreate.has(remote.name)) {
+			const local = indexesToCreate.get(remote.name);
+			switch (local.type) {
+				case "plain":
+				case "unique":
+				case "text": {
+					if ((local.type === "text" || objMatch(local.fields, remote.key)) && objMatch(local.weights || {}, remote.weights || {})) indexesToCreate.delete(remote.name);
+else {
+						host._log("dropIndex", remote.name);
+						await host.collection.dropIndex(remote.name);
+					}
+					break;
+				}
+				default:
+			}
+		} else {
+			host._log("dropIndex", remote.name);
+			await host.collection.dropIndex(remote.name);
+		}
+	}
+	for (const [key, value] of allIndexes.entries()) switch (value.type) {
+		case "plain": {
+			if (!indexesToCreate.has(key)) continue;
+			host._log("createIndex", key, value.fields);
+			await host.collection.createIndex(value.fields, { name: key });
+			break;
+		}
+		case "unique": {
+			if (!indexesToCreate.has(key)) continue;
+			host._log("createIndex (unique)", key, value.fields);
+			await host.collection.createIndex(value.fields, {
+				name: key,
+				unique: true
+			});
+			break;
+		}
+		case "text": {
+			if (!indexesToCreate.has(key)) continue;
+			host._log("createIndex (text)", key, value.fields);
+			await host.collection.createIndex(value.fields, {
+				weights: value.weights,
+				name: key
+			});
+			break;
+		}
+		default:
+	}
+	try {
+		const toUpdate = new Set();
+		const existingSearchIndexes = await host.collection.listSearchIndexes().toArray();
+		for (const remote of existingSearchIndexes) {
+			if (!remote.name.startsWith(INDEX_PREFIX)) continue;
+			if (indexesToCreate.has(remote.name)) {
+				const local = indexesToCreate.get(remote.name);
+				const right = remote.latestDefinition;
+				switch (local.type) {
+					case "dynamic_text":
+					case "search_text": {
+						const left = local.definition;
+						if (left.analyzer === right.analyzer && fieldsMatch(left.mappings.fields || {}, right.mappings.fields || {})) indexesToCreate.delete(remote.name);
+else toUpdate.add(remote.name);
+						break;
+					}
+					case "vector": {
+						if (vectorFieldsMatch(local.definition.fields || [], right.fields || [])) indexesToCreate.delete(remote.name);
+else toUpdate.add(remote.name);
+						break;
+					}
+					default:
+				}
+			} else if (remote.status !== "DELETING") {
+				host._log("dropSearchIndex", remote.name);
+				await host.collection.dropSearchIndex(remote.name);
+			}
+		}
+		for (const [key, value] of indexesToCreate.entries()) switch (value.type) {
+			case "dynamic_text":
+			case "search_text":
+			case "vector": {
+				if (toUpdate.has(key)) {
+					host._log("updateSearchIndex", key, value.definition);
+					await host.collection.updateSearchIndex(key, value.definition);
+				} else {
+					host._log("createSearchIndex", key, value.type);
+					await host.collection.createSearchIndex({
+						name: key,
+						type: value.type === "vector" ? "vectorSearch" : "search",
+						definition: value.definition
+					});
+				}
+				break;
+			}
+			default:
+		}
+	} catch {}
+}
+function objMatch(o1, o2) {
+	const keys1 = Object.keys(o1);
+	const keys2 = Object.keys(o2);
+	if (keys1.length !== keys2.length) return false;
+	for (const key of keys1) if (o1[key] !== o2[key]) return false;
+	return true;
+}
+function fieldsMatch(left, right) {
+	if (!left || !right) return left === right;
+	const leftKeys = Object.keys(left);
+	const rightKeys = Object.keys(right);
+	if (leftKeys.length !== rightKeys.length) return false;
+	for (const key of leftKeys) {
+		if (!(key in right)) return false;
+		if (left[key].type !== right[key].type || left[key].analyzer !== right[key].analyzer) return false;
+	}
+	return true;
+}
+function vectorFieldsMatch(left, right) {
+	if (left.length !== (right || []).length) return false;
+	const rightMap = new Map();
+	for (const f of right || []) rightMap.set(f.path, f);
+	for (const l of left) {
+		const r = rightMap.get(l.path);
+		if (!r) return false;
+		if (l.type !== r.type || l.path !== r.path || l.similarity !== r.similarity || l.numDimensions !== r.numDimensions) return false;
+	}
+	return true;
+}
+
+//#endregion
+//#region packages/db-mongo/src/lib/validate-plugins.ts
+const validateMongoIdPlugin = (ctx, def, value) => {
+	if (def.type.tags?.has("objectId")) {
+		if (ctx.path === "_id" && (value === undefined || value === null)) {
+			const dbCtx = ctx.context;
+			if (dbCtx && (dbCtx.mode === "insert" || dbCtx.mode === "replace")) return true;
+		}
+		return ctx.validateAnnotatedType(def, value instanceof ObjectId ? value.toString() : value);
+	}
+};
+
+//#endregion
+//#region packages/db-mongo/src/lib/mongo-adapter.ts
+function _define_property(obj, key, value) {
+	if (key in obj) Object.defineProperty(obj, key, {
+		value,
+		enumerable: true,
+		configurable: true,
+		writable: true
+	});
+else obj[key] = value;
+	return obj;
+}
+var MongoAdapter = class MongoAdapter extends BaseDbAdapter {
+	get _client() {
+		return this.client;
+	}
+	get _txDisabled() {
+		return this.client ? MongoAdapter._txDisabledClients.has(this.client) : true;
+	}
+	set _txDisabled(value) {
+		if (value && this.client) MongoAdapter._txDisabledClients.add(this.client);
+	}
+	/**
+	* Uses MongoDB's Convenient Transaction API (`session.withTransaction()`).
+	* This handles txnNumber management and automatic retry for
+	* `TransientTransactionError` / `UnknownTransactionCommitResult`.
+	*/ async withTransaction(fn) {
+		if (this._getTransactionState()) return fn();
+		if (this._txDisabled || !this._client) return fn();
+		try {
+			const topology = this._client.topology;
+			if (topology) {
+				const desc = topology.description ?? topology.s?.description;
+				const type = desc?.type;
+				if (type === "Single" || type === "Unknown") {
+					this._txDisabled = true;
+					return fn();
+				}
+			}
+		} catch {
+			this._txDisabled = true;
+			return fn();
+		}
+		const session = this._client.startSession();
+		try {
+			let result;
+			await session.withTransaction(async () => {
+				result = await this._runInTransactionContext(session, fn);
+			});
+			return result;
+		} finally {
+			try {
+				await session.endSession();
+			} catch {}
+		}
+	}
+	/** Returns `{ session }` opts if inside a transaction, empty object otherwise. */ _getSessionOpts() {
+		const session = this._getTransactionState();
+		return session ? { session } : MongoAdapter._noSession;
+	}
+	get collection() {
+		if (!this._collection) this._collection = this.db.collection(this.resolveTableName(false));
+		return this._collection;
+	}
+	aggregatePipeline(pipeline) {
+		return this.collection.aggregate(pipeline, this._getSessionOpts());
+	}
+	async aggregate(query) {
+		const { buildAggregatePipeline, buildCountPipeline } = await import("./agg-CUX5Jb_A.mjs");
+		if (query.controls?.$count) {
+			const pipeline$1 = buildCountPipeline(query);
+			this._log("aggregate (count)", pipeline$1);
+			const result = await this.aggregatePipeline(pipeline$1).toArray();
+			return result.length > 0 ? result : [{ count: 0 }];
+		}
+		const pipeline = buildAggregatePipeline(query);
+		this._log("aggregate", pipeline);
+		return this.aggregatePipeline(pipeline).toArray();
+	}
+	get idType() {
+		const idProp = this._table.type.type.props.get("_id");
+		const idTags = idProp?.type.tags;
+		if (idTags?.has("objectId") && idTags?.has("mongo")) return "objectId";
+		if (idProp?.type.kind === "") return idProp.type.designType;
+		return "objectId";
+	}
+	prepareId(id, fieldType) {
+		const tags = fieldType.type.tags;
+		if (tags?.has("objectId") && tags?.has("mongo")) return id instanceof ObjectId ? id : new ObjectId(id);
+		if (fieldType.type.kind === "") {
+			const dt = fieldType.type.designType;
+			if (dt === "number") return Number(id);
+		}
+		return String(id);
+	}
+	/**
+	* Convenience method that uses `idType` to transform an ID value.
+	* For use in controllers that don't have access to the field type.
+	*/ prepareIdFromIdType(id) {
+		switch (this.idType) {
+			case "objectId": return id instanceof ObjectId ? id : new ObjectId(id);
+			case "number": return Number(id);
+			case "string": return String(id);
+			default: throw new Error("Unknown \"_id\" type");
+		}
+	}
+	supportsNestedObjects() {
+		return true;
+	}
+	supportsNativePatch() {
+		return true;
+	}
+	getValidatorPlugins() {
+		return [validateMongoIdPlugin];
+	}
+	getAdapterTableName(type) {
+		return undefined;
+	}
+	supportsNativeRelations() {
+		return true;
+	}
+	async loadRelations(rows, withRelations, relations, foreignKeys, tableResolver) {
+		return loadRelationsImpl(this, rows, withRelations, relations, foreignKeys, tableResolver);
+	}
+	/** Returns the context object used by CollectionPatcher. */ getPatcherContext() {
+		return {
+			flatMap: this._table.flatMap,
+			prepareId: (id) => this.prepareIdFromIdType(id),
+			createValidator: (opts) => this._table.createValidator(opts)
+		};
+	}
+	async nativePatch(filter, patch) {
+		const mongoFilter = buildMongoFilter(filter);
+		const patcher = new CollectionPatcher(this.getPatcherContext(), patch);
+		const { updateFilter, updateOptions } = patcher.preparePatch();
+		this._log("updateOne (patch)", mongoFilter, updateFilter);
+		const result = await this.collection.updateOne(mongoFilter, updateFilter, {
+			...updateOptions,
+			...this._getSessionOpts()
+		});
+		return {
+			matchedCount: result.matchedCount,
+			modifiedCount: result.modifiedCount
+		};
+	}
+	onBeforeFlatten(type) {
+		const typeMeta = type.metadata;
+		const capped = typeMeta.get("db.mongo.capped");
+		if (capped) this._cappedOptions = {
+			size: capped.size,
+			max: capped.max
+		};
+		const dynamicText = typeMeta.get("db.mongo.search.dynamic");
+		if (dynamicText) this._setSearchIndex("dynamic_text", "_", {
+			mappings: { dynamic: true },
+			analyzer: dynamicText.analyzer,
+			text: { fuzzy: { maxEdits: dynamicText.fuzzy || 0 } }
+		});
+		for (const textSearch of typeMeta.get("db.mongo.search.static") || []) this._setSearchIndex("search_text", textSearch.indexName, {
+			mappings: { fields: {} },
+			analyzer: textSearch.analyzer,
+			text: { fuzzy: { maxEdits: textSearch.fuzzy || 0 } }
+		});
+	}
+	onFieldScanned(field, type, metadata) {
+		if (field === "_id") this._hasExplicitId = true;
+		if (field !== "_id" && metadata.has("meta.id")) {
+			this._addMongoIndexField("unique", "__pk", field);
+			this._pendingUniqueFields.push(field);
+		}
+		if (metadata.has("db.default.increment")) {
+			const physicalName = metadata.get("db.column") ?? field;
+			const startValue = metadata.get("db.default.increment");
+			this._incrementFields.set(physicalName, typeof startValue === "number" ? startValue : undefined);
+		}
+		for (const index of metadata.get("db.index.fulltext") || []) {
+			const name = typeof index === "object" ? index.name || "" : "";
+			const weight = typeof index === "object" ? index.weight || 1 : 1;
+			this._addMongoIndexField("text", name, field, weight);
+		}
+		for (const index of metadata.get("db.mongo.search.text") || []) this._addFieldToSearchIndex("search_text", index.indexName, field, index.analyzer);
+		const vectorIndex = metadata.get("db.search.vector");
+		if (vectorIndex) {
+			const indexName = vectorIndex.indexName || field;
+			this._setSearchIndex("vector", indexName, { fields: [{
+				type: "vector",
+				path: field,
+				similarity: vectorIndex.similarity || "cosine",
+				numDimensions: vectorIndex.dimensions
+			}] });
+			const threshold = metadata.get("db.search.vector.threshold");
+			if (threshold !== undefined) this._vectorThresholds.set(mongoIndexKey("vector", indexName), threshold);
+		}
+		for (const indexName of metadata.get("db.search.filter") || []) this._vectorFilters.set(mongoIndexKey("vector", indexName), field);
+	}
+	getMetadataOverrides(meta) {
+		const uniqueFields = this._pendingUniqueFields;
+		if (this._hasExplicitId) return {
+			addPrimaryKeys: ["_id"],
+			removePrimaryKeys: meta.originalMetaIdFields.filter((f) => f !== "_id"),
+			addUniqueFields: uniqueFields.length > 0 ? uniqueFields : undefined
+		};
+		uniqueFields.push("_id");
+		return {
+			injectFields: [{
+				path: "_id",
+				type: {
+					__is_atscript_annotated_type: true,
+					type: {
+						kind: "",
+						designType: "string",
+						tags: new Set(["objectId", "mongo"])
+					},
+					metadata: new Map()
+				}
+			}],
+			addUniqueFields: uniqueFields
+		};
+	}
+	onAfterFlatten() {
+		for (const [key, value] of this._vectorFilters.entries()) {
+			const index = this._mongoIndexes.get(key);
+			if (index && index.type === "vector") index.definition.fields?.push({
+				type: "filter",
+				path: value
+			});
+		}
+		for (const fd of this._table.fieldDescriptors) if (fd.collate && fd.collate !== "binary") {
+			if (!this._collateFields) this._collateFields = new Map();
+			this._collateFields.set(fd.physicalName, fd.collate);
+		}
+	}
+	/** Returns MongoDB-specific search index map (internal). */ getMongoSearchIndexes() {
+		if (!this._searchIndexesMap) {
+			this._table.flatMap;
+			this._searchIndexesMap = new Map();
+			let defaultIndex;
+			for (const index of this._table.indexes.values()) if (index.type === "fulltext" && !defaultIndex) defaultIndex = {
+				key: index.key,
+				name: index.name,
+				type: "text",
+				fields: Object.fromEntries(index.fields.map((f) => [f.name, "text"])),
+				weights: Object.fromEntries(index.fields.filter((f) => f.weight).map((f) => [f.name, f.weight]))
+			};
+			for (const index of this._mongoIndexes.values()) switch (index.type) {
+				case "text": {
+					if (!defaultIndex) defaultIndex = index;
+					break;
+				}
+				case "dynamic_text": {
+					defaultIndex = index;
+					break;
+				}
+				case "search_text": {
+					if (!defaultIndex || defaultIndex.type === "text") defaultIndex = index;
+					this._searchIndexesMap.set(index.name, index);
+					break;
+				}
+				case "vector": {
+					this._searchIndexesMap.set(index.name, index);
+					break;
+				}
+				default:
+			}
+			if (defaultIndex && !this._searchIndexesMap.has(DEFAULT_INDEX_NAME)) this._searchIndexesMap.set(DEFAULT_INDEX_NAME, defaultIndex);
+		}
+		return this._searchIndexesMap;
+	}
+	/** Returns a specific MongoDB search index by name. */ getMongoSearchIndex(name = DEFAULT_INDEX_NAME) {
+		return this.getMongoSearchIndexes().get(name);
+	}
+	/** Returns the default similarity threshold for a vector index (from @db.search.vector.threshold). */ getVectorThreshold(indexName) {
+		const key = mongoIndexKey("vector", indexName || DEFAULT_INDEX_NAME);
+		return this._vectorThresholds.get(key);
+	}
+	getSearchIndexes() {
+		return getSearchIndexesImpl(this);
+	}
+	isVectorSearchable() {
+		return isVectorSearchableImpl(this);
+	}
+	async search(text, query, indexName) {
+		return searchImpl(this, text, query, indexName);
+	}
+	async searchWithCount(text, query, indexName) {
+		return searchWithCountImpl(this, text, query, indexName);
+	}
+	async vectorSearch(vector, query, indexName) {
+		return vectorSearchImpl(this, vector, query, indexName);
+	}
+	async vectorSearchWithCount(vector, query, indexName) {
+		return vectorSearchWithCountImpl(this, vector, query, indexName);
+	}
+	async findManyWithCount(query) {
+		const filter = buildMongoFilter(query.filter);
+		const controls = query.controls || {};
+		const dataStages = [];
+		if (controls.$sort) dataStages.push({ $sort: controls.$sort });
+		if (controls.$skip) dataStages.push({ $skip: controls.$skip });
+		if (controls.$limit) dataStages.push({ $limit: controls.$limit });
+		if (controls.$select) dataStages.push({ $project: controls.$select.asProjection });
+		const pipeline = [{ $match: filter }, { $facet: {
+			data: dataStages,
+			meta: [{ $count: "count" }]
+		} }];
+		this._log("aggregate (findManyWithCount)", pipeline);
+		const result = await this.collection.aggregate(pipeline, {
+			...this._getCollationOpts(query),
+			...this._getSessionOpts()
+		}).toArray();
+		return {
+			data: result[0]?.data || [],
+			count: result[0]?.meta[0]?.count || 0
+		};
+	}
+	async collectionExists() {
+		const cols = await this.db.listCollections({ name: this._table.tableName }).toArray();
+		return cols.length > 0;
+	}
+	async ensureCollectionExists() {
+		const exists = await this.collectionExists();
+		if (!exists) {
+			this._log("createCollection", this._table.tableName);
+			const opts = { comment: "Created by Atscript Mongo Adapter" };
+			if (this._cappedOptions) {
+				opts.capped = true;
+				opts.size = this._cappedOptions.size;
+				if (this._cappedOptions.max !== null && this._cappedOptions.max !== undefined) opts.max = this._cappedOptions.max;
+			}
+			await this.db.createCollection(this._table.tableName, opts);
+		}
+	}
+	/**
+	* Wraps an async operation to catch MongoDB duplicate key errors
+	* (code 11000) and rethrow as structured `DbError`.
+	*/ async _wrapDuplicateKeyError(fn) {
+		try {
+			return await fn();
+		} catch (error) {
+			if (error instanceof MongoServerError && error.code === 11e3) {
+				const field = error.keyPattern ? Object.keys(error.keyPattern)[0] ?? "" : "";
+				throw new DbError("CONFLICT", [{
+					path: field,
+					message: error.message
+				}]);
+			}
+			throw error;
+		}
+	}
+	async insertOne(data) {
+		if (this._incrementFields.size > 0) {
+			const fields = this._fieldsNeedingIncrement(data);
+			if (fields.length > 0) {
+				const nextValues = await this._allocateIncrementValues(fields, 1);
+				for (const physical of fields) data[physical] = nextValues.get(physical) ?? 1;
+			}
+		}
+		this._log("insertOne", data);
+		const result = await this._wrapDuplicateKeyError(() => this.collection.insertOne(data, this._getSessionOpts()));
+		return { insertedId: this._resolveInsertedId(data, result.insertedId) };
+	}
+	async insertMany(data) {
+		if (this._incrementFields.size > 0) {
+			const allFields = new Set();
+			for (const item of data) for (const f of this._fieldsNeedingIncrement(item)) allFields.add(f);
+			if (allFields.size > 0) await this._assignBatchIncrements(data, allFields);
+		}
+		this._log("insertMany", `${data.length} docs`);
+		const result = await this._wrapDuplicateKeyError(() => this.collection.insertMany(data, this._getSessionOpts()));
+		return {
+			insertedCount: result.insertedCount,
+			insertedIds: data.map((item, i) => this._resolveInsertedId(item, result.insertedIds[i]))
+		};
+	}
+	async findOne(query) {
+		const filter = buildMongoFilter(query.filter);
+		const opts = this._buildFindOptions(query.controls);
+		this._log("findOne", filter, opts);
+		return this.collection.findOne(filter, {
+			...opts,
+			...this._getCollationOpts(query),
+			...this._getSessionOpts()
+		});
+	}
+	async findMany(query) {
+		const filter = buildMongoFilter(query.filter);
+		const opts = this._buildFindOptions(query.controls);
+		this._log("findMany", filter, opts);
+		return this.collection.find(filter, {
+			...opts,
+			...this._getCollationOpts(query),
+			...this._getSessionOpts()
+		}).toArray();
+	}
+	async count(query) {
+		const filter = buildMongoFilter(query.filter);
+		this._log("countDocuments", filter);
+		return this.collection.countDocuments(filter, {
+			...this._getCollationOpts(query),
+			...this._getSessionOpts()
+		});
+	}
+	async updateOne(filter, data) {
+		const mongoFilter = buildMongoFilter(filter);
+		this._log("updateOne", mongoFilter, { $set: data });
+		const result = await this.collection.updateOne(mongoFilter, { $set: data }, this._getSessionOpts());
+		return {
+			matchedCount: result.matchedCount,
+			modifiedCount: result.modifiedCount
+		};
+	}
+	async replaceOne(filter, data) {
+		const mongoFilter = buildMongoFilter(filter);
+		this._log("replaceOne", mongoFilter, data);
+		const result = await this._wrapDuplicateKeyError(() => this.collection.replaceOne(mongoFilter, data, this._getSessionOpts()));
+		return {
+			matchedCount: result.matchedCount,
+			modifiedCount: result.modifiedCount
+		};
+	}
+	async deleteOne(filter) {
+		const mongoFilter = buildMongoFilter(filter);
+		this._log("deleteOne", mongoFilter);
+		const result = await this.collection.deleteOne(mongoFilter, this._getSessionOpts());
+		return { deletedCount: result.deletedCount };
+	}
+	async updateMany(filter, data) {
+		const mongoFilter = buildMongoFilter(filter);
+		this._log("updateMany", mongoFilter, { $set: data });
+		const result = await this.collection.updateMany(mongoFilter, { $set: data }, this._getSessionOpts());
+		return {
+			matchedCount: result.matchedCount,
+			modifiedCount: result.modifiedCount
+		};
+	}
+	async replaceMany(filter, data) {
+		const mongoFilter = buildMongoFilter(filter);
+		this._log("replaceMany", mongoFilter, { $set: data });
+		const result = await this.collection.updateMany(mongoFilter, { $set: data }, this._getSessionOpts());
+		return {
+			matchedCount: result.matchedCount,
+			modifiedCount: result.modifiedCount
+		};
+	}
+	async deleteMany(filter) {
+		const mongoFilter = buildMongoFilter(filter);
+		this._log("deleteMany", mongoFilter);
+		const result = await this.collection.deleteMany(mongoFilter, this._getSessionOpts());
+		return { deletedCount: result.deletedCount };
+	}
+	clearCollectionCache() {
+		this._collection = undefined;
+	}
+	async tableExists() {
+		return tableExistsImpl(this);
+	}
+	async ensureTable() {
+		return ensureTableImpl(this, this._table);
+	}
+	async syncIndexes() {
+		return syncIndexesImpl(this);
+	}
+	async syncColumns(diff) {
+		return syncColumnsImpl(this, diff);
+	}
+	async dropColumns(columns) {
+		return dropColumnsImpl(this, columns);
+	}
+	async renameTable(oldName) {
+		return renameTableImpl(this, oldName);
+	}
+	async recreateTable() {
+		return recreateTableImpl(this);
+	}
+	async dropTable() {
+		return dropTableImpl(this);
+	}
+	async dropViewByName(viewName) {
+		return dropViewByNameImpl(this, viewName);
+	}
+	async dropTableByName(tableName) {
+		return dropTableByNameImpl(this, tableName);
+	}
+	getDesiredTableOptions() {
+		return getDesiredTableOptionsImpl(this._cappedOptions);
+	}
+	async getExistingTableOptions() {
+		return getExistingTableOptionsImpl(this);
+	}
+	destructiveOptionKeys() {
+		return DESTRUCTIVE_OPTION_KEYS;
+	}
+	/** Returns the counters collection used for atomic auto-increment. */ get _countersCollection() {
+		return this.db.collection("__atscript_counters");
+	}
+	/** Returns physical field names of increment fields that are undefined in the data. */ _fieldsNeedingIncrement(data) {
+		const result = [];
+		for (const physical of this._incrementFields.keys()) if (data[physical] === undefined || data[physical] === null) result.push(physical);
+		return result;
+	}
+	/**
+	* Atomically allocates `count` sequential values for each increment field
+	* using a counter collection. Returns a map of field → first allocated value.
+	*/ async _allocateIncrementValues(physicalFields, count) {
+		const counters = this._countersCollection;
+		const collectionName = this._table.tableName;
+		const result = new Map();
+		for (const field of physicalFields) {
+			const counterId = `${collectionName}.${field}`;
+			const startValue = this._incrementFields.get(field);
+			const doc = await counters.findOneAndUpdate({ _id: counterId }, { $inc: { seq: count } }, {
+				upsert: true,
+				returnDocument: "after"
+			});
+			const seq = doc?.seq ?? count;
+			if (seq === count) {
+				const currentMax = await this._getCurrentFieldMax(field);
+				const minStart = typeof startValue === "number" ? startValue : 1;
+				const effectiveBase = Math.max(minStart, currentMax + 1);
+				if (effectiveBase > seq) {
+					const adjusted = effectiveBase + count - 1;
+					await counters.updateOne({ _id: counterId }, { $max: { seq: adjusted } });
+					result.set(field, effectiveBase);
+					continue;
+				}
+			}
+			result.set(field, seq - count + 1);
+		}
+		return result;
+	}
+	/** Reads current max value for a single field via $group aggregation. */ async _getCurrentFieldMax(field) {
+		const alias = `max__${field.replace(/\./g, "__")}`;
+		const agg = await this.collection.aggregate([{ $group: {
+			_id: null,
+			[alias]: { $max: `$${field}` }
+		} }]).toArray();
+		if (agg.length > 0) {
+			const val = agg[0][alias];
+			if (typeof val === "number") return val;
+		}
+		return 0;
+	}
+	/** Allocates increment values for a batch of items, assigning in order. */ async _assignBatchIncrements(data, allFields) {
+		const fieldCounts = new Map();
+		for (const physical of allFields) {
+			let count = 0;
+			for (const item of data) if (item[physical] === undefined || item[physical] === null) count++;
+			if (count > 0) fieldCounts.set(physical, count);
+		}
+		const fieldCounters = new Map();
+		for (const [physical, count] of fieldCounts) {
+			const allocated = await this._allocateIncrementValues([physical], count);
+			fieldCounters.set(physical, allocated.get(physical) ?? 1);
+		}
+		for (const item of data) for (const physical of allFields) if (item[physical] === undefined || item[physical] === null) {
+			const next = fieldCounters.get(physical) ?? 1;
+			item[physical] = next;
+			fieldCounters.set(physical, next + 1);
+		}
+	}
+	_buildFindOptions(controls) {
+		const opts = {};
+		if (!controls) return opts;
+		if (controls.$sort) opts.sort = controls.$sort;
+		if (controls.$limit) opts.limit = controls.$limit;
+		if (controls.$skip) opts.skip = controls.$skip;
+		if (controls.$select) opts.projection = controls.$select.asProjection;
+		return opts;
+	}
+	/**
+	* Returns MongoDB collation options if any filter field has a non-binary collation.
+	* Uses pre-computed insights when available, falls back to computing them on demand.
+	* Maps: nocase → strength 2 (case-insensitive), unicode → strength 1 (case+accent-insensitive).
+	*/ _getCollationOpts(query) {
+		if (!this._collateFields) return undefined;
+		const insights = query.insights ?? computeInsights(query.filter);
+		let strength;
+		for (const field of insights.keys()) {
+			const collation = this._collateFields.get(field);
+			if (collation === "unicode") return { collation: {
+				locale: "en",
+				strength: 1
+			} };
+			if (collation === "nocase") strength = 2;
+		}
+		return strength ? { collation: {
+			locale: "en",
+			strength
+		} } : undefined;
+	}
+	_addMongoIndexField(type, name, field, weight) {
+		const key = mongoIndexKey(type, name);
+		let index = this._mongoIndexes.get(key);
+		const value = type === "text" ? "text" : 1;
+		if (index) index.fields[field] = value;
+else {
+			index = {
+				key,
+				name,
+				type,
+				fields: { [field]: value },
+				weights: {}
+			};
+			this._mongoIndexes.set(key, index);
+		}
+		if (weight) index.weights[field] = weight;
+	}
+	_setSearchIndex(type, name, definition) {
+		const key = mongoIndexKey(type, name || DEFAULT_INDEX_NAME);
+		this._mongoIndexes.set(key, {
+			key,
+			name: name || DEFAULT_INDEX_NAME,
+			type,
+			definition
+		});
+	}
+	_addFieldToSearchIndex(type, _name, fieldName, analyzer) {
+		const name = _name || DEFAULT_INDEX_NAME;
+		let index = this._mongoIndexes.get(mongoIndexKey(type, name));
+		if (!index && type === "search_text") {
+			this._setSearchIndex(type, name, {
+				mappings: { fields: {} },
+				text: { fuzzy: { maxEdits: 0 } }
+			});
+			index = this._mongoIndexes.get(mongoIndexKey(type, name));
+		}
+		if (index) {
+			index.definition.mappings.fields[fieldName] = { type: "string" };
+			if (analyzer) index.definition.mappings.fields[fieldName].analyzer = analyzer;
+		}
+	}
+	constructor(db, client) {
+		super(), _define_property(this, "db", void 0), _define_property(this, "client", void 0), _define_property(this, "_collection", void 0), _define_property(this, "_mongoIndexes", void 0), _define_property(this, "_vectorFilters", void 0), _define_property(this, "_vectorThresholds", void 0), _define_property(this, "_searchIndexesMap", void 0), _define_property(this, "_incrementFields", void 0), _define_property(this, "_collateFields", void 0), _define_property(this, "_cappedOptions", void 0), _define_property(this, "_hasExplicitId", void 0), _define_property(this, "_pendingUniqueFields", void 0), this.db = db, this.client = client, this._mongoIndexes = new Map(), this._vectorFilters = new Map(), this._vectorThresholds = new Map(), this._incrementFields = new Map(), this._hasExplicitId = false, this._pendingUniqueFields = [];
+	}
+};
+/**
+* Per-client cache: whether transactions are unavailable (standalone MongoDB).
+* Shared across all adapter instances for the same client so topology is probed once.
+*/ _define_property(MongoAdapter, "_txDisabledClients", new WeakSet());
+_define_property(MongoAdapter, "_noSession", Object.freeze({}));
+
+//#endregion
+//#region packages/db-mongo/src/lib/index.ts
+function createAdapter(connection, _options) {
+	const client = new MongoClient(connection);
+	const db = client.db();
+	return new DbSpace(() => new MongoAdapter(db, client));
+}
+
+//#endregion
+export { CollectionPatcher, MongoAdapter, buildMongoFilter, createAdapter, validateMongoIdPlugin };