@nullix/zod-mongoose-studio 1.0.13 → 2.0.0

package/.output/server/node_modules/mongoose/lib/model.js

@@ -21,6 +21,7 @@ const ValidationError = require('./error/validation');
 const VersionError = require('./error/version');
 const ParallelSaveError = require('./error/parallelSave');
 const applyDefaultsHelper = require('./helpers/document/applyDefaults');
+const isInPathsToSave = require('./helpers/document/isInPathsToSave');
 const applyDefaultsToPOJO = require('./helpers/model/applyDefaultsToPOJO');
 const applyEmbeddedDiscriminators = require('./helpers/discriminator/applyEmbeddedDiscriminators');
 const applyHooks = require('./helpers/model/applyHooks');
@@ -50,6 +51,7 @@ const immediate = require('./helpers/immediate');
 const internalToObjectOptions = require('./options').internalToObjectOptions;
 const isDefaultIdIndex = require('./helpers/indexes/isDefaultIdIndex');
 const isIndexEqual = require('./helpers/indexes/isIndexEqual');
+const isIndexSpecEqual = require('./helpers/indexes/isIndexSpecEqual');
 const isTimeseriesIndex = require('./helpers/indexes/isTimeseriesIndex');
 const {
   getRelatedDBIndexes,
@@ -59,10 +61,12 @@ const decorateDiscriminatorIndexOptions = require('./helpers/indexes/decorateDis
 const isPathSelectedInclusive = require('./helpers/projection/isPathSelectedInclusive');
 const leanPopulateMap = require('./helpers/populate/leanPopulateMap');
 const parallelLimit = require('./helpers/parallelLimit');
+const parseProjection = require('./helpers/projection/parseProjection');
 const prepareDiscriminatorPipeline = require('./helpers/aggregate/prepareDiscriminatorPipeline');
 const pushNestedArrayPaths = require('./helpers/model/pushNestedArrayPaths');
 const removeDeselectedForeignField = require('./helpers/populate/removeDeselectedForeignField');
 const setDottedPath = require('./helpers/path/setDottedPath');
+const { buildMiddlewareFilter } = require('./helpers/buildMiddlewareFilter');
 const util = require('util');
 const utils = require('./utils');
 const minimize = require('./helpers/minimize');
@@ -71,7 +75,11 @@ const ObjectExpectedError = require('./error/objectExpected');
 const decorateBulkWriteResult = require('./helpers/model/decorateBulkWriteResult');
 const modelCollectionSymbol = Symbol('mongoose#Model#collection');
 const modelDbSymbol = Symbol('mongoose#Model#db');
-const modelSymbol = require('./helpers/symbols').modelSymbol;
+const {
+  arrayAtomicsBackupSymbol,
+  arrayAtomicsSymbol,
+  modelSymbol
+} = require('./helpers/symbols');
 const subclassedSymbol = Symbol('mongoose#Model#subclassed');
 
 const { VERSION_INC, VERSION_WHERE, VERSION_ALL } = Document;
@@ -102,9 +110,11 @@ const saveToObjectOptions = Object.assign({}, internalToObjectOptions, {
  *     // You also use a model to create queries:
  *     const userFromDb = await UserModel.findOne({ name: 'Foo' });
  *
- * @param {Object} doc values for initial set
- * @param {Object} [fields] optional object containing the fields that were selected in the query which returned this document. You do **not** need to set this parameter to ensure Mongoose handles your [query projection](https://mongoosejs.com/docs/api/query.html#Query.prototype.select()).
- * @param {Boolean} [skipId=false] optional boolean. If true, mongoose doesn't add an `_id` field to the document.
+ * @param {object} doc values for initial set
+ * @param {object} [fields] optional object containing the fields that were selected in the query which returned this document. You do **not** need to set this parameter to ensure Mongoose handles your [query projection](https://mongoosejs.com/docs/api/query.html#Query.prototype.select()).
+ * @param {object} [options] optional object containing the options for the document.
+ * @param {boolean} [options.defaults=true] if `false`, skip applying default values to this document.
+ * @param {boolean} [options.skipId=false] By default, Mongoose document if one is not provided and the document's schema does not override Mongoose's default `_id`. Set `skipId` to `true` to skip this generation step.
  * @inherits Document https://mongoosejs.com/docs/api/document.html
  * @event `error`: If listening to this event, 'error' is emitted when a document was saved and an `error` occurred. If not listening, the event bubbles to the connection used to create this Model.
  * @event `index`: Emitted after `Model#ensureIndexes` completes. If an error occurred it is passed with the event.
@@ -113,7 +123,7 @@ const saveToObjectOptions = Object.assign({}, internalToObjectOptions, {
  * @api public
  */
 
-function Model(doc, fields, skipId) {
+function Model(doc, fields, options) {
   if (fields instanceof Schema) {
     throw new TypeError('2nd argument to `Model` constructor must be a POJO or string, ' +
       '**not** a schema. Make sure you\'re calling `mongoose.model()`, not ' +
@@ -124,7 +134,7 @@ function Model(doc, fields, skipId) {
       '**not** a string. Make sure you\'re calling `mongoose.model()`, not ' +
       '`mongoose.Model()`.');
   }
-  Document.call(this, doc, fields, skipId);
+  Document.call(this, doc, fields, options);
 }
 
 /**
@@ -173,14 +183,17 @@ Model.prototype.db;
  * If you use `useConnection()` to switch a model's connection, the model will still have the old connection's plugins.
  *
  * @function useConnection
- * @param [Connection] connection The new connection to use
- * @return [Model] this
+ * @param {Connection} connection The new connection to use
+ * @return {Model} this
  * @api public
  */
 
 Model.useConnection = function useConnection(connection) {
-  if (!connection) {
-    throw new Error('Please provide a connection.');
+  if (typeof connection?.model !== 'function' || typeof connection.collection !== 'function' || typeof connection.base?.version !== 'string') {
+    throw new MongooseError('`useConnection()` requires a Mongoose connection.');
+  }
+  if (this.db?.base?.version && this.db?.base?.version !== connection.base?.version) {
+    throw new MongooseError(`The connection passed to \`useConnection()\` has a different version of Mongoose (${connection.base?.version}) than the model you are using (${this.db?.base?.version}).`);
   }
   if (this.db) {
     delete this.db.models[this.modelName];
@@ -316,11 +329,10 @@ function _applyCustomWhere(doc, where) {
 /*!
  * ignore
  */
-
-Model.prototype.$__handleSave = function(options, callback) {
+function _createSaveOptions(doc, options) {
   const saveOptions = {};
 
-  applyWriteConcern(this.$__schema, options);
+  applyWriteConcern(doc.$__schema, options);
   if (typeof options.writeConcern !== 'undefined') {
     saveOptions.writeConcern = {};
     if ('w' in options.writeConcern) {
@@ -347,211 +359,223 @@ Model.prototype.$__handleSave = function(options, callback) {
     saveOptions.checkKeys = options.checkKeys;
   }
 
-  const session = this.$session();
-  const asyncLocalStorage = this[modelDbSymbol].base.transactionAsyncLocalStorage?.getStore();
+  const session = doc.$session();
+  const asyncLocalStorage = doc[modelDbSymbol].base.transactionAsyncLocalStorage?.getStore();
   if (session != null) {
     saveOptions.session = session;
   } else if (!Object.hasOwn(options, 'session') && asyncLocalStorage?.session != null) {
     // Only set session from asyncLocalStorage if `session` option wasn't originally passed in options
     saveOptions.session = asyncLocalStorage.session;
   }
-  if (this.$isNew) {
-    // send entire doc
-    const obj = this.toObject(saveToObjectOptions);
-    if ((obj || {})._id === void 0) {
-      // documents must have an _id else mongoose won't know
-      // what to update later if more changes are made. the user
-      // wouldn't know what _id was generated by mongodb either
-      // nor would the ObjectId generated by mongodb necessarily
-      // match the schema definition.
-      immediate(function() {
-        callback(new MongooseError('document must have an _id before saving'));
-      });
-      return;
-    }
 
-    this.$__version(true, obj);
-    this[modelCollectionSymbol].insertOne(obj, saveOptions).then(
-      ret => callback(null, ret),
-      err => {
-        _setIsNew(this, true);
+  return saveOptions;
+}
 
-        callback(err, null);
-      }
-    );
+/*!
+ * ignore
+ */
+
+Model.prototype.$__save = async function $__save(options) {
+  try {
+    const hasValidateBeforeSaveOption = options &&
+      (typeof options === 'object') &&
+      ('validateBeforeSave' in options);
+    const shouldValidateBeforeSave = hasValidateBeforeSaveOption ?
+      !!options.validateBeforeSave :
+      this.$__schema.options.validateBeforeSave;
+    if (shouldValidateBeforeSave) {
+      const hasValidateModifiedOnlyOption = options != null &&
+        typeof options === 'object' &&
+        Object.hasOwn(options, 'validateModifiedOnly');
+      const validateOptions = hasValidateModifiedOnlyOption ?
+        { validateModifiedOnly: options.validateModifiedOnly } :
+        null;
+      await this.$validate(validateOptions);
+      this.$op = 'save';
+    }
 
-    this.$__reset();
-    _setIsNew(this, false);
-    // Make it possible to retry the insert
-    this.$__.inserting = true;
+    await this._execDocumentPreHooks('save', options, [options]);
+  } catch (error) {
+    await this._execDocumentPostHooks('save', options, error);
     return;
   }
 
-  // Make sure we don't treat it as a new object on error,
-  // since it already exists
-  this.$__.inserting = false;
-  const delta = this.$__delta();
 
-  if (options.pathsToSave) {
-    for (const key in delta[1]['$set']) {
-      if (options.pathsToSave.includes(key)) {
-        continue;
-      } else if (options.pathsToSave.some(pathToSave => key.slice(0, pathToSave.length) === pathToSave && key.charAt(pathToSave.length) === '.')) {
-        continue;
-      } else {
-        delete delta[1]['$set'][key];
+  let result = null;
+  let where = null;
+  try {
+    const saveOptions = _createSaveOptions(this, options);
+
+    if (this.$isNew) {
+      // send entire doc
+      const obj = this.$__hasOnlyPrimitiveValues() ?
+        this.$__toObjectShallow() :
+        this.toObject(saveToObjectOptions);
+      if ((obj || {})._id === void 0) {
+        // documents must have an _id else mongoose won't know
+        // what to update later if more changes are made. the user
+        // wouldn't know what _id was generated by mongodb either
+        // nor would the ObjectId generated by mongodb necessarily
+        // match the schema definition.
+        throw new MongooseError('document must have an _id before saving');
       }
-    }
-  }
-  if (delta) {
-    if (delta instanceof MongooseError) {
-      callback(delta);
-      return;
-    }
 
-    const where = this.$__where(delta[0]);
-    if (where instanceof MongooseError) {
-      callback(where);
-      return;
-    }
-
-    _applyCustomWhere(this, where);
-
-    const update = delta[1];
-    if (this.$__schema.options.minimize) {
-      for (const updateOp of Object.values(update)) {
-        if (updateOp == null) {
-          continue;
-        }
-        for (const key of Object.keys(updateOp)) {
-          if (updateOp[key] == null || typeof updateOp[key] !== 'object') {
-            continue;
-          }
-          if (!utils.isPOJO(updateOp[key])) {
-            continue;
-          }
-          minimize(updateOp[key]);
-          if (Object.keys(updateOp[key]).length === 0) {
-            delete updateOp[key];
-            update.$unset = update.$unset || {};
-            update.$unset[key] = 1;
+      this.$__version(true, obj);
+      this.$__reset();
+      _setIsNew(this, false);
+      // Make it possible to retry the insert
+      this.$__.inserting = true;
+      result = await this[modelCollectionSymbol].insertOne(obj, saveOptions).catch(err => {
+        _setIsNew(this, true);
+        throw err;
+      });
+    } else {
+      // Make sure we don't treat it as a new object on error,
+      // since it already exists
+      this.$__.inserting = false;
+      const pathsToSave = Array.isArray(options.pathsToSave) ? options.pathsToSave : null;
+      const pathsToSaveSet = pathsToSave != null ? new Set(pathsToSave) : null;
+      const delta = this.$__delta(pathsToSave, pathsToSaveSet);
+      const unsavedDirty = pathsToSave != null ? (delta != null ? delta[2] : this.$__dirty()) : null;
+      const unsavedDefaultPaths = pathsToSave != null
+        ? Object.keys(this.$__.activePaths.getStatePaths('default')).filter(path => !isInPathsToSave(path, pathsToSaveSet, pathsToSave))
+        : null;
+
+      if (delta) {
+        where = this.$__where(delta[0]);
+        _applyCustomWhere(this, where);
+
+        const update = delta[1];
+        if (this.$__schema.options.minimize) {
+          for (const updateOp of Object.values(update)) {
+            if (updateOp == null) {
+              continue;
+            }
+            for (const key of Object.keys(updateOp)) {
+              if (updateOp[key] == null || typeof updateOp[key] !== 'object') {
+                continue;
+              }
+              if (!utils.isPOJO(updateOp[key])) {
+                continue;
+              }
+              minimize(updateOp[key]);
+              if (utils.hasOwnKeys(updateOp[key]) === false) {
+                delete updateOp[key];
+                update.$unset = update.$unset || {};
+                update.$unset[key] = 1;
+              }
+            }
           }
         }
-      }
-    }
 
-    this[modelCollectionSymbol].updateOne(where, update, saveOptions).then(
-      ret => {
-        if (ret == null) {
-          ret = { $where: where };
-        } else {
-          ret.$where = where;
+        // store the modified paths before the document is reset
+        this.$__.modifiedPaths = this.modifiedPaths();
+        this.$__reset();
+        restoreUnsavedState(this, unsavedDirty, unsavedDefaultPaths);
+
+        _setIsNew(this, false);
+        result = await this[modelCollectionSymbol].updateOne(where, update, saveOptions).catch(err => {
+          this.$__undoReset();
+          throw err;
+        });
+      } else {
+        where = this.$__where();
+        _applyCustomWhere(this, where);
+        if (this.$__.version) {
+          this.$__version(where, delta);
         }
-        callback(null, ret);
-      },
-      err => {
-        this.$__undoReset();
 
-        callback(err);
+        applyReadConcern(this.$__schema, saveOptions);
+        result = await this.constructor.collection.findOne(where, { ...saveOptions, projection: { _id: 1 } })
+          .then(documentExists => ({ matchedCount: !documentExists ? 0 : 1 }));
       }
-    );
-  } else {
-    handleEmptyUpdate.call(this);
+    }
+  } catch (err) {
+    const error = this.$__schema._transformDuplicateKeyError(err);
+    await this._execDocumentPostHooks('save', options, error);
     return;
   }
 
-  // store the modified paths before the document is reset in case we need to generate version error.
-  this.$__.modifiedPaths = this.modifiedPaths().concat(Object.keys(this.$__.activePaths.getStatePaths('default')));
-  this.$__reset();
-
-  _setIsNew(this, false);
+  let numAffected = 0;
+  const writeConcern = options != null ?
+    options.writeConcern != null ?
+      options.writeConcern.w :
+      options.w :
+    0;
+  if (writeConcern !== 0) {
+    // Skip checking if write succeeded if writeConcern is set to
+    // unacknowledged writes, because otherwise `numAffected` will always be 0
+    if (result != null) {
+      if (Array.isArray(result)) {
+        numAffected = result.length;
+      } else if (result.matchedCount != null) {
+        numAffected = result.matchedCount;
+      } else {
+        numAffected = result;
+      }
+    }
 
-  function handleEmptyUpdate() {
-    const optionsWithCustomValues = Object.assign({}, options, saveOptions);
-    const where = this.$__where();
-    const optimisticConcurrency = this.$__schema.options.optimisticConcurrency;
-    if (optimisticConcurrency && !Array.isArray(optimisticConcurrency)) {
+    const versionBump = this.$__.version;
+    // was this an update that required a version bump?
+    if (versionBump && !this.$__.inserting) {
+      const doIncrement = VERSION_INC === (VERSION_INC & this.$__.version);
+      this.$__.version = undefined;
       const key = this.$__schema.options.versionKey;
-      const val = this.$__getValue(key);
-      if (val != null) {
-        where[key] = val;
+      const version = this.$__getValue(key) || 0;
+      if (numAffected <= 0) {
+        // the update failed. pass an error back
+        this.$__undoReset();
+        const err = this.$__.$versionError ||
+          new VersionError(this, version, this.$__.modifiedPaths);
+        await this._execDocumentPostHooks('save', options, err);
+        return;
       }
-    }
 
-    applyReadConcern(this.$__schema, optionsWithCustomValues);
-    this.constructor.collection.findOne(where, optionsWithCustomValues)
-      .then(documentExists => {
-        const matchedCount = !documentExists ? 0 : 1;
-        callback(null, { $where: where, matchedCount });
-      })
-      .catch(callback);
+      // increment version if was successful
+      if (doIncrement) {
+        this.$__setValue(key, version + 1);
+      }
+    }
+    if (result != null && numAffected <= 0) {
+      this.$__undoReset();
+      const error = new DocumentNotFoundError(where, this.constructor.modelName, numAffected, result);
+      await this._execDocumentPostHooks('save', options, error);
+      return;
+    }
   }
+  this.$__.saving = undefined;
+  this.$__.savedState = {};
+  this.$emit('save', this, numAffected);
+  this.constructor.emit('save', this, numAffected);
+  await this._execDocumentPostHooks('save', options);
 };
 
 /*!
- * ignore
+ * Restores $__.activePaths state and any atomics for paths that failed
+ * to save.
+ *
+ * @param {Document} doc
+ * @param {object[]} unsavedDirty
+ * @param {string[]} unsavedDefaultPaths
  */
 
-Model.prototype.$__save = function(options, callback) {
-  this.$__handleSave(options, (error, result) => {
-    if (error) {
-      error = this.$__schema._transformDuplicateKeyError(error);
-      const hooks = this.$__schema.s.hooks;
-      return hooks.execPost('save:error', this, [this], { error: error }, (error) => {
-        callback(error, this);
-      });
-    }
-    let numAffected = 0;
-    const writeConcern = options != null ?
-      options.writeConcern != null ?
-        options.writeConcern.w :
-        options.w :
-      0;
-    if (writeConcern !== 0) {
-      // Skip checking if write succeeded if writeConcern is set to
-      // unacknowledged writes, because otherwise `numAffected` will always be 0
-      if (result != null) {
-        if (Array.isArray(result)) {
-          numAffected = result.length;
-        } else if (result.matchedCount != null) {
-          numAffected = result.matchedCount;
-        } else {
-          numAffected = result;
-        }
-      }
-
-      const versionBump = this.$__.version;
-      // was this an update that required a version bump?
-      if (versionBump && !this.$__.inserting) {
-        if (numAffected <= 0) {
-          const key = this.$__schema.options.versionKey;
-          const version = this.$__getValue(key) || 0;
-          // the update failed. pass an error back
-          this.$__undoReset();
-          const err = this.$__.$versionError ||
-            new VersionError(this, version, this.$__.modifiedPaths);
-          return callback(err, this);
-        }
+function restoreUnsavedState(doc, unsavedDirty, unsavedDefaultPaths) {
+  if (unsavedDirty == null) {
+    return;
+  }
 
-        this._applyVersionIncrement();
-      }
-      if (result != null && numAffected <= 0) {
-        this.$__undoReset();
-        error = new DocumentNotFoundError(result.$where,
-          this.constructor.modelName, numAffected, result);
-        const hooks = this.$__schema.s.hooks;
-        return hooks.execPost('save:error', this, [this], { error: error }, (error) => {
-          callback(error, this);
-        });
-      }
+  for (const dirty of unsavedDirty) {
+    doc.$__.activePaths.modify(dirty.path);
+    if (dirty.value?.[arrayAtomicsBackupSymbol]) {
+      dirty.value[arrayAtomicsSymbol] = dirty.value[arrayAtomicsBackupSymbol];
+      dirty.value[arrayAtomicsBackupSymbol] = null;
     }
-    this.$__.saving = undefined;
-    this.$__.savedState = {};
-    this.$emit('save', this, numAffected);
-    this.constructor.emit('save', this, numAffected);
-    callback(null, this);
-  });
-};
+  }
+
+  for (const path of unsavedDefaultPaths) {
+    doc.$__.activePaths.default(path);
+  }
+}
 
 /*!
  * ignore
@@ -583,17 +607,20 @@ function generateVersionError(doc, modifiedPaths, defaultPaths) {
  *     const newProduct = await product.save();
  *     newProduct === product; // true
  *
- * @param {Object} [options] options optional options
+ * @param {object} [options] options optional options
  * @param {Session} [options.session=null] the [session](https://www.mongodb.com/docs/manual/reference/server-sessions/) associated with this save operation. If not specified, defaults to the [document's associated session](https://mongoosejs.com/docs/api/document.html#Document.prototype.session()).
- * @param {Object} [options.safe] (DEPRECATED) overrides [schema's safe option](https://mongoosejs.com/docs/guide.html#safe). Use the `w` option instead.
- * @param {Boolean} [options.validateBeforeSave] set to false to save without validating.
- * @param {Boolean} [options.validateModifiedOnly=false] if `true`, Mongoose will only validate modified paths, as opposed to modified paths and `required` paths.
- * @param {Number|String} [options.w] set the [write concern](https://www.mongodb.com/docs/manual/reference/write-concern/#w-option). Overrides the [schema-level `writeConcern` option](https://mongoosejs.com/docs/guide.html#writeConcern)
- * @param {Boolean} [options.j] set to true for MongoDB to wait until this `save()` has been [journaled before resolving the returned promise](https://www.mongodb.com/docs/manual/reference/write-concern/#j-option). Overrides the [schema-level `writeConcern` option](https://mongoosejs.com/docs/guide.html#writeConcern)
- * @param {Number} [options.wtimeout] sets a [timeout for the write concern](https://www.mongodb.com/docs/manual/reference/write-concern/#wtimeout). Overrides the [schema-level `writeConcern` option](https://mongoosejs.com/docs/guide.html#writeConcern).
- * @param {Boolean} [options.checkKeys=true] the MongoDB driver prevents you from saving keys that start with '$' or contain '.' by default. Set this option to `false` to skip that check. See [restrictions on field names](https://docs.mongodb.com/manual/reference/limits/#mongodb-limit-Restrictions-on-Field-Names)
- * @param {Boolean} [options.timestamps=true] if `false` and [timestamps](https://mongoosejs.com/docs/guide.html#timestamps) are enabled, skip timestamps for this `save()`.
+ * @param {object} [options.safe] (DEPRECATED) overrides [schema's safe option](https://mongoosejs.com/docs/guide.html#safe). Use the `w` option instead.
+ * @param {boolean} [options.validateBeforeSave] set to false to save without validating.
+ * @param {boolean} [options.validateModifiedOnly=false] if `true`, Mongoose will only validate modified paths, as opposed to modified paths and `required` paths.
+ * @param {number|string} [options.w] set the [write concern](https://www.mongodb.com/docs/manual/reference/write-concern/#w-option). Overrides the [schema-level `writeConcern` option](https://mongoosejs.com/docs/guide.html#writeConcern)
+ * @param {boolean} [options.j] set to true for MongoDB to wait until this `save()` has been [journaled before resolving the returned promise](https://www.mongodb.com/docs/manual/reference/write-concern/#j-option). Overrides the [schema-level `writeConcern` option](https://mongoosejs.com/docs/guide.html#writeConcern)
+ * @param {number} [options.wtimeout] sets a [timeout for the write concern](https://www.mongodb.com/docs/manual/reference/write-concern/#wtimeout). Overrides the [schema-level `writeConcern` option](https://mongoosejs.com/docs/guide.html#writeConcern).
+ * @param {boolean} [options.checkKeys=true] the MongoDB driver prevents you from saving keys that start with '$' or contain '.' by default. Set this option to `false` to skip that check. See [restrictions on field names](https://docs.mongodb.com/manual/reference/limits/#mongodb-limit-Restrictions-on-Field-Names)
+ * @param {boolean} [options.timestamps=true] if `false` and [timestamps](https://mongoosejs.com/docs/guide.html#timestamps) are enabled, skip timestamps for this `save()`.
  * @param {Array} [options.pathsToSave] An array of paths that tell mongoose to only validate and save the paths in `pathsToSave`.
+ * @param {boolean|object} [options.middleware=true] set to `false` to skip all user-defined middleware
+ * @param {boolean} [options.middleware.pre=true] set to `false` to skip only pre hooks
+ * @param {boolean} [options.middleware.post=true] set to `false` to skip only post hooks
  * @throws {DocumentNotFoundError} if this [save updates an existing document](https://mongoosejs.com/docs/api/document.html#Document.prototype.isNew) but the document doesn't exist in the database. For example, you will get this error if the document is [deleted between when you retrieved the document and when you saved it](documents.html#updating).
  * @return {Promise}
  * @api public
@@ -611,7 +638,7 @@ Model.prototype.save = async function save(options) {
   if (this.$__.saving) {
     parallelSave = new ParallelSaveError(this);
   } else {
-    this.$__.saving = new ParallelSaveError(this);
+    this.$__.saving = true;
   }
 
   options = new SaveOptions(options);
@@ -621,11 +648,13 @@ Model.prototype.save = async function save(options) {
   if (this.$__.timestamps != null) {
     options.timestamps = this.$__.timestamps;
   }
-  this.$__.$versionError = generateVersionError(
-    this,
-    this.modifiedPaths(),
-    Object.keys(this.$__.activePaths.getStatePaths('default'))
-  );
+  if (!this.$isNew) {
+    this.$__.$versionError = generateVersionError(
+      this,
+      this.modifiedPaths(),
+      Object.keys(this.$__.activePaths.getStatePaths('default'))
+    );
+  }
 
   if (parallelSave) {
     this.$__handleReject(parallelSave);
@@ -634,20 +663,17 @@ Model.prototype.save = async function save(options) {
 
   this.$__.saveOptions = options;
 
-  await new Promise((resolve, reject) => {
-    this.$__save(options, error => {
-      this.$__.saving = null;
-      this.$__.saveOptions = null;
-      this.$__.$versionError = null;
-      this.$op = null;
-      if (error != null) {
-        this.$__handleReject(error);
-        return reject(error);
-      }
-
-      resolve();
-    });
-  });
+  try {
+    await this.$__save(options);
+  } catch (error) {
+    this.$__handleReject(error);
+    throw error;
+  } finally {
+    this.$__.saving = null;
+    this.$__.saveOptions = null;
+    this.$__.$versionError = null;
+    this.$op = null;
+  }
 
   return this;
 };
@@ -745,7 +771,7 @@ Model.prototype.$__where = function _where(where) {
   }
 
   if (this._doc._id === void 0) {
-    return new MongooseError('No _id found on document!');
+    throw new MongooseError('No _id found on document!');
   }
 
   return where;
@@ -786,9 +812,6 @@ Model.prototype.deleteOne = function deleteOne(options) {
 
   const self = this;
   const where = this.$__where();
-  if (where instanceof Error) {
-    throw where;
-  }
   const query = self.constructor.deleteOne();
 
   if (this.$session() != null) {
@@ -797,38 +820,37 @@ Model.prototype.deleteOne = function deleteOne(options) {
     }
   }
 
+  const preFilter = buildMiddlewareFilter(options, 'pre');
+  const postFilter = buildMiddlewareFilter(options, 'post');
+
   query.pre(async function queryPreDeleteOne() {
-    await new Promise((resolve, reject) => {
-      self.constructor._middleware.execPre('deleteOne', self, [self, options], err => {
-        query.deleteOne(where, options);
-        if (err) reject(err);
-        else resolve();
-      });
-    });
+    const res = await self.constructor._middleware.execPre('deleteOne', self, [self, options], { filter: preFilter });
+    // `self` is passed to pre hooks as argument for backwards compatibility, but that
+    // isn't the actual arguments passed to the wrapped function.
+    if (res[0] !== self || res[1] !== options) {
+      throw new MongooseError('Document deleteOne pre hooks cannot overwrite arguments');
+    }
+    query.deleteOne(where, options);
     // Apply custom where conditions _after_ document deleteOne middleware for
     // consistency with save() - sharding plugin needs to set $where
     if (self.$where != null) {
       this.where(self.$where);
     }
+    return res;
   });
-  query.pre(function callSubdocPreHooks(cb) {
-    each(self.$getAllSubdocs(), (subdoc, cb) => {
-      subdoc.constructor._middleware.execPre('deleteOne', subdoc, [subdoc, options], cb);
-    }, cb);
+  query.pre(function callSubdocPreHooks() {
+    return Promise.all(self.$getAllSubdocs().map(subdoc => subdoc.constructor._middleware.execPre('deleteOne', subdoc, [subdoc], { filter: preFilter })));
   });
-  query.pre(function skipIfAlreadyDeleted(cb) {
+  query.pre(function skipIfAlreadyDeleted() {
     if (self.$__.isDeleted) {
-      return cb(Kareem.skipWrappedFunction());
+      throw new Kareem.skipWrappedFunction();
     }
-    return cb();
   });
-  query.post(function callSubdocPostHooks(cb) {
-    each(self.$getAllSubdocs(), (subdoc, cb) => {
-      subdoc.constructor._middleware.execPost('deleteOne', subdoc, [subdoc], {}, cb);
-    }, cb);
+  query.post(function callSubdocPostHooks() {
+    return Promise.all(self.$getAllSubdocs().map(subdoc => subdoc.constructor._middleware.execPost('deleteOne', subdoc, [subdoc], { filter: postFilter })));
   });
-  query.post(function queryPostDeleteOne(cb) {
-    self.constructor._middleware.execPost('deleteOne', self, [self], {}, cb);
+  query.post(function queryPostDeleteOne() {
+    return self.constructor._middleware.execPost('deleteOne', self, [self], { filter: postFilter });
   });
   query.transform(function setIsDeleted(result) {
     if (result?.deletedCount > 0) {
@@ -850,7 +872,7 @@ Model.prototype.deleteOne = function deleteOne(options) {
  *     doc.$model() === Tank; // true
  *     await doc.$model('User').findById(id);
  *
- * @param {String} [name] model name
+ * @param {string} [name] model name
  * @method $model
  * @api public
  * @return {Model}
@@ -873,7 +895,7 @@ Model.prototype.$model = function $model(name) {
  *     doc.$model() === Tank; // true
  *     await doc.$model('User').findById(id);
  *
- * @param {String} [name] model name
+ * @param {string} [name] model name
  * @method model
  * @api public
  * @return {Model}
@@ -900,8 +922,8 @@ Model.prototype.model = Model.prototype.$model;
  *
  * - `findOne()`
  *
- * @param {Object} filter
- * @param {Object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
+ * @param {object} filter
+ * @param {object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
  * @return {Query}
  */
 
@@ -945,14 +967,14 @@ Model.exists = function exists(filter, options) {
  *     const Employee = Person.discriminator('Employee', employeeSchema, 'staff');
  *     new Employee().__t; // "staff" because of 3rd argument above
  *
- * @param {String} name discriminator model name
+ * @param {string} name discriminator model name
  * @param {Schema} schema discriminator model schema
- * @param {Object|String} [options] If string, same as `options.value`.
- * @param {String} [options.value] the string stored in the `discriminatorKey` property. If not specified, Mongoose uses the `name` parameter.
- * @param {Boolean} [options.clone=true] By default, `discriminator()` clones the given `schema`. Set to `false` to skip cloning.
- * @param {Boolean} [options.overwriteModels=false] by default, Mongoose does not allow you to define a discriminator with the same name as another discriminator. Set this to allow overwriting discriminators with the same name.
- * @param {Boolean} [options.mergeHooks=true] By default, Mongoose merges the base schema's hooks with the discriminator schema's hooks. Set this option to `false` to make Mongoose use the discriminator schema's hooks instead.
- * @param {Boolean} [options.mergePlugins=true] By default, Mongoose merges the base schema's plugins with the discriminator schema's plugins. Set this option to `false` to make Mongoose use the discriminator schema's plugins instead.
+ * @param {object|string} [options] If string, same as `options.value`.
+ * @param {string} [options.value] the string stored in the `discriminatorKey` property. If not specified, Mongoose uses the `name` parameter.
+ * @param {boolean} [options.clone=true] By default, `discriminator()` clones the given `schema`. Set to `false` to skip cloning.
+ * @param {boolean} [options.overwriteModels=false] by default, Mongoose does not allow you to define a discriminator with the same name as another discriminator. Set this to allow overwriting discriminators with the same name.
+ * @param {boolean} [options.mergeHooks=true] By default, Mongoose merges the base schema's hooks with the discriminator schema's hooks. Set this option to `false` to make Mongoose use the discriminator schema's hooks instead.
+ * @param {boolean} [options.mergePlugins=true] By default, Mongoose merges the base schema's plugins with the discriminator schema's plugins. Set this option to `false` to make Mongoose use the discriminator schema's plugins instead.
  * @return {Model} The newly created discriminator model
  * @api public
  */
@@ -1175,7 +1197,7 @@ Model.init = function init() {
  *     });
  *
  * @api public
- * @param {Object} [options] see [MongoDB driver docs](https://mongodb.github.io/node-mongodb-native/4.9/classes/Db.html#createCollection)
+ * @param {object} [options] see [MongoDB driver docs](https://mongodb.github.io/node-mongodb-native/7.0/classes/Db.html#createCollection)
  * @returns {Promise}
  */
 
@@ -1185,37 +1207,32 @@ Model.createCollection = async function createCollection(options) {
     throw new MongooseError('Model.createCollection() no longer accepts a callback');
   }
 
-  const shouldSkip = await new Promise((resolve, reject) => {
-    this.hooks.execPre('createCollection', this, [options], (err) => {
-      if (err != null) {
-        if (err instanceof Kareem.skipWrappedFunction) {
-          return resolve(true);
-        }
-        return reject(err);
-      }
-      resolve();
-    });
+  const preFilter = buildMiddlewareFilter(options, 'pre');
+  const postFilter = buildMiddlewareFilter(options, 'post');
+
+  // Remove middleware option before passing to MongoDB
+  if (options?.middleware != null) {
+    options = { ...options };
+    delete options.middleware;
+  }
+
+  [options] = await this.hooks.execPre('createCollection', this, [options], { filter: preFilter }).catch(err => {
+    if (err instanceof Kareem.skipWrappedFunction) {
+      return [err];
+    }
+    throw err;
   });
 
-  const collectionOptions = this &&
-    this.schema &&
-    this.schema.options &&
-    this.schema.options.collectionOptions;
+  const collectionOptions = this?.schema?.options?.collectionOptions;
   if (collectionOptions != null) {
     options = Object.assign({}, collectionOptions, options);
   }
 
-  const schemaCollation = this &&
-    this.schema &&
-    this.schema.options &&
-    this.schema.options.collation;
+  const schemaCollation = this?.schema?.options?.collation;
   if (schemaCollation != null) {
     options = Object.assign({ collation: schemaCollation }, options);
   }
-  const capped = this &&
-    this.schema &&
-    this.schema.options &&
-    this.schema.options.capped;
+  const capped = this?.schema?.options?.capped;
   if (capped != null) {
     if (typeof capped === 'number') {
       options = Object.assign({ capped: true, size: capped }, options);
@@ -1223,10 +1240,7 @@ Model.createCollection = async function createCollection(options) {
       options = Object.assign({ capped: true }, capped, options);
     }
   }
-  const timeseries = this &&
-    this.schema &&
-    this.schema.options &&
-    this.schema.options.timeseries;
+  const timeseries = this?.schema?.options?.timeseries;
   if (timeseries != null) {
     options = Object.assign({ timeseries }, options);
     if (options.expireAfterSeconds != null) {
@@ -1241,40 +1255,22 @@ Model.createCollection = async function createCollection(options) {
     }
   }
 
-  const clusteredIndex = this &&
-    this.schema &&
-    this.schema.options &&
-    this.schema.options.clusteredIndex;
+  const clusteredIndex = this?.schema?.options?.clusteredIndex;
   if (clusteredIndex != null) {
     options = Object.assign({ clusteredIndex: { ...clusteredIndex, unique: true } }, options);
   }
 
   try {
-    if (!shouldSkip) {
+    if (!(options instanceof Kareem.skipWrappedFunction)) {
       await this.db.createCollection(this.$__collection.collectionName, options);
     }
   } catch (err) {
     if (err != null && (err.name !== 'MongoServerError' || err.code !== 48)) {
-      await new Promise((resolve, reject) => {
-        const _opts = { error: err };
-        this.hooks.execPost('createCollection', this, [null], _opts, (err) => {
-          if (err != null) {
-            return reject(err);
-          }
-          resolve();
-        });
-      });
+      await this.hooks.execPost('createCollection', this, [null], { error: err, filter: postFilter });
     }
   }
 
-  await new Promise((resolve, reject) => {
-    this.hooks.execPost('createCollection', this, [this.$__collection], (err) => {
-      if (err != null) {
-        return reject(err);
-      }
-      resolve();
-    });
-  });
+  await this.hooks.execPost('createCollection', this, [this.$__collection], { filter: postFilter });
 
   return this.$__collection;
 };
@@ -1307,9 +1303,8 @@ Model.createCollection = async function createCollection(options) {
  *     toDrop; // Array of strings containing names of indexes that `syncIndexes()` will drop
  *     toCreate; // Array of strings containing names of indexes that `syncIndexes()` will create
  *
- * @param {Object} [options] options to pass to `ensureIndexes()`
- * @param {Boolean} [options.background=null] if specified, overrides each index's `background` property
- * @param {Boolean} [options.hideIndexes=false] set to `true` to hide indexes instead of dropping. Requires MongoDB server 4.4 or higher
+ * @param {object} [options] options to pass to `ensureIndexes()`
+ * @param {boolean} [options.hideIndexes=false] set to `true` to hide indexes instead of dropping. Requires MongoDB server 4.4 or higher
  * @return {Promise}
  * @api public
  */
@@ -1353,9 +1348,9 @@ Model.syncIndexes = async function syncIndexes(options) {
  *     const Customer = mongoose.model('Customer', schema);
  *     await Customer.createSearchIndex({ name: 'test', definition: { mappings: { dynamic: true } } });
  *
- * @param {Object} description index options, including `name` and `definition`
- * @param {String} description.name
- * @param {Object} description.definition
+ * @param {object} description index options, including `name` and `definition`
+ * @param {string} description.name
+ * @param {object} description.definition
  * @return {Promise}
  * @api public
  */
@@ -1376,8 +1371,8 @@ Model.createSearchIndex = async function createSearchIndex(description) {
  *     const Customer = mongoose.model('Customer', schema);
  *     await Customer.updateSearchIndex('test', { mappings: { dynamic: true } });
  *
- * @param {String} name
- * @param {Object} definition
+ * @param {string} name
+ * @param {object} definition
  * @return {Promise}
  * @api public
  */
@@ -1398,7 +1393,7 @@ Model.updateSearchIndex = async function updateSearchIndex(name, definition) {
  *     const Customer = mongoose.model('Customer', schema);
  *     await Customer.dropSearchIndex('test');
  *
- * @param {String} name
+ * @param {string} name
  * @return {Promise}
  * @api public
  */
@@ -1421,7 +1416,7 @@ Model.dropSearchIndex = async function dropSearchIndex(name) {
  *     await Customer.createSearchIndex({ name: 'test', definition: { mappings: { dynamic: true } } });
  *     const res = await Customer.listSearchIndexes(); // Includes `[{ name: 'test' }]`
  *
- * @param {Object} [options]
+ * @param {object} [options]
  * @return {Promise<Array>}
  * @api public
  */
@@ -1443,9 +1438,9 @@ Model.listSearchIndexes = async function listSearchIndexes(options) {
  *     toDrop; // Array of strings containing names of indexes that `syncIndexes()` will drop
  *     toCreate; // Array of index specs containing the keys of indexes that `syncIndexes()` will create
  *
- * @param {Object} [options]
- * @param {Boolean} [options.indexOptionsToCreate=false] If true, `toCreate` will include both the index spec and the index options, not just the index spec
- * @return {Promise<Object>} contains the indexes that would be dropped in MongoDB and indexes that would be created in MongoDB as `{ toDrop: string[], toCreate: string[] }`.
+ * @param {object} [options]
+ * @param {boolean} [options.indexOptionsToCreate=false] If true, `toCreate` will include both the index spec and the index options, not just the index spec
+ * @return {Promise<object>} contains the indexes that would be dropped in MongoDB and indexes that would be created in MongoDB as `{ toDrop: string[], toCreate: string[] }`.
  */
 
 Model.diffIndexes = async function diffIndexes(options) {
@@ -1548,10 +1543,10 @@ function getIndexesToDrop(schema, schemaIndexes, dbIndexes) {
  *
  * The returned promise resolves to a list of the dropped indexes' names as an array
  *
- * @param {Object} [options]
- * @param {Array<String>} [options.toDrop] if specified, contains a list of index names to drop
- * @param {Boolean} [options.hideIndexes=false] set to `true` to hide indexes instead of dropping. Requires MongoDB server 4.4 or higher
- * @return {Promise<Array<String>>} list of dropped or hidden index names
+ * @param {object} [options]
+ * @param {string[]} [options.toDrop] if specified, contains a list of index names to drop
+ * @param {boolean} [options.hideIndexes=false] set to `true` to hide indexes instead of dropping. Requires MongoDB server 4.4 or higher
+ * @return {Promise<string[]>} list of dropped or hidden index names
  * @api public
  */
 
@@ -1562,7 +1557,7 @@ Model.cleanIndexes = async function cleanIndexes(options) {
   }
   const model = this;
 
-  if (Array.isArray(options && options.toDrop)) {
+  if (Array.isArray(options?.toDrop)) {
     const res = await _dropIndexes(options.toDrop, model, options);
     return res;
   }
@@ -1577,7 +1572,7 @@ async function _dropIndexes(toDrop, model, options) {
   }
 
   const collection = model.$__collection;
-  if (options && options.hideIndexes) {
+  if (options?.hideIndexes) {
     await Promise.all(toDrop.map(indexName => {
       return model.db.db.command({
         collMod: collection.collectionName,
@@ -1637,7 +1632,7 @@ Model.listIndexes = async function listIndexes() {
  *
  * _NOTE: It is not recommended that you run this in production. Index creation may impact database performance depending on your load. Use with caution._
  *
- * @param {Object} [options] internal options
+ * @param {object} [options] internal options
  * @return {Promise}
  * @api public
  */
@@ -1659,10 +1654,10 @@ Model.ensureIndexes = async function ensureIndexes(options) {
 };
 
 /**
- * Similar to `ensureIndexes()`, except for it uses the [`createIndex`](https://mongodb.github.io/node-mongodb-native/4.9/classes/Db.html#createIndex)
+ * Similar to `ensureIndexes()`, except for it uses the [`createIndex`](https://mongodb.github.io/node-mongodb-native/7.0/classes/Db.html#createIndex)
  * function.
  *
- * @param {Object} [options] internal options
+ * @param {object} [options] internal options
  * @return {Promise}
  * @api public
  */
@@ -1704,14 +1699,32 @@ function _ensureIndexes(model, options, callback) {
     }
   }
 
+  // Check for duplicate index definitions (gh-15056)
+  const seenIndexes = [];
+  for (const index of indexes) {
+    const fields = index[0];
+    const indexOptions = index[1];
+    if (indexOptions.name == null) {
+      for (const existingIndex of seenIndexes) {
+        if (existingIndex[1].name == null && isIndexSpecEqual(existingIndex[0], fields)) {
+          utils.warn('mongoose: Duplicate schema index on ' + JSON.stringify(fields) +
+            ' for model "' + model.modelName + '". ' +
+            'This is often due to declaring an index using both "index: true" and "schema.index()". ' +
+            'Please remove the duplicate index definition.');
+          break;
+        }
+      }
+    }
+    seenIndexes.push(index);
+  }
+
   if (!indexes.length) {
     immediate(function() {
       done();
     });
     return;
   }
-  // Indexes are created one-by-one to support how MongoDB < 2.4 deals
-  // with background indexes.
+  // Indexes are created one-by-one
 
   const indexSingleDone = function(err, fields, options, name) {
     model.emit('index-single-done', err, fields, options, name);
@@ -1763,10 +1776,6 @@ function _ensureIndexes(model, options, callback) {
 
     indexSingleStart(indexFields, options);
 
-    if ('background' in options) {
-      indexOptions.background = options.background;
-    }
-
     // Just in case `createIndex()` throws a sync error
     let promise = null;
     try {
@@ -1912,9 +1921,9 @@ Model.discriminators;
  *
  * Only translate arguments of object type anything else is returned raw
  *
- * @param {Object} fields fields/conditions that may contain aliased keys
- * @param {Boolean} [errorOnDuplicates] if true, throw an error if there's both a key and an alias for that key in `fields`
- * @return {Object} the translated 'pure' fields/conditions
+ * @param {object} fields fields/conditions that may contain aliased keys
+ * @param {boolean} [errorOnDuplicates] if true, throw an error if there's both a key and an alias for that key in `fields`
+ * @return {object} the translated 'pure' fields/conditions
  */
 Model.translateAliases = function translateAliases(fields, errorOnDuplicates) {
   _checkContext(this, 'translateAliases');
@@ -1926,7 +1935,7 @@ Model.translateAliases = function translateAliases(fields, errorOnDuplicates) {
     let currentSchema = this.schema;
     for (const i in fieldKeys) {
       const name = fieldKeys[i];
-      if (currentSchema && currentSchema.aliases[name]) {
+      if (currentSchema?.aliases[name]) {
         alias = currentSchema.aliases[name];
         if (errorOnDuplicates && alias in fields) {
           throw new MongooseError(`Provided object has both field "${name}" and its alias "${alias}"`);
@@ -1940,7 +1949,7 @@ Model.translateAliases = function translateAliases(fields, errorOnDuplicates) {
       }
 
       // Check if aliased path is a schema
-      if (currentSchema && currentSchema.paths[alias]) {
+      if (currentSchema?.paths[alias]) {
         currentSchema = currentSchema.paths[alias].schema;
       }
       else
@@ -2010,9 +2019,9 @@ Model.translateAliases = function translateAliases(fields, errorOnDuplicates) {
  * This function triggers `deleteOne` query hooks. Read the
  * [middleware docs](https://mongoosejs.com/docs/middleware.html#naming) to learn more.
  *
- * @param {Object} conditions
- * @param {Object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
- * @param {Boolean} [options.translateAliases=null] If set to `true`, translates any schema-defined aliases in `filter`, `projection`, `update`, and `distinct`. Throws an error if there are any conflicts where both alias and raw property are defined on the same object.
+ * @param {object} conditions
+ * @param {object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
+ * @param {boolean} [options.translateAliases=null] If set to `true`, translates any schema-defined aliases in `filter`, `projection`, `update`, and `distinct`. Throws an error if there are any conflicts where both alias and raw property are defined on the same object.
  * @return {Query}
  * @api public
  */
@@ -2043,9 +2052,9 @@ Model.deleteOne = function deleteOne(conditions, options) {
  * This function triggers `deleteMany` query hooks. Read the
  * [middleware docs](https://mongoosejs.com/docs/middleware.html#naming) to learn more.
  *
- * @param {Object} conditions
- * @param {Object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
- * @param {Boolean} [options.translateAliases=null] If set to `true`, translates any schema-defined aliases in `filter`, `projection`, `update`, and `distinct`. Throws an error if there are any conflicts where both alias and raw property are defined on the same object.
+ * @param {object} conditions
+ * @param {object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
+ * @param {boolean} [options.translateAliases=null] If set to `true`, translates any schema-defined aliases in `filter`, `projection`, `update`, and `distinct`. Throws an error if there are any conflicts where both alias and raw property are defined on the same object.
  * @return {Query}
  * @api public
  */
@@ -2084,10 +2093,10 @@ Model.deleteMany = function deleteMany(conditions, options) {
  *     // passing options
  *     await MyModel.find({ name: /john/i }, null, { skip: 10 }).exec();
  *
- * @param {Object|ObjectId} filter
- * @param {Object|String|String[]} [projection] optional fields to return, see [`Query.prototype.select()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.select())
- * @param {Object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
- * @param {Boolean} [options.translateAliases=null] If set to `true`, translates any schema-defined aliases in `filter`, `projection`, `update`, and `distinct`. Throws an error if there are any conflicts where both alias and raw property are defined on the same object.
+ * @param {object|ObjectId} filter
+ * @param {object|string|string[]} [projection] optional fields to return, see [`Query.prototype.select()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.select())
+ * @param {object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
+ * @param {boolean} [options.translateAliases=null] If set to `true`, translates any schema-defined aliases in `filter`, `projection`, `update`, and `distinct`. Throws an error if there are any conflicts where both alias and raw property are defined on the same object.
  * @return {Query}
  * @see field selection https://mongoosejs.com/docs/api/query.html#Query.prototype.select()
  * @see query casting https://mongoosejs.com/docs/tutorials/query_casting.html
@@ -2124,9 +2133,9 @@ Model.find = function find(conditions, projection, options) {
  *     // select only the adventures name and length
  *     await Adventure.findById(id, 'name length').exec();
  *
- * @param {Any} id value of `_id` to query by
- * @param {Object|String|String[]} [projection] optional fields to return, see [`Query.prototype.select()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.select())
- * @param {Object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
+ * @param {any} id value of `_id` to query by
+ * @param {object|string|string[]} [projection] optional fields to return, see [`Query.prototype.select()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.select())
+ * @param {object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
  * @return {Query}
  * @see field selection https://mongoosejs.com/docs/api/query.html#Query.prototype.select()
  * @see lean queries https://mongoosejs.com/docs/tutorials/lean.html
@@ -2162,10 +2171,10 @@ Model.findById = function findById(id, projection, options) {
  *     // Select only the adventures name and length
  *     await Adventure.findOne({ country: 'Croatia' }, 'name length').exec();
  *
- * @param {Object} [conditions]
- * @param {Object|String|String[]} [projection] optional fields to return, see [`Query.prototype.select()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.select())
- * @param {Object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
- * @param {Boolean} [options.translateAliases=null] If set to `true`, translates any schema-defined aliases in `filter`, `projection`, `update`, and `distinct`. Throws an error if there are any conflicts where both alias and raw property are defined on the same object.
+ * @param {object} [conditions]
+ * @param {object|string|string[]} [projection] optional fields to return, see [`Query.prototype.select()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.select())
+ * @param {object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
+ * @param {boolean} [options.translateAliases=null] If set to `true`, translates any schema-defined aliases in `filter`, `projection`, `update`, and `distinct`. Throws an error if there are any conflicts where both alias and raw property are defined on the same object.
  * @return {Query}
  * @see field selection https://mongoosejs.com/docs/api/query.html#Query.prototype.select()
  * @see lean queries https://mongoosejs.com/docs/tutorials/lean.html
@@ -2195,7 +2204,7 @@ Model.findOne = function findOne(conditions, projection, options) {
  *
  *     const numAdventures = await Adventure.estimatedDocumentCount();
  *
- * @param {Object} [options]
+ * @param {object} [options]
  * @return {Query}
  * @api public
  */
@@ -2222,7 +2231,7 @@ Model.estimatedDocumentCount = function estimatedDocumentCount(options) {
  * a full collection scan and **not** use any indexes.
  *
  * The `countDocuments()` function is similar to `count()`, but there are a
- * [few operators that `countDocuments()` does not support](https://mongodb.github.io/node-mongodb-native/4.9/classes/Collection.html#countDocuments).
+ * [few operators that `countDocuments()` does not support](https://mongodb.github.io/node-mongodb-native/7.0/classes/Collection.html#countDocuments).
  * Below are the operators that `count()` supports but `countDocuments()` does not,
  * and the suggested replacement:
  *
@@ -2230,7 +2239,7 @@ Model.estimatedDocumentCount = function estimatedDocumentCount(options) {
  * - `$near`: [`$geoWithin`](https://www.mongodb.com/docs/manual/reference/operator/query/geoWithin/) with [`$center`](https://www.mongodb.com/docs/manual/reference/operator/query/center/#op._S_center)
  * - `$nearSphere`: [`$geoWithin`](https://www.mongodb.com/docs/manual/reference/operator/query/geoWithin/) with [`$centerSphere`](https://www.mongodb.com/docs/manual/reference/operator/query/centerSphere/#op._S_centerSphere)
  *
- * @param {Object} filter
+ * @param {object} filter
  * @return {Query}
  * @api public
  */
@@ -2258,9 +2267,9 @@ Model.countDocuments = function countDocuments(conditions, options) {
  *     const query = Link.distinct('url');
  *     query.exec();
  *
- * @param {String} field
- * @param {Object} [conditions] optional
- * @param {Object} [options] optional
+ * @param {string} field
+ * @param {object} [conditions] optional
+ * @param {object} [options] optional
  * @return {Query}
  * @api public
  */
@@ -2297,8 +2306,8 @@ Model.distinct = function distinct(field, conditions, options) {
  *     .where('name', /^b/i)
  *     ... etc
  *
- * @param {String} path
- * @param {Object} [val] optional value
+ * @param {string} path
+ * @param {object} [val] optional value
  * @return {Query}
  * @api public
  */
@@ -2316,9 +2325,9 @@ Model.where = function where(path, val) {
  *
  * Sometimes you need to query for things in mongodb using a JavaScript expression. You can do so via `find({ $where: javascript })`, or you can use the mongoose shortcut method $where via a Query chain or from your mongoose Model.
  *
- *     Blog.$where('this.username.indexOf("val") !== -1').exec(function (err, docs) {});
+ *     const result = await Blog.$where('this.username.indexOf("val") !== -1').exec();
  *
- * @param {String|Function} argument is a javascript string or anonymous function
+ * @param {string|Function} argument is a javascript string or anonymous function
  * @method $where
  * @memberOf Model
  * @return {Query}
@@ -2373,25 +2382,25 @@ Model.$where = function $where() {
  *     doc.name = 'jason bourne';
  *     await doc.save();
  *
- * @param {Object} [conditions]
- * @param {Object} [update]
- * @param {Object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
- * @param {String} [options.returnDocument='before'] Has two possible values, `'before'` and `'after'`. By default, it will return the document before the update was applied.
- * @param {Object} [options.lean] if truthy, mongoose will return the document as a plain JavaScript object rather than a mongoose document. See [`Query.lean()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.lean()) and [the Mongoose lean tutorial](https://mongoosejs.com/docs/tutorials/lean.html).
+ * @param {object} [conditions]
+ * @param {object} [update]
+ * @param {object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
+ * @param {'before'|'after'} [options.returnDocument='before'] Has two possible values, `'before'` and `'after'`. By default, it will return the document before the update was applied.
+ * @param {object} [options.lean] if truthy, mongoose will return the document as a plain JavaScript object rather than a mongoose document. See [`Query.lean()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.lean()) and [the Mongoose lean tutorial](https://mongoosejs.com/docs/tutorials/lean.html).
  * @param {ClientSession} [options.session=null] The session associated with this query. See [transactions docs](https://mongoosejs.com/docs/transactions.html).
- * @param {Boolean|String} [options.strict] overwrites the schema's [strict mode option](https://mongoosejs.com/docs/guide.html#strict)
- * @param {Boolean} [options.timestamps=null] If set to `false` and [schema-level timestamps](https://mongoosejs.com/docs/guide.html#timestamps) are enabled, skip timestamps for this update. Note that this allows you to overwrite timestamps. Does nothing if schema-level timestamps are not set.
- * @param {Boolean} [options.upsert=false] if true, and no documents found, insert a new document
- * @param {Object|String|String[]} [options.projection=null] optional fields to return, see [`Query.prototype.select()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.select())
- * @param {Boolean} [options.new=false] if true, return the modified document rather than the original
- * @param {Object|String} [options.fields] Field selection. Equivalent to `.select(fields).findOneAndUpdate()`
- * @param {Number} [options.maxTimeMS] puts a time limit on the query - requires mongodb >= 2.6.0
- * @param {Object|String} [options.sort] if multiple docs are found by the conditions, sets the sort order to choose which doc to update.
- * @param {Boolean} [options.runValidators] if true, runs [update validators](https://mongoosejs.com/docs/validation.html#update-validators) on this command. Update validators validate the update operation against the model's schema
- * @param {Boolean} [options.setDefaultsOnInsert=true] If `setDefaultsOnInsert` and `upsert` are true, mongoose will apply the [defaults](https://mongoosejs.com/docs/defaults.html) specified in the model's schema if a new document is created
- * @param {Boolean} [options.includeResultMetadata] if true, returns the [raw result from the MongoDB driver](https://mongodb.github.io/node-mongodb-native/4.9/interfaces/ModifyResult.html)
- * @param {Boolean} [options.translateAliases=null] If set to `true`, translates any schema-defined aliases in `filter`, `projection`, `update`, and `distinct`. Throws an error if there are any conflicts where both alias and raw property are defined on the same object.
- * @param {Boolean} [options.overwriteDiscriminatorKey=false] Mongoose removes discriminator key updates from `update` by default, set `overwriteDiscriminatorKey` to `true` to allow updating the discriminator key
+ * @param {boolean|'throw'} [options.strict] overwrites the schema's [strict mode option](https://mongoosejs.com/docs/guide.html#strict)
+ * @param {boolean} [options.timestamps=null] If set to `false` and [schema-level timestamps](https://mongoosejs.com/docs/guide.html#timestamps) are enabled, skip timestamps for this update. Note that this allows you to overwrite timestamps. Does nothing if schema-level timestamps are not set.
+ * @param {boolean} [options.upsert=false] if true, and no documents found, insert a new document
+ * @param {object|string|string[]} [options.projection=null] optional fields to return, see [`Query.prototype.select()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.select())
+ * @param {boolean} [options.new=false] if true, return the modified document rather than the original
+ * @param {object|string} [options.fields] Field selection. Equivalent to `.select(fields).findOneAndUpdate()`
+ * @param {number} [options.maxTimeMS] puts a time limit on the query - requires mongodb >= 2.6.0
+ * @param {object|string} [options.sort] if multiple docs are found by the conditions, sets the sort order to choose which doc to update.
+ * @param {boolean} [options.runValidators] if true, runs [update validators](https://mongoosejs.com/docs/validation.html#update-validators) on this command. Update validators validate the update operation against the model's schema
+ * @param {boolean} [options.setDefaultsOnInsert=true] If `setDefaultsOnInsert` and `upsert` are true, mongoose will apply the [defaults](https://mongoosejs.com/docs/defaults.html) specified in the model's schema if a new document is created
+ * @param {boolean} [options.includeResultMetadata] if true, returns the [raw result from the MongoDB driver](https://mongodb.github.io/node-mongodb-native/7.0/interfaces/ModifyResult.html)
+ * @param {boolean} [options.translateAliases=null] If set to `true`, translates any schema-defined aliases in `filter`, `projection`, `update`, and `distinct`. Throws an error if there are any conflicts where both alias and raw property are defined on the same object.
+ * @param {boolean} [options.overwriteDiscriminatorKey=false] Mongoose removes discriminator key updates from `update` by default, set `overwriteDiscriminatorKey` to `true` to allow updating the discriminator key
  * @return {Query}
  * @see Tutorial https://mongoosejs.com/docs/tutorials/findoneandupdate.html
  * @see mongodb https://www.mongodb.com/docs/manual/reference/command/findAndModify/
@@ -2409,13 +2418,6 @@ Model.findOneAndUpdate = function(conditions, update, options) {
     fields = options.fields || options.projection;
   }
 
-  update = clone(update, {
-    depopulate: true,
-    _isNested: true
-  });
-
-  decorateUpdateWithVersionKey(update, options, this.schema.options.versionKey);
-
   const mq = new this.Query({}, {}, this, this.$__collection);
   mq.select(fields);
 
@@ -2462,23 +2464,23 @@ Model.findOneAndUpdate = function(conditions, update, options) {
  *     doc.name = 'jason bourne';
  *     await doc.save();
  *
- * @param {Object|Number|String} id value of `_id` to query by
- * @param {Object} [update]
- * @param {Object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
- * @param {String} [options.returnDocument='before'] Has two possible values, `'before'` and `'after'`. By default, it will return the document before the update was applied.
- * @param {Object} [options.lean] if truthy, mongoose will return the document as a plain JavaScript object rather than a mongoose document. See [`Query.lean()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.lean()) and [the Mongoose lean tutorial](https://mongoosejs.com/docs/tutorials/lean.html).
+ * @param {object|number|string} id value of `_id` to query by
+ * @param {object} [update]
+ * @param {object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
+ * @param {'before'|'after'} [options.returnDocument='before'] Has two possible values, `'before'` and `'after'`. By default, it will return the document before the update was applied.
+ * @param {object} [options.lean] if truthy, mongoose will return the document as a plain JavaScript object rather than a mongoose document. See [`Query.lean()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.lean()) and [the Mongoose lean tutorial](https://mongoosejs.com/docs/tutorials/lean.html).
  * @param {ClientSession} [options.session=null] The session associated with this query. See [transactions docs](https://mongoosejs.com/docs/transactions.html).
- * @param {Boolean|String} [options.strict] overwrites the schema's [strict mode option](https://mongoosejs.com/docs/guide.html#strict)
- * @param {Boolean} [options.timestamps=null] If set to `false` and [schema-level timestamps](https://mongoosejs.com/docs/guide.html#timestamps) are enabled, skip timestamps for this update. Note that this allows you to overwrite timestamps. Does nothing if schema-level timestamps are not set.
- * @param {Object|String} [options.sort] if multiple docs are found by the conditions, sets the sort order to choose which doc to update.
- * @param {Boolean} [options.runValidators] if true, runs [update validators](https://mongoosejs.com/docs/validation.html#update-validators) on this command. Update validators validate the update operation against the model's schema
- * @param {Boolean} [options.setDefaultsOnInsert=true] If `setDefaultsOnInsert` and `upsert` are true, mongoose will apply the [defaults](https://mongoosejs.com/docs/defaults.html) specified in the model's schema if a new document is created
- * @param {Boolean} [options.includeResultMetadata] if true, returns the full [ModifyResult from the MongoDB driver](https://mongodb.github.io/node-mongodb-native/4.9/interfaces/ModifyResult.html) rather than just the document
- * @param {Boolean} [options.upsert=false] if true, and no documents found, insert a new document
- * @param {Boolean} [options.new=false] if true, return the modified document rather than the original
- * @param {Object|String} [options.select] sets the document fields to return.
- * @param {Boolean} [options.translateAliases=null] If set to `true`, translates any schema-defined aliases in `filter`, `projection`, `update`, and `distinct`. Throws an error if there are any conflicts where both alias and raw property are defined on the same object.
- * @param {Boolean} [options.overwriteDiscriminatorKey=false] Mongoose removes discriminator key updates from `update` by default, set `overwriteDiscriminatorKey` to `true` to allow updating the discriminator key
+ * @param {boolean|'throw'} [options.strict] overwrites the schema's [strict mode option](https://mongoosejs.com/docs/guide.html#strict)
+ * @param {boolean} [options.timestamps=null] If set to `false` and [schema-level timestamps](https://mongoosejs.com/docs/guide.html#timestamps) are enabled, skip timestamps for this update. Note that this allows you to overwrite timestamps. Does nothing if schema-level timestamps are not set.
+ * @param {object|string} [options.sort] if multiple docs are found by the conditions, sets the sort order to choose which doc to update.
+ * @param {boolean} [options.runValidators] if true, runs [update validators](https://mongoosejs.com/docs/validation.html#update-validators) on this command. Update validators validate the update operation against the model's schema
+ * @param {boolean} [options.setDefaultsOnInsert=true] If `setDefaultsOnInsert` and `upsert` are true, mongoose will apply the [defaults](https://mongoosejs.com/docs/defaults.html) specified in the model's schema if a new document is created
+ * @param {boolean} [options.includeResultMetadata] if true, returns the full [ModifyResult from the MongoDB driver](https://mongodb.github.io/node-mongodb-native/7.0/interfaces/ModifyResult.html) rather than just the document
+ * @param {boolean} [options.upsert=false] if true, and no documents found, insert a new document
+ * @param {boolean} [options.new=false] if true, return the modified document rather than the original
+ * @param {object|string} [options.select] sets the document fields to return.
+ * @param {boolean} [options.translateAliases=null] If set to `true`, translates any schema-defined aliases in `filter`, `projection`, `update`, and `distinct`. Throws an error if there are any conflicts where both alias and raw property are defined on the same object.
+ * @param {boolean} [options.overwriteDiscriminatorKey=false] Mongoose removes discriminator key updates from `update` by default, set `overwriteDiscriminatorKey` to `true` to allow updating the discriminator key
  * @return {Query}
  * @see Model.findOneAndUpdate https://mongoosejs.com/docs/api/model.html#Model.findOneAndUpdate()
  * @see mongodb https://www.mongodb.com/docs/manual/reference/command/findAndModify/
@@ -2524,16 +2526,16 @@ Model.findByIdAndUpdate = function(id, update, options) {
  *     doc.name = 'jason bourne';
  *     await doc.save();
  *
- * @param {Object} conditions
- * @param {Object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
- * @param {Boolean|String} [options.strict] overwrites the schema's [strict mode option](https://mongoosejs.com/docs/guide.html#strict)
- * @param {Object|String|String[]} [options.projection=null] optional fields to return, see [`Query.prototype.select()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.select())
+ * @param {object} conditions
+ * @param {object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
+ * @param {boolean|'throw'} [options.strict] overwrites the schema's [strict mode option](https://mongoosejs.com/docs/guide.html#strict)
+ * @param {object|string|string[]} [options.projection=null] optional fields to return, see [`Query.prototype.select()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.select())
  * @param {ClientSession} [options.session=null] The session associated with this query. See [transactions docs](https://mongoosejs.com/docs/transactions.html).
- * @param {Boolean} [options.includeResultMetadata] if true, returns the full [ModifyResult from the MongoDB driver](https://mongodb.github.io/node-mongodb-native/4.9/interfaces/ModifyResult.html) rather than just the document
- * @param {Object|String} [options.sort] if multiple docs are found by the conditions, sets the sort order to choose which doc to update.
- * @param {Object|String} [options.select] sets the document fields to return.
- * @param {Number} [options.maxTimeMS] puts a time limit on the query - requires mongodb >= 2.6.0
- * @param {Boolean} [options.translateAliases=null] If set to `true`, translates any schema-defined aliases in `filter`, `projection`, `update`, and `distinct`. Throws an error if there are any conflicts where both alias and raw property are defined on the same object.
+ * @param {boolean} [options.includeResultMetadata] if true, returns the full [ModifyResult from the MongoDB driver](https://mongodb.github.io/node-mongodb-native/7.0/interfaces/ModifyResult.html) rather than just the document
+ * @param {object|string} [options.sort] if multiple docs are found by the conditions, sets the sort order to choose which doc to update.
+ * @param {object|string} [options.select] sets the document fields to return.
+ * @param {number} [options.maxTimeMS] puts a time limit on the query - requires mongodb >= 2.6.0
+ * @param {boolean} [options.translateAliases=null] If set to `true`, translates any schema-defined aliases in `filter`, `projection`, `update`, and `distinct`. Throws an error if there are any conflicts where both alias and raw property are defined on the same object.
  * @return {Query}
  * @api public
  */
@@ -2566,10 +2568,10 @@ Model.findOneAndDelete = function(conditions, options) {
  *
  * - `findOneAndDelete()`
  *
- * @param {Object|Number|String} id value of `_id` to query by
- * @param {Object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
- * @param {Boolean|String} [options.strict] overwrites the schema's [strict mode option](https://mongoosejs.com/docs/guide.html#strict)
- * @param {Boolean} [options.translateAliases=null] If set to `true`, translates any schema-defined aliases in `filter`, `projection`, `update`, and `distinct`. Throws an error if there are any conflicts where both alias and raw property are defined on the same object.
+ * @param {object|number|string} id value of `_id` to query by
+ * @param {object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
+ * @param {boolean|'throw'} [options.strict] overwrites the schema's [strict mode option](https://mongoosejs.com/docs/guide.html#strict)
+ * @param {boolean} [options.translateAliases=null] If set to `true`, translates any schema-defined aliases in `filter`, `projection`, `update`, and `distinct`. Throws an error if there are any conflicts where both alias and raw property are defined on the same object.
  * @return {Query}
  * @see Model.findOneAndDelete https://mongoosejs.com/docs/api/model.html#Model.findOneAndDelete()
  * @see mongodb https://www.mongodb.com/docs/manual/reference/command/findAndModify/
@@ -2600,20 +2602,20 @@ Model.findByIdAndDelete = function(id, options) {
  *     A.findOneAndReplace(filter, replacement) // returns Query
  *     A.findOneAndReplace()                    // returns Query
  *
- * @param {Object} filter Replace the first document that matches this filter
- * @param {Object} [replacement] Replace with this document
- * @param {Object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
- * @param {String} [options.returnDocument='before'] Has two possible values, `'before'` and `'after'`. By default, it will return the document before the update was applied.
- * @param {Object} [options.lean] if truthy, mongoose will return the document as a plain JavaScript object rather than a mongoose document. See [`Query.lean()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.lean()) and [the Mongoose lean tutorial](https://mongoosejs.com/docs/tutorials/lean.html).
+ * @param {object} filter Replace the first document that matches this filter
+ * @param {object} [replacement] Replace with this document
+ * @param {object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
+ * @param {'before'|'after'} [options.returnDocument='before'] Has two possible values, `'before'` and `'after'`. By default, it will return the document before the update was applied.
+ * @param {object} [options.lean] if truthy, mongoose will return the document as a plain JavaScript object rather than a mongoose document. See [`Query.lean()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.lean()) and [the Mongoose lean tutorial](https://mongoosejs.com/docs/tutorials/lean.html).
  * @param {ClientSession} [options.session=null] The session associated with this query. See [transactions docs](https://mongoosejs.com/docs/transactions.html).
- * @param {Boolean|String} [options.strict] overwrites the schema's [strict mode option](https://mongoosejs.com/docs/guide.html#strict)
- * @param {Boolean} [options.timestamps=null] If set to `false` and [schema-level timestamps](https://mongoosejs.com/docs/guide.html#timestamps) are enabled, skip timestamps for this update. Note that this allows you to overwrite timestamps. Does nothing if schema-level timestamps are not set.
- * @param {Object|String|String[]} [options.projection=null] optional fields to return, see [`Query.prototype.select()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.select())
- * @param {Object|String} [options.sort] if multiple docs are found by the conditions, sets the sort order to choose which doc to update.
- * @param {Boolean} [options.includeResultMetadata] if true, returns the full [ModifyResult from the MongoDB driver](https://mongodb.github.io/node-mongodb-native/4.9/interfaces/ModifyResult.html) rather than just the document
- * @param {Object|String} [options.select] sets the document fields to return.
- * @param {Number} [options.maxTimeMS] puts a time limit on the query - requires mongodb >= 2.6.0
- * @param {Boolean} [options.translateAliases=null] If set to `true`, translates any schema-defined aliases in `filter`, `projection`, `update`, and `distinct`. Throws an error if there are any conflicts where both alias and raw property are defined on the same object.
+ * @param {boolean|'throw'} [options.strict] overwrites the schema's [strict mode option](https://mongoosejs.com/docs/guide.html#strict)
+ * @param {boolean} [options.timestamps=null] If set to `false` and [schema-level timestamps](https://mongoosejs.com/docs/guide.html#timestamps) are enabled, skip timestamps for this update. Note that this allows you to overwrite timestamps. Does nothing if schema-level timestamps are not set.
+ * @param {object|string|string[]} [options.projection=null] optional fields to return, see [`Query.prototype.select()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.select())
+ * @param {object|string} [options.sort] if multiple docs are found by the conditions, sets the sort order to choose which doc to update.
+ * @param {boolean} [options.includeResultMetadata] if true, returns the full [ModifyResult from the MongoDB driver](https://mongodb.github.io/node-mongodb-native/7.0/interfaces/ModifyResult.html) rather than just the document
+ * @param {object|string} [options.select] sets the document fields to return.
+ * @param {number} [options.maxTimeMS] puts a time limit on the query - requires mongodb >= 2.6.0
+ * @param {boolean} [options.translateAliases=null] If set to `true`, translates any schema-defined aliases in `filter`, `projection`, `update`, and `distinct`. Throws an error if there are any conflicts where both alias and raw property are defined on the same object.
  * @return {Query}
  * @api public
  */
@@ -2659,10 +2661,10 @@ Model.findOneAndReplace = function(filter, replacement, options) {
  *     // specify options.
  *     await Character.create([{ name: 'Jean-Luc Picard' }], { session });
  *
- * @param {Array|Object} docs Documents to insert, as a spread or array
- * @param {Object} [options] Options passed down to `save()`. To specify `options`, `docs` **must** be an array, not a spread. See [Model.save](https://mongoosejs.com/docs/api/model.html#Model.prototype.save()) for available options.
- * @param {Boolean} [options.ordered] saves the docs in series rather than parallel.
- * @param {Boolean} [options.aggregateErrors] Aggregate Errors instead of throwing the first one that occurs. Default: false
+ * @param {Array|object} docs Documents to insert, as a spread or array
+ * @param {object} [options] Options passed down to `save()`. To specify `options`, `docs` **must** be an array, not a spread. See [Model.save](https://mongoosejs.com/docs/api/model.html#Model.prototype.save()) for available options.
+ * @param {boolean} [options.ordered] saves the docs in series rather than parallel.
+ * @param {boolean} [options.aggregateErrors] Aggregate Errors instead of throwing the first one that occurs. Default: false
  * @return {Promise}
  * @api public
  */
@@ -2727,6 +2729,26 @@ Model.create = async function create(doc, options) {
     throw new MongooseError('Cannot call `create()` with a session and multiple documents unless `ordered: true` is set');
   }
 
+  if (!Array.isArray(doc) && args.length === 1) {
+    let toSave = doc;
+
+    const Model = this.discriminators && doc[discriminatorKey] != null ?
+      this.discriminators[doc[discriminatorKey]] || getDiscriminatorByValue(this.discriminators, doc[discriminatorKey]) :
+      this;
+    if (Model == null) {
+      throw new MongooseError(`Discriminator "${doc[discriminatorKey]}" not ` +
+      `found for model "${this.modelName}"`);
+    }
+
+    if (!(toSave instanceof Model)) {
+      toSave = new Model(toSave);
+    }
+
+    await toSave.$save(options);
+
+    return toSave;
+  }
+
   if (options.ordered) {
     for (let i = 0; i < args.length; i++) {
       try {
@@ -2805,11 +2827,6 @@ Model.create = async function create(doc, options) {
     }
   }
 
-
-  if (!Array.isArray(doc) && args.length === 1) {
-    return res[0];
-  }
-
   return res;
 };
 
@@ -2831,8 +2848,8 @@ Model.create = async function create(doc, options) {
  *     // Create a new character within a transaction.
  *     await Character.insertOne({ name: 'Jean-Luc Picard' }, { session });
  *
- * @param {Object|Document} doc Document to insert, as a POJO or Mongoose document
- * @param {Object} [options] Options passed down to `save()`.
+ * @param {object|Document} doc Document to insert, as a POJO or Mongoose document
+ * @param {object} [options] Options passed down to `save()`.
  * @return {Promise<Document>} resolves to the saved document
  * @api public
  */
@@ -2840,6 +2857,10 @@ Model.create = async function create(doc, options) {
 Model.insertOne = async function insertOne(doc, options) {
   _checkContext(this, 'insertOne');
 
+  if (doc == null || typeof doc !== 'object') {
+    throw new ObjectParameterError(doc, 'doc', 'insertOne');
+  }
+
   const discriminatorKey = this.schema.options.discriminatorKey;
   const Model = this.discriminators && doc[discriminatorKey] != null ?
     this.discriminators[doc[discriminatorKey]] || getDiscriminatorByValue(this.discriminators, doc[discriminatorKey]) :
@@ -2883,8 +2904,8 @@ Model.insertOne = async function insertOne(doc, options) {
  *     await doc.deleteOne();
  *
  * @param {Array} [pipeline]
- * @param {Object} [options] see the [mongodb driver options](https://mongodb.github.io/node-mongodb-native/4.9/classes/Collection.html#watch)
- * @param {Boolean} [options.hydrate=false] if true and `fullDocument: 'updateLookup'` is set, Mongoose will automatically hydrate `fullDocument` into a fully fledged Mongoose document
+ * @param {object} [options] see the [mongodb driver options](https://mongodb.github.io/node-mongodb-native/7.0/classes/Collection.html#watch)
+ * @param {boolean} [options.hydrate=false] if true and `fullDocument: 'updateLookup'` is set, Mongoose will automatically hydrate `fullDocument` into a fully fledged Mongoose document
  * @return {ChangeStream} mongoose-specific change stream wrapper, inherits from EventEmitter
  * @api public
  */
@@ -2892,27 +2913,21 @@ Model.insertOne = async function insertOne(doc, options) {
 Model.watch = function(pipeline, options) {
   _checkContext(this, 'watch');
 
-  const changeStreamThunk = cb => {
-    pipeline = pipeline || [];
-    prepareDiscriminatorPipeline(pipeline, this.schema, 'fullDocument');
-    if (this.$__collection.buffer) {
-      this.$__collection.addQueue(() => {
-        if (this.closed) {
-          return;
-        }
-        const driverChangeStream = this.$__collection.watch(pipeline, options);
-        cb(null, driverChangeStream);
-      });
-    } else {
-      const driverChangeStream = this.$__collection.watch(pipeline, options);
-      cb(null, driverChangeStream);
-    }
-  };
-
   options = options || {};
+  const watchOptions = options?.hydrate !== undefined ?
+    utils.omit(options, ['hydrate']) :
+    { ...options };
   options.model = this;
 
-  return new ChangeStream(changeStreamThunk, pipeline, options);
+
+  pipeline = pipeline || [];
+  prepareDiscriminatorPipeline(pipeline, this.schema, 'fullDocument');
+
+  const changeStreamPromise = this.db._waitForConnect().then(
+    () => this.$__collection.watch(pipeline, watchOptions)
+  );
+
+  return new ChangeStream(changeStreamPromise, pipeline, options);
 };
 
 /**
@@ -2935,8 +2950,8 @@ Model.watch = function(pipeline, options) {
  *     // secondary that is experiencing replication lag.
  *     doc = await Person.findOne({ name: 'Ned Stark' }, null, { session, readPreference: 'secondary' });
  *
- * @param {Object} [options] see the [mongodb driver options](https://mongodb.github.io/node-mongodb-native/4.9/classes/MongoClient.html#startSession)
- * @param {Boolean} [options.causalConsistency=true] set to false to disable causal consistency
+ * @param {object} [options] see the [mongodb driver options](https://mongodb.github.io/node-mongodb-native/7.0/classes/MongoClient.html#startSession)
+ * @param {boolean} [options.causalConsistency=true] set to false to disable causal consistency
  * @return {Promise<ClientSession>} promise that resolves to a MongoDB driver `ClientSession`
  * @api public
  */
@@ -2978,14 +2993,17 @@ Model.startSession = function() {
  *       { name: 'The Empire Strikes Back' }
  *     ], { rawResult: true });
  *
- * @param {Array|Object|*} doc(s)
- * @param {Object} [options] see the [mongodb driver options](https://mongodb.github.io/node-mongodb-native/4.9/classes/Collection.html#insertMany)
- * @param {Boolean} [options.ordered=true] if true, will fail fast on the first error encountered. If false, will insert all the documents it can and report errors later. An `insertMany()` with `ordered = false` is called an "unordered" `insertMany()`.
- * @param {Boolean} [options.rawResult=false] if false, the returned promise resolves to the documents that passed mongoose document validation. If `true`, will return the [raw result from the MongoDB driver](https://mongodb.github.io/node-mongodb-native/4.9/interfaces/InsertManyResult.html) with a `mongoose` property that contains `validationErrors` and `results` if this is an unordered `insertMany`.
- * @param {Boolean} [options.lean=false] if `true`, skips hydrating the documents. This means Mongoose will **not** cast, validate, or apply defaults to any of the documents passed to `insertMany()`. This option is useful if you need the extra performance, but comes with data integrity risk. Consider using with [`castObject()`](https://mongoosejs.com/docs/api/model.html#Model.castObject()) and [`applyDefaults()`](https://mongoosejs.com/docs/api/model.html#Model.applyDefaults()).
- * @param {Number} [options.limit=null] this limits the number of documents being processed (validation/casting) by mongoose in parallel, this does **NOT** send the documents in batches to MongoDB. Use this option if you're processing a large number of documents and your app is running out of memory.
- * @param {String|Object|Array} [options.populate=null] populates the result documents. This option is a no-op if `rawResult` is set.
- * @param {Boolean} [options.throwOnValidationError=false] If true and `ordered: false`, throw an error if one of the operations failed validation, but all valid operations completed successfully.
+ * @param {Array|object|any} doc(s)
+ * @param {object} [options] see the [mongodb driver options](https://mongodb.github.io/node-mongodb-native/7.0/classes/Collection.html#insertMany)
+ * @param {boolean} [options.ordered=true] if true, will fail fast on the first error encountered. If false, will insert all the documents it can and report errors later. An `insertMany()` with `ordered = false` is called an "unordered" `insertMany()`.
+ * @param {boolean} [options.rawResult=false] if false, the returned promise resolves to the documents that passed mongoose document validation. If `true`, will return the [raw result from the MongoDB driver](https://mongodb.github.io/node-mongodb-native/7.0/interfaces/InsertManyResult.html) with a `mongoose` property that contains `validationErrors` and `results` if this is an unordered `insertMany`.
+ * @param {boolean} [options.lean=false] if `true`, skips hydrating the documents. This means Mongoose will **not** cast, validate, or apply defaults to any of the documents passed to `insertMany()`. This option is useful if you need the extra performance, but comes with data integrity risk. Consider using with [`castObject()`](https://mongoosejs.com/docs/api/model.html#Model.castObject()) and [`applyDefaults()`](https://mongoosejs.com/docs/api/model.html#Model.applyDefaults()).
+ * @param {number} [options.limit=null] this limits the number of documents being processed (validation/casting) by mongoose in parallel, this does **NOT** send the documents in batches to MongoDB. Use this option if you're processing a large number of documents and your app is running out of memory.
+ * @param {string|object|Array} [options.populate=null] populates the result documents. This option is a no-op if `rawResult` is set.
+ * @param {boolean} [options.throwOnValidationError=false] If true and `ordered: false`, throw an error if one of the operations failed validation, but all valid operations completed successfully.
+ * @param {boolean|object} [options.middleware=true] set to `false` to skip all user-defined middleware
+ * @param {boolean} [options.middleware.pre=true] set to `false` to skip only pre hooks
+ * @param {boolean} [options.middleware.post=true] set to `false` to skip only post hooks
  * @return {Promise} resolving to the raw result from the MongoDB driver if `options.rawResult` was `true`, or the documents that passed validation, otherwise
  * @api public
  */
@@ -2997,37 +3015,16 @@ Model.insertMany = async function insertMany(arr, options) {
     throw new MongooseError('Model.insertMany() no longer accepts a callback');
   }
 
-  return new Promise((resolve, reject) => {
-    this.$__insertMany(arr, options, (err, res) => {
-      if (err != null) {
-        return reject(err);
-      }
-      resolve(res);
-    });
-  });
-};
-
-/**
- * ignore
- *
- * @param {Array} arr
- * @param {Object} options
- * @param {Function} callback
- * @api private
- * @memberOf Model
- * @method $__insertMany
- * @static
- */
+  options = options || {};
+  const preFilter = buildMiddlewareFilter(options, 'pre');
+  const postFilter = buildMiddlewareFilter(options, 'post');
 
-Model.$__insertMany = function(arr, options, callback) {
-  const _this = this;
-  if (typeof options === 'function') {
-    callback = options;
-    options = null;
+  try {
+    [arr] = await this._middleware.execPre('insertMany', this, [arr], { filter: preFilter });
+  } catch (error) {
+    await this._middleware.execPost('insertMany', this, [arr], { error, filter: postFilter });
   }
-
-  callback = callback || utils.noop;
-  options = options || {};
+  const ThisModel = this;
   const limit = options.limit || 1000;
   const rawResult = !!options.rawResult;
   const ordered = typeof options.ordered === 'boolean' ? options.ordered : true;
@@ -3046,238 +3043,213 @@ Model.$__insertMany = function(arr, options, callback) {
   const validationErrors = [];
   const validationErrorsToOriginalOrder = new Map();
   const results = ordered ? null : new Array(arr.length);
-  const toExecute = arr.map((doc, index) =>
-    callback => {
-      // If option `lean` is set to true bypass validation and hydration
-      if (lean) {
-        // we have to execute callback at the nextTick to be compatible
-        // with parallelLimit, as `results` variable has TDZ issue if we
-        // execute the callback synchronously
-        return immediate(() => callback(null, doc));
-      }
-      let createdNewDoc = false;
-      if (!(doc instanceof _this)) {
-        if (doc != null && typeof doc !== 'object') {
-          return callback(new ObjectParameterError(doc, 'arr.' + index, 'insertMany'));
-        }
-        try {
-          doc = new _this(doc);
-          createdNewDoc = true;
-        } catch (err) {
-          return callback(err);
-        }
+  async function validateDoc(doc, index) {
+    // If option `lean` is set to true bypass validation and hydration
+    if (lean) {
+      return doc;
+    }
+    let createdNewDoc = false;
+    if (!(doc instanceof ThisModel)) {
+      if (doc != null && typeof doc !== 'object') {
+        throw new ObjectParameterError(doc, 'arr.' + index, 'insertMany');
       }
+      doc = new ThisModel(doc);
+      createdNewDoc = true;
+    }
 
-      if (options.session != null) {
-        doc.$session(options.session);
-      }
-      // If option `lean` is set to true bypass validation
-      if (lean) {
-        // we have to execute callback at the nextTick to be compatible
-        // with parallelLimit, as `results` variable has TDZ issue if we
-        // execute the callback synchronously
-        return immediate(() => callback(null, doc));
-      }
-      doc.$validate(createdNewDoc ? { _skipParallelValidateCheck: true } : null).then(
-        () => { callback(null, doc); },
-        error => {
-          if (ordered === false) {
-            // Add index to validation error so users can identify which document failed
-            error.index = index;
-            validationErrors.push(error);
-            validationErrorsToOriginalOrder.set(error, index);
-            results[index] = error;
-            return callback(null, null);
-          }
-          callback(error);
+    if (options.session != null) {
+      doc.$session(options.session);
+    }
+    return doc.$validate(createdNewDoc ? { _skipParallelValidateCheck: true } : null)
+      .then(() => doc)
+      .catch(error => {
+        if (ordered === false) {
+          error.index = index;
+          validationErrors.push(error);
+          validationErrorsToOriginalOrder.set(error, index);
+          results[index] = error;
+          return;
         }
-      );
-    });
+        throw error;
+      });
+  }
 
-  parallelLimit(toExecute, limit, function(error, docs) {
-    if (error) {
-      callback(error, null);
-      return;
-    }
+  const docs = await parallelLimit(arr, validateDoc, limit);
 
-    const originalDocIndex = new Map();
-    const validDocIndexToOriginalIndex = new Map();
-    for (let i = 0; i < docs.length; ++i) {
-      originalDocIndex.set(docs[i], i);
-    }
+  const originalDocIndex = new Map();
+  const validDocIndexToOriginalIndex = new Map();
+  for (let i = 0; i < docs.length; ++i) {
+    originalDocIndex.set(docs[i], i);
+  }
 
-    // We filter all failed pre-validations by removing nulls
-    const docAttributes = docs.filter(function(doc) {
-      return doc != null;
+  // We filter all failed pre-validations by removing nulls
+  const docAttributes = docs.filter(function(doc) {
+    return doc != null;
+  });
+  for (let i = 0; i < docAttributes.length; ++i) {
+    validDocIndexToOriginalIndex.set(i, originalDocIndex.get(docAttributes[i]));
+  }
+
+  // Make sure validation errors are in the same order as the
+  // original documents, so if both doc1 and doc2 both fail validation,
+  // `Model.insertMany([doc1, doc2])` will always have doc1's validation
+  // error before doc2's. Re: gh-12791.
+  if (validationErrors.length > 0) {
+    validationErrors.sort((err1, err2) => {
+      return validationErrorsToOriginalOrder.get(err1) - validationErrorsToOriginalOrder.get(err2);
     });
-    for (let i = 0; i < docAttributes.length; ++i) {
-      validDocIndexToOriginalIndex.set(i, originalDocIndex.get(docAttributes[i]));
-    }
+  }
 
-    // Make sure validation errors are in the same order as the
-    // original documents, so if both doc1 and doc2 both fail validation,
-    // `Model.insertMany([doc1, doc2])` will always have doc1's validation
-    // error before doc2's. Re: gh-12791.
-    if (validationErrors.length > 0) {
-      validationErrors.sort((err1, err2) => {
-        return validationErrorsToOriginalOrder.get(err1) - validationErrorsToOriginalOrder.get(err2);
-      });
+  // Quickly escape while there aren't any valid docAttributes
+  if (docAttributes.length === 0) {
+    if (throwOnValidationError) {
+      throw new MongooseBulkWriteError(
+        validationErrors,
+        results,
+        null,
+        'insertMany'
+      );
     }
-
-    // Quickly escape while there aren't any valid docAttributes
-    if (docAttributes.length === 0) {
-      if (throwOnValidationError) {
-        return callback(new MongooseBulkWriteError(
-          validationErrors,
-          results,
-          null,
-          'insertMany'
-        ));
-      }
-      if (rawResult) {
-        const res = {
-          acknowledged: true,
-          insertedCount: 0,
-          insertedIds: {}
-        };
-        decorateBulkWriteResult(res, validationErrors, validationErrors);
-        return callback(null, res);
-      }
-      callback(null, []);
-      return;
+    if (rawResult) {
+      const res = {
+        acknowledged: true,
+        insertedCount: 0,
+        insertedIds: {}
+      };
+      decorateBulkWriteResult(res, validationErrors, validationErrors);
+      return res;
     }
-    const docObjects = lean ? docAttributes : docAttributes.map(function(doc) {
-      if (doc.$__schema.options.versionKey) {
-        doc[doc.$__schema.options.versionKey] = 0;
-      }
-      const shouldSetTimestamps = (!options || options.timestamps !== false) && doc.initializeTimestamps && (!doc.$__ || doc.$__.timestamps !== false);
-      if (shouldSetTimestamps) {
-        doc.initializeTimestamps();
-      }
-      if (doc.$__hasOnlyPrimitiveValues()) {
-        return doc.$__toObjectShallow();
-      }
-      return doc.toObject(internalToObjectOptions);
-    });
-
-    _this.$__collection.insertMany(docObjects, options).then(
-      res => {
-        if (!lean) {
-          for (const attribute of docAttributes) {
-            attribute.$__reset();
-            _setIsNew(attribute, false);
-          }
-        }
+    return [];
+  }
+  const docObjects = lean ? docAttributes : docAttributes.map(function(doc) {
+    if (doc.$__schema.options.versionKey) {
+      doc[doc.$__schema.options.versionKey] = 0;
+    }
+    const shouldSetTimestamps = options?.timestamps !== false && doc.initializeTimestamps && (!doc.$__ || doc.$__.timestamps !== false);
+    if (shouldSetTimestamps) {
+      doc.initializeTimestamps(options?.timestamps);
+    }
+    if (doc.$__hasOnlyPrimitiveValues()) {
+      return doc.$__toObjectShallow();
+    }
+    return doc.toObject(internalToObjectOptions);
+  });
 
-        if (ordered === false && throwOnValidationError && validationErrors.length > 0) {
-          for (let i = 0; i < results.length; ++i) {
-            if (results[i] === void 0) {
-              results[i] = docs[i];
-            }
-          }
-          return callback(new MongooseBulkWriteError(
-            validationErrors,
-            results,
-            res,
-            'insertMany'
-          ));
-        }
+  let res;
+  try {
+    res = await this.$__collection.insertMany(docObjects, options);
+  } catch (error) {
+    // `writeErrors` is a property reported by the MongoDB driver,
+    // just not if there's only 1 error.
+    if (error.writeErrors == null &&
+        error.result?.result?.writeErrors != null) {
+      error.writeErrors = error.result.result.writeErrors;
+    }
 
-        if (rawResult) {
-          if (ordered === false) {
-            for (let i = 0; i < results.length; ++i) {
-              if (results[i] === void 0) {
-                results[i] = docs[i];
-              }
-            }
+    // `insertedDocs` is a Mongoose-specific property
+    const hasWriteErrors = error?.writeErrors;
+    const erroredIndexes = new Set((error?.writeErrors || []).map(err => err.index));
 
-            // Decorate with mongoose validation errors in case of unordered,
-            // because then still do `insertMany()`
-            decorateBulkWriteResult(res, validationErrors, results);
-          }
-          return callback(null, res);
+    if (error.writeErrors != null) {
+      for (let i = 0; i < error.writeErrors.length; ++i) {
+        const originalIndex = validDocIndexToOriginalIndex.get(error.writeErrors[i].index);
+        error.writeErrors[i] = { ...error.writeErrors[i], index: originalIndex };
+        if (!ordered) {
+          results[originalIndex] = error.writeErrors[i];
         }
+      }
+    }
 
-        if (options.populate != null) {
-          return _this.populate(docAttributes, options.populate).then(
-            docs => { callback(null, docs); },
-            err => {
-              if (err != null) {
-                err.insertedDocs = docAttributes;
-              }
-              throw err;
-            }
-          );
+    if (!ordered) {
+      for (let i = 0; i < results.length; ++i) {
+        if (results[i] === void 0) {
+          results[i] = docs[i];
         }
+      }
 
-        callback(null, docAttributes);
-      },
-      error => {
-        // `writeErrors` is a property reported by the MongoDB driver,
-        // just not if there's only 1 error.
-        if (error.writeErrors == null &&
-            (error.result && error.result.result && error.result.result.writeErrors) != null) {
-          error.writeErrors = error.result.result.writeErrors;
-        }
+      error.results = results;
+    }
 
-        // `insertedDocs` is a Mongoose-specific property
-        const hasWriteErrors = error && error.writeErrors;
-        const erroredIndexes = new Set((error && error.writeErrors || []).map(err => err.index));
+    let firstErroredIndex = -1;
+    error.insertedDocs = docAttributes.
+      filter((doc, i) => {
+        const isErrored = !hasWriteErrors || erroredIndexes.has(i);
 
-        if (error.writeErrors != null) {
-          for (let i = 0; i < error.writeErrors.length; ++i) {
-            const originalIndex = validDocIndexToOriginalIndex.get(error.writeErrors[i].index);
-            error.writeErrors[i] = { ...error.writeErrors[i], index: originalIndex };
-            if (!ordered) {
-              results[originalIndex] = error.writeErrors[i];
-            }
+        if (ordered) {
+          if (firstErroredIndex > -1) {
+            return i < firstErroredIndex;
           }
-        }
 
-        if (!ordered) {
-          for (let i = 0; i < results.length; ++i) {
-            if (results[i] === void 0) {
-              results[i] = docs[i];
-            }
+          if (isErrored) {
+            firstErroredIndex = i;
           }
+        }
 
-          error.results = results;
+        return !isErrored;
+      }).
+      map(function setIsNewForInsertedDoc(doc) {
+        if (lean) {
+          return doc;
         }
+        doc.$__reset();
+        _setIsNew(doc, false);
+        return doc;
+      });
 
-        let firstErroredIndex = -1;
-        error.insertedDocs = docAttributes.
-          filter((doc, i) => {
-            const isErrored = !hasWriteErrors || erroredIndexes.has(i);
+    if (rawResult && ordered === false) {
+      decorateBulkWriteResult(error, validationErrors, results);
+    }
 
-            if (ordered) {
-              if (firstErroredIndex > -1) {
-                return i < firstErroredIndex;
-              }
+    await this._middleware.execPost('insertMany', this, [arr], { error, filter: postFilter });
+  }
 
-              if (isErrored) {
-                firstErroredIndex = i;
-              }
-            }
+  if (!lean) {
+    for (const attribute of docAttributes) {
+      attribute.$__reset();
+      _setIsNew(attribute, false);
+    }
+  }
 
-            return !isErrored;
-          }).
-          map(function setIsNewForInsertedDoc(doc) {
-            if (lean) {
-              return doc;
-            }
-            doc.$__reset();
-            _setIsNew(doc, false);
-            return doc;
-          });
+  if (ordered === false && throwOnValidationError && validationErrors.length > 0) {
+    for (let i = 0; i < results.length; ++i) {
+      if (results[i] === void 0) {
+        results[i] = docs[i];
+      }
+    }
+    throw new MongooseBulkWriteError(
+      validationErrors,
+      results,
+      res,
+      'insertMany'
+    );
+  }
 
-        if (rawResult && ordered === false) {
-          decorateBulkWriteResult(error, validationErrors, results);
+  if (rawResult) {
+    if (ordered === false) {
+      for (let i = 0; i < results.length; ++i) {
+        if (results[i] === void 0) {
+          results[i] = docs[i];
         }
+      }
+
+      // Decorate with mongoose validation errors in case of unordered,
+      // because then still do `insertMany()`
+      decorateBulkWriteResult(res, validationErrors, results);
+    }
+    return res;
+  }
 
-        callback(error, null);
+  if (options.populate != null) {
+    return this.populate(docAttributes, options.populate).catch(err => {
+      if (err != null) {
+        err.insertedDocs = docAttributes;
       }
-    );
-  });
+      throw err;
+    });
+  }
+
+  const [result] = await this._middleware.execPost('insertMany', this, [docAttributes], { filter: postFilter });
+  return result;
 };
 
 /*!
@@ -3359,38 +3331,43 @@ function _setIsNew(doc, val) {
  * - `replaceOne`
  *
  * @param {Array} ops
- * @param {Object} [ops.insertOne.document] The document to insert
- * @param {Object} [ops.insertOne.timestamps=true] If false, do not apply [timestamps](https://mongoosejs.com/docs/guide.html#timestamps) to the operation
- * @param {Object} [ops.updateOne.filter] Update the first document that matches this filter
- * @param {Object} [ops.updateOne.update] An object containing [update operators](https://www.mongodb.com/docs/manual/reference/operator/update/)
- * @param {Boolean} [ops.updateOne.upsert=false] If true, insert a doc if none match
- * @param {Boolean} [ops.updateOne.timestamps=true] If false, do not apply [timestamps](https://mongoosejs.com/docs/guide.html#timestamps) to the operation
- * @param {Object} [ops.updateOne.collation] The [MongoDB collation](https://thecodebarbarian.com/a-nodejs-perspective-on-mongodb-34-collations) to use
+ * @param {object} [ops.insertOne.document] The document to insert
+ * @param {object} [ops.insertOne.timestamps=true] If false, do not apply [timestamps](https://mongoosejs.com/docs/guide.html#timestamps) to the operation
+ * @param {object} [ops.updateOne.filter] Update the first document that matches this filter
+ * @param {object} [ops.updateOne.update] An object containing [update operators](https://www.mongodb.com/docs/manual/reference/operator/update/)
+ * @param {boolean} [ops.updateOne.upsert=false] If true, insert a doc if none match
+ * @param {boolean} [ops.updateOne.timestamps=true] If false, do not apply [timestamps](https://mongoosejs.com/docs/guide.html#timestamps) to the operation
+ * @param {boolean} [ops.updateOne.overwriteImmutable=false] Mongoose removes updated immutable properties from `update` by default (excluding $setOnInsert). Set `overwriteImmutable` to `true` to allow updating immutable properties using other update operators.
+ * @param {object} [ops.updateOne.collation] The [MongoDB collation](https://thecodebarbarian.com/a-nodejs-perspective-on-mongodb-34-collations) to use
  * @param {Array} [ops.updateOne.arrayFilters] The [array filters](https://thecodebarbarian.com/a-nodejs-perspective-on-mongodb-36-array-filters.html) used in `update`
- * @param {Object} [ops.updateMany.filter] Update all the documents that match this filter
- * @param {Object} [ops.updateMany.update] An object containing [update operators](https://www.mongodb.com/docs/manual/reference/operator/update/)
- * @param {Boolean} [ops.updateMany.upsert=false] If true, insert a doc if no documents match `filter`
- * @param {Boolean} [ops.updateMany.timestamps=true] If false, do not apply [timestamps](https://mongoosejs.com/docs/guide.html#timestamps) to the operation
- * @param {Object} [ops.updateMany.collation] The [MongoDB collation](https://thecodebarbarian.com/a-nodejs-perspective-on-mongodb-34-collations) to use
+ * @param {object} [ops.updateMany.filter] Update all the documents that match this filter
+ * @param {object} [ops.updateMany.update] An object containing [update operators](https://www.mongodb.com/docs/manual/reference/operator/update/)
+ * @param {boolean} [ops.updateMany.upsert=false] If true, insert a doc if no documents match `filter`
+ * @param {boolean} [ops.updateMany.timestamps=true] If false, do not apply [timestamps](https://mongoosejs.com/docs/guide.html#timestamps) to the operation
+ * @param {boolean} [ops.updateMany.overwriteImmutable=false] Mongoose removes updated immutable properties from `update` by default (excluding $setOnInsert). Set `overwriteImmutable` to `true` to allow updating immutable properties using other update operators.
+ * @param {object} [ops.updateMany.collation] The [MongoDB collation](https://thecodebarbarian.com/a-nodejs-perspective-on-mongodb-34-collations) to use
  * @param {Array} [ops.updateMany.arrayFilters] The [array filters](https://thecodebarbarian.com/a-nodejs-perspective-on-mongodb-36-array-filters.html) used in `update`
- * @param {Object} [ops.deleteOne.filter] Delete the first document that matches this filter
- * @param {Object} [ops.deleteMany.filter] Delete all documents that match this filter
- * @param {Object} [ops.replaceOne.filter] Replace the first document that matches this filter
- * @param {Object} [ops.replaceOne.replacement] The replacement document
- * @param {Boolean} [ops.replaceOne.upsert=false] If true, insert a doc if no documents match `filter`
- * @param {Object} [ops.replaceOne.timestamps=true] If false, do not apply [timestamps](https://mongoosejs.com/docs/guide.html#timestamps) to the operation
- * @param {Object} [options]
- * @param {Boolean} [options.ordered=true] If true, execute writes in order and stop at the first error. If false, execute writes in parallel and continue until all writes have either succeeded or errored.
- * @param {Boolean} [options.timestamps=true] If false, do not apply [timestamps](https://mongoosejs.com/docs/guide.html#timestamps) to any operations. Can be overridden at the operation-level.
+ * @param {object} [ops.deleteOne.filter] Delete the first document that matches this filter
+ * @param {object} [ops.deleteMany.filter] Delete all documents that match this filter
+ * @param {object} [ops.replaceOne.filter] Replace the first document that matches this filter
+ * @param {object} [ops.replaceOne.replacement] The replacement document
+ * @param {boolean} [ops.replaceOne.upsert=false] If true, insert a doc if no documents match `filter`
+ * @param {object} [ops.replaceOne.timestamps=true] If false, do not apply [timestamps](https://mongoosejs.com/docs/guide.html#timestamps) to the operation
+ * @param {object} [options]
+ * @param {boolean} [options.ordered=true] If true, execute writes in order and stop at the first error. If false, execute writes in parallel and continue until all writes have either succeeded or errored.
+ * @param {boolean} [options.timestamps=true] If false, do not apply [timestamps](https://mongoosejs.com/docs/guide.html#timestamps) to any operations. Can be overridden at the operation-level.
  * @param {ClientSession} [options.session=null] The session associated with this bulk write. See [transactions docs](https://mongoosejs.com/docs/transactions.html).
- * @param {String|number} [options.w=1] The [write concern](https://www.mongodb.com/docs/manual/reference/write-concern/). See [`Query#w()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.w()) for more information.
+ * @param {string|number} [options.w=1] The [write concern](https://www.mongodb.com/docs/manual/reference/write-concern/). See [`Query#w()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.w()) for more information.
  * @param {number} [options.wtimeout=null] The [write concern timeout](https://www.mongodb.com/docs/manual/reference/write-concern/#wtimeout).
- * @param {Boolean} [options.j=true] If false, disable [journal acknowledgement](https://www.mongodb.com/docs/manual/reference/write-concern/#j-option)
- * @param {Boolean} [options.skipValidation=false] Set to true to skip Mongoose schema validation on bulk write operations. Mongoose currently runs validation on `insertOne` and `replaceOne` operations by default.
- * @param {Boolean} [options.bypassDocumentValidation=false] If true, disable [MongoDB server-side schema validation](https://www.mongodb.com/docs/manual/core/schema-validation/) for all writes in this bulk.
- * @param {Boolean} [options.throwOnValidationError=false] If true and `ordered: false`, throw an error if one of the operations failed validation, but all valid operations completed successfully. Note that Mongoose will still send all valid operations to the MongoDB server.
- * @param {Boolean|"throw"} [options.strict=null] Overwrites the [`strict` option](https://mongoosejs.com/docs/guide.html#strict) on schema. If false, allows filtering and writing fields not defined in the schema for all writes in this bulk.
- * @return {Promise} resolves to a [`BulkWriteOpResult`](https://mongodb.github.io/node-mongodb-native/4.9/classes/BulkWriteResult.html) if the operation succeeds
+ * @param {boolean} [options.j=true] If false, disable [journal acknowledgement](https://www.mongodb.com/docs/manual/reference/write-concern/#j-option)
+ * @param {boolean} [options.skipValidation=false] Set to true to skip Mongoose schema validation on bulk write operations. Mongoose currently runs validation on `insertOne` and `replaceOne` operations by default.
+ * @param {boolean} [options.bypassDocumentValidation=false] If true, disable [MongoDB server-side schema validation](https://www.mongodb.com/docs/manual/core/schema-validation/) for all writes in this bulk.
+ * @param {boolean} [options.throwOnValidationError=false] If true and `ordered: false`, throw an error if one of the operations failed validation, but all valid operations completed successfully. Note that Mongoose will still send all valid operations to the MongoDB server.
+ * @param {boolean|"throw"} [options.strict=null] Overwrites the [`strict` option](https://mongoosejs.com/docs/guide.html#strict) on schema. If false, allows filtering and writing fields not defined in the schema for all writes in this bulk.
+ * @param {boolean|object} [options.middleware=true] set to `false` to skip all user-defined middleware
+ * @param {boolean} [options.middleware.pre=true] set to `false` to skip only pre hooks
+ * @param {boolean} [options.middleware.post=true] set to `false` to skip only post hooks
+ * @return {Promise} resolves to a [`BulkWriteOpResult`](https://mongodb.github.io/node-mongodb-native/7.0/classes/BulkWriteResult.html) if the operation succeeds
  * @api public
  */
 
@@ -3402,21 +3379,21 @@ Model.bulkWrite = async function bulkWrite(ops, options) {
     throw new MongooseError('Model.bulkWrite() no longer accepts a callback');
   }
   options = options || {};
+  const preFilter = buildMiddlewareFilter(options, 'pre');
+  const postFilter = buildMiddlewareFilter(options, 'post');
 
-  const shouldSkip = await new Promise((resolve, reject) => {
-    this.hooks.execPre('bulkWrite', this, [ops, options], (err) => {
-      if (err != null) {
-        if (err instanceof Kareem.skipWrappedFunction) {
-          return resolve(err);
-        }
-        return reject(err);
-      }
-      resolve();
-    });
-  });
+  try {
+    [ops, options] = await this.hooks.execPre('bulkWrite', this, [ops, options], { filter: preFilter });
+  } catch (err) {
+    if (err instanceof Kareem.skipWrappedFunction) {
+      ops = err;
+    } else {
+      await this.hooks.execPost('bulkWrite', this, [null], { error: err, filter: postFilter });
+    }
+  }
 
-  if (shouldSkip) {
-    return shouldSkip.args[0];
+  if (ops instanceof Kareem.skipWrappedFunction) {
+    return ops.args[0];
   }
 
   const ordered = options.ordered == null ? true : options.ordered;
@@ -3450,15 +3427,7 @@ Model.bulkWrite = async function bulkWrite(ops, options) {
     try {
       res = await this.$__collection.bulkWrite(ops, options);
     } catch (error) {
-      await new Promise((resolve, reject) => {
-        const _opts = { error: error };
-        this.hooks.execPost('bulkWrite', this, [null], _opts, (err) => {
-          if (err != null) {
-            return reject(err);
-          }
-          resolve();
-        });
-      });
+      await this.hooks.execPost('bulkWrite', this, [null], { error, filter: postFilter });
     }
   } else {
     let validOpIndexes = [];
@@ -3490,7 +3459,7 @@ Model.bulkWrite = async function bulkWrite(ops, options) {
       sort((v1, v2) => v1.index - v2.index).
       map(v => v.error);
 
-    const validOps = validOpIndexes.sort().map(index => ops[index]);
+    const validOps = validOpIndexes.sort((a, b) => a - b).map(index => ops[index]);
 
     if (validOps.length === 0) {
       if (options.throwOnValidationError && validationErrors.length) {
@@ -3527,15 +3496,7 @@ Model.bulkWrite = async function bulkWrite(ops, options) {
         decorateBulkWriteResult(error, validationErrors, results);
       }
 
-      await new Promise((resolve, reject) => {
-        const _opts = { error: error };
-        this.hooks.execPost('bulkWrite', this, [null], _opts, (err) => {
-          if (err != null) {
-            return reject(err);
-          }
-          resolve();
-        });
-      });
+      await this.hooks.execPost('bulkWrite', this, [null], { error, filter: postFilter });
     }
 
     if (validationErrors.length > 0) {
@@ -3552,14 +3513,7 @@ Model.bulkWrite = async function bulkWrite(ops, options) {
     }
   }
 
-  await new Promise((resolve, reject) => {
-    this.hooks.execPost('bulkWrite', this, [res], (err) => {
-      if (err != null) {
-        return reject(err);
-      }
-      resolve();
-    });
-  });
+  await this.hooks.execPost('bulkWrite', this, [res], { filter: postFilter });
 
   return res;
 };
@@ -3578,14 +3532,17 @@ Model.bulkWrite = async function bulkWrite(ops, options) {
  *
  * Note that `bulkSave()` will **not** throw an error if only some of the `save()` calls succeeded.
  *
- * @param {Array<Document>} documents
- * @param {Object} [options] options passed to the underlying `bulkWrite()`
- * @param {Boolean} [options.timestamps] defaults to `null`, when set to false, mongoose will not add/update timestamps to the documents.
+ * @param {Document[]} documents
+ * @param {object} [options] options passed to the underlying `bulkWrite()`
+ * @param {boolean} [options.timestamps] defaults to `null`, when set to false, mongoose will not add/update timestamps to the documents.
  * @param {ClientSession} [options.session=null] The session associated with this bulk write. See [transactions docs](https://mongoosejs.com/docs/transactions.html).
- * @param {String|number} [options.w=1] The [write concern](https://www.mongodb.com/docs/manual/reference/write-concern/). See [`Query#w()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.w()) for more information.
+ * @param {string|number} [options.w=1] The [write concern](https://www.mongodb.com/docs/manual/reference/write-concern/). See [`Query#w()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.w()) for more information.
  * @param {number} [options.wtimeout=null] The [write concern timeout](https://www.mongodb.com/docs/manual/reference/write-concern/#wtimeout).
- * @param {Boolean} [options.j=true] If false, disable [journal acknowledgement](https://www.mongodb.com/docs/manual/reference/write-concern/#j-option)
- * @param {Boolean} [options.validateBeforeSave=true] set to `false` to skip Mongoose validation on all documents
+ * @param {boolean} [options.j=true] If false, disable [journal acknowledgement](https://www.mongodb.com/docs/manual/reference/write-concern/#j-option)
+ * @param {boolean} [options.validateBeforeSave=true] set to `false` to skip Mongoose validation on all documents
+ * @param {boolean|object} [options.middleware=true] set to `false` to skip all user-defined middleware
+ * @param {boolean} [options.middleware.pre=true] set to `false` to skip only pre hooks
+ * @param {boolean} [options.middleware.post=true] set to `false` to skip only post hooks
  * @return {BulkWriteResult} the return value from `bulkWrite()`
  */
 Model.bulkSave = async function bulkSave(documents, options) {
@@ -3631,7 +3588,7 @@ Model.bulkSave = async function bulkSave(documents, options) {
   const successfulDocuments = [];
   for (let i = 0; i < documents.length; i++) {
     const document = documents[i];
-    const documentError = bulkWriteError && bulkWriteError.writeErrors.find(writeError => {
+    const documentError = bulkWriteError?.writeErrors.find(writeError => {
       const writeErrorDocumentId = writeError.err.op._id || writeError.err.op.q._id;
       return writeErrorDocumentId.toString() === document._doc._id.toString();
     });
@@ -3640,7 +3597,7 @@ Model.bulkSave = async function bulkSave(documents, options) {
       successfulDocuments.push(document);
     }
   }
-  await Promise.all(successfulDocuments.map(document => handleSuccessfulWrite(document)));
+  await Promise.all(successfulDocuments.map(document => handleSuccessfulWrite(document, options)));
 
   if (bulkWriteError != null) {
     throw bulkWriteError;
@@ -3649,43 +3606,30 @@ Model.bulkSave = async function bulkSave(documents, options) {
   return bulkWriteResult;
 };
 
-function buildPreSavePromise(document, options) {
-  return new Promise((resolve, reject) => {
-    document.schema.s.hooks.execPre('save', document, [options], (err) => {
-      if (err) {
-        reject(err);
-        return;
-      }
-      resolve();
-    });
-  });
+async function buildPreSavePromise(document, options) {
+  const preFilter = buildMiddlewareFilter(options, 'pre');
+  const [newOptions] = await document.schema.s.hooks.execPre('save', document, [options], { filter: preFilter });
+  if (newOptions !== options) {
+    throw new MongooseError('Cannot overwrite options in pre("save") hook on bulkSave()');
+  }
 }
 
-function handleSuccessfulWrite(document) {
-  return new Promise((resolve, reject) => {
-    if (document.$isNew) {
-      _setIsNew(document, false);
-    }
-
-    document.$__reset();
-    document._applyVersionIncrement();
-
-    document.schema.s.hooks.execPost('save', document, [document], {}, (err) => {
-      if (err) {
-        reject(err);
-        return;
-      }
-      resolve();
-    });
+async function handleSuccessfulWrite(document, options) {
+  if (document.$isNew) {
+    _setIsNew(document, false);
+  }
 
-  });
+  document.$__reset();
+  document._applyVersionIncrement();
+  const postFilter = buildMiddlewareFilter(options, 'post');
+  return document.schema.s.hooks.execPost('save', document, [document], { filter: postFilter });
 }
 
 /**
  * Apply defaults to the given document or POJO.
  *
- * @param {Object|Document} obj object or document to apply defaults on
- * @returns {Object|Document}
+ * @param {object|Document} obj object or document to apply defaults on
+ * @returns {object|Document}
  * @api public
  */
 
@@ -3722,9 +3666,9 @@ Model.applyDefaults = function applyDefaults(doc) {
  *     obj.name; // 'John'
  *     obj.upper; // 'JOHN', Mongoose applied the return value of the virtual to the given object
  *
- * @param {Object} obj object or document to apply virtuals on
- * @param {Array<string>} [virtualsToApply] optional whitelist of virtuals to apply
- * @returns {Object} obj
+ * @param {object} obj object or document to apply virtuals on
+ * @param {string[]} [virtualsToApply] optional whitelist of virtuals to apply
+ * @returns {object} obj
  * @api public
  */
 
@@ -3755,11 +3699,11 @@ Model.applyVirtuals = function applyVirtuals(obj, virtualsToApply) {
  *     obj.createdAt; // 2024-06-01T18:00:00.000Z
  *     obj.updatedAt; // 2024-06-01T18:00:00.000Z
  *
- * @param {Object} obj object or document to apply virtuals on
- * @param {Object} [options]
- * @param {Boolean} [options.isUpdate=false] if true, treat this as an update: just set updatedAt, skip setting createdAt. If false, set both createdAt and updatedAt
+ * @param {object} obj object or document to apply virtuals on
+ * @param {object} [options]
+ * @param {boolean} [options.isUpdate=false] if true, treat this as an update: just set updatedAt, skip setting createdAt. If false, set both createdAt and updatedAt
  * @param {Function} [options.currentTime] if set, Mongoose will call this function to get the current time.
- * @returns {Object} obj
+ * @returns {object} obj
  * @api public
  */
 
@@ -3789,10 +3733,10 @@ Model.applyTimestamps = function applyTimestamps(obj, options) {
  *
  *     Test.castObject({ num: 'not a number' }); // Throws a ValidationError
  *
- * @param {Object} obj object or document to cast
- * @param {Object} options options passed to castObject
- * @param {Boolean} options.ignoreCastErrors If set to `true` will not throw a ValidationError and only return values that were successfully cast.
- * @returns {Object} POJO casted to the model's schema
+ * @param {object} obj object or document to cast
+ * @param {object} options options passed to castObject
+ * @param {boolean} options.ignoreCastErrors If set to `true` will not throw a ValidationError and only return values that were successfully cast.
+ * @returns {object} POJO casted to the model's schema
  * @throws {ValidationError} if casting failed for at least one path
  * @api public
  */
@@ -3810,7 +3754,7 @@ Model.castObject = function castObject(obj, options) {
 
   for (const path of paths) {
     const schemaType = schema.path(path);
-    if (!schemaType || !schemaType.$isMongooseArray) {
+    if (!schemaType?.$isMongooseArray) {
       continue;
     }
 
@@ -3851,7 +3795,7 @@ Model.castObject = function castObject(obj, options) {
           }
         } else {
           cur[pieces[pieces.length - 1]] = [
-            Model.castObject.call(schemaType.caster, val)
+            Model.castObject.call(schemaType.Constructor, val)
           ];
         }
 
@@ -3860,7 +3804,7 @@ Model.castObject = function castObject(obj, options) {
     }
     if (schemaType.$isSingleNested || schemaType.$isMongooseDocumentArrayElement) {
       try {
-        val = Model.castObject.call(schemaType.caster, val);
+        val = Model.castObject.call(schemaType.Constructor, val);
       } catch (err) {
         if (!options.ignoreCastErrors) {
           error = error || new ValidationError();
@@ -3896,17 +3840,17 @@ Model.castObject = function castObject(obj, options) {
 /**
  * Build bulk write operations for `bulkSave()`.
  *
- * @param {Array<Document>} documents The array of documents to build write operations of
- * @param {Object} options
- * @param {Boolean} options.skipValidation defaults to `false`, when set to true, building the write operations will bypass validating the documents.
- * @param {Boolean} options.timestamps defaults to `null`, when set to false, mongoose will not add/update timestamps to the documents.
- * @return {Array<Promise>} Returns a array of all Promises the function executes to be awaited.
+ * @param {Document[]} documents The array of documents to build write operations of
+ * @param {object} options
+ * @param {boolean} options.skipValidation defaults to `false`, when set to true, building the write operations will bypass validating the documents.
+ * @param {boolean} options.timestamps defaults to `null`, when set to false, mongoose will not add/update timestamps to the documents.
+ * @return {Promise[]} Returns a array of all Promises the function executes to be awaited.
  * @api private
  */
 
 Model.buildBulkWriteOperations = function buildBulkWriteOperations(documents, options) {
   if (!Array.isArray(documents)) {
-    throw new Error(`bulkSave expects an array of documents to be passed, received \`${documents}\` instead`);
+    throw new MongooseError(`bulkSave expects an array of documents to be passed, received \`${documents}\` instead`);
   }
 
   setDefaultOptions();
@@ -3914,7 +3858,7 @@ Model.buildBulkWriteOperations = function buildBulkWriteOperations(documents, op
   const writeOperations = documents.map((document, i) => {
     if (!options.skipValidation) {
       if (!(document instanceof Document)) {
-        throw new Error(`documents.${i} was not a mongoose document, documents must be an array of mongoose documents (instanceof mongoose.Document).`);
+        throw new MongooseError(`documents.${i} was not a mongoose document, documents must be an array of mongoose documents (instanceof mongoose.Document).`);
       }
       if (options.validateBeforeSave == null || options.validateBeforeSave) {
         const err = document.validateSync();
@@ -3981,18 +3925,18 @@ Model.buildBulkWriteOperations = function buildBulkWriteOperations(documents, op
  *     // hydrate previous data into a Mongoose document
  *     const mongooseCandy = Candy.hydrate({ _id: '54108337212ffb6d459f854c', type: 'jelly bean' });
  *
- * @param {Object} obj
- * @param {Object|String|String[]} [projection] optional projection containing which fields should be selected for this document
- * @param {Object} [options] optional options
- * @param {Boolean} [options.setters=false] if true, apply schema setters when hydrating
- * @param {Boolean} [options.hydratedPopulatedDocs=false] if true, populates the docs if passing pre-populated data
- * @param {Boolean} [options.virtuals=false] if true, sets any virtuals present on `obj`
- * @param {Boolean|String} [options.strict=false] configure strict mode for the hydrated document. In particular, if strict is false, fields not in the schema won't be stripped out; if strict is 'throw', `hydrate()` will throw an error if there are any fields that are not in the schema. Defaults to true (silently strip out fields not in the schema).
+ * @param {object} obj
+ * @param {object|string|string[]} [projection] optional projection containing which fields should be selected for this document
+ * @param {object} [options] optional options
+ * @param {boolean} [options.setters=false] if true, apply schema setters when hydrating
+ * @param {boolean} [options.hydratedPopulatedDocs=false] if true, populates the docs if passing pre-populated data
+ * @param {boolean} [options.virtuals=false] if true, sets any virtuals present on `obj`
+ * @param {boolean|'throw'} [options.strict=false] configure strict mode for the hydrated document. In particular, if strict is false, fields not in the schema won't be stripped out; if strict is 'throw', `hydrate()` will throw an error if there are any fields that are not in the schema. Defaults to true (silently strip out fields not in the schema).
  * @return {Document} document instance
  * @api public
  */
 
-Model.hydrate = function(obj, projection, options) {
+Model.hydrate = function hydrate(obj, projection, options) {
   _checkContext(this, 'hydrate');
 
   if (options?.virtuals && options?.hydratedPopulatedDocs === false) {
@@ -4000,9 +3944,10 @@ Model.hydrate = function(obj, projection, options) {
   }
 
   if (projection != null) {
-    if (obj != null && obj.$__ != null) {
+    if (obj?.$__ != null) {
       obj = obj.toObject(internalToObjectOptions);
     }
+    projection = parseProjection(projection);
     obj = applyProjection(obj, projection);
   }
   const document = require('./queryHelpers').createModel(this, obj, projection, projection, options);
@@ -4035,19 +3980,19 @@ Model.hydrate = function(obj, projection, options) {
  *
  * - `updateMany()`
  *
- * @param {Object} filter
- * @param {Object|Array} update. If array, this update will be treated as an update pipeline and not casted.
- * @param {Object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
- * @param {Boolean|String} [options.strict] overwrites the schema's [strict mode option](https://mongoosejs.com/docs/guide.html#strict)
- * @param {Boolean} [options.upsert=false] if true, and no documents found, insert a new document
- * @param {Object} [options.writeConcern=null] sets the [write concern](https://www.mongodb.com/docs/manual/reference/write-concern/) for replica sets. Overrides the [schema-level write concern](https://mongoosejs.com/docs/guide.html#writeConcern)
- * @param {Boolean} [options.timestamps=null] If set to `false` and [schema-level timestamps](https://mongoosejs.com/docs/guide.html#timestamps) are enabled, skip timestamps for this update. Does nothing if schema-level timestamps are not set.
- * @param {Boolean} [options.translateAliases=null] If set to `true`, translates any schema-defined aliases in `filter`, `projection`, `update`, and `distinct`. Throws an error if there are any conflicts where both alias and raw property are defined on the same object.
- * @param {Boolean} [options.overwriteDiscriminatorKey=false] Mongoose removes discriminator key updates from `update` by default, set `overwriteDiscriminatorKey` to `true` to allow updating the discriminator key
+ * @param {object} filter
+ * @param {object|Array} update. If array, this update will be treated as an update pipeline and not casted.
+ * @param {object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
+ * @param {boolean|'throw'} [options.strict] overwrites the schema's [strict mode option](https://mongoosejs.com/docs/guide.html#strict)
+ * @param {boolean} [options.upsert=false] if true, and no documents found, insert a new document
+ * @param {object} [options.writeConcern=null] sets the [write concern](https://www.mongodb.com/docs/manual/reference/write-concern/) for replica sets. Overrides the [schema-level write concern](https://mongoosejs.com/docs/guide.html#writeConcern)
+ * @param {boolean} [options.timestamps=null] If set to `false` and [schema-level timestamps](https://mongoosejs.com/docs/guide.html#timestamps) are enabled, skip timestamps for this update. Does nothing if schema-level timestamps are not set.
+ * @param {boolean} [options.translateAliases=null] If set to `true`, translates any schema-defined aliases in `filter`, `projection`, `update`, and `distinct`. Throws an error if there are any conflicts where both alias and raw property are defined on the same object.
+ * @param {boolean} [options.overwriteDiscriminatorKey=false] Mongoose removes discriminator key updates from `update` by default, set `overwriteDiscriminatorKey` to `true` to allow updating the discriminator key
  * @return {Query}
  * @see Query docs https://mongoosejs.com/docs/queries.html
  * @see MongoDB docs https://www.mongodb.com/docs/manual/reference/command/update/#update-command-output
- * @see UpdateResult https://mongodb.github.io/node-mongodb-native/4.9/interfaces/UpdateResult.html
+ * @see UpdateResult https://mongodb.github.io/node-mongodb-native/7.0/interfaces/UpdateResult.html
  * @api public
  */
 
@@ -4083,19 +4028,19 @@ Model.updateMany = function updateMany(conditions, update, options) {
  *
  * - `updateOne()`
  *
- * @param {Object} filter
- * @param {Object|Array} update. If array, this update will be treated as an update pipeline and not casted.
- * @param {Object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
- * @param {Boolean|String} [options.strict] overwrites the schema's [strict mode option](https://mongoosejs.com/docs/guide.html#strict)
- * @param {Boolean} [options.upsert=false] if true, and no documents found, insert a new document
- * @param {Object} [options.writeConcern=null] sets the [write concern](https://www.mongodb.com/docs/manual/reference/write-concern/) for replica sets. Overrides the [schema-level write concern](https://mongoosejs.com/docs/guide.html#writeConcern)
- * @param {Boolean} [options.timestamps=null] If set to `false` and [schema-level timestamps](https://mongoosejs.com/docs/guide.html#timestamps) are enabled, skip timestamps for this update. Note that this allows you to overwrite timestamps. Does nothing if schema-level timestamps are not set.
- * @param {Boolean} [options.translateAliases=null] If set to `true`, translates any schema-defined aliases in `filter`, `projection`, `update`, and `distinct`. Throws an error if there are any conflicts where both alias and raw property are defined on the same object.
- * @param {Boolean} [options.overwriteDiscriminatorKey=false] Mongoose removes discriminator key updates from `update` by default, set `overwriteDiscriminatorKey` to `true` to allow updating the discriminator key
+ * @param {object} filter
+ * @param {object|Array} update. If array, this update will be treated as an update pipeline and not casted.
+ * @param {object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
+ * @param {boolean|'throw'} [options.strict] overwrites the schema's [strict mode option](https://mongoosejs.com/docs/guide.html#strict)
+ * @param {boolean} [options.upsert=false] if true, and no documents found, insert a new document
+ * @param {object} [options.writeConcern=null] sets the [write concern](https://www.mongodb.com/docs/manual/reference/write-concern/) for replica sets. Overrides the [schema-level write concern](https://mongoosejs.com/docs/guide.html#writeConcern)
+ * @param {boolean} [options.timestamps=null] If set to `false` and [schema-level timestamps](https://mongoosejs.com/docs/guide.html#timestamps) are enabled, skip timestamps for this update. Note that this allows you to overwrite timestamps. Does nothing if schema-level timestamps are not set.
+ * @param {boolean} [options.translateAliases=null] If set to `true`, translates any schema-defined aliases in `filter`, `projection`, `update`, and `distinct`. Throws an error if there are any conflicts where both alias and raw property are defined on the same object.
+ * @param {boolean} [options.overwriteDiscriminatorKey=false] Mongoose removes discriminator key updates from `update` by default, set `overwriteDiscriminatorKey` to `true` to allow updating the discriminator key
  * @return {Query}
  * @see Query docs https://mongoosejs.com/docs/queries.html
  * @see MongoDB docs https://www.mongodb.com/docs/manual/reference/command/update/#update-command-output
- * @see UpdateResult https://mongodb.github.io/node-mongodb-native/4.9/interfaces/UpdateResult.html
+ * @see UpdateResult https://mongodb.github.io/node-mongodb-native/7.0/interfaces/UpdateResult.html
  * @api public
  */
 
@@ -4121,17 +4066,17 @@ Model.updateOne = function updateOne(conditions, doc, options) {
  *
  * - `replaceOne()`
  *
- * @param {Object} filter
- * @param {Object} doc
- * @param {Object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
- * @param {Boolean|String} [options.strict] overwrites the schema's [strict mode option](https://mongoosejs.com/docs/guide.html#strict)
- * @param {Boolean} [options.upsert=false] if true, and no documents found, insert a new document
- * @param {Object} [options.writeConcern=null] sets the [write concern](https://www.mongodb.com/docs/manual/reference/write-concern/) for replica sets. Overrides the [schema-level write concern](https://mongoosejs.com/docs/guide.html#writeConcern)
- * @param {Boolean} [options.timestamps=null] If set to `false` and [schema-level timestamps](https://mongoosejs.com/docs/guide.html#timestamps) are enabled, skip timestamps for this update. Does nothing if schema-level timestamps are not set.
- * @param {Boolean} [options.translateAliases=null] If set to `true`, translates any schema-defined aliases in `filter`, `projection`, `update`, and `distinct`. Throws an error if there are any conflicts where both alias and raw property are defined on the same object.
+ * @param {object} filter
+ * @param {object} doc
+ * @param {object} [options] optional see [`Query.prototype.setOptions()`](https://mongoosejs.com/docs/api/query.html#Query.prototype.setOptions())
+ * @param {boolean|'throw'} [options.strict] overwrites the schema's [strict mode option](https://mongoosejs.com/docs/guide.html#strict)
+ * @param {boolean} [options.upsert=false] if true, and no documents found, insert a new document
+ * @param {object} [options.writeConcern=null] sets the [write concern](https://www.mongodb.com/docs/manual/reference/write-concern/) for replica sets. Overrides the [schema-level write concern](https://mongoosejs.com/docs/guide.html#writeConcern)
+ * @param {boolean} [options.timestamps=null] If set to `false` and [schema-level timestamps](https://mongoosejs.com/docs/guide.html#timestamps) are enabled, skip timestamps for this update. Does nothing if schema-level timestamps are not set.
+ * @param {boolean} [options.translateAliases=null] If set to `true`, translates any schema-defined aliases in `filter`, `projection`, `update`, and `distinct`. Throws an error if there are any conflicts where both alias and raw property are defined on the same object.
  * @return {Query}
  * @see Query docs https://mongoosejs.com/docs/queries.html
- * @see UpdateResult https://mongodb.github.io/node-mongodb-native/4.9/interfaces/UpdateResult.html
+ * @see UpdateResult https://mongodb.github.io/node-mongodb-native/7.0/interfaces/UpdateResult.html
  * @return {Query}
  * @api public
  */
@@ -4139,7 +4084,7 @@ Model.updateOne = function updateOne(conditions, doc, options) {
 Model.replaceOne = function replaceOne(conditions, doc, options) {
   _checkContext(this, 'replaceOne');
 
-  const versionKey = this && this.schema && this.schema.options && this.schema.options.versionKey || null;
+  const versionKey = this?.schema?.options?.versionKey || null;
   if (versionKey && !doc[versionKey]) {
     doc[versionKey] = 0;
   }
@@ -4165,10 +4110,7 @@ function _update(model, op, conditions, doc, options) {
   }
   options = typeof options === 'function' ? options : clone(options);
 
-  const versionKey = model &&
-  model.schema &&
-  model.schema.options &&
-  model.schema.options.versionKey || null;
+  const versionKey = model?.schema?.options?.versionKey ?? null;
   decorateUpdateWithVersionKey(doc, options, versionKey);
 
   return mq[op](conditions, doc, options);
@@ -4214,7 +4156,7 @@ function _update(model, op, conditions, doc, options) {
  * @see Aggregate https://mongoosejs.com/docs/api/aggregate.html#Aggregate()
  * @see MongoDB https://www.mongodb.com/docs/manual/applications/aggregation/
  * @param {Array} [pipeline] aggregation pipeline as an array of objects
- * @param {Object} [options] aggregation options
+ * @param {object} [options] aggregation options
  * @return {Aggregate}
  * @api public
  */
@@ -4253,10 +4195,10 @@ Model.aggregate = function aggregate(pipeline, options) {
  *       Object.keys(err.errors); // ['name']
  *     }
  *
- * @param {Object} obj
- * @param {Object|Array|String} pathsOrOptions
- * @param {Object} [context]
- * @return {Promise<Object>} casted and validated copy of `obj` if validation succeeded
+ * @param {object} obj
+ * @param {object|Array|string} pathsOrOptions
+ * @param {object} [context]
+ * @return {Promise<object>} casted and validated copy of `obj` if validation succeeded
  * @api public
  */
 
@@ -4307,7 +4249,7 @@ Model.validate = async function validate(obj, pathsOrOptions, context) {
 
   for (const path of paths) {
     const schemaType = schema.path(path);
-    if (!schemaType || !schemaType.$isMongooseArray || schemaType.$isMongooseDocumentArray) {
+    if (!schemaType?.$isMongooseArray || schemaType.$isMongooseDocumentArray) {
       continue;
     }
 
@@ -4327,51 +4269,34 @@ Model.validate = async function validate(obj, pathsOrOptions, context) {
     }
   }
 
-  let remaining = paths.size;
-
-  return new Promise((resolve, reject) => {
-    if (remaining === 0) {
-      return settle();
+  const promises = [];
+  for (const path of paths) {
+    const schemaType = schema.path(path);
+    if (schemaType == null) {
+      continue;
     }
 
-    for (const path of paths) {
-      const schemaType = schema.path(path);
-      if (schemaType == null) {
-        _checkDone();
-        continue;
-      }
-
-      const pieces = path.indexOf('.') === -1 ? [path] : path.split('.');
-      let cur = obj;
-      for (let i = 0; i < pieces.length - 1; ++i) {
-        cur = cur[pieces[i]];
-      }
-
-      const val = get(obj, path, void 0);
-
-      schemaType.doValidate(val, err => {
-        if (err) {
-          error = error || new ValidationError();
-          error.addError(path, err);
-        }
-        _checkDone();
-      }, context, { path: path });
+    const pieces = path.indexOf('.') === -1 ? [path] : path.split('.');
+    let cur = obj;
+    for (let i = 0; i < pieces.length - 1; ++i) {
+      cur = cur[pieces[i]];
     }
 
-    function settle() {
-      if (error) {
-        reject(error);
-      } else {
-        resolve(obj);
-      }
-    }
+    const val = get(obj, path, void 0);
+    promises.push(
+      schemaType.doValidate(val, context, { path: path }).catch(err => {
+        error = error || new ValidationError();
+        error.addError(path, err);
+      })
+    );
+  }
 
-    function _checkDone() {
-      if (--remaining <= 0) {
-        return settle();
-      }
-    }
-  });
+  await Promise.all(promises);
+  if (error != null) {
+    throw error;
+  }
+
+  return obj;
 };
 
 /**
@@ -4414,20 +4339,20 @@ Model.validate = async function validate(obj, pathsOrOptions, context) {
  *     users[0].dog.breed; // undefined because of `select`
  *
  * @param {Document|Array} docs Either a single document or array of documents to populate.
- * @param {Object|String} options Either the paths to populate or an object specifying all parameters
+ * @param {object|string} options Either the paths to populate or an object specifying all parameters
  * @param {string} [options.path=null] The path to populate.
  * @param {string|PopulateOptions} [options.populate=null] Recursively populate paths in the populated documents. See [deep populate docs](https://mongoosejs.com/docs/populate.html#deep-populate).
  * @param {boolean} [options.retainNullValues=false] By default, Mongoose removes null and undefined values from populated arrays. Use this option to make `populate()` retain `null` and `undefined` array entries.
  * @param {boolean} [options.getters=false] If true, Mongoose will call any getters defined on the `localField`. By default, Mongoose gets the raw value of `localField`. For example, you would need to set this option to `true` if you wanted to [add a `lowercase` getter to your `localField`](https://mongoosejs.com/docs/schematypes.html#schematype-options).
  * @param {boolean} [options.clone=false] When you do `BlogPost.find().populate('author')`, blog posts with the same author will share 1 copy of an `author` doc. Enable this option to make Mongoose clone populated docs before assigning them.
- * @param {Object|Function} [options.match=null] Add an additional filter to the populate query. Can be a filter object containing [MongoDB query syntax](https://www.mongodb.com/docs/manual/tutorial/query-documents/), or a function that returns a filter object.
- * @param {Boolean} [options.skipInvalidIds=false] By default, Mongoose throws a cast error if `localField` and `foreignField` schemas don't line up. If you enable this option, Mongoose will instead filter out any `localField` properties that cannot be casted to `foreignField`'s schema type.
- * @param {Number} [options.perDocumentLimit=null] For legacy reasons, `limit` with `populate()` may give incorrect results because it only executes a single query for every document being populated. If you set `perDocumentLimit`, Mongoose will ensure correct `limit` per document by executing a separate query for each document to `populate()`. For example, `.find().populate({ path: 'test', perDocumentLimit: 2 })` will execute 2 additional queries if `.find()` returns 2 documents.
- * @param {Boolean} [options.strictPopulate=true] Set to false to allow populating paths that aren't defined in the given model's schema.
- * @param {Object} [options.options=null] Additional options like `limit` and `lean`.
+ * @param {object|Function} [options.match=null] Add an additional filter to the populate query. Can be a filter object containing [MongoDB query syntax](https://www.mongodb.com/docs/manual/tutorial/query-documents/), or a function that returns a filter object.
+ * @param {boolean} [options.skipInvalidIds=false] By default, Mongoose throws a cast error if `localField` and `foreignField` schemas don't line up. If you enable this option, Mongoose will instead filter out any `localField` properties that cannot be casted to `foreignField`'s schema type.
+ * @param {number} [options.perDocumentLimit=null] For legacy reasons, `limit` with `populate()` may give incorrect results because it only executes a single query for every document being populated. If you set `perDocumentLimit`, Mongoose will ensure correct `limit` per document by executing a separate query for each document to `populate()`. For example, `.find().populate({ path: 'test', perDocumentLimit: 2 })` will execute 2 additional queries if `.find()` returns 2 documents.
+ * @param {boolean} [options.strictPopulate=true] Set to false to allow populating paths that aren't defined in the given model's schema.
+ * @param {object} [options.options=null] Additional options like `limit` and `lean`.
  * @param {Function} [options.transform=null] Function that Mongoose will call on every populated document that allows you to transform the populated document.
- * @param {Boolean} [options.forceRepopulate=true] Set to `false` to prevent Mongoose from repopulating paths that are already populated
- * @param {Boolean} [options.ordered=false] Set to `true` to execute any populate queries one at a time, as opposed to in parallel. Set this option to `true` if populating multiple paths or paths with multiple models in transactions.
+ * @param {boolean} [options.forceRepopulate=true] Set to `false` to prevent Mongoose from repopulating paths that are already populated
+ * @param {boolean} [options.ordered=false] Set to `true` to execute any populate queries one at a time, as opposed to in parallel. Set this option to `true` if populating multiple paths or paths with multiple models in transactions.
  * @return {Promise}
  * @api public
  */
@@ -4472,7 +4397,7 @@ const excludeIdRegGlobal = /\s?-_id\s?/g;
 
 async function _populatePath(model, docs, populateOptions) {
   if (populateOptions.strictPopulate == null) {
-    if (populateOptions._localModel != null && populateOptions._localModel.schema._userProvidedOptions.strictPopulate != null) {
+    if (populateOptions._localModel?.schema._userProvidedOptions.strictPopulate != null) {
       populateOptions.strictPopulate = populateOptions._localModel.schema._userProvidedOptions.strictPopulate;
     } else if (populateOptions._localModel != null && model.base.options.strictPopulate != null) {
       populateOptions.strictPopulate = model.base.options.strictPopulate;
@@ -4556,7 +4481,7 @@ async function _populatePath(model, docs, populateOptions) {
       }
     }
 
-    if (mod.options.options && mod.options.options.limit != null) {
+    if (mod.options.options?.limit != null) {
       assignmentOpts.originalLimit = mod.options.options.limit;
     } else if (mod.options.limit != null) {
       assignmentOpts.originalLimit = mod.options.limit;
@@ -4579,20 +4504,35 @@ async function _populatePath(model, docs, populateOptions) {
     return;
   }
 
+  // Track deferred populates per-param (per model) to avoid mixing them
+  const deferredPopulatesPerParam = new Map();
+
   if (populateOptions.ordered) {
     // Populate in series, primarily for transactions because MongoDB doesn't support multiple operations on
     // one transaction in parallel.
-    for (const arr of params) {
-      await _execPopulateQuery.apply(null, arr).then(valsFromDb => { vals = vals.concat(valsFromDb); });
+    for (let i = 0; i < params.length; i++) {
+      const arr = params[i];
+      const { docs, deferredPopulates } = await _execPopulateQuery.apply(null, arr);
+      vals = vals.concat(docs);
+      if (deferredPopulates.length > 0) {
+        deferredPopulatesPerParam.set(i, deferredPopulates);
+      }
     }
   } else {
     // By default, populate in parallel
     const promises = [];
     for (const arr of params) {
-      promises.push(_execPopulateQuery.apply(null, arr).then(valsFromDb => { vals = vals.concat(valsFromDb); }));
+      promises.push(_execPopulateQuery.apply(null, arr));
     }
 
-    await Promise.all(promises);
+    const results = await Promise.all(promises);
+    for (let i = 0; i < results.length; i++) {
+      const { docs, deferredPopulates } = results[i];
+      vals = vals.concat(docs);
+      if (deferredPopulates.length > 0) {
+        deferredPopulatesPerParam.set(i, deferredPopulates);
+      }
+    }
   }
 
 
@@ -4605,12 +4545,49 @@ async function _populatePath(model, docs, populateOptions) {
     _assign(model, vals, mod, assignmentOpts);
   }
 
+  // Handle deferred populate for cases with per-document match functions.
+  // We defer populate so sift filtering can compare ObjectIds (not populated docs).
+  // This handles both explicit sub-populate and populate added by pre('find') hooks.
+  // Each param's deferred populates are tracked separately to avoid mixing them
+  // between different models (e.g., when using refPath with multiple model types).
+  if (deferredPopulatesPerParam.size > 0) {
+    for (let i = 0; i < params.length; i++) {
+      const arr = params[i];
+      const mod = arr[0];
+      if (!Array.isArray(mod.match)) {
+        continue;
+      }
+
+      const paramDeferredPopulates = deferredPopulatesPerParam.get(i);
+      if (!paramDeferredPopulates || paramDeferredPopulates.length === 0) {
+        continue;
+      }
+
+      // Get the assigned (filtered) children from parent docs
+      const childDocsToPopulate = [];
+      for (const doc of mod.docs) {
+        const childVal = doc.$__ != null ? doc.get(mod.options.path) : doc[mod.options.path];
+        if (Array.isArray(childVal)) {
+          childDocsToPopulate.push(...childVal);
+        } else if (childVal != null) {
+          childDocsToPopulate.push(childVal);
+        }
+      }
+
+      if (childDocsToPopulate.length > 0) {
+        for (const pop of paramDeferredPopulates) {
+          await mod.model.populate(childDocsToPopulate, pop);
+        }
+      }
+    }
+  }
+
   for (const arr of params) {
     removeDeselectedForeignField(arr[0].foreignField, arr[0].options, vals);
   }
   for (const arr of params) {
     const mod = arr[0];
-    if (mod.options && mod.options.options && mod.options.options._leanTransform) {
+    if (mod.options?.options?._leanTransform) {
       for (const doc of vals) {
         mod.options.options._leanTransform(doc);
       }
@@ -4647,6 +4624,12 @@ function _execPopulateQuery(mod, match, select) {
     queryOptions.limit = queryOptions.limit * mod.ids.length;
   }
 
+  // When there's a per-document match function, defer any populate (including from hooks)
+  // until after sift filtering, otherwise sift compares ObjectIds against populated docs.
+  if (Array.isArray(mod.match)) {
+    queryOptions._deferPopulate = true;
+  }
+
   const query = mod.model.find(match, select, queryOptions);
   // If we're doing virtual populate and projection is inclusive and foreign
   // field is not selected, automatically select it because mongoose needs it.
@@ -4668,7 +4651,14 @@ function _execPopulateQuery(mod, match, select) {
     }
   }
 
-  // If we need to sub-populate, call populate recursively
+  // If we need to sub-populate, call populate recursively.
+  // However, if we have a per-document match function (Array.isArray(mod.match)),
+  // defer sub-populate until after sift filtering, otherwise sift compares
+  // ObjectIds against already-populated docs and fails to match.
+  const shouldDeferSubPopulate = subPopulate && Array.isArray(mod.match);
+
+  // Prepare sub-populate options with necessary metadata (_fullPath, strictPopulate, _localModel).
+  // This must be done for both immediate and deferred sub-populate cases.
   if (subPopulate) {
     // If subpopulating on a discriminator, skip check for non-existent
     // paths. Because the discriminator may not have the path defined.
@@ -4686,11 +4676,21 @@ function _execPopulateQuery(mod, match, select) {
     if (Array.isArray(subPopulate)) {
       for (const pop of subPopulate) {
         pop._fullPath = basePath + '.' + pop.path;
+        // Set _localModel for deferred populates so strictPopulate works correctly
+        if (shouldDeferSubPopulate && pop._localModel == null) {
+          pop._localModel = mod.model;
+        }
       }
     } else if (typeof subPopulate === 'object') {
       subPopulate._fullPath = basePath + '.' + subPopulate.path;
+      // Set _localModel for deferred populates so strictPopulate works correctly
+      if (shouldDeferSubPopulate && subPopulate._localModel == null) {
+        subPopulate._localModel = mod.model;
+      }
     }
+  }
 
+  if (subPopulate && !shouldDeferSubPopulate) {
     query.populate(subPopulate);
   }
 
@@ -4699,7 +4699,16 @@ function _execPopulateQuery(mod, match, select) {
       for (const val of docs) {
         leanPopulateMap.set(val, mod.model);
       }
-      return docs;
+      // Return both docs and any deferred populates (from hooks or explicit sub-populate)
+      const deferredPopulates = [];
+      if (query._deferredPopulate) {
+        deferredPopulates.push(...query._deferredPopulate);
+        delete query._deferredPopulate;
+      }
+      if (shouldDeferSubPopulate) {
+        deferredPopulates.push(subPopulate);
+      }
+      return { docs, deferredPopulates };
     }
   );
 }
@@ -4741,14 +4750,7 @@ function _assign(model, vals, mod, assignmentOpts) {
           if (__val instanceof Document) {
             __val = __val._doc._id;
           }
-          if (__val?.constructor?.name === 'Binary' && __val.sub_type === 4 && typeof __val.toUUID === 'function') {
-            // Workaround for gh-15315 because Mongoose UUIDs don't use BSON UUIDs yet.
-            key = String(__val.toUUID());
-          } else if (__val?.constructor?.name === 'Buffer' && __val._subtype === 4 && typeof __val.toUUID === 'function') {
-            key = String(__val.toUUID());
-          } else {
-            key = String(__val);
-          }
+          key = String(__val);
           if (rawDocs[key]) {
             if (Array.isArray(rawDocs[key])) {
               rawDocs[key].push(val);
@@ -4771,14 +4773,7 @@ function _assign(model, vals, mod, assignmentOpts) {
         if (_val instanceof Document) {
           _val = _val._doc._id;
         }
-        if (_val?.constructor?.name === 'Binary' && _val.sub_type === 4 && typeof _val.toUUID === 'function') {
-          // Workaround for gh-15315 because Mongoose UUIDs don't use BSON UUIDs yet.
-          key = String(_val.toUUID());
-        } else if (_val?.constructor?.name === 'Buffer' && _val._subtype === 4 && typeof _val.toUUID === 'function') {
-          key = String(_val.toUUID());
-        } else {
-          key = String(_val);
-        }
+        key = String(_val);
         if (rawDocs[key]) {
           if (Array.isArray(rawDocs[key])) {
             rawDocs[key].push(val);
@@ -4830,9 +4825,9 @@ function _assign(model, vals, mod, assignmentOpts) {
 /**
  * Compiler utility.
  *
- * @param {String|Function} name model name or class extending Model
+ * @param {string|Function} name model name or class extending Model
  * @param {Schema} schema
- * @param {String} collectionName
+ * @param {string} collectionName
  * @param {Connection} connection
  * @param {Mongoose} base mongoose instance
  * @api private
@@ -4899,7 +4894,6 @@ Model.compile = function compile(name, schema, collectionName, connection, base)
   model.events = new EventEmitter();
 
   schema._preCompile();
-
   const _userProvidedOptions = schema._userProvidedOptions || {};
 
   const collectionOptions = {
@@ -4955,7 +4949,7 @@ Model.compile = function compile(name, schema, collectionName, connection, base)
 Model.clientEncryption = function clientEncryption() {
   const ClientEncryption = this.base.driver.get().ClientEncryption;
   if (!ClientEncryption) {
-    throw new Error('The mongodb driver must be used to obtain a ClientEncryption object.');
+    throw new MongooseError('The mongodb driver must be used to obtain a ClientEncryption object.');
   }
 
   const client = this.collection?.conn?.client;
@@ -5026,7 +5020,7 @@ function applyQueryMethods(model, methods) {
  *
  * @param {Connection} conn
  * @param {Schema} [schema]
- * @param {String} [collection]
+ * @param {string} [collection]
  * @return {Model}
  * @api private
  * @memberOf Model
@@ -5179,7 +5173,7 @@ Model._applyQueryMiddleware = function _applyQueryMiddleware() {
       return !!contexts.query;
     }
     if (hook.name === 'deleteOne' || hook.name === 'updateOne') {
-      return !!contexts.query || Object.keys(contexts).length === 0;
+      return !!contexts.query || utils.hasOwnKeys(contexts) === false;
     }
     if (hook.query != null || hook.document != null) {
       return !!hook.query;