GeezerVison

To get a session history entry's document, return its document state's document.

Serialized state is intended to be used for two main purposes: first, storing a preparsed description of the state in the URL so that in the simple case an author doesn't have to do the parsing (though one would still need the parsing for handling URLs passed around by users, so it's only a minor optimization). Second, so that the author can store state that one wouldn't store in the URL because it only applies to the current Document instance and it would have to be reconstructed if a new Document were opened.

An example of the latter would be something like keeping track of the precise coordinate from which a popup div was made to animate, so that if the user goes back, it can be made to animate to the same location. Or alternatively, it could be used to keep a pointer into a cache of data that would be fetched from the server based on the information in the URL, so that when going back and forward, the information doesn't have to be fetched again.

To append session history traversal steps to a traversable navigable traversable given algorithm steps steps, append steps to traversable's session history traversal queue's algorithm set.

To append session history synchronous navigation steps involving a navigable targetNavigable to a traversable navigable traversable given algorithm steps steps, append steps as synchronous navigation steps targeting target navigable targetNavigable to traversable's session history traversal queue's algorithm set.

To start a new session history traversal parallel queue:

1. Let sessionHistoryTraversalQueue be a new session history traversal parallel queue.

2. Run the following steps in parallel:

   1. While true:

      1. If sessionHistoryTraversalQueue's algorithm set is empty, then continue.

      2. Let steps be the result of dequeuing from sessionHistoryTraversalQueue's algorithm set.

      3. Run steps.

3. Return sessionHistoryTraversalQueue.

Imagine the joint session history depicted by this Jake diagram:

And the following code runs at the top level:

history.back();
location.href = '#foo';

The desired result is:

This isn't straightforward, as the sync navigation wins the race in terms of being observable, whereas the traversal wins the race in terms of queuing steps on the session history traversal parallel queue. To achieve this result, the following happens:

1. history.back() appends steps intended to traverse by a delta of −1.

2. location.href = '#foo' synchronously changes the active session history entry entry to a newly-created one, with the URL /b#foo, and appends synchronous steps to notify the central source of truth about that new entry. Note that this does not yet update the current session history entry, current session history step, or the session history entries list; those updates cannot be done synchronously, and instead must be done as part of the queued steps.

3. On the session history traversal parallel queue, the steps queued by history.back() run:

   1. The target history step is determined to be 0: the current session history step (i.e., 1) plus the intended delta of −1.

   2. We enter the main apply the history step algorithm.

      The entry at step 0, for the /a URL, has its document populated.

      Meanwhile, the queue is checked for synchronous navigation steps. The steps queued by the location.href setter now run, and block the traversal from performing effects beyond document population (such as, unloading documents and switching active history entries) until they are finished. Those steps cause the following to happen:

      1. The entry with URL /b#foo is added, with its step determined to be 2: the current session history step (i.e., 1) plus 1.

      2. We fully switch to that newly added entry, including a nested call to apply the history step. This ultimately results in updating the document by dispatching events like hashchange.

      Only once that is all complete, and the /a history entry has been fully populated with a document, do we move on with applying the history step given the target step of 0.

      At this point, the Document with URL /b#foo unloads, and we finish moving to our target history step 0, which makes the entry with URL /a become the active session history entry and 0 become the current session history step.

Here is another more complex example, involving races between populating two different iframes, and a synchronous navigation once one of those iframes loads. We start with this setup:

and then call history.go(-2). The following then occurs:

1. history.go(-2) appends steps intended to traverse by a delta of −2. Once those steps run:

   1. The target step is determined to be 2 + (−2) = 0.

   2. In parallel, the fetches are made to populate the two iframes, fetching /i-0-a and /i-1-a respectively.

      Meanwhile, the queue is checked for synchronous navigation steps. There aren't any right now.

   3. In the fetch race, the fetch for /i-0-a wins. We proceed onward to finish all of apply the history step's work for how the traversal impacts the frames[0] navigable, including updating its active session history entry to the entry with URL /i-0-a.

   4. Before the fetch for /i-1-a finishes, we reach the point where scripts may run for the newly-created document in the frames[0] navigable's active document. Some such script does run:

      location.href = '#foo'

      This synchronously changes the frames[0] navigable's active session history entry entry to a newly-created one, with the URL /i-0-a#foo, and appends synchronous steps to notify the central source of truth about that new entry.

      Unlike in the previous example, these synchronous steps do not "jump the queue" and update the traversable before we finish the fetch for /i-1-a. This is because the navigable in question, frames[0], has already been altered as part of the traversal, so we know that with the current session history step being 2, adding the new entry as a step 3 doesn't make sense.

   5. Once the fetch for /i-1-a finally finishes, we proceed to finish updating the frames[1] navigable for the traversal, including updating its active session history entry to the entry with URL /i-1-a.

   6. Now that both navigables have finished processing the traversal, we update the current session history step to the target step of 0.

2. Now we can process the steps that were queued for the synchronous navigation:

   1. The /i-0-a#foo entry is added, with its step determined to be 1: the current session history step (i.e., 0) plus 1. This also clears existing forward history.

   2. We fully switch to that newly added entry, including calling apply the history step. This ultimately results in updating the document by dispatching events like hashchange, as well as updating the current session history step to the target step of 1.

The end result is:

To get session history entries of a navigable navigable:

1. Let traversable be navigable's traversable navigable.

2. Assert: this is running within traversable's session history traversal queue.

3. If navigable is traversable, return traversable's session history entries.

4. Let docStates be an empty ordered set of document states.

5. For each entry of traversable's session history entries, append entry's document state to docStates.

6. For each docState of docStates:

   1. For each nestedHistory of docState's nested histories:

      1. If nestedHistory's id equals navigable's id, return nestedHistory's entries.

      2. For each entry of nestedHistory's entries, append entry's document state to docStates.

7. Assert: this step is not reached.

To get session history entries for the navigation API of a navigable navigable given an integer targetStep:

1. Let rawEntries be the result of getting session history entries for navigable.

2. Let entriesForNavigationAPI be a new empty list.

3. Let startingIndex be the index of the session history entry in rawEntries who has the greatest step less than or equal to targetStep.

   See this example to understand why it's the greatest step less than or equal to targetStep.

4. Append rawEntries[startingIndex] to entriesForNavigationAPI.

5. Let startingOrigin be rawEntries[startingIndex]'s document state's origin.

6. Let i be startingIndex − 1.

7. While i > 0:

   1. If rawEntries[i]'s document state's origin is not same origin with startingOrigin, then break.

   2. Prepend rawEntries[i] to entriesForNavigationAPI.

   3. Set i to i − 1.

8. Set i to startingIndex + 1.

9. While i < rawEntries's size:

   1. If rawEntries[i]'s document state's origin is not same origin with startingOrigin, then break.

   2. Append rawEntries[i] to entriesForNavigationAPI.

   3. Set i to i + 1.

10. Return entriesForNavigationAPI.

To clear the forward session history of a traversable navigable navigable:

1. Assert: this is running within navigable's session history traversal queue.

2. Let step be the navigable's current session history step.

3. Let entryLists be the ordered set « navigable's session history entries ».

4. For each entryList of entryLists:

   1. Remove every session history entry from entryList that has a step greater than step.

   2. For each entry of entryList:

      1. For each nestedHistory of entry's document state's nested histories, append nestedHistory's entries list to entryLists.

To get all used history steps that are part of traversable navigable traversable:

1. Assert: this is running within traversable's session history traversal queue.

2. Let steps be an empty ordered set of non-negative integers.

3. Let entryLists be the ordered set « traversable's session history entries ».

4. For each entryList of entryLists:

   1. For each entry of entryList:

      1. Append entry's step to steps.

      2. For each nestedHistory of entry's document state's nested histories, append nestedHistory's entries list to entryLists.

5. Return steps, sorted.

Although in this standard the word "navigation" refers specifically to the navigate algorithm, this doesn't always line up with web developer or user perceptions. For example:

• The URL and history update steps are often used during so-called "single-page app navigations" or "same-document navigations", but they do not trigger the navigate algorithm.

• Reloads and traversals are sometimes talked about as a type of navigation, since all three will often attempt to populate the history entry's document and thus could perform navigational fetches. See, e.g., the APIs exposed Navigation Timing. But they have their own entry point algorithms, separate from the navigate algorithm. [NAVIGATIONTIMING]

• Although fragment navigations are always done through the navigate algorithm, a user might perceive them as more like jumping around a single page, than as a true navigation.

To snapshot source snapshot params given a Document-or-null sourceDocument:

1. If sourceDocument is null, then return a new source snapshot params with

   has transient activation

   true

   sandboxing flags

   an empty sandboxing flag set

   allows downloading

   true

   fetch client

   null

   source policy container

   a new policy container

   This only occurs in the case of a browser UI-initiated navigation.

2. Return a new source snapshot params with

   has transient activation

   true if sourceDocument's relevant global object has transient activation; otherwise false

   sandboxing flags

   sourceDocument's active sandboxing flag set

   allows downloading

   false if sourceDocument's active sandboxing flag set has the sandboxed downloads browsing context flag set; otherwise true

   fetch client

   sourceDocument's relevant settings object

   source policy container

   a clone of sourceDocument's policy container

To snapshot target snapshot params given a navigable targetNavigable, return a new target snapshot params with:

sandboxing flags

the result of determining the creation sandboxing flags given targetNavigable's active browsing context and targetNavigable's container

iframe element referrer policy

the result of determining the iframe element referrer policy given targetNavigable's container

The navigation must be a replace, given a URL url and a Document document, if any of the following are true:

• url's scheme is "javascript"; or

• document's is initial about:blank is true.

Other cases that often, but not always, force a "replace" navigation are:

• if the Document is not completely loaded; or

• if the target URL equals the Document's URL.

For convenience at certain call sites, the user navigation involvement for an Event event is defined as follows:

1. Assert: this algorithm is being called as part of an activation behavior definition.

2. Assert: event's type is "click".

3. If event's isTrusted is initialized to true, then return "activation".

4. Return "none".

To navigate a navigable navigable to a URL url using an optional Document-or-null sourceDocument (default null), with an optional POST resource, string, or null documentResource (default null), an optional response-or-null response (default null), an optional boolean exceptionsEnabled (default false), an optional NavigationHistoryBehavior historyHandling (default "auto"), an optional serialized state-or-null navigationAPIState (default null), an optional entry list or null formDataEntryList (default null), an optional referrer policy referrerPolicy (default the empty string), an optional user navigation involvement userInvolvement (default "none"), an optional Element sourceElement (default null), an optional boolean initialInsertion (default false), and an optional navigation API method tracker-or-null apiMethodTracker (default null):

1. Let cspNavigationType be "form-submission" if formDataEntryList is non-null; otherwise "other".

2. Let sourceSnapshotParams be the result of snapshotting source snapshot params given sourceDocument.

3. Let initiatorOriginSnapshot be a new opaque origin.

4. Let initiatorBaseURLSnapshot be about:blank.

5. If sourceDocument is null:

   1. Assert: userInvolvement is "browser UI".

   2. If url's scheme is "javascript", then set initiatorOriginSnapshot to navigable's active document's origin.

6. Otherwise:

   1. Assert: userInvolvement is not "browser UI".

   2. If sourceDocument's node navigable is not allowed by sandboxing to navigate navigable given sourceSnapshotParams:

      1. If exceptionsEnabled is true, then throw a "SecurityError" DOMException.

      2. Return.

   3. Set initiatorOriginSnapshot to sourceDocument's origin.

   4. Set initiatorBaseURLSnapshot to sourceDocument's document base URL.

