mongodb 6.10.0 → 6.11.0-dev.20241123.sha.32f7ac63

package/src/operations/run_command.ts

@@ -5,6 +5,7 @@ import { type TODO_NODE_3286 } from '../mongo_types';
 import type { ReadPreferenceLike } from '../read_preference';
 import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
+import { type TimeoutContext } from '../timeout';
 import { MongoDBNamespace } from '../utils';
 import { AbstractOperation } from './operation';
 
@@ -14,6 +15,13 @@ export type RunCommandOptions = {
   session?: ClientSession;
   /** The read preference */
   readPreference?: ReadPreferenceLike;
+  /**
+   * @experimental
+   * Specifies the time an operation will run until it throws a timeout error
+   */
+  timeoutMS?: number;
+  /** @internal */
+  omitMaxTimeMS?: boolean;
 } & BSONSerializeOptions;
 
 /** @internal */
@@ -31,7 +39,11 @@ export class RunCommandOperation<T = Document> extends AbstractOperation<T> {
     return 'runCommand' as const;
   }
 
-  override async execute(server: Server, session: ClientSession | undefined): Promise<T> {
+  override async execute(
+    server: Server,
+    session: ClientSession | undefined,
+    timeoutContext: TimeoutContext
+  ): Promise<T> {
     this.server = server;
     const res: TODO_NODE_3286 = await server.command(
       this.ns,
@@ -39,10 +51,12 @@ export class RunCommandOperation<T = Document> extends AbstractOperation<T> {
       {
         ...this.options,
         readPreference: this.readPreference,
-        session
+        session,
+        timeoutContext
       },
       this.options.responseType
     );
+
     return res;
   }
 }
@@ -63,12 +77,17 @@ export class RunAdminCommandOperation<T = Document> extends AbstractOperation<T>
     return 'runCommand' as const;
   }
 
