WebDriver BiDi

When an algorithm algorithm running in parallel awaits a set of events events, and resume id:

1. Pause the execution of algorithm.

2. Assert: wait queue does not contain resume id.

3. Set wait queue[resume id] to (events, algorithm).

To resume given name, id and parameters:

1. If wait queue does not contain id, return.

2. Let (events, algorithm) be wait queue[id]

3. For each event in events:

   1. If event equals name:

      1. Remove id from wait queue.

      2. Resume running the steps in algorithm from the point at which they were paused, passing name and parameters as the result of the await.

         Should we have something like microtasks to ensure this runs before any other tasks on the event loop?

Command = {
  id: js-uint,
  CommandData,
  Extensible,
}

CommandData = (
  BrowserCommand //
  BrowsingContextCommand //
  EmulationCommand //
  InputCommand //
  NetworkCommand //
  ScriptCommand //
  SessionCommand //
  StorageCommand //
  WebExtensionCommand
)

EmptyParams = {
   Extensible
}

Message = (
  CommandResponse /
  ErrorResponse /
  Event
)

CommandResponse = {
  type: "success",
  id: js-uint,
  result: ResultData,
  Extensible
}

ErrorResponse = {
  type: "error",
  id: js-uint / null,
  error: ErrorCode,
  message: text,
  ? stacktrace: text,
  Extensible
}

ResultData = (
  BrowsingContextResult /
  EmptyResult /
  NetworkResult /
  ScriptResult /
  SessionResult /
  StorageResult /
  WebExtensionResult
)

EmptyResult = {
  Extensible
}

Event = {
  type: "event",
  EventData,
  Extensible
}

EventData = (
  BrowsingContextEvent //
  InputEvent //
  LogEvent //
  NetworkEvent //
  ScriptEvent
)

Extensible = (*text => any)

js-int = -9007199254740991..9007199254740991
js-uint = 0..9007199254740991

The list of active BiDi sessions is given by:

1. Let BiDi sessions be a new list.

2. For each session in active sessions:

   1. If session is a BiDi session append session to BiDi sessions.

3. Return BiDi sessions.

ErrorCode = "invalid argument" /
            "invalid selector" /
            "invalid session id" /
            "invalid web extension" /
            "move target out of bounds" /
            "no such alert" /
            "no such network collector" /
            "no such element" /
            "no such frame" /
            "no such handle" /
            "no such history entry" /
            "no such intercept" /
            "no such network data" /
            "no such node" /
            "no such request" /
            "no such script" /
            "no such storage partition" /
            "no such user context" /
            "no such web extension" /
            "session not created" /
            "unable to capture screen" /
            "unable to close browser" /
            "unable to set cookie" /
            "unable to set file input" /
            "unavailable network data" /
            "underspecified storage partition" /
            "unknown command" /
            "unknown error" /
            "unsupported operation"

The set of sessions for which an event is enabled given event name and navigables is:

1. Let sessions be a new set.

2. For each session in active BiDI sessions:

   1. If event is enabled with session, event name and navigables, append session to sessions.

3. Return sessions.

To determine if an event is enabled given session, event name and navigables:

Note: navigables is a set because a shared worker can be associated with multiple contexts.

1. Let top-level traversables be get top-level traversables with navigables.

2. For each subscription in session’s subscriptions:

   1. If subscription’s event names do not contains event name, continue.

   2. If subscription is global return true.

   3. If user context ids is not empty:

      1. For each navigable in top-level traversables:

         1. If subscription’s user context ids contains navigable’s associated user context’s user context id, return true.

   4. Otherwise:

      1. Let subscription top-level traversables be get navigables by ids with subscription’s top-level traversable ids.

      2. If the intersection of top-level traversables and subscription top-level traversables is not empty return true.

3. Return false.

The set of top-level traversables for which an event is enabled given event name and session is:

1. Let result be a new set.

2. For each subscription in session’s subscriptions:

   1. If subscription’s event names does not contain event name, continue.

   2. If subscription’s is global:

      1. For each traversable in remote end’s top-level traversables:

         1. Append traversable to result.

      2. Break.

   3. Otherwise, if user context ids is not empty:

      1. For each traversable in remote end’s top-level traversables:

         1. Append traversable to result if subscription’s user context ids contains traversable’s associated user context’s user context id.

   4. Otherwise:

      1. Let top-level traversables be get navigables by ids with subscription’s top-level traversable ids.

      2. Append each item of top-level traversables to result.

3. Return result.

To obtain a set of event names given a name:

1. Let events be an empty set.

2. If name contains a U+002E (period):

   1. If name is the event name for an event, append name to events and return success with data events.

   2. Return an error with error code invalid argument

3. Otherwise name is interpreted as representing all the events in a module. If name is not a module name return an error with error code invalid argument.

4. Append the event name for each event in the module with name name to events.

5. Return success with data events.

To construct a WebSocket resource name given a session session:

1. If session is null, return "/session"

2. Return the result of concatenating the string "/session/" with session’s session ID.

To construct a WebSocket URL given a WebSocket listener listener and session session:

1. Let resource name be the result of construct a WebSocket resource name with session.

2. Return a WebSocket URI constructed with host set to listener’s host, port set to listener’s port, path set to resource name, following the wss-URI construct if listener’s secure flag is set and the ws-URL construct otherwise.

To get a session ID for a WebSocket resource given resource name:

1. If resource name doesn’t begin with the byte string "/session/", return null.

2. Let session id be the bytes in resource name following the "/session/" prefix.

3. If session id is not the string representation of a UUID, return null.

4. Return session id.

To start listening for a WebSocket connection given a session session:

1. If there is an existing WebSocket listener in active listeners which the remote end would like to reuse, let listener be that listener. Otherwise let listener be a new WebSocket listener with implementation-defined host, port, secure flag, and an empty list of WebSocket resources.

2. Let resource name be the result of construct a WebSocket resource name with session.

3. Append resource name to the list of WebSocket resources for listener.

4. Append listener to the remote end’s active listeners.

5. Return listener.

To handle an incoming message given a WebSocket connection connection, type type and data data:

1. If type is not text, send an error response given connection, null, and invalid argument, and finally return.

2. Assert: data is a scalar value string, because the WebSocket handling errors in UTF-8-encoded data would already have failed the WebSocket connection otherwise.

   Nothing seems to define what status code is used for UTF-8 errors.

3. If there is a BiDi Session associated with connection connection, let session be that session. Otherwise if connection is in WebSocket connections not associated with a session, let session be null. Otherwise, return.

4. Let parsed be the result of parsing JSON into Infra values given data. If this throws an exception, then send an error response given connection, null, and invalid argument, and finally return.

5. If session is not null and not in active sessions then return.

6. Match parsed against the remote end definition. If this results in a match:

   1. Let matched be the map representing the matched data.

   2. Assert: matched contains "id", "method", and "params".

   3. Let command id be matched["id"].

   4. Let method be matched["method"]

   5. Let command be the command with command name method.

   6. If session is null and command is not a static command, then send an error response given connection, command id, and invalid session id, and return.

   7. Run the following steps in parallel:

      1. Let result be the result of running the remote end steps for command given session and command parameters matched["params"]

      2. If result is an error, then send an error response given connection, command id, and result’s error code, and finally return.

      3. Let value be result’s data.

      4. Assert: value matches the definition for the result type corresponding to the command with command name method.

      5. If method is "session.new", let session be the entry in the list of active sessions whose session ID is equal to the "sessionId" property of value, append connection to session’s session WebSocket connections, and remove connection from the WebSocket connections not associated with a session.

      6. Let response be a new map matching the CommandResponse production in the local end definition with the id field set to command id and the value field set to value.

      7. Let serialized be the result of serialize an infra value to JSON bytes given response.

      8. Send a WebSocket message comprised of serialized over connection.

7. Otherwise:

   1. Let command id be null.

   2. If parsed is a map and parsed["id"] exists and is an integer greater than or equal to zero, set command id to that integer.

   3. Let error code be invalid argument.

   4. If parsed is a map and parsed["method"] exists and is a string, but parsed["method"] is not in the set of all command names, set error code to unknown command.

   5. Send an error response given connection, command id, and error code.

To get related navigables given an settings object settings:

1. Let related navigables be an empty set.

2. If settings’ relevant global object is a Window:

   1. Let navigable be relevant global object’s associated Document’s node navigable.

   2. If navigable is not null, append navigable to related navigables.