7. Let navigationId be the result of generating a random UUID. [WEBCRYPTO]

8. If the surrounding agent is equal to navigable's active document's relevant agent, then continue these steps. Otherwise, queue a global task on the navigation and traversal task source given navigable's active window to continue these steps.

   We do this because we are about to look at a lot of properties of navigable's active document, which are in theory only accessible over in the appropriate event loop. (But, we do not want to unconditionally queue a task, since — for example — same-event-loop fragment navigations need to take effect synchronously.)

   Another implementation strategy would be to replicate the relevant information across event loops, or into a canonical "browser process", so that it can be consulted without queueing a task. This could give different results than what we specify here in edge cases, where the relevant properties have changed over in the target event loop but not yet been replicated. Further testing is needed to determine which of these strategies best matches browser behavior, in such racy edge cases.

9. If navigable's active document's unload counter is greater than 0, then invoke WebDriver BiDi navigation failed with navigable and a WebDriver BiDi navigation status whose id is navigationId, status is "canceled", and url is url, and return.

10. Let container be navigable's container.

11. If container is an iframe element and will lazy load element steps given container returns true, then stop intersection-observing a lazy loading element container and set container's lazy load resumption steps to null.

12. If navigable's allowed to perform a navigation or history update returns blocked, then invoke WebDriver BiDi navigation failed with navigable and a WebDriver BiDi navigation status whose id is navigationId, status is "canceled", and url is url, and return.

13. If historyHandling is "auto":

    1. If url equals navigable's active document's URL, and either userInvolvement is "browser UI" or initiatorOriginSnapshot is same origin with navigable's active document's origin, then set historyHandling to "replace".

    2. Otherwise, set historyHandling to "push".

14. If the navigation must be a replace given url and navigable's active document, then set historyHandling to "replace".

15. If all of the following are true:

    • documentResource is null;

    • response is null;

    • url equals navigable's active session history entry's URL with exclude fragments set to true; and

    • url's fragment is non-null,

    then:

    1. Navigate to a fragment given navigable, url, historyHandling, userInvolvement, sourceElement, navigationAPIState, and navigationId.

    2. Return.

16. If navigable's parent is non-null, then set navigable's is delaying load events to true.

17. Let targetSnapshotParams be the result of snapshotting target snapshot params given navigable.

18. Invoke WebDriver BiDi navigation started with navigable and a new WebDriver BiDi navigation status whose id is navigationId, status is "pending", and url is url.

19. If navigable's ongoing navigation is "traversal":

    1. Invoke WebDriver BiDi navigation failed with navigable and a new WebDriver BiDi navigation status whose id is navigationId, status is "canceled", and url is url.

    2. Return.

    Any attempts to navigate a navigable that is currently traversing are ignored.

20. Set the ongoing navigation for navigable to navigationId.

    This will have the effect of aborting other ongoing navigations of navigable, since at certain points during navigation changes to the ongoing navigation will cause further work to be abandoned.

21. If url's scheme is "javascript":

    1. Let request be a new request, with

       URL

       url

       client

       sourceSnapshotParams's fetch client

       policy container

       sourceSnapshotParams's source policy container

       This is a synthetic request, needed because the Content Security Policy check in navigate to a javascript: URL operates on a request. It will never hit the network.

    2. Queue a global task on the navigation and traversal task source given navigable's active window to navigate to a javascript: URL given navigable, request, historyHandling, initiatorOriginSnapshot, userInvolvement, cspNavigationType, initialInsertion, and navigationId.

    3. Return.

22. If all of the following are true:

    • userInvolvement is not "browser UI";

    • navigable's active document's origin is same origin-domain with sourceDocument's origin;

    • navigable's active document's is initial about:blank is false; and

    • url's scheme is a fetch scheme,

    then:

    1. Let navigation be navigable's active window's navigation API.

    2. Let entryListForFiring be formDataEntryList if documentResource is a POST resource; otherwise, null.

    3. Let navigationAPIStateForFiring be navigationAPIState if navigationAPIState is not null; otherwise, StructuredSerializeForStorage(undefined).

    4. Let continue be the result of firing a push/replace/reload navigate event at navigation with navigationType set to historyHandling, isSameDocument set to false, userInvolvement set to userInvolvement, sourceElement set to sourceElement, formDataEntryList set to entryListForFiring, destinationURL set to url, navigationAPIState set to navigationAPIStateForFiring, and apiMethodTracker set to apiMethodTracker.

    5. If continue is false, then return.

    It is possible for navigations with userInvolvement of "browser UI" or initiated by a cross origin-domain sourceDocument to fire navigate events, if they go through the earlier navigate to a fragment path.

23. If sourceDocument is navigable's container document, then reserve deferred fetch quota for navigable's container given url's origin.

24. In parallel, run these steps:

    1. Let unloadPromptCanceled be the result of checking if unloading is canceled for navigable's active document's inclusive descendant navigables.

    2. If unloadPromptCanceled is not "continue", or navigable's ongoing navigation is no longer navigationId:

       1. Invoke WebDriver BiDi navigation failed with navigable and a new WebDriver BiDi navigation status whose id is navigationId, status is "canceled", and url is url.

       2. Abort these steps.

    3. Queue a global task on the navigation and traversal task source given navigable's active window to abort a document and its descendants given navigable's active document.

    4. Let documentState be a new document state with

       request referrer policy

       referrerPolicy

       initiator origin

       initiatorOriginSnapshot

       resource

       documentResource

       navigable target name

       navigable's target name

       The navigable target name can get cleared under various conditions later in the navigation process, before the document state is finalized.

    5. If url matches about:blank or is about:srcdoc:

       1. Set documentState's origin to initiatorOriginSnapshot.

       2. Set documentState's about base URL to initiatorBaseURLSnapshot.

    6. Let historyEntry be a new session history entry, with its URL set to url and its document state set to documentState.

    7. Let navigationParams be null.

    8. If response is non-null:

       The navigate algorithm is only supplied with a response as part of the object and embed processing models, or for processing parts of multipart/x-mixed-replace responses after the initial response.

       1. Let sourcePolicyContainer be a clone of the sourceDocument's policy container, if sourceDocument is not null; otherwise null.

       2. Let policyContainer be the result of determining navigation params policy container given response's URL, null, sourcePolicyContainer, navigable's container document's policy container, and null.

       3. Let finalSandboxFlags be the union of targetSnapshotParams's sandboxing flags and policyContainer's CSP list's CSP-derived sandboxing flags.

       4. Let responseOrigin be the result of determining the origin given response's URL, finalSandboxFlags, and documentState's initiator origin.

       5. Let coop be a new opener policy.

       6. Let coopEnforcementResult be a new opener policy enforcement result with

          url

          response's URL

          origin

          responseOrigin

          opener policy

          coop

       7. Set navigationParams to a new navigation params, with

          id

          navigationId

          navigable

          navigable

          request

          null

          response

          response

          fetch controller

          null

          commit early hints

          null

          COOP enforcement result

          coopEnforcementResult

          reserved environment

          null

          origin

          responseOrigin

          policy container

          policyContainer

          final sandboxing flag set

          finalSandboxFlags

          iframe element referrer policy

          targetSnapshotParams's iframe element referrer policy

          opener policy

          coop

          navigation timing type

          "navigate"

          about base URL

          documentState's about base URL

          user involvement

          userInvolvement

    9. Attempt to populate the history entry's document for historyEntry, given navigable, "navigate", sourceSnapshotParams, targetSnapshotParams, userInvolvement, navigationId, navigationParams, cspNavigationType, with allowPOST set to true and completionSteps set to the following step:

       1. Append session history traversal steps to navigable's traversable navigable to finalize a cross-document navigation given navigable, historyHandling, userInvolvement, and historyEntry.

To finalize a cross-document navigation given a navigable navigable, a history handling behavior historyHandling, a user navigation involvement userInvolvement, and a session history entry historyEntry:

1. Assert: this is running on navigable's traversable navigable's session history traversal queue.

2. Set navigable's is delaying load events to false.

3. If historyEntry's document is null, then return.

   This means that attempting to populate the history entry's document ended up not creating a document, as a result of e.g., the navigation being canceled by a subsequent navigation, a 204 No Content response, etc.

4. If all of the following are true:

   • navigable's parent is null;

   • historyEntry's document's browsing context is not an auxiliary browsing context whose opener browsing context is non-null; and

   • historyEntry's document's origin is not same origin with navigable's active document's origin,

   then set historyEntry's document state's navigable target name to the empty string.

5. Let entryToReplace be navigable's active session history entry if historyHandling is "replace", otherwise null.

6. Let traversable be navigable's traversable navigable.

7. Let targetStep be null.

8. Let targetEntries be the result of getting session history entries for navigable.

9. If entryToReplace is null:

   1. Clear the forward session history of traversable.

   2. Set targetStep to traversable's current session history step + 1.

   3. Set historyEntry's step to targetStep.

   4. Append historyEntry to targetEntries.

   Otherwise:

   1. Replace entryToReplace with historyEntry in targetEntries.

   2. Set historyEntry's step to entryToReplace's step.

   3. If historyEntry's document state's origin is same origin with entryToReplace's document state's origin, then set historyEntry's navigation API key to entryToReplace's navigation API key.

   4. Set targetStep to traversable's current session history step.

10. Apply the push/replace history step targetStep to traversable given historyHandling and userInvolvement.

To navigate to a javascript: URL, given a navigable targetNavigable, a request request, a history handling behavior historyHandling, an origin initiatorOrigin, a user navigation involvement userInvolvement, a string cspNavigationType, a boolean initialInsertion, and a navigation ID navigationId:

1. Assert: historyHandling is "replace".

2. If targetNavigable's ongoing navigation is no longer navigationId, then return.

3. Set the ongoing navigation for targetNavigable to null.

4. If initiatorOrigin is not same origin-domain with targetNavigable's active document's origin, then return.

5. If the result of should navigation request of type be blocked by Content Security Policy? given request and cspNavigationType is "Blocked", then return. [CSP]

   This can change request's URL, as the require-trusted-types-for pre-navigation check passes the script source through the default policy. [TRUSTED-TYPES]

6. Let newDocument be the result of evaluating a javascript: URL given targetNavigable, request's URL, initiatorOrigin, userInvolvement, and navigationId.

7. If newDocument is null:

   1. Let container be targetNavigable's container.

   2. If initialInsertion is true, container is non-null, and targetNavigable's active document's is initial about:blank is true:

      1. If container is an iframe element, then run the iframe load event steps given container.

      2. Otherwise, fire an event named load at container.

      container can be null if author code, such as the Trusted Types default policy or javascript:frameElement.remove(), removed it.

   3. Return.

   In this case, some JavaScript code was executed, but no new Document was created, so we will not perform a navigation.

8. Assert: initiatorOrigin is newDocument's origin.

9. Let entryToReplace be targetNavigable's active session history entry.

10. Let oldDocState be entryToReplace's document state.

11. Let documentState be a new document state with

    document

    newDocument

    history policy container

    a clone of the oldDocState's history policy container if it is non-null; null otherwise

    request referrer

    oldDocState's request referrer

    request referrer policy

    oldDocState's request referrer policy or should this be the referrerPolicy that was passed to navigate?

    initiator origin

    initiatorOrigin

    origin

    initiatorOrigin

    about base URL

    oldDocState's about base URL

    resource

    null

    ever populated

    true

    navigable target name

    oldDocState's navigable target name

