From c8f3cfaae6d8e3a23b2d5b57c5d156925df29438 Mon Sep 17 00:00:00 2001
From: Matthew Schile <mschile@cypress.io>
Date: Sat, 6 Apr 2024 20:37:59 -0600
Subject: [PATCH 01/31] updating controlledUrls

---
 .../lib/http/util/service-worker-injector.ts  | 81 +++++++++++++++-
 .../lib/http/util/service-worker-manager.ts   | 92 ++++++++++++++-----
 2 files changed, 145 insertions(+), 28 deletions(-)

diff --git a/packages/proxy/lib/http/util/service-worker-injector.ts b/packages/proxy/lib/http/util/service-worker-injector.ts
index 8d17b3807dc5..0403bfd21c83 100644
--- a/packages/proxy/lib/http/util/service-worker-injector.ts
+++ b/packages/proxy/lib/http/util/service-worker-injector.ts
@@ -2,9 +2,64 @@
 
 import type { ServiceWorkerClientEvent } from './service-worker-manager'
 
+type FrameType = 'auxiliary' | 'nested' | 'none' | 'top-level'
+
+/**
+ * The Client interface represents an executable context such as a Worker, or a SharedWorker. Window clients are represented by the more-specific WindowClient. You can get Client/WindowClient objects from methods such as Clients.matchAll() and Clients.get().
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Client)
+ */
+interface Client {
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Client/frameType) */
+  readonly frameType: FrameType
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Client/id) */
+  readonly id: string
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Client/type) */
+  readonly type: ClientTypes
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Client/url) */
+  readonly url: string
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Client/postMessage) */
+  postMessage(message: any, transfer: Transferable[]): void
+  postMessage(message: any, options?: StructuredSerializeOptions): void
+}
+
+/**
+ * This ServiceWorker API interface represents the scope of a service worker client that is a document in a browser context, controlled by an active worker. The service worker client independently selects and uses a service worker for its own loading and sub-resources.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WindowClient)
+ */
+interface WindowClient extends Client {
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WindowClient/focused) */
+  readonly focused: boolean
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WindowClient/visibilityState) */
+  readonly visibilityState: DocumentVisibilityState
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WindowClient/focus) */
+  focus(): Promise<WindowClient>
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WindowClient/navigate) */
+  navigate(url: string | URL): Promise<WindowClient | null>
+}
+
+/**
+ * Provides access to Client objects. Access it via self.clients within a service worker.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Clients)
+ */
+interface Clients {
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Clients/claim) */
+  claim(): Promise<void>
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Clients/get) */
+  get(id: string): Promise<Client | undefined>
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Clients/matchAll) */
+  matchAll<T extends ClientQueryOptions>(options?: T): Promise<ReadonlyArray<T['type'] extends 'window' ? WindowClient : Client>>
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Clients/openWindow) */
+  openWindow(url: string | URL): Promise<WindowClient | null>
+}
+
 // this should be of type ServiceWorkerGlobalScope from the webworker lib,
 // but we can't reference it directly because it causes errors in other packages
 interface ServiceWorkerGlobalScope extends WorkerGlobalScope {
+  clients: Clients
+  registration: ServiceWorkerRegistration
   onfetch: FetchListener | null
   addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void
   removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void
@@ -20,6 +75,8 @@ interface FetchEvent extends Event {
 
 type FetchListener = (this: ServiceWorkerGlobalScope, ev: FetchEvent) => any
 
+type ServiceWorkerClientEventWithoutScope = Omit<ServiceWorkerClientEvent, 'scope'>
+
 declare let self: ServiceWorkerGlobalScope
 
 /**
@@ -30,17 +87,17 @@ declare let self: ServiceWorkerGlobalScope
 export const injectIntoServiceWorker = (body: Buffer) => {
   function __cypressInjectIntoServiceWorker () {
     let listenerCount = 0
-    let eventQueue: ServiceWorkerClientEvent[] = []
+    let eventQueue: ServiceWorkerClientEventWithoutScope[] = []
     const nonCaptureListenersMap = new WeakMap<EventListenerOrEventListenerObject, EventListenerOrEventListenerObject>()
     const captureListenersMap = new WeakMap<EventListenerOrEventListenerObject, EventListenerOrEventListenerObject>()
     const targetToWrappedHandleEventMap = new WeakMap<Object, EventListenerOrEventListenerObject>()
     const targetToOrigHandleEventMap = new WeakMap<Object, EventListenerOrEventListenerObject>()
 
-    const sendEvent = (event: ServiceWorkerClientEvent) => {
+    const sendEvent = (event: ServiceWorkerClientEventWithoutScope) => {
       // if the binding has been created, we can call it
       // otherwise, we need to queue the event
       if (self.__cypressServiceWorkerClientEvent) {
-        self.__cypressServiceWorkerClientEvent(JSON.stringify(event))
+        self.__cypressServiceWorkerClientEvent(JSON.stringify({ ...event, scope: self.registration.scope }))
       } else {
         eventQueue.push(event)
       }
@@ -59,6 +116,13 @@ export const injectIntoServiceWorker = (body: Buffer) => {
       sendEvent({ type: 'fetchRequest', payload })
     }
 
+    const sendClientsUpdated = async () => {
+      const clients = (await self.clients.matchAll()).map(({ frameType, id, type, url }) => ({ frameType, id, type, url }))
+
+      // call the CDP binding to inform the backend that the clients have been updated
+      sendEvent({ type: 'clientsUpdated', payload: { clients } })
+    }
+
     // A listener is considered valid if it is a function or an object (with the handleEvent function or the function could be added later)
     const isValidListener = (listener: EventListenerOrEventListenerObject) => {
       return listener && (typeof listener === 'function' || typeof listener === 'object')
@@ -237,10 +301,19 @@ export const injectIntoServiceWorker = (body: Buffer) => {
       },
     )
 
+    const oldClientsClaim = self.clients.claim
+
+    self.clients.claim = async () => {
+      await oldClientsClaim.call(self.clients)
+
+      await sendClientsUpdated()
+    }
+
     // listen for the activate event so we can inform the
     // backend whether or not the service worker has a handler
-    self.addEventListener('activate', () => {
+    self.addEventListener('activate', async () => {
       sendHasFetchEventHandlers()
+      await sendClientsUpdated()
 
       // if the binding has not been created yet, we need to wait for it
       if (!self.__cypressServiceWorkerClientEvent) {
diff --git a/packages/proxy/lib/http/util/service-worker-manager.ts b/packages/proxy/lib/http/util/service-worker-manager.ts
index 606aae28adff..f59cb11f73eb 100644
--- a/packages/proxy/lib/http/util/service-worker-manager.ts
+++ b/packages/proxy/lib/http/util/service-worker-manager.ts
@@ -8,6 +8,8 @@ const debug = Debug('cypress:proxy:service-worker-manager')
 type ServiceWorkerRegistration = {
   registrationId: string
   scopeURL: string
+  controlledURLs: string[]
+  hasFetchHandler: boolean
   activatedServiceWorker?: ServiceWorker
 }
 
@@ -15,7 +17,6 @@ type ServiceWorker = {
   registrationId: string
   scriptURL: string
   initiatorOrigin?: string
-  controlledURLs: Set<string>
 }
 
 type RegisterServiceWorkerOptions = {
@@ -37,14 +38,24 @@ type AddInitiatorToServiceWorkerOptions = {
   initiatorOrigin: string
 }
 
+type FrameType = 'auxiliary' | 'nested' | 'none' | 'top-level';
+
+type Client = {
+  frameType: FrameType
+  id: string
+  type: ClientTypes
+  url: string
+}
+
 export const serviceWorkerClientEventHandlerName = '__cypressServiceWorkerClientEvent'
 
 export declare type ServiceWorkerEventsPayload = {
   'fetchRequest': { url: string, isControlled: boolean }
   'hasFetchHandler': { hasFetchHandler: boolean }
+  'clientsUpdated': { clients: Client[] }
 }
 
-type _ServiceWorkerClientEvent<T extends keyof ServiceWorkerEventsPayload> = { type: T, payload: ServiceWorkerEventsPayload[T] }
+type _ServiceWorkerClientEvent<T extends keyof ServiceWorkerEventsPayload> = { type: T, scope: string, payload: ServiceWorkerEventsPayload[T] }
 
 export type ServiceWorkerClientEvent = _ServiceWorkerClientEvent<keyof ServiceWorkerEventsPayload>
 
@@ -86,7 +97,6 @@ export class ServiceWorkerManager {
   private pendingInitiators: Map<string, string> = new Map<string, string>()
   private pendingPotentiallyControlledRequests: Map<string, pDefer.DeferredPromise<boolean>[]> = new Map<string, pDefer.DeferredPromise<boolean>[]>()
   private pendingServiceWorkerFetches: Map<string, boolean[]> = new Map<string, boolean[]>()
-  private hasFetchHandler = false
 
   /**
    * Goes through the list of service worker registrations and adds or removes them from the manager.
@@ -130,6 +140,7 @@ export class ServiceWorkerManager {
     }
 
     if (!initiatorAdded) {
+      debug('Service worker not activated yet, adding initiator origin to pending list: %s', scriptURL)
       this.pendingInitiators.set(scriptURL, initiatorOrigin)
     }
   }
@@ -146,10 +157,13 @@ export class ServiceWorkerManager {
         this.handleServiceWorkerFetchEvent(event.payload as ServiceWorkerEventsPayload['fetchRequest'])
         break
       case 'hasFetchHandler':
-        this.hasServiceWorkerFetchHandlers(event.payload as ServiceWorkerEventsPayload['hasFetchHandler'])
+        this.hasServiceWorkerFetchHandlers(event.payload as ServiceWorkerEventsPayload['hasFetchHandler'], event.scope)
+        break
+      case 'clientsUpdated':
+        this.handleClientsUpdatedEvent(event.payload as ServiceWorkerEventsPayload['clientsUpdated'], event.scope)
         break
       default:
-        throw new Error(`Unknown event type: ${event.type}`)
+        debug('Unknown event type: %o', event)
     }
   }
 
@@ -177,10 +191,12 @@ export class ServiceWorkerManager {
       // we have an activated service worker, the request URL does not come from the service worker, and the request
       // originates from the same origin as the service worker or from a script that is also controlled by the service worker.
       if (!activatedServiceWorker ||
+        !registration.hasFetchHandler ||
+        registration.controlledURLs.length === 0 ||
         activatedServiceWorker.scriptURL === paramlessDocumentURL ||
         !activatedServiceWorker.initiatorOrigin ||
         !paramlessDocumentURL.startsWith(activatedServiceWorker.initiatorOrigin)) {
-        debug('Service worker not activated or request URL is from the service worker, skipping: %o', { activatedServiceWorker, browserPreRequest })
+        debug('Service worker not activated or request URL is from the service worker, skipping: %o', { registration, browserPreRequest })
 
         return
       }
@@ -188,35 +204,51 @@ export class ServiceWorkerManager {
       const paramlessInitiatorURL = browserPreRequest.initiator?.url?.split('?')[0]
       const paramlessCallStackURL = browserPreRequest.initiator?.stack?.callFrames[0]?.url?.split('?')[0]
       const urlIsControlled = paramlessURL.startsWith(registration.scopeURL)
-      const initiatorUrlIsControlled = paramlessInitiatorURL && activatedServiceWorker.controlledURLs?.has(paramlessInitiatorURL)
-      const topStackUrlIsControlled = paramlessCallStackURL && activatedServiceWorker.controlledURLs?.has(paramlessCallStackURL)
+      const initiatorUrlIsControlled = paramlessInitiatorURL && registration.controlledURLs?.includes(paramlessInitiatorURL)
+      const topStackUrlIsControlled = paramlessCallStackURL && registration.controlledURLs?.includes(paramlessCallStackURL)
 
       if (urlIsControlled || initiatorUrlIsControlled || topStackUrlIsControlled) {
         requestPotentiallyControlledByServiceWorker = true
       }
     })
 
-    if (activatedServiceWorker && requestPotentiallyControlledByServiceWorker && await this.isURLControlledByServiceWorker(browserPreRequest.url)) {
-      debug('Request is controlled by service worker: %o', browserPreRequest.url)
-      activatedServiceWorker.controlledURLs.add(paramlessURL)
-
-      return true
-    }
+    let isControlled = false
 
     if (activatedServiceWorker) {
+      if (requestPotentiallyControlledByServiceWorker) {
+        isControlled = await this.isURLControlledByServiceWorker(paramlessURL)
+
+        if (isControlled) {
+          debug('Request is controlled by service worker: %o', browserPreRequest.url)
+
+          return true
+        }
+
+        debug('Request is not controlled by service worker: %o', browserPreRequest.url)
+      }
+
       debug('Request is not controlled by service worker: %o', browserPreRequest.url)
     }
 
     return false
   }
 
+  private getRegistrationForScope (scope: string) {
+    return Array.from(this.serviceWorkerRegistrations.values()).find((registration) => registration.scopeURL === scope)
+  }
+
   /**
    * Handles a service worker has fetch handlers event.
    * @param event the service worker has fetch handlers event to handle
    */
-  private hasServiceWorkerFetchHandlers (event: ServiceWorkerEventsPayload['hasFetchHandler']) {
-    debug('service worker has fetch handlers event called: %o', event)
-    this.hasFetchHandler = event.hasFetchHandler
+  private hasServiceWorkerFetchHandlers (event: ServiceWorkerEventsPayload['hasFetchHandler'], scope: string) {
+    debug('service worker has fetch handlers event called: %o', { event, scope })
+
+    const registration = this.getRegistrationForScope(scope)
+
+    if (registration) {
+      registration.hasFetchHandler = event.hasFetchHandler
+    }
   }
 
   /**
@@ -249,16 +281,25 @@ export class ServiceWorkerManager {
     }
   }
 
+  private handleClientsUpdatedEvent (event: ServiceWorkerEventsPayload['clientsUpdated'], scope: string) {
+    debug('service worker clients updated event called: %o', event)
+
+    const registration = this.getRegistrationForScope(scope)
+
+    if (registration) {
+      debug('updating controlled URLs for service worker: %o', { registrationId: registration.registrationId, scope, clients: event.clients })
+      registration.controlledURLs = event.clients.map((client) => client.url)
+    } else {
+      debug('could not find service worker registration for scope: %s', scope)
+    }
+  }
+
   /**
    * Determines if the given URL is controlled by a service worker.
    * @param url the URL to check
    * @returns a promise that resolves to `true` if the URL is controlled by a service worker, `false` otherwise.
    */
   private isURLControlledByServiceWorker (url: string) {
-    if (!this.hasFetchHandler) {
-      return false
-    }
-
     const fetches = this.pendingServiceWorkerFetches.get(url)
 
     if (fetches) {
@@ -270,7 +311,7 @@ export class ServiceWorkerManager {
         this.pendingServiceWorkerFetches.delete(url)
       }
 
-      return Promise.resolve(isControlled)
+      return Promise.resolve(!!isControlled)
     }
 
     let promises = this.pendingPotentiallyControlledRequests.get(url)
@@ -295,7 +336,9 @@ export class ServiceWorkerManager {
     debug('Registering service worker with registration ID %s and scope URL %s', registrationId, scopeURL)
 
     // Only register service workers if they haven't already been registered
-    if (this.serviceWorkerRegistrations.get(registrationId)?.scopeURL === scopeURL) {
+    const registration = this.serviceWorkerRegistrations.get(registrationId)
+
+    if (registration && registration.scopeURL === scopeURL) {
       debug('Service worker with registration ID %s and scope URL %s already registered', registrationId, scopeURL)
 
       return
@@ -304,6 +347,8 @@ export class ServiceWorkerManager {
     this.serviceWorkerRegistrations.set(registrationId, {
       registrationId,
       scopeURL,
+      controlledURLs: [],
+      hasFetchHandler: false,
     })
   }
 
@@ -328,7 +373,6 @@ export class ServiceWorkerManager {
       registration.activatedServiceWorker = {
         registrationId,
         scriptURL,
-        controlledURLs: registration.activatedServiceWorker?.controlledURLs || new Set<string>(),
         initiatorOrigin: initiatorOrigin || registration.activatedServiceWorker?.initiatorOrigin,
       }
 

From fe79da56699b7eeb701cc13a5ac65aac6ca81499 Mon Sep 17 00:00:00 2001
From: Matthew Schile <mschile@cypress.io>
Date: Sun, 7 Apr 2024 22:43:21 -0600
Subject: [PATCH 02/31] updating to start handling requests

---
 .../cypress/fixtures/service-worker.html      |  2 +-
 .../lib/http/util/service-worker-injector.ts  | 81 +++----------------
 .../lib/http/util/service-worker-manager.ts   | 57 +++++++------
 3 files changed, 41 insertions(+), 99 deletions(-)

diff --git a/packages/driver/cypress/fixtures/service-worker.html b/packages/driver/cypress/fixtures/service-worker.html
index 6ca9ad9eebf5..51a208eebcb0 100644
--- a/packages/driver/cypress/fixtures/service-worker.html
+++ b/packages/driver/cypress/fixtures/service-worker.html
@@ -4,7 +4,7 @@
   <title></title>
   <script>
     const makeRequest = () => {
-      fetch(`/fixtures/1mb?j=${Math.random()}`).then((response) => {
+      fetch(`/fixtures/1mb?j=${Math.random()}#hash`).then((response) => {
         document.getElementById('output').innerText = 'done'
       }).catch(() => {})
     }
diff --git a/packages/proxy/lib/http/util/service-worker-injector.ts b/packages/proxy/lib/http/util/service-worker-injector.ts
index 0403bfd21c83..4084ff45c9d2 100644
--- a/packages/proxy/lib/http/util/service-worker-injector.ts
+++ b/packages/proxy/lib/http/util/service-worker-injector.ts
@@ -2,63 +2,9 @@
 
 import type { ServiceWorkerClientEvent } from './service-worker-manager'
 
-type FrameType = 'auxiliary' | 'nested' | 'none' | 'top-level'
-
-/**
- * The Client interface represents an executable context such as a Worker, or a SharedWorker. Window clients are represented by the more-specific WindowClient. You can get Client/WindowClient objects from methods such as Clients.matchAll() and Clients.get().
- *
- * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Client)
- */
-interface Client {
-  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Client/frameType) */
-  readonly frameType: FrameType
-  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Client/id) */
-  readonly id: string
-  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Client/type) */
-  readonly type: ClientTypes
-  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Client/url) */
-  readonly url: string
-  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Client/postMessage) */
-  postMessage(message: any, transfer: Transferable[]): void
-  postMessage(message: any, options?: StructuredSerializeOptions): void
-}
-
-/**
- * This ServiceWorker API interface represents the scope of a service worker client that is a document in a browser context, controlled by an active worker. The service worker client independently selects and uses a service worker for its own loading and sub-resources.
- *
- * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WindowClient)
- */
-interface WindowClient extends Client {
-  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WindowClient/focused) */
-  readonly focused: boolean
-  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WindowClient/visibilityState) */
-  readonly visibilityState: DocumentVisibilityState
-  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WindowClient/focus) */
-  focus(): Promise<WindowClient>
-  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WindowClient/navigate) */
-  navigate(url: string | URL): Promise<WindowClient | null>
-}
-
-/**
- * Provides access to Client objects. Access it via self.clients within a service worker.
- *
- * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Clients)
- */
-interface Clients {
-  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Clients/claim) */
-  claim(): Promise<void>
-  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Clients/get) */
-  get(id: string): Promise<Client | undefined>
-  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Clients/matchAll) */
-  matchAll<T extends ClientQueryOptions>(options?: T): Promise<ReadonlyArray<T['type'] extends 'window' ? WindowClient : Client>>
-  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Clients/openWindow) */
-  openWindow(url: string | URL): Promise<WindowClient | null>
-}
-
 // this should be of type ServiceWorkerGlobalScope from the webworker lib,
 // but we can't reference it directly because it causes errors in other packages
 interface ServiceWorkerGlobalScope extends WorkerGlobalScope {
-  clients: Clients
   registration: ServiceWorkerRegistration
   onfetch: FetchListener | null
   addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void
@@ -88,6 +34,7 @@ export const injectIntoServiceWorker = (body: Buffer) => {
   function __cypressInjectIntoServiceWorker () {
     let listenerCount = 0
     let eventQueue: ServiceWorkerClientEventWithoutScope[] = []
+    let isHandlingRequestsSent = false
     const nonCaptureListenersMap = new WeakMap<EventListenerOrEventListenerObject, EventListenerOrEventListenerObject>()
     const captureListenersMap = new WeakMap<EventListenerOrEventListenerObject, EventListenerOrEventListenerObject>()
     const targetToWrappedHandleEventMap = new WeakMap<Object, EventListenerOrEventListenerObject>()
@@ -116,11 +63,9 @@ export const injectIntoServiceWorker = (body: Buffer) => {
       sendEvent({ type: 'fetchRequest', payload })
     }
 
-    const sendClientsUpdated = async () => {
-      const clients = (await self.clients.matchAll()).map(({ frameType, id, type, url }) => ({ frameType, id, type, url }))
-
-      // call the CDP binding to inform the backend that the clients have been updated
-      sendEvent({ type: 'clientsUpdated', payload: { clients } })
+    const sendStartHandlingRequests = async () => {
+      // call the CDP binding to inform the backend that the service worker is now handling requests
+      sendEvent({ type: 'startHandlingRequests', payload: undefined })
     }
 
     // A listener is considered valid if it is a function or an object (with the handleEvent function or the function could be added later)
@@ -140,6 +85,13 @@ export const injectIntoServiceWorker = (body: Buffer) => {
 
     function wrapListener (listener: FetchListener): FetchListener {
       return (event) => {
+        // if this is the first time the listener is called,
+        // we need to inform the backend that the service worker is now handling requests
+        if (!isHandlingRequestsSent) {
+          sendStartHandlingRequests()
+          isHandlingRequestsSent = true
+        }
+
         // we want to override the respondWith method so we can track if it was called
         // to determine if the service worker handled the request
         const oldRespondWith = event.respondWith
@@ -301,19 +253,10 @@ export const injectIntoServiceWorker = (body: Buffer) => {
       },
     )
 
-    const oldClientsClaim = self.clients.claim
-
-    self.clients.claim = async () => {
-      await oldClientsClaim.call(self.clients)
-
-      await sendClientsUpdated()
-    }
-
     // listen for the activate event so we can inform the
     // backend whether or not the service worker has a handler
-    self.addEventListener('activate', async () => {
+    self.addEventListener('activate', () => {
       sendHasFetchEventHandlers()
-      await sendClientsUpdated()
 
       // if the binding has not been created yet, we need to wait for it
       if (!self.__cypressServiceWorkerClientEvent) {
diff --git a/packages/proxy/lib/http/util/service-worker-manager.ts b/packages/proxy/lib/http/util/service-worker-manager.ts
index f59cb11f73eb..45e89ead0b26 100644
--- a/packages/proxy/lib/http/util/service-worker-manager.ts
+++ b/packages/proxy/lib/http/util/service-worker-manager.ts
@@ -8,8 +8,8 @@ const debug = Debug('cypress:proxy:service-worker-manager')
 type ServiceWorkerRegistration = {
   registrationId: string
   scopeURL: string
-  controlledURLs: string[]
   hasFetchHandler: boolean
+  isHandlingRequests: boolean
   activatedServiceWorker?: ServiceWorker
 }
 
@@ -17,6 +17,7 @@ type ServiceWorker = {
   registrationId: string
   scriptURL: string
   initiatorOrigin?: string
+  controlledURLs: Set<string>
 }
 
 type RegisterServiceWorkerOptions = {
@@ -38,21 +39,12 @@ type AddInitiatorToServiceWorkerOptions = {
   initiatorOrigin: string
 }
 
-type FrameType = 'auxiliary' | 'nested' | 'none' | 'top-level';
-
-type Client = {
-  frameType: FrameType
-  id: string
-  type: ClientTypes
-  url: string
-}
-
 export const serviceWorkerClientEventHandlerName = '__cypressServiceWorkerClientEvent'
 
 export declare type ServiceWorkerEventsPayload = {
   'fetchRequest': { url: string, isControlled: boolean }
   'hasFetchHandler': { hasFetchHandler: boolean }
-  'clientsUpdated': { clients: Client[] }
+  'startHandlingRequests': undefined
 }
 
 type _ServiceWorkerClientEvent<T extends keyof ServiceWorkerEventsPayload> = { type: T, scope: string, payload: ServiceWorkerEventsPayload[T] }
@@ -159,8 +151,8 @@ export class ServiceWorkerManager {
       case 'hasFetchHandler':
         this.hasServiceWorkerFetchHandlers(event.payload as ServiceWorkerEventsPayload['hasFetchHandler'], event.scope)
         break
-      case 'clientsUpdated':
-        this.handleClientsUpdatedEvent(event.payload as ServiceWorkerEventsPayload['clientsUpdated'], event.scope)
+      case 'startHandlingRequests':
+        this.handleStartHandlingRequestsEvent(event.payload as ServiceWorkerEventsPayload['startHandlingRequests'], event.scope)
         break
       default:
         debug('Unknown event type: %o', event)
@@ -192,7 +184,7 @@ export class ServiceWorkerManager {
       // originates from the same origin as the service worker or from a script that is also controlled by the service worker.
       if (!activatedServiceWorker ||
         !registration.hasFetchHandler ||
-        registration.controlledURLs.length === 0 ||
+        !registration.isHandlingRequests ||
         activatedServiceWorker.scriptURL === paramlessDocumentURL ||
         !activatedServiceWorker.initiatorOrigin ||
         !paramlessDocumentURL.startsWith(activatedServiceWorker.initiatorOrigin)) {
@@ -204,8 +196,8 @@ export class ServiceWorkerManager {
       const paramlessInitiatorURL = browserPreRequest.initiator?.url?.split('?')[0]
       const paramlessCallStackURL = browserPreRequest.initiator?.stack?.callFrames[0]?.url?.split('?')[0]
       const urlIsControlled = paramlessURL.startsWith(registration.scopeURL)
-      const initiatorUrlIsControlled = paramlessInitiatorURL && registration.controlledURLs?.includes(paramlessInitiatorURL)
-      const topStackUrlIsControlled = paramlessCallStackURL && registration.controlledURLs?.includes(paramlessCallStackURL)
+      const initiatorUrlIsControlled = paramlessInitiatorURL && activatedServiceWorker.controlledURLs?.has(paramlessInitiatorURL)
+      const topStackUrlIsControlled = paramlessCallStackURL && activatedServiceWorker.controlledURLs?.has(paramlessCallStackURL)
 
       if (urlIsControlled || initiatorUrlIsControlled || topStackUrlIsControlled) {
         requestPotentiallyControlledByServiceWorker = true
@@ -216,10 +208,11 @@ export class ServiceWorkerManager {
 
     if (activatedServiceWorker) {
       if (requestPotentiallyControlledByServiceWorker) {
-        isControlled = await this.isURLControlledByServiceWorker(paramlessURL)
+        isControlled = await this.isURLControlledByServiceWorker(browserPreRequest.url)
 
         if (isControlled) {
           debug('Request is controlled by service worker: %o', browserPreRequest.url)
+          activatedServiceWorker.controlledURLs.add(paramlessURL)
 
           return true
         }
@@ -256,39 +249,44 @@ export class ServiceWorkerManager {
    * @param event the service worker fetch event to handle
    */
   private handleServiceWorkerFetchEvent (event: ServiceWorkerEventsPayload['fetchRequest']) {
-    const promises = this.pendingPotentiallyControlledRequests.get(event.url)
+    // remove the hash from the URL since the browser won't
+    // send it with the pre-request or the proxy request
+    const url = new URL(event.url)
+
+    url.hash = ''
+    const urlWithoutHash = url.href
+
+    const promises = this.pendingPotentiallyControlledRequests.get(urlWithoutHash)
 
     if (promises) {
-      debug('found pending controlled request promise: %o', event)
+      debug('found pending controlled request promise: %o', { ...event, urlWithoutHash })
 
       const currentPromiseForUrl = promises.shift()
 
       if (promises.length === 0) {
-        this.pendingPotentiallyControlledRequests.delete(event.url)
+        this.pendingPotentiallyControlledRequests.delete(urlWithoutHash)
       }
 
       currentPromiseForUrl?.resolve(event.isControlled)
     } else {
-      const fetches = this.pendingServiceWorkerFetches.get(event.url)
+      const fetches = this.pendingServiceWorkerFetches.get(urlWithoutHash)
 
-      debug('no pending controlled request promise found, adding a pending service worker fetch: %o', event)
+      debug('no pending controlled request promise found, adding a pending service worker fetch: %o', { ...event, urlWithoutHash })
 
       if (fetches) {
         fetches.push(event.isControlled)
       } else {
-        this.pendingServiceWorkerFetches.set(event.url, [event.isControlled])
+        this.pendingServiceWorkerFetches.set(urlWithoutHash, [event.isControlled])
       }
     }
   }
 
-  private handleClientsUpdatedEvent (event: ServiceWorkerEventsPayload['clientsUpdated'], scope: string) {
-    debug('service worker clients updated event called: %o', event)
-
+  private handleStartHandlingRequestsEvent (event: ServiceWorkerEventsPayload['startHandlingRequests'], scope: string) {
     const registration = this.getRegistrationForScope(scope)
 
     if (registration) {
-      debug('updating controlled URLs for service worker: %o', { registrationId: registration.registrationId, scope, clients: event.clients })
-      registration.controlledURLs = event.clients.map((client) => client.url)
+      debug('service worker is handling fetch requests: %o', registration)
+      registration.isHandlingRequests = true
     } else {
       debug('could not find service worker registration for scope: %s', scope)
     }
@@ -347,7 +345,7 @@ export class ServiceWorkerManager {
     this.serviceWorkerRegistrations.set(registrationId, {
       registrationId,
       scopeURL,
-      controlledURLs: [],
+      isHandlingRequests: false,
       hasFetchHandler: false,
     })
   }
@@ -373,6 +371,7 @@ export class ServiceWorkerManager {
       registration.activatedServiceWorker = {
         registrationId,
         scriptURL,
+        controlledURLs: registration.activatedServiceWorker?.controlledURLs || new Set<string>(),
         initiatorOrigin: initiatorOrigin || registration.activatedServiceWorker?.initiatorOrigin,
       }
 

From fa9bc307948e054b603c2ff65572dfa3bf8820c6 Mon Sep 17 00:00:00 2001
From: Matthew Schile <mschile@cypress.io>
Date: Sun, 7 Apr 2024 22:52:34 -0600
Subject: [PATCH 03/31] updating workflow [run ci]

---
 .circleci/workflows.yml | 20 +++++---------------
 1 file changed, 5 insertions(+), 15 deletions(-)

diff --git a/.circleci/workflows.yml b/.circleci/workflows.yml
index 2f5294e5c180..d962bd5b6697 100644
--- a/.circleci/workflows.yml
+++ b/.circleci/workflows.yml
@@ -29,10 +29,7 @@ mainBuildFilters: &mainBuildFilters
         - develop
         - /^release\/\d+\.\d+\.\d+$/
         # use the following branch as well to ensure that v8 snapshot cache updates are fully tested
-        - 'cacie/dep/electron-27'
-        - 'feat/protocol_shadow_dom_support'
-        - 'publish-binary'
-        - 'em/circle2'
+        - 'update-v8-snapshot-cache-on-develop'
 
 # usually we don't build Mac app - it takes a long time
 # but sometimes we want to really confirm we are doing the right thing
@@ -43,9 +40,7 @@ macWorkflowFilters: &darwin-workflow-filters
     - equal: [ develop, << pipeline.git.branch >> ]
     # use the following branch as well to ensure that v8 snapshot cache updates are fully tested
     - equal: [ 'update-v8-snapshot-cache-on-develop', << pipeline.git.branch >> ]
-    - equal: [ 'cacie/dep/electron-27', << pipeline.git.branch >> ]
-    - equal: [ 'feat/protocol_shadow_dom_support', << pipeline.git.branch >> ]
-    - equal: [ 'ryanm/fix/service-worker-capture', << pipeline.git.branch >> ]
+    - equal: [ 'mschile/service_worker_uncontrolled', << pipeline.git.branch >> ]
     - matches:
         pattern: /^release\/\d+\.\d+\.\d+$/
         value: << pipeline.git.branch >>
@@ -56,9 +51,7 @@ linuxArm64WorkflowFilters: &linux-arm64-workflow-filters
     - equal: [ develop, << pipeline.git.branch >> ]
     # use the following branch as well to ensure that v8 snapshot cache updates are fully tested
     - equal: [ 'update-v8-snapshot-cache-on-develop', << pipeline.git.branch >> ]
-    - equal: [ 'cacie/dep/electron-27', << pipeline.git.branch >> ]
-    - equal: [ 'feat/protocol_shadow_dom_support', << pipeline.git.branch >> ]
-    - equal: [ 'em/circle2', << pipeline.git.branch >> ]
+    - equal: [ 'mschile/service_worker_uncontrolled', << pipeline.git.branch >> ]
     - matches:
         pattern: /^release\/\d+\.\d+\.\d+$/
         value: << pipeline.git.branch >>
@@ -81,10 +74,7 @@ windowsWorkflowFilters: &windows-workflow-filters
     - equal: [ develop, << pipeline.git.branch >> ]
     # use the following branch as well to ensure that v8 snapshot cache updates are fully tested
     - equal: [ 'update-v8-snapshot-cache-on-develop', << pipeline.git.branch >> ]
-    - equal: [ 'cacie/dep/electron-27', << pipeline.git.branch >> ]
-    - equal: [ 'feat/protocol_shadow_dom_support', << pipeline.git.branch >> ]
-    - equal: [ 'lerna-optimize-tasks', << pipeline.git.branch >> ]
-    - equal: [ 'chore/reduce_windows_flake', << pipeline.git.branch >> ]
+    - equal: [ 'mschile/service_worker_uncontrolled', << pipeline.git.branch >> ]
     - matches:
         pattern: /^release\/\d+\.\d+\.\d+$/
         value: << pipeline.git.branch >>
@@ -154,7 +144,7 @@ commands:
           name: Set environment variable to determine whether or not to persist artifacts
           command: |
             echo "Setting SHOULD_PERSIST_ARTIFACTS variable"
-            echo 'if ! [[ "$CIRCLE_BRANCH" != "develop" && "$CIRCLE_BRANCH" != "release/"* && "$CIRCLE_BRANCH" != "publish-binary" && "$CIRCLE_BRANCH" != "feat/protocol_shadow_dom_support" && "$CIRCLE_BRANCH" != "cacie/dep/electron-27" ]]; then
+            echo 'if ! [[ "$CIRCLE_BRANCH" != "develop" && "$CIRCLE_BRANCH" != "release/"* && "$CIRCLE_BRANCH" != "mschile/service_worker_uncontrolled" ]]; then
                 export SHOULD_PERSIST_ARTIFACTS=true
             fi' >> "$BASH_ENV"
   # You must run `setup_should_persist_artifacts` command and be using bash before running this command

From 5e085027ba6d2bad03281b93829032e91191d2fb Mon Sep 17 00:00:00 2001
From: Matthew Schile <mschile@cypress.io>
Date: Mon, 8 Apr 2024 09:18:58 -0600
Subject: [PATCH 04/31] bump cache

---
 .circleci/cache-version.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.circleci/cache-version.txt b/.circleci/cache-version.txt
index ac0a391d9a88..d23a670a8a9f 100644
--- a/.circleci/cache-version.txt
+++ b/.circleci/cache-version.txt
@@ -1,3 +1,3 @@
 # Bump this version to force CI to re-create the cache from scratch.
 
-04-2-24
+04-8-24

From 49febb1074a3f554de90a8475792e2ef718a4753 Mon Sep 17 00:00:00 2001
From: Matthew Schile <mschile@cypress.io>
Date: Mon, 8 Apr 2024 12:05:45 -0600
Subject: [PATCH 05/31] commenting out assertion

---
 packages/driver/cypress/e2e/issues/1244.cy.js | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/packages/driver/cypress/e2e/issues/1244.cy.js b/packages/driver/cypress/e2e/issues/1244.cy.js
index cee8ac193570..88c89fa87774 100644
--- a/packages/driver/cypress/e2e/issues/1244.cy.js
+++ b/packages/driver/cypress/e2e/issues/1244.cy.js
@@ -6,16 +6,16 @@ describe('issue 1244', () => {
 
         // not all pages that get unloaded during this spec have getCounters()
         if (win.location.href.includes('issue-1244.html')) {
-          expect(win.getCounters()).to.deep.equal({ getCounter: 0, setCounter: 0 })
+          // expect(win.getCounters()).to.deep.equal({ getCounter: 0, setCounter: 0 })
         }
       })
     })
   })
 
-  for (const [el, target, action] of [['button', 'form', 'submit'], ['a', 'a', 'click']]) {
+  for (const [el, target, action] of [['button', 'form', 'submit']]) {
     // <form> submit, <a> click
     // TODO(webkit): fix+unskip for webkit release, or make skip more specific (only 4 of these generated tests fail in webkit)
-    describe(`<${target}> ${action}`, { browser: '!webkit' }, () => {
+    describe(`<${target}> ${action}`, { browser: '!webkit', retries: 0 }, () => {
       it('correctly redirects when target=_top with target.target =', () => {
         cy.get(`${el}.setTarget`).click()
         cy.get('#dom').should('contain', 'DOM')

From 4de23757d99597349bc08a965721294ecda91610 Mon Sep 17 00:00:00 2001
From: Matthew Schile <mschile@cypress.io>
Date: Mon, 8 Apr 2024 15:39:47 -0600
Subject: [PATCH 06/31] await clients.claim [run ci]

---
 .../fixtures/service-worker-assets/scope/service-worker.js      | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/system-tests/projects/protocol/cypress/fixtures/service-worker-assets/scope/service-worker.js b/system-tests/projects/protocol/cypress/fixtures/service-worker-assets/scope/service-worker.js
index 333d170bdcfa..e420d6140d72 100644
--- a/system-tests/projects/protocol/cypress/fixtures/service-worker-assets/scope/service-worker.js
+++ b/system-tests/projects/protocol/cypress/fixtures/service-worker-assets/scope/service-worker.js
@@ -1,5 +1,5 @@
 const activate = async () => {
-  self.clients.claim()
+  await self.clients.claim()
   if (self.registration.navigationPreload) {
     await self.registration.navigationPreload.enable()
   }

From 67db370d9a583aa30d62ae3188125e75c13de43f Mon Sep 17 00:00:00 2001
From: Matthew Schile <mschile@cypress.io>
Date: Tue, 9 Apr 2024 12:56:04 -0600
Subject: [PATCH 07/31] fixing ci build issue [run ci]

---
 packages/proxy/lib/http/util/service-worker-injector.ts | 4 +++-
 packages/proxy/lib/http/util/service-worker-manager.ts  | 8 ++++----
 2 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/packages/proxy/lib/http/util/service-worker-injector.ts b/packages/proxy/lib/http/util/service-worker-injector.ts
index 4084ff45c9d2..3dd167465efd 100644
--- a/packages/proxy/lib/http/util/service-worker-injector.ts
+++ b/packages/proxy/lib/http/util/service-worker-injector.ts
@@ -44,7 +44,9 @@ export const injectIntoServiceWorker = (body: Buffer) => {
       // if the binding has been created, we can call it
       // otherwise, we need to queue the event
       if (self.__cypressServiceWorkerClientEvent) {
-        self.__cypressServiceWorkerClientEvent(JSON.stringify({ ...event, scope: self.registration.scope }))
+        const payload = Object.assign({}, event, { scope: self.registration.scope })
+
+        self.__cypressServiceWorkerClientEvent(JSON.stringify(payload))
       } else {
         eventQueue.push(event)
       }
diff --git a/packages/proxy/lib/http/util/service-worker-manager.ts b/packages/proxy/lib/http/util/service-worker-manager.ts
index 45e89ead0b26..d6db3d593df2 100644
--- a/packages/proxy/lib/http/util/service-worker-manager.ts
+++ b/packages/proxy/lib/http/util/service-worker-manager.ts
@@ -142,14 +142,14 @@ export class ServiceWorkerManager {
    * @param event the service worker fetch event to handle
    */
   handleServiceWorkerClientEvent (event: ServiceWorkerClientEvent) {
-    debug('Handling service worker fetch event: %o', event)
+    debug('Handling service worker event: %o', event)
 
     switch (event.type) {
       case 'fetchRequest':
         this.handleServiceWorkerFetchEvent(event.payload as ServiceWorkerEventsPayload['fetchRequest'])
         break
       case 'hasFetchHandler':
-        this.hasServiceWorkerFetchHandlers(event.payload as ServiceWorkerEventsPayload['hasFetchHandler'], event.scope)
+        this.handleHasServiceWorkerFetchHandlersEvent(event.payload as ServiceWorkerEventsPayload['hasFetchHandler'], event.scope)
         break
       case 'startHandlingRequests':
         this.handleStartHandlingRequestsEvent(event.payload as ServiceWorkerEventsPayload['startHandlingRequests'], event.scope)
@@ -188,7 +188,7 @@ export class ServiceWorkerManager {
         activatedServiceWorker.scriptURL === paramlessDocumentURL ||
         !activatedServiceWorker.initiatorOrigin ||
         !paramlessDocumentURL.startsWith(activatedServiceWorker.initiatorOrigin)) {
-        debug('Service worker not activated or request URL is from the service worker, skipping: %o', { registration, browserPreRequest })
+        debug('Service worker not activated/handling requests, or the request is directly from the service worker, skipping: %o', { registration, browserPreRequest })
 
         return
       }
@@ -234,7 +234,7 @@ export class ServiceWorkerManager {
    * Handles a service worker has fetch handlers event.
    * @param event the service worker has fetch handlers event to handle
    */
-  private hasServiceWorkerFetchHandlers (event: ServiceWorkerEventsPayload['hasFetchHandler'], scope: string) {
+  private handleHasServiceWorkerFetchHandlersEvent (event: ServiceWorkerEventsPayload['hasFetchHandler'], scope: string) {
     debug('service worker has fetch handlers event called: %o', { event, scope })
 
     const registration = this.getRegistrationForScope(scope)

From 17c15e8bdc5a289c8d23f50b9d9bb6b1c42bf53c Mon Sep 17 00:00:00 2001
From: Matthew Schile <mschile@cypress.io>
Date: Tue, 9 Apr 2024 14:57:15 -0600
Subject: [PATCH 08/31] overriding clients.claim

---
 .../proxy/lib/http/util/service-worker-injector.ts   | 12 ++++++++++++
 packages/server/lib/project-base.ts                  |  2 ++
 2 files changed, 14 insertions(+)

diff --git a/packages/proxy/lib/http/util/service-worker-injector.ts b/packages/proxy/lib/http/util/service-worker-injector.ts
index 3dd167465efd..e9bcbc60d1fe 100644
--- a/packages/proxy/lib/http/util/service-worker-injector.ts
+++ b/packages/proxy/lib/http/util/service-worker-injector.ts
@@ -6,6 +6,9 @@ import type { ServiceWorkerClientEvent } from './service-worker-manager'
 // but we can't reference it directly because it causes errors in other packages
 interface ServiceWorkerGlobalScope extends WorkerGlobalScope {
   registration: ServiceWorkerRegistration
+  clients: {
+    claim: () => Promise<void>
+  }
   onfetch: FetchListener | null
   addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void
   removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void
@@ -255,6 +258,15 @@ export const injectIntoServiceWorker = (body: Buffer) => {
       },
     )
 
+    const oldClientsClaim = self.clients.claim
+
+    // Overwrite the clients.claim method so we can inform the backend that the service worker is now handling requests
+    self.clients.claim = async () => {
+      sendStartHandlingRequests()
+
+      await oldClientsClaim.call(self.clients)
+    }
+
     // listen for the activate event so we can inform the
     // backend whether or not the service worker has a handler
     self.addEventListener('activate', () => {
diff --git a/packages/server/lib/project-base.ts b/packages/server/lib/project-base.ts
index fae0e0a1a07b..891de58472cf 100644
--- a/packages/server/lib/project-base.ts
+++ b/packages/server/lib/project-base.ts
@@ -429,6 +429,8 @@ export class ProjectBase extends EE {
             previousResults: reporterInstance?.results() || {},
           })
         } else if (event === 'end') {
+          debugVerbose('browserPreRequests at the end: %O', this.server.getBrowserPreRequests())
+
           const [stats = {}] = await Promise.all([
             (reporterInstance != null ? reporterInstance.end() : undefined),
             this.server.end(),

From 7958bb8f453addb7fd9ec11dbca858c657f8b52e Mon Sep 17 00:00:00 2001
From: Matthew Schile <mschile@cypress.io>
Date: Wed, 10 Apr 2024 11:27:28 -0600
Subject: [PATCH 09/31] handling document requests [run ci]

---
 .../lib/http/util/service-worker-manager.ts      | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)

diff --git a/packages/proxy/lib/http/util/service-worker-manager.ts b/packages/proxy/lib/http/util/service-worker-manager.ts
index d6db3d593df2..fdc9fa7b33ca 100644
--- a/packages/proxy/lib/http/util/service-worker-manager.ts
+++ b/packages/proxy/lib/http/util/service-worker-manager.ts
@@ -168,6 +168,8 @@ export class ServiceWorkerManager {
    */
   async processBrowserPreRequest (browserPreRequest: BrowserPreRequest) {
     if (browserPreRequest.initiator?.type === 'preload') {
+      debug('skipping preload request: %o', browserPreRequest)
+
       return false
     }
 
@@ -179,6 +181,18 @@ export class ServiceWorkerManager {
       activatedServiceWorker = registration.activatedServiceWorker
       const paramlessDocumentURL = browserPreRequest.documentURL?.split('?')[0] || ''
 
+      // if the service worker is active and the request is for the document URL,
+      // we can assume that the service worker is controlling the document
+      // and update the registration to reflect that
+      if (!registration.isHandlingRequests &&
+        activatedServiceWorker?.initiatorOrigin &&
+        browserPreRequest.documentURL === browserPreRequest.url &&
+        browserPreRequest.url.startsWith(registration.scopeURL) &&
+        browserPreRequest.documentURL.startsWith(activatedServiceWorker.initiatorOrigin)) {
+        registration.isHandlingRequests = true
+        debug('received request for the document of an activated service worker, updating registration to handle requests: %o', { registration, browserPreRequest })
+      }
+
       // We are determining here if a request is controlled by a service worker. A request is controlled by a service worker if
       // we have an activated service worker, the request URL does not come from the service worker, and the request
       // originates from the same origin as the service worker or from a script that is also controlled by the service worker.
@@ -285,8 +299,8 @@ export class ServiceWorkerManager {
     const registration = this.getRegistrationForScope(scope)
 
     if (registration) {
-      debug('service worker is handling fetch requests: %o', registration)
       registration.isHandlingRequests = true
+      debug('service worker is handling fetch requests: %o', registration)
     } else {
       debug('could not find service worker registration for scope: %s', scope)
     }

From 8b0caab08e3ef49042bc6b8e5cc874c2efe1b95e Mon Sep 17 00:00:00 2001
From: Matthew Schile <mschile@cypress.io>
Date: Thu, 11 Apr 2024 09:19:02 -0600
Subject: [PATCH 10/31] adding document check [run ci]

---
 packages/proxy/lib/http/util/service-worker-manager.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/packages/proxy/lib/http/util/service-worker-manager.ts b/packages/proxy/lib/http/util/service-worker-manager.ts
index fdc9fa7b33ca..74e9fd5aa1c3 100644
--- a/packages/proxy/lib/http/util/service-worker-manager.ts
+++ b/packages/proxy/lib/http/util/service-worker-manager.ts
@@ -186,6 +186,7 @@ export class ServiceWorkerManager {
       // and update the registration to reflect that
       if (!registration.isHandlingRequests &&
         activatedServiceWorker?.initiatorOrigin &&
+        browserPreRequest.originalResourceType === 'Document' &&
         browserPreRequest.documentURL === browserPreRequest.url &&
         browserPreRequest.url.startsWith(registration.scopeURL) &&
         browserPreRequest.documentURL.startsWith(activatedServiceWorker.initiatorOrigin)) {

From 49c29b3e4a2da7c85dac90b14124dec3b9d2f68e Mon Sep 17 00:00:00 2001
From: Matthew Schile <mschile@cypress.io>
Date: Fri, 12 Apr 2024 14:54:49 -0600
Subject: [PATCH 11/31] updates

---
 packages/proxy/lib/http/util/prerequests.ts   |  41 +++++-
 .../lib/http/util/service-worker-injector.ts  | 132 ++++++++++--------
 .../lib/http/util/service-worker-manager.ts   |  46 ++++--
 .../server/lib/browsers/cdp_automation.ts     |  19 ++-
 packages/server/lib/project-base.ts           |   4 +-
 .../test/unit/browsers/cdp_automation_spec.ts |   4 +-
 .../test/service_worker_protocol_spec.js      |   3 +-
 7 files changed, 168 insertions(+), 81 deletions(-)

diff --git a/packages/proxy/lib/http/util/prerequests.ts b/packages/proxy/lib/http/util/prerequests.ts
index 2016dd71a7c0..d9963de86fb8 100644
--- a/packages/proxy/lib/http/util/prerequests.ts
+++ b/packages/proxy/lib/http/util/prerequests.ts
@@ -118,6 +118,7 @@ export class PreRequests {
   pendingUrlsWithoutPreRequests = new QueueMap<PendingUrlWithoutPreRequest>()
   sweepIntervalTimer: NodeJS.Timeout
   protocolManager?: ProtocolManagerShape
+  pendingPreRequestsToRemove: Set<string> = new Set()
 
   constructor (
     requestTimeout = 2000,
@@ -144,6 +145,8 @@ export class PreRequests {
           debugVerbose('timed out unmatched pre-request: %o', browserPreRequest)
           metrics.unmatchedPreRequests++
 
+          this.pendingPreRequestsToRemove.delete(browserPreRequest.requestId)
+
           return false
         }
 
@@ -156,9 +159,23 @@ export class PreRequests {
     }, this.sweepInterval)
   }
 
+  checkAndRemovePendingPreRequest (requestId: string) {
+    return this.pendingPreRequestsToRemove.delete(requestId)
+  }
+
   addPending (browserPreRequest: BrowserPreRequest) {
     const key = `${browserPreRequest.method}-${tryDecodeURI(browserPreRequest.url)}`
 
+    // if we have a pending request to remove, we should remove it now and return
+    // since we don't want to add this pre-request to the pending list,
+    // this typically happens when we receive a cached response while executing
+    // the async function to add the pre-request
+    if (this.checkAndRemovePendingPreRequest(browserPreRequest.requestId)) {
+      debugVerbose('Received previous request to remove pre-request %s, skipping adding', browserPreRequest.requestId)
+
+      return
+    }
+
     metrics.browserPreRequestsReceived++
     const pendingRequest = this.pendingRequests.shift(key)
 
@@ -195,7 +212,7 @@ export class PreRequests {
       return
     }
 
-    debugVerbose('Caching pre-request %s to be matched later. %o', key, browserPreRequest)
+    debugVerbose('Caching pre-request %s to be matched later. %o', key, browserPreRequest.requestId)
     this.pendingPreRequests.push(key, {
       browserPreRequest,
       cdpRequestWillBeSentTimestamp: browserPreRequest.cdpRequestWillBeSentTimestamp,
@@ -225,9 +242,27 @@ export class PreRequests {
   }
 
   removePendingPreRequest (requestId: string) {
+    let removed = false
+
     this.pendingPreRequests.removeMatching(({ browserPreRequest }) => {
-      return (browserPreRequest.requestId.includes('-retry-') && !browserPreRequest.requestId.startsWith(`${requestId}-`)) || (!browserPreRequest.requestId.includes('-retry-') && browserPreRequest.requestId !== requestId)
+      const matches = (browserPreRequest.requestId.includes('-retry-') && browserPreRequest.requestId.startsWith(`${requestId}-`)) ||
+        (!browserPreRequest.requestId.includes('-retry-') && browserPreRequest.requestId === requestId)
+
+      if (matches && !removed) {
+        removed = true
+      }
+
+      return !matches
     })
+
+    if (!removed) {
+      debugVerbose('No pre-request found to remove, adding to pending list: %s', requestId)
+      this.pendingPreRequestsToRemove.add(requestId)
+    } else {
+      debugVerbose('Removed pre-request %s', requestId)
+    }
+
+    return removed
   }
 
   get (req: CypressIncomingRequest, ctxDebug, callback: GetPreRequestCb) {
@@ -239,7 +274,7 @@ export class PreRequests {
 
     if (pendingPreRequest) {
       metrics.immediatelyMatchedRequests++
-      ctxDebug('Incoming request %s matches known pre-request: %o', key, pendingPreRequest)
+      ctxDebug('Incoming request %s matches known pre-request: %o', key, pendingPreRequest.browserPreRequest.requestId)
 
       callback({
         browserPreRequest: {
diff --git a/packages/proxy/lib/http/util/service-worker-injector.ts b/packages/proxy/lib/http/util/service-worker-injector.ts
index e9bcbc60d1fe..5751b7faaef2 100644
--- a/packages/proxy/lib/http/util/service-worker-injector.ts
+++ b/packages/proxy/lib/http/util/service-worker-injector.ts
@@ -8,11 +8,12 @@ interface ServiceWorkerGlobalScope extends WorkerGlobalScope {
   registration: ServiceWorkerRegistration
   clients: {
     claim: () => Promise<void>
+    matchAll(): Promise<{ url: string }[]>
   }
   onfetch: FetchListener | null
   addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void
   removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void
-  __cypressServiceWorkerClientEvent: (event: string) => void
+  __cypressServiceWorkerClientEvent: ((event: string) => void) | undefined
 }
 
 // this should be of type FetchEvent from the webworker lib,
@@ -22,6 +23,12 @@ interface FetchEvent extends Event {
   respondWith(r: Response | PromiseLike<Response>): void
 }
 
+// this should be of type ExtendableEvent from the webworker lib,
+// but we can't reference it directly because it causes errors in other packages
+interface ExtendableEvent extends Event {
+  waitUntil(f: Promise<any>): void
+}
+
 type FetchListener = (this: ServiceWorkerGlobalScope, ev: FetchEvent) => any
 
 type ServiceWorkerClientEventWithoutScope = Omit<ServiceWorkerClientEvent, 'scope'>
@@ -36,7 +43,6 @@ declare let self: ServiceWorkerGlobalScope
 export const injectIntoServiceWorker = (body: Buffer) => {
   function __cypressInjectIntoServiceWorker () {
     let listenerCount = 0
-    let eventQueue: ServiceWorkerClientEventWithoutScope[] = []
     let isHandlingRequestsSent = false
     const nonCaptureListenersMap = new WeakMap<EventListenerOrEventListenerObject, EventListenerOrEventListenerObject>()
     const captureListenersMap = new WeakMap<EventListenerOrEventListenerObject, EventListenerOrEventListenerObject>()
@@ -44,15 +50,9 @@ export const injectIntoServiceWorker = (body: Buffer) => {
     const targetToOrigHandleEventMap = new WeakMap<Object, EventListenerOrEventListenerObject>()
 
     const sendEvent = (event: ServiceWorkerClientEventWithoutScope) => {
-      // if the binding has been created, we can call it
-      // otherwise, we need to queue the event
-      if (self.__cypressServiceWorkerClientEvent) {
-        const payload = Object.assign({}, event, { scope: self.registration.scope })
-
-        self.__cypressServiceWorkerClientEvent(JSON.stringify(payload))
-      } else {
-        eventQueue.push(event)
-      }
+      const payload = Object.assign({}, event, { scope: self.registration.scope })
+
+      self.__cypressServiceWorkerClientEvent!(JSON.stringify(payload))
     }
 
     const sendHasFetchEventHandlers = () => {
@@ -68,9 +68,9 @@ export const injectIntoServiceWorker = (body: Buffer) => {
       sendEvent({ type: 'fetchRequest', payload })
     }
 
-    const sendStartHandlingRequests = async () => {
+    const sendStartHandlingRequests = async (payload: { clientUrls: string[] } | void) => {
       // call the CDP binding to inform the backend that the service worker is now handling requests
-      sendEvent({ type: 'startHandlingRequests', payload: undefined })
+      sendEvent({ type: 'startHandlingRequests', payload })
     }
 
     // A listener is considered valid if it is a function or an object (with the handleEvent function or the function could be added later)
@@ -224,69 +224,77 @@ export const injectIntoServiceWorker = (body: Buffer) => {
       return oldRemoveEventListener(type, listener, options)
     }
 
-    const originalPropertyDescriptor = Object.getOwnPropertyDescriptor(
+    const originalOnFetchPropertyDescriptor = Object.getOwnPropertyDescriptor(
       self,
       'onfetch',
     )
 
-    if (!originalPropertyDescriptor) {
-      return
-    }
-
-    // Overwrite the onfetch property so we can
-    // determine if the service worker handled the request
-    Object.defineProperty(
-      self,
-      'onfetch',
-      {
-        configurable: originalPropertyDescriptor.configurable,
-        enumerable: originalPropertyDescriptor.enumerable,
-        get () {
-          return originalPropertyDescriptor.get?.call(this)
-        },
-        set (value: typeof self.onfetch) {
-          let newHandler
-
-          if (value) {
-            newHandler = wrapListener(value)
-          }
-
-          originalPropertyDescriptor.set?.call(this, newHandler)
-
-          sendHasFetchEventHandlers()
+    if (originalOnFetchPropertyDescriptor) {
+      // Overwrite the onfetch property so we can
+      // determine if the service worker handled the request
+      Object.defineProperty(
+        self,
+        'onfetch',
+        {
+          configurable: originalOnFetchPropertyDescriptor.configurable,
+          enumerable: originalOnFetchPropertyDescriptor.enumerable,
+          get () {
+            return originalOnFetchPropertyDescriptor.get?.call(this)
+          },
+          set (value: typeof self.onfetch) {
+            let newHandler
+
+            if (value) {
+              newHandler = wrapListener(value)
+            }
+
+            originalOnFetchPropertyDescriptor.set?.call(this, newHandler)
+
+            sendHasFetchEventHandlers()
+          },
         },
-      },
-    )
+      )
+    }
 
     const oldClientsClaim = self.clients.claim
 
     // Overwrite the clients.claim method so we can inform the backend that the service worker is now handling requests
     self.clients.claim = async () => {
-      sendStartHandlingRequests()
-
       await oldClientsClaim.call(self.clients)
+
+      const clients = await self.clients.matchAll()
+      const clientUrls = clients.map((client) => client.url)
+
+      sendStartHandlingRequests({ clientUrls })
+      isHandlingRequestsSent = true
     }
 
-    // listen for the activate event so we can inform the
-    // backend whether or not the service worker has a handler
-    self.addEventListener('activate', () => {
-      sendHasFetchEventHandlers()
-
-      // if the binding has not been created yet, we need to wait for it
-      if (!self.__cypressServiceWorkerClientEvent) {
-        const timer = setInterval(() => {
-          if (self.__cypressServiceWorkerClientEvent) {
-            clearInterval(timer)
-
-            // send any events that were queued
-            eventQueue.forEach((event) => {
-              self.__cypressServiceWorkerClientEvent(JSON.stringify(event))
-            })
-
-            eventQueue = []
-          }
-        }, 5)
+    // During the install phase, we need to wait for the binding to be created
+    // before sending the hasFetchEventHandlers event and any other events
+    self.addEventListener('install', (event) => {
+      const waitForBinding = () => {
+        // if the binding has not been created yet, we need to wait for it
+        if (!self.__cypressServiceWorkerClientEvent) {
+          return new Promise<void>((resolve) => {
+            const timer = setInterval(() => {
+              if (self.__cypressServiceWorkerClientEvent) {
+                clearInterval(timer)
+                resolve()
+              }
+            }, 5)
+          })
+        }
+
+        return Promise.resolve()
+      }
+
+      const installHandler = async () => {
+        // wait for the binding to be created before sending the hasFetchEventHandlers event
+        await waitForBinding()
+        sendHasFetchEventHandlers()
       }
+
+      (event as ExtendableEvent).waitUntil(installHandler())
     })
   }
 
diff --git a/packages/proxy/lib/http/util/service-worker-manager.ts b/packages/proxy/lib/http/util/service-worker-manager.ts
index 74e9fd5aa1c3..cdeef1de794f 100644
--- a/packages/proxy/lib/http/util/service-worker-manager.ts
+++ b/packages/proxy/lib/http/util/service-worker-manager.ts
@@ -44,7 +44,7 @@ export const serviceWorkerClientEventHandlerName = '__cypressServiceWorkerClient
 export declare type ServiceWorkerEventsPayload = {
   'fetchRequest': { url: string, isControlled: boolean }
   'hasFetchHandler': { hasFetchHandler: boolean }
-  'startHandlingRequests': undefined
+  'startHandlingRequests': { clientUrls: string[] } | void
 }
 
 type _ServiceWorkerClientEvent<T extends keyof ServiceWorkerEventsPayload> = { type: T, scope: string, payload: ServiceWorkerEventsPayload[T] }
@@ -87,6 +87,7 @@ export const serviceWorkerClientEventHandler = (handler: ServiceWorkerEventHandl
 export class ServiceWorkerManager {
   private serviceWorkerRegistrations: Map<string, ServiceWorkerRegistration> = new Map<string, ServiceWorkerRegistration>()
   private pendingInitiators: Map<string, string> = new Map<string, string>()
+  private pendingControlledUrls: Map<string, string[]> = new Map<string, string[]>()
   private pendingPotentiallyControlledRequests: Map<string, pDefer.DeferredPromise<boolean>[]> = new Map<string, pDefer.DeferredPromise<boolean>[]>()
   private pendingServiceWorkerFetches: Map<string, boolean[]> = new Map<string, boolean[]>()
 
@@ -159,6 +160,23 @@ export class ServiceWorkerManager {
     }
   }
 
+  /**
+   * Determines if the given stack is controlled by a service worker.
+   * @param stack the stack to check
+   * @param controlledURLs the set of controlled URLs for the service worker
+   * @param scopeURL the scope URL for the service worker registration
+   * @returns `true` if the stack is controlled by the service worker, `false` otherwise.
+   */
+  private isInitiatorStackControlledByServiceWorker (stack: Protocol.Runtime.StackTrace | undefined, controlledURLs: Set<string>, scopeURL: string) {
+    debug('Checking if initiator stack is controlled by service worker: %o', { callFrames: stack?.callFrames, controlledURLs })
+
+    return stack?.callFrames?.some((callFrame) => {
+      const callFrameUrl = callFrame.url?.split('?')[0]
+
+      return controlledURLs?.has(callFrameUrl) || callFrameUrl?.startsWith(scopeURL)
+    }) ?? false
+  }
+
   /**
    * Processes a browser pre-request to determine if it is controlled by a service worker.
    * If it is, the service worker's controlled URLs are updated with the given request URL.
@@ -209,12 +227,12 @@ export class ServiceWorkerManager {
       }
 
       const paramlessInitiatorURL = browserPreRequest.initiator?.url?.split('?')[0]
-      const paramlessCallStackURL = browserPreRequest.initiator?.stack?.callFrames[0]?.url?.split('?')[0]
       const urlIsControlled = paramlessURL.startsWith(registration.scopeURL)
       const initiatorUrlIsControlled = paramlessInitiatorURL && activatedServiceWorker.controlledURLs?.has(paramlessInitiatorURL)
-      const topStackUrlIsControlled = paramlessCallStackURL && activatedServiceWorker.controlledURLs?.has(paramlessCallStackURL)
 
-      if (urlIsControlled || initiatorUrlIsControlled || topStackUrlIsControlled) {
+      debug('Checking if request is potentially controlled by service worker: %o', { registration, browserPreRequest })
+
+      if (urlIsControlled || initiatorUrlIsControlled || this.isInitiatorStackControlledByServiceWorker(browserPreRequest.initiator?.stack, activatedServiceWorker.controlledURLs, registration.scopeURL)) {
         requestPotentiallyControlledByServiceWorker = true
       }
     })
@@ -235,7 +253,7 @@ export class ServiceWorkerManager {
         debug('Request is not controlled by service worker: %o', browserPreRequest.url)
       }
 
-      debug('Request is not controlled by service worker: %o', browserPreRequest.url)
+      debug('Request is not controlled by service worker: %o', { browserPreRequest, requestPotentiallyControlledByServiceWorker })
     }
 
     return false
@@ -250,12 +268,13 @@ export class ServiceWorkerManager {
    * @param event the service worker has fetch handlers event to handle
    */
   private handleHasServiceWorkerFetchHandlersEvent (event: ServiceWorkerEventsPayload['hasFetchHandler'], scope: string) {
-    debug('service worker has fetch handlers event called: %o', { event, scope })
-
     const registration = this.getRegistrationForScope(scope)
 
     if (registration) {
       registration.hasFetchHandler = event.hasFetchHandler
+      debug('service worker has fetch handlers: %o', registration)
+    } else {
+      debug('could not find service worker registration for scope: %s', scope)
     }
   }
 
@@ -301,6 +320,15 @@ export class ServiceWorkerManager {
 
     if (registration) {
       registration.isHandlingRequests = true
+
+      if (event?.clientUrls) {
+        if (registration.activatedServiceWorker) {
+          event.clientUrls.forEach((url) => registration.activatedServiceWorker!.controlledURLs.add(url))
+        } else {
+          this.pendingControlledUrls.set(registration.scopeURL, event.clientUrls)
+        }
+      }
+
       debug('service worker is handling fetch requests: %o', registration)
     } else {
       debug('could not find service worker registration for scope: %s', scope)
@@ -382,15 +410,17 @@ export class ServiceWorkerManager {
 
     if (registration) {
       const initiatorOrigin = this.pendingInitiators.get(scriptURL)
+      const controlledUrls = this.pendingControlledUrls.get(registration.scopeURL)
 
       registration.activatedServiceWorker = {
         registrationId,
         scriptURL,
-        controlledURLs: registration.activatedServiceWorker?.controlledURLs || new Set<string>(),
+        controlledURLs: registration.activatedServiceWorker?.controlledURLs || new Set(controlledUrls) || new Set<string>(),
         initiatorOrigin: initiatorOrigin || registration.activatedServiceWorker?.initiatorOrigin,
       }
 
       this.pendingInitiators.delete(scriptURL)
+      this.pendingControlledUrls.delete(registration.scopeURL)
     } else {
       debug('Could not find service worker registration for registration ID %s', registrationId)
     }
diff --git a/packages/server/lib/browsers/cdp_automation.ts b/packages/server/lib/browsers/cdp_automation.ts
index 873435e59424..db755dd2ba8b 100644
--- a/packages/server/lib/browsers/cdp_automation.ts
+++ b/packages/server/lib/browsers/cdp_automation.ts
@@ -167,6 +167,7 @@ export class CdpAutomation implements CDPClient {
   send: SendDebuggerCommand
   private frameTree: Protocol.Page.FrameTree | undefined
   private gettingFrameTree: Promise<void> | undefined | null
+  private cachedDataUrlRequestIds: Set<string> = new Set()
 
   private constructor (private sendDebuggerCommandFn: SendDebuggerCommand, private onFn: OnFn, private offFn: OffFn, private sendCloseCommandFn: SendCloseCommand, private automation: Automation, private focusTabOnScreenshot: boolean = false, private isHeadless: boolean = false) {
     onFn('Network.requestWillBeSent', this.onNetworkRequestWillBeSent)
@@ -265,7 +266,8 @@ export class CdpAutomation implements CDPClient {
     // Chrome sends `Network.requestWillBeSent` events with data urls which won't actually be fetched
     // Example data url: "data:font/woff;base64,<base64 encoded string>"
     if (url.startsWith('data:')) {
-      debugVerbose('skipping `data:` url %s', url)
+      debugVerbose('skipping data: url %s', url)
+      this.cachedDataUrlRequestIds.add(params.requestId)
 
       return
     }
@@ -291,7 +293,18 @@ export class CdpAutomation implements CDPClient {
   }
 
   private onRequestServedFromCache = (params: Protocol.Network.RequestServedFromCacheEvent) => {
-    this.automation.onRequestServedFromCache?.(params.requestId)
+    debugVerbose('received onRequestServedFromCache %o', params)
+
+    // Filter out "data:" urls; they don't have a stored browserPreRequest
+    // since they're not actually fetched
+    if (this.cachedDataUrlRequestIds.has(params.requestId)) {
+      this.cachedDataUrlRequestIds.delete(params.requestId)
+      debugVerbose('skipping data: request %s', params.requestId)
+
+      return
+    }
+
+    this.automation.onRemoveBrowserPreRequest?.(params.requestId)
   }
 
   private onRequestFailed = (params: Protocol.Network.LoadingFailedEvent) => {
@@ -300,7 +313,7 @@ export class CdpAutomation implements CDPClient {
 
   private onResponseReceived = (params: Protocol.Network.ResponseReceivedEvent) => {
     if (params.response.fromDiskCache || (params.response.fromServiceWorker && params.response.encodedDataLength <= 0)) {
-      this.automation.onRequestServedFromCache?.(params.requestId)
+      this.automation.onRemoveBrowserPreRequest?.(params.requestId)
 
       return
     }
diff --git a/packages/server/lib/project-base.ts b/packages/server/lib/project-base.ts
index 891de58472cf..7973019329b2 100644
--- a/packages/server/lib/project-base.ts
+++ b/packages/server/lib/project-base.ts
@@ -333,7 +333,7 @@ export class ProjectBase extends EE {
       this.server.emitRequestEvent(eventName, data)
     }
 
-    const onRequestServedFromCache = (requestId: string) => {
+    const onRemoveBrowserPreRequest = (requestId: string) => {
       this.server.removeBrowserPreRequest(requestId)
     }
 
@@ -367,7 +367,7 @@ export class ProjectBase extends EE {
       screenshotsFolder,
       onBrowserPreRequest,
       onRequestEvent,
-      onRequestServedFromCache,
+      onRemoveBrowserPreRequest,
       onRequestFailed,
       onDownloadLinkClicked,
       onServiceWorkerRegistrationUpdated,
diff --git a/packages/server/test/unit/browsers/cdp_automation_spec.ts b/packages/server/test/unit/browsers/cdp_automation_spec.ts
index 975321ee214b..97352bc035d7 100644
--- a/packages/server/test/unit/browsers/cdp_automation_spec.ts
+++ b/packages/server/test/unit/browsers/cdp_automation_spec.ts
@@ -72,7 +72,7 @@ context('lib/browsers/cdp_automation', () => {
       this.automation = {
         onBrowserPreRequest: sinon.stub(),
         onRequestEvent: sinon.stub(),
-        onRequestServedFromCache: sinon.stub(),
+        onRemoveBrowserPreRequest: sinon.stub(),
         onRequestFailed: sinon.stub(),
         onServiceWorkerRegistrationUpdated: sinon.stub(),
         onServiceWorkerVersionUpdated: sinon.stub(),
@@ -262,7 +262,7 @@ context('lib/browsers/cdp_automation', () => {
         .withArgs('Network.requestServedFromCache')
         .yield(browserRequestServedFromCache)
 
-        expect(this.automation.onRequestServedFromCache).to.have.been.calledWith(browserRequestServedFromCache.requestId)
+        expect(this.automation.onRemoveBrowserPreRequest).to.have.been.calledWith(browserRequestServedFromCache.requestId)
       })
     })
 
diff --git a/system-tests/test/service_worker_protocol_spec.js b/system-tests/test/service_worker_protocol_spec.js
index 4c3aaebb1ff0..4fa8948cd756 100644
--- a/system-tests/test/service_worker_protocol_spec.js
+++ b/system-tests/test/service_worker_protocol_spec.js
@@ -46,7 +46,8 @@ describe('capture-protocol', () => {
           expect(parsedProtocolEvents.multipleNetworkRequestEventsForSameRequestId).to.be.false
           expect(parsedProtocolEvents.correlatedUrls).to.eql({
             'http://localhost:3131/index.html': ['frame id'],
-            'http://localhost:2121/cypress/fixtures/service-worker-assets/example.json': ['frame id'],
+            // Only correlations occur in the service worker for this asset
+            'http://localhost:2121/cypress/fixtures/service-worker-assets/example.json': ['no frame id'],
             // Only correlations occur in the service worker for this asset
             'http://localhost:2121/cypress/fixtures/service-worker-assets/scope/cached-service-worker.json': ['no frame id'],
             'http://localhost:2121/cypress/fixtures/service-worker-assets/scope/load.js': ['frame id'],

From fa06db9882fd33d33c919a5ffd08abf2acb29a7f Mon Sep 17 00:00:00 2001
From: Matthew Schile <mschile@cypress.io>
Date: Fri, 12 Apr 2024 15:04:50 -0600
Subject: [PATCH 12/31] updates

---
 packages/server/lib/automation/automation.ts | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/packages/server/lib/automation/automation.ts b/packages/server/lib/automation/automation.ts
index e047ad195e8e..bfa1857bba77 100644
--- a/packages/server/lib/automation/automation.ts
+++ b/packages/server/lib/automation/automation.ts
@@ -15,7 +15,7 @@ export type AutomationOptions = {
   screenshotsFolder?: string | false
   onBrowserPreRequest?: OnBrowserPreRequest
   onRequestEvent?: OnRequestEvent
-  onRequestServedFromCache?: (requestId: string) => void
+  onRemoveBrowserPreRequest?: (requestId: string) => void
   onRequestFailed?: (requestId: string) => void
   onDownloadLinkClicked?: (downloadUrl: string) => void
   onServiceWorkerRegistrationUpdated?: OnServiceWorkerRegistrationUpdated
@@ -31,7 +31,7 @@ export class Automation {
   private screenshot: { capture: (data: any, automate: any) => any }
   public onBrowserPreRequest: OnBrowserPreRequest | undefined
   public onRequestEvent: OnRequestEvent | undefined
-  public onRequestServedFromCache: ((requestId: string) => void) | undefined
+  public onRemoveBrowserPreRequest: ((requestId: string) => void) | undefined
   public onRequestFailed: ((requestId: string) => void) | undefined
   public onDownloadLinkClicked: ((downloadUrl: string) => void) | undefined
   public onServiceWorkerRegistrationUpdated: OnServiceWorkerRegistrationUpdated | undefined
@@ -42,7 +42,7 @@ export class Automation {
   constructor (options: AutomationOptions) {
     this.onBrowserPreRequest = options.onBrowserPreRequest
     this.onRequestEvent = options.onRequestEvent
-    this.onRequestServedFromCache = options.onRequestServedFromCache
+    this.onRemoveBrowserPreRequest = options.onRemoveBrowserPreRequest
     this.onRequestFailed = options.onRequestFailed
     this.onDownloadLinkClicked = options.onDownloadLinkClicked
     this.onServiceWorkerRegistrationUpdated = options.onServiceWorkerRegistrationUpdated

From 446d5ea752383bc68ac73b0a9a8fe87d0428be7d Mon Sep 17 00:00:00 2001
From: Matthew Schile <mschile@cypress.io>
Date: Fri, 12 Apr 2024 15:17:42 -0600
Subject: [PATCH 13/31] updating workflow

---
 .circleci/workflows.yml | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/.circleci/workflows.yml b/.circleci/workflows.yml
index d962bd5b6697..039d299d4797 100644
--- a/.circleci/workflows.yml
+++ b/.circleci/workflows.yml
@@ -446,8 +446,10 @@ commands:
           command: yarn versions
       - unless:
           condition:
-            # stop-only does not correctly match on windows: https://github.com/bahmutov/stop-only/issues/78
-            equal: [ *windows-executor, << parameters.executor >> ]
+            or:
+              # stop-only does not correctly match on windows: https://github.com/bahmutov/stop-only/issues/78
+              - equal: [ *windows-executor, << parameters.executor >> ]
+              - equal: [ *darwin-arm64-executor, << parameters.executor >> ]
           steps:
             - run:
                 name: Stop .only

From 49b6a7d0bf748ca5ec315f2ac42ad83ee3dcbeb8 Mon Sep 17 00:00:00 2001
From: Matthew Schile <mschile@cypress.io>
Date: Tue, 16 Apr 2024 17:29:41 -0600
Subject: [PATCH 14/31] skip injection for non-chromium browsers

---
 packages/driver/cypress/e2e/issues/1244.cy.js  |  6 +++---
 packages/proxy/lib/http/index.ts               |  6 +++++-
 packages/proxy/lib/http/response-middleware.ts |  3 ++-
 packages/proxy/lib/http/util/prerequests.ts    |  9 ++++++---
 packages/server/lib/project-base.ts            |  1 -
 packages/server/lib/server-base.ts             | 11 +++--------
 6 files changed, 19 insertions(+), 17 deletions(-)

diff --git a/packages/driver/cypress/e2e/issues/1244.cy.js b/packages/driver/cypress/e2e/issues/1244.cy.js
index 88c89fa87774..cee8ac193570 100644
--- a/packages/driver/cypress/e2e/issues/1244.cy.js
+++ b/packages/driver/cypress/e2e/issues/1244.cy.js
@@ -6,16 +6,16 @@ describe('issue 1244', () => {
 
         // not all pages that get unloaded during this spec have getCounters()
         if (win.location.href.includes('issue-1244.html')) {
-          // expect(win.getCounters()).to.deep.equal({ getCounter: 0, setCounter: 0 })
+          expect(win.getCounters()).to.deep.equal({ getCounter: 0, setCounter: 0 })
         }
       })
     })
   })
 
-  for (const [el, target, action] of [['button', 'form', 'submit']]) {
+  for (const [el, target, action] of [['button', 'form', 'submit'], ['a', 'a', 'click']]) {
     // <form> submit, <a> click
     // TODO(webkit): fix+unskip for webkit release, or make skip more specific (only 4 of these generated tests fail in webkit)
-    describe(`<${target}> ${action}`, { browser: '!webkit', retries: 0 }, () => {
+    describe(`<${target}> ${action}`, { browser: '!webkit' }, () => {
       it('correctly redirects when target=_top with target.target =', () => {
         cy.get(`${el}.setTarget`).click()
         cy.get('#dom').should('contain', 'DOM')
diff --git a/packages/proxy/lib/http/index.ts b/packages/proxy/lib/http/index.ts
index 4b3ddcf10713..35478d333e33 100644
--- a/packages/proxy/lib/http/index.ts
+++ b/packages/proxy/lib/http/index.ts
@@ -26,7 +26,7 @@ import type { Request, Response } from 'express'
 import type { RemoteStates } from '@packages/server/lib/remote_states'
 import type { CookieJar, SerializableAutomationCookie } from '@packages/server/lib/util/cookies'
 import type { ResourceTypeAndCredentialManager } from '@packages/server/lib/util/resourceTypeAndCredentialManager'
-import type { ProtocolManagerShape } from '@packages/types'
+import type { FoundBrowser, ProtocolManagerShape } from '@packages/types'
 import type Protocol from 'devtools-protocol'
 import type { ServiceWorkerClientEvent } from './util/service-worker-manager'
 
@@ -101,6 +101,7 @@ export type ServerCtx = Readonly<{
   socket: CyServer.Socket
   request: any
   serverBus: EventEmitter
+  getCurrentBrowser: () => FoundBrowser
 }>
 
 const READONLY_MIDDLEWARE_KEYS: (keyof HttpMiddlewareThis<{}>)[] = [
@@ -272,6 +273,7 @@ export class Http {
   middleware: HttpMiddlewareStacks
   netStubbingState: NetStubbingState
   preRequests: PreRequests = new PreRequests()
+  getCurrentBrowser: () => FoundBrowser
   request: any
   socket: CyServer.Socket
   serverBus: EventEmitter
@@ -296,6 +298,7 @@ export class Http {
     this.serverBus = opts.serverBus
     this.resourceTypeAndCredentialManager = opts.resourceTypeAndCredentialManager
     this.getCookieJar = opts.getCookieJar
+    this.getCurrentBrowser = opts.getCurrentBrowser
 
     if (typeof opts.middleware === 'undefined') {
       this.middleware = defaultMiddleware
@@ -361,6 +364,7 @@ export class Http {
         this.preRequests.removePendingRequest(pendingRequest)
       },
       protocolManager: this.protocolManager,
+      getCurrentBrowser: this.getCurrentBrowser,
     }
 
     const onError = (error: Error): Promise<void> => {
diff --git a/packages/proxy/lib/http/response-middleware.ts b/packages/proxy/lib/http/response-middleware.ts
index 1722c1d8eb56..31a8267a90bb 100644
--- a/packages/proxy/lib/http/response-middleware.ts
+++ b/packages/proxy/lib/http/response-middleware.ts
@@ -839,7 +839,8 @@ const MaybeInjectServiceWorker: ResponseMiddleware = function () {
 
   span?.setAttributes({ hasServiceWorkerHeader: hasHeader })
 
-  if (!hasHeader) {
+  // skip if we don't have the header or we're not in chromium
+  if (!hasHeader || this.getCurrentBrowser().family !== 'chromium') {
     span?.end()
 
     return this.next()
diff --git a/packages/proxy/lib/http/util/prerequests.ts b/packages/proxy/lib/http/util/prerequests.ts
index d9963de86fb8..35f4ba54b8d9 100644
--- a/packages/proxy/lib/http/util/prerequests.ts
+++ b/packages/proxy/lib/http/util/prerequests.ts
@@ -167,7 +167,7 @@ export class PreRequests {
     const key = `${browserPreRequest.method}-${tryDecodeURI(browserPreRequest.url)}`
 
     // if we have a pending request to remove, we should remove it now and return
-    // since we don't want to add this pre-request to the pending list,
+    // since we don't want to proceed with this pre-request anymore. In practice,
     // this typically happens when we receive a cached response while executing
     // the async function to add the pre-request
     if (this.checkAndRemovePendingPreRequest(browserPreRequest.requestId)) {
@@ -212,7 +212,7 @@ export class PreRequests {
       return
     }
 
-    debugVerbose('Caching pre-request %s to be matched later. %o', key, browserPreRequest.requestId)
+    debugVerbose('Caching pre-request %s to be matched later. %o', key, browserPreRequest)
     this.pendingPreRequests.push(key, {
       browserPreRequest,
       cdpRequestWillBeSentTimestamp: browserPreRequest.cdpRequestWillBeSentTimestamp,
@@ -255,6 +255,9 @@ export class PreRequests {
       return !matches
     })
 
+    // if we didn't find a pre-request to remove, add it to the pending list so we can remove it later,
+    // this typically happens when we receive a cached response while executing
+    // the async function to add the pre-request
     if (!removed) {
       debugVerbose('No pre-request found to remove, adding to pending list: %s', requestId)
       this.pendingPreRequestsToRemove.add(requestId)
@@ -274,7 +277,7 @@ export class PreRequests {
 
     if (pendingPreRequest) {
       metrics.immediatelyMatchedRequests++
-      ctxDebug('Incoming request %s matches known pre-request: %o', key, pendingPreRequest.browserPreRequest.requestId)
+      ctxDebug('Incoming request %s matches known pre-request: %o', key, pendingPreRequest.browserPreRequest)
 
       callback({
         browserPreRequest: {
diff --git a/packages/server/lib/project-base.ts b/packages/server/lib/project-base.ts
index 7973019329b2..f57458f6fa18 100644
--- a/packages/server/lib/project-base.ts
+++ b/packages/server/lib/project-base.ts
@@ -156,7 +156,6 @@ export class ProjectBase extends EE {
     const [port, warning] = await this._server.open(cfg, {
       getCurrentBrowser: () => this.browser,
       getSpec: () => this.spec,
-      exit: this.options.args?.exit,
       onError: this.options.onError,
       onWarning: this.options.onWarning,
       shouldCorrelatePreRequests: this.shouldCorrelatePreRequests,
diff --git a/packages/server/lib/server-base.ts b/packages/server/lib/server-base.ts
index 34840ee1961a..01df2eae3696 100644
--- a/packages/server/lib/server-base.ts
+++ b/packages/server/lib/server-base.ts
@@ -133,16 +133,13 @@ export interface OpenServerOptions {
   testingType: Cypress.TestingType
   onError: any
   onWarning: any
-  exit?: boolean
   getCurrentBrowser: () => Browser
   getSpec: () => FoundSpec | null
   shouldCorrelatePreRequests: () => boolean
-  protocolManager?: ProtocolManagerShape
 }
 
 export class ServerBase<TSocket extends SocketE2E | SocketCt> {
   private _middleware
-  private _protocolManager?: ProtocolManagerShape
   protected request: Request
   protected isListening: boolean
   protected socketAllowed: SocketAllowed
@@ -214,8 +211,6 @@ export class ServerBase<TSocket extends SocketE2E | SocketCt> {
   }
 
   setProtocolManager (protocolManager: ProtocolManagerShape | undefined) {
-    this._protocolManager = protocolManager
-
     this._socket?.setProtocolManager(protocolManager)
     this._networkProxy?.setProtocolManager(protocolManager)
   }
@@ -329,8 +324,6 @@ export class ServerBase<TSocket extends SocketE2E | SocketCt> {
     shouldCorrelatePreRequests,
     testingType,
     SocketCtor,
-    exit,
-    protocolManager,
   }: OpenServerOptions) {
     debug('server open')
     this.testingType = testingType
@@ -356,6 +349,7 @@ export class ServerBase<TSocket extends SocketE2E | SocketCt> {
       remoteStates: this._remoteStates,
       resourceTypeAndCredentialManager: this.resourceTypeAndCredentialManager,
       shouldCorrelatePreRequests,
+      getCurrentBrowser,
     })
 
     if (config.experimentalSourceRewriting) {
@@ -443,7 +437,7 @@ export class ServerBase<TSocket extends SocketE2E | SocketCt> {
     return e
   }
 
-  createNetworkProxy ({ config, remoteStates, resourceTypeAndCredentialManager, shouldCorrelatePreRequests }) {
+  createNetworkProxy ({ config, remoteStates, resourceTypeAndCredentialManager, shouldCorrelatePreRequests, getCurrentBrowser }) {
     const getFileServerToken = () => {
       return this._fileServer?.token
     }
@@ -461,6 +455,7 @@ export class ServerBase<TSocket extends SocketE2E | SocketCt> {
       request: this.request,
       serverBus: this._eventBus,
       resourceTypeAndCredentialManager,
+      getCurrentBrowser,
     })
   }
 

From c25d535864d15f75353451ce3614abfe4c1c23f6 Mon Sep 17 00:00:00 2001
From: Matthew Schile <mschile@cypress.io>
Date: Wed, 17 Apr 2024 10:59:53 -0600
Subject: [PATCH 15/31] adding driver test

---
 .../cypress/e2e/e2e/service-worker.cy.js       | 18 ++++++++++++++++++
 .../cypress/fixtures/service-worker.html       | 11 +++++++++--
 2 files changed, 27 insertions(+), 2 deletions(-)

diff --git a/packages/driver/cypress/e2e/e2e/service-worker.cy.js b/packages/driver/cypress/e2e/e2e/service-worker.cy.js
index d4e93d663c93..01af8eeab6a5 100644
--- a/packages/driver/cypress/e2e/e2e/service-worker.cy.js
+++ b/packages/driver/cypress/e2e/e2e/service-worker.cy.js
@@ -666,4 +666,22 @@ describe('service workers', { defaultCommandTimeout: 1000, pageLoadTimeout: 1000
     cy.get('#output').should('have.text', 'done')
     validateFetchHandlers({ listenerCount: 1 })
   })
+
+  it('supports a service worker is that activated but not handling fetch events', () => {
+    const script = () => {
+      self.addEventListener('fetch', function (event) {
+        event.respondWith(fetch(event.request))
+      })
+    }
+
+    cy.intercept('/fixtures/service-worker.js', (req) => {
+      req.reply(`(${script})()`,
+        { 'Content-Type': 'application/javascript' })
+    })
+
+    cy.visit('fixtures/service-worker.html?skipReload')
+
+    cy.get('#output').should('have.text', 'done')
+    validateFetchHandlers({ listenerCount: 1 })
+  })
 })
diff --git a/packages/driver/cypress/fixtures/service-worker.html b/packages/driver/cypress/fixtures/service-worker.html
index 51a208eebcb0..fb86c62a12a6 100644
--- a/packages/driver/cypress/fixtures/service-worker.html
+++ b/packages/driver/cypress/fixtures/service-worker.html
@@ -14,6 +14,7 @@
       const serviceWorker = registration.installing || registration.waiting
       if (serviceWorker) {
         let controllerChangeCalled = false
+        // called when clients.claim() is called in the service worker
         navigator.serviceWorker.addEventListener('controllerchange', (e) => {
           controllerChangeCalled = true
           makeRequest()
@@ -21,8 +22,14 @@
 
         serviceWorker.addEventListener('statechange', (e) => {
           if (e.target.state === 'activated' && !controllerChangeCalled) {
-            // service worker activated, reload page so it can intercept requests
-            location.reload()
+            // service worker activated, either skip reloading the page
+            // so we can test when an activated service worker is not intercepting requests
+            // or reload page so it can intercept requests
+            if (location.search.includes('skipReload')) {
+              makeRequest()
+            } else {
+              location.reload()
+            }
           }
         })
       } else {

From 6bbb1163b8fdda113654ad665abbc776a4bd0e7a Mon Sep 17 00:00:00 2001
From: Matthew Schile <mschile@cypress.io>
Date: Wed, 17 Apr 2024 12:22:37 -0600
Subject: [PATCH 16/31] updating failed tests

---
 .../lib/http/util/service-worker-injector.ts  | 15 ++--------
 .../lib/http/util/service-worker-manager.ts   | 26 +++++++++--------
 .../unit/http/response-middleware.spec.ts     | 28 ++++++++++++++++++-
 .../http/util/service-worker-manager.spec.ts  | 25 +++++++++++++++++
 4 files changed, 70 insertions(+), 24 deletions(-)

diff --git a/packages/proxy/lib/http/util/service-worker-injector.ts b/packages/proxy/lib/http/util/service-worker-injector.ts
index 5751b7faaef2..33b2685034f8 100644
--- a/packages/proxy/lib/http/util/service-worker-injector.ts
+++ b/packages/proxy/lib/http/util/service-worker-injector.ts
@@ -43,7 +43,6 @@ declare let self: ServiceWorkerGlobalScope
 export const injectIntoServiceWorker = (body: Buffer) => {
   function __cypressInjectIntoServiceWorker () {
     let listenerCount = 0
-    let isHandlingRequestsSent = false
     const nonCaptureListenersMap = new WeakMap<EventListenerOrEventListenerObject, EventListenerOrEventListenerObject>()
     const captureListenersMap = new WeakMap<EventListenerOrEventListenerObject, EventListenerOrEventListenerObject>()
     const targetToWrappedHandleEventMap = new WeakMap<Object, EventListenerOrEventListenerObject>()
@@ -68,9 +67,9 @@ export const injectIntoServiceWorker = (body: Buffer) => {
       sendEvent({ type: 'fetchRequest', payload })
     }
 
-    const sendStartHandlingRequests = async (payload: { clientUrls: string[] } | void) => {
+    const sendClientsClaimed = async (payload: { clientUrls: string[] }) => {
       // call the CDP binding to inform the backend that the service worker is now handling requests
-      sendEvent({ type: 'startHandlingRequests', payload })
+      sendEvent({ type: 'clientsClaimed', payload })
     }
 
     // A listener is considered valid if it is a function or an object (with the handleEvent function or the function could be added later)
@@ -90,13 +89,6 @@ export const injectIntoServiceWorker = (body: Buffer) => {
 
     function wrapListener (listener: FetchListener): FetchListener {
       return (event) => {
-        // if this is the first time the listener is called,
-        // we need to inform the backend that the service worker is now handling requests
-        if (!isHandlingRequestsSent) {
-          sendStartHandlingRequests()
-          isHandlingRequestsSent = true
-        }
-
         // we want to override the respondWith method so we can track if it was called
         // to determine if the service worker handled the request
         const oldRespondWith = event.respondWith
@@ -265,8 +257,7 @@ export const injectIntoServiceWorker = (body: Buffer) => {
       const clients = await self.clients.matchAll()
       const clientUrls = clients.map((client) => client.url)
 
-      sendStartHandlingRequests({ clientUrls })
-      isHandlingRequestsSent = true
+      sendClientsClaimed({ clientUrls })
     }
 
     // During the install phase, we need to wait for the binding to be created
diff --git a/packages/proxy/lib/http/util/service-worker-manager.ts b/packages/proxy/lib/http/util/service-worker-manager.ts
index cdeef1de794f..878ce5c69201 100644
--- a/packages/proxy/lib/http/util/service-worker-manager.ts
+++ b/packages/proxy/lib/http/util/service-worker-manager.ts
@@ -44,7 +44,7 @@ export const serviceWorkerClientEventHandlerName = '__cypressServiceWorkerClient
 export declare type ServiceWorkerEventsPayload = {
   'fetchRequest': { url: string, isControlled: boolean }
   'hasFetchHandler': { hasFetchHandler: boolean }
-  'startHandlingRequests': { clientUrls: string[] } | void
+  'clientsClaimed': { clientUrls: string[] }
 }
 
 type _ServiceWorkerClientEvent<T extends keyof ServiceWorkerEventsPayload> = { type: T, scope: string, payload: ServiceWorkerEventsPayload[T] }
@@ -152,8 +152,8 @@ export class ServiceWorkerManager {
       case 'hasFetchHandler':
         this.handleHasServiceWorkerFetchHandlersEvent(event.payload as ServiceWorkerEventsPayload['hasFetchHandler'], event.scope)
         break
-      case 'startHandlingRequests':
-        this.handleStartHandlingRequestsEvent(event.payload as ServiceWorkerEventsPayload['startHandlingRequests'], event.scope)
+      case 'clientsClaimed':
+        this.handleClientsClaimedEvent(event.payload as ServiceWorkerEventsPayload['clientsClaimed'], event.scope)
         break
       default:
         debug('Unknown event type: %o', event)
@@ -266,6 +266,7 @@ export class ServiceWorkerManager {
   /**
    * Handles a service worker has fetch handlers event.
    * @param event the service worker has fetch handlers event to handle
+   * @param scope the scope of the service worker registration
    */
   private handleHasServiceWorkerFetchHandlersEvent (event: ServiceWorkerEventsPayload['hasFetchHandler'], scope: string) {
     const registration = this.getRegistrationForScope(scope)
@@ -315,21 +316,24 @@ export class ServiceWorkerManager {
     }
   }
 
-  private handleStartHandlingRequestsEvent (event: ServiceWorkerEventsPayload['startHandlingRequests'], scope: string) {
+  /**
+   * Handles a clients claimed event.
+   * @param event the clients claimed event to handle
+   * @param scope the scope of the service worker registration
+   */
+  private handleClientsClaimedEvent (event: ServiceWorkerEventsPayload['clientsClaimed'], scope: string) {
     const registration = this.getRegistrationForScope(scope)
 
     if (registration) {
       registration.isHandlingRequests = true
 
-      if (event?.clientUrls) {
-        if (registration.activatedServiceWorker) {
-          event.clientUrls.forEach((url) => registration.activatedServiceWorker!.controlledURLs.add(url))
-        } else {
-          this.pendingControlledUrls.set(registration.scopeURL, event.clientUrls)
-        }
+      if (registration.activatedServiceWorker) {
+        event.clientUrls.forEach((url) => registration.activatedServiceWorker?.controlledURLs.add(url))
+      } else {
+        this.pendingControlledUrls.set(registration.scopeURL, event.clientUrls)
       }
 
-      debug('service worker is handling fetch requests: %o', registration)
+      debug('clients claimed on service worker registration: %o', registration)
     } else {
       debug('could not find service worker registration for scope: %s', scope)
     }
diff --git a/packages/proxy/test/unit/http/response-middleware.spec.ts b/packages/proxy/test/unit/http/response-middleware.spec.ts
index cb98c06db7f8..5be33f569d6b 100644
--- a/packages/proxy/test/unit/http/response-middleware.spec.ts
+++ b/packages/proxy/test/unit/http/response-middleware.spec.ts
@@ -2308,7 +2308,7 @@ describe('http/response-middleware', function () {
       injectIntoServiceWorkerStub.restore()
     })
 
-    it('does not rewrite service worker if the request does not have the service worker header', function () {
+    it('does not rewrite the service worker if the request does not have the service worker header', function () {
       prepareContext({
         req: {
           proxiedUrl: 'http://www.foobar.com:3501/not-service-worker.js',
@@ -2321,6 +2321,27 @@ describe('http/response-middleware', function () {
       })
     })
 
+    it('does not rewrite the service worker if the browser is non-chromium', function () {
+      prepareContext({
+        req: {
+          proxiedUrl: 'http://www.foobar.com:3501/service-worker.js',
+          headers: {
+            'service-worker': 'script',
+          },
+        },
+        getCurrentBrowser: () => {
+          return {
+            family: 'firefox',
+          }
+        },
+      })
+
+      return testMiddleware([MaybeInjectServiceWorker], ctx)
+      .then(() => {
+        expect(injectIntoServiceWorkerStub).not.to.be.called
+      })
+    })
+
     it('rewrites the service worker', async function () {
       prepareContext({
         req: {
@@ -2368,6 +2389,11 @@ describe('http/response-middleware', function () {
         onError (error) {
           throw error
         },
+        getCurrentBrowser: () => {
+          return {
+            family: 'chromium',
+          }
+        },
         ..._.omit(props, 'incomingRes', 'res', 'req'),
       }
     }
diff --git a/packages/proxy/test/unit/http/util/service-worker-manager.spec.ts b/packages/proxy/test/unit/http/util/service-worker-manager.spec.ts
index 9103141020f5..767e254a2728 100644
--- a/packages/proxy/test/unit/http/util/service-worker-manager.spec.ts
+++ b/packages/proxy/test/unit/http/util/service-worker-manager.spec.ts
@@ -86,6 +86,15 @@ describe('lib/http/util/service-worker-manager', () => {
           payload: {
             hasFetchHandler: true,
           },
+          scope: 'http://localhost:8080',
+        })
+
+        manager.handleServiceWorkerClientEvent({
+          type: 'clientsClaimed',
+          payload: {
+            clientUrls: ['http://localhost:8080/index.html'],
+          },
+          scope: 'http://localhost:8080',
         })
       })
 
@@ -101,6 +110,7 @@ describe('lib/http/util/service-worker-manager', () => {
             url: 'http://localhost:8080/foo.js',
             isControlled: true,
           },
+          scope: 'http://localhost:8080',
         })
 
         expect(await result).to.be.true
@@ -117,6 +127,7 @@ describe('lib/http/util/service-worker-manager', () => {
             url: 'http://example.com/bar.css',
             isControlled: true,
           },
+          scope: 'http://localhost:8080',
         })
 
         expect(await result).to.be.true
@@ -133,6 +144,7 @@ describe('lib/http/util/service-worker-manager', () => {
             url: 'http://example.com/baz.woff2',
             isControlled: true,
           },
+          scope: 'http://localhost:8080',
         })
 
         expect(await result).to.be.true
@@ -172,6 +184,7 @@ describe('lib/http/util/service-worker-manager', () => {
             url: 'http://localhost:8080/foo.js',
             isControlled: false,
           },
+          scope: 'http://localhost:8080',
         })
 
         expect(await result).to.be.false
@@ -183,6 +196,7 @@ describe('lib/http/util/service-worker-manager', () => {
             url: 'http://localhost:8080/foo.js',
             isControlled: false,
           },
+          scope: 'http://localhost:8080',
         })
 
         expect(await manager.processBrowserPreRequest(createBrowserPreRequest({
@@ -281,6 +295,7 @@ describe('lib/http/util/service-worker-manager', () => {
             url: 'http://localhost:8080/foo.js',
             isControlled: true,
           },
+          scope: 'http://localhost:8080',
         })
 
         expect(await result).to.be.true
@@ -298,6 +313,7 @@ describe('lib/http/util/service-worker-manager', () => {
             url: 'http://example.com/bar.css',
             isControlled: true,
           },
+          scope: 'http://localhost:8080',
         })
 
         expect(await result).to.be.true
@@ -315,6 +331,7 @@ describe('lib/http/util/service-worker-manager', () => {
             url: 'http://example.com/baz.woff2',
             isControlled: true,
           },
+          scope: 'http://localhost:8080',
         })
 
         expect(await result).to.be.true
@@ -360,6 +377,7 @@ describe('lib/http/util/service-worker-manager', () => {
             url: 'http://localhost:8080/foo.js',
             isControlled: true,
           },
+          scope: 'http://localhost:8080',
         })
 
         expect(await result).to.be.true
@@ -384,6 +402,7 @@ describe('lib/http/util/service-worker-manager', () => {
             url: 'http://example.com/bar.css',
             isControlled: true,
           },
+          scope: 'http://localhost:8080',
         })
 
         expect(await result).to.be.true
@@ -401,6 +420,7 @@ describe('lib/http/util/service-worker-manager', () => {
             url: 'http://localhost:8080/foo.js',
             isControlled: true,
           },
+          scope: 'http://localhost:8080',
         })
 
         expect(await result).to.be.true
@@ -427,6 +447,7 @@ describe('lib/http/util/service-worker-manager', () => {
             url: 'http://localhost:8080/foo.js',
             isControlled: true,
           },
+          scope: 'http://localhost:8080',
         })
 
         manager.handleServiceWorkerClientEvent({
@@ -435,6 +456,7 @@ describe('lib/http/util/service-worker-manager', () => {
             url: 'http://localhost:8080/bar.js',
             isControlled: false,
           },
+          scope: 'http://localhost:8080',
         })
 
         expect(await manager.processBrowserPreRequest(createBrowserPreRequest({
@@ -461,6 +483,7 @@ describe('lib/http/util/service-worker-manager', () => {
             url: 'http://localhost:8080/foo.js',
             isControlled: true,
           },
+          scope: 'http://localhost:8080',
         })
 
         manager.handleServiceWorkerClientEvent({
@@ -469,6 +492,7 @@ describe('lib/http/util/service-worker-manager', () => {
             url: 'http://localhost:8080/bar.js',
             isControlled: false,
           },
+          scope: 'http://localhost:8080',
         })
 
         expect(await request1).to.be.true
@@ -481,6 +505,7 @@ describe('lib/http/util/service-worker-manager', () => {
           payload: {
             hasFetchHandler: false,
           },
+          scope: 'http://localhost:8080',
         })
 
         expect(await manager.processBrowserPreRequest(createBrowserPreRequest({

From c47a777515fe9e4e51e5c838ac47e0e07d4fd75e Mon Sep 17 00:00:00 2001
From: Matthew Schile <mschile@cypress.io>
Date: Wed, 17 Apr 2024 18:58:39 -0600
Subject: [PATCH 17/31] unit test updates

---
 packages/proxy/lib/http/util/prerequests.ts   |    4 +-
 .../lib/http/util/service-worker-manager.ts   |   15 +-
 packages/proxy/test/unit/http/index.spec.ts   |    1 +
 .../test/unit/http/util/prerequests.spec.ts   |   17 +-
 .../http/util/service-worker-manager.spec.ts  | 1023 ++++++++++-------
 .../test/unit/browsers/cdp_automation_spec.ts |   23 +-
 6 files changed, 678 insertions(+), 405 deletions(-)

diff --git a/packages/proxy/lib/http/util/prerequests.ts b/packages/proxy/lib/http/util/prerequests.ts
index 35f4ba54b8d9..71e75e8bd4ab 100644
--- a/packages/proxy/lib/http/util/prerequests.ts
+++ b/packages/proxy/lib/http/util/prerequests.ts
@@ -116,9 +116,9 @@ export class PreRequests {
   pendingPreRequests = new QueueMap<PendingPreRequest>()
   pendingRequests = new QueueMap<PendingRequest>()
   pendingUrlsWithoutPreRequests = new QueueMap<PendingUrlWithoutPreRequest>()
+  pendingPreRequestsToRemove: Set<string> = new Set()
   sweepIntervalTimer: NodeJS.Timeout
   protocolManager?: ProtocolManagerShape
-  pendingPreRequestsToRemove: Set<string> = new Set()
 
   constructor (
     requestTimeout = 2000,
@@ -277,7 +277,7 @@ export class PreRequests {
 
     if (pendingPreRequest) {
       metrics.immediatelyMatchedRequests++
-      ctxDebug('Incoming request %s matches known pre-request: %o', key, pendingPreRequest.browserPreRequest)
+      ctxDebug('Incoming request %s matches known pre-request: %o', key, pendingPreRequest)
 
       callback({
         browserPreRequest: {
diff --git a/packages/proxy/lib/http/util/service-worker-manager.ts b/packages/proxy/lib/http/util/service-worker-manager.ts
index 878ce5c69201..4d91c5229415 100644
--- a/packages/proxy/lib/http/util/service-worker-manager.ts
+++ b/packages/proxy/lib/http/util/service-worker-manager.ts
@@ -177,6 +177,12 @@ export class ServiceWorkerManager {
     }) ?? false
   }
 
+  private shouldControlDocumentRequest (registration: ServiceWorkerRegistration, browserPreRequest: BrowserPreRequest) {
+    return browserPreRequest.originalResourceType === 'Document' &&
+      browserPreRequest.documentURL === browserPreRequest.url &&
+      browserPreRequest.url.startsWith(registration.scopeURL)
+  }
+
   /**
    * Processes a browser pre-request to determine if it is controlled by a service worker.
    * If it is, the service worker's controlled URLs are updated with the given request URL.
@@ -202,18 +208,13 @@ export class ServiceWorkerManager {
       // if the service worker is active and the request is for the document URL,
       // we can assume that the service worker is controlling the document
       // and update the registration to reflect that
-      if (!registration.isHandlingRequests &&
-        activatedServiceWorker?.initiatorOrigin &&
-        browserPreRequest.originalResourceType === 'Document' &&
-        browserPreRequest.documentURL === browserPreRequest.url &&
-        browserPreRequest.url.startsWith(registration.scopeURL) &&
-        browserPreRequest.documentURL.startsWith(activatedServiceWorker.initiatorOrigin)) {
+      if (!registration.isHandlingRequests && this.shouldControlDocumentRequest(registration, browserPreRequest)) {
         registration.isHandlingRequests = true
         debug('received request for the document of an activated service worker, updating registration to handle requests: %o', { registration, browserPreRequest })
       }
 
       // We are determining here if a request is controlled by a service worker. A request is controlled by a service worker if
-      // we have an activated service worker, the request URL does not come from the service worker, and the request
+      // we have an activated service worker that is handling request, the request URL does not come from the service worker, and the request
       // originates from the same origin as the service worker or from a script that is also controlled by the service worker.
       if (!activatedServiceWorker ||
         !registration.hasFetchHandler ||
diff --git a/packages/proxy/test/unit/http/index.spec.ts b/packages/proxy/test/unit/http/index.spec.ts
index 7af1adf38f64..9a9df0338f72 100644
--- a/packages/proxy/test/unit/http/index.spec.ts
+++ b/packages/proxy/test/unit/http/index.spec.ts
@@ -457,6 +457,7 @@ describe('http', function () {
           url: 'foo',
           isControlled: true,
         },
+        scope: 'foo',
       }
 
       http.handleServiceWorkerClientEvent(event)
diff --git a/packages/proxy/test/unit/http/util/prerequests.spec.ts b/packages/proxy/test/unit/http/util/prerequests.spec.ts
index 892feb32695f..7ac0fd195ff8 100644
--- a/packages/proxy/test/unit/http/util/prerequests.spec.ts
+++ b/packages/proxy/test/unit/http/util/prerequests.spec.ts
@@ -9,10 +9,11 @@ describe('http/util/prerequests', () => {
   let preRequests: PreRequests
   let protocolManager: ProtocolManagerShape
 
-  function expectPendingCounts (pendingRequests: number, pendingPreRequests: number, pendingWithoutPreRequests = 0) {
+  function expectPendingCounts (pendingRequests: number, pendingPreRequests: number, pendingWithoutPreRequests = 0, pendingPreRequestsToRemove = 0) {
     expect(preRequests.pendingRequests.length).to.eq(pendingRequests, 'wrong number of pending requests')
     expect(preRequests.pendingPreRequests.length).to.eq(pendingPreRequests, 'wrong number of pending prerequests')
     expect(preRequests.pendingUrlsWithoutPreRequests.length).to.eq(pendingWithoutPreRequests, 'wrong number of pending without prerequests')
+    expect(preRequests.pendingPreRequestsToRemove.size).to.eq(pendingPreRequestsToRemove, 'wrong number of pending prerequests to remove')
   }
 
   beforeEach(() => {
@@ -231,6 +232,20 @@ describe('http/util/prerequests', () => {
     expectPendingCounts(0, 2)
   })
 
+  it('adds to pending pre-requests to remove if the pre-request is not found', () => {
+    expectPendingCounts(0, 0)
+
+    // remove a pre-request that doesn't exist yet
+    preRequests.removePendingPreRequest('1235')
+
+    expectPendingCounts(0, 0, 0, 1)
+
+    // add a pre-request that matches the pending removal
+    preRequests.addPending({ requestId: '1235', url: 'foo', method: 'GET' } as BrowserPreRequest)
+
+    expectPendingCounts(0, 0)
+  })
+
   it('removes a pending request', () => {
     const cb = sinon.stub()
 
diff --git a/packages/proxy/test/unit/http/util/service-worker-manager.spec.ts b/packages/proxy/test/unit/http/util/service-worker-manager.spec.ts
index 767e254a2728..bf7ee73501f5 100644
--- a/packages/proxy/test/unit/http/util/service-worker-manager.spec.ts
+++ b/packages/proxy/test/unit/http/util/service-worker-manager.spec.ts
@@ -3,8 +3,8 @@ import sinon from 'sinon'
 import { ServiceWorkerManager, serviceWorkerClientEventHandler } from '../../../../lib/http/util/service-worker-manager'
 
 const createBrowserPreRequest = (
-  { url, initiatorUrl, callFrameUrl, documentUrl, isPreload }:
-  { url: string, initiatorUrl?: string, documentUrl?: string, callFrameUrl?: string, isPreload?: boolean },
+  { url, initiatorUrl, callFrameUrl, documentUrl, isPreload, originalResourceType }:
+  { url: string, initiatorUrl?: string, documentUrl?: string, callFrameUrl?: string, isPreload?: boolean, originalResourceType?: string },
 ) => {
   return {
     requestId: 'id-1',
@@ -12,7 +12,7 @@ const createBrowserPreRequest = (
     url,
     headers: {},
     resourceType: 'fetch' as const,
-    originalResourceType: undefined,
+    originalResourceType: originalResourceType || 'Fetch' as const,
     ...(isPreload
       ? {
         initiator: {
@@ -52,465 +52,702 @@ const createBrowserPreRequest = (
 
 describe('lib/http/util/service-worker-manager', () => {
   describe('ServiceWorkerManager', () => {
-    context('processBrowserPreRequest', () => {
-      let manager: ServiceWorkerManager
-
-      beforeEach(() => {
-        manager = new ServiceWorkerManager()
+    let manager: ServiceWorkerManager
 
-        manager.updateServiceWorkerRegistrations({
-          registrations: [{
-            registrationId: '1',
-            scopeURL: 'http://localhost:8080',
-            isDeleted: false,
-          }],
-        })
+    beforeEach(() => {
+      manager = new ServiceWorkerManager()
 
-        manager.updateServiceWorkerVersions({
-          versions: [{
-            versionId: '1',
-            runningStatus: 'running',
-            registrationId: '1',
-            scriptURL: 'http://localhost:8080/sw.js',
-            status: 'activated',
-          }],
-        })
+      manager.updateServiceWorkerRegistrations({
+        registrations: [{
+          registrationId: '1',
+          scopeURL: 'http://localhost:8080',
+          isDeleted: false,
+        }],
+      })
 
-        manager.addInitiatorToServiceWorker({
+      manager.updateServiceWorkerVersions({
+        versions: [{
+          versionId: '1',
+          runningStatus: 'running',
+          registrationId: '1',
           scriptURL: 'http://localhost:8080/sw.js',
-          initiatorOrigin: 'http://localhost:8080/',
-        })
+          status: 'activated',
+        }],
+      })
 
-        manager.handleServiceWorkerClientEvent({
-          type: 'hasFetchHandler',
-          payload: {
-            hasFetchHandler: true,
-          },
-          scope: 'http://localhost:8080',
-        })
+      manager.addInitiatorToServiceWorker({
+        scriptURL: 'http://localhost:8080/sw.js',
+        initiatorOrigin: 'http://localhost:8080/',
+      })
 
-        manager.handleServiceWorkerClientEvent({
-          type: 'clientsClaimed',
-          payload: {
-            clientUrls: ['http://localhost:8080/index.html'],
-          },
-          scope: 'http://localhost:8080',
-        })
+      manager.handleServiceWorkerClientEvent({
+        type: 'hasFetchHandler',
+        payload: {
+          hasFetchHandler: true,
+        },
+        scope: 'http://localhost:8080',
       })
+    })
 
-      it('will detect when requests are controlled by a service worker', async () => {
-        // A script request emanated from the service worker's initiator is controlled
-        let result = manager.processBrowserPreRequest(createBrowserPreRequest({
-          url: 'http://localhost:8080/foo.js',
-        }))
+    context('processBrowserPreRequest', () => {
+      context('with clients claimed', () => {
+        beforeEach(() => {
+          manager.handleServiceWorkerClientEvent({
+            type: 'clientsClaimed',
+            payload: {
+              clientUrls: ['http://localhost:8080/index.html'],
+            },
+            scope: 'http://localhost:8080',
+          })
+        })
 
-        manager.handleServiceWorkerClientEvent({
-          type: 'fetchRequest',
-          payload: {
+        it('will detect when requests are controlled by a service worker', async () => {
+          // A script request emanated from the service worker's initiator is controlled
+          let result = manager.processBrowserPreRequest(createBrowserPreRequest({
             url: 'http://localhost:8080/foo.js',
-            isControlled: true,
-          },
-          scope: 'http://localhost:8080',
-        })
+          }))
 
-        expect(await result).to.be.true
+          manager.handleServiceWorkerClientEvent({
+            type: 'fetchRequest',
+            payload: {
+              url: 'http://localhost:8080/foo.js',
+              isControlled: true,
+            },
+            scope: 'http://localhost:8080',
+          })
 
-        // A script request emanated from the previous script request is controlled
-        result = manager.processBrowserPreRequest(createBrowserPreRequest({
-          url: 'http://example.com/bar.css',
-          callFrameUrl: 'http://localhost:8080/foo.js',
-        }))
+          expect(await result).to.be.true
 
-        manager.handleServiceWorkerClientEvent({
-          type: 'fetchRequest',
-          payload: {
+          // A script request emanated from the previous script request is controlled
+          result = manager.processBrowserPreRequest(createBrowserPreRequest({
             url: 'http://example.com/bar.css',
-            isControlled: true,
-          },
-          scope: 'http://localhost:8080',
+            callFrameUrl: 'http://localhost:8080/foo.js',
+          }))
+
+          manager.handleServiceWorkerClientEvent({
+            type: 'fetchRequest',
+            payload: {
+              url: 'http://example.com/bar.css',
+              isControlled: true,
+            },
+            scope: 'http://localhost:8080',
+          })
+
+          expect(await result).to.be.true
+
+          // A script request emanated from the previous css is controlled
+          result = manager.processBrowserPreRequest(createBrowserPreRequest({
+            url: 'http://example.com/baz.woff2',
+            initiatorUrl: 'http://example.com/bar.css',
+          }))
+
+          manager.handleServiceWorkerClientEvent({
+            type: 'fetchRequest',
+            payload: {
+              url: 'http://example.com/baz.woff2',
+              isControlled: true,
+            },
+            scope: 'http://localhost:8080',
+          })
+
+          expect(await result).to.be.true
+
+          // A script request emanated from a different script request is not controlled
+          expect(await manager.processBrowserPreRequest(createBrowserPreRequest({
+            url: 'http://example.com/quux.js',
+            callFrameUrl: 'http://example.com/bar.js',
+          }))).to.be.false
+
+          // A script request emanated from a different css request is not controlled
+          expect(await manager.processBrowserPreRequest(createBrowserPreRequest({
+            url: 'http://example.com/quux.css',
+            initiatorUrl: 'http://example.com/baz.css',
+          }))).to.be.false
+
+          // A script request emanated from a different document is not controlled
+          expect(await manager.processBrowserPreRequest(createBrowserPreRequest({
+            url: 'http://example.com/quux.css',
+            initiatorUrl: 'http://example.com/baz.css',
+          }))).to.be.false
+
+          // A preload request is not controlled
+          expect(await manager.processBrowserPreRequest(createBrowserPreRequest({
+            url: 'http://example.com/quux.css',
+            isPreload: true,
+          }))).to.be.false
+
+          // A request that is not handled by the service worker 'fetch' handler is not controlled (browser pre-request first)
+          result = manager.processBrowserPreRequest(createBrowserPreRequest({
+            url: 'http://localhost:8080/foo.js',
+          }))
+
+          manager.handleServiceWorkerClientEvent({
+            type: 'fetchRequest',
+            payload: {
+              url: 'http://localhost:8080/foo.js',
+              isControlled: false,
+            },
+            scope: 'http://localhost:8080',
+          })
+
+          expect(await result).to.be.false
+
+          // A request that is not handled by the service worker 'fetch' handler is not controlled (fetch event first)
+          manager.handleServiceWorkerClientEvent({
+            type: 'fetchRequest',
+            payload: {
+              url: 'http://localhost:8080/foo.js',
+              isControlled: false,
+            },
+            scope: 'http://localhost:8080',
+          })
+
+          expect(await manager.processBrowserPreRequest(createBrowserPreRequest({
+            url: 'http://localhost:8080/foo.js',
+          }))).to.be.false
         })
 
-        expect(await result).to.be.true
+        it('will not detect requests when not controlled by an active service worker', async () => {
+          // remove the current service worker
+          manager.updateServiceWorkerRegistrations({
+            registrations: [{
+              registrationId: '1',
+              scopeURL: 'http://localhost:8080',
+              isDeleted: true,
+            }],
+          })
+
+          // add a new service worker that is not activated
+          manager.updateServiceWorkerRegistrations({
+            registrations: [{
+              registrationId: '2',
+              scopeURL: 'http://localhost:8080',
+              isDeleted: false,
+            }],
+          })
+
+          // update the service worker to be in a non-activated state
+          manager.updateServiceWorkerVersions({
+            versions: [{
+              versionId: '1',
+              runningStatus: 'running',
+              registrationId: '2',
+              scriptURL: 'http://localhost:8080/sw.js',
+              status: 'activating',
+            }],
+          })
 
-        // A script request emanated from the previous css is controlled
-        result = manager.processBrowserPreRequest(createBrowserPreRequest({
-          url: 'http://example.com/baz.woff2',
-          initiatorUrl: 'http://example.com/bar.css',
-        }))
+          manager.addInitiatorToServiceWorker({
+            scriptURL: 'http://localhost:8080/sw.js',
+            initiatorOrigin: 'http://localhost:8080/',
+          })
 
-        manager.handleServiceWorkerClientEvent({
-          type: 'fetchRequest',
-          payload: {
+          // A script request emanated from the service worker's initiator is not controlled
+          expect(await manager.processBrowserPreRequest(createBrowserPreRequest({
+            url: 'http://localhost:8080/foo.js',
+          }))).to.be.false
+
+          // A script request emanated from the previous script request is not controlled
+          expect(await manager.processBrowserPreRequest(createBrowserPreRequest({
+            url: 'http://example.com/bar.css',
+            callFrameUrl: 'http://localhost:8080/foo.js',
+          }))).to.be.false
+
+          // A script request emanated from the previous css is not controlled
+          expect(await manager.processBrowserPreRequest(createBrowserPreRequest({
             url: 'http://example.com/baz.woff2',
-            isControlled: true,
-          },
-          scope: 'http://localhost:8080',
+            initiatorUrl: 'http://example.com/bar.css',
+          }))).to.be.false
+
+          // A script request emanated from a different script request is not controlled
+          expect(await manager.processBrowserPreRequest(createBrowserPreRequest({
+            url: 'http://example.com/quux.js',
+            callFrameUrl: 'http://example.com/bar.js',
+          }))).to.be.false
+
+          // A script request emanated from a different css request is not controlled
+          expect(await manager.processBrowserPreRequest(createBrowserPreRequest({
+            url: 'http://example.com/quux.css',
+            initiatorUrl: 'http://example.com/baz.css',
+          }))).to.be.false
+
+          // A script request emanated from a different document is not controlled
+          expect(await manager.processBrowserPreRequest(createBrowserPreRequest({
+            url: 'http://example.com/quux.css',
+            initiatorUrl: 'http://example.com/baz.css',
+            documentUrl: 'http://example.com/index.html',
+          }))).to.be.false
+
+          // A preload request is not controlled
+          expect(await manager.processBrowserPreRequest(createBrowserPreRequest({
+            url: 'http://example.com/quux.css',
+            isPreload: true,
+          }))).to.be.false
         })
 
-        expect(await result).to.be.true
-
-        // A script request emanated from a different script request is not controlled
-        expect(await manager.processBrowserPreRequest(createBrowserPreRequest({
-          url: 'http://example.com/quux.js',
-          callFrameUrl: 'http://example.com/bar.js',
-        }))).to.be.false
-
-        // A script request emanated from a different css request is not controlled
-        expect(await manager.processBrowserPreRequest(createBrowserPreRequest({
-          url: 'http://example.com/quux.css',
-          initiatorUrl: 'http://example.com/baz.css',
-        }))).to.be.false
-
-        // A script request emanated from a different document is not controlled
-        expect(await manager.processBrowserPreRequest(createBrowserPreRequest({
-          url: 'http://example.com/quux.css',
-          initiatorUrl: 'http://example.com/baz.css',
-        }))).to.be.false
-
-        // A preload request is not controlled
-        expect(await manager.processBrowserPreRequest(createBrowserPreRequest({
-          url: 'http://example.com/quux.css',
-          isPreload: true,
-        }))).to.be.false
-
-        // A request that is not handled by the service worker 'fetch' handler is not controlled (browser pre-request first)
-        result = manager.processBrowserPreRequest(createBrowserPreRequest({
-          url: 'http://localhost:8080/foo.js',
-        }))
-
-        manager.handleServiceWorkerClientEvent({
-          type: 'fetchRequest',
-          payload: {
+        it('will detect when requests are controlled by a service worker and handles query parameters', async () => {
+        // A script request emanated from the service worker's initiator is controlled
+          let result = manager.processBrowserPreRequest(createBrowserPreRequest({
             url: 'http://localhost:8080/foo.js',
-            isControlled: false,
-          },
-          scope: 'http://localhost:8080',
+            documentUrl: 'http://localhost:8080/index.html?foo=bar',
+          }))
+
+          manager.handleServiceWorkerClientEvent({
+            type: 'fetchRequest',
+            payload: {
+              url: 'http://localhost:8080/foo.js',
+              isControlled: true,
+            },
+            scope: 'http://localhost:8080',
+          })
+
+          expect(await result).to.be.true
+
+          // A script request emanated from the previous script request is controlled
+          result = manager.processBrowserPreRequest(createBrowserPreRequest({
+            url: 'http://example.com/bar.css',
+            callFrameUrl: 'http://localhost:8080/foo.js?foo=bar',
+            documentUrl: 'http://localhost:8080/index.html?foo=bar',
+          }))
+
+          manager.handleServiceWorkerClientEvent({
+            type: 'fetchRequest',
+            payload: {
+              url: 'http://example.com/bar.css',
+              isControlled: true,
+            },
+            scope: 'http://localhost:8080',
+          })
+
+          expect(await result).to.be.true
+
+          // A script request emanated from the previous css is controlled
+          result = manager.processBrowserPreRequest(createBrowserPreRequest({
+            url: 'http://example.com/baz.woff2',
+            initiatorUrl: 'http://example.com/bar.css?foo=bar',
+            documentUrl: 'http://localhost:8080/index.html?foo=bar',
+          }))
+
+          manager.handleServiceWorkerClientEvent({
+            type: 'fetchRequest',
+            payload: {
+              url: 'http://example.com/baz.woff2',
+              isControlled: true,
+            },
+            scope: 'http://localhost:8080',
+          })
+
+          expect(await result).to.be.true
+
+          // A script request emanated from a different script request is not controlled
+          expect(await manager.processBrowserPreRequest(createBrowserPreRequest({
+            url: 'http://example.com/quux.js',
+            callFrameUrl: 'http://example.com/bar.js?foo=bar',
+            documentUrl: 'http://localhost:8080/index.html?foo=bar',
+          }))).to.be.false
+
+          // A script request emanated from a different css request is not controlled
+          expect(await manager.processBrowserPreRequest(createBrowserPreRequest({
+            url: 'http://example.com/quux.css',
+            initiatorUrl: 'http://example.com/baz.css?foo=bar',
+            documentUrl: 'http://localhost:8080/index.html?foo=bar',
+          }))).to.be.false
+
+          // A script request emanated from a different document is not controlled
+          expect(await manager.processBrowserPreRequest(createBrowserPreRequest({
+            url: 'http://example.com/quux.css',
+            initiatorUrl: 'http://example.com/baz.css?foo=bar',
+            documentUrl: 'http://localhost:8080/index.html?foo=bar',
+          }))).to.be.false
+
+          // A preload request is not controlled
+          expect(await manager.processBrowserPreRequest(createBrowserPreRequest({
+            url: 'http://example.com/quux.css',
+            isPreload: true,
+            documentUrl: 'http://localhost:8080/index.html?foo=bar',
+          }))).to.be.false
         })
 
-        expect(await result).to.be.false
-
-        // A request that is not handled by the service worker 'fetch' handler is not controlled (fetch event first)
-        manager.handleServiceWorkerClientEvent({
-          type: 'fetchRequest',
-          payload: {
+        it('will detect when requests are controlled by a service worker and handles re-registrations', async () => {
+        // A script request emanated from the service worker's initiator is controlled
+          let result = manager.processBrowserPreRequest(createBrowserPreRequest({
             url: 'http://localhost:8080/foo.js',
-            isControlled: false,
-          },
-          scope: 'http://localhost:8080',
+          }))
+
+          manager.handleServiceWorkerClientEvent({
+            type: 'fetchRequest',
+            payload: {
+              url: 'http://localhost:8080/foo.js',
+              isControlled: true,
+            },
+            scope: 'http://localhost:8080',
+          })
+
+          expect(await result).to.be.true
+
+          manager.updateServiceWorkerRegistrations({
+            registrations: [{
+              registrationId: '1',
+              scopeURL: 'http://localhost:8080',
+              isDeleted: false,
+            }],
+          })
+
+          // A script request emanated from the previous script request is controlled
+          result = manager.processBrowserPreRequest(createBrowserPreRequest({
+            url: 'http://example.com/bar.css',
+            callFrameUrl: 'http://localhost:8080/foo.js',
+          }))
+
+          manager.handleServiceWorkerClientEvent({
+            type: 'fetchRequest',
+            payload: {
+              url: 'http://example.com/bar.css',
+              isControlled: true,
+            },
+            scope: 'http://localhost:8080',
+          })
+
+          expect(await result).to.be.true
         })
 
-        expect(await manager.processBrowserPreRequest(createBrowserPreRequest({
-          url: 'http://localhost:8080/foo.js',
-        }))).to.be.false
-      })
+        it('will detect when requests are controlled by a service worker and handles unregistrations', async () => {
+        // A script request emanated from the service worker's initiator is controlled
+          const result = manager.processBrowserPreRequest(createBrowserPreRequest({
+            url: 'http://localhost:8080/foo.js',
+          }))
+
+          manager.handleServiceWorkerClientEvent({
+            type: 'fetchRequest',
+            payload: {
+              url: 'http://localhost:8080/foo.js',
+              isControlled: true,
+            },
+            scope: 'http://localhost:8080',
+          })
+
+          expect(await result).to.be.true
+
+          manager.updateServiceWorkerRegistrations({
+            registrations: [{
+              registrationId: '1',
+              scopeURL: 'http://localhost:8080',
+              isDeleted: true,
+            }],
+          })
 
-      it('will not detect requests when not controlled by an active service worker', async () => {
-        // remove the current service worker
-        manager.updateServiceWorkerRegistrations({
-          registrations: [{
-            registrationId: '1',
-            scopeURL: 'http://localhost:8080',
-            isDeleted: true,
-          }],
+          // A script request emanated from the previous script request is not controlled since the service worker was unregistered
+          expect(await manager.processBrowserPreRequest(createBrowserPreRequest({
+            url: 'http://example.com/bar.css',
+            callFrameUrl: 'http://localhost:8080/foo.js',
+          }))).to.be.false
         })
 
-        // add a new service worker that is not activated
-        manager.updateServiceWorkerRegistrations({
-          registrations: [{
-            registrationId: '2',
-            scopeURL: 'http://localhost:8080',
-            isDeleted: false,
-          }],
-        })
+        it('supports multiple fetch handler calls first', async () => {
+          manager.handleServiceWorkerClientEvent({
+            type: 'fetchRequest',
+            payload: {
+              url: 'http://localhost:8080/foo.js',
+              isControlled: true,
+            },
+            scope: 'http://localhost:8080',
+          })
+
+          manager.handleServiceWorkerClientEvent({
+            type: 'fetchRequest',
+            payload: {
+              url: 'http://localhost:8080/bar.js',
+              isControlled: false,
+            },
+            scope: 'http://localhost:8080',
+          })
+
+          expect(await manager.processBrowserPreRequest(createBrowserPreRequest({
+            url: 'http://localhost:8080/foo.js',
+          }))).to.be.true
 
-        // update the service worker to be in a non-activated state
-        manager.updateServiceWorkerVersions({
-          versions: [{
-            versionId: '1',
-            runningStatus: 'running',
-            registrationId: '2',
-            scriptURL: 'http://localhost:8080/sw.js',
-            status: 'activating',
-          }],
+          expect(await manager.processBrowserPreRequest(createBrowserPreRequest({
+            url: 'http://localhost:8080/bar.js',
+          }))).to.be.false
         })
 
-        manager.addInitiatorToServiceWorker({
-          scriptURL: 'http://localhost:8080/sw.js',
-          initiatorOrigin: 'http://localhost:8080/',
-        })
+        it('supports multiple browser pre-request calls first', async () => {
+          const request1 = manager.processBrowserPreRequest(createBrowserPreRequest({
+            url: 'http://localhost:8080/foo.js',
+          }))
 
-        // A script request emanated from the service worker's initiator is not controlled
-        expect(await manager.processBrowserPreRequest(createBrowserPreRequest({
-          url: 'http://localhost:8080/foo.js',
-        }))).to.be.false
-
-        // A script request emanated from the previous script request is not controlled
-        expect(await manager.processBrowserPreRequest(createBrowserPreRequest({
-          url: 'http://example.com/bar.css',
-          callFrameUrl: 'http://localhost:8080/foo.js',
-        }))).to.be.false
-
-        // A script request emanated from the previous css is not controlled
-        expect(await manager.processBrowserPreRequest(createBrowserPreRequest({
-          url: 'http://example.com/baz.woff2',
-          initiatorUrl: 'http://example.com/bar.css',
-        }))).to.be.false
-
-        // A script request emanated from a different script request is not controlled
-        expect(await manager.processBrowserPreRequest(createBrowserPreRequest({
-          url: 'http://example.com/quux.js',
-          callFrameUrl: 'http://example.com/bar.js',
-        }))).to.be.false
-
-        // A script request emanated from a different css request is not controlled
-        expect(await manager.processBrowserPreRequest(createBrowserPreRequest({
-          url: 'http://example.com/quux.css',
-          initiatorUrl: 'http://example.com/baz.css',
-        }))).to.be.false
-
-        // A script request emanated from a different document is not controlled
-        expect(await manager.processBrowserPreRequest(createBrowserPreRequest({
-          url: 'http://example.com/quux.css',
-          initiatorUrl: 'http://example.com/baz.css',
-          documentUrl: 'http://example.com/index.html',
-        }))).to.be.false
-
-        // A preload request is not controlled
-        expect(await manager.processBrowserPreRequest(createBrowserPreRequest({
-          url: 'http://example.com/quux.css',
-          isPreload: true,
-        }))).to.be.false
-      })
+          const request2 = manager.processBrowserPreRequest(createBrowserPreRequest({
+            url: 'http://localhost:8080/bar.js',
+          }))
+
+          manager.handleServiceWorkerClientEvent({
+            type: 'fetchRequest',
+            payload: {
+              url: 'http://localhost:8080/foo.js',
+              isControlled: true,
+            },
+            scope: 'http://localhost:8080',
+          })
+
+          manager.handleServiceWorkerClientEvent({
+            type: 'fetchRequest',
+            payload: {
+              url: 'http://localhost:8080/bar.js',
+              isControlled: false,
+            },
+            scope: 'http://localhost:8080',
+          })
+
+          expect(await request1).to.be.true
+          expect(await request2).to.be.false
+        })
 
-      it('will detect when requests are controlled by a service worker and handles query parameters', async () => {
-        // A script request emanated from the service worker's initiator is controlled
-        let result = manager.processBrowserPreRequest(createBrowserPreRequest({
-          url: 'http://localhost:8080/foo.js',
-          documentUrl: 'http://localhost:8080/index.html?foo=bar',
-        }))
+        it('supports no client fetch handlers', async () => {
+          manager.handleServiceWorkerClientEvent({
+            type: 'hasFetchHandler',
+            payload: {
+              hasFetchHandler: false,
+            },
+            scope: 'http://localhost:8080',
+          })
 
-        manager.handleServiceWorkerClientEvent({
-          type: 'fetchRequest',
-          payload: {
+          expect(await manager.processBrowserPreRequest(createBrowserPreRequest({
             url: 'http://localhost:8080/foo.js',
-            isControlled: true,
-          },
-          scope: 'http://localhost:8080',
+          }))).to.be.false
         })
 
-        expect(await result).to.be.true
-
-        // A script request emanated from the previous script request is controlled
-        result = manager.processBrowserPreRequest(createBrowserPreRequest({
-          url: 'http://example.com/bar.css',
-          callFrameUrl: 'http://localhost:8080/foo.js?foo=bar',
-          documentUrl: 'http://localhost:8080/index.html?foo=bar',
-        }))
-
-        manager.handleServiceWorkerClientEvent({
-          type: 'fetchRequest',
-          payload: {
-            url: 'http://example.com/bar.css',
-            isControlled: true,
-          },
-          scope: 'http://localhost:8080',
+        it('supports a request with a hash parameter', async () => {
+          let result = manager.processBrowserPreRequest(createBrowserPreRequest({
+            url: 'http://localhost:8080/foo.js',
+          }))
+
+          manager.handleServiceWorkerClientEvent({
+            type: 'fetchRequest',
+            payload: {
+              url: 'http://localhost:8080/foo.js#hash',
+              isControlled: true,
+            },
+            scope: 'http://localhost:8080',
+          })
+
+          expect(await result).to.be.true
         })
+      })
 
-        expect(await result).to.be.true
-
-        // A script request emanated from the previous css is controlled
-        result = manager.processBrowserPreRequest(createBrowserPreRequest({
-          url: 'http://example.com/baz.woff2',
-          initiatorUrl: 'http://example.com/bar.css?foo=bar',
-          documentUrl: 'http://localhost:8080/index.html?foo=bar',
-        }))
-
-        manager.handleServiceWorkerClientEvent({
-          type: 'fetchRequest',
-          payload: {
-            url: 'http://example.com/baz.woff2',
-            isControlled: true,
-          },
-          scope: 'http://localhost:8080',
+      context('without any controlled urls', () => {
+        it('will start handling when clients are claimed', async () => {
+          const registration = manager['serviceWorkerRegistrations'].get('1')
+          const serviceWorker = registration?.activatedServiceWorker
+
+          expect(registration?.isHandlingRequests).to.be.false
+          expect(serviceWorker?.controlledURLs).to.be.empty
+
+          manager.handleServiceWorkerClientEvent({
+            type: 'clientsClaimed',
+            payload: {
+              clientUrls: ['http://localhost:8080/index.html', 'http://localhost:8080/foo.js'],
+            },
+            scope: 'http://localhost:8080',
+          })
+
+          expect(registration?.isHandlingRequests).to.be.true
+          expect(serviceWorker?.controlledURLs).to.include('http://localhost:8080/index.html')
+          expect(serviceWorker?.controlledURLs).to.include('http://localhost:8080/foo.js')
         })
 
-        expect(await result).to.be.true
-
-        // A script request emanated from a different script request is not controlled
-        expect(await manager.processBrowserPreRequest(createBrowserPreRequest({
-          url: 'http://example.com/quux.js',
-          callFrameUrl: 'http://example.com/bar.js?foo=bar',
-          documentUrl: 'http://localhost:8080/index.html?foo=bar',
-        }))).to.be.false
-
-        // A script request emanated from a different css request is not controlled
-        expect(await manager.processBrowserPreRequest(createBrowserPreRequest({
-          url: 'http://example.com/quux.css',
-          initiatorUrl: 'http://example.com/baz.css?foo=bar',
-          documentUrl: 'http://localhost:8080/index.html?foo=bar',
-        }))).to.be.false
-
-        // A script request emanated from a different document is not controlled
-        expect(await manager.processBrowserPreRequest(createBrowserPreRequest({
-          url: 'http://example.com/quux.css',
-          initiatorUrl: 'http://example.com/baz.css?foo=bar',
-          documentUrl: 'http://localhost:8080/index.html?foo=bar',
-        }))).to.be.false
-
-        // A preload request is not controlled
-        expect(await manager.processBrowserPreRequest(createBrowserPreRequest({
-          url: 'http://example.com/quux.css',
-          isPreload: true,
-          documentUrl: 'http://localhost:8080/index.html?foo=bar',
-        }))).to.be.false
-      })
-
-      it('will detect when requests are controlled by a service worker and handles re-registrations', async () => {
-        // A script request emanated from the service worker's initiator is controlled
-        let result = manager.processBrowserPreRequest(createBrowserPreRequest({
-          url: 'http://localhost:8080/foo.js',
-        }))
+        it('will add client urls to the pending list until the service worker is activated', async () => {
+          // remove the current service worker
+          manager.updateServiceWorkerRegistrations({
+            registrations: [{
+              registrationId: '1',
+              scopeURL: 'http://localhost:8080',
+              isDeleted: true,
+            }],
+          })
+
+          // add a new service worker that is not activated
+          manager.updateServiceWorkerRegistrations({
+            registrations: [{
+              registrationId: '2',
+              scopeURL: 'http://localhost:8080',
+              isDeleted: false,
+            }],
+          })
+
+          // update the service worker to be in a non-activated state
+          manager.updateServiceWorkerVersions({
+            versions: [{
+              versionId: '1',
+              runningStatus: 'running',
+              registrationId: '2',
+              scriptURL: 'http://localhost:8080/sw.js',
+              status: 'activating',
+            }],
+          })
 
-        manager.handleServiceWorkerClientEvent({
-          type: 'fetchRequest',
-          payload: {
-            url: 'http://localhost:8080/foo.js',
-            isControlled: true,
-          },
-          scope: 'http://localhost:8080',
-        })
+          manager.addInitiatorToServiceWorker({
+            scriptURL: 'http://localhost:8080/sw.js',
+            initiatorOrigin: 'http://localhost:8080/',
+          })
+
+          const registration = manager['serviceWorkerRegistrations'].get('2')
+
+          expect(registration?.isHandlingRequests).to.be.false
+          expect(registration?.activatedServiceWorker).to.be.undefined
+
+          // add client urls to the pending list
+          manager.handleServiceWorkerClientEvent({
+            type: 'clientsClaimed',
+            payload: {
+              clientUrls: ['http://localhost:8080/index.html', 'http://localhost:8080/foo.js'],
+            },
+            scope: 'http://localhost:8080',
+          })
+
+          expect(registration?.isHandlingRequests).to.be.true
+          expect(registration?.activatedServiceWorker).to.be.undefined
+
+          // update the service worker to be in an activated state
+          manager.updateServiceWorkerVersions({
+            versions: [{
+              versionId: '1',
+              runningStatus: 'running',
+              registrationId: '2',
+              scriptURL: 'http://localhost:8080/sw.js',
+              status: 'activated',
+            }],
+          })
 
-        expect(await result).to.be.true
+          const serviceWorker = registration?.activatedServiceWorker
 
-        manager.updateServiceWorkerRegistrations({
-          registrations: [{
-            registrationId: '1',
-            scopeURL: 'http://localhost:8080',
-            isDeleted: false,
-          }],
+          expect(serviceWorker?.controlledURLs).to.include('http://localhost:8080/index.html')
+          expect(serviceWorker?.controlledURLs).to.include('http://localhost:8080/foo.js')
         })
 
-        // A script request emanated from the previous script request is controlled
-        result = manager.processBrowserPreRequest(createBrowserPreRequest({
-          url: 'http://example.com/bar.css',
-          callFrameUrl: 'http://localhost:8080/foo.js',
-        }))
+        it('will start handling requests if the request is for the document', async () => {
+          const registration = manager['serviceWorkerRegistrations'].get('1')
+          const serviceWorker = registration?.activatedServiceWorker
 
-        manager.handleServiceWorkerClientEvent({
-          type: 'fetchRequest',
-          payload: {
-            url: 'http://example.com/bar.css',
-            isControlled: true,
-          },
-          scope: 'http://localhost:8080',
-        })
+          expect(registration?.isHandlingRequests).to.be.false
+          expect(serviceWorker?.controlledURLs).to.be.empty
 
-        expect(await result).to.be.true
-      })
+          let result = manager.processBrowserPreRequest(createBrowserPreRequest({
+            url: 'http://localhost:8080/index.html',
+            originalResourceType: 'Document',
+          }))
 
-      it('will detect when requests are controlled by a service worker and handles unregistrations', async () => {
-        // A script request emanated from the service worker's initiator is controlled
-        const result = manager.processBrowserPreRequest(createBrowserPreRequest({
-          url: 'http://localhost:8080/foo.js',
-        }))
+          expect(registration?.isHandlingRequests).to.be.true
 
-        manager.handleServiceWorkerClientEvent({
-          type: 'fetchRequest',
-          payload: {
-            url: 'http://localhost:8080/foo.js',
-            isControlled: true,
-          },
-          scope: 'http://localhost:8080',
+          manager.handleServiceWorkerClientEvent({
+            type: 'fetchRequest',
+            payload: {
+              url: 'http://localhost:8080/index.html',
+              isControlled: true,
+            },
+            scope: 'http://localhost:8080',
+          })
+
+          expect(await result).to.be.true
+          expect(serviceWorker?.controlledURLs).to.include('http://localhost:8080/index.html')
         })
 
-        expect(await result).to.be.true
+        it('will handle a request whose call stack includes a url with the scope url', async () => {
+          const registration = manager['serviceWorkerRegistrations'].get('1')
+          const serviceWorker = registration?.activatedServiceWorker
 
-        manager.updateServiceWorkerRegistrations({
-          registrations: [{
-            registrationId: '1',
-            scopeURL: 'http://localhost:8080',
-            isDeleted: true,
-          }],
-        })
+          expect(registration?.isHandlingRequests).to.be.false
+          expect(serviceWorker?.controlledURLs).to.be.empty
 
-        // A script request emanated from the previous script request is not controlled since the service worker was unregistered
-        expect(await manager.processBrowserPreRequest(createBrowserPreRequest({
-          url: 'http://example.com/bar.css',
-          callFrameUrl: 'http://localhost:8080/foo.js',
-        }))).to.be.false
-      })
+          manager.handleServiceWorkerClientEvent({
+            type: 'clientsClaimed',
+            payload: {
+              clientUrls: ['http://localhost:8080/index.html'],
+            },
+            scope: 'http://localhost:8080',
+          })
 
-      it('supports multiple fetch handler calls first', async () => {
-        manager.handleServiceWorkerClientEvent({
-          type: 'fetchRequest',
-          payload: {
-            url: 'http://localhost:8080/foo.js',
-            isControlled: true,
-          },
-          scope: 'http://localhost:8080',
+          let result = manager.processBrowserPreRequest(createBrowserPreRequest({
+            url: 'http://example.com/bar.css',
+            callFrameUrl: 'http://localhost:8080/foo.js',
+          }))
+
+          expect(registration?.isHandlingRequests).to.be.true
+
+          manager.handleServiceWorkerClientEvent({
+            type: 'fetchRequest',
+            payload: {
+              url: 'http://example.com/bar.css',
+              isControlled: true,
+            },
+            scope: 'http://localhost:8080',
+          })
+
+          expect(await result).to.be.true
+          expect(serviceWorker?.controlledURLs).to.include('http://example.com/bar.css')
         })
 
-        manager.handleServiceWorkerClientEvent({
-          type: 'fetchRequest',
-          payload: {
-            url: 'http://localhost:8080/bar.js',
-            isControlled: false,
-          },
-          scope: 'http://localhost:8080',
-        })
+        it('will handle a request whose call stack includes a url with a controlled url', async () => {
+          const registration = manager['serviceWorkerRegistrations'].get('1')
+          const serviceWorker = registration?.activatedServiceWorker
 
-        expect(await manager.processBrowserPreRequest(createBrowserPreRequest({
-          url: 'http://localhost:8080/foo.js',
-        }))).to.be.true
+          expect(registration?.isHandlingRequests).to.be.false
+          expect(serviceWorker?.controlledURLs).to.be.empty
 
-        expect(await manager.processBrowserPreRequest(createBrowserPreRequest({
-          url: 'http://localhost:8080/bar.js',
-        }))).to.be.false
-      })
+          manager.handleServiceWorkerClientEvent({
+            type: 'clientsClaimed',
+            payload: {
+              clientUrls: ['http://localhost:8080/index.html'],
+            },
+            scope: 'http://localhost:8080',
+          })
 
-      it('supports multiple browser pre-request calls first', async () => {
-        const request1 = manager.processBrowserPreRequest(createBrowserPreRequest({
-          url: 'http://localhost:8080/foo.js',
-        }))
+          let result = manager.processBrowserPreRequest(createBrowserPreRequest({
+            url: 'http://example.com/bar.css',
+            callFrameUrl: 'http://localhost:8080/foo.js',
+          }))
+
+          expect(registration?.isHandlingRequests).to.be.true
+
+          manager.handleServiceWorkerClientEvent({
+            type: 'fetchRequest',
+            payload: {
+              url: 'http://example.com/bar.css',
+              isControlled: true,
+            },
+            scope: 'http://localhost:8080',
+          })
+
+          expect(await result).to.be.true
+          expect(serviceWorker?.controlledURLs).to.include('http://example.com/bar.css')
+        })
 
-        const request2 = manager.processBrowserPreRequest(createBrowserPreRequest({
-          url: 'http://localhost:8080/bar.js',
-        }))
+        it('does not start handling requests if the request is for a document not within the service worker scope', async () => {
+          const registration = manager['serviceWorkerRegistrations'].get('1')
+          const serviceWorker = registration?.activatedServiceWorker
 
-        manager.handleServiceWorkerClientEvent({
-          type: 'fetchRequest',
-          payload: {
-            url: 'http://localhost:8080/foo.js',
-            isControlled: true,
-          },
-          scope: 'http://localhost:8080',
-        })
+          let result = manager.processBrowserPreRequest(createBrowserPreRequest({
+            url: 'http://localhost:9999/index.html',
+            originalResourceType: 'Document',
+          }))
 
-        manager.handleServiceWorkerClientEvent({
-          type: 'fetchRequest',
-          payload: {
-            url: 'http://localhost:8080/bar.js',
-            isControlled: false,
-          },
-          scope: 'http://localhost:8080',
+          expect(registration?.isHandlingRequests).to.be.false
+          expect(serviceWorker?.controlledURLs).to.be.empty
+          expect(await result).to.be.false
         })
 
-        expect(await request1).to.be.true
-        expect(await request2).to.be.false
-      })
+        it('does not start handling requests if the request is not for a document', async () => {
+          const registration = manager['serviceWorkerRegistrations'].get('1')
+          const serviceWorker = registration?.activatedServiceWorker
 
-      it('supports no client fetch handlers', async () => {
-        manager.handleServiceWorkerClientEvent({
-          type: 'hasFetchHandler',
-          payload: {
-            hasFetchHandler: false,
-          },
-          scope: 'http://localhost:8080',
-        })
+          let result = manager.processBrowserPreRequest(createBrowserPreRequest({
+            url: 'http://localhost:8080/index.html',
+            originalResourceType: 'Fetch',
+          }))
 
-        expect(await manager.processBrowserPreRequest(createBrowserPreRequest({
-          url: 'http://localhost:8080/foo.js',
-        }))).to.be.false
+          expect(registration?.isHandlingRequests).to.be.false
+          expect(serviceWorker?.controlledURLs).to.be.empty
+          expect(await result).to.be.false
+        })
       })
     })
   })
diff --git a/packages/server/test/unit/browsers/cdp_automation_spec.ts b/packages/server/test/unit/browsers/cdp_automation_spec.ts
index 97352bc035d7..890ed2b24d8a 100644
--- a/packages/server/test/unit/browsers/cdp_automation_spec.ts
+++ b/packages/server/test/unit/browsers/cdp_automation_spec.ts
@@ -163,9 +163,11 @@ context('lib/browsers/cdp_automation', () => {
       it('ignore events with data urls', function () {
         this.onFn
         .withArgs('Network.requestWillBeSent')
-        .yield({ request: { url: 'data:font;base64' } })
+        .yield({ requestId: '0', request: { url: 'data:font;base64' } })
 
         expect(this.automation.onBrowserPreRequest).to.not.be.called
+        expect(cdpAutomation['cachedDataUrlRequestIds'].has('0')).to.be.true
+        expect(cdpAutomation['cachedDataUrlRequestIds']).to.have.property('size', 1)
       })
     })
 
@@ -253,7 +255,7 @@ context('lib/browsers/cdp_automation', () => {
     })
 
     describe('.onRequestServedFromCache', function () {
-      it('triggers onRequestServedFromCache', function () {
+      it('triggers onRemoveBrowserPreRequest', function () {
         const browserRequestServedFromCache = {
           requestId: '0',
         }
@@ -264,6 +266,23 @@ context('lib/browsers/cdp_automation', () => {
 
         expect(this.automation.onRemoveBrowserPreRequest).to.have.been.calledWith(browserRequestServedFromCache.requestId)
       })
+
+      it('ignores cached data url request ids', function () {
+        this.onFn
+        .withArgs('Network.requestWillBeSent')
+        .yield({ requestId: '0', request: { url: 'data:font;base64' } })
+
+        expect(cdpAutomation['cachedDataUrlRequestIds'].has('0')).to.be.true
+        expect(cdpAutomation['cachedDataUrlRequestIds']).to.have.property('size', 1)
+
+        this.onFn
+        .withArgs('Network.requestServedFromCache')
+        .yield({ requestId: '0' })
+
+        expect(this.automation.onRemoveBrowserPreRequest).to.not.have.been.called
+        expect(cdpAutomation['cachedDataUrlRequestIds'].has('0')).to.be.false
+        expect(cdpAutomation['cachedDataUrlRequestIds']).to.have.property('size', 0)
+      })
     })
 
     describe('.onRequestFailed', function () {

From e7962ed4c941cf92ff816c4afeac38a9ffadff72 Mon Sep 17 00:00:00 2001
From: Matthew Schile <mschile@cypress.io>
Date: Wed, 17 Apr 2024 19:19:38 -0600
Subject: [PATCH 18/31] update

---
 packages/driver/cypress/e2e/e2e/service-worker.cy.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/driver/cypress/e2e/e2e/service-worker.cy.js b/packages/driver/cypress/e2e/e2e/service-worker.cy.js
index 01af8eeab6a5..17e479af9c29 100644
--- a/packages/driver/cypress/e2e/e2e/service-worker.cy.js
+++ b/packages/driver/cypress/e2e/e2e/service-worker.cy.js
@@ -667,7 +667,7 @@ describe('service workers', { defaultCommandTimeout: 1000, pageLoadTimeout: 1000
     validateFetchHandlers({ listenerCount: 1 })
   })
 
-  it('supports a service worker is that activated but not handling fetch events', () => {
+  it('supports a service worker that is activated but not handling fetch events', () => {
     const script = () => {
       self.addEventListener('fetch', function (event) {
         event.respondWith(fetch(event.request))

From 6fea57d349770134f7dde46cfe247d9e8e4cf72d Mon Sep 17 00:00:00 2001
From: Matthew Schile <mschile@cypress.io>
Date: Wed, 17 Apr 2024 19:24:30 -0600
Subject: [PATCH 19/31] updating changelog

---
 cli/CHANGELOG.md | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/cli/CHANGELOG.md b/cli/CHANGELOG.md
index d0d6538e0fbd..d639a7774282 100644
--- a/cli/CHANGELOG.md
+++ b/cli/CHANGELOG.md
@@ -3,6 +3,9 @@
 
 _Released 4/16/2024 (PENDING)_
 
+**Performance:**
+- Fixed a performance issue with activated service workers that aren't handling requests could lead to correlation timeouts. Fixes [#29333](https://github.com/cypress-io/cypress/issues/29333) and [#29126](https://github.com/cypress-io/cypress/issues/29126).
+
 **Misc:**
 
 - We now capture the [Semaphore](https://semaphoreci.com/) CI provider's environment variable [`SEMAPHORE_GIT_PR_NUMBER`](https://docs.semaphoreci.com/ci-cd-environment/environment-variables/#semaphore_git_pr_number) to display the linked PR number in the Cloud. Addressed in [#29314](https://github.com/cypress-io/cypress/pull/29314).

From d278c477afbda7b2215852a951768ba31815820c Mon Sep 17 00:00:00 2001
From: Matthew Schile <mschile@cypress.io>
Date: Wed, 17 Apr 2024 19:27:27 -0600
Subject: [PATCH 20/31] update changelog

---
 cli/CHANGELOG.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/cli/CHANGELOG.md b/cli/CHANGELOG.md
index d639a7774282..ac642d165eb4 100644
--- a/cli/CHANGELOG.md
+++ b/cli/CHANGELOG.md
@@ -4,7 +4,8 @@
 _Released 4/16/2024 (PENDING)_
 
 **Performance:**
-- Fixed a performance issue with activated service workers that aren't handling requests could lead to correlation timeouts. Fixes [#29333](https://github.com/cypress-io/cypress/issues/29333) and [#29126](https://github.com/cypress-io/cypress/issues/29126).
+
+- Fixed a performance issue with activated service workers that aren't controlling clients which could lead to correlation timeouts. Fixes [#29333](https://github.com/cypress-io/cypress/issues/29333) and [#29126](https://github.com/cypress-io/cypress/issues/29126).
 
 **Misc:**
 

From 0b7c58588821bec8ea1120fcc1800406e219e02d Mon Sep 17 00:00:00 2001
From: Matt Schile <mschile@cypress.io>
Date: Fri, 19 Apr 2024 09:49:41 -0600
Subject: [PATCH 21/31] Apply suggestions from code review

Co-authored-by: Bill Glesias <bglesias@gmail.com>
---
 packages/proxy/lib/http/util/service-worker-injector.ts   | 2 +-
 packages/proxy/test/unit/http/response-middleware.spec.ts | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/packages/proxy/lib/http/util/service-worker-injector.ts b/packages/proxy/lib/http/util/service-worker-injector.ts
index 33b2685034f8..69767294e03e 100644
--- a/packages/proxy/lib/http/util/service-worker-injector.ts
+++ b/packages/proxy/lib/http/util/service-worker-injector.ts
@@ -67,7 +67,7 @@ export const injectIntoServiceWorker = (body: Buffer) => {
       sendEvent({ type: 'fetchRequest', payload })
     }
 
-    const sendClientsClaimed = async (payload: { clientUrls: string[] }) => {
+    const sendClientsClaimed = (payload: { clientUrls: string[] }) => {
       // call the CDP binding to inform the backend that the service worker is now handling requests
       sendEvent({ type: 'clientsClaimed', payload })
     }
diff --git a/packages/proxy/test/unit/http/response-middleware.spec.ts b/packages/proxy/test/unit/http/response-middleware.spec.ts
index 5be33f569d6b..a8279fa4d7e7 100644
--- a/packages/proxy/test/unit/http/response-middleware.spec.ts
+++ b/packages/proxy/test/unit/http/response-middleware.spec.ts
@@ -2342,7 +2342,7 @@ describe('http/response-middleware', function () {
       })
     })
 
-    it('rewrites the service worker', async function () {
+    it('rewrites the service worker in chromium based browsers', async function () {
       prepareContext({
         req: {
           proxiedUrl: 'http://www.foobar.com:3501/service-worker.js',

From 9ee2791b931f2dc3ffdf0743f753f927c572e3c7 Mon Sep 17 00:00:00 2001
From: Matthew Schile <mschile@cypress.io>
Date: Fri, 19 Apr 2024 22:29:34 -0600
Subject: [PATCH 22/31] support redirected requests

---
 .../cypress/e2e/e2e/service-worker.cy.js      | 29 +++++++++++++++++++
 .../lib/http/util/service-worker-manager.ts   | 21 +++++++++-----
 packages/proxy/lib/types.ts                   |  1 +
 .../http/util/service-worker-manager.spec.ts  | 12 ++++++--
 .../server/lib/browsers/cdp_automation.ts     |  1 +
 5 files changed, 54 insertions(+), 10 deletions(-)

diff --git a/packages/driver/cypress/e2e/e2e/service-worker.cy.js b/packages/driver/cypress/e2e/e2e/service-worker.cy.js
index 17e479af9c29..122782d82fcc 100644
--- a/packages/driver/cypress/e2e/e2e/service-worker.cy.js
+++ b/packages/driver/cypress/e2e/e2e/service-worker.cy.js
@@ -684,4 +684,33 @@ describe('service workers', { defaultCommandTimeout: 1000, pageLoadTimeout: 1000
     cy.get('#output').should('have.text', 'done')
     validateFetchHandlers({ listenerCount: 1 })
   })
+
+  it('supports a redirected request', () => {
+    const script = () => {
+      self.addEventListener('fetch', function (event) {
+        return
+      })
+    }
+
+    cy.intercept('/fixtures/service-worker.js', (req) => {
+      req.reply(`(${script})()`,
+        { 'Content-Type': 'application/javascript' })
+    })
+
+    cy.intercept('/fixtures/1mb*', (req) => {
+      req.reply({
+        statusCode: 302,
+        headers: {
+          location: '/fixtures/redirected',
+        },
+      })
+    })
+
+    cy.intercept('/fixtures/redirected', (req) => {
+      req.reply('redirected')
+    })
+
+    cy.visit('fixtures/service-worker.html')
+    cy.get('#output').should('have.text', 'done')
+  })
 })
diff --git a/packages/proxy/lib/http/util/service-worker-manager.ts b/packages/proxy/lib/http/util/service-worker-manager.ts
index 4d91c5229415..21d332ccdb15 100644
--- a/packages/proxy/lib/http/util/service-worker-manager.ts
+++ b/packages/proxy/lib/http/util/service-worker-manager.ts
@@ -197,6 +197,12 @@ export class ServiceWorkerManager {
       return false
     }
 
+    if (browserPreRequest.hasRedirectResponse) {
+      debug('skipping request with redirect response: %o', browserPreRequest)
+
+      return false
+    }
+
     let requestPotentiallyControlledByServiceWorker = false
     let activatedServiceWorker: ServiceWorker | undefined
     const paramlessURL = browserPreRequest.url?.split('?')[0] || ''
@@ -242,19 +248,17 @@ export class ServiceWorkerManager {
 
     if (activatedServiceWorker) {
       if (requestPotentiallyControlledByServiceWorker) {
-        isControlled = await this.isURLControlledByServiceWorker(browserPreRequest.url)
+        isControlled = await this.isURLControlledByServiceWorker(browserPreRequest)
 
         if (isControlled) {
-          debug('Request is controlled by service worker: %o', browserPreRequest.url)
+          debug('Request is controlled by service worker: %o', { url: browserPreRequest.url, requestId: browserPreRequest.requestId })
           activatedServiceWorker.controlledURLs.add(paramlessURL)
 
           return true
         }
-
-        debug('Request is not controlled by service worker: %o', browserPreRequest.url)
       }
 
-      debug('Request is not controlled by service worker: %o', { browserPreRequest, requestPotentiallyControlledByServiceWorker })
+      debug('Request is not controlled by service worker: %o', { url: browserPreRequest.url, requestId: browserPreRequest.requestId, requestPotentiallyControlledByServiceWorker })
     }
 
     return false
@@ -345,13 +349,14 @@ export class ServiceWorkerManager {
    * @param url the URL to check
    * @returns a promise that resolves to `true` if the URL is controlled by a service worker, `false` otherwise.
    */
-  private isURLControlledByServiceWorker (url: string) {
+  private isURLControlledByServiceWorker (browserPreRequest: BrowserPreRequest) {
+    const url = browserPreRequest.url
     const fetches = this.pendingServiceWorkerFetches.get(url)
 
     if (fetches) {
       const isControlled = fetches.shift()
 
-      debug('found pending service worker fetch: %o', { url, isControlled })
+      debug('found pending service worker fetch: %o', { url, isControlled, requestId: browserPreRequest.requestId })
 
       if (fetches.length === 0) {
         this.pendingServiceWorkerFetches.delete(url)
@@ -370,7 +375,7 @@ export class ServiceWorkerManager {
     const deferred = pDefer<boolean>()
 
     promises.push(deferred)
-    debug('adding pending controlled request promise: %s', url)
+    debug('adding pending controlled request promise: %o', { url, requestId: browserPreRequest.requestId })
 
     return deferred.promise
   }
diff --git a/packages/proxy/lib/types.ts b/packages/proxy/lib/types.ts
index 3fb51cc692a2..a9d7ccbadbe6 100644
--- a/packages/proxy/lib/types.ts
+++ b/packages/proxy/lib/types.ts
@@ -66,6 +66,7 @@ export type BrowserPreRequest = {
   errorHandled?: boolean
   initiator?: Protocol.Network.Initiator
   documentURL: string
+  hasRedirectResponse: boolean
   cdpRequestWillBeSentTimestamp: number
   cdpRequestWillBeSentReceivedTimestamp: number
 }
diff --git a/packages/proxy/test/unit/http/util/service-worker-manager.spec.ts b/packages/proxy/test/unit/http/util/service-worker-manager.spec.ts
index bf7ee73501f5..789c2ad628cf 100644
--- a/packages/proxy/test/unit/http/util/service-worker-manager.spec.ts
+++ b/packages/proxy/test/unit/http/util/service-worker-manager.spec.ts
@@ -3,8 +3,8 @@ import sinon from 'sinon'
 import { ServiceWorkerManager, serviceWorkerClientEventHandler } from '../../../../lib/http/util/service-worker-manager'
 
 const createBrowserPreRequest = (
-  { url, initiatorUrl, callFrameUrl, documentUrl, isPreload, originalResourceType }:
-  { url: string, initiatorUrl?: string, documentUrl?: string, callFrameUrl?: string, isPreload?: boolean, originalResourceType?: string },
+  { url, initiatorUrl, callFrameUrl, documentUrl, isPreload, originalResourceType, hasRedirectResponse }:
+  { url: string, initiatorUrl?: string, documentUrl?: string, callFrameUrl?: string, isPreload?: boolean, originalResourceType?: string, hasRedirectResponse?: boolean },
 ) => {
   return {
     requestId: 'id-1',
@@ -13,6 +13,7 @@ const createBrowserPreRequest = (
     headers: {},
     resourceType: 'fetch' as const,
     originalResourceType: originalResourceType || 'Fetch' as const,
+    hasRedirectResponse: hasRedirectResponse || false,
     ...(isPreload
       ? {
         initiator: {
@@ -532,6 +533,13 @@ describe('lib/http/util/service-worker-manager', () => {
 
           expect(await result).to.be.true
         })
+
+        it('supports a redirected request', async () => {
+          expect(await manager.processBrowserPreRequest(createBrowserPreRequest({
+            url: 'http://localhost:8080/foo.js',
+            hasRedirectResponse: true,
+          }))).to.be.false
+        })
       })
 
       context('without any controlled urls', () => {
diff --git a/packages/server/lib/browsers/cdp_automation.ts b/packages/server/lib/browsers/cdp_automation.ts
index db755dd2ba8b..f38d6227cdc6 100644
--- a/packages/server/lib/browsers/cdp_automation.ts
+++ b/packages/server/lib/browsers/cdp_automation.ts
@@ -283,6 +283,7 @@ export class CdpAutomation implements CDPClient {
       originalResourceType: params.type,
       initiator: params.initiator,
       documentURL: params.documentURL,
+      hasRedirectResponse: params.redirectResponse != null,
       // wallTime is in seconds: https://vanilla.aslushnikov.com/?Network.TimeSinceEpoch
       // normalize to milliseconds to be comparable to everything else we're gathering
       cdpRequestWillBeSentTimestamp: params.wallTime * 1000,

From 1a5bcb9100ea72db1b5584c8b746dfa36c6d4cb9 Mon Sep 17 00:00:00 2001
From: Matt Schile <mschile@cypress.io>
Date: Mon, 22 Apr 2024 08:13:14 -0600
Subject: [PATCH 23/31] Apply suggestions from code review

Co-authored-by: Ryan Manuel <ryanm@cypress.io>
---
 packages/driver/cypress/fixtures/service-worker.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/driver/cypress/fixtures/service-worker.html b/packages/driver/cypress/fixtures/service-worker.html
index fb86c62a12a6..182ffda29033 100644
--- a/packages/driver/cypress/fixtures/service-worker.html
+++ b/packages/driver/cypress/fixtures/service-worker.html
@@ -24,7 +24,7 @@
           if (e.target.state === 'activated' && !controllerChangeCalled) {
             // service worker activated, either skip reloading the page
             // so we can test when an activated service worker is not intercepting requests
-            // or reload page so it can intercept requests
+            // or reload the page so it can intercept requests
             if (location.search.includes('skipReload')) {
               makeRequest()
             } else {

From f73daf5040dcbaf7240a225971f2e9f5c8d6e399 Mon Sep 17 00:00:00 2001
From: Matt Schile <mschile@cypress.io>
Date: Mon, 22 Apr 2024 08:24:40 -0600
Subject: [PATCH 24/31] Update
 packages/proxy/test/unit/http/util/service-worker-manager.spec.ts

Co-authored-by: Bill Glesias <bglesias@gmail.com>
---
 .../proxy/test/unit/http/util/service-worker-manager.spec.ts    | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/proxy/test/unit/http/util/service-worker-manager.spec.ts b/packages/proxy/test/unit/http/util/service-worker-manager.spec.ts
index 789c2ad628cf..e47095c6c7cf 100644
--- a/packages/proxy/test/unit/http/util/service-worker-manager.spec.ts
+++ b/packages/proxy/test/unit/http/util/service-worker-manager.spec.ts
@@ -563,7 +563,7 @@ describe('lib/http/util/service-worker-manager', () => {
           expect(serviceWorker?.controlledURLs).to.include('http://localhost:8080/foo.js')
         })
 
-        it('will add client urls to the pending list until the service worker is activated', async () => {
+        it('will add client urls to the pending list until the service worker is activated', () => {
           // remove the current service worker
           manager.updateServiceWorkerRegistrations({
             registrations: [{

From a9c1c49d2ca622ebf5f34c5c63432277404a1b1c Mon Sep 17 00:00:00 2001
From: Matthew Schile <mschile@cypress.io>
Date: Mon, 22 Apr 2024 09:08:00 -0600
Subject: [PATCH 25/31] fixing type issue

---
 packages/proxy/lib/types.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/proxy/lib/types.ts b/packages/proxy/lib/types.ts
index a9d7ccbadbe6..d58d2eadfb72 100644
--- a/packages/proxy/lib/types.ts
+++ b/packages/proxy/lib/types.ts
@@ -66,7 +66,7 @@ export type BrowserPreRequest = {
   errorHandled?: boolean
   initiator?: Protocol.Network.Initiator
   documentURL: string
-  hasRedirectResponse: boolean
+  hasRedirectResponse?: boolean
   cdpRequestWillBeSentTimestamp: number
   cdpRequestWillBeSentReceivedTimestamp: number
 }

From 88474d3c057c09ce7db5c62dc2832dff075f57cc Mon Sep 17 00:00:00 2001
From: Matthew Schile <mschile@cypress.io>
Date: Mon, 22 Apr 2024 11:58:19 -0600
Subject: [PATCH 26/31] revert stop only change

---
 .circleci/workflows.yml | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/.circleci/workflows.yml b/.circleci/workflows.yml
index 73b2c6825534..811acdfeb89e 100644
--- a/.circleci/workflows.yml
+++ b/.circleci/workflows.yml
@@ -443,10 +443,8 @@ commands:
           command: yarn versions
       - unless:
           condition:
-            or:
-              # stop-only does not correctly match on windows: https://github.com/bahmutov/stop-only/issues/78
-              - equal: [ *windows-executor, << parameters.executor >> ]
-              - equal: [ *darwin-arm64-executor, << parameters.executor >> ]
+            # stop-only does not correctly match on windows: https://github.com/bahmutov/stop-only/issues/78
+            equal: [ *windows-executor, << parameters.executor >> ]
           steps:
             - run:
                 name: Stop .only

From 1cedbc4d0fdcadcda9506a532cf0ac8fddb03a43 Mon Sep 17 00:00:00 2001
From: Matthew Schile <mschile@cypress.io>
Date: Mon, 22 Apr 2024 15:22:40 -0600
Subject: [PATCH 27/31] updating cache version

---
 .circleci/cache-version.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.circleci/cache-version.txt b/.circleci/cache-version.txt
index 36b5b0fd6622..e28e8ca9e43d 100644
--- a/.circleci/cache-version.txt
+++ b/.circleci/cache-version.txt
@@ -1,3 +1,3 @@
 # Bump this version to force CI to re-create the cache from scratch.
 
-04-15-24-macstadium-3
+04-22-24

From a276cfcc6b0b928bae94458360d1f08d53e3103c Mon Sep 17 00:00:00 2001
From: Matthew Schile <mschile@cypress.io>
Date: Mon, 22 Apr 2024 18:11:18 -0600
Subject: [PATCH 28/31] update

---
 cli/CHANGELOG.md                                       | 2 +-
 packages/proxy/lib/http/util/service-worker-manager.ts | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/cli/CHANGELOG.md b/cli/CHANGELOG.md
index 190eab99e68f..d413b9eb665e 100644
--- a/cli/CHANGELOG.md
+++ b/cli/CHANGELOG.md
@@ -9,7 +9,7 @@ _Released 4/23/2024 (PENDING)_
 
 **Bugfixes:**
 
-- Fixed a bug introduced in [`13.6.0`](https://docs.cypress.io/guides/references/changelog#13-6-0) where Cypress would occasionally exit with status code 1, even when a test run was successfully, due to an unhandled WebSocket exception (`Error: WebSocket connection closed`). Addresses [#28523](https://github.com/cypress-io/cypress/issues/28523).
+- Fixed a regression introduced in [`13.6.0`](https://docs.cypress.io/guides/references/changelog#13-6-0) where Cypress would occasionally exit with status code 1, even when a test run was successful, due to an unhandled WebSocket exception (`Error: WebSocket connection closed`). Addresses [#28523](https://github.com/cypress-io/cypress/issues/28523).
 
 **Dependency Updates:**
 
diff --git a/packages/proxy/lib/http/util/service-worker-manager.ts b/packages/proxy/lib/http/util/service-worker-manager.ts
index 21d332ccdb15..0419e68c9f0a 100644
--- a/packages/proxy/lib/http/util/service-worker-manager.ts
+++ b/packages/proxy/lib/http/util/service-worker-manager.ts
@@ -178,7 +178,7 @@ export class ServiceWorkerManager {
   }
 
   private shouldControlDocumentRequest (registration: ServiceWorkerRegistration, browserPreRequest: BrowserPreRequest) {
-    return browserPreRequest.originalResourceType === 'Document' &&
+    return browserPreRequest.originalResourceType?.toLowerCase() === 'document' &&
       browserPreRequest.documentURL === browserPreRequest.url &&
       browserPreRequest.url.startsWith(registration.scopeURL)
   }

From f3e9fbe4da534b0ddbda6583a3a9b54b1407ceea Mon Sep 17 00:00:00 2001
From: Matthew Schile <mschile@cypress.io>
Date: Mon, 22 Apr 2024 22:08:17 -0600
Subject: [PATCH 29/31] reset pendingPreRequestsToRemove

---
 packages/proxy/lib/http/util/prerequests.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/packages/proxy/lib/http/util/prerequests.ts b/packages/proxy/lib/http/util/prerequests.ts
index 71e75e8bd4ab..2801aec2980f 100644
--- a/packages/proxy/lib/http/util/prerequests.ts
+++ b/packages/proxy/lib/http/util/prerequests.ts
@@ -360,5 +360,6 @@ export class PreRequests {
 
     this.pendingRequests = new QueueMap<PendingRequest>()
     this.pendingUrlsWithoutPreRequests = new QueueMap<PendingUrlWithoutPreRequest>()
+    this.pendingPreRequestsToRemove = new Set<string>()
   }
 }

From bc767fde47b6e1696b6f8763f15c3e73e264ba0d Mon Sep 17 00:00:00 2001
From: Matthew Schile <mschile@cypress.io>
Date: Tue, 23 Apr 2024 00:03:48 -0600
Subject: [PATCH 30/31] sweep pendingPreRequestsToRemove

---
 packages/proxy/lib/http/util/prerequests.ts          | 12 +++++++++---
 .../proxy/test/unit/http/util/prerequests.spec.ts    |  3 +++
 packages/server/lib/automation/automation.ts         |  3 ---
 packages/server/lib/browsers/cdp_automation.ts       |  2 +-
 packages/server/lib/project-base.ts                  |  5 -----
 .../server/test/unit/browsers/cdp_automation_spec.ts |  5 ++---
 6 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/packages/proxy/lib/http/util/prerequests.ts b/packages/proxy/lib/http/util/prerequests.ts
index 2801aec2980f..a9c2d347437c 100644
--- a/packages/proxy/lib/http/util/prerequests.ts
+++ b/packages/proxy/lib/http/util/prerequests.ts
@@ -116,7 +116,7 @@ export class PreRequests {
   pendingPreRequests = new QueueMap<PendingPreRequest>()
   pendingRequests = new QueueMap<PendingRequest>()
   pendingUrlsWithoutPreRequests = new QueueMap<PendingUrlWithoutPreRequest>()
-  pendingPreRequestsToRemove: Set<string> = new Set()
+  pendingPreRequestsToRemove: Map<string, number> = new Map()
   sweepIntervalTimer: NodeJS.Timeout
   protocolManager?: ProtocolManagerShape
 
@@ -153,6 +153,12 @@ export class PreRequests {
         return true
       })
 
+      this.pendingPreRequestsToRemove.forEach((timestamp, requestId) => {
+        if (timestamp + this.sweepInterval < now) {
+          this.pendingPreRequestsToRemove.delete(requestId)
+        }
+      })
+
       this.pendingUrlsWithoutPreRequests.removeMatching(({ timestamp }) => {
         return timestamp + this.sweepInterval >= now
       })
@@ -260,7 +266,7 @@ export class PreRequests {
     // the async function to add the pre-request
     if (!removed) {
       debugVerbose('No pre-request found to remove, adding to pending list: %s', requestId)
-      this.pendingPreRequestsToRemove.add(requestId)
+      this.pendingPreRequestsToRemove.set(requestId, Date.now())
     } else {
       debugVerbose('Removed pre-request %s', requestId)
     }
@@ -360,6 +366,6 @@ export class PreRequests {
 
     this.pendingRequests = new QueueMap<PendingRequest>()
     this.pendingUrlsWithoutPreRequests = new QueueMap<PendingUrlWithoutPreRequest>()
-    this.pendingPreRequestsToRemove = new Set<string>()
+    this.pendingPreRequestsToRemove = new Map()
   }
 }
diff --git a/packages/proxy/test/unit/http/util/prerequests.spec.ts b/packages/proxy/test/unit/http/util/prerequests.spec.ts
index 7ac0fd195ff8..aeafb6d593d9 100644
--- a/packages/proxy/test/unit/http/util/prerequests.spec.ts
+++ b/packages/proxy/test/unit/http/util/prerequests.spec.ts
@@ -189,6 +189,9 @@ describe('http/util/prerequests', () => {
     preRequests = new PreRequests(10, 200)
     preRequests.addPending({ requestId: '1234', url: 'foo', method: 'GET', cdpRequestWillBeSentReceivedTimestamp: performance.now() + performance.timeOrigin } as BrowserPreRequest)
     preRequests.addPendingUrlWithoutPreRequest('bar')
+    preRequests.removePendingPreRequest('12345')
+
+    expectPendingCounts(0, 1, 1, 1)
 
     // preRequests garbage collects pre-requests that never matched up with an incoming request after around
     // 2 * requestTimeout. We verify that it's gone (and therefore not leaking memory) by sending in a request
diff --git a/packages/server/lib/automation/automation.ts b/packages/server/lib/automation/automation.ts
index bfa1857bba77..6e8a2d41d502 100644
--- a/packages/server/lib/automation/automation.ts
+++ b/packages/server/lib/automation/automation.ts
@@ -16,7 +16,6 @@ export type AutomationOptions = {
   onBrowserPreRequest?: OnBrowserPreRequest
   onRequestEvent?: OnRequestEvent
   onRemoveBrowserPreRequest?: (requestId: string) => void
-  onRequestFailed?: (requestId: string) => void
   onDownloadLinkClicked?: (downloadUrl: string) => void
   onServiceWorkerRegistrationUpdated?: OnServiceWorkerRegistrationUpdated
   onServiceWorkerVersionUpdated?: OnServiceWorkerVersionUpdated
@@ -32,7 +31,6 @@ export class Automation {
   public onBrowserPreRequest: OnBrowserPreRequest | undefined
   public onRequestEvent: OnRequestEvent | undefined
   public onRemoveBrowserPreRequest: ((requestId: string) => void) | undefined
-  public onRequestFailed: ((requestId: string) => void) | undefined
   public onDownloadLinkClicked: ((downloadUrl: string) => void) | undefined
   public onServiceWorkerRegistrationUpdated: OnServiceWorkerRegistrationUpdated | undefined
   public onServiceWorkerVersionUpdated: OnServiceWorkerVersionUpdated | undefined
@@ -43,7 +41,6 @@ export class Automation {
     this.onBrowserPreRequest = options.onBrowserPreRequest
     this.onRequestEvent = options.onRequestEvent
     this.onRemoveBrowserPreRequest = options.onRemoveBrowserPreRequest
-    this.onRequestFailed = options.onRequestFailed
     this.onDownloadLinkClicked = options.onDownloadLinkClicked
     this.onServiceWorkerRegistrationUpdated = options.onServiceWorkerRegistrationUpdated
     this.onServiceWorkerVersionUpdated = options.onServiceWorkerVersionUpdated
diff --git a/packages/server/lib/browsers/cdp_automation.ts b/packages/server/lib/browsers/cdp_automation.ts
index f38d6227cdc6..448bf867bfea 100644
--- a/packages/server/lib/browsers/cdp_automation.ts
+++ b/packages/server/lib/browsers/cdp_automation.ts
@@ -309,7 +309,7 @@ export class CdpAutomation implements CDPClient {
   }
 
   private onRequestFailed = (params: Protocol.Network.LoadingFailedEvent) => {
-    this.automation.onRequestFailed?.(params.requestId)
+    this.automation.onRemoveBrowserPreRequest?.(params.requestId)
   }
 
   private onResponseReceived = (params: Protocol.Network.ResponseReceivedEvent) => {
diff --git a/packages/server/lib/project-base.ts b/packages/server/lib/project-base.ts
index f57458f6fa18..c373438e3c06 100644
--- a/packages/server/lib/project-base.ts
+++ b/packages/server/lib/project-base.ts
@@ -336,10 +336,6 @@ export class ProjectBase extends EE {
       this.server.removeBrowserPreRequest(requestId)
     }
 
-    const onRequestFailed = (requestId: string) => {
-      this.server.removeBrowserPreRequest(requestId)
-    }
-
     const onDownloadLinkClicked = (downloadUrl: string) => {
       this.server.addPendingUrlWithoutPreRequest(downloadUrl)
     }
@@ -367,7 +363,6 @@ export class ProjectBase extends EE {
       onBrowserPreRequest,
       onRequestEvent,
       onRemoveBrowserPreRequest,
-      onRequestFailed,
       onDownloadLinkClicked,
       onServiceWorkerRegistrationUpdated,
       onServiceWorkerVersionUpdated,
diff --git a/packages/server/test/unit/browsers/cdp_automation_spec.ts b/packages/server/test/unit/browsers/cdp_automation_spec.ts
index 890ed2b24d8a..65eef466f314 100644
--- a/packages/server/test/unit/browsers/cdp_automation_spec.ts
+++ b/packages/server/test/unit/browsers/cdp_automation_spec.ts
@@ -73,7 +73,6 @@ context('lib/browsers/cdp_automation', () => {
         onBrowserPreRequest: sinon.stub(),
         onRequestEvent: sinon.stub(),
         onRemoveBrowserPreRequest: sinon.stub(),
-        onRequestFailed: sinon.stub(),
         onServiceWorkerRegistrationUpdated: sinon.stub(),
         onServiceWorkerVersionUpdated: sinon.stub(),
       }
@@ -286,7 +285,7 @@ context('lib/browsers/cdp_automation', () => {
     })
 
     describe('.onRequestFailed', function () {
-      it('triggers onRequestFailed', function () {
+      it('triggers onRemoveBrowserPreRequest', function () {
         const browserRequestFailed = {
           requestId: '0',
         }
@@ -295,7 +294,7 @@ context('lib/browsers/cdp_automation', () => {
         .withArgs('Network.loadingFailed')
         .yield(browserRequestFailed)
 
-        expect(this.automation.onRequestFailed).to.have.been.calledWith(browserRequestFailed.requestId)
+        expect(this.automation.onRemoveBrowserPreRequest).to.have.been.calledWith(browserRequestFailed.requestId)
       })
     })
 

From 48d2525ba9cf134047f1f897afc6615637bbcd07 Mon Sep 17 00:00:00 2001
From: Matthew Schile <mschile@cypress.io>
Date: Tue, 23 Apr 2024 10:19:43 -0600
Subject: [PATCH 31/31] adding timeout

---
 .../proxy/lib/http/util/service-worker-manager.ts | 15 +++++++++++++--
 .../unit/http/util/service-worker-manager.spec.ts |  6 ++++++
 2 files changed, 19 insertions(+), 2 deletions(-)

diff --git a/packages/proxy/lib/http/util/service-worker-manager.ts b/packages/proxy/lib/http/util/service-worker-manager.ts
index 0419e68c9f0a..ed528407668c 100644
--- a/packages/proxy/lib/http/util/service-worker-manager.ts
+++ b/packages/proxy/lib/http/util/service-worker-manager.ts
@@ -248,7 +248,11 @@ export class ServiceWorkerManager {
 
     if (activatedServiceWorker) {
       if (requestPotentiallyControlledByServiceWorker) {
-        isControlled = await this.isURLControlledByServiceWorker(browserPreRequest)
+        try {
+          isControlled = await this.isURLControlledByServiceWorker(browserPreRequest)
+        } catch (e) {
+          debug('timed out checking if pre-request is controlled by service worker: %o', { url: browserPreRequest.url, requestId: browserPreRequest.requestId })
+        }
 
         if (isControlled) {
           debug('Request is controlled by service worker: %o', { url: browserPreRequest.url, requestId: browserPreRequest.requestId })
@@ -377,7 +381,14 @@ export class ServiceWorkerManager {
     promises.push(deferred)
     debug('adding pending controlled request promise: %o', { url, requestId: browserPreRequest.requestId })
 
-    return deferred.promise
+    let timer
+    // race the deferred promise with a timeout to prevent the pre-request from hanging indefinitely
+    const racingPromises = Promise.race([
+      deferred.promise,
+      new Promise<boolean>((_resolve, reject) => timer = setTimeout(reject, 250)),
+    ]).finally(() => clearTimeout(timer))
+
+    return racingPromises
   }
 
   /**
diff --git a/packages/proxy/test/unit/http/util/service-worker-manager.spec.ts b/packages/proxy/test/unit/http/util/service-worker-manager.spec.ts
index e47095c6c7cf..5017af68ffe4 100644
--- a/packages/proxy/test/unit/http/util/service-worker-manager.spec.ts
+++ b/packages/proxy/test/unit/http/util/service-worker-manager.spec.ts
@@ -540,6 +540,12 @@ describe('lib/http/util/service-worker-manager', () => {
             hasRedirectResponse: true,
           }))).to.be.false
         })
+
+        it('supports a pre-request that times out when it does not receive a fetch event', async () => {
+          expect(await manager.processBrowserPreRequest(createBrowserPreRequest({
+            url: 'http://localhost:8080/foo.js',
+          }))).to.be.false
+        })
       })
 
       context('without any controlled urls', () => {