3. Otherwise if the global object specified by settings is a WorkerGlobalScope, for each owner in the global object’s owner set:

   1. Let navigable be null.

   2. If owner is a Document, set navigable to owner’s node navigable.

   3. If navigable is not null, append navigable to related navigables.

4. Return related navigables.

To get navigables by ids given a list of context ids navigable ids:

1. Let result be an empty set.

2. For each navigable id in navigable ids:

   1. Let navigable be the navigable with id navigable id if such navigable exists, and null otherwise.

   2. Append navigable to result if navigable is not null.

3. Return result.

To get top-level traversables given a list of navigables navigables:

1. Let result be an empty set.

2. For each navigable in navigables:

   1. Append navigable’s top-level traversable to result.

3. Return result.

To get valid navigables by ids given a list of context ids navigable ids:

1. Let result be an empty set.

2. For each navigable id in navigable ids:

   1. Let navigable be the result of trying to get a navigable with navigable id.

   2. Append navigable to result.

3. Return success with data result.

To get valid top-level traversables by ids given a list of context ids navigable ids:

1. Let result be an empty set.

2. For each navigable id in navigable ids:

   1. Let navigable be the result of trying to get a navigable with navigable id.

   2. If navigable is not a top-level traversable, return error with error code invalid argument.

   3. Append navigable to result.

3. Return success with data result.

To emit an event given session, and body:

1. Assert: body matches the Event production.

2. Let serialized be the result of serialize an infra value to JSON bytes given body.

3. For each connection in session’s session WebSocket connections:

   1. Send a WebSocket message comprised of serialized over connection.

To send an error response given a WebSocket connection connection, command id, and error code:

1. Let error data be a new map matching the ErrorResponse production in the local end definition, with the id field set to command id, the error field set to error code, the message field set to an implementation-defined string containing a human-readable definition of the error that occurred and the stacktrace field optionally set to an implementation-defined string containing a stack trace report of the active stack frames at the time when the error occurred.

2. Let response be the result of serialize an infra value to JSON bytes given error data.

   Note: command id can be null, in which case the id field will also be set to null, not omitted from response.

3. Send a WebSocket message comprised of response over connection.

To handle a connection closing given a WebSocket connection connection:

1. If there is a BiDi session associated with connection connection:

   1. Let session be the BiDi session associated with connection connection.

   2. Remove connection from session’s session WebSocket connections.

2. Otherwise, if WebSocket connections not associated with a session contains connection, remove connection from that set.

Note: This does not end any session.

Need to hook in to the session ending to allow the UA to close the listener if it wants.

To close the WebSocket connections given session:

1. For each connection in session’s session WebSocket connections:

   1. Start the WebSocket closing handshake with connection.

      Note: this will result in the steps in handle a connection closing being run for connection, which will clean up resources associated with connection.

The WebDriver new session algorithm defined by this specification, with parameters session, capabilities, and flags is:

1. If flags contains "bidi", return.

2. Let webSocketUrl be the result of getting a property named "webSocketUrl" from capabilities.

3. If webSocketUrl is undefined, return.

4. Assert: webSocketUrl is true.

5. Let listener be the result of start listening for a WebSocket connection given session.

6. Set webSocketUrl to the result of construct a WebSocket URL with listener and session.

7. Set a property on capabilities named "webSocketUrl" to webSocketUrl.

8. Set session’s BiDi flag to true.

9. Append "bidi" to flags.

Implementations should also allow clients to establish a BiDi Session which is not a HTTP Session. In this case the URL to the WebSocket server is communicated out-of-band. An implementation that allows this supports BiDi-only sessions. At the time such an implementation is ready to accept requests to start a WebDriver session, it must:

1. Start listening for a WebSocket connection given null.

To get or create a sandbox realm given name and navigable:

1. If name is an empty string, then return error with error code invalid argument.

2. Let window be navigable’s active window.

3. If sandbox map does not contain window, set sandbox map[window] to a new map.

4. Let sandboxes be sandbox map[window].

5. If sandboxes does not contain name, set sandboxes[name] to create a sandbox realm with navigable.

6. Return success with data sandboxes[name].

To create a sandbox realm with window:

Define creation of sandbox realm. This is going to return a SandboxWindowProxy wrapping window.

To get a sandbox name given target realm:

1. Let realms maps be get the values of sandbox map.

2. For each realms map in realms maps:

   1. For each name → realm in realms map:

      1. If realm is target realm, return name.

3. Return null.

To get unwrapped object:

1. While object is SandboxProxy or SandboxWindowProxy, set object to it’s wrapped object.

2. Return object.

To remove user context subscriptions:

1. For each session in active sessions:

   1. Let subscriptions to remove be a set.

   2. For each subscription in session’s subscriptions:

      1. If subscription’s user context ids contains navigable’s associated user context’s user context id;

         1. Remove navigable’s associated user context’s user context id from subscription’s user context ids.

         2. If subscription’s user context ids is empty:

            1. Append subscription to subscriptions to remove.

   3. Remove subscriptions to remove from session’s subscriptions.

To get user context given user context id:

1. For each user context in the set of user contexts:

2. If user context’s user context id equals user context id:

   1. Return user context.

3. Return null.

To get valid user contexts given user context ids:

1. Let result be an empty set.

2. For each user context id of user context ids:

   1. Set user context to get user context with user context id.

   2. If user context is null, return error with error code no such user context.

   3. Append user context to result.

3. Return result.

SessionCommand = (
  session.End //
  session.New //
  session.Status //
  session.Subscribe //
  session.Unsubscribe
)

SessionResult = (
   session.NewResult /
   session.StatusResult /
   session.SubscribeResult
)

To end the session given session:

1. Remove session from active sessions.

2. If active sessions is empty, set the webdriver-active flag to false.

To cleanup the session given session:

1. Close the WebSocket connections with session.

2. For each user context in the set of user contexts:

   1. Remove session’s user context to accept insecure certificates override map[user context].

   2. Remove session’s user context to proxy configuration map[user context].

3. For each request id → (request, phase, response) in session’s blocked request map:

   1. Resume with "continue request", request id and (response, "incomplete").

4. For each collector in session’s network collectors:

   1. Let collector id be collector’s collector.

   2. For each collected data in collected network data, remove collector from data with collected data and collector id.

5. If active sessions is empty, cleanup remote end state.

6. Perform any implementation-specific cleanup steps.

To cleanup remote end state.

1. Clear the before request sent map.

2. Set the default cache behavior to "default".

3. Clear the navigable cache behavior map.

4. Perform implementation-defined steps to enable any implementation-specific resource caches that are usually enabled in the current remote end configuration.

session.CapabilitiesRequest = {
  ? alwaysMatch: session.CapabilityRequest,
  ? firstMatch: [*session.CapabilityRequest]
}

session.CapabilityRequest = {
  ? acceptInsecureCerts: bool,
  ? browserName: text,
  ? browserVersion: text,
  ? platformName: text,
  ? proxy: session.ProxyConfiguration,
  ? unhandledPromptBehavior: session.UserPromptHandler,
  Extensible
}

The additional capability deserialization algorithm for the "webSocketUrl" capability, with parameter value is:

1. If value is not a boolean, return error with code invalid argument.

2. Return success with data value.

The matched capability serialization algorithm for the "webSocketUrl" capability, with parameter value is:

1. If value is false, return success with data null.

2. Return success with data true.

session.ProxyConfiguration = {
   session.AutodetectProxyConfiguration //
   session.DirectProxyConfiguration //
   session.ManualProxyConfiguration //
   session.PacProxyConfiguration //
   session.SystemProxyConfiguration
}

session.AutodetectProxyConfiguration = (
   proxyType: "autodetect",
   Extensible
)

session.DirectProxyConfiguration = (
   proxyType: "direct",
   Extensible
)

session.ManualProxyConfiguration = (
   proxyType: "manual",
   ? httpProxy: text,
   ? sslProxy: text,
   ? session.SocksProxyConfiguration,
   ? noProxy: [*text],
   Extensible
)

session.SocksProxyConfiguration = (
   socksProxy: text,
   socksVersion: 0..255,
)

session.PacProxyConfiguration = (
   proxyType: "pac",
   proxyAutoconfigUrl: text,
   Extensible
)

session.SystemProxyConfiguration = (
   proxyType: "system",
   Extensible
)

session.UserPromptHandler = {
  ? alert: session.UserPromptHandlerType,
  ? beforeUnload: session.UserPromptHandlerType,
  ? confirm: session.UserPromptHandlerType,
  ? default: session.UserPromptHandlerType,
  ? file: session.UserPromptHandlerType,
  ? prompt: session.UserPromptHandlerType,
}