12. Let historyEntry be a new session history entry, with

    URL

    entryToReplace's URL

    document state

    documentState

    For the URL, we do not use request's URL, i.e., the javascript: URL that was evaluated. This means javascript: URLs are never stored in session history, and so can never be traversed to.

13. Append session history traversal steps to targetNavigable's traversable navigable to finalize a cross-document navigation with targetNavigable, historyHandling, userInvolvement, and historyEntry.

To evaluate a javascript: URL given a navigable targetNavigable, a URL url, an origin newDocumentOrigin, a user navigation involvement userInvolvement, and a navigation ID navigationId:

1. Let urlString be the result of running the URL serializer on url.

2. Let encodedScriptSource be the result of removing the leading "javascript:" from urlString.

3. Let scriptSource be the UTF-8 decoding of the percent-decoding of encodedScriptSource.

4. Let settings be targetNavigable's active document's relevant settings object.

5. Let baseURL be settings's API base URL.

6. Let script be the result of creating a classic script given scriptSource, settings, baseURL, and the default script fetch options.

7. Let evaluationStatus be the result of running the classic script script.

8. Let result be null.

9. If evaluationStatus is a normal completion, and evaluationStatus.[[Value]] is a String, then set result to evaluationStatus.[[Value]].

10. Otherwise, return null.

11. Let response be a new response with

    URL

    targetNavigable's active document's URL

    header list

    « (`Content-Type`, `text/html;charset=utf-8`) »

    body

    the UTF-8 encoding of result, as a body

    The encoding to UTF-8 means that unpaired surrogates will not roundtrip, once the HTML parser decodes the response body.

12. Let policyContainer be targetNavigable's active document's policy container.

13. Let finalSandboxFlags be policyContainer's CSP list's CSP-derived sandboxing flags.

14. Let coop be targetNavigable's active document's opener policy.

15. Let coopEnforcementResult be a new opener policy enforcement result with

    url

    url

    origin

    newDocumentOrigin

    opener policy

    coop

16. Let navigationParams be a new navigation params, with

    id

    navigationId

    navigable

    targetNavigable

    request

    null this will cause the referrer of the resulting Document to be null; is that correct?

    response

    response

    fetch controller

    null

    commit early hints

    null

    COOP enforcement result

    coopEnforcementResult

    reserved environment

    null

    origin

    newDocumentOrigin

    policy container

    policyContainer

    final sandboxing flag set

    finalSandboxFlags

    iframe element referrer policy

    targetSnapshotParams's iframe element referrer policy

    opener policy

    coop

    navigation timing type

    "navigate"

    about base URL

    targetNavigable's active document's about base URL

    user involvement

    userInvolvement

17. Return the result of loading an HTML document given navigationParams.

To navigate to a fragment given a navigable navigable, a URL url, a history handling behavior historyHandling, a user navigation involvement userInvolvement, an Element-or-null sourceElement, a serialized state-or-null navigationAPIState, and a navigation ID navigationId:

1. Let navigation be navigable's active window's navigation API.

2. Let destinationNavigationAPIState be navigable's active session history entry's navigation API state.

3. If navigationAPIState is not null, then set destinationNavigationAPIState to navigationAPIState.

4. Let continue be the result of firing a push/replace/reload navigate event at navigation with navigationType set to historyHandling, isSameDocument set to true, userInvolvement set to userInvolvement, sourceElement set to sourceElement, destinationURL set to url, and navigationAPIState set to destinationNavigationAPIState.

5. If continue is false:

   1. If navigation's ongoing navigate event is not null, then set the ongoing navigation of navigable to navigationId.

      This makes intercepted hash navigations cancelable by browser UI or window.stop().

   2. Return.

6. Let historyEntry be a new session history entry, with

   URL

   url

   document state

   navigable's active session history entry's document state

   navigation API state

   destinationNavigationAPIState

   scroll restoration mode

   navigable's active session history entry's scroll restoration mode

   For navigations performed with navigation.navigate(), the value provided by the state option is used for the new navigation API state. (This will set it to the serialization of undefined, if no value is provided for that option.) For other fragment navigations, including user-initiated ones, the navigation API state is carried over from the previous entry.

   The classic history API state is never carried over.

7. Let entryToReplace be navigable's active session history entry if historyHandling is "replace", otherwise null.

8. If entryToReplace is non-null, then set historyEntry's navigation API key to entryToReplace's navigation API key.

9. Let history be navigable's active document's history object.

10. Let scriptHistoryIndex be history's index.

11. Let scriptHistoryLength be history's length.

12. If historyHandling is "push":

    1. Set history's state to null.

    2. Increment scriptHistoryIndex.

    3. Set scriptHistoryLength to scriptHistoryIndex + 1.

13. Set navigable's active document's URL to url.

14. Set navigable's active session history entry to historyEntry.

15. Update document for history step application given navigable's active document, historyEntry, true, scriptHistoryIndex, scriptHistoryLength, and historyHandling.

    This algorithm will be called twice as a result of a single fragment navigation: once synchronously, where best-guess values scriptHistoryIndex and scriptHistoryLength are set, history.state is nulled out, and various events are fired; and once asynchronously, where the final values for index and length are set, history.state remains untouched, and no events are fired.

16. Scroll to the fragment given navigable's active document.

    If the scrolling fails because the Document is new and the relevant ID has not yet been parsed, then the second asynchronous call to update document for history step application will take care of scrolling.

17. Let traversable be navigable's traversable navigable.

18. Append the following session history synchronous navigation steps involving navigable to traversable:

    1. Finalize a same-document navigation given traversable, navigable, historyEntry, entryToReplace, historyHandling, and userInvolvement.

    2. Invoke WebDriver BiDi fragment navigated with navigable and a new WebDriver BiDi navigation status whose id is navigationId, url is url, and status is "complete".

To finalize a same-document navigation given a traversable navigable traversable, a navigable targetNavigable, a session history entry targetEntry, a session history entry-or-null entryToReplace, a history handling behavior historyHandling, and a user navigation involvement userInvolvement:

This is used by both fragment navigations and by the URL and history update steps, which are the only synchronous updates to session history. By virtue of being synchronous, those algorithms are performed outside of the top-level traversable's session history traversal queue. This puts them out of sync with the top-level traversable's current session history step, so this algorithm is used to resolve conflicts due to race conditions.

1. Assert: this is running on traversable's session history traversal queue.

2. If targetNavigable's active session history entry is not targetEntry, then return.

3. Let targetStep be null.

4. Let targetEntries be the result of getting session history entries for targetNavigable.

5. If entryToReplace is null:

   1. Clear the forward session history of traversable.

   2. Set targetStep to traversable's current session history step + 1.

   3. Set targetEntry's step to targetStep.

   4. Append targetEntry to targetEntries.

   Otherwise:

   1. Replace entryToReplace with targetEntry in targetEntries.

   2. Set targetEntry's step to entryToReplace's step.

   3. Set targetStep to traversable's current session history step.

6. Apply the push/replace history step targetStep to traversable given historyHandling and userInvolvement.

   This is done even for "replace" navigations, as it resolves race conditions across multiple synchronous navigations.

To attempt to create a non-fetch scheme document, given a non-fetch scheme navigation params navigationParams:

1. Let url be navigationParams's URL.
2. Let navigable be navigationParams's navigable.

3. If url is to be handled using a mechanism that does not affect navigable, e.g., because url's scheme is handled externally:

   1. Hand-off to external software given url, navigable, navigationParams's target snapshot sandboxing flags, navigationParams's source snapshot has transient activation, and navigationParams's initiator origin.

   2. Return null.

4. Handle url by displaying some sort of inline content, e.g., an error message because the specified scheme is not one of the supported protocols, or an inline prompt to allow the user to select a registered handler for the given scheme. Return the result of displaying the inline content given navigable, navigationParams's id, navigationParams's navigation timing type, and navigationParams's user involvement.

   In the case of a registered handler being used, navigate will be invoked with a new URL.

To hand-off to external software given a URL or response resource, a navigable navigable, a sandboxing flag set sandboxFlags, a boolean hasTransientActivation, and an origin initiatorOrigin, user agents should:

1. If all of the following are true:

   • navigable is not a top-level traversable;

   • sandboxFlags has its sandboxed custom protocols navigation browsing context flag set; and

   • sandboxFlags has its sandboxed top-level navigation with user activation browsing context flag set, or hasTransientActivation is false,

   then return without invoking the external software package.

   Navigation inside an iframe toward external software can be seen by users as a new popup or a new top-level navigation. That's why its is allowed in sandboxed iframe only when one of allow-popups, allow-top-navigation, allow-top-navigation-by-user-activation, or allow-top-navigation-to-custom-protocols is specified.

2. Perform the appropriate handoff of resource while attempting to mitigate the risk that this is an attempt to exploit the target software. For example, user agents could prompt the user to confirm that initiatorOrigin is to be allowed to invoke the external software in question. In particular, if hasTransientActivation is false, then the user agent should not invoke the external software package without prior user confirmation.

   For example, there could be a vulnerability in the target software's URL handler which a hostile page would attempt to exploit by tricking a user into clicking a link.

A navigable source is allowed by sandboxing to navigate a second navigable target, given a source snapshot params sourceSnapshotParams, if the following steps return true:

1. If source is target, then return true.

2. If source is an ancestor of target, then return true.

3. If target is an ancestor of source:

   1. If target is not a top-level traversable, then return true.

   2. If sourceSnapshotParams's has transient activation is true, and sourceSnapshotParams's sandboxing flags's sandboxed top-level navigation with user activation browsing context flag is set, then return false.

   3. If sourceSnapshotParams's has transient activation is false, and sourceSnapshotParams's sandboxing flags's sandboxed top-level navigation without user activation browsing context flag is set, then return false.

   4. Return true.

4. If target is a top-level traversable:

   1. If source is the one permitted sandboxed navigator of target, then return true.

   2. If sourceSnapshotParams's sandboxing flags's sandboxed navigation browsing context flag is set, then return false.

   3. Return true.

5. If sourceSnapshotParams's sandboxing flags's sandboxed navigation browsing context flag is set, then return false.

6. Return true.

To check if unloading is canceled for a list of navigables navigablesThatNeedBeforeUnload, given an optional traversable navigable traversable, an optional integer targetStep, and an optional user navigation involvement userInvolvementForNavigateEvent, run these steps. They return "canceled-by-beforeunload", "canceled-by-navigate", or "continue".

1. Let documentsToFireBeforeunload be the active document of each item in navigablesThatNeedBeforeUnload.

2. Let unloadPromptShown be false.

3. Let finalStatus be "continue".

