Service Workers 1

2.1.1. Lifetime

The lifetime of a service worker is tied to the execution lifetime of events and not references held by service worker clients to the ServiceWorker object.

A user agent may terminate service workers at any time it:

• Has no event to handle.
• Detects abnormal operation: such as infinite loops and tasks exceeding imposed time limits (if any) while handling the events.

2.2.1. Lifetime

A user agent must persistently keep a list of registered service worker registrations unless otherwise they are explicitly unregistered. A user agent has a scope to registration map that stores the entries of the tuple of service worker registration’s scope url and the corresponding service worker registration. The lifetime of service worker registrations is beyond that of the ServiceWorkerRegistration objects which represent them within the lifetime of their corresponding service worker clients.

3.1.1. scriptURL

The scriptURL attribute must return the service worker’s serialized script url.

// Script on the page https://example.com/app.html
navigator.serviceWorker.register("/service_worker.js", { scope: "/" });

3.1.2. state

The state attribute must return the value (in ServiceWorkerState enumeration) to which it was last set.

3.1.3. postMessage(message, transfer)

The postMessage(message, transfer) method must run these steps or their equivalent:

1. If the state attribute value of the context object is "redundant", throw an "InvalidStateError" exception and abort these steps.
2. Let serviceWorker be the service worker represented by the context object.
3. Invoke Run Service Worker algorithm with serviceWorker as the argument.
4. Let destination be the ServiceWorkerGlobalScope object associated with serviceWorker.
5. Let targetRealm be destination’s Realm.
6. Let cloneRecord be StructuredCloneWithTransfer(message, transfer, targetRealm). If this throws an exception, rethrow that exception and abort these steps.
7. Let clonedMessage be cloneRecord.[[Clone]].
8. Let newPorts be a new frozen array consisting of all MessagePort objects in cloneRecord.[[TransferList]], if any, maintaining their relative order.
9. Queue a task that runs the following steps:
   1. Create an event e that uses the ExtendableMessageEvent interface, with the event type message, which does not bubble, is not cancelable, and has no default action.
   2. Let the data attribute of e be initialized to clonedMessage.
   3. Let the origin attribute of e be initialized to the Unicode serialisation of the origin specified by the incumbent settings object.
   4. If the global object globalObject specified by the incumbent settings object is a ServiceWorkerGlobalScope object, let the source attribute of e be initialized to a new ServiceWorker object that represents globalObject’s service worker.
   5. Else if globalObject is a Window object, let the source attribute of e be initialized to a new WindowClient object that represents globalObject’s browsing context.
   6. Else, let it be initialized to a new Client object that represents the worker associated with globalObject.
   7. Let the ports attribute of e be initialized to newPorts.
   8. Dispatch e at destination.

   The task must use the DOM manipulation task source.

3.1.4. Event handler

The following is the event handler (and its corresponding event handler event type) that must be supported, as event handler IDL attributes, by all objects implementing ServiceWorker interface:

3.2.1. installing

installing attribute must return the value to which it was last set.

The ServiceWorker objects returned from this attribute getter that represent the same service worker are the same objects.

3.2.2. waiting

waiting attribute must return the value to which it was last set.

The ServiceWorker objects returned from this attribute getter that represent the same service worker are the same objects.

3.2.3. active

active attribute must return the value to which it was last set.

The ServiceWorker objects returned from this attribute getter that represent the same service worker are the same objects.

3.2.4. scope

The scope attribute must return service worker registration’s serialized scope url.

In the example in section 3.1.1, the value of registration.scope, obtained from navigator.serviceWorker.ready.then(function(registration) { console.log(registration.scope); }) for example, will be "https://example.com/".

3.2.5. update()

update() method must run these steps or their equivalent:

1. Let p be a promise.
2. Let registration be the service worker registration.
3. Let newestWorker be the result of running Get Newest Worker algorithm passing registration as its argument.
4. If newestWorker is null, reject p with an "InvalidStateError" exception and abort these steps.
5. If the context object’s relevant settings object’s global object globalObject is a ServiceWorkerGlobalScope object, and globalObject’s associated service worker’s state is installing, reject p with an "InvalidStateError" exception and abort these steps.
6. Let job be the result of running Create Job with update, registration’s scope url, newestWorker’s script url, p, and the context object’s relevant settings object client.
7. Invoke Schedule Job with job.
8. Return p.

3.2.6. unregister()

The unregister() method unregisters the service worker registration. It is important to note that the currently controlled service worker client’s active worker’s containing service worker registration is effective until all the service worker clients (including itself) using this service worker registration unload. That is, the unregister() method only affects subsequent navigations.

unregister() method must return the result of running these steps or their equivalent:

1. Let p be a promise.
2. Let job be the result of running Create Job with unregister, the scope url of the service worker registration, null, p, and the context object’s relevant settings object client.
3. Invoke Schedule Job with job.
4. Return p.

3.2.7. Event handler

The following is the event handler (and its corresponding event handler event type) that must be supported, as event handler IDL attributes, by all objects implementing ServiceWorkerRegistration interface:

3.4.1. controller

controller attribute must return the result of running these steps or their equivalent:

1. Let client be the context object’s service worker client.
2. Return the ServiceWorker object that represents client’s active worker.

navigator.serviceWorker.controller returns null if the request is a force refresh (shift+refresh). The ServiceWorker objects returned from this attribute getter that represent the same service worker are the same objects.

3.4.2. ready

ready attribute must return the result of running these steps or their equivalent:

1. If the context object’s ready promise is settled, return the context object’s ready promise.
2. Let client be the context object’s service worker client.
3. Let registration be null.
4. Let clientURL be client’s creation url.
5. Run the following substeps in parallel:
   1. CheckRegistration: If the result of running Match Service Worker Registration algorithm, or its equivalent, with clientURL as its argument is not null, then:
      1. Set registration to the result value.
   2. Else:
      1. Wait until scope to registration map has a new entry.
      2. Jump to the step labeled CheckRegistration.
   3. If registration’s active worker is null, wait until registration’s active worker changes.

      Implementers should consider this condition is met when the corresponding registration request gets to the step 6 of Activate algorithm.

   4. Resolve context object’s ready promise with the ServiceWorkerRegistration object which represents registration.
6. Return context object’s ready promise.

When the ready attribute is accessed, the returned promise will never reject. Instead, it waits until the promise resolves with a service worker registration that has an active worker.

3.4.3. register(scriptURL, options)

The register(scriptURL, options) method creates or updates a service worker registration for the given scope url. If successful, a service worker registration ties the provided scriptURL to a scope url, which is subsequently used for navigation matching.

register(scriptURL, options) method must run these steps or their equivalent:

1. Let p be a promise.
2. Let client be the context object’s service worker client.
3. Let scriptURL be the result of parsing scriptURL with entry settings object’s API base URL.
4. If scriptURL is failure, reject p with a TypeError and abort these steps.
5. If scriptURL’s scheme is not one of "http" and "https", reject p with a TypeError and abort these steps.
6. If any of the strings in scriptURL’s path contains either ASCII case-insensitive "%2f" or ASCII case-insensitive "%5c", reject p with a TypeError and abort these steps.
7. Let scopeURL be null.
8. If options.scope is not present, set scopeURL to the result of parsing a string "./" with scriptURL.

   The scope url for the registration is set to the location of the service worker script by default.

9. Else, set scopeURL to the result of parsing options.scope with entry settings object’s API base URL.
10. If scopeURL is failure, reject p with a TypeError and abort these steps.
11. If scopeURL’s scheme is not one of "http" and "https", reject p with a TypeError and abort these steps.
12. If any of the strings in scopeURL’s path contains either ASCII case-insensitive "%2f" or ASCII case-insensitive "%5c", reject p with a TypeError and abort these steps.
13. Let job be the result of running Create Job with register, scopeURL, scriptURL, p, and client.
14. Invoke Schedule Job with job.
15. Return p.

3.4.4. getRegistration(clientURL)

getRegistration(clientURL) method must run these steps or their equivalent:

1. Let client be the context object’s service worker client.
2. Let clientURL be the result of parsing clientURL with entry settings object’s API base URL.
3. If clientURL is failure, return a promise rejected with a TypeError.
4. If the origin of clientURL is not client’s origin, return a promise rejected with a "SecurityError" exception.
5. Let promise be a new promise.
6. Run the following substeps in parallel:
   1. Let registration be the result of running Match Service Worker Registration algorithm, or its equivalent, with clientURL as its argument.
   2. If registration is not null, then:
      1. Resolve promise with the ServiceWorkerRegistration object which represents registration.
   3. Else:
      1. Resolve promise with undefined.
7. Return promise.

3.4.5. getRegistrations()

getRegistrations() method must run these steps or their equivalent:

1. Let client be the context object’s service worker client.
2. Let promise be a new promise.
3. Run the following substeps in parallel:
   1. Let array be an empty array.
   2. For each Record {[[key]], [[value]]} entry of scope to registration map:
      1. If the origin of the result of parsing entry.[[key]] is the same as client’s origin, add the ServiceWorkerRegistration object associated with entry.[[value]] to the array.
   3. Resolve promise with array.
4. Return promise.

3.4.6. Event handlers

The following are the event handlers (and their corresponding event handler event types) that must be supported, as event handler IDL attributes, by all objects implementing the ServiceWorkerContainer interface:

3.5.1. event.data

The data attribute must return the value it was initialized to. When the object is created, this attribute must be initialized to null. It represents the message being sent.

3.5.2. event.origin

The origin attribute must return the value it was initialized to. When the object is created, this attribute must be initialized to the empty string. It represents the origin of the service worker’s environment settings object from which the message is sent.

3.5.3. event.lastEventId

The lastEventId attribute must return the value it was initialized to. When the object is created, this attribute must be initialized to the empty string.

3.5.4. event.source

The source attribute must return the value it was initialized to. When the object is created, this attribute must be initialized to null. It represents the ServiceWorker object whose associated service worker the message is sent from.

3.5.5. event.ports