session.UserPromptHandlerType = "accept" / "dismiss" / "ignore";

session.Subscription = text

session.SubscriptionRequest = {
  events: [+text],
  ? contexts: [+browsingContext.BrowsingContext],
  ? userContexts: [+browser.UserContext],
}

session.UnsubscribeByIDRequest = {
  subscriptions: [+session.Subscription],
}

session.UnsubscribeByAttributesRequest = {
  events: [+text],
  ? contexts: [+browsingContext.BrowsingContext],
}

The remote end steps given session, and command parameters are:

1. Let body be a new map with the following properties:

   "ready"

   The remote end’s readiness state.

   "message"

   An implementation-defined string explaining the remote end’s readiness state.

2. Return success with data body

The remote end steps given session and command parameters are:

1. If session is not null, return an error with error code session not created.

2. If the implementation is unable to start a new session for any reason, return an error with error code session not created.

3. Let flags be a set containing "bidi".

4. Let capabilities json be the result of trying to process capabilities with command parameters and flags.

5. Let capabilities be convert a JSON-derived JavaScript value to an Infra value with capabilities json.

6. Let session be the result of trying to create a session with capabilities and flags.

7. Set session’s BiDi flag to true.

   Note: the connection for this session will be set to the current connection by the caller.

8. Let body be a new map matching the session.NewResult production, with the sessionId field set to session’s session ID, and the capabilities field set to capabilities.

9. Return success with data body.

The remote end steps given session and command parameters are:

1. End the session with session.

2. Return success with data null, and in parallel run the following steps:

   1. Wait until the Send a WebSocket message steps have been called with the response to this command.

      this is rather imprecise language, but hopefully it’s clear that the intent is that we send the response to the command before starting shutdown of the connections.

   2. Cleanup the session with session.

The remote end steps with session and command parameters are:

1. Let event names be an empty set.

2. For each entry name in command parameters["events"], let event names be the union of event names and the result of trying to obtain a set of event names with name.

3. Let input user context ids be create a set with command parameters[userContexts].

4. Let input context ids be create a set with command parameters[contexts].

5. If input user context ids is not empty and input context ids is not empty, return error with error code invalid argument.

6. Let subscription navigables be a set.

7. Let top-level traversable context ids be a set.

8. If input context ids is not empty:

   1. Let navigables be the result of trying to get valid navigables by ids with input context ids.

   2. Set subscription navigables be get top-level traversables with navigables.

   3. For each navigable in subscription navigables:

      1. Append navigable’s navigable id to top-level traversable context ids.

9. Otherwise, if input user context ids is not empty:

   1. For each user context id of input user context ids:

      1. Let user context be get user context with user context id.

      2. If user context is null, return error with error code no such user context.

      3. For each top-level traversable in the list of all top-level traversables whose associated user context is user context:

         1. Append top-level traversable to subscription navigables.

10. Otherwise, set subscription navigables to a set of all top-level traversables in the remote end.

11. Let subscription be a subscription with subscription id set to the string representation of a UUID, event names set to event names, top-level traversable ids set to top-level traversable context ids and user context ids set to input user context ids.

12. Let subscribe step events be a new map.

13. For each event name in the event names:

    1. If the event with event name event name does not define remote end subscribe steps, continue;

    2. Let existing navigables be a set of top-level traversables for which an event is enabled with session and event name.

    3. Set subscribe step events[event name] to difference of subscription navigables and existing navigables.

14. Append subscription to session’s subscriptions.

15. Append subscription’s subscription id to session’s known subscription ids.

16. Sort in ascending order subscribe step events using the following less than algorithm given two entries with keys event name one and event name two:

    1. Let event one be the event with name event name one

    2. Let event two be the event with name event name two

    3. Return true if event one’s subscribe priority is less than event two’s subscribe priority, or false otherwise.

17. If subscription is global, let include global be true, otherwise let include global be false.

18. For each event name → navigables in subscribe step events:

    1. Run the remote end subscribe steps for the event with event name event name given session, navigables and include global.

19. Let body be a new map matching the session.SubscribeResult production, with the subscription field set to subscription’s subscription id.

20. Return success with data body.

The remote end steps with session and command parameters are:

1. If command parameters does not contain "subscriptions":

   Note: The condition implies that command parameters is matching the session.UnsubscribeByAttributesRequest production.

   1. Let event names be an empty set.

   2. For each entry name in command parameters["events"], let event names be the union of event names and the result of trying to obtain a set of event names with name.

   3. Let top-level traversable context ids be a set.

   4. Let input context ids be create a set with command parameters[contexts].

   5. If input context ids is not empty:

      1. Let navigables be the result of trying to get valid navigables by ids with input context ids.

      2. Set top-level traversables be get top-level traversables with navigables.

      3. For each navigable in top-level traversables:

         1. Append navigable’s navigable id to top-level traversable context ids.

   6. Let new subscriptions to be a list.

   7. Let matched events to be a set.

   8. Let matched contexts to be a set.

   9. For each subscription of session’s subscriptions:

      1. If intersection of subscription’s event names and event names is an empty set:

         1. append subscription to new subscriptions.

         2. Continue.

      2. If top-level traversable context ids is an empty set:

         1. If subscription is not global:

            1. append subscription to new subscriptions.

            2. Continue.

         2. Let subscription event names be clone of subscription’s event names.

         3. For each event name of event names:

            1. If subscription event names contains event name:

               1. Append event name to matched events.

               2. Remove event name from subscription event names.

         4. If subscription event names is not empty:

            1. Let cloned subscription be a subscription with subscription id set to subscription’s subscription id, event names set to a new set containing subscription event names.

            2. append cloned subscription to new subscriptions.

      3. Otherwise:

         1. If subscription is global:

            1. append subscription to new subscriptions.

         2. Otherwise, if subscription’s user context ids is not empty, continue.

         3. Otherwise:

            Note: unsubscribe by contexts is deprecated and will be removed in the future versions.

            1. Let event map be an empty map.

            2. For each event name in subscription’s event names:

               1. Set event map[event name] to clone of subscription’s top-level traversable ids.

            3. For each event name in event names:

               1. If event map[event name] does not exist, continue.

               2. For each top-level traversable id of top-level traversable context ids:

                  1. If event map[event name] contains top-level traversable id:

                     1. Append top-level traversable id to matched contexts.

                     2. Append event name to matched events.

                     3. Remove top-level traversable id from event map[event name].

               3. If event map[event name] is an empty set,

                  1. Remove event map[event name].

            4. For each event name → remaining top-level traversable ids in event map:

               1. Let partial subscription be a subscription with subscription id set to subscription’s subscription id, event names set to a new set containing event name, top-level traversable ids set to remaining top-level traversable ids.

               2. append partial subscription to new subscriptions.

   10. If matched events is not equal to event names, return error with error code invalid argument.

   11. If top-level traversable context ids is not empty and matched contexts is not equal to top-level traversable context ids, return error with error code invalid argument.

   12. Set session’s subscriptions to new subscriptions.

2. Otherwise:

   1. Let subscriptions be create a set with command parameters[subscriptions].

   2. Let unknown subscription ids to difference between subscriptions and session’s known subscription ids.

   3. If unknown subscription ids is not empty:

      1. Return error with error code invalid argument.

   4. Let subscriptions to remove be an empty set.

   5. For each subscription in session’s subscriptions:

      1. If subscriptions contains subscription’s subscription id:

         1. Append subscription to subscriptions to remove.

   6. Set session’s known subscription ids to difference between session’s known subscription ids and subscriptions.

   7. Remove each item in subscriptions to remove from session’s subscriptions.

3. Return success with data null.

BrowserCommand = (
  browser.Close //
  browser.CreateUserContext //
  browser.GetClientWindows //
  browser.GetUserContexts //
  browser.RemoveUserContext //
  browser.SetClientWindowState
)

BrowserResult = (
   browser.CreateUserContextResult /
   browser.GetUserContextsResult
)

To get the client window state given window:

1. Let documents be an empty list.

2. Let visible documents be an empty list.

3. For each top-level traversable traversable:

   1. If traversable’s client window is not window then continue.

   2. Let document be traversable’s active document.

   3. Append document to documents.

   4. If document’s visibility state is "visible", Append document to visible documents.

4. For each document in visible documents:

   1. If document’s fullscreen element is not null, return "fullscreen".

5. If visible documents is empty but documents is not empty, or if window is otherwise in an OS-specific minimized state, return "minimized".

   Note: This will usually, but not necessarily, mean that window’s width and height are equal to 0.