4. If traversable was given:

   1. Assert: targetStep and userInvolvementForNavigateEvent were given.

   2. Let targetEntry be the result of getting the target history entry given traversable and targetStep.

   3. If targetEntry is not traversable's current session history entry, and targetEntry's document state's origin is the same as traversable's current session history entry's document state's origin:

      In this case, we're going to fire the navigate event for traversable here. Because under some circumstances it might be canceled, we need to do this separately from other traversal navigate events, which happen later.

      Additionally, because we want beforeunload events to fire before navigate events, this means we need to fire beforeunload for traversable here (if applicable), instead of doing it as part of the below loop over documentsToFireBeforeunload.

      1. Let eventsFired be false.

      2. Let needsBeforeunload be true if navigablesThatNeedBeforeUnload contains traversable; otherwise false.

      3. If needsBeforeunload is true, then remove traversable's active document from documentsToFireBeforeunload.

      4. Queue a global task on the navigation and traversal task source given traversable's active window to perform the following steps:

         1. If needsBeforeunload is true:

            1. Let (unloadPromptShownForThisDocument, unloadPromptCanceledByThisDocument) be the result of running the steps to fire beforeunload given traversable's active document and false.

            2. If unloadPromptShownForThisDocument is true, then set unloadPromptShown to true.

            3. If unloadPromptCanceledByThisDocument is true, then set finalStatus to "canceled-by-beforeunload".

         2. If finalStatus is "canceled-by-beforeunload", then abort these steps.

         3. Let navigation be traversable's active window's navigation API.

         4. Let navigateEventResult be the result of firing a traverse navigate event at navigation given targetEntry and userInvolvementForNavigateEvent.

         5. If navigateEventResult is false, then set finalStatus to "canceled-by-navigate".

         6. Set eventsFired to true.

      5. Wait until eventsFired is true.

      6. If finalStatus is not "continue", then return finalStatus.

5. Let totalTasks be the size of documentsToFireBeforeunload.

6. Let completedTasks be 0.

7. For each document of documentsToFireBeforeunload, queue a global task on the navigation and traversal task source given document's relevant global object to run the steps:

   1. Let (unloadPromptShownForThisDocument, unloadPromptCanceledByThisDocument) be the result of running the steps to fire beforeunload given document and unloadPromptShown.

   2. If unloadPromptShownForThisDocument is true, then set unloadPromptShown to true.

   3. If unloadPromptCanceledByThisDocument is true, then set finalStatus to "canceled-by-beforeunload".

   4. Increment completedTasks.

8. Wait for completedTasks to be totalTasks.

9. Return finalStatus.

The steps to fire beforeunload given a Document document and a boolean unloadPromptShown are:

1. Let unloadPromptCanceled be false.

2. Increase the document's unload counter by 1.

3. Increase document's relevant agent's event loop's termination nesting level by 1.

4. Let eventFiringResult be the result of firing an event named beforeunload at document's relevant global object, using BeforeUnloadEvent, with the cancelable attribute initialized to true.

5. Decrease document's relevant agent's event loop's termination nesting level by 1.

6. If all of the following are true:

   • unloadPromptShown is false;

   • document's active sandboxing flag set does not have its sandboxed modals flag set;

   • document's relevant global object has sticky activation;

   • eventFiringResult is false, or the returnValue attribute of event is not the empty string; and

   • showing an unload prompt is unlikely to be annoying, deceptive, or pointless,

   then:

   1. Set unloadPromptShown to true.

   2. Let userPromptHandler be the result of WebDriver BiDi user prompt opened with document's relevant global object, "beforeunload", and "".

   3. If userPromptHandler is "dismiss", then set unloadPromptCanceled to true.

   4. If userPromptHandler is "none":

      1. Ask the user to confirm that they wish to unload the document, and pause while waiting for the user's response.

         The message shown to the user is not customizable, but instead determined by the user agent. In particular, the actual value of the returnValue attribute is ignored.

      2. If the user did not confirm the page navigation, then set unloadPromptCanceled to true.

   5. Invoke WebDriver BiDi user prompt closed with document's relevant global object, "beforeunload", and true if unloadPromptCanceled is false or false otherwise.

7. Decrease document's unload counter by 1.

8. Return (unloadPromptShown, unloadPromptCanceled).

To set the ongoing navigation for a navigable navigable to newValue:

1. If navigable's ongoing navigation is equal to newValue, then return.

2. Inform the navigation API about aborting navigation given navigable.

3. Set navigable's ongoing navigation to newValue.

To reload a navigable navigable given an optional serialized state-or-null navigationAPIState (default null), an optional user navigation involvement userInvolvement (default "none"), and an optional navigation API method tracker-or-null apiMethodTracker (default null):

1. If userInvolvement is not "browser UI":

   1. Let navigation be navigable's active window's navigation API.

   2. Let destinationNavigationAPIState be navigable's active session history entry's navigation API state.

   3. If navigationAPIState is not null, then set destinationNavigationAPIState to navigationAPIState.

   4. Let continue be the result of firing a push/replace/reload navigate event at navigation with navigationType set to "reload", isSameDocument set to false, userInvolvement set to userInvolvement, destinationURL set to navigable's active session history entry's URL, navigationAPIState set to destinationNavigationAPIState, and apiMethodTracker set to apiMethodTracker.

   5. If continue is false, then return.

2. Set navigable's active session history entry's document state's reload pending to true.

3. Let traversable be navigable's traversable navigable.

4. Append the following session history traversal steps to traversable:

   1. Apply the reload history step to traversable given userInvolvement.

To traverse the history by a delta given a traversable navigable traversable, an integer delta, and an optional Document sourceDocument:

1. Let sourceSnapshotParams and initiatorToCheck be null.

2. Let userInvolvement be "browser UI".

3. If sourceDocument is given:

   1. Set sourceSnapshotParams to the result of snapshotting source snapshot params given sourceDocument.

   2. Set initiatorToCheck to sourceDocument's node navigable.

   3. Set userInvolvement to "none".

4. Append the following session history traversal steps to traversable:

   1. Let allSteps be the result of getting all used history steps for traversable.

   2. Let currentStepIndex be the index of traversable's current session history step within allSteps.

   3. Let targetStepIndex be currentStepIndex plus delta.

   4. If allSteps[targetStepIndex] does not exist, then abort these steps.

   5. Apply the traverse history step allSteps[targetStepIndex] to traversable, given sourceSnapshotParams, initiatorToCheck, and userInvolvement.

The URL and history update steps, given a Document document, a URL newURL, an optional serialized state-or-null serializedData (default null), and an optional history handling behavior historyHandling (default "replace"), are:

1. Let navigable be document's node navigable.

2. Let activeEntry be navigable's active session history entry.

3. Let newEntry be a new session history entry, with

   URL

   newURL

   serialized state

   if serializedData is not null, serializedData; otherwise activeEntry's classic history API state

   document state

   activeEntry's document state

   scroll restoration mode

   activeEntry's scroll restoration mode

   persisted user state

   activeEntry's persisted user state

4. If document's is initial about:blank is true, then set historyHandling to "replace".

   This means that pushState() on an initial about:blank Document behaves as a replaceState() call.

5. Let entryToReplace be activeEntry if historyHandling is "replace", otherwise null.

6. If entryToReplace is non-null, then set newEntry's navigation API key to entryToReplace's navigation API key.

7. If historyHandling is "push":

   1. Increment document's history object's index.

   2. Set document's history object's length to its index + 1.

   These are temporary best-guess values for immediate synchronous access.

8. If serializedData is not null, then restore the history object state given document and newEntry.

9. Set the URL given document to newURL.

   Since this is neither a navigation nor a history traversal, it does not cause a hashchange event to be fired.

10. Set document's latest entry to newEntry.

11. Set navigable's active session history entry to newEntry.

12. Update the navigation API entries for a same-document navigation given document's relevant global object's navigation API, newEntry, and historyHandling.

13. Let traversable be navigable's traversable navigable.

14. Append the following session history synchronous navigation steps involving navigable to traversable:

    1. Finalize a same-document navigation given traversable, navigable, newEntry, entryToReplace, historyHandling, and "none".

    2. Invoke WebDriver BiDi history updated with navigable.

To attempt to populate the history entry's document for a session history entry entry, given a navigable navigable, a NavigationTimingType navTimingType, a source snapshot params sourceSnapshotParams, a target snapshot params targetSnapshotParams, a user navigation involvement userInvolvement, an optional navigation ID-or-null navigationId (default null), an optional navigation params-or-null navigationParams (default null), an optional string cspNavigationType (default "other"), an optional boolean allowPOST (default false), and optional algorithm steps completionSteps (default an empty algorithm):

1. Assert: this is running in parallel.

2. Assert: if navigationParams is non-null, then navigationParams's response is non-null.

3. Let documentResource be entry's document state's resource.

4. If navigationParams is null:

   1. If documentResource is a string, then set navigationParams to the result of creating navigation params from a srcdoc resource given entry, navigable, targetSnapshotParams, userInvolvement, navigationId, and navTimingType.

   2. Otherwise, if all of the following are true:

      • entry's URL's scheme is a fetch scheme; and

      • documentResource is null, or allowPOST is true and documentResource's request body is not failure,

      then set navigationParams to the result of creating navigation params by fetching given entry, navigable, sourceSnapshotParams, targetSnapshotParams, cspNavigationType, userInvolvement, navigationId, and navTimingType.

   3. Otherwise, if entry's URL's scheme is not a fetch scheme, then set navigationParams to a new non-fetch scheme navigation params, with

      id

      navigationId

      navigable

      navigable

      URL

      entry's URL

      target snapshot sandboxing flags

      targetSnapshotParams's sandboxing flags

      source snapshot has transient activation

      sourceSnapshotParams's has transient activation

      initiator origin

      entry's document state's initiator origin

      navigation timing type

      navTimingType

      user involvement

      userInvolvement

5. Queue a global task on the navigation and traversal task source, given navigable's active window, to run these steps:

   1. If navigable's ongoing navigation no longer equals navigationId, then run completionSteps and abort these steps.

   2. Let saveExtraDocumentState be true.

      Usually, in the cases where we end up populating entry's document state's document, we then want to save some of the state from that Document into entry. This ensures that if there are future traversals to entry where its document has been destroyed, we can use that state when creating a new Document.

      However, in some specific cases, saving the state would be unhelpful. For those, we set saveExtraDocumentState to false later in this algorithm.

   3. If navigationParams is a non-fetch scheme navigation params:

      1. Set entry's document state's document to the result of running attempt to create a non-fetch scheme document given navigationParams.

         This can result in setting entry's document state's document to null, e.g., when handing-off to external software.

      2. Set saveExtraDocumentState to false.

   4. Otherwise, if any of the following are true:

      • navigationParams is null;

      • the result of should navigation response to navigation request of type in target be blocked by Content Security Policy? given navigationParams's request, navigationParams's response, navigationParams's policy container's CSP list, cspNavigationType, and navigable is "Blocked";

      • navigationParams's reserved environment is non-null and the result of checking a navigation response's adherence to its embedder policy given navigationParams's response, navigable, and navigationParams's policy container's embedder policy is false; or

      • the result of checking a navigation response's adherence to `X-Frame-Options` given navigationParams's response, navigable, navigationParams's policy container's CSP list, and navigationParams's origin is false,

      then:

      1. Set entry's document state's document to the result of creating a document for inline content that doesn't have a DOM, given navigable, null, navTimingType, and userInvolvement. The inline content should indicate to the user the sort of error that occurred.

      2. Make document unsalvageable given entry's document state's document and "navigation-failure".

      3. Set saveExtraDocumentState to false.

      4. If navigationParams is not null:

         1. Run the environment discarding steps for navigationParams's reserved environment.

         2. Invoke WebDriver BiDi navigation failed with navigable and a new WebDriver BiDi navigation status whose id is navigationId, status is "canceled", and url is navigationParams's response's URL.

   5. Otherwise, if navigationParams's response has a `Content-Disposition` header specifying the attachment disposition type:

      1. Let sourceAllowsDownloading be sourceSnapshotParams's allows downloading.

      2. Let targetAllowsDownloading be false if navigationParams's final sandboxing flag set has the sandboxed downloads browsing context flag set; otherwise true.

      3. Let uaAllowsDownloading be true.

      4. Optionally, the user agent may set uaAllowsDownloading to false, if it believes doing so would safeguard the user from a potentially hostile download.

      5. If sourceAllowsDownloading, targetAllowsDownloading, and uaAllowsDownloading are true:

         1. Handle as a download navigationParams's response with navigable and navigationId.

      This branch leaves entry's document state's document as null.

   6. Otherwise, if navigationParams's response's status is not 204 and is not 205, then set entry's document state's document to the result of loading a document given navigationParams, sourceSnapshotParams, and entry's document state's initiator origin.

      This can result in setting entry's document state's document to null, e.g., when handing-off to external software.

   7. If entry's document state's document is not null:

      1. Set entry's document state's ever populated to true.

      2. If saveExtraDocumentState is true:

         1. Let document be entry's document state's document.

         2. Set entry's document state's origin to document's origin.

         3. If document's URL requires storing the policy container in history:

            1. Assert: navigationParams is a navigation params (i.e., neither null nor a non-fetch scheme navigation params).

            2. Set entry's document state's history policy container to navigationParams's policy container.

      3. If entry's document state's request referrer is "client", and navigationParams is a navigation params (i.e., neither null nor a non-fetch scheme navigation params):

         1. Assert: navigationParams's request is not null.

         2. Set entry's document state's request referrer to navigationParams's request's referrer.

   8. Run completionSteps.