The ports attribute must return the value it was initialized to. When the object is created, this attribute must be initialized to null. It represents the MessagePort array being sent, if any.

4.1.1. clients

clients attribute must return the Clients object that is associated with the context object.

4.1.2. registration

The registration attribute must return the ServiceWorkerRegistration object that represents the service worker’s containing service worker registration.

4.1.3. skipWaiting()

The skipWaiting() method allows this service worker to progress from the registration’s waiting position to active even while service worker clients are using the registration.

skipWaiting() method must run these steps or their equivalent:

1. Let promise be a new promise.
2. Run the following substeps in parallel:
   1. Set service worker’s skip waiting flag
   2. If service worker’s state is installed, then:
      1. Run Activate algorithm, or its equivalent, passing service worker’s registration as the argument.
   3. Resolve promise with undefined.
3. Return promise.

4.1.4. Event handlers

The following are the event handlers (and their corresponding event handler event types) that must be supported, as event handler IDL attributes, by all objects implementing the ServiceWorkerGlobalScope interface:

4.2.1. url

The url attribute must return the context object’s associated service worker client’s serialized creation url.

4.2.2. frameType

The frameType attribute must return the value (in FrameType enumeration) corresponding to the first matching statement, switching on service worker client’s frame type:

auxiliary

"auxiliary"

The window client’s global object’s browsing context is an auxiliary browsing context.

top-level

"top-level"

The window client’s global object’s browsing context is a top-level browsing context.

nested

"nested"

The window client’s global object’s browsing context is a nested browsing context.

none

"none"

4.2.3. id

The id attribute must return its associated service worker client’s id.

4.2.4. postMessage(message, transfer)

The postMessage(message, transfer) method must run these steps or their equivalent:

1. Let destination be the ServiceWorkerContainer object whose service worker client is the context object’s service worker client.
2. If destination is null, throw an "InvalidStateError" exception.
3. Let targetRealm be destination’s Realm.
4. Let cloneRecord be StructuredCloneWithTransfer(message, transfer, targetRealm). If this throws an exception, rethrow that exception and abort these steps.
5. Let clonedMessage be cloneRecord.[[Clone]].
6. Let newPorts be a new frozen array consisting of all MessagePort objects in cloneRecord.[[TransferList]], if any, maintaining their relative order.
7. Queue a task that runs the following steps:
   1. Create an event e that uses the ServiceWorkerMessageEvent interface, with the event type message, which does not bubble, is not cancelable, and has no default action.
   2. Let the data attribute of e be initialized to clonedMessage.
   3. Let the origin attribute of e be initialized to the Unicode serialisation of the origin specified by the incumbent settings object.
   4. Let the source attribute of e be initialized to a ServiceWorker object, which represents the service worker associated with the global object specified by the incumbent settings object.
   5. Let the ports attribute of e be initialized to newPorts.
   6. Dispatch e at destination.

   The task must use the DOM manipulation task source, and, for those where the event loop specified by the target ServiceWorkerContainer object’s service worker client is a browsing context event loop, must be associated with the responsible document specified by that target ServiceWorkerContainer object’s service worker client.

4.2.5. visibilityState

The visibilityState attribute must return the context object’s visibility state.

4.2.6. focused

The focused attribute must return the context object’s focus state.

4.2.7. focus()

The focus() method must run these steps or their equivalent:

1. If this algorithm is not triggered by user activation, return a promise rejected with an "InvalidAccessError" exception.
2. Let promise be a new promise.
3. Run these substeps in parallel:
   1. Let browsingContext be the context object’s associated service worker client’s global object’s browsing context.
   2. Let visibilityState be null.
   3. Let focusState be null.
   4. Queue a task task to run the following substeps on the context object’s associated service worker client’s responsible event loop using the user interaction task source:
      1. Run the focusing steps with browsingContext.
      2. Set visibilityState to browsingContext’s active document’s visibilityState attribute value.
      3. Set focusState to the result of running the has focus steps with browsingContext’s active document as the argument.
   5. Wait for task to have executed.
   6. Let windowClient be the result of running Create Window Client algorithm, or its equivalent, with the context object’s associated service worker client, visibilityState and focusState as the arguments.
   7. If windowClient’s focus state is true, resolve promise with windowClient.
   8. Else, reject promise with a TypeError.
4. Return promise.

4.2.8. navigate(url)

The navigate() method must run these steps or their equivalent:

1. Let url be the result of parsing url with entry settings object’s API base URL.
2. If url is failure, return a promise rejected with a TypeError.
3. If url is about:blank, return a promise rejected with a TypeError.
4. If the context object’s associated service worker client’s active worker is not the incumbent settings object’s global object’s service worker, return a promise rejected with a TypeError.
5. Let promise be a new promise.
6. Run these substeps in parallel:
   1. Let browsingContext be the context object’s associated service worker client’s global object’s browsing context.
   2. If browsingContext has discarded its Document, reject promise with a TypeError and abort these steps.
   3. Let navigateFailed to false.
   4. Let visibilityState be null.
   5. Let focusState be null.
   6. Queue a task task to run the following substeps on the context object’s associated service worker client’s responsible event loop using the user interaction task source:
      1. HandleNavigate: Navigate browsingContext to url with replacement enabled and exceptions enabled. The source browsing context must be browsingContext.
      2. If the algorithm steps invoked in the step labeled HandleNavigate throws an exception, set navigateFailed to true.
      3. Set visibilityState to browsingContext’s active document’s visibilityState attribute value.
      4. Set focusState to the result of running the has focus steps with browsingContext’s active document as the argument.
   7. Wait for task to have executed (including its asynchronous steps).
   8. If navigateFailed is true, reject promise with a TypeError and abort these steps.
   9. If browsingContext’s Window object’s environment settings object’s creation url’s origin is not the same as the service worker’s origin, then:
      1. Resolve promise with null.
      2. Abort these steps.
   10. Let windowClient be the result of running Create Window Client algorithm, or its equivalent, with browsingContext’s Window object’s environment settings object, visibilityState and focusState as the arguments.
   11. Resolve promise with windowClient.
7. Return promise.

4.3.1. get(id)

The get(id) method must run these steps or their equivalent:

1. Let promise be a new promise.
2. Run these substeps in parallel:
   1. For each service worker client client whose origin is the same as the associated service worker’s origin:
      1. If client’s id is id, then:
         1. If client is not a secure context, reject promise with a "SecurityError" exception and abort these steps.
         2. If client is a window client, then:
            1. Let browsingContext be client’s global object’s browsing context.
            2. Let visibilityState be null.
            3. Let focusState be null.
            4. Queue a task task to run the following substeps:
               1. Set visibilityState to browsingContext’s active document’s visibilityState attribute value.
               2. Set focusState to the result of running the has focus steps with browsingContext’s active document as the argument.
            5. Wait for task to have executed.
            6. Let windowClient be the result of running Create Window Client algorithm, or its equivalent, with client, visibilityState and focusState as the arguments.
            7. Resolve promise with windowClient and abort these steps.
         3. Else:
            1. Let clientObject be the result of running Create Client algorithm, or its equivalent, with client as the argument.
            2. Resolve promise with clientObject and abort these steps.
   2. Resolve promise with undefined.
3. Return promise.

4.3.2. matchAll(options)

The matchAll(options) method must run these steps or their equivalent:

1. Let promise be a new promise.
2. Run these substeps in parallel:
   1. Let targetClients be an empty array.
   2. For each service worker client client whose origin is the same as the associated service worker’s origin:
      1. If client is not a secure context, continue to the next iteration of the loop.
      2. If options.includeUncontrolled is false, then:
         1. If client’s active worker is the associated service worker, add client to targetClients.
      3. Else:
         1. Add client to targetClients.
   3. Let matchedClients be an empty array.
   4. For each service worker client client in targetClients, in the most recently focused order for window clients:
      1. If options.type is "window", and client is a window client, then:
         1. Let browsingContext be client’s global object’s browsing context.
         2. Let visibilityState be null.
         3. Let focusState be null.
         4. Queue a task task to run the following substeps on client’s responsible event loop using the user interaction task source:
            1. Set visibilityState to browsingContext’s active document’s visibilityState attribute value.
            2. Set focusState to the result of running the has focus steps with browsingContext’s active document as the argument.
         5. Wait for task to have executed.

            Wait is a blocking wait, but implementers may run the iterations in parallel as long as the state is not broken.

         6. Let windowClient be the result of running Create Window Client algorithm, or its equivalent, with client, visibilityState and focusState as the arguments.
         7. Add windowClient to matchedClients.
      2. Else if options.type is "worker" and client is a dedicated worker client, or options.type is "sharedworker" and client is a shared worker client, then:
         1. Let clientObject be the result of running Create Client algorithm, or its equivalent, with client as the argument.
         2. Add clientObject to matchedClients.
      3. Else if options.type is "all", then:
         1. If client is a window client, then:
            1. Let browsingContext be client’s global object’s browsing context.
            2. Let visibilityState be null.
            3. Let focusState be null.
            4. Queue a task task to run the following substeps on client’s responsible event loop using the user interaction task source:
               1. Set visibilityState to browsingContext’s active document’s visibilityState attribute value.
               2. Set focusState to the result of running the has focus steps with browsingContext’s active document as the argument.
            5. Wait for task to have executed.

               Wait is a blocking wait, but implementers may run the iterations in parallel as long as the state is not broken.

            6. Let windowClient be the result of running Create Window Client algorithm, or its equivalent, with client, visibilityState and focusState as the arguments.
            7. Add windowClient to matchedClients.
         2. Else:
            1. Let clientObject be the result of running Create Client algorithm, or its equivalent, with client as the argument.
            2. Add clientObject to matchedClients.
   5. Resolve promise with matchedClients.
3. Return promise.

4.3.3. openWindow(url)

The openWindow(url) method must run these steps or their equivalent:

