cry-db 2.5.1 → 2.5.3

package/dist/mongo.mjs

@@ -7,13 +7,13 @@ var _a;
 // AI modified: 2026-05-09 (terminal bracket-id `arr[<id>]` z array vrednostjo → idempotent insert preko aggregation pipeline ($concatArrays + $filter); quoted bracket id `['p0']`/`["p0"]` zdaj enak unquoted `[p0]`)
 // AI modified: 2026-04-25 (GetNewerSpec.specId — disambiguate duplicate-collection specs in findNewerMany / findNewerManyStream)
 // AI modified: 2026-04-21
-import * as bcrypt from 'bcrypt';
-import { Formatter, FracturedJsonOptions } from 'fracturedjsonjs';
+import * as bcrypt from "bcrypt";
+import { Formatter, FracturedJsonOptions } from "fracturedjsonjs";
 import cloneDeep from "lodash.clonedeep";
-import { ObjectId, ReadConcern, ReadPreference, Timestamp, WriteConcern } from 'mongodb';
+import { ObjectId, ReadConcern, ReadPreference, Timestamp, WriteConcern, } from "mongodb";
 import { TypedEmitter } from "tiny-typed-emitter";
-import { Db, log } from './db.mjs';
-import { FIELD_SEQUENCES_COLLECTION, SEQUENCES_COLLECTION } from './types.mjs';
+import { Db, log } from "./db.mjs";
+import { FIELD_SEQUENCES_COLLECTION, SEQUENCES_COLLECTION, } from "./types.mjs";
 import { Base } from "./base.mjs";
 const MONGO_DEBUG_UPDATE_COLLECTIONS = (_a = process.env.MONGO_DEBUG_UPDATE_COLLECTIONS) === null || _a === void 0 ? void 0 : _a.match(/yes|true|da|1/i);
 const assert = (cond, msg, calledFrom, payload) => {
@@ -29,20 +29,20 @@ const assert = (cond, msg, calledFrom, payload) => {
                 parts.push(String(payload));
             }
         }
-        const fullMsg = parts.join(' | ');
+        const fullMsg = parts.join(" | ");
         const err = new Error(fullMsg);
         console.error("assert failed:", fullMsg, "\n" + err.stack);
         throw err;
     }
 };
 const saltRounds = 10;
-const HASHED_PREFIX = '__hashed__';
-const parseFieldList = (fields) => (typeof fields === 'string' ? fields.split(',') : fields)
-    .map(f => f.trim())
-    .filter(f => f.length > 0);
+const HASHED_PREFIX = "__hashed__";
+const parseFieldList = (fields) => (typeof fields === "string" ? fields.split(",") : fields)
+    .map((f) => f.trim())
+    .filter((f) => f.length > 0);
 // String helper functions (faster than RegExp)
-const startsWithDollar = (s) => s.length > 0 && s[0] === '$';
-const startsWithDoubleUnderscore = (s) => s.length > 1 && s[0] === '_' && s[1] === '_';
+const startsWithDollar = (s) => s.length > 0 && s[0] === "$";
+const startsWithDoubleUnderscore = (s) => s.length > 1 && s[0] === "_" && s[1] === "_";
 const isServerReserved = (s) => s === "_rev" || s === "_ts";
 const startsWithHashedPrefix = (s) => s.length > 10 && s.startsWith(HASHED_PREFIX);
 const isHex24 = (s) => {
@@ -60,8 +60,8 @@ const TRANSACTION_OPTIONS = {
     defaultTransactionOptions: {
         readPreference: new ReadPreference("primary"),
         readConcern: new ReadConcern("local"),
-        writeConcern: new WriteConcern("majority")
-    }
+        writeConcern: new WriteConcern("majority"),
+    },
 };
 // FracturedJson formatter for readable object logging
 const fjOptions = new FracturedJsonOptions();
@@ -76,7 +76,9 @@ export const fj = (value) => {
     if (Array.isArray(value)) {
         return value.map(fj);
     }
-    if (value && typeof value === 'object' && Object.getPrototypeOf(value) === Object.prototype) {
+    if (value &&
+        typeof value === "object" &&
+        Object.getPrototypeOf(value) === Object.prototype) {
         return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, fj(v)]));
     }
     return value;
@@ -86,26 +88,28 @@ export const fj = (value) => {
 // `key: undefined` entries (which cry-db routes to `$unset` / `$pull`) are
 // invisible in the log, making bug diagnosis impossible. Walk the structure
 // and replace `undefined` with a readable sentinel.
-const UNDEFINED_MARKER = '<undefined>';
+const UNDEFINED_MARKER = "<undefined>";
 const markUndefined = (value) => {
     if (value === undefined)
         return UNDEFINED_MARKER;
     if (Array.isArray(value))
         return value.map(markUndefined);
-    if (value && typeof value === 'object' && Object.getPrototypeOf(value) === Object.prototype) {
+    if (value &&
+        typeof value === "object" &&
+        Object.getPrototypeOf(value) === Object.prototype) {
         return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, markUndefined(v)]));
     }
     return value;
 };
 // Wrap log methods to auto-format objects with fracturedjson