To create navigation params from a srcdoc resource given a session history entry entry, a navigable navigable, a target snapshot params targetSnapshotParams, a user navigation involvement userInvolvement, a navigation ID-or-null navigationId, and a NavigationTimingType navTimingType:

1. Let documentResource be entry's document state's resource.

2. Let response be a new response with

   URL

   about:srcdoc

   header list

   « (`Content-Type`, `text/html`) »

   body

   the UTF-8 encoding of documentResource, as a body

3. Let responseOrigin be the result of determining the origin given response's URL, targetSnapshotParams's sandboxing flags, and entry's document state's origin.

4. Let coop be a new opener policy.

5. Let coopEnforcementResult be a new opener policy enforcement result with

   url

   response's URL

   origin

   responseOrigin

   opener policy

   coop

6. Let policyContainer be the result of determining navigation params policy container given response's URL, entry's document state's history policy container, null, navigable's container document's policy container, and null.

7. Return a new navigation params, with

   id

   navigationId

   navigable

   navigable

   request

   null

   response

   response

   fetch controller

   null

   commit early hints

   null

   COOP enforcement result

   coopEnforcementResult

   reserved environment

   null

   origin

   responseOrigin

   policy container

   policyContainer

   final sandboxing flag set

   targetSnapshotParams's sandboxing flags

   iframe element referrer policy

   targetSnapshotParams's iframe element referrer policy

   opener policy

   coop

   navigation timing type

   navTimingType

   about base URL

   entry's document state's about base URL

   user involvement

   userInvolvement

To create navigation params by fetching given a session history entry entry, a navigable navigable, a source snapshot params sourceSnapshotParams, a target snapshot params targetSnapshotParams, a string cspNavigationType, a user navigation involvement userInvolvement, a navigation ID-or-null navigationId, and a NavigationTimingType navTimingType, perform the following steps. They return a navigation params, a non-fetch scheme navigation params, or null.

This algorithm mutates entry.

1. Assert: this is running in parallel.

2. Let documentResource be entry's document state's resource.

3. Let request be a new request, with

   URL

   entry's URL

   client

   sourceSnapshotParams's fetch client

   destination

   "document" The destination is updated below when navigable has a container.

   credentials mode

   "include"

   use-URL-credentials flag

   set

   redirect mode

   "manual"

   replaces client id

   navigable's active document's relevant settings object's id

   mode

   "navigate"

   referrer

   entry's document state's request referrer

   referrer policy

   entry's document state's request referrer policy

   policy container

   sourceSnapshotParams's source policy container

   traversable for user prompts

   navigable's top-level traversable

4. If navigable is a top-level traversable, then set request's top-level navigation initiator origin to entry's document state's initiator origin.

5. If request's client is null:

   This only occurs in the case of a browser UI-initiated navigation.

   1. Set request's origin to a new opaque origin.

   2. Set request's service-workers mode to "all".

   3. Set request's referrer to "no-referrer".

6. If documentResource is a POST resource:

   1. Set request's method to `POST`.

   2. Set request's body to documentResource's request body.

   3. Set `Content-Type` to documentResource's request content-type in request's header list.

7. If entry's document state's reload pending is true, then set request's reload-navigation flag.

8. Otherwise, if entry's document state's ever populated is true, then set request's history-navigation flag.

9. If sourceSnapshotParams's has transient activation is true, then set request's user-activation to true.

10. If navigable's container is non-null:

    1. If the navigable's container has a browsing context scope origin, then set request's origin to that browsing context scope origin.

    2. Set request's destination to navigable's container's local name.

    3. If sourceSnapshotParams's fetch client is navigable's container document's relevant settings object, then set request's initiator type to navigable's container's local name.

       This ensure that only container-initiated navigations are reported to resource timing.

11. Let response be null.

12. Let responseOrigin be null.

13. Let fetchController be null.

14. Let coopEnforcementResult be a new opener policy enforcement result, with

    url

    navigable's active document's URL

    origin

    navigable's active document's origin

    opener policy

    navigable's active document's opener policy

    current context is navigation source

    true if navigable's active document's origin is same origin with entry's document state's initiator origin otherwise false

15. Let finalSandboxFlags be an empty sandboxing flag set.

16. Let responsePolicyContainer be null.

17. Let responseCOOP be a new opener policy.

18. Let locationURL be null.

19. Let currentURL be request's current URL.

20. Let commitEarlyHints be null.

21. While true:

    1. If request's reserved client is not null and currentURL's origin is not the same as request's reserved client's creation URL's origin:

       1. Run the environment discarding steps for request's reserved client.

       2. Set request's reserved client to null.

       3. Set commitEarlyHints to null.

          Preloaded links from early hint headers remain in the preload cache after a same origin redirect, but get discarded when the redirect is cross-origin.

    2. If request's reserved client is null:

       1. Let topLevelCreationURL be currentURL.

       2. Let topLevelOrigin be null.

       3. If navigable is not a top-level traversable:

          1. Let parentEnvironment be navigable's parent's active document's relevant settings object.

          2. Set topLevelCreationURL to parentEnvironment's top-level creation URL.

          3. Set topLevelOrigin to parentEnvironment's top-level origin.

       4. Set request's reserved client to a new environment whose id is a unique opaque string, target browsing context is navigable's active browsing context, creation URL is currentURL, top-level creation URL is topLevelCreationURL, and top-level origin is topLevelOrigin.

          The created environment's active service worker is set in the Handle Fetch algorithm during the fetch if the request URL matches a service worker registration. [SW]

    3. If the result of should navigation request of type be blocked by Content Security Policy? given request and cspNavigationType is "Blocked", then set response to a network error and break. [CSP]

    4. Set response to null.

    5. If fetchController is null, then set fetchController to the result of fetching request, with processEarlyHintsResponse set to processEarlyHintsResponse as defined below, processResponse set to processResponse as defined below, and useParallelQueue set to true.

       Let processEarlyHintsResponse be the following algorithm given a response earlyResponse:

       1. If commitEarlyHints is null, then set commitEarlyHints to the result of processing early hint headers given earlyResponse and request's reserved client.

       Let processResponse be the following algorithm given a response fetchedResponse:

       1. Set response to fetchedResponse.

    6. Otherwise, process the next manual redirect for fetchController.

       This will result in calling the processResponse we supplied above, during our first iteration through the loop, and thus setting response.

       Navigation handles redirects manually as navigation is the only place in the web platform that cares for redirects to mailto: URLs and such.

    7. Wait until either response is non-null, or navigable's ongoing navigation changes to no longer equal navigationId.

       If the latter condition occurs, then abort fetchController, and return.

       Otherwise, proceed onward.

    8. If request's body is null, then set entry's document state's resource to null.

       Fetch unsets the body for particular redirects.

    9. Set responsePolicyContainer to the result of creating a policy container from a fetch response given response and request's reserved client.

    10. Set finalSandboxFlags to the union of targetSnapshotParams's sandboxing flags and responsePolicyContainer's CSP list's CSP-derived sandboxing flags.

    11. Set responseOrigin to the result of determining the origin given response's URL, finalSandboxFlags, and entry's document state's initiator origin.

        If response is a redirect, then response's URL will be the URL that led to the redirect to response's location URL; it will not be the location URL itself.

    12. If navigable is a top-level traversable:

        1. Set responseCOOP to the result of obtaining an opener policy given response and request's reserved client.

        2. Set coopEnforcementResult to the result of enforcing the response's opener policy given navigable's active browsing context, response's URL, responseOrigin, responseCOOP, coopEnforcementResult, and request's referrer.

        3. If finalSandboxFlags is not empty and responseCOOP's value is not "unsafe-none", then set response to an appropriate network error and break.

           This results in a network error as one cannot simultaneously provide a clean slate to a response using opener policy and sandbox the result of navigating to that response.

    13. If all of the following are true:

        • response is not a network error;

        • navigable is a child navigable;

        • response's URL's scheme is an HTTP(S) scheme; and

        • the result of performing a cross-origin resource policy check with navigable's container document's origin, navigable's container document's relevant settings object, request's destination, response, and true is blocked,

        then set response to a network error and break.

        Here we're running the cross-origin resource policy check against the parent navigable rather than navigable itself. This is because we care about the same-originness of the embedded content against the parent context, not the navigation source. We only run it for HTTP(S) scheme responses, as in Fetch; other responses are still subject to checking a navigation response's adherence to its embedder policy.

    14. Set locationURL to response's location URL given currentURL's fragment.

    15. If locationURL is failure or null, then break.

    16. Assert: locationURL is a URL.

    17. Set entry's classic history API state to StructuredSerializeForStorage(null).

    18. Let oldDocState be entry's document state.

    19. Set entry's document state to a new document state, with

        history policy container

        a clone of the oldDocState's history policy container if it is non-null; null otherwise

        request referrer

        oldDocState's request referrer

        request referrer policy

        oldDocState's request referrer policy

        initiator origin

        oldDocState's initiator origin

        origin

        oldDocState's origin

        about base URL

        oldDocState's about base URL

        resource

        oldDocState's resource

        ever populated

        oldDocState's ever populated

        navigable target name

        oldDocState's navigable target name

        For the navigation case, only entry referenced oldDocState, which was created early in the navigate algorithm. So for navigations, this is functionally just an update to entry's document state. For the traversal case, it's possible adjacent session history entries also reference oldDocState, in which case they will continue doing so even after we've updated entry's document state.

        oldDocState's history policy container is only ever non-null here in the traversal case, after we've populated it during a navigation to a URL that requires storing the policy container in history.

        The setup is given by the following Jake diagram:

        	0	1	2	3
        top	/a	/a#foo	/a#bar	/b

        Also assume that the document state shared by the entries in steps 0, 1, and 2 has a null document, i.e., bfcache is not in play.

        Now consider the scenario where we traverse back to step 2, but this time when fetching /a, the server responds with a `Location` header pointing to /c. That is, locationURL points to /c and so we have reached this step instead of breaking out of the loop.

        In this case, we replace the document state of the session history entry occupying step 2, but we do not replace the document state of the entries occupying steps 0 and 1. The resulting Jake diagram looks like this:

        	0	1	2	3
        top	/a	/a#foo	/c#bar	/b

        Note that we perform this replacement even if we end up in a redirect chain back to the original URL, for example if /c itself had a `Location` header pointing to /a. Such a case would end up like so:

        	0	1	2	3
        top	/a	/a#foo	/a#bar	/b

    20. If locationURL's scheme is not an HTTP(S) scheme:

        1. Set entry's document state's resource to null.

        2. Break.

    21. Set currentURL to locationURL.

    22. Set entry's URL to currentURL.

    By the end of this loop we will be in one of these scenarios:

    • locationURL is failure, because of an unparseable `Location` header.

    • locationURL is null, either because response is a network error or because we successfully fetched a non-network error HTTP(S) response with no `Location` header.

    • locationURL is a URL with a non-HTTP(S) scheme.