1. Let url be the result of parsing url with entry settings object’s API base URL.
2. If url is failure, return a promise rejected with a TypeError.
3. If url is about:blank, return a promise rejected with a TypeError.
4. If this algorithm is not triggered by user activation, return a promise rejected with an "<InvalidAccessError" exception.
5. Let promise be a new promise.
6. Run these substeps in parallel:
   1. Let newContext be a new top-level browsing context.
   2. Let openWindowFailed to false.
   3. Let visibilityState be null.
   4. Let focusState be null.
   5. Queue a task task to run the following substeps on newContext’s Window object’s environment settings object’s responsible event loop using the user interaction task source:
      1. HandleNavigate: Navigate newContext to url, with exceptions enabled and replacement enabled.
      2. If the algorithm steps invoked in the step labeled HandleNavigate throws an exception, set openWindowFailed to true.
      3. Set visibilityState to newContext’s active document’s visibilityState attribute value.
      4. Set focusState to the result of running the has focus steps with newContext’s active document as the argument.
   6. Wait for task to have executed (including its asynchronous steps).
   7. If openWindowFailed is true, reject promise with a TypeError and abort these steps.
   8. If newContext’s Window object’s environment settings object’s creation url’s origin is not the same as the service worker’s origin, then:
      1. Resolve promise with null.
      2. Abort these steps.
   9. Let client be the result of running Create Window Client algorithm, or its equivalent, with newContext’s Window object’s environment settings object, visibilityState and focusState as the arguments.
   10. Resolve promise with client.
7. Return promise.

4.3.4. claim()

The claim() method must run these steps or their equivalent:

1. If the service worker is not an active worker, return a promise rejected with an "InvalidStateError" exception.
2. Let promise be a new promise.
3. Run the following substeps in parallel:
   1. For each service worker client client whose origin is the same as the service worker’s origin:
      1. If client is not a secure context, continue to the next iteration of the loop.
      2. Let registration be the result of running Match Service Worker Registration algorithm passing client’s creation url as the argument.
      3. If registration is not the service worker’s containing service worker registration, continue to the next iteration of the loop.
      4. If client’s active worker is not the service worker, then:
         1. Invoke Handle Service Worker Client Unload with client as the argument.
         2. Set client’s active worker to service worker.
         3. Invoke Notify Controller Change algorithm with client as the argument.
   2. Resolve promise with undefined.
4. Return promise.

4.4.1. event.waitUntil(f)

waitUntil(f) method extends the lifetime of the event.

waitUntil(f) method must run these steps or their equivalent:

1. If the extensions allowed flag is unset, then:
   1. Throw an "InvalidStateError" exception.
   2. Abort these steps.
2. Add f to the extend lifetime promises.

4.5.1. event.request

request attribute must return the value it was initialized to.

4.5.2. event.clientId

clientId attribute must return the value it was initialized to. When an event is created the attribute must be initialized to null.

4.5.3. event.isReload

isReload attribute must return the value it was initialized to. When an event is created the attribute must be initialized to false.

Pressing the refresh button should be considered a reload while clicking a link and pressing the back button should not. The behavior of the Ctrl+l enter is left to the implementations of the user agents.

4.5.4. event.respondWith(r)

Developers can set the argument r with either a promise that resolves with a Response object or a Response object (which is automatically cast to a promise). Otherwise, a network error is returned to Fetch. Renderer-side security checks about tainting for cross-origin content are tied to the types of filtered responses defined in Fetch.

respondWith(r) method must run these steps or their equivalent:

1. If the dispatch flag is unset, then:
   1. Throw an "InvalidStateError" exception.
   2. Abort these steps.
2. If the respond-with entered flag is set, then:
   1. Throw an "InvalidStateError" exception.
   2. Abort these steps.
3. Add r to the extend lifetime promises.

   event.respondWith(r) extends the lifetime of the event by default as if event.waitUntil(r) is called.

4. Set the stop propagation flag and stop immediate propagation flag.
5. Set the respond-with entered flag.
6. Set the wait to respond flag.
7. Run the following substeps in parallel:
   1. Wait until r settles.
   2. If r rejected, then:
      1. Set the respond-with error flag.
   3. If r resolved with response, then:
      1. If response is a Response object, then:
         1. If response is disturbed or locked, then:
            1. Set the respond-with error flag.
         2. Else:
            1. Let potentialResponse be a copy of response’s associated response, except for its body.
            2. If response’s body is non-null, run these substeps:
               1. Set potentialResponse’s body to response’s body.
               2. Let dummyStream be an empty ReadableStream object.
               3. Set response’s body to a new body whose stream is dummyStream.
               4. Let reader be the result of getting a reader from dummyStream.
               5. Read all bytes from dummyStream with reader.

               These substeps are meant to produce the observable equivalent of "piping" response’s body’s stream into potentialResponse. That is, response is left with a body with a ReadableStream object that is disturbed and locked, while the data readable from potentialResponse’s body’s stream is now equal to what used to be response’s, if response’s original body is non-null.

               These substeps will be replaced by using pipe when the algorithm for pipeTo becomes stable.

            3. Set the potential response to potentialResponse.
      2. Else:
         1. Set the respond-with error flag.

         If the respond-with error flag is set, a network error is returned to Fetch through Handle Fetch algorithm. (See the step 21.1.) Otherwise, the value response is returned to Fetch through Handle Fetch algorithm. (See the step 22.1.)

   4. Unset the wait to respond flag.

4.6.1. event.data

The data attribute must return the value it was initialized to. When the object is created, this attribute must be initialized to null. It represents the message being sent.

4.6.2. event.origin

The origin attribute must return the value it was initialized to. When the object is created, this attribute must be initialized to the empty string. It represents the origin of the service worker client that sent the message.

4.6.3. event.lastEventId

The lastEventId attribute must return the value it was initialized to. When the object is created, this attribute must be initialized to the empty string.

4.6.4. event.source

The source attribute must return the value it was initialized to. When the object is created, this attribute must be initialized to null. It represents the Client object from which the message is sent.

4.6.5. event.ports

The ports attribute must return the value it was initialized to. When the object is created, this attribute must be initialized to null. It represents the MessagePort array being sent, if any.

5.3.1. caches

caches attribute must return the CacheStorage object that is associated with the context object.

5.4.1. match(request, options)

match(request, options) method must run these steps or their equivalent:

1. Let promise be a new promise.
2. Run these substeps in parallel:
   1. Let p be the result of running the algorithm specified in matchAll(request, options) method with request and options as the arguments.
   2. Wait until p settles.
   3. If p rejects with an exception, then:
      1. Reject promise with that exception.
   4. Else if p resolves with an array, responseArray, then:
      1. If responseArray is an empty array, then:
         1. Resolve promise with undefined.
      2. Else:
         1. Resolve promise with the first element of responseArray.
3. Return promise.

5.4.2. matchAll(request, options)

matchAll(request, options) method must run these steps or their equivalent:

1. Let r be null.
2. If the optional argument request is not omitted, then:
   1. If request is a Request object, then:
      1. Set r to request’s request.
      2. If r’s method is neither `GET` nor `HEAD` and options.ignoreMethod is false, return a promise resolved with an empty array.
   2. Else if request is a string, then:
      1. Set r to the associated request of the result of invoking the initial value of Request as constructor with request as its argument. If this throws an exception, return a promise rejected with that exception.
3. Let promise be a new promise.
4. Run these substeps in parallel:
   1. Let responseArray be an empty array.
   2. If the optional argument request is omitted, then:
      1. For each fetching record entry of its request to response map, in key insertion order:
         1. Add a copy of entry.[[value]] to responseArray.
      2. Resolve promise with responseArray.
      3. Abort these steps.
   3. Else:
      1. Let entries be the result of running Query Cache algorithm passing a Request object associated with r and options as the arguments.
      2. For each entry of entries:
         1. Let response be null.
         2. If the incumbent record incumbentRecord of the corresponding fetching record fetchingRecord in request to response map is not null, set response to a copy of incumbentRecord.[[value]].
         3. Else, set response to a copy of entry[1].
         4. If r’s method is `HEAD` and options.ignoreMethod is false, then:
            1. Let actualResponse be response’s associated response, if response’s associated response is not a filtered response, and to response’s associated response’s internal response otherwise.
            2. Set actualResponse’s body to null.
         5. Add response to responseArray.
      3. Resolve promise with responseArray.
5. Return promise.

5.4.3. add(request)

add(request) method must run these steps or their equivalent:

1. Let requests be an array containing only request.
2. Set responseArrayPromise to the result of running the algorithm specified in addAll(requests) passing requests as the argument.
3. Return the result of transforming responseArrayPromise with a fulfillment handler that returns undefined.

5.4.4. addAll(requests)

addAll(requests) method must run these steps or their equivalent:

1. Let responsePromiseArray be an empty array.
2. Let requestArray be an empty array.
3. For each request whose type is Request in requests:
   1. Let r be request’s request.
   2. If r’s url’s scheme is not one of "http" and "https", or r’s method is not `GET`, return a promise rejected with a TypeError.
4. For each request in requests:
   1. Let r be the associated request of the result of invoking the initial value of Request as constructor with request as its argument. If this throws an exception, return a promise rejected with that exception.
   2. If r’s url’s scheme is not one of "http" and "https", then:
      1. Terminate all the ongoing fetches initiated by requests with reason fatal.
      2. Break the loop.
   3. Set r’s initiator to "fetch" and destination to "subresource".
   4. Add a Request object associated with r to requestArray.
   5. Let responsePromise be a new promise.
   6. Run the following substeps in parallel:
      • Fetch r.
      • To process response for response, run these substeps:
        1. If response’s type is error, or response’s status is not an ok status, reject responsePromise with a TypeError.
        2. Else if response’s header list contains a header named `Vary`, then:
           1. Let varyHeaders be the array containing the elements corresponding to the field-values of the Vary header.
           2. Let matchAsterisk be false.
           3. For each f in varyHeaders:
              1. If f matches "*", set matchAsterisk to true and break the loop.
           4. If matchAsterisk is true, reject responsePromise with a TypeError.
           5. Else, resolve responsePromise with a new Response object associated with response and a new Headers object whose guard is "immutable".
        3. Else, resolve responsePromise with a new Response object associated with response and a new Headers object whose guard is "immutable".

        This step ensures that the promise for this fetch resolves as soon as the response’s headers become available.

      • To process response body for response, do nothing.
      • To process response end-of-file for response, do nothing.
   7. Add responsePromise to responsePromiseArray.
