@use-tusk/drift-node-sdk 0.1.34 → 0.1.36

package/dist/index.js

@@ -1,10 +1,10 @@
 import { createRequire } from "node:module";
 import * as fs$1 from "fs";
 import fs from "fs";
+import os from "os";
 import * as path$1 from "path";
 import path, { normalize } from "path";
-import { parse, satisfies } from "semver";
-import os from "os";
+import { satisfies } from "semver";
 import { Hook } from "require-in-the-middle";
 import { Hook as Hook$1 } from "import-in-the-middle";
 import yaml from "js-yaml";
@@ -55,207 +55,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
-//#endregion
-//#region src/nextjs/utils.ts
-/**
-* Get the installed Next.js version by reading package.json from node_modules.
-*
-* @returns The Next.js version string, or undefined if not found
-*/
-function getNextjsVersion() {
-	try {
-		const nextPackageJsonPath = path$1.join(process.cwd(), "node_modules", "next", "package.json");
-		if (fs$1.existsSync(nextPackageJsonPath)) return JSON.parse(fs$1.readFileSync(nextPackageJsonPath, "utf-8")).version;
-	} catch (error) {}
-}
-/**
-* Parse a semantic version string into its components.
-*
-* @param version - The version string to parse (e.g., "15.0.0-canary.124")
-* @returns Parsed version object with major, minor, patch, and prerelease
-*/
-function parseVersion(version$1) {
-	try {
-		const parsed = parse(version$1);
-		if (!parsed) return {
-			major: void 0,
-			minor: void 0,
-			patch: void 0,
-			prerelease: void 0
-		};
-		return {
-			major: parsed.major,
-			minor: parsed.minor,
-			patch: parsed.patch,
-			prerelease: parsed.prerelease.length > 0 ? parsed.prerelease.join(".") : void 0
-		};
-	} catch {
-		return {
-			major: void 0,
-			minor: void 0,
-			patch: void 0,
-			prerelease: void 0
-		};
-	}
-}
-/**
-* Check if the Next.js version requires the instrumentationHook to be set.
-* From Next.js 15.0.0-rc.1 onwards, the instrumentationHook is no longer needed
-* and Next.js will warn if it's set.
-*
-* @param version - The Next.js version string
-* @returns true if instrumentationHook should be set, false otherwise
-*/
-function shouldSetInstrumentationHook(version$1) {
-	if (!version$1) return true;
-	const { major: major$1, minor, patch, prerelease } = parseVersion(version$1);
-	if (major$1 === void 0 || minor === void 0 || patch === void 0) return true;
-	if (major$1 >= 16) return false;
-	if (major$1 < 15) return true;
-	if (major$1 === 15) {
-		if (minor > 0 || patch > 0) return false;
-		if (minor === 0 && patch === 0 && prerelease === void 0) return false;
-		if (prerelease?.startsWith("rc.")) {
-			if (parseInt(prerelease.split(".")[1] || "0", 10) >= 1) return false;
-		}
-		if (prerelease?.startsWith("canary.")) {
-			if (parseInt(prerelease.split(".")[1] || "0", 10) >= 124) return false;
-		}
-		return true;
-	}
-	return true;
-}
-/**
-* Log a message if debug mode is enabled.
-*
-* @param debug - Whether debug mode is enabled
-* @param message - The message to log
-*/
-function debugLog(debug, message) {
-	if (debug) console.log(`[Tusk Drift] ${message}`);
-}
-/**
-* Log a warning message if warnings are not suppressed.
-*
-* @param suppress - Whether to suppress the warning
-* @param message - The warning message to log
-*/
-function warn(suppress, message) {
-	if (!suppress) console.warn(`[Tusk Drift] ${message}`);
-}
-
-//#endregion
-//#region src/nextjs/withTuskDrift.ts
-/**
-* Wraps your Next.js configuration with Tusk Drift instrumentation setup.
-*
-* This function automatically configures Next.js to work with Tusk Drift by:
-* - Enabling the Next.js instrumentation hook (for Next.js < 15.0.0-rc.1)
-* - Configuring server external packages to prevent bundling of core instrumentation packages
-* - Supporting both webpack and Turbopack bundlers
-* - Preserving your existing Next.js configuration and webpack customizations
-*
-* @param nextConfig - Your existing Next.js configuration object (optional)
-* @param options - Additional options to configure Tusk Drift's behavior (optional)
-* @returns The wrapped Next.js configuration with Tusk Drift instrumentation enabled
-*
-* @example
-* Basic usage:
-* ```javascript
-* // next.config.js
-* const { withTuskDrift } = require('@use-tusk/drift-node-sdk');
-*
-* module.exports = withTuskDrift({
-*   // Your Next.js config
-* });
-* ```
-*
-* @example
-* With debug logging:
-* ```javascript
-* // next.config.js
-* const { withTuskDrift } = require('@use-tusk/drift-node-sdk');
-*
-* module.exports = withTuskDrift(
-*   {
-*     // Your Next.js config
-*   },
-*   {
-*     debug: true,
-*   }
-* );
-* ```
-*
-* @remarks
-* The following packages are added as server externals for both webpack and Turbopack:
-* - `require-in-the-middle` - Required for CommonJS module interception
-* - `jsonpath` - Required for schema manipulation
-* - Additional packages when TUSK_DRIFT_MODE is RECORD or REPLAY (e.g., database clients, etc.)
-*
-* Works with both webpack (default) and Turbopack (`next dev --turbo`).
-*/
-function withTuskDrift(nextConfig = {}, options = {}) {
-	const config = nextConfig;
-	const debug = options.debug || false;
-	const suppressAllWarnings = options.suppressWarnings || false;
-	const nextjsVersion = getNextjsVersion();
-	if (nextjsVersion) debugLog(debug, `Detected Next.js version: ${nextjsVersion}`);
-	else warn(suppressAllWarnings || false, "Could not detect Next.js version. Some features may not work correctly. If you encounter issues, please ensure Next.js is properly installed.");
-	const needsInstrumentationHook = !options.disableInstrumentationHook && shouldSetInstrumentationHook(nextjsVersion);
-	const mode = process.env.TUSK_DRIFT_MODE?.toUpperCase();
-	const coreExternals = [
-		"require-in-the-middle",
-		"jsonpath",
-		...mode === "RECORD" || mode === "REPLAY" ? [
-			"@upstash/redis",
-			"ioredis",
-			"pg",
-			"postgres",
-			"mysql2",
-			"@prisma/client",
-			"@google-cloud/firestore",
-			"@grpc/grpc-js",
-			"graphql",
-			"jsonwebtoken",
-			"jwks-rsa"
-		] : []
-	];
-	const wrappedConfig = {
-		...config,
-		...needsInstrumentationHook ? { experimental: {
-			...config.experimental,
-			instrumentationHook: true
-		} } : { experimental: config.experimental },
-		serverExternalPackages: [...config.serverExternalPackages || [], ...coreExternals],
-		webpack: (webpackConfig, webpackOptions) => {
-			if (webpackOptions.isServer) {
-				const originalExternals = webpackConfig.externals;
-				const externalsMapping = {};
-				for (const pkg of coreExternals) {
-					externalsMapping[pkg] = `commonjs ${pkg}`;
-					debugLog(debug, `Mapped external ${pkg} -> commonjs ${pkg}`);
-				}
-				if (!originalExternals) {
-					webpackConfig.externals = [externalsMapping];
-					debugLog(debug, "Created new externals with SDK paths");
-				} else if (Array.isArray(originalExternals)) {
-					originalExternals.push(externalsMapping);
-					debugLog(debug, "Added SDK paths to existing externals array");
-				} else {
-					webpackConfig.externals = [originalExternals, externalsMapping];
-					debugLog(debug, "Wrapped existing externals with SDK paths");
-				}
-			}
-			if (typeof config.webpack === "function") return config.webpack(webpackConfig, webpackOptions);
-			return webpackConfig;
-		}
-	};
-	if (needsInstrumentationHook) debugLog(debug, "Set experimental.instrumentationHook to true");
-	else debugLog(debug, "Skipped setting experimental.instrumentationHook (not needed for Next.js 15.0.0-rc.1+)");
-	if (options.disableInstrumentationHook && nextjsVersion && shouldSetInstrumentationHook(nextjsVersion)) warn(suppressAllWarnings || false, "You disabled instrumentationHook, but your Next.js version requires it. Tusk Drift may not initialize properly. Please remove the disableInstrumentationHook option.");
-	return wrappedConfig;
-}
-
 //#endregion
 //#region src/instrumentation/core/baseClasses/TdInstrumentationAbstract.ts
 var TdInstrumentationAbstract = class {
@@ -293,6 +92,7 @@ var TdInstrumentationAbstract = class {
 function safeJsonStringify(obj) {
 	const seen = /* @__PURE__ */ new WeakSet();
 	return JSON.stringify(obj, (key, value) => {
+		if (typeof value === "bigint") return value.toString();
 		if (typeof value === "object" && value !== null) {
 			if (seen.has(value)) return "[Circular]";
 			seen.add(value);
@@ -7915,7 +7715,7 @@ var SpanUtils = class SpanUtils {
 				...addSpanAttributesOptions.submodule && { [TdSpanAttributes.SUBMODULE_NAME]: addSpanAttributesOptions.submodule },
 				...addSpanAttributesOptions.isPreAppStart && { [TdSpanAttributes.IS_PRE_APP_START]: addSpanAttributesOptions.isPreAppStart },
 				...addSpanAttributesOptions.inputValue && { [TdSpanAttributes.INPUT_VALUE]: createSpanInputValue(addSpanAttributesOptions.inputValue) },
-				...addSpanAttributesOptions.outputValue && { [TdSpanAttributes.OUTPUT_VALUE]: JSON.stringify(addSpanAttributesOptions.outputValue) },
+				...addSpanAttributesOptions.outputValue && { [TdSpanAttributes.OUTPUT_VALUE]: safeJsonStringify(addSpanAttributesOptions.outputValue) },
 				...addSpanAttributesOptions.inputSchemaMerges && { [TdSpanAttributes.INPUT_SCHEMA_MERGES]: JSON.stringify(addSpanAttributesOptions.inputSchemaMerges) },
 				...addSpanAttributesOptions.outputSchemaMerges && { [TdSpanAttributes.OUTPUT_SCHEMA_MERGES]: JSON.stringify(addSpanAttributesOptions.outputSchemaMerges) },
 				...addSpanAttributesOptions.metadata && { [TdSpanAttributes.METADATA]: JSON.stringify(addSpanAttributesOptions.metadata) },
@@ -18762,6 +18562,11 @@ var IORedisInstrumentation = class extends TdInstrumentationBase {
 				if (self.mode === TuskDriftMode.REPLAY) return handleReplayMode({
 					noOpRequestHandler: () => {
 						process.nextTick(() => {
+							this.status = "connecting";
+							this.emit("connecting");
+							this.status = "connect";
+							this.emit("connect");
+							this.status = "ready";
 							this.emit("ready");
 						});
 						return Promise.resolve();
@@ -18968,6 +18773,11 @@ var IORedisInstrumentation = class extends TdInstrumentationBase {
 	async _handleReplayConnect(thisContext) {
 		logger.debug(`[IORedisInstrumentation] Replaying IORedis connect`);
 		process.nextTick(() => {
+			thisContext.status = "connecting";
+			thisContext.emit("connecting");
+			thisContext.status = "connect";
+			thisContext.emit("connect");
+			thisContext.status = "ready";
 			thisContext.emit("ready");
 		});
 		return Promise.resolve();
@@ -22268,11 +22078,34 @@ let PrismaErrorClassName = /* @__PURE__ */ function(PrismaErrorClassName$1) {
 //#endregion
 //#region src/instrumentation/libraries/prisma/Instrumentation.ts
 var import_src$14 = /* @__PURE__ */ __toESM(require_src$7(), 1);
-var PrismaInstrumentation = class extends TdInstrumentationBase {
+/**
+* Prisma instrumentation for recording and replaying database operations.
+*
+* ## Type deserialization
+*
+* Prisma returns special JS types (Date, BigInt, Decimal, Buffer) for certain
+* column types. JSON round-trip during record/replay loses this type information.
+* We reconstruct types during replay using two strategies:
+*
+* 1. **Model-based operations** (findFirst, create, update, etc.): The middleware
+*    provides the model name, so we look up field types from `_runtimeDataModel`
+*    at replay time. No extra metadata needed during recording.
+*
+* 2. **Raw queries** ($queryRaw): No model name is available. During recording,
+*    we sniff JS types from the result and store a per-column `_tdTypeMap`
+*    (e.g., `{bigNum: "bigint", data: "bytes"}`). During replay, we use this
+*    map to reconstruct the values.
+*
+* Both strategies share `_reconstructSingleValue` for the actual conversion.
+* See docs/prisma-type-deserialization-bug.md for the full design doc.
+*/
+var PrismaInstrumentation = class PrismaInstrumentation extends TdInstrumentationBase {
 	constructor(config = {}) {
 		super("@prisma/client", config);
 		this.INSTRUMENTATION_NAME = "PrismaInstrumentation";
 		this.prismaErrorClasses = [];
+		this.prismaClient = null;
+		this.prismaNamespace = null;
 		this.mode = config.mode || TuskDriftMode.DISABLED;
 		this.tuskDrift = TuskDriftCore.getInstance();
 	}
@@ -22289,6 +22122,7 @@ var PrismaInstrumentation = class extends TdInstrumentationBase {
 			return prismaModule;
 		}
 		this._storePrismaErrorClasses(prismaModule);
+		this.prismaNamespace = prismaModule.Prisma || prismaModule;
 		logger.debug(`[PrismaInstrumentation] Wrapping PrismaClient constructor`);
 		this._wrap(prismaModule, "PrismaClient", (OriginalPrismaClient) => {
 			const self = this;
@@ -22296,7 +22130,9 @@ var PrismaInstrumentation = class extends TdInstrumentationBase {
 			return class TdPrismaClient {
 				constructor(...args) {
 					logger.debug(`[PrismaInstrumentation] Creating patched PrismaClient instance`);
-					return new OriginalPrismaClient(...args).$extends({ query: { async $allOperations({ model, operation, args: operationArgs, query }) {
+					const prismaClient = new OriginalPrismaClient(...args);
+					self.prismaClient = prismaClient;
+					const extendedClient = prismaClient.$extends({ query: { async $allOperations({ model, operation, args: operationArgs, query }) {
 						logger.debug(`[PrismaInstrumentation] $allOperations intercepted: ${model}.${operation}`);
 						return self._handlePrismaOperation({
 							model,
@@ -22305,6 +22141,22 @@ var PrismaInstrumentation = class extends TdInstrumentationBase {
 							query
 						});
 					} } });
+					if (self.mode === TuskDriftMode.REPLAY) {
+						const originalTransaction = extendedClient.$transaction.bind(extendedClient);
+						extendedClient.$transaction = async function(...txArgs) {
+							const firstArg = txArgs[0];
+							if (typeof firstArg === "function") {
+								logger.debug(`[PrismaInstrumentation] Replay: bypassing interactive $transaction DB connection`);
+								return firstArg(extendedClient);
+							}
+							if (Array.isArray(firstArg)) {
+								logger.debug(`[PrismaInstrumentation] Replay: bypassing sequential $transaction DB connection`);
+								return Promise.all(firstArg);
+							}
+							return originalTransaction(...txArgs);
+						};
+					}
+					return extendedClient;
 				}
 			};
 		});
@@ -22361,7 +22213,7 @@ var PrismaInstrumentation = class extends TdInstrumentationBase {
 					inputValue,
 					isPreAppStart
 				}, (spanInfo) => {
-					return this._handleRecordPrismaOperation(spanInfo, query, args);
+					return this._handleRecordPrismaOperation(spanInfo, query, args, model);
 				});
 			},
 			spanKind: import_src$14.SpanKind.CLIENT
@@ -22388,13 +22240,15 @@ var PrismaInstrumentation = class extends TdInstrumentationBase {
 			});
 		} else return query(args);
 	}
-	async _handleRecordPrismaOperation(spanInfo, query, args) {
+	async _handleRecordPrismaOperation(spanInfo, query, args, model) {
 		try {
 			logger.debug(`[PrismaInstrumentation] Recording Prisma operation`);
 			const result = await query(args);
+			const typeMap = model ? null : this._buildTypeMap(result);
 			const outputValue = {
 				prismaResult: result,
-				_tdOriginalFormat: "result"
+				_tdOriginalFormat: "result",
+				...typeMap && { _tdTypeMap: typeMap }
 			};
 			try {
 				SpanUtils.addSpanAttributes(spanInfo.span, { outputValue });
@@ -22457,8 +22311,158 @@ var PrismaInstrumentation = class extends TdInstrumentationBase {
 			});
 			throw errorObj;
 		}
+		let result = outputValue.prismaResult;
+		try {
+			if (inputValue.model) result = this._reconstructPrismaTypes(result, inputValue.model);
+			else if (outputValue._tdTypeMap) result = this._reconstructFromTypeMap(result, outputValue._tdTypeMap);
+		} catch (reconstructError) {
+			logger.debug(`[PrismaInstrumentation] Failed to reconstruct types: ${reconstructError}`);
+		}
 		SpanUtils.endSpan(spanInfo.span, { code: import_src$14.SpanStatusCode.OK });
-		return outputValue.prismaResult;
+		return result;
+	}
+	/**
+	* Sniff the JS type of a value returned by Prisma.
+	*
+	* Returns type names that mirror Prisma's internal `QueryIntrospectionBuiltinType`
+	* enum from `@prisma/client/runtime` (used in `deserializeRawResults.ts`):
+	*   "bigint" | "bytes" | "decimal" | "datetime"
+	*
+	* We don't import these types directly — we use our own string literals that
+	* match Prisma's naming convention so the type map is self-documenting and
+	* consistent with what Prisma would produce internally.
+	*/
+	_sniffType(value) {
+		if (typeof value === "bigint") return "bigint";
+		if (value instanceof Date) return "datetime";
+		if (Buffer.isBuffer(value) || value instanceof Uint8Array) return "bytes";
+		if (typeof value === "object" && value !== null && typeof value.toFixed === "function" && typeof value.toExponential === "function" && typeof value.toSignificantDigits === "function") return "decimal";
+		return null;
+	}
+	/**
+	* Build a per-column type map by sniffing values in the result.
+	* For arrays of objects (e.g., $queryRaw results), scans all rows to handle
+	* cases where the first row has null values but later rows don't.
+	* Returns null if no special types are detected.
+	*/
+	_buildTypeMap(result) {
+		if (result === null || result === void 0) return null;
+		const rows = Array.isArray(result) ? result : typeof result === "object" ? [result] : null;
+		if (!rows || rows.length === 0) return null;
+		const typeMap = {};
+		let hasTypes = false;
+		for (const row of rows) {
+			if (!row || typeof row !== "object") continue;
+			for (const [key, value] of Object.entries(row)) {
+				if (typeMap[key] || value === null || value === void 0) continue;
+				if (Array.isArray(value) && value.length > 0) {
+					const elemType = this._sniffType(value[0]);
+					if (elemType) {
+						typeMap[key] = `${elemType}-array`;
+						hasTypes = true;
+						continue;
+					}
+				}
+				const type = this._sniffType(value);
+				if (type) {
+					typeMap[key] = type;
+					hasTypes = true;
+				}
+			}
+			if (hasTypes && Object.keys(typeMap).length >= Object.keys(row).length) break;
+		}
+		return hasTypes ? typeMap : null;
+	}
+	/**
+	* Reconstruct types from a _tdTypeMap (used for $queryRaw and other model-less operations).
+	*/
+	_reconstructFromTypeMap(result, typeMap) {
+		if (result === null || result === void 0) return result;
+		const reconstructRow = (row) => {
+			if (typeof row !== "object" || row === null) return row;
+			for (const [key, type] of Object.entries(typeMap)) {
+				const value = row[key];
+				if (value === null || value === void 0) continue;
+				if (typeof type === "string" && type.endsWith("-array") && Array.isArray(value)) {
+					const baseType = type.replace("-array", "");
+					row[key] = value.map((v) => this._reconstructSingleValue(v, baseType));
+					continue;
+				}
+				row[key] = this._reconstructSingleValue(value, type);
+			}
+			return row;
+		};
+		if (Array.isArray(result)) return result.map(reconstructRow);
+		return reconstructRow(result);
+	}
+	/**
+	* Reconstruct a single value from its JSON-deserialized form back to the
+	* original JS type that Prisma would have returned.
+	*
+	* The `type` parameter uses the same names as Prisma's query engine types
+	* (see _sniffType and PRISMA_SCHEMA_TO_ENGINE_TYPE). Both the model-based
+	* and raw-query replay paths converge here.
+	*/
+	_reconstructSingleValue(value, type) {
+		if (value === null || value === void 0) return value;
+		switch (type) {
+			case "bigint":
+				if (typeof value === "string" || typeof value === "number") return BigInt(value);
+				return value;
+			case "datetime":
+				if (typeof value === "string") return new Date(value);
+				return value;
+			case "decimal":
+				if (typeof value === "string" || typeof value === "number") {
+					if (this.prismaNamespace?.Decimal) return new this.prismaNamespace.Decimal(value);
+					const decimalValue = String(value);
+					return {
+						toString: () => decimalValue,
+						toFixed: (dp) => Number(decimalValue).toFixed(dp),
+						valueOf: () => Number(decimalValue),
+						[Symbol.toPrimitive]: (hint) => hint === "string" ? decimalValue : Number(decimalValue)
+					};
+				}
+				return value;
+			case "bytes":
+				if (typeof value === "string") return Buffer.from(value, "base64");
+				if (typeof value === "object" && !Buffer.isBuffer(value)) {
+					const bufferData = value.data || Object.values(value);
+					return Buffer.from(bufferData);
+				}
+				return value;
+			default: return value;
+		}
+	}
+	/**
+	* Reconstruct Prisma types for model-based operations (findFirst, create, update, etc.).
+	*
+	* Uses `prismaClient._runtimeDataModel` — Prisma's internal schema representation
+	* available at runtime — to determine field types. This avoids needing to store
+	* type metadata during recording; the schema itself is the source of truth.
+	*
+	* Handles scalar fields, array fields (e.g., BigInt[]), and nested relations recursively.
+	*/
+	_reconstructPrismaTypes(result, modelName) {
+		if (result === null || result === void 0) return result;
+		const runtimeDataModel = this.prismaClient?._runtimeDataModel;
+		if (!runtimeDataModel) return result;
+		if (Array.isArray(result)) return result.map((item) => this._reconstructPrismaTypes(item, modelName));
+		const model = runtimeDataModel.models[modelName];
+		if (!model) return result;
+		if (typeof result !== "object") return result;
+		const fieldTypeMap = new Map(model.fields.map((f) => [f.name, f]));
+		for (const [key, value] of Object.entries(result)) {
+			const field = fieldTypeMap.get(key);
+			if (!field || value === null || value === void 0) continue;
+			if (field.kind === "scalar") {
+				const engineType = PrismaInstrumentation.PRISMA_SCHEMA_TO_ENGINE_TYPE[field.type];
+				if (engineType) if (Array.isArray(value)) result[key] = value.map((v) => this._reconstructSingleValue(v, engineType));
+				else result[key] = this._reconstructSingleValue(value, engineType);
+			}
+			if (field.kind === "object" && field.type && typeof value === "object") result[key] = this._reconstructPrismaTypes(value, field.type);
+		}
+		return result;
 	}
 	_getPrismaErrorClassName(error) {
 		for (const errorInfo of this.prismaErrorClasses) if (error instanceof errorInfo.errorClass) return errorInfo.name;
@@ -22483,6 +22487,70 @@ var PrismaInstrumentation = class extends TdInstrumentationBase {
 		wrap(target, propertyName, wrapper);
 	}
 };
+PrismaInstrumentation.PRISMA_SCHEMA_TO_ENGINE_TYPE = {
+	DateTime: "datetime",
+	BigInt: "bigint",
+	Decimal: "decimal",
+	Bytes: "bytes"
+};
+
+//#endregion
+//#region src/instrumentation/libraries/mongodb/mocks/FakeTopology.ts
+/**
+* Fake MongoDB Topology for replay mode.
+*
+* When BulkOperationBase is constructed, it calls getTopology(collection)
+* which requires a connected topology. In replay mode, no real connection
+* exists, so we inject this fake topology to satisfy the constructor's
+* requirements without hitting a real server.
+*
+* The constructor reads:
+*   - topology.lastHello()       -> returns {} so all size limits use defaults
+*   - topology.lastIsMaster()    -> returns {} (legacy compat)
+*   - topology.s.options         -> returns {} so autoEncryption check is false
+*
+* The topology is also injected onto the shared MongoClient (via
+* _injectFakeTopology) and persists across requests. Other driver code
+* (e.g. ClientSession.loadBalanced getter) accesses
+* topology.description.type, so we provide a minimal description to
+* prevent TypeError when the property is read.
+*/
+var TdFakeTopology = class extends EventEmitter {
+	constructor() {
+		super();
+		this.fakeServer = { description: { address: "fake:27017" } };
+		this.s = { options: {} };
+		this.description = {
+			type: "Unknown",
+			servers: /* @__PURE__ */ new Map(),
+			hasServer: () => false
+		};
+	}
+	lastHello() {
+		return {};
+	}
+	lastIsMaster() {
+		return {};
+	}
+	shouldCheckForSessionSupport() {
+		return false;
+	}
+	hasSessionSupport() {
+		return true;
+	}
+	isConnected() {
+		return true;
+	}
+	isDestroyed() {
+		return false;
+	}
+	selectServerAsync() {
+		return Promise.resolve(this.fakeServer);
+	}
+	selectServer(_selector, _options, callback) {
+		if (typeof callback === "function") callback(null, this.fakeServer);
+	}
+};
 
 //#endregion
 //#region src/instrumentation/libraries/mongodb/handlers/ConnectionHandler.ts
@@ -22517,7 +22585,7 @@ var ConnectionHandler = class {
 					inputValue,
 					isPreAppStart: !this.isAppReady()
 				}, (spanInfo) => {
-					return this.handleReplayConnect(spanInfo, thisArg);
+					return this.handleReplayConnect(spanInfo, thisArg, args);
 				});
 			}
 		});
@@ -22548,17 +22616,21 @@ var ConnectionHandler = class {
 	* - DISABLED: Passthrough.
 	*/
 	handleClose(original, thisArg, args) {
-		if (this.mode === TuskDriftMode.REPLAY) return handleReplayMode({
-			noOpRequestHandler: () => {
-				return Promise.resolve();
-			},
-			isServerRequest: false,
-			replayModeHandler: () => {
-				logger.debug(`[${this.instrumentationName}] Replaying MongoDB close (no-op)`);
-				return Promise.resolve();
-			}
-		});
-		else if (this.mode === TuskDriftMode.RECORD) return handleRecordMode({
+		if (this.mode === TuskDriftMode.REPLAY) {
+			const callback = args.length > 0 && typeof args[args.length - 1] === "function" ? args[args.length - 1] : void 0;
+			return handleReplayMode({
+				noOpRequestHandler: () => {
+					if (callback) callback();
+					return Promise.resolve();
+				},
+				isServerRequest: false,
+				replayModeHandler: () => {
+					logger.debug(`[${this.instrumentationName}] Replaying MongoDB close (no-op)`);
+					if (callback) callback();
+					return Promise.resolve();
+				}
+			});
+		} else if (this.mode === TuskDriftMode.RECORD) return handleRecordMode({
 			originalFunctionCall: () => original.apply(thisArg, args),
 			recordModeHandler: ({ isPreAppStart }) => {
 				return SpanUtils.createAndExecuteSpan(this.mode, () => original.apply(thisArg, args), {
@@ -22588,7 +22660,18 @@ var ConnectionHandler = class {
 		return original.apply(thisArg, args);
 	}
 	handleRecordConnect(spanInfo, original, thisArg, args) {
-		return original.apply(thisArg, args).then((result) => {
+		const connectResult = original.apply(thisArg, args);
+		if (!(connectResult && typeof connectResult.then === "function")) {
+			try {
+				logger.debug(`[${this.instrumentationName}] MongoDB connect returned a non-promise value; recording best-effort span`);
+				SpanUtils.addSpanAttributes(spanInfo.span, { outputValue: { connected: true } });
+				SpanUtils.endSpan(spanInfo.span, { code: import_src$13.SpanStatusCode.OK });
+			} catch (error) {
+				logger.error(`[${this.instrumentationName}] Error ending non-promise connect span:`, error);
+			}
+			return Promise.resolve(connectResult);
+		}
+		return connectResult.then((result) => {
 			try {
 				logger.debug(`[${this.instrumentationName}] MongoDB connection created successfully (${SpanUtils.getTraceInfo()})`);
 				SpanUtils.addSpanAttributes(spanInfo.span, { outputValue: { connected: true } });
@@ -22611,8 +22694,9 @@ var ConnectionHandler = class {
 			throw error;
 		});
 	}
-	handleReplayConnect(spanInfo, thisArg) {
+	handleReplayConnect(spanInfo, thisArg, args) {
 		logger.debug(`[${this.instrumentationName}] Replaying MongoDB connection (skipping TCP connect)`);
+		this.injectFakeTopology(thisArg);
 		try {
 			SpanUtils.addSpanAttributes(spanInfo.span, { outputValue: {
 				connected: true,
@@ -22622,10 +22706,35 @@ var ConnectionHandler = class {
 		} catch (error) {
 			logger.error(`[${this.instrumentationName}] Error ending replay connect span:`, error);
 		}
+		const callback = args.length > 0 && typeof args[args.length - 1] === "function" ? args[args.length - 1] : void 0;
+		if (callback) {
+			callback(null, thisArg);
+			return Promise.resolve(thisArg);
+		}
 		return Promise.resolve(thisArg);
 	}
+	injectFakeTopology(client) {
+		const fakeTopology = new TdFakeTopology();
+		if (!client) return;
+		if (!client.topology) client.topology = fakeTopology;
+		if (client.s && !client.s.topology) client.s.topology = fakeTopology;
+		if (client.s) {
+			if (client.s.hasBeenClosed === true) client.s.hasBeenClosed = false;
+			if (client.s.isMongoClient === false) client.s.isMongoClient = true;
+		}
+	}
 	handleRecordClose(spanInfo, original, thisArg, args) {
-		return original.apply(thisArg, args).then(() => {
+		const closeResult = original.apply(thisArg, args);
+		if (!(closeResult && typeof closeResult.then === "function")) {
+			try {
+				SpanUtils.addSpanAttributes(spanInfo.span, { outputValue: { closed: true } });
+				SpanUtils.endSpan(spanInfo.span, { code: import_src$13.SpanStatusCode.OK });
+			} catch (error) {
+				logger.error(`[${this.instrumentationName}] Error ending non-promise close span:`, error);
+			}
+			return Promise.resolve();
+		}
+		return closeResult.then(() => {
 			try {
 				logger.debug(`[${this.instrumentationName}] MongoDB connection closed successfully (${SpanUtils.getTraceInfo()})`);
 				SpanUtils.addSpanAttributes(spanInfo.span, { outputValue: { closed: true } });
@@ -22706,21 +22815,37 @@ var TdFakeFindCursor = class TdFakeFindCursor {
 		});
 		if (this._mockLoadPromise) await this._mockLoadPromise;
 	}
-	async toArray() {
-		await this._ensureMockLoaded();
-		return [...this.documents];
+	toArray(callback) {
+		const promise = this._ensureMockLoaded().then(() => [...this.documents]);
+		if (typeof callback === "function") {
+			promise.then((docs) => callback(null, docs), (error) => callback(error));
+			return;
+		}
+		return promise;
 	}
-	async next() {
-		await this._ensureMockLoaded();
-		return this.documents[this.index++] ?? null;
+	next(callback) {
+		const promise = this._ensureMockLoaded().then(() => this.documents[this.index++] ?? null);
+		if (typeof callback === "function") {
+			promise.then((doc) => callback(null, doc), (error) => callback(error));
+			return;
+		}
+		return promise;
 	}
-	async tryNext() {
-		await this._ensureMockLoaded();
-		return this.documents[this.index++] ?? null;
+	tryNext(callback) {
+		const promise = this._ensureMockLoaded().then(() => this.documents[this.index++] ?? null);
+		if (typeof callback === "function") {
+			promise.then((doc) => callback(null, doc), (error) => callback(error));
+			return;
+		}
+		return promise;
 	}
-	async hasNext() {
-		await this._ensureMockLoaded();
-		return this.index < this.documents.length;
+	hasNext(callback) {
+		const promise = this._ensureMockLoaded().then(() => this.index < this.documents.length);
+		if (typeof callback === "function") {
+			promise.then((hasNext) => callback(null, hasNext), (error) => callback(error));
+			return;
+		}
+		return promise;
 	}
 	async forEach(fn) {
 		await this._ensureMockLoaded();
@@ -22793,7 +22918,14 @@ var TdFakeFindCursor = class TdFakeFindCursor {
 	map() {
 		return this;
 	}
-	async close() {}
+	close(callback) {
+		const promise = Promise.resolve();
+		if (typeof callback === "function") {
+			promise.then(() => callback(), (error) => callback(error));
+			return;
+		}
+		return promise;
+	}
 	rewind() {
 		this.index = 0;
 	}
@@ -22911,45 +23043,6 @@ var TdFakeChangeStream = class {
 	}
 };
 
-//#endregion
-//#region src/instrumentation/libraries/mongodb/mocks/FakeTopology.ts
-/**
-* Fake MongoDB Topology for replay mode.
-*
-* When BulkOperationBase is constructed, it calls getTopology(collection)
-* which requires a connected topology. In replay mode, no real connection
-* exists, so we inject this fake topology to satisfy the constructor's
-* requirements without hitting a real server.
-*
-* The constructor reads:
-*   - topology.lastHello()       -> returns {} so all size limits use defaults
-*   - topology.lastIsMaster()    -> returns {} (legacy compat)
-*   - topology.s.options         -> returns {} so autoEncryption check is false
-*
-* The topology is also injected onto the shared MongoClient (via
-* _injectFakeTopology) and persists across requests. Other driver code
-* (e.g. ClientSession.loadBalanced getter) accesses
-* topology.description.type, so we provide a minimal description to
-* prevent TypeError when the property is read.
-*/
-var TdFakeTopology = class extends EventEmitter {
-	constructor() {
-		super();
-		this.s = { options: {} };
-		this.description = {
-			type: "Unknown",
-			servers: /* @__PURE__ */ new Map(),
-			hasServer: () => false
-		};
-	}
-	lastHello() {
-		return {};
-	}
-	lastIsMaster() {
-		return {};
-	}
-};
-
 //#endregion
 //#region node_modules/bson/lib/bson.cjs
 var require_bson = /* @__PURE__ */ __commonJS({ "node_modules/bson/lib/bson.cjs": ((exports) => {
@@ -26999,7 +27092,8 @@ const COLLECTION_METHODS_TO_WRAP = [
 	"createIndexes",
 	"dropIndex",
 	"dropIndexes",
-	"indexes"
+	"indexes",
+	"drop"
 ];
 /**
 * Cursor-returning methods on Collection.prototype.
@@ -27024,6 +27118,12 @@ const DB_METHODS_TO_WRAP = [
 * Db.prototype methods that return cursors.
 */
 const DB_CURSOR_METHODS_TO_WRAP = ["listCollections", "aggregate"];
+const SUPPORTED_MONGODB_VERSIONS = [
+	"4.*",
+	"5.*",
+	"6.*",
+	"7.*"
+];
 var MongodbInstrumentation = class extends TdInstrumentationBase {
 	constructor(config = {}) {
 		super("mongodb", config);
@@ -27035,38 +27135,37 @@ var MongodbInstrumentation = class extends TdInstrumentationBase {
 	init() {
 		return [new TdInstrumentationNodeModule({
 			name: "mongodb",
-			supportedVersions: [
-				"5.*",
-				"6.*",
-				"7.*"
-			],
-			patch: (moduleExports) => this._patchMongodbModule(moduleExports),
+			supportedVersions: [...SUPPORTED_MONGODB_VERSIONS],
+			patch: (moduleExports, moduleVersion) => this._patchMongodbModule(moduleExports, moduleVersion),
 			files: [
 				new TdInstrumentationNodeModuleFile({
 					name: "mongodb/lib/sessions.js",
-					supportedVersions: [
-						"5.*",
-						"6.*",
-						"7.*"
-					],
+					supportedVersions: [...SUPPORTED_MONGODB_VERSIONS],
+					patch: (moduleExports) => this._patchSessionModule(moduleExports)
+				}),
+				new TdInstrumentationNodeModuleFile({
+					name: "mongodb/lib/sessions",
+					supportedVersions: [...SUPPORTED_MONGODB_VERSIONS],
 					patch: (moduleExports) => this._patchSessionModule(moduleExports)
 				}),
 				new TdInstrumentationNodeModuleFile({
 					name: "mongodb/lib/bulk/ordered.js",
-					supportedVersions: [
-						"5.*",
-						"6.*",
-						"7.*"
-					],
+					supportedVersions: [...SUPPORTED_MONGODB_VERSIONS],
+					patch: (moduleExports) => this._patchOrderedBulkModule(moduleExports)
+				}),
+				new TdInstrumentationNodeModuleFile({
+					name: "mongodb/lib/bulk/ordered",
+					supportedVersions: [...SUPPORTED_MONGODB_VERSIONS],
 					patch: (moduleExports) => this._patchOrderedBulkModule(moduleExports)
 				}),
 				new TdInstrumentationNodeModuleFile({
 					name: "mongodb/lib/bulk/unordered.js",
-					supportedVersions: [
-						"5.*",
-						"6.*",
-						"7.*"
-					],
+					supportedVersions: [...SUPPORTED_MONGODB_VERSIONS],
+					patch: (moduleExports) => this._patchUnorderedBulkModule(moduleExports)
+				}),
+				new TdInstrumentationNodeModuleFile({
+					name: "mongodb/lib/bulk/unordered",
+					supportedVersions: [...SUPPORTED_MONGODB_VERSIONS],
 					patch: (moduleExports) => this._patchUnorderedBulkModule(moduleExports)
 				})
 			]
@@ -27077,8 +27176,9 @@ var MongodbInstrumentation = class extends TdInstrumentationBase {
 	* Wraps MongoClient, Collection, Db, and cursor prototypes to intercept
 	* all database operations for record/replay.
 	*/
-	_patchMongodbModule(mongodbModule) {
-		logger.debug(`[${this.INSTRUMENTATION_NAME}] Patching MongoDB module in ${this.mode} mode`);
+	_patchMongodbModule(mongodbModule, moduleVersion) {
+		this.mongodbMajorVersion = this._getMajorVersion(moduleVersion);
+		logger.debug(`[${this.INSTRUMENTATION_NAME}] Patching MongoDB module v${moduleVersion || "unknown"} in ${this.mode} mode`);
 		if (this.isModulePatched(mongodbModule)) {
 			logger.debug(`[${this.INSTRUMENTATION_NAME}] MongoDB module already patched, skipping`);
 			return mongodbModule;
@@ -27145,6 +27245,11 @@ var MongodbInstrumentation = class extends TdInstrumentationBase {
 		logger.debug(`[${this.INSTRUMENTATION_NAME}] MongoDB module patching complete`);
 		return mongodbModule;
 	}
+	_getMajorVersion(version$1) {
+		if (!version$1) return void 0;
+		const major$1 = Number(version$1.split(".")[0]);
+		return Number.isFinite(major$1) ? major$1 : void 0;
+	}
 	/**
 	* Patch all Collection.prototype CRUD methods that return Promises.
 	* Guards each method with typeof check for version compatibility.
@@ -27170,13 +27275,24 @@ var MongodbInstrumentation = class extends TdInstrumentationBase {
 		const submodule = `collection-${methodName}`;
 		return (original) => {
 			return function(...args) {
+				const callback = args.length > 0 && typeof args[args.length - 1] === "function" ? args[args.length - 1] : void 0;
+				const effectiveArgs = callback ? args.slice(0, -1) : args;
 				const collectionName = this?.s?.namespace?.collection;
 				const databaseName = this?.s?.namespace?.db;
-				const inputValue = self._extractCollectionInput(methodName, collectionName, databaseName, args);
+				const inputValue = self._extractCollectionInput(methodName, collectionName, databaseName, effectiveArgs);
 				if (self.mode === TuskDriftMode.DISABLED) return original.apply(this, args);
-				if (self.mode === TuskDriftMode.RECORD) return self._handleRecordCollectionMethod(original, this, args, inputValue, spanName, submodule);
-				if (self.mode === TuskDriftMode.REPLAY) return self._handleReplayCollectionMethod(original, this, args, inputValue, spanName, submodule, methodName);
-				return original.apply(this, args);
+				const invokeHandler = () => {
+					if (self.mode === TuskDriftMode.RECORD) return self._handleRecordCollectionMethod(original, this, effectiveArgs, inputValue, spanName, submodule);
+					if (self.mode === TuskDriftMode.REPLAY) return self._handleReplayCollectionMethod(original, this, effectiveArgs, inputValue, spanName, submodule, methodName);
+					return original.apply(this, effectiveArgs);
+				};
+				if (callback) {
+					Promise.resolve(invokeHandler()).then((result) => callback(null, result)).catch((error) => callback(error));
+					return;
+				}
+				if (self.mode === TuskDriftMode.RECORD) return invokeHandler();
+				if (self.mode === TuskDriftMode.REPLAY) return invokeHandler();
+				return original.apply(this, effectiveArgs);
 			};
 		};
 	}
@@ -27199,7 +27315,8 @@ var MongodbInstrumentation = class extends TdInstrumentationBase {
 					isPreAppStart,
 					stopRecordingChildSpans: true
 				}, (spanInfo) => {
-					return original.apply(thisArg, args).then((result) => {
+					const resultPromise = original.apply(thisArg, args);
+					return Promise.resolve(resultPromise).then((result) => {
 						try {
 							addOutputAttributesToSpan(spanInfo, wrapDirectOutput(result));
 							SpanUtils.endSpan(spanInfo.span, { code: import_src$12.SpanStatusCode.OK });
@@ -27236,7 +27353,7 @@ var MongodbInstrumentation = class extends TdInstrumentationBase {
 			},
 			isServerRequest: false,
 			replayModeHandler: () => {
-				return SpanUtils.createAndExecuteSpan(this.mode, () => original.apply(thisArg, args), {
+				return SpanUtils.createAndExecuteSpan(this.mode, () => Promise.resolve(this._getNoOpResult(methodName)), {
 					name: spanName,
 					kind: import_src$12.SpanKind.CLIENT,
 					submodule,
@@ -27391,10 +27508,16 @@ var MongodbInstrumentation = class extends TdInstrumentationBase {
 		};
 		if (typeof cursor.toArray === "function") {
 			const originalToArray = cursor.toArray.bind(cursor);
-			cursor.toArray = () => {
-				if (cursorState.recorded) return originalToArray();
+			cursor.toArray = (callback) => {
+				if (cursorState.recorded) {
+					if (typeof callback === "function") {
+						originalToArray().then((result) => callback(null, result)).catch((error) => callback(error));
+						return;
+					}
+					return originalToArray();
+				}
 				cursorState.recorded = true;
-				return import_src$12.context.with(creationContext, () => {
+				const resultPromise = import_src$12.context.with(creationContext, () => {
 					return handleRecordMode({
 						originalFunctionCall: () => originalToArray(),
 						recordModeHandler: ({ isPreAppStart }) => {
@@ -27434,37 +27557,125 @@ var MongodbInstrumentation = class extends TdInstrumentationBase {
 						spanKind: import_src$12.SpanKind.CLIENT
 					});
 				});
+				if (typeof callback === "function") {
+					resultPromise.then((result) => callback(null, result)).catch((error) => callback(error));
+					return;
+				}
+				return resultPromise;
 			};
 		}
 		if (typeof cursor.next === "function") {
 			const originalNext = cursor.next.bind(cursor);
-			cursor.next = async () => {
-				if (cursorState.recorded) return originalNext();
-				if (!import_src$12.context.with(creationContext, () => ensureSpanCreated())) return originalNext();
-				try {
-					const doc = await (cursorState.spanInfo ? SpanUtils.withSpan(cursorState.spanInfo, () => originalNext()) : originalNext());
+			cursor.next = (callback) => {
+				if (typeof callback === "function") {
+					if (cursorState.recorded) {
+						let settled$1 = false;
+						const finish$1 = (error, doc) => {
+							if (settled$1) return;
+							settled$1 = true;
+							callback(error, doc);
+						};
+						const maybeResult$1 = originalNext((error, doc) => finish$1(error, doc));
+						Promise.resolve(maybeResult$1).then((doc) => finish$1(null, doc)).catch((error) => finish$1(error, null));
+						return;
+					}
+					if (!import_src$12.context.with(creationContext, () => ensureSpanCreated())) {
+						let settled$1 = false;
+						const finish$1 = (error, doc) => {
+							if (settled$1) return;
+							settled$1 = true;
+							callback(error, doc);
+						};
+						const maybeResult$1 = originalNext((error, doc) => finish$1(error, doc));
+						Promise.resolve(maybeResult$1).then((doc) => finish$1(null, doc)).catch((error) => finish$1(error, null));
+						return;
+					}
+					let settled = false;
+					const finish = (error, doc) => {
+						if (settled) return;
+						settled = true;
+						if (error) {
+							handleCursorError(error);
+							callback(error);
+							return;
+						}
+						if (doc !== null) cursorState.collectedDocuments.push(doc);
+						else finalizeCursorSpan();
+						callback(null, doc);
+					};
+					const runOriginal = () => originalNext((error, doc) => {
+						finish(error, doc);
+					});
+					const maybeResult = cursorState.spanInfo ? SpanUtils.withSpan(cursorState.spanInfo, () => runOriginal()) : runOriginal();
+					Promise.resolve(maybeResult).then((doc) => finish(null, doc)).catch((error) => finish(error, null));
+					return;
+				}
+				if (cursorState.recorded) return callback === void 0 ? originalNext() : originalNext(callback);
+				if (!import_src$12.context.with(creationContext, () => ensureSpanCreated())) return callback === void 0 ? originalNext() : originalNext(callback);
+				return Promise.resolve(cursorState.spanInfo ? SpanUtils.withSpan(cursorState.spanInfo, () => callback === void 0 ? originalNext() : originalNext(callback)) : callback === void 0 ? originalNext() : originalNext(callback)).then((doc) => {
 					if (doc !== null) cursorState.collectedDocuments.push(doc);
 					else finalizeCursorSpan();
 					return doc;
-				} catch (error) {
+				}).catch((error) => {
 					handleCursorError(error);
 					throw error;
-				}
+				});
 			};
 		}
 		if (typeof cursor.hasNext === "function") {
 			const originalHasNext = cursor.hasNext.bind(cursor);
-			cursor.hasNext = async () => {
-				if (cursorState.recorded) return originalHasNext();
-				if (!import_src$12.context.with(creationContext, () => ensureSpanCreated())) return originalHasNext();
-				try {
-					const result = await (cursorState.spanInfo ? SpanUtils.withSpan(cursorState.spanInfo, () => originalHasNext()) : originalHasNext());
+			cursor.hasNext = (callback) => {
+				if (typeof callback === "function") {
+					if (cursorState.recorded) {
+						let settled$1 = false;
+						const finish$1 = (error, result) => {
+							if (settled$1) return;
+							settled$1 = true;
+							callback(error, result);
+						};
+						const maybeResult$1 = originalHasNext((error, result) => finish$1(error, result));
+						Promise.resolve(maybeResult$1).then((result) => finish$1(null, result)).catch((error) => finish$1(error, false));
+						return;
+					}
+					if (!import_src$12.context.with(creationContext, () => ensureSpanCreated())) {
+						let settled$1 = false;
+						const finish$1 = (error, result) => {
+							if (settled$1) return;
+							settled$1 = true;
+							callback(error, result);
+						};
+						const maybeResult$1 = originalHasNext((error, result) => finish$1(error, result));
+						Promise.resolve(maybeResult$1).then((result) => finish$1(null, result)).catch((error) => finish$1(error, false));
+						return;
+					}
+					let settled = false;
+					const finish = (error, result) => {
+						if (settled) return;
+						settled = true;
+						if (error) {
+							handleCursorError(error);
+							callback(error);
+							return;
+						}
+						if (!result) finalizeCursorSpan();
+						callback(null, result);
+					};
+					const runOriginal = () => originalHasNext((error, result) => {
+						finish(error, result);
+					});
+					const maybeResult = cursorState.spanInfo ? SpanUtils.withSpan(cursorState.spanInfo, () => runOriginal()) : runOriginal();
+					Promise.resolve(maybeResult).then((result) => finish(null, result)).catch((error) => finish(error, false));
+					return;
+				}
+				if (cursorState.recorded) return callback === void 0 ? originalHasNext() : originalHasNext(callback);
+				if (!import_src$12.context.with(creationContext, () => ensureSpanCreated())) return callback === void 0 ? originalHasNext() : originalHasNext(callback);
+				return Promise.resolve(cursorState.spanInfo ? SpanUtils.withSpan(cursorState.spanInfo, () => callback === void 0 ? originalHasNext() : originalHasNext(callback)) : callback === void 0 ? originalHasNext() : originalHasNext(callback)).then((result) => {
 					if (!result) finalizeCursorSpan();
 					return result;
-				} catch (error) {
+				}).catch((error) => {
 					handleCursorError(error);
 					throw error;
-				}
+				});
 			};
 		}
 		if (typeof cursor.forEach === "function") {
@@ -27520,14 +27731,30 @@ var MongodbInstrumentation = class extends TdInstrumentationBase {
 		}
 		if (typeof cursor.close === "function") {
 			const originalClose = cursor.close.bind(cursor);
-			cursor.close = async () => {
-				try {
-					await originalClose();
+			cursor.close = (callback) => {
+				if (typeof callback === "function") {
+					let settled = false;
+					const finish = (error) => {
+						if (settled) return;
+						settled = true;
+						if (error) {
+							handleCursorError(error);
+							callback(error);
+							return;
+						}
+						finalizeCursorSpan();
+						callback();
+					};
+					const maybeResult = originalClose((error) => finish(error));
+					Promise.resolve(maybeResult).then(() => finish()).catch((error) => finish(error));
+					return;
+				}
+				return Promise.resolve(callback === void 0 ? originalClose() : originalClose(callback)).then(() => {
 					finalizeCursorSpan();
-				} catch (error) {
+				}).catch((error) => {
 					handleCursorError(error);
 					throw error;
-				}
+				});
 			};
 		}
 		if (typeof cursor[Symbol.asyncIterator] === "function") {
@@ -27803,6 +28030,7 @@ var MongodbInstrumentation = class extends TdInstrumentationBase {
 			case "dropIndex": return {};
 			case "dropIndexes": return { ok: 1 };
 			case "indexes": return [];
+			case "drop": return true;
 			default: return null;
 		}
 	}
@@ -27831,18 +28059,29 @@ var MongodbInstrumentation = class extends TdInstrumentationBase {
 		const submodule = `db-${methodName}`;
 		return (original) => {
 			return function(...args) {
+				const callback = args.length > 0 && typeof args[args.length - 1] === "function" ? args[args.length - 1] : void 0;
+				const effectiveArgs = callback ? args.slice(0, -1) : args;
 				const databaseName = this?.databaseName || this?.s?.namespace?.db;
-				const inputValue = self._extractDbInput(methodName, databaseName, args);
+				const inputValue = self._extractDbInput(methodName, databaseName, effectiveArgs);
 				if (self.mode === TuskDriftMode.DISABLED) return original.apply(this, args);
-				if (self.mode === TuskDriftMode.RECORD) {
-					if (methodName === "createCollection") return self._handleRecordCreateCollection(original, this, args, inputValue, spanName, submodule);
-					return self._handleRecordDbMethod(original, this, args, inputValue, spanName, submodule);
-				}
-				if (self.mode === TuskDriftMode.REPLAY) {
-					if (methodName === "createCollection") return self._handleReplayCreateCollection(this, args, inputValue, spanName, submodule);
-					return self._handleReplayDbMethod(original, this, args, inputValue, spanName, submodule, methodName);
+				const invokeHandler = () => {
+					if (self.mode === TuskDriftMode.RECORD) {
+						if (methodName === "createCollection") return self._handleRecordCreateCollection(original, this, effectiveArgs, inputValue, spanName, submodule);
+						return self._handleRecordDbMethod(original, this, effectiveArgs, inputValue, spanName, submodule);
+					}
+					if (self.mode === TuskDriftMode.REPLAY) {
+						if (methodName === "createCollection") return self._handleReplayCreateCollection(this, effectiveArgs, inputValue, spanName, submodule);
+						return self._handleReplayDbMethod(original, this, effectiveArgs, inputValue, spanName, submodule, methodName);
+					}
+					return original.apply(this, effectiveArgs);
+				};
+				if (callback) {
+					Promise.resolve(invokeHandler()).then((result) => callback(null, result)).catch((error) => callback(error));
+					return;
 				}
-				return original.apply(this, args);
+				if (self.mode === TuskDriftMode.RECORD) return invokeHandler();
+				if (self.mode === TuskDriftMode.REPLAY) return invokeHandler();
+				return original.apply(this, effectiveArgs);
 			};
 		};
 	}
@@ -27865,7 +28104,8 @@ var MongodbInstrumentation = class extends TdInstrumentationBase {
 					isPreAppStart,
 					stopRecordingChildSpans: true
 				}, (spanInfo) => {
-					return original.apply(thisArg, args).then((result) => {
+					const resultPromise = original.apply(thisArg, args);
+					return Promise.resolve(resultPromise).then((result) => {
 						try {
 							addOutputAttributesToSpan(spanInfo, wrapDirectOutput(result));
 							SpanUtils.endSpan(spanInfo.span, { code: import_src$12.SpanStatusCode.OK });
@@ -27902,7 +28142,7 @@ var MongodbInstrumentation = class extends TdInstrumentationBase {
 			},
 			isServerRequest: false,
 			replayModeHandler: () => {
-				return SpanUtils.createAndExecuteSpan(this.mode, () => original.apply(thisArg, args), {
+				return SpanUtils.createAndExecuteSpan(this.mode, () => Promise.resolve(this._getDbNoOpResult(methodName)), {
 					name: spanName,
 					kind: import_src$12.SpanKind.CLIENT,
 					submodule,
@@ -27960,7 +28200,8 @@ var MongodbInstrumentation = class extends TdInstrumentationBase {
 					isPreAppStart,
 					stopRecordingChildSpans: true
 				}, (spanInfo) => {
-					return original.apply(thisArg, args).then((result) => {
+					const resultPromise = original.apply(thisArg, args);
+					return Promise.resolve(resultPromise).then((result) => {
 						try {
 							const collectionName = args[0];
 							SpanUtils.addSpanAttributes(spanInfo.span, { outputValue: sanitizeBsonValue({ collectionName }) });
@@ -28224,13 +28465,26 @@ var MongodbInstrumentation = class extends TdInstrumentationBase {
 	*/
 	_getStartSessionWrapper() {
 		const self = this;
+		const REPLAY_WITH_TXN_PATCHED = Symbol("tdReplayWithTransactionPatched");
 		return (original) => {
 			return function(...args) {
-				if (self.mode === TuskDriftMode.REPLAY) {
-					logger.debug(`[${self.INSTRUMENTATION_NAME}] startSession called in REPLAY mode`);
-					return original.apply(this, args);
+				const session = original.apply(this, args);
+				if (self.mode === TuskDriftMode.REPLAY && self.mongodbMajorVersion === 4 && session && typeof session.withTransaction === "function" && !session[REPLAY_WITH_TXN_PATCHED]) {
+					const originalWithTransaction = session.withTransaction.bind(session);
+					session.withTransaction = async (fn, _options) => {
+						try {
+							await Promise.resolve(fn(session));
+							if (typeof session.commitTransaction === "function") return await session.commitTransaction();
+							return;
+						} catch (error) {
+							if (typeof session.abortTransaction === "function") await session.abortTransaction();
+							throw error;
+						}
+					};
+					session.__tdOriginalWithTransaction = originalWithTransaction;
+					session[REPLAY_WITH_TXN_PATCHED] = true;
 				}
-				return original.apply(this, args);
+				return session;
 			};
 		};
 	}
@@ -28306,7 +28560,8 @@ var MongodbInstrumentation = class extends TdInstrumentationBase {
 					isPreAppStart,
 					stopRecordingChildSpans: true
 				}, (spanInfo) => {
-					return original.apply(thisArg, args).then((result) => {
+					const resultPromise = original.apply(thisArg, args);
+					return Promise.resolve(resultPromise).then((result) => {
 						try {
 							addOutputAttributesToSpan(spanInfo, result ?? { success: true });
 							SpanUtils.endSpan(spanInfo.span, { code: import_src$12.SpanStatusCode.OK });
@@ -28341,7 +28596,7 @@ var MongodbInstrumentation = class extends TdInstrumentationBase {
 			noOpRequestHandler: () => Promise.resolve(void 0),
 			isServerRequest: false,
 			replayModeHandler: () => {
-				return SpanUtils.createAndExecuteSpan(this.mode, () => original.apply(thisArg, args), {
+				return SpanUtils.createAndExecuteSpan(this.mode, () => Promise.resolve(void 0), {
 					name: spanName,
 					kind: import_src$12.SpanKind.CLIENT,
 					submodule,
@@ -28615,7 +28870,8 @@ var MongodbInstrumentation = class extends TdInstrumentationBase {
 					isPreAppStart,
 					stopRecordingChildSpans: true
 				}, (spanInfo) => {
-					return original.apply(thisArg, args).then((result) => {
+					const resultPromise = original.apply(thisArg, args);
+					return Promise.resolve(resultPromise).then((result) => {
 						try {
 							addOutputAttributesToSpan(spanInfo, wrapDirectOutput(result));
 							SpanUtils.endSpan(spanInfo.span, { code: import_src$12.SpanStatusCode.OK });
@@ -28661,7 +28917,16 @@ var MongodbInstrumentation = class extends TdInstrumentationBase {
 			},
 			isServerRequest: false,
 			replayModeHandler: () => {
-				return SpanUtils.createAndExecuteSpan(this.mode, () => original.apply(thisArg, args), {
+				return SpanUtils.createAndExecuteSpan(this.mode, () => Promise.resolve({
+					acknowledged: false,
+					insertedCount: 0,
+					matchedCount: 0,
+					modifiedCount: 0,
+					deletedCount: 0,
+					upsertedCount: 0,
+					insertedIds: {},
+					upsertedIds: {}
+				}), {
 					name: spanName,
 					kind: import_src$12.SpanKind.CLIENT,
 					submodule,
@@ -40896,7 +41161,7 @@ var require_src = /* @__PURE__ */ __commonJS({ "node_modules/@opentelemetry/sdk-
 //#endregion
 //#region package.json
 var import_src$1 = /* @__PURE__ */ __toESM(require_src(), 1);
-var version = "0.1.34";
+var version = "0.1.36";
 
 //#endregion
 //#region src/version.ts
@@ -42797,7 +43062,14 @@ var TuskDriftCore = class TuskDriftCore {
 			logger.info(`Rust core path enabled at startup (env=${envDisplay}, reason=${status.reason}).`);
 			return;
 		}
-		logger.warn(`Rust core path requested but binding unavailable; falling back to JavaScript path (env=${envDisplay}, reason=${status.reason}, error=${status.bindingError}).`);
+		logger.info(`Rust core path unavailable at startup; using JavaScript path instead (env=${envDisplay}, reason=${status.reason}, error=${status.bindingError}).`);
+	}
+	logStartupSummary() {
+		const serviceName = this.config.service?.name || "unknown";
+		const serviceId = this.config.service?.id || "<unset>";
+		const environment = this.initParams.env || "<unset>";
+		const exportSpans = this.config.recording?.export_spans || false;
+		logger.info(`SDK initialized successfully (version=${SDK_VERSION}, mode=${this.mode}, env=${environment}, service=${serviceName}, serviceId=${serviceId}, exportSpans=${exportSpans}, samplingRate=${this.samplingRate}, logLevel=${logger.getLogLevel()}, runtime=node ${process.version}, platform=${process.platform}/${process.arch}).`);
 	}
 	validateSamplingRate(value, source) {
 		if (typeof value !== "number" || isNaN(value)) {
@@ -43044,7 +43316,7 @@ var TuskDriftCore = class TuskDriftCore {
 		this.initializeTracing({ baseDirectory });
 		this.createEnvVarsSnapshot();
 		this.initialized = true;
-		logger.info("SDK initialized successfully");
+		this.logStartupSummary();
 	}
 	markAppAsReady() {
 		if (!this.initialized) {
@@ -43180,5 +43452,5 @@ var TuskDriftSDK = class {
 const TuskDrift = new TuskDriftSDK();
 
 //#endregion
-export { TuskDrift, withTuskDrift };
+export { TuskDrift };
 //# sourceMappingURL=index.js.map