6. If window is in an OS-specific maximized state return "maximized".

   Note: This will usually, but not necessarily, mean that window’s width is equal to the width of the web-exposed screen area and window’s height is equal to the height of the web-exposed screen area.

7. Return "normal".

To set the client window state given window and state:

1. Let current state be get the client window state with window.

2. If current state is "fullscreen", "maximized", or "minimized" and is equal to state, return success with data null.

3. In the following list of conditions and associated steps, run the first set of steps for which the associated condition is true:

   "fullscreen"

   If not fullscreen is supported return error with error code unsupported operation.

   "normal"

   If not restore client window is supported for window return error with error code unsupported operation.

   "maximize"

   If not maximize client window is supported for window return error with error code unsupported operation.

   "minimize"

   If not minimize client window is supported for window return error with error code unsupported operation.

4. Let documents be an empty list.

5. For each top-level traversable traversable:

   1. If traversable’s associated client window is not window then continue.

   2. Let document be traversable’s active document.

   3. Append document to documents.

6. If documents is empty return error with error code no such client window.

7. If current state is "fullscreen":

   1. For each document in documents:

      1. Fully exit fullscreen with document.

         Note: This is a no-op for documents in window that are not fullscreen.

8. Switch on the value of state:

   "fullscreen"

   1. For each document in documents:

      1. If document’s visibility state is "visible", fullscreen an element with document’s document element.

      2. Break.

   "normal"

   1. Restore the client window window.

   "maximize"

   1. Maximize the client window window.

   "minimize"

   1. Minimize the client window window.

9. Return success with data null.

browser.ClientWindow = text;

browser.ClientWindowInfo = {
  active: bool,
  clientWindow: browser.ClientWindow,
  height: js-uint,
  state: "fullscreen" / "maximized" / "minimized" / "normal",
  width: js-uint,
  x: js-int,
  y: js-int,
}

To get the client window info given client window:

1. Let client window id be the client window id for client window.

2. Let state be get the client window state with client window.

3. If client window can receive keyboard input channeled from the operating system, let active be true, otherwise let active be false.

   Note: This could mean that a top-level traversable whose client window is client window has system focus, or it could mean that the user interface of the browser itself currently has focus.

4. Let client window info be a map matching the browser.ClientWindowsInfo production with the clientWindow field set to client window id, state field set to state, the x field set to client window’s x-coordinate, the y field set to client window’s y-coordinate, the width field set to client window’s width, the height field set to client window’s height, and the active field set to active.

5. Return client window info

browser.UserContext = text;

browser.UserContextInfo = {
  userContext: browser.UserContext
}

The remote end steps with session and command parameters are:

1. End the session with session.

2. If active sessions is not empty an implementation may return error with error code unable to close browser, and then run the following steps in parallel:

   1. Wait until the Send a WebSocket message steps have been called with the response to this command.

   2. Cleanup the session with session.

   Note: The behaviour in cases where the browser has multiple automation sessions is currently unspecified. It might be that any session can close the browser, or that only the final open session can actually close the browser, or only the first session started can. This behaviour might be fully specified in a future version of this specification.

3. For each active session in active sessions:

   1. End the session active session.

   2. Cleanup the session with active session

4. Return success with data null, and run the following steps in parallel.

   1. Wait until the Send a WebSocket message steps have been called with the response to this command.

   2. Cleanup the session with session.

   3. Close any top-level traversables without prompting to unload.

   4. Perform implementation defined steps to clean up resources associated with the remote end under automation.

      Note: For example this might include cleanly shutting down any OS-level processes associated with the browser under automation, removing temporary state, such as user profile data, created by the remote end while under automation, or shutting down the WebSocket Listener. Because of differences between browsers and operating systems it is not possible to specify in detail precise invariants local ends can depend on here.

The remote end steps with session and command parameters are:

1. Let user context be a new user context.

2. If command parameters contain "acceptInsecureCerts":

   Note: If "acceptInsecureCerts" is set, it overrides the accept insecure TLS flag’s behavior.

   1. Let acceptInsecureCerts be command parameters["acceptInsecureCerts"]:

   2. If acceptInsecureCerts is true and endpoint node doesn’t support accepting insecure TLS connections, return error with error code unsupported operation.

   3. Set session’s user context to accept insecure certificates override map[user context] to acceptInsecureCerts.

3. If command parameters contains "proxy":

   1. Let proxy configuration be command parameters["proxy"].

   2. If the remote end is unable to configure proxy settings per user context, or is unable to configure the proxy with proxy configuration, return error with error code unsupported operation.

   3. Set session’s user context to proxy configuration map[user context] to proxy configuration.

4. Append user context to the set of user contexts.

5. Let user context info be a map matching the browser.UserContextInfo production with the userContext field set to user context’s user context id.

6. Return success with data user context info.

The remote end steps are:

1. Let client window ids be an empty set.

2. Let client windows be an empty list.

3. For each top-level traversable traversable:

   1. Let client window be traversable’s associated client window

   2. Let client window id be the client window id for client window.

   3. If client window ids contains client window id, continue.

   4. Append client window id to client window ids.

   5. Let client window info be get the client window info with client window.

   6. Append client window info to client windows.

4. Let result be a map matching the browser.GetClientWindowsResult production with the clientWindows field set to client windows.

5. Return success with data result.

The remote end steps are:

1. Let user contexts be an empty list.

2. For each user context in the set of user contexts:

   1. Let user context info be a map matching the browser.UserContextInfo production with the userContext field set to user context’s user context id.

   2. Append user context info to user contexts.

3. Let result be a map matching the browser.GetUserContextsResult production with the userContexts field set to user contexts.

4. Return success with data result.

The remote end steps with command parameters are:

1. Let user context id be command parameters["userContext"].

2. If user context id is "default", return error with error code invalid argument.

3. Set user context to get user context with user context id.

4. If user context is null, return error with error code no such user context.

5. For each top-level traversable navigable:

   1. If navigable’s associated user context is user context:

      1. Close navigable without prompting to unload.

6. Remove user context for the set of user contexts.

7. Return success with data null.

The remote end steps with session and command parameters are:

1. If the implementation does not support setting the client window state at all, then return error with error code unsupported operation.

2. If there is a client window with client window id command parameters["clientWindow"], let client window be that client window. Otherwise return error with error code no such client window.

3. Try to set the client window state with client window and command parameters["state"].

4. If command parameters["state"] is "normal":

   1. If command parameters contains "x" and the implementation supports positioning client windows, set the x-coordinate of client window to a value that is as close as possible command parameters["x"].

   2. If command parameters contains "y" and the implementation supports positioning client windows, set the y-coordinate of client window to a value that is as close as possible command parameters["y"].

   3. If command parameters contains "width" and the implementation supports resizing client windows, set the width of client window to a value that is as close as possible command parameters["width"].

   4. If command parameters contains "width" and the implementation supports resizing client windows, set the width of client window to a value that is as close as possible command parameters["width"].

5. Let client window info be get the client window info with client window.

6. Return success with data client window info.

Note: For simplicity this models all client window operations as synchronous. Therefore the returned client window dimensions are expected to be those after the window has reached its new state.

BrowsingContextCommand = (
  browsingContext.Activate //
  browsingContext.CaptureScreenshot //
  browsingContext.Close //
  browsingContext.Create //
  browsingContext.GetTree //
  browsingContext.HandleUserPrompt //
  browsingContext.LocateNodes //
  browsingContext.Navigate //
  browsingContext.Print //
  browsingContext.Reload //
  browsingContext.SetViewport //
  browsingContext.TraverseHistory
)

BrowsingContextResult = (
  browsingContext.CaptureScreenshotResult /
  browsingContext.CreateResult /
  browsingContext.GetTreeResult /
  browsingContext.LocateNodesResult /
  browsingContext.NavigateResult /
  browsingContext.PrintResult /
  browsingContext.TraverseHistoryResult
)

BrowsingContextEvent = (
  browsingContext.ContextCreated //
  browsingContext.ContextDestroyed //
  browsingContext.DomContentLoaded //
  browsingContext.DownloadEnd //
  browsingContext.DownloadWillBegin //
  browsingContext.FragmentNavigated //
  browsingContext.HistoryUpdated //
  browsingContext.Load //
  browsingContext.NavigationAborted //
  browsingContext.NavigationCommitted //
  browsingContext.NavigationFailed //
  browsingContext.NavigationStarted //
  browsingContext.UserPromptClosed //
  browsingContext.UserPromptOpened
)

browsingContext.BrowsingContext = text;

