index.bs

<pre class='metadata'>
Title: Service Workers 1
Status: ED
ED: https://w3c.github.io/ServiceWorker/v1/
TR: https://www.w3.org/TR/service-workers/
Shortname: service-workers
Level: 1
Editor: Alex Russell, Google, slightlyoff@chromium.org
Editor: Jungkee Song, Samsung Electronics, jungkee.song@samsung.com
Editor: Jake Archibald, Google, jakearchibald@chromium.org
Editor: Marijn Kruisselbrink, Google, mek@chromium.org
Repository: w3c/ServiceWorker
Group: webplatform
!Tests: <a href=https://github.com/w3c/web-platform-tests/tree/master/service-workers>web-platform-tests service-workers/</a> (<a href=https://github.com/w3c/web-platform-tests/labels/service-workers>ongoing work</a>)
Abstract: This specification describes a method that enables applications to take advantage of persistent background processing, including hooks to enable bootstrapping of web applications while offline.
Abstract:
Abstract: The core of this system is an event-driven <a>Web Worker</a>, which responds to events dispatched from documents and other sources. A system for managing installation, versions, and upgrades is provided.
Abstract:
Abstract: The service worker is a generic entry point for event-driven background processing in the Web Platform that is <a href="#extensibility">extensible by other specifications</a>.
Markup Shorthands: css no, markdown yes
</pre>

<pre class="link-defaults">
spec: html;
    type: dfn; text: task queues; for: /
    type: element; text: link

spec: dom;
    type: interface; text: Document

spec: fetch;
    type: dfn
        for: /; text: fetch
        text: empty
    type: interface
        text: ReadableStream
spec: infra;
    type: dfn;
        for: set; text: append
        for: list; text: append
</pre>

<pre class="anchors">
spec: push; urlPrefix: https://w3c.github.io/push-api/
    type: event
        text: push; url: h-the-push-event

spec: ecma-262; urlPrefix: http://tc39.github.io/ecma262/
    type: dfn
        text: Assert; url: sec-algorithm-conventions
        text: [[Call]]; url: sec-ecmascript-function-objects-call-thisargument-argumentslist
        text: promise; url: sec-promise-objects
        text: DetachArrayBuffer; url: sec-detacharraybuffer
        url: sec-list-and-record-specification-type
            text: List
            text: Record
        text: map objects; url: sec-map-objects
        text: InitializeHostDefinedRealm; url: sec-initializehostdefinedrealm
        text: execution context; url: sec-execution-contexts

spec: page-visibility; urlPrefix: https://www.w3.org/TR/page-visibility/
    type: enum; text: VisibilityState; url: VisibilityState
    type: attribute; text: visibilityState; for: Document; url: dom-document-visibilitystate

spec: html; urlPrefix: https://html.spec.whatwg.org/multipage/
    type: attribute
        urlPrefix: comms.html
            text: origin; for: MessageEvent; url: dom-messageevent-origin
            text: source; for: MessageEvent; url: dom-messageevent-source
            text: ports; for: MessageEvent; url: dom-messageevent-ports
            text: data; for: MessageEvent; url: dom-messageevent-data
    type: dfn
        urlPrefix: browsers.html
            text: ancestor origins list; for: Location; url: concept-location-ancestor-origins-list
        urlPrefix: syntax.html
            text: delay the load event; for: document; url: delay-the-load-event

spec: fetch; urlPrefix: https://fetch.spec.whatwg.org/
    type: dfn
        text: response; for: Response; url: concept-response-response
        text: request; for: Request; url: concept-request-request
        text: HTTP fetch; for: /; url: concept-http-fetch

spec: rfc7230; urlPrefix: https://tools.ietf.org/html/rfc7230
    type: dfn
        text: field-value; for: http; url: section-3.2

spec: rfc7231; urlPrefix: https://tools.ietf.org/html/rfc7231
    type: dfn
        text: Vary; url: section-7.1.4

spec: webappsec-referrer-policy; urlPrefix: https://w3c.github.io/webappsec-referrer-policy/
    type: dfn
        text: Parse a referrer policy from a Referrer-Policy header; url: parse-referrer-policy-from-header
</pre>

<pre class="biblio">
{
  "unsanctioned-tracking": {
    "href": "https://www.w3.org/2001/tag/doc/unsanctioned-tracking/",
    "title": "Unsanctioned Web Tracking",
    "date": "17 July 2015",
    "status": "Finding of the W3C TAG",
    "publisher": "W3C TAG"
  }
}
</pre>

<section>
  <h2 id="motivations">Motivations</h2>

  *This section is non-normative.*

  Web Applications traditionally assume that the network is reachable. This assumption pervades the platform. HTML documents are loaded over HTTP and traditionally fetch all of their sub-resources via subsequent HTTP requests. This places web content at a disadvantage versus other technology stacks.

  The [=/service worker=] is designed first to redress this balance by providing a Web Worker context, which can be started by a runtime when navigations are about to occur. This event-driven worker is registered against an origin and a path (or pattern), meaning it can be consulted when navigations occur to that location. Events that correspond to network requests are dispatched to the worker and the responses generated by the worker may override default network stack behavior. This puts the [=/service worker=], conceptually, between the network and a document renderer, allowing the [=/service worker=] to provide content for documents, even while offline.

  Web developers familiar with previous attempts to solve the offline problem have reported a deficit of flexibility in those solutions. As a result, the [=/service worker=] is highly procedural, providing a maximum of flexibility at the price of additional complexity for developers. Part of this complexity arises from the need to keep [=/service workers=] responsive in the face of a single-threaded execution model. As a result, APIs exposed by [=/service workers=] are almost entirely asynchronous, a pattern familiar in other JavaScript contexts but accentuated here by the need to avoid blocking document and resource loading.

  Developers using the <a lt="application cache">HTML5 Application Cache</a> have also <a href="http://alistapart.com/article/application-cache-is-a-douchebag">reported that several attributes</a> of the design contribute to <a href="http://alistapart.com/article/application-cache-is-a-douchebag#section6">unrecoverable errors</a>. A key design principle of the [=/service worker=] is that errors should *always* be recoverable. Many details of the update process of [=/service workers=] are designed to avoid these hazards.

  [=/Service workers=] are started and kept alive by their relationship to events, not documents. This design borrows heavily from developer and vendor experience with <a>Shared Workers</a> and <a href="https://developer.chrome.com/extensions/background_pages">Chrome Background Pages</a>. A key lesson from these systems is the necessity to time-limit the execution of background processing contexts, both to conserve resources and to ensure that background context loss and restart is top-of-mind for developers. As a result, [=/service workers=] bear more than a passing resemblance to <a href="https://developer.chrome.com/extensions/event_pages">Chrome Event Pages</a>, the successor to Background Pages. [=/Service workers=] may be started by user agents *without an attached document* and may be killed by the user agent at nearly any time. Conceptually, [=/service workers=] can be thought of as Shared Workers that can start, process events, and die without ever handling messages from documents. Developers are advised to keep in mind that [=/service workers=] may be started and killed many times a second.

  [=/Service workers=] are generic, event-driven, time-limited script contexts that run at an origin. These properties make them natural endpoints for a range of runtime services that may outlive the context of a particular document, e.g. handling push notifications, background data synchronization, responding to resource requests from other origins, or receiving centralized updates to expensive-to-calculate data (e.g., geolocation or gyroscope).
</section>