-  override async execute(server: Server, session: ClientSession | undefined): Promise<T> {
+  override async execute(
+    server: Server,
+    session: ClientSession | undefined,
+    timeoutContext: TimeoutContext
+  ): Promise<T> {
     this.server = server;
     const res: TODO_NODE_3286 = await server.command(this.ns, this.command, {
       ...this.options,
       readPreference: this.readPreference,
-      session
+      session,
+      timeoutContext
     });
     return res;
   }

package/src/operations/search_indexes/create.ts

@@ -2,6 +2,7 @@ import type { Document } from '../../bson';
 import type { Collection } from '../../collection';
 import type { Server } from '../../sdam/server';
 import type { ClientSession } from '../../sessions';
+import { type TimeoutContext } from '../../timeout';
 import { AbstractOperation } from '../operation';
 
 /**
@@ -31,14 +32,21 @@ export class CreateSearchIndexesOperation extends AbstractOperation<string[]> {
     return 'createSearchIndexes' as const;
   }
 
-  override async execute(server: Server, session: ClientSession | undefined): Promise<string[]> {
+  override async execute(
+    server: Server,
+    session: ClientSession | undefined,
+    timeoutContext: TimeoutContext
+  ): Promise<string[]> {
     const namespace = this.collection.fullNamespace;
     const command = {
       createSearchIndexes: namespace.collection,
       indexes: this.descriptions
     };
 
-    const res = await server.command(namespace, command, { session });
+    const res = await server.command(namespace, command, {
+      session,
+      timeoutContext
+    });
 
     const indexesCreated: Array<{ name: string }> = res?.indexesCreated ?? [];
     return indexesCreated.map(({ name }) => name);

package/src/operations/search_indexes/drop.ts

@@ -3,6 +3,7 @@ import type { Collection } from '../../collection';
 import { MONGODB_ERROR_CODES, MongoServerError } from '../../error';
 import type { Server } from '../../sdam/server';
 import type { ClientSession } from '../../sessions';
+import { type TimeoutContext } from '../../timeout';
 import { AbstractOperation } from '../operation';
 
 /** @internal */
@@ -18,7 +19,11 @@ export class DropSearchIndexOperation extends AbstractOperation<void> {
     return 'dropSearchIndex' as const;
   }
 
-  override async execute(server: Server, session: ClientSession | undefined): Promise<void> {
+  override async execute(
+    server: Server,
+    session: ClientSession | undefined,
+    timeoutContext: TimeoutContext
+  ): Promise<void> {
     const namespace = this.collection.fullNamespace;
 
     const command: Document = {
@@ -30,7 +35,7 @@ export class DropSearchIndexOperation extends AbstractOperation<void> {
     }
 
     try {
-      await server.command(namespace, command, { session });
+      await server.command(namespace, command, { session, timeoutContext });
     } catch (error) {
       const isNamespaceNotFoundError =
         error instanceof MongoServerError && error.code === MONGODB_ERROR_CODES.NamespaceNotFound;

package/src/operations/search_indexes/update.ts

@@ -2,6 +2,7 @@ import type { Document } from '../../bson';
 import type { Collection } from '../../collection';
 import type { Server } from '../../sdam/server';
 import type { ClientSession } from '../../sessions';
+import { type TimeoutContext } from '../../timeout';
 import { AbstractOperation } from '../operation';
 
 /** @internal */
@@ -18,7 +19,11 @@ export class UpdateSearchIndexOperation extends AbstractOperation<void> {
     return 'updateSearchIndex' as const;
   }
 
-  override async execute(server: Server, session: ClientSession | undefined): Promise<void> {
+  override async execute(
+    server: Server,
+    session: ClientSession | undefined,
+    timeoutContext: TimeoutContext
+  ): Promise<void> {
     const namespace = this.collection.fullNamespace;
     const command = {
       updateSearchIndex: namespace.collection,
@@ -26,7 +31,7 @@ export class UpdateSearchIndexOperation extends AbstractOperation<void> {
       definition: this.definition
     };
 
-    await server.command(namespace, command, { session });
+    await server.command(namespace, command, { session, timeoutContext });
     return;
   }
 }

package/src/operations/set_profiling_level.ts

@@ -2,6 +2,7 @@ import type { Db } from '../db';
 import { MongoInvalidArgumentError } from '../error';
 import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
+import { type TimeoutContext } from '../timeout';
 import { enumToString } from '../utils';
 import { CommandOperation, type CommandOperationOptions } from './command';
 
@@ -53,7 +54,8 @@ export class SetProfilingLevelOperation extends CommandOperation<ProfilingLevel>
 
   override async execute(
     server: Server,
-    session: ClientSession | undefined
+    session: ClientSession | undefined,
+    timeoutContext: TimeoutContext
   ): Promise<ProfilingLevel> {
     const level = this.level;
 
@@ -64,7 +66,7 @@ export class SetProfilingLevelOperation extends CommandOperation<ProfilingLevel>
     }
 
     // TODO(NODE-3483): Determine error to put here
-    await super.executeCommand(server, session, { profile: this.profile });
+    await super.executeCommand(server, session, { profile: this.profile }, timeoutContext);
     return level;
   }
 }

package/src/operations/stats.ts

@@ -2,6 +2,7 @@ import type { Document } from '../bson';
 import type { Db } from '../db';
 import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
+import { type TimeoutContext } from '../timeout';
 import { CommandOperation, type CommandOperationOptions } from './command';
 import { Aspect, defineAspects } from './operation';
 
@@ -24,13 +25,17 @@ export class DbStatsOperation extends CommandOperation<Document> {
     return 'dbStats' as const;
   }
 
-  override async execute(server: Server, session: ClientSession | undefined): Promise<Document> {
+  override async execute(
+    server: Server,
+    session: ClientSession | undefined,
+    timeoutContext: TimeoutContext
+  ): Promise<Document> {
     const command: Document = { dbStats: true };
     if (this.options.scale != null) {
       command.scale = this.options.scale;
     }
 
-    return await super.executeCommand(server, session, command);
+    return await super.executeCommand(server, session, command, timeoutContext);
   }
 }
 

package/src/operations/update.ts

@@ -4,6 +4,7 @@ import { MongoCompatibilityError, MongoInvalidArgumentError, MongoServerError }
 import type { InferIdType, TODO_NODE_3286 } from '../mongo_types';
 import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
+import { type TimeoutContext } from '../timeout';
 import { hasAtomicOperators, type MongoDBNamespace } from '../utils';
 import { type CollationOptions, CommandOperation, type CommandOperationOptions } from './command';
 import { Aspect, defineAspects, type Hint } from './operation';
@@ -91,7 +92,11 @@ export class UpdateOperation extends CommandOperation<Document> {
     return this.statements.every(op => op.multi == null || op.multi === false);
   }
 
-  override async execute(server: Server, session: ClientSession | undefined): Promise<Document> {
+  override async execute(
+    server: Server,
+    session: ClientSession | undefined,
+    timeoutContext: TimeoutContext
+  ): Promise<Document> {
     const options = this.options ?? {};
     const ordered = typeof options.ordered === 'boolean' ? options.ordered : true;
     const command: Document = {
@@ -122,7 +127,7 @@ export class UpdateOperation extends CommandOperation<Document> {
       }
     }
 
-    const res = await super.executeCommand(server, session, command);
+    const res = await super.executeCommand(server, session, command, timeoutContext);
     return res;
   }
 }
@@ -143,9 +148,10 @@ export class UpdateOneOperation extends UpdateOperation {
 
   override async execute(
     server: Server,
-    session: ClientSession | undefined
+    session: ClientSession | undefined,
+    timeoutContext: TimeoutContext
   ): Promise<UpdateResult> {
-    const res: TODO_NODE_3286 = await super.execute(server, session);
+    const res: TODO_NODE_3286 = await super.execute(server, session, timeoutContext);
     if (this.explain != null) return res;
     if (res.code) throw new MongoServerError(res);
     if (res.writeErrors) throw new MongoServerError(res.writeErrors[0]);
@@ -177,9 +183,10 @@ export class UpdateManyOperation extends UpdateOperation {
 
   override async execute(
     server: Server,
-    session: ClientSession | undefined
+    session: ClientSession | undefined,
+    timeoutContext: TimeoutContext
   ): Promise<UpdateResult> {
-    const res: TODO_NODE_3286 = await super.execute(server, session);
+    const res: TODO_NODE_3286 = await super.execute(server, session, timeoutContext);
     if (this.explain != null) return res;
     if (res.code) throw new MongoServerError(res);
     if (res.writeErrors) throw new MongoServerError(res.writeErrors[0]);
@@ -230,9 +237,10 @@ export class ReplaceOneOperation extends UpdateOperation {
 
   override async execute(
     server: Server,
-    session: ClientSession | undefined
+    session: ClientSession | undefined,
+    timeoutContext: TimeoutContext
   ): Promise<UpdateResult> {
-    const res: TODO_NODE_3286 = await super.execute(server, session);
+    const res: TODO_NODE_3286 = await super.execute(server, session, timeoutContext);
     if (this.explain != null) return res;
     if (res.code) throw new MongoServerError(res);
     if (res.writeErrors) throw new MongoServerError(res.writeErrors[0]);

package/src/operations/validate_collection.ts

@@ -3,6 +3,7 @@ import type { Document } from '../bson';
 import { MongoUnexpectedServerResponseError } from '../error';
 import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
+import { type TimeoutContext } from '../timeout';
 import { CommandOperation, type CommandOperationOptions } from './command';
 
 /** @public */
@@ -37,10 +38,14 @@ export class ValidateCollectionOperation extends CommandOperation<Document> {
     return 'validate' as const;
   }
 
-  override async execute(server: Server, session: ClientSession | undefined): Promise<Document> {
+  override async execute(
+    server: Server,
+    session: ClientSession | undefined,
+    timeoutContext: TimeoutContext
+  ): Promise<Document> {
     const collectionName = this.collectionName;
 
-    const doc = await super.executeCommand(server, session, this.command);
+    const doc = await super.executeCommand(server, session, this.command, timeoutContext);
     if (doc.result != null && typeof doc.result !== 'string')
       throw new MongoUnexpectedServerResponseError('Error with validation data');
     if (doc.result != null && doc.result.match(/exception|corrupt/) != null)

package/src/read_concern.ts

@@ -31,7 +31,7 @@ export class ReadConcern {
      * A spec test exists that allows level to be any string.
      * "invalid readConcern with out stage"
      * @see ./test/spec/crud/v2/aggregate-out-readConcern.json
-     * @see https://github.com/mongodb/specifications/blob/master/source/read-write-concern/read-write-concern.rst#unknown-levels-and-additional-options-for-string-based-readconcerns
+     * @see https://github.com/mongodb/specifications/blob/master/source/read-write-concern/read-write-concern.md#unknown-levels-and-additional-options-for-string-based-readconcerns
      */
     this.level = ReadConcernLevel[level] ?? level;
   }

package/src/sdam/common.ts

@@ -1,5 +1,3 @@
-import { clearTimeout } from 'timers';
-
 import type { Binary, Long, Timestamp } from '../bson';
 import type { ClientSession } from '../sessions';
 import type { Topology } from './topology';
@@ -46,15 +44,6 @@ export const ServerType = Object.freeze({
 /** @public */
 export type ServerType = (typeof ServerType)[keyof typeof ServerType];
 
-/** @internal */
-export type TimerQueue = Set<NodeJS.Timeout>;
-
-/** @internal */
-export function drainTimerQueue(queue: TimerQueue): void {
-  queue.forEach(clearTimeout);
-  queue.clear();
-}
-
 /**
  * @public
  * Gossiped in component for the cluster time tracking the state of user databases

package/src/sdam/server.ts

@@ -40,6 +40,7 @@ import type { ServerApi } from '../mongo_client';
 import { TypedEventEmitter } from '../mongo_types';
 import type { GetMoreOptions } from '../operations/get_more';
 import type { ClientSession } from '../sessions';
+import { type TimeoutContext } from '../timeout';
 import { isTransactionCommand } from '../transactions';
 import {
   type EventEmitterWithState,
@@ -104,6 +105,11 @@ export type ServerEvents = {
 } & ConnectionPoolEvents &
   EventEmitterWithState;
 
+/** @internal */
+export type ServerCommandOptions = Omit<CommandOptions, 'timeoutContext' | 'socketTimeoutMS'> & {
+  timeoutContext: TimeoutContext;
+};
+
 /** @internal */
 export class Server extends TypedEventEmitter<ServerEvents> {
   /** @internal */
@@ -267,20 +273,20 @@ export class Server extends TypedEventEmitter<ServerEvents> {
   public async command<T extends MongoDBResponseConstructor>(
     ns: MongoDBNamespace,
     command: Document,
-    options: CommandOptions | undefined,
+    options: ServerCommandOptions,
     responseType: T | undefined
   ): Promise<typeof responseType extends undefined ? Document : InstanceType<T>>;
 
   public async command(
     ns: MongoDBNamespace,
     command: Document,
-    options?: CommandOptions
+    options: ServerCommandOptions
   ): Promise<Document>;
 
   public async command(
     ns: MongoDBNamespace,
     cmd: Document,
-    options: CommandOptions,
+    options: ServerCommandOptions,
     responseType?: MongoDBResponseConstructor
   ): Promise<Document> {
     if (ns.db == null || typeof ns === 'string') {
@@ -305,13 +311,17 @@ export class Server extends TypedEventEmitter<ServerEvents> {
       delete finalOptions.readPreference;
     }
 
+    if (this.description.iscryptd) {
+      finalOptions.omitMaxTimeMS = true;
+    }
+
     const session = finalOptions.session;
     let conn = session?.pinnedConnection;
 
     this.incrementOperationCount();
     if (conn == null) {
       try {
-        conn = await this.pool.checkOut();
+        conn = await this.pool.checkOut(options);
         if (this.loadBalanced && isPinnableCommand(cmd, session)) {
           session?.pin(conn);
         }

package/src/sdam/server_description.ts

@@ -75,6 +75,8 @@ export class ServerDescription {
   maxWriteBatchSize: number | null;
   /** The max bson object size. */
   maxBsonObjectSize: number | null;
+  /** Indicates server is a mongocryptd instance. */
+  iscryptd: boolean;
 
   // NOTE: does this belong here? It seems we should gossip the cluster time at the CMAP level
   $clusterTime?: ClusterTime;
@@ -123,6 +125,7 @@ export class ServerDescription {
     this.primary = hello?.primary ?? null;
     this.me = hello?.me?.toLowerCase() ?? null;
     this.$clusterTime = hello?.$clusterTime ?? null;
+    this.iscryptd = Boolean(hello?.iscryptd);
   }
 
   get hostAddress(): HostAddress {
@@ -159,8 +162,8 @@ export class ServerDescription {
   }
 
   /**
-   * Determines if another `ServerDescription` is equal to this one per the rules defined
-   * in the {@link https://github.com/mongodb/specifications/blob/master/source/server-discovery-and-monitoring/server-discovery-and-monitoring.rst#serverdescription|SDAM spec}
+   * Determines if another `ServerDescription` is equal to this one per the rules defined in the SDAM specification.
+   * @see https://github.com/mongodb/specifications/blob/master/source/server-discovery-and-monitoring/server-discovery-and-monitoring.md
    */
   equals(other?: ServerDescription | null): boolean {
     // Despite using the comparator that would determine a nullish topologyVersion as greater than
@@ -176,6 +179,7 @@ export class ServerDescription {
 
     return (
       other != null &&
+      other.iscryptd === this.iscryptd &&
       errorStrictEqual(this.error, other.error) &&
       this.type === other.type &&
       this.minWireVersion === other.minWireVersion &&

package/src/sdam/server_selection.ts

@@ -75,7 +75,9 @@ export function secondaryWritableServerSelector(
 
 /**
  * Reduces the passed in array of servers by the rules of the "Max Staleness" specification
- * found here: https://github.com/mongodb/specifications/blob/master/source/max-staleness/max-staleness.rst
+ * found here:
+ *
+ * @see https://github.com/mongodb/specifications/blob/master/source/max-staleness/max-staleness.md
  *
  * @param readPreference - The read preference providing max staleness guidance
  * @param topologyDescription - The topology description
@@ -212,7 +214,8 @@ function tagSetReducer(
 /**
  * Reduces a list of servers to ensure they fall within an acceptable latency window. This is
  * further specified in the "Server Selection" specification, found here:
- * https://github.com/mongodb/specifications/blob/master/source/server-selection/server-selection.rst
+ *
+ * @see https://github.com/mongodb/specifications/blob/master/source/server-selection/server-selection.md
  *
  * @param topologyDescription - The topology description
  * @param servers - The list of servers to reduce

package/src/sdam/topology.ts

@@ -24,6 +24,7 @@ import {
   type MongoDriverError,
   MongoError,
   MongoErrorLabel,
+  MongoOperationTimeoutError,
   MongoRuntimeError,
   MongoServerSelectionError,
   MongoTopologyClosedError
@@ -33,7 +34,7 @@ import { MongoLoggableComponent, type MongoLogger, SeverityLevel } from '../mong
 import { TypedEventEmitter } from '../mongo_types';
 import { ReadPreference, type ReadPreferenceLike } from '../read_preference';
 import type { ClientSession } from '../sessions';
-import { Timeout, TimeoutError } from '../timeout';
+import { Timeout, TimeoutContext, TimeoutError } from '../timeout';
 import type { Transaction } from '../transactions';
 import {
   type Callback,
@@ -49,13 +50,11 @@ import {
 import {
   _advanceClusterTime,
   type ClusterTime,
-  drainTimerQueue,
   ServerType,
   STATE_CLOSED,
   STATE_CLOSING,
   STATE_CONNECTED,
   STATE_CONNECTING,
-  type TimerQueue,
   TopologyType
 } from './common';
 import {
@@ -107,7 +106,6 @@ export interface ServerSelectionRequest {
   resolve: (server: Server) => void;
   reject: (error: MongoError) => void;
   [kCancelled]?: boolean;
-  timeout: Timeout;
   operationName: string;
   waitingLogged: boolean;
   previousServer?: ServerDescription;
@@ -132,8 +130,6 @@ export interface TopologyPrivate {
   servers: Map<string, Server>;
   credentials?: MongoCredentials;
   clusterTime?: ClusterTime;
-  /** timers created for the initial connect to a server */
-  connectionTimers: TimerQueue;
 
   /** related to srv polling */
   srvPoller?: SrvPoller;
@@ -178,8 +174,11 @@ export interface SelectServerOptions {
   session?: ClientSession;
   operationName: string;
   previousServer?: ServerDescription;
-  /** @internal*/
-  timeout?: Timeout;
+  /**
+   * @internal
+   * TODO(NODE-6496): Make this required by making ChangeStream use LegacyTimeoutContext
+   * */
+  timeoutContext?: TimeoutContext;
 }
 
 /** @public */
@@ -322,8 +321,6 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
       credentials: options?.credentials,
       clusterTime: undefined,
 
-      // timer management
-      connectionTimers: new Set<NodeJS.Timeout>(),
       detectShardedTopology: ev => this.detectShardedTopology(ev),
       detectSrvRecords: ev => this.detectSrvRecords(ev)
     };
@@ -412,8 +409,6 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
     } finally {
       this.connectionLock = undefined;
     }
-
-    return this;
   }
 
   private async _connect(options?: ConnectOptions): Promise<Topology> {
@@ -457,17 +452,28 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
       }
     }
 
+    const serverSelectionTimeoutMS = this.client.s.options.serverSelectionTimeoutMS;
     const readPreference = options.readPreference ?? ReadPreference.primary;
-    const selectServerOptions = { operationName: 'ping', ...options };
+    const timeoutContext = TimeoutContext.create({
+      // TODO(NODE-6448): auto-connect ignores timeoutMS; potential future feature
+      timeoutMS: undefined,
+      serverSelectionTimeoutMS,
+      waitQueueTimeoutMS: this.client.s.options.waitQueueTimeoutMS
+    });
+    const selectServerOptions = {
+      operationName: 'ping',
+      ...options,
+      timeoutContext
+    };
+
     try {
       const server = await this.selectServer(
         readPreferenceServerSelector(readPreference),
         selectServerOptions
       );
-
       const skipPingOnConnect = this.s.options[Symbol.for('@@mdb.skipPingOnConnect')] === true;
-      if (!skipPingOnConnect && server && this.s.credentials) {
-        await server.command(ns('admin.$cmd'), { ping: 1 }, {});
+      if (!skipPingOnConnect && this.s.credentials) {
+        await server.command(ns('admin.$cmd'), { ping: 1 }, { timeoutContext });
         stateTransition(this, STATE_CONNECTED);
         this.emit(Topology.OPEN, this);
         this.emit(Topology.CONNECT, this);
@@ -501,7 +507,6 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
     stateTransition(this, STATE_CLOSING);
 
     drainWaitQueue(this[kWaitQueue], new MongoTopologyClosedError());
-    drainTimerQueue(this.s.connectionTimers);
 
     if (this.s.srvPoller) {
       this.s.srvPoller.stop();
@@ -556,6 +561,11 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
         new ServerSelectionStartedEvent(selector, this.description, options.operationName)
       );
     }
+    let timeout;
+    if (options.timeoutContext) timeout = options.timeoutContext.serverSelectionTimeout;
+    else {
+      timeout = Timeout.expires(options.serverSelectionTimeoutMS ?? 0);
+    }
 
     const isSharded = this.description.type === TopologyType.Sharded;
     const session = options.session;
@@ -578,11 +588,12 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
           )
         );
       }
+      if (options.timeoutContext?.clearServerSelectionTimeout) timeout?.clear();
       return transaction.server;
     }
 
     const { promise: serverPromise, resolve, reject } = promiseWithResolvers<Server>();
-    const timeout = Timeout.expires(options.serverSelectionTimeoutMS ?? 0);
+
     const waitQueueMember: ServerSelectionRequest = {
       serverSelector,
       topologyDescription: this.description,
@@ -590,7 +601,6 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
       transaction,
       resolve,
       reject,
-      timeout,
       startTime: now(),
       operationName: options.operationName,
       waitingLogged: false,
@@ -601,14 +611,18 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
     processWaitQueue(this);
 
     try {
-      return await Promise.race([serverPromise, waitQueueMember.timeout]);
+      timeout?.throwIfExpired();
+      const server = await (timeout ? Promise.race([serverPromise, timeout]) : serverPromise);
+      if (options.timeoutContext?.csotEnabled() && server.description.minRoundTripTime !== 0) {
+        options.timeoutContext.minRoundTripTime = server.description.minRoundTripTime;
+      }
+      return server;
     } catch (error) {
       if (TimeoutError.is(error)) {
         // Timeout
         waitQueueMember[kCancelled] = true;
-        timeout.clear();
         const timeoutError = new MongoServerSelectionError(
-          `Server selection timed out after ${options.serverSelectionTimeoutMS} ms`,
+          `Server selection timed out after ${timeout?.duration} ms`,
           this.description
         );
         if (
@@ -628,10 +642,17 @@ export class Topology extends TypedEventEmitter<TopologyEvents> {
           );
         }
 
+        if (options.timeoutContext?.csotEnabled()) {
+          throw new MongoOperationTimeoutError('Timed out during server selection', {
+            cause: timeoutError
+          });
+        }
         throw timeoutError;
       }
       // Other server selection error
       throw error;
+    } finally {
+      if (options.timeoutContext?.clearServerSelectionTimeout) timeout?.clear();
     }
   }
   /**
@@ -889,8 +910,6 @@ function drainWaitQueue(queue: List<ServerSelectionRequest>, drainError: MongoDr
       continue;
     }
 
-    waitQueueMember.timeout.clear();
-
     if (!waitQueueMember[kCancelled]) {
       if (
         waitQueueMember.mongoLogger?.willLog(
@@ -944,7 +963,6 @@ function processWaitQueue(topology: Topology) {
           )
         : serverDescriptions;
     } catch (selectorError) {
-      waitQueueMember.timeout.clear();
       if (
         topology.client.mongoLogger?.willLog(
           MongoLoggableComponent.SERVER_SELECTION,
@@ -1032,8 +1050,6 @@ function processWaitQueue(topology: Topology) {
       transaction.pinServer(selectedServer);
     }
 
-    waitQueueMember.timeout.clear();
-
     if (
       topology.client.mongoLogger?.willLog(
         MongoLoggableComponent.SERVER_SELECTION,