@depup/msw 3.0.2-depup.0 → 3.0.3-depup.0

package/lib/mockServiceWorker.js

@@ -7,7 +7,7 @@
  * - Please do NOT modify this file.
  */
 
-const PACKAGE_VERSION = '3.0.2'
+const PACKAGE_VERSION = '3.0.3'
 const INTEGRITY_CHECKSUM = '5cd5cf8b54c3a90f82960cedcd637772'
 const IS_MOCKED_RESPONSE = Symbol('isMockedResponse')
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@depup/msw",
-  "version": "3.0.2-depup.0",
+  "version": "3.0.3-depup.0",
   "description": "The industry standard for API mocking in JavaScript. (with updated dependencies)",
   "type": "module",
   "main": "./lib/core/index.js",
@@ -94,7 +94,6 @@
   "funding": "https://github.com/sponsors/mswjs",
   "files": [
     "config/constants.js",
-    "config/scripts/postinstall.js",
     "cli",
     "lib",
     "src",
@@ -123,9 +122,9 @@
   ],
   "sideEffects": false,
   "dependencies": {
-    "@inquirer/confirm": "^6.3.2",
+    "@inquirer/confirm": "^6.3.3",
     "@msw/url": "^0.1.2",
-    "@mswjs/interceptors": "^0.45.6",
+    "@mswjs/interceptors": "^0.45.7",
     "cookie": "^2.0.1",
     "headers-polyfill": "^5.0.1",
     "is-node-process": "^1.2.0",
@@ -167,7 +166,7 @@
     "json-bigint": "^1.0.0",
     "knip": "^6.34.0",
     "lint-staged": "^17.1.1",
-    "msw": "^3.0.2",
+    "msw": "^3.0.3",
     "oxlint": "^1.75.0",
     "page-with": "^0.6.1",
     "prettier": "^3.9.6",
@@ -229,17 +228,21 @@
     "changes": {
       "@inquirer/confirm": {
         "from": "^6.0.11",
-        "to": "^6.3.2"
+        "to": "^6.3.3"
+      },
+      "@mswjs/interceptors": {
+        "from": "^0.45.6",
+        "to": "^0.45.7"
       },
       "type-fest": {
         "from": "^5.5.0",
         "to": "^5.10.0"
       }
     },
-    "depsUpdated": 2,
+    "depsUpdated": 3,
     "originalPackage": "msw",
-    "originalVersion": "3.0.2",
-    "processedAt": "2026-10-03T08:12:25.616Z",
+    "originalVersion": "3.0.3",
+    "processedAt": "2026-10-10T04:42:39.550Z",
     "smokeTest": "passed"
   }
 }

package/src/browser/default-network-options.ts