5. Let p be waiting for all of responsePromiseArray.
6. Return the result of transforming p with a fulfillment handler that, when called with argument responseArray, performs the following substeps in parallel:
   1. Let operations be an empty array.
   2. For each response in responseArray with the index index:
      1. Let o be an empty object representing a CacheBatchOperation dictionary.
      2. Set the type dictionary member of o to "put".
      3. Set the request dictionary member of o to requestArray[index].
      4. Set the response dictionary member of o to response.
      5. Add o to operations.
   3. Let resultPromise be the result of running Batch Cache Operations algorithm passing operations as the argument.
   4. Return the result of transforming resultPromise with a fulfillment handler that, when called with argument responses, performs the following substeps in parallel:
      1. Let responseBodyPromiseArray be an empty array.
      2. For each response in responses:
         1. Let responseBodyPromise be a new promise.
         2. Run the following substeps in parallel:
            1. Wait for either end-of-file to have been pushed to response’s associated response r’s body or for r to have a termination reason.
            2. If r had a termination reason, then:
               1. If the incumbent record incumbentRecord of the corresponding fetching record fetchingRecord in request to response map is not null, then:
                  1. Set fetchingRecord in request to response map to the copy of incumbentRecord.
               2. Else:
                  1. Delete fetchingRecord from request to response map.
               3. Reject responseBodyPromise with a TypeError.
            3. Else:
               1. Set the incumbent record of the corresponding fetching record fetchingRecord in request to response map to the copy of fetchingRecord.
               2. Let invalidRecords be the result of running Query Cache algorithm passing fetchingRecord.[[key]] as the argument.
               3. For each invalidRecord in invalidRecords:
                  1. If invalidRecord is not fetchingRecord, delete it from request to response map.
               4. Resolve responseBodyPromise with response.
         3. Add responseBodyPromise to responseBodyPromiseArray.
      3. Let q be waiting for all of responseBodyPromiseArray.
      4. Return the result of transforming q with a fulfillment handler that returns undefined.

5.4.5. put(request, response)

put(request, response) method must run these steps or their equivalent:

1. Let r be null.
2. If request is a Request object, then:
   1. Set r to request’s request.
   2. If r’s url’s scheme is not one of "http" and "https", or r’s method is not `GET`, return a promise rejected with a TypeError.
3. Else if request is a string, then:
   1. Set r to the associated request of the result of invoking the initial value of Request as constructor with request as its argument. If this throws an exception, return a promise rejected with that exception.
   2. If r’s url’s scheme is not one of "http" and "https", return a promise rejected with a TypeError.
4. If response’s associated response’s header list contains a header named `Vary`, then:
   1. Let varyHeaders be the array containing the elements corresponding to the field-values of the Vary header.
   2. For each f in varyHeaders:
      1. If f matches "*", return a promise rejected with a TypeError.
5. If response is disturbed or locked, return a promise rejected with a TypeError.
6. Let newResponse be a new Response object associated with response’s associated response and a new Headers object whose guard is response’s Headers' guard.
7. If response’s body is non-null, run these substeps:
   1. Let dummyStream be an empty ReadableStream object.
   2. Set response’s body to a new body whose stream is dummyStream.
   3. Let reader be the result of getting a reader from dummyStream.
   4. Read all bytes from dummyStream with reader.
8. Let operations be an empty array.
9. Let o be an empty object representing a CacheBatchOperation dictionary.
10. Set the type dictionary member of o to "put".
11. Set the request dictionary member of o to a Request object associated with r.
12. Set the response dictionary member of o to newResponse.
13. Add o to operations.
14. Let resultPromise be the result of running Batch Cache Operations passing operations as the argument.
15. Return the result of transforming resultPromise with a fulfillment handler that, when called with argument responses, performs the following substeps in parallel:
    1. Wait for either end-of-file to have been pushed to responses[0]'s associated response r’s body or for r to have a termination reason.
    2. If r had a termination reason, then:
       1. If the incumbent record incumbentRecord of the corresponding fetching record fetchingRecord in request to response map is not null, then:
          1. Set fetchingRecord in request to response map to the copy of incumbentRecord.
       2. Else:
          1. Delete fetchingRecord from request to response map.
       3. Throw a TypeError.
    3. Else:
       1. Set the incumbent record of the corresponding fetching record fetchingRecord in request to response map to the copy of fetchingRecord.
       2. Let invalidRecords be the result of running Query Cache algorithm passing fetchingRecord.[[key]] as the argument.
       3. For each invalidRecord in invalidRecords:
          1. If invalidRecord is not fetchingRecord, delete it from request to response map.
       4. Return undefined.

5.4.6. delete(request, options)

delete(request, options) method must run these steps or their equivalent:

1. Let r be null.
2. If request is a Request object, then:
   1. Set r to request’s request.
   2. If r’s method is neither `GET` nor `HEAD` and options.ignoreMethod is false, return a promise resolved with false.
3. Else if request is a string, then:
   1. Set r to the associated request of the result of invoking the initial value of Request as constructor with request as its argument. If this throws an exception, return a promise rejected with that exception.
4. Let operations be an empty array.
5. Let o be an empty object representing a CacheBatchOperation dictionary.
6. Set the type dictionary member of o to "delete".
7. Set the request dictionary member of o to a Request object associated with r.
8. Set the options dictionary member of o to options.
9. Add o to operations.
10. Let resultPromise be the result of running Batch Cache Operations passing operations as the argument.
11. Return the result of transforming resultPromise with a fulfillment handler, when called with argument responseArray, performs the following substeps in parallel:
    1. If responseArray is not null, return true.
    2. Else, return false.

5.4.7. keys(request, options)

keys(request, options) method must run these steps or their equivalent:

1. Let promise be a new promise.
2. Run these substeps in parallel:
   1. Let resultArray be an empty array.
   2. If the optional argument request is omitted, then:
      1. For each fetching record entry of its request to response map, in key insertion order:
         1. Add entry.[[key]] to resultArray.
   3. Else:
      1. Let r be null.
      2. If request is a Request object, then:
         1. Set r to request’s request.
         2. If r’s method is neither `GET` nor `HEAD` and options.ignoreMethod is false, resolve promise with an empty array.
      3. Else if request is a string, then:
         1. Set r to the associated request of the result of invoking the initial value of Request as constructor with request as its argument. If this throws an exception, return a promise rejected with that exception.
      4. Let requestResponseArray be the result of running Query Cache algorithm passing a Request object that represents r and options as the arguments.
      5. For each requestResponse in requestResponseArray:
         1. Add requestResponse[0] to resultArray.
   4. Resolve promise with resultArray.
3. Return promise.

5.5.1. match(request, options)

match(request, options) method must run these steps or their equivalent:

1. If options.cacheName is present, then:
   1. Return a new promise p and run the following substeps in parallel:
      1. For each Record {[[key]], [[value]]} entry of its name to cache map, in key insertion order:
         1. If options.cacheName matches entry.[[key]], then:
            1. Resolve p with the result of running the algorithm specified in match(request, options) method of Cache interface with request and options as the arguments (providing entry.[[value]] as thisArgument to the [[Call]] internal method of match(request, options).)
            2. Abort these steps.
      2. Resolve p with undefined.
2. Else:
   1. Let p be a promise resolved with undefined.
   2. For each Record {[[key]], [[value]]} entry of its name to cache map, in key insertion order:
      1. Set p to the result of transforming itself with a fulfillment handler that, when called with argument v, performs the following substeps in parallel:
         1. If v is not undefined, return v.
         2. Return the result of running the algorithm specified in match(request, options) method of Cache interface with request and options as the arguments (providing entry.[[value]] as thisArgument to the [[Call]] internal method of match(request, options).)
   3. Return p.

5.5.2. has(cacheName)

has(cacheName) method must run these steps or their equivalent:

1. Return a promise p resolved with the result of running the following substeps:
   1. For each Record {[[key]], [[value]]} entry of its name to cache map, in key insertion order:
      1. If cacheName matches entry.[[key]], then:
         1. Return true.
   2. Return false.

5.5.3. open(cacheName)

open(cacheName) method must run these steps or their equivalent:

1. Let p be a new promise.
2. Run the following substeps:
   1. For each Record {[[key]], [[value]]} entry of its name to cache map, in key insertion order:
      1. If cacheName matches entry.[[key]], then:
         1. Resolve p with a new Cache object which is a copy of entry.[[value]].
         2. Abort these steps.
   2. Let cache be a new Cache object.
   3. Set a newly-created Record {[[key]]: cacheName, [[value]]: cache} to name to cache map. If this cache write operation failed due to exceeding the granted quota limit, reject p with a "QuotaExceededError" exception and abort these steps.
   4. Resolve p with cache.
3. Return p.

5.5.4. delete(cacheName)

delete(cacheName) method must run these steps or their equivalent:

1. Let p be the result of running the algorithm specified in has(cacheName) method with cacheName as the argument.
2. Return the result of transforming p with a fulfillment handler that, when called with argument cacheExists, performs the following substeps in parallel:
   1. If cacheExists is true, then:
      1. Delete a Record {[[key]], [[value]]} entry from its name to cache map where cacheName matches entry.[[key]].
      2. Return true.
      3. Abort these steps.

      After this step, the existing DOM objects (i.e. the currently referenced Cache, Request, and Response objects) should remain functional.

   2. Else:
      1. Return false.

5.5.5. keys()

keys() method must run these steps or their equivalent:

The promise returned from this method resolves with the sequence of keys, cache names in DOMString, in insertion order.

1. Let resultArray be an empty array.
2. Return a promise p resolved with the result of running the following substeps:
   1. For each Record {[[key]], [[value]]} entry of its name to cache map, in key insertion order:
      1. Add entry.[[key]] to resultArray.
   2. Return resultArray.

