@depup/mswjs__interceptors 0.42.1-depup.0 → 0.42.3-depup.0

package/README.md

@@ -13,8 +13,8 @@ npm install @depup/mswjs__interceptors
 
 | Field | Value |
 |-------|-------|
-| Original | [@mswjs/interceptors](https://www.npmjs.com/package/@mswjs/interceptors) @ 0.42.1 |
-| Processed | 2026-07-23 |
+| Original | [@mswjs/interceptors](https://www.npmjs.com/package/@mswjs/interceptors) @ 0.42.3 |
+| Processed | 2026-07-24 |
 | Smoke test | passed |
 | Deps updated | 0 |
 

package/changes.json

@@ -1,5 +1,5 @@
 {
   "bumped": {},
-  "timestamp": "2026-07-23T00:38:38.519Z",
+  "timestamp": "2026-07-24T08:53:12.765Z",
   "totalUpdated": 0
 }

package/lib/node/{has-configurable-global-CJCh_g1I.js → has-configurable-global-BU1sT1u4.js}

@@ -1,4 +1,4 @@
-import { a as getDeepPropertyDescriptor } from "./net-DtMnyEeg.js";
+import { a as getDeepPropertyDescriptor } from "./net-Ca8p1rIe.js";
 //#region src/utils/has-configurable-global.ts
 /**
 * Returns a boolean indicating whether the given global property
@@ -19,4 +19,4 @@ function hasConfigurableGlobal(propertyName) {
 //#endregion
 export { hasConfigurableGlobal as t };
 
-//# sourceMappingURL=has-configurable-global-CJCh_g1I.js.map
+//# sourceMappingURL=has-configurable-global-BU1sT1u4.js.map

package/lib/node/{has-configurable-global-CJCh_g1I.js.map → has-configurable-global-BU1sT1u4.js.map}

@@ -1 +1 @@
-{"version":3,"file":"has-configurable-global-CJCh_g1I.js","names":[],"sources":["../../src/utils/has-configurable-global.ts"],"sourcesContent":["import { getDeepPropertyDescriptor } from './patches-registry'\n\n/**\n * Returns a boolean indicating whether the given global property\n * is defined and is configurable.\n */\nexport function hasConfigurableGlobal(propertyName: string): boolean {\n  const match = getDeepPropertyDescriptor(globalThis, propertyName)\n\n  // The property is not set at all.\n  if (typeof match === 'undefined') {\n    return false\n  }\n\n  const { descriptor } = match\n\n  // The property is set to a getter that returns undefined.\n  if (\n    typeof descriptor.get === 'function' &&\n    typeof descriptor.get() === 'undefined'\n  ) {\n    return false\n  }\n\n  // The property is set to a value equal to undefined.\n  if (typeof descriptor.get === 'undefined' && descriptor.value == null) {\n    return false\n  }\n\n  if (typeof descriptor.set === 'undefined' && !descriptor.configurable) {\n    console.error(\n      `[MSW] Failed to apply interceptor: the global \\`${propertyName}\\` property is non-configurable. This is likely an issue with your environment. If you are using a framework, please open an issue about this in their repository.`\n    )\n    return false\n  }\n\n  return true\n}\n"],"mappings":";;;;;;AAMA,SAAgB,sBAAsB,cAA+B;CACnE,MAAM,QAAQ,0BAA0B,YAAY,YAAY;CAGhE,IAAI,OAAO,UAAU,aACnB,OAAO;CAGT,MAAM,EAAE,eAAe;CAGvB,IACE,OAAO,WAAW,QAAQ,cAC1B,OAAO,WAAW,IAAI,MAAM,aAE5B,OAAO;CAIT,IAAI,OAAO,WAAW,QAAQ,eAAe,WAAW,SAAS,MAC/D,OAAO;CAGT,IAAI,OAAO,WAAW,QAAQ,eAAe,CAAC,WAAW,cAAc;EACrE,QAAQ,MACN,mDAAmD,aAAa,mKAClE;EACA,OAAO;CACT;CAEA,OAAO;AACT"}
+{"version":3,"file":"has-configurable-global-BU1sT1u4.js","names":[],"sources":["../../src/utils/has-configurable-global.ts"],"sourcesContent":["import { getDeepPropertyDescriptor } from './patches-registry'\n\n/**\n * Returns a boolean indicating whether the given global property\n * is defined and is configurable.\n */\nexport function hasConfigurableGlobal(propertyName: string): boolean {\n  const match = getDeepPropertyDescriptor(globalThis, propertyName)\n\n  // The property is not set at all.\n  if (typeof match === 'undefined') {\n    return false\n  }\n\n  const { descriptor } = match\n\n  // The property is set to a getter that returns undefined.\n  if (\n    typeof descriptor.get === 'function' &&\n    typeof descriptor.get() === 'undefined'\n  ) {\n    return false\n  }\n\n  // The property is set to a value equal to undefined.\n  if (typeof descriptor.get === 'undefined' && descriptor.value == null) {\n    return false\n  }\n\n  if (typeof descriptor.set === 'undefined' && !descriptor.configurable) {\n    console.error(\n      `[MSW] Failed to apply interceptor: the global \\`${propertyName}\\` property is non-configurable. This is likely an issue with your environment. If you are using a framework, please open an issue about this in their repository.`\n    )\n    return false\n  }\n\n  return true\n}\n"],"mappings":";;;;;;AAMA,SAAgB,sBAAsB,cAA+B;CACnE,MAAM,QAAQ,0BAA0B,YAAY,YAAY;CAGhE,IAAI,OAAO,UAAU,aACnB,OAAO;CAGT,MAAM,EAAE,eAAe;CAGvB,IACE,OAAO,WAAW,QAAQ,cAC1B,OAAO,WAAW,IAAI,MAAM,aAE5B,OAAO;CAIT,IAAI,OAAO,WAAW,QAAQ,eAAe,WAAW,SAAS,MAC/D,OAAO;CAGT,IAAI,OAAO,WAAW,QAAQ,eAAe,CAAC,WAAW,cAAc;EACrE,QAAQ,MACN,mDAAmD,aAAa,mKAClE;EACA,OAAO;CACT;CAEA,OAAO;AACT"}

package/lib/node/interceptors/ClientRequest/index.js

@@ -1,6 +1,6 @@
-import { i as forwardHttpEvents, o as runInRequestContext, t as NodeHttpRequestSource } from "../../source-lP0yyEtA.js";
+import { i as forwardHttpEvents, o as runInRequestContext, t as NodeHttpRequestSource } from "../../source-CIgPng7r.js";
 import { i as Interceptor } from "../../buffer-utils-BvPY1Tc-.js";
-import { o as patchesRegistry } from "../../net-DtMnyEeg.js";
+import { o as patchesRegistry } from "../../net-Ca8p1rIe.js";
 import http from "node:http";
 import https from "node:https";
 //#region src/interceptors/ClientRequest/index.ts

package/lib/node/interceptors/XMLHttpRequest/node.js

@@ -1,8 +1,8 @@
-import { a as requestContext, i as forwardHttpEvents, t as NodeHttpRequestSource } from "../../source-lP0yyEtA.js";
+import { a as requestContext, i as forwardHttpEvents, t as NodeHttpRequestSource } from "../../source-CIgPng7r.js";
 import { a as createLogger, i as Interceptor } from "../../buffer-utils-BvPY1Tc-.js";
 import { t as FetchRequest } from "../../fetch-utils-Dw1PsmtX.js";
-import { o as patchesRegistry } from "../../net-DtMnyEeg.js";
-import { t as hasConfigurableGlobal } from "../../has-configurable-global-CJCh_g1I.js";
+import { o as patchesRegistry } from "../../net-Ca8p1rIe.js";
+import { t as hasConfigurableGlobal } from "../../has-configurable-global-BU1sT1u4.js";
 //#region src/interceptors/XMLHttpRequest/node.ts
 const logger = createLogger("xhr");
 var XMLHttpRequestInterceptor = class extends Interceptor {

package/lib/node/interceptors/fetch/node.js

@@ -1,8 +1,8 @@
-import { a as requestContext, i as forwardHttpEvents, t as NodeHttpRequestSource } from "../../source-lP0yyEtA.js";
+import { a as requestContext, i as forwardHttpEvents, t as NodeHttpRequestSource } from "../../source-CIgPng7r.js";
 import { i as Interceptor } from "../../buffer-utils-BvPY1Tc-.js";
 import { i as getErrorResponse } from "../../fetch-utils-Dw1PsmtX.js";
-import { o as patchesRegistry } from "../../net-DtMnyEeg.js";
-import { t as hasConfigurableGlobal } from "../../has-configurable-global-CJCh_g1I.js";
+import { o as patchesRegistry } from "../../net-Ca8p1rIe.js";
+import { t as hasConfigurableGlobal } from "../../has-configurable-global-BU1sT1u4.js";
 //#region src/interceptors/fetch/node.ts
 /**
 * Interceptor for `fetch` requests in Node.js.

package/lib/node/interceptors/http/index.js

@@ -1,4 +1,4 @@
-import { i as forwardHttpEvents, t as NodeHttpRequestSource } from "../../source-lP0yyEtA.js";
+import { i as forwardHttpEvents, t as NodeHttpRequestSource } from "../../source-CIgPng7r.js";
 import { i as Interceptor } from "../../buffer-utils-BvPY1Tc-.js";
 //#region src/interceptors/http/index.ts
 /**

package/lib/node/interceptors/net/index.d.ts

@@ -103,6 +103,7 @@ interface TcpWrap {
   oncomplete: (status: OperationStatus, owner: TcpHandle, request: TcpWrap, readable?: boolean, writable?: boolean) => void;
 }
 declare abstract class SocketController {
+  #private;
   static PENDING: 0;
   static CLAIMED: 1;
   static PASSTHROUGH: 2;
@@ -119,6 +120,22 @@ declare abstract class SocketController {
    * Establish this socket connection as-is.
    */
   passthrough(): void;
+  /**
+   * Await a verdict on this connection from the given number of
+   * subscribers. A connection nobody awaits to inspect (or one that
+   * every awaited subscriber has declined) is passed through as-is.
+   * This makes "unclaimed after everyone declined" a state owned by
+   * the controller instead of the individual subscribers.
+   */
+  awaitVerdicts(count: number): void;
+  /**
+   * Decline this socket connection. Declining means the subscriber
+   * has inspected the connection and will not handle it (e.g. the
+   * traffic is not of the protocol that subscriber implements).
+   * Once every awaited subscriber declines, the connection is
+   * passed through as-is.
+   */
+  decline(): void;
 }
 type FlushPendingDataFunction = (data: NonNullable<net.Socket['_pendingData']>, encoding: BufferEncoding | undefined, callback: (data: NonNullable<net.Socket['_pendingData']>) => void) => void;
 declare class TcpSocketController extends SocketController {
@@ -133,8 +150,29 @@ declare class TcpSocketController extends SocketController {
    * on this socket can be handled anew. This is meant for kept-alive
    * sockets that are reused for multiple exchanges by clients that
    * don't emit the "free" event on the socket (e.g. Undici).
+   *
+   * Providing connection options retargets this connection: the
+   * exchanges that follow belong to the given target (e.g. the
+   * authority of an established "CONNECT" tunnel). An unclaimed
+   * exchange then passes through to that target instead of the
+   * originally dialed one, and a claimed exchange reports it as the
+   * peer. The verdict count is deliberately not re-armed: subscribers
+   * that declined this connection's protocol stay declined across
+   * the exchanges, retargeted or not.
+   */
+  reset(connectionOptions?: NetworkConnectionOptions & net.SocketConnectOpts): void;
+  /**
+   * Schedule a reset of this controller to happen right before the
+   * next client write. The consumer signals the boundary of the
+   * current exchange (e.g. an HTTP message boundary) the moment it is
+   * parsed — mid-delivery of the exchange's final chunk — when an
+   * immediate reset would discard that chunk. Deferring the reset to
+   * the next write lets the current exchange settle as-is while the
+   * next exchange's first write already buffers for a new verdict
+   * (instead of following the previous one, e.g. leaking to the
+   * passthrough connection).
    */
-  reset(): void;
+  scheduleReset(): void;
   protected emulateConnect(): void;
   /**
    * Suspend forwarding of the passthrough socket events ("data", "end", "close")

package/lib/node/interceptors/net/index.js

@@ -1,2 +1,2 @@
-import { t as SocketInterceptor } from "../../net-DtMnyEeg.js";
+import { t as SocketInterceptor } from "../../net-Ca8p1rIe.js";
 export { SocketInterceptor };

package/lib/node/{net-DtMnyEeg.js → net-Ca8p1rIe.js}

@@ -381,6 +381,7 @@ var SocketController = class SocketController {
 	static {
 		this.PASSTHROUGH = 2;
 	}
+	#awaitedVerdicts = 0;
 	constructor(socket) {
 		this[kRawSocket] = socket;
 		socket[kPatched] = true;
@@ -402,15 +403,51 @@ var SocketController = class SocketController {
 		invariant(this.readyState === SocketController.PENDING, "Failed to passthrough a socket connection: already handled (%s)", this.readyState);
 		this.readyState = SocketController.PASSTHROUGH;
 	}
+	/**
+	* Await a verdict on this connection from the given number of
+	* subscribers. A connection nobody awaits to inspect (or one that
+	* every awaited subscriber has declined) is passed through as-is.
+	* This makes "unclaimed after everyone declined" a state owned by
+	* the controller instead of the individual subscribers.
+	*/
+	awaitVerdicts(count) {
+		this.#awaitedVerdicts = count;
+		if (this.#awaitedVerdicts === 0) this.passthrough();
+	}
+	/**
+	* Decline this socket connection. Declining means the subscriber
+	* has inspected the connection and will not handle it (e.g. the
+	* traffic is not of the protocol that subscriber implements).
+	* Once every awaited subscriber declines, the connection is
+	* passed through as-is.
+	*/
+	decline() {
+		if (this.readyState !== SocketController.PENDING) return;
+		this.#awaitedVerdicts -= 1;
+		if (this.#awaitedVerdicts <= 0)
+ /**
+		* @note Defer the passthrough so it never transitions this
+		* controller in the middle of a client write. Declines are
+		* issued while the written data is being pushed to the server
+		* socket, and a synchronous transition would race the write's
+		* own bookkeeping (e.g. re-buffering the write after a reset
+		* at an exchange boundary).
+		*/
+		process.nextTick(() => {
+			if (this.readyState === SocketController.PENDING && !this[kRawSocket].destroyed) this.passthrough();
+		});
+	}
 };
 var TcpSocketController = class extends SocketController {
 	#connectionOptions;
+	#retargetedConnectionOptions;
 	#realWriteGeneric;
 	#passthroughSocket = null;
 	#bufferedWrites = [];
 	#readsCorked = false;
 	#corkedReads = [];
 	#realHandleSwapped = false;
+	#resetScheduled = false;
 	#clientCloseEmitted = false;
 	#clientEndPushed = false;
 	#connectEmulated = false;
@@ -492,8 +529,39 @@ var TcpSocketController = class extends SocketController {
 	* on this socket can be handled anew. This is meant for kept-alive
 	* sockets that are reused for multiple exchanges by clients that
 	* don't emit the "free" event on the socket (e.g. Undici).
+	*
+	* Providing connection options retargets this connection: the
+	* exchanges that follow belong to the given target (e.g. the
+	* authority of an established "CONNECT" tunnel). An unclaimed
+	* exchange then passes through to that target instead of the
+	* originally dialed one, and a claimed exchange reports it as the
+	* peer. The verdict count is deliberately not re-armed: subscribers
+	* that declined this connection's protocol stay declined across
+	* the exchanges, retargeted or not.
 	*/
-	reset() {
+	reset(connectionOptions) {
+		if (connectionOptions != null) {
+			this.#retargetedConnectionOptions = connectionOptions;
+			this.#connectionOptions = connectionOptions;
+			/**
+			* @note The passthrough connection to the original target, if
+			* any, cannot serve the retargeted exchanges. Detach its
+			* forwarding listeners before destroying it so its teardown is
+			* not mistaken for the client connection's own (e.g. its "close"
+			* must not close the client socket).
+			*/
+			if (this.#passthroughSocket) {
+				this.#passthroughSocket.removeListener("connect", this.#onRealSocketConnect).removeListener("connectionAttemptFailed", this.#onRealSocketConnectionAttemptFailed).removeListener("connectionAttemptTimeout", this.#onRealSocketConnectionAttemptTimeout).removeListener("data", this.#onRealSocketData).removeListener("error", this.#onRealSocketError).removeListener("end", this.#onRealSocketEnd).removeListener("close", this.#onRealSocketClose).destroy();
+				this.#passthroughSocket = null;
+				/**
+				* @note The handle swapped in from the destroyed connection,
+				* if any, no longer carries this socket's traffic. Treat the
+				* socket as not swapped so the retargeted passthrough writes
+				* directly to the new connection until its own handle swap.
+				*/
+				this.#realHandleSwapped = false;
+			}
+		}
 		/**
 		* @note Only settled (claimed or passed-through) sockets need a reset.
 		* Resetting a pending socket again would discard the writes already
@@ -503,8 +571,23 @@ var TcpSocketController = class extends SocketController {
 		if (this.readyState === SocketController.PENDING) return;
 		this.#reset();
 	}
+	/**
+	* Schedule a reset of this controller to happen right before the
+	* next client write. The consumer signals the boundary of the
+	* current exchange (e.g. an HTTP message boundary) the moment it is
+	* parsed — mid-delivery of the exchange's final chunk — when an
+	* immediate reset would discard that chunk. Deferring the reset to
+	* the next write lets the current exchange settle as-is while the
+	* next exchange's first write already buffers for a new verdict
+	* (instead of following the previous one, e.g. leaking to the
+	* passthrough connection).
+	*/
+	scheduleReset() {
+		this.#resetScheduled = true;
+	}
 	#reset() {
 		logger$1.verbose("resetting the socket...");
+		this.#resetScheduled = false;
 		this.readyState = SocketController.PENDING;
 		this.pendingConnection = Promise.withResolvers();
 		this.#bufferedWrites = [];
@@ -555,6 +638,13 @@ var TcpSocketController = class extends SocketController {
 		const data = args[1];
 		logger$1.verbose("socket write (state: %d) %o", this.readyState, args);
 		/**
+		* @note A scheduled reset marks the boundary of the previous
+		* exchange (see "scheduleReset"). This write is the first one past
+		* the boundary; reset before dispatching so it opens the next
+		* exchange instead of following the previous exchange's verdict.
+		*/
+		if (this.#resetScheduled) this.reset();
+		/**
 		* @note Buffer the write BEFORE pushing the data to the server socket.
 		* Handling the pushed data may transition this controller within the
 		* same call stack, and each transition settles the buffered entry:
@@ -832,6 +922,16 @@ var TcpSocketController = class extends SocketController {
 		this.#passthroughSocket?.resume();
 	};
 	/**
+	* Forward the client's half-close to the passthrough socket.
+	* The client's writable side may finish before the real handle is
+	* swapped in ("_final" of a connected client runs against the mock
+	* handle), leaving the FIN unsent. Once the handle is swapped, the
+	* client's own shutdown reaches the real connection natively.
+	*/
+	#forwardClientFinish = () => {
+		if (!this.#realHandleSwapped) this.#passthroughSocket?.end();
+	};
+	/**
 	* Suspend forwarding of the passthrough socket events ("data", "end", "close")
 	* to the client socket. The events are buffered in order until `uncorkReads()`
 	* is called. This allows the consumer to delay the delivery of the original
@@ -931,7 +1031,7 @@ var TcpSocketController = class extends SocketController {
 		super.passthrough();
 		logger$1.verbose("-> passthrough!");
 		const createRealSocket = () => {
-			const realSocket = this.createConnection();
+			const realSocket = this.#retargetedConnectionOptions ? this.#createRetargetedConnection(this.#retargetedConnectionOptions) : this.createConnection();
 			realSocket[kPatched] = true;
 			if (this.socket.timeout != null) realSocket.setTimeout(this.socket.timeout);
 			return realSocket;
@@ -964,8 +1064,34 @@ var TcpSocketController = class extends SocketController {
 		this.socket.on("drain", this.#onMockSocketDrain);
 		realSocket.removeListener("connect", this.#onRealSocketConnect).removeListener("connectionAttemptFailed", this.#onRealSocketConnectionAttemptFailed).removeListener("connectionAttemptTimeout", this.#onRealSocketConnectionAttemptTimeout).removeListener("data", this.#onRealSocketData).removeListener("error", this.#onRealSocketError).removeListener("end", this.#onRealSocketEnd).removeListener("close", this.#onRealSocketClose);
 		realSocket.once("connect", this.#onRealSocketConnect).on("connectionAttemptFailed", this.#onRealSocketConnectionAttemptFailed).on("connectionAttemptTimeout", this.#onRealSocketConnectionAttemptTimeout).on("data", this.#onRealSocketData).on("error", this.#onRealSocketError).on("end", this.#onRealSocketEnd).on("close", this.#onRealSocketClose);
+		/**
+		* @note Forward the client's half-close, unless the real handle
+		* is already swapped in — the client's own shutdown then reaches
+		* the real connection natively (see "#forwardClientFinish").
+		*/
+		if (!this.#realHandleSwapped) if (this.socket.writableFinished) this.#forwardClientFinish();
+		else {
+			this.socket.removeListener("finish", this.#forwardClientFinish);
+			this.socket.once("finish", this.#forwardClientFinish);
+		}
 		return realSocket;
 	}
+	/**
+	* Create the passthrough connection to the target this controller
+	* was retargeted to (see `reset()`). The original `createConnection`
+	* dials the originally requested target and cannot serve retargeted
+	* exchanges.
+	*/
+	#createRetargetedConnection(connectionOptions) {
+		const realSocket = new net.Socket();
+		/**
+		* @note Mark the socket as patched before connecting: the patched
+		* "Socket.prototype.connect" exempts such sockets, establishing
+		* the connection for real.
+		*/
+		realSocket[kPatched] = true;
+		return realSocket.connect(connectionOptions);
+	}
 };
 var TlsSocketController = class extends TcpSocketController {
 	/**
@@ -1299,15 +1425,18 @@ var SocketInterceptor = class extends Interceptor {
 					}
 					process.nextTick(() => {
 						if (socket.destroyed) return;
-						if (!interceptor.emitter.emit(new SocketConnectionEvent({
+						/**
+						* @note Expect a verdict on this connection from every
+						* "connection" listener before emitting the event. With no
+						* listeners to claim the connection (or once every listener
+						* declines it), the controller passes it through as-is.
+						*/
+						controller.awaitVerdicts(interceptor.listenerCount("connection"));
+						interceptor.emitter.emit(new SocketConnectionEvent({
 							socket: controller.serverSocket,
 							controller,
 							connectionOptions
-						}))) {
-							logger.verbose("no \"connection\" listeners found on the interceptor, passthrough...");
-							controller.passthrough();
-							return;
-						}
+						}));
 						logger.verbose("emitted \"connection\" event!");
 					});
 					logger.verbose("connecting the socket...");
@@ -1385,4 +1514,4 @@ var SocketInterceptor = class extends Interceptor {
 //#endregion
 export { getDeepPropertyDescriptor as a, unwrapPendingData as i, SocketController as n, patchesRegistry as o, kRawSocket as r, SocketInterceptor as t };
 
-//# sourceMappingURL=net-DtMnyEeg.js.map
+//# sourceMappingURL=net-Ca8p1rIe.js.map