@atscript/db-mongo 0.1.39 → 0.1.41

package/dist/index.mjs

@@ -1,27 +1,57 @@
-import { buildMongoFilter } from "./mongo-filter-CL69Yhcm.mjs";
-import { AtscriptDbView, BaseDbAdapter, DbError, DbSpace, computeInsights, getKeyProps } from "@atscript/db";
+import { t as buildMongoFilter } from "./mongo-filter-CcQO-sEh.mjs";
+import { AtscriptDbView, BaseDbAdapter, DbError, DbSpace, computeInsights, getDbFieldOp, 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;
-}
+//#region src/lib/collection-patcher.ts
+/**
+* CollectionPatcher is a small helper that converts a *patch payload* produced
+* by Atscript into a shape that the official MongoDB driver understands – a
+* triple of `(filter, update, options)` to be fed to `collection.updateOne()`.
+*
+* Supported high‑level operations for *top‑level arrays* (see the attached
+* spreadsheet in the chat):
+*
+* | Payload field | MongoDB operator        | Purpose                                |
+* |-------------- |-------------------------|----------------------------------------|
+* | `$replace`    | full `$set`             | Replace the whole array.               |
+* | `$insert`     | `$push`                 | Append new items (duplicates allowed). |
+* | `$upsert`     | custom                  | Insert or update by *key* (see TODO).  |
+* | `$update`     | `$set` + `arrayFilters` | Update array elements matched by *key* |
+* | `$remove`     | `$pullAll` / `$pull`    | Remove by value or by *key*.           |
+*
+* The class walks through the incoming payload, detects which of the above
+* operations applies to each top‑level array and builds the corresponding
+* MongoDB update document. Primitive fields are flattened into a regular
+* `$set` map.
+*/
 var CollectionPatcher = class {
+	constructor(collection, payload, ops) {
+		this.collection = collection;
+		this.payload = payload;
+		this.ops = ops;
+	}
+	static getKeyProps = getKeyProps;
+	/**
+	* Internal accumulator: filter passed to `updateOne()`.
+	* Filled only with the `_id` field right now.
+	*/
+	filterObj = {};
+	/** MongoDB *update* document being built. */
+	updatePipeline = [];
+	/** Current `$set` stage being populated. */
+	currentSetStage = null;
+	/** Additional *options* (mainly `arrayFilters`). */
+	optionsObj = {};
 	/**
 	* Entry point – walk the payload, build `filter`, `update` and `options`.
 	*
 	* @returns Helper object exposing both individual parts and
 	*          a `.toArgs()` convenience callback.
-	*/ preparePatch() {
+	*/
+	preparePatch() {
 		this.filterObj = { _id: this.collection.prepareId(this.payload._id) };
 		this.flattenPayload(this.payload);
+		if (this.ops?.inc) for (const key in this.ops.inc) this._set(key, this._fieldOpExpr(key, "inc", this.ops.inc[key]));
+		if (this.ops?.mul) for (const key in this.ops.mul) this._set(key, this._fieldOpExpr(key, "mul", this.ops.mul[key]));
 		const updateFilter = this.updatePipeline;
 		return {
 			toArgs: () => [
@@ -34,13 +64,18 @@ var CollectionPatcher = class {
 			updateOptions: this.optionsObj
 		};
 	}
+	/** Builds a MongoDB aggregation expression for an $inc or $mul field op. */
+	_fieldOpExpr(key, op, value) {
+		return op === "inc" ? { $add: [`$${key}`, value] } : { $multiply: [`$${key}`, value] };
+	}
 	/**
 	* 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) {
+	*/
+	_set(key, val) {
 		if (this.currentSetStage && !(key in this.currentSetStage.$set)) {
 			this.currentSetStage.$set[key] = val;
 			return;
@@ -55,15 +90,20 @@ var CollectionPatcher = class {
 	* @param payload Current payload chunk
 	* @param prefix  Dotted path accumulated so far
 	* @private
-	*/ flattenPayload(payload, prefix = "") {
+	*/
+	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);
+			else if (typeof value === "object" && flatType?.metadata?.get("db.patch.strategy") === "merge") this.flattenPayload(value, key);
+			else if (key !== "_id") {
+				const fieldOp = getDbFieldOp(value);
+				if (fieldOp) this._set(key, this._fieldOpExpr(key, fieldOp.op, fieldOp.value));
+				else this._set(key, value);
+			}
 		}
 		return this.updatePipeline;
 	}
@@ -74,13 +114,14 @@ else if (key !== "_id") this._set(key, value);
 	* @param key   Dotted path to the array field
 	* @param value Payload slice for that field
 	* @private
-	*/ parseArrayPatch(key, value, flatType) {
+	*/
+	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 keyProps = flatType.type.kind === "array" ? getKeyProps(flatType) : /* @__PURE__ */ new Set();
 		const keys = keyProps.size > 0 ? [...keyProps] : [];
 		this._remove(key, toRemove, keys, flatType);
 		this._replace(key, toReplace);
@@ -98,7 +139,8 @@ else if (key !== "_id") this._set(key, value);
 	* @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) {
+	*/
+	_keysEqual(keys, left, right) {
 		const eqs = keys.map((k) => ({ $eq: [`${left}.${k}`, `${right}.${k}`] }));
 		return eqs.length === 1 ? eqs[0] : { $and: eqs };
 	}
@@ -108,24 +150,26 @@ else if (key !== "_id") this._set(key, value);
 	* @param key   Dotted path to the array
 	* @param input New array value (may be `undefined`)
 	* @private
-	*/ _replace(key, input) {
+	*/
+	_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) {
+	*/
+	_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] });
+		if (flatType.metadata?.has("expect.array.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) {
+	*/
+	_upsert(key, input, keys, flatType) {
 		if (!input?.length) return;
 		if (keys.length > 0) {
 			const mergeStrategy = flatType.metadata?.get("db.patch.strategy") === "merge";
@@ -166,7 +210,8 @@ else this._set(key, { $concatArrays: [{ $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) {
+	*/
+	_update(key, input, keys, flatType) {
 		if (!input?.length) return;
 		if (keys.length > 0) {
 			const mergeStrategy = flatType.metadata?.get("db.patch.strategy") === "merge";
@@ -189,7 +234,8 @@ else this._set(key, { $concatArrays: [{ $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) {
+	*/
+	_remove(key, input, keys, _flatType) {
 		if (!input?.length) return;
 		if (keys.length > 0) this._set(key, { $let: {
 			vars: { rem: input },
@@ -203,46 +249,29 @@ else this._set(key, { $concatArrays: [{ $ifNull: [`$${key}`, []] }, input] });
 				} } } }
 			} }
 		} });
-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 = {};
+		else this._set(key, { $setDifference: [{ $ifNull: [`$${key}`, []] }, input] });
 	}
 };
-_define_property$1(CollectionPatcher, "getKeyProps", getKeyProps);
-
 //#endregion
-//#region packages/db-mongo/src/lib/mongo-types.ts
+//#region 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}`;
+	return `${INDEX_PREFIX}${type}__${name.replace(/[^a-z0-9_.-]/gi, "_").replace(/_+/g, "_").slice(0, 117 - type.length - 2)}`;
 }
-
 //#endregion
-//#region packages/db-mongo/src/lib/mongo-relations.ts
+//#region src/lib/mongo-relations.ts
 function buildPKKey(primaryKeys, doc) {
-	if (primaryKeys.length === 1) return String(doc[primaryKeys[0]] ?? "");
+	if (primaryKeys.length === 1) {
+		const val = doc[primaryKeys[0]];
+		return val == null ? "" : `${val}`;
+	}
 	let key = "";
 	for (let i = 0; i < primaryKeys.length; i++) {
 		if (i > 0) key += "\0";
-		key += String(doc[primaryKeys[i]] ?? "");
+		const val = doc[primaryKeys[i]];
+		key += val == null ? "" : `${val}`;
 	}
 	return key;
 }
@@ -269,23 +298,23 @@ async function loadRelationsImpl(host, rows, withRelations, relations, foreignKe
 	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);
+		mergeRelationResults(rows, await host.collection.aggregate(pipeline, host._getSessionOpts()).toArray(), 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) {
+/** 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();
+		const values = /* @__PURE__ */ new Set();
 		for (const row of rows) {
 			const v = row[pk];
-			if (v !== null && v !== undefined) values.add(v);
+			if (v !== null && v !== void 0) values.add(v);
 		}
-		if (values.size === 0) return undefined;
+		if (values.size === 0) return;
 		return { [pk]: { $in: [...values] } };
 	}
-	const seen = new Set();
+	const seen = /* @__PURE__ */ new Set();
 	const orFilters = [];
 	for (const row of rows) {
 		const key = buildPKKey(primaryKeys, row);
@@ -295,7 +324,7 @@ async function loadRelationsImpl(host, rows, withRelations, relations, foreignKe
 		let valid = true;
 		for (const pk of primaryKeys) {
 			const val = row[pk];
-			if (val === null || val === undefined) {
+			if (val === null || val === void 0) {
 				valid = false;
 				break;
 			}
@@ -303,18 +332,20 @@ async function loadRelationsImpl(host, rows, withRelations, relations, foreignKe
 		}
 		if (valid) orFilters.push(condition);
 	}
-	if (orFilters.length === 0) return undefined;
+	if (orFilters.length === 0) return;
 	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) {
+/** 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;
+		default: return;
 	}
 }
-/** Builds `let` variable bindings and the corresponding `$expr` match for `$lookup`. */ function buildLookupJoin(localFields, remoteFields, varPrefix) {
+/** 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 {
@@ -328,32 +359,33 @@ async function loadRelationsImpl(host, rows, withRelations, relations, foreignKe
 		exprMatch: { $and: andClauses }
 	};
 }
-/** $lookup for TO relations (FK is on this table → target). Always single-valued. */ function buildToLookup(withRel, relation, foreignKeys) {
+/** $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;
+	if (!fk) return;
 	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,
+		stages: [{ $lookup: {
+			from: fk.targetTable,
+			let: letVars,
+			pipeline: [{ $match: { $expr: exprMatch } }, ...innerPipeline],
+			as: withRel.name
+		} }, { $unwind: {
+			path: `$${withRel.name}`,
+			preserveNullAndEmptyArrays: true
+		} }],
 		isArray: false
 	};
 }
-/** $lookup for FROM relations (FK is on target → this table). */ function buildFromLookup(host, withRel, relation, tableResolver) {
+/** $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;
+	if (!targetType || !tableResolver) return;
 	const targetMeta = tableResolver(targetType);
-	if (!targetMeta) return undefined;
+	if (!targetMeta) return;
 	const remoteFK = findRemoteFK(targetMeta, host._table.tableName, relation.alias);
-	if (!remoteFK) return undefined;
+	if (!remoteFK) return;
 	const targetTableName = resolveRelTargetTableName(relation);
 	const innerPipeline = buildLookupInnerPipeline(withRel, remoteFK.fields);
 	const { letVars, exprMatch } = buildLookupJoin(remoteFK.targetFields, remoteFK.fields, "pk_");
@@ -372,46 +404,47 @@ async function loadRelationsImpl(host, rows, withRelations, relations, foreignKe
 		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;
+/** $lookup for VIA relations (M:N through junction table). Always array. */
+function buildViaLookup(host, withRel, relation, tableResolver) {
+	if (!relation.viaType || !tableResolver) return;
 	const junctionType = relation.viaType();
-	if (!junctionType) return undefined;
+	if (!junctionType) return;
 	const junctionMeta = tableResolver(junctionType);
-	if (!junctionMeta) return undefined;
+	if (!junctionMeta) return;
 	const junctionTableName = junctionType.metadata?.get("db.table") || junctionType.id || "";
 	const targetTableName = resolveRelTargetTableName(relation);
 	const fkToThis = findRemoteFK(junctionMeta, host._table.tableName);
-	if (!fkToThis) return undefined;
+	if (!fkToThis) return;
 	const fkToTarget = findRemoteFK(junctionMeta, targetTableName);
-	if (!fkToTarget) return undefined;
+	if (!fkToTarget) return;
 	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,
+		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
+		} }],
 		isArray: true
 	};
 }
-/** Builds inner pipeline stages for relation controls ($sort, $limit, $skip, $select, filter). */ function buildLookupInnerPipeline(withRel, requiredFields) {
+/** 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 || {};
@@ -423,7 +456,7 @@ async function loadRelationsImpl(host, rows, withRelations, relations, foreignKe
 	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 (limit !== null && limit !== void 0) pipeline.push({ $limit: limit });
 	if (select) {
 		const projection = {};
 		for (const f of select) projection[f] = 1;
@@ -433,13 +466,14 @@ async function loadRelationsImpl(host, rows, withRelations, relations, foreignKe
 	}
 	return pipeline;
 }
-/** Extracts nested $with from a WithRelation's controls. */ function extractNestedWith(withRel) {
+/** 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;
+	const nestedWith = (withRel.controls || {}).$with || flatRel.$with;
+	return nestedWith && nestedWith.length > 0 ? nestedWith : void 0;
 }
-/** Post-processes nested $with by delegating to the target table's own relation loading. */ async function loadNestedRelations(rows, relMeta, tableResolver) {
+/** 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) {
@@ -452,26 +486,28 @@ async function loadRelationsImpl(host, rows, withRelations, relations, foreignKe
 		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);
+			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();
+/** Merges aggregation results back onto the original rows by PK. */
+function mergeRelationResults(rows, results, primaryKeys, relMeta) {
+	const resultIndex = /* @__PURE__ */ 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] = 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) {
+/** 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 {
@@ -484,22 +520,22 @@ else row[meta.name] = value ?? (meta.isArray ? [] : null);
 		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) {
+/** 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) {
+/** 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
+//#region src/lib/mongo-search.ts
+/** Returns available search indexes as generic metadata for UI. */
 function getSearchIndexesImpl(host) {
 	const result = [];
 	for (const [name, index] of host.getMongoSearchIndexes()) result.push({
@@ -509,40 +545,43 @@ function getSearchIndexesImpl(host) {
 	});
 	return result;
 }
+/** Checks if any vector search index is available. */
 function isVectorSearchableImpl(host) {
 	for (const index of host.getMongoSearchIndexes().values()) if (index.type === "vector") return true;
 	return false;
 }
+/** Text search via $search aggregation stage. */
 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");
 }
+/** Text search with faceted count. */
 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");
 }
+/** Vector search via $vectorSearch aggregation stage. */
 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);
+	return runSearchPipeline(host, buildVectorSearchStage(host, vector, indexName, controls.$limit), query, "vectorSearch", resolveThreshold(host, controls, indexName));
 }
+/** Vector search with faceted count. */
 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);
+	return runSearchWithCountPipeline(host, buildVectorSearchStage(host, vector, indexName, controls.$limit), query, "vectorSearchWithCount", resolveThreshold(host, controls, indexName));
 }
-/** Resolves the effective threshold: query-time $threshold > schema-level @db.search.vector.threshold. */ function resolveThreshold(host, controls, indexName) {
+/** 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;
+	if (queryThreshold !== void 0) return queryThreshold;
 	return host.getVectorThreshold(indexName);
 }
-/** Builds a MongoDB $search pipeline stage for text search. */ function buildSearchStage(host, text, 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) return;
 	if (index.type === "vector") throw new Error("Vector indexes cannot be used with text search. Use vectorSearch() instead.");
 	return { $search: {
 		index: index.key,
@@ -552,7 +591,8 @@ async function vectorSearchWithCountImpl(host, vector, query, indexName) {
 		}
 	} };
 }
-/** Builds a $vectorSearch aggregation stage from a pre-computed vector. */ function buildVectorSearchStage(host, vector, indexName, limit) {
+/** 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);
@@ -579,11 +619,12 @@ async function vectorSearchWithCountImpl(host, vector, query, indexName) {
 		limit: limit || 20
 	} };
 }
-/** Runs a search/vector pipeline and returns results. Shared by search + vectorSearch. */ async function runSearchPipeline(host, stage, query, label, threshold) {
+/** 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) {
+	if (threshold !== void 0) {
 		pipeline.push({ $addFields: { _score: { $meta: "vectorSearchScore" } } });
 		pipeline.push({ $match: { _score: { $gte: threshold } } });
 	}
@@ -591,16 +632,17 @@ async function vectorSearchWithCountImpl(host, vector, query, indexName) {
 	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 });
+	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) {
+/** 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) {
+	if (threshold !== void 0) {
 		preStages.push({ $addFields: { _score: { $meta: "vectorSearchScore" } } });
 		preStages.push({ $match: { _score: { $gte: threshold } } });
 	}
@@ -625,9 +667,8 @@ else pipeline.push({ $limit: 1e3 });
 		count: result[0]?.meta[0]?.count || 0
 	};
 }
-
 //#endregion
-//#region packages/db-mongo/src/lib/mongo-schema-sync.ts
+//#region src/lib/mongo-schema-sync.ts
 const DESTRUCTIVE_OPTION_KEYS = new Set([
 	"capped",
 	"capped.size",
@@ -645,7 +686,7 @@ function getDesiredTableOptionsImpl(cappedOptions) {
 		key: "capped.size",
 		value: String(cappedOptions.size)
 	}];
-	if (cappedOptions.max !== undefined) opts.push({
+	if (cappedOptions.max !== void 0) opts.push({
 		key: "capped.max",
 		value: String(cappedOptions.max)
 	});
@@ -660,11 +701,11 @@ async function getExistingTableOptionsImpl(host) {
 		key: "capped",
 		value: "true"
 	}];
-	if (collOpts.size !== undefined) opts.push({
+	if (collOpts.size !== void 0) opts.push({
 		key: "capped.size",
 		value: String(collOpts.size)
 	});
-	if (collOpts.max !== undefined) opts.push({
+	if (collOpts.max !== void 0) opts.push({
 		key: "capped.max",
 		value: String(collOpts.max)
 	});
@@ -674,9 +715,9 @@ 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;
+/** Creates a MongoDB view from the AtscriptDbView's view plan. */
+async function ensureView(host, view) {
+	if (await host.collectionExists()) return;
 	const plan = view.viewPlan;
 	const columns = view.getViewColumnMappings();
 	const pipeline = [];
@@ -698,13 +739,14 @@ async function ensureTableImpl(host, table) {
 		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}`;
+	/** 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) };
+			else group[col.viewColumn] = { [`$${col.aggFn}`]: colSourceField(col) };
 			project[col.viewColumn] = `$${col.viewColumn}`;
 		} else {
 			group._id[col.viewColumn] = colSourceField(col);
@@ -727,11 +769,10 @@ else group[col.viewColumn] = { [`$${col.aggFn}`]: colSourceField(col) };
 		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 {
+/** Extracts localField/foreignField from a join condition. */
+function resolveJoinFields(condition, entryTable, joinTable) {
+	const c = "$and" in condition ? condition.$and[0] : condition;
+	if ((c.left.type ? c.left.type()?.metadata?.get("db.table") || "" : entryTable) === joinTable) return {
 		localField: c.right.field,
 		foreignField: c.left.field
 	};
@@ -740,7 +781,8 @@ else group[col.viewColumn] = { [`$${col.aggFn}`]: colSourceField(col) };
 		foreignField: c.right.field
 	};
 }
-/** Translates an AtscriptQueryNode to a MongoDB $match expression. */ function queryNodeToMatch(node, entryTable) {
+/** Translates an AtscriptQueryNode to a MongoDB $match expression. */
+function queryNodeToMatch(node, entryTable) {
 	if ("$and" in node) {
 		const items = node.$and;
 		const result = [];
@@ -764,7 +806,8 @@ else group[col.viewColumn] = { [`$${col.aggFn}`]: colSourceField(col) };
 	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) {
+/** 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;
@@ -773,7 +816,8 @@ else group[col.viewColumn] = { [`$${col.aggFn}`]: colSourceField(col) };
 /**
 * 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) {
+*/
+function queryNodeToHaving(node, columns) {
 	const colMap = new Map(columns.map((c) => [c.viewColumn, c]));
 	const resolveHavingField = (ref) => {
 		if (!ref.type) {
@@ -854,7 +898,7 @@ async function syncColumnsImpl(host, diff) {
 		const setSpec = {};
 		for (const field of diff.added) {
 			const defaultVal = resolveSyncDefault(field);
-			if (defaultVal !== undefined) setSpec[field.physicalName] = defaultVal;
+			if (defaultVal !== void 0) setSpec[field.physicalName] = defaultVal;
 			added.push(field.physicalName);
 		}
 		if (Object.keys(setSpec).length > 0) update.$set = setSpec;
@@ -871,14 +915,14 @@ async function dropColumnsImpl(host, columns) {
 	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;
+/** Resolves a field's default value for bulk $set during column sync. */
+function resolveSyncDefault(field) {
+	if (!field.defaultValue) return field.optional ? null : void 0;
 	if (field.defaultValue.kind === "value") return field.defaultValue.value;
-	return undefined;
 }
 async function syncIndexesImpl(host) {
 	await host.ensureCollectionExists();
-	const allIndexes = new Map();
+	const allIndexes = /* @__PURE__ */ new Map();
 	for (const [key, index] of host._table.indexes.entries()) {
 		const fields = {};
 		const weights = {};
@@ -911,20 +955,19 @@ async function syncIndexesImpl(host) {
 	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 (!remote.name.startsWith("atscript__")) continue;
 		if (indexesToCreate.has(remote.name)) {
 			const local = indexesToCreate.get(remote.name);
 			switch (local.type) {
 				case "plain":
 				case "unique":
-				case "text": {
+				case "text":
 					if ((local.type === "text" || objMatch(local.fields, remote.key)) && objMatch(local.weights || {}, remote.weights || {})) indexesToCreate.delete(remote.name);
-else {
+					else {
 						host._log("dropIndex", remote.name);
 						await host.collection.dropIndex(remote.name);
 					}
 					break;
-				}
 				default:
 			}
 		} else {
@@ -933,13 +976,12 @@ else {
 		}
 	}
 	for (const [key, value] of allIndexes.entries()) switch (value.type) {
-		case "plain": {
+		case "plain":
 			if (!indexesToCreate.has(key)) continue;
 			host._log("createIndex", key, value.fields);
 			await host.collection.createIndex(value.fields, { name: key });
 			break;
-		}
-		case "unique": {
+		case "unique":
 			if (!indexesToCreate.has(key)) continue;
 			host._log("createIndex (unique)", key, value.fields);
 			await host.collection.createIndex(value.fields, {
@@ -947,8 +989,7 @@ else {
 				unique: true
 			});
 			break;
-		}
-		case "text": {
+		case "text":
 			if (!indexesToCreate.has(key)) continue;
 			host._log("createIndex (text)", key, value.fields);
 			await host.collection.createIndex(value.fields, {
@@ -956,14 +997,13 @@ else {
 				name: key
 			});
 			break;
-		}
 		default:
 	}
 	try {
-		const toUpdate = new Set();
+		const toUpdate = /* @__PURE__ */ new Set();
 		const existingSearchIndexes = await host.collection.listSearchIndexes().toArray();
 		for (const remote of existingSearchIndexes) {
-			if (!remote.name.startsWith(INDEX_PREFIX)) continue;
+			if (!remote.name.startsWith("atscript__")) continue;
 			if (indexesToCreate.has(remote.name)) {
 				const local = indexesToCreate.get(remote.name);
 				const right = remote.latestDefinition;
@@ -972,14 +1012,13 @@ else {
 					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);
+						else toUpdate.add(remote.name);
 						break;
 					}
-					case "vector": {
+					case "vector":
 						if (vectorFieldsMatch(local.definition.fields || [], right.fields || [])) indexesToCreate.delete(remote.name);
-else toUpdate.add(remote.name);
+						else toUpdate.add(remote.name);
 						break;
-					}
 					default:
 				}
 			} else if (remote.status !== "DELETING") {
@@ -990,7 +1029,7 @@ else toUpdate.add(remote.name);
 		for (const [key, value] of indexesToCreate.entries()) switch (value.type) {
 			case "dynamic_text":
 			case "search_text":
-			case "vector": {
+			case "vector":
 				if (toUpdate.has(key)) {
 					host._log("updateSearchIndex", key, value.definition);
 					await host.collection.updateSearchIndex(key, value.definition);
@@ -1003,7 +1042,6 @@ else toUpdate.add(remote.name);
 					});
 				}
 				break;
-			}
 			default:
 		}
 	} catch {}
@@ -1028,7 +1066,7 @@ function fieldsMatch(left, right) {
 }
 function vectorFieldsMatch(left, right) {
 	if (left.length !== (right || []).length) return false;
-	const rightMap = new Map();
+	const rightMap = /* @__PURE__ */ new Map();
 	for (const f of right || []) rightMap.set(f.path, f);
 	for (const l of left) {
 		const r = rightMap.get(l.path);
@@ -1037,35 +1075,52 @@ function vectorFieldsMatch(left, right) {
 	}
 	return true;
 }
-
 //#endregion
-//#region packages/db-mongo/src/lib/validate-plugins.ts
+//#region src/lib/validate-plugins.ts
 const validateMongoIdPlugin = (ctx, def, value) => {
 	if (def.type.tags?.has("objectId")) {
-		if (ctx.path === "_id" && (value === undefined || value === null)) {
+		if (ctx.path === "_id" && (value === void 0 || 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;
-}
+//#region src/lib/mongo-adapter.ts
 var MongoAdapter = class MongoAdapter extends BaseDbAdapter {
+	_collection;
+	/** MongoDB-specific indexes (search, vector) — separate from table.indexes. */
+	_mongoIndexes = /* @__PURE__ */ new Map();
+	/** Vector search filter associations built during flattening. */
+	_vectorFilters = /* @__PURE__ */ new Map();
+	/** Default similarity thresholds per vector index (from @db.search.vector.threshold). */
+	_vectorThresholds = /* @__PURE__ */ new Map();
+	/** Cached search index lookup. */
+	_searchIndexesMap;
+	/** Physical field names with @db.default.increment → optional start value. */
+	_incrementFields = /* @__PURE__ */ new Map();
+	/** Physical field names that have a non-binary collation (nocase/unicode). */
+	_collateFields;
+	/** Capped collection options from @db.mongo.capped. */
+	_cappedOptions;
+	/** Whether the schema explicitly defines _id (via @db.mongo.collection or manual _id field). */
+	_hasExplicitId = false;
+	/** Unique fields accumulated during onFieldScanned, returned via getMetadataOverrides. */
+	_pendingUniqueFields = [];
+	constructor(db, client) {
+		super();
+		this.db = db;
+		this.client = client;
+	}
 	get _client() {
 		return this.client;
 	}
+	/**
+	* Per-client cache: whether transactions are unavailable (standalone MongoDB).
+	* Shared across all adapter instances for the same client so topology is probed once.
+	*/
+	static _txDisabledClients = /* @__PURE__ */ new WeakSet();
 	get _txDisabled() {
 		return this.client ? MongoAdapter._txDisabledClients.has(this.client) : true;
 	}
@@ -1076,14 +1131,14 @@ var MongoAdapter = class MongoAdapter extends BaseDbAdapter {
 	* Uses MongoDB's Convenient Transaction API (`session.withTransaction()`).
 	* This handles txnNumber management and automatic retry for
 	* `TransientTransactionError` / `UnknownTransactionCommitResult`.
-	*/ async withTransaction(fn) {
+	*/
+	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;
+				const type = (topology.description ?? topology.s?.description)?.type;
 				if (type === "Single" || type === "Unknown") {
 					this._txDisabled = true;
 					return fn();
@@ -1106,7 +1161,9 @@ var MongoAdapter = class MongoAdapter extends BaseDbAdapter {
 			} catch {}
 		}
 	}
-	/** Returns `{ session }` opts if inside a transaction, empty object otherwise. */ _getSessionOpts() {
+	static _noSession = Object.freeze({});
+	/** Returns `{ session }` opts if inside a transaction, empty object otherwise. */
+	_getSessionOpts() {
 		const session = this._getTransactionState();
 		return session ? { session } : MongoAdapter._noSession;
 	}
@@ -1118,11 +1175,11 @@ var MongoAdapter = class MongoAdapter extends BaseDbAdapter {
 		return this.collection.aggregate(pipeline, this._getSessionOpts());
 	}
 	async aggregate(query) {
-		const { buildAggregatePipeline, buildCountPipeline } = await import("./agg-CUX5Jb_A.mjs");
+		const { buildAggregatePipeline, buildCountPipeline } = await import("./agg.mjs");
 		if (query.controls?.$count) {
-			const pipeline$1 = buildCountPipeline(query);
-			this._log("aggregate (count)", pipeline$1);
-			const result = await this.aggregatePipeline(pipeline$1).toArray();
+			const pipeline = buildCountPipeline(query);
+			this._log("aggregate (count)", pipeline);
+			const result = await this.aggregatePipeline(pipeline).toArray();
 			return result.length > 0 ? result : [{ count: 0 }];
 		}
 		const pipeline = buildAggregatePipeline(query);
@@ -1136,19 +1193,20 @@ var MongoAdapter = class MongoAdapter extends BaseDbAdapter {
 		if (idProp?.type.kind === "") return idProp.type.designType;
 		return "objectId";
 	}
-	prepareId(id, fieldType) {
+	prepareId(id, _fieldType) {
+		const fieldType = _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);
+			if (fieldType.type.designType === "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) {
+	*/
+	prepareIdFromIdType(id) {
 		switch (this.idType) {
 			case "objectId": return id instanceof ObjectId ? id : new ObjectId(id);
 			case "number": return Number(id);
@@ -1165,26 +1223,24 @@ var MongoAdapter = class MongoAdapter extends BaseDbAdapter {
 	getValidatorPlugins() {
 		return [validateMongoIdPlugin];
 	}
-	getAdapterTableName(type) {
-		return undefined;
-	}
+	getAdapterTableName(_type) {}
 	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() {
+	/** 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) {
+	async nativePatch(filter, patch, ops) {
 		const mongoFilter = buildMongoFilter(filter);
-		const patcher = new CollectionPatcher(this.getPatcherContext(), patch);
-		const { updateFilter, updateOptions } = patcher.preparePatch();
+		const { updateFilter, updateOptions } = new CollectionPatcher(this.getPatcherContext(), patch, ops).preparePatch();
 		this._log("updateOne (patch)", mongoFilter, updateFilter);
 		const result = await this.collection.updateOne(mongoFilter, updateFilter, {
 			...updateOptions,
@@ -1195,8 +1251,8 @@ var MongoAdapter = class MongoAdapter extends BaseDbAdapter {
 			modifiedCount: result.modifiedCount
 		};
 	}
-	onBeforeFlatten(type) {
-		const typeMeta = type.metadata;
+	onBeforeFlatten(_type) {
+		const typeMeta = _type.metadata;
 		const capped = typeMeta.get("db.mongo.capped");
 		if (capped) this._cappedOptions = {
 			size: capped.size,
@@ -1214,7 +1270,7 @@ var MongoAdapter = class MongoAdapter extends BaseDbAdapter {
 			text: { fuzzy: { maxEdits: textSearch.fuzzy || 0 } }
 		});
 	}
-	onFieldScanned(field, type, metadata) {
+	onFieldScanned(field, _type, metadata) {
 		if (field === "_id") this._hasExplicitId = true;
 		if (field !== "_id" && metadata.has("meta.id")) {
 			this._addMongoIndexField("unique", "__pk", field);
@@ -1223,7 +1279,7 @@ var MongoAdapter = class MongoAdapter extends BaseDbAdapter {
 		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);
+			this._incrementFields.set(physicalName, typeof startValue === "number" ? startValue : void 0);
 		}
 		for (const index of metadata.get("db.index.fulltext") || []) {
 			const name = typeof index === "object" ? index.name || "" : "";
@@ -1241,7 +1297,7 @@ var MongoAdapter = class MongoAdapter extends BaseDbAdapter {
 				numDimensions: vectorIndex.dimensions
 			}] });
 			const threshold = metadata.get("db.search.vector.threshold");
-			if (threshold !== undefined) this._vectorThresholds.set(mongoIndexKey("vector", indexName), threshold);
+			if (threshold !== void 0) this._vectorThresholds.set(mongoIndexKey("vector", indexName), threshold);
 		}
 		for (const indexName of metadata.get("db.search.filter") || []) this._vectorFilters.set(mongoIndexKey("vector", indexName), field);
 	}
@@ -1250,7 +1306,7 @@ var MongoAdapter = class MongoAdapter extends BaseDbAdapter {
 		if (this._hasExplicitId) return {
 			addPrimaryKeys: ["_id"],
 			removePrimaryKeys: meta.originalMetaIdFields.filter((f) => f !== "_id"),
-			addUniqueFields: uniqueFields.length > 0 ? uniqueFields : undefined
+			addUniqueFields: uniqueFields.length > 0 ? uniqueFields : void 0
 		};
 		uniqueFields.push("_id");
 		return {
@@ -1263,7 +1319,7 @@ var MongoAdapter = class MongoAdapter extends BaseDbAdapter {
 						designType: "string",
 						tags: new Set(["objectId", "mongo"])
 					},
-					metadata: new Map()
+					metadata: /* @__PURE__ */ new Map()
 				}
 			}],
 			addUniqueFields: uniqueFields
@@ -1278,14 +1334,15 @@ var MongoAdapter = class MongoAdapter extends BaseDbAdapter {
 			});
 		}
 		for (const fd of this._table.fieldDescriptors) if (fd.collate && fd.collate !== "binary") {
-			if (!this._collateFields) this._collateFields = new Map();
+			if (!this._collateFields) this._collateFields = /* @__PURE__ */ new Map();
 			this._collateFields.set(fd.physicalName, fd.collate);
 		}
 	}
-	/** Returns MongoDB-specific search index map (internal). */ getMongoSearchIndexes() {
+	/** Returns MongoDB-specific search index map (internal). */
+	getMongoSearchIndexes() {
 		if (!this._searchIndexesMap) {
 			this._table.flatMap;
-			this._searchIndexesMap = new Map();
+			this._searchIndexesMap = /* @__PURE__ */ new Map();
 			let defaultIndex;
 			for (const index of this._table.indexes.values()) if (index.type === "fulltext" && !defaultIndex) defaultIndex = {
 				key: index.key,
@@ -1295,34 +1352,32 @@ var MongoAdapter = class MongoAdapter extends BaseDbAdapter {
 				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": {
+				case "text":
 					if (!defaultIndex) defaultIndex = index;
 					break;
-				}
-				case "dynamic_text": {
+				case "dynamic_text":
 					defaultIndex = index;
 					break;
-				}
-				case "search_text": {
+				case "search_text":
 					if (!defaultIndex || defaultIndex.type === "text") defaultIndex = index;
 					this._searchIndexesMap.set(index.name, index);
 					break;
-				}
-				case "vector": {
+				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);
+			if (defaultIndex && !this._searchIndexesMap.has("DEFAULT")) this._searchIndexesMap.set(DEFAULT_INDEX_NAME, defaultIndex);
 		}
 		return this._searchIndexesMap;
 	}
-	/** Returns a specific MongoDB search index by name. */ getMongoSearchIndex(name = DEFAULT_INDEX_NAME) {
+	/** 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);
+	/** Returns the default similarity threshold for a vector index (from @db.search.vector.threshold). */
+	getVectorThreshold(indexName) {
+		const key = mongoIndexKey("vector", indexName || "DEFAULT");
 		return this._vectorThresholds.get(key);
 	}
 	getSearchIndexes() {
@@ -1366,18 +1421,16 @@ var MongoAdapter = class MongoAdapter extends BaseDbAdapter {
 		};
 	}
 	async collectionExists() {
-		const cols = await this.db.listCollections({ name: this._table.tableName }).toArray();
-		return cols.length > 0;
+		return (await this.db.listCollections({ name: this._table.tableName }).toArray()).length > 0;
 	}
 	async ensureCollectionExists() {
-		const exists = await this.collectionExists();
-		if (!exists) {
+		if (!await this.collectionExists()) {
 			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;
+				if (this._cappedOptions.max !== null && this._cappedOptions.max !== void 0) opts.max = this._cappedOptions.max;
 			}
 			await this.db.createCollection(this._table.tableName, opts);
 		}
@@ -1385,17 +1438,15 @@ var MongoAdapter = class MongoAdapter extends BaseDbAdapter {
 	/**
 	* Wraps an async operation to catch MongoDB duplicate key errors
 	* (code 11000) and rethrow as structured `DbError`.
-	*/ async _wrapDuplicateKeyError(fn) {
+	*/
+	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
-				}]);
-			}
+			if (error instanceof MongoServerError && error.code === 11e3) throw new DbError("CONFLICT", [{
+				path: error.keyPattern ? Object.keys(error.keyPattern)[0] ?? "" : "",
+				message: error.message
+			}]);
 			throw error;
 		}
 	}
@@ -1413,7 +1464,7 @@ var MongoAdapter = class MongoAdapter extends BaseDbAdapter {
 	}
 	async insertMany(data) {
 		if (this._incrementFields.size > 0) {
-			const allFields = new Set();
+			const allFields = /* @__PURE__ */ 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);
 		}
@@ -1452,10 +1503,11 @@ var MongoAdapter = class MongoAdapter extends BaseDbAdapter {
 			...this._getSessionOpts()
 		});
 	}
-	async updateOne(filter, data) {
+	async updateOne(filter, data, ops) {
 		const mongoFilter = buildMongoFilter(filter);
-		this._log("updateOne", mongoFilter, { $set: data });
-		const result = await this.collection.updateOne(mongoFilter, { $set: data }, this._getSessionOpts());
+		const updateDoc = buildMongoUpdateDoc(data, ops);
+		this._log("updateOne", mongoFilter, updateDoc);
+		const result = await this.collection.updateOne(mongoFilter, updateDoc, this._getSessionOpts());
 		return {
 			matchedCount: result.matchedCount,
 			modifiedCount: result.modifiedCount
@@ -1473,13 +1525,13 @@ var MongoAdapter = class MongoAdapter extends BaseDbAdapter {
 	async deleteOne(filter) {
 		const mongoFilter = buildMongoFilter(filter);
 		this._log("deleteOne", mongoFilter);
-		const result = await this.collection.deleteOne(mongoFilter, this._getSessionOpts());
-		return { deletedCount: result.deletedCount };
+		return { deletedCount: (await this.collection.deleteOne(mongoFilter, this._getSessionOpts())).deletedCount };
 	}
-	async updateMany(filter, data) {
+	async updateMany(filter, data, ops) {
 		const mongoFilter = buildMongoFilter(filter);
-		this._log("updateMany", mongoFilter, { $set: data });
-		const result = await this.collection.updateMany(mongoFilter, { $set: data }, this._getSessionOpts());
+		const updateDoc = buildMongoUpdateDoc(data, ops);
+		this._log("updateMany", mongoFilter, updateDoc);
+		const result = await this.collection.updateMany(mongoFilter, updateDoc, this._getSessionOpts());
 		return {
 			matchedCount: result.matchedCount,
 			modifiedCount: result.modifiedCount
@@ -1497,11 +1549,10 @@ var MongoAdapter = class MongoAdapter extends BaseDbAdapter {
 	async deleteMany(filter) {
 		const mongoFilter = buildMongoFilter(filter);
 		this._log("deleteMany", mongoFilter);
-		const result = await this.collection.deleteMany(mongoFilter, this._getSessionOpts());
-		return { deletedCount: result.deletedCount };
+		return { deletedCount: (await this.collection.deleteMany(mongoFilter, this._getSessionOpts())).deletedCount };
 	}
 	clearCollectionCache() {
-		this._collection = undefined;
+		this._collection = void 0;
 	}
 	async tableExists() {
 		return tableExistsImpl(this);
@@ -1542,29 +1593,31 @@ var MongoAdapter = class MongoAdapter extends BaseDbAdapter {
 	destructiveOptionKeys() {
 		return DESTRUCTIVE_OPTION_KEYS;
 	}
-	/** Returns the counters collection used for atomic auto-increment. */ get _countersCollection() {
+	/** 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) {
+	/** 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);
+		for (const physical of this._incrementFields.keys()) if (data[physical] === void 0 || 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) {
+	*/
+	async _allocateIncrementValues(physicalFields, count) {
 		const counters = this._countersCollection;
 		const collectionName = this._table.tableName;
-		const result = new Map();
+		const result = /* @__PURE__ */ 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 } }, {
+			const seq = (await counters.findOneAndUpdate({ _id: counterId }, { $inc: { seq: count } }, {
 				upsert: true,
 				returnDocument: "after"
-			});
-			const seq = doc?.seq ?? count;
+			}))?.seq ?? count;
 			if (seq === count) {
 				const currentMax = await this._getCurrentFieldMax(field);
 				const minStart = typeof startValue === "number" ? startValue : 1;
@@ -1580,7 +1633,8 @@ var MongoAdapter = class MongoAdapter extends BaseDbAdapter {
 		}
 		return result;
 	}
-	/** Reads current max value for a single field via $group aggregation. */ async _getCurrentFieldMax(field) {
+	/** 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,
@@ -1592,19 +1646,20 @@ var MongoAdapter = class MongoAdapter extends BaseDbAdapter {
 		}
 		return 0;
 	}
-	/** Allocates increment values for a batch of items, assigning in order. */ async _assignBatchIncrements(data, allFields) {
-		const fieldCounts = new Map();
+	/** Allocates increment values for a batch of items, assigning in order. */
+	async _assignBatchIncrements(data, allFields) {
+		const fieldCounts = /* @__PURE__ */ new Map();
 		for (const physical of allFields) {
 			let count = 0;
-			for (const item of data) if (item[physical] === undefined || item[physical] === null) count++;
+			for (const item of data) if (item[physical] === void 0 || item[physical] === null) count++;
 			if (count > 0) fieldCounts.set(physical, count);
 		}
-		const fieldCounters = new Map();
+		const fieldCounters = /* @__PURE__ */ 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) {
+		for (const item of data) for (const physical of allFields) if (item[physical] === void 0 || item[physical] === null) {
 			const next = fieldCounters.get(physical) ?? 1;
 			item[physical] = next;
 			fieldCounters.set(physical, next + 1);
@@ -1623,8 +1678,9 @@ var MongoAdapter = class MongoAdapter extends BaseDbAdapter {
 	* 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;
+	*/
+	_getCollationOpts(query) {
+		if (!this._collateFields) return;
 		const insights = query.insights ?? computeInsights(query.filter);
 		let strength;
 		for (const field of insights.keys()) {
@@ -1638,14 +1694,14 @@ var MongoAdapter = class MongoAdapter extends BaseDbAdapter {
 		return strength ? { collation: {
 			locale: "en",
 			strength
-		} } : undefined;
+		} } : void 0;
 	}
 	_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 {
+		else {
 			index = {
 				key,
 				name,
@@ -1658,16 +1714,16 @@ else {
 		if (weight) index.weights[field] = weight;
 	}
 	_setSearchIndex(type, name, definition) {
-		const key = mongoIndexKey(type, name || DEFAULT_INDEX_NAME);
+		const key = mongoIndexKey(type, name || "DEFAULT");
 		this._mongoIndexes.set(key, {
 			key,
-			name: name || DEFAULT_INDEX_NAME,
+			name: name || "DEFAULT",
 			type,
 			definition
 		});
 	}
 	_addFieldToSearchIndex(type, _name, fieldName, analyzer) {
-		const name = _name || DEFAULT_INDEX_NAME;
+		const name = _name || "DEFAULT";
 		let index = this._mongoIndexes.get(mongoIndexKey(type, name));
 		if (!index && type === "search_text") {
 			this._setSearchIndex(type, name, {
@@ -1681,23 +1737,30 @@ else {
 			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({}));
-
+* Builds a MongoDB update document from a data object that may contain
+* field ops (`{ $inc: N }`, `{ $dec: N }`, `{ $mul: N }`).
+* Regular fields go into `$set`, ops go into `$inc` / `$mul`.
+*/
+function buildMongoUpdateDoc(data, ops) {
+	const updateDoc = {};
+	let hasData = false;
+	for (const _ in data) {
+		hasData = true;
+		break;
+	}
+	if (hasData) updateDoc.$set = data;
+	if (ops?.inc) updateDoc.$inc = ops.inc;
+	if (ops?.mul) updateDoc.$mul = ops.mul;
+	return updateDoc;
+}
 //#endregion
-//#region packages/db-mongo/src/lib/index.ts
+//#region 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 };
+export { CollectionPatcher, MongoAdapter, buildMongoFilter, createAdapter, validateMongoIdPlugin };