6.3.1. Origin restriction

This section is non-normative.

A Service worker executes in the registering service worker client’s origin. One of the advanced concerns that major applications would encounter is whether they can be hosted from a CDN. By definition, these are servers in other places, often on other origins. Therefore, service workers cannot be hosted on CDNs. But they can include resources via importScripts(). The reason for this restriction is that service workers create the opportunity for a bad actor to turn a bad day into a bad eternity.

6.3.2. importScripts(urls)

When the importScripts(urls) method is called on a ServiceWorkerGlobalScope object, the user agent must import scripts into worker global scope, with the following options:

To validate the state, the user agent must do nothing.

To get a fetch result, the user agent must run the following steps:

1. Let serviceWorker be the settings object’s global object’s service worker.
2. If serviceWorker’s imported scripts updated flag is unset, then:
   1. Attempt to fetch each resource identified by the resulting absolute URLs, from the origin specified by settings object, using the referrer source specified by settings object, and with the blocking flag set.
3. Else:
   1. If there exists a corresponding Record record for url in serviceWorker’s script resource map, set the script resource to record.[[value]].
   2. Else, set the script resource to null.

To postprocess the fetch result, the user agent must run the following steps:

1. If serviceWorker’s imported scripts updated flag is unset, then:
   1. If the fetching attempt failed (e.g. the server returned a 4xx or 5xx status code or equivalent, or there was a DNS error), throw a "NetworkError" exception and abort all these steps.
   2. Else:
      1. If there exists a corresponding Record record for the resulting absolute URL url in serviceWorker’s script resource map, set record.[[value]] to the fetched script resource.
      2. Else, set a newly-created Record {[[key]]: url, [[value]]: the fetched script resource} to serviceWorker’s script resource map.
2. Else, if the script resource is null, throw a "NetworkError" exception and abort all these steps.

8.1. Define API bound to Service Worker Registration

Specifications may define an API tied to a service worker registration by using partial interface definition to the ServiceWorkerRegistration interface where it may define the specification specific attributes and methods:

partial interface ServiceWorkerRegistration {
  // e.g. define an API namespace
  readonly attribute APISpaceType APISpace;
  // e.g. define a method
  Promise<T> methodName(list of arguments);
};

8.2. Define Functional Event

Specifications may define a functional event by extending ExtendableEvent interface:

// e.g. define FunctionalEvent interface
interface FunctionalEvent : ExtendableEvent {
  // add a functional event’s own attributes and methods
};

8.3. Define Event Handler

Specifications may define an event handler attribute for the corresponding functional event using partial interface definition to the ServiceWorkerGlobalScope interface:

partial interface ServiceWorkerGlobalScope {
  attribute EventHandler onfunctionalevent;
};

8.4. Request Functional Event Dispatch

To request a functional event dispatch to a service worker, specifications may invoke Handle Functional Event algorithm, or its equivalent, with its service worker registration registration and the algorithm callbackSteps as the arguments.

Specifications may define an algorithm callbackSteps where the corresponding functional event can be created and fired with specification specific objects. The algorithm is passed globalObject (a ServiceWorkerGlobalScope object) at which it may fire its functional events. This algorithm is called on a task queued by Handle Functional Event algorithm.

See an example hook defined in Notifications API.

Create Job

Input

jobType, a job type

scopeURL, a URL

scriptURL, a URL

promise, a promise

client, a service worker client

Output

job, a job

1. Let job be a new job.
2. Set job’s job type to jobType.
3. Set job’s scope url to scopeURL.
4. Set job’s script url to scriptURL.
5. Set job’s promise to promise.
6. Set job’s client to client.
7. Return job.

Schedule Job

Input

job, a job

Output

none

1. If the job queue is empty, then:
   1. Push job to the job queue and invoke Run Job.
2. Else:
   1. Let lastJob be the element at the back of the job queue.
   2. If job is equivalent to lastJob and lastJob’s promise has not settled, append job to lastJob’s list of equivalent jobs.
   3. Else, push job to the job queue.

Run Job

Input

none

Output

none

1. Assert: the job queue is not empty.
2. Queue a task to run these steps:
   1. Let job be the element in the front of the job queue.
   2. If job’s job type is register, run Register with job in parallel.
   3. Else if job’s job type is update, run Update with job in parallel.

      For a register job and an update job, the user agent delays queuing a task for running the job until after the document initiated the job has been dispatched DOMContentLoaded event.

   4. Else if job’s job type is unregister, run Unregister with job in parallel.

Finish Job

Input

job, a job

Output

none

1. Assert: the top element in the job queue is job.
2. Pop the top element from the job queue.
3. If the job queue is not empty, invoke Run Job with the top element of the job queue.

Resolve Job Promise

Input

job, a job

value, any

Output

none

1. If job’s client is not null, queue a task to resolve job’s promise with value on job’s client’s responsible event loop using the DOM manipulation task source as the task source.
2. For each equivalentJob in job’s list of equivalent jobs:
   1. If equivalentJob’s client is not null, queue a task to resolve equivalentJob’s promise with value on equivalentJob’s client’s responsible event loop using the DOM manipulation task source as the task source.

Reject Job Promise

Input

job, a job

reason, an exception

Output

none

1. If job’s client is not null, queue a task to reject job’s promise with reason on job’s client’s responsible event loop using the DOM manipulation task source as the task source.
2. For each equivalentJob in job’s list of equivalent jobs:
   1. If equivalentJob’s client is not null, queue a task to reject equivalentJob’s promise with reason on equivalentJob’s client’s responsible event loop using the DOM manipulation task source as the task source.

Register

Input

job, a job

Output

promise, a promise

1. If the result of running Is origin potentially trustworthy with the origin of job’s script url as the argument is Not Trusted, then:
   1. Invoke Reject Job Promise with job and a "SecurityError" exception.
   2. Invoke Finish Job with job and abort these steps.
2. If the origin of job’s script url is not job’s client’s origin, then:
   1. Invoke Reject Job Promise with job and a "SecurityError" exception.
   2. Invoke Finish Job with job and abort these steps.
3. If the origin of job’s scope url is not job’s client’s origin, then:
   1. Invoke Reject Job Promise with job and a "SecurityError" exception.
   2. Invoke Finish Job with job and abort these steps.
4. Let registration be the result of running the Get Registration algorithm passing job’s scope url as the argument.
5. If registration is not null, then:
   1. If registration’s uninstalling flag is set, unset it.
   2. Let newestWorker be the result of running the Get Newest Worker algorithm passing registration as the argument.
   3. If newestWorker is not null and job’s script url equals newestWorker’s script url with the exclude fragments flag set, then:
      1. If newestWorker is an active worker, then:
         1. Invoke Resolve Job Promise with job and the ServiceWorkerRegistration object which represents registration.
         2. Invoke Finish Job with job and abort these steps.
6. Else:
   1. Invoke Set Registration algorithm passing job’s scope url as its argument.
7. Invoke Update algorithm, or its equivalent, passing job as the argument.

Update

Input

job, a job

Output

none

1. Let registration be the result of running the Get Registration algorithm passing job’s scope url as the argument.
2. If registration is null or registration’s uninstalling flag is set, then:
   1. Invoke Reject Job Promise with job and a TypeError.
   2. Invoke Finish Job with job and abort these steps.
3. Let newestWorker be the result of running Get Newest Worker algorithm passing registration as the argument.
4. If job’s job type is update, and newestWorker’s script url does not equal job’s script url with the exclude fragments flag set, then:
   1. Invoke Reject Job Promise with job and a TypeError.
   2. Invoke Finish Job with job and abort these steps.
5. Let r be the associated request of the result of invoking the initial value of Request as constructor with job’s serialized script url. If this throws an exception, then:
   1. Invoke Reject Job Promise with job and the exception.
   2. If newestWorker is null, invoke Clear Registration algorithm passing registration as its argument.
   3. Invoke Finish Job with job and abort these steps.
6. Set r’s initiator to "" and destination to "serviceworker".
7. Set r’s client to job’s client.
8. Append `Service-Worker`/`script` to r’s header list.

   See the definition of the Service-Worker header in Appendix B: Extended HTTP headers.

9. Set r’s skip service worker flag, r’s synchronous flag, and r’s redirect mode to "error".
10. If newestWorker is not null and registration’s last update check time is not null, then:
    1. If the time difference in seconds calculated by the current time minus registration’s last update check time is greater than 86400, or force bypass cache flag is set, set r’s cache mode to "reload".

    Even if the cache mode is not set to "reload", the user agent obeys Cache-Control header’s max-age value in the network layer to determine if it should bypass the browser cache.

11. Let response be the result of running fetch using r.
12. If response is a network error or response’s status is not in the range 200 to 299, then:
    1. Invoke Reject Job Promise with job and a TypeError.
    2. If newestWorker is null, invoke Clear Registration algorithm passing registration as its argument.
    3. Invoke Finish Job with job and abort these steps.
13. Extract a MIME type from the response’s header list. If this MIME type (ignoring parameters) is not one of text/javascript, application/x-javascript, and application/javascript, then:
    1. Invoke Reject Job Promise with job and a "SecurityError" exception.
    2. If newestWorker is null, invoke Clear Registration algorithm passing registration as its argument.
    3. Invoke Finish Job with job and abort these steps.
14. Let serviceWorkerAllowed be the result of parsing `Service-Worker-Allowed` in response’s header list.

    See the definition of the Service-Worker-Allowed header in Appendix B: Extended HTTP headers.

15. If serviceWorkerAllowed is failure, then:
    1. Invoke Reject Job Promise with job and a TypeError.
    2. If newestWorker is null, invoke Clear Registration algorithm passing registration as its argument.
    3. Invoke Finish Job with job and abort these steps.
16. Let scopeURL be registration’s scope url.
17. Let maxScopeString be null.
18. If serviceWorkerAllowed is null, then:
    1. Set maxScopeString to "/" concatenated with the strings, except the last string that denotes the script’s file name, in job’s script url’s path (including empty strings), separated from each other by "/".