22. If locationURL is a URL whose scheme is not a fetch scheme, then return a new non-fetch scheme navigation params, with

    id

    navigationId

    navigable

    navigable

    URL

    locationURL

    target snapshot sandboxing flags

    targetSnapshotParams's sandboxing flags

    source snapshot has transient activation

    sourceSnapshotParams's has transient activation

    initiator origin

    responseOrigin

    navigation timing type

    navTimingType

    user involvement

    userInvolvement

    At this point, request's current URL is the last URL in the redirect chain with a fetch scheme before redirecting to a non-fetch scheme URL. It is this URL's origin that will be used as the initiator origin for navigations to non-fetch scheme URLs.

23. If any of the following are true:

    • response is a network error;

    • locationURL is failure; or

    • locationURL is a URL whose scheme is a fetch scheme,

    then return null.

    We allow redirects to non-fetch scheme URLs, but redirects to fetch scheme URLs that aren't HTTP(S) are treated like network errors.

24. Assert: locationURL is null and response is not a network error.

25. Let resultPolicyContainer be the result of determining navigation params policy container given response's URL, entry's document state's history policy container, sourceSnapshotParams's source policy container, null, and responsePolicyContainer.

26. If navigable's container is an iframe, and response's timing allow passed flag is set, then set navigable's container's pending resource-timing start time to null.

    If the iframe is allowed to report to resource timing, we don't need to run its fallback steps as the normal reporting would happen.

27. Return a new navigation params, with

    id

    navigationId

    navigable

    navigable

    request

    request

    response

    response

    fetch controller

    fetchController

    commit early hints

    commitEarlyHints

    opener policy

    responseCOOP

    reserved environment

    request's reserved client

    origin

    responseOrigin

    policy container

    resultPolicyContainer

    final sandboxing flag set

    finalSandboxFlags

    COOP enforcement result

    coopEnforcementResult

    navigation timing type

    navTimingType

    about base URL

    entry's document state's about base URL

    user involvement

    userInvolvement

An element has a browsing context scope origin if its Document's node navigable is a top-level traversable or if all of its Document's ancestor navigables have active documents whose origins are the same origin as the element's node document's origin. If an element has a browsing context scope origin, then its value is the origin of the element's node document.

To load a document given navigation params navigationParams, source snapshot params sourceSnapshotParams, and origin initiatorOrigin, perform the following steps. They return a Document or null.

1. Let type be the computed type of navigationParams's response.

2. If the user agent has been configured to process resources of the given type using some mechanism other than rendering the content in a navigable, then skip this step. Otherwise, if the type is one of the following types:

   an HTML MIME type

   Return the result of loading an HTML document, given navigationParams.

   an XML MIME type that is not an explicitly supported XML MIME type

   Return the result of loading an XML document given navigationParams and type.

   a JavaScript MIME type

   a JSON MIME type that is not an explicitly supported JSON MIME type

   "text/css"

   "text/plain"

   "text/vtt"

   Return the result of loading a text document given navigationParams and type.

   "multipart/x-mixed-replace"

   Return the result of loading a multipart/x-mixed-replace document, given navigationParams, sourceSnapshotParams, and initiatorOrigin.

   a supported image, video, or audio type

   Return the result of loading a media document given navigationParams and type.

   "application/pdf"

   "text/pdf"

   If the user agent's PDF viewer supported is true, return the result of creating a document for inline content that doesn't have a DOM given navigationParams's navigable, navigationParams's id, navigationParams's navigation timing type, and navigationParams's user involvement.

   Otherwise, proceed onward.

   An explicitly supported XML MIME type is an XML MIME type for which the user agent is configured to use an external application to render the content, or for which the user agent has dedicated processing rules. For example, a web browser with a built-in Atom feed viewer would be said to explicitly support the application/atom+xml MIME type.

   An explicitly supported JSON MIME type is a JSON MIME type for which the user agent is configured to use an external application to render the content, or for which the user agent has dedicated processing rules.

   In both cases, the external application or user agent will either display the content inline directly in navigationParams's navigable, or hand it off to external software. Both happen in the steps below.

3. If, given type, the new resource is to be handled by displaying some sort of inline content, e.g., a native rendering of the content or an error message because the specified type is not supported, then return the result of creating a document for inline content that doesn't have a DOM given navigationParams's navigable, navigationParams's id, navigationParams's navigation timing type, and navigationParams's user involvement.

4. Otherwise, the document's type is such that the resource will not affect navigationParams's navigable, e.g., because the resource is to be handed to an external application or because it is an unknown type that will be processed by handle as a download. Hand-off to external software given navigationParams's response, navigationParams's navigable, navigationParams's final sandboxing flag set, sourceSnapshotParams's has transient activation, and initiatorOrigin.

5. Return null.

To update for navigable creation/destruction given a traversable navigable traversable:

1. Let step be traversable's current session history step.

2. Return the result of applying the history step step to traversable given false, null, null, "none", and null.

To apply the push/replace history step given a non-negative integer step to a traversable navigable traversable, given a history handling behavior historyHandling and a user navigation involvement userInvolvement:

1. Return the result of applying the history step step to traversable given false, null, null, userInvolvement, and historyHandling.

To apply the reload history step to a traversable navigable traversable given user navigation involvement userInvolvement:

1. Let step be traversable's current session history step.

2. Return the result of applying the history step step to traversable given true, null, null, userInvolvement, and "reload".

To apply the traverse history step given a non-negative integer step to a traversable navigable traversable, with source snapshot params sourceSnapshotParams, navigable initiatorToCheck, and user navigation involvement userInvolvement:

1. Return the result of applying the history step step to traversable given true, sourceSnapshotParams, initiatorToCheck, userInvolvement, and "traverse".

To resume applying the traverse history step given a non-negative integer step, a traversable navigable traversable, and user navigation involvement userInvolvement, apply step to traversable given false, null, null, userInvolvement, and "traverse".

To apply the history step given a non-negative integer step to a traversable navigable traversable, with boolean checkForCancelation, source snapshot params-or-null sourceSnapshotParams, navigable-or-null initiatorToCheck, user navigation involvement userInvolvement, and NavigationType-or-null navigationType, perform the following steps. They return "initiator-disallowed", "canceled-by-beforeunload", "canceled-by-navigate", or "applied".

1. Assert: This is running within traversable's session history traversal queue.

2. Let targetStep be the result of getting the used step given traversable and step.

3. If initiatorToCheck is not null:

   1. Assert: sourceSnapshotParams is not null.

   2. For each navigable of get all navigables whose current session history entry will change or reload: if initiatorToCheck is not allowed by sandboxing to navigate navigable given sourceSnapshotParams, then return "initiator-disallowed".

4. Let navigablesCrossingDocuments be the result of getting all navigables that might experience a cross-document traversal given traversable and targetStep.

5. If checkForCancelation is true, and the result of checking if unloading is canceled given navigablesCrossingDocuments, traversable, targetStep, and userInvolvement is not "continue", then return that result.

6. Let changingNavigables be the result of get all navigables whose current session history entry will change or reload given traversable and targetStep.

7. Let nonchangingNavigablesThatStillNeedUpdates be the result of getting all navigables that only need history object length/index update given traversable and targetStep.

8. For each navigable of changingNavigables:

   1. Let targetEntry be the result of getting the target history entry given navigable and targetStep.

   2. Set navigable's current session history entry to targetEntry.

   3. If targetEntry's document is not navigable's active document, then queue a global task on the navigation and traversal task source of navigable's active window to run these steps:

      1. Let navigation be navigable's active window's navigation API.

      2. Set navigation's ongoing navigate event to null.

      3. Set navigation's ongoing API method tracker to null.

      This prevents the navigateerror event and the corresponding signal from firing as a result of a successful cross-document navigation.

   4. Set navigable's ongoing navigation to "traversal".

9. Let totalChangeJobs be the size of changingNavigables.

10. Let completedChangeJobs be 0.

11. Let changingNavigableContinuations be an empty queue of changing navigable continuation states.

    This queue is used to split the operations on changingNavigables into two parts. Specifically, changingNavigableContinuations holds data for the second part.

12. For each navigable of changingNavigables, queue a global task on the navigation and traversal task source of navigable's active window to run the steps:

    This set of steps are split into two parts to allow synchronous navigations to be processed before documents unload. State is stored in changingNavigableContinuations for the second part.

    1. Let displayedEntry be navigable's active session history entry.

    2. Let targetEntry be navigable's current session history entry.

    3. Let changingNavigableContinuation be a changing navigable continuation state with:

       displayed document

       displayedEntry's document

       target entry

       targetEntry

       navigable

       navigable

       update-only

       false

    4. If displayedEntry is targetEntry and targetEntry's document state's reload pending is false:

       1. Set changingNavigableContinuation's update-only to true.

       2. Enqueue changingNavigableContinuation on changingNavigableContinuations.

       3. Abort these steps.

       This case occurs due to a synchronous navigation which already updated the active session history entry.

    5. Switch on navigationType:

       "reload"

       Assert: targetEntry's document state's reload pending is true.

       "traverse"

       Assert: targetEntry's document state's ever populated is true.

       "replace"

       Assert: targetEntry's step is displayedEntry's step and targetEntry's document state's ever populated is false.

       "push"

       Assert: targetEntry's step is displayedEntry's step + 1 and targetEntry's document state's ever populated is false.

    6. Let oldOrigin be targetEntry's document state's origin.

    7. If all of the following are true:

       • navigationType is "traverse";

       • navigable is not traversable;

       • targetEntry is not displayedEntry; and

       • oldOrigin is the same as displayedEntry's document state's origin,

       then:

       1. Let navigation be navigable's active window's navigation API.

       2. Fire a traverse navigate event at navigation given targetEntry and userInvolvement.

    8. If targetEntry's document is null, or targetEntry's document state's reload pending is true:

       1. Let navTimingType be "back_forward" if targetEntry's document is null; otherwise "reload".

       2. Let targetSnapshotParams be the result of snapshotting target snapshot params given navigable.

       3. Let potentiallyTargetSpecificSourceSnapshotParams be sourceSnapshotParams.

       4. If potentiallyTargetSpecificSourceSnapshotParams is null, then set it to the result of snapshotting source snapshot params given navigable's active document.

          In this case there is no clear source of the traversal/reload. We treat this situation as if navigable navigated itself, but note that some properties of targetEntry's original initiator are preserved in targetEntry's document state, such as the initiator origin and referrer, which will appropriately influence the navigation.

       5. Set targetEntry's document state's reload pending to false.

       6. Let allowPOST be targetEntry's document state's reload pending.

       7. In parallel, attempt to populate the history entry's document for targetEntry, given navigable, potentiallyTargetSpecificSourceSnapshotParams, targetSnapshotParams, userInvolvement, with allowPOST set to allowPOST and completionSteps set to queue a global task on the navigation and traversal task source given navigable's active window to run afterDocumentPopulated.

       Otherwise, run afterDocumentPopulated immediately.

       In both cases, let afterDocumentPopulated be the following steps:

       1. If targetEntry's document is null, then set changingNavigableContinuation's update-only to true.

          This means we tried to populate the document, but were unable to do so, e.g. because of the server returning a 204.

          These kinds of failed navigations or traversals will not be signaled to the navigation API (e.g., through the promises of any navigation API method tracker, or the navigateerror event). Doing so would leak information about the timing of responses from other origins, in the cross-origin case, and providing different results in the cross-origin vs. same-origin cases was deemed too confusing.

          However, implementations could use this opportunity to clear any promise handlers for the navigation.transition.finished promise, as they are guaranteed at this point to never run. And, they might wish to report a warning to the console if any part of the navigation API initiated these navigations, to make it clear to the web developer why their promises will never settle and events will never fire.

       2. If targetEntry's document's origin is not same origin with oldOrigin, then set targetEntry's classic history API state to StructuredSerializeForStorage(null).

          This clears history state when the origin changed vs a previous load of targetEntry without a redirect occurring. This can happen due to a change in CSP sandbox headers.

       3. If all of the following are true:

          • navigable's parent is null;

          • targetEntry's document's browsing context is not an auxiliary browsing context whose opener browsing context is non-null; and

          • targetEntry's document's origin is not same origin with oldOrigin,

          then set targetEntry's document state's navigable target name to the empty string.

       4. Enqueue changingNavigableContinuation on changingNavigableContinuations.

          The rest of this job runs later in this algorithm.