<section>
  <h2 id="model">Model</h2>

  <section dfn-for="service worker">
    <h3 id="service-worker-concept">Service Worker</h3>

    A <dfn export id="dfn-service-worker" for="">service worker</dfn> is a type of <a>web worker</a>. A [=/service worker=] executes in the registering [=/service worker client=]'s [=/origin=].

    A [=/service worker=] has an associated <dfn export id="dfn-state">state</dfn>, which is one of *parsed*, *installing*, *installed*, *activating*, *activated*, and *redundant*. It is initially *parsed*.

    A [=/service worker=] has an associated <dfn export id="dfn-script-url">script url</dfn> (a [=/URL=]).

    A [=/service worker=] has an associated <dfn export id="dfn-type">type</dfn> which is either "<code>classic</code>" or "<code>module</code>". Unless stated otherwise, it is "<code>classic</code>".

    A [=/service worker=] has an associated <dfn export id="dfn-containing-service-worker-registration" lt="registration|containing service worker registration">containing service worker registration</dfn> (a [=/service worker registration=]), which contains itself.

    A [=/service worker=] has an associated <dfn export id="dfn-service-worker-id">id</dfn> (an opaque string), which uniquely identifies itself during the lifetime of its <a>containing service worker registration</a>.

    A [=/service worker=] has an associated <dfn export id="dfn-service-worker-global-object" for="service worker">global object</dfn> (a {{ServiceWorkerGlobalScope}} object or null).

    A [=/service worker=] is dispatched a set of <dfn export id="dfn-lifecycle-events">lifecycle events</dfn>, {{install!!event}} and {{activate!!event}}, and <dfn export id="dfn-functional-events">functional events</dfn> including {{fetch!!event}}.

    A [=/service worker=] has an associated <dfn export id="dfn-script-resource">script resource</dfn> (a <a>script</a>), which represents its own script resource. It is initially set to null.

    A <a>script resource</a> has an associated <dfn export for="script resource" id="dfn-has-ever-been-evaluated-flag">has ever been evaluated flag</dfn>. It is initially unset.

    A <a>script resource</a> has an associated <dfn export for="script resource" id="dfn-https-state">HTTPS state</dfn> (an <a>HTTPS state value</a>). It is initially "<code>none</code>".

    A <a>script resource</a> has an associated <dfn export for="script resource" id="dfn-referrer-policy">referrer policy</dfn> (a [=/referrer policy=]). It is initially the empty string.

    A [=/service worker=] has an associated <dfn export id="dfn-script-resource-map">script resource map</dfn> which is an <a>ordered map</a> where the keys are [=/URLs=] and the values are [=/responses=].

    A [=/service worker=] has an associated <dfn export id="dfn-skip-waiting-flag">skip waiting flag</dfn>. Unless stated otherwise it is unset.

    A [=/service worker=] has an associated <dfn export id="dfn-imported-scripts-updated-flag">imported scripts updated flag</dfn>. It is initially unset.

    A [=/service worker=] has an associated <dfn export id="dfn-set-of-event-types-to-handle">set of event types to handle</dfn> (a [=ordered set|set=]) whose [=item=] is an <a>event listener</a>'s event type. It is initially an empty set.

    A [=/service worker=] has an associated <dfn export id="dfn-set-of-extended-events">set of extended events</dfn> (a [=ordered set|set=]) whose [=item=] is an {{ExtendableEvent}}. It is initially an empty set.

    <section>
      <h4 id="service-worker-lifetime">Lifetime</h4>

      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* <a lt="terminate service worker">terminate</a> [=/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.
    </section>
  </section>

  <section dfn-for="service worker registration">
    <h3 id="service-worker-registration-concept">Service Worker Registration</h3>

    A <dfn export id="dfn-service-worker-registration" for="">service worker registration</dfn> is a tuple of a [=service worker registration/scope url=] and a set of [=/service workers=], an <a>installing worker</a>, a <a>waiting worker</a>, and an <a>active worker</a>. A user agent *may* enable many [=/service worker registrations=] at a single origin so long as the [=service worker registration/scope url=] of the [=/service worker registration=] differs. A [=/service worker registration=] of an identical [=service worker registration/scope url=] when one already exists in the user agent causes the existing [=/service worker registration=] to be replaced.

    A [=/service worker registration=] has an associated <dfn export id="dfn-scope-url">scope url</dfn> (a [=/URL=]).

    A [=/service worker registration=] has an associated <dfn export id="dfn-installing-worker">installing worker</dfn> (a [=/service worker=] or null) whose [=service worker/state=] is *installing*. It is initially set to null.

    A [=/service worker registration=] has an associated <dfn export id="dfn-waiting-worker">waiting worker</dfn> (a [=/service worker=] or null) whose [=service worker/state=] is *installed*. It is initially set to null.

    A [=/service worker registration=] has an associated <dfn export id="dfn-active-worker">active worker</dfn> (a [=/service worker=] or null) whose [=service worker/state=] is either *activating* or *activated*. It is initially set to null.

    A [=/service worker registration=] has an associated <dfn export id="dfn-last-update-check-time">last update check time</dfn>. It is initially set to null.

    A [=/service worker registration=] has an associated <dfn export id="dfn-use-cache">use cache</dfn> (a boolean). It is initially set to false.

    A [=/service worker registration=] has an associated <dfn export id="dfn-uninstalling-flag">uninstalling flag</dfn>. It is initially unset.

    A [=/service worker registration=] has one or more <dfn export id="dfn-service-worker-registration-task-queue">task queues</dfn> that back up the <a>tasks</a> from its <a>active worker</a>'s <a>event loop</a>'s corresponding [=/task queues=]. (The target task sources for this back up operation are the <a>handle fetch task source</a> and the <a>handle functional event task source</a>.) The user agent dumps the <a>active worker</a>'s <a>tasks</a> to the [=/service worker registration=]'s [=service worker registration/task queues=] when the <a>active worker</a> is <a lt="terminate service worker">terminated</a> and <a lt="queue a task">re-queues those tasks</a> to the <a>active worker</a>'s <a>event loop</a>'s corresponding [=/task queues=] when the <a>active worker</a> spins off. Unlike the [=/task queues=] owned by <a>event loops</a>, the [=/service worker registration=]'s [=service worker registration/task queues=] are not processed by any <a>event loops</a> in and of itself.

    <section>
      <h4 id="service-worker-registration-lifetime">Lifetime</h4>

      A user agent *must* persistently keep a list of <a>registered</a> [=/service worker registrations=] unless otherwise they are explicitly <a>unregistered</a>. A user agent has a <a>scope to registration map</a> that stores the entries of the tuple of [=/service worker registration=]'s [=service worker registration/scope url=], [=URL serializer|serialized=], 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=].
    </section>
  </section>

  <section dfn-for="service worker client">
    <h3 id="service-worker-client-concept">Service Worker Client</h3>

    A <dfn export id="dfn-service-worker-client" for="">service worker client</dfn> is an [=environment=].

    A [=/service worker client=] has an algorithm defined as the <dfn export for="service worker client">origin</dfn> that returns the [=/service worker client=]'s [=environment settings object/origin=] if the [=/service worker client=] is an [=environment settings object=], and the [=/service worker client=]'s <a>creation URL</a>'s [=url/origin=] otherwise.

    A <dfn export id="dfn-window-client">window client</dfn> is a [=/service worker client=] whose [=environment settings object/global object=] is a {{Window}} object.

    A <dfn export id="dfn-dedicatedworker-client">dedicated worker client</dfn> is a [=/service worker client=] whose [=environment settings object/global object=] is a {{DedicatedWorkerGlobalScope}} object.

    A <dfn export id="dfn-sharedworker-client">shared worker client</dfn> is a [=/service worker client=] whose [=environment settings object/global object=] is a {{SharedWorkerGlobalScope}} object.

    A <dfn export id="dfn-worker-client">worker client</dfn> is either a <a>dedicated worker client</a> or a <a>shared worker client</a>.
  </section>

  <section>
    <h3 id="selection">Selection and Use</h3>

    A [=/service worker client=] independently <a lt="selection">selects</a> and <a>uses</a> a [=/service worker registration=] for its own loading and its subresources. The <dfn id="dfn-service-worker-registration-selection">selection</dfn> of a [=/service worker registration=], upon a <a>non-subresource request</a>, is a process of either <a lt="Match Service Worker Registration">matching</a> a [=/service worker registration=] from <a>scope to registration map</a> or inheriting an existing [=/service worker registration=] from its parent or owner context depending on the request's [=request/url=].

    When the request's [=request/url=] is not <a lt="is local">local</a>, a [=/service worker client=] <a lt="Match Service Worker Registration">matches</a> a [=/service worker registration=] from <a>scope to registration map</a>. That is, the [=/service worker client=] attempts to consult a [=/service worker registration=] whose [=service worker registration/scope url=] <a lt="Match Service Worker Registration">matches</a> its <a>creation URL</a>.

    When the request's [=request/url=] <a>is local</a>, if the [=/service worker client=]'s <a>responsible browsing context</a> is a <a>nested browsing context</a> or the [=/service worker client=] is a <a>worker client</a>, the [=/service worker client=] inherits the [=/service worker registration=] from its <a>parent browsing context</a>'s environment or one of <a>the worker's Documents</a>' environment, respectively, if it exists.

    If the <a>selection</a> was successful, the <a lt="selection">selected</a> [=/service worker registration=]'s <a>active worker</a> starts to <dfn id="dfn-control">control</dfn> the [=/service worker client=]. Otherwise, the flow returns to [=/fetch=] where it falls back to the default behavior. When a [=/service worker client=] is <a>controlled</a> by an <a>active worker</a>, it is considered that the [=/service worker client=] is <dfn id="dfn-use" lt="using|uses|used">using</dfn> the <a>active worker</a>'s <a>containing service worker registration</a>.
  </section>

  <section>
    <h3 id="task-sources">Task Sources</h3>

    The following additional <a>task sources</a> are used by [=/service workers=].

      : The <dfn export id="dfn-handle-fetch-task-source">handle fetch task source</dfn>
      :: This <a>task source</a> is used for <a>dispatching</a> {{fetch!!event}} events to [=/service workers=].
      : The <dfn export id="dfn-handle-functional-event-task-source">handle functional event task source</dfn>
      :: This <a>task source</a> is used for features that <a>dispatch</a> other <a>functional events</a>, e.g. {{push!!event}} events, to [=/service workers=].

        Note: A user agent may use a separate task source for each functional event type in order to avoid a head-of-line blocking phenomenon for certain functional events.
  </section>

  <section>
    <h3 id="user-agent-shutdown">User Agent Shutdown</h3>

    A user agent *must* maintain the state of its stored [=/service worker registrations=] across restarts with the following rules:

      * An <a>installing worker</a> does not persist but is discarded. If the <a>installing worker</a> was the only [=/service worker=] for the [=/service worker registration=], the [=/service worker registration=] is discarded.
      * A <a>waiting worker</a> promotes to an <a>active worker</a>.

    To attain this, the user agent *must* invoke <a>Handle User Agent Shutdown</a> when it terminates.
  </section>
</section>
<section>
  <h2 id="document-context">Client Context</h2>

  <div class="example">
    Bootstrapping with a service worker:

    <pre highlight="js">
      // scope defaults to the path the script sits in
      // "/" in this example
      navigator.serviceWorker.register("/serviceworker.js").then(registration => {
        console.log("success!");
        if (registration.installing) {
          registration.installing.postMessage("Howdy from your installing page.");
        }
      }, err => {
        console.error("Installing the worker failed!", err);
      });
    </pre>
  </div>

  <section>
    <h3 id="serviceworker-interface">{{ServiceWorker}}</h3>

    <pre class="idl">
      [SecureContext, Exposed=(Window,Worker)]
      interface ServiceWorker : EventTarget {
        readonly attribute USVString scriptURL;
        readonly attribute ServiceWorkerState state;
        void postMessage(any message, optional sequence&lt;object&gt; transfer = []);

        // event
        attribute EventHandler onstatechange;
      };
      ServiceWorker implements AbstractWorker;

      enum ServiceWorkerState {
        "installing",
        "installed",
        "activating",
        "activated",
        "redundant"
      };
    </pre>

    A {{ServiceWorker}} object represents a [=/service worker=]. Each {{ServiceWorker}} object is associated with a [=/service worker=]. Multiple separate objects implementing the {{ServiceWorker}} interface across documents and workers can all be associated with the same [=/service worker=] simultaneously.

    A {{ServiceWorker}} object has an associated {{ServiceWorkerState}} object which is itself associated with [=/service worker=]'s <a>state</a>.

    <section>
      <h4 id="service-worker-url">{{ServiceWorker/scriptURL}}</h4>

      The <dfn attribute for="ServiceWorker"><code>scriptURL</code></dfn> attribute *must* return the [=/service worker=]'s <a lt="URL serializer">serialized</a> [=service worker/script url=].

      <div class="example">
        For example, consider a document created by a navigation to <code>https://example.com/app.html</code> which <a lt="Match Service Worker Registration">matches</a> via the following registration call which has been previously executed:

        <pre highlight="js">
          // Script on the page https://example.com/app.html
          navigator.serviceWorker.register("/service_worker.js");
        </pre>

        The value of <code>navigator.serviceWorker.controller.scriptURL</code> will be "<code>https://example.com/service_worker.js</code>".
      </div>
    </section>

    <section>
      <h4 id="service-worker-state">{{ServiceWorker/state}}</h4>

      The <dfn attribute for="ServiceWorker"><code>state</code></dfn> attribute *must* return the value (in {{ServiceWorkerState}} enumeration) to which it was last set.
    </section>

    <section algorithm="service-worker-postmessage">
      <h4 id="service-worker-postmessage">{{ServiceWorker/postMessage(message, transfer)}}</h4>

      The <dfn method for="ServiceWorker"><code>postMessage(|message|, |transfer|)</code></dfn> method *must* run these steps:

        1. If the {{ServiceWorker/state}} attribute value of the <a>context object</a> is {{"redundant"}}, <a>throw</a> an "{{InvalidStateError}}" exception and abort these steps.
        1. Let |serviceWorker| be the [=/service worker=] represented by the <a>context object</a>.
        1. Invoke <a>Run Service Worker</a> algorithm with |serviceWorker| as the argument.
        1. Let |incumbentSettings| be the <a>incumbent settings object</a>, and |incumbentGlobal| its [=environment settings object/global object=].
        1. Let |serializeWithTransferResult| be <a abstract-op>StructuredSerializeWithTransfer</a>(|message|, |transfer|). Rethrow any exceptions.
        1. [=Queue a task=] on the [=DOM manipulation task source=] to run the following steps:
            1. Let |source| be determined by switching on the type of |incumbentGlobal|:
                <dl class="switch">
                    <dt>{{ServiceWorkerGlobalScope}}</dt>
                    <dd>a new {{ServiceWorker}} object that represents |incumbentGlobal|'s [=ServiceWorkerGlobalScope/service worker=].</dd>

                    <dt>{{Window}}</dt>
                    <dd>a new {{WindowClient}} object that represents |incumbentGlobal|'s [=relevant settings object=].</dd>

                    <dt>Otherwise</dt>
                    <dd>a new {{Client}} object that represents |incumbentGlobal|'s associated worker
                </dd>
            1. Let |origin| be the [=Unicode serialization of an origin|Unicode serialization=] of |incumbentSettings|'s [=environment settings object/origin=].
            1. Let |destination| be the {{ServiceWorkerGlobalScope}} object associated with |serviceWorker|.
            1.  Let |deserializeRecord| be <a abstract-op>StructuredDeserializeWithTransfer</a>(|serializeWithTransferResult|, |destination|'s [=global object/Realm=]).

                If this throws an exception, [=fire an event=] named {{messageerror!!event}} at |destination|, using {{MessageEvent}}, with the {{MessageEvent/origin}} attribute initialized to |origin| and the {{MessageEvent/source}} attribute initialized to |source|, and then abort these steps.
            1. Let |messageClone| be |deserializeRecord|.\[[Deserialized]].
            1. Let |newPorts| be a new [=frozen array type|frozen array=] consisting of all {{MessagePort}} objects in |deserializeRecord|.\[[TransferredValues]], if any, maintaining their relative order.
            1. Let |e| be the result of [=creating an event=] named {{message!!event}}, using {{ExtendableMessageEvent}}, with the {{ExtendableMessageEvent/origin}} attribute initialized to |origin|, the {{ExtendableMessageEvent/source}} attribute initialized to |source|, the {{ExtendableMessageEvent/data}} attribute initialized to |messageClone|, and the {{ExtendableMessageEvent/ports}} attribute initialized to |newPorts|.
            1. [=Dispatch=] |e| at |destination|.
            1. Invoke [=Update Service Worker Extended Events Set=] with |serviceWorker| and |e|.
    </section>

    <section>
      <h4 id="service-worker-event-handler">Event handler</h4>

      The following is the <a>event handler</a> (and its corresponding <a>event handler event type</a>) that *must* be supported, as <a>event handler IDL attributes</a>, by all objects implementing {{ServiceWorker}} interface:

      <table class="data">
        <thead>
          <tr>
            <th><a>event handler</a></th>
            <th><a>event handler event type</a></th>
          </tr>
        </thead>
        <tbody>
          <tr>
            <td><dfn attribute for="ServiceWorker"><code>onstatechange</code></dfn></td>
            <td>{{ServiceWorker/statechange}}</td>
          </tr>
        </tbody>
      </table>
    </section>
  </section>

  <section>
    <h3 id="serviceworkerregistration-interface">{{ServiceWorkerRegistration}}</h3>

    <pre class="idl">
      [SecureContext, Exposed=(Window,Worker)]
      interface ServiceWorkerRegistration : EventTarget {
        readonly attribute ServiceWorker? installing;
        readonly attribute ServiceWorker? waiting;
        readonly attribute ServiceWorker? active;

        readonly attribute USVString scope;
        readonly attribute boolean useCache;

        [NewObject] Promise&lt;void&gt; update();
        [NewObject] Promise&lt;boolean&gt; unregister();

        // event
        attribute EventHandler onupdatefound;
      };
    </pre>

    A {{ServiceWorkerRegistration}} object represents a [=/service worker registration=]. Each {{ServiceWorkerRegistration}} object is associated with a <dfn for="ServiceWorkerRegistration">service worker registration</dfn> (a [=/service worker registration=]). Multiple separate objects implementing the {{ServiceWorkerRegistration}} interface across documents and workers can all be associated with the same [=/service worker registration=] simultaneously.

    <section algorithm="navigator-service-worker-installing">
      <h4 id="navigator-service-worker-installing">{{ServiceWorkerRegistration/installing}}</h4>

      <dfn attribute for="ServiceWorkerRegistration"><code>installing</code></dfn> attribute *must* return the value to which it was last set.

      Note: The {{ServiceWorker}} objects returned from this attribute getter that represent the same [=/service worker=] are the same objects.
    </section>

    <section algorithm="navigator-service-worker-waiting">
      <h4 id="navigator-service-worker-waiting">{{ServiceWorkerRegistration/waiting}}</h4>

      <dfn attribute for="ServiceWorkerRegistration"><code>waiting</code></dfn> attribute *must* return the value to which it was last set.

      Note: The {{ServiceWorker}} objects returned from this attribute getter that represent the same [=/service worker=] are the same objects.
    </section>

    <section algorithm="navigator-service-worker-active">
      <h4 id="navigator-service-worker-active">{{ServiceWorkerRegistration/active}}</h4>

      <dfn attribute for="ServiceWorkerRegistration"><code>active</code></dfn> attribute *must* return the value to which it was last set.

      Note: The {{ServiceWorker}} objects returned from this attribute getter that represent the same [=/service worker=] are the same objects.
    </section>

    <section algorithm="service-worker-registration-scope">
      <h4 id="service-worker-registration-scope">{{ServiceWorkerRegistration/scope}}</h4>

      The <dfn attribute for="ServiceWorkerRegistration"><code>scope</code></dfn> attribute *must* return [=ServiceWorkerRegistration/service worker registration=]'s <a lt="URL serializer">serialized</a> [=service worker registration/scope url=].

      <div class="example">
        In the example in [[#service-worker-url]], the value of <code>registration.scope</code>, obtained from <code>navigator.serviceWorker.ready.then(registration => console.log(registration.scope))</code> for example, will be "<code>https://example.com/</code>".
      </div>
    </section>

    <section algorithm="service-worker-registration-usecache">
      <h4 id="service-worker-registration-usecache">{{ServiceWorkerRegistration/useCache}}</h4>

      The <dfn attribute for="ServiceWorkerRegistration"><code>useCache</code></dfn> attribute *must* return [=ServiceWorkerRegistration/service worker registration=]'s [=service worker registration/use cache=].
    </section>

    <section algorithm="service-worker-registration-update">
      <h4 id="service-worker-registration-update">{{ServiceWorkerRegistration/update()}}</h4>

      <dfn method for="ServiceWorkerRegistration"><code>update()</code></dfn> method *must* run these steps:

        1. Let |p| be a <a>promise</a>.
        1. Let |registration| be the [=ServiceWorkerRegistration/service worker registration=].
        1. Let |newestWorker| be the result of running <a>Get Newest Worker</a> algorithm passing |registration| as its argument.
        1. If |newestWorker| is null, reject |p| with an "{{InvalidStateError}}" exception and abort these steps.
        1. If the <a>context object</a>'s <a>relevant settings object</a>'s [=environment settings object/global object=] |globalObject| is a {{ServiceWorkerGlobalScope}} object, and |globalObject|'s associated [=ServiceWorkerGlobalScope/service worker=]'s <a>state</a> is *installing*, reject |p| with an "{{InvalidStateError}}" exception and abort these steps.
        1. Let |job| be the result of running <a>Create Job</a> with *update*, |registration|'s [=service worker registration/scope url=], |newestWorker|'s [=service worker/script url=], |p|, and the <a>context object</a>'s <a>relevant settings object</a>.
        1. Set |job|'s <a>worker type</a> to |newestWorker|'s [=service worker/type=].
        1. Invoke <a>Schedule Job</a> with |job|.
        1. Return |p|.
    </section>

    <section algorithm="navigator-service-worker-unregister">
      <h4 id="navigator-service-worker-unregister">{{ServiceWorkerRegistration/unregister()}}</h4>

      Note: The {{ServiceWorkerRegistration/unregister()}} method unregisters the [=/service worker registration=]. It is important to note that the currently <a>controlled</a> [=/service worker client=]'s <a>active service worker</a>'s <a>containing service worker registration</a> is effective until all the [=/service worker clients=] (including itself) using this [=/service worker registration=] unload. That is, the {{ServiceWorkerRegistration/unregister()}} method only affects subsequent <a lt="navigate">navigations</a>.

      <dfn method for="ServiceWorkerRegistration"><code>unregister()</code></dfn> method *must* run these steps:

        1. Let |p| be a <a>promise</a>.
        1. Let |job| be the result of running <a>Create Job</a> with *unregister*, the [=service worker registration/scope url=] of the [=ServiceWorkerRegistration/service worker registration=], null, |p|, and the <a>context object</a>'s <a>relevant settings object</a>.
        1. Invoke <a>Schedule Job</a> with |job|.
        1. Return |p|.
    </section>

    <section>
      <h4 id="service-worker-registration-event-handler">Event handler</h4>

      The following is the <a>event handler</a> (and its corresponding <a>event handler event type</a>) that *must* be supported, as <a>event handler IDL attributes</a>, by all objects implementing {{ServiceWorkerRegistration}} interface:

      <table class="data">
        <thead>
          <tr>
            <th><a>event handler</a></th>
            <th><a>event handler event type</a></th>
          </tr>
        </thead>
        <tbody>
          <tr>
            <td><dfn attribute for="ServiceWorkerRegistration"><code>onupdatefound</code></dfn></td>
            <td>{{updatefound!!event}}</td>
          </tr>
        </tbody>
      </table>
    </section>
  </section>

  <section>
    <h3 id="navigator-serviceworker">{{Navigator/serviceWorker|navigator.serviceWorker}}</h3>

    <pre class="idl">
      partial interface Navigator {
        [SecureContext, SameObject] readonly attribute ServiceWorkerContainer serviceWorker;
      };

      partial interface WorkerNavigator {
        [SecureContext, SameObject] readonly attribute ServiceWorkerContainer serviceWorker;
      };
    </pre>

    The <dfn attribute for="Navigator,WorkerNavigator" id="navigator-service-worker-attribute"><code>serviceWorker</code></dfn> attribute *must* return the {{ServiceWorkerContainer}} object that is associated with the <a>context object</a>.
  </section>

  <section>
    <h3 id="serviceworkercontainer-interface">{{ServiceWorkerContainer}}</h3>

    <pre class="idl">
      [SecureContext, Exposed=(Window,Worker)]
      interface ServiceWorkerContainer : EventTarget {
        readonly attribute ServiceWorker? controller;
        readonly attribute Promise&lt;ServiceWorkerRegistration&gt; ready;

        [NewObject] Promise&lt;ServiceWorkerRegistration&gt; register(USVString scriptURL, optional RegistrationOptions options);

        [NewObject] Promise&lt;any&gt; getRegistration(optional USVString clientURL = "");
        [NewObject] Promise&lt;sequence&lt;ServiceWorkerRegistration&gt;&gt; getRegistrations();

        void startMessages();


        // events
        attribute EventHandler oncontrollerchange;
        attribute EventHandler onmessage; // event.source of message events is ServiceWorker object
        attribute EventHandler onmessageerror;
      };
    </pre>
    <pre class="idl" id="registration-option-list-dictionary">
      dictionary RegistrationOptions {
        USVString scope;
        WorkerType type = "classic";
        boolean useCache = false;
      };
    </pre>

    The user agent *must* create a {{ServiceWorkerContainer}} object when a {{Navigator}} object or a {{WorkerNavigator}} object is created and associate it with that object.

    A {{ServiceWorkerContainer}} provides capabilities to register, unregister, and update the [=/service worker registrations=], and provides access to the state of the [=/service worker registrations=] and their associated [=/service workers=].

    A {{ServiceWorkerContainer}} has an associated <dfn for="ServiceWorkerContainer">service worker client</dfn>, which is a [=/service worker client=] whose [=environment settings object/global object=] is associated with the {{Navigator}} object or the {{WorkerNavigator}} object that the {{ServiceWorkerContainer}} is retrieved from.

    A {{ServiceWorkerContainer}} object has an associated <dfn for="ServiceWorkerContainer">ready promise</dfn> (a <a>promise</a>). It is initially set to a new <a>promise</a>.

    A {{ServiceWorkerContainer}} object has a <a>task source</a> called the <dfn export id="dfn-client-message-queue" for="ServiceWorkerContainer">client message queue</dfn>, initially empty. A [=ServiceWorkerContainer/client message queue=] can be enabled or disabled, and is initially disabled. When a {{ServiceWorkerContainer}} object's [=ServiceWorkerContainer/client message queue=] is enabled, the <a>event loop</a> *must* use it as one of its <a>task sources</a>. When the {{ServiceWorkerContainer}} object's <a>relevant global object</a> is a {{Window}} object, all <a>tasks</a> <a lt="queue a task">queued</a> on its [=ServiceWorkerContainer/client message queue=] *must* be associated with its <a>relevant settings object</a>'s <a>responsible document</a>.

    <section algorithm="navigator-service-worker-controller">
      <h4 id="navigator-service-worker-controller">{{ServiceWorkerContainer/controller}}</h4>

      <dfn attribute for="ServiceWorkerContainer"><code>controller</code></dfn> attribute *must* run these steps:

        1. Let |client| be the <a>context object</a>'s [=ServiceWorkerContainer/service worker client=].
        1. Return the {{ServiceWorker}} object that represents |client|'s <a>active service worker</a>.

      Note: {{ServiceWorkerContainer/controller|navigator.serviceWorker.controller}} returns <code>null</code> 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.
    </section>

    <section algorithm="navigator-service-worker-ready">
      <h4 id="navigator-service-worker-ready">{{ServiceWorkerContainer/ready}}</h4>

      <dfn attribute for="ServiceWorkerContainer"><code>ready</code></dfn> attribute *must* run these steps:

        1. If the <a>context object</a>'s [=ServiceWorkerContainer/ready promise=] is settled, return the <a>context object</a>'s [=ServiceWorkerContainer/ready promise=].
        1. Let |client| be the <a>context object</a>'s [=ServiceWorkerContainer/service worker client=].
        1. Let |clientURL| be |client|'s <a>creation URL</a>.
        1. Run the following substeps <a>in parallel</a>:
            1. *CheckRegistration*: Let |registration| be the result of running <a>Match Service Worker Registration</a> algorithm with |clientURL|.
            1. If |registration| is null, then:
                1. Wait until <a>scope to registration map</a> has a new entry.
                1. Jump to the step labeled *CheckRegistration*.
            1. If |registration|'s <a>active worker</a> is null, wait until |registration|'s <a>active worker</a> changes.

                Note: Implementers should consider this condition is met when the corresponding registration request gets to the step 6 of <a>Activate</a> algorithm.

            1. Resolve <a>context object</a>'s [=ServiceWorkerContainer/ready promise=] with the {{ServiceWorkerRegistration}} object which represents |registration|.
        1. Return <a>context object</a>'s [=ServiceWorkerContainer/ready promise=].

      Note: When the {{ServiceWorkerContainer/ready}} attribute is accessed, the returned <a>promise</a> will never reject. Instead, it waits until the <a>promise</a> resolves with a [=/service worker registration=] that has an <a>active worker</a>.
    </section>

    <section algorithm="navigator-service-worker-register">
      <h4 id="navigator-service-worker-register">{{ServiceWorkerContainer/register(scriptURL, options)}}</h4>

      Note: The {{ServiceWorkerContainer/register(scriptURL, options)}} method creates or updates a [=/service worker registration=] for the given [=service worker registration/scope url=]. If successful, a [=/service worker registration=] ties the provided |scriptURL| to a [=service worker registration/scope url=], which is subsequently used for <a lt="handle fetch">navigation matching</a>.

      <dfn method for="ServiceWorkerContainer"><code>register(|scriptURL|, |options|)</code></dfn> method *must* run these steps:

        1. Let |p| be a <a>promise</a>.
        1. Let |client| be the <a>context object</a>'s [=ServiceWorkerContainer/service worker client=].
        1. Let |scriptURL| be the result of <a lt="URL parser">parsing</a> |scriptURL| with the <a>context object</a>'s <a>relevant settings object</a>'s <a>API base URL</a>.
        1. If |scriptURL| is failure, reject |p| with a <code>TypeError</code> and abort these steps.
        1. If |scriptURL|'s [=url/scheme=] is not one of "<code>http</code>" and "<code>https</code>", reject |p| with a <code>TypeError</code> and abort these steps.
        1. If any of the strings in |scriptURL|'s [=url/path=] contains either <a>ASCII case-insensitive</a> "<code>%2f</code>" or <a>ASCII case-insensitive</a> "<code>%5c</code>", reject |p| with a <code>TypeError</code> and abort these steps.
        1. Let |scopeURL| be null.
        1. If |options|.{{RegistrationOptions/scope}} is <a lt="present">not present</a>, set |scopeURL| to the result of <a lt="url parser">parsing</a> a string "<code>./</code>" with |scriptURL|.

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

        1. Else, set |scopeURL| to the result of <a lt="url parser">parsing</a> |options|.{{RegistrationOptions/scope}} with the <a>context object</a>'s <a>relevant settings object</a>'s <a>API base URL</a>.
        1. If |scopeURL| is failure, reject |p| with a <code>TypeError</code> and abort these steps.
        1. If |scopeURL|'s [=url/scheme=] is not one of "<code>http</code>" and "<code>https</code>", reject |p| with a <code>TypeError</code> and abort these steps.
        1. If any of the strings in |scopeURL|'s [=url/path=] contains either <a>ASCII case-insensitive</a> "<code>%2f</code>" or <a>ASCII case-insensitive</a> "<code>%5c</code>", reject |p| with a <code>TypeError</code> and abort these steps.
        1. Let |job| be the result of running <a>Create Job</a> with *register*, |scopeURL|, |scriptURL|, |p|, and |client|.
        1. Set |job|'s [=job/worker type=] to |options|.{{RegistrationOptions/type}}.
        1. Set |job|'s [=job/use cache=] to |options|.{{RegistrationOptions/useCache}}.
        1. Invoke <a>Schedule Job</a> with |job|.
        1. Return |p|.
    </section>

    <section algorithm="navigator-service-worker-getRegistration">
      <h4 id="navigator-service-worker-getRegistration">{{ServiceWorkerContainer/getRegistration(clientURL)}}</h4>

      <dfn method for="ServiceWorkerContainer"><code>getRegistration(|clientURL|)</code></dfn> method *must* run these steps:

        1. Let |client| be the <a>context object</a>'s [=ServiceWorkerContainer/service worker client=].
        1. Let |clientURL| be the result of <a lt="URL parser">parsing</a> |clientURL| with the <a>context object</a>'s <a>relevant settings object</a>'s <a>API base URL</a>.
        1. If |clientURL| is failure, return a <a>promise</a> rejected with a <code>TypeError</code>.
        1. If the [=environment settings object/origin=] of |clientURL| is not |client|'s [=environment settings object/origin=], return a |promise| rejected with a "{{SecurityError}}" exception.
        1. Let |promise| be a new <a>promise</a>.
        1. Run the following substeps <a>in parallel</a>:
            1. Let |registration| be the result of running <a>Match Service Worker Registration</a> algorithm with |clientURL| as its argument.
            1. If |registration| is not null, then:
                1. Resolve |promise| with the {{ServiceWorkerRegistration}} object which represents |registration|.
            1. Else:
                1. Resolve |promise| with undefined.
        1. Return |promise|.
    </section>

    <section algorithm="navigator-service-worker-getRegistrations">
      <h4 id="navigator-service-worker-getRegistrations">{{ServiceWorkerContainer/getRegistrations()}}</h4>

      <dfn method for="ServiceWorkerContainer"><code>getRegistrations()</code></dfn> method *must* run these steps:

        1. Let |client| be the <a>context object</a>'s [=ServiceWorkerContainer/service worker client=].
        1. Let |promise| be a new <a>promise</a>.
        1. Run the following substeps <a>in parallel</a>:
            1. Let |array| be an empty array.
            1. [=map/For each=] |key| → |value| of <a>scope to registration map</a>:
                1. If the [=url/origin=] of the result of <a lt="URL parser">parsing</a> |key| is the <a lt="same origin">same</a> as |client|'s [=environment settings object/origin=], and |value|'s <a>uninstalling flag</a> is unset, add the {{ServiceWorkerRegistration}} object associated with |value| to the |array|.
            1. Resolve |promise| with |array|.
        1. Return |promise|.
    </section>

    <section algorithm="navigator-service-worker-startMessages">
      <h4 id="navigator-service-worker-startMessages">{{ServiceWorkerContainer/startMessages()}}</h4>

      <dfn method for="ServiceWorkerContainer"><code>startMessages()</code></dfn> method *must* enable the <a>context object</a>'s [=ServiceWorkerContainer/client message queue=] if it is not enabled.
    </section>

    <section>
      <h4 id="service-worker-container-event-handlers">Event handlers</h4>

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

      <table class="data">
        <thead>
          <tr>
            <th><a>event handler</a></th>
            <th><a>event handler event type</a></th>
          </tr>
        </thead>
        <tbody>
          <tr>
            <td><dfn attribute for="ServiceWorkerContainer"><code>oncontrollerchange</code></dfn></td>
            <td>{{ServiceWorkerContainer/controllerchange!!event}}</td>
          </tr>
          <tr>
            <td><dfn attribute for="ServiceWorkerContainer"><code>onmessage</code></dfn></td>
            <td>{{ServiceWorkerContainer/message!!event}}</td>
          </tr>
          <tr>
            <td><dfn attribute for="ServiceWorkerContainer"><code>onmessageerror</code></dfn></td>
            <td>{{ServiceWorkerContainer/messageerror!!event}}</td>
          </tr>
        </tbody>
      </table>

      The first time the <a>context object</a>'s {{ServiceWorkerContainer/onmessage}} IDL attribute is set, its [=ServiceWorkerContainer/client message queue=] *must* be enabled.
    </section>
  </section>
  <section>
    <h3 id="document-context-events">Events</h3>

    The following event is dispatched on {{ServiceWorker}} object:

    <table class="data">
      <thead>
        <tr>
          <th>Event name</th>
          <th>Interface</th>
          <th>Dispatched when&mldr;</th>
        </tr>
      </thead>
      <tbody>
        <tr>
          <td><dfn event for="ServiceWorker"><code>statechange</code></dfn></td>
          <td>{{Event}}</td>
          <td>The {{ServiceWorker/state}} attribute of the {{ServiceWorker}} object is changed.</td>
        </tr>
      </tbody>
    </table>

    The following event is dispatched on {{ServiceWorkerRegistration}} object:

    <table class="data">
      <thead>
        <tr>
          <th>Event name</th>
          <th>Interface</th>
          <th>Dispatched when&mldr;</th>
        </tr>
      </thead>
      <tbody>
        <tr>
          <td><dfn event for="ServiceWorkerRegistration" id="service-worker-registration-updatefound-event"><code>updatefound</code></dfn></td>
          <td>{{Event}}</td>
          <td>The [=ServiceWorkerRegistration/service worker registration=]'s <a>installing worker</a> changes. (See step 8 of the <a>Install</a> algorithm.)</td>
        </tr>
      </tbody>
    </table>

    The following events are dispatched on {{ServiceWorkerContainer}} object:

    <table class="data" dfn-for="ServiceWorkerContainer">
      <thead>
        <tr>
          <th>Event name</th>
          <th>Interface</th>
          <th>Dispatched when&mldr;</th>
        </tr>
      </thead>
      <tbody>
        <tr>
          <td><dfn event id="service-worker-container-controllerchange-event"><code>controllerchange</code></dfn></td>
          <td>{{Event}}</td>
          <td>The [=ServiceWorkerContainer/service worker client=]'s <a>active service worker</a> changes. (See step 9.2 of the <a>Activate</a> algorithm. The <a>skip waiting flag</a> of a [=/service worker=] causes <a lt="activate">activation</a> of the [=/service worker registration=] to occur while [=/service worker clients=] are <a>using</a> the [=/service worker registration=], {{ServiceWorkerContainer/controller|navigator.serviceWorker.controller}} immediately reflects the <a>active worker</a> as the [=/service worker=] that <a>controls</a> the [=/service worker client=].)</td>
        </tr>
      </tbody>
    </table>
  </section>
</section>

<section>
  <h2 id="execution-context">Execution Context</h2>

  <div class="example">
    Serving Cached Resources:

    <pre highlight="js">
      // caching.js
      self.addEventListener("install", event => {
        event.waitUntil(
          // Open a cache of resources.
          caches.open("shell-v1").then(cache => {
            // Begins the process of fetching them.
            // The coast is only clear when all the resources are ready.
            return cache.addAll([
              "/app.html",
              "/assets/v1/base.css",
              "/assets/v1/app.js",
              "/assets/v1/logo.png",
              "/assets/v1/intro_video.webm"
            ]);
          })
        );
      });

      self.addEventListener("fetch", event => {
        // No "fetch" events are dispatched to the service worker until it
        // successfully installs and activates.

        // All operations on caches are async, including matching URLs, so we use
        // promises heavily. e.respondWith() even takes promises to enable this:
        event.respondWith(
          caches.match(e.request).then(response => {
            return response || fetch(e.request);
          }).catch(() => {
            return caches.match("/fallback.html");
          })
        );
      });
    </pre>
  </div>

  <section>
    <h3 id="serviceworkerglobalscope-interface">{{ServiceWorkerGlobalScope}}</h3>

    <pre class="idl">
      [Global=(Worker,ServiceWorker), Exposed=ServiceWorker]
      interface ServiceWorkerGlobalScope : WorkerGlobalScope {
        [SameObject] readonly attribute Clients clients;
        [SameObject] readonly attribute ServiceWorkerRegistration registration;

        [NewObject] Promise&lt;void&gt; skipWaiting();

        attribute EventHandler oninstall;
        attribute EventHandler onactivate;
        attribute EventHandler onfetch;

        // event
        attribute EventHandler onmessage; // event.source of the message events is Client object
        attribute EventHandler onmessageerror;
      };
    </pre>

    A {{ServiceWorkerGlobalScope}} object represents the global execution context of a [=/service worker=]. A {{ServiceWorkerGlobalScope}} object has an associated <dfn for="ServiceWorkerGlobalScope">service worker</dfn> (a [=/service worker=]). A {{ServiceWorkerGlobalScope}} object has an associated <dfn for="ServiceWorkerGlobalScope">force bypass cache for importscripts flag</dfn>. It is initially unset.

    Note: {{ServiceWorkerGlobalScope}} object provides generic, event-driven, time-limited script execution contexts that run at an origin. Once successfully <a>registered</a>, a [=/service worker=] is started, kept alive and killed by their relationship to events, not [=/service worker clients=]. Any type of synchronous requests must not be initiated inside of a [=/service worker=].

    <section>
      <h4 id="service-worker-global-scope-clients">{{ServiceWorkerGlobalScope/clients}}</h4>

      <dfn attribute for="ServiceWorkerGlobalScope"><code>clients</code></dfn> attribute *must* return the {{Clients}} object that is associated with the <a>context object</a>.
    </section>

    <section>
      <h4 id="service-worker-global-scope-registration">{{ServiceWorkerGlobalScope/registration}}</h4>

      The <dfn attribute for="ServiceWorkerGlobalScope"><code>registration</code></dfn> attribute *must* return the {{ServiceWorkerRegistration}} object that represents the [=ServiceWorkerGlobalScope/service worker=]'s <a>containing service worker registration</a>.
    </section>

    <section algorithm="service-worker-global-scope-skipwaiting">
      <h4 id="service-worker-global-scope-skipwaiting">{{ServiceWorkerGlobalScope/skipWaiting()}}</h4>

      Note: The {{ServiceWorkerGlobalScope/skipWaiting()}} method allows this [=/service worker=] to progress from the [=service worker/registration=]'s <a lt="waiting worker">waiting</a> position to <a lt="active worker">active</a> even while [=/service worker clients=] are <a>using</a> the [=service worker/registration=].

      <dfn method for="ServiceWorkerGlobalScope"><code>skipWaiting()</code></dfn> method *must* run these steps:

        1. Let |promise| be a new <a>promise</a>.
        1. Run the following substeps <a>in parallel</a>:
            1. Set [=ServiceWorkerGlobalScope/service worker=]'s <a>skip waiting flag</a>.
            1. Invoke [=Try Activate=] with [=ServiceWorkerGlobalScope/service worker=]'s [=containing service worker registration=].
            1. Resolve |promise| with undefined.
        1. Return |promise|.
    </section>

    <section>
      <h4 id="service-worker-global-scope-event-handlers">Event handlers</h4>

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

      <table class="data">
        <thead>
          <tr>
            <th><a>event handler</a></th>
            <th><a>event handler event type</a></th>
          </tr>
        </thead>
        <tbody>
          <tr>
            <td><dfn attribute for="ServiceWorkerGlobalScope"><code>oninstall</code></dfn></td>
            <td>{{install!!event}}</td>
          </tr>
          <tr>
            <td><dfn attribute for="ServiceWorkerGlobalScope"><code>onactivate</code></dfn></td>
            <td>{{activate!!event}}</td>
          </tr>
          <tr>
            <td><dfn attribute for="ServiceWorkerGlobalScope"><code>onfetch</code></dfn></td>
            <td>{{fetch!!event}}</td>
          </tr>
          <tr>
            <td><dfn attribute for="ServiceWorkerGlobalScope"><code>onmessage</code></dfn></td>
            <td>{{message!!event}}</td>
          </tr>
          <tr>
            <td><dfn attribute for="ServiceWorkerGlobalScope"><code>onmessageerror</code></dfn></td>
            <td>{{messageerror!!event}}</td>
          </tr>
        </tbody>
      </table>
    </section>
  </section>

  <section>
    <h3 id="client-interface">{{Client}}</h3>

    <pre class="idl">
      [Exposed=ServiceWorker]
      interface Client {
        readonly attribute USVString url;
        readonly attribute DOMString id;
        readonly attribute ClientType type;
        readonly attribute boolean reserved;
        void postMessage(any message, optional sequence&lt;object&gt; transfer = []);
      };

      [Exposed=ServiceWorker]
      interface WindowClient : Client {
        readonly attribute VisibilityState visibilityState;
        readonly attribute boolean focused;
        [SameObject] readonly attribute FrozenArray&lt;USVString&gt; ancestorOrigins;
        [NewObject] Promise&lt;WindowClient&gt; focus();
        [NewObject] Promise&lt;WindowClient&gt; navigate(USVString url);
      };
    </pre>

    A {{Client}} object has an associated <dfn for="Client">service worker client</dfn> (a [=/service worker client=]).

    A {{Client}} object has an associated <dfn for="Client">reserved state</dfn>, which is either true or false.

    A {{WindowClient}} object has an associated <dfn id="dfn-service-worker-client-visibilitystate">visibility state</dfn>, which is one of {{Document/visibilityState}} attribute value.

    A {{WindowClient}} object has an associated <dfn id="dfn-service-worker-client-focusstate">focus state</dfn>, which is either true or false (initially false).

    A {{WindowClient}} object has an associated <dfn for="WindowClient">ancestor origins array</dfn>.

    <section>
      <h4 id="client-url">{{Client/url}}</h4>

      The <dfn attribute for="Client"><code>url</code></dfn> attribute *must* return the <a>context object</a>'s associated [=Client/service worker client=]'s <a lt="URL serializer">serialized</a> <a>creation URL</a>.
    </section>

    <section>
      <h4 id="client-id">{{Client/id}}</h4>

      The <dfn attribute for="Client"><code>id</code></dfn> attribute *must* return its associated [=Client/service worker client=]'s [=environment/id=].
    </section>

    <section>
      <h4 id="client-type">{{Client/type}}</h4>

      The <dfn attribute for="Client"><code>type</code></dfn> attribute *must* run these steps:

        1. Let |client| be [=context object=]'s [=Client/service worker client=].
        1. If |client| is an [=environment settings object=], then:
            1. If |client| is a [=window client=], return {{ClientType/"window"}}.
            1. Else if |client| is a [=dedicated worker client=], return {{ClientType/"worker"}}.
            1. Else if |client| is a [=shared worker client=], return {{ClientType/"sharedworker"}}.
        1. Else:
            1. Return {{ClientType/"window"}}.
    </section>

    <section>
      <h4 id="client-reserved">{{Client/reserved}}</h4>

      The <dfn attribute for="Client"><code>reserved</code></dfn> attribute *must* return the <a>context object</a>'s associated [=Client/reserved state=].
    </section>

    <section algorithm="client-postmessage">
      <h4 id="client-postmessage">{{Client/postMessage(message, transfer)}}</h4>

      The <dfn method for="Client"><code>postMessage(|message|, |transfer|)</code></dfn> method *must* run these steps:

        1. Let |sourceSettings| be the <a>context object</a>'s <a>relevant settings object</a>.
        1. Let |destination| be the {{ServiceWorkerContainer}} object whose [=ServiceWorkerContainer/service worker client=] is the <a>context object</a>'s [=Client/service worker client=].
        1. If |destination| is null, <a>throw</a> an "{{InvalidStateError}}" exception.
        1. Let |serializeWithTransferResult| be <a abstract-op>StructuredSerializeWithTransfer</a>(|message|, |transfer|). Rethrow any exceptions.
        1. Add a <a>task</a> that runs the following steps to |destination|'s [=ServiceWorkerContainer/client message queue=]:
            1. Let |origin| be the [=Unicode serialization of an origin|Unicode serialization=] of |sourceSettings|'s [=environment settings object/origin=].
            1. Let |source| be a {{ServiceWorker}} object, which represents the [=ServiceWorkerGlobalScope/service worker=] associated with |sourceSettings|'s [=environment settings object/global object=].
            1. Let |deserializeRecord| be <a abstract-op>StructuredDeserializeWithTransfer</a>(|serializeWithTransferResult|, |destination|'s [=relevant Realm=]).

                If this throws an exception, [=fire an event=] named {{messageerror!!event}} at |destination|, using {{MessageEvent}}, with the {{MessageEvent/origin}} attribute initialized to |origin| and the {{MessageEvent/source}} attribute initialized to |source|, and then abort these steps.
            1. Let |messageClone| be |deserializeRecord|.\[[Deserialized]].
            1. Let |newPorts| be a new [=frozen array type|frozen array=] consisting of all {{MessagePort}} objects in |deserializeRecord|.\[[TransferredValues]], if any,
            1. [=Dispatch|Dispatch an event=] named {{Window/message!!event}} at |destination|, using {{MessageEvent}}, with the {{MessageEvent/origin}} attribute initialized to |origin|, the {{MessageEvent/source}} attribute initialized to |source|, the {{MessageEvent/data}} attribute initialized to |messageClone|, and the {{MessageEvent/ports}} attribute initialized to |newPorts|.
    </section>

    <section>
      <h4 id="client-visibilitystate">{{WindowClient/visibilityState}}</h4>

      The <dfn attribute for="WindowClient"><code>visibilityState</code></dfn> attribute *must* return the <a>context object</a>'s <a>visibility state</a>.
    </section>

    <section>
      <h4 id="client-focused">{{WindowClient/focused}}</h4>

      The <dfn attribute for="WindowClient"><code>focused</code></dfn> attribute *must* return the <a>context object</a>'s <a>focus state</a>.
    </section>

    <section>
      <h4 id="client-ancestororigins">{{WindowClient/ancestorOrigins}}</h4>

      The <dfn attribute for="WindowClient"><code>ancestorOrigins</code></dfn> attribute *must* return the <a>context object</a>'s associated [=WindowClient/ancestor origins array=].
    </section>

    <section algorithm="client-focus">
      <h4 id="client-focus">{{WindowClient/focus()}}</h4>

      The <dfn method for="WindowClient"><code>focus()</code></dfn> method *must* run these steps:

        1. If this algorithm is not <a>triggered by user activation</a>, return a <a>promise</a> rejected with an "{{InvalidAccessError}}" exception.
        1. Let |promise| be a new <a>promise</a>.
        1. Run these substeps <a>in parallel</a>:
            1. Let |browsingContext| be the <a>context object</a>'s associated [=Client/service worker client=]'s [=environment settings object/global object=]'s [=/browsing context=].
            1. Let |visibilityState| be null.
            1. Let |focusState| be false.
            1. Let |ancestorOriginsList| be the empty list.
            1. <a>Queue a task</a> |task| to run the following substeps on the <a>context object</a>'s associated [=Client/service worker client=]'s <a>responsible event loop</a> using the <a>user interaction task source</a>:
                1. Run the <a>focusing steps</a> with |browsingContext|.
                1. Set |visibilityState| to |browsingContext|'s <a>active document</a>'s {{Document/visibilityState}} attribute value.
                1. Set |focusState| to the result of running the <a>has focus steps</a> with |browsingContext|'s <a>active document</a> as the argument.
                1. Set |ancestorOriginsList| to |browsingContext|'s <a>active document</a>'s <a>relevant global object</a>'s {{Location}} object's [=Location/ancestor origins list=]'s associated list.
            1. Wait for |task| to have executed.
            1. Let |windowClient| be the result of running <a>Create Window Client</a> algorithm with the <a>context object</a>'s associated [=Client/service worker client=], |visibilityState|, |focusState|, and |ancestorOriginsList| as the arguments.
            1. If |windowClient|'s <a>focus state</a> is true, resolve |promise| with |windowClient|.
            1. Else, reject |promise| with a <code>TypeError</code>.
        1. Return |promise|.
    </section>

    <section algorithm="client-navigate">
      <h4 id="client-navigate">{{WindowClient/navigate(url)}}</h4>

      The <dfn method for="WindowClient"><code>navigate()</code></dfn> method *must* run these steps:

        1. Let |url| be the result of <a lt="URL parser">parsing</a> |url| with the <a>context object</a>'s <a>relevant settings object</a>'s <a>API base URL</a>.
        1. If |url| is failure, return a <a>promise</a> rejected with a <code>TypeError</code>.
        1. If |url| is <code>about:blank</code>, return a <a>promise</a> rejected with a <code>TypeError</code>.
        1. If the <a>context object</a>'s associated [=Client/service worker client=]'s <a>active service worker</a> is not the <a>context object</a>'s <a>relevant global object</a>'s [=ServiceWorkerGlobalScope/service worker=], return a <a>promise</a> rejected with a <code>TypeError</code>.
        1. Let |promise| be a new <a>promise</a>.
        1. Run these substeps <a>in parallel</a>:
            1. Let |browsingContext| be the <a>context object</a>'s associated [=Client/service worker client=]'s [=environment settings object/global object=]'s [=/browsing context=].
            1. If |browsingContext| has <a lt="discard a document">discarded</a> its {{Document}}, reject |promise| with a <code>TypeError</code> and abort these steps.
            1. Let |navigateFailed| be false.
            1. Let |visibilityState| be null.
            1. Let |focusState| be false.
            1. Let |ancestorOriginsList| be the empty list.
            1. <a>Queue a task</a> |task| to run the following substeps on the <a>context object</a>'s associated [=Client/service worker client=]'s <a>responsible event loop</a> using the <a>user interaction task source</a>:
                1. *HandleNavigate*: <a>Navigate</a> |browsingContext| to |url| with <a lt="exceptions enabled flag">exceptions enabled</a>. The <a>source browsing context</a> must be |browsingContext|.
                1. If the algorithm steps invoked in the step labeled *HandleNavigate* <a>throws</a> an exception, set |navigateFailed| to true.
                1. Set |visibilityState| to |browsingContext|'s <a>active document</a>'s {{Document/visibilityState}} attribute value.
                1. Set |focusState| to the result of running the <a>has focus steps</a> with |browsingContext|'s <a>active document</a> as the argument.
                1. Set |ancestorOriginsList| to |browsingContext|'s <a>active document</a>'s <a>relevant global object</a>'s {{Location}} object's [=Location/ancestor origins list=]'s associated list.
            1. Wait for |task| to have executed (including its asynchronous steps).
            1. If |navigateFailed| is true, reject |promise| with a <code>TypeError</code> and abort these steps.
            1. If |browsingContext|'s {{Window}} object's <a>environment settings object</a>'s <a>creation URL</a>'s [=url/origin=] is not the <a lt="same origin">same</a> as the [=ServiceWorkerGlobalScope/service worker=]'s [=environment settings object/origin=], then:
                1. Resolve |promise| with null.
                1. Abort these steps.
            1. Let |windowClient| be the result of running <a>Create Window Client</a> algorithm with |browsingContext|'s {{Window}} object's <a>environment settings object</a>, |visibilityState|, |focusState|, and |ancestorOriginsList| as the arguments.
            1. Resolve |promise| with |windowClient|.
        1. Return |promise|.
    </section>
  </section>

  <section>
    <h3 id="clients-interface">{{Clients}}</h3>

    <pre class="idl">
      [Exposed=ServiceWorker]
      interface Clients {
        // The objects returned will be new instances every time
        [NewObject] Promise&lt;any&gt; get(DOMString id);
        [NewObject] Promise&lt;sequence&lt;Client&gt;&gt; matchAll(optional ClientQueryOptions options);
        [NewObject] Promise&lt;WindowClient?&gt; openWindow(USVString url);
        [NewObject] Promise&lt;void&gt; claim();
      };
    </pre>
    <pre class="idl" id="serviceworker-client-query-options-dictionary">
      dictionary ClientQueryOptions {
        boolean includeUncontrolled = false;
        boolean includeReserved = false;
        ClientType type = "window";
      };
    </pre>
    <pre class="idl" id="client-type-enum">
      enum ClientType {
        "window",
        "worker",
        "sharedworker",
        "all"
      };
    </pre>

    The user agent *must* create a {{Clients}} object when a {{ServiceWorkerGlobalScope}} object is created and associate it with that object.

    <section algorithm="clients-get">
      <h4 id="clients-get">{{Clients/get(id)}}</h4>

      The <dfn method for="Clients"><code>get(|id|)</code></dfn> method *must* run these steps:

        1. Let |promise| be a new <a>promise</a>.
        1. Run these substeps <a>in parallel</a>:
            1. For each [=/service worker client=] |client| whose [=service worker client/origin=] is the <a lt="same origin">same</a> as the associated [=ServiceWorkerGlobalScope/service worker=]'s [=environment settings object/origin=]:
                1. If |client|'s [=environment/id=] is not |id|, continue to the next iteration of the loop.
                1. If |client| is an [=environment settings object=], then:
                    1. If |client| is not a <a>secure context</a>, reject |promise| with a "{{SecurityError}}" exception and abort these steps.
                1. Else:
                    1. If |client|’s <a>creation URL</a> is not a <a>potentially trustworthy URL</a>, reject |promise| with a "{{SecurityError}}" exception and abort these steps.
                1. If |client| is an [=environment settings object=] and is not a [=window client=], then:
                    1. Let |clientObject| be the result of running <a>Create Client</a> algorithm with |client| as the argument.
                    1. Resolve |promise| with |clientObject| and abort these steps.
                1. Else:
                    1. Let |browsingContext| be null.
                    1. Let |visibilityState| be null.
                    1. Let |focusState| be false.
                    1. Let |ancestorOriginsList| be the empty list.
                    1. If |client| is an [=environment settings object=], set |browsingContext| to |client|'s [=environment settings object/global object=]'s [=/browsing context=].
                    1. Else, set |browsingContext| to |client|’s [=environment/target browsing context=].
                    1. <a>Queue a task</a> |task| to run the following substeps on |browsingContext|'s <a>event loop</a> using the <a>user interaction task source</a>:
                        1. Set |visibilityState| to |browsingContext|'s <a>active document</a>'s {{Document/visibilityState}} attribute value.
                        1. Set |focusState| to the result of running the <a>has focus steps</a> with |browsingContext|'s <a>active document</a> as the argument.
                        1. If |client| is a <a>window client</a>, set |ancestorOriginsList| to |browsingContext|'s <a>active document</a>'s <a>relevant global object</a>'s {{Location}} object's [=Location/ancestor origins list=]'s associated list.
                    1. Wait for |task| to have executed.
                    1. Let |windowClient| be the result of running <a>Create Window Client</a> algorithm with |client|, |visibilityState|, |focusState|, and |ancestorOriginsList| as the arguments.
                    1. Resolve |promise| with |windowClient| and abort these steps.
            1. Resolve |promise| with undefined.
        1. Return |promise|.
    </section>

    <section algorithm="clients-getall">
      <h4 id="clients-getall">{{Clients/matchAll(options)}}</h4>

      The <dfn method for="Clients"><code>matchAll(|options|)</code></dfn> method *must* run these steps:

        1. Let |promise| be a new <a>promise</a>.
        1. Run these substeps <a>in parallel</a>:
            1. Let |targetClients| be an empty array.
            1. For each [=/service worker client=] |client| whose [=service worker client/origin=] is the <a lt="same origin">same</a> as the associated [=ServiceWorkerGlobalScope/service worker=]'s [=environment settings object/origin=]:
                1. If |client| is an [=environment settings object=], then:
                    1. If |client| is not a <a>secure context</a>, continue to the next iteration of the loop.
                1. Else:
                    1. If |client|’s <a>creation URL</a> is not a <a>potentially trustworthy URL</a>, continue to the next iteration of the loop.
                1. If |options|.{{ClientQueryOptions/includeUncontrolled}} is false, then:
                    1. If |client|'s <a>active service worker</a> is not the associated [=ServiceWorkerGlobalScope/service worker=], continue to the next iteration of the loop.
                1. If |options|.{{ClientQueryOptions/includeReserved}} is false, then:
                    1. If |client|'s [=environment/execution ready flag=] is unset, continue to the next iteration of the loop.
                1. Add |client| to |targetClients|.
            1. Let |matchedClients| be an empty array.
            1. For each [=/service worker client=] |client| in |targetClients|:
                1. If |options|.{{ClientQueryOptions/type}} is {{ClientType/"window"}} or {{ClientType/"all"}}, and |client| is not an [=environment settings object=] or is a [=window client=], then:
                    1. Let |browsingContext| be null.
                    1. Let |isClientEnumerable| be true.
                    1. Let |visibilityState| be the empty string.
                    1. Let |focusState| be false.
                    1. Let |ancestorOriginsList| be the empty list.
                    1. If |client| is an [=environment settings object=], set |browsingContext| to |client|'s [=environment settings object/global object=]'s [=/browsing context=].
                    1. Else, set |browsingContext| to |client|’s [=environment/target browsing context=].
                    1. <a>Queue a task</a> |task| to run the following substeps on |browsingContext|'s <a>event loop</a> using the <a>user interaction task source</a>:
                        1. If |browsingContext| has been <a lt="a browsing context is discarded">discarded</a>, set |isClientEnumerable| to false and abort these steps.
                        1. If |client| is a window client and |client|'s <a>responsible document</a> is not |browsingContext|'s <a>active document</a>,  set |isClientEnumerable| to false and abort these steps.
                        1. Set |visibilityState| to |browsingContext|'s <a>active document</a>'s {{Document/visibilityState}} attribute value.
                        1. Set |focusState| to the result of running the <a>has focus steps</a> with |browsingContext|'s <a>active document</a> as the argument.
                        1. It |client| is a <a>window client</a>, set |ancestorOriginsList| to |browsingContext|'s <a>active document</a>'s <a>relevant global object</a>'s {{Location}} object's [=Location/ancestor origins list=]'s associated list.
                    1. Wait for |task| to have executed.

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

                    1. If |isClientEnumerable| is true, then:
                        1. Let |windowClient| be the result of running <a>Create Window Client</a> algorithm with |client|, |visibilityState|, |focusState|, and |ancestorOriginsList| as the arguments.
                        1. Add |windowClient| to |matchedClients|.
                1. Else if |options|.{{ClientQueryOptions/type}} is {{ClientType/"worker"}} or {{ClientType/"all"}} and |client| is a [=dedicated worker client=], or |options|.{{ClientQueryOptions/type}} is {{ClientType/"sharedworker"}} or {{ClientType/"all"}} and |client| is a [=shared worker client=], then:
                    1. Let |clientObject| be the result of running <a>Create Client</a> algorithm with |client| as the argument.
                    1. Add |clientObject| to |matchedClients|.
            1. Sort |matchedClients| such that:
                * {{WindowClient}} objects are always placed before {{Client}} objects whose associated [=Client/service worker clients=] are <a>worker clients</a>.
                * {{WindowClient}} objects that have been <a lt="focusing steps">focused</a> are placed first sorted in the most recently <a lt="focusing steps">focused</a> order, and {{WindowClient}} objects that have never been <a lt="focusing steps">focused</a> are placed next sorted in their [=Client/service worker clients=]' creation order.
                * {{Client}} objects whose associated [=Client/service worker clients=] are <a>worker clients</a> are placed next sorted in their [=Client/service worker clients=]' creation order.
            1. Resolve |promise| with |matchedClients|.
        1. Return |promise|.
    </section>

    <section algorithm="clients-openwindow">
      <h4 id="clients-openwindow">{{Clients/openWindow(url)}}</h4>

      The <dfn method for="Clients"><code>openWindow(|url|)</code></dfn> method *must* run these steps:
        1. Let |url| be the result of <a lt="URL parser">parsing</a> |url| with the <a>context object</a>'s <a>relevant settings object</a>'s <a>API base URL</a>.
        1. If |url| is failure, return a <a>promise</a> rejected with a <code>TypeError</code>.
        1. If |url| is <code>about:blank</code>, return a <a>promise</a> rejected with a <code>TypeError</code>.
        1. If this algorithm is not <a>triggered by user activation</a>, return a <a>promise</a> rejected with an "{{InvalidAccessError}}" exception.
        1. Let |promise| be a new <a>promise</a>.
        1. Run these substeps <a>in parallel</a>:
            1. Let |newContext| be a new <a>top-level browsing context</a>.
            1. Let |openWindowFailed| to false.
            1. Let |visibilityState| be null.
            1. Let |focusState| be false.
            1. Let |ancestorOriginsList| be the empty list.
            1. <a>Queue a task</a> |task| to run the following substeps on |newContext|'s {{Window}} object's <a>environment settings object</a>'s <a>responsible event loop</a> using the <a>user interaction task source</a>:
                1. *HandleNavigate*: <a>Navigate</a> |newContext| to |url| with <a lt="exceptions enabled flag">exceptions enabled</a> and <a>replacement enabled</a>.
                1. If the algorithm steps invoked in the step labeled *HandleNavigate* <a>throws</a> an exception, set |openWindowFailed| to true.
                1. Set |visibilityState| to |newContext|'s <a>active document</a>'s {{Document/visibilityState}} attribute value.
                1. Set |focusState| to the result of running the <a>has focus steps</a> with |newContext|'s <a>active document</a> as the argument.
                1. Set |ancestorOriginsList| to |newContext|'s <a>active document</a>'s <a>relevant global object</a>'s {{Location}} object's [=Location/ancestor origins list=]'s associated list.
            1. Wait for |task| to have executed (including its asynchronous steps).
            1. If |openWindowFailed| is true, reject |promise| with a <code>TypeError</code> and abort these steps.
            1. If |newContext|'s {{Window}} object's <a>environment settings object</a>'s <a>creation URL</a>'s [=environment settings object/origin=] is not the <a lt="same origin">same</a> as the [=ServiceWorkerGlobalScope/service worker=]'s [=environment settings object/origin=], then:
                1. Resolve |promise| with null.
                1. Abort these steps.
            1. Let |client| be the result of running <a>Create Window Client</a> algorithm with |newContext|'s {{Window}} object's <a>environment settings object</a>, |visibilityState|, |focusState|, and |ancestorOriginsList| as the arguments.
            1. Resolve |promise| with |client|.
        1. Return |promise|.
    </section>

    <section algorithm="clients-claim">
      <h4 id="clients-claim">{{Clients/claim()}}</h4>

      The <dfn method for="Clients"><code>claim()</code></dfn> method *must* run these steps:

        1. If the [=ServiceWorkerGlobalScope/service worker=] is not an <a>active worker</a>, return a <a>promise</a> rejected with an "{{InvalidStateError}}" exception.
        1. Let |promise| be a new <a>promise</a>.
        1. Run the following substeps <a>in parallel</a>:
            1. For each [=/service worker client=] |client| whose [=service worker client/origin=] is the <a lt="same origin">same</a> as the [=ServiceWorkerGlobalScope/service worker=]'s [=environment settings object/origin=]:
                1. If |client| is an [=environment settings object=], then:
                    1. If |client| is not a <a>secure context</a>, continue to the next iteration of the loop.
                1. Else:
                    1. If |client|’s <a>creation URL</a> is not a <a>potentially trustworthy URL</a>, continue to the next iteration of the loop.
                1. Let |registration| be the result of running <a>Match Service Worker Registration</a> algorithm passing |client|'s <a>creation URL</a> as the argument.
                1. If |registration| is not the [=ServiceWorkerGlobalScope/service worker=]'s <a>containing service worker registration</a>, continue to the next iteration of the loop.
                1. If |client|'s <a>active service worker</a> is not the [=ServiceWorkerGlobalScope/service worker=], then:
                    1. Invoke <a>Handle Service Worker Client Unload</a> with |client| as the argument.
                    1. Set |client|'s <a>active service worker</a> to [=ServiceWorkerGlobalScope/service worker=].
                    1. Invoke <a>Notify Controller Change</a> algorithm with |client| as the argument.
            1. Resolve |promise| with undefined.
        1. Return |promise|.
    </section>
  </section>

  <section>
    <h3 id="extendableevent-interface">{{ExtendableEvent}}</h3>

    <pre class="idl">
      [Constructor(DOMString type, optional ExtendableEventInit eventInitDict), Exposed=ServiceWorker]
      interface ExtendableEvent : Event {
        void waitUntil(Promise&lt;any&gt; f);
      };
    </pre>
    <pre class="idl" id="extendable-event-init-dictionary">
      dictionary ExtendableEventInit : EventInit {
        // Defined for the forward compatibility across the derived events
      };
    </pre>

    An {{ExtendableEvent}} object has an associated <dfn for="ExtendableEvent">extend lifetime promises</dfn> (an array of <a>promises</a>). It is initially an empty array.

    An {{ExtendableEvent}} object has an associated <dfn for="ExtendableEvent">pending promises count</dfn> (the number of pending promises in the [=ExtendableEvent/extend lifetime promises=]). It is initially set to zero.

    [=/Service workers=] have two <a>lifecycle events</a>, {{install!!event}} and {{activate!!event}}. [=/Service workers=] use the {{ExtendableEvent}} interface for {{activate!!event}} event and {{install!!event}} event.

    <a href="#extensibility">Service worker extensions</a> that <a href="#extension-to-service-worker-global-scope">define event handlers</a> *may* also use or extend the {{ExtendableEvent}} interface.

    <section algorithm="wait-until-method">
      <h4 id="wait-until-method">{{ExtendableEvent/waitUntil()|event.waitUntil(f)}}</h4>

      {{ExtendableEvent/waitUntil()}} method extends the lifetime of the event.

      <dfn method for="ExtendableEvent"><code>waitUntil(|f|)</code></dfn> method *must* run these steps:

        1. If the [=ExtendableEvent/pending promises count=] is zero and the [=dispatch flag=] is unset, then:
            1. <a>Throw</a> an "{{InvalidStateError}}" exception.
            1. Abort these steps.

            Note: If no lifetime extension promise has been added in the task that called the event handlers), calling {{ExtendableEvent/waitUntil()}} in subsequent asynchronous tasks will throw.

        1. Add |f| to the [=ExtendableEvent/extend lifetime promises=].
        1. Increment the [=ExtendableEvent/pending promises count=] by one.

            Note: The [=ExtendableEvent/pending promises count=] is incremented even if the given promise has already been settled. The corresponding count decrement is done in the microtask queued by the reaction to the promise.

        1. Upon [=upon fulfillment|fulfillment=] or [=upon rejection|rejection=] of |f|, [=queue a microtask=] to run these substeps:
            1. Decrement the [=ExtendableEvent/pending promises count=] by one.
            1. Let |registration| be the [=context object=]'s [=relevant global object=]'s associated [=ServiceWorkerGlobalScope/service worker=]'s [=containing service worker registration=].
            1. If |registration|'s [=uninstalling flag=] is set, invoke [=Try Clear Registration=] with |registration|.
            1. If |registration| is not null, invoke [=Try Activate=] with |registration|.

        The user agent *should not* <a lt="terminate service worker">terminate</a> the [=/service worker=] associated with |event|'s <a>relevant settings object</a>'s [=environment settings object/global object=] when |event|'s [=dispatch flag=] is set or |event|'s [=ExtendableEvent/pending promises count=] is not zero. However, the user agent *may* impose a time limit to this lifetime extension.
    </section>

    [=/Service workers=] and <a href="#extensibility">extensions</a> that <a href="#extension-to-service-worker-global-scope">define event handlers</a> *may* define their own behaviors, allowing the [=ExtendableEvent/extend lifetime promises=] to suggest operation length, and the rejected state of any of the <a>promise</a> in [=ExtendableEvent/extend lifetime promises=] to suggest operation failure.

    [=/Service workers=] define the following behaviors for <code><a>install</a></code> event and <code><a>activate</a></code> event, respectively:

      * Adding a <a>promise</a> |f| to the event's <a>extend lifetime promises</a> delays treating the <a>installing worker</a> as *installed* (i.e. a <a>waiting worker</a>) until all the <a>promises</a> in the <a>extend lifetime promises</a> resolve successfully. (See step 11.3.1 of <a>Install</a> algorithm.) If |f| rejects, the installation fails. This is primarily used to ensure that a [=/service worker=] is not considered *installed* (i.e. a <a>waiting worker</a>) until all of the core caches it depends on are populated.
      * Adding a <a>promise</a> to the event's <a>extend lifetime promises</a> delays treating the <a>active worker</a> as *activated* until all the <a>promises</a> in the <a>extend lifetime promises</a> settle. (See step 12.3 of <a>Activate</a> algorithm.) This is primarily used to ensure that any <a>functional events</a> are not dispatched to the {{ServiceWorkerGlobalScope}} object that represents the [=/service worker=] until it upgrades database schemas and deletes the outdated cache entries.
  </section>

  <section>
    <h3 id="fetchevent-interface">{{FetchEvent}}</h3>

    <pre class="idl">
      [Constructor(DOMString type, FetchEventInit eventInitDict), Exposed=ServiceWorker]
      interface FetchEvent : ExtendableEvent {
        [SameObject] readonly attribute Request request;
        readonly attribute DOMString clientId;
        readonly attribute DOMString reservedClientId;
        readonly attribute DOMString targetClientId;

        void respondWith(Promise&lt;Response&gt; r);
      };
    </pre>
    <pre class="idl" id="fetch-event-init-dictionary">
      dictionary FetchEventInit : ExtendableEventInit {
        required Request request;
        DOMString clientId = "";
        DOMString reservedClientId = "";
        DOMString targetClientId = "";
      };
    </pre>

    [=/Service workers=] have an essential <a>functional event</a> {{fetch!!event}}. For {{fetch!!event}} event, [=/service workers=] use the {{FetchEvent}} interface which extends the {{ExtendableEvent}} interface.

    Each event using {{FetchEvent}} interface has an associated <dfn for="FetchEvent">potential response</dfn> (a [=/response=]), initially set to null, and the following associated flags that are initially unset:

      * <dfn for="FetchEvent">wait to respond flag</dfn>
      * <dfn for="FetchEvent">respond-with entered flag</dfn>
      * <dfn for="FetchEvent">respond-with error flag</dfn>

    <section>
      <h4 id="fetch-event-request">{{FetchEvent/request|event.request}}</h4>

      <dfn attribute for="FetchEvent"><code>request</code></dfn> attribute *must* return the value it was initialized to.
    </section>

    <section>
      <h4 id="fetch-event-clientid">{{FetchEvent/clientId|event.clientId}}</h4>

      <dfn attribute for="FetchEvent"><code>clientId</code></dfn> attribute *must* return the value it was initialized to. When an <a>event</a> is created the attribute *must* be initialized to the empty string.
    </section>

    <section>
      <h4 id="fetch-event-reservedclientid">{{FetchEvent/reservedClientId|event.reservedClientId}}</h4>

      <dfn attribute for="FetchEvent"><code>reservedClientId</code></dfn> attribute *must* return the value it was initialized to. When an <a>event</a> is created the attribute *must* be initialized to the empty string.
    </section>

    <section>
      <h4 id="fetch-event-targetclientid">{{FetchEvent/targetClientId|event.targetClientId}}</h4>

      <dfn attribute for="FetchEvent"><code>targetClientId</code></dfn> attribute *must* return the value it was initialized to. When an <a>event</a> is created the attribute *must* be initialized to the empty string.
    </section>

    <section algorithm="fetch-event-respondwith">
      <h4 id="fetch-event-respondwith">{{FetchEvent/respondWith(r)|event.respondWith(r)}}</h4>

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

      <dfn method for="FetchEvent"><code>respondWith(|r|)</code></dfn> method *must* run these steps:

        1. If the <a>dispatch flag</a> is unset, then:
            1. <a>Throw</a> an "{{InvalidStateError}}" exception.
            1. Abort these steps.
        1. If the [=FetchEvent/respond-with entered flag=] is set, then:
            1. <a>Throw</a> an "{{InvalidStateError}}" exception.
            1. Abort these steps.
        1. Add |r| to the <a>extend lifetime promises</a>.
        1. Increment the [=ExtendableEvent/pending promises count=] by one.

            Note: The [=ExtendableEvent/pending promises count=] is incremented even if the given promise has already been settled. The corresponding count decrement is done in the microtask queued by the reaction to the promise.

        1. Upon [=upon fulfillment|fulfillment=] or [=upon rejection|rejection=] of |r|, [=queue a microtask=] to run these substeps:
            1. Decrement the [=ExtendableEvent/pending promises count=] by one.
            1. Let |registration| be the [=context object=]'s [=relevant global object=]'s associated [=ServiceWorkerGlobalScope/service worker=]'s [=containing service worker registration=].
            1. If |registration|'s [=uninstalling flag=] is set, invoke [=Try Clear Registration=] with |registration|.
            1. If |registration| is not null, invoke [=Try Activate=] with |registration|.

            Note: {{FetchEvent/respondWith(r)|event.respondWith(r)}} extends the lifetime of the event by default as if {{ExtendableEvent/waitUntil()|event.waitUntil(r)}} is called.

        1. Set the <a>stop propagation flag</a> and <a>stop immediate propagation flag</a>.
        1. Set the [=FetchEvent/respond-with entered flag=].
        1. Set the [=FetchEvent/wait to respond flag=].
        1. Let |targetRealm| be the <a>relevant Realm</a> of the <a>context object</a>.
        1. Run the following substeps <a>in parallel</a>:
            1. Wait until |r| settles.
            1. If |r| rejected, then:
                1. Set the [=FetchEvent/respond-with error flag=].
            1. If |r| resolved with |response|, then:
                1. If |response| is a {{Response}} object, then:
                    1. If |response| is [=Body/disturbed=] or [=Body/locked=], then:
                        1. Set the [=FetchEvent/respond-with error flag=].
                    1. Else:
                        1. Let |bytes| be an empty byte sequence.
                        1. Let |end-of-body| be false.
                        1. Let |done| be false.
                        1. Let |potentialResponse| be a copy of |response|'s associated [=Response/response=], except for its [=response/body=].
                        1. If |response|'s [=response/body=] is non-null, run these substeps:
                            1. Let |reader| be the result of <a lt="get a reader">getting a reader</a> from |response|'s [=response/body=]'s <a>stream</a>.
                            1. Let |strategy| be an object created in |targetRealm|. The user agent may choose any object.
                            1. Let |pull| be an action that runs these subsubsteps:
                                1. Let |promise| be the result of <a lt="read a chunk">reading a chunk</a> from |response|'s [=response/body=]'s <a>stream</a> with |reader|.
                                1. When |promise| is fulfilled with an object whose <code>done</code> property is false and whose <code>value</code> property is a <code>Uint8Array</code> object, append the bytes represented by the <code>value</code> property to |bytes| and perform ! <a>DetachArrayBuffer</a> with the <code>ArrayBuffer</code> object wrapped by the <code>value</code> property.
                                1. When |promise| is fulfilled with an object whose <code>done</code> property is true, set |end-of-body| to true.
                                1. When |promise| is fulfilled with a value that matches with neither of the above patterns, or |promise| is rejected, [=ReadableStream/error=] |newStream| with a <code>TypeError</code>.
                            1. Let |cancel| be an action that [=ReadableStream/cancels=] |response|'s [=response/body=]'s <a>stream</a> with |reader|.
                            1. Let |newStream| be the result of [=ReadableStream/construct a ReadableStream object=] with |strategy|, |pull| and |cancel| in |targetRealm|.
                            1. Set |potentialResponse|'s [=response/body=] to a new [=/body=] whose <a>stream</a> is |newStream|.
                            1. Run these subsubsteps repeatedly <a>in parallel</a> while |done| is false:
                                1. If |newStream| is <a>errored</a>, then set |done| to true.
                                1. Otherwise, if |bytes| is empty and |end-of-body| is true, then [=ReadableStream/close=] |newStream| and set |done| to true.
                                1. Otherwise, if |bytes| is not empty, run these subsubsubsteps:
                                    1. Let |chunk| be a subsequence of |bytes| starting from the beginning of |bytes|.
                                    1. Remove |chunk| from |bytes|.
                                    1. Let |buffer| be an <code>ArrayBuffer</code> object created in |targetRealm| and containing |chunk|.
                                    1. [=ReadableStream/Enqueue=] a <code>Uint8Array</code> object created in |targetRealm| and wrapping |buffer| to |newStream|.

                            Note: These substeps are meant to produce the observable equivalent of "piping" |response|'s [=response/body=]'s <a>stream</a> into |potentialResponse|.

                        1. Set the [=FetchEvent/potential response=] to |potentialResponse|.
                1. Else:
                    1. Set the [=FetchEvent/respond-with error flag=].

                    Note: If the [=FetchEvent/respond-with error flag=] is set, a <a>network error</a> is returned to [=/Fetch=] through <a>Handle Fetch</a> algorithm. (See the step 21.1.) Otherwise, the value |response| is returned to [=/Fetch=] through <a>Handle Fetch</a> algorithm. (See the step 22.1.)

            1. Unset the [=FetchEvent/wait to respond flag=].
    </section>
  </section>

  <section>
    <h3 id="extendablemessageevent-interface">{{ExtendableMessageEvent}}</h3>

    <pre class="idl">
      [Constructor(DOMString type, optional ExtendableMessageEventInit eventInitDict), Exposed=ServiceWorker]
      interface ExtendableMessageEvent : ExtendableEvent {
        readonly attribute any data;
        readonly attribute USVString origin;
        readonly attribute DOMString lastEventId;
        [SameObject] readonly attribute (Client or ServiceWorker or MessagePort)? source;
        readonly attribute FrozenArray&lt;MessagePort&gt; ports;
      };
    </pre>
    <pre class="idl" id="extendablemessage-event-init-dictionary">
      dictionary ExtendableMessageEventInit : ExtendableEventInit {
        any data = null;
        USVString origin = "";
        DOMString lastEventId = "";
        (Client or ServiceWorker or MessagePort)? source = null;
        sequence&lt;MessagePort&gt; ports = [];
      };
    </pre>

    [=/Service workers=] define the <a method lt="waitUntil()" for="ExtendableEvent">extendable</a> {{message!!event}} event to allow extending the lifetime of the event. For the {{message!!event}} event, [=/service workers=] use the {{ExtendableMessageEvent}} interface which extends the {{ExtendableEvent}} interface.

    <section>
      <h4 id="extendablemessage-event-data">{{ExtendableMessageEvent/data|event.data}}</h4>

      The <dfn attribute for="ExtendableMessageEvent">data</dfn> 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.
    </section>

    <section>
      <h4 id="extendablemessage-event-origin">{{ExtendableMessageEvent/origin|event.origin}}</h4>

      The <dfn attribute for="ExtendableMessageEvent">origin</dfn> 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 [=environment settings object/origin=] of the [=/service worker client=] that sent the message.
    </section>

    <section>
      <h4 id="extendablemessage-event-lasteventid">{{ExtendableMessageEvent/lastEventId|event.lastEventId}}</h4>

      The <dfn attribute for="ExtendableMessageEvent">lastEventId</dfn> attribute *must* return the value it was initialized to. When the object is created, this attribute *must* be initialized to the empty string.
    </section>

    <section>
      <h4 id="extendablemessage-event-source">{{ExtendableMessageEvent/source|event.source}}</h4>

      The <dfn attribute for="ExtendableMessageEvent">source</dfn> 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.
    </section>

    <section>
      <h4 id="extendablemessage-event-ports">{{ExtendableMessageEvent/ports|event.ports}}</h4>

      The <dfn attribute for="ExtendableMessageEvent">ports</dfn> attribute *must* return the value it was initialized to. When the object is created, this attribute *must* be initialized to the empty array. It represents the {{MessagePort}} array being sent.
    </section>
  </section>

  <section>
    <h3 id="execution-context-events">Events</h3>

    The following events are dispatched on {{ServiceWorkerGlobalScope}} object:

    <table class="data" dfn-for="ServiceWorkerGlobalScope">
      <thead>
        <tr>
          <th>Event name</th>
          <th>Interface</th>
          <th>Dispatched when&mldr;</th>
        </tr>
      </thead>
      <tbody>
        <tr>
          <td><dfn event id="service-worker-global-scope-install-event"><code>install</code></dfn></td>
          <td>{{ExtendableEvent}}</td>
          <td>[<a>Lifecycle event</a>] The [=ServiceWorkerGlobalScope/service worker=]'s <a>containing service worker registration</a>'s <a>installing worker</a> changes. (See step 11.2 of the <a>Install</a> algorithm.)</td>
        </tr>
        <tr>
          <td><dfn event id="service-worker-global-scope-activate-event"><code>activate</code></dfn></td>
          <td>{{ExtendableEvent}}</td>
          <td>[<a>Lifecycle event</a>] The [=ServiceWorkerGlobalScope/service worker=]'s <a>containing service worker registration</a>'s <a>active worker</a> changes. (See step 12.2 of the <a>Activate</a> algorithm.)</td>
        </tr>
        <tr>
          <td><dfn event id="service-worker-global-scope-fetch-event"><code>fetch</code></dfn></td>
          <td>{{FetchEvent}}</td>
          <td>[<a>Functional event</a>] The [=/http fetch=] invokes <a>Handle Fetch</a> with |request|. As a result of performing <a>Handle Fetch</a>, the [=ServiceWorkerGlobalScope/service worker=] returns a [=/response=] to the [=/http fetch=]. The [=/response=], represented by a {{Response}} object, can be retrieved from a {{Cache}} object or directly from network using {{WindowOrWorkerGlobalScope/fetch(input, init)|self.fetch(input, init)}} method. (A custom {{Response}} object can be another option.)</td>
        </tr>
        <tr>
          <td><dfn event><code>message</code></dfn></td>
          <td>{{ExtendableMessageEvent}}</td>
          <td>When it receives a message.</td>
        </tr>
        <tr>
          <td><dfn event><code>messageerror</code></dfn></td>
          <td>{{MessageEvent}}</td>
          <td>When it was sent a message that cannot be deserialized.</td>
        </tr>
      </tbody>
    </table>
  </section>
</section>


<section>
  <h2 id="cache-objects">Caches</h2>

  To allow authors to fully manage their content caches for offline use, the {{Window}} and the {{WorkerGlobalScope}} provide the asynchronous caching methods that open and manipulate {{Cache}} objects. An [=environment settings object/origin=] can have multiple, named {{Cache}} objects, whose contents are entirely under the control of scripts. Caches are not shared across [=/origins=], and they are completely isolated from the browser's HTTP cache.

  <section>
    <h3 id="cache-constructs">Constructs</h3>

    A <dfn id="dfn-fetching-record">fetching record</dfn> is a <a>Record</a> {\[[key]], \[[value]]} where \[[key]] is a {{Request}} and \[[value]] is a {{Response}}.

    A <a>fetching record</a> has an associated <dfn id="dfn-incumbent-record">incumbent record</dfn> (a <a>fetching record</a>). It is initially set to null.

    A <dfn id="dfn-request-to-response-map">request to response map</dfn> is a <a>List</a> of <a>fetching records</a>.

    A <dfn id="dfn-name-to-cache-map">name to cache map</dfn> is an <a>ordered map</a> where the keys are strings that represents a name of the {{Cache}} object, and the values are {{Cache}} objects.

    Each [=/origin=] has an associated <a>name to cache map</a>.
  </section>

  <section>
    <h3 id="cache-lifetimes">Understanding Cache Lifetimes</h3>

    The {{Cache}} instances are not part of the browser's HTTP cache. The {{Cache}} objects are exactly what authors have to manage themselves. The {{Cache}} objects do not get updated unless authors explicitly request them to be. The {{Cache}} objects do not expire unless authors delete the entries. The {{Cache}} objects do not disappear just because the [=/service worker=] script is updated. That is, caches are not updated automatically. Updates must be manually managed. This implies that authors should version their caches by name and make sure to use the caches only from the version of the [=/service worker=] that can safely operate on.
  </section>

  <section>
    <h3 id="self-caches">{{WindowOrWorkerGlobalScope/caches|self.caches}}</h3>

    <pre class="idl">
      partial interface WindowOrWorkerGlobalScope {
        [SecureContext, SameObject] readonly attribute CacheStorage caches;
      };
    </pre>

    <section>
      <h4 id="global-caches">{{WindowOrWorkerGlobalScope/caches}}</h4>

      <dfn attribute for="WindowOrWorkerGlobalScope" id="global-caches-attribute"><code>caches</code></dfn> attribute *must* return this object's associated {{CacheStorage}} object.
    </section>
  </section>

  <section>
    <h3 id="cache-interface">{{Cache}}</h3>

    <pre class="idl">
      [SecureContext, Exposed=(Window,Worker)]
      interface Cache {
        [NewObject] Promise&lt;any&gt; match(RequestInfo request, optional CacheQueryOptions options);
        [NewObject] Promise&lt;sequence&lt;Response&gt;&gt; matchAll(optional RequestInfo request, optional CacheQueryOptions options);
        [NewObject] Promise&lt;void&gt; add(RequestInfo request);
        [NewObject] Promise&lt;void&gt; addAll(sequence&lt;RequestInfo&gt; requests);
        [NewObject] Promise&lt;void&gt; put(RequestInfo request, Response response);
        [NewObject] Promise&lt;boolean&gt; delete(RequestInfo request, optional CacheQueryOptions options);
        [NewObject] Promise&lt;sequence&lt;Request&gt;&gt; keys(optional RequestInfo request, optional CacheQueryOptions options);
      };
    </pre>
    <pre class="idl" id="cache-query-options-dictionary">
      dictionary CacheQueryOptions {
        boolean ignoreSearch = false;
        boolean ignoreMethod = false;
        boolean ignoreVary = false;
        DOMString cacheName;
      };
    </pre>
    <pre class="idl" id="cache-batch-operation-dictionary">
      dictionary CacheBatchOperation {
        DOMString type;
        Request request;
        Response response;
        CacheQueryOptions options;
      };
    </pre>

    A {{Cache}} object represents a <a>request to response map</a>. Multiple separate objects implementing the {{Cache}} interface across documents and workers can all be associated with the same <a>request to response map</a> simultaneously.

    {{Cache}} objects are always enumerable via {{WindowOrWorkerGlobalScope/caches|self.caches}} in insertion order (per <a lt="map objects">ECMAScript 6 Map objects</a>).

    <section algorithm="cache-match">
      <h4 id="cache-match">{{Cache/match(request, options)}}</h4>

      <dfn method for="Cache"><code>match(|request|, |options|)</code></dfn> method *must* run these steps:

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

    <section algorithm="cache-matchall">
      <h4 id="cache-matchall">{{Cache/matchAll(request, options)}}</h4>

      <dfn method for="Cache"><code>matchAll(|request|, |options|)</code></dfn> method *must* run these steps:

        1. Let |r| be null.
        1. If the optional argument |request| is not omitted, then:
            1. If |request| is a {{Request}} object, then:
                1. Set |r| to |request|'s [=Request/request=].
                1. If |r|'s [=request/method=] is not \`<code>GET</code>\` and |options|.ignoreMethod is false, return a <a>promise</a> resolved with an empty array.
            1. Else if |request| is a string, then:
                1. Set |r| to the associated [=Request/request=] of the result of invoking the initial value of {{Request}} as constructor with |request| as its argument. If this <a>throws</a> an exception, return a <a>promise</a> rejected with that exception.
        1. Let |promise| be a new <a>promise</a>.
        1. Run these substeps <a>in parallel</a>:
            1. Let |responseArray| be an empty array.
            1. If the optional argument |request| is omitted, then:
                1. For each <a>fetching record</a> |entry| of its <a>request to response map</a>, in key insertion order:
                    1. Add a  copy of |entry|.\[[value]] to |responseArray|.
                1. Resolve |promise| with |responseArray|.
                1. Abort these steps.
            1. Else:
                1. Let |entries| be the result of running <a>Query Cache</a> algorithm passing a {{Request}} object associated with |r| and |options| as the arguments.
                1. For each |entry| of |entries|:
                    1. Let |response| be null.
                    1. If the <a>incumbent record</a> |incumbentRecord| of the corresponding <a>fetching record</a> in <a>request to response map</a> is not null, set |response| to a copy of |incumbentRecord|.\[[value]].
                    1. Else, set |response| to a copy of |entry|[1].
                    1. Add |response| to |responseArray|.
                1. Resolve |promise| with |responseArray|.
        1. Return |promise|.
    </section>

    <section algorithm="cache-add">
      <h4 id="cache-add">{{Cache/add(request)}}</h4>

      <dfn method for="Cache"><code>add(|request|)</code></dfn> method *must* run these steps:

        1. Let |requests| be an array containing only |request|.
        1. Set |responseArrayPromise| to the result of running the algorithm specified in {{Cache/addAll(requests)}} passing |requests| as the argument.
        1. Return the result of <a>transforming</a> |responseArrayPromise| with a fulfillment handler that returns undefined.
    </section>

    <section algorithm="cache-addAll">
      <h4 id="cache-addAll">{{Cache/addAll(requests)}}</h4>

      <dfn method for="Cache"><code>addAll(|requests|)</code></dfn> method *must* run these steps:

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

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

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

    <section algorithm="cache-put">
      <h4 id="cache-put">{{Cache/put(request, response)}}</h4>

      <dfn method for="Cache"><code>put(|request|, |response|)</code></dfn> method *must* run these steps:

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

    <section algorithm="cache-delete">
      <h4 id="cache-delete">{{Cache/delete(request, options)}}</h4>

      <dfn method for="Cache"><code>delete(|request|, |options|)</code></dfn> method *must* run these steps:

        1. Let |r| be null.
        1. If |request| is a {{Request}} object, then:
            1. Set |r| to |request|'s [=Request/request=].
            1. If |r|'s [=request/method=] is not \`<code>GET</code>\` and |options|.ignoreMethod is false, return a <a>promise</a> resolved with false.
        1. Else if |request| is a string, then:
            1. Set |r| to the associated [=Request/request=] of the result of invoking the initial value of {{Request}} as constructor with |request| as its argument. If this <a>throws</a> an exception, return a <a>promise</a> rejected with that exception.
        1. Let |operations| be an empty array.
        1. Let |o| be an empty object representing a {{CacheBatchOperation}} dictionary.
        1. Set the {{CacheBatchOperation/type}} dictionary member of |o| to "delete".
        1. Set the {{CacheBatchOperation/request}} dictionary member of |o| to a {{Request}} object associated with |r|.
        1. Set the {{CacheBatchOperation/options}} dictionary member of |o| to |options|.
        1. Add |o| to |operations|.
        1. Let |resultPromise| be the result of running <a>Batch Cache Operations</a> passing |operations| as the argument.
        1. Return the result of <a>transforming</a> |resultPromise| with a fulfillment handler, when called with argument |responseArray|, performs the following substeps <a>in parallel</a>:
            1. If |responseArray| is not null, return true.
            1. Else, return false.
    </section>

    <section algorithm="cache-keys">
      <h4 id="cache-keys">{{Cache/keys(request, options)}}</h4>

      <dfn method for="Cache"><code>keys(|request|, |options|)</code></dfn> method *must* run these steps:

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

  <section>
    <h3 id="cachestorage-interface">{{CacheStorage}}</h3>

    <pre class="idl">
      [SecureContext, Exposed=(Window,Worker)]
      interface CacheStorage {
        [NewObject] Promise&lt;any&gt; match(RequestInfo request, optional CacheQueryOptions options);
        [NewObject] Promise&lt;boolean&gt; has(DOMString cacheName);
        [NewObject] Promise&lt;Cache&gt; open(DOMString cacheName);
        [NewObject] Promise&lt;boolean&gt; delete(DOMString cacheName);
        [NewObject] Promise&lt;sequence&lt;DOMString&gt;&gt; keys();
      };
    </pre>
    <!--FIXME(jungkees): set method is not entirely dropped yet. Promise&lt;any&gt; set(DOMString key, Cache val);-->

    Note: {{CacheStorage}} interface is designed to largely conform to <a lt="map objects">ECMAScript 6 Map objects</a> but entirely async, and with additional convenience methods. The methods, <code>clear</code>, <code>forEach</code>, <code>entries</code> and <code>values</code>, are intentionally excluded from the scope of the first version resorting to the ongoing discussion about the async iteration by TC39.

    The user agent *must* create a {{CacheStorage}} object when a {{Window}} object or a {{WorkerGlobalScope}} object is created and associate it with that <dfn for="CacheStorage">global object</dfn>.

    A {{CacheStorage}} object represents a <a>name to cache map</a> of its associated [=CacheStorage/global object=]'s <a>environment settings object</a>'s [=environment settings object/origin=]. Multiple separate objects implementing the {{CacheStorage}} interface across documents and workers can all be associated with the same <a>name to cache map</a> simultaneously.

    <section algorithm="cache-storage-match">
      <h4 id="cache-storage-match">{{CacheStorage/match(request, options)}}</h4>

      <dfn method for="CacheStorage"><code>match(|request|, |options|)</code></dfn> method *must* run these steps:

        1. If |options|.{{CacheQueryOptions/cacheName}} is <a>present</a>, then:
            1. Return a new <a>promise</a> |p| and run the following substeps <a>in parallel</a>:
                1. [=map/For each=] |cacheName| → |cache| of <a>name to cache map</a>:
                    1. If |options|.{{CacheQueryOptions/cacheName}} matches |cacheName|, then:
                        1. Resolve |p| with the result of running the algorithm specified in {{Cache/match(request, options)}} method of {{Cache}} interface with |request| and |options| as the arguments (providing |cache| as thisArgument to the <a>\[[Call]]</a> internal method of {{Cache/match(request, options)}}.)
                        1. Abort these steps.
                1. Resolve |p| with undefined.
        1. Else:
            1. Let |p| be a <a>promise</a> resolved with undefined.
            1. [=map/For each=] <var ignore>cacheName</var> → |cache| of <a>name to cache map</a>:
                1. Set |p| to the result of <a>transforming</a> itself with a fulfillment handler that, when called with argument |v|, performs the following substeps <a>in parallel</a>:
                    1. If |v| is not undefined, return |v|.
                    1. Return the result of running the algorithm specified in {{Cache/match(request, options)}} method of {{Cache}} interface with |request| and |options| as the arguments (providing |cache|] as thisArgument to the <a>\[[Call]]</a> internal method of {{Cache/match(request, options)}}.)
            1. Return |p|.
    </section>

    <section algorithm="cache-storage-has">
      <h4 id="cache-storage-has">{{CacheStorage/has(cacheName)}}</h4>

      <dfn method for="CacheStorage"><code>has(|cacheName|)</code></dfn> method *must* run these steps:

        1. Return a <a>promise</a> resolved with the result of running the following substeps:
            1. [=map/For each=] |key| → <var ignore>value</var> of <a>name to cache map</a>:
                1. If |cacheName| matches |key|, then:
                    1. Return true.
            1. Return false.
    </section>

    <section algorithm="cache-storage-open">
      <h4 id="cache-storage-open">{{CacheStorage/open(cacheName)}}</h4>

      <dfn method for="CacheStorage"><code>open(|cacheName|)</code></dfn> method *must* run these steps:

        1. Let |p| be a new <a>promise</a>.
        1. Run the following substeps:
            1. [=map/For each=] |key| → |value| of <a>name to cache map</a>:
                1. If |cacheName| matches |key|, then:
                    1. Resolve |p| with a new {{Cache}} object which is a copy of |value|.
                    1. Abort these steps.
            1. Let |cache| be a new {{Cache}} object.
            1. [=map/Set=] <a>name to cache map</a>[|cacheName|] to |cache|. If this cache write operation failed due to exceeding the granted quota limit, reject |p| with a "{{QuotaExceededError}}" exception and abort these steps.
            1. Resolve |p| with |cache|.
        1. Return |p|.
    </section>

    <section algorithm="cache-storage-delete">
      <h4 id="cache-storage-delete">{{CacheStorage/delete(cacheName)}}</h4>

      <dfn method for="CacheStorage"><code>delete(|cacheName|)</code></dfn> method *must* run these steps:

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

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

            1. Else:
                1. Return false.
    </section>

    <section algorithm="cache-storage-keys">
      <h4 id="cache-storage-keys">{{CacheStorage/keys()}}</h4>

      <dfn method for="CacheStorage"><code>keys()</code></dfn> method *must* run these steps:

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

        1. Let |cacheKeys| be the result of [=map/get the keys|getting the keys=] of <a>name to cache map</a>.
        1. Return |cacheKeys|.
    </section>
  </section>
</section>

<section>
  <h2 id="security-considerations">Security Considerations</h2>

  <section>
    <h3 id="secure-context">Secure Context</h3>

    [=/Service workers=] *must* execute in <a>secure contexts</a>. [=/Service worker clients=] *must* also be <a>secure contexts</a> to register a [=/service worker registration=], to get access to the [=/service worker registrations=] and the [=/service workers=], to do messaging with the [=/service workers=], and to be manipulated by the [=/service workers=].

    Note: This effectively means that [=/service workers=] and their [=/service worker clients=] need to be hosted over HTTPS. A user agent can allow <code>localhost</code> (see <a href="https://w3c.github.io/webappsec-secure-contexts/#localhost">the requirements</a>), <code>127.0.0.0/8</code>, and <code>::1/128</code> for development purposes. The primary reason for this restriction is to protect users from the <a href="https://w3c.github.io/webappsec-secure-contexts/#threat-risks">risks associated with insecure contexts</a>.
  </section>

  <section>
    <h3 id="content-security-policy">Content Security Policy</h3>

    Whenever a user agent invokes <a>Run Service Worker</a> algorithm with a [=/service worker=] |serviceWorker|:

      * If |serviceWorker|'s <a>script resource</a> was delivered with a <code>Content-Security-Policy</code> HTTP header containing the value |policy|, the user agent *must* <a>enforce</a> |policy| for |serviceWorker|.
      * If |serviceWorker|'s <a>script resource</a> was delivered with a <code>Content-Security-Policy-Report-Only</code> HTTP header containing the value |policy|, the user agent *must* <a>monitor</a> |policy| for |serviceWorker|.

    The primary reason for this restriction is to mitigate a broad class of content injection vulnerabilities, such as cross-site scripting (XSS).
  </section>

  <section>
    <h3 id="origin-relativity">Origin Relativity</h3>

    <section>
      <h4 id="origin-restriction">Origin restriction</h4>

      *This section is non-normative.*

      A [=/service worker=] executes in the registering [=/service worker client=]'s [=environment settings object/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 <a>importScripts()</a>. 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.
    </section>

    <section>
      <h4 id="importscripts">{{WorkerGlobalScope/importScripts(urls)}}</h4>

      When the <dfn method for="ServiceWorkerGlobalScope" id="importscripts-method"><code>importScripts(|urls|)</code></dfn> method is called on a {{ServiceWorkerGlobalScope}} object, the user agent *must* <a>import scripts into worker global scope</a>, given this {{ServiceWorkerGlobalScope}} object and |urls|, and with the following steps to [=fetching scripts/perform the fetch=] given the [=/request=] |request|:

        1. Let |serviceWorker| be |request|'s [=request/client=]'s [=environment settings object/global object=]'s [=ServiceWorkerGlobalScope/service worker=].
        1. If |serviceWorker|'s <a>imported scripts updated flag</a> is unset, then:
            1. Let |registration| be |serviceWorker|'s [=containing service worker registration=].
            1. Set |request|'s [=service-workers mode=] to "`foreign`".
            1. Set |request|'s [=request/cache mode=] to "<code>no-cache</code>" if any of the following are true:
                * |registration|'s [=service worker registration/use cache=] is false.
                * The [=current global object=]'s [=force bypass cache for importscripts flag=] is set.
                * |registration|'s [=last update check time=] is not null and the time difference in seconds calculated by the current time minus |registration|’s [=last update check time=] is greater than 86400.
            1. Let |response| be the result of <a lt="fetch">fetching</a> |request|.
            1. If |response|’s <a for="response" href="https://github.com/whatwg/fetch/issues/376">cache state</a> is not "<code>local</code>", set |registration|’s [=service worker registration/last update check time=] to the current time.
            1. [=Extract a MIME type=] from the |response|'s [=unsafe response=]'s [=response/header list=]. If this MIME type (ignoring parameters) is not a [=JavaScript MIME type=], return a [=network error=].
            1. If |response|'s <a>unsafe response</a>'s [=response/type=] is not "<code>error</code>", and |response|'s [=response/status=] is an <a>ok status</a>, then:
                1. [=map/Set=] <a>script resource map</a>[|request|'s [=request/url=]] to |response|.
            1. Return |response|.
        1. Else:
            1. If <a>script resource map</a>[|url|] [=map/exists=], return <a>script resource map</a>[|url|].
            1. Else, return a <a>network error</a>.
    </section>
  </section>

  <section>
    <h3 id="cross-origin-resources">Cross-Origin Resources and CORS</h3>

    *This section is non-normative.*

    Applications tend to cache items that come from a CDN or other [=environment settings object/origin=]. It is possible to request many of them directly using <code>&lt;script&gt;</code>, <code>&lt;img&gt;</code>, <code>&lt;video&gt;</code> and <code>&lt;link&gt;</code> elements. It would be hugely limiting if this sort of runtime collaboration broke when offline. Similarly, it is possible to [=/fetch=] many sorts of off-[=environment settings object/origin=] resources when appropriate CORS headers are set.
    [=/Service workers=] enable this by allowing {{Cache|Caches}} to [=/fetch=] and cache off-origin items. Some restrictions apply, however. First, unlike same-origin resources which are managed in the {{Cache}} as {{Response}} objects whose corresponding [=Response/responses=] are <a>basic filtered response</a>, the objects stored are {{Response}} objects whose corresponding [=Response/responses=] are either <a>CORS filtered responses</a> or <a>opaque filtered responses</a>. They can be passed to {{FetchEvent/respondWith(r)|event.respondWith(r)}} method in the same manner as the {{Response}} objects whose corresponding [=Response/responses=] are <a>basic filtered responses</a>, but cannot be meaningfully created programmatically. These limitations are necessary to preserve the security invariants of the platform. Allowing {{Cache|Caches}} to store them allows applications to avoid re-architecting in most cases.
  </section>

  <section>
    <h3 id="implementer-concerns">Implementer Concerns</h3>

    *This section is non-normative.*

    The implementers are encouraged to note:

      * Plug-ins should not load via [=/service workers=]. As plug-ins may get their security origins from their own urls, the embedding [=/service worker=] cannot handle it. For this reason, the <a>Handle Fetch</a> algorithm makes the <a>potential-navigation-or-subresource request</a> (whose context is either <code>&lt;embed&gt;</code> or <code>&lt;object&gt;</code>) immediately fallback to the network without dispatching {{fetch!!event}} event.
      * Some of the legacy networking stack code may need to be carefully audited to understand the ramifications of interactions with [=/service workers=].
  </section>

  <section>
    <h3 id="privacy">Privacy</h3>

    [=/Service workers=] introduce new persistent storage features including <a>scope to registration map</a> (for [=/service worker registrations=] and their [=/service workers=]), <a>request to response map</a> and <a>name to cache map</a> (for caches), and <a>script resource map</a> (for script resources). In order to protect users from any potential <a biblio data-biblio-type="informative" lt="unsanctioned-tracking">unsanctioned tracking</a> threat, these persistent storages *should* be cleared when users intend to clear them and *should* maintain and interoperate with existing user controls e.g. purging all existing persistent storages.
  </section>
</section>

<section>
  <h2 id="extensibility">Extensibility</h2>

  [=/Service workers=] are extensible from other specifications.

  <section>
    <h3 id="extension-to-service-worker-registration">Define API bound to Service Worker Registration</h3>

    Specifications *may* define an API tied to a [=/service worker registration=] by using <a>partial interface</a> definition to the {{ServiceWorkerRegistration}} interface where it *may* define the specification specific attributes and methods:

    <pre class="example idl" data-no-idl>
      partial interface ServiceWorkerRegistration {
        // e.g. define an API namespace
        readonly attribute APISpaceType APISpace;
        // e.g. define a method
        Promise&lt;T&gt; methodName(/* list of arguments */);
      };
    </pre>
  </section>

  <section>
    <h3 id="extension-to-extendable-event">Define Functional Event</h3>

    Specifications *may* define a <a>functional event</a> by extending {{ExtendableEvent}} interface:

    <pre class="example idl" data-no-idl>
      // e.g. define FunctionalEvent interface
      interface FunctionalEvent : ExtendableEvent {
        // add a functional event's own attributes and methods
      };
    </pre>
  </section>

  <section>
    <h3 id="extension-to-service-worker-global-scope">Define Event Handler</h3>

    Specifications *may* define an event handler attribute for the corresponding <a>functional event</a> using <a>partial interface</a> definition to the {{ServiceWorkerGlobalScope}} interface:

    <pre class="example idl" data-no-idl>
      partial interface ServiceWorkerGlobalScope {
        attribute EventHandler onfunctionalevent;
      };
    </pre>
  </section>

  <section>
    <h3 id="request-functional-event-dispatch">Request Functional Event Dispatch</h3>

    To request a <a>functional event</a> dispatch to a [=/service worker=], specifications *may* invoke <a>Handle Functional Event</a> algorithm with its [=/service worker registration=] <var ignore>registration</var> and the algorithm |callbackSteps| as the arguments.

    Specifications *may* define an algorithm |callbackSteps| where the corresponding <a>functional event</a> can be created and fired with specification specific objects. The algorithm is passed <var ignore>globalObject</var> (a {{ServiceWorkerGlobalScope}} object) at which it *may* fire its <a>functional events</a>. This algorithm is called on a <a>task</a> <a lt="queue a task">queued</a> by <a>Handle Functional Event</a> algorithm.

    Note: See an <a href="https://notifications.spec.whatwg.org/#activating-a-notification">example</a> hook defined in <a biblio data-biblio-type="informative" lt="notifications">Notifications API</a>.
  </section>
</section>

<section>
  <h2 id="algorithms">Appendix A: Algorithms</h2>

  The following definitions are the user agent's internal data structures used throughout the specification.

  A <dfn id="dfn-scope-to-registration-map">scope to registration map</dfn> is an <a>ordered map</a> where the keys are [=service worker registration/scope urls=], [=URL serializer|serialized=], and the values are [=/service worker registrations=].

  A <dfn id="dfn-job">job</dfn> is an abstraction of one of register, update, and unregister request for a [=/service worker registration=].

  <div dfn-for="job">
    A <a>job</a> has a <dfn id="dfn-job-type">job type</dfn>, which is one of *register*, *update*, and *unregister*.

    A <a>job</a> has a <dfn id="dfn-job-scope-url">scope url</dfn> (a [=/URL=]).

    A <a>job</a> has a <dfn id="dfn-job-script-url">script url</dfn> (a [=/URL=]).

    A <a>job</a> has a <dfn id="dfn-job-worker-type">worker type</dfn> ("<code>classic</code>" or "<code>module</code>").

    A <a>job</a> has a <dfn id="dfn-job-use-cache">use cache</dfn> (a boolean).

    A <a>job</a> has a <dfn id="dfn-job-client">client</dfn> (a [=/service worker client=]). It is initially null.

    A <a>job</a> has a <dfn id="dfn-job-promise">job promise</dfn> (a <a>promise</a>). It is initially null.

    A <a>job</a> has a <dfn id="dfn-job-list-of-equivalent-jobs">list of equivalent jobs</dfn> (a list of <a>jobs</a>). It is initially the empty list.

    A <a>job</a> has a <dfn id="dfn-job-force-bypass-cache-flag">force bypass cache flag</dfn>. It is initially unset.
  </div>


  Two <a>jobs</a> are <dfn id="dfn-job-equivalent">equivalent</dfn> when their <a>job type</a> is the same and:

    * For *register* and *update* <a>jobs</a>, both their [=job/scope url=] and the [=job/script url=] are the same.
    * For *unregister* <a>jobs</a>, their [=job/scope url=] is the same.

  A <dfn id="dfn-job-queue">job queue</dfn> is a thread safe queue used to synchronize the set of concurrent <a>jobs</a>. The <a>job queue</a> contains <a>jobs</a> as its elements. The <a>job queue</a> *should* satisfy the general properties of FIFO queue. A user agent *must* maintain a separate <a>job queue</a> for each [=/service worker registration=] keyed by its [=service worker registration/scope url=]. A <a>job queue</a> is initially empty. Unless stated otherwise, the <a>job queue</a> referenced from the algorithm steps is a <a>job queue</a> for the <a>job</a>'s [=job/scope url=].

  <section algorithm>
    <h3 id="create-job-algorithm"><dfn>Create Job</dfn></h3>

      : Input
      :: |jobType|, a <a>job type</a>
      :: |scopeURL|, a [=/URL=]
      :: |scriptURL|, a [=/URL=]
      :: |promise|, a <a>promise</a>
      :: |client|, a [=/service worker client=]
      : Output
      :: |job|, a <a>job</a>

      1. Let |job| be a new <a>job</a>.
      1. Set |job|'s [=job/job type=] to |jobType|.
      1. Set |job|'s [=job/scope url=] to |scopeURL|.
      1. Set |job|'s [=job/script url=] to |scriptURL|.
      1. Set |job|'s [=job/job promise=] to |promise|.
      1. Set |job|'s [=job/client=] to |client|.
      1. Return |job|.
  </section>

  <section algorithm>
    <h3 id="schedule-job-algorithm"><dfn>Schedule Job</dfn></h3>

      : Input
      :: |job|, a <a>job</a>
      : Output
      :: none

      1. If the <a>job queue</a> is empty, then:
          1. Push |job| to the <a>job queue</a> and invoke <a>Run Job</a>.
      1. Else:
          1. Let |lastJob| be the element at the back of the <a>job queue</a>.
          1. If |job| is <a>equivalent</a> to |lastJob| and |lastJob|'s [=job/job promise=] has not settled, append |job| to |lastJob|'s <a>list of equivalent jobs</a>.
          1. Else, push |job| to the <a>job queue</a>.
  </section>

  <section algorithm>
    <h3 id="run-job-algorithm"><dfn>Run Job</dfn></h3>

      : Input
      :: none
      : Output
      :: none

      1. Assert: the <a>job queue</a> is not empty.
      1. <a>Queue a task</a> to run these steps:
          1. Let |job| be the element in the front of the <a>job queue</a>.
          1. If |job|'s <a>job type</a> is *register*, run <a>Register</a> with |job| <a>in parallel</a>.
          1. Else if |job|'s <a>job type</a> is *update*, run <a>Update</a> with |job| <a>in parallel</a>.

              Note: For a register job and an update job, the user agent delays queuing a task for running the job until after a {{Document/DOMContentLoaded}} event has been dispatched to the document that initiated the job.

          1. Else if |job|'s <a>job type</a> is *unregister*, run <a>Unregister</a> with |job| <a>in parallel</a>.
  </section>

  <section algorithm>
    <h3 id="finish-job-algorithm"><dfn>Finish Job</dfn></h3>

      : Input
      :: |job|, a <a>job</a>
      : Output
      :: none

      1. Assert: the top element in the <a>job queue</a> is |job|.
      1. Pop the top element from the <a>job queue</a>.
      1. If the <a>job queue</a> is not empty, invoke <a>Run Job</a> with the top element of the <a>job queue</a>.
  </section>

  <section algorithm>
    <h3 id="resolve-job-promise-algorithm"><dfn>Resolve Job Promise</dfn></h3>

      : Input
      :: |job|, a <a>job</a>
      :: |value|, any
      : Output
      :: none

      1. If |job|'s [=job/client=] is not null, <a>queue a task</a> to resolve |job|'s [=job/job promise=] with |value| on |job|'s [=job/client=]'s <a>responsible event loop</a> using the <a>DOM manipulation task source</a> as the <a>task source</a>.
      1. For each |equivalentJob| in |job|'s <a>list of equivalent jobs</a>:
          1. If |equivalentJob|'s [=job/client=] is not null, <a>queue a task</a> to resolve |equivalentJob|'s [=job/job promise=] with |value| on |equivalentJob|'s [=job/client=]'s <a>responsible event loop</a> using the <a>DOM manipulation task source</a> as the <a>task source</a>.
  </section>

  <section algorithm>
    <h3 id="reject-job-promise-algorithm"><dfn>Reject Job Promise</dfn></h3>

      : Input
      :: |job|, a <a>job</a>
      :: |reason|, an <a>exception</a>
      : Output
      :: none

      1. If |job|'s [=job/client=] is not null, <a>queue a task</a> to reject |job|'s [=job/job promise=] with |reason| on |job|'s [=job/client=]'s <a>responsible event loop</a> using the <a>DOM manipulation task source</a> as the <a>task source</a>.
      1. For each |equivalentJob| in |job|'s <a>list of equivalent jobs</a>:
          1. If |equivalentJob|'s [=job/client=] is not null, <a>queue a task</a> to reject |equivalentJob|'s [=job/job promise=] with |reason| on |equivalentJob|'s [=job/client=]'s <a>responsible event loop</a> using the <a>DOM manipulation task source</a> as the <a>task source</a>.
  </section>

  <section algorithm>
    <h3 id="register-algorithm"><dfn>Register</dfn></h3>

      : Input
      :: |job|, a <a>job</a>
      : Output
      :: none

      1. If the result of running <a>potentially trustworthy origin</a> with the [=environment settings object/origin=] of |job|'s [=job/script url=] as the argument is <code>Not Trusted</code>, then:
          1. Invoke <a>Reject Job Promise</a> with |job| and a "{{SecurityError}}" exception.
          1. Invoke <a>Finish Job</a> with |job| and abort these steps.
      1. If the [=environment settings object/origin=] of |job|'s [=job/script url=] is not |job|'s [=job/client=]'s [=environment settings object/origin=], then:
          1. Invoke <a>Reject Job Promise</a> with |job| and a "{{SecurityError}}" exception.
          1. Invoke <a>Finish Job</a> with |job| and abort these steps.
      1. If the [=environment settings object/origin=] of |job|'s [=job/scope url=] is not |job|'s [=job/client=]'s [=environment settings object/origin=], then:
          1. Invoke <a>Reject Job Promise</a> with |job| and a "{{SecurityError}}" exception.
          1. Invoke <a>Finish Job</a> with |job| and abort these steps.
      1. Let |registration| be the result of running the <a>Get Registration</a> algorithm passing |job|'s [=job/scope url=] as the argument.
      1. If |registration| is not null, then:
          1. If |registration|'s <a>uninstalling flag</a> is set, unset it.
          1. Let |newestWorker| be the result of running the <a>Get Newest Worker</a> algorithm passing |registration| as the argument.
          1. If |newestWorker| is not null, |job|'s [=job/script url=] [=url/equals=] |newestWorker|'s [=service worker/script url=] with the *exclude fragments flag* set, and |job|'s [=job/use cache=]'s value equals |registration|'s [=service worker registration/use cache=]'s value, then:
              1. Invoke <a>Resolve Job Promise</a> with |job| and the {{ServiceWorkerRegistration}} object which represents |registration|.
              1. Invoke <a>Finish Job</a> with |job| and abort these steps.
      1. Else:
          1. Invoke <a>Set Registration</a> algorithm with |job|'s [=job/scope url=] and |job|'s [=job/use cache=].
      1. Invoke <a>Update</a> algorithm passing |job| as the argument.
  </section>

  <section algorithm>
    <h3 id="update-algorithm"><dfn>Update</dfn></h3>

      : Input
      :: |job|, a <a>job</a>
      : Output
      :: none

      1. Let |registration| be the result of running the <a>Get Registration</a> algorithm passing |job|'s [=job/scope url=] as the argument.
      1. If |registration| is null or |registration|'s <a>uninstalling flag</a> is set, then:
          1. Invoke <a>Reject Job Promise</a> with |job| and a <code>TypeError</code>.
          1. Invoke <a>Finish Job</a> with |job| and abort these steps.
      1. Let |newestWorker| be the result of running <a>Get Newest Worker</a> algorithm passing |registration| as the argument.
      1. If |job|'s <a>job type</a> is *update*, and |newestWorker|'s [=service worker/script url=] does not [=url/equal=] |job|'s [=job/script url=] with the *exclude fragments flag* set, then:
          1. Invoke <a>Reject Job Promise</a> with |job| and a <code>TypeError</code>.
          1. Invoke <a>Finish Job</a> with |job| and abort these steps.
      1. Let |httpsState| be "<code>none</code>".
      1. Let |referrerPolicy| be the empty string.
      1. Switching on |job|'s <a>worker type</a>, run these substeps with the following options:
          <!-- TODO: reorganize algorithm so that the worker environment is created before fetching happens -->
          : "<code>classic</code>"
          :: <a>Fetch a classic worker script</a> given |job|’s <a lt="URL serializer">serialized</a> [=job/script url=], |job|’s [=job/client=], "<code>serviceworker</code>", and the to-be-created <a>environment settings object</a> for this service worker.
          : "<code>module</code>"
          :: <a>Fetch a module worker script graph</a> given |job|’s <a lt="URL serializer">serialized</a> [=job/script url=], |job|’s [=job/client=], "<code>serviceworker</code>", "<code>omit</code>", and the to-be-created <a>environment settings object</a> for this service worker.

          To [=fetching scripts/perform the fetch=] given |request|, run the following steps:

          1. Append \`<code>Service-Worker</code>\`/\`<code>script</code>\` to |request|'s [=request/header list=].

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

          1. Set |request|'s [=request/cache mode=] to "<code>no-cache</code>" if any of the following are true:
              * |registration|'s [=service worker registration/use cache=] is false.
              * |job|'s [=force bypass cache flag=] is set.
              * |newestWorker| is not null, and |registration|'s [=last update check time=] is not null and the time difference in seconds calculated by the current time minus |registration|’s [=last update check time=] is greater than 86400.

              Note: Even if the cache mode is not set to "<code>no-cache</code>", the user agent obeys Cache-Control header's max-age value in the network layer to determine if it should bypass the browser cache.

          1. Set |request|'s [=service-workers mode=] to "`none`".
          1. If the [=fetching scripts/is top-level=] flag is unset, then return the result of [=/fetching=] |request|.
          1. Set |request|'s [=request/redirect mode=] to "<code>error</code>".
          1. [=/Fetch=] |request|, and asynchronously wait to run the remaining steps as part of fetch's <a>process response</a> for the [=/response=] |response|.
          1. [=Extract a MIME type=] from the |response|'s [=response/header list=]. If this MIME type (ignoring parameters) is not a [=JavaScript MIME type=], then:
              1. Invoke [=Reject Job Promise=] with |job| and a "{{SecurityError}}" exception.
              1. Asynchronously complete these steps with a [=network error=].
          1. Let |serviceWorkerAllowed| be the result of [=extracting header list values=] given \`<code>Service-Worker-Allowed</code>\` and |response|'s [=response/header list=].

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

          1. Set |httpsState| to |response|'s [=response/HTTPS state=].
          1. Set |referrerPolicy| to the result of <a>parse a referrer policy from a <code>Referrer-Policy</code> header</a> of |response|.
          1. If |serviceWorkerAllowed| is failure, then:
              1. Asynchronously complete these steps with a <a>network error</a>.
          1. Let |scopeURL| be |registration|'s [=service worker registration/scope url=].
          1. Let |maxScopeString| be null.
          1. If |serviceWorkerAllowed| is null, then:
              1. Set |maxScopeString| to "<code>/</code>" concatenated with the strings, except the last string that denotes the script's file name, in |job|'s [=job/script url=]'s [=url/path=] (including empty strings), separated from each other by "<code>/</code>".
          1. Else:
              1. Let |maxScope| be the result of <a lt="URL parser">parsing</a> |serviceWorkerAllowed| with |job|'s [=job/script url=].
              1. Set |maxScopeString| to "<code>/</code>" concatenated with the strings in |maxScope|'s [=url/path=] (including empty strings), separated from each other by "<code>/</code>".
          1. Let |scopeString| be "<code>/</code>" concatenated with the strings in |scopeURL|'s [=url/path=] (including empty strings), separated from each other by "<code>/</code>".
          1. If |scopeString| starts with |maxScopeString|, do nothing.
          1. Else:
              1. Invoke <a>Reject Job Promise</a> with |job| and a "{{SecurityError}}" exception.
              1. Asynchronously complete these steps with a <a>network error</a>.
          1. If |response|'s <a for="response" href="https://github.com/whatwg/fetch/issues/376">cache state</a> is not "<code>local</code>", set |registration|'s <a>last update check time</a> to the current time.

              Issue: The response's cache state concept had been removed from fetch. The fetch issue <a href="https://github.com/whatwg/fetch/issues/376">#376</a> tracks the request to restore the concept or add some similar way to check this state.

          1. Return true.

          If the algorithm asynchronously completes with null, then:

              1. Invoke <a>Reject Job Promise</a> with |job| and a <code>TypeError</code>.

                  Note: This will do nothing if <a>Reject Job Promise</a> was previously invoked with a "{{SecurityError}}" exception.

              1. If |newestWorker| is null, invoke <a>Clear Registration</a> algorithm passing |registration| as its argument.
              1. Invoke <a>Finish Job</a> with |job| and abort these steps.

          Else, continue the rest of these steps after the algorithm's asynchronous completion, with |script| being the asynchronous completion value.

      1. If |newestWorker| is not null, |newestWorker|'s [=service worker/script url=] [=url/equals=] |job|'s [=job/script url=] with the *exclude fragments flag* set, and |script|'s [=source text=] is a byte-for-byte match with |newestWorker|'s [=script resource=]'s [=source text=], if |script| is a [=classic script=], and |script|'s [=module script/module record=]'s \[[ECMAScriptCode]] is a byte-for-byte match with |newestWorker|'s [=script resource=]'s [=module script/module record=]'s \[[ECMAScriptCode]] otherwise, then:
          1. Invoke <a>Resolve Job Promise</a> with |job| and the {{ServiceWorkerRegistration}} object which represents |registration|.
          1. Invoke <a>Finish Job</a> with |job| and abort these steps.
      1. Else:
          1. Let |worker| be a new [=/service worker=].
          1. Generate a unique opaque string and set |worker|'s <a>id</a> to the value.
          1. Set |worker|'s [=service worker/script url=] to |job|'s [=job/script url=], |worker|'s <a>script resource</a> to |script|, and |worker|'s <a>type</a> to |job|'s <a>worker type</a>.
          1. Set |worker|'s <a>script resource</a>'s <a>HTTPS state</a> to |httpsState|.
          1. Set |worker|'s <a>script resource</a>'s [=script resource/referrer policy=] to |referrerPolicy|.
          1. Invoke <a>Run Service Worker</a> algorithm given |worker|, and with the *force bypass cache for importscripts flag* set if |job|'s [=job/force bypass cache flag=] is set.
          1. If an uncaught runtime script error occurs during the above step, then:
              1. Invoke <a>Reject Job Promise</a> with |job| and a <code>TypeError</code>.
              1. If |newestWorker| is null, invoke <a>Clear Registration</a> algorithm passing |registration| as its argument.
              1. Invoke <a>Finish Job</a> with |job| and abort these steps.
      1. Invoke <a>Install</a> algorithm with |job|, |worker|, and |registration| as its arguments.
  </section>

  <section algorithm>
    <h3 id="soft-update-algorithm"><dfn>Soft Update</dfn></h3>

    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

        Note: 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 <a>Get Newest Worker</a> algorithm passing |registration| as its argument.
      1. If |newestWorker| is null, abort these steps.
      1. Let |job| be the result of running <a>Create Job</a> with *update*, |registration|'s [=service worker registration/scope url=], |newestWorker|'s [=service worker/script url=], null, and null.
      1. Set |job|'s <a>worker type</a> to |newestWorker|'s [=service worker/type=].
      1. Set |job|'s <a>force bypass cache flag</a> if the *force bypass cache flag* is set.
      1. Invoke <a>Schedule Job</a> with |job|.
  </section>

  <section algorithm>
    <h3 id="installation-algorithm"><dfn>Install</dfn></h3>

      : Input
      :: |job|, a <a>job</a>
      :: |worker|, a [=/service worker=]
      :: |registration|, a [=/service worker registration=]
      : Output
      :: none

      1. Let |installFailed| be false.
      1. Let |newestWorker| be the result of running <a>Get Newest Worker</a> algorithm passing |registration| as its argument.
      1. Run the <a>Update Registration State</a> algorithm passing |registration|, "<code>installing</code>" and |worker| as the arguments.
      1. Run the <a>Update Worker State</a> algorithm passing |registration|'s <a>installing worker</a> and *installing* as the arguments.
      1. Assert: |job|'s [=job/job promise=] is not null.
      1. Invoke <a>Resolve Job Promise</a> with |job| and the {{ServiceWorkerRegistration}} object which represents |registration|.
      1. <a>Queue a task</a> to <a>fire an event</a> named <code>updatefound</code> at all the {{ServiceWorkerRegistration}} objects for all the [=/service worker clients=] whose <a>creation URL</a> <a lt="Match Service Worker Registration">matches</a> |registration|'s [=service worker registration/scope url=] and all the [=/service workers=] whose <a>containing service worker registration</a> is |registration|.
      1. Let |installingWorker| be |registration|'s <a>installing worker</a>.
      1. Invoke <a>Run Service Worker</a> algorithm given |installingWorker|, and with the *force bypass cache for importscripts flag* set if |job|'s [=job/force bypass cache flag=] is set.
      1. <a>Queue a task</a> |task| to run the following substeps:
          1. Let |e| be the result of <a>creating an event</a> with {{ExtendableEvent}}.
          1. Initialize |e|’s {{Event/type}} attribute to {{install!!event}}.
          1. <a>Dispatch</a> |e| at |installingWorker|'s [=service worker/global object=].
          1. *WaitForAsynchronousExtensions*: Run the following substeps <a>in parallel</a>:
              1. Wait until |e|'s [=ExtendableEvent/pending promises count=] is zero.
              1. If the result of <a>waiting for all</a> of |e|'s <a>extend lifetime promises</a> rejected, set |installFailed| to true.

          If |task| is discarded or the script has been aborted by the <a lt="Terminate Service Worker">termination</a> of |installingWorker|, set |installFailed| to true.

      1. Wait for |task| to have executed or been discarded.
      1. Wait for the step labeled *WaitForAsynchronousExtensions* to complete.
      1. If |installFailed| is true, then:
          1. Run the <a>Update Worker State</a> algorithm passing |registration|'s [=installing worker=] and *redundant* as the arguments.
          1. Run the <a>Update Registration State</a> algorithm passing |registration|, "<code>installing</code>" and null as the arguments.
          1. If |newestWorker| is null, invoke <a>Clear Registration</a> algorithm passing |registration| as its argument.
          1. Invoke <a>Finish Job</a> with |job| and abort these steps.
      1. Set |registration|'s <a>installing worker</a>'s <a>imported scripts updated flag</a>.
      1. If |registration|'s <a>waiting worker</a> is not null, then:
          1. [=Terminate Service Worker|Terminate=] |registration|'s [=waiting worker=].
          1. Run the [=Update Worker State=] algorithm passing |registration|'s [=waiting worker=] and *redundant* as the arguments.
      1. Run the <a>Update Registration State</a> algorithm passing |registration|, "<code>waiting</code>" and |registration|'s <a>installing worker</a> as the arguments.
      1. Run the <a>Update Registration State</a> algorithm passing |registration|, "<code>installing</code>" and null as the arguments.
      1. Run the <a>Update Worker State</a> algorithm passing |registration|'s <a>waiting worker</a> and *installed* as the arguments.
      1. Invoke <a>Finish Job</a> with |job|.
      1. Wait for all the <a>tasks</a> <a lt="queue a task">queued</a> by <a>Update Worker State</a> invoked in this algorithm have executed.
      1. Invoke [=Try Activate=] with |registration|.

          Note: If [=Try Activate=] does not trigger [=Activate=] here, [=Activate=] is tried again when the last client controlled by the existing [=active worker=] is [=Handle Service Worker Client Unload|unloaded=], {{ServiceWorkerGlobalScope/skipWaiting()}} is asynchronously called, or the [=extend lifetime promises=] for the existing [=active worker=] settle.
  </section>

  <section algorithm>
    <h3 id="activation-algorithm"><dfn>Activate</dfn></h3>

      : Input
      :: |registration|, a [=/service worker registration=]
      : Output
      :: None

      1. If |registration|'s <a>waiting worker</a> is null, abort these steps.
      1. If |registration|'s [=active worker=] is not null, then:
          1. [=Terminate Service Worker|Terminate=] |registration|'s [=active worker=].
          1. Run the [=Update Worker State=] algorithm passing |registration|'s [=active worker=] and *redundant* as the arguments.
      1. Run the <a>Update Registration State</a> algorithm passing |registration|, "<code>active</code>" and |registration|'s <a>waiting worker</a> as the arguments.
      1. Run the <a>Update Registration State</a> algorithm passing |registration|, "<code>waiting</code>" and null as the arguments.
      1. Run the <a>Update Worker State</a> algorithm passing |registration|'s <a>active worker</a> and *activating* as the arguments.

          Note: 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.

      1. For each [=/service worker client=] |client| whose <a>creation URL</a> <a lt="Match Service Worker Registration">matches</a> |registration|'s [=service worker registration/scope url=]:
          1. If |client| is a <a>window client</a>, unassociate |client|'s <a>responsible document</a> from its <a>application cache</a>, if it has one.
          1. Else if |client| is a <a>shared worker client</a>, unassociate |client|'s [=environment settings object/global object=] from its <a>application cache</a>, if it has one.

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

      1. For each [=/service worker client=] |client| who is <a>using</a> |registration|:
          1. Set |client|'s <a>active worker</a> to |registration|'s <a>active worker</a>.
          1. Invoke <a>Notify Controller Change</a> algorithm with |client| as the argument.
      1. Let |activeWorker| be |registration|'s <a>active worker</a>.
      1. Invoke <a>Run Service Worker</a> algorithm with |activeWorker| as the argument.
      1. <a>Queue a task</a> |task| to run the following substeps:
          1. Let |e| be the result of <a>creating an event</a> with {{ExtendableEvent}}.
          1. Initialize |e|’s {{Event/type}} attribute to {{activate!!event}}.
          1. <a>Dispatch</a> |e| at |activeWorker|'s [=service worker/global object=].
          1. *WaitForAsynchronousExtensions*: Wait, <a>in parallel</a>, until |e|'s [=ExtendableEvent/pending promises count=] is zero.
      1. Wait for |task| to have executed or been discarded, or the script to have been aborted by the <a lt="terminate service worker">termination</a> of |activeWorker|.
      1. Wait for the step labeled *WaitForAsynchronousExtensions* to complete.
      1. Run the <a>Update Worker State</a> algorithm passing |registration|'s <a>active worker</a> and *activated* as the arguments.
  </section>

  <section algorithm>
    <h3 id="try-activate-algorithm"><dfn>Try Activate</dfn></h3>

      : Input
      :: |registration|, a [=/service worker registration=]
      : Output
      :: None

      1. If |registration|'s [=waiting worker=] is null, return.
      1. If |registration|'s [=active worker=] is not null and |registration|'s [=active worker=]'s [=state=] is *activating*, return.

          Note: If the existing active worker is still in activating state, the activation of the waiting worker is delayed.

      1. Invoke [=Activate=] with |registration| if either of the following is true:
        * |registration|'s [=active worker=] is null.
        * The result of running [=Service Worker Has No Pending Events=] with |registration|’s [=active worker=] is true, and no [=/service worker client=] is [=using=] |registration| or |registration|’s [=waiting worker=]'s [=skip waiting flag=] is set.
  </section>

  <section algorithm>
    <h3 id="run-service-worker-algorithm"><dfn>Run Service Worker</dfn></h3>

      : Input
      :: |serviceWorker|, a [=/service worker=]
      :: *force bypass cache for importscripts flag*, an optional flag unset by default
      : Output
      :: None

      1. Let |script| be |serviceWorker|'s [=service worker/script resource=].
      1. Assert: |script| is not null.
      1. If |serviceWorker| is already running, abort these steps.
      1. 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.
      1. Call the JavaScript [=InitializeHostDefinedRealm|InitializeHostDefinedRealm()=] abstract operation with the following customizations:
          * For the global object, create a new {{ServiceWorkerGlobalScope}} object. Let |workerGlobalScope| be the created object.
          * Let |realmExecutionContext| be the created [=execution context|JavaScript execution context=].
      1. Set |serviceWorker|'s [=service worker/global object=] to |workerGlobalScope|.
      1. Let |workerEventLoop| be a newly created <a>event loop</a>.
      1. Let |settingsObject| be a new <a>environment settings object</a> whose algorithms are defined as follows:

          : The [=environment settings object/realm execution context=]
          :: Return |realmExecutionContext|.
          : The [=environment settings object/global object=]
          :: Return |workerGlobalScope|.
          : The <a>responsible event loop</a>
          :: Return |workerEventLoop|.
          : The [=environment settings object/referrer policy=]
          :: Return |workerGlobalScope|'s [=WorkerGlobalScope/referrer policy=].
          : The <a>API URL character encoding</a>
          :: Return UTF-8.
          : The <a>API base URL</a>
          :: Return |serviceWorker|'s [=service worker/script url=].
          : The [=environment settings object/origin=]
          :: Return its registering [=/service worker client=]'s [=environment settings object/origin=].
          : The <a>creation URL</a>
          :: Return |workerGlobalScope|'s [=WorkerGlobalScope/url=].
          : The [=environment settings object/HTTPS state=]
          :: Return |workerGlobalScope|'s [=WorkerGlobalScope/HTTPS state=].

      1. Set |workerGlobalScope|'s [=WorkerGlobalScope/url=] to |serviceWorker|'s [=service worker/script url=].
      1. Set |workerGlobalScope|'s [=WorkerGlobalScope/HTTPS state=] to |serviceWorker|'s <a>script resource</a>'s <a>HTTPS state</a>.
      1. Set |workerGlobalScope|'s [=WorkerGlobalScope/referrer policy=] to |serviceWorker|'s <a>script resource</a>'s [=script resource/referrer policy=].
      1. Set |workerGlobalScope|'s [=WorkerGlobalScope/type=] to |serviceWorker|'s <a>type</a>.
      1. Set |workerGlobalScope|'s [=ServiceWorkerGlobalScope/force bypass cache for importscripts flag=] if the *force bypass cache for importscripts flag* is set.
      1. Create a new {{WorkerLocation}} object and associate it with |workerGlobalScope|.
      1. If |serviceWorker| is an <a>active worker</a>, and there are any <a>tasks</a> queued in |serviceWorker|'s <a>containing service worker registration</a>'s [=service worker registration/task queues=], <a lt="queue a task">queue</a> them to |serviceWorker|'s <a>event loop</a>'s [=/task queues=] in the same order using their original <a>task sources</a>.
      1. If |script| is a <a>classic script</a>, then <a lt="run a classic script">run the classic script</a> |script|. Otherwise, it is a <a>module script</a>; <a lt="run a module script">run the module script</a> |script|.

          Note: In addition to the usual possibilities of returning a value or failing due to an exception, this could be prematurely aborted by the <a>terminate service worker</a> algorithm.

      1. If |script|'s <a>has ever been evaluated flag</a> is unset, then:
          1. For each |eventType| of |settingsObject|'s [=environment settings object/global object=]'s associated list of <a>event listeners</a>' event types:
              1. [=set/Append=] |eventType| to |workerGlobalScope|'s associated [=ServiceWorkerGlobalScope/service worker=]'s <a>set of event types to handle</a>.

          Note: 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 remains 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.

          1. Set |script|'s <a>has ever been evaluated flag</a>.
      1. Run the <a>responsible event loop</a> specified by |settingsObject| until it is destroyed.
      1. Empty |workerGlobalScope|'s <a>list of active timers</a>.
  </section>

  <section algorithm>
    <h3 id="terminate-service-worker-algorithm"><dfn>Terminate Service Worker</dfn></h3>

      : Input
      :: |serviceWorker|, a [=/service worker=]
      : Output
      :: None

      1. If |serviceWorker| is not running, abort these steps.
      1. Let |serviceWorkerGlobalScope| be |serviceWorker|'s [=service worker/global object=].
      1. Set |serviceWorkerGlobalScope|'s closing flag to true.
      1. [=set/Remove=] all the [=items=] from |serviceWorker|'s [=set of extended events=].
      1. If there are any <a>tasks</a>, whose <a>task source</a> is either the <a>handle fetch task source</a> or the <a>handle functional event task source</a>, queued in |serviceWorkerGlobalScope|'s <a>event loop</a>'s [=/task queues=], <a lt="queue a task">queue</a> them to |serviceWorker|'s <a>containing service worker registration</a>'s corresponding [=service worker registration/task queues=] in the same order using their original <a>task sources</a>, and discard all the <a>tasks</a> (including <a>tasks</a> whose <a>task source</a> is neither the <a>handle fetch task source</a> nor the <a>handle functional event task source</a>) from |serviceWorkerGlobalScope|'s <a>event loop</a>'s [=/task queues=] without processing them.

          Note: 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.

      1. Abort the script currently running in |serviceWorker|.
  </section>

  <section algorithm>
    <h3 id="on-fetch-request-algorithm"><dfn export>Handle Fetch</dfn></h3>

    The <a>Handle Fetch</a> 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.
      1. Let |respondWithEntered| be false.
      1. Let |eventCanceled| be false.
      1. Let |response| be null.
      1. Let |registration| be null.
      1. Let |client| be |request|'s [=request/client=].
      1. Let |reservedClient| be |request|'s [=request/reserved client=].
      1. Assert: |request|'s [=request/destination=] is not "<code>serviceworker</code>".
      1. If |request| is a <a>potential-navigation-or-subresource request</a>, then:
          1. Return null.
      1. Else if |request| is a <a>non-subresource request</a>, then:

          Note: 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 |reservedClient| is not null and is an <a>environment settings object</a>, then:
              1. If |reservedClient| is not a <a>secure context</a>, return null.
          1. Else:
              1. If |request|'s [=request/url=] is not a <a>potentially trustworthy URL</a>, return null.
          1. If |request| is a <a>navigation request</a> and the <a lt="navigate">navigation</a> triggering it was initiated with a shift+reload or equivalent, return null.
          1. Set |registration| to the result of running <a>Match Service Worker Registration</a> algorithm passing |request|'s [=request/url=] as the argument.
          1. If |registration| is null or |registration|'s <a>active worker</a> is null, return null.
          1. If |request|'s [=request/destination=] is not {{RequestDestination/"report"}}, set |reservedClient|'s <a>active service worker</a> to |registration|'s <a>active worker</a>.

          Note: From this point, the [=/service worker client=] starts to <a>use</a> its <a>active service worker</a>'s <a>containing service worker registration</a>.

      1. Else if |request| is a <a>subresource request</a>, then:
          1. If |client|'s <a>active service worker</a> is non-null, set |registration| to |client|'s <a>active service worker</a>'s <a>containing service worker registration</a>.
          1. Else, return null.
      1. Let |activeWorker| be |registration|'s <a>active worker</a>.
      1. If |activeWorker|'s <a>set of event types to handle</a> does not [=set/contain=] <code>fetch</code>, then:
          1. Return null and continue running these steps <a>in parallel</a>.
          1. If |request| is a <a>non-subresource request</a>, or |request| is a <a>subresource request</a> and the time difference in seconds calculated by the current time minus |registration|'s <a>last update check time</a> is greater than 86400, invoke <a>Soft Update</a> algorithm with |registration|.
          1. Abort these steps.

          Note: 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.

      1. If |activeWorker|'s <a>state</a> is *activating*, wait for |activeWorker|'s <a>state</a> to become *activated*.
      1. Invoke <a>Run Service Worker</a> algorithm with |activeWorker| as the argument.
      1. <a>Queue a task</a> |task| to run the following substeps:
          1. Let |e| be the result of <a>creating an event</a> with {{FetchEvent}}.
          1. Initialize |e|’s {{Event/type}} attribute to {{fetch!!event}}.
          1. Initialize |e|’s {{Event/cancelable}} attribute to true.
          1. Initialize |e|’s {{FetchEvent/request}} attribute to a new {{Request}} object associated with |request| and a new associated {{Headers}} object whose [=guard=] is "`immutable`".
          1. Initialize |e|'s {{FetchEvent/clientId}} attribute to |client|'s [=environment/id=].
          1. If |request| is a <a>non-subresource request</a> and |request|'s [=request/destination=] is not {{RequestDestination/"report"}}, initialize |e|'s {{FetchEvent/reservedClientId}} attribute to |reservedClient|'s [=environment/id=], and to the empty string otherwise.
          1. If |request| is a <a>navigation request</a>, initialize |e|'s {{FetchEvent/targetClientId}} attribute to |request|'s [=request/target client id=], and to the empty string otherwise.
          1. <a>Dispatch</a> |e| at |activeWorker|'s [=service worker/global object=].
          1. Invoke [=Update Service Worker Extended Events Set=] with |activeWorker| and |e|.
          1. If |e|'s [=FetchEvent/respond-with entered flag=] is set, set |respondWithEntered| to true.
          1. If |e|'s [=FetchEvent/wait to respond flag=] is set, then:
              1. Wait until |e|'s [=FetchEvent/wait to respond flag=] is unset.
              1. If |e|'s [=FetchEvent/respond-with error flag=] is set, set |handleFetchFailed| to true.
              1. Else, set |response| to |e|'s [=FetchEvent/potential response=].
          1. If |e|'s <a>canceled flag</a> is set, set |eventCanceled| to true.

          If |task| is discarded or the script has been aborted by the <a lt="terminate service worker">termination</a> of |activeWorker|, set |handleFetchFailed| to true.

          The |task| *must* use |activeWorker|'s <a>event loop</a> and the <a>handle fetch task source</a>.

      1. Wait for |task| to have executed or been discarded.
      1. If |respondWithEntered| is false, then:
          1. If |eventCanceled| is true, return a <a>network error</a> and continue running these steps <a>in parallel</a>.
          1. Else, return null and continue running these steps <a>in parallel</a>.
          1. If |request| is a <a>non-subresource request</a>, or |request| is a <a>subresource request</a> and the time difference in seconds calculated by the current time minus |registration|'s <a>last update check time</a> is greater than 86400, invoke <a>Soft Update</a> algorithm with |registration|.
          1. Abort these steps.
      1. If |handleFetchFailed| is true, then:
          1. Return a <a>network error</a> and continue running these steps <a>in parallel</a>.
          1. If |request| is a <a>non-subresource request</a>, or |request| is a <a>subresource request</a> and the time difference in seconds calculated by the current time minus |registration|'s <a>last update check time</a> is greater than 86400, invoke <a>Soft Update</a> algorithm with |registration|.
      1. Else:
          1. Return |response| and continue running these steps <a>in parallel</a>.
          1. If |request| is a <a>non-subresource request</a>, or |request| is a <a>subresource request</a> and the time difference in seconds calculated by the current time minus |registration|'s <a>last update check time</a> is greater than 86400, invoke <a>Soft Update</a> algorithm with |registration|.
  </section>

  <section algorithm>
    <h3 id="handle-functional-event-algorithm"><dfn export>Handle Functional Event</dfn></h3>

      : Input
      :: |event|, an {{ExtendableEvent}} object
      :: |registration|, a [=/service worker registration=]
      :: |callbackSteps|, an algorithm
      : Output
      :: None

      1. Assert: <a>scope to registration map</a> contains a value equal to |registration|.
      1. Assert: |registration|'s <a>active worker</a> is not null.
      1. Let |activeWorker| be |registration|'s <a>active worker</a>.
      1. If |activeWorker|'s <a>set of event types to handle</a> does not [=set/contain=] |event|'s {{Event/type}}, then:
          1. Return and continue running these steps <a>in parallel</a>.
          1. If the time difference in seconds calculated by the current time minus |registration|'s <a>last update check time</a> is greater than 86400, invoke <a>Soft Update</a> algorithm with |registration|.
          1. Abort these steps.

          Note: 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.

      1. If |activeWorker|'s <a>state</a> is *activating*, wait for |activeWorker|'s <a>state</a> to become *activated*.
      1. Invoke <a>Run Service Worker</a> algorithm with |activeWorker| as the argument.
      1. <a>Queue a task</a> |task| to run these substeps:
          1. Invoke |callbackSteps| with |activeWorker|'s [=service worker/global object=] as its argument.
          1. Invoke [=Update Service Worker Extended Events Set=] with |activeWorker| and |event|.

          The |task| *must* use |activeWorker|'s <a>event loop</a> and the <a>handle functional event task source</a>.

      1. Wait for |task| to have executed or been discarded.
      1. If the time difference in seconds calculated by the current time minus |registration|'s <a>last update check time</a> is greater than 86400, invoke <a>Soft Update</a> algorithm with |registration|.
  </section>

  <section algorithm>
    <h3 id="on-client-unload-algorithm"><dfn>Handle Service Worker Client Unload</dfn></h3>

    The user agent *must* run these steps when a [=/service worker client=] unloads by <a lt="unload a document">unloading</a> or <a lt="terminate service worker">terminating</a>.

      : Input
      :: |client|, a [=/service worker client=]
      : Output
      :: None

      1. Run the following steps atomically.
      1. Let |registration| be the [=/service worker registration=] <a>used</a> by |client|.
      1. If |registration| is null, abort these steps.
      1. If any other [=/service worker client=] is <a>using</a> |registration|, abort these steps.
      1. If |registration|'s [=uninstalling flag=] is set, invoke [=Try Clear Registration=] with |registration|.
      1. If |registration| is not null, invoke [=Try Activate=] with |registration|.
  </section>

  <section algorithm>
    <h3 id="on-user-agent-shutdown-algorithm"><dfn>Handle User Agent Shutdown</dfn></h3>

      : Input
      :: None
      : Output
      :: None

      1. [=map/For each=] <var ignore>scope</var> → |registration| of <a>scope to registration map</a>:
          1. If |registration|'s <a>installing worker</a> |installingWorker| is not null, then:
              1. If |registration|'s [=waiting worker=] is null and |registration|'s [=active worker=] is null, invoke <a>Clear Registration</a> with |registration| and continue to the next iteration of the loop.
              1. Else, set |installingWorker| to null.
          1. If |registration|'s <a>waiting worker</a> is not null, run the following substep <a>in parallel</a>:
              1. Invoke <a>Activate</a> with |registration|.
  </section>

  <section algorithm>
    <h3 id="update-service-worker-extended-events-set-algorithm"><dfn>Update Service Worker Extended Events Set</dfn></h3>

      : Input
      :: |worker|, a [=/service worker=]
      :: |event|, an [=event=]
      : Output
      :: None

      1. Assert: |event|'s [=dispatch flag=] is unset.
      1. For each |item| of |worker|'s [=set of extended events=]:
          1. If |item|'s [=pending promises count=] is zero, [=set/remove=] |item| from |worker|'s [=set of extended events=].
      1. If |event|'s [=pending promises count=] is not zero, [=set/append=] |event| to |worker|'s [=set of extended events=].
  </section>

  <section algorithm>
    <h3 id="unregister-algorithm"><dfn>Unregister</dfn></h3>

      : Input
      :: |job|, a <a>job</a>
      : Output
      :: none

      1. If the [=environment settings object/origin=] of |job|'s [=job/scope url=] is not |job|'s [=job/client=]'s [=environment settings object/origin=], then:
          1. Invoke <a>Reject Job Promise</a> with |job| and a "{{SecurityError}}" exception.
          1. Invoke <a>Finish Job</a> with |job| and abort these steps.
      1. Let |registration| be the result of running <a>Get Registration</a> algorithm passing |job|'s [=job/scope url=] as the argument.
      1. If |registration| is null, then:
          1. Invoke <a>Resolve Job Promise</a> with |job| and false.
          1. Invoke <a>Finish Job</a> with |job| and abort these steps.
      1. Set |registration|'s <a>uninstalling flag</a>.
      1. Invoke <a>Resolve Job Promise</a> with |job| and true.
      1. Invoke [=Try Clear Registration=] with |registration|.

          Note: If [=Try Clear Registration=] does not trigger [=Clear Registration=] here, [=Clear Registration=] is tried again when the last client [=using=] the registration is [=Handle Service Worker Client Unload|unloaded=] or the [=extend lifetime promises=] for the registration's service workers settle.

      1. Invoke <a>Finish Job</a> with |job|.
  </section>

  <section algorithm>
    <h3 id="set-registration-algorithm"><dfn>Set Registration</dfn></h3>

      : Input
      :: |scope|, a [=/URL=]
      :: |useCache|, a boolean
      : Output
      :: |registration|, a [=/service worker registration=]

      1. Run the following steps atomically.
      1. Let |scopeString| be <a lt="URL serializer">serialized</a> |scope| with the *exclude fragment flag* set.
      1. Let |registration| be a new [=/service worker registration=] whose [=service worker registration/scope url=] is set to |scope| and [=service worker registration/use cache=] is set to |useCache|.
      1. [=map/Set=] <a>scope to registration map</a>[|scopeString|] to |registration|.
      1. Return |registration|.
  </section>

  <section algorithm>
    <h3 id="clear-registration-algorithm"><dfn>Clear Registration</dfn></h3>

      : Input
      :: |registration|, a [=/service worker registration=]
      : Output
      :: None

      1. Run the following steps atomically.
      1. If |registration|'s <a>installing worker</a> is not null, then:
          1. [=Terminate Service Worker|Terminate=] |registration|'s [=installing worker=].
          1. Run the <a>Update Worker State</a> algorithm passing |registration|'s [=installing worker=] and *redundant* as the arguments.
          1. Run the <a>Update Registration State</a> algorithm passing |registration|, "<code>installing</code>" and null as the arguments.
      1. If |registration|'s <a>waiting worker</a> is not null, then:
          1. [=Terminate Service Worker|Terminate=] |registration|'s [=waiting worker=].
          1. Run the <a>Update Worker State</a> algorithm passing |registration|'s [=waiting worker=] and *redundant* as the arguments.
          1. Run the <a>Update Registration State</a> algorithm passing |registration|, "<code>waiting</code>" and null as the arguments.
      1. If |registration|'s <a>active worker</a> is not null, then:
          1. [=Terminate Service Worker|Terminate=] |registration|'s [=active worker=].
          1. Run the <a>Update Worker State</a> algorithm passing |registration|'s [=active worker=] and *redundant* as the arguments.
          1. Run the <a>Update Registration State</a> algorithm passing |registration|, "<code>active</code>" and null as the arguments.
      1. Let |scopeString| be <a lt="URL serializer">serialized</a> |registration|'s [=service worker registration/scope url=] with the *exclude fragment flag* set.
      1. [=map/Remove=] <a>scope to registration map</a>[|scopeString|].
  </section>

  <section algorithm>
    <h3 id="try-clear-registration-algorithm"><dfn>Try Clear Registration</dfn></h3>

      : Input
      :: |registration|, a [=/service worker registration=]
      : Output
      :: None

      1. Invoke [=Clear Registration=] with |registration| if no [=/service worker client=] is [=using=] |registration| and all of the following conditions are true:
          * |registration|'s [=installing worker=] is null or the result of running [=Service Worker Has No Pending Events=] with |registration|’s [=installing worker=] is true.
          * |registration|'s [=waiting worker=] is null or the result of running [=Service Worker Has No Pending Events=] with |registration|’s [=waiting worker=] is true.
          * |registration|'s [=active worker=] is null or the result of running [=Service Worker Has No Pending Events=] with |registration|’s [=active worker=] is true.
  </section>

  <section algorithm>
    <h3 id="update-registration-state-algorithm"><dfn>Update Registration State</dfn></h3>

      : Input
      :: |registration|, a [=/service worker registration=]
      :: |target|, a string (one of "<code>installing</code>", "<code>waiting</code>", and "<code>active</code>")
      :: |source|, a [=/service worker=] or null
      : Output
      :: None

      1. Let |registrationObjects| be an array containing all the {{ServiceWorkerRegistration}} objects associated with |registration|.
      1. If |target| is "<code>installing</code>", then:
          1. Set |registration|'s <a>installing worker</a> to |source|.
          1. For each |registrationObject| in |registrationObjects|:
              1. <a>Queue a task</a> to set the {{ServiceWorkerRegistration/installing}} attribute of |registrationObject| to the {{ServiceWorker}} object that represents |registration|’s <a>installing worker</a>, or null if |registration|’s <a>installing worker</a> is null.
      1. Else if |target| is "<code>waiting</code>", then:
          1. Set |registration|'s <a>waiting worker</a> to |source|.
          1. For each |registrationObject| in |registrationObjects|:
              1. <a>Queue a task</a> to set the {{ServiceWorkerRegistration/waiting}} attribute of |registrationObject| to the {{ServiceWorker}} object that represents |registration|’s <a>waiting worker</a>, or null if |registration|’s <a>waiting worker</a> is null.
      1. Else if |target| is "<code>active</code>", then:
          1. Set |registration|'s [=service worker registration/active worker=] to |source|.
          1. For each |registrationObject| in |registrationObjects|:
              1. <a>Queue a task</a> to set the {{ServiceWorkerRegistration/active}} attribute of |registrationObject| to the {{ServiceWorker}} object that represents |registration|’s [=service worker registration/active worker=], or null if |registration|’s [=service worker registration/active worker=] is null.

        The <a>task</a> *must* use |registrationObject|'s <a>relevant settings object</a>'s <a>responsible event loop</a> and the <a>DOM manipulation task source</a>.
  </section>

  <section algorithm>
    <h3 id="update-state-algorithm"><dfn>Update Worker State</dfn></h3>

      : Input
      :: |worker|, a [=/service worker=]
      :: |state|, a [=/service worker=]'s <a>state</a>
      : Output
      :: None

      1. Set |worker|'s <a>state</a> to |state|.
      1. Let |workerObjects| be an array containing all the {{ServiceWorker}} objects associated with |worker|.
      1. For each |workerObject| in |workerObjects|:
          1. <a>Queue a task</a> to run these substeps:
              1. Set the {{ServiceWorker/state}} attribute of |workerObject| to the value (in {{ServiceWorkerState}} enumeration) corresponding to the first matching statement, switching on |worker|'s <a>state</a>:
                  : *installing*
                  :: {{"installing"}}

                      Note: The [=/service worker=] in this state is considered an <a>installing worker</a>. During this state, {{ExtendableEvent/waitUntil()}} can be called inside the {{ServiceWorkerGlobalScope/oninstall}} <a>event handler</a> to extend the life of the <a>installing worker</a> until the passed <a>promise</a> 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"}}

                      Note: The [=/service worker=] in this state is considered a <a>waiting worker</a>.

                  : *activating*
                  :: {{"activating"}}

                      Note: The [=/service worker=] in this state is considered an <a>active worker</a>. During this state, {{ExtendableEvent/waitUntil()}} can be called inside the {{ServiceWorkerGlobalScope/onactivate}} <a>event handler</a> to extend the life of the <a>active worker</a> until the passed <a>promise</a> resolves successfully. No <a>functional events</a> are dispatched until the state becomes *activated*.

                  : *activated*
                  :: {{"activated"}}

                      Note: The [=/service worker=] in this state is considered an <a>active worker</a> ready to handle <a>functional events</a>.

                  : *redundant*
                  :: {{"redundant"}}

                      Note: A new [=/service worker=] is replacing the current [=/service worker=], or the current [=/service worker=] is being discarded due to an install failure.

              1. <a>Fire an event</a> named <code>statechange</code> at |workerObject|.

        The <a>task</a> *must* use |workerObject|'s <a>relevant settings object</a>'s <a>responsible event loop</a> and the <a>DOM manipulation task source</a>.
  </section>

  <section algorithm>
    <h3 id="notify-controller-change-algorithm"><dfn>Notify Controller Change</dfn></h3>

      : Input
      :: |client|, a [=/service worker client=]
      : Output
      :: None

      1. Assert: |client| is not null.
      1. If |client| is an [=environment settings object=], <a>queue a task</a> to [=fire an event=] named <code>controllerchange</code> at the {{ServiceWorkerContainer}} object that |client| is [=ServiceWorkerContainer/service worker client|associated=] with.

    The <a>task</a> *must* use |client|'s <a>responsible event loop</a> and the <a>DOM manipulation task source</a>.
  </section>

  <section algorithm>
    <h3 id="scope-match-algorithm"><dfn export>Match Service Worker Registration</dfn></h3>

      : Input
      :: |clientURL|, a [=/URL=]
      : Output
      :: |registration|, a [=/service worker registration=]

      1. Run the following steps atomically.
      1. Let |clientURLString| be <a lt="URL serializer">serialized</a> |clientURL|.
      1. Let |matchingScopeString| be the empty string.
      1. Let |scopeStringSet| be the result of [=map/get the keys|getting the keys=] from <a>scope to registration map</a>.
      1. Set |matchingScopeString| to the longest value in |scopeStringSet| which the value of |clientURLString| starts with, if it exists.

          Note: The URL string matching in this step is prefix-based rather than path-structural. E.g. a client URL string with "https://example.com/prefix-of/resource.html" will match a registration for a scope with "https://example.com/prefix". The URL string comparison is safe for the same-origin security as HTTP(S) URLs are always [=URL serializer|serialized=] with a trailing slash at the end of the origin part of the URLs.

      1. Let |matchingScope| be null.
      1. If |matchingScopeString| is not the empty string, then:
          1. Set |matchingScope| to the result of <a lt="URL parser">parsing</a> |matchingScopeString|.
          1. Assert: |matchingScope|'s [=url/origin=] and |clientURL|'s [=url/origin=] are [=same origin=].
      1. Let |registration| be the result of running <a>Get Registration</a> algorithm passing |matchingScope| as the argument.
      1. If |registration| is not null and |registration|'s <a>uninstalling flag</a> is set, return null.
      1. Return |registration|.
  </section>

  <section algorithm>
    <h3 id="get-registration-algorithm"><dfn>Get Registration</dfn></h3>

      : Input
      :: |scope|, a [=/URL=]
      : Output
      :: |registration|, a [=/service worker registration=]

      1. Run the following steps atomically.
      1. Let |scopeString| be the empty string.
      1. If |scope| is not null, set |scopeString| to <a lt="URL serializer">serialized</a> |scope| with the *exclude fragment flag* set.
      1. Let |registration| be null.
      1. [=map/For each=] |key| → |value| of <a>scope to registration map</a>:
          1. If |scopeString| matches |key|, set |registration| to |value|.
      1. Return |registration|.
  </section>

  <section algorithm>
    <h3 id="get-newest-worker-algorithm"><dfn>Get Newest Worker</dfn></h3>

      : Input
      :: |registration|, a [=/service worker registration=]
      : Output
      :: |newestWorker|, a [=/service worker=]

      1. Run the following steps atomically.
      1. Let |newestWorker| be null.
      1. If |registration|'s <a>installing worker</a> is not null, set |newestWorker| to |registration|'s <a>installing worker</a>.
      1. Else if |registration|'s <a>waiting worker</a> is not null, set |newestWorker| to |registration|'s <a>waiting worker</a>.
      1. Else if |registration|'s <a>active worker</a> is not null, set |newestWorker| to |registration|'s <a>active worker</a>.
      1. Return |newestWorker|.
  </section>

  <section algorithm>
    <h3 id="service-worker-has-no-pending-events-algorithm"><dfn>Service Worker Has No Pending Events</dfn></h3>

      : Input
      :: |worker|, a [=/service worker=]
      : Output
      :: True or false, a boolean

      1. Let |sum| be zero.
      1. For each |item| of |worker|'s [=set of extended events=]:
          1. Add |item|'s [=pending promises count=] to |sum|.
      1. If |sum| is zero, return true.
      1. Else, return false.
  </section>

  <section algorithm>
    <h3 id="create-client-algorithm"><dfn>Create Client</dfn></h3>

      : Input
      :: |client|, a [=/service worker client=]
      : Output
      :: |clientObject|, a {{Client}} object

      1. Let |clientObject| be a new {{Client}} object.
      1. Set |clientObject|'s [=Client/service worker client=] to |client|.
      1. Set |clientObject|'s [=Client/reserved state=] to true if |client|'s [=environment/execution ready flag=] is unset, and false otherwise.
      1. Return |clientObject|.
  </section>

  <section algorithm>
    <h3 id="create-windowclient-algorithm"><dfn>Create Window Client</dfn></h3>

      : Input
      :: |client|, a [=/service worker client=]
      :: |visibilityState|, a string
      :: |focusState|, a boolean
      :: |ancestorOriginsList|, a list
      : Output
      :: |windowClient|, a {{WindowClient}} object

      1. Let |windowClient| be a new {{WindowClient}} object.
      1. Set |windowClient|'s [=Client/service worker client=] to |client|.
      1. Set |windowClient|'s <a>visibility state</a> to |visibilityState|.
      1. Set |windowClient|'s <a>focus state</a> to |focusState|.
      1. Set |windowClient|'s [=WindowClient/ancestor origins array=] to a [=frozen array type|frozen array=] created from |ancestorOriginsList|.
      1. Return |windowClient|.
  </section>

  <section algorithm>
    <h3 id="query-cache-algorithm"><dfn>Query Cache</dfn></h3>

      : 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.
      1. Let |responseArray| be an empty array.
      1. Let |resultArray| be an empty array.
      1. If |options|.{{CacheQueryOptions/ignoreMethod}} is false and |request|.method is not \`<code>GET</code>\`, return |resultArray|.
      1. Let |cachedURL| and |requestURL| be null.
      1. If the optional argument |targetStorage| is omitted, then:
          1. For each <a>fetching record</a> |entry| of its <a>request to response map</a>, in key insertion order:
              1. Set |cachedURL| to |entry|.\[[key]]'s associated [=Request/request=]'s [=request/url=].
              1. Set |requestURL| to |request|'s associated [=Request/request=]'s [=request/url=].
              1. If |options|.ignoreSearch is true, then:
                  1. Set |cachedURL|'s [=url/query=] to the empty string.
                  1. Set |requestURL|'s [=url/query=] to the empty string.
              1. If |cachedURL| [=url/equals=] |requestURL| with the *exclude fragments flag* set, then:
                  1. Add a copy of |entry|.\[[key]] to |requestArray|.
                  1. Add a copy of |entry|.\[[value]] to |responseArray|.
      1. Else:
          1. For each |record| in |targetStorage|:
              1. Set |cachedURL| to |record|[0]'s associated [=Request/request=]'s [=request/url=].
              1. Set |requestURL| to |request|'s associated [=Request/request=]'s [=request/url=].
              1. If |options|.{{CacheQueryOptions/ignoreSearch}} is true, then:
                  1. Set |cachedURL|'s [=url/query=] to the empty string.
                  1. Set |requestURL|'s [=url/query=] to the empty string.
              1. If |cachedURL| [=url/equals=] |requestURL| with the *exclude fragments flag* set, then:
                  1. Add |record|[0] to |requestArray|.
                  1. Add |record|[1] to |responseArray|.
      1. For each |cachedResponse| in |responseArray| with the index |index|:
          1. Let |cachedRequest| be the |index|th element in |requestArray|.
          1. If |cachedResponse|'s [=Response/response=]'s [=response/header list=] contains no <a>header</a> [=header/named=] \`<code>Vary</code>\`, or |options|.{{CacheQueryOptions/ignoreVary}} is true, then:
              1. Add an array [|cachedRequest|, |cachedResponse|] to |resultArray|.
              1. Continue to the next iteration of the loop.
          1. Let |varyHeaders| be the array containing the elements corresponding to the [=http/field-values=] of the <a>Vary</a> header.
          1. Let |matchFailed| be false.
          1. For each |f| in |varyHeaders|:
              1. If |f| matches "<code>*</code>", or the result of running |cachedRequest|.{{Request/headers}} object's {{Headers/get(name)}} method with |f| as the argument does not match the result of running |request|.{{Request/headers}} object's {{Headers/get(name)}} method with |f| as the argument, then:
                  1. Set |matchFailed| to true.
                  1. Break the loop.
          1. If |matchFailed| is false, add an array [|cachedRequest|, |cachedResponse|] to |resultArray|.
      1. Return |resultArray|.
  </section>

  <section algorithm>
    <h3 id="batch-cache-operations-algorithm"><dfn>Batch Cache Operations</dfn></h3>

      : Input
      :: |operations|, an array of  {{CacheBatchOperation}} dictionary objects
      : Output
      :: |promise|, a <a>promise</a> resolves with an array of {{Response}} objects

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

                          Note: The cache commit is allowed as long as the response's headers are available.

                      1. If the cache write operation in the previous two steps failed due to exceeding the granted quota limit, <a>throw</a> a "{{QuotaExceededError}}" exception.
                      1. Add an array [|operation|.request, |operation|.response] to |addedRecords|.
                  1. Add |operation|.response to |resultArray|.
              1. Return |resultArray|.
          1. And then, if an exception was <a lt="throw">thrown</a>, then:
              1. Set the <a>context object</a>'s <a>request to response map</a> to |itemsCopy|.
              1. <a>Throw</a> the exception
  </section>
</section>

<section>
  <h2 id="extended-http-headers">Appendix B: Extended HTTP headers</h2>

  <section>
    <h3 id="service-worker-script-request">Service Worker Script Request</h3>

    An HTTP request to [=/fetch=] a [=/service worker=]'s <a>script resource</a> will include the following <a>header</a>:

      : \`<dfn><code>Service-Worker</code></dfn>\`
      :: Indicates this request is a [=/service worker=]'s <a>script resource</a> request.

        Note: This header helps administrators log the requests and detect threats.
  </section>

  <section>
    <h3 id="service-worker-script-response">Service Worker Script Response</h3>

    An HTTP response to a [=/service worker=]'s <a>script resource</a> request can include the following <a>header</a>:

      : \`<dfn><code>Service-Worker-Allowed</code></dfn>\`
      :: Indicates the user agent will override the path restriction, which limits the maximum allowed [=service worker registration/scope url=] that the script can <a>control</a>, to the given value.

        Note: The value is a URL. If a relative URL is given, it is parsed against the script's URL.

    <div class="example">
      Default scope:

      <pre highlight="js">
        // Maximum allowed scope defaults to the path the script sits in
        // "/js" in this example
        navigator.serviceWorker.register("/js/sw.js").then(() => {
          console.log("Install succeeded with the default scope '/js'.");
        });
      </pre>
    </div>

    <div class="example">
      Upper path without Service-Worker-Allowed header:

      <pre highlight="js">
        // Set the scope to an upper path of the script location
        // Response has no Service-Worker-Allowed header
        navigator.serviceWorker.register("/js/sw.js", { scope: "/" }).catch(() => {
          console.error("Install failed due to the path restriction violation.");
        });
      </pre>
    </div>

    <div class="example">
      Upper path with Service-Worker-Allowed header:

      <pre highlight="js">
        // Set the scope to an upper path of the script location
        // Response included "Service-Worker-Allowed : /"
        navigator.serviceWorker.register("/js/sw.js", { scope: "/" }).then(() => {
          console.log("Install succeeded as the max allowed scope was overriden to '/'.");
        });
      </pre>
    </div>

    <div class="example">
      A path restriction voliation even with Service-Worker-Allowed header:

      <pre highlight="js">
        // Set the scope to an upper path of the script location
        // Response included "Service-Worker-Allowed : /foo"
        navigator.serviceWorker.register("/foo/bar/sw.js", { scope: "/" }).catch(() => {
          console.error("Install failed as the scope is still out of the overriden maximum allowed scope.");
        });
      </pre>
    </div>
  </section>

  <section>
    <h3 id="syntax">Syntax</h3>

    <a biblio data-biblio-type="normative" lt="rfc5234">ABNF</a> for the values of the headers used by the [=/service worker=]'s <a>script resource</a> requests and responses:

    <pre>
      Service-Worker = %x73.63.72.69.70.74 ; "script", case-sensitive
    </pre>

    Note: The validation of the Service-Worker-Allowed header's values is done by URL parsing algorithm (in Update algorithm) instead of using ABNF.
  </section>
</section>

<section>
  <h2 id="acknowledgements">Acknowledgements</h2>
  <!-- FIXME: INCOMPLETE!! Please add collaborators below. -->

  Deep thanks go to Andrew Betts for organizing and hosting a small workshop of like-minded individuals including: Jake Archibald, Jackson Gabbard, Tobie Langel, Robin Berjon, Patrick Lauke, Christian Heilmann. From the clarity of the day's discussions and the use-cases outlined there, much has become possible. Further thanks to Andrew for raising consciousness about the offline problem. His organization of EdgeConf and inclusion of Offline as a persistent topic there has created many opportunities and connections that have enabled this work to progress.

  Anne van Kesteren has generously lent his encyclopedic knowledge of Web Platform arcana and standards development experience throughout the development of the service worker. This specification would be incomplete without his previous work in describing the real-world behavior of URLs, HTTP Fetch, Promises, and DOM. Similarly, this specification would not be possible without Ian Hickson's rigorous Web Worker spec. Much thanks to him.

  In no particular order, deep gratitude for design guidance and discussion goes to: Jungkee Song, Alec Flett, David Barrett-Kahn, Aaron Boodman, Michael Nordman, Tom Ashworth, Kinuko Yasuda, Darin Fisher, Jonas Sicking, Jesús Leganés Combarro, Mark Christian, Dave Hermann, Yehuda Katz, François Remy, Ilya Grigorik, Will Chan, Domenic Denicola, Nikhil Marathe, Yves Lafon, Adam Barth, Greg Simon, Devdatta Akhawe, Dominic Cooney, Jeffrey Yasskin, Joshua Bell, Boris Zbarsky, Matt Falkenhagen, Tobie Langel, Gavin Peters, Ben Kelly, Hiroki Nakagawa, Jake Archibald, Josh Soref, Jinho Bang, Yutaka Hirano, isonmad, Ali Alabbas, Philip Jägenstedt, and Mike Pennisi.

  Jason Weber, Chris Wilson, Paul Kinlan, Ehsan Akhgari, and Daniel Austin have provided valuable, well-timed feedback on requirements and the standardization process.

  The authors would also like to thank Dimitri Glazkov for his scripts and formatting tools which have been essential in the production of this specification. The authors are also grateful for his considerable guidance.

  Thanks also to Vivian Cromwell, Greg Simon, Alex Komoroske, Wonsuk Lee, and Seojin Kim for their considerable professional support.
</section>