-const fjArgs = (args) => args.map(a => {
+const fjArgs = (args) => args.map((a) => {
     var _a;
     if (a === undefined)
         return UNDEFINED_MARKER;
-    if (typeof a !== 'object' || a === null)
+    if (typeof a !== "object" || a === null)
         return a;
     const replaced = markUndefined(fj(a));
-    if (typeof replaced !== 'object' || replaced === null)
+    if (typeof replaced !== "object" || replaced === null)
         return replaced;
     try {
         return (_a = fjFormatter.Serialize(replaced)) !== null && _a !== void 0 ? _a : JSON.stringify(replaced);
@@ -115,11 +119,21 @@ const fjArgs = (args) => args.map(a => {
     }
 });
 const fjLog = {
-    debug: (...args) => { log.debug(...fjArgs(args)); },
-    trace: (...args) => { log.trace(...fjArgs(args)); },
-    info: (...args) => { log.info(...fjArgs(args)); },
-    warn: (...args) => { log.warn(...fjArgs(args)); },
-    error: (...args) => { log.error(...fjArgs(args)); },
+    debug: (...args) => {
+        log.debug(...fjArgs(args));
+    },
+    trace: (...args) => {
+        log.trace(...fjArgs(args));
+    },
+    info: (...args) => {
+        log.info(...fjArgs(args));
+    },
+    warn: (...args) => {
+        log.warn(...fjArgs(args));
+    },
+    error: (...args) => {
+        log.error(...fjArgs(args));
+    },
 };
 // export const DummyExportToFixTsCompilation = true;
 export class Mongo extends Db {
@@ -136,13 +150,13 @@ export class Mongo extends Db {
         this.auditCollectionName = "dblog";
         this.auditedCollectionsLower = [];
         this.auditedCollections = this.auditCollections(process.env.AUDIT_COLLECTIONS || []);
-        this._findNewerRemoveFields = new Set(parseFieldList(process.env.REMOVE_FIELDS_FOR_FINDNEWER || ''));
-        this._removeFieldsAlways = new Set(parseFieldList(process.env.REMOVE_FIELDS_ALWAYS || ''));
+        this._findNewerRemoveFields = new Set(parseFieldList(process.env.REMOVE_FIELDS_FOR_FINDNEWER || ""));
+        this._removeFieldsAlways = new Set(parseFieldList(process.env.REMOVE_FIELDS_ALWAYS || ""));
         this.emitter = new TypedEmitter();
         this.user = undefined;
         this.audit = undefined;
         this._sequencesIndexEnsured = false;
-        fjLog.debug('new Mongo:', this.url, this.db);
+        fjLog.debug("new Mongo:", this.url, this.db);
     }
     on(evt, listener) {
         fjLog.debug("on", evt, listener);
@@ -157,19 +171,19 @@ export class Mongo extends Db {
         this.emitter.once(evt, listener);
     }
     setUser(username) {
-        return this.user = username;
+        return (this.user = username);
     }
     setAudit(obj) {
-        return this.audit = obj;
+        return (this.audit = obj);
     }
     useRevisions(enabled) {
-        return this.revisions = !!enabled;
+        return (this.revisions = !!enabled);
     }
     usesRevisions() {
         return this.revisions;
     }
     useSoftDelete(enabled) {
-        return this.softdelete = !!enabled;
+        return (this.softdelete = !!enabled);
     }
     usesSoftDelete() {
         return this.softdelete;
@@ -180,26 +194,26 @@ export class Mongo extends Db {
      * unless `returnArchived: true` is passed in opts.
      */
     useArchive(enabled) {
-        return this.softarchive = !!enabled;
+        return (this.softarchive = !!enabled);
     }
     usesArchive() {
         return this.softarchive;
     }
     useAuditing(enabled) {
-        return this.auditing = enabled;
+        return (this.auditing = enabled);
     }
     usesAuditing() {
         return this.auditing;
     }
     useSync(enabled) {
-        return this.syncSupport = enabled;
+        return (this.syncSupport = enabled);
     }
     usesSync() {
         return this.syncSupport;
     }
     auditToCollection(c) {
         if (c)
-            return this.auditCollectionName = c;
+            return (this.auditCollectionName = c);
         return this.auditCollectionName;
     }
     auditCollection(coll, enable = true) {
@@ -239,17 +253,23 @@ export class Mongo extends Db {
         if (arr === undefined)
             return this.auditedCollections;
         if (arr && typeof arr === "string")
-            this.auditedCollections = arr.toString().split(',').map(a => a.trim().toLowerCase()).filter(a => !!a);
+            this.auditedCollections = arr
+                .toString()
+                .split(",")
+                .map((a) => a.trim().toLowerCase())
+                .filter((a) => !!a);
         if (arr instanceof Array)
-            this.auditedCollections = arr.map(a => a.trim().toLowerCase()).filter(a => !!a);
-        this.auditedCollectionsLower = this.auditedCollections.map(a => a.toLowerCase());
+            this.auditedCollections = arr
+                .map((a) => a.trim().toLowerCase())
+                .filter((a) => !!a);
+        this.auditedCollectionsLower = this.auditedCollections.map((a) => a.toLowerCase());
         return this.auditedCollections;
     }
     auditingCollection(coll, db = this.db) {
         return this._shouldAuditCollection(db, coll);
     }
     emitPublishEvents(enabled) {
-        return this.emittingPublishEvents = enabled;
+        return (this.emittingPublishEvents = enabled);
     }
     emitsPublishEvents() {
         return this.emittingPublishEvents;
@@ -261,7 +281,7 @@ export class Mongo extends Db {
         }
         if (enabled)
             fjLog.debug("publishing rev events");
-        return this.emittingPublishRevEvents = enabled;
+        return (this.emittingPublishRevEvents = enabled);
     }
     emitsPublishRevEvents() {
         return this.emittingPublishRevEvents;
@@ -273,13 +293,13 @@ export class Mongo extends Db {
     async distinct(collection, field, opts = {}) {
         assert(collection, "collection is required", "distinct");
         assert(field, "field is required", "distinct", { collection });
-        fjLog.debug('distinct called', collection, field);
+        fjLog.debug("distinct called", collection, field);
         const dbName = this.db;
         let client = await this.connect();
         let conn = client.db(dbName).collection(collection);
         let ret = await conn.distinct(field, {}, opts);
         ret.sort();
-        fjLog.debug('distinct returns', ret);
+        fjLog.debug("distinct returns", ret);
         return ret;
     }
     async count(collection, query = {}, opts = {}) {
@@ -292,11 +312,11 @@ export class Mongo extends Db {
             if (!query._archived)
                 query._archived = { $exists: false };
         }
-        fjLog.debug('count called', collection, query, opts);
+        fjLog.debug("count called", collection, query, opts);
         let ret = await this.executeTransactionally(collection, async (conn) => {
             return await conn.countDocuments(query, opts);
         }, false, { operation: "count", collection, query, opts });
-        fjLog.debug('count returns', ret);
+        fjLog.debug("count returns", ret);
         return ret;
     }
     async find(collection, query = {}, opts = {}) {
@@ -310,12 +330,12 @@ export class Mongo extends Db {
             if (!query._archived)
                 query._archived = { $exists: false };
         }
-        fjLog.debug('find called', collection, query, opts);
+        fjLog.debug("find called", collection, query, opts);
         let ret = await this.executeTransactionally(collection, async (conn) => {
             let r = this._applyQueryOpts(conn.find(query, this._buildFindOptions(opts)), opts);
             return this._processReturnedObject(await r.toArray());
         }, false, { operation: "find", collection, query, opts });
-        fjLog.debug('find returns', ret);
+        fjLog.debug("find returns", ret);
         return ret;
     }
     async findAll(collection, query = {}, opts = {}) {
@@ -325,7 +345,7 @@ export class Mongo extends Db {
             let r = this._applyQueryOpts(conn.find(query, this._buildFindOptions(opts)), opts);
             return this._processReturnedObject(await r.toArray());
         }, false, { operation: "findAll", collection, query, opts });
-        fjLog.debug('findAll returns', ret);
+        fjLog.debug("findAll returns", ret);
         return ret;
     }
     async findNewer(collection, timestamp, query = {}, opts = {}) {
@@ -338,12 +358,12 @@ export class Mongo extends Db {
             if (!query._archived)
                 query._archived = { $exists: false };
         }
-        fjLog.debug('findNewer called', collection, timestamp, query, opts);
+        fjLog.debug("findNewer called", collection, timestamp, query, opts);
         let ret = await this.executeTransactionally(collection, async (conn) => {
             let r = this._applyQueryOpts(conn.find(query, this._buildFindOptions(opts)).sort({ _ts: 1 }), opts);
             return this._processReturnedObject(await r.toArray(), this._findNewerRemoveFields);
         }, false, { operation: "findNewer", collection, timestamp, query, opts });
-        fjLog.debug('findNewer returns', ret);
+        fjLog.debug("findNewer returns", ret);
         return ret;
     }
     /**
@@ -357,7 +377,7 @@ export class Mongo extends Db {
      */
     async findNewerMany(spec = [], defaultOpts = {}) {
         var _a;
-        fjLog.debug('findNewerMany called', spec);
+        fjLog.debug("findNewerMany called", spec);
         const dbName = this.db; // Capture db at operation start
         let conn = await this.connect();
         const getOneColl = async (coll) => {
@@ -375,7 +395,11 @@ export class Mongo extends Db {
             if (process.env.MONGO_DEBUG_FINDNEWERMANY) {
                 fjLog.debug("findNewerMany <-", coll.collection, coll.specId, coll.timestamp, coll.query, " -> ", JSON.stringify(query));
             }
-            let r = this._applyQueryOpts(conn.db(dbName).collection(coll.collection).find(query, {}).sort({ _ts: 1 }), opts);
+            let r = this._applyQueryOpts(conn
+                .db(dbName)
+                .collection(coll.collection)
+                .find(query, {})
+                .sort({ _ts: 1 }), opts);
             let data = await r.toArray();
             if (process.env.MONGO_DEBUG_FINDNEWERMANY) {
                 fjLog.debug("findNewerMany ->", coll.collection, JSON.stringify(data, null, 2));
@@ -397,7 +421,9 @@ export class Mongo extends Db {
             for (let coll of spec)
                 promises.push(getOneColl(coll));
             let out = {};
-            (await Promise.all(promises)).filter(r => r.data.length).forEach(r => out[r.key] = r.data);
+            (await Promise.all(promises))
+                .filter((r) => r.data.length)
+                .forEach((r) => (out[r.key] = r.data));
             return out;
         }
     }
@@ -417,7 +443,7 @@ export class Mongo extends Db {
      * @param defaultOpts - Default query options applied to all collections
      */
     async findNewerManyStream(spec = [], onChunk, chunkSize = 200, defaultOpts = {}) {
-        fjLog.debug('findNewerManyStream called', spec);
+        fjLog.debug("findNewerManyStream called", spec);
         const dbName = this.db;
         let conn = await this.connect();
         for (const coll of spec) {
@@ -431,7 +457,11 @@ export class Mongo extends Db {
                 if (!query._archived)
                     query._archived = { $exists: false };
             }
-            let cursor = this._applyQueryOpts(conn.db(dbName).collection(coll.collection).find(query, {}).sort({ _ts: 1 }), opts);
+            let cursor = this._applyQueryOpts(conn
+                .db(dbName)
+                .collection(coll.collection)
+                .find(query, {})
+                .sort({ _ts: 1 }), opts);
             let chunk = [];
             for await (const doc of cursor) {
                 this._processReturnedObject(doc, this._findNewerRemoveFields);
@@ -449,7 +479,7 @@ export class Mongo extends Db {
     async latestTimestamps(collections) {
         assert(collections, "collections is required", "latestTimestamps");
         assert(collections instanceof Array, "collections must be an Array", "latestTimestamps");
-        fjLog.debug('latestTimestamps called', collections);
+        fjLog.debug("latestTimestamps called", collections);
         const dbName = this.db; // Capture db at operation start
         let conn = await this.connect();
         const getOne = async (collection) => {
@@ -469,15 +499,17 @@ export class Mongo extends Db {
         for (let c of collections)
             promises.push(getOne(c));
         let out = {};
-        (await Promise.all(promises)).forEach(r => { if (r.ts)
-            out[r.collection] = r.ts; });
-        fjLog.debug('latestTimestamps returns', out);
+        (await Promise.all(promises)).forEach((r) => {
+            if (r.ts)
+                out[r.collection] = r.ts;
+        });
+        fjLog.debug("latestTimestamps returns", out);
         return out;
     }
     async latestTimestamp(collection) {
         var _a;
         assert(collection, "collection is required", "latestTimestamp");
-        fjLog.debug('latestTimestamp called', collection);
+        fjLog.debug("latestTimestamp called", collection);
         const dbName = this.db; // Capture db at operation start
         let conn = await this.connect();
         let cursor = conn
@@ -489,11 +521,11 @@ export class Mongo extends Db {
             .limit(1);
         let res = await cursor.toArray();
         let ts = (_a = res === null || res === void 0 ? void 0 : res[0]) === null || _a === void 0 ? void 0 : _a._ts;
-        fjLog.debug('latestTimestamp returns', ts);
+        fjLog.debug("latestTimestamp returns", ts);
         return ts;
     }
     _createQueryForNewer(timestamp, query) {
-        let ts = (timestamp === 1 || timestamp === "1" || timestamp === "0" || !timestamp)
+        let ts = timestamp === 1 || timestamp === "1" || timestamp === "0" || !timestamp
             ? {}
             : { _ts: { $gt: Base.timestamp(timestamp) } };
         if (query) {
@@ -572,9 +604,12 @@ export class Mongo extends Db {
                 query._archived = { $exists: false };
         }
         // if (!query._blocked) query._blocked = { $exists: false };   // intentionally - blocked records are returned
-        fjLog.debug('findOne called', collection, query, projection);
-        let ret = await this.executeTransactionally(collection, async (conn) => await conn.findOne(query, { ...(projection ? { projection } : {}), ...this._sessionOpt() }), false, { operation: "findOne", collection, query, projection });
-        fjLog.debug('findOne returns', ret);
+        fjLog.debug("findOne called", collection, query, projection);
+        let ret = await this.executeTransactionally(collection, async (conn) => await conn.findOne(query, {
+            ...(projection ? { projection } : {}),
+            ...this._sessionOpt(),
+        }), false, { operation: "findOne", collection, query, projection });
+        fjLog.debug("findOne returns", ret);
         return this._processReturnedObject(ret);
     }
     async findById(collection, id, projection, opts = {}) {
@@ -592,27 +627,30 @@ export class Mongo extends Db {
         if (this.softarchive && !opts.returnArchived) {
             query._archived = { $exists: false };
         }
-        fjLog.debug('findById called', dbName, collection, id, projection);
-        fjLog.trace('findById executing with query', collection, query, projection);
+        fjLog.debug("findById called", dbName, collection, id, projection);
+        fjLog.trace("findById executing with query", collection, query, projection);
         let ret = await this.executeTransactionally(collection, async (conn) => {
-            let r = await conn.findOne(query, { ...(projection ? { projection } : {}), ...this._sessionOpt() });
+            let r = await conn.findOne(query, {
+                ...(projection ? { projection } : {}),
+                ...this._sessionOpt(),
+            });
             return r;
         }, false, { operation: "findById", collection, id, projection });
-        fjLog.debug('findById returns', ret);
+        fjLog.debug("findById returns", ret);
         return this._processReturnedObject(ret);
     }
     async findByIdsInManyCollections(request, opts = {}) {
         if (!request || request.length === 0)
             return {};
         const dbName = this.db;
-        fjLog.debug('findByIdsInManyCollections called', dbName, request);
+        fjLog.debug("findByIdsInManyCollections called", dbName, request);
         // Process all collections in parallel
         const fetchOne = async (req) => {
             const { collection, ids, projection } = req;
             if (!collection || !ids || ids.length === 0) {
                 return { collection, entities: [] };
             }
-            const objectIds = ids.map(id => Mongo._toId(id));
+            const objectIds = ids.map((id) => Mongo._toId(id));
             const entities = await this.executeTransactionally(collection, async (conn) => {
                 let query = { _id: { $in: objectIds } };
                 if (this.softdelete && !opts.returnDeleted) {
@@ -621,17 +659,28 @@ export class Mongo extends Db {
                 if (this.softarchive && !opts.returnArchived) {
                     query._archived = { $exists: false };
                 }
-                let r = conn.find(query, { ...(projection ? { projection } : {}), ...this._sessionOpt() });
+                let r = conn.find(query, {
+                    ...(projection ? { projection } : {}),
+                    ...this._sessionOpt(),
+                });
                 return await r.toArray();
-            }, false, { operation: "findByIdsInManyCollections", collection, ids, projection });
-            return { collection, entities: this._processReturnedObject(entities) };
+            }, false, {
+                operation: "findByIdsInManyCollections",
+                collection,
+                ids,
+                projection,
+            });
+            return {
+                collection,
+                entities: this._processReturnedObject(entities),
+            };
         };
         const results = await Promise.all(request.map(fetchOne));
         const result = {};
         for (const { collection, entities } of results) {
             result[collection] = entities;
         }
-        fjLog.debug('findByIdsInManyCollections returns', result);
+        fjLog.debug("findByIdsInManyCollections returns", result);
         return result;
     }
     async findByIds(collection, ids, projection, opts = {}) {
@@ -640,8 +689,8 @@ export class Mongo extends Db {
         if (!ids || ids.length === 0)
             return [];
         const dbName = this.db;
-        const objectIds = ids.map(id => Mongo._toId(id));
-        fjLog.debug('findByIds called', dbName, collection, ids, projection);
+        const objectIds = ids.map((id) => Mongo._toId(id));
+        fjLog.debug("findByIds called", dbName, collection, ids, projection);
         let ret = await this.executeTransactionally(collection, async (conn) => {
             let query = { _id: { $in: objectIds } };
             if (this.softdelete && !opts.returnDeleted) {
@@ -650,10 +699,13 @@ export class Mongo extends Db {
             if (this.softarchive && !opts.returnArchived) {
                 query._archived = { $exists: false };
             }
-            let r = conn.find(query, { ...(projection ? { projection } : {}), ...this._sessionOpt() });
+            let r = conn.find(query, {
+                ...(projection ? { projection } : {}),
+                ...this._sessionOpt(),
+            });
             return await r.toArray();
         }, false, { operation: "findByIds", collection, ids, projection });
-        fjLog.debug('findByIds returns', ret);
+        fjLog.debug("findByIds returns", ret);
         return this._processReturnedObject(ret);
     }
     async updateOne(collection, query, update, options = { returnFullObject: false }) {
@@ -666,7 +718,7 @@ export class Mongo extends Db {
         let opts = {
             upsert: false,
             returnDocument: "after",
-            ...this._sessionOpt()
+            ...this._sessionOpt(),
         };
         if (this._hasHashedKeys(update))
             await this._processHashedKeys(update);
@@ -682,24 +734,33 @@ export class Mongo extends Db {
         const isPipeline = Array.isArray(processed.update);
         // For pipeline form, sequence-keys auto-injection cannot recurse into array of stages.
         // Skip the `update.$set` normalization and seqKeys path entirely when pipeline.
-        let seqKeys = isPipeline ? undefined : this._findSequenceKeys(update.$set);
-        fjLog.debug('updateOne called', collection, query, update);
+        let seqKeys = isPipeline
+            ? undefined
+            : this._findSequenceKeys(update.$set);
+        fjLog.debug("updateOne called", collection, query, update);
         let obj = await this.executeTransactionally(collection, async (conn, client) => {
             if (!isPipeline) {
                 update.$set = update.$set || {};
                 if (seqKeys)
                     await this._processSequenceField(client, dbName, collection, update.$set, seqKeys);
-                if (update.$set === undefined || Object.keys(update.$set).length === 0)
+                if (update.$set === undefined ||
+                    Object.keys(update.$set).length === 0)
                     delete update.$set;
             }
             let res = await conn.findOneAndUpdate(query, processed.update, opts);
             if (!res)
                 return null;
             let resObj = this._buildPublishDelta(res, inputUpdate, !!(options === null || options === void 0 ? void 0 : options.returnFullObject));
-            await this._publishAndAudit('update', dbName, collection, resObj, false, inputUpdate);
+            await this._publishAndAudit("update", dbName, collection, resObj, false, inputUpdate);
             return resObj;
-        }, !!seqKeys, { operation: "updateOne", collection, query, update: processed.update, options });
-        fjLog.debug('updateOne returns', obj);
+        }, !!seqKeys, {
+            operation: "updateOne",
+            collection,
+            query,
+            update: processed.update,
+            options,
+        });
+        fjLog.debug("updateOne returns", obj);
         return this._processReturnedObject(await obj);
     }
     async save(collection, update, id = undefined, options = { returnFullObject: false }) {
@@ -710,7 +771,7 @@ export class Mongo extends Db {
         let opts = {
             upsert: true,
             returnDocument: "after",
-            ...this._sessionOpt()
+            ...this._sessionOpt(),
         };
         let _id = Mongo.toId(id || update._id) || Mongo.newid();
         if (this._hasHashedKeys(update))
@@ -721,24 +782,25 @@ export class Mongo extends Db {
         if (processed.arrayFilters)
             opts.arrayFilters = processed.arrayFilters;
         const isPipeline = Array.isArray(processed.update);
-        fjLog.debug('save called', collection, id, update);
+        fjLog.debug("save called", collection, id, update);
         let seqKeys = isPipeline ? undefined : this._findSequenceKeys(update.$set);
         let obj = await this.executeTransactionally(collection, async (conn, client) => {
             if (!isPipeline) {
                 update.$set = update.$set || {};
                 if (seqKeys)
                     await this._processSequenceField(client, dbName, collection, update.$set, seqKeys);
-                if (update.$set === undefined || Object.keys(update.$set).length === 0)
+                if (update.$set === undefined ||
+                    Object.keys(update.$set).length === 0)
                     delete update.$set;
             }
             let res = await conn.findOneAndUpdate({ _id }, processed.update, opts);
             if (!res)
                 return null;
             let resObj = this._buildPublishDelta(res, inputUpdate, !!(options === null || options === void 0 ? void 0 : options.returnFullObject));
-            await this._publishAndAudit('update', dbName, collection, resObj, false, inputUpdate);
+            await this._publishAndAudit("update", dbName, collection, resObj, false, inputUpdate);
             return resObj;
         }, !!seqKeys, { operation: "save", collection, _id, update: processed.update, options });
-        fjLog.debug('save returns', obj);
+        fjLog.debug("save returns", obj);
         return this._processReturnedObject(await obj);
     }
     async update(collection, query, update) {
@@ -754,7 +816,7 @@ export class Mongo extends Db {
         let opts = {
             upsert: false,
             returnDocument: "after",
-            ...this._sessionOpt()
+            ...this._sessionOpt(),
         };
         if (this._hasHashedKeys(update))
             await this._processHashedKeys(update);
@@ -763,36 +825,39 @@ export class Mongo extends Db {
         if (processed.arrayFilters)
             opts.arrayFilters = processed.arrayFilters;
         const isPipeline = Array.isArray(processed.update);
-        fjLog.debug('update called', collection, query, update);
+        fjLog.debug("update called", collection, query, update);
         let seqKeys = isPipeline ? undefined : this._findSequenceKeys(update.$set);
         let obj = await this.executeTransactionally(collection, async (conn, client) => {
             if (!isPipeline) {
                 update.$set = update.$set || {};
                 if (seqKeys)
                     await this._processSequenceField(client, dbName, collection, update.$set, seqKeys);
-                if (update.$set === undefined || Object.keys(update.$set).length === 0)
+                if (update.$set === undefined ||
+                    Object.keys(update.$set).length === 0)
                     delete update.$set;
             }
-            fjLog.debug('update called', collection, query, update);
+            fjLog.debug("update called", collection, query, update);
             let res = await conn.updateMany(query, processed.update, opts);
             let resObj = {
                 n: res.modifiedCount,
-                ok: !!res.acknowledged
+                ok: !!res.acknowledged,
             };
             // No `rawUpdate` for `updateMany` — mongo doesn't return per-doc _id-s,
             // so the spec is not actionable on the consumer side. Subscribers see
             // `enquireLastTs: true` on the rev event and refetch via `findNewer*`.
-            await this._publishAndAudit('updateMany', dbName, collection, resObj);
+            await this._publishAndAudit("updateMany", dbName, collection, resObj);
             return resObj;
         }, !!seqKeys, { operation: "update", collection, query, update: processed.update });
-        fjLog.debug('update returns', obj);
+        fjLog.debug("update returns", obj);
         return await obj;
     }
     async upsert(collection, query, update, options = { returnFullObject: false }) {
         assert(collection, "collection is required", "upsert");
         assert(query, "query is required", "upsert", { collection });
         assert(update, "update is required", "upsert", { collection });
-        assert(typeof update === 'object', "update must be an object", "upsert", { collection });
+        assert(typeof update === "object", "update must be an object", "upsert", {
+            collection,
+        });
         // if (!Object.keys(update).length) return null;
         const dbName = this.db; // Capture db at operation start
         query = this.replaceIds(query);
@@ -801,9 +866,9 @@ export class Mongo extends Db {
             ...options,
             upsert: true,
             returnDocument: "after",
-            ...this._sessionOpt()
+            ...this._sessionOpt(),
         };
-        fjLog.debug('upsert called', collection, query, update);
+        fjLog.debug("upsert called", collection, query, update);
         if (this._hasHashedKeys(update))
             await this._processHashedKeys(update);
         const inputUpdate = cloneDeep(update);
@@ -813,7 +878,7 @@ export class Mongo extends Db {
             opts.arrayFilters = processed.arrayFilters;
         const isPipeline = Array.isArray(processed.update);
         let seqKeys = isPipeline ? undefined : this._findSequenceKeys(update.$set);
-        fjLog.debug('upsert processed', collection, query, update);
+        fjLog.debug("upsert processed", collection, query, update);
         if (Object.keys(query).length === 0)
             query._id = Mongo.newid();
         let ret = await this.executeTransactionally(collection, async (conn, client) => {
@@ -821,7 +886,8 @@ export class Mongo extends Db {
                 update.$set = update.$set || {};
                 if (seqKeys)
                     await this._processSequenceField(client, dbName, collection, update.$set, seqKeys);
-                if (update.$set === undefined || Object.keys(update.$set).length === 0)
+                if (update.$set === undefined ||
+                    Object.keys(update.$set).length === 0)
                     delete update.$set;
             }
             let ret = await conn.findOneAndUpdate(query, processed.update, opts);
@@ -832,21 +898,24 @@ export class Mongo extends Db {
                 // For inserts, surface the full record (query fields like {a:4} need to land);
                 // for updates, build the de-bracketed delta. rawUpdate is sent on update only —
                 // an insert isn't a delta against a prior state, so the spec adds no signal there.
-                let retObj = isInsert ? ret : this._buildPublishDelta(ret, inputUpdate, !!(options === null || options === void 0 ? void 0 : options.returnFullObject));
+                let retObj = isInsert
+                    ? ret
+                    : this._buildPublishDelta(ret, inputUpdate, !!(options === null || options === void 0 ? void 0 : options.returnFullObject));
                 await this._publishAndAudit(oper, dbName, collection, retObj, false, isInsert ? undefined : inputUpdate);
                 return this._buildPublishDelta(ret, inputUpdate, !!(options === null || options === void 0 ? void 0 : options.returnFullObject));
             }
-            ;
             return ret;
         }, !!seqKeys, { operation: "upsert", query, update, options });
-        fjLog.debug('upsert returns', ret);
+        fjLog.debug("upsert returns", ret);
         return this._processReturnedObject(await ret);
     }
     async insert(collection, insert) {
         assert(collection, "collection is required", "insert");
         assert(insert, "insert is required", "insert", { collection });
-        assert(typeof insert === "object", "insert must be an object", "insert", { collection });
-        fjLog.debug('insert called', collection, insert);
+        assert(typeof insert === "object", "insert must be an object", "insert", {
+            collection,
+        });
+        fjLog.debug("insert called", collection, insert);
         const dbName = this.db; // Capture db at operation start
         insert = this.replaceIds(insert);
         this._stripDoubleUnderscoreKeys(insert);
@@ -861,10 +930,10 @@ export class Mongo extends Db {
                 insert = await this._processSequenceField(client, dbName, collection, insert, seqKeys);
             let obj = await conn.insertOne(insert, this._sessionOpt());
             let fullObj = { _id: obj.insertedId, ...insert };
-            await this._publishAndAudit('insert', dbName, collection, fullObj);
+            await this._publishAndAudit("insert", dbName, collection, fullObj);
             return fullObj;
         }, !!seqKeys, { operation: "insert", collection, insert });
-        fjLog.debug('insert returns', ret);
+        fjLog.debug("insert returns", ret);
         return this._processReturnedObject(await ret);
     }
     /**
@@ -880,7 +949,7 @@ export class Mongo extends Db {
         assert(collectionsBatches, "collectionsBatches is required", "updateCollections");
         assert(collectionsBatches instanceof Array, "collectionsBatches must be an Array", "updateCollections");
         const debugMethod = MONGO_DEBUG_UPDATE_COLLECTIONS ? "info" : "debug";
-        (_a = fjLog === null || fjLog === void 0 ? void 0 : fjLog[debugMethod]) === null || _a === void 0 ? void 0 : _a.call(fjLog, 'updateCollections called', collectionsBatches.length, 'collections');
+        (_a = fjLog === null || fjLog === void 0 ? void 0 : fjLog[debugMethod]) === null || _a === void 0 ? void 0 : _a.call(fjLog, "updateCollections called", collectionsBatches.length, "collections");
         (_b = fjLog === null || fjLog === void 0 ? void 0 : fjLog[debugMethod]) === null || _b === void 0 ? void 0 : _b.call(fjLog, collectionsBatches);
         const dbName = this.db;
         const conn = await this.connect();
@@ -898,7 +967,7 @@ export class Mongo extends Db {
                         updated: [],
                         deleted: [],
                         mustRefresh: [],
-                    }
+                    },
                 };
                 const batchData = [];
                 const errors = [];
@@ -907,18 +976,19 @@ export class Mongo extends Db {
                 // server-side (SEQ_*/__hashed__)? Captured BEFORE the bulk sequence
                 // resolution and per-update hashing mutate the updates in place, so
                 // the placeholders are still observable here.
-                const updateResolvedFlags = (updates !== null && updates !== void 0 ? updates : []).map(u => this._hasSequenceFields(u.update) || this._hasHashedKeys(u.update));
+                const updateResolvedFlags = (updates !== null && updates !== void 0 ? updates : []).map((u) => this._hasSequenceFields(u.update) || this._hasHashedKeys(u.update));
                 // Handle sequences in updates before processing
                 if (updates === null || updates === void 0 ? void 0 : updates.length) {
-                    const updatesWithSeq = updates.filter(u => this._hasSequenceFields(u.update));
+                    const updatesWithSeq = updates.filter((u) => this._hasSequenceFields(u.update));
                     if (updatesWithSeq.length > 0) {
-                        await this._processSequenceFieldForMany(conn, dbName, collection, updatesWithSeq.map(u => u.update));
+                        await this._processSequenceFieldForMany(conn, dbName, collection, updatesWithSeq.map((u) => u.update));
                     }
                 }
                 // Process updates (with upsert) in parallel
                 if (updates === null || updates === void 0 ? void 0 : updates.length) {
                     const updatePromises = updates.map(async ({ _id, _rev: clientRev, update }, idx) => {
                         var _a, _b;
+                        let processedUpdateForDiagnostics;
                         try {
                             const objectId = Mongo._toId(_id);
                             update = this.replaceIds(update);
@@ -927,9 +997,10 @@ export class Mongo extends Db {
                             const inputUpdate = cloneDeep(update);
                             const processedBase = this._processUpdateObject({ ...update });
                             const processed = this._applyBracketProcessing(processedBase);
+                            processedUpdateForDiagnostics = processed.update;
                             if (processed.warnings) {
                                 for (const w of processed.warnings) {
-                                    const msg = w.kind === 'overlap'
+                                    const msg = w.kind === "overlap"
                                         ? `same-id overlap at "${w.path}" — terminal-bracket value ${JSON.stringify(w.value)} sets the element base; sub-field overlay applies on top`
                                         : `dropped nested-bracket ${w.op} path "${w.path}" = ${JSON.stringify(w.value)}`;
                                     warnings.push({ _id: String(_id), error: msg });
@@ -939,10 +1010,13 @@ export class Mongo extends Db {
                                 upsert: true,
                                 returnDocument: "after",
                                 includeResultMetadata: true,
-                                ...(processed.arrayFilters ? { arrayFilters: processed.arrayFilters } : {}),
-                                ...this._sessionOpt()
+                                ...(processed.arrayFilters
+                                    ? { arrayFilters: processed.arrayFilters }
+                                    : {}),
+                                ...this._sessionOpt(),
                             };
                             (_a = fjLog === null || fjLog === void 0 ? void 0 : fjLog[debugMethod]) === null || _a === void 0 ? void 0 : _a.call(fjLog, `  updateCollections findOneAndUpdate ${dbName}.${collection}`, { _id: objectId }, "UPDATE", processed.update, "opts", opts);
+                            console.error(`[Mongo] updateCollections findOneAndUpdate payload collection=${collection} _id=${String(_id)} clientRev=${clientRev}`, { collection, _id: String(_id), clientRev, filter: { _id: objectId }, update: processed.update });
                             const res = await conn
                                 .db(dbName)
                                 .collection(collection)
@@ -950,7 +1024,9 @@ export class Mongo extends Db {
                             if (res === null || res === void 0 ? void 0 : res.value) {
                                 // Determine if this was an insert or update based on lastErrorObject
                                 const wasInsert = !((_b = res.lastErrorObject) === null || _b === void 0 ? void 0 : _b.updatedExisting);
-                                const operation = wasInsert ? 'insert' : 'update';
+                                const operation = wasInsert
+                                    ? "insert"
+                                    : "update";
                                 // mustRefresh: the client must replace its local copy when cry-db
                                 // resolved a field (SEQ_*/__hashed__) OR a concurrent external write
                                 // advanced the stored `_rev` beyond this write (gap > the +1 this write
@@ -958,10 +1034,10 @@ export class Mongo extends Db {
                                 // old-client fallback. Built from a sanitized clone (hash never leaks).
                                 const writtenRev = res.value._rev;
                                 const inc = this.revisions ? 1 : 0;
-                                const externallyModified = !wasInsert
-                                    && typeof writtenRev === 'number'
-                                    && (writtenRev - inc) > (clientRev !== null && clientRev !== void 0 ? clientRev : 0);
-                                const mustRefresh = (updateResolvedFlags[idx] || externallyModified)
+                                const externallyModified = !wasInsert &&
+                                    typeof writtenRev === "number" &&
+                                    writtenRev - inc > (clientRev !== null && clientRev !== void 0 ? clientRev : 0);
+                                const mustRefresh = updateResolvedFlags[idx] || externallyModified
                                     ? this._buildMustRefreshRecord(res.value)
                                     : undefined;
                                 // Inserts surface the full doc (query fields must reach the client).
@@ -972,12 +1048,25 @@ export class Mongo extends Db {
                                     ? res.value
                                     : this._buildPublishDelta(res.value, inputUpdate, false);
                                 this._processReturnedObject(retObj);
-                                return { success: true, _id, data: retObj, operation, wasInsert, rawUpdate: wasInsert ? undefined : inputUpdate, mustRefresh };
+                                return {
+                                    success: true,
+                                    _id,
+                                    data: retObj,
+                                    operation,
+                                    wasInsert,
+                                    rawUpdate: wasInsert ? undefined : inputUpdate,
+                                    mustRefresh,
+                                };
                             }
-                            return { success: false, _id, error: 'Operation failed' };
+                            return { success: false, _id, error: "Operation failed" };
                         }
                         catch (err) {
-                            return { success: false, _id, error: err.message || String(err) };
+                            console.error(`[Mongo] updateCollections findOneAndUpdate error collection=${collection} _id=${String(_id)} reason=${err.message || String(err)}`, { collection, _id: String(_id), clientRev, err, update: processedUpdateForDiagnostics });
+                            return {
+                                success: false,
+                                _id,
+                                error: err.message || String(err),
+                            };
                         }
                     });
                     const updateResults = await Promise.all(updatePromises);
@@ -1021,26 +1110,32 @@ export class Mongo extends Db {
                                     // Hard delete applies no `_rev` increment: the removed doc's `_rev`
                                     // exceeding the client's base means an external write landed first.
                                     // Omitted `_rev` (clientRev → 0) forces a refresh — old-client fallback.
-                                    const externallyModified = typeof res._rev === 'number'
-                                        && res._rev > (clientRev !== null && clientRev !== void 0 ? clientRev : 0);
+                                    const externallyModified = typeof res._rev === "number" &&
+                                        res._rev > (clientRev !== null && clientRev !== void 0 ? clientRev : 0);
                                     const mustRefresh = externallyModified
                                         ? this._buildMustRefreshRecord(res)
                                         : undefined;
                                     this._processReturnedObject(res);
-                                    return { success: true, _id, data: res, operation: 'delete', mustRefresh };
+                                    return {
+                                        success: true,
+                                        _id,
+                                        data: res,
+                                        operation: "delete",
+                                        mustRefresh,
+                                    };
                                 }
-                                return { success: false, _id, error: 'Document not found' };
+                                return { success: false, _id, error: "Document not found" };
                             }
                             else {
                                 const del = {
                                     $set: { _deleted: new Date() },
                                     $inc: { _rev: 1 },
-                                    $currentDate: { _ts: { $type: 'timestamp' } }
+                                    $currentDate: { _ts: { $type: "timestamp" } },
                                 };
                                 const opts = {
                                     upsert: false,
                                     returnDocument: "after",
-                                    ...this._sessionOpt()
+                                    ...this._sessionOpt(),
                                 };
                                 const res = await conn
                                     .db(dbName)
@@ -1050,19 +1145,29 @@ export class Mongo extends Db {
                                     // Soft delete applied a +1 `_rev` increment: a gap beyond that +1
                                     // means an external write modified the record before this delete.
                                     // Omitted `_rev` (clientRev → 0) forces a refresh — old-client fallback.
-                                    const externallyModified = typeof res._rev === 'number'
-                                        && (res._rev - 1) > (clientRev !== null && clientRev !== void 0 ? clientRev : 0);
+                                    const externallyModified = typeof res._rev === "number" &&
+                                        res._rev - 1 > (clientRev !== null && clientRev !== void 0 ? clientRev : 0);
                                     const mustRefresh = externallyModified
                                         ? this._buildMustRefreshRecord(res)
                                         : undefined;
                                     this._processReturnedObject(res);
-                                    return { success: true, _id, data: res, operation: 'delete', mustRefresh };
+                                    return {
+                                        success: true,
+                                        _id,
+                                        data: res,
+                                        operation: "delete",
+                                        mustRefresh,
+                                    };
                                 }
-                                return { success: false, _id, error: 'Document not found' };
+                                return { success: false, _id, error: "Document not found" };
                             }
                         }
                         catch (err) {
-                            return { success: false, _id, error: err.message || String(err) };
+                            return {
+                                success: false,
+                                _id,
+                                error: err.message || String(err),
+                            };
                         }
                     });
                     const deleteResults = await Promise.all(deletePromises);
@@ -1099,8 +1204,8 @@ export class Mongo extends Db {
                                 operation: "batch",
                                 db: dbName,
                                 collection,
-                                data: batchData
-                            }
+                                data: batchData,
+                            },
                         });
                     }
                     if (this.emittingPublishRevEvents) {
@@ -1108,11 +1213,11 @@ export class Mongo extends Db {
                             operation: "batch",
                             db: dbName,
                             collection,
-                            data: batchData.map(item => ({
+                            data: batchData.map((item) => ({
                                 operation: item.operation,
                                 _id: item.data._id,
                                 _ts: item.data._ts,
-                            }))
+                            })),
                         };
                         this.emit("publishRev", {
                             channel: `dbrev/${dbName}/${collection}`,
@@ -1128,22 +1233,24 @@ export class Mongo extends Db {
                 results.push(result);
             }
         }
-        (_c = fjLog === null || fjLog === void 0 ? void 0 : fjLog[debugMethod]) === null || _c === void 0 ? void 0 : _c.call(fjLog, 'updateCollections returns', results);
+        (_c = fjLog === null || fjLog === void 0 ? void 0 : fjLog[debugMethod]) === null || _c === void 0 ? void 0 : _c.call(fjLog, "updateCollections returns", results);
         return results;
     }
     async upsertBatch(collection, batch) {
         assert(collection, "collection is required", "upsertBatch");
         assert(batch, "batch is required", "upsertBatch", { collection });
-        assert(batch instanceof Array, "batch must be an Array", "upsertBatch", { collection });
-        fjLog.debug('upsertBatch called', collection, batch);
+        assert(batch instanceof Array, "batch must be an Array", "upsertBatch", {
+            collection,
+        });
+        fjLog.debug("upsertBatch called", collection, batch);
         const dbName = this.db; // Capture db at operation start
         batch = this.replaceIds(batch);
-        await Promise.all(batch.map(item => this._processHashedKeys(item === null || item === void 0 ? void 0 : item.update)));
+        await Promise.all(batch.map((item) => this._processHashedKeys(item === null || item === void 0 ? void 0 : item.update)));
         let ret = await this.executeTransactionally(collection, async (conn, client) => {
             // Only process sequences if any batch item has SEQ_NEXT or SEQ_LAST
-            const updatesWithSeq = batch.filter(b => this._hasSequenceFields(b.update));
+            const updatesWithSeq = batch.filter((b) => this._hasSequenceFields(b.update));
             if (updatesWithSeq.length > 0) {
-                await this._processSequenceFieldForMany(client, dbName, collection, updatesWithSeq.map(b => b.update));
+                await this._processSequenceFieldForMany(client, dbName, collection, updatesWithSeq.map((b) => b.update));
             }
             // Process all updates in parallel
             const upsertPromises = batch.map(async (part) => {
@@ -1154,7 +1261,7 @@ export class Mongo extends Db {
                     upsert: true,
                     returnDocument: "after",
                     includeResultMetadata: true,
-                    ...this._sessionOpt()
+                    ...this._sessionOpt(),
                 };
                 if (this._hasHashedKeys(update))
                     await this._processHashedKeys(update);
@@ -1182,7 +1289,11 @@ export class Mongo extends Db {
                     ? ret
                     : this._buildPublishDelta(ret, inputUpdate, !!(opts === null || opts === void 0 ? void 0 : opts.returnFullObject));
                 this._processReturnedObject(retObj);
-                return { operation: oper, data: retObj, rawUpdate: oper === 'update' ? inputUpdate : undefined };
+                return {
+                    operation: oper,
+                    data: retObj,
+                    rawUpdate: oper === "update" ? inputUpdate : undefined,
+                };
             });
             const results = await Promise.all(upsertPromises);
             // Filter out nulls and separate batchData and changes
@@ -1205,8 +1316,8 @@ export class Mongo extends Db {
                         operation: "batch",
                         db: dbName,
                         collection,
-                        data: batchData
-                    }
+                        data: batchData,
+                    },
                 });
             }
             if (this.emittingPublishRevEvents) {
@@ -1214,11 +1325,11 @@ export class Mongo extends Db {
                     operation: "batch",
                     db: dbName,
                     collection,
-                    data: batchData.map(item => ({
+                    data: batchData.map((item) => ({
                         operation: item.operation,
                         _id: item.data._id,
                         _ts: item.data._ts,
-                    }))
+                    })),
                 };
                 this.emit("publishRev", {
                     channel: `dbrev/${dbName}/${collection}`,
@@ -1227,23 +1338,28 @@ export class Mongo extends Db {
             }
             return changes;
         }, false, { operation: "upsertBatch", collection, batch });
-        fjLog.debug('upsertBatch returns', ret);
+        fjLog.debug("upsertBatch returns", ret);
         return ret;
     }
     async insertMany(collection, insert) {
         assert(collection, "collection is required", "insertMany");
         assert(insert, "insert is required", "insertMany", { collection });
-        assert(insert instanceof Array, "insert must be an Array", "insertMany", { collection });
-        fjLog.debug('insertMany called', collection, insert);
+        assert(insert instanceof Array, "insert must be an Array", "insertMany", {
+            collection,
+        });
+        fjLog.debug("insertMany called", collection, insert);
         const dbName = this.db; // Capture db at operation start
         insert = this.replaceIds(insert);
-        insert.forEach(item => this._stripDoubleUnderscoreKeys(item));
-        await Promise.all(insert.map(item => this._processHashedKeys(item)));
+        insert.forEach((item) => this._stripDoubleUnderscoreKeys(item));
+        await Promise.all(insert.map((item) => this._processHashedKeys(item)));
         if (this.revisions)
-            insert.forEach(ins => { ins._rev = 1; ins._ts = Base.timestamp(); });
+            insert.forEach((ins) => {
+                ins._rev = 1;
+                ins._ts = Base.timestamp();
+            });
         let ret = await this.executeTransactionally(collection, async (conn, client) => {
             // Only process sequences if any insert has SEQ_NEXT or SEQ_LAST
-            const insertsWithSeq = insert.filter(item => this._hasSequenceFields(item));
+            const insertsWithSeq = insert.filter((item) => this._hasSequenceFields(item));
             if (insertsWithSeq.length > 0) {
                 await this._processSequenceFieldForMany(client, dbName, collection, insert);
             }
@@ -1253,16 +1369,20 @@ export class Mongo extends Db {
                 let n = Number(ns);
                 let rec = {
                     _id: obj.insertedIds[n],
-                    ...insert[n]
+                    ...insert[n],
                 };
                 ret.push(rec);
             }
-            if (this.emittingPublishEvents || this.emittingPublishRevEvents || this.auditing) {
-                await Promise.all(ret.filter(rec => rec).map(rec => this._publishAndAudit('insert', dbName, collection, rec)));
+            if (this.emittingPublishEvents ||
+                this.emittingPublishRevEvents ||
+                this.auditing) {
+                await Promise.all(ret
+                    .filter((rec) => rec)
+                    .map((rec) => this._publishAndAudit("insert", dbName, collection, rec)));
             }
             return ret;
         }, false, { operation: "insertMany", collection, insert });
-        fjLog.debug('insertMany returns', ret);
+        fjLog.debug("insertMany returns", ret);
         return ret;
     }
     async deleteOne(collection, query) {
@@ -1272,36 +1392,46 @@ export class Mongo extends Db {
         query = this.replaceIds(query);
         if (!this.softdelete) {
             const opts = this._sessionOpt();
-            fjLog.debug('deleteOne called', this.softdelete, collection, query);
+            fjLog.debug("deleteOne called", this.softdelete, collection, query);
             let ret = await this.executeTransactionally(collection, async (conn) => {
                 let obj = await conn.findOneAndDelete(query, opts);
                 if (obj)
-                    await this._publishAndAudit('delete', dbName, collection, obj);
+                    await this._publishAndAudit("delete", dbName, collection, obj);
                 return obj;
-            }, false, { operation: "deleteOne", collection, query, softdelete: this.softdelete });
-            fjLog.debug('deleteOne returns', ret);
+            }, false, {
+                operation: "deleteOne",
+                collection,
+                query,
+                softdelete: this.softdelete,
+            });
+            fjLog.debug("deleteOne returns", ret);
             return ret;
         }
         else {
             let opts = {
                 upsert: false,
                 returnDocument: "after",
-                ...this._sessionOpt()
+                ...this._sessionOpt(),
             };
-            fjLog.debug('deleteOne called', collection, query);
+            fjLog.debug("deleteOne called", collection, query);
             let ret = await this.executeTransactionally(collection, async (conn /*, client*/) => {
                 let del = {
                     $set: { _deleted: new Date() },
-                    $inc: { _rev: 1, },
-                    $currentDate: { _ts: { $type: 'timestamp' } }
+                    $inc: { _rev: 1 },
+                    $currentDate: { _ts: { $type: "timestamp" } },
                 };
                 // if (this.syncSupport) del.$set._csq = await this._getNextCollectionUpdateSeqNo(collection, client)
                 let obj = await conn.findOneAndUpdate(query, del, opts);
                 if (obj)
-                    await this._publishAndAudit('delete', dbName, collection, obj);
+                    await this._publishAndAudit("delete", dbName, collection, obj);
                 return obj;
-            }, false, { operation: "deleteOne", collection, query, softdelete: this.softdelete });
-            fjLog.debug('deleteOne returns', ret);
+            }, false, {
+                operation: "deleteOne",
+                collection,
+                query,
+                softdelete: this.softdelete,
+            });
+            fjLog.debug("deleteOne returns", ret);
             return ret;
         }
     }
@@ -1309,56 +1439,56 @@ export class Mongo extends Db {
         let opts = {
             upsert: false,
             returnDocument: "after",
-            ...this._sessionOpt()
+            ...this._sessionOpt(),
         };
         const dbName = this.db; // Capture db at operation start
         query = this.replaceIds(query);
-        fjLog.debug('blockOne called', collection, query);
+        fjLog.debug("blockOne called", collection, query);
         let ret = await this.executeTransactionally(collection, async (conn) => {
             query._blocked = { $exists: 0 };
             let update = {
-                $set: { _blocked: new Date(), },
-                $inc: { _rev: 1, },
-                $currentDate: { _ts: { $type: 'timestamp' } }
+                $set: { _blocked: new Date() },
+                $inc: { _rev: 1 },
+                $currentDate: { _ts: { $type: "timestamp" } },
             };
             // if (this.syncSupport) update.$set._csq = await this._getNextCollectionUpdateSeqNo(collection, client)
             let obj = await conn.findOneAndUpdate(query, update, opts);
             if (!obj || !(obj === null || obj === void 0 ? void 0 : obj._id))
                 return {
-                    ok: false
+                    ok: false,
                 };
-            await this._publishAndAudit('update', dbName, collection, obj);
+            await this._publishAndAudit("update", dbName, collection, obj);
             return obj;
         }, false, { operation: "blockOne", collection, query });
-        fjLog.debug('blockOne returns', ret);
+        fjLog.debug("blockOne returns", ret);
         return ret;
     }
     async unblockOne(collection, query) {
         let opts = {
             upsert: false,
             returnDocument: "after",
-            ...this._sessionOpt()
+            ...this._sessionOpt(),
         };
         const dbName = this.db; // Capture db at operation start
         query = this.replaceIds(query);
-        fjLog.debug('unblockOne called', collection, query);
+        fjLog.debug("unblockOne called", collection, query);
         let ret = await this.executeTransactionally(collection, async (conn) => {
             query._blocked = { $exists: 1 };
             let update = {
                 $unset: { _blocked: 1 },
-                $inc: { _rev: 1, },
-                $currentDate: { _ts: { $type: 'timestamp' } }
+                $inc: { _rev: 1 },
+                $currentDate: { _ts: { $type: "timestamp" } },
             };
             // if (this.syncSupport) update.$set = { _csq: await this._getNextCollectionUpdateSeqNo(collection, client) };
             let obj = await conn.findOneAndUpdate(query, update, opts);
             if (!obj || !(obj === null || obj === void 0 ? void 0 : obj._id))
                 return {
-                    ok: false
+                    ok: false,
                 };
-            await this._publishAndAudit('update', dbName, collection, obj);
+            await this._publishAndAudit("update", dbName, collection, obj);
             return obj;
         }, false, { operation: "unblockOne", collection, query });
-        fjLog.debug('unblockOne returns', ret);
+        fjLog.debug("unblockOne returns", ret);
         return ret;
     }
     /**
@@ -1369,27 +1499,27 @@ export class Mongo extends Db {
         let opts = {
             upsert: false,
             returnDocument: "after",
-            ...this._sessionOpt()
+            ...this._sessionOpt(),
         };
         const dbName = this.db;
         query = this.replaceIds(query);
-        fjLog.debug('archiveOne called', collection, query);
+        fjLog.debug("archiveOne called", collection, query);
         let ret = await this.executeTransactionally(collection, async (conn) => {
             query._archived = { $exists: false };
             let update = {
-                $set: { _archived: new Date(), },
-                $inc: { _rev: 1, },
-                $currentDate: { _ts: { $type: 'timestamp' } }
+                $set: { _archived: new Date() },
+                $inc: { _rev: 1 },
+                $currentDate: { _ts: { $type: "timestamp" } },
             };
             let obj = await conn.findOneAndUpdate(query, update, opts);
             if (!obj || !(obj === null || obj === void 0 ? void 0 : obj._id))
                 return {
-                    ok: false
+                    ok: false,
                 };
-            await this._publishAndAudit('update', dbName, collection, obj);
+            await this._publishAndAudit("update", dbName, collection, obj);
             return obj;
         }, false, { operation: "archiveOne", collection, query });
-        fjLog.debug('archiveOne returns', ret);
+        fjLog.debug("archiveOne returns", ret);
         return ret;
     }
     /**
@@ -1400,27 +1530,27 @@ export class Mongo extends Db {
         let opts = {
             upsert: false,
             returnDocument: "after",
-            ...this._sessionOpt()
+            ...this._sessionOpt(),
         };
         const dbName = this.db;
         query = this.replaceIds(query);
-        fjLog.debug('unarchiveOne called', collection, query);
+        fjLog.debug("unarchiveOne called", collection, query);
         let ret = await this.executeTransactionally(collection, async (conn) => {
             query._archived = { $exists: true };
             let update = {
                 $unset: { _archived: 1 },
-                $inc: { _rev: 1, },
-                $currentDate: { _ts: { $type: 'timestamp' } }
+                $inc: { _rev: 1 },
+                $currentDate: { _ts: { $type: "timestamp" } },
             };
             let obj = await conn.findOneAndUpdate(query, update, opts);
             if (!obj || !(obj === null || obj === void 0 ? void 0 : obj._id))
                 return {
-                    ok: false
+                    ok: false,
                 };
-            await this._publishAndAudit('update', dbName, collection, obj);
+            await this._publishAndAudit("update", dbName, collection, obj);
             return obj;
         }, false, { operation: "unarchiveOne", collection, query });
-        fjLog.debug('unarchiveOne returns', ret);
+        fjLog.debug("unarchiveOne returns", ret);
         return ret;
     }
     /**
@@ -1429,7 +1559,9 @@ export class Mongo extends Db {
     async archiveOneById(collection, id) {
         assert(collection, "collection is required", "archiveOneById");
         assert(id, "id is required", "archiveOneById", { collection });
-        return await this.archiveOne(collection, { _id: Mongo._toId(id) });
+        return await this.archiveOne(collection, {
+            _id: Mongo._toId(id),
+        });
     }
     /**
      * Archives multiple documents found by their `_id`s.
@@ -1443,29 +1575,32 @@ export class Mongo extends Db {
         const opts = {
             upsert: false,
             returnDocument: "after",
-            ...this._sessionOpt()
+            ...this._sessionOpt(),
         };
         const dbName = this.db;
-        fjLog.debug('archiveManyByIds called', collection, ids);
+        fjLog.debug("archiveManyByIds called", collection, ids);
         let ret = [];
         for (const id of ids) {
             let r = await this.executeTransactionally(collection, async (conn) => {
-                let query = { _id: Mongo._toId(id), _archived: { $exists: false } };
+                let query = {
+                    _id: Mongo._toId(id),
+                    _archived: { $exists: false },
+                };
                 let update = {
                     $set: { _archived: new Date() },
                     $inc: { _rev: 1 },
-                    $currentDate: { _ts: { $type: 'timestamp' } }
+                    $currentDate: { _ts: { $type: "timestamp" } },
                 };
                 let obj = await conn.findOneAndUpdate(query, update, opts);
                 if (obj === null || obj === void 0 ? void 0 : obj._id) {
-                    await this._publishAndAudit('update', dbName, collection, obj);
+                    await this._publishAndAudit("update", dbName, collection, obj);
                 }
                 return obj;
             }, false, { operation: "archiveManyByIds", collection, id });
             if (r === null || r === void 0 ? void 0 : r._id)
                 ret.push(r);
         }
-        fjLog.debug('archiveManyByIds returns', ret);
+        fjLog.debug("archiveManyByIds returns", ret);
         return ret;
     }
     /**
@@ -1474,7 +1609,9 @@ export class Mongo extends Db {
     async unarchiveOneById(collection, id) {
         assert(collection, "collection is required", "unarchiveOneById");
         assert(id, "id is required", "unarchiveOneById", { collection });
-        return await this.unarchiveOne(collection, { _id: Mongo._toId(id) });
+        return await this.unarchiveOne(collection, {
+            _id: Mongo._toId(id),
+        });
     }
     /**
      * Unarchives multiple documents found by their `_id`s.
@@ -1488,52 +1625,57 @@ export class Mongo extends Db {
         const opts = {
             upsert: false,
             returnDocument: "after",
-            ...this._sessionOpt()
+            ...this._sessionOpt(),
         };
         const dbName = this.db;
-        fjLog.debug('unarchiveManyByIds called', collection, ids);
+        fjLog.debug("unarchiveManyByIds called", collection, ids);
         let ret = [];
         for (const id of ids) {
             let r = await this.executeTransactionally(collection, async (conn) => {
-                let query = { _id: Mongo._toId(id), _archived: { $exists: true } };
+                let query = {
+                    _id: Mongo._toId(id),
+                    _archived: { $exists: true },
+                };
                 let update = {
                     $unset: { _archived: 1 },
                     $inc: { _rev: 1 },
-                    $currentDate: { _ts: { $type: 'timestamp' } }
+                    $currentDate: { _ts: { $type: "timestamp" } },
                 };
                 let obj = await conn.findOneAndUpdate(query, update, opts);
                 if (obj === null || obj === void 0 ? void 0 : obj._id) {
-                    await this._publishAndAudit('update', dbName, collection, obj);
+                    await this._publishAndAudit("update", dbName, collection, obj);
                 }
                 return obj;
             }, false, { operation: "unarchiveManyByIds", collection, id });
             if (r === null || r === void 0 ? void 0 : r._id)
                 ret.push(r);
         }
-        fjLog.debug('unarchiveManyByIds returns', ret);
+        fjLog.debug("unarchiveManyByIds returns", ret);
         return ret;
     }
     async hardDeleteOne(collection, query) {
         assert(collection, "collection is required", "hardDeleteOne");
         assert(query, "query is required", "hardDeleteOne", { collection });
         const dbName = this.db; // Capture db at operation start
-        if (typeof query === "string" || typeof query === "number" || query instanceof ObjectId) {
+        if (typeof query === "string" ||
+            typeof query === "number" ||
+            query instanceof ObjectId) {
             query = { _id: query };
         }
         query = this.replaceIds(query);
         let opts = {
             returnDocument: "after",
-            ...this._sessionOpt()
+            ...this._sessionOpt(),
         };
-        fjLog.debug('hardDeleteOne called', collection, query);
+        fjLog.debug("hardDeleteOne called", collection, query);
         let ret = await this.executeTransactionally(collection, async (conn) => {
             let obj = await conn.findOneAndDelete(query, opts);
             if (obj) {
-                await this._publishAndAudit('delete', dbName, collection, obj);
+                await this._publishAndAudit("delete", dbName, collection, obj);
             }
             return obj;
         }, false, { operation: "hardDeleteOne", collection, query });
-        fjLog.debug('hardDeleteOne returns', ret);
+        fjLog.debug("hardDeleteOne returns", ret);
         return ret;
     }
     async delete(collection, query) {
@@ -1544,42 +1686,42 @@ export class Mongo extends Db {
         query = this.replaceIds(query);
         if (!this.softdelete) {
             const opts = this._sessionOpt();
-            fjLog.debug('delete called', collection, query);
+            fjLog.debug("delete called", collection, query);
             let ret = await this.executeTransactionally(collection, async (conn) => {
                 let obj = await conn.deleteMany(query, opts);
                 let resObj = {
                     n: obj.deletedCount,
-                    ok: !!obj.acknowledged
+                    ok: !!obj.acknowledged,
                 };
-                await this._publishAndAudit('deleteMany', dbName, collection, resObj);
+                await this._publishAndAudit("deleteMany", dbName, collection, resObj);
                 return resObj;
             }, false, { operation: "delete", collection, query, softdelete: this.softdelete });
-            fjLog.debug('delete returns', ret);
+            fjLog.debug("delete returns", ret);
             return ret;
         }
         else {
             let opts = {
                 upsert: false,
                 returnDocument: "after",
-                ...this._sessionOpt()
+                ...this._sessionOpt(),
             };
             let date = new Date();
-            fjLog.debug('delete called', collection, query);
+            fjLog.debug("delete called", collection, query);
             let ret = await this.executeTransactionally(collection, async (conn) => {
                 let upd = {
                     $set: { _deleted: date },
                     $inc: { _rev: 1 },
-                    $currentDate: { _ts: { $type: 'timestamp' } }
+                    $currentDate: { _ts: { $type: "timestamp" } },
                 };
                 let obj = await conn.updateMany(query, upd, opts);
                 let resObj = {
                     n: obj.modifiedCount,
-                    ok: !!obj.acknowledged
+                    ok: !!obj.acknowledged,
                 };
-                await this._publishAndAudit('deleteMany', dbName, collection, resObj);
+                await this._publishAndAudit("deleteMany", dbName, collection, resObj);
                 return resObj;
             }, false, { operation: "delete", collection, query, softdelete: this.softdelete });
-            fjLog.debug('delete returns', ret);
+            fjLog.debug("delete returns", ret);
             return ret;
         }
     }
@@ -1590,22 +1732,27 @@ export class Mongo extends Db {
         const dbName = this.db; // Capture db at operation start
         query = this.replaceIds(query);
         const opts = this._sessionOpt();
-        fjLog.debug('hardDelete called', collection, query);
+        fjLog.debug("hardDelete called", collection, query);
         let ret = await this.executeTransactionally(collection, async (conn) => {
             let obj = await conn.deleteMany(query, opts);
             let resObj = {
                 n: obj.deletedCount,
-                ok: !!obj.acknowledged
+                ok: !!obj.acknowledged,
             };
-            await this._publishAndAudit('deleteMany', dbName, collection, resObj);
+            await this._publishAndAudit("deleteMany", dbName, collection, resObj);
             return resObj;
-        }, false, { operation: "hardDelete", collection, query, softdelete: this.softdelete });
-        fjLog.debug('hardDelete returns', ret);
+        }, false, {
+            operation: "hardDelete",
+            collection,
+            query,
+            softdelete: this.softdelete,
+        });
+        fjLog.debug("hardDelete returns", ret);
         return ret;
     }
     async testHash(collection, query, field, unhashedValue) {
         let _field;
-        fjLog.debug('testHash called', collection, query, field, unhashedValue);
+        fjLog.debug("testHash called", collection, query, field, unhashedValue);
         if (typeof field === "object") {
             if (Object.keys(field).length === 1)
                 [_field, unhashedValue] = Object.entries(field)[0];
@@ -1618,13 +1765,16 @@ export class Mongo extends Db {
             _field = HASHED_PREFIX + _field;
         const dbName = this.db; // Capture db at operation start
         let conn = await this.connect();
-        let obj = await conn.db(dbName).collection(collection).findOne(query, { projection: { [_field]: 1 }, ...this._sessionOpt() });
+        let obj = await conn
+            .db(dbName)
+            .collection(collection)
+            .findOne(query, { projection: { [_field]: 1 }, ...this._sessionOpt() });
         if (!obj || !obj[_field]) {
-            fjLog.debug('testHash returns false', obj);
+            fjLog.debug("testHash returns false", obj);
             return false;
         }
         let res = await bcrypt.compare(unhashedValue, obj[_field].hash);
-        fjLog.debug('testHash returns', res);
+        fjLog.debug("testHash returns", res);
         return res;
     }
     async aggregate(collection, pipeline, opts = {
@@ -1632,7 +1782,7 @@ export class Mongo extends Db {
     }) {
         assert(collection, "collection is required", "aggregate");
         assert(pipeline instanceof Array, "pipeline must be an Array", "aggregate", { collection });
-        fjLog.debug('aggregate called', collection, pipeline);
+        fjLog.debug("aggregate called", collection, pipeline);
         pipeline = this.replaceIds(pipeline);
         if (this.session)
             opts.session = this.session;
@@ -1640,7 +1790,7 @@ export class Mongo extends Db {
             let res = await conn.aggregate(pipeline, opts).toArray();
             return res;
         }, false, { operation: "aggregate", collection, pipeline, opts });
-        fjLog.debug('aggregare returns', ret);
+        fjLog.debug("aggregare returns", ret);
         return ret;
     }
     async isUnique(collection, field, value, id) {
@@ -1648,7 +1798,7 @@ export class Mongo extends Db {
         assert(field, "field is required", "isUnique", { collection });
         if (!value)
             return false;
-        fjLog.debug('isUnique called', collection, field, value, id);
+        fjLog.debug("isUnique called", collection, field, value, id);
         let _id = id === null || id === void 0 ? void 0 : id.toString();
         let query = typeof value === "object" ? value : { [field]: value };
         query = this.replaceIds(query);
@@ -1666,12 +1816,12 @@ export class Mongo extends Db {
                 return false;
             }
         }
-        fjLog.debug('isUnique returns', ret);
+        fjLog.debug("isUnique returns", ret);
         return ret;
     }
     async dropCollection(collection) {
         assert(collection, "collection is required", "dropCollection");
-        fjLog.debug('dropCollection called', this.auditCollections);
+        fjLog.debug("dropCollection called", this.auditCollections);
         const dbName = this.db; // Capture db at operation start
         let client = await this.connect();
         let existing = await client.db(dbName).collections();
@@ -1679,14 +1829,15 @@ export class Mongo extends Db {
         if (existingNames.has(collection)) {
             await client.db(dbName).dropCollection(collection);
         }
-        fjLog.debug('dropCollection returns');
+        fjLog.debug("dropCollection returns");
     }
     async resetCollectionSync(collection) {
         assert(collection, "collection is required", "resetCollectionSync");
-        fjLog.debug('resetCollectionSync called for', collection);
+        fjLog.debug("resetCollectionSync called for", collection);
         const dbName = this.db; // Capture db at operation start
         let client = await this.connect();
-        await client.db(dbName)
+        await client
+            .db(dbName)
             .collection(SEQUENCES_COLLECTION)
             .findOneAndDelete({ collection });
         fjLog.debug(`resetCollectionSync for ${collection} returns`);
@@ -1694,7 +1845,7 @@ export class Mongo extends Db {
     async dropCollections(collections) {
         assert(collections, "collections is required", "dropCollections");
         assert(collections instanceof Array, "collections must be an Array", "dropCollections");
-        fjLog.debug('dropCollections called', this.auditCollections);
+        fjLog.debug("dropCollections called", this.auditCollections);
         const dbName = this.db; // Capture db at operation start
         let client = await this.connect();
         let existing = await client.db(dbName).collections();
@@ -1704,12 +1855,12 @@ export class Mongo extends Db {
                 await client.db(dbName).dropCollection(collection);
             }
         }
-        fjLog.debug('dropCollections returns');
+        fjLog.debug("dropCollections returns");
     }
     async createCollections(collections) {
         assert(collections, "collections is required", "createCollections");
         assert(collections instanceof Array, "collections must be an Array", "createCollections");
-        fjLog.debug('createCollections called', this.auditCollections);
+        fjLog.debug("createCollections called", this.auditCollections);
         const dbName = this.db; // Capture db at operation start
         let client = await this.connect();
         let existing = await this.getCollections();
@@ -1719,25 +1870,25 @@ export class Mongo extends Db {
                 await client.db(dbName).createCollection(collection);
             }
         }
-        fjLog.debug('createCollections returns');
+        fjLog.debug("createCollections returns");
     }
     async createCollection(collection) {
         assert(collection, "collection is required", "createCollection");
-        fjLog.debug('createCollection called', collection);
+        fjLog.debug("createCollection called", collection);
         const dbName = this.db; // Capture db at operation start
         let client = await this.connect();
         let existing = await this.getCollections();
         if (!existing.includes(collection)) {
             await client.db(dbName).createCollection(collection);
         }
-        fjLog.debug('createCollection returns');
+        fjLog.debug("createCollection returns");
     }
     async dbLogPurge(collection, _id) {
         assert(collection, "collection is required", "dbLogPurge");
-        fjLog.debug('dblogPurge called', collection, _id);
+        fjLog.debug("dblogPurge called", collection, _id);
         const dbName = this.db; // Capture db at operation start
         let ret = await this.executeTransactionally(collection, async () => {
-            let cond = { db: dbName, collection, };
+            let cond = { db: dbName, collection };
             if (_id !== undefined)
                 cond._id = Mongo._toId(_id);
             let client = await this.connect();
@@ -1747,15 +1898,15 @@ export class Mongo extends Db {
                 .deleteMany(cond, this._sessionOpt());
             return {
                 ok: !!ret.acknowledged,
-                n: ret.deletedCount
+                n: ret.deletedCount,
             };
         }, false, { operation: "dbLogPurge", collection, _id });
-        fjLog.debug('dblogPurge returns', ret);
+        fjLog.debug("dblogPurge returns", ret);
         return ret;
     }
     async dbLogGet(collection, _id) {
         assert(collection, "collection is required", "dbLogGet");
-        fjLog.debug('dblogGet called', collection, _id);
+        fjLog.debug("dblogGet called", collection, _id);
         const dbName = this.db; // Capture db at operation start
         let ret = await this.executeTransactionally(collection, async () => {
             let cond = { db: dbName, collection };
@@ -1770,7 +1921,7 @@ export class Mongo extends Db {
                 .toArray();
             return ret;
         }, false, { operation: "dbLogGet", collection, _id });
-        fjLog.debug('dblogGet returns', ret);
+        fjLog.debug("dblogGet returns", ret);
         return ret;
     }
     // HELPER FUNCTIONS
@@ -1805,13 +1956,13 @@ export class Mongo extends Db {
             if (typeof data === "string")
                 return data;
             if (data instanceof Array) {
-                return data.map(d => this.replaceIds(d));
+                return data.map((d) => this.replaceIds(d));
             }
-            if (typeof data == 'object' && (data === null || data === void 0 ? void 0 : data.t) && (data === null || data === void 0 ? void 0 : data.i) !== undefined)
+            if (typeof data == "object" && (data === null || data === void 0 ? void 0 : data.t) && (data === null || data === void 0 ? void 0 : data.i) !== undefined)
                 return Base.timestamp(data);
-            if (typeof data == 'object' && (data === null || data === void 0 ? void 0 : data.high) && (data === null || data === void 0 ? void 0 : data.low) !== undefined)
+            if (typeof data == "object" && (data === null || data === void 0 ? void 0 : data.high) && (data === null || data === void 0 ? void 0 : data.low) !== undefined)
                 return Base.timestamp(data);
-            if (typeof data == 'object') {
+            if (typeof data == "object") {
                 for (let key in data) {
                     data[key] = this.replaceIds(data[key]);
                 }
@@ -1820,7 +1971,7 @@ export class Mongo extends Db {
             throw new Error(`ObjectId test failed for ${data}`);
         }
         catch (err) {
-            console.error('error in replaceIds', err, data);
+            console.error("error in replaceIds", err, data);
             throw err;
         }
     }
@@ -1868,14 +2019,14 @@ export class Mongo extends Db {
         this._sequencesIndexEnsured = false;
     }
     async inTransaction() {
-        if (!await this.isOnReplicaSet())
+        if (!(await this.isOnReplicaSet()))
             return false;
         if (!this.session)
             return false;
         return this.session.inTransaction();
     }
     async withTransaction(funct) {
-        if (!await this.isOnReplicaSet())
+        if (!(await this.isOnReplicaSet()))
             return await funct(await this.connect(), null);
         const hadSession = !!this.session;
         try {
@@ -1899,14 +2050,16 @@ export class Mongo extends Db {
                     await this.session.endSession();
                     fjLog.info("session ended after error");
                 }
-                catch { /* ignore cleanup errors */ }
+                catch {
+                    /* ignore cleanup errors */
+                }
                 this.session = undefined;
             }
             throw err;
         }
     }
     async startTransaction() {
-        if (!await this.isOnReplicaSet())
+        if (!(await this.isOnReplicaSet()))
             return;
         let client = await this.connect();
         try {
@@ -1914,13 +2067,13 @@ export class Mongo extends Db {
                 this.session = client.startSession(TRANSACTION_OPTIONS);
                 fjLog.info("session started");
             }
-            if (!await this.inTransaction()) {
+            if (!(await this.inTransaction())) {
                 await this.session.startTransaction();
                 fjLog.info("transaction started");
             }
         }
         catch (err) {
-            fjLog.error('startTransaction error', err);
+            fjLog.error("startTransaction error", err);
             try {
                 if (this.session) {
                     await this.session.endSession();
@@ -1935,10 +2088,10 @@ export class Mongo extends Db {
         }
     }
     async commitTransaction() {
-        if (!await this.isOnReplicaSet())
+        if (!(await this.isOnReplicaSet()))
             return;
         try {
-            if (!await this.inTransaction())
+            if (!(await this.inTransaction()))
                 return;
             let session = this.session;
             await session.commitTransaction();
@@ -1952,10 +2105,10 @@ export class Mongo extends Db {
         }
     }
     async abortTransaction() {
-        if (!await this.isOnReplicaSet())
+        if (!(await this.isOnReplicaSet()))
             return;
         try {
-            if (!await this.inTransaction())
+            if (!(await this.inTransaction()))
                 return;
             let session = this.session;
             await session.abortTransaction();
@@ -2009,22 +2162,24 @@ export class Mongo extends Db {
             // E11000 duplicate key — log concise one-liner (avoid dumping full batch)
             if (x.match(/E11000/i)) {
                 const dupMatch = x.match(/dup key:\s*(\{[^}]+\})/);
-                const count = Array.isArray(debugObject.insert) ? debugObject.insert.length : 1;
+                const count = Array.isArray(debugObject.insert)
+                    ? debugObject.insert.length
+                    : 1;
                 const rollback = this.session ? "ROLLBACK - " : "";
                 fjLog.error(`${rollback}Mongo ${debugObject.operation} E11000 on ${dbName}.${collection} (batch=${count}${dupMatch ? `, ${dupMatch[1].trim()}` : ""}) — ignoring`);
                 if (debugObject.operation === "insert")
                     return debugObject.insert;
                 throw err;
             }
-            fjLog.error(`Mongo command has failed for ${dbName}.${collection} - ${(this.session ? "ROLLBACK - " : "")} ${err.message || err}`);
+            fjLog.error(`Mongo command has failed for ${dbName}.${collection} - ${this.session ? "ROLLBACK - " : ""} ${err.message || err}`);
             fjLog.error(debugObject);
             fjLog.debug(err);
-            let isRepeatable = x.match(/Topology is closed, please connect/i)
-                || x.match(/connection timed out/i)
-                || x.match(/not master/i)
-                || x.match(/Topology closed/i)
-                || x.match(/Topology is closed/i)
-                || x.match(/Connection pool closed/i);
+            let isRepeatable = x.match(/Topology is closed, please connect/i) ||
+                x.match(/connection timed out/i) ||
+                x.match(/not master/i) ||
+                x.match(/Topology closed/i) ||
+                x.match(/Topology is closed/i) ||
+                x.match(/Connection pool closed/i);
             if (isRepeatable) {
                 try {
                     fjLog.error("Trying to reopen connection and repeat as");
@@ -2049,11 +2204,11 @@ export class Mongo extends Db {
     }
     async _findLastSequenceForKey(connection, key) {
         var _a;
-        let maxfld = await (connection
+        let maxfld = await connection
             .find({}, this._sessionOpt())
             .sort({ [key]: -1 })
             .limit(1)
-            .toArray());
+            .toArray();
         if (maxfld.length === 0)
             return undefined;
         return parseInt((_a = maxfld === null || maxfld === void 0 ? void 0 : maxfld[0]) === null || _a === void 0 ? void 0 : _a[key]) || 0;
@@ -2095,19 +2250,19 @@ export class Mongo extends Db {
         if (!existingSeq) {
             // First time for this collection/field - ensure index exists
             await this._ensureSequencesIndex(dbConnection);
-            const seedValue = (existingMax !== undefined && existingMax >= 1) ? existingMax : 0;
+            const seedValue = existingMax !== undefined && existingMax >= 1 ? existingMax : 0;
             // Use $max to handle concurrent seeding - only sets if greater than current value
             // This ensures the highest seed value wins in case of concurrent operations
             await dbConnection
                 .collection(FIELD_SEQUENCES_COLLECTION)
                 .findOneAndUpdate({ collection, field }, {
                 $max: { lastSeqNum: seedValue },
-                $setOnInsert: { collection, field }
-            }, { upsert: true, returnDocument: 'after', ...this._sessionOpt() });
+                $setOnInsert: { collection, field },
+            }, { upsert: true, returnDocument: "after", ...this._sessionOpt() });
             // Now increment atomically to get next value
             const updated = await dbConnection
                 .collection(FIELD_SEQUENCES_COLLECTION)
-                .findOneAndUpdate({ collection, field }, { $inc: { lastSeqNum: 1 } }, { returnDocument: 'after', ...this._sessionOpt() });
+                .findOneAndUpdate({ collection, field }, { $inc: { lastSeqNum: 1 } }, { returnDocument: "after", ...this._sessionOpt() });
             return updated.lastSeqNum;
         }
         // Sequence exists - check if collection was cleared (reset scenario)
@@ -2120,7 +2275,7 @@ export class Mongo extends Db {
         // Increment and return
         const result = await dbConnection
             .collection(FIELD_SEQUENCES_COLLECTION)
-            .findOneAndUpdate({ collection, field }, { $inc: { lastSeqNum: 1 } }, { returnDocument: 'after', ...this._sessionOpt() });
+            .findOneAndUpdate({ collection, field }, { $inc: { lastSeqNum: 1 } }, { returnDocument: "after", ...this._sessionOpt() });
         return result.lastSeqNum;
     }
     /**
@@ -2169,14 +2324,14 @@ export class Mongo extends Db {
         if (!existingSeq) {
             // First time for this collection/field - ensure index exists
             await this._ensureSequencesIndex(dbConnection);
-            const seedValue = (existingMax !== undefined && existingMax >= 1) ? existingMax : 0;
+            const seedValue = existingMax !== undefined && existingMax >= 1 ? existingMax : 0;
             // Use $max to handle concurrent seeding
             await dbConnection
                 .collection(FIELD_SEQUENCES_COLLECTION)
                 .findOneAndUpdate({ collection, field }, {
                 $max: { lastSeqNum: seedValue },
-                $setOnInsert: { collection, field }
-            }, { upsert: true, returnDocument: 'after', ...this._sessionOpt() });
+                $setOnInsert: { collection, field },
+            }, { upsert: true, returnDocument: "after", ...this._sessionOpt() });
         }
         else if (existingMax === undefined && existingSeq.lastSeqNum > 0) {
             // Collection is empty but we have a non-zero sequence - reset to 0
@@ -2187,7 +2342,7 @@ export class Mongo extends Db {
         // Now atomically reserve the range
         const result = await dbConnection
             .collection(FIELD_SEQUENCES_COLLECTION)
-            .findOneAndUpdate({ collection, field }, { $inc: { lastSeqNum: count } }, { returnDocument: 'after', ...this._sessionOpt() });
+            .findOneAndUpdate({ collection, field }, { $inc: { lastSeqNum: count } }, { returnDocument: "after", ...this._sessionOpt() });
         const end = result.lastSeqNum;
         return { start: end - count + 1, end };
     }
@@ -2212,17 +2367,20 @@ export class Mongo extends Db {
             return;
         if (!this._hasSequenceFields(object) && !this.syncSupport)
             return;
-        const seqKeys = Object.keys(object).filter(key => object[key] === 'SEQ_NEXT' || object[key] === 'SEQ_LAST');
+        const seqKeys = Object.keys(object).filter((key) => object[key] === "SEQ_NEXT" ||
+            object[key] === "SEQ_LAST");
         return { seqKeys };
     }
     async _processSequenceField(client, dbName, collection, insert, seqKeys) {
-        assert(this.client, "client is required", "_processSequenceField", { collection });
+        assert(this.client, "client is required", "_processSequenceField", {
+            collection,
+        });
         // if (this.syncSupport) {
         //     insert._csq = (await this._getNextCollectionUpdateSeqNo(collection, client));
         // }
         const db = client.db(dbName);
         for (const seqKey of (seqKeys === null || seqKeys === void 0 ? void 0 : seqKeys.seqKeys) || []) {
-            if (insert[seqKey] === 'SEQ_LAST') {
+            if (insert[seqKey] === "SEQ_LAST") {
                 insert[seqKey] = await this._getLastSequenceValue(db, collection, seqKey);
             }
             else {
@@ -2232,7 +2390,9 @@ export class Mongo extends Db {
         return insert;
     }
     async _processSequenceFieldForMany(connection, dbName, collection, inserts) {
-        assert(this.client, "client is required", "_processSequenceFieldForMany", { collection });
+        assert(this.client, "client is required", "_processSequenceFieldForMany", {
+            collection,
+        });
         assert(connection, "connection is required", "_processSequenceFieldForMany", { collection });
         if (!(inserts === null || inserts === void 0 ? void 0 : inserts.length))
             return;
@@ -2240,7 +2400,7 @@ export class Mongo extends Db {
         let seqKeysSet = new Set();
         for (let insert of inserts) {
             let spec = this._findSequenceKeys(insert);
-            spec === null || spec === void 0 ? void 0 : spec.seqKeys.forEach(key => seqKeysSet.add(key));
+            spec === null || spec === void 0 ? void 0 : spec.seqKeys.forEach((key) => seqKeysSet.add(key));
         }
         let seqKeys = Array.from(seqKeysSet);
         if (!seqKeys.length)
@@ -2251,7 +2411,7 @@ export class Mongo extends Db {
             // Count SEQ_NEXT occurrences to reserve the range
             let seqNextCount = 0;
             for (const insert of inserts) {
-                if (insert[seqKey] === 'SEQ_NEXT')
+                if (insert[seqKey] === "SEQ_NEXT")
                     seqNextCount++;
             }
             // Get current value and reserve range for SEQ_NEXT if needed
@@ -2268,10 +2428,10 @@ export class Mongo extends Db {
             // Process inserts in order - SEQ_LAST gets current, SEQ_NEXT increments and gets new value
             for (const insert of inserts) {
                 const val = insert[seqKey];
-                if (val === 'SEQ_LAST') {
+                if (val === "SEQ_LAST") {
                     insert[seqKey] = currentValue;
                 }
-                else if (val === 'SEQ_NEXT') {
+                else if (val === "SEQ_NEXT") {
                     currentValue++;
                     insert[seqKey] = currentValue;
                 }
@@ -2282,9 +2442,13 @@ export class Mongo extends Db {
     _getFieldsRecursively(obj, into = []) {
         for (let key in obj) {
             const isDollarKey = startsWithDollar(key);
-            if (isDollarKey && typeof obj[key] === "object" && !Array.isArray(obj[key]))
+            if (isDollarKey &&
+                typeof obj[key] === "object" &&
+                !Array.isArray(obj[key]))
                 this._getFieldsRecursively(obj[key], into);
-            else if (!isDollarKey && typeof obj[key] === "object" && !Array.isArray(obj[key]))
+            else if (!isDollarKey &&
+                typeof obj[key] === "object" &&
+                !Array.isArray(obj[key]))
                 into.push(key);
             else if (!isDollarKey)
                 into.push(key);
@@ -2314,7 +2478,7 @@ export class Mongo extends Db {
         const out = {};
         const keys = this._getFieldsRecursively(inputUpdate);
         for (const k of keys) {
-            const bracketIdx = k.indexOf('[');
+            const bracketIdx = k.indexOf("[");
             if (bracketIdx < 0) {
                 out[k] = wholerecord[k];
                 continue;
@@ -2322,7 +2486,7 @@ export class Mongo extends Db {
             // Bracket path: publish the top-level parent field as a whole,
             // sliced from the post-update document. The "top-level parent" is
             // everything before the FIRST `.` or `[` separator.
-            const dotIdx = k.indexOf('.');
+            const dotIdx = k.indexOf(".");
             const cutAt = dotIdx >= 0 && dotIdx < bracketIdx ? dotIdx : bracketIdx;
             const topField = k.substring(0, cutAt);
             if (topField && !(topField in out))
@@ -2351,7 +2515,7 @@ export class Mongo extends Db {
         if (!this.auditing)
             return false;
         const fullName = ((db ? db + "." : "") + (col || "")).toLowerCase();
-        return this.auditedCollectionsLower.some(m => fullName.includes(m));
+        return this.auditedCollectionsLower.some((m) => fullName.includes(m));
     }
     async _publishAndAudit(operation, db, collection, dataToPublish, noEmit, rawUpdate) {
         if (!dataToPublish._id && !["deleteMany", "updateMany"].includes(operation))
@@ -2383,7 +2547,7 @@ export class Mongo extends Db {
             }
         }
         if (this._shouldAuditCollection(db, collection)) {
-            if (['insert', 'update', 'delete'].includes(operation))
+            if (["insert", "update", "delete"].includes(operation))
                 await this._writeAuditRecord(db, collection, operation, data);
         }
         return toPublishAll;
@@ -2411,11 +2575,11 @@ export class Mongo extends Db {
         const user = (_a = data === null || data === void 0 ? void 0 : data._auth) === null || _a === void 0 ? void 0 : _a.username;
         let toPublish;
         switch (operation) {
-            case 'insert':
+            case "insert":
                 toPublish = {
                     channel,
                     payload: {
-                        operation: 'insert',
+                        operation: "insert",
                         db,
                         collection,
                         _id: data._id,
@@ -2425,11 +2589,11 @@ export class Mongo extends Db {
                     },
                 };
                 break;
-            case 'update':
+            case "update":
                 toPublish = {
                     channel,
                     payload: {
-                        operation: 'update',
+                        operation: "update",
                         db,
                         collection,
                         _id: data._id,
@@ -2439,11 +2603,11 @@ export class Mongo extends Db {
                     },
                 };
                 break;
-            case 'delete':
+            case "delete":
                 toPublish = {
                     channel,
                     payload: {
-                        operation: 'delete',
+                        operation: "delete",
                         db,
                         collection,
                         _id: data._id,
@@ -2453,30 +2617,30 @@ export class Mongo extends Db {
                     },
                 };
                 break;
-            case 'updateMany':
+            case "updateMany":
                 toPublish = {
                     channel,
                     payload: {
-                        operation: 'updateMany',
+                        operation: "updateMany",
                         db,
                         collection,
                         enquireLastTs: true,
                     },
                 };
                 break;
-            case 'deleteMany':
+            case "deleteMany":
                 toPublish = {
                     channel,
                     payload: {
-                        operation: 'deleteMany',
+                        operation: "deleteMany",
                         db,
                         collection,
                         enquireLastTs: true,
                     },
                 };
                 break;
-            case 'batch':
-                throw new Error('batch operation should use direct emit, not _makeRevPublication');
+            case "batch":
+                throw new Error("batch operation should use direct emit, not _makeRevPublication");
         }
         if (user)
             toPublish.user = user;
@@ -2493,12 +2657,17 @@ export class Mongo extends Db {
         if (!this.auditing)
             return;
         let client = await this.connect();
-        let previousAuditRecords = await (await client.db(db).collection(this.auditCollectionName).aggregate([
+        let previousAuditRecords = await (await client
+            .db(db)
+            .collection(this.auditCollectionName)
+            .aggregate([
             { $match: { entityid: Mongo._toId(data._id) } },
             { $sort: { rev: -1 } },
-            { $limit: 1 }
+            { $limit: 1 },
         ], this.session ? { session: this.session } : {})).toArray();
-        let previousAuditRecord = previousAuditRecords.length ? previousAuditRecords[0] : { rev: 0, changes: {} };
+        let previousAuditRecord = previousAuditRecords.length
+            ? previousAuditRecords[0]
+            : { rev: 0, changes: {} };
         if (previousAuditRecords.length === 0)
             await this.createCollection(this.auditCollectionName);
         let dataNoId = { ...data };
@@ -2517,11 +2686,12 @@ export class Mongo extends Db {
             auditRecord.user = user;
         if (audit)
             auditRecord.audit = audit;
-        fjLog.trace('AUDITING', auditRecord);
-        let ret = await client.db(db)
+        fjLog.trace("AUDITING", auditRecord);
+        let ret = await client
+            .db(db)
             .collection(this.auditCollectionName)
             .insertOne(auditRecord, this._sessionOpt());
-        fjLog.debug('AUDITED', auditRecord, ret.insertedId);
+        fjLog.debug("AUDITED", auditRecord, ret.insertedId);
     }
     _sessionOpt() {
         return this.session ? { session: this.session } : {};
@@ -2552,7 +2722,7 @@ export class Mongo extends Db {
         return Object.keys(obj).some(startsWithHashedPrefix);
     }
     _hasSequenceFields(obj) {
-        return Object.values(obj).some(v => v === 'SEQ_NEXT' || v === 'SEQ_LAST');
+        return Object.values(obj).some((v) => v === "SEQ_NEXT" || v === "SEQ_LAST");
     }
     _processUpdateObject(update) {
         for (let k in update) {
@@ -2560,7 +2730,8 @@ export class Mongo extends Db {
             const keyStr = String(key);
             if (keyStr[0] === "$")
                 continue;
-            if (startsWithDoubleUnderscore(keyStr) && !keyStr.startsWith(HASHED_PREFIX)) {
+            if (startsWithDoubleUnderscore(keyStr) &&
+                !keyStr.startsWith(HASHED_PREFIX)) {
                 delete update[key];
                 continue;
             }
@@ -2568,7 +2739,7 @@ export class Mongo extends Db {
                 delete update[key];
                 continue;
             }
-            if (key === '' || key === null || key === undefined) {
+            if (key === "" || key === null || key === undefined) {
                 delete update[key];
                 continue;
             }
@@ -2586,12 +2757,14 @@ export class Mongo extends Db {
         if (this.revisions) {
             update.$inc = update.$inc || {};
             update.$inc._rev = 1;
-            const currentDate = update.$currentDate && typeof update.$currentDate === 'object' && !Array.isArray(update.$currentDate)
+            const currentDate = update.$currentDate &&
+                typeof update.$currentDate === "object" &&
+                !Array.isArray(update.$currentDate)
                 ? update.$currentDate
                 : undefined;
             update.$currentDate = {
                 ...(currentDate || {}),
-                _ts: { $type: 'timestamp' }
+                _ts: { $type: "timestamp" },
             };
         }
         if (update.$set) {
@@ -2631,35 +2804,41 @@ export class Mongo extends Db {
         const translatePath = (path) => {
             const tokens = Mongo._tokenizePath(path);
             const out = [];
-            let parentKey = '';
+            let parentKey = "";
             for (const t of tokens) {
-                if (t.length >= 2 && t.charCodeAt(0) === 91 /* [ */ && t.charCodeAt(t.length - 1) === 93 /* ] */) {
+                if (t.length >= 2 &&
+                    t.charCodeAt(0) === 91 /* [ */ &&
+                    t.charCodeAt(t.length - 1) === 93 /* ] */) {
                     const idStr = Mongo._unquoteBracketId(t, path);
                     const memoKey = `${parentKey}|${idStr}`;
                     let filterName = memo.get(memoKey);
                     if (filterName === undefined) {
                         filterName = `f${counter++}`;
                         memo.set(memoKey, filterName);
-                        filters.push({ [`${filterName}._id`]: Mongo._normalizeBracketId(idStr) });
+                        filters.push({
+                            [`${filterName}._id`]: Mongo._normalizeBracketId(idStr),
+                        });
                     }
                     out.push(`$[${filterName}]`);
-                    parentKey = parentKey ? `${parentKey}.$[${filterName}]` : `$[${filterName}]`;
+                    parentKey = parentKey
+                        ? `${parentKey}.$[${filterName}]`
+                        : `$[${filterName}]`;
                 }
                 else {
                     out.push(t);
                     parentKey = parentKey ? `${parentKey}.${t}` : t;
                 }
             }
-            return out.join('.');
+            return out.join(".");
         };
         const translateOp = (opName) => {
             const op = update[opName];
-            if (!op || typeof op !== 'object')
+            if (!op || typeof op !== "object")
                 return;
             // Fast path: skip rebuild if no bracket present.
             let hasBracket = false;
             for (const k of Object.keys(op)) {
-                if (k.indexOf('[') >= 0) {
+                if (k.indexOf("[") >= 0) {
                     hasBracket = true;
                     break;
                 }
@@ -2672,8 +2851,8 @@ export class Mongo extends Db {
             }
             update[opName] = translated;
         };
-        translateOp('$set');
-        translateOp('$unset');
+        translateOp("$set");
+        translateOp("$unset");
         return filters.length > 0 ? filters : undefined;
     }
     /**
@@ -2723,38 +2902,38 @@ export class Mongo extends Db {
         var _a;
         if (value === null || value === undefined)
             return false;
-        if (typeof value !== 'object')
+        if (typeof value !== "object")
             return false;
         if (value instanceof Date)
             return false;
         const ctorName = (_a = value.constructor) === null || _a === void 0 ? void 0 : _a.name;
-        if (ctorName === 'ObjectId' ||
-            ctorName === 'Timestamp' ||
-            ctorName === 'Decimal128' ||
-            ctorName === 'Binary' ||
-            ctorName === 'Long' ||
-            ctorName === 'Double' ||
-            ctorName === 'Int32')
+        if (ctorName === "ObjectId" ||
+            ctorName === "Timestamp" ||
+            ctorName === "Decimal128" ||
+            ctorName === "Binary" ||
+            ctorName === "Long" ||
+            ctorName === "Double" ||
+            ctorName === "Int32")
             return false;
         return true;
     }
     static _tokenizePath(path) {
         const out = [];
-        let buf = '';
+        let buf = "";
         for (let i = 0; i < path.length; i++) {
             const ch = path[i];
-            if (ch === '.') {
+            if (ch === ".") {
                 if (buf) {
                     out.push(buf);
-                    buf = '';
+                    buf = "";
                 }
             }
-            else if (ch === '[') {
+            else if (ch === "[") {
                 if (buf) {
                     out.push(buf);
-                    buf = '';
+                    buf = "";
                 }
-                const close = path.indexOf(']', i);
+                const close = path.indexOf("]", i);
                 if (close < 0) {
                     buf += ch;
                     continue;
@@ -2786,7 +2965,8 @@ export class Mongo extends Db {
         if (len >= 2) {
             const first = id.charCodeAt(0);
             const last = id.charCodeAt(len - 1);
-            if ((first === 39 /* ' */ && last === 39) || (first === 34 /* " */ && last === 34)) {
+            if ((first === 39 /* ' */ && last === 39) ||
+                (first === 34 /* " */ && last === 34)) {
                 id = id.slice(1, -1);
             }
         }
@@ -2818,11 +2998,11 @@ export class Mongo extends Db {
      */
     _validateAndAutoFillTerminalBracketValues(update) {
         const $set = update.$set;
-        if (!$set || typeof $set !== 'object')
+        if (!$set || typeof $set !== "object")
             return;
         let hasBracket = false;
         for (const k of Object.keys($set)) {
-            if (k.indexOf('[') >= 0) {
+            if (k.indexOf("[") >= 0) {
                 hasBracket = true;
                 break;
             }
@@ -2832,17 +3012,17 @@ export class Mongo extends Db {
         for (const path of Object.keys($set)) {
             const tokens = Mongo._tokenizePath(path);
             const lastToken = tokens[tokens.length - 1];
-            const isTerminalBracket = !!(lastToken
-                && lastToken.length >= 2
-                && lastToken.charCodeAt(0) === 91 /* [ */
-                && lastToken.charCodeAt(lastToken.length - 1) === 93 /* ] */);
+            const isTerminalBracket = !!((lastToken &&
+                lastToken.length >= 2 &&
+                lastToken.charCodeAt(0) === 91 /* [ */ &&
+                lastToken.charCodeAt(lastToken.length - 1) === 93) /* ] */);
             if (!isTerminalBracket)
                 continue;
             const bracketId = Mongo._unquoteBracketId(lastToken, path); // throws on empty
             const value = $set[path];
             const validateElement = (el, locator) => {
-                if (el == null || typeof el !== 'object') {
-                    throw new Error(`cry-db: bracket-id terminal at "${path}"${locator} — value must be an object with _id matching bracket id "${bracketId}" (got ${el === null ? 'null' : typeof el}).`);
+                if (el == null || typeof el !== "object") {
+                    throw new Error(`cry-db: bracket-id terminal at "${path}"${locator} — value must be an object with _id matching bracket id "${bracketId}" (got ${el === null ? "null" : typeof el}).`);
                 }
                 if (el._id == null) {
                     throw new Error(`cry-db: bracket-id terminal at "${path}"${locator} — element is missing _id. Set it explicitly to "${bracketId}" (auto-fill is no longer supported).`);
@@ -2855,8 +3035,10 @@ export class Mongo extends Db {
                 for (let i = 0; i < value.length; i++)
                     validateElement(value[i], ` [${i}]`);
             }
-            else if (value !== null && value !== undefined && typeof value === 'object') {
-                validateElement(value, '');
+            else if (value !== null &&
+                value !== undefined &&
+                typeof value === "object") {
+                validateElement(value, "");
             }
             // Primitives (string/number/boolean) — pass through to existing arrayFilters
             // path. Mongo would set the array element to the primitive, which is unusual
@@ -2887,12 +3069,12 @@ export class Mongo extends Db {
      */
     _extractArrayInserts(update) {
         const $set = update.$set;
-        if (!$set || typeof $set !== 'object')
+        if (!$set || typeof $set !== "object")
             return undefined;
         // Fast path: no bracket present in any key.
         let hasBracket = false;
         for (const k of Object.keys($set)) {
-            if (k.indexOf('[') >= 0) {
+            if (k.indexOf("[") >= 0) {
                 hasBracket = true;
                 break;
             }
@@ -2905,19 +3087,19 @@ export class Mongo extends Db {
             const value = $set[path];
             const tokens = Mongo._tokenizePath(path);
             const lastToken = tokens[tokens.length - 1];
-            const isTerminalBracket = !!(lastToken
-                && lastToken.length >= 2
-                && lastToken.charCodeAt(0) === 91 /* [ */
-                && lastToken.charCodeAt(lastToken.length - 1) === 93 /* ] */);
+            const isTerminalBracket = !!((lastToken &&
+                lastToken.length >= 2 &&
+                lastToken.charCodeAt(0) === 91 /* [ */ &&
+                lastToken.charCodeAt(lastToken.length - 1) === 93) /* ] */);
             if (isTerminalBracket && Array.isArray(value)) {
                 const parentTokens = tokens.slice(0, -1);
                 // Reject nested-bracket parent paths — combining $push semantics with
                 // arrayFilters-targeted parent is not cleanly expressible in mongo.
                 const parentHasBracket = parentTokens.some((t) => t.length > 0 && t.charCodeAt(0) === 91);
                 // Every element must have `_id` (required so we can dedupe before push).
-                const allElementsHaveId = value.every((e) => e && typeof e === 'object' && e._id != null);
+                const allElementsHaveId = value.every((e) => e && typeof e === "object" && e._id != null);
                 if (!parentHasBracket && allElementsHaveId && parentTokens.length > 0) {
-                    const fieldPath = parentTokens.join('.');
+                    const fieldPath = parentTokens.join(".");
                     const ids = value.map((e) => String(e._id));
                     inserts.push({ field: fieldPath, ids, elements: value });
                     continue;
@@ -2954,11 +3136,11 @@ export class Mongo extends Db {
      */
     _extractArrayRemoves(update) {
         const $unset = update.$unset;
-        if (!$unset || typeof $unset !== 'object')
+        if (!$unset || typeof $unset !== "object")
             return undefined;
         let hasBracket = false;
         for (const k of Object.keys($unset)) {
-            if (k.indexOf('[') >= 0) {
+            if (k.indexOf("[") >= 0) {
                 hasBracket = true;
                 break;
             }
@@ -2970,15 +3152,15 @@ export class Mongo extends Db {
         for (const path of Object.keys($unset)) {
             const tokens = Mongo._tokenizePath(path);
             const lastToken = tokens[tokens.length - 1];
-            const isTerminalBracket = !!(lastToken
-                && lastToken.length >= 2
-                && lastToken.charCodeAt(0) === 91 /* [ */
-                && lastToken.charCodeAt(lastToken.length - 1) === 93 /* ] */);
+            const isTerminalBracket = !!((lastToken &&
+                lastToken.length >= 2 &&
+                lastToken.charCodeAt(0) === 91 /* [ */ &&
+                lastToken.charCodeAt(lastToken.length - 1) === 93) /* ] */);
             if (isTerminalBracket) {
                 const parentTokens = tokens.slice(0, -1);
                 const parentHasBracket = parentTokens.some((t) => t.length > 0 && t.charCodeAt(0) === 91);
                 if (!parentHasBracket && parentTokens.length > 0) {
-                    const fieldPath = parentTokens.join('.');
+                    const fieldPath = parentTokens.join(".");
                     const id = Mongo._unquoteBracketId(lastToken, path);
                     if (!removesByField.has(fieldPath))
                         removesByField.set(fieldPath, []);
@@ -2993,7 +3175,10 @@ export class Mongo extends Db {
         update.$unset = remaining;
         if (Object.keys(remaining).length === 0)
             delete update.$unset;
-        return Array.from(removesByField.entries()).map(([field, ids]) => ({ field, ids }));
+        return Array.from(removesByField.entries()).map(([field, ids]) => ({
+            field,
+            ids,
+        }));
     }
     /**
      * Extracts SINGLE-bracket bracket-by-_id paths from `$set`/`$unset`, grouped
@@ -3029,11 +3214,11 @@ export class Mongo extends Db {
         };
         const processOp = (opName) => {
             const op = update[opName];
-            if (!op || typeof op !== 'object')
+            if (!op || typeof op !== "object")
                 return;
             let hasBracket = false;
             for (const k of Object.keys(op)) {
-                if (k.indexOf('[') >= 0) {
+                if (k.indexOf("[") >= 0) {
                     hasBracket = true;
                     break;
                 }
@@ -3048,18 +3233,20 @@ export class Mongo extends Db {
                 let bracketIdx = -1;
                 for (let i = 0; i < tokens.length; i++) {
                     const t = tokens[i];
-                    if (t.length >= 2 && t.charCodeAt(0) === 91 /* [ */ && t.charCodeAt(t.length - 1) === 93 /* ] */) {
+                    if (t.length >= 2 &&
+                        t.charCodeAt(0) === 91 /* [ */ &&
+                        t.charCodeAt(t.length - 1) === 93 /* ] */) {
                         bracketCount++;
                         bracketIdx = i;
                     }
                 }
                 if (bracketCount === 1 && bracketIdx > 0) {
-                    const parentField = tokens.slice(0, bracketIdx).join('.');
+                    const parentField = tokens.slice(0, bracketIdx).join(".");
                     const id = Mongo._unquoteBracketId(tokens[bracketIdx], path);
-                    const restPath = tokens.slice(bracketIdx + 1).join('.');
+                    const restPath = tokens.slice(bracketIdx + 1).join(".");
                     const elOps = ensureEntry(parentField, id);
-                    if (opName === '$set') {
-                        if (restPath === '') {
+                    if (opName === "$set") {
+                        if (restPath === "") {
                             // `arr[id]: <obj>` — whole-element replace.
                             elOps.replace = op[path];
                         }
@@ -3070,7 +3257,7 @@ export class Mongo extends Db {
                     else {
                         // `$unset arr[id].field` — sub-field unset. Terminal `$unset arr[id]`
                         // is already extracted by `_extractArrayRemoves`.
-                        if (restPath === '') {
+                        if (restPath === "") {
                             remaining[path] = op[path];
                             continue;
                         }
@@ -3088,8 +3275,8 @@ export class Mongo extends Db {
                     delete update[opName];
             }
         };
-        processOp('$set');
-        processOp('$unset');
+        processOp("$set");
+        processOp("$unset");
         return extractedAny ? result : undefined;
     }
     /**
@@ -3108,8 +3295,8 @@ export class Mongo extends Db {
         const filteredInput = {
             $filter: {
                 input: { $ifNull: [baseInputPath, []] },
-                as: 'el',
-                cond: { $not: { $in: ['$$el._id', dedupedRemoveIds] } },
+                as: "el",
+                cond: { $not: { $in: ["$$el._id", dedupedRemoveIds] } },
             },
         };
         const concatExpr = {
@@ -3120,15 +3307,15 @@ export class Mongo extends Db {
         const branches = [];
         for (const [id, elOps] of ops.elementOps.entries()) {
             branches.push({
-                case: { $eq: ['$$el._id', Mongo._normalizeBracketId(id)] },
-                then: Mongo._buildElementMergeExpr('$$el', elOps),
+                case: { $eq: ["$$el._id", Mongo._normalizeBracketId(id)] },
+                then: Mongo._buildElementMergeExpr("$$el", elOps),
             });
         }
         return {
             $map: {
                 input: concatExpr,
-                as: 'el',
-                in: { $switch: { branches, default: '$$el' } },
+                as: "el",
+                in: { $switch: { branches, default: "$$el" } },
             },
         };
     }
@@ -3211,13 +3398,13 @@ export class Mongo extends Db {
             return {
                 $let: {
                     vars: { replaced: replaceExpr },
-                    in: wrapWithNestedArrays('$$replaced', '$$replaced'),
+                    in: wrapWithNestedArrays("$$replaced", "$$replaced"),
                 },
             };
         }
         const root = { directs: {}, nested: {}, unsets: [] };
         const walkInsert = (path, isUnset, value) => {
-            const parts = path.split('.');
+            const parts = path.split(".");
             let node = root;
             for (let i = 0; i < parts.length - 1; i++) {
                 const key = parts[i];
@@ -3255,15 +3442,17 @@ export class Mongo extends Db {
                 overlay[k] = buildOverlay(sub, subPath);
             }
             // Merge sets/nested onto the existing object (or {} if absent).
-            let merged = { $mergeObjects: [{ $ifNull: [basePath, {}] }, overlay] };
+            let merged = {
+                $mergeObjects: [{ $ifNull: [basePath, {}] }, overlay],
+            };
             // Drop unset top-level keys at this level via kv-filter.
             if (node.unsets.length > 0) {
                 merged = {
                     $arrayToObject: {
                         $filter: {
                             input: { $objectToArray: merged },
-                            as: 'kv',
-                            cond: { $not: { $in: ['$$kv.k', node.unsets] } },
+                            as: "kv",
+                            cond: { $not: { $in: ["$$kv.k", node.unsets] } },
                         },
                     },
                 };
@@ -3273,11 +3462,11 @@ export class Mongo extends Db {
         // If a replace is also requested, treat replacement as the new base.
         // Wrap with `$let` since a literal object isn't addressable by string field path.
         if (hasReplace) {
-            const overlayExpr = buildOverlay(root, '$$replaced');
+            const overlayExpr = buildOverlay(root, "$$replaced");
             return {
                 $let: {
                     vars: { replaced: { $literal: ops.replace } },
-                    in: wrapWithNestedArrays(overlayExpr, '$$replaced'),
+                    in: wrapWithNestedArrays(overlayExpr, "$$replaced"),
                 },
             };
         }
@@ -3298,7 +3487,7 @@ export class Mongo extends Db {
     static _drainIncAndCurrentDateToPipelineStages(update) {
         const stages = [];
         const inc = update.$inc;
-        if (inc && typeof inc === 'object') {
+        if (inc && typeof inc === "object") {
             const setObj = {};
             for (const [k, v] of Object.entries(inc)) {
                 setObj[k] = { $add: [{ $ifNull: [`$${k}`, 0] }, v] };
@@ -3308,13 +3497,15 @@ export class Mongo extends Db {
             delete update.$inc;
         }
         const cd = update.$currentDate;
-        if (cd && typeof cd === 'object') {
+        if (cd && typeof cd === "object") {
             const setObj = {};
             for (const [k, spec] of Object.entries(cd)) {
                 let isTimestamp = false;
-                if (spec && typeof spec === 'object' && spec.$type === 'timestamp')
+                if (spec &&
+                    typeof spec === "object" &&
+                    spec.$type === "timestamp")
                     isTimestamp = true;
-                setObj[k] = isTimestamp ? '$$CLUSTER_TIME' : '$$NOW';
+                setObj[k] = isTimestamp ? "$$CLUSTER_TIME" : "$$NOW";
             }
             if (Object.keys(setObj).length > 0)
                 stages.push({ $set: setObj });
@@ -3370,14 +3561,18 @@ export class Mongo extends Db {
                     continue;
                 let bracketCount = 0;
                 for (const t of tokens) {
-                    if (t.length >= 2 && t.charCodeAt(0) === 91 && t.charCodeAt(t.length - 1) === 93) {
+                    if (t.length >= 2 &&
+                        t.charCodeAt(0) === 91 &&
+                        t.charCodeAt(t.length - 1) === 93) {
                         bracketCount++;
                     }
                 }
                 if (bracketCount < 2)
                     continue;
                 const last = tokens[tokens.length - 1];
-                if (last.length >= 2 && last.charCodeAt(0) === 91 && last.charCodeAt(last.length - 1) === 93) {
+                if (last.length >= 2 &&
+                    last.charCodeAt(0) === 91 &&
+                    last.charCodeAt(last.length - 1) === 93) {
                     return true;
                 }
             }
@@ -3385,13 +3580,51 @@ export class Mongo extends Db {
         };
         const $setEarlyForNested = update.$set;
         const $unsetEarlyForNested = update.$unset;
-        const hasNestedTerminal = hasNestedTerminalBracket($setEarlyForNested) || hasNestedTerminalBracket($unsetEarlyForNested);
+        const hasNestedTerminal = hasNestedTerminalBracket($setEarlyForNested) ||
+            hasNestedTerminalBracket($unsetEarlyForNested);
         // Pure sub-field updates only (no inserts, no removes, no nested-terminal) —
         // keep on legacy arrayFilters path (faster, smaller payload, doesn't fight
         // $inc/$currentDate). Nested sub-field paths like `arr[A].sub[B].field`
         // ARE supported via nested arrayFilters here.
         if (!inserts && !removes && !hasNestedTerminal) {
             const arrayFilters = this._extractArrayFilters(update);
+            // Detect conflict: bare-field `$set` with array value alongside a
+            // bracket-transformed sub-path on the same field (`postavke: [...]` +
+            // `postavke.$[f0].nbc`). MongoDB silently drops the sub-field update
+            // in this case — throw so the caller gets an error instead of data loss.
+            if (arrayFilters) {
+                // Collect bare-field array keys and sub-paths from BOTH
+                // $set AND $unset — $set.postavke conflicts with both
+                // $set.postavke.$[f0].nbc AND $unset.postavke.$[f0].nbc.
+                const $setCheck = update.$set;
+                const $unsetCheck = update.$unset;
+                const bareFields = [];
+                const subPaths = [];
+                if ($setCheck) {
+                    for (const k of Object.keys($setCheck)) {
+                        (k.includes(".") || k.includes("[") ? subPaths : bareFields).push(k);
+                    }
+                }
+                if ($unsetCheck) {
+                    for (const k of Object.keys($unsetCheck)) {
+                        (k.includes(".") || k.includes("[") ? subPaths : bareFields).push(k);
+                    }
+                }
+                for (const bare of bareFields) {
+                    // Only $set bare fields with array values cause conflicts.
+                    if ($setCheck && Array.isArray($setCheck[bare])) {
+                        for (const sub of subPaths) {
+                            if (sub.startsWith(bare + ".") || sub.startsWith(bare + "[")) {
+                                throw new Error(`cry-db: bare-field array replacement "${bare}" conflicts ` +
+                                    `with bracket-by-_id sub-field path "${sub}" on the same ` +
+                                    `array. Replace the bare-field assignment with a ` +
+                                    `terminal-bracket form (e.g. \`${bare}[<id>]: [...]\`) ` +
+                                    `when combining array updates with bracket-by-_id paths.`);
+                            }
+                        }
+                    }
+                }
+            }
             return arrayFilters ? { update, arrayFilters } : { update };
         }
         // Removes-only fast path: `$pull` on update doc. Coexists fine with `$set` on
@@ -3412,15 +3645,14 @@ export class Mongo extends Db {
             for (const k of Object.keys($setEarly)) {
                 if (k === field)
                     return true;
-                if (k.startsWith(field + '.'))
+                if (k.startsWith(field + "."))
                     return true;
-                if (k.startsWith(field + '['))
+                if (k.startsWith(field + "["))
                     return true;
             }
             return false;
         };
-        const removesOnlyNoSetConflict = removes && !inserts
-            && !removes.some(rm => setTargetsField(rm.field));
+        const removesOnlyNoSetConflict = removes && !inserts && !removes.some((rm) => setTargetsField(rm.field));
         if (removesOnlyNoSetConflict) {
             const pullOp = (update.$pull || {});
             for (const rm of removes) {
@@ -3465,12 +3697,20 @@ export class Mongo extends Db {
         const fieldOps = new Map();
         const ensureField = (container, field) => {
             if (!container.has(field))
-                container.set(field, { removeIds: [], insertElements: [], elementOps: new Map() });
+                container.set(field, {
+                    removeIds: [],
+                    insertElements: [],
+                    elementOps: new Map(),
+                });
             return container.get(field);
         };
         const ensureElement = (fops, id) => {
             if (!fops.elementOps.has(id))
-                fops.elementOps.set(id, { sets: {}, unsets: [], nestedArrayOps: new Map() });
+                fops.elementOps.set(id, {
+                    sets: {},
+                    unsets: [],
+                    nestedArrayOps: new Map(),
+                });
             const elOps = fops.elementOps.get(id);
             if (!elOps.nestedArrayOps)
                 elOps.nestedArrayOps = new Map();
@@ -3514,7 +3754,7 @@ export class Mongo extends Db {
                 return;
             const remaining = {};
             for (const path of Object.keys(op)) {
-                if (path.indexOf('[') < 0) {
+                if (path.indexOf("[") < 0) {
                     remaining[path] = op[path];
                     continue;
                 }
@@ -3522,14 +3762,16 @@ export class Mongo extends Db {
                 const brackets = [];
                 for (let i = 0; i < tokens.length; i++) {
                     const t = tokens[i];
-                    if (t.length >= 2 && t.charCodeAt(0) === 91 && t.charCodeAt(t.length - 1) === 93) {
+                    if (t.length >= 2 &&
+                        t.charCodeAt(0) === 91 &&
+                        t.charCodeAt(t.length - 1) === 93) {
                         brackets.push({ idx: i, id: Mongo._unquoteBracketId(t, path) });
                     }
                 }
                 if (brackets.length < 2) {
                     // Single-bracket: extractors above should have handled it; if it
                     // remained, it's malformed (e.g. empty parent). Drop with warning.
-                    warnings.push({ path, value: op[path], op: opName, kind: 'dropped' });
+                    warnings.push({ path, value: op[path], op: opName, kind: "dropped" });
                     continue;
                 }
                 // Walk all but the innermost bracket — descend through nestedArrayOps.
@@ -3538,7 +3780,7 @@ export class Mongo extends Db {
                 for (let bi = 0; bi < brackets.length - 1; bi++) {
                     const bracket = brackets[bi];
                     const fieldStart = bi === 0 ? 0 : brackets[bi - 1].idx + 1;
-                    const fieldName = tokens.slice(fieldStart, bracket.idx).join('.');
+                    const fieldName = tokens.slice(fieldStart, bracket.idx).join(".");
                     if (!fieldName) {
                         ok = false;
                         break;
@@ -3548,21 +3790,21 @@ export class Mongo extends Db {
                     currentMap = elOps.nestedArrayOps;
                 }
                 if (!ok) {
-                    warnings.push({ path, value: op[path], op: opName, kind: 'dropped' });
+                    warnings.push({ path, value: op[path], op: opName, kind: "dropped" });
                     continue;
                 }
                 const lastB = brackets[brackets.length - 1];
                 const fieldStart = brackets[brackets.length - 2].idx + 1;
-                const innerFieldName = tokens.slice(fieldStart, lastB.idx).join('.');
-                const restPath = tokens.slice(lastB.idx + 1).join('.');
+                const innerFieldName = tokens.slice(fieldStart, lastB.idx).join(".");
+                const restPath = tokens.slice(lastB.idx + 1).join(".");
                 if (!innerFieldName) {
-                    warnings.push({ path, value: op[path], op: opName, kind: 'dropped' });
+                    warnings.push({ path, value: op[path], op: opName, kind: "dropped" });
                     continue;
                 }
                 const innerFOps = ensureField(currentMap, innerFieldName);
                 const value = op[path];
-                if (opName === '$set') {
-                    if (restPath === '') {
+                if (opName === "$set") {
+                    if (restPath === "") {
                         if (Array.isArray(value)) {
                             innerFOps.removeIds.push(lastB.id);
                             innerFOps.insertElements.push(...value);
@@ -3580,7 +3822,7 @@ export class Mongo extends Db {
                 }
                 else {
                     // $unset
-                    if (restPath === '') {
+                    if (restPath === "") {
                         innerFOps.removeIds.push(lastB.id);
                     }
                     else {
@@ -3593,8 +3835,8 @@ export class Mongo extends Db {
             if (Object.keys(remaining).length === 0)
                 delete update[opName];
         };
-        processNestedPaths(update.$set, '$set');
-        processNestedPaths(update.$unset, '$unset');
+        processNestedPaths(update.$set, "$set");
+        processNestedPaths(update.$unset, "$unset");
         // Detect same-id overlap at NESTED levels: a "new base" (terminal-array
         // insert OR whole-element replace) targeting the same `_id` as a
         // sub-field set/unset on the same element. Both apply — new base goes
@@ -3614,7 +3856,7 @@ export class Mongo extends Db {
         const detectOverlaps = (container, parentPathRepr) => {
             for (const [field, fops] of container.entries()) {
                 const fullField = parentPathRepr ? `${parentPathRepr}.${field}` : field;
-                const isNested = parentPathRepr !== '';
+                const isNested = parentPathRepr !== "";
                 // Flavor 1: terminal-array insert + sub-field on same id.
                 const removeIdSet = new Set(fops.removeIds);
                 if (isNested) {
@@ -3622,16 +3864,16 @@ export class Mongo extends Db {
                         const elOps = fops.elementOps.get(id);
                         if (!elOps)
                             continue;
-                        const hasOps = Object.keys(elOps.sets).length > 0
-                            || elOps.unsets.length > 0
-                            || elOps.replace !== undefined;
+                        const hasOps = Object.keys(elOps.sets).length > 0 ||
+                            elOps.unsets.length > 0 ||
+                            elOps.replace !== undefined;
                         if (hasOps) {
                             const insertedEl = fops.insertElements.find((e) => String(e._id) === id);
                             warnings.push({
                                 path: `${fullField}[${id}]`,
                                 value: insertedEl,
-                                op: '$set',
-                                kind: 'overlap',
+                                op: "$set",
+                                kind: "overlap",
                             });
                         }
                     }
@@ -3641,14 +3883,13 @@ export class Mongo extends Db {
                 for (const [id, elOps] of fops.elementOps.entries()) {
                     if (isNested && !removeIdSet.has(id)) {
                         const hasReplace = elOps.replace !== undefined;
-                        const hasSetsOrUnsets = Object.keys(elOps.sets).length > 0
-                            || elOps.unsets.length > 0;
+                        const hasSetsOrUnsets = Object.keys(elOps.sets).length > 0 || elOps.unsets.length > 0;
                         if (hasReplace && hasSetsOrUnsets) {
                             warnings.push({
                                 path: `${fullField}[${id}]`,
                                 value: elOps.replace,
-                                op: '$set',
-                                kind: 'overlap',
+                                op: "$set",
+                                kind: "overlap",
                             });
                         }
                     }
@@ -3658,19 +3899,21 @@ export class Mongo extends Db {
                 }
             }
         };
-        detectOverlaps(fieldOps, '');
+        detectOverlaps(fieldOps, "");
         if (warnings.length > 0) {
-            fjLog.warn('cry-db: bracket-by-_id warnings:', warnings);
+            fjLog.warn("cry-db: bracket-by-_id warnings:", warnings);
         }
         if (update.$set && Object.keys(update.$set).length === 0)
             delete update.$set;
-        if (update.$unset && Object.keys(update.$unset).length === 0)
+        if (update.$unset &&
+            Object.keys(update.$unset).length === 0)
             delete update.$unset;
         const pipeline = [];
         if (update.$set && Object.keys(update.$set).length > 0) {
             pipeline.push({ $set: update.$set });
         }
-        if (update.$unset && Object.keys(update.$unset).length > 0) {
+        if (update.$unset &&
+            Object.keys(update.$unset).length > 0) {
             pipeline.push({ $unset: Object.keys(update.$unset) });
         }
         // Translate $inc / $currentDate so revisions (_rev/_ts) still update in pipeline form.
@@ -3686,7 +3929,9 @@ export class Mongo extends Db {
                 },
             });
         }
-        return warnings.length > 0 ? { update: pipeline, warnings } : { update: pipeline };
+        return warnings.length > 0
+            ? { update: pipeline, warnings }
+            : { update: pipeline };
     }
     async _processHashedKeys(obj) {
         const hashedKeys = Object.keys(obj).filter(startsWithHashedPrefix);
@@ -3742,10 +3987,10 @@ export class Mongo extends Db {
         }
         else {
             for (let key in ret) {
-                if (startsWithHashedPrefix(key)
-                    || startsWithDoubleUnderscore(key)
-                    || removeFields.has(key)
-                    || this._removeFieldsAlways.has(key))
+                if (startsWithHashedPrefix(key) ||
+                    startsWithDoubleUnderscore(key) ||
+                    removeFields.has(key) ||
+                    this._removeFieldsAlways.has(key))
                     delete ret[key];
             }
         }