To get a navigable given navigable id:

1. If navigable id is null, return success with data null.

2. If there is no navigable with navigable id navigable id return error with error code no such frame

3. Let navigable be the navigable with id navigable id.

4. Return success with data navigable.

browsingContext.InfoList = [*browsingContext.Info]

browsingContext.Info = {
  children: browsingContext.InfoList / null,
  clientWindow: browser.ClientWindow,
  context: browsingContext.BrowsingContext,
  originalOpener: browsingContext.BrowsingContext / null,
  url: text,
  userContext: browser.UserContext,
  ? parent: browsingContext.BrowsingContext / null,
}

To get the child navigables given navigable:

TODO: make this return a list in document order

1. Let child navigables be a set containing all navigables that are a child navigable of navigable.

2. Return child navigables.

To get the navigable info given navigable, max depth and include parent id:

1. Let navigable id be the navigable id for navigable.

2. Let parent navigable be navigable’s parent.

3. If parent navigable is not null let parent id be the navigable id of parent navigable. Otherwise let parent id be null.

4. Let document be navigable’s active document.

5. Let url be the result of running the URL serializer, given document’s URL.

   Note: This includes the fragment component of the URL.

6. Let child infos be null.

7. If max depth is null, or max depth is greater than 0:

   1. Let child navigables be get the child navigables given navigable.

   2. Let child depth be max depth - 1 if max depth is not null, or null otherwise.

   3. Set child infos to an empty list.

   4. For each child navigable of child navigables:

      1. Let info be the result of get the navigable info given child navigable, child depth, and false.

      2. Append info to child infos

8. Let user context be navigable’s associated user context.

9. Let opener id be the navigable id for navigable’s original opener, if navigable’s original opener is not null, and null otherwise.

10. Let top-level traversable be navigable’s top-level traversable.

11. Let client window id be the client window id for top-level traversable’s associated client window.

12. Let navigable info be a map matching the browsingContext.Info production with the context field set to navigable id, the parent field set to parent id if include parent id is true, or unset otherwise, the url field set to url, the userContext field set to user context’s user context id, originalOpener field set to opener id, the children field set to child infos, and the clientWindow field set to client window id.

13. Return navigable info.

To await a navigation given navigable, request, wait condition, and optionally history handling (default: "default") and ignore cache (default: false):

1. Let navigation id be the string representation of a UUID based on truly random, or pseudo-random numbers.

2. Navigate navigable with resource request, and using navigable’s active document as the source Document, with navigation id navigation id, and history handling behavior history handling. If ignore cache is true, the navigation must not load resources from the HTTP cache.

   property specify how the ignore cache flag works. This needs to consider whether only the first load of a resource bypasses the cache (i.e. whether this is like initially clearing the cache and proceeding like normal), or whether resources not directly loaded by the HTML parser (e.g. loads initiated by scripts or stylesheets) also bypass the cache.

3. Let (event received, navigate status) be await given «"navigation started", "navigation failed", "fragment navigated"», and navigation id.

4. Assert: navigate status’s id is navigation id.

5. If navigate status’s status is "complete":

   1. Let body be a map matching the browsingContext.NavigateResult production, with the navigation field set to navigation id, and the url field set to the result of the URL serializer given navigate status’s url.

   2. Return success with data body.

   Note: this is the case if the navigation only caused the fragment to change.

6. If navigate status’s status is "canceled" return error with error code unknown error.

   TODO: is this the right way to handle errors here?

7. Assert: navigate status’s status is "pending" and navigation id is not null.

8. If wait condition is "committed", let event name be "committed".

9. Otherwise, if wait condition is "interactive", let event name be "domContentLoaded".

10. Otherwise, let event name be "load".

11. Let (event received, status) be await given «event name, "download started", "navigation aborted", "navigation failed"» and navigation id.

12. If event received is "navigation failed" return error with error code unknown error.

    Are we surfacing enough information about what failed and why with an error here? What error code do we want? Is there going to be a problem where local ends parse the implementation-defined strings to figure out what actually went wrong?

13. Let body be a map matching the browsingContext.NavigateResult production, with the navigation field set to status’s id, and the url field set to the result of the URL serializer given status’s url.

14. Return success with data body.

browsingContext.Locator = (
   browsingContext.AccessibilityLocator /
   browsingContext.CssLocator /
   browsingContext.ContextLocator /
   browsingContext.InnerTextLocator /
   browsingContext.XPathLocator
)

browsingContext.AccessibilityLocator = {
   type: "accessibility",
   value: {
    ? name: text,
    ? role: text,
   }
}

browsingContext.CssLocator = {
   type: "css",
   value: text
}

browsingContext.ContextLocator = {
  type: "context",
  value: {
    context: browsingContext.BrowsingContext,
  }
}

browsingContext.InnerTextLocator = {
   type: "innerText",
   value: text,
   ? ignoreCase: bool
   ? matchType: "full" / "partial",
   ? maxDepth: js-uint,
}

browsingContext.XPathLocator = {
   type: "xpath",
   value: text
}

browsingContext.Navigation = text;

browsingContext.BaseNavigationInfo = (
  context: browsingContext.BrowsingContext,
  navigation: browsingContext.Navigation / null,
  timestamp: js-uint,
  url: text,
)

browsingContext.NavigationInfo = {
  browsingContext.BaseNavigationInfo
}

To get the navigation info, given navigable and navigation status:

1. Let navigable id be the navigable id for navigable.

2. Let navigation id be navigation status’s id.

3. Let timestamp be a time value representing the current date and time in UTC.

4. Let url be navigation status’s url.

5. Return a map matching the browsingContext.NavigationInfo production, with the context field set to navigable id, the navigation field set to navigation id, the timestamp field set to timestamp, and the url field set to the result of the URL serializer given url.

browsingContext.ReadinessState = "none" / "interactive" / "complete"

browsingContext.UserPromptType = "alert" / "beforeunload" / "confirm" / "prompt";

The remote end steps with command parameters are:

1. Let navigable id be the value of the command parameters["context"] field.

2. Let navigable be the result of trying to get a navigable with navigable id.

3. If navigable is not a top-level traversable, return error with error code invalid argument.

4. Return activate a navigable with navigable.

To activate a navigable given navigable:

1. Run implementation-specific steps so that navigable’s system visibility state becomes visible. If this is not possible return error with error code unsupported operation.

   Note: This can have the side effect of making currently visible navigables hidden.

   Note: This can change the underlying OS state by causing the window to become unminimized or by other side effects related to changing the system visibility state.

2. Run implementation-specific steps to set the system focus on the navigable if it is not focused.

   Note: This does not change the focused area of the document except as mandated by other specifications.

3. Return success with data null.

To normalize rect given rect:

Note: This ensures that the resulting rect has positive width dimension and height dimension.

1. Let x be rect’s x coordinate.

2. Let y be rect’s y coordinate.

3. Let width be rect’s width dimension.

4. Let height be rect’s height dimension.

5. If width is less than 0, set x to x + width and then set width to -width.

6. If height is less than 0, set y to y + height and then set height to -height.

7. Return a new DOMRectReadOnly with x coordinate x, y coordinate y, width dimension width and height dimension height.

To rectangle intersection given rect1 and rect2

1. Let rect1 be normalize rect with rect1.

2. Let rect2 be normalize rect with rect2.

3. Let x1_0 be rect1’s x coordinate.

4. Let x2_0 be rect2’s x coordinate.

5. Let x1_1 be rect1’s x coordinate plus rect1’s width dimension.

6. Let x2_1 be rect2’s x coordinate plus rect2’s width dimension.

7. Let x_0 be the maximum element of «x1_0, x2_0».

8. Let x_1 be the minimum element of «x1_1, x2_1».

9. Let y1_0 be rect1’s y coordinate.

10. Let y2_0 be rect2’s y coordinate.

11. Let y1_1 be rect1’s y coordinate plus rect1’s height dimension.

12. Let y2_1 be rect2’s y coordinate plus rect2’s height dimension.

13. Let y_0 be the maximum element of «y1_0, y2_0».

14. Let y_1 be the minimum element of «y1_1, y2_1».

15. If x_1 is less than x_0, let width be 0. Otherwise let width be x_1 - x_0.

16. If y_1 is less than y_0, let height be 0. Otherwise let height be y_1 - y_0.

17. Return a new DOMRectReadOnly with x coordinate x_0, y coordinate y_0, width dimension width and height dimension height.

To render document to a canvas given document and rect:

1. Let ratio be determine the device pixel ratio given document’s default view.