19. Else:
    1. Let maxScope be the result of parsing serviceWorkerAllowed with job’s script url.
    2. Set maxScopeString to "/" concatenated with the strings in maxScope’s path (including empty strings), separated from each other by "/".
20. Let scopeString be "/" concatenated with the strings in scopeURL’s path (including empty strings), separated from each other by "/".
21. If scopeString starts with maxScopeString, do nothing.
22. Else:
    1. Invoke Reject Job Promise with job and a "SecurityError" exception.
    2. If newestWorker is null, invoke Clear Registration algorithm passing registration as its argument.
    3. Invoke Finish Job with job and abort these steps.
23. If response’s cache state is not "local", set registration’s last update check time to the current time.
24. If newestWorker is not null, newestWorker’s script url equals job’s script url with the exclude fragments flag set, and response is a byte-for-byte match with the script resource of newestWorker, then:
    1. Invoke Resolve Job Promise with job and the ServiceWorkerRegistration object which represents registration.
    2. Invoke Finish Job with job and abort these steps.
25. Else:
    1. Let worker be a new service worker.
    2. Generate a unique opaque string and set worker’s id to the value.
    3. Set worker’s script url to job’s script url, worker’s script resource to the script resource retrieved from the fetched response.
    4. Invoke Run Service Worker algorithm with worker as the argument.
    5. If an uncaught runtime script error occurs during the above step, then:
       1. Invoke Reject Job Promise with job and a TypeError.
       2. If newestWorker is null, invoke Clear Registration algorithm passing registration as its argument.
       3. Invoke Finish Job with job and abort these steps.
26. Invoke Install algorithm, or its equivalent, with job, worker, and registration as its arguments.

Soft Update

The user agent may call this as often as it likes to check for updates.

Input

registration, a service worker registration

force bypass cache flag, an optional flag unset by default

Implementers may use the force bypass cache flag to aid debugging (e.g. invocations from developer tools), and other specifications that extend service workers may also use the flag on their own needs.

Output

None

1. Let newestWorker be the result of running Get Newest Worker algorithm passing registration as its argument.
2. If newestWorker is null, abort these steps.
3. Let job be the result of running Create Job with update, registration’s scope url, newestWorker’s script url, null, and null.
4. Set job’s force bypass cache flag if its force bypass cache flag is set.
5. Invoke Schedule Job with job.

Install

Input

job, a job

worker, a service worker

registration, a service worker registration

Output

none

1. Let installFailed be false.
2. Let newestWorker be the result of running Get Newest Worker algorithm passing registration as its argument.
3. Let redundantWorker be null.
4. Run the Update Registration State algorithm passing registration, "installing" and worker as the arguments.
5. Run the Update Worker State algorithm passing registration’s installing worker and installing as the arguments.
6. Assert: job’s promise is not null.
7. Invoke Resolve Job Promise with job and the ServiceWorkerRegistration object which represents registration.
8. Queue a task to fire a simple event named updatefound at all the ServiceWorkerRegistration objects for all the service worker clients whose creation url matches registration’s scope url and all the service workers whose containing service worker registration is registration.
9. Let installingWorker be registration’s installing worker.
10. Invoke Run Service Worker algorithm with installingWorker as the argument.
11. Queue a task task to run the following substeps:
    1. Create a trusted event e that uses the ExtendableEvent interface, with the event type install, which does not bubble, is not cancelable, and has no default action.
    2. Dispatch e at installingWorker’s environment settings object’s global object globalObject.
    3. For each event listener invoked:
       1. If any uncaught runtime script error occurs, then:
          1. Report the error for the script per the runtime script errors handling.
          2. Set redundantWorker to registration’s installing worker.
          3. Run the Update Registration State algorithm passing registration, "installing" and null as the arguments.
          4. Run the Update Worker State algorithm passing redundantWorker and redundant as the arguments.
          5. If newestWorker is null, invoke Clear Registration algorithm passing registration as its argument.
          6. Invoke Finish Job with job and abort these steps.
    4. Let p be waiting for all of e’s extend lifetime promises.
    5. Run the following substeps in parallel:
       1. Wait until p settles.
       2. If p rejected, set installFailed to true.
       3. Else if p resolved with a value, do nothing.

    If task is discarded or the script has been aborted by the termination of installingWorker, set installFailed to true.

12. Wait for task to have executed or been discarded.
13. If installFailed is true, then:
    1. Set redundantWorker to registration’s installing worker.
    2. Run the Update Registration State algorithm passing registration, "installing" and null as the arguments.
    3. Run the Update Worker State algorithm passing redundantWorker and redundant as the arguments.
    4. If newestWorker is null, invoke Clear Registration algorithm passing registration as its argument.
    5. Invoke Finish Job with job and abort these steps.
14. Set registration’s installing worker’s imported scripts updated flag.
15. If registration’s waiting worker is not null, then:
    1. Set redundantWorker to registration’s waiting worker.
    2. Terminate redundantWorker.
    3. The user agent may abort in-flight requests triggered by redundantWorker.
16. Run the Update Registration State algorithm passing registration, "waiting" and registration’s installing worker as the arguments.
17. Run the Update Registration State algorithm passing registration, "installing" and null as the arguments.
18. Run the Update Worker State algorithm passing registration’s waiting worker and installed as the arguments.
19. If redundantWorker is not null, run the Update Worker State algorithm passing redundantWorker and redundant as the arguments.
20. If registration’s waiting worker’s skip waiting flag is set, then:
    1. Run Activate algorithm, or its equivalent, passing registration as the argument.
    2. Invoke Finish Job with job and abort these steps.
21. Invoke Finish Job with job.
22. Wait for all the tasks queued by Update Worker State invoked in this algorithm have executed.
23. Wait until no service worker client is using registration or registration’s waiting worker’s skip waiting flag is set.
24. If registration’s waiting worker waitingWorker is not null and waitingWorker’s skip waiting flag is not set, invoke Activate algorithm, or its equivalent, with registration as its argument.

Activate

Input

registration, a service worker registration

Output

None

1. If registration’s waiting worker is null, abort these steps.
2. Let redundantWorker be null.
3. If registration’s active worker is not null, then:
   1. Set redundantWorker to registration’s active worker.
   2. Wait for redundantWorker to finish handling any in-progress requests.
   3. Terminate redundantWorker.
4. Run the Update Registration State algorithm passing registration, "active" and registration’s waiting worker as the arguments.
5. Run the Update Registration State algorithm passing registration, "waiting" and null as the arguments.
6. Run the Update Worker State algorithm passing registration’s active worker and activating as the arguments.

   Once an active worker is activating, neither a runtime script error nor a force termination of the active worker prevents the active worker from getting activated.

7. If redundantWorker is not null, run the Update Worker State algorithm passing redundantWorker and redundant as the arguments.
8. For each service worker client client whose creation url matches registration’s scope url:
   1. If client is a window client, unassociate client’s responsible document from its application cache, if it has one.
   2. Else if client is a shared worker client, unassociate client’s global object from its application cache, if it has one.

   Resources will now use the service worker registration instead of the existing application cache.

9. For each service worker client client who is using registration:
   1. Set client’s active worker to registration’s active worker.
   2. Invoke Notify Controller Change algorithm with client as the argument.
10. Let activeWorker be registration’s active worker.
11. Invoke Run Service Worker algorithm with activeWorker as the argument.
12. Queue a task task to run the following substeps:
    1. Create a trusted event e that uses the ExtendableEvent interface, with the event type activate, which does not bubble, is not cancelable, and has no default action.
    2. Dispatch e at activeWorker’s environment settings object’s global object.
    3. For each event listener invoked:
       1. If any uncaught runtime script error occurs, report the error for the script per the runtime script errors handling.
    4. Let p be waiting for all of e’s extend lifetime promises.
13. Wait for task to have executed and p defined in task has settled, or task to have been discarded or the script to have been aborted by the termination of activeWorker.
14. Run the Update Worker State algorithm passing registration’s active worker and activated as the arguments.

Run Service Worker

Input

serviceWorker, a service worker

Output

None

1. Assert: serviceWorker has the script resource successfully fetched against its script url.
2. If serviceWorker is already running, abort these steps.
3. Let workerGlobalScope be a new ServiceWorkerGlobalScope object.
4. Let workerEventLoop be a newly created event loop.
5. If serviceWorker is an active worker, and there are any tasks queued in serviceWorker’s containing service worker registration’s task queues, queue them to serviceWorker’s event loop’s task queues in the same order using their original task sources.
6. Let settingsObject be a new environment settings object whose algorithms are defined as follows:

   The script execution environments

   When the environment settings object is created, for each language supported by the user agent, create an appropriate execution environment as defined by the relevant specification.

   When a script execution environment is needed, return the appropriate one from those created when the environment settings object was created.

   The global object

   Return workerGlobalScope.

   The responsible event loop

   Return workerEventLoop.

   The referrer source

   Return serviceWorker’s script url.

   The API URL character encoding

   Return UTF-8.

   The API base URL

   Return serviceWorker’s script url.

   The origin and effective script origin

   Return its registering service worker client’s origin.

7. Create a separate parallel execution environment (i.e. a separate thread or process or equivalent construct), and run the rest of these steps in that context.
8. Let source be the result of running the UTF-8 decode algorithm on serviceWorker’s script resource scriptResource.
9. Let language be JavaScript.
10. In the newly created execution environment, create a JavaScript global environment whose global object is workerGlobalScope. (The JavaScript global environment whose global object is a ServiceWorkerGlobalScope object is defined as the service worker environment, which is a type of worker environments.)
11. Let script be a new script.
12. Obtain the appropriate script execution environment for the scripting language language from settingsObject.
13. Parse/compile/initialize source using that script execution environment, as appropriate for language, and thus obtain a code entry-point. If the script was not compiled successfully, let the code entry-point be a no-op script, and act as if a corresponding uncaught script error had occurred.
14. Let script’s settings object be settingsObject.
15. Jump to the script’s code entry-point, and let that run until it either returns, fails to catch an exception, or gets aborted by the kill a worker or Terminate Service Worker algorithms.
16. If scriptResource’s has ever been evaluated flag is unset, then:
    1. Set workerGlobalScope’s associated service worker’s set of event types to handle to the set of event types created from settingsObject’s global object’s associated list of event listeners' event types.

       If the global object’s associated list of event listeners does not have any event listener added at this moment, the service worker’s set of event types to handle is set to an empty set. The user agents are encouraged to show a warning that the event listeners must be added on the very first evaluation of the worker script.

    2. Set scriptResource’s has ever been evaluated flag.
