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 //
  InputCommand //
  NetworkCommand //
  ScriptCommand //
  SessionCommand
)

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
)

EmptyResult = {
  Extensible
}

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

EventData = (
  BrowsingContextEvent //
  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 session id" /
            "move target out of bounds" /
            "no such alert" /
            "no such element" /
            "no such frame" /
            "no such handle" /
            "no such intercept" /
            "no such node" /
            "no such request" /
            "no such script" /
            "session not created" /
            "unable to capture screen" /
            "unable to close browser" /
            "unknown command" /
            "unknown error" /
            "unsupported operation"

To obtain a list of event enabled browsing contexts given session and event name:

1. Let contexts be an empty set.

2. For each context → events of session’s browsing context event map:

   1. If events contains event name, append context to contexts

3. Return contexts.

The set of sessions for which an event is enabled given event name and browsing contexts 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 browsing contexts, append session to sessions.

3. Return sessions.

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

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

1. Let top-level browsing contexts be an empty set.

2. For each browsing context of browsing contexts, append browsing context’s top-level browsing context to top-level browsing contexts.

3. Let event map be the browsing context event map for session.

4. For each browsing context of top-level browsing contexts:

   1. If event map contains browsing context, let browsing context events be event map[browsing context]. Otherwise let browsing context events be null.

   2. If browsing context events is not null, and browsing context events contains event name, return true.

5. If the global event set for session contains event name return true.

6. Return false.

To obtain a set of event names given an 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 constructing a WebSocket resource name given 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 constructing a WebSocket resource name given 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 browsing contexts given an settings object settings:

1. Let related browsing contexts be an empty set

2. If settings’ relevant global object is a Window, append settings’ relevant global object's associated Document’s browsing context to related browsing contexts.

   Otherwise if the global object specified by settings is a WorkerGlobalScope, for each owner in the global object's owner set, if owner is a Document, append owner’s browsing context to related browsing contexts.

3. Return related browsing contexts.

To emit an event given session, and body:

1. Assert: body has size 2 and contains "method" and "params".

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.

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

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 or false, 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 constructing a WebSocket URL given 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 browsing context:

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

2. Let window be browsing context’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 browsing context.

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.

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

SessionResult = (
   session.NewResult /
   session.StatusResult
)

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. Perform any implementation-specific cleanup steps.

To update the event map, given session, requested event names, browsing contexts, and enabled:

Note: The return value of this algorithm is a map between event names and contexts. When the events are being enabled, the contexts in the return value are those for which the event are now enabled but were not previously. When events are disabled, the return value is always empty.

1. Let global event set be a clone of the global event set for session.

2. Let event map be a new map.

3. For each key → value of the browsing context event map for session:

   1. Set event map[key] to a clone of value.

4. Let event names be an empty set.

5. For each entry name in requested event names, let event names be the union of event names and the result of trying to obtain a set of event names with name.

6. Let enabled events be a new map.

7. If browsing contexts is null:

   1. If enabled is true:

      1. For each event name of event names:

         1. If global event set doesn’t contain event name:

            1. Let already enabled contexts be the event enabled browsing contexts given session and event name

            2. Add event name to global event set.

            3. For each context of already enabled contexts, remove event name from event map[context].

            4. Let newly enabled contexts be a list of all top-level browsing contexts that are not contained in already enabled contexts,

            5. Set enabled events[event name] to newly enabled contexts.

   2. If enabled is false:

      1. For each event name in event names:

         1. If global event set contains event name, remove event name from global event set. Otherwise return error with error code invalid argument.

8. Otherwise, if browsing contexts is not null:

   1. Let targets be an empty map.

   2. For each context id in browsing contexts:

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

      2. Let top-level context be the top-level browsing context for context.

      3. If event map does not contain top-level context, set event map[top-level context] to a new set.

      4. Set targets[top-level context] to event map[top-level context].

   3. For each event name in event names:

      1. If enabled is true and global event set contains event name, continue.

      2. For each context → target in targets:

         1. If enabled is true and target does not contain event name:

            1. Add event name to target.

            2. If enabled events does not contain event name, set enabled events[event name] to a new set.

            3. Append context to enabled events[event name].

         2. If enabled is false:

            1. If target contains event name, remove event name from target. Otherwise return error with error code invalid argument.

9. Set the global event set for session to global event set.

10. Set the browsing context event map for session to event map.

11. Return success with data enabled events.

Note: Implementations that do additional work when an event is enabled, e.g. subscribing to the relevant engine-internal events, will likely perform those additional steps when updating the event map. This specification uses a model where hooks are always called and then the event map is used to filter only those that ought to be returned to the local end.

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

session.CapabilityRequest = {
  ? acceptInsecureCerts: bool,
  ? browserName: text,
  ? browserVersion: text,
  ? platformName: text,
  ? proxy: {
    ? proxyType: "pac" / "direct" / "autodetect" / "system" / "manual",
    ? proxyAutoconfigUrl: text,
    ? ftpProxy: text,
    ? httpProxy: text,
    ? noProxy: [*text],
    ? sslProxy: text,
    ? socksProxy: text,
    ? socksVersion: 0..255,
  },
  Extensible
};

session.SubscriptionRequest = {
  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 be the result of trying to process capabilities with command parameters and flags.

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

6. Set session’s BiDi flag to true.

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

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

8. 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 the list of event names be the value of the events field of command parameters

2. Let the list of contexts be the value of the contexts field of command parameters if it is present or null if it isn’t.

3. Let enabled events be the result of trying to update the event map with session, list of event names , list of contexts and enabled true.

4. Let subscribe step events be a new map.

5. For each event name → contexts in enabled events:

   1. If the event with event name event name defines remote end subscribe steps, set subscribe step events[event name] to contexts.

6. 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.

7. If list of contexts is null, let include global be true, otherwise let include global be false.

8. For each event name → contexts in subscribe step events:

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

9. Return success with data null.

The remote end steps with session and command parameters are:

1. Let the list of event names be the value of the events field of command parameters.

2. Let the list of contexts be the value of the contexts field of command parameters if it is present or null if it isn’t.

3. Try to update the event map with session, list of event names, list of contexts and enabled false.

4. Return success with data null.

BrowserCommand = (
  browser.Close
)

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 browsing contexts without prompting to unload.

      Note: This implicitly only affects browsing contexts that were under automation in the first place.

   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.

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

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

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

browsingContext.BrowsingContext = text;

To get a browsing context given context id:

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

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

3. Let context be the browsing context with id context id.

4. Return success with data context

browsingContext.InfoList = [*browsingContext.Info]

browsingContext.Info = {
  context: browsingContext.BrowsingContext,
  url: text,
  children: browsingContext.InfoList / null
  ? parent: browsingContext.BrowsingContext / null,
}

To get the parent browsing context given browsing context:

1. Let navigable be the navigable whose active document is browsing context’s active document.

2. Let parent navigable be navigable’s parent.

3. If parent navigable is null, then return null.

4. Return parent navigable’s active browsing context.

To get the child browsing contexts given browsing context:

TODO: make this return a list in document order

1. Let navigable be the navigable whose active document is browsing context’s active document.

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

3. Let child browsing contexts be an empty set.

4. For each child navigable in child navigables:

   1. Append child navigable’s active browsing context to child browsing contexts.

5. Return child browsing contexts.

To get the browsing context info given context, max depth and is root:

1. Let context id be the browsing context id for context.

2. Let parent browsing context be get the parent browsing context given context.

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

4. Let document be context’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 contexts be get the child browsing contexts given context.

   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 context of child contexts:

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

      2. Append info to child infos

8. Let context info be a map matching the browsingContext.Info production with the context field set to context id, the parent field set to parent id if is root is true, or unset otherwise, the url field set to url, and the children field set to child infos.

9. Return context info.

To await a navigation given context, 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. Let navigable be the navigable whose active document is context’s active document.

3. Navigate navigable with resource request, and using context’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.

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

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

6. 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.

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

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

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

9. If wait condition is "none":

   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.

10. If wait condition is "interactive", let event name be "domContentLoaded", 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.Navigation = text;

browsingContext.NavigationInfo = {
  context: browsingContext.BrowsingContext,
  navigation: browsingContext.Navigation / null,
  timestamp: js-uint,
  url: text,
}

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

1. Let context id be the browsing context id for context.

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 context 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"

The remote end steps with command parameters are:

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

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

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

4. Return activate a context with context.

To activate a context given context:

1. Run implementation-specific steps so that context’s traversable 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 context 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 viewport to a canvas given viewport and rect:

1. Assert: rect is normalized and represents a non-empty sub-region of viewport, i.e. all the following hold:

   • rect’s x coordinate is greater than or equal to 0.

   • rect’s width dimension is greater than 0.

   • rect’s y coordinate is greater than or equal to 0.

   • rect’s height dimension is greater than 0.

   • rect’s x coordinate plus rect’s width dimension is less than or equal to viewport’s width.

   • rect’s y coordinate plus rect’s height dimension is less than or equal to viewport’s height.

2. Let scale be determine the device pixel ratio for the output device of viewport.

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

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

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

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

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

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

9. Return canvas.

The remote end steps with command parameters are:

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

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

3. Assert: context is not null.

4. If context is not a top-level browsing context, return error with error code invalid argument.

5. Close context.

6. Return success with data null.

There is an open discussion about the behavior when closing the last top-level browsing context. We could expect to close the browser, close the session or leave this up to the implementation. [Issue #w3c/webdriver-bidi#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 context id be the value of the referenceContext field of command parameters, if present, or null otherwise.

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

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

5. If the implementation is unable to create a new browsing context for any reason then return error with error code unsupported operation.

6. Create a new top-level browsing context by running the window open steps with url set to "about:blank", target set to the empty string, and features set to "noopener". Which OS window the new browsing context is created in depends on type and reference context:

   • If type is "tab" and the implementation supports multiple browsing contexts in the same OS window:

     • The new browsing context should reuse an existing OS window, if any.

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

   • If type is "window", and the implementation supports multiple browsing contexts in separate OS windows, the created browsing context should be in a new OS window.

   • Otherwise, the details of how the browsing context is presented to the user are implementation defined.

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

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

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

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

8. Let context id be the browsing context id of the newly created browsing context.

9. Let body be a map matching the browsingContext.CreateResult production, with the context field set to context id.

10. 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 contexts be an empty list.

4. If root id is not null, append the result of trying to get a browsing context given root id to contexts. Otherwise append all top-level browsing contexts to contexts.

5. Let contexts info be an empty list.

6. For each context of contexts:

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

   2. Append info to contexts info

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

8. Return success with data body.

The remote end steps with session and command parameters are:

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

2. Let context be the result of trying to get a browsing context with context 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 context is currently showing a simple dialog from a call to alert then acknowledge the prompt.

   Otherwise if context 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 context 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 context 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.

The remote end steps with session and command parameters are:

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

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

3. Assert: context is not null.

4. Let wait condition be the value of the wait field of command parameters if present, or "none" otherwise.

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

6. Let document be context’s active document.

7. Let base be document’s base URL.

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

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

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

11. Return the result of await a navigation with context, request and wait condition.

The remote end steps with command parameters are:

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

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

3. Assert: context 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 the value of the wait field of command parameters if present, or "none" otherwise.

6. Let document be context’s active document.

7. Let url be document’s URL.

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

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

The remote end steps with command parameters are:

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

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

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

4. Let viewport parameter be the command parameters["viewport"] field.

5. If viewport parameter is not null:

   1. Let width be the viewport parameter["width"]

   2. Let height be the viewport parameter["height"]

   3. If the width or height is outside of the implementation-specific or runtime constraints, return an error with the error code unsupported operation.

   4. Set the layout CSS 2.1 § 9.1.1 The viewport of the context to be width CSS pixels wide and height CSS pixels high.

6. Else:

   1. Set the layout CSS 2.1 § 9.1.1 The viewport of context to the implementation-defined default layout viewport for context.

7. Run the CSSOM View § 13.1 Resizing viewports steps.

8. Return success with data null.

To Recursively emit context created events given session and context:

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

2. For each child browsing context, child, of context:

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

To Emit a context created event given session and context:

1. Let params be the result of get the browsing context info given context, 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:

When the create a new browsing context algorithm is invoked, after the active document of the browsing context is set, run the following steps:

1. Let context be the newly created browsing context.

2. Let related browsing contexts be a set containing context.

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

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

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

1. For each context in contexts:

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

Define the following browsing context tree discarded steps:

1. Let context be the browsing context being discarded.

2. Let params be the result of get the browsing context info, given context, 0, and true.

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

4. Let related browsing contexts be a set containing the result of get the parent browsing context with context, if that is not null, or an empty set otherwise.

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

   1. Emit an event with session and body.

the way this hooks into HTML feels very fragile. See https://github.com/whatwg/html/issues/6194

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.

The remote end event trigger is the WebDriver BiDi navigation started steps given context and navigation status:

1. Let params be the result of get the navigation info given context and navigation status.

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

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

4. Let related browsing contexts be a set containing context.

5. Resume with "navigation started", navigation id, and navigation status.

6. For each session in the set of sessions for which an event is enabled given "browsingContext.navigationStarted" and related browsing contexts:

   1. Emit an event with session and body.

The remote end event trigger is the WebDriver BiDi fragment navigated steps given context and navigation status:

1. Let params be the result of get the navigation info given context and navigation status.

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

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

4. Let related browsing contexts be a set containing context.

5. Resume with "fragment navigated", navigation id, and navigation status.

6. For each session in the set of sessions for which an event is enabled given "browsingContext.fragmentNavigated" and related browsing contexts:

   1. Emit an event with session and body.

The remote end event trigger is the WebDriver BiDi DOM content loaded steps given context and navigation status:

1. Let params be the result of get the navigation info given context and navigation status.

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

3. Let related browsing contexts be a set containing context.

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

5. Resume with "domContentLoaded", navigation id, and navigation status.

6. For each session in the set of sessions for which an event is enabled given "browsingContext.domContentLoaded" and related browsing contexts:

   1. Emit an event with session and body.

The remote end event trigger is the WebDriver BiDi load complete steps given context and navigation status:

1. Let params be the result of get the navigation info given context and navigation status.

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

3. Let related browsing contexts be a set containing context.

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

5. Resume with "load", navigation id and navigation status.

6. For each session in the set of sessions for which an event is enabled given "browsingContext.load" and related browsing contexts:

   1. Emit an event with session and body.

The remote end event trigger is the WebDriver BiDi download started steps given context and navigation status:

1. Let params be the result of get the navigation info given context and navigation status.

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

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

4. Let related browsing contexts be a set containing context.

5. Resume with "download started", navigation id, and navigation status.

6. For each session in the set of sessions for which an event is enabled given "browsingContext.downloadWillBegin" and related browsing contexts:

   1. Emit an event with session and body.

The remote end event trigger is the WebDriver BiDi navigation aborted steps given context and navigation status:

1. Let params be the result of get the navigation info given context and navigation status.

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

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

4. Let related browsing contexts be a set containing context.

5. Resume with "navigation aborted", navigation id, and navigation status.

6. For each session in the set of sessions for which an event is enabled given "browsingContext.navigationAborted" and related browsing contexts:

   1. Emit an event with session and body.

The remote end event trigger is the WebDriver BiDi navigation failed steps given context and navigation status:

1. Let params be the result of get the navigation info given context and navigation status.

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

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

4. Let related browsing contexts be a set containing context.

5. Resume with "navigation failed", navigation id, and navigation status.

6. For each session in the set of sessions for which an event is enabled given "browsingContext.navigationFailed" and related browsing contexts:

   1. Emit an event with session and body.

The remote end event trigger is the WebDriver BiDi user prompt closed steps given window, accepted and optional user text (default: null).

1. Let context be window’s browsing context.

2. Let context id be the browsing context id for context.

3. Let params be a map matching the browsingContext.UserPromptClosedParameters production with the context field set to context id, the accepted field set to accepted, and the userText field set to user text if user text is not null or omitted otherwise.

4. Let body be a map matching the BrowsingContextUserPromptClosedEvent production, with the params field set to params.

5. Let related browsing contexts be a set containing context.

6. For each session in the set of sessions for which an event is enabled given "browsingContext.userPromptClosed" and related browsing contexts:

   1. Emit an event with session and body.

The remote end event trigger is the WebDriver BiDi user prompt opened steps given window, type, message, and optional default value (default: null).

1. Let context be window’s browsing context.

2. Let context id be the browsing context id for context.

3. Let params be a map matching the browsingContext.UserPromptOpenedParameters production with the context field set to context id, the type field set to type, the message field set to message, and the defaultValue field set to default value if default value is not null or omitted otherwise.

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

5. Let related browsing contexts be a set containing context.

6. For each session in the set of sessions for which an event is enabled given "browsingContext.userPromptOpened" and related browsing contexts:

   1. Emit an event with session and body.

NetworkCommand = (
  network.AddIntercept //
  network.ContinueRequest //
  network.ContinueResponse //
  network.ContinueWithAuth //
  network.FailRequest //
  network.ProvideResponse //
  network.RemoveIntercept
)

NetworkResult = (
   network.AddInterceptResult
)

NetworkEvent = (
    network.AuthRequired //
    network.BeforeRequestSent //
    network.FetchError //
    network.ResponseCompleted //
    network.ResponseStarted
)

To get the network intercepts given session, event, and request:

1. Let session intercepts be session’s intercept map.

2. Let intercepts be an empty list.

3. Run the steps under the first matching condition:

   event is "network.beforeRequestSent"

   Set phase to the "beforeRequestSent".

   event is "network.responseStarted"

   Set phase to "responseStarted".

   event is "network.authRequired"

   Set phase to "authRequired".

   event is "network.responseCompleted"

   Return intercepts.

4. Let url be the result of running the URL serializer with request’s URL.

5. For each intercept id → intercept of session intercepts:

   1. If intercept’s phases contains phase:

      1. Let url patterns be intercept’s url patterns.

      2. If url patterns is empty:

         1. Append intercept id to intercepts.

         2. Continue.

      3. For each url pattern in url patterns:

         1. If match URL pattern with url pattern and url:

            1. Append intercept id to intercepts.

            2. Continue.

6. Return intercepts.

network.AuthChallenge = {
  scheme: text,
  realm: text,
}

To extract challenges given response:

Should we include parameters other than realm?

1. If response’s status is 401, let header name be `WWW-Authenticate`. Otherwise if response’s status is 407, let header name be `Proxy-Authenticate`. Otherwise return null.

2. Let challenges be a new list.

3. For each (name, value) in response’s header list:

   as in Fetch it’s unclear if this is the right way to handle multiple headers, parsing issues, etc.

   1. If name is a byte-case-insensitive match for header name:

      1. Let header challenges be the result of parsing value into a list of challenges, each consisting of a scheme and a list of parameters, each of which is a tuple (name, value), according to the rules of [RFC9110].

      2. For each header challenge in header challenges:

         1. Let scheme be header challenge’s scheme.

         2. Let realm be the empty string.

         3. For each (param name, param value) in header challenge’s parameters:

            1. If param name equals `realm` let realm be UTF-8 decode param value.

         4. Let challenge be a new map matching the network.AuthChallenge production, with the scheme field set to scheme and the realm field set to realm.

      3. Append challenge to challenges.

4. Return challenges.

network.AuthCredentials = {
  type: "password",
  username: text,
  password: text,
}

network.BaseParameters = (
    context: browsingContext.BrowsingContext / null,
    isBlocked: bool,
    navigation: browsingContext.Navigation / null,
    redirectCount: js-uint,
    request: network.RequestData,
    timestamp: js-uint,
    ? intercepts: [+network.Intercept]
)

To process a network event given session, event, and request:

1. Let intercepts be the result of get the network intercepts with session, event, and request.

2. Let request data be the result of get the request data with request.

3. Let navigation be request’s navigation id.

4. Let context id be null.

5. If request’s window is an environment settings object:

   1. Let environment settings be request’s window

   2. If there is a browsing context whose active window is environment settings’ global object, let context id be the browsing context id for that context.

6. Let redirect count be request’s redirect count.

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

8. If intercepts is not empty, let is blocked be true, otherwise let is blocked be false.

9. Let params be map matching the network.BaseParameters production, with the request field set to request data, the navigation field set to navigation, the context field set to context id, the timestamp field set to timestamp, the redirectCount field set to redirect count, the isBlocked field set to is blocked, and intercepts field set to intercepts if is blocked is true, or omitted otherwise.

10. Return params

network.BytesValue = network.StringValue / network.Base64Value;

network.StringValue = {
  type: "string",
  value: text,
}

network.Base64Value = {
  type: "base64",
  value: text,
}

To deserialize protocol bytes given protocol bytes:

Note: this takes bytes encoded as a network.BytesValue and returns a byte sequence.

1. If protocol bytes matches the network.StringValue production, let bytes be UTF-8 encode protocol bytes["value"].

2. Otherwise if protocol bytes matches the network.Base64Value production. Let bytes be forgiving-base64 decode protocol bytes["value"].

3. Return bytes.

To serialize protocol bytes given bytes:

Note: this takes a byte sequence and returns a network.BytesValue.

1. Let text be UTF-8 decode without BOM or fail bytes.

2. If text is failure, return a map matching the network.Base64Value production, with value set to forgiving-base64 encode bytes.

3. Return a map matching the network.StringValue production, with value set to text.

network.Cookie = {
    name: text,
    value: network.BytesValue,
    domain: text,
    path: text,
    size: js-uint,
    httpOnly: bool,
    secure: bool,
    sameSite: "strict" / "lax" / "none",
    ? expires: js-uint,
};

To serialize cookie given stored cookie:

Note: The definitions of stored cookie’s fields are from [COOKIES], except samesite-flag, which is from [SAME-SITE-COOKIES].

1. Let name be the result of UTF-8 decode with stored cookie’s name field.

2. Let value be serialize protocol bytes with stored cookie’s value.

3. Let domain be stored cookie’s domain field.

4. Let path be stored cookie’s path field.

5. Let expires be stored cookie’s expires field represented as a unix timestamp, if set, or null otherwise.

6. Let size be the byte length of the result of serializing stored cookie as it would be represented in a Cookie header.

7. Let http only be true if stored cookie’s http-only-flag is true, or false otherwise.

8. Let secure be true if stored cookie’s secure-only-flag is true, or false otherwise.

9. Let same site be "none" if stored cookie’s samesite-flag is "None", "lax" if it is "Lax", or "strict" if it is "Strict".

10. Return a map matching the network.Cookie production, with the name field set to name, the value field set to value, the domain field set to domain, the path field set to path, the expires field set to expires if it’s not null, or omitted otherwise, the size field set to size, the httpOnly field set to http only, the secure field set to secure, and the sameSite field set to same site.

network.CookieHeader = {
    name: text,
    value: network.BytesValue,
};

To serialize cookie header given protocol cookie:

1. Let name be UTF-8 encode protocol cookie["name"].

2. Let value be deserialize protocol bytes with protocol cookie["value"].

3. Let header value be the byte sequence formed by concatenating name, `=`, and value

4. Return header value.

network.FetchTimingInfo = {
    timeOrigin: float,
    requestTime: float,
    redirectStart: float,
    redirectEnd: float,
    fetchStart: float,
    dnsStart: float,
    dnsEnd: float,
    connectStart: float,
    connectEnd: float,
    tlsStart: float,
    requestStart: float,
    responseStart: float,
    responseEnd: float,
};

To get the fetch timings given request:

1. Let global be request’s client.

2. If global is null, return a map matching the network.FetchTimingInfo production, with all fields set to 0.

3. Let time origin be get time origin timestamp with global.

4. Let timings be request’s fetch timing info.

5. Let connection timing be timings’ final connection timing info if it’s not null, or a new connection timing info otherwise.

6. Let request time be convert fetch timestamp given timings’ start time and global.

7. Let redirect start be convert fetch timestamp given timings’ redirect start time and global.

8. Let redirect end be convert fetch timestamp given timings’ redirect end time and global.

9. Let fetch start be convert fetch timestamp given timings’ post-redirect start time and global.

10. Let DNS start be convert fetch timestamp given connection timing’s domain lookup start time and global.

11. Let DNS end be convert fetch timestamp given connection timing’s domain lookup end time and global.

12. Let TLS start be convert fetch timestamp given connection timing’s secure connection start time and global.

13. Let connect start be convert fetch timestamp given connection timing’s connection start time and global.

14. Let connect end be convert fetch timestamp given connection timing’s connection end time and global.

15. Let request start be convert fetch timestamp given timings’ final network-request start time and global.

16. Let response start be convert fetch timestamp given timings’ final network-response start time and global.

17. Let response end be convert fetch timestamp given timings’ end time and global.

18. Return a map matching the network.FetchTimingInfo production with the timeOrigin field set to time origin, the requestTime field set to request time, the redirectStart field set to redirect start, the redirectEnd field set to redirect end, the fetchStart field set to fetch start, the dnsStart field set to DNS start, the dnsEnd field set to DNS end, the connectStart field set to connect start, the connectEnd field set to connect end, the tlsStart field set to TLS start, the requestStart field set to request start, the responseStart field set to response start, and the responseEnd field set to response end.

network.Header = {
  name: text,
  value: network.BytesValue,
}

To serialize header given name bytes and value bytes:

1. Let name be the result of UTF-8 decode with name bytes.

   Assert: Since header names are constrained to be ASCII-only this cannot fail.

2. Let value be serialize protocol bytes with value bytes.

3. Return a map matching the network.Header production, with the name field set to name, and the value field set to value.

To deserialize header given protocol header:

1. Let name be UTF-8 encode protocol header["name"].

2. Let value be deserialize protocol bytes with protocol header["value"].

3. Return a header (name, value).

network.Initiator = {
    type: "parser" / "script" / "preflight" / "other",
    ? columnNumber: js-uint,
    ? lineNumber: js-uint,
    ? stackTrace: script.StackTrace,
    ? request: network.Request
};

To get the initiator given request:

1. Let request id be request’s request id.

2. Let type be "other".

3. If request is a CORS-Preflight Request, set type to "preflight".

4. TODO: Get the type. It’s not quite clear how this ought to work; the CDP data depends on whether the navigation was kicked off by the parser or by script (so e.g. inserting an image from script causes the initiator to be "script"), but that doesn’t correspond to anything in Fetch.

5. If request’s initiator type is "fetch" or "xmlhttprequest":

   1. Let stack trace be the current stack trace.

   2. If stack trace has size of 1 or greater, let line number be value of the lineNumber field in stack trace[0], and let column number be the value of the columnNumber field stack trace[0]. Otherwise let line number and column number be 0.

   Otherwise, let stack trace, column number, and line number all be null.

   TODO: Chrome includes the current parser position as column number / line number for parser-inserted resources.

6. Return a map matching the network.Initiator production, with the type field set to type, the columnNumber field set to column number if it’s not null, or omitted otherwise, the lineNumber field set to line number if it’s not null, or omitted otherwise, the stackTrace field set to stack trace if it’s not null, or omitted otherwise, and the request field set to request id.

network.Intercept = text

network.Request = text;

network.RequestData = {
    request: network.Request,
    url: text,
    method: text,
    headers: [*network.Header],
    cookies: [*network.Cookie],
    headersSize: js-uint,
    bodySize: js-uint / null,
    timings: network.FetchTimingInfo,
};

To get the request data given request:

1. Let request id be request’s request id.

2. Let url be the result of running the URL serializer with request’s URL.

3. Let method be request’s method.

4. Let body size be null.

5. Let body be request’s body.

6. If body is a byte sequence, let body size be the length of that sequence. Otherwise, if body is a body then let body size be that body’s length.

7. Let headers size be the size in bytes of request’s headers list when serialized as mandated by [HTTP11].

   Note: For protocols which allow header compression, this is the compressed size of the headers, as sent over the network.

8. Let headers be an empty list.

9. Let cookies be an empty list.

10. For each (name, value) in request’s headers list:

    1. Append the result of serialize header with name and value to headers.

    2. If name is a byte-case-insensitive match for "Cookie" then:

       1. For each cookie in the user agent’s cookie store that are included in request:

          Note: [COOKIES] defines some baseline requirements for which cookies in the store can be included in a request, but user agents are free to impose additional constraints.

          1. Append the result of serialize cookie given cookie to cookies.

11. Let timings be get the fetch timings with request.

12. Return a map matching the network.RequestData production, with the request field set to request id, url field set to url, the method field set to method, the headers field set to headers, the cookies field set to cookies, and the headersSize field set to headers size, the bodySize field set to body size, and the timings field set to timings.

network.ResponseContent = {
    size: js-uint
};

To get the response content info given response.

1. Return a new map matching the network.ResponseContent production, with the size field set to response’s response body info's decoded size

network.ResponseData = {
    url: text,
    protocol: text,
    status: js-uint,
    statusText: text,
    fromCache: bool,
    headers: [*network.Header],
    mimeType: text,
    bytesReceived: js-uint,
    headersSize: js-uint / null,
    bodySize: js-uint / null,
    content: network.ResponseContent,
    ?authChallenge: network.AuthChallenge,
};

To get the protocol given response:

1. Let protocol be the empty string.

2. If response’s final connection timing info is not null, set protocol to response’s final connection timing info's ALPN negotiated protocol.

3. If protocol is the empty string, or is equal to "unknown":

   1. Set protocol to response’s url's scheme

   2. If protocol is equal to either "http" or "https" and response has an associated HTTP Response.

      Note: [FETCH] isn’t clear about the relation between a HTTP network response and a response object.

      1. Let http version be the HTTP Response’s Status line’s HTTP-version [HTTP11].

      2. If http version starts with "HTTP/":

         1. Let version be the code unit substring of http version from 5 to http version’s length.

         2. If version is "0.9", set protocol to "http/0.9", otherwise if version is "1.0", set protocol to "http/1.0", otherwise if version is "1.1", set protocol to "http/1.1".

4. Return protocol.

To get the response data given response:

1. Let url be the result of running the URL serializer with response’s URL.

2. Set protocol to get the protocol given response.

3. Let status be response’s status.

4. Let status text be response’s status message.

5. If response’s cache state is "local", let from cache be true, otherwise let it be false.

6. Let headers be an empty list.

7. Let mime type be the essence of the computed mime type for response.

   Note: this is whatever MIME type the browser is actually using, even if it isn’t following the exact algorithm in the [MIMESNIFF] specification.

8. For each (name, value) in response’s headers list:

   1. Append the result of serialize header with name and value to headers.

9. Let bytes received be the total number of bytes transmitted as part of the HTTP response associated with response.

10. Let headers size be the number of bytes transmitted as part of the header fields section of the HTTP response.

11. Let body size be response’s response body info's encoded size.

12. Let content be the result of get the response content info with response.

13. Let auth challenges be the result of extract challenges with response.

14. Return a map matching the network.ResponseData production, with the url field set to url, the protocol field set to protocol, the status field set to status, the statusText field set to status text, the fromCache field set to from cache, the headers field set to headers, the mimeType field set to mime type, the bytesReceived field set to bytes received, the headersSize field set to headers size, the bodySize field set to body size, content field set to content, and the authChallenges field set to auth challenges if it’s not null, or omitted otherwise.

network.SetCookieHeader = {
    name: text,
    value: network.BytesValue,
    ? domain: text,
    ? httpOnly: bool,
    ? expires: text,
    ? maxAge: js-int,
    ? path: text,
    ? sameSite: "strict" / "lax" / "none",
    ? secure: bool,
}

To serialize an integer given input that is an integer:

Note: This produces the shortest representation of input as a string of decimal digits.

1. Let serialized be an empty string.

2. Let value be input.

3. While value is greater than 0:

   1. Let x be value divided by 10.

   2. Let most significant digits be the integer part of x.

   3. Let y be most significant digits multiplied by 10.

   4. Let least significant digit be value - y.

   5. Assert: least significant digit is an integer in the range 0 to 9, inclusive.

   6. Let codepoint be the code point whose value is U+0030 DIGIT ZERO’s value + least significant digit.

   7. Prepend codepoint to serialized.

   8. Let value be most significant digits.

4. Return serialized.

To serialize set-cookie header given protocol cookie:

1. Let name be UTF-8 encode protocol cookie["name"].

2. Let value be deserialize protocol bytes with protocol cookie["value"].

3. Let header value be the byte sequence formed by concatenating name, `=`, and value.

4. If protocol cookie contains "expires:

   1. Let attribute be `;Expires=`

   2. Append UTF-8 encode protocol cookie["expires"] to attribute.

   3. Append attribute to header value.

5. If protocol cookie contains "maxAge:

   1. Let attribute be `;Max-Age=`

   2. Let max age string be serialize an integer protocol cookie["maxAge"].

   3. Append UTF-8 encode max age string to attribute.

   4. Append attribute to header value.

6. If protocol cookie contains "domain":

   1. Let attribute be `;Domain=`

   2. Append UTF-8 encode protocol cookie["domain"] to attribute.

   3. Append attribute to header value.

7. If protocol cookie contains "path":

   1. Let attribute be `;Path=`

   2. Append UTF-8 encode protocol cookie["path"] to attribute.

   3. Append attribute to header value.

8. If protocol cookie contains "secure" and protocol cookie["secure"] is true:

   1. Append `;Secure` to header value.

9. If protocol cookie contains "httpOnly" and protocol cookie["httpOnly"] is true:

   1. Append `;HttpOnly` to header value.

10. If protocol cookie contains "sameSite":

    1. Let attribute be `;SameSite=`

    2. Append UTF-8 encode protocol cookie["sameSite"] to attribute.

    3. Append attribute to header value.

11. Return header value.

network.UrlPattern = (
  network.UrlPatternPattern /
  network.UrlPatternString
)

network.UrlPatternPattern = {
    type: "pattern",
    ?protocol: text,
    ?hostname: text,
    ?port: text,
    ?pathname: text,
    ?search: text,
}


network.UrlPatternString = {
    type: "string",
    pattern: text,
}

To unescape URL pattern given pattern

1. Let forbidden characters be the set of codepoints «U+0028 ((), U+0029 ()), U+002A (*), U+007B ({), U+007D (})»

2. Let result be the empty string.

3. Let is escaped character be false.

4. For each codepoint in pattern:

   1. If is escaped character is false:

      1. If forbidden characters contains codepoint, return error with error code invalid argument.

      2. If codepoint is U+005C (\):

         1. Set is escaped character to true.

         2. Continue.

   2. Append codepoint to result.

   3. Set is escaped character to false.

5. Return success with data result.

To parse URL pattern, given pattern:

1. Let has protocol be true.

2. Let has hostname be true.

3. Let has port be true.

4. Let has pathname be true.

5. Let has search be true.

6. If pattern matches the network.UrlPatternPattern production:

   1. Let pattern url be the empty string.

   2. If pattern contains "protocol":

      1. If pattern["protocol"] is the empty string, return error with error code invalid argument.

      2. Let protocol be the result of trying to unescape URL Pattern with pattern["protocol"].

      3. For each codepoint in protocol:

         1. If codepoint is not ASCII alphanumeric and «U+002B (+), U+002D (-), U+002E (.)» does not contain codepoint:

            1. Return error with error code invalid argument.

      4. Append protocol to pattern url.

   3. Otherwise:

      1. Set has protocol to false.

      2. Append "http" to pattern url.

   4. Let scheme be ASCII lowercase with pattern url.

   5. Append ":" to pattern url.

   6. If scheme is special, append "//" to pattern url.

   7. If pattern contains "hostname":

      1. If pattern["hostname"] is the empty string, return error with error code invalid argument.

      2. If scheme is "file" return error with error code invalid argument.

      3. Let hostname be the result of trying to unescape URL Pattern with pattern["hostname"].

      4. Let inside brackets be false.

      5. For each codepoint in hostname:

         1. If «U+002F (/), U+003F (?), U+0023 (#)» contains codepoint:

            1. Return error with error code invalid argument.

         2. If inside brackets is false and codepoint is U+003A (:):

            1. Return error with error code invalid argument.

         3. If codepoint is U+005B ([), set inside brackets to true.

         4. If codepoint is U+005D (]), set inside brackets to false.

      6. Append hostname to pattern url.

   8. Otherwise:

      1. If scheme is not "file", append "placeholder" to pattern url.

      2. Set has hostname to false.

   9. If pattern contains "port":

      1. If pattern["port"] is the empty string, return error with error code invalid argument.

      2. Let port be the result of trying to unescape URL Pattern with pattern["port"].

      3. Append ":" to pattern url.

      4. For each codepoint in port:

         1. If codepoint is not an ASCII digit:

            1. Return error with error code invalid argument.

      5. Append port to pattern url.

   10. Otherwise:

       1. Set has port to false.

   11. If pattern contains "pathname":

       1. Let pathname be the result of trying to unescape URL Pattern with pattern["pathname"].

       2. If pathname does not start with U+002F (/), then append "/" to pattern.

       3. For each codepoint in pathname:

          1. If «U+003F (?), U+0023 (#)» contains codepoint:

             1. Return error with error code invalid argument.

       4. Append pathname to pattern url.

   12. Otherwise:

       1. Set has pathname to false.

   13. If pattern contains "search":

       1. Let search be the result of trying to unescape URL pattern with pattern["search"].

       2. If search does not start with U+003F (?), then append "?" to pattern url.

       3. For each codepoint in search:

          1. If codepoint is U+0023 (#):

             1. Return error with error code invalid argument.

       4. Append search to pattern url.

   14. Otherwise:

       1. Set has search to false.

7. Otherwise, if pattern matches the network.UrlPatternString production:

   1. Let pattern url be the result of trying to unescape URL pattern with pattern["pattern"].

8. Let url be the result of parsing pattern url.

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

10. Let parsed be a struct with the following fields:

    protocol

    url’s scheme if has protocol is true, or null otherwise.

    hostname

    url’s host if has hostname is true, or null otherwise.

    port

    1. If has port is false:

       1. null.

    2. Otherwise:

       1. If url’s scheme is special and url’s scheme's default port is not null, and url’s port is null or is equal to scheme's default port:

          1. The empty string.

       2. Otherwise, if url’s port is not null:

          1. Serialize an integer with url’s port.

       3. Otherwise:

          1. null.

    pathname

    1. If has pathname is false:

       1. null.

    2. Otherwise:

       1. The result of running the URL path serializer with url, if url’s path is not the empty string and is not empty, or null otherwise.

    search

    1. If has search is false:

       1. null.

    2. Otherwise:

       1. The empty string if url’s query is null, or url’s query otherwise.

11. Return success with data parsed.

To match URL pattern given url pattern and url string:

1. Let url be the result of parsing url string.

2. If url pattern’s protocol is not null and is not equal to url’s scheme, return false.

3. If url pattern’s hostname is not null and is not equal to url’s host, return false.

4. If url pattern’s port is not null:

   1. Let port be null.

   2. If url’s scheme is special and url’s scheme's default port is not null, and url’s port is null or is equal to scheme's default port:

      1. Set port to the empty string.

   3. Otherwise, if url’s port, is not null:

      1. Set port to serialize an integer with url’s port.

   4. If url pattern’s port is not equal to port, return false.

5. If url pattern’s pathname is not null and is not equal to the result of running the URL path serializer with url, return false.

6. If url pattern’s search is not null:

   1. Let url query be url’s query.

   2. If url query is null, set url query to the empty string.

   3. If url pattern’s search is not equal to url query, return false.

7. Return true.

The remote end steps given session and command parameters are:

1. Let intercept be the string representation of a UUID.

2. Let url patterns be the urlPatterns field of command parameters if present, or an empty list otherwise.

3. Let intercept map be session’s intercept map.

4. Let parsed patterns be an empty list.

5. For each url pattern in url patterns:

   1. Let parsed be the result of trying to parse url pattern with url pattern.

   2. Append parsed to parsed patterns.

6. Set intercept map[intercept] to a struct with url patterns parsed patterns and phases command parameters["phases"].

7. Return a new map matching the network.AddInterceptResult production with the intercept field set to intercept.

The remote end steps given session and command parameters are:

1. Let blocked requests be session’s blocked request map.

2. Let request id be command parameters["request"].

3. If blocked requests does not contain request id then return error with error code no such request.

4. Let (request, phase, response) be blocked requests[request id].

5. If phase is not "beforeRequestSent", then return error with error code invalid argument.

   consider a "request already sent" error.

6. If command parameters contains "url":

   1. Let url record be the result of applying the URL parser to command parameters["url"], with base URL null.

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

      TODO: Should we also resume here?

   3. Let request’s url be url record.

7. If command parameters contains "method":

   1. Let request’s method be command parameters["method"].

8. If command parameters contains "headers":

   1. Let headers be an empty header list.

   2. For header in command parameters["headers"]:

      1. Append deserialize header with header to headers.

   3. Set request’s headers list to headers.

9. If command parameters contains "cookies":

   1. Let cookie header be an empty byte sequence.

   2. For each cookie in command parameters:

      1. If cookie header is not empty, append `;` to cookie header.

      2. Append serialize cookie header with cookie to cookie header.

   3. Let found cookie header be false.

   4. For each header in request’s headers list:

      1. Let name be header’s name.

      2. If byte-lowercase name is `cookie`:

         1. Set header’s value to cookie header.

         2. Set found cookie header to true.

         3. Break.

   5. If found cookie header is false:

      1. Append the header (`Cookie`, cookie header) to request’s headers list.

10. If command parameters contains "body":

    1. Let body be deserialize protocol bytes with command parameters["body"].

    2. Set request’s body to body.

11. Resume with "continue request", request id, and (null, "incomplete").

12. Return success with data null.

To update the response given session, command and command parameters:

1. Let blocked requests be session’s blocked request map.

2. Let request id be command parameters["request"].

3. If blocked requests does not contain request id then return error with error code no such request.

4. Let (request, phase, response) be blocked requests[request id].

5. If phase is "beforeRequestSent" and command is "continueResponse", return error with error code "invalid argument".

   TODO: Consider a different error

6. If response is null:

   1. Assert: phase is "beforeRequestSent".

   2. Set response to a new response.

7. If command parameters contains "statusCode":

   1. Set responses’s status be command parameters["statusCode"].

8. If command parameters contains "reasonPhrase":

   1. Set responses’s status message be UTF-8 encode with command parameters["reasonPhrase"].

9. If command parameters contains "headers":

   1. Let headers be an empty header list.

   2. For header in command parameters["headers"]:

      1. Append deserialize header with header to headers.

   3. Set response’s header list to headers.

10. If command parameters contains "cookies":

    1. If command parameters contains "headers", let headers be response’s header list.

       Otherwise:

       1. Let headers be an empty header list.

       2. For each header in response’s headers list:

          1. Let name be header’s name.

          2. If byte-lowercase name is not `set-cookie`:

             1. Append header to headers

    2. For cookie in command parameters["cookies"]:

       1. Let header value be serialize set-cookie header with cookie.

       2. Append (`Set-Cookie`, header value) to headers.

       3. Set response’s header list to headers.

11. If command parameters contains "credentials":

    This doesn’t have a way to cancel the auth.

    1. Let credentials be command parameters["credentials"].

    2. Assert: credentials{"type"] is "password".

    3. Set response’s authentication credentials to (credentials["username"], credentials["password"])

12. Return response

The remote end steps given session and command parameters are:

1. Let request id be command parameters["request"].

2. Let response be the result of trying to update the response with session, "continueResponse" and command parameters.

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

4. Return success with data null.

The remote end steps given session and command parameters are:

1. Let blocked requests be session’s blocked request map.

2. Let request id be command parameters["request"].

3. If blocked requests does not contain request id then return error with error code no such request.

4. Let (request, phase, response) be blocked requests[request id].

5. If phase is not "authRequired", then return error with error code invalid argument.

6. If command parameters "action is "cancel", set response’s authentication credentials to "cancelled".

7. If command parameters "action" is "provideCredentials":

   1. Let credentials be command parameters["credentials"].

   2. Assert: credentials["type"] is "password".

   3. Set response’s authentication credentials to (credentials["username"], credentials["password"])

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

9. Return success with data null.

The remote end steps given session and command parameters are:

1. Let blocked requests be session’s blocked request map.

2. Let request id be command parameters["request"].

3. If blocked requests does not contain request id then return error with error code no such request.

4. Let (request, phase, response) be blocked requests[request id].

5. If phase is "authRequired", then return error with error code invalid argument.

6. Let response be a new network error.

   Allow setting the precise kind of error [Issue #508]

7. Resume with "continue request", request id, and (response, "complete").

8. Return success with data null.

The remote end steps given session and command parameters are:

1. Let request id be command parameters["request"].

2. Let response be the result of trying to update the response with session, "provideResponse", and command parameters.

3. If command parameters contains "body":

   1. Let body be deserialize protocol bytes with command parameters["body"].

   2. Set response’s body to body as a body.

4. Resume with "continue request", request id, and (response,"complete").

5. Return success with data null.

The remote end steps given session and command parameters are:

1. Let intercept be the value of the "intercept" field in command parameters.

2. Let intercept map be session’s intercept map.

3. If intercept map does not contain intercept, return error with error code no such intercept.

4. Remove intercept from intercept map.

5. Return success with data null.

The remote end event trigger is the WebDriver BiDi auth required steps given request and response:

1. Let redirect count be request’s redirect count.

2. Assert: before request sent map[request] is equal to redirect count.

   Note: This implies that every caller needs to ensure that the WebDriver BiDi before request sent steps are invoked with request before these steps.

3. If request’s client is not null, let related browsing contexts be the result of get related browsing contexts with request’s client. Otherwise let related browsing contexts be an empty set.

4. For each session in the set of sessions for which an event is enabled given "network.authRequired" and related browsing contexts:

   1. Let params be the result of process a network event with session "network.authRequired", and request.

   2. Let response data be the result of get the response data with response.

   3. Assert: response data contains "authChallenge".

   4. Set the response field of params to response data.

   5. Assert: params matches the network.AuthRequiredParameters production.

   6. Let body be a map matching the network.AuthRequired production, with the params field set to params.

   7. Emit an event with session and body.

   8. If params["isBlocked"] is true:

      1. Let blocked requests be session’s blocked request map.

      2. Let request id be request’s request id.

      3. Set blocked requests[request id] to (request, "authRequired", response).

      4. Await with «"continue request"», and request id.

The remote end event trigger is the WebDriver BiDi before request sent steps given request:

1. If before request sent map does not contain request, set before request sent map[request] to a new set.

2. Let redirect count be request’s redirect count.

3. Add redirect count to before request sent map[request].

4. If request’s client is not null, let related browsing contexts be the result of get related browsing contexts with request’s client. Otherwise let related browsing contexts be an empty set.

5. Let response be null.

6. Let response status be "incomplete".

7. For each session in the set of sessions for which an event is enabled given "network.beforeRequestSent" and related browsing contexts:

   1. Let params be the result of process a network event with session, "network.beforeRequestSent", and request.

   2. If params is null then continue.

   3. Let initiator be the result of get the initiator with request.

   4. Set the initiator field of params to initiator.

   5. Assert: params matches the network.BeforeRequestSentParameters production.

   6. Let body be a map matching the network.BeforeRequestSent production, with the params field set to params.

   7. Emit an event with session and body.

   8. If params["isBlocked"] is true, then:

      1. Let blocked requests be session’s blocked request map.

      2. Let request id be request’s request id.

      3. Set blocked requests[request id] to (request, "beforeRequestSent", null).

      4. Let (response, status) be await with «"continue request"», and request’s request id.

      5. If status is "complete" set response status to status.

      6. Remove blocked requests[request id].

      Note: While waiting, no further processing of the request occurs.

8. Return (response, response status).

The remote end event trigger is the WebDriver BiDi fetch error steps given request:

1. If before request sent map[request] does not contain request’s redirect count, then run the WebDriver BiDi before request sent steps with request.

   Note: This ensures that a network.beforeRequestSent can always be emitted before a network.fetchError, without the caller needing to explicitly invoke the WebDriver BiDi before request sent steps on every error path.

2. If request’s client is not null, let related browsing contexts be the result of get related browsing contexts with request’s client. Otherwise let related browsing contexts be an empty set.

3. For each session in the set of sessions for which an event is enabled given "network.fetchError" and related browsing contexts:

   1. Let params be the result of process a network event with session "network.fetchError", and request.

   2. TODO: Set the errorText field of params.

   3. Assert: params matches the network.FetchErrorParameters production.

   4. Let body be a map matching the network.FetchError production, with the params field set to params.

   5. Emit an event with session and body.

The remote end event trigger is the WebDriver BiDi response completed steps given request and response:

1. Let redirect count be request’s redirect count.

2. Assert: before request sent map[request] contains redirect count.

   Note: This implies that every caller needs to ensure that the WebDriver BiDi before request sent steps are invoked with request before these steps.

3. If request’s client is not null, let related browsing contexts be the result of get related browsing contexts with request’s client. Otherwise let related browsing contexts be an empty set.

4. For each session in the set of sessions for which an event is enabled given "network.responseCompleted" and related browsing contexts:

   1. Let params be the result of process a network event with session "network.responseCompleted", and request.

   2. Assert: params["isBlocked"] is false.

   3. Let response data be the result of get the response data with response.

   4. Set the response field of params to response data.

   5. Assert: params matches the network.ResponseCompletedParameters production.

   6. Let body be a map matching the network.ResponseCompleted production, with the params field set to params.

   7. Emit an event with session and body.

The remote end event trigger is the WebDriver BiDi response started steps given request and response:

1. Let redirect count be request’s redirect count.

2. Assert: before request sent map[request] is equal to redirect count.

   Note: This implies that every caller needs to ensure that the WebDriver BiDi before request sent steps are invoked with request before these steps.

3. If request’s client is not null, let related browsing contexts be the result of get related browsing contexts with request’s client. Otherwise let related browsing contexts be an empty set.

4. Let response status be "incomplete".

5. For each session in the set of sessions for which an event is enabled given "network.responseStarted" and related browsing contexts:

   1. Let params be the result of process a network event with session "network.responseStarted", and request.

   2. Let response data be the result of get the response data with response.

   3. Set the response field of params to response data.

   4. Assert: params matches the network.ResponseStartedParameters production.

   5. Let body be a map matching the network.ResponseStarted production, with the params field set to params.

   6. Emit an event with session and body.

   7. If params["isBlocked"] is true:

      1. Let blocked requests be session’s blocked request map.

      2. Let request id be request’s request id.

      3. Set blocked requests[request id] to (request, "beforeRequestSent", response).

      4. Let (response, status) be await with «"continue request"», and request id.

      5. If status is "complete", set response status to status.

6. Return (response, response status).

ScriptCommand = (
  script.AddPreloadScript //
  script.CallFunction //
  script.Disown //
  script.Evaluate //
  script.GetRealms //
  script.RemovePreloadScript
)

ScriptResult = (
  script.AddPreloadScriptResult /
  script.EvaluateResult /
  script.GetRealmsResult
)

ScriptEvent = (
  script.Message //
  script.RealmCreated //
  script.RealmDestroyed
)

To run WebDriver BiDi preload scripts given environment settings:

1. Let document be environment settings’ relevant global object's associated Document.

2. Let browsing context be document’s browsing context.

3. For each session in active BiDi sessions:

   1. For each preload script in session’s preload script map's values:

      1. If preload script’s contexts is not null:

         1. Let top level context be browsing context’s top-level browsing context.

         2. Let context id be top level context’s id.

         3. If contexts does not contain context id, return.

      2. If preload script’s sandbox is not null, let realm be get or create a sandbox realm with preload script’s sandbox and browsing context. Otherwise let realm be environment settings’ realm execution context's Realm component.

      3. Let arguments be preload script’s arguments.

      4. Let deserialized arguments be an empty list.

      5. For each argument in arguments:

         1. Let channel be create a channel with session, realm and argument.

         2. Append channel to deserialized arguments.

      6. Let base URL be the API base URL of environment settings.

      7. Let options be the default classic script fetch options.

      8. Let function declaration be preload script’s function declaration.

      9. Let (script, function body evaluation status) be the result of evaluate function body with function declaration, environment settings, base URL, and options.

      10. If function body evaluation status is an abrupt completion, then report the exception given by function body evaluation status.[[Value]] for script.

      11. Let function object be function body evaluation status.[[Value]].

      12. If IsCallable(function object) is false:

          1. Let error be a new TypeError object in realm.

          2. Report the exception error.

      13. Prepare to run script with environment settings.

      14. Set evaluation status to Call(function object, null, deserialized arguments).

      15. Clean up after running script with environment settings.

      16. If evaluation status is an abrupt completion, then report the exception given by evaluation status.[[Value]] for script.

script.Channel = text;

script.ChannelValue = {
  type: "channel",
  value: script.ChannelProperties,
};

script.ChannelProperties = {
  channel: script.Channel,
  ? serializationOptions: script.SerializationOptions,
  ? ownership: script.ResultOwnership,
}

To create a channel given session, realm and protocol value:

1. Let channel properties be protocol value["value"].

2. Let steps be the following steps given the argument message:

   1. Let current realm be the current Realm Record.

   2. Emit a script message with session, current realm, channel properties and message.

3. Return CreateBuiltinFunction(steps, 1, "", « », realm).

script.EvaluateResult = (
  script.EvaluateResultSuccess /
  script.EvaluateResultException
)

script.EvaluateResultSuccess = {
  type: "success",
  result: script.RemoteValue,
  realm: script.Realm
}

script.EvaluateResultException = {
  type: "exception",
  exceptionDetails: script.ExceptionDetails
  realm: script.Realm
}

script.ExceptionDetails = {
  columnNumber: js-uint,
  exception: script.RemoteValue,
  lineNumber: js-uint,
  stackTrace: script.StackTrace,
  text: text,
};

To get exception details given a realm, a completion record record, an ownership type and a session:

1. Assert: record.[[Type]] is throw.

2. Let text be an implementation-defined textual description of the error represented by record.

   TODO: Tighten up the requirements here; people will probably try to parse this data with regex or something equally bad.

3. Let serialization options be a map matching the script.SerializationOptions production with the fields set to their default values.

4. Let exception be the result of serialize as a remote value with record.[[Value]], serialization options, ownership type, a new map as serialization internal map, realm and session.

5. Let stack trace be the stack trace for an exception given record.

6. If stack trace has size of 1 or greater, let line number be value of the lineNumber field in stack trace[0], and let column number be the value of the columnNumber field stack trace[0]. Otherwise let line number and column number be 0.

7. Let exception details be a map matching the script.ExceptionDetails production, with the text field set to text, the exception field set to exception, the lineNumber field set to line number, the columnNumber field set to column number, and the stackTrace field set to stack trace.

8. Return exception details.

script.Handle = text;

script.LocalValue = (
  script.RemoteReference /
  script.PrimitiveProtocolValue /
  script.ChannelValue /
  script.ArrayLocalValue /
  script.DateLocalValue /
  script.MapLocalValue /
  script.ObjectLocalValue /
  script.RegExpLocalValue /
  script.SetLocalValue
)

script.ListLocalValue = [*script.LocalValue];

script.ArrayLocalValue = {
  type: "array",
  value: script.ListLocalValue,
}

script.DateLocalValue = {
  type: "date",
  value: text
}

script.MappingLocalValue = [*[(script.LocalValue / text), script.LocalValue]];

script.MapLocalValue = {
  type: "map",
  value: script.MappingLocalValue,
}

script.ObjectLocalValue = {
  type: "object",
  value: script.MappingLocalValue,
}

script.RegExpValue = {
  pattern: text,
  ? flags: text,
}

script.RegExpLocalValue = {
  type: "regexp",
  value: script.RegExpValue,
}

script.SetLocalValue = {
  type: "set",
  value: script.ListLocalValue,
}

To deserialize key-value list given serialized key-value list, realm and session:

1. Let deserialized key-value list be a new list.

2. For each serialized key-value in the serialized key-value list:

   1. If size of serialized key-value is not 2, return error with error code invalid argument.

   2. Let serialized key be serialized key-value[0].

   3. If serialized key is a string, let deserialized key be serialized key.

   4. Otherwise let deserialized key be result of trying to given deserialize local value with serialized key, realm and session.

   5. Let serialized value be serialized key-value[1].

   6. Let deserialized value be result of trying to deserialize local value given serialized value, realm and session.

   7. Append CreateArrayFromList(«deserialized key, deserialized value») to deserialized key-value list.

3. Return success with data deserialized key-value list.