2. Let paint width be rect’s width dimension multiplied by ratio, rounded to the nearest integer, so it matches the width of rect in device pixels.

3. Let paint height be rect’s height dimension multiplied by ratio, rounded to the nearest integer, so it matches the height of rect in device pixels.

4. Let canvas be a new HTMLCanvasElement with width paint width and height paint height.

5. Let canvas context be the result of running the 2D context creation algorithm with canvas and null.

6. Set canvas’s context mode to 2D.

7. Complete implementation specific steps equivalent to drawing the region of the framebuffer representing the region of document covered by rect to canvas context, such that each pixel in the framebuffer corresponds to a pixel in canvas context with (rect’s x coordinate, rect’s y coordinate) in viewport coordinates corresponding to (0,0) in canvas context and (rect’s x coordinate + rect’s width dimension, rect’s y coordinate + rect’s height dimension) corresponding to (paint width, paint height).

8. Return canvas.

To encode a canvas as Base64 given canvas and format:

1. If format is not null, let type be the type field of format, and let quality be the quality field of format.

2. Otherwise, let type be "image/png" and let quality be undefined.

3. Let file be a serialization of the bitmap as a file for canvas with type and quality.

4. Let encoded string be the forgiving-base64 encode of file.

5. Return success with data encoded string.

To get the origin rectangle given document and origin:

1. If origin is "viewport":

   1. Let viewport be document’s visual viewport.

   2. Let viewport rect be a DOMRectReadOnly with x coordinate viewport page left, y coordinate viewport page top, width dimension viewport width, and height dimension viewport height.

   3. Return success with data viewport rect.

2. Assert: origin is "document".

3. Let document element be the document element for document.

4. Let document rect be a DOMRectReadOnly with x coordinate 0, y coordinate 0, width dimension document element scroll height, and height dimension document element scroll width.

5. Return success with data document rect.

The remote end steps with command parameters are:

1. Let navigable id be the value of the context field of command parameters.

2. Let prompt unload be the value of the promptUnload field of command parameters.

3. Let navigable be the result of trying to get a navigable with navigable id.

4. Assert: navigable is not null.

5. If navigable is not a top-level traversable, return error with error code invalid argument.

6. If prompt unload is true:

   1. Close navigable.

7. Otherwise:

   1. Close navigable without prompting to unload.

8. Return success with data null.