17. Run the responsible event loop specified by settingsObject until it is destroyed.
18. Empty workerGlobalScope’s list of active timers.

Terminate Service Worker

Input

serviceWorker, a service worker

Output

None

1. If serviceWorker is not running, abort these steps.
2. Let serviceWorkerGlobalScope be serviceWorker’s environment settings object’s global object.
3. Set serviceWorkerGlobalScope’s closing flag to true.
4. If there are any tasks, whose task source is either the handle fetch task source or the handle functional event task source, queued in serviceWorkerGlobalScope’s event loop’s task queues, queue them to serviceWorker’s containing service worker registration’s corresponding task queues in the same order using their original task sources, and discard all the tasks (including tasks whose task source is neither the handle fetch task source nor the handle functional event task source) from serviceWorkerGlobalScope’s event loop’s task queues without processing them.

   This effectively means that the fetch events and the other functional events such as push events are backed up by the registration’s task queues while the other tasks including message events are discarded.

5. Abort the script currently running in serviceWorker.

Handle Fetch

The Handle Fetch algorithm is the entry point for the fetch handling handed to the service worker context.

Input

request, a request

Output

response, a response

1. Let handleFetchFailed be false.
2. Let respondWithEntered be false.
3. Let eventCanceled be false.
4. Let r be a new Request object associated with request.
5. Let headersObject be r’s headers attribute value.
6. Set headersObject’s guard to immutable.
7. Let response be null.
8. Let registration be null.
9. Let client be the service worker client that corresponds to request’s client.
10. Assert: request’s destination is not "serviceworker".
11. If request is a potential-navigation-or-subresource request, then:
    1. Return null.
12. Else if request is a non-subresource request, then:

    If the non-subresource request is under the scope of a service worker registration, application cache is completely bypassed regardless of whether the non-subresource request uses the service worker registration.

    1. If client is not a secure context, return null.
    2. If request is a navigation request and the navigation triggering it was initiated with a shift+reload or equivalent, return null.
    3. Set registration to the result of running Match Service Worker Registration algorithm, or its equivalent, passing request’s url as the argument.
    4. If registration is null or registration’s active worker is null, return null.
    5. Set client’s active worker to registration’s active worker.

    From this point, the service worker client starts to use its active worker’s containing service worker registration.

13. Else if request is a subresource request, then:
    1. If client’s active worker is non-null, set registration to client’s active worker’s containing service worker registration.
    2. Else, return null.
14. Let activeWorker be registration’s active worker.
15. If activeWorker’s set of event types to handle does not contain fetch, return null.

    To avoid unnecessary delays, the Handle Fetch enforces early return when no event listeners have been deterministically added in the service worker’s global during the very first script execution.

16. If activeWorker’s state is activating, wait for activeWorker’s state to become activated.
17. Invoke Run Service Worker algorithm with activeWorker as the argument.
18. Queue a task task to run the following substeps:
    1. Create a trusted event e that uses the FetchEvent interface, with the event type fetch, which does not bubble and has no default action.
    2. Let the request attribute of e be initialized to r.
    3. Let the clientId attribute of e be initialized to client’s id if request is not a non-subresource request, and to null otherwise.
    4. Let the isReload attribute of e be initialized to true if request’s client is a window client and the event was dispatched with the user’s intention for the page reload, and false otherwise.
    5. Dispatch e at activeWorker’s environment settings object’s global object.
    6. For each event listener invoked:
       1. If any uncaught runtime script error occurs, then:
          1. Report the error for the script per the runtime script errors handling.
          2. Abort these steps.
    7. If e’s respond-with entered flag is set, set respondWithEntered to true.
    8. If e’s wait to respond flag is set, then:
       1. Wait until e’s wait to respond flag is unset.
       2. If e’s respond-with error flag is set, set handleFetchFailed to true.
       3. Else, set response to e’s potential response.
    9. If e’s canceled flag is set, set eventCanceled to true.

    If task is discarded or the script has been aborted by the termination of activeWorker, set handleFetchFailed to true.

    The task must use activeWorker’s event loop and the handle fetch task source.

19. Wait for task to have executed or been discarded.
20. If respondWithEntered is false, then:
    1. If eventCanceled is true, return a network error and continue running these substeps in parallel.
    2. Else, return null and continue running these substeps in parallel.
    3. If request is a non-subresource request, or request is a subresource request and the time difference in seconds calculated by the current time minus registration’s last update check time is greater than 86400, invoke Soft Update algorithm, or its equivalent, with registration.
    4. Abort these steps.
21. If handleFetchFailed is true, then:
    1. Return a network error and continue running these substeps in parallel.
    2. If request is a non-subresource request, or request is a subresource request and the time difference in seconds calculated by the current time minus registration’s last update check time is greater than 86400, invoke Soft Update algorithm, or its equivalent, with registration.
22. Else:
    1. Return response and continue running these substeps in parallel.
    2. If request is a non-subresource request, or request is a subresource request and the time difference in seconds calculated by the current time minus registration’s last update check time is greater than 86400, invoke Soft Update algorithm, or its equivalent, with registration.

Handle Functional Event

Input

registration, a service worker registration

callbackSteps, an algorithm

Output

None

1. Assert: a Record with the [[value]] equals to registration is contained in scope to registration map.
2. Assert: registration’s active worker is not null.
3. Let activeWorker be registration’s active worker.
4. If activeWorker’s set of event types to handle does not contain the event type for this functional event, return.

   To avoid unnecessary delays, the Handle Functional Event enforces early return when no event listeners have been deterministically added in the service worker’s global during the very first script execution.

5. If activeWorker’s state is activating, wait for activeWorker’s state to become activated.
6. Invoke Run Service Worker algorithm with activeWorker as the argument.
7. Queue a task task to invoke callbackSteps with activeWorker’s environment settings object’s global object as its argument.

   The task must use activeWorker’s event loop and the handle functional event task source.

8. Wait for task to have executed or been discarded.
9. If the time difference in seconds calculated by the current time minus registration’s last update check time is greater than 86400, invoke Soft Update algorithm, or its equivalent, with registration.

Handle Service Worker Client Unload

The user agent must run these steps, or their equivalent, when a service worker client unloads by unloading, being killed, or terminating.

Input

client, a service worker client

Output

None

1. Run the following steps atomically.
2. Let registration be the service worker registration used by client.
3. If registration is null, abort these steps.
4. If any other service worker client is using registration, abort these steps.
5. If registration’s uninstalling flag is set, invoke Clear Registration algorithm passing registration as its argument and abort these steps.
6. If registration’s waiting worker is not null, run Activate algorithm, or its equivalent, with registration as the argument.

Handle User Agent Shutdown

Input

None

Output

None

1. For each Record {[[key]], [[value]]} entry of its scope to registration map:
   1. Let registration be entry.[[value]].
   2. If registration’s installing worker installingWorker is not null, then:
      1. If the result of running Get Newest Worker with registration is installingWorker, invoke Clear Registration with registration and continue to the next iteration of the loop.
      2. Else, set registration’s installing worker to null.
   3. If registration’s waiting worker is not null, run the following substep in parallel:
      1. Invoke Activate with registration.

Unregister

Input

job, a job

Output

none

1. If the origin of job’s scope url is not job’s client’s origin, then:
   1. Invoke Reject Job Promise with job and a "SecurityError" exception.
   2. Invoke Finish Job with job and abort these steps.
2. Let registration be the result of running Get Registration algorithm passing job’s scope url as the argument.
3. If registration is null, then:
   1. Invoke Resolve Job Promise with job and false.
   2. Invoke Finish Job with job and abort these steps.
4. Set registration’s uninstalling flag.
5. Invoke Resolve Job Promise with job and true.
6. If no service worker client is using registration, then:
   1. If registration’s uninstalling flag is unset, invoke Finish Job with job and abort these steps.
   2. Invoke Clear Registration algorithm passing registration as its argument.

   When the registration is being used for a client, the deletion of the registration is handled by the Handle Service Worker Client Unload algorithm.

7. Invoke Finish Job with job.

Set Registration

Input

scope, a URL

Output

registration, a service worker registration

1. Run the following steps atomically.
2. Let scopeString be serialized scope with the exclude fragment flag set.
3. Let registration be a new service worker registration whose scope url is set to scope.
4. Set a newly-created Record {[[key]]: scopeString, [[value]]: registration} to scope to registration map.
5. Return registration.

Clear Registration

Input

registration, a service worker registration

Output

None

1. Run the following steps atomically.
2. Let redundantWorker be null.
3. If registration’s installing worker is not null, then:
   1. Set redundantWorker to registration’s installing worker.
   2. Terminate redundantWorker.
   3. The user agent may abort in-flight requests triggered by redundantWorker.
   4. Run the Update Registration State algorithm passing registration, "installing" and null as the arguments.
   5. Run the Update Worker State algorithm passing redundantWorker and redundant as the arguments.
4. If registration’s waiting worker is not null, then:
   1. Set redundantWorker to registration’s waiting worker.
   2. Terminate redundantWorker.
   3. The user agent may abort in-flight requests triggered by redundantWorker.
   4. Run the Update Registration State algorithm passing registration, "waiting" and null as the arguments.
   5. Run the Update Worker State algorithm passing redundantWorker and redundant as the arguments.