13. Let navigablesThatMustWaitBeforeHandlingSyncNavigation be an empty set.

14. While completedChangeJobs does not equal totalChangeJobs:

    1. If traversable's running nested apply history step is false:

       1. While traversable's session history traversal queue's algorithm set contains one or more synchronous navigation steps with a target navigable not contained in navigablesThatMustWaitBeforeHandlingSyncNavigation:

          1. Let steps be the first item in traversable's session history traversal queue's algorithm set that is synchronous navigation steps with a target navigable not contained in navigablesThatMustWaitBeforeHandlingSyncNavigation.

          2. Remove steps from traversable's session history traversal queue's algorithm set.

          3. Set traversable's running nested apply history step to true.

          4. Run steps.

          5. Set traversable's running nested apply history step to false.

          Synchronous navigations that are intended to take place before this traversal jump the queue at this point, so they can be added to the correct place in traversable's session history entries before this traversal potentially unloads their document. More details can be found here.

    2. Let changingNavigableContinuation be the result of dequeuing from changingNavigableContinuations.

    3. If changingNavigableContinuation is nothing, then continue.

    4. Let displayedDocument be changingNavigableContinuation's displayed document.

    5. Let targetEntry be changingNavigableContinuation's target entry.

    6. Let navigable be changingNavigableContinuation's navigable.

    7. Let (scriptHistoryLength, scriptHistoryIndex) be the result of getting the history object length and index given traversable and targetStep.

       These values might have changed since they were last calculated.

    8. Append navigable to navigablesThatMustWaitBeforeHandlingSyncNavigation.

       Once a navigable has reached this point in traversal, additionally queued synchronous navigation steps are likely to be intended to occur after this traversal rather than before it, so they no longer jump the queue. More details can be found here.

    9. Let entriesForNavigationAPI be the result of getting session history entries for the navigation API given navigable and targetStep.

    10. If changingNavigableContinuation's update-only is true, or targetEntry's document is displayedDocument:

        This is a same-document navigation: we proceed without unloading.

        1. Set navigable's ongoing navigation to null.

           This allows new navigations of navigable to start, whereas during the traversal they were blocked.

        2. Queue a global task on the navigation and traversal task source given navigable's active window to perform afterPotentialUnloads.

    11. Otherwise:

        1. Assert: navigationType is not null.

        2. Deactivate displayedDocument, given userInvolvement, targetEntry, navigationType, and afterPotentialUnloads.

    12. In both cases, let afterPotentialUnloads be the following steps:

        1. Let previousEntry be navigable's active session history entry.

        2. If changingNavigableContinuation's update-only is false, then activate history entry targetEntry for navigable.

        3. Let updateDocument be an algorithm step which performs update document for history step application given targetEntry's document, targetEntry, changingNavigableContinuation's update-only, scriptHistoryLength, scriptHistoryIndex, navigationType, entriesForNavigationAPI, and previousEntry.

        4. If targetEntry's document is equal to displayedDocument, then perform updateDocument.

        5. Otherwise, queue a global task on the navigation and traversal task source given targetEntry's document's relevant global object to perform updateDocument.

        6. Increment completedChangeJobs.

15. Let totalNonchangingJobs be the size of nonchangingNavigablesThatStillNeedUpdates.

    This step onwards deliberately waits for all the previous operations to complete, as they include processing synchronous navigations which will also post tasks to update history length and index.

16. Let completedNonchangingJobs be 0.

17. Let (scriptHistoryLength, scriptHistoryIndex) be the result of getting the history object length and index given traversable and targetStep.

18. For each navigable of nonchangingNavigablesThatStillNeedUpdates, queue a global task on the navigation and traversal task source given navigable's active window to run the steps:

    1. Let document be navigable's active document.

    2. Set document's history object's index to scriptHistoryIndex.

    3. Set document's history object's length to scriptHistoryLength.

    4. Increment completedNonchangingJobs.

19. Wait for completedNonchangingJobs to equal totalNonchangingJobs.

20. Set traversable's current session history step to targetStep.

21. Return "applied".

To deactivate a document for a cross-document navigation given a Document displayedDocument, a user navigation involvement userNavigationInvolvement, a session history entry targetEntry, a NavigationType navigationType, and afterPotentialUnloads, which is an algorithm that receives no arguments:

1. Let navigable be displayedDocument's node navigable.

2. Let potentiallyTriggerViewTransition be false.

3. Let isBrowserUINavigation be true if userNavigationInvolvement is "browser UI"; otherwise false.

4. Set potentiallyTriggerViewTransition to the result of calling can navigation trigger a cross-document view-transition? given displayedDocument, targetEntry's document, navigationType, and isBrowserUINavigation.

5. If potentiallyTriggerViewTransition is false:

   1. Let firePageSwapBeforeUnload be the following step:

      1. Fire the pageswap event given displayedDocument, targetEntry, navigationType, and null.

   2. Set navigable's ongoing navigation to null.

      This allows new navigations of navigable to start, whereas during the traversal they were blocked.

   3. Unload a document and its descendants given displayedDocument, targetEntry's document, afterPotentialUnloads, and firePageSwapBeforeUnload.

6. Otherwise, queue a global task on the navigation and traversal task source given navigable's active window to run the steps:

   1. Let proceedWithNavigationAfterViewTransitionCapture be the following step:

      1. Append the following session history traversal steps to navigable's traversable navigable:

         1. Set navigable's ongoing navigation to null.

            This allows new navigations of navigable to start, whereas during the traversal they were blocked.

         2. Unload a document and its descendants given displayedDocument, targetEntry's document, and afterPotentialUnloads.

   2. Let viewTransition be the result of setting up a cross-document view-transition given displayedDocument, targetEntry's document, and proceedWithNavigationAfterViewTransitionCapture.

   3. Fire the pageswap event given displayedDocument, targetEntry, navigationType, and viewTransition.

   4. If viewTransition is null, then run proceedWithNavigationAfterViewTransitionCapture.

      In the case where a view transition started, the view transitions algorithms are responsible for calling proceedWithNavigationAfterViewTransitionCapture.

To fire the pageswap event given a Document displayedDocument, a session history entry targetEntry, a NavigationType navigationType, and a ViewTransition-or-null viewTransition:

1. Assert: this is running as part of a task queued on displayedDocument's relevant agent's event loop.

2. Let navigation be displayedDocument's relevant global object's navigation API.

3. Let activation be null.

4. If all of the following are true:

   • targetEntry's document's origin is same origin with displayedDocument's origin; and

   • targetEntry's document's was created via cross-origin redirects is false, or targetEntry's document's latest entry is not null,

   then:

   1. Let destinationEntry be determined by switching on navigationType:

      "reload"

      The current entry of navigation

      "traverse"

      The NavigationHistoryEntry in navigation's entry list whose session history entry is targetEntry

      "push"

      "replace"

      A new NavigationHistoryEntry in displayedDocument's relevant realm with its session history entry set to targetEntry

   2. Set activation to a new NavigationActivation created in displayedDocument's relevant realm, with

      old entry

      the current entry of navigation

      new entry

      destinationEntry

      navigation type

      navigationType

   This means that a cross-origin redirect during a navigation would result in a null activation in the old document's PageSwapEvent, unless the new document is being restored from bfcache.

5. Fire an event named pageswap at displayedDocument's relevant global object, using PageSwapEvent with its activation set to activation, and its viewTransition set to viewTransition.

To activate history entry session history entry entry for navigable navigable:

1. Save persisted state to the navigable's active session history entry.

2. Let newDocument be entry's document.

3. Assert: newDocument's is initial about:blank is false, i.e., we never traverse back to the initial about:blank Document because it always gets replaced when we navigate away from it.

4. Set navigable's active session history entry to entry.

5. Make active newDocument.

6. Set the initial visibility state of newDocument to navigable's traversable navigable's system visibility state.

To get the used step given a traversable navigable traversable, and a non-negative integer step, perform the following steps. They return a non-negative integer.

1. Let steps be the result of getting all used history steps within traversable.

2. Return the greatest item in steps that is less than or equal to step.

   This caters for situations where there's no session history entry with step step, due to the removal of a navigable.

To get the history object length and index given a traversable navigable traversable, and a non-negative integer step, perform the following steps. They return a tuple of two non-negative integers.

1. Let steps be the result of getting all used history steps within traversable.

2. Let scriptHistoryLength be the size of steps.

3. Assert: steps contains step.

   It is assumed that step has been adjusted by getting the used step.

4. Let scriptHistoryIndex be the index of step in steps.

5. Return (scriptHistoryLength, scriptHistoryIndex).

To get all navigables whose current session history entry will change or reload given a traversable navigable traversable, and a non-negative integer targetStep, perform the following steps. They return a list of navigables.

1. Let results be an empty list.

2. Let navigablesToCheck be « traversable ».

   This list is extended in the loop below.

3. For each navigable of navigablesToCheck:

   1. Let targetEntry be the result of getting the target history entry given navigable and targetStep.

   2. If targetEntry is not navigable's current session history entry or targetEntry's document state's reload pending is true, then append navigable to results.

   3. If targetEntry's document is navigable's active document, and targetEntry's document state's reload pending is false, then extend navigablesToCheck with the child navigables of navigable.

      Adding child navigables to navigablesToCheck means those navigables will also be checked by this loop. Child navigables are only checked if the navigable's active document will not change as part of this traversal.

4. Return results.

To get all navigables that only need history object length/index update given a traversable navigable traversable, and a non-negative integer targetStep, perform the following steps. They return a list of navigables.

Other navigables might not be impacted by the traversal. For example, if the response is a 204, the currently active document will remain. Additionally, going 'back' after a 204 will change the current session history entry, but the active session history entry will already be correct.

1. Let results be an empty list.

2. Let navigablesToCheck be « traversable ».

   This list is extended in the loop below.

3. For each navigable of navigablesToCheck:

   1. Let targetEntry be the result of getting the target history entry given navigable and targetStep.

   2. If targetEntry is navigable's current session history entry and targetEntry's document state's reload pending is false:

      1. Append navigable to results.

      2. Extend navigablesToCheck with navigable's child navigables.

         Adding child navigables to navigablesToCheck means those navigables will also be checked by this loop. child navigables are only checked if the navigable's active document will not change as part of this traversal.

4. Return results.

To get the target history entry given a navigable navigable, and a non-negative integer step, perform the following steps. They return a session history entry.

1. Let entries be the result of getting session history entries for navigable.

2. Return the item in entries that has the greatest step less than or equal to step.

To see why getting the target history entry returns the entry with the greatest step less than or equal to the input step, consider the following Jake diagram:

For the input step 1, the target history entry for the top navigable is the /t entry, whose step is 0, while the target history entry for the frames[0] navigable is the /i-0-b entry, whose step is 1:

Similarly, given the input step 3 we get the top entry whose step is 3, and the frames[0] entry whose step is 1:

To get all navigables that might experience a cross-document traversal given a traversable navigable traversable, and a non-negative integer targetStep, perform the following steps. They return a list of navigables.

1. Let results be an empty list.

2. Let navigablesToCheck be « traversable ».

   This list is extended in the loop below.

3. For each navigable of navigablesToCheck:

   1. Let targetEntry be the result of getting the target history entry given navigable and targetStep.

   2. If targetEntry's document is not navigable's active document or targetEntry's document state's reload pending is true, then append navigable to results.

      Although navigable's active history entry can change synchronously, the new entry will always have the same Document, so accessing navigable's active document is reliable.

   3. Otherwise, extend navigablesToCheck with navigable's child navigables.

      Adding child navigables to navigablesToCheck means those navigables will also be checked by this loop. Child navigables are only checked if the navigable's active document will not change as part of this traversal.

4. Return results.

To update document for history step application given a Document document, a session history entry entry, a boolean doNotReactivate, integers scriptHistoryLength and scriptHistoryIndex, NavigationType-or-null navigationType, an optional list of session history entries entriesForNavigationAPI, and an optional session history entry previousEntryForActivation:

1. Let documentIsNew be true if document's latest entry is null; otherwise false.

2. Let documentsEntryChanged be true if document's latest entry is not entry; otherwise false.

3. Set document's history object's index to scriptHistoryIndex.

4. Set document's history object's length to scriptHistoryLength.

5. Let navigation be history's relevant global object's navigation API.

6. If documentsEntryChanged is true:

   1. Let oldURL be document's latest entry's URL.

   2. Set document's latest entry to entry.

   3. Restore the history object state given document and entry.

   4. If documentIsNew is false:

      1. Assert: navigationType is not null.

      2. Update the navigation API entries for a same-document navigation given navigation, entry, and navigationType.

      3. Fire an event named popstate at document's relevant global object, using PopStateEvent, with the state attribute initialized to document's history object's state and hasUAVisualTransition initialized to true if a visual transition, to display a cached rendered state of the latest entry, was done by the user agent.

      4. Restore persisted state given entry.

      5. If oldURL's fragment is not equal to entry's URL's fragment, then queue a global task on the DOM manipulation task source given document's relevant global object to fire an event named hashchange at document's relevant global object, using HashChangeEvent, with the oldURL attribute initialized to the serialization of oldURL and the newURL attribute initialized to the serialization of entry's URL.

   5. Otherwise:

      1. Assert: entriesForNavigationAPI is given.

      2. Restore persisted state given entry.

      3. Initialize the navigation API entries for a new document given navigation, entriesForNavigationAPI, and entry.

7. If all the following are true:

   • previousEntryForActivation is given;

   • navigationType is non-null; and

   • navigationType is "reload" or previousEntryForActivation's document is not document,

   then:

   1. If navigation's activation is null, then set navigation's activation to a new NavigationActivation object in navigation's relevant realm.

   2. Let previousEntryIndex be the result of getting the navigation API entry index of previousEntryForActivation within navigation.

   3. If previousEntryIndex is non-negative, then set activation's old entry to navigation's entry list[previousEntryIndex].

   4. Otherwise, if all the following are true:

      • navigationType is "replace";

      • previousEntryForActivation's document state's origin is same origin with document's origin; and

      • previousEntryForActivation's document's is initial about:blank is false,

      then set activation's old entry to a new NavigationHistoryEntry in navigation's relevant realm, whose session history entry is previousEntryForActivation.

   5. Set activation's new entry to navigation's current entry.

   6. Set activation's navigation type to navigationType.

8. If documentIsNew is true:

   1. Assert: document's during-loading navigation ID for WebDriver BiDi is not null.

   2. Invoke WebDriver BiDi navigation committed with navigable and a new WebDriver BiDi navigation status whose id is document's during-loading navigation ID for WebDriver BiDi, status is "committed", and url is document's URL.

   3. Try to scroll to the fragment for document.

   4. At this point scripts may run for the newly-created document document.

9. Otherwise, if documentsEntryChanged is false and doNotReactivate is false:

   1. Assert: entriesForNavigationAPI is given.

   2. Reactivate document given entry and entriesForNavigationAPI.

   documentsEntryChanged can be false for one of two reasons: either we are restoring from bfcache, or we are asynchronously finishing up a synchronous navigation which already synchronously set document's latest entry. The doNotReactivate argument distinguishes between these two cases.

To restore the history object state given Document document and session history entry entry:

1. Let targetRealm be document's relevant realm.

2. Let state be StructuredDeserialize(entry's classic history API state, targetRealm). If this throws an exception, catch it and let state be null.

3. Set document's history object's state to state.

To make active a Document document:

1. Let window be document's relevant global object.

2. Set document's browsing context's active document to document.

3. Set document's browsing context's WindowProxy's [[Window]] internal slot value to window.

4. Set window's relevant settings object's execution ready flag.

To reactivate a Document document given a session history entry reactivatedEntry and a list of session history entries entriesForNavigationAPI:

This algorithm updates document after it has come out of bfcache, i.e., after it has been made fully active again. Other specifications that want to watch for this change to the fully active state are encouraged to add steps into this algorithm, so that the ordering of events that happen in effect of the change is clear.

1. For each formControl of form controls in document with an autofill field name of "off", invoke the reset algorithm for formControl.

2. If document's suspended timer handles is not empty:

   1. Assert: document's suspension time is not zero.

   2. Let suspendDuration be the current high resolution time minus document's suspension time.

   3. Let activeTimers be document's relevant global object's map of active timers.

   4. For each handle in document's suspended timer handles, if activeTimers[handle] exists, then increase activeTimers[handle] by suspendDuration.

3. Update the navigation API entries for reactivation given document's relevant global object's navigation API, entriesForNavigationAPI, and reactivatedEntry.

4. If document's current document readiness is "complete", and document's page showing is false:

   1. Set document's page showing to true.

   2. Set document's has been revealed to false.

   3. Update the visibility state of document to "visible".

   4. Fire a page transition event named pageshow at document's relevant global object with true.

To try to scroll to the fragment for a Document document, perform the following steps in parallel:

1. Wait for an implementation-defined amount of time. (This is intended to allow the user agent to optimize the user experience in the face of performance concerns.)

2. Queue a global task on the navigation and traversal task source given document's relevant global object to run these steps:

   1. If document has no parser, or its parser has stopped parsing, or the user agent has reason to believe the user is no longer interested in scrolling to the fragment, then abort these steps.

   2. Scroll to the fragment given document.

   3. If document's indicated part is still null, then try to scroll to the fragment for document.

To make document unsalvageable, given a Document document and a string reason:

1. Let details be a new not restored reason details whose reason is reason.

2. Append details to document's bfcache blocking details.

3. Set document's salvageable state to false.

To build not restored reasons for document state given Document document:

1. Let notRestoredReasonsForDocument be a new not restored reasons.

2. Set notRestoredReasonsForDocument's URL to document's URL.

3. Let container be document's node navigable's container.

4. If container is an iframe element:

   1. Let src be the empty string.

   2. If container has a src attribute:

      1. Let src be the result of encoding-parsing-and-serializing a URL given container's src attribute's value, relative to container's node document.

      2. If src is failure, then set src to container's src attribute's value.

   3. Set notRestoredReasonsForDocument's src to src.

   4. Set notRestoredReasonsForDocument's id to container's id attribute's value, or the empty string if it has no such attribute.

   5. Set notRestoredReasonsForDocument's name to container's name attribute's value, or the empty string if it has no such attribute.

5. Set notRestoredReasonsForDocument's reasons to a clone of document's bfcache blocking details.

6. For each navigable of document's document-tree child navigables:

   1. Let childDocument be navigable's active document.

   2. Build not restored reasons for document state given childDocument.

   3. Append childDocument's not restored reasons to notRestoredReasonsForDocument's children.

7. Set document's node navigable's active session history entry's document state's not restored reasons to notRestoredReasonsForDocument.

To build not restored reasons for a top-level traversable and its descendants given top-level traversable topLevelTraversable:

1. Build not restored reasons for document state given topLevelTraversable's active document.

2. Let crossOriginDescendants be an empty list.

3. For each childNavigable of topLevelTraversable's active document's descendant navigables:

   1. If childNavigable's active document's origin is not same origin with topLevelTraversable's active document's origin, then append childNavigable to crossOriginDescendants.

4. Let crossOriginDescendantsPreventsBfcache be false.

5. For each crossOriginNavigable of crossOriginDescendants:

   1. Let reasonsForCrossOriginChild be crossOriginNavigable's active document's document state's not restored reasons.

   2. If reasonsForCrossOriginChild's reasons is not empty, set crossOriginDescendantsPreventsBfcache to true.

   3. Set reasonsForCrossOriginChild's URL to null.

   4. Set reasonsForCrossOriginChild's reasons to null.

   5. Set reasonsForCrossOriginChild's children to null.

6. If crossOriginDescendantsPreventsBfcache is true, make document unsalvageable given topLevelTraversable's active document and "masked".

To reveal a Document document:

1. If document's has been revealed is true, then return.

2. Set document's has been revealed to true.

3. Let transition be the result of resolving inbound cross-document view-transition for document.

4. Fire an event named pagereveal at document's relevant global object, using PageRevealEvent with its viewTransition set to transition.

5. If transition is not null:

   1. Prepare to run script given document's relevant settings object.

   2. Activate transition.

   3. Clean up after running script given document's relevant settings object.

   Activating a view transition might resolve/reject promises, so by wrapping the activation with prepare/cleanup we ensure those promises are handled before the next rendering step.

To scroll to the fragment given a Document document:

1. If document's indicated part is null, then set document's target element to null.

2. Otherwise, if document's indicated part is top of the document:

   1. Set document's target element to null.

   2. Scroll to the beginning of the document for document. [CSSOMVIEW]

   3. Return.

3. Otherwise:

   1. Assert: document's indicated part is an element.

   2. Let target be document's indicated part.

   3. Set document's target element to target.

   4. Run the ancestor revealing algorithm on target.

   5. Scroll target into view, with behavior set to "auto", block set to "start", and inline set to "nearest". [CSSOMVIEW]

   6. Run the focusing steps for target, with the Document's viewport as the fallback target.

   7. Move the sequential focus navigation starting point to target.