@@ -17,7 +17,7 @@ export function createDefaultNetworkOptions(
     sources: [
       supportsServiceWorker()
         ? new ServiceWorkerSource({ serviceWorker: { url: workerUrl } })
-        : new FallbackHttpSource({}),
+        : new FallbackHttpSource(),
       new InterceptorSource({
         interceptors: [
           new WebSocketInterceptor() as InterceptorSourceOptions['interceptors'][number],

package/src/browser/setup-worker.ts

@@ -56,11 +56,8 @@ export function setupWorker(...handlers: Array<AnyHandler>): SetupWorker {
               options: options?.serviceWorker?.options,
             },
             findWorker: options?.findWorker,
-            quiet: options?.quiet,
-          })
-        : new FallbackHttpSource({
-            quiet: options?.quiet,
           })
+        : new FallbackHttpSource()
 
       network.configure({
         sources: [

package/src/browser/sources/fallback-http-source.ts

@@ -1,23 +1,26 @@
 import { FetchInterceptor } from '@mswjs/interceptors/fetch'
 import { XMLHttpRequestInterceptor } from '@mswjs/interceptors/XMLHttpRequest'
 import { InterceptorSource } from '#core/experimental/sources/interceptor-source'
+import type { NetworkFrameResolutionContext } from '#core/experimental/frames/network-frame'
 import { devUtils } from '#core/utils/internal/dev-utils'
 
-interface FallbackHttpSourceOptions {
-  quiet?: boolean
-}
-
 export class FallbackHttpSource extends InterceptorSource {
-  constructor(private readonly options: FallbackHttpSourceOptions) {
+  /**
+   * The resolved context of the network this source was last enabled with.
+   */
+  #context?: NetworkFrameResolutionContext
+
+  constructor() {
     super({
       interceptors: [new XMLHttpRequestInterceptor(), new FetchInterceptor()],
     })
   }
 
-  public enable(): void {
+  public enable(context?: NetworkFrameResolutionContext): void {
+    this.#context = context
     super.enable()
 
-    if (!this.options.quiet) {
+    if (!this.#context?.quiet) {
       this.#printStartMessage()
     }
   }
@@ -25,7 +28,7 @@ export class FallbackHttpSource extends InterceptorSource {
   public disable(): void {
     super.disable()
 
-    if (!this.options.quiet) {
+    if (!this.#context?.quiet) {
       this.#printStopMessage()
     }
   }

package/src/browser/sources/service-worker-source.ts

@@ -2,6 +2,7 @@ import { invariant } from 'outvariant'
 import type { Emitter } from 'rettime'
 import { FetchResponse } from '@mswjs/interceptors'
 import { NetworkSource } from '#core/experimental/sources/network-source'
+import type { NetworkFrameResolutionContext } from '#core/experimental/frames/network-frame'
 import { RequestHandler } from '#core/handlers/request-handler'
 import {
   HttpNetworkFrame,
@@ -23,7 +24,6 @@ import { validateWorkerScope } from '../utils/validate-worker-scope'
 import { shouldInvalidateWorker } from '../utils/should-invalidate-worker'
 
 export interface ServiceWorkerSourceOptions {
-  quiet?: boolean
   serviceWorker: {
     url: string
     options?: RegistrationOptions
@@ -75,6 +75,10 @@ export class ServiceWorkerSource extends NetworkSource<ServiceWorkerHttpNetworkF
   }
 
   #options: ServiceWorkerSourceOptions
+  /**
+   * The resolved context of the network this source was last enabled with.
+   */
+  #context?: NetworkFrameResolutionContext
   /**
    * @note We cannot use `WeakMap` here as request/response
    * identity cannot be preserved through the client-worker channel.
@@ -109,7 +113,10 @@ export class ServiceWorkerSource extends NetworkSource<ServiceWorkerHttpNetworkF
     })
   }
 
-  public async enable(): Promise<ServiceWorkerRegistration> {
+  public async enable(
+    context?: NetworkFrameResolutionContext,
+  ): Promise<ServiceWorkerRegistration> {
+    this.#context = context
     this.#channel.removeAllListeners()
     this.#frames.clear()
 
@@ -147,7 +154,7 @@ export class ServiceWorkerSource extends NetworkSource<ServiceWorkerHttpNetworkF
     })
     await clientConfirmationPromise.promise
 
-    if (!this.#options.quiet) {
+    if (!this.#context?.quiet) {
       this.#printStartMessage()
     }
 
@@ -178,7 +185,7 @@ export class ServiceWorkerSource extends NetworkSource<ServiceWorkerHttpNetworkF
      * `#handleRequest`. `#startWorker` swaps in a fresh deferred on re-enable.
      */
 
-    if (!this.#options.quiet) {
+    if (!this.#context?.quiet) {
       this.#printStopMessage()
     }
   }
@@ -294,7 +301,7 @@ Please consider using a custom "serviceWorker.url" option to point to the actual
       this.#channel.postMessage('KEEPALIVE_REQUEST')
     }, 5000)
 
-    if (!this.#options.quiet) {
+    if (!this.#context?.quiet) {
       validateWorkerScope(registration)
     }
 

package/src/browser/utils/should-invalidate-worker.test.ts

@@ -104,19 +104,3 @@ test('returns false when findWorker is the same reference', () => {
     ),
   ).toBe(false)
 })
-
-test('returns false regardless of the "quiet" option', () => {
-  expect(
-    shouldInvalidateWorker(
-      createOptions({ quiet: true }),
-      createOptions({ quiet: true }),
-    ),
-  ).toBe(false)
-
-  expect(
-    shouldInvalidateWorker(
-      createOptions({ quiet: false }),
-      createOptions({ quiet: true }),
-    ),
-  ).toBe(false)
-})

package/src/core/experimental/define-network.ts

@@ -203,7 +203,7 @@ export function defineNetwork<Sources extends Array<NetworkSource<any>>>(
           )
         })
 
-        return source.enable()
+        return source.enable(resolvedOptions.context)
       })
 
       return colorlessPromiseAll(result) as MaybePromise<

package/src/core/experimental/handlers-controller.test.ts

@@ -308,6 +308,67 @@ describe(InMemoryHandlersController.prototype.reset, () => {
     expect(controller.getHandlersByKind('websocket')).toEqual([wsOne, wsTwo])
     expect(controller.getHandlersByKind('request')).toEqual([upgradeHandler])
   })
+
+  test('resets the kept handlers and disposes of the removed ones', () => {
+    const initialHandler = http.get('/initial', () => {})
+    initialHandler.reset = vi.fn()
+    initialHandler.dispose = vi.fn()
+    const runtimeHandler = http.get('/runtime', () => {})
+    runtimeHandler.reset = vi.fn()
+    runtimeHandler.dispose = vi.fn()
+
+    const controller = new InMemoryHandlersController([initialHandler])
+    controller.use([runtimeHandler])
+    controller.reset([])
+
+    expect.soft(initialHandler.reset).toHaveBeenCalledOnce()
+    expect.soft(initialHandler.dispose).not.toHaveBeenCalled()
+    expect.soft(runtimeHandler.reset).not.toHaveBeenCalled()
+    expect(runtimeHandler.dispose).toHaveBeenCalledOnce()
+  })
+
+  test('reports a rejected disposal of a removed handler', async () => {
+    vi.spyOn(console, 'error').mockImplementation(() => {})
+    onTestFinished(() => vi.restoreAllMocks())
+
+    const runtimeHandler = http.get('/runtime', () => {})
+    runtimeHandler.dispose = () =>
+      Promise.reject(new Error('Handler disposal error'))
+
+    const controller = new InMemoryHandlersController([])
+    controller.use([runtimeHandler])
+    controller.reset([])
+
+    await expect
+      .poll(() => console.error)
+      .toHaveBeenCalledWith(
+        `[MSW] Failed to dispose of "request" handler removed during reset. Please see the original error below.\nError: Handler disposal error`,
+      )
+  })
+
+  test('removes the remaining handlers when a disposal throws', () => {
+    vi.spyOn(console, 'error').mockImplementation(() => {})
+    onTestFinished(() => vi.restoreAllMocks())
+
+    const throwingHandler = http.get('/throwing', () => {})
+    throwingHandler.dispose = () => {
+      throw new Error('Handler disposal error')
+    }
+    const runtimeHandler = http.get('/runtime', () => {})
+    runtimeHandler.dispose = vi.fn()
+
+    const controller = new InMemoryHandlersController([])
+    controller.use([throwingHandler, runtimeHandler])
+    controller.reset([])
+
+    expect
+      .soft(console.error)
+      .toHaveBeenCalledWith(
+        `[MSW] Failed to dispose of "request" handler removed during reset. Please see the original error below.\nError: Handler disposal error`,
+      )
+    expect.soft(runtimeHandler.dispose).toHaveBeenCalledOnce()
+    expect(controller.currentHandlers()).toEqual([])
+  })
 })
 
 describe(InMemoryHandlersController.prototype.listHandlers, () => {

package/src/core/experimental/handlers-controller.ts

@@ -168,11 +168,38 @@ export abstract class HandlersController {
       ),
     )
 
-    for (const handler of this.currentHandlers()) {
+    const { initialHandlers } = this.getState()
+    const nextInitialHandlers =
+      nextHandlers.length > 0
+        ? groupHandlersByKind(nextHandlers)
+        : initialHandlers
+    const currentHandlers = new Set(this.currentHandlers())
+    const nextHandlersSet = new Set(
+      Object.values(nextInitialHandlers).flat().filter(Boolean),
+    )
+
+    for (const handler of currentHandlers.intersection(nextHandlersSet)) {
       handler.reset()
     }
 
-    const { initialHandlers } = this.getState()
+    // The handlers that leave the network with this reset release
+    // whatever they hold (e.g. live connection bindings).
+    // Resetting is synchronous, so their disposal is not awaited.
+    for (const handler of currentHandlers.difference(nextHandlersSet)) {
+      try {
+        const disposal = handler.dispose()
+
+        if (disposal instanceof Promise) {
+          disposal.catch((error) => {
+            this.#printDisposalError(handler, error)
+          })
+        }
+      } catch (error) {
+        // A failing disposal must not prevent the remaining handlers
+        // from being disposed of, nor the removed handlers from being cleared.
+        this.#printDisposalError(handler, error)
+      }
+    }
 
     if (nextHandlers.length === 0) {
       this.setState({
@@ -182,11 +209,9 @@ export abstract class HandlersController {
       return
     }
 
-    const normalizedNextHandlers = groupHandlersByKind(nextHandlers)
-
     this.setState({
-      initialHandlers: normalizedNextHandlers,
-      handlers: { ...normalizedNextHandlers },
+      initialHandlers: nextInitialHandlers,
+      handlers: { ...nextInitialHandlers },
     })
   }
 
@@ -217,6 +242,14 @@ export abstract class HandlersController {
   #validateHandlers(handlers: Array<AnyHandler>): boolean {
     return handlers.every((handler) => !Array.isArray(handler))
   }
+
+  #printDisposalError(handler: AnyHandler, error: unknown): void {
+    devUtils.error(
+      'Failed to dispose of "%s" handler removed during reset. Please see the original error below.\n%s',
+      handler.kind,
+      error,
+    )
+  }
 }
 
 export class InMemoryHandlersController extends HandlersController {

package/src/core/experimental/sources/network-source.ts

@@ -2,6 +2,7 @@ import { Emitter, TypedEvent, type TypedListenerOptions } from 'rettime'
 import type {
   AnyNetworkFrame,
   ExtractFrameEvents,
+  NetworkFrameResolutionContext,
 } from '../frames/network-frame'
 
 class NetworkFrameEvent<
@@ -33,7 +34,13 @@ export abstract class NetworkSource<
     this.emitter = new Emitter()
   }
 
-  public abstract enable(): unknown | Promise<unknown>
+  /**
+   * Enable this network source.
+   * @param context The resolved context of the network this source belongs to.
+   */
+  public abstract enable(
+    context?: NetworkFrameResolutionContext,
+  ): unknown | Promise<unknown>
 
   public async queue(frame: Frame): Promise<void> {
     await this.emitter.emitAsPromise(

package/src/core/handlers/handler.ts

@@ -32,8 +32,9 @@ export abstract class Handler {
   /**
    * Release the resources held by this handler.
    *
-   * @note This method is invoked automatically when the network is
-   * disabled (e.g. `server.close()`). Override it in the handlers that
+   * @note This method is invoked automatically when the handler leaves
+   * the network: when the network is disabled (e.g. `server.close()`)
+   * or when a reset removes it (e.g. `server.resetHandlers()`). Override it in the handlers that
    * hold onto anything beyond a single frame, like timers, connections,
    * or event listeners. Returning a promise makes the network await
    * this handler's disposal before it tears itself down.

package/src/graphql/graphql-subscription.ts

@@ -585,24 +585,32 @@ export class GraphQLSubscriptionTransportHandler extends GraphQLWebSocketHandler
   }
 
   /**
-   * Drop this transport's subscribers and active subscriptions from the
-   * sessions it participates in. The sessions themselves are left intact:
-   * they are shared with the other transports of the same connection and
-   * own the protocol listeners for as long as the client stays connected.
+   * Remove the given handler from the subscribers of every session
+   * this transport participates in. The handler no longer matches
+   * subscriptions on the connections opened while it was registered.
+   */
+  public unsubscribe(handler: WebSocketHandler): void {
+    for (const connection of connections.values()) {
+      connection.subscribers.delete(handler)
+    }
+  }
+
+  /**
+   * End the active subscriptions of the sessions this transport
+   * participates in. The sessions and their subscribers are left intact:
+   * the handlers that survive the reset keep serving the connections
+   * opened before it, while the removed handlers unsubscribe themselves
+   * on disposal. The sessions own the protocol listeners for as long as
+   * the client stays connected.
    *
    * @note This method is invoked automatically when the handlers
    * controller resets the handlers (e.g. `server.resetHandlers()`).
    */
   public reset(): void {
     for (const connection of connections.values()) {
-      let ownsConnection = false
-
-      for (const [handler, entry] of connection.subscribers) {
-        if (entry.transport === this) {
-          connection.subscribers.delete(handler)
-          ownsConnection = true
-        }
-      }
+      const ownsConnection = Array.from(connection.subscribers.values()).some(
+        (entry) => entry.transport === this,
+      )
 
       // Resetting the handlers detaches the resolvers from their
       // subscriptions, so run their cleanups instead of dropping them.
@@ -935,6 +943,16 @@ export class GraphQLSubscriptionHandler<
     this.isUsed = false
   }
 
+  /**
+   * Stop serving the connections this handler was bound to.
+   * @note This method is invoked automatically when the handler
+   * is removed from the network, either by resetting the handlers
+   * (e.g. `server.resetHandlers()`) or by disabling the network.
+   */
+  public dispose(): void {
+    this.#transport.unsubscribe(this)
+  }
+
   /**
    * @note Individual subscription handlers stay silent. The subscription
    * transport owns the GraphQL-aware logging for the entire connection