5. If registration’s active worker is not null, then:
   1. Set redundantWorker to registration’s active worker.
   2. Terminate redundantWorker.
   3. The user agent may abort in-flight requests triggered by redundantWorker.
   4. Run the Update Registration State algorithm passing registration, "active" and null as the arguments.
   5. Run the Update Worker State algorithm passing redundantWorker and redundant as the arguments.
6. Delete a Record {[[key]], [[value]]} entry from scope to registration map where registration’s scope url is the result of parsing entry.[[key]].

Update Registration State

Input

registration, a service worker registration

target, a string (one of "installing", "waiting", and "active")

source, a service worker or null

Output

None

1. Let registrationObjects be an array containing all the ServiceWorkerRegistration objects associated with registration.
2. If target is "installing", then:
   1. Set registration’s installing worker to source.
   2. For each registrationObject in registrationObjects:
      1. Queue a task to set the installing attribute of registrationObject to the ServiceWorker object that represents registration’s installing worker, or null if registration’s installing worker is null.
3. Else if target is "waiting", then:
   1. Set registration’s waiting worker to source.
   2. For each registrationObject in registrationObjects:
      1. Queue a task to set the waiting attribute of registrationObject to the ServiceWorker object that represents registration’s waiting worker, or null if registration’s waiting worker is null.
4. Else if target is "active", then:
   1. Set registration’s active worker to source.
   2. For each registrationObject in registrationObjects:
      1. Queue a task to set the active attribute of registrationObject to the ServiceWorker object that represents registration’s active worker, or null if registration’s active worker is null.

   The task must use registrationObject’s relevant settings object’s responsible event loop and the DOM manipulation task source.

Update Worker State

Input

worker, a service worker

state, a service worker’s state

Output

None

1. Set worker’s state to state.
2. Let workerObjects be an array containing all the ServiceWorker objects associated with worker.
3. For each workerObject in workerObjects:
   1. Queue a task to run these substeps:
      1. Set the state attribute of workerObject to the value (in ServiceWorkerState enumeration) corresponding to the first matching statement, switching on worker’s state:

         installing

         "installing"

         The service worker in this state is considered an installing worker. During this state, event.waitUntil(f) can be called inside the oninstall event handler to extend the life of the installing worker until the passed promise resolves successfully. This is primarily used to ensure that the service worker is not active until all of the core caches are populated.

         installed

         "installed"

         The service worker in this state is considered a waiting worker.

         activating

         "activating"

         The service worker in this state is considered an active worker. During this state, event.waitUntil(f) can be called inside the onactivate event handler to extend the life of the active worker until the passed promise resolves successfully. No functional events are dispatched until the state becomes activated.

         activated

         "activated"

         The service worker in this state is considered an active worker ready to handle functional events.

         redundant

         "redundant"

         A new service worker is replacing the current service worker, or the current service worker is being discarded due to an install failure.

      2. Fire a simple event named statechange at workerObject.

   The task must use workerObject’s relevant settings object’s responsible event loop and the DOM manipulation task source.

Notify Controller Change

Input

client, a service worker client

Output

None

1. Assert: client is not null.
2. Queue a task to fire a simple event named controllerchange at the ServiceWorkerContainer object client is associated with.

The task must use client’s responsible event loop and the DOM manipulation task source.

Match Service Worker Registration

Input

clientURL, a URL

Output

registration, a service worker registration

1. Run the following steps atomically.
2. Let clientURLString be serialized clientURL.
3. Let matchingScope be the empty string.
4. Set matchingScope to the longest [[key]] in scope to registration map which the value of clientURLString starts with, if it exists.

   The URL string matching in this step is prefix-based rather than path-structural (e.g. a client URL string with "/prefix-of/resource.html" will match a registration for a scope with "/prefix").

5. Let parsedMatchingScope be null.
6. If matchingScope is not the empty string, set parsedMatchingScope to the result of parsing matchingScope.
7. Let registration be the result of running Get Registration algorithm passing parsedMatchingScope as the argument.
8. If registration is not null and registration’s uninstalling flag is set, return null.
9. Return registration.

Get Registration

Input

scope, a URL

Output

registration, a service worker registration

1. Run the following steps atomically.
2. Let scopeString be the empty string.
3. If scope is not null, set scopeString to serialized scope with the exclude fragment flag set.
4. Let registration be null.
5. For each Record {[[key]], [[value]]} entry of its scope to registration map:
   1. If scopeString matches entry.[[key]], set registration to entry.[[value]].
6. Return registration.

Get Newest Worker

Input

registration, a service worker registration

Output

worker, a service worker

1. Run the following steps atomically.
2. Let newestWorker be null.
3. If registration’s installing worker is not null, set newestWorker to registration’s installing worker.
4. Else if registration’s waiting worker is not null, set newestWorker to registration’s waiting worker.
5. Else if registration’s active worker is not null, set newestWorker to registration’s active worker.
6. Return newestWorker.

Create Client

Input

client, a service worker client

Output

clientObject, a Client object

1. Let clientObject be a new Client object.
2. Set clientObject’s service worker client to client.
3. Return clientObject.

Create Window Client

Input

client, a service worker client

visibilityState, a string

focusState, a boolean

Output

windowClient, a WindowClient object

1. Let windowClient be a new WindowClient object.
2. Set windowClient’s service worker client to client.
3. Set windowClient’s visibility state to visibilityState.
4. Set windowClient’s focus state to focusState.
5. Return windowClient.

Query Cache

Input

request, a Request object

options, a CacheQueryOptions object, optional

targetStorage, an array that has [Request, Response] pairs as its elements, optional

Output

resultArray, an array that has [Request, Response] pairs as its elements

1. Let requestArray be an empty array.
2. Let responseArray be an empty array.
3. Let resultArray be an empty array.
4. If options.ignoreMethod is false and request.method is neither "GET" nor "HEAD", return resultArray.
5. Let cachedURL and requestURL be null.
6. If the optional argument targetStorage is omitted, then:
   1. For each fetching record entry of its request to response map, in key insertion order:
      1. Set cachedURL to entry.[[key]]'s associated request’s url.
      2. Set requestURL to request’s associated request’s url.
      3. If options.ignoreSearch is true, then:
         1. Set cachedURL’s query to the empty string.
         2. Set requestURL’s query to the empty string.
      4. If cachedURL equals requestURL with the exclude fragments flag set, then:
         1. Add a copy of entry.[[key]] to requestArray.
         2. Add a copy of entry.[[value]] to responseArray.
7. Else:
   1. For each record in targetStorage:
      1. Set cachedURL to record[0]'s associated request’s url.
      2. Set requestURL to request’s associated request’s url.
      3. If options.ignoreSearch is true, then:
         1. Set cachedURL’s query to the empty string.
         2. Set requestURL’s query to the empty string.
      4. If cachedURL equals requestURL with the exclude fragments flag set, then:
         1. Add record[0] to requestArray.
         2. Add record[1] to responseArray.
8. For each cachedResponse in responseArray with the index index:
   1. Let cachedRequest be the indexth element in requestArray.
   2. If cachedResponse’s response’s header list contains no header named `Vary`, or options.ignoreVary is true, then:
      1. Add an array [cachedRequest, cachedResponse] to resultArray.
      2. Continue to the next iteration of the loop.
   3. Let varyHeaders be the array containing the elements corresponding to the field-values of the Vary header.
   4. Let matchFailed be false.
   5. For each f in varyHeaders:
      1. If f matches "*", or the result of running cachedRequest.headers object’s get(name) method with f as the argument does not match the result of running request.headers object’s get(name) method with f as the argument, then:
         1. Set matchFailed to true.
         2. Break the loop.
   6. If matchFailed is false, add an array [cachedRequest, cachedResponse] to resultArray.
9. Return resultArray.

Batch Cache Operations

Input

operations, an array of CacheBatchOperation dictionary objects

Output

promise, a promise resolves with an array of Response objects.

1. Let p be a promise resolved with no value.
2. Return the result of transforming p with a fulfillment handler that performs the following substeps in parallel:
   1. Let itemsCopy be a new request to response map that is a copy of its context object’s request to response map.
   2. Let addedRecords be an empty array.
   3. Try running the following substeps atomically:
      1. Let resultArray be an empty array.
      2. For each operation in operations with the index index:
         1. If operation.type matches neither "delete" nor "put", throw a TypeError.
         2. If operation.type matches "delete" and operation.response is not null, throw a TypeError.
         3. If the result of running Query Cache algorithm passing operation.request, operation.options, and addedRecords as the arguments is not an empty array, throw an "InvalidStateError" exception.
         4. Let requestResponseArray be the result of running Query Cache algorithm passing operation.request and operation.options as the arguments.
         5. For each requestResponse in requestResponseArray:
            1. If operation.type matches "delete", remove the corresponding fetching record from request to response map.
         6. If operation.type matches "put", then:
            1. If operation.response is null, throw a TypeError.
            2. Let r be operation.request's associated request.
            3. If r’s url’s scheme is not one of "http" and "https", throw a TypeError.
            4. If r’s method is not `GET`, throw a TypeError.
            5. If operation.options is not null, throw a TypeError.
            6. Set requestResponseArray to the result of running Query Cache algorithm passing operation.request.
            7. If requestResponseArray is not an empty array, then:
               1. Let requestResponse be requestResponseArray[0].
               2. Let fetchingRecord be the corresponding fetching record for requestResponse[0] and requestResponse[1] in request to response map.
               3. Set fetchingRecord.[[key]] to operation.request and fetchingRecord.[[value]] to operation.response.
            8. Else:
               1. Set a newly-created fetching record {[[key]]: operation.request, [[value]]: operation.response} to request to response map.

               The cache commit is allowed as long as the response’s headers are available.

            9. If the cache write operation in the previous two steps failed due to exceeding the granted quota limit, throw a "QuotaExceededError" exception.
            10. Add an array [operation.request, operation.response] to addedRecords.
         7. Add operation.response to resultArray.
      3. Return resultArray.
   4. And then, if an exception was thrown, then:
      1. Set the context object’s request to response map to itemsCopy.
      2. Throw the exception