There is an open discussion about the behavior when closing the last top-level traversable. We could expect to close the browser, close the session or leave this up to the implementation. [w3c/webdriver-bidi Issue #170]

The remote end steps with command parameters are:

1. Let type be the value of the type field of command parameters.

2. Let reference navigable id be the value of the referenceContext field of command parameters, if present, or null otherwise.

3. If reference navigable id is not null, let reference navigable be the result of trying to get a navigable with reference navigable id. Otherwise let reference navigable be null.

4. If reference navigable is not null and is not a top-level traversable, return error with error code invalid argument.

5. If the implementation is unable to create a new top-level traversable for any reason then return error with error code unsupported operation.

6. Let user context be the default user context if reference navigable is null, and reference navigable’ associated user context otherwise.

7. Let user context id be the value of the userContext field of command parameters if present, or null otherwise.

8. If user context id is not null, set user context to the result of trying to get user context with user context id.

9. If user context is null, return error with error code no such user context.

10. If the implementation is unable to create a new top-level traversable with associated user context user context for any reason, return error with error code unsupported operation.

11. Let traversable be the result of trying to create a new top-level traversable steps with null and empty string, and setting the associated user context for the newly created top-level traversable to user context. Which OS window the new top-level traversable is created in depends on type and reference navigable:

    • If type is "tab" and the implementation supports multiple top-level traversables in the same OS window:

      • The new top-level traversable should reuse an existing OS window, if any.

      • If reference navigable is not null, the new top-level traversable should reuse the window containing reference navigable, if any. If the top-level traversables inside an OS window have a definite ordering, the new top-level traversable should be immediately after reference navigable’s top-level traversable in that ordering.

    • If type is "window", and the implementation supports multiple top-level traversable in separate OS windows, the created top-level traversable should be in a new OS window.

    • Otherwise, the details of how the top-level traversable is presented to the user are implementation defined.

12. If the value of the command parameters’ background field is false:

    1. Let activate result be the result of activate a navigable with the newly created navigable.

    2. If activate result is an error, return activate result.

    Note: Do not invoke the focusing steps for the created navigable if background is true.

13. Let body be a map matching the browsingContext.CreateResult production, with the context field set to traversable’s navigable id.

14. Return success with data body.

The remote end steps with session and command parameters are:

1. Let root id be the value of the root field of command parameters if present, or null otherwise.

2. Let max depth be the value of the maxDepth field of command parameters if present, or null otherwise.

3. Let navigables be an empty list.

4. If root id is not null, append the result of trying to get a navigable given root id to navigables. Otherwise append all top-level traversables to navigables.

5. Let navigables infos be an empty list.

6. For each navigable of navigables:

   1. Let info be the result of get the navigable info given navigable, max depth, and true.

   2. Append info to navigables infos

7. Let body be a map matching the browsingContext.GetTreeResult production, with the contexts field set to navigables infos.

8. Return success with data body.

The remote end steps with session and command parameters are:

1. Let navigable id be the value of the context field of command parameters.

2. Let navigable be the result of trying to get a navigable with navigable id.

3. Let accept be the value of the accept field of command parameters if present, or true otherwise.

4. Let userText be the value of the userText field of command parameters if present, or the empty string otherwise.

5. If navigable is currently showing a simple dialog from a call to alert then acknowledge the prompt.

   Otherwise if navigable is currently showing a simple dialog from a call to confirm, then respond positively if accept is true, or respond negatively if accept is false.

   Otherwise if navigable is currently showing a simple dialog from a call to prompt, then respond with the string value userText if accept is true, or abort if accept is false.

   Otherwise, if navigable is currently showing a prompt as part of the prompt to unload steps, then confirm the navigation if accept is true, otherwise refuse the navigation.

   Otherwise return error with error code no such alert.

6. Return success with data null.

To locate nodes using CSS with given navigable, context nodes, selector, maximum returned node count, and session:

1. Let returned nodes be an empty list.

2. Let parse result be the result of parse a selector given selector.

3. If parse result is failure, return error with error code invalid selector.

4. For each context node of context nodes:

   1. Let elements be the result of match a selector against a tree with parse result and navigable’s active document root using scoping root context node.

   2. For each element in elements:

      1. Append element to returned nodes.

      2. If maximum returned node count is not null and size of returned nodes is equal to maximum returned node count, return success with data returned nodes.

5. Return success with data returned nodes.

To locate the container element given navigable:

1. Let returned nodes be an empty list.

2. If navigable’s container is not null, append navigable’s container to returned nodes.

3. Return returned nodes.

To locate nodes using XPath with given navigable, context nodes, selector, and maximum returned node count:

Note: Owing to the unmaintained state of the XPath specification, this algorithm is phrased as if making calls to the XPath DOM APIs. However this is to be understood as equivalent to spec-internal calls directly accessing the underlying algorithms, without going via the ECMAScript runtime.

1. Let returned nodes be an empty list.

2. For each context node of context nodes:

   1. Let evaluate result be the result of calling evaluate on navigable’s active document, with arguments selector, context node, null, ORDERED_NODE_SNAPSHOT_TYPE, and null. If this throws a "SyntaxError" DOMException, return error with error code invalid selector; otherwise, if this throws any other exception return error with error code unknown error.

   2. Let index be 0.

   3. Let length be the result of getting the snapshotLength property from evaluate result.

   4. Repeat, while index is less than length:

      1. Let node be the result of calling snapshotItem with evaluate result as this and index as the argument.

      2. Append node to returned nodes.

      3. If maximum returned node count not null and size of returned nodes is equal to maximum returned node count, return success with data returned nodes.

      4. Set index to index + 1.

3. Return success with data returned nodes.

To locate nodes using inner text with given context nodes, selector, max depth, match type, ignore case, and maximum returned node count:

1. If selector is the empty string, return error with error code invalid selector.

2. Let returned nodes be an empty list.

3. If ignore case is false, let search text be selector. Otherwise, let search text be the result of toUppercase with selector according to the Unicode Default Case Conversion algorithm.

4. For each context node in context nodes:

   1. If context node implements Document or DocumentFragment:

      Note: when traversing the document or document fragment, max depth is not decreased intentionally to make the search result with document and document.documentElement equivalent.

      1. Let child nodes be an empty list.

      2. For each node child in the children of context node.

         1. Append child to child nodes.

      3. Extend returned nodes with the result of trying to locate nodes using inner text with child nodes, selector, max depth, match type, ignore case, and maximum returned node count.

   2. If context node does not implement HTMLElement then continue.

   3. Let node inner text be the result of calling the innerText getter steps with context node as the this value.

   4. If ignore case is false, let node text be node inner text. Otherwise, let node text be the result of toUppercase with node inner text according to the Unicode Default Case Conversion algorithm.

   5. If search text is a code point substring of node text, perform the following steps:

      1. Let child nodes be an empty list and, for each node child in the children of context node:

         1. Append child to child nodes.

      2. If size of child nodes is equal to 0 or max depth is equal to 0, perform the following steps:

         1. If match type is "full" and node text is search text, append context node to returned nodes.

         2. Otherwise, if match type is "partial", append context node to returned nodes.

      3. Otherwise, perform the following steps:

         1. Let child max depth be null if max depth is null, or max depth - 1 otherwise.

         2. Let child node matches be the result of locate nodes using inner text with child nodes, selector, child max depth , match type, ignore case, and maximum returned node count.

         3. If size of child node matches is equal to 0 and match type is "partial", append context node to returned nodes. Otherwise, extend returned nodes with child node matches.

5. If maximum returned node count is not null, remove all entries in returned nodes with an index greater than or equal to maximum returned node count.

6. Return success with data returned nodes.

To collect nodes using accessibility attributes with given context nodes, selector, maximum returned node count, and returned nodes:

1. If returned nodes is null:

   1. Set returned nodes to an empty list.

2. For each context node in context nodes:

   1. Let match be true.

   2. If context node implements Element:

      1. If selector contains "role":

         1. Let role be the computed role of context node.

         2. If selector["role"] is not role:

            1. Set match to false.

      2. If selector contains "name":

         1. Let name be the accessible name of context node.

         2. If selector["name"] is not name:

            1. Set match to false.

   3. Otherwise, set match to false.

   4. If match is true:

      1. If maximum returned node count is not null and size of returned nodes is equal to maximum returned node count, break.

      2. Append context node to returned nodes.

   5. Let child nodes be an empty list and, for each node child in the children of context node:

      1. If child implements Element, append child to child nodes.

   6. Try to collect nodes using accessibility attributes with child nodes, selector, maximum returned node count, and returned nodes.

3. Return returned nodes.

To locate nodes using accessibility attributes with given context nodes, selector, and maximum returned node count:

1. If selector does not contain "role" and selector does not contain "name", return error with error code invalid selector.

2. Return the result of collect nodes using accessibility attributes with context nodes, selector, maximum returned node count, and null.

The remote end steps with session and command parameters are:

1. Let navigable id be command parameters["context"].

2. Let navigable be the result of trying to get a navigable with navigable id.

3. Assert: navigable is not null.

4. Let realm be the result of trying to get a realm from a navigable with navigable id of navigable and null.

5. Let locator be command parameters["locator"].

6. If command parameters contains "startNodes", let start nodes parameter be command parameters["startNodes"]. Otherwise let start nodes parameter be null.

7. If command parameters contains "maxNodeCount", let maximum returned node count be command parameters["maxNodeCount"]. Otherwise, let maximum returned node count be null.

8. Let context nodes be an empty list.

9. If start nodes parameter is null, append the document element of navigable’s active document to context nodes. Otherwise, for each serialized start node in start nodes parameter:

   1. Let start node be the result of trying to deserialize shared reference given serialized start node, realm and session.

   2. Append start node to context nodes.

10. Assert size of context nodes is greater than 0.

11. Let type be locator["type"].

12. In the following list of conditions and associated steps, run the first set of steps for which the associated condition is true:

    type is the string "css"

    1. Let selector be locator["value"].

    2. Let result nodes be a result of trying to locate nodes using css given navigable, context nodes, selector and maximum returned nodes.

    type is the string "xpath"

    1. Let selector be locator["value"].

    2. Let result nodes be a result of trying to locate nodes using xpath given navigable, context nodes, selector and maximum returned nodes.

    type is the string "innerText"

    1. Let selector be locator["value"].

    2. If locator contains maxDepth, let max depth be locator["maxDepth"]. Otherwise, let max depth be null.

    3. If locator contains ignoreCase, let ignore case be locator["ignoreCase"]. Otherwise, let ignore case be false.

    4. If locator contains matchType, let match type be locator["matchType"]. Otherwise, let match type be "full".

    5. Let result nodes be a result of trying to locate nodes using inner text given context nodes, selector, max depth, match type, ignore case and maximum returned node count.

    type is the string "accessibility"

    1. Let selector be locator["value"].

    2. Let result nodes be locate nodes using accessibility attributes given context nodes, selector, and maximum returned node count.

    type is the string "context"

    1. If start nodes parameter is not null, return error with error code "invalid argument".

    2. Let selector be locator["value"].

    3. Let context id be selector["context"].

    4. Let child navigable be the result of trying to get a navigable with context id.

    5. If child navigable’s parent is not navigable, return error with error code "invalid argument".

    6. Let result nodes be locate the container element given child navigable.

    7. Assert: For each node in result nodes, node’s node navigable is navigable.

13. Assert: maximum returned node count is null or size of result nodes is less than or equal to maximum returned node count.

14. If command parameters contains "serializationOptions", let serialization options be command parameters["serializationOptions"]. Otherwise, let serialization options be a map matching the script.SerializationOptions production with the fields set to their default values.

15. Let result ownership be "none".

16. Let serialized nodes be an empty list.

17. For each result node in result nodes:

    1. Let serialized node be the result of serialize as a remote value with result node, serialization options, result ownership, a new map as serialization internal map, realm and session.

    2. Append serialized node to serialized nodes.

18. Let result be a map matching the browsingContext.LocateNodesResult production, with the nodes field set serialized nodes.

19. Return success with data result.

The remote end steps with session and command parameters are:

1. Let navigable id be the value of the context field of command parameters.

2. Let navigable be the result of trying to get a navigable with navigable id.

3. Assert: navigable is not null.

4. Let wait condition be "committed".

5. If command parameters contains wait and command parameters[wait] is not "none", set wait condition to command parameters[wait].

6. Let url be the value of the url field of command parameters.

7. Let document be navigable’s active document.

8. Let base be document’s base URL.

9. Let url record be the result of applying the URL parser to url, with base URL base.

10. If url record is failure, return error with error code invalid argument.

11. Let request be a new request whose URL is url record.

12. Return the result of await a navigation with navigable, request and wait condition.

The remote end steps with session and command parameters are:

1. Let navigable id be the value of the context field of command parameters.

2. Let navigable be the result of trying to get a navigable with navigable id.

3. If the implementation is unable to provide a paginated representation of navigable for any reason then return error with error code unsupported operation.

4. Let margin be the value of the margin field of command parameters if present, or otherwise a map matching the browsingContext.PrintMarginParameters with the fields set to their default values.

5. Let page size be the value of the page field of command parameters if present, or otherwise a map matching the browsingContext.PrintPageParameters with the fields set to their default values.

Note: The minimum page size is 1 point, which is (2.54 / 72) cm as per absolute lengths.

1. Let page ranges be the value of the pageRanges field of command parameters if present or an empty list otherwise.

2. Let document be navigable’s active document.

3. Immediately after the next invocation of the run the animation frame callbacks algorithm for document:

   This ought to be integrated into the update rendering algorithm in some more explicit way.

   1. Let pdf data be the result taking UA-specific steps to generate a paginated representation of document, with the CSS media type set to print, encoded as a PDF, with the following paper settings:

      Property	Value
      Width in cm	page size["width"] if command parameters["orientation"] is "portrait" otherwise page size["height"]
      Height in cm	page size["height"] if command parameters["orientation"] is "portrait" otherwise page size["width"]
      Top margin, in cm	margin["top"]
      Bottom margin, in cm	margin["bottom"]
      Left margin, in cm	margin["left"]
      Right margin, in cm	margin["right"]

      In addition, the following formatting hints should be applied by the UA:

      If command parameters["scale"] is not equal to 1:

      Zoom the size of the content by a factor command parameters["scale"]

      If command parameters["background"] is false:

      Suppress output of background images

      If command parameters["shrinkToFit"] is true:

      Resize the content to match the page width, overriding any page width specified in the content

   2. If page ranges is not empty, let pages be the result of trying to parse a page range with page ranges and the number of pages contained in pdf data, then remove any pages from pdf data whose one-based index is not contained in pages.

   3. Let encoding result be the result of calling Base64 Encode on pdf data.

   4. Let encoded data be encoding result’s data.

   5. Let body be a map matching the browsingContext.PrintResult production, with the data field set to encoded data.

   6. Return success with data body.

The remote end steps with command parameters are:

1. Let navigable id be the value of the context field of command parameters.

2. Let navigable be the result of trying to get a navigable with navigable id.

3. Assert: navigable is not null.

4. Let ignore cache be the the value of the ignoreCache field of command parameters if present, or false otherwise.

5. Let wait condition be "committed".

6. If command parameters contains wait and command parameters[wait] is not "none", set wait condition to command parameters[wait].

7. Let document be navigable’s active document.

8. Let url be document’s URL.

9. Let request be a new request whose URL is url.

10. Return the result of await a navigation with navigable, request, wait condition, history handling "reload", and ignore cache ignore cache.

To set device pixel ratio override given navigable and device pixel ratio:

1. If device pixel ratio is not null:

   1. For document currently loaded in a specified navigable:

      1. When the select an image source from a source set steps are run, act as if the implementation’s pixel density was set to device pixel ratio when selecting an image.

      2. For the purposes of the resolution media feature, act as if the implementation’s resolution is device pixel ratio dppx scaled by the page zoom.

   2. Set device pixel ratio overrides[navigable] to device pixel ratio.

      Note: This will take an effect because of the patch of § 8.3.1 Determine the device pixel ratio.

2. Otherwise:

   1. For document currently loaded in a specified navigable:

      1. When the select an image source from a source set steps are run, use the implementation’s default behavior, without any changes made by previous invocations of these steps.

      2. For the purposes of the resolution media feature, use the implementation’s default behavior, without any changes made by previous invocations of these steps.

   2. Remove navigable from device pixel ratio overrides.

3. Run evaluate media queries and report changes for document currently loaded in a specified navigable.

To set viewport given navigable and viewport:

1. If viewport is not null, set the width of navigable’s layout viewport to be the width of viewport in CSS pixels and set the height of the navigable’s layout viewport to be the height of viewport in CSS pixels.

2. Otherwise, set the navigable’s layout viewport to the implementation-defined default.

After creating a document in a new navigable navigable and before the run WebDriver BiDi preload scripts algorithm is invoked:

TODO: Move it as a hook in the html spec instead.

1. Let user context be navigable’s associated user context.

2. If navigable is a top-level traversable:

   1. If geolocation overrides map contains user context, set emulated position data with navigable and geolocation overrides map[user context].

   2. If screen orientation overrides map contains user context, set emulated screen orientation with navigable and screen orientation overrides map[user context].

3. If viewport overrides map contains user context:

   1. If navigable is a top-level traversable and the viewport field of viewport overrides map[user context] is not null:

      1. Set viewport with navigable and viewport overrides map[user context]["viewport"].

   2. If the devicePixelRatio field of viewport overrides map[user context] is not null:

      1. Set device pixel ratio override with navigable and viewport overrides map[user context]["devicePixelRatio""].

The remote end steps with command parameters are:

1. If the implementation is unable to adjust the layout viewport parameters with the given command parameters for any reason, return error with error code unsupported operation.

2. If command parameters contains "userContexts" and command parameters contains "context", return error with error code invalid argument.

3. Let navigables be a set.

4. If the context field of command parameters is present:

   1. Let navigable id be the value of the context field of command parameters.

   2. Let navigable be the result of trying to get a navigable with navigable id.

   3. If navigable is not a top-level traversable, return error with error code invalid argument.

   4. Append navigable to navigables.

5. Otherwise, if the userContexts field of command parameters is present:

   1. Let user contexts be the result of trying to get valid user contexts with command parameters["userContexts"].

   2. For each user context of user contexts:

      1. Set viewport overrides map[user context] to a struct.

      2. If command parameters contains "viewport":

         1. Set viewport overrides map[user context]["viewport"] to command parameters["viewport"].

      3. If command parameters contains "devicePixelRatio":

         1. Set viewport overrides map[user context]["devicePixelRatio"] to command parameters["devicePixelRatio"].

      4. For each top-level traversable of the list of all top-level traversables whose associated user context is user context:

         1. Append top-level traversable to navigables.

6. Otherwise, return error with error code invalid argument.

7. If command parameters contains the viewport field:

   1. Let viewport be the command parameters["viewport"].

   2. For each navigable of navigables:

      1. Set viewport with navigable and viewport.

      2. Run the CSSOM View § 13.1 Resizing viewports steps with navigable’s active document.

8. If command parameters contains the devicePixelRatio field:

   1. Let device pixel ratio be the command parameters["devicePixelRatio"].

   2. For each navigable of navigables:

      1. For the navigable and all descendant navigables:

         1. Set device pixel ratio override with navigable and device pixel ratio.

9. Return success with data null.

The remote end steps with command parameters are:

1. Let navigable be the result of trying to get a navigable with command parameters["context"].

2. If navigable is not a top-level traversable, return error with error code invalid argument.

3. Assert: navigable is not null.

4. Let delta be command parameters["delta"].

5. Let resume id be a unique string.

6. Queue a task on navigable’s session history traversal queue to run the following steps:

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

   2. Let current index be the index of navigable’s current session history step within all steps.

   3. Let target index be current index plus delta.

   4. Let valid entry be false if all steps[target index] does not exist, or true otherwise.

   5. Resume with "check history", resume id, and valid entry.

7. Let is valid entry be await with «"check history"», and resume id.

8. If is valid entry is false, return error with error code no such history entry.

9. Traverse the history by a delta given delta and navigable.

   There is a race condition in the algorithm as written because by the time we try to navigate the target session history entry might not exist. Once we support waiting for history to navigate we can handle this more robustly.

10. TODO: Support waiting for the history traversal to complete.

11. Let body be a map matching the browsingContext.TraverseHistoryResult production.

12. Return success with data body.

The WebDriver BiDi page show steps given context and navigation status are:

Do we want to expose a `browsingContext.pageShow event? In that case we’d need to call this whenever `pageshow` is going to be emitted, not just on bfcache restore, and also add the persisted status to the data.

1. Let navigation id be navigation status’s id.

2. Resume with "page show", navigation id, and navigation status.

The WebDriver BiDi pop state steps given context and navigation status are:

1. Let navigation id be navigation status’s id.

2. Resume with "pop state", navigation id, and navigation status.

To Recursively emit context created events given session and navigable:

1. Emit a context created event with session and navigable.

2. For each child navigable, child, of navigable:

   1. Recursively emit context created events given session and child.

To Emit a context created event given session and navigable:

1. Let params be the result of get the navigable info given navigable, 0, and true.

2. Let body be a map matching the browsingContext.ContextCreated production, with the params field set to params.

3. Emit an event with session and body.

The remote end event trigger is the WebDriver BiDi navigable created steps given navigable and opener navigable:

1. Set navigable’s original opener to opener navigable, if opener navigable is provided.

2. If the navigable cache behavior with navigable is "bypass", then perform implementation-defined steps to disable any implementation-specific resource caches for network requests originating from navigable.

3. Let related navigables be a set containing navigable.

4. For each session in the set of sessions for which an event is enabled given "browsingContext.contextCreated" and related navigables:

   1. Emit a context created event given session and navigable.

The remote end subscribe steps, with subscribe priority 1, given session, navigables and include global are:

1. For each navigable in navigables:

   1. Recursively emit context created events given session and navigable.

The remote end event trigger is the WebDriver BiDi navigable destroyed steps given navigable:

1. Let params be the result of get the navigable info, given navigable, null, and true.

2. Let body be a map matching the browsingContext.ContextDestroyed production, with the params field set to params.

3. Let related navigables be a set containing navigable’s parent, if that is not null, or an empty set otherwise.

4. For each session in the set of sessions for which an event is enabled given "browsingContext.contextDestroyed" and related navigables:

   1. Emit an event with session and body.

   2. Let subscriptions to remove be a set.

   3. For each subscription in session’s subscriptions:

      1. If subscription’s top-level traversable ids contains navigable’s navigable id;

         1. Remove navigable’s navigable id from subscription’s top-level traversable ids.

         2. If subscription’s top-level traversable ids is empty:

            1. Append subscription to subscriptions to remove.

   4. Remove subscriptions to remove from session’s subscriptions.

It’s unclear if we ought to only fire this event for browsing contexts that have active documents; navigation can also cause contexts to become inaccessible but not yet get